surface-cli 0.1.1 → 0.3.0

package/dist/state/database.js

@@ -24,6 +24,19 @@ export class SurfaceDatabase {
         updated_at TEXT NOT NULL
       );
 
+      CREATE TABLE IF NOT EXISTS account_identities (
+        account_id TEXT PRIMARY KEY,
+        primary_email TEXT NOT NULL,
+        display_name TEXT,
+        email_aliases_json TEXT NOT NULL DEFAULT '[]',
+        name_aliases_json TEXT NOT NULL DEFAULT '[]',
+        primary_email_source TEXT NOT NULL DEFAULT 'configured',
+        display_name_source TEXT,
+        verified_at TEXT,
+        updated_at TEXT NOT NULL,
+        FOREIGN KEY(account_id) REFERENCES accounts(account_id) ON DELETE CASCADE
+      );
+
       CREATE TABLE IF NOT EXISTS threads (
         thread_ref TEXT PRIMARY KEY,
         account_id TEXT NOT NULL,
@@ -101,13 +114,34 @@ export class SurfaceDatabase {
         brief TEXT NOT NULL,
         needs_action INTEGER NOT NULL DEFAULT 0,
         importance TEXT NOT NULL,
+        fingerprint TEXT,
         generated_at TEXT NOT NULL,
         FOREIGN KEY(thread_ref) REFERENCES threads(thread_ref) ON DELETE CASCADE
       );
+
+      CREATE TABLE IF NOT EXISTS sessions (
+        session_id TEXT PRIMARY KEY,
+        account_id TEXT NOT NULL,
+        provider TEXT NOT NULL,
+        transport TEXT NOT NULL,
+        socket_path TEXT NOT NULL,
+        auth_token TEXT NOT NULL,
+        status TEXT NOT NULL,
+        pid INTEGER,
+        idle_timeout_seconds INTEGER NOT NULL,
+        max_age_seconds INTEGER NOT NULL,
+        error_detail TEXT,
+        created_at TEXT NOT NULL,
+        last_used_at TEXT NOT NULL,
+        closed_at TEXT,
+        FOREIGN KEY(account_id) REFERENCES accounts(account_id) ON DELETE CASCADE
+      );
     `);
         this.ensureColumn("threads", "participants_json", "TEXT NOT NULL DEFAULT '[]'");
         this.ensureColumn("messages", "invite_json", "TEXT");
+        this.ensureColumn("summaries", "fingerprint", "TEXT");
         this.ensureProviderLocatorSchema();
+        this.seedMissingAccountIdentities();
     }
     tableColumns(tableName) {
         return this.connection
@@ -158,6 +192,153 @@ export class SurfaceDatabase {
         }
         this.connection.exec("DROP TABLE IF EXISTS provider_locators_legacy;");
     }
+    parseStringArray(rawValue) {
+        try {
+            const parsed = JSON.parse(rawValue);
+            return Array.isArray(parsed)
+                ? parsed.filter((entry) => typeof entry === "string" && entry.trim().length > 0)
+                : [];
+        }
+        catch {
+            return [];
+        }
+    }
+    normalizeEmailList(values) {
+        const seen = new Set();
+        const normalized = [];
+        for (const value of values) {
+            const candidate = value.trim().toLowerCase();
+            if (!candidate || seen.has(candidate)) {
+                continue;
+            }
+            seen.add(candidate);
+            normalized.push(candidate);
+        }
+        return normalized;
+    }
+    isPlaceholderEmail(value) {
+        return value.trim().toLowerCase().endsWith("@placeholder.local");
+    }
+    normalizeNameList(values) {
+        const seen = new Set();
+        const normalized = [];
+        for (const value of values) {
+            const candidate = value.trim().replace(/\s+/g, " ");
+            const key = candidate.toLowerCase();
+            if (!candidate || seen.has(key)) {
+                continue;
+            }
+            seen.add(key);
+            normalized.push(candidate);
+        }
+        return normalized;
+    }
+    rowToAccountIdentity(row) {
+        return {
+            account_id: row.account_id,
+            primary_email: row.primary_email,
+            display_name: row.display_name,
+            email_aliases: this.parseStringArray(row.email_aliases_json),
+            name_aliases: this.parseStringArray(row.name_aliases_json),
+            primary_email_source: row.primary_email_source,
+            display_name_source: row.display_name_source,
+            verified_at: row.verified_at,
+            updated_at: row.updated_at,
+        };
+    }
+    seedMissingAccountIdentities() {
+        const timestamp = nowIsoUtc();
+        this.connection
+            .prepare(`
+        INSERT OR IGNORE INTO account_identities (
+          account_id,
+          primary_email,
+          email_aliases_json,
+          name_aliases_json,
+          primary_email_source,
+          display_name_source,
+          verified_at,
+          updated_at
+        )
+        SELECT
+          account_id,
+          lower(email),
+          '[]',
+          '[]',
+          'configured',
+          NULL,
+          NULL,
+          @updated_at
+        FROM accounts
+        `)
+            .run({ updated_at: timestamp });
+    }
+    seedOrUpdateConfiguredIdentity(account) {
+        const existing = this.findAccountIdentity(account);
+        const timestamp = nowIsoUtc();
+        if (!existing) {
+            this.connection
+                .prepare(`
+          INSERT INTO account_identities (
+            account_id,
+            primary_email,
+            email_aliases_json,
+            name_aliases_json,
+            primary_email_source,
+            display_name_source,
+            verified_at,
+            updated_at
+          ) VALUES (
+            @account_id,
+            @primary_email,
+            '[]',
+            '[]',
+            'configured',
+            NULL,
+            NULL,
+            @updated_at
+          )
+          `)
+                .run({
+                account_id: account.account_id,
+                primary_email: account.email.trim().toLowerCase(),
+                updated_at: timestamp,
+            });
+            return;
+        }
+        if (existing.primary_email_source !== "configured") {
+            return;
+        }
+        const primaryEmail = account.email.trim().toLowerCase();
+        if (existing.primary_email === primaryEmail) {
+            return;
+        }
+        this.connection
+            .prepare(`
+        UPDATE account_identities
+        SET primary_email = @primary_email,
+            updated_at = @updated_at
+        WHERE account_id = @account_id
+        `)
+            .run({
+            account_id: account.account_id,
+            primary_email: primaryEmail,
+            updated_at: timestamp,
+        });
+        this.clearSummariesForAccount(account.account_id);
+    }
+    clearSummariesForAccount(accountId) {
+        this.connection
+            .prepare(`
+        DELETE FROM summaries
+        WHERE thread_ref IN (
+          SELECT thread_ref
+          FROM threads
+          WHERE account_id = ?
+        )
+        `)
+            .run(accountId);
+    }
     upsertAccount(input) {
         const existing = this.findAccountByName(input.name);
         const timestamp = nowIsoUtc();
@@ -178,7 +359,9 @@ export class SurfaceDatabase {
                 email: input.email,
                 updated_at: timestamp,
             });
-            return this.findAccountByName(input.name);
+            const account = this.findAccountByName(input.name);
+            this.seedOrUpdateConfiguredIdentity(account);
+            return account;
         }
         const account = {
             account_id: makeAccountId(),
@@ -210,8 +393,144 @@ export class SurfaceDatabase {
         )
         `)
             .run(account);
