linkshell-cli 0.10.32 → 0.10.34

package/dist/host/src/drivers/acp/antigravity.js

@@ -1,7 +1,13 @@
-import { accessSync, constants, existsSync, mkdirSync, readdirSync } from "node:fs";
+import { execFile } from "node:child_process";
+import { accessSync, constants, existsSync, mkdirSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
 import { basename, delimiter, dirname, isAbsolute, join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { promisify } from "node:util";
+import { RpcError, } from "@linkshell/wire";
 import { AcpDriver } from "./driver.js";
+const execFileAsync = promisify(execFile);
 /**
  * Official Google Antigravity ACP distribution metadata (from the ACP Registry:
  * `antigravity-acp/agent.json`).
@@ -74,7 +80,6 @@ function findInManagedToolRoots(roots, binaryName) {
     for (const root of roots) {
         if (!existsSync(root))
             continue;
-        // Check `<root>/<version>/<platform>-<arch>/<binaryName>` and `<root>/<binaryName>`
         const direct = join(root, binaryName);
         if (isExecutable(direct))
             return { path: direct, version: ANTIGRAVITY_ACP_VERSION };
@@ -162,6 +167,63 @@ export function resolveAntigravityLaunch(env = process.env) {
         version,
     };
 }
+/**
+ * Resolves an installed Antigravity Desktop app (`/Applications/Antigravity.app`)
+ * and its conversation store (`~/.gemini/antigravity`).
+ */
+export function resolveAntigravityDesktop(env = process.env) {
+    if (env.PATH === "" && !env.ANTIGRAVITY_APP_DATA_DIR)
+        return undefined;
+    const home = env.HOME || homedir();
+    const dataCandidates = [
+        env.ANTIGRAVITY_APP_DATA_DIR?.trim(),
+        join(home, ".gemini", "antigravity"),
+        join(home, ".gemini", "antigravity-ide"),
+    ].filter((entry) => Boolean(entry));
+    const dataDir = dataCandidates.find((dir) => existsSync(join(dir, "conversation_summaries.db")) || existsSync(join(dir, "brain")));
+    const lsCandidates = process.platform === "darwin"
+        ? [
+            "/Applications/Antigravity.app/Contents/Resources/bin/language_server",
+            join(home, "Applications", "Antigravity.app", "Contents", "Resources", "bin", "language_server"),
+        ]
+        : [];
+    const languageServerPath = lsCandidates.find((candidate) => isExecutable(candidate));
+    if (!dataDir && !languageServerPath)
+        return undefined;
+    const logCandidates = process.platform === "darwin"
+        ? [join(home, "Library", "Logs", "Antigravity", "language_server.log")]
+        : [join(home, ".config", "Antigravity", "logs", "language_server.log")];
+    const logPath = logCandidates.find((candidate) => existsSync(candidate));
+    let version = "desktop";
+    if (logPath) {
+        try {
+            const head = readFileSync(logPath, "utf8").slice(0, 2048);
+            const match = /Language server version:\s*([^\s\r\n]+)/i.exec(head);
+            if (match?.[1])
+                version = match[1];
+        }
+        catch {
+            // ignore unreadable log
+        }
+    }
+    if (version === "desktop" && process.platform === "darwin") {
+        try {
+            const plist = readFileSync("/Applications/Antigravity.app/Contents/Info.plist", "utf8");
+            const match = /<key>CFBundleShortVersionString<\/key>\s*<string>([^<]+)<\/string>/.exec(plist);
+            if (match?.[1])
+                version = match[1].trim();
+        }
+        catch {
+            // ignore unreadable plist
+        }
+    }
+    return {
+        dataDir: dataDir ?? join(home, ".gemini", "antigravity"),
+        languageServerPath,
+        logPath,
+        version,
+    };
+}
 const AUTH_URL_PATTERN = /Open the following link to authenticate the ACP server:\s*(https?:\/\/\S+)/i;
 export function extractAntigravityAuthUrl(line) {
     const match = AUTH_URL_PATTERN.exec(line.trim());
@@ -187,12 +249,271 @@ export function antigravitySpec() {
         authStatus: antigravityAuthStatus,
     };
 }
+function unquoteArg(value) {
+    if (typeof value !== "string")
+        return value;
+    const trimmed = value.trim();
+    if ((trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+        (trimmed.startsWith("{") && trimmed.endsWith("}")) ||
+        (trimmed.startsWith("[") && trimmed.endsWith("]")) ||
+        trimmed === "true" ||
+        trimmed === "false" ||
+        /^-?\d+(?:\.\d+)?$/.test(trimmed)) {
+        try {
+            return JSON.parse(trimmed);
+        }
+        catch {
+            return value;
+        }
+    }
+    return value;
+}
+function parseToolArgs(raw) {
+    if (!raw || typeof raw !== "object")
+        return {};
+    const result = {};
+    for (const [k, v] of Object.entries(raw)) {
+        result[k] = unquoteArg(v);
+    }
+    return result;
+}
+export function cleanAntigravityUserInput(content) {
+    const requestMatch = /<USER_REQUEST>\s*([\s\S]*?)\s*<\/USER_REQUEST>/i.exec(content);
+    if (requestMatch)
+        return requestMatch[1].trim();
+    return content
+        .replace(/<(?:ADDITIONAL_METADATA|USER_SETTINGS_CHANGE|SYSTEM_MESSAGE|CONTEXT_SUMMARY)>[\s\S]*?<\/(?:ADDITIONAL_METADATA|USER_SETTINGS_CHANGE|SYSTEM_MESSAGE|CONTEXT_SUMMARY)>/gi, "")
+        .trim();
+}
+function mapAntigravityToolCall(stepIndex, callIndex, call, outputText) {
+    const name = call.name ?? "tool";
+    const args = parseToolArgs(call.args);
+    const summary = (typeof args.toolSummary === "string" && args.toolSummary.trim()) ||
+        (typeof args.toolAction === "string" && args.toolAction.trim()) ||
+        name;
+    const toolCallId = call.id || `agy:tc:${stepIndex}:${callIndex}`;
+    let kind = "other";
+    let rawInput = args;
+    let locations;
+    if (name === "run_command") {
+        kind = "execute";
+        rawInput = {
+            command: typeof args.CommandLine === "string" ? args.CommandLine : summary,
+            cwd: typeof args.Cwd === "string" ? args.Cwd : undefined,
+        };
+    }
+    else if (name === "view_file") {
+        kind = "read";
+        const path = typeof args.AbsolutePath === "string" ? args.AbsolutePath : undefined;
+        const line = typeof args.StartLine === "number" ? args.StartLine : undefined;
+        if (path) {
+            rawInput = { file_path: path };
+            locations = [{ path, ...(line ? { line } : {}) }];
+        }
+    }
+    else if (name === "replace_file_content" || name === "multi_replace_file_content" || name === "write_to_file") {
+        kind = "edit";
+        const path = typeof args.TargetFile === "string" ? args.TargetFile : undefined;
+        const line = typeof args.StartLine === "number" ? args.StartLine : undefined;
+        if (path) {
+            rawInput = { file_path: path };
+            locations = [{ path, ...(line ? { line } : {}) }];
+        }
+    }
+    else if (name === "search_web") {
+        kind = "search";
+        rawInput = { query: typeof args.query === "string" ? args.query : summary };
+    }
+    else if (name === "read_url_content") {
+        kind = "fetch";
+        rawInput = { url: typeof args.Url === "string" ? args.Url : summary };
+    }
+    return {
+        sessionUpdate: "tool_call",
+        toolCallId,
+        title: summary,
+        name,
+        kind,
+        status: "completed",
+        rawInput,
+        ...(outputText ? { rawOutput: { output: outputText } } : {}),
+        ...(locations ? { locations } : {}),
+    };
+}
+/**
+ * Converts an Antigravity Desktop `transcript.jsonl` file into LinkShell's
+ * `HistoryItem[]` list.
+ */
+export function parseAntigravityTranscript(transcriptPath, fromLine = 0) {
+    if (!existsSync(transcriptPath))
+        return { items: [], nextLine: fromLine };
+    let lines;
+    try {
+        lines = readFileSync(transcriptPath, "utf8").split("\n").filter((line) => line.trim().length > 0);
+    }
+    catch {
+        return { items: [], nextLine: fromLine };
+    }
+    if (fromLine >= lines.length)
+        return { items: [], nextLine: lines.length };
+    const parsed = [];
+    for (let i = fromLine; i < lines.length; i++) {
+        try {
+            const step = JSON.parse(lines[i]);
+            parsed.push({ index: step.step_index ?? i, step });
+        }
+        catch {
+            // skip partial trailing JSON line
+            return { items: [], nextLine: i };
+        }
+    }
+    const items = [];
+    for (let i = 0; i < parsed.length; i++) {
+        const { index: stepIndex, step } = parsed[i];
+        if (step.type === "USER_INPUT") {
+            const text = typeof step.content === "string" ? cleanAntigravityUserInput(step.content) : "";
+            if (!text)
+                continue;
+            const messageId = `agy:user:${stepIndex}`;
+            items.push({
+                itemId: messageId,
+                updates: [
+                    {
+                        sessionUpdate: "user_message_chunk",
+                        messageId,
+                        content: { type: "text", text },
+                    },
+                ],
+            });
+        }
+        else if (step.type === "PLANNER_RESPONSE") {
+            const updates = [];
+            if (typeof step.thinking === "string" && step.thinking.trim()) {
+                const thoughtId = `agy:thought:${stepIndex}`;
+                updates.push({
+                    sessionUpdate: "agent_thought_chunk",
+                    messageId: thoughtId,
+                    content: { type: "text", text: step.thinking.trim() },
+                }, {
+                    sessionUpdate: "ls_message_done",
+                    messageId: thoughtId,
+                    role: "thought",
+                });
+            }
+            const calls = Array.isArray(step.tool_calls) ? step.tool_calls : [];
+            if (calls.length > 0) {
+                // Subsequent GENERIC steps hold the outputs of these tool calls in order.
+                const outputs = [];
+                let lookahead = i + 1;
+                while (lookahead < parsed.length && parsed[lookahead].step.type === "GENERIC" && outputs.length < calls.length) {
+                    outputs.push(typeof parsed[lookahead].step.content === "string" ? parsed[lookahead].step.content : "");
+                    lookahead++;
+                }
+                calls.forEach((call, callIdx) => {
+                    updates.push(mapAntigravityToolCall(stepIndex, callIdx, call, outputs[callIdx]));
+                });
+            }
+            if (typeof step.content === "string" && step.content.trim()) {
+                const messageId = `agy:msg:${stepIndex}`;
+                updates.push({
+                    sessionUpdate: "agent_message_chunk",
+                    messageId,
+                    content: { type: "text", text: step.content.trim() },
+                }, {
+                    sessionUpdate: "ls_message_done",
+                    messageId,
+                    role: "agent",
+                });
+            }
+            if (updates.length > 0) {
+                items.push({
+                    itemId: `agy:step:${stepIndex}`,
+                    updates,
+                });
+            }
+        }
+    }
+    return { items, nextLine: lines.length };
+}
+async function findRunningLanguageServer(desktop) {
+    if (!desktop?.logPath || !existsSync(desktop.logPath))
+        return undefined;
+    let httpPort;
+    try {
+        const head = readFileSync(desktop.logPath, "utf8").slice(0, 4096);
+        const match = /listening on \w+ port at (\d+) for HTTP\b/i.exec(head);
+        if (match?.[1])
+            httpPort = Number(match[1]);
+    }
+    catch {
+        return undefined;
+    }
+    if (!httpPort)
+        return undefined;
+    try {
+        const { stdout } = await execFileAsync("ps", ["-ax", "-o", "args="], { timeout: 3000 });
+        for (const line of stdout.split("\n")) {
+            if (!line.includes("language_server") || !line.includes("--csrf_token"))
+                continue;
+            const tokenMatch = /--csrf_token[=\s]+([^\s]+)/.exec(line);
+            if (tokenMatch?.[1]) {
+                return { httpPort, csrfToken: tokenMatch[1] };
+            }
+        }
+    }
+    catch {
+        // ignore ps errors
+    }
+    return undefined;
+}
+async function callLanguageServer(conn, method, body) {
+    const response = await fetch(`http://127.0.0.1:${conn.httpPort}/exa.language_server_pb.LanguageServerService/${method}`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "x-codeium-csrf-token": conn.csrfToken,
+        },
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(10_000),
+    });
+    if (!response.ok) {
+        const text = await response.text().catch(() => "");
+        throw new Error(`Antigravity Desktop RPC ${method} failed (${response.status}): ${text.slice(0, 200)}`);
+    }
+    return (await response.json());
+}
+function parseWorkspaceCwd(workspaceUrisJson, fallbackCwd) {
+    if (!workspaceUrisJson)
+        return fallbackCwd;
+    try {
+        const uris = JSON.parse(workspaceUrisJson);
+        if (Array.isArray(uris) && typeof uris[0] === "string") {
+            const first = uris[0];
+            if (first.startsWith("file://"))
+                return fileURLToPath(first);
+            if (isAbsolute(first))
+                return first;
+        }
+    }
+    catch {
+        // ignore invalid JSON
+    }
+    return fallbackCwd;
+}
 /**
- * Specialized ACP driver for Google Antigravity (`agy_acp_server.par` / `agy-acp`).
- * Dynamically resolves the binary + `localharness_external`, sets up `.par` file-storage
- * environment variables, and surfaces stdout Google OAuth links as session/driver notices.
+ * Specialized driver for Google Antigravity:
+ * - Drives `agy_acp_server.par` / `agy-acp` over ACP when installed.
+ * - Also discovers and interacts with Antigravity Desktop (`/Applications/Antigravity.app`,
+ *   `~/.gemini/antigravity/conversation_summaries.db`, `brain/<id>/.system_generated/logs/transcript.jsonl`,
+ *   and its local `language_server` Connect-RPC service) so users with only the Desktop app
+ *   get full session visibility, history, model selection, and messaging.
  */
 export class AntigravityDriver extends AcpDriver {
+    desktopMode = false;
+    desktopSummaryTimer;
+    desktopSessionStates = new Map();
+    desktopWatchers = new Map();
+    desktopModelsCache;
     constructor(options) {
         super(antigravitySpec(), options);
     }
@@ -204,21 +525,441 @@ export class AntigravityDriver extends AcpDriver {
             ...resolved?.env,
         };
     }
+    async authStatus() {
+        const base = await super.authStatus();
+        if (base.state !== "unknown")
+            return base;
+        const desktop = resolveAntigravityDesktop(this.options.env ?? process.env);
+        if (desktop && (existsSync(join(desktop.dataDir, "antigravity_state.pbtxt")) || existsSync(join(desktop.dataDir, "conversation_summaries.db")))) {
+            return { state: "ok", method: "antigravity-desktop" };
+        }
+        return base;
+    }
     async detectVersion() {
-        const resolved = resolveAntigravityLaunch(this.options.env ?? process.env);
-        if (!resolved)
-            return undefined;
-        this.spec.command = resolved.command;
-        this.spec.args = resolved.args;
-        return resolved.version;
+        const env = this.options.env ?? process.env;
+        const resolved = resolveAntigravityLaunch(env);
+        if (resolved) {
+            this.desktopMode = false;
+            this.spec.command = resolved.command;
+            this.spec.args = resolved.args;
+            return resolved.version;
+        }
+        const desktop = resolveAntigravityDesktop(env);
+        if (desktop) {
+            this.desktopMode = true;
+            return desktop.version;
+        }
+        return undefined;
     }
     async boot() {
-        const resolved = resolveAntigravityLaunch(this.options.env ?? process.env);
+        const env = this.options.env ?? process.env;
+        const resolved = resolveAntigravityLaunch(env);
         if (resolved) {
+            this.desktopMode = false;
             this.spec.command = resolved.command;
             this.spec.args = resolved.args;
+            await super.boot();
+            return;
+        }
+        const desktop = resolveAntigravityDesktop(env);
+        if (desktop) {
+            this.desktopMode = true;
+            this.capabilityState = {
+                ...this.capabilityState,
+                images: true,
+                models: true,
+            };
+            this.current = { installed: true, version: desktop.version };
+            if (!this.desktopSummaryTimer) {
+                this.desktopSummaryTimer = setInterval(() => {
+                    for (const s of this.listDesktopSessions(30)) {
+                        const nextState = s.state === "running" ? "running" : "idle";
+                        const prev = this.desktopSessionStates.get(s.nativeId);
+                        this.desktopSessionStates.set(s.nativeId, nextState);
+                        if (prev !== undefined && prev !== nextState) {
+                            this.host?.update(this.id, s.nativeId, {
+                                sessionUpdate: "ls_status",
+                                state: nextState,
+                                turnActive: nextState === "running",
+                            });
+                        }
+                    }
+                }, 3000);
+                this.desktopSummaryTimer.unref?.();
+            }
+            return;
         }
         await super.boot();
     }
+    async stop() {
+        if (this.desktopSummaryTimer) {
+            clearInterval(this.desktopSummaryTimer);
+            this.desktopSummaryTimer = undefined;
+        }
+        for (const watcher of this.desktopWatchers.values())
+            clearInterval(watcher.timer);
+        this.desktopWatchers.clear();
+        await super.stop();
+    }
+    transcriptPathFor(nativeId) {
+        const desktop = resolveAntigravityDesktop(this.options.env ?? process.env);
+        if (!desktop)
+            return undefined;
+        return join(desktop.dataDir, "brain", nativeId, ".system_generated", "logs", "transcript.jsonl");
+    }
+    isConversationRunningInDesktop(nativeId, statusCol) {
+        const desktop = resolveAntigravityDesktop(this.options.env ?? process.env);
+        if (!desktop)
+            return false;
+        const lockPath = join(desktop.dataDir, "presence", `${nativeId}.lock`);
+        if (!existsSync(lockPath))
+            return false;
+        let status = statusCol;
+        if (status === undefined) {
+            const dbPath = join(desktop.dataDir, "conversation_summaries.db");
+            if (existsSync(dbPath)) {
+                let db;
+                try {
+                    db = new DatabaseSync(dbPath, { readOnly: true });
+                    const row = db
+                        .prepare("SELECT status FROM conversation_summaries WHERE conversation_id = ?")
+                        .get(nativeId);
+                    status = row?.status;
+                }
+                catch {
+                    // ignore
+                }
+                finally {
+                    try {
+                        db?.close();
+                    }
+                    catch {
+                        // ignore
+                    }
+                }
+            }
+        }
+        return status === "CASCADE_RUN_STATUS_RUNNING";
+    }
+    listDesktopSessions(limit) {
+        const desktop = resolveAntigravityDesktop(this.options.env ?? process.env);
+        if (!desktop)
+            return [];
+        const dbPath = join(desktop.dataDir, "conversation_summaries.db");
+        const home = (this.options.env ?? process.env).HOME || homedir();
+        const results = [];
+        if (existsSync(dbPath)) {
+            let db;
+            try {
+                db = new DatabaseSync(dbPath, { readOnly: true });
+                const rows = db
+                    .prepare(`SELECT conversation_id, title, last_modified_time, workspace_uris, status, parent_conversation_id, killed
+             FROM conversation_summaries
+             WHERE (parent_conversation_id = '' OR parent_conversation_id IS NULL) AND killed = 0
+             ORDER BY last_modified_time DESC
+             LIMIT ?`)
+                    .all(limit);
+                for (const row of rows) {
+                    if (!row.conversation_id)
+                        continue;
+                    const cwd = parseWorkspaceCwd(row.workspace_uris, home);
+                    const updatedAt = Date.parse(row.last_modified_time) || Date.now();
+                    let title = row.title?.trim() || undefined;
+                    if (!title) {
+                        const transcriptPath = join(desktop.dataDir, "brain", row.conversation_id, ".system_generated", "logs", "transcript.jsonl");
+                        const { items } = parseAntigravityTranscript(transcriptPath, 0);
+                        const firstUser = items.find((entry) => entry.updates.some((u) => u.sessionUpdate === "user_message_chunk"));
+                        const chunk = firstUser?.updates.find((u) => u.sessionUpdate === "user_message_chunk");
+                        if (chunk?.sessionUpdate === "user_message_chunk" && chunk.content.type === "text") {
+                            title = chunk.content.text.split("\n")[0]?.slice(0, 100).trim() || undefined;
+                        }
+                    }
+                    const running = this.isConversationRunningInDesktop(row.conversation_id, row.status);
+                    const state = running ? "running" : "idle";
+                    if (!this.desktopSessionStates.has(row.conversation_id)) {
+                        this.desktopSessionStates.set(row.conversation_id, state);
+                    }
+                    results.push({
+                        nativeId: row.conversation_id,
+                        cwd,
+                        title,
+                        createdAt: updatedAt,
+                        updatedAt,
+                        state,
+                    });
+                }
+            }
+            catch {
+                // fallback to brain directory scan below if sqlite table is locked or unreadable
+            }
+            finally {
+                try {
+                    db?.close();
+                }
+                catch {
+                    // ignore close errors
+                }
+            }
+        }
+        if (results.length === 0 && existsSync(join(desktop.dataDir, "brain"))) {
+            try {
+                const dirs = readdirSync(join(desktop.dataDir, "brain"));
+                for (const id of dirs) {
+                    const transcriptPath = join(desktop.dataDir, "brain", id, ".system_generated", "logs", "transcript.jsonl");
+                    if (!existsSync(transcriptPath))
+                        continue;
+                    const stat = statSync(transcriptPath);
+                    const { items } = parseAntigravityTranscript(transcriptPath, 0);
+                    const firstUser = items.find((entry) => entry.updates.some((u) => u.sessionUpdate === "user_message_chunk"));
+                    const chunk = firstUser?.updates.find((u) => u.sessionUpdate === "user_message_chunk");
+                    const title = chunk?.sessionUpdate === "user_message_chunk" && chunk.content.type === "text"
+                        ? chunk.content.text.split("\n")[0]?.slice(0, 100).trim()
+                        : undefined;
+                    results.push({
+                        nativeId: id,
+                        cwd: home,
+                        title,
+                        createdAt: stat.mtimeMs,
+                        updatedAt: stat.mtimeMs,
+                        state: "idle",
+                    });
+                    if (results.length >= limit)
+                        break;
+                }
+            }
+            catch {
+                // ignore unreadable brain dir
+            }
+        }
+        return results;
+    }
+    async listSessions(limit) {
+        const acpSessions = !this.desktopMode && this.connection?.alive ? await super.listSessions(limit).catch(() => []) : [];
+        const desktopSessions = this.listDesktopSessions(limit);
+        const merged = new Map();
+        for (const session of [...acpSessions, ...desktopSessions]) {
+            if (!merged.has(session.nativeId))
+                merged.set(session.nativeId, session);
+        }
+        return [...merged.values()].sort((a, b) => b.updatedAt - a.updatedAt).slice(0, limit);
+    }
+    async loadDesktopModels() {
+        if (this.desktopModelsCache?.length)
+            return this.desktopModelsCache;
+        const desktop = resolveAntigravityDesktop(this.options.env ?? process.env);
+        const conn = await findRunningLanguageServer(desktop);
+        if (!conn)
+            return [];
+        try {
+            const data = await callLanguageServer(conn, "GetCascadeModelConfigData", {});
+            const models = (data.clientModelConfigs ?? [])
+                .map((entry) => {
+                const value = entry.modelOrAlias?.model ?? entry.modelOrAlias?.alias;
+                const name = entry.label?.trim();
+                if (!value || !name)
+                    return undefined;
+                return {
+                    value,
+                    name,
+                    ...(entry.tagTitle ? { description: entry.tagTitle } : {}),
+                };
+            })
+                .filter((entry) => Boolean(entry));
+            if (models.length > 0)
+                this.desktopModelsCache = models;
+            return models;
+        }
+        catch {
+            return [];
+        }
+    }
+    async emitDesktopConfig(nativeId, selectedModel) {
+        const models = await this.loadDesktopModels();
+        if (models.length === 0)
+            return;
+        let defaultModel = selectedModel;
+        if (!defaultModel) {
+            const desktop = resolveAntigravityDesktop(this.options.env ?? process.env);
+            if (desktop && existsSync(join(desktop.dataDir, "antigravity_state.pbtxt"))) {
+                try {
+                    const stateText = readFileSync(join(desktop.dataDir, "antigravity_state.pbtxt"), "utf8");
+                    const match = /last_selected_agent_model:\s*(\S+)/.exec(stateText);
+                    if (match?.[1] && models.some((m) => m.value === match[1]))
+                        defaultModel = match[1];
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
+        const current = defaultModel && models.some((m) => m.value === defaultModel) ? defaultModel : models[0].value;
+        const options = [
+            {
+                id: "model",
+                name: "Model",
+                category: "model",
+                current,
+                values: models,
+            },
+        ];
+        this.host?.update(this.id, nativeId, { sessionUpdate: "ls_config", options });
+    }
+    startWatchingDesktopTranscript(nativeId, transcriptPath, initialLine) {
+        const existing = this.desktopWatchers.get(nativeId);
+        if (existing)
+            clearInterval(existing.timer);
+        const lastSize = existsSync(transcriptPath) ? statSync(transcriptPath).size : 0;
+        const watcher = {
+            nextLine: initialLine,
+            lastSize,
+            running: this.isConversationRunningInDesktop(nativeId),
+            selectedModel: existing?.selectedModel,
+            timer: setInterval(() => {
+                if (existsSync(transcriptPath)) {
+                    try {
+                        const stat = statSync(transcriptPath);
+                        if (stat.size > watcher.lastSize) {
+                            watcher.lastSize = stat.size;
+                            const { items, nextLine } = parseAntigravityTranscript(transcriptPath, watcher.nextLine);
+                            watcher.nextLine = nextLine;
+                            for (const item of items) {
+                                item.updates.forEach((update, idx) => {
+                                    this.host?.update(this.id, nativeId, update, idx === item.updates.length - 1 ? item.itemId : undefined);
+                                });
+                            }
+                        }
+                    }
+                    catch {
+                        // ignore stat/read errors
+                    }
+                }
+                const nowRunning = this.isConversationRunningInDesktop(nativeId);
+                if (nowRunning !== watcher.running) {
+                    watcher.running = nowRunning;
+                    if (nowRunning) {
+                        this.host?.update(this.id, nativeId, { sessionUpdate: "ls_turn", state: "started" });
+                        this.host?.update(this.id, nativeId, { sessionUpdate: "ls_status", state: "running", turnActive: true });
+                    }
+                    else {
+                        this.host?.update(this.id, nativeId, { sessionUpdate: "ls_turn", state: "ended", stopReason: "end_turn" });
+                        this.host?.update(this.id, nativeId, { sessionUpdate: "ls_status", state: "idle", turnActive: false });
+                    }
+                }
+            }, 1500),
+        };
+        watcher.timer.unref?.();
+        this.desktopWatchers.set(nativeId, watcher);
+    }
+    async attach(nativeId, context) {
+        const transcriptPath = this.transcriptPathFor(nativeId);
+        if (this.desktopMode || (transcriptPath && existsSync(transcriptPath))) {
+            await this.ensureStarted();
+            const { items, nextLine } = transcriptPath ? parseAntigravityTranscript(transcriptPath, 0) : { items: [], nextLine: 0 };
+            if (transcriptPath) {
+                this.startWatchingDesktopTranscript(nativeId, transcriptPath, nextLine);
+            }
+            const running = this.isConversationRunningInDesktop(nativeId);
+            this.host?.update(this.id, nativeId, { sessionUpdate: "ls_status", state: running ? "running" : "idle", turnActive: running });
+            void this.emitDesktopConfig(nativeId, this.desktopWatchers.get(nativeId)?.selectedModel);
+            return items;
+        }
+        return super.attach(nativeId, context);
+    }
+    async detach(nativeId) {
+        const watcher = this.desktopWatchers.get(nativeId);
+        if (watcher) {
+            clearInterval(watcher.timer);
+            this.desktopWatchers.delete(nativeId);
+        }
+        await super.detach(nativeId);
+    }
+    async createSession(options) {
+        if (!this.desktopMode)
+            return super.createSession(options);
+        await this.ensureStarted();
+        const desktop = resolveAntigravityDesktop(this.options.env ?? process.env);
+        const conn = await findRunningLanguageServer(desktop);
+        if (!conn) {
+            throw RpcError.app("agent_unavailable", "请先在电脑上打开 Antigravity 桌面端应用");
+        }
+        const response = await callLanguageServer(conn, "StartCascade", {
+            workspaceUris: [pathToFileURL(options.cwd).href],
+            overrideWorkspaceUris: true,
+            ...(options.model ? { requestedModel: options.model } : {}),
+        });
+        const nativeId = response.cascadeId;
+        if (!nativeId)
+            throw RpcError.app("agent_unavailable", "Antigravity 未返回新会话 ID");
+        const transcriptPath = this.transcriptPathFor(nativeId);
+        if (transcriptPath)
+            this.startWatchingDesktopTranscript(nativeId, transcriptPath, 0);
+        if (options.model) {
+            const watcher = this.desktopWatchers.get(nativeId);
+            if (watcher)
+                watcher.selectedModel = options.model;
+        }
+        void this.emitDesktopConfig(nativeId, options.model);
+        const now = Date.now();
+        return { nativeId, cwd: options.cwd, createdAt: now, updatedAt: now, state: "idle" };
+    }
+    async prompt(nativeId, content, clientMessageId, context) {
+        const transcriptPath = this.transcriptPathFor(nativeId);
+        if (!this.desktopMode && !(transcriptPath && existsSync(transcriptPath))) {
+            return super.prompt(nativeId, content, clientMessageId, context);
+        }
+        const desktop = resolveAntigravityDesktop(this.options.env ?? process.env);
+        const conn = await findRunningLanguageServer(desktop);
+        if (!conn) {
+            throw RpcError.app("agent_unavailable", "请先在电脑上打开 Antigravity 桌面端应用，再发送消息");
+        }
+        const text = content
+            .map((block) => (block.type === "text" ? block.text : ""))
+            .join("\n")
+            .trim();
+        if (!text)
+            throw RpcError.app("invalid_params", "nothing to send");
+        const fullText = context ? `${context}\n\n${text}` : text;
+        const selectedModel = this.desktopWatchers.get(nativeId)?.selectedModel;
+        this.host?.update(this.id, nativeId, { sessionUpdate: "ls_turn", state: "started" });
+        this.host?.update(this.id, nativeId, { sessionUpdate: "ls_status", state: "running", turnActive: true });
+        await callLanguageServer(conn, "SendUserCascadeMessage", {
+            cascadeId: nativeId,
+            items: [{ text: fullText }],
+            ...(selectedModel ? { cascadeConfig: { plannerConfig: { requestedModel: { model: selectedModel } } } } : {}),
+        });
+        if (transcriptPath && !this.desktopWatchers.has(nativeId)) {
+            const { nextLine } = parseAntigravityTranscript(transcriptPath, 0);
+            this.startWatchingDesktopTranscript(nativeId, transcriptPath, nextLine);
+        }
+        return "started";
+    }
+    async cancel(nativeId) {
+        if (this.desktopMode || this.desktopWatchers.has(nativeId)) {
+            const desktop = resolveAntigravityDesktop(this.options.env ?? process.env);
+            const conn = await findRunningLanguageServer(desktop);
+            if (conn) {
+                await callLanguageServer(conn, "CancelCascadeInvocation", {
+                    cascadeId: nativeId,
+                    killBackgroundTasks: false,
+                }).catch(() => { });
+            }
+            this.host?.update(this.id, nativeId, { sessionUpdate: "ls_turn", state: "ended", stopReason: "cancelled" });
+            this.host?.update(this.id, nativeId, { sessionUpdate: "ls_status", state: "idle", turnActive: false });
+            return;
+        }
+        await super.cancel(nativeId);
+    }
+    async setConfig(nativeId, optionId, value) {
+        if (this.desktopMode || this.desktopWatchers.has(nativeId)) {
+            if (optionId !== "model")
+                throw RpcError.app("not_supported", `Antigravity 暂不支持设置 ${optionId}`);
+            const watcher = this.desktopWatchers.get(nativeId);
+            if (watcher)
+                watcher.selectedModel = value;
+            await this.emitDesktopConfig(nativeId, value);
+            return;
+        }
+        await super.setConfig(nativeId, optionId, value);
+    }
 }
 //# sourceMappingURL=antigravity.js.map