Skip to content

Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS

5.2 KB
Raw Blame
import { noteReadinessChanged } from './readinessSignal.js';
import { join } from 'path';
import { v4 as uuidv4 } from '../lib/uuid.js';
import { ensureDir, PATHS, readJSONFile, atomicWrite } from '../lib/fileUtils.js';
import { createFileWriteQueue } from '../lib/fileWriteQueue.js';
import { isPlainObject } from '../lib/objects.js';

const ACCOUNTS_FILE = join(PATHS.calendar, 'accounts.json');
// Every account mutator reads and rewrites this one file, so even writes for
// different accounts must share one tail to preserve both changes.
const queueWrite = createFileWriteQueue();

async function loadAccounts() {
  await ensureDir(PATHS.calendar);
  // Account mutations must never save an empty map over unreadable account bytes.
  const parsed = await readJSONFile(ACCOUNTS_FILE, {}, { strict: true });
  return isPlainObject(parsed) ? parsed : {};
}

async function saveAccounts(accounts) {
  await ensureDir(PATHS.calendar);
  await atomicWrite(ACCOUNTS_FILE, accounts);
  noteReadinessChanged();
}

export async function listAccounts() {
  const accounts = await loadAccounts();
  return Object.values(accounts).sort((a, b) => a.name.localeCompare(b.name));
}

export async function getAccount(id) {
  const accounts = await loadAccounts();
  return accounts[id] || null;
}

export async function createAccount(data) {
  return queueWrite(async () => {
    const accounts = await loadAccounts();
    const id = uuidv4();
    accounts[id] = {
      id,
      name: data.name,
      type: data.type, // outlook-calendar
      email: data.email || '',
      enabled: true,
      syncConfig: {
        maxAge: data.syncConfig?.maxAge || '90d',
        syncInterval: data.syncConfig?.syncInterval || 300000,
        calendarIds: data.syncConfig?.calendarIds || ['default']
      },
      lastSyncAt: null,
      lastSyncStatus: null,
      createdAt: new Date().toISOString()
    };
    // For google-calendar, initialize subcalendars
    if (data.type === 'google-calendar') {
      accounts[id].subcalendars = (data.subcalendars || []).map(sc => ({
        calendarId: sc.calendarId,
        name: sc.name,
        color: sc.color || '',
        enabled: sc.enabled !== false,
        dormant: sc.dormant || false,
        goalIds: sc.goalIds || [],
        addedAt: sc.addedAt || new Date().toISOString()
      }));
      // Default to google-api if OAuth is configured, otherwise claude-mcp
      const { getAuthStatus } = await import('./googleAuth.js');
      const authStatus = await getAuthStatus().catch(() => ({}));
      accounts[id].syncMethod = authStatus.hasTokens ? 'google-api' : 'claude-mcp';
    }
    await saveAccounts(accounts);
    console.log(`📅 Calendar account created: ${data.name} (${data.type})`);
    return accounts[id];
  });
}

export async function updateAccount(id, updates) {
  return queueWrite(async () => {
    const accounts = await loadAccounts();
    if (!accounts[id]) return null;
    const { name, email, enabled, syncConfig } = updates;
    if (name !== undefined) accounts[id].name = name;
    if (email !== undefined) accounts[id].email = email;
    if (enabled !== undefined) accounts[id].enabled = enabled;
    if (syncConfig) accounts[id].syncConfig = { ...accounts[id].syncConfig, ...syncConfig };
    if (updates.syncMethod !== undefined) accounts[id].syncMethod = updates.syncMethod;
    accounts[id].updatedAt = new Date().toISOString();
    await saveAccounts(accounts);
    return accounts[id];
  });
}

export async function deleteAccount(id) {
  return queueWrite(async () => {
    const accounts = await loadAccounts();
    if (!accounts[id]) return false;
    delete accounts[id];
    await saveAccounts(accounts);
    console.log(`🗑️ Calendar account deleted: ${id}`);
    return true;
  });
}

export async function updateSubcalendars(id, subcalendars) {
  return queueWrite(async () => {
    const accounts = await loadAccounts();
    if (!accounts[id]) return null;
    accounts[id].subcalendars = subcalendars.map(sc => ({
      calendarId: sc.calendarId,
      name: sc.name,
      color: sc.color || '',
      enabled: sc.enabled !== false,
      dormant: sc.dormant || false,
      goalIds: sc.goalIds || [],
      addedAt: sc.addedAt || new Date().toISOString()
    }));
    accounts[id].updatedAt = new Date().toISOString();
    await saveAccounts(accounts);
    console.log(`📅 Updated subcalendars for account ${accounts[id].name}: ${subcalendars.length} calendars`);
    return accounts[id];
  });
}

export function mergeDiscoveredSubcalendars(existing, discovered) {
  const existingMap = new Map((existing || []).map(sc => [sc.calendarId, sc]));
  return discovered.map(cal => {
    const prev = existingMap.get(cal.id);
    return {
      calendarId: cal.id,
      name: cal.name || cal.id,
      color: cal.color || prev?.color || '',
      enabled: prev?.enabled ?? false,
      dormant: prev?.dormant ?? false,
      goalIds: prev?.goalIds || [],
      addedAt: prev?.addedAt || new Date().toISOString()
    };
  });
}

export async function updateSyncStatus(id, status) {
  return queueWrite(async () => {
    const accounts = await loadAccounts();
    if (!accounts[id]) return null;
    accounts[id].lastSyncAt = new Date().toISOString();
    accounts[id].lastSyncStatus = status;
    await saveAccounts(accounts);
    return accounts[id];
  });
}