spiracha 1.5.0 → 2.0.0

package/src/lib/cursor-db.ts

@@ -360,8 +360,11 @@ export const groupCursorBuckets = (buckets: CursorWorkspaceBucket[]): CursorWork
     return groups.sort((a, b) => b.lastActiveMs - a.lastActiveMs);
 };
 
-export const listCursorWorkspaceGroups = async (userDir = resolveCursorUserDir()): Promise<CursorWorkspaceGroup[]> => {
-    return (await discoverCursorWorkspaces(userDir)).groups;
+export const listCursorWorkspaceGroups = async (
+    userDir = resolveCursorUserDir(),
+    options: CursorDiscoveryOptions = {},
+): Promise<CursorWorkspaceGroup[]> => {
+    return (await discoverCursorWorkspaces(userDir, options)).groups;
 };
 
 export const cursorBucketMatchesQuery = (bucket: CursorWorkspaceBucket, query: string): boolean => {
@@ -462,6 +465,7 @@ export const findCursorTranscriptDirs = async (
 
 export type ListCursorThreadsOptions = {
     includeTranscriptDirs?: boolean;
+    updatedAfterMs?: number;
 };
 
 export const listCursorThreadsForGroup = async (
@@ -469,7 +473,7 @@ export const listCursorThreadsForGroup = async (
     userDir = resolveCursorUserDir(),
     options: ListCursorThreadsOptions = {},
 ): Promise<CursorThreadSummary[]> => {
-    const discovery = await discoverCursorWorkspaces(userDir);
+    const discovery = await discoverCursorWorkspaces(userDir, options);
     const threads = discovery.threadsByKey.get(group.key) ?? [];
 
     if (options.includeTranscriptDirs === false) {
@@ -505,6 +509,10 @@ type CursorDiscovery = {
     threadsByKey: Map<string, CursorThreadSummary[]>;
 };
 
+type CursorDiscoveryOptions = {
+    updatedAfterMs?: number;
+};
+
 // Discovery does a full scan of the (potentially multi-GB) global DB, so cache it briefly. Writes
 // (recover/prune/delete) call invalidateCursorDiscoveryCache() so the UI never shows stale results.
 const DISCOVERY_TTL_MS = 60_000;
@@ -662,7 +670,20 @@ const inferFolderFromBubbles = (db: Database, composerId: string): string | null
     return inferFolderFromPaths(paths);
 };
 
-const readAllHeads = (db: Database): Map<string, GlobalHead> => {
+const readAllHeads = (db: Database, options: CursorDiscoveryOptions = {}): Map<string, GlobalHead> => {
+    if (options.updatedAfterMs !== undefined) {
+        const rows = db
+            .query(
+                `SELECT substr(key, 14) AS id, value
+                 FROM cursorDiskKV
+                 WHERE key LIKE 'composerData:%'
+                    AND COALESCE(json_extract(value, '$.lastUpdatedAt'), 0) >= ?`,
+            )
+            .all(options.updatedAfterMs) as Array<{ id: string; value: string }>;
+
+        return new Map(rows.map((row) => [row.id, parseGlobalHead(row.value)]));
+    }
+
     const rows = db
         .query(`SELECT substr(key, 14) AS id, value FROM cursorDiskKV WHERE key LIKE 'composerData:%'`)
         .all() as Array<{ id: string; value: string }>;
@@ -693,17 +714,28 @@ const parseGlobalHead = (value: string): GlobalHead => {
     };
 };
 
-const readBubbleStats = (db: Database): Map<string, BubbleStat> => {
+const readBubbleStats = (db: Database, composerIds?: Iterable<string>): Map<string, BubbleStat> => {
+    const ids = composerIds ? [...composerIds] : null;
+    if (ids?.length === 0) {
+        return new Map();
+    }
+
     // Keys are `bubbleId:<composerId>:<bubbleId>`; composer ids contain no colon, so slice up to the
     // next ':' rather than assuming a fixed UUID length (keeps tests and any id format working).
-    const rows = db
-        .query(
-            `SELECT substr(key, 10, instr(substr(key, 10), ':') - 1) AS id,
+    const query =
+        ids === null
+            ? `SELECT substr(key, 10, instr(substr(key, 10), ':') - 1) AS id,
+                    COUNT(*) AS count,
+                    COALESCE(SUM(length(value)), 0) AS bytes
+             FROM cursorDiskKV WHERE key GLOB 'bubbleId:*:*' GROUP BY id`
+            : `SELECT substr(key, 10, instr(substr(key, 10), ':') - 1) AS id,
                     COUNT(*) AS count,
                     COALESCE(SUM(length(value)), 0) AS bytes
-             FROM cursorDiskKV WHERE key GLOB 'bubbleId:*:*' GROUP BY id`,
-        )
-        .all() as Array<{ id: string; count: number; bytes: number }>;
+             FROM cursorDiskKV
+             WHERE key GLOB 'bubbleId:*:*'
+                AND substr(key, 10, instr(substr(key, 10), ':') - 1) IN (${ids.map(() => '?').join(',')})
+             GROUP BY id`;
+    const rows = db.query(query).all(...(ids ?? [])) as Array<{ id: string; count: number; bytes: number }>;
 
     return new Map(rows.map((row) => [row.id, { bytes: row.bytes, count: row.count }]));
 };
@@ -936,14 +968,13 @@ const buildDiscoveryGroups = (
     return groups.sort((a, b) => b.lastActiveMs - a.lastActiveMs);
 };
 
-const buildDiscovery = async (userDir: string): Promise<CursorDiscovery> => {
+const buildDiscovery = async (userDir: string, options: CursorDiscoveryOptions = {}): Promise<CursorDiscovery> => {
     const buckets = await loadCursorBuckets(userDir);
     const bucketGroups = groupCursorBuckets(buckets);
-    const fileHistoryActivity = await readCursorFileHistoryProjectActivity(userDir);
     const globalDbPath = getCursorGlobalDbPath(userDir);
 
     if (!(await pathExists(globalDbPath))) {
-        return assembleDiscovery([], bucketGroups, fileHistoryActivity);
+        return assembleDiscovery([], bucketGroups, new Map());
     }
 
     const bucketIdToGroupKey = new Map<string, string>();
@@ -955,14 +986,20 @@ const buildDiscovery = async (userDir: string): Promise<CursorDiscovery> => {
         }
     }
 
-    const headerInfo = readHeaderInfo(globalDbPath);
-    const bucketComposerIds = collectBucketComposerIds(buckets);
-
     const db = openCursorReadonlyDb(globalDbPath);
     try {
-        const heads = readAllHeads(db);
-        const stats = readBubbleStats(db);
-        const universe = new Set<string>([...heads.keys(), ...headerInfo.keys(), ...bucketComposerIds.keys()]);
+        const heads = readAllHeads(db, options);
+        if (options.updatedAfterMs !== undefined && heads.size === 0) {
+            return assembleDiscovery([], bucketGroups, new Map());
+        }
+
+        const headerInfo = readHeaderInfo(globalDbPath);
+        const bucketComposerIds = options.updatedAfterMs === undefined ? collectBucketComposerIds(buckets) : new Map();
+        const stats = readBubbleStats(db, options.updatedAfterMs === undefined ? undefined : heads.keys());
+        const universe =
+            options.updatedAfterMs === undefined
+                ? new Set<string>([...heads.keys(), ...headerInfo.keys(), ...bucketComposerIds.keys()])
+                : new Set<string>(heads.keys());
         const resolved: ResolvedThread[] = [];
 
         for (const composerId of universe) {
@@ -980,13 +1017,22 @@ const buildDiscovery = async (userDir: string): Promise<CursorDiscovery> => {
             );
         }
 
+        const fileHistoryActivity =
+            options.updatedAfterMs === undefined ? await readCursorFileHistoryProjectActivity(userDir) : new Map();
         return assembleDiscovery(resolved, bucketGroups, fileHistoryActivity);
     } finally {
         db.close();
     }
 };
 
-const discoverCursorWorkspaces = async (userDir: string): Promise<CursorDiscovery> => {
+const discoverCursorWorkspaces = async (
+    userDir: string,
+    options: CursorDiscoveryOptions = {},
+): Promise<CursorDiscovery> => {
+    if (options.updatedAfterMs !== undefined) {
+        return await buildDiscovery(userDir, options);
+    }
+
     const now = Date.now();
     if (discoveryCache && discoveryCache.userDir === userDir && now - discoveryCache.at < DISCOVERY_TTL_MS) {
         return discoveryCache.value;

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

@@ -152,25 +152,6 @@ export type CursorExportOptions = {
     outputFormat: ExportFormat;
 };
 
-export type CursorCliOptions = CursorExportOptions & {
-    userDir: string;
-    workspaceQuery: string | null;
-    threadIds: string[];
-    outputDir: string | null;
-};
-
-export type CursorExportedFile = {
-    composerId: string;
-    outputPath: string;
-};
-
-export type CursorExportRunResult = {
-    outputDir: string;
-    exportedCount: number;
-    files: CursorExportedFile[];
-    missingThreadIds: string[];
-};
-
 export type CursorRecoverResult = {
     workspaceKey: string;
     activeBucketId: string;

package/src/lib/qoder-acp-client.ts

@@ -0,0 +1,268 @@
+import net from 'node:net';
+import path from 'node:path';
+import { resolveQoderUserDir } from './qoder-exporter-types';
+import { asObject, asString, type JsonValue } from './shared';
+
+const DEFAULT_TIMEOUT_MS = 2_500;
+const DEFAULT_DRAIN_MS = 300;
+const INITIALIZE_REQUEST_ID = 1;
+const LOAD_REQUEST_ID = 2;
+
+type JsonRpcMessage = {
+    id?: number;
+    jsonrpc?: '2.0';
+    method?: string;
+    params?: Record<string, JsonValue>;
+    result?: JsonValue;
+};
+
+export type QoderAcpSessionUpdate = {
+    requestId: string | null;
+    sessionId: string;
+    update: Record<string, JsonValue>;
+};
+
+export type QoderAcpSessionLoadResult = {
+    events: QoderAcpSessionUpdate[];
+    socketPath: string;
+};
+
+export type QoderAcpSessionLoadOptions = {
+    cwd: string;
+    drainMs?: number;
+    requestLimit?: number;
+    sessionId: string;
+    socketPath?: string;
+    taskId?: string | null;
+    timeoutMs?: number;
+};
+
+export const resolveQoderAcpSocketPath = (): string => {
+    const configured = process.env.SPIRACHA_QODER_SOCKET_PATH?.trim() || process.env.SPIRACHA_QODER_SOCKET?.trim();
+    return configured ? configured : path.join(path.dirname(resolveQoderUserDir()), 'SharedClientCache', 'qoder.sock');
+};
+
+const encodeJsonRpcMessage = (message: JsonRpcMessage): string => {
+    const body = JSON.stringify(message);
+    return `Content-Length: ${Buffer.byteLength(body)}\r\n\r\n${body}`;
+};
+
+const appendSocketChunk = (
+    buffer: Buffer<ArrayBufferLike>,
+    chunk: Buffer<ArrayBufferLike> | string,
+): Buffer<ArrayBufferLike> => {
+    return Buffer.concat([buffer, typeof chunk === 'string' ? Buffer.from(chunk) : chunk]);
+};
+
+const parseJsonRpcMessages = (
+    buffer: Buffer<ArrayBufferLike>,
+): {
+    messages: JsonRpcMessage[];
+    rest: Buffer<ArrayBufferLike>;
+} => {
+    const messages: JsonRpcMessage[] = [];
+    let rest = buffer;
+
+    while (true) {
+        const headerEnd = rest.indexOf('\r\n\r\n');
+        if (headerEnd < 0) {
+            return { messages, rest };
+        }
+
+        const header = rest.subarray(0, headerEnd).toString('utf8');
+        const lengthMatch = /Content-Length:\s*(\d+)/iu.exec(header);
+        if (!lengthMatch) {
+            return { messages, rest: Buffer.alloc(0) };
+        }
+
+        const contentLength = Number(lengthMatch[1]);
+        const bodyStart = headerEnd + 4;
+        const bodyEnd = bodyStart + contentLength;
+        if (rest.length < bodyEnd) {
+            return { messages, rest };
+        }
+
+        try {
+            messages.push(JSON.parse(rest.subarray(bodyStart, bodyEnd).toString('utf8')) as JsonRpcMessage);
+        } catch {}
+
+        rest = rest.subarray(bodyEnd);
+    }
+};
+
+const getRequestId = (params: Record<string, JsonValue> | null): string | null => {
+    const meta = asObject(params?._meta ?? null);
+    return asString(meta?.['ai-coding/request-id'] ?? null);
+};
+
+const getSessionUpdate = (message: JsonRpcMessage): QoderAcpSessionUpdate | null => {
+    if (message.method !== 'session/update') {
+        return null;
+    }
+
+    const params = asObject(message.params ?? null);
+    const sessionId = asString(params?.sessionId ?? null);
+    const update = asObject(params?.update ?? null);
+    if (!sessionId || !update) {
+        return null;
+    }
+
+    return {
+        requestId: getRequestId(params),
+        sessionId,
+        update,
+    };
+};
+
+export const loadQoderAcpSession = async (
+    options: QoderAcpSessionLoadOptions,
+): Promise<QoderAcpSessionLoadResult | null> => {
+    const socketPath = options.socketPath ?? resolveQoderAcpSocketPath();
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const drainMs = options.drainMs ?? DEFAULT_DRAIN_MS;
+    const requestLimit = options.requestLimit ?? 50;
+
+    return await new Promise<QoderAcpSessionLoadResult | null>((resolve) => {
+        const socket = net.createConnection(socketPath);
+        const events: QoderAcpSessionUpdate[] = [];
+        let buffer: Buffer<ArrayBufferLike> = Buffer.alloc(0);
+        let resolved = false;
+        let loadCompleted = false;
+        let drainTimer: ReturnType<typeof setTimeout> | null = null;
+        let timeout: ReturnType<typeof setTimeout> | null = null;
+
+        const cleanup = () => {
+            if (drainTimer) {
+                clearTimeout(drainTimer);
+            }
+            if (timeout) {
+                clearTimeout(timeout);
+            }
+            socket.destroy();
+        };
+
+        const finish = (result: QoderAcpSessionLoadResult | null) => {
+            if (resolved) {
+                return;
+            }
+
+            resolved = true;
+            cleanup();
+            resolve(result);
+        };
+
+        timeout = setTimeout(() => {
+            finish(events.length > 0 ? { events, socketPath } : null);
+        }, timeoutMs);
+
+        const write = (message: JsonRpcMessage) => {
+            socket.write(encodeJsonRpcMessage(message));
+        };
+
+        const sendLoadRequest = () => {
+            write({
+                id: LOAD_REQUEST_ID,
+                jsonrpc: '2.0',
+                method: 'session/load',
+                params: {
+                    _meta: {
+                        'ai-coding/load-request-limit': requestLimit,
+                        ...(options.taskId ? { 'ai-coding/quest-task-id': options.taskId } : {}),
+                    },
+                    cwd: options.cwd,
+                    mcpServers: [],
+                    sessionId: options.sessionId,
+                    timestamp: Date.now(),
+                },
+            });
+        };
+
+        const scheduleDrain = () => {
+            if (drainTimer) {
+                clearTimeout(drainTimer);
+            }
+
+            drainTimer = setTimeout(() => {
+                finish(events.length > 0 ? { events, socketPath } : null);
+            }, drainMs);
+        };
+
+        const recordMatchingUpdate = (message: JsonRpcMessage) => {
+            const update = getSessionUpdate(message);
+            if (update?.sessionId !== options.sessionId) {
+                return false;
+            }
+
+            if (events.length < requestLimit) {
+                events.push(update);
+            }
+            if (loadCompleted && events.length >= requestLimit) {
+                finish({ events, socketPath });
+                return true;
+            }
+            if (loadCompleted) {
+                scheduleDrain();
+            }
+            return true;
+        };
+
+        const markLoadCompleted = (message: JsonRpcMessage) => {
+            if (message.id !== LOAD_REQUEST_ID || loadCompleted) {
+                return false;
+            }
+
+            loadCompleted = true;
+            if (events.length >= requestLimit) {
+                finish({ events, socketPath });
+                return true;
+            }
+            scheduleDrain();
+            return true;
+        };
+
+        const handleMessage = (message: JsonRpcMessage) => {
+            if (message.id === INITIALIZE_REQUEST_ID) {
+                sendLoadRequest();
+                return;
+            }
+
+            if (recordMatchingUpdate(message)) {
+                return;
+            }
+
+            markLoadCompleted(message);
+        };
+
+        socket.on('connect', () => {
+            write({
+                id: INITIALIZE_REQUEST_ID,
+                jsonrpc: '2.0',
+                method: 'initialize',
+                params: {
+                    clientCapabilities: {},
+                    ideWindowType: 'quest',
+                    protocolVersion: 1,
+                    timestamp: Date.now(),
+                },
+            });
+        });
+
+        socket.on('data', (chunk) => {
+            try {
+                const parsed = parseJsonRpcMessages(appendSocketChunk(buffer, chunk));
+                buffer = parsed.rest;
+                parsed.messages.forEach(handleMessage);
+            } catch {
+                finish(events.length > 0 ? { events, socketPath } : null);
+            }
+        });
+
+        socket.on('error', () => {
+            finish(null);
+        });
+
+        socket.on('close', () => {
+            finish(events.length > 0 ? { events, socketPath } : null);
+        });
+    });
+};