spiracha 1.2.0 → 1.3.0

package/src/lib/antigravity-exporter-types.ts

@@ -0,0 +1,70 @@
+import os from 'node:os';
+import path from 'node:path';
+
+export const DEFAULT_ANTIGRAVITY_IDE_DIR = path.join(os.homedir(), '.gemini', 'antigravity-ide');
+export const DEFAULT_ANTIGRAVITY_DIR = path.join(os.homedir(), '.gemini', 'antigravity');
+
+export const resolveAntigravityRoots = (): string[] => {
+    const configured = process.env.SPIRACHA_ANTIGRAVITY_DIRS?.trim() || process.env.SPIRACHA_ANTIGRAVITY_DIR?.trim();
+    if (configured) {
+        return configured
+            .split(path.delimiter)
+            .map((entry) => entry.trim())
+            .filter(Boolean);
+    }
+
+    return [DEFAULT_ANTIGRAVITY_IDE_DIR, DEFAULT_ANTIGRAVITY_DIR];
+};
+
+export const getAntigravityConversationDir = (root: string): string => path.join(root, 'conversations');
+
+export const getAntigravityBrainDir = (root: string): string => path.join(root, 'brain');
+
+export const getAntigravitySummaryIndexPath = (root: string): string => path.join(root, 'agyhub_summaries_proto.pb');
+
+export type AntigravityArtifact = {
+    artifactType: string | null;
+    bytes: number;
+    name: string;
+    path: string;
+    sourceRoot: string;
+    summary: string | null;
+    updatedAtMs: number | null;
+};
+
+export type AntigravityTranscriptSource = 'overview' | 'safe-storage' | 'transcript';
+
+export type AntigravityConversation = {
+    artifactBytes: number;
+    artifactCount: number;
+    artifacts: AntigravityArtifact[];
+    conversationBytes: number;
+    conversationId: string;
+    conversationMtimeMs: number | null;
+    conversationPath: string | null;
+    createdAtMs: number | null;
+    indexedItemCount: number | null;
+    lastUpdatedAtMs: number | null;
+    sourceRoot: string | null;
+    summaryPath: string | null;
+    title: string;
+    transcriptBytes: number;
+    transcriptEntryCount: number;
+    transcriptPath: string | null;
+    transcriptSource: AntigravityTranscriptSource | null;
+    workspaceFolder: string | null;
+    workspaceKey: string;
+    workspaceLabel: string;
+    workspaceUri: string | null;
+};
+
+export type AntigravityWorkspaceGroup = {
+    artifactCount: number;
+    conversationBytes: number;
+    conversationCount: number;
+    key: string;
+    label: string;
+    lastActiveMs: number;
+    transcriptCount: number;
+    uri: string | null;
+};

package/src/lib/antigravity-keychain.ts

