paseo-acp-agy 1.2.7 → 1.2.9

package/dist/native-sessions.d.ts

@@ -0,0 +1,4 @@
+import { SessionInfo } from "./protocol.js";
+export declare function getAgyAppDataDir(): string;
+export declare function loadNativeAntigravitySessions(cwd?: string): SessionInfo[];
+export declare function getNativeAntigravitySession(conversationId: string): SessionInfo | null;

package/dist/native-sessions.js

@@ -0,0 +1,176 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { createRequire } from "node:module";
+import { logger } from "./logger.js";
+const require = createRequire(import.meta.url);
+export function getAgyAppDataDir() {
+    if (process.env.AGY_APP_DATA_DIR) {
+        return process.env.AGY_APP_DATA_DIR;
+    }
+    if (process.env.AGY_BRAIN_DIR) {
+        return path.dirname(process.env.AGY_BRAIN_DIR);
+    }
+    return path.join(os.homedir(), ".gemini", "antigravity-cli");
+}
+export function loadNativeAntigravitySessions(cwd) {
+    const results = [];
+    const appDataDir = getAgyAppDataDir();
+    const dbPath = path.join(appDataDir, "conversation_summaries.db");
+    const normalizedTargetCwd = cwd ? path.resolve(cwd).toLowerCase() : undefined;
+    if (fs.existsSync(dbPath)) {
+        let DatabaseSync = null;
+        try {
+            DatabaseSync = require("node:sqlite")?.DatabaseSync;
+        }
+        catch { }
+        if (DatabaseSync) {
+            try {
+                const db = new DatabaseSync(dbPath, { readOnly: true });
+                const rows = db
+                    .prepare(`SELECT conversation_id, title, preview, last_modified_time, workspace_uris
+             FROM conversation_summaries
+             ORDER BY last_modified_time DESC
+             LIMIT 100`)
+                    .all();
+                for (const row of rows) {
+                    if (!row.conversation_id)
+                        continue;
+                    let primaryCwd = process.cwd();
+                    let matchesCwd = false;
+                    if (row.workspace_uris) {
+                        try {
+                            const uris = JSON.parse(row.workspace_uris);
+                            if (Array.isArray(uris) && uris.length > 0) {
+                                const filePaths = uris
+                                    .map((u) => u.replace(/^file:\/\//i, ""))
+                                    .filter(Boolean);
+                                if (filePaths.length > 0) {
+                                    primaryCwd = filePaths[0];
+                                }
+                                if (normalizedTargetCwd) {
+                                    matchesCwd = filePaths.some((p) => path.resolve(p).toLowerCase() === normalizedTargetCwd);
+                                }
+                            }
+                        }
+                        catch { }
+                    }
+                    if (normalizedTargetCwd && !matchesCwd) {
+                        continue;
+                    }
+                    const rawDate = row.last_modified_time;
+                    const dateIso = rawDate ? new Date(rawDate).toISOString() : undefined;
+                    results.push({
+                        sessionId: row.conversation_id,
+                        cwd: primaryCwd,
+                        title: (row.title && row.title.trim()) ||
+                            (row.preview && row.preview.trim()) ||
+                            "Antigravity Session",
+                        updatedAt: dateIso,
+                    });
+                }
+            }
+            catch (err) {
+                logger.debug("Failed to read native conversation summaries from sqlite", {
+                    error: err.message,
+                });
+            }
+        }
+    }
+    // Fallback: Only scan brainDir if no conversations were found in DB
+    if (results.length === 0) {
+        try {
+            const brainDir = path.join(appDataDir, "brain");
+            if (fs.existsSync(brainDir)) {
+                const entries = fs.readdirSync(brainDir, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (!entry.isDirectory())
+                        continue;
+                    const convId = entry.name;
+                    if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(convId)) {
+                        continue;
+                    }
+                    if (results.some((r) => r.sessionId === convId))
+                        continue;
+                    const transcriptPath = path.join(brainDir, convId, ".system_generated", "logs", "transcript.jsonl");
+                    if (fs.existsSync(transcriptPath)) {
+                        const stat = fs.statSync(transcriptPath);
+                        if (stat.size > 0) {
+                            results.push({
+                                sessionId: convId,
+                                cwd: process.cwd(),
+                                title: "Antigravity Session",
+                                updatedAt: stat.mtime.toISOString(),
+                            });
+                            if (results.length >= 50)
+                                break;
+                        }
+                    }
+                }
+            }
+        }
+        catch { }
+    }
+    return results;
+}
+export function getNativeAntigravitySession(conversationId) {
+    if (!conversationId)
+        return null;
+    const appDataDir = getAgyAppDataDir();
+    const dbPath = path.join(appDataDir, "conversation_summaries.db");
+    if (fs.existsSync(dbPath)) {
+        let DatabaseSync = null;
+        try {
+            DatabaseSync = require("node:sqlite")?.DatabaseSync;
+        }
+        catch { }
+        if (DatabaseSync) {
+            try {
+                const db = new DatabaseSync(dbPath, { readOnly: true });
+                const row = db
+                    .prepare(`SELECT conversation_id, title, preview, last_modified_time, workspace_uris
+             FROM conversation_summaries
+             WHERE conversation_id = ?`)
+                    .get(conversationId);
+                if (row) {
+                    let primaryCwd = process.cwd();
+                    if (row.workspace_uris) {
+                        try {
+                            const uris = JSON.parse(row.workspace_uris);
+                            if (Array.isArray(uris) && uris.length > 0) {
+                                const p = uris[0].replace(/^file:\/\//i, "");
+                                if (p)
+                                    primaryCwd = p;
+                            }
+                        }
+                        catch { }
+                    }
+                    return {
+                        sessionId: row.conversation_id,
+                        cwd: primaryCwd,
+                        title: (row.title && row.title.trim()) ||
+                            (row.preview && row.preview.trim()) ||
+                            "Antigravity Session",
+                        updatedAt: row.last_modified_time
+                            ? new Date(row.last_modified_time).toISOString()
+                            : undefined,
+                    };
+                }
+            }
+            catch { }
+        }
+    }
+    // Fallback check transcript file
+    const brainDir = path.join(appDataDir, "brain", conversationId);
+    const transcriptPath = path.join(brainDir, ".system_generated", "logs", "transcript.jsonl");
+    if (fs.existsSync(transcriptPath)) {
+        const stat = fs.statSync(transcriptPath);
+        return {
+            sessionId: conversationId,
+            cwd: process.cwd(),
+            title: "Antigravity Session",
+            updatedAt: stat.mtime.toISOString(),
+        };
+    }
+    return null;
+}

package/dist/session-store.js

@@ -116,6 +116,13 @@ export class SessionStore {
                     const parsed = JSON.parse(content);
                     if (!parsed.sessionId)
                         continue;
+                    // Skip untitled placeholder sessions that have neither conversationId nor any recorded usage
+                    const hasTitle = Boolean(parsed.title && parsed.title.trim());
+                    const hasConv = Boolean(parsed.conversationId);
+                    const hasUsage = Boolean(parsed.usage && (parsed.usage.totalTokens > 0 || parsed.usage.inputTokens > 0));
+                    if (!hasTitle && !hasConv && !hasUsage) {
+                        continue;
+                    }
                     if (normalizedTargetCwd && parsed.cwd) {
                         const sessionCwd = path.resolve(parsed.cwd).toLowerCase();
                         if (sessionCwd !== normalizedTargetCwd)

package/dist/session.d.ts

@@ -11,6 +11,7 @@ export interface SessionOptions {
     permission?: string;
     conversationId?: string;
     usage?: SessionUsageState;
+    updatedAt?: string;
     sandbox?: boolean;
     dangerouslySkipPermissions?: boolean;
     env?: Record<string, string>;
@@ -27,6 +28,7 @@ export declare class Session {
     permission: string;
     readonly createdAt: Date;
     lastActivity: Date;
+    updatedAt: string;
     isCancelled: boolean;
     process: AntigravityProcess;
     usage: SessionUsageState;

package/dist/session.js

@@ -1,10 +1,13 @@
 import crypto from "node:crypto";
+import fs from "node:fs";
 import path from "node:path";
 import { AntigravityProcess } from "./antigravity-process.js";
 import { logger } from "./logger.js";
 import { resolvePermissionSettings } from "./permissions.js";
 import { calculateUsageCostUsd, getModelContextWindow } from "./protocol.js";
 import { sessionStore, } from "./session-store.js";
+import { resolveConversationBrainDir } from "./transcript.js";
+import { loadNativeAntigravitySessions, getNativeAntigravitySession, } from "./native-sessions.js";
 export class Session {
     id;
     cwd;
@@ -15,6 +18,7 @@ export class Session {
     permission;
     createdAt;
     lastActivity;
+    updatedAt;
     isCancelled = false;
     process;
     usage;
@@ -32,6 +36,7 @@ export class Session {
                 (options.sandbox ? "sandbox" : options.dangerouslySkipPermissions ? "bypass" : "default");
         this.createdAt = new Date();
         this.lastActivity = new Date();
+        this.updatedAt = options.updatedAt || new Date().toISOString();
         this.store = options.store || sessionStore;
         const maxTokens = getModelContextWindow(this.model);
         this.usage = options.usage
@@ -82,7 +87,7 @@ export class Session {
             mode: this.mode,
             permission: this.permission,
             usage: this.usage,
-            updatedAt: new Date().toISOString(),
+            updatedAt: this.updatedAt,
         };
     }
     setTitle(title) {
@@ -199,10 +204,13 @@ export class Session {
             }
         }
         this.usage.contextWindowUsedTokens = Math.min(activeContextTokens, executingMaxTokens);
+        this.lastActivity = new Date();
+        this.updatedAt = this.lastActivity.toISOString();
         this.persist();
     }
     touch() {
         this.lastActivity = new Date();
+        this.updatedAt = this.lastActivity.toISOString();
     }
     cancelTurn() {
         const processCancelled = this.process.cancelCurrentTurn();
@@ -228,20 +236,26 @@ export class SessionManager {
     }
     createSession(options = {}) {
         const persisted = options.id ? this.store.load(options.id) : null;
-        if (options.id && !persisted) {
+        const native = options.id ? getNativeAntigravitySession(options.id) : null;
+        const brainDir = options.id ? resolveConversationBrainDir(options.id) : null;
+        const hasBrainDir = Boolean(brainDir && fs.existsSync(brainDir));
+        if (options.id && !persisted && !native && !hasBrainDir) {
             throw new Error(`Cannot restore unknown ACP session: ${options.id}`);
         }
         const session = new Session({
             id: options.id,
             binaryPath: options.binaryPath || this.defaultBinaryPath,
-            cwd: options.cwd || persisted?.cwd,
-            title: options.title || persisted?.title,
+            cwd: options.cwd || persisted?.cwd || (native?.cwd ?? undefined),
+            title: options.title || persisted?.title || (native?.title ?? undefined),
             model: options.model || persisted?.model,
             effort: options.effort || persisted?.effort,
             mode: options.mode || persisted?.mode,
             permission: options.permission || persisted?.permission,
-            conversationId: options.conversationId || persisted?.conversationId,
+            conversationId: options.conversationId ||
+                persisted?.conversationId ||
+                (options.id && (hasBrainDir || native) ? options.id : undefined),
             usage: options.usage || persisted?.usage,
+            updatedAt: options.updatedAt || persisted?.updatedAt || (native?.updatedAt ?? undefined),
             sandbox: options.sandbox,
             dangerouslySkipPermissions: options.dangerouslySkipPermissions,
             env: options.env,
@@ -280,16 +294,32 @@ export class SessionManager {
         return Array.from(this.sessions.values());
     }
     listSessions(cwd) {
-        const persisted = this.store.list(cwd);
         const sessionMap = new Map();
+        // 1. Add native Antigravity conversations
+        const nativeSessions = loadNativeAntigravitySessions(cwd);
+        const nativeByConvId = new Map();
+        for (const n of nativeSessions) {
+            nativeByConvId.set(n.sessionId, n);
+            sessionMap.set(n.sessionId, n);
+        }
+        // 2. Add persisted ACP sessions
+        const persisted = this.store.list(cwd);
         for (const p of persisted) {
+            const nativeMatch = p.conversationId ? nativeByConvId.get(p.conversationId) : undefined;
+            const realTitle = p.title || nativeMatch?.title || (p.cwd ? path.basename(p.cwd) : "Antigravity Session");
+            const realUpdatedAt = nativeMatch?.updatedAt || p.updatedAt;
+            // If an ACP session wraps a native conversation, remove the raw native entry to prevent duplicates
+            if (p.conversationId && sessionMap.has(p.conversationId)) {
+                sessionMap.delete(p.conversationId);
+            }
             sessionMap.set(p.sessionId, {
                 sessionId: p.sessionId,
                 cwd: p.cwd,
-                title: p.title || (p.cwd ? path.basename(p.cwd) : "Antigravity Session"),
-                updatedAt: p.updatedAt,
+                title: realTitle,
+                updatedAt: realUpdatedAt,
             });
         }
+        // 3. Active in-memory sessions
         for (const active of this.sessions.values()) {
             if (cwd) {
                 const targetCwd = path.resolve(cwd).toLowerCase();
@@ -297,10 +327,16 @@ export class SessionManager {
                 if (targetCwd !== activeCwd)
                     continue;
             }
+            const hasTitle = Boolean(active.title && active.title.trim());
+            const hasConv = Boolean(active.process.currentConversationId);
+            const hasUsage = Boolean(active.usage && active.usage.totalTokens > 0);
+            if (!hasTitle && !hasConv && !hasUsage)
+                continue;
+            const existing = sessionMap.get(active.id);
             sessionMap.set(active.id, {
                 sessionId: active.id,
                 cwd: active.cwd,
-                title: active.title || (active.cwd ? path.basename(active.cwd) : "Antigravity Session"),
+                title: active.title || existing?.title || (active.cwd ? path.basename(active.cwd) : "Antigravity Session"),
                 updatedAt: active.lastActivity.toISOString(),
             });
         }
@@ -310,6 +346,6 @@ export class SessionManager {
             const timeB = b.updatedAt ? new Date(b.updatedAt).getTime() : 0;
             return timeB - timeA;
         });
-        return list;
+        return list.slice(0, 100);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "paseo-acp-agy",
-  "version": "1.2.7",
+  "version": "1.2.9",
   "description": "ACP (Agent Client Protocol) provider for Google Antigravity in Paseo and Zed",
   "type": "module",
   "main": "dist/index.js",