spiracha 1.1.2 → 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-export.ts

@@ -11,9 +11,9 @@ import { buildUiExportDownloadUrl, ensureUiExportDir } from './ui-export-files';
 type RenderCodexThreadDownloadInput = {
     dbPath: string;
     includeCommentary: boolean;
+    includeMetadata: boolean;
     includeTools: boolean;
     largeExportThresholdBytes?: number;
-    optimized: boolean;
     outputFormat: ExportFormat;
     pathDisplaySettings?: Pick<PathDisplaySettings, 'convertToProjectRoot' | 'redactUsername'>;
     publicExportDir?: string;
@@ -101,9 +101,9 @@ const toDownloadOptions = (input: RenderCodexThreadDownloadInput): CodexCliOptio
         dbPath: input.dbPath,
         flat: false,
         includeCommentary: input.includeCommentary,
+        includeMetadata: input.includeMetadata,
         includeTools: input.includeTools,
         inputDir: '',
-        optimized: input.optimized,
         outputDir: '',
         outputFormat: input.outputFormat,
         projectFilter: null,

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-exporter-cli.ts

@@ -10,7 +10,7 @@ export const parseCodexCliArgs = (argv: string[]): CodexCliOptions => {
     let projectFilter: string | null = null;
     let threadIds: string[] = [];
     let outputProvided = false;
-    let optimized = false;
+    let includeMetadata = true;
     let includeCommentary = true;
     let includeTools = false;
     let outputFormat: ExportFormat = 'md';
@@ -22,9 +22,9 @@ export const parseCodexCliArgs = (argv: string[]): CodexCliOptions => {
             dbPath,
             flat,
             includeCommentary,
+            includeMetadata,
             includeTools,
             inputDir,
-            optimized,
             outputDir,
             outputFormat,
             outputProvided,
@@ -37,9 +37,9 @@ export const parseCodexCliArgs = (argv: string[]): CodexCliOptions => {
             dbPath,
             flat,
             includeCommentary,
+            includeMetadata,
             includeTools,
             inputDir,
-            optimized,
             outputDir,
             outputFormat,
             outputProvided,
@@ -58,9 +58,9 @@ export const parseCodexCliArgs = (argv: string[]): CodexCliOptions => {
         dbPath,
         flat,
         includeCommentary,
+        includeMetadata,
         includeTools,
         inputDir,
-        optimized,
         outputDir: outputDir ?? DEFAULT_OUTPUT_DIR,
         outputFormat,
         projectFilter,
@@ -73,9 +73,9 @@ type CodexCliState = {
     dbPath: string;
     flat: boolean;
     includeCommentary: boolean;
+    includeMetadata: boolean;
     includeTools: boolean;
     inputDir: string;
-    optimized: boolean;
     outputDir: string | null;
     outputFormat: ExportFormat;
     outputProvided: boolean;
@@ -142,12 +142,12 @@ const applyCodexCliArg = (argv: string[], index: number, state: CodexCliState):
         };
     }
 
-    if (arg === '--optimized') {
+    if (arg === '--no-metadata') {
         return {
             index,
             state: {
                 ...state,
-                optimized: true,
+                includeMetadata: false,
             },
         };
     }
@@ -220,7 +220,7 @@ export const getCodexHelpText = (): string => {
         'Usage:',
         '  codex-chats',
         '  codex-chats --interactive',
-        '  codex-chats [--db FILE] [--input DIR] [--output DIR] [--cwd DIR] [--project NAME] [--optimized] [--tools] [--flat] [--output-format md|txt] [codex://threads/<thread-id> ...]',
+        '  codex-chats [--db FILE] [--input DIR] [--output DIR] [--cwd DIR] [--project NAME] [--no-metadata] [--tools] [--flat] [--output-format md|txt] [codex://threads/<thread-id> ...]',
         '',
         'Options:',
         `  --db            Thread database path (default: ${DEFAULT_DB_PATH})`,
@@ -230,7 +230,7 @@ export const getCodexHelpText = (): string => {
         '  --project       Only export chats whose cwd basename matches this project name',
         '  codex://threads/<id>',
         '                  Only export the exact threads referenced by these Codex deeplinks',
-        '  --optimized     Suppress metadata and apply token-saving text cleanup',
+        '  --no-metadata   Omit the chat metadata section from the export header',
         '  --tools         Include tool-call logs such as exec_command invocations',
         '  --flat          Write all exports into one folder instead of nested subfolders',
         '  --output-format Output file format: md or txt (default: md)',