@@ -0,0 +1,203 @@
+import { execFile } from 'node:child_process';
+import { createDecipheriv, pbkdf2Sync } from 'node:crypto';
+import { promisify } from 'node:util';
+
+export const ANTIGRAVITY_KEYCHAIN_SERVICE = 'Antigravity Safe Storage';
+export const ANTIGRAVITY_KEYCHAIN_ACCOUNT = 'Antigravity Key';
+
+export type AntigravityDecryptionState = {
+    canRequestAccess: boolean;
+    error: string | null;
+    isUnlocked: boolean;
+    keychainAccount: string;
+    keychainService: string;
+    platform: NodeJS.Platform;
+    provider: 'keychain' | 'unsupported';
+    status: 'error' | 'locked' | 'unlocked' | 'unsupported';
+};
+
+const execFileAsync = promisify(execFile);
+const SAFE_STORAGE_SALT = 'saltysalt';
+const SAFE_STORAGE_ITERATIONS = 1003;
+const SAFE_STORAGE_KEY_LENGTH = 16;
+const SAFE_STORAGE_IV = Buffer.alloc(16, 0x20);
+
+let cachedKeychainSecret: string | null = null;
+let lastKeychainError: string | null = null;
+
+export const deriveAntigravitySafeStorageKey = (keychainSecret: string | Buffer): Buffer => {
+    return pbkdf2Sync(keychainSecret, SAFE_STORAGE_SALT, SAFE_STORAGE_ITERATIONS, SAFE_STORAGE_KEY_LENGTH, 'sha1');
+};
+
+const parseBufferJson = (value: unknown): Buffer | null => {
+    if (!value || typeof value !== 'object') {
+        return null;
+    }
+
+    const data = (value as { data?: unknown }).data;
+    if (!Array.isArray(data) || data.some((entry) => typeof entry !== 'number')) {
+        return null;
+    }
+
+    return Buffer.from(data);
+};
+
+const normalizeEncryptedPayload = (payload: Buffer | Uint8Array | string): Buffer | null => {
+    if (payload instanceof Buffer) {
+        return payload;
+    }
+
+    if (payload instanceof Uint8Array) {
+        return Buffer.from(payload);
+    }
+
+    const trimmed = payload.trim();
+    if (trimmed.startsWith('{')) {
+        try {
+            return parseBufferJson(JSON.parse(trimmed));
+        } catch {
+            return null;
+        }
+    }
+
+    return Buffer.from(payload, 'binary');
+};
+
+const hasSafeStoragePrefix = (payload: Buffer): boolean => {
+    const prefix = payload.subarray(0, 3).toString('ascii');
+    return prefix === 'v10' || prefix === 'v11';
+};
+
+const isReadableUtf8 = (value: string): boolean => {
+    if (value.includes('\uFFFD')) {
+        return false;
+    }
+
+    const printable = [...value].filter((char) => {
+        const code = char.charCodeAt(0);
+        return code === 9 || code === 10 || code === 13 || code >= 32;
+    }).length;
+
+    return value.length === 0 || printable / value.length > 0.95;
+};
+
+const decryptWithKey = (encrypted: Buffer, key: Buffer): string | null => {
+    const ciphertext = hasSafeStoragePrefix(encrypted) ? encrypted.subarray(3) : encrypted;
+    if (ciphertext.length === 0 || ciphertext.length % 16 !== 0) {
+        return null;
+    }
+
+    try {
+        const decipher = createDecipheriv('aes-128-cbc', key, SAFE_STORAGE_IV);
+        const decrypted = Buffer.concat([decipher.update(ciphertext), decipher.final()]).toString('utf8');
+        return isReadableUtf8(decrypted) ? decrypted : null;
+    } catch {
+        return null;
+    }
+};
+
+export const decryptAntigravitySafeStoragePayload = (
+    payload: Buffer | Uint8Array | string,
+    keychainSecret: string,
+): string | null => {
+    const encrypted = normalizeEncryptedPayload(payload);
+    if (!encrypted) {
+        return null;
+    }
+
+    const keyAttempts = [deriveAntigravitySafeStorageKey(keychainSecret)];
+    if (/^[A-Za-z0-9+/]+={0,2}$/u.test(keychainSecret)) {
+        keyAttempts.push(deriveAntigravitySafeStorageKey(Buffer.from(keychainSecret, 'base64')));
+    }
+
+    for (const key of keyAttempts) {
+        const decrypted = decryptWithKey(encrypted, key);
+        if (decrypted !== null) {
+            return decrypted;
+        }
+    }
+
+    return null;
+};
+
+export const getAntigravityDecryptionState = ({
+    cachedSecret = cachedKeychainSecret,
+    lastError = lastKeychainError,
+    platform = process.platform,
+}: {
+    cachedSecret?: string | null;
+    lastError?: string | null;
+    platform?: NodeJS.Platform;
+} = {}): AntigravityDecryptionState => {
+    if (platform !== 'darwin') {
+        return {
+            canRequestAccess: false,
+            error: null,
+            isUnlocked: false,
+            keychainAccount: ANTIGRAVITY_KEYCHAIN_ACCOUNT,
+            keychainService: ANTIGRAVITY_KEYCHAIN_SERVICE,
+            platform,
+            provider: 'unsupported',
+            status: 'unsupported',
+        };
+    }
+
+    if (cachedSecret) {
+        return {
+            canRequestAccess: true,
+            error: null,
+            isUnlocked: true,
+            keychainAccount: ANTIGRAVITY_KEYCHAIN_ACCOUNT,
+            keychainService: ANTIGRAVITY_KEYCHAIN_SERVICE,
+            platform,
+            provider: 'keychain',
+            status: 'unlocked',
+        };
+    }
+
+    return {
+        canRequestAccess: true,
+        error: lastError,
+        isUnlocked: false,
+        keychainAccount: ANTIGRAVITY_KEYCHAIN_ACCOUNT,
+        keychainService: ANTIGRAVITY_KEYCHAIN_SERVICE,
+        platform,
+        provider: 'keychain',
+        status: lastError ? 'error' : 'locked',
+    };
+};
+
+export const getCachedAntigravityKeychainSecret = (): string | null => cachedKeychainSecret;
+
+export const readAntigravityKeychainSecret = async (): Promise<string> => {
+    if (process.platform !== 'darwin') {
+        throw new Error('Antigravity Keychain access is only available on macOS.');
+    }
+
+    const { stdout } = await execFileAsync('security', [
+        'find-generic-password',
+        '-s',
+        ANTIGRAVITY_KEYCHAIN_SERVICE,
+        '-a',
+        ANTIGRAVITY_KEYCHAIN_ACCOUNT,
+        '-w',
+    ]);
+    const secret = stdout.trim();
+    if (!secret) {
+        throw new Error(`No secret was returned for ${ANTIGRAVITY_KEYCHAIN_SERVICE}.`);
+    }
+
+    return secret;
+};
+
+export const unlockAntigravityDecryption = async (): Promise<AntigravityDecryptionState> => {
+    try {
+        cachedKeychainSecret = await readAntigravityKeychainSecret();
+        lastKeychainError = null;
+    } catch (error) {
+        cachedKeychainSecret = null;
+        lastKeychainError = error instanceof Error ? error.message : String(error);
+    }
+
+    return getAntigravityDecryptionState();
+};