+        this.seedOrUpdateConfiguredIdentity(account);
         return account;
     }
+    findAccountIdentity(account) {
+        const row = this.connection
+            .prepare(`
+        SELECT
+          account_id,
+          primary_email,
+          display_name,
+          email_aliases_json,
+          name_aliases_json,
+          primary_email_source,
+          display_name_source,
+          verified_at,
+          updated_at
+        FROM account_identities
+        WHERE account_id = ?
+        LIMIT 1
+        `)
+            .get(account.account_id);
+        return row ? this.rowToAccountIdentity(row) : undefined;
+    }
+    getAccountIdentity(account) {
+        const existing = this.findAccountIdentity(account);
+        if (existing) {
+            return existing;
+        }
+        this.seedOrUpdateConfiguredIdentity(account);
+        const seeded = this.findAccountIdentity(account);
+        if (!seeded) {
+            throw new Error(`Account identity could not be created for account '${account.name}'.`);
+        }
+        return seeded;
+    }
+    updateAccountIdentityFromUser(account, input) {
+        const existing = this.getAccountIdentity(account);
+        const timestamp = nowIsoUtc();
+        const primaryEmail = input.primary_email?.trim().toLowerCase() ?? existing.primary_email;
+        const displayName = input.display_name?.trim().replace(/\s+/g, " ") ?? existing.display_name;
+        const emailAliases = this.normalizeEmailList([
+            ...(input.clear_email_aliases ? [] : existing.email_aliases),
+            ...(input.email_aliases ?? []),
+        ].filter((email) => email.trim().toLowerCase() !== primaryEmail));
+        const nameAliases = this.normalizeNameList([
+            ...(input.clear_name_aliases ? [] : existing.name_aliases),
+            ...(input.name_aliases ?? []),
+        ].filter((name) => name.trim().replace(/\s+/g, " ") !== displayName));
+        this.connection
+            .prepare(`
+        UPDATE account_identities
+        SET primary_email = @primary_email,
+            display_name = @display_name,
+            email_aliases_json = @email_aliases_json,
+            name_aliases_json = @name_aliases_json,
+            primary_email_source = @primary_email_source,
+            display_name_source = @display_name_source,
+            verified_at = @verified_at,
+            updated_at = @updated_at
+        WHERE account_id = @account_id
+        `)
+            .run({
+            account_id: account.account_id,
+            primary_email: primaryEmail,
+            display_name: displayName,
+            email_aliases_json: JSON.stringify(emailAliases),
+            name_aliases_json: JSON.stringify(nameAliases),
+            primary_email_source: input.primary_email ? "user_confirmed" : existing.primary_email_source,
+            display_name_source: input.display_name ? "user_confirmed" : existing.display_name_source,
+            verified_at: input.primary_email ? timestamp : existing.verified_at,
+            updated_at: timestamp,
+        });
+        if (input.primary_email) {
+            this.connection
+                .prepare(`
+          UPDATE accounts
+          SET email = @email,
+              updated_at = @updated_at
+          WHERE account_id = @account_id
+          `)
+                .run({
+                account_id: account.account_id,
+                email: primaryEmail,
+                updated_at: timestamp,
+            });
+        }
+        this.clearSummariesForAccount(account.account_id);
+        return this.getAccountIdentity(account);
+    }
+    updateAccountIdentityFromProvider(account, authenticatedEmail) {
+        const existing = this.getAccountIdentity(account);
+        const timestamp = nowIsoUtc();
+        const primaryEmail = authenticatedEmail.trim().toLowerCase();
+        const emailAliases = this.normalizeEmailList([
+            ...existing.email_aliases,
+            ...(existing.primary_email
+                && existing.primary_email !== primaryEmail
+                && !this.isPlaceholderEmail(existing.primary_email)
+                ? [existing.primary_email]
+                : []),
+        ].filter((email) => email.trim().toLowerCase() !== primaryEmail));
+        const identityChanged = primaryEmail !== existing.primary_email
+            || existing.primary_email_source !== "provider_verified"
+            || JSON.stringify(emailAliases) !== JSON.stringify(existing.email_aliases);
+        this.connection
+            .prepare(`
+        UPDATE account_identities
+        SET primary_email = @primary_email,
+            email_aliases_json = @email_aliases_json,
+            primary_email_source = 'provider_verified',
+            verified_at = @verified_at,
+            updated_at = @updated_at
+        WHERE account_id = @account_id
+        `)
+            .run({
+            account_id: account.account_id,
+            primary_email: primaryEmail,
+            email_aliases_json: JSON.stringify(emailAliases),
+            verified_at: timestamp,
+            updated_at: timestamp,
+        });
+        this.connection
+            .prepare(`
+        UPDATE accounts
+        SET email = @email,
+            updated_at = @updated_at
+        WHERE account_id = @account_id
+        `)
+            .run({
+            account_id: account.account_id,
+            email: primaryEmail,
+            updated_at: timestamp,
+        });
+        if (identityChanged) {
+            this.clearSummariesForAccount(account.account_id);
+        }
+        return this.getAccountIdentity({ ...account, email: primaryEmail });
+    }
     listAccounts() {
         return this.connection
             .prepare(`
@@ -509,7 +828,7 @@ export class SurfaceDatabase {
         `)
             .run(savedTo, attachmentId);
     }