package/src/lib/codex-browser-db.ts

@@ -491,7 +491,13 @@ export const getCodexDashboardSummary = (dbPath: string): DashboardSummary => {
     return {
         activeThreads: threads.filter((thread) => !thread.archived).length,
         archivedThreads: threads.filter((thread) => Boolean(thread.archived)).length,
-        recentThreads: threads.slice(0, 5),
+        recentThreads: threads
+            .slice(0, 5)
+            .filter((thread) => Boolean(getPortablePathBasename(thread.cwd)))
+            .map((thread) => ({
+                project: getPortablePathBasename(thread.cwd),
+                thread: compactThreadListRow(thread),
+            })),
         threadsWithRelations,
         topProjectsByThreadCount: [...projects]
             .sort((left, right) => {

package/src/lib/codex-browser-types.ts

@@ -170,10 +170,15 @@ export type ThreadBrowseData = {
     thread: ThreadRow;
 };
 
+export type DashboardRecentThread = {
+    project: string;
+    thread: ThreadRow;
+};
+
 export type DashboardSummary = {
     activeThreads: number;
     archivedThreads: number;
-    recentThreads: ThreadRow[];
+    recentThreads: DashboardRecentThread[];
     threadsWithRelations: number;
     topProjectsByThreadCount: ProjectSummary[];
     topProjectsByTokens: ProjectSummary[];
@@ -191,6 +196,22 @@ export type DeleteProjectResult = DeleteThreadsResult & {
     projectName: string;
 };
 
+export type RecoverProjectThreadsResult = {
+    backups: {
+        globalState: string;
+        sessionIndex: string;
+        stateDb: string;
+    };
+    projectName: string;
+    projectRootsAdded: number;
+    resolvedCwds: string[];
+    rolloutFilesTouched: number;
+    savedRootsAdded: number;
+    sessionIndexRowsUpdated: number;
+    threadDbRowsUpdated: number;
+    topLevelThreadsFound: number;
+};
+
 export type ToolUsageSummary = {
     count: number;
     name: string;

package/src/lib/codex-thread-recovery.ts

@@ -0,0 +1,202 @@
+import { Database } from 'bun:sqlite';
+import { copyFile, utimes } from 'node:fs/promises';
+import path from 'node:path';
+import type { RecoverProjectThreadsResult } from './codex-browser-types';
+import { getPortablePathBasename } from './shared';
+import { runWithSqliteRetry } from './sqlite-retry';
+
+type RecoveryThreadRow = {
+    cwd: string;
+    id: string;
+    rollout_path: string;
+    thread_source: string | null;
+};
+
+type GlobalState = {
+    'active-workspace-roots'?: string[];
+    'electron-saved-workspace-roots'?: string[];
+    'project-order'?: string[];
+};
+
+const backupFile = async (filePath: string, label: string) => {
+    const stamp = new Date()
+        .toISOString()
+        .replaceAll(':', '')
+        .replace(/\.\d{3}Z$/, 'Z')
+        .replace('T', '-');
+    const backupPath = `${filePath}.bak-${label}-${stamp}`;
+    await copyFile(filePath, backupPath);
+    return backupPath;
+};
+
+const resolveCodexDirFromDbPath = (dbPath: string) => {
+    const dbDir = path.dirname(dbPath);
+    return path.basename(dbDir) === 'sqlite' ? path.dirname(dbDir) : dbDir;
+};
+
+const assertRequiredStatePath = async (filePath: string) => {
+    if (!(await Bun.file(filePath).exists())) {
+        throw new Error(`Required Codex state file not found: ${filePath}`);
+    }
+};
+
+const readGlobalState = async (globalStatePath: string) => {
+    return (await Bun.file(globalStatePath).json()) as GlobalState;
+};
+
+const writeGlobalState = async (globalStatePath: string, state: GlobalState) => {
+    await Bun.write(globalStatePath, JSON.stringify(state));
+};
+
+const updateGlobalRoots = (state: GlobalState, projectCwds: string[]) => {
+    const savedRoots = state['electron-saved-workspace-roots'] ?? [];
+    const projectOrder = state['project-order'] ?? [];
+    const missingSaved = projectCwds.filter((cwd) => !savedRoots.includes(cwd));
+    const missingProjectOrder = projectCwds.filter((cwd) => !projectOrder.includes(cwd));
+
+    if (missingSaved.length === 0 && missingProjectOrder.length === 0) {
+        return {
+            projectRootsAdded: 0,
+            savedRootsAdded: 0,
+            state,
+        };
+    }
+
+    state['electron-saved-workspace-roots'] = [...savedRoots, ...missingSaved];
+    state['project-order'] = [...projectOrder, ...missingProjectOrder];
+
+    return {
+        projectRootsAdded: missingProjectOrder.length,
+        savedRootsAdded: missingSaved.length,
+        state,
+    };
+};
+
+const getProjectTopLevelThreads = (db: Database, projectName: string): RecoveryThreadRow[] => {
+    const threads = db
+        .query('SELECT id, cwd, rollout_path, thread_source FROM threads WHERE archived = 0')
+        .all() as RecoveryThreadRow[];
+    return threads.filter((thread) => {
+        return getPortablePathBasename(thread.cwd) === projectName && thread.thread_source !== 'subagent';
+    });
+};
+
+const refreshThreadRows = (db: Database, threadIds: string[]) => {
+    if (threadIds.length === 0) {
+        return 0;
+    }
+
+    const nowSeconds = Math.floor(Date.now() / 1000);
+    const nowMs = Date.now();
+    const placeholders = threadIds.map(() => '?').join(', ');
+    const statement = db.prepare(`
+        UPDATE threads
+        SET updated_at = ?1,
+            updated_at_ms = ?2,
+            has_user_event = 1
+        WHERE id IN (${placeholders})
+    `);
+    const result = statement.run(nowSeconds, nowMs, ...threadIds);
+    return Number(result.changes);
+};
+
+const refreshSessionIndex = async (sessionIndexPath: string, threadIds: string[]) => {
+    if (threadIds.length === 0) {
+        return 0;
+    }
+
+    const now = new Date().toISOString().replace(/\.\d{3}Z$/, 'Z');
+    const threadIdSet = new Set(threadIds);
+    const lines = (await Bun.file(sessionIndexPath).text()).split('\n');
+    let updated = 0;
+    const rewrittenLines: string[] = [];
+
+    for (const line of lines) {
+        if (!line.trim()) {
+            continue;
+        }
+
+        const parsed = JSON.parse(line) as { id?: string; updated_at?: string };
+        if (parsed.id && threadIdSet.has(parsed.id)) {
+            parsed.updated_at = now;
+            updated += 1;
+        }
+
+        rewrittenLines.push(JSON.stringify(parsed));
+    }
+
+    await Bun.write(sessionIndexPath, `${rewrittenLines.join('\n')}\n`);
+    return updated;
+};
+
+const touchRolloutFiles = async (codexDir: string, rolloutPaths: string[]) => {
+    const now = new Date();
+    let touched = 0;
+
+    for (const rolloutPath of rolloutPaths) {
+        const absolutePath = path.isAbsolute(rolloutPath) ? rolloutPath : path.join(codexDir, rolloutPath);
+        if (!(await Bun.file(absolutePath).exists())) {
+            continue;
+        }
+
+        await utimes(absolutePath, now, now);
+        touched += 1;
+    }
+
+    return touched;
+};
+
+export const recoverCodexProjectThreads = async (
+    dbPath: string,
+    projectName: string,
+): Promise<RecoverProjectThreadsResult> => {
+    const codexDir = resolveCodexDirFromDbPath(dbPath);
+    const globalStatePath = path.join(codexDir, '.codex-global-state.json');
+    const sessionIndexPath = path.join(codexDir, 'session_index.jsonl');
+
+    await assertRequiredStatePath(dbPath);
+    await assertRequiredStatePath(globalStatePath);
+    await assertRequiredStatePath(sessionIndexPath);
+
+    const backups = {
+        globalState: await backupFile(globalStatePath, 'recover-project-roots'),
+        sessionIndex: await backupFile(sessionIndexPath, 'recover-project-session-index'),
+        stateDb: await backupFile(dbPath, 'recover-project-threads'),
+    };
+
+    const globalState = await readGlobalState(globalStatePath);
+    const db = runWithSqliteRetry({
+        action: () => {
+            const opened = new Database(dbPath);
+            opened.exec('PRAGMA busy_timeout = 5000');
+            return opened;
+        },
+    });
+
+    try {
+        const topLevelThreads = getProjectTopLevelThreads(db, projectName);
+        const projectCwds = [...new Set(topLevelThreads.map((thread) => thread.cwd))];
+        const rootUpdateResult = updateGlobalRoots(globalState, projectCwds);
+        await writeGlobalState(globalStatePath, rootUpdateResult.state);
+
+        const threadIds = topLevelThreads.map((thread) => thread.id);
+        const rolloutPaths = topLevelThreads.map((thread) => thread.rollout_path);
+        const threadDbRowsUpdated = refreshThreadRows(db, threadIds);
+        const sessionIndexRowsUpdated = await refreshSessionIndex(sessionIndexPath, threadIds);
+        const rolloutFilesTouched = await touchRolloutFiles(codexDir, rolloutPaths);
+
+        return {
+            backups,
+            projectName,
+            projectRootsAdded: rootUpdateResult.projectRootsAdded,
+            resolvedCwds: projectCwds,
+            rolloutFilesTouched,
+            savedRootsAdded: rootUpdateResult.savedRootsAdded,
+            sessionIndexRowsUpdated,
+            threadDbRowsUpdated,
+            topLevelThreadsFound: threadIds.length,
+        };
+    } finally {
+        db.close();
+    }
+};