-    upsertSummary(threadRef, summary) {
+    upsertSummary(threadRef, summary, fingerprint) {
         this.connection
             .prepare(`
         INSERT INTO summaries (
@@ -519,6 +838,7 @@ export class SurfaceDatabase {
           brief,
           needs_action,
           importance,
+          fingerprint,
           generated_at
         ) VALUES (
           @thread_ref,
@@ -527,6 +847,7 @@ export class SurfaceDatabase {
           @brief,
           @needs_action,
           @importance,
+          @fingerprint,
           @generated_at
         )
         ON CONFLICT(thread_ref) DO UPDATE SET
@@ -535,6 +856,7 @@ export class SurfaceDatabase {
           brief = excluded.brief,
           needs_action = excluded.needs_action,
           importance = excluded.importance,
+          fingerprint = excluded.fingerprint,
           generated_at = excluded.generated_at
         `)
             .run({
@@ -544,13 +866,22 @@ export class SurfaceDatabase {
             brief: summary.brief,
             needs_action: summary.needs_action ? 1 : 0,
             importance: summary.importance,
+            fingerprint,
             generated_at: nowIsoUtc(),
         });
     }
-    findSummary(threadRef) {
+    clearSummary(threadRef) {
+        this.connection
+            .prepare(`
+        DELETE FROM summaries
+        WHERE thread_ref = ?
+        `)
+            .run(threadRef);
+    }
+    findStoredSummary(threadRef) {
         const row = this.connection
             .prepare(`
-        SELECT backend, model, brief, needs_action, importance
+        SELECT thread_ref, backend, model, brief, needs_action, importance, fingerprint
         FROM summaries
         WHERE thread_ref = ?
         LIMIT 1
@@ -559,6 +890,151 @@ export class SurfaceDatabase {
         if (!row) {
             return null;
         }
+        return row;
+    }
+    createSession(input) {
+        const timestamp = nowIsoUtc();
+        this.connection
+            .prepare(`
+        INSERT INTO sessions (
+          session_id,
+          account_id,
+          provider,
+          transport,
+          socket_path,
+          auth_token,
+          status,
+          pid,
+          idle_timeout_seconds,
+          max_age_seconds,
+          error_detail,
+          created_at,
+          last_used_at,
+          closed_at
+        ) VALUES (
+          @session_id,
+          @account_id,
+          @provider,
+          @transport,
+          @socket_path,
+          @auth_token,
+          'starting',
+          NULL,
+          @idle_timeout_seconds,
+          @max_age_seconds,
+          NULL,
+          @created_at,
+          @last_used_at,
+          NULL
+        )
+        `)
+            .run({
+            ...input,
+            created_at: timestamp,
+            last_used_at: timestamp,
+        });
+        return this.getSession(input.session_id);
+    }
+    getSession(sessionId) {
+        return this.connection
+            .prepare(`
+        SELECT
+          session_id,
+          account_id,
+          provider,
+          transport,
+          socket_path,
+          auth_token,
+          status,
+          pid,
+          idle_timeout_seconds,
+          max_age_seconds,
+          error_detail,
+          created_at,
+          last_used_at,
+          closed_at
+        FROM sessions
+        WHERE session_id = ?
+        LIMIT 1
+        `)
+            .get(sessionId);
+    }
+    listSessions() {
+        return this.connection
+            .prepare(`
+        SELECT
+          session_id,
+          account_id,
+          provider,
+          transport,
+          socket_path,
+          auth_token,
+          status,
+          pid,
+          idle_timeout_seconds,
+          max_age_seconds,
+          error_detail,
+          created_at,
+          last_used_at,
+          closed_at
+        FROM sessions
+        ORDER BY created_at DESC
+        `)
+            .all();
+    }
+    markSessionRunning(sessionId, pid) {
+        this.connection
+            .prepare(`
+        UPDATE sessions
+        SET status = 'running',
+            pid = ?,
+            error_detail = NULL,
+            closed_at = NULL
+        WHERE session_id = ?
+        `)
+            .run(pid, sessionId);
+    }
+    updateSessionProcessInfo(sessionId, pid) {
+        this.connection
+            .prepare(`
+        UPDATE sessions
+        SET pid = ?
+        WHERE session_id = ?
+        `)
+            .run(pid, sessionId);
+    }
+    touchSession(sessionId) {
+        this.connection
+            .prepare(`
+        UPDATE sessions
+        SET last_used_at = ?
+        WHERE session_id = ?
+        `)
+            .run(nowIsoUtc(), sessionId);
+    }
+    markSessionClosed(sessionId, status, options = {}) {
+        this.connection
+            .prepare(`
+        UPDATE sessions
+        SET status = @status,
+            error_detail = @error_detail,
+            pid = @pid,
+            closed_at = @closed_at
+        WHERE session_id = @session_id
+        `)
+            .run({
+            session_id: sessionId,
+            status,
+            error_detail: options.errorDetail ?? null,
+            pid: options.pid ?? null,
+            closed_at: nowIsoUtc(),
+        });
+    }
+    findSummary(threadRef) {
+        const row = this.findStoredSummary(threadRef);
+        if (!row) {
+            return null;
+        }
         return {
             backend: row.backend,
             model: row.model,
@@ -604,7 +1080,30 @@ export class SurfaceDatabase {
         `)
             .get(messageRef);
     }
+    getStoredThread(threadRef) {
+        return this.connection
+            .prepare(`
+        SELECT
+          thread_ref,
+          account_id,
+          subject,
+          mailbox,
+          participants_json,
+          labels_json,
+          received_at,
+          message_count,
+          unread_count,
+          has_attachments
+        FROM threads
+        WHERE thread_ref = ?
+        LIMIT 1
+        `)
+            .get(threadRef);
+    }
     updateInviteStatusForThread(threadRef, responseStatus) {
+        this.updateInviteForThread(threadRef, { response_status: responseStatus });
+    }
+    updateInviteForThread(threadRef, patch) {
         const rows = this.connection
             .prepare(`
         SELECT message_ref, invite_json
@@ -627,10 +1126,7 @@ export class SurfaceDatabase {
             const invite = JSON.parse(row.invite_json);
             update.run({
                 message_ref: row.message_ref,
-                invite_json: JSON.stringify({
-                    ...invite,
-                    response_status: responseStatus,
-                }),
+                invite_json: JSON.stringify({ ...invite, ...patch }),
                 last_synced_at: lastSyncedAt,
             });
         }
@@ -645,6 +1141,34 @@ export class SurfaceDatabase {
           `)
             .all(threadRef).map((row) => row.message_ref);
     }
+    listStoredMessagesForThread(threadRef) {
+        return this.connection
+            .prepare(`
+        SELECT
+          m.message_ref,
+          m.account_id,
+          m.thread_ref,
+          m.subject,
+          m.from_name,
+          m.from_email,
+          m.to_json,
+          m.cc_json,
+          m.sent_at,
+          m.received_at,
+          m.unread,
+          m.snippet,
+          m.body_cache_path,
+          m.body_cached,
+          m.body_truncated,
+          m.body_cached_bytes,
+          m.invite_json
+        FROM thread_messages tm
+        INNER JOIN messages m ON m.message_ref = tm.message_ref
+        WHERE tm.thread_ref = ?
+        ORDER BY tm.position ASC
+        `)
+            .all(threadRef);
+    }
     markThreadArchived(threadRef) {
         this.connection
             .prepare(`
@@ -717,6 +1241,16 @@ export class SurfaceDatabase {
         `)
             .get(messageRef);
     }
+    findThreadByRef(threadRef) {
+        return this.connection
+            .prepare(`
+        SELECT thread_ref, account_id
+        FROM threads
+        WHERE thread_ref = ?
+        LIMIT 1
+        `)
+            .get(threadRef);
+    }
     findAttachmentById(attachmentId) {
         return this.connection
             .prepare(`