@simonepri/refined-antigravity-acp 0.1.0 → 0.1.2

package/dist/src/connector.js

@@ -0,0 +1,1138 @@
+import fs from "node:fs";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { once } from "node:events";
+import readline from "node:readline";
+import { agyCommand, ensureAntigravityBinary } from "./command.js";
+import { ensurePatchedBinary } from "./agy-patch.js";
+import { formatSystemContext, sanitizeAssistantText, StreamSanitizer } from "./sanitize.js";
+import { ensureAuthenticated } from "./auth.js";
+import { sharedMcpProxyPool } from "./mcp-proxy.js";
+export const DEFAULT_HANG_GRACE_MS = 5000;
+export const DEFAULT_HANG_INACTIVITY_MS = 30_000;
+export const DEFAULT_RECYCLE_TIMEOUT_MS = 30_000;
+export const RECYCLE_ID_PREFIX = "paseo-antigravity:recycle:";
+export const RECYCLE_INIT_ID = `${RECYCLE_ID_PREFIX}init`;
+export const RECYCLE_LOAD_ID = `${RECYCLE_ID_PREFIX}load`;
+export const RECYCLE_MODE_ID = `${RECYCLE_ID_PREFIX}mode`;
+export const RECYCLE_CONFIG_PREFIX = `${RECYCLE_ID_PREFIX}config:`;
+function parseEnvMs(val, defaultMs) {
+    if (!val)
+        return defaultMs;
+    const num = Number(val);
+    return Number.isFinite(num) && num > 0 ? num : defaultMs;
+}
+function extractJsonCandidate(line) {
+    const marker = "RAW WS MSG:";
+    const idx = line.indexOf(marker);
+    if (idx !== -1) {
+        return line.slice(idx + marker.length).trim();
+    }
+    const keyIdx = line.indexOf('"trajectoryStateUpdate"');
+    if (keyIdx === -1)
+        return null;
+    const braceIdx = line.lastIndexOf("{", keyIdx);
+    if (braceIdx === -1)
+        return null;
+    return line.slice(braceIdx).trim();
+}
+function parseTsuObject(parsed) {
+    if (!parsed || typeof parsed !== "object")
+        return null;
+    const tsu = parsed.trajectoryStateUpdate;
+    if (!tsu || typeof tsu !== "object")
+        return null;
+    const o = tsu;
+    if (typeof o.trajectoryId !== "string" || typeof o.state !== "string")
+        return null;
+    return { trajectoryId: o.trajectoryId, state: o.state };
+}
+export function parseTrajectoryStateUpdate(line) {
+    const candidate = extractJsonCandidate(line);
+    if (!candidate)
+        return null;
+    try {
+        return parseTsuObject(JSON.parse(candidate));
+    }
+    catch {
+        const lastBrace = candidate.lastIndexOf("}");
+        if (lastBrace === -1)
+            return null;
+        try {
+            return parseTsuObject(JSON.parse(candidate.slice(0, lastBrace + 1)));
+        }
+        catch {
+            return null;
+        }
+    }
+}
+function parseStepUpdateObject(parsed) {
+    if (!parsed || typeof parsed !== "object")
+        return null;
+    const su = parsed.stepUpdate;
+    if (!su || typeof su !== "object")
+        return null;
+    const o = su;
+    if (typeof o.trajectoryId !== "string" || typeof o.state !== "string")
+        return null;
+    return {
+        trajectoryId: o.trajectoryId,
+        state: o.state,
+        target: typeof o.target === "string" ? o.target : undefined,
+        source: typeof o.source === "string" ? o.source : undefined,
+    };
+}
+export function parseStepUpdate(line) {
+    const candidate = extractJsonCandidate(line);
+    if (!candidate)
+        return null;
+    try {
+        return parseStepUpdateObject(JSON.parse(candidate));
+    }
+    catch {
+        const lastBrace = candidate.lastIndexOf("}");
+        if (lastBrace === -1)
+            return null;
+        try {
+            return parseStepUpdateObject(JSON.parse(candidate.slice(0, lastBrace + 1)));
+        }
+        catch {
+            return null;
+        }
+    }
+}
+export class HangDetector {
+    graceMs;
+    inactivityMs;
+    onHangDeclared;
+    pendingPrompts = new Map();
+    lastStates = new Map();
+    hungSessions = new Set();
+    now;
+    constructor(options) {
+        this.graceMs =
+            options?.graceMs ?? parseEnvMs(process.env.PASEO_AGY_HANG_GRACE_MS, DEFAULT_HANG_GRACE_MS);
+        this.inactivityMs =
+            options?.inactivityMs ??
+                parseEnvMs(process.env.PASEO_AGY_HANG_INACTIVITY_MS, DEFAULT_HANG_INACTIVITY_MS);
+        this.onHangDeclared = options?.onHangDeclared;
+        this.now = options?.now ?? Date.now;
+    }
+    isHung(nativeSessionId) {
+        return this.hungSessions.has(nativeSessionId);
+    }
+    clearHung(nativeSessionId) {
+        this.hungSessions.delete(nativeSessionId);
+        this.lastStates.delete(nativeSessionId);
+    }
+    scheduleInactivityTimer(nativeSessionId, promptId, prompt) {
+        if (prompt.inactivityTimer) {
+            clearTimeout(prompt.inactivityTimer);
+        }
+        prompt.inactivityTimer = setTimeout(() => {
+            this.checkInactivity(nativeSessionId, promptId);
+        }, this.inactivityMs);
+    }
+    startGraceTimer(nativeSessionId, id, prompt) {
+        if (prompt.timer)
+            return;
+        prompt.timer = setTimeout(() => {
+            this.onGraceTimerFired(nativeSessionId, id);
+        }, this.graceMs);
+    }
+    recordPrompt(id, nativeSessionId) {
+        const now = this.now();
+        const prompt = {
+            nativeSessionId,
+            sentAt: now,
+            lastActivityAt: now,
+        };
+        this.pendingPrompts.set(id, prompt);
+        this.scheduleInactivityTimer(nativeSessionId, id, prompt);
+        if (this.lastStates.get(nativeSessionId) === "STATE_WAITING_FOR_TASKS") {
+            this.startGraceTimer(nativeSessionId, id, prompt);
+        }
+    }
+    recordActivity(nativeSessionId) {
+        const now = this.now();
+        for (const [id, prompt] of this.pendingPrompts.entries()) {
+            if (prompt.nativeSessionId === nativeSessionId) {
+                prompt.lastActivityAt = now;
+                this.scheduleInactivityTimer(nativeSessionId, id, prompt);
+            }
+        }
+    }
+    resolvePrompt(id) {
+        const prompt = this.pendingPrompts.get(id);
+        if (!prompt)
+            return;
+        if (prompt.timer) {
+            clearTimeout(prompt.timer);
+        }
+        if (prompt.inactivityTimer) {
+            clearTimeout(prompt.inactivityTimer);
+        }
+        this.pendingPrompts.delete(id);
+    }
+    clearPromptTimers(prompt) {
+        if (prompt.timer) {
+            clearTimeout(prompt.timer);
+            prompt.timer = undefined;
+        }
+        if (prompt.inactivityTimer) {
+            clearTimeout(prompt.inactivityTimer);
+            prompt.inactivityTimer = undefined;
+        }
+    }
+    logHangReason(nativeSessionId, promptId, reason) {
+        if (reason === "inactivity") {
+            console.error(`[paseo-antigravity] Inactivity backstop fired for session ${nativeSessionId}, prompt ${promptId}`);
+        }
+        else if (reason === "turn_complete") {
+            console.error(`[paseo-antigravity] Turn completion grace timer fired for session ${nativeSessionId}, prompt ${promptId}`);
+        }
+        else {
+            console.error(`[paseo-antigravity] Hang declared for session ${nativeSessionId}, prompt ${promptId} (STATE_WAITING_FOR_TASKS)`);
+        }
+    }
+    declareHang(nativeSessionId, promptId, reason) {
+        this.hungSessions.add(nativeSessionId);
+        const prompt = this.pendingPrompts.get(promptId);
+        if (prompt) {
+            this.clearPromptTimers(prompt);
+            this.pendingPrompts.delete(promptId);
+        }
+        this.logHangReason(nativeSessionId, promptId, reason);
+        this.onHangDeclared?.(nativeSessionId, promptId);
+    }
+    onGraceTimerFired(nativeSessionId, promptId, reason = "grace") {
+        const prompt = this.pendingPrompts.get(promptId);
+        if (!prompt)
+            return;
+        prompt.timer = undefined;
+        this.declareHang(nativeSessionId, promptId, reason);
+    }
+    checkInactivity(nativeSessionId, promptId) {
+        const prompt = this.pendingPrompts.get(promptId);
+        if (!prompt)
+            return;
+        const elapsed = this.now() - prompt.lastActivityAt;
+        if (elapsed >= this.inactivityMs) {
+            this.declareHang(nativeSessionId, promptId, "inactivity");
+            return;
+        }
+        const remaining = this.inactivityMs - elapsed;
+        prompt.inactivityTimer = setTimeout(() => {
+            this.checkInactivity(nativeSessionId, promptId);
+        }, remaining);
+    }
+    handleWaitingForTasks(nativeSessionId) {
+        for (const [id, prompt] of this.pendingPrompts.entries()) {
+            if (prompt.nativeSessionId === nativeSessionId) {
+                this.startGraceTimer(nativeSessionId, id, prompt);
+            }
+        }
+    }
+    handleTurnCompleteCandidate(nativeSessionId) {
+        for (const [id, prompt] of this.pendingPrompts.entries()) {
+            if (prompt.nativeSessionId === nativeSessionId && !prompt.timer) {
+                prompt.timer = setTimeout(() => {
+                    this.onGraceTimerFired(nativeSessionId, id, "turn_complete");
+                }, this.graceMs);
+            }
+        }
+    }
+    clearGraceTimersForSession(nativeSessionId) {
+        for (const prompt of this.pendingPrompts.values()) {
+            if (prompt.nativeSessionId === nativeSessionId && prompt.timer) {
+                clearTimeout(prompt.timer);
+                prompt.timer = undefined;
+            }
+        }
+    }
+    processStderrLine(line) {
+        const tsu = parseTrajectoryStateUpdate(line);
+        if (tsu) {
+            const { trajectoryId, state } = tsu;
+            this.lastStates.set(trajectoryId, state);
+            if (state === "STATE_WAITING_FOR_TASKS") {
+                this.handleWaitingForTasks(trajectoryId);
+            }
+            else {
+                this.clearGraceTimersForSession(trajectoryId);
+            }
+            return;
+        }
+        const su = parseStepUpdate(line);
+        if (su) {
+            const { trajectoryId, state, target } = su;
+            if (state === "STATE_DONE" && target === "TARGET_USER") {
+                this.handleTurnCompleteCandidate(trajectoryId);
+            }
+            else if (state === "STATE_ACTIVE" && target === "TARGET_ENVIRONMENT") {
+                // Active environment step (e.g. running a tool) clears grace timer
+                this.clearGraceTimersForSession(trajectoryId);
+            }
+        }
+    }
+    processOutbound(msg) {
+        if (!("method" in msg) || msg.method !== "session/prompt")
+            return;
+        const m = msg;
+        if (typeof m.id !== "string" && typeof m.id !== "number")
+            return;
+        if (typeof m.params?.sessionId !== "string")
+            return;
+        this.recordPrompt(m.id, m.params.sessionId);
+    }
+    processInbound(msg) {
+        if ("method" in msg && msg.method === "session/update") {
+            const sessionId = msg.params?.sessionId;
+            if (typeof sessionId === "string") {
+                this.recordActivity(sessionId);
+            }
+            return;
+        }
+        if (("result" in msg || "error" in msg) && "id" in msg) {
+            const id = msg.id;
+            if (typeof id === "string" || typeof id === "number") {
+                this.resolvePrompt(id);
+            }
+        }
+    }
+    dispose() {
+        for (const prompt of this.pendingPrompts.values()) {
+            this.clearPromptTimers(prompt);
+        }
+        this.pendingPrompts.clear();
+    }
+}
+/**
+ * Strips duplicate mode configuration options from ACP session/new and session/load responses.
+ *
+ * agy_acp_server returns modes both in `result.modes` and as a setting option with `id: "mode"`
+ * in `result.configOptions`. Filtering out `id: "mode"` prevents duplicate controls in the Paseo UI.
+ */
+export function filterConfigOptions(result) {
+    if (!result || typeof result !== "object" || !("configOptions" in result))
+        return;
+    const res = result;
+    if (!Array.isArray(res.configOptions))
+        return;
+    res.configOptions = res.configOptions.filter((opt) => {
+        if (!opt || typeof opt !== "object")
+            return true;
+        const o = opt;
+        return o.id !== "mode" && o.category !== "mode";
+    });
+}
+function fallbackSanitizeBlock(block) {
+    if (block && typeof block === "object" && "text" in block && typeof block.text === "string") {
+        block.text = sanitizeAssistantText(block.text);
+    }
+}
+function fallbackSanitizeInboundText(msg) {
+    if (!("method" in msg) || msg.method !== "session/update")
+        return;
+    const content = msg.params?.update?.content;
+    if (!content)
+        return;
+    if (Array.isArray(content)) {
+        for (const block of content)
+            fallbackSanitizeBlock(block);
+    }
+    else {
+        fallbackSanitizeBlock(content);
+    }
+}
+function sanitizeBlock(block, sanitizer) {
+    if (block && typeof block === "object" && "text" in block && typeof block.text === "string") {
+        block.text = sanitizer.process(block.text);
+        return block.text !== "";
+    }
+    return true;
+}
+function extractUpdateContent(msg) {
+    if (!("method" in msg) || msg.method !== "session/update")
+        return null;
+    const update = msg.params?.update;
+    if (!update || typeof update !== "object")
+        return null;
+    const content = update.content;
+    if (!content)
+        return null;
+    const isMessageChunk = update.sessionUpdate === "agent_message_chunk";
+    return { content, isMessageChunk };
+}
+function sanitizeInboundText(msg, sanitizer) {
+    const target = extractUpdateContent(msg);
+    if (!target)
+        return true;
+    let hasNonEmpty = false;
+    if (Array.isArray(target.content)) {
+        for (const block of target.content) {
+            if (sanitizeBlock(block, sanitizer))
+                hasNonEmpty = true;
+        }
+    }
+    else {
+        hasNonEmpty = sanitizeBlock(target.content, sanitizer);
+    }
+    return !target.isMessageChunk || hasNonEmpty;
+}
+export function createSystemPromptState() {
+    return {
+        pendingSystemPrompts: new Map(),
+        sessionSystemPrompts: new Map(),
+        injectedSessions: new Set(),
+    };
+}
+const defaultSystemPromptState = createSystemPromptState();
+export function resetSystemPromptState() {
+    defaultSystemPromptState.pendingSystemPrompts.clear();
+    defaultSystemPromptState.sessionSystemPrompts.clear();
+    defaultSystemPromptState.injectedSessions.clear();
+}
+function sessionIdOf(msg) {
+    if (!("method" in msg) || msg.method !== "session/update")
+        return null;
+    const sessionId = msg.params?.sessionId;
+    return typeof sessionId === "string" ? sessionId : null;
+}
+function agentMessageChunk(sessionId, text) {
+    return {
+        jsonrpc: "2.0",
+        method: "session/update",
+        params: {
+            sessionId,
+            update: { sessionUpdate: "agent_message_chunk", content: { type: "text", text } },
+        },
+    };
+}
+/**
+ * Processes an inbound ACP message received from `agy_acp_server`:
+ * 1. Filters duplicate mode controls from `configOptions`.
+ * 2. Sanitizes assistant streaming text notifications across chunk boundaries.
+ * 3. Flushes text still held in the sanitizer's look-ahead buffer at a turn boundary.
+ *
+ * Returns the messages to forward. A streaming chunk that sanitizes to nothing is
+ * dropped, and a turn boundary may yield an extra chunk carrying the flushed tail.
+ */
+function closeTurn(msg, sanitizer, state) {
+    filterConfigOptions(msg.result);
+    // A response ends the turn. Whatever is still buffered was a suspected harness tag
+    // that never materialized, so it is real text and must be emitted, not discarded.
+    const tail = sanitizer?.flush() ?? "";
+    sanitizer?.reset();
+    const sessionId = state?.lastSessionId;
+    return tail && sessionId ? [agentMessageChunk(sessionId, tail), msg] : [msg];
+}
+export function createSessionCache() {
+    return {
+        sessions: new Map(),
+        pendingSessionMetadata: new Map(),
+        cachedInitializeParams: undefined,
+    };
+}
+const defaultSessionCache = createSessionCache();
+export function resetSessionCache() {
+    defaultSessionCache.sessions.clear();
+    defaultSessionCache.pendingSessionMetadata.clear();
+    defaultSessionCache.cachedInitializeParams = undefined;
+}
+export function getOrCreateSession(cache, sessionId) {
+    let session = cache.sessions.get(sessionId);
+    if (!session) {
+        session = {
+            sessionId,
+            lastConfigOptions: new Map(),
+        };
+        cache.sessions.set(sessionId, session);
+    }
+    return session;
+}
+function recordAllocatedSessionPrompt(id, sessionId, promptState) {
+    if (promptState.pendingSystemPrompts.has(id)) {
+        const systemPrompt = promptState.pendingSystemPrompts.get(id);
+        promptState.pendingSystemPrompts.delete(id);
+        promptState.sessionSystemPrompts.set(sessionId, systemPrompt);
+    }
+}
+function recordAllocatedSessionMeta(id, sessionId, cache) {
+    if (cache.pendingSessionMetadata.has(id)) {
+        const pending = cache.pendingSessionMetadata.get(id);
+        cache.pendingSessionMetadata.delete(id);
+        const session = getOrCreateSession(cache, sessionId);
+        if (pending?.cwd !== undefined)
+            session.cwd = pending.cwd;
+        if (pending?.mcpServers !== undefined)
+            session.mcpServers = pending.mcpServers;
+        if (pending?._meta !== undefined)
+            session._meta = pending._meta;
+    }
+}
+function recordAllocatedSession(msg, promptState, cache) {
+    if (!("result" in msg) || !msg.result || typeof msg.result !== "object")
+        return;
+    if (!("sessionId" in msg.result))
+        return;
+    const sessionId = msg.result.sessionId;
+    if (typeof sessionId !== "string" || !("id" in msg) || msg.id === null || msg.id === undefined) {
+        return;
+    }
+    recordAllocatedSessionPrompt(msg.id, sessionId, promptState);
+    recordAllocatedSessionMeta(msg.id, sessionId, cache);
+}
+export function processInboundMessage(msg, sanitizer, state, promptState = defaultSystemPromptState, sessionCache = defaultSessionCache) {
+    if ("result" in msg && msg.result) {
+        recordAllocatedSession(msg, promptState, sessionCache);
+        return closeTurn(msg, sanitizer, state);
+    }
+    if (state) {
+        const sessionId = sessionIdOf(msg);
+        if (sessionId)
+            state.lastSessionId = sessionId;
+    }
+    if (sanitizer) {
+        return sanitizeInboundText(msg, sanitizer) ? [msg] : [];
+    }
+    fallbackSanitizeInboundText(msg);
+    return [msg];
+}
+function normalizeMcpHeaders(headers) {
+    if (!headers)
+        return undefined;
+    if (Array.isArray(headers)) {
+        return headers.flatMap((h) => {
+            if (!h || typeof h !== "object")
+                return [];
+            const name = typeof h.name === "string" ? h.name : typeof h.key === "string" ? h.key : "";
+            const value = typeof h.value === "string" ? h.value : "";
+            return name ? [{ name, value }] : [];
+        });
+    }
+    if (typeof headers === "object") {
+        return Object.entries(headers).flatMap(([name, val]) => typeof val === "string" ? [{ name, value: val }] : []);
+    }
+    return undefined;
+}
+/**
+ * Rewrites Paseo MCP server declarations for agy_acp_server:
+ * 1. Routes the URL through a local proxy that normalizes the MCP protocol version.
+ * 2. Normalizes headers to array shape [{ name, value }].
+ *
+ * The transport type is passed through untouched. agy advertises
+ * `mcpCapabilities: {http: true, sse: true}` and issues streamable-HTTP POSTs either
+ * way, so declaring Paseo's streamable-HTTP endpoint as "sse" only misdescribed it.
+ */
+export async function rewriteMcpServers(servers, proxies) {
+    for (const s of servers) {
+        if (!s || typeof s !== "object")
+            continue;
+        const server = s;
+        if (server.url && proxies) {
+            server.url = await proxies.rewriteUrl(server.url);
+        }
+        const normalized = normalizeMcpHeaders(server.headers);
+        if (normalized) {
+            server.headers = normalized;
+        }
+    }
+}
+/**
+ * Processes an outbound ACP message sent from Paseo to `agy_acp_server`:
+ * 1. Rewrites MCP server declarations (URL proxying, headers normalization).
+ * 2. Maps legacy / generic mode IDs ("accept-edits" -> "auto_edit", "dangerously-skip-permissions" -> "yolo").
+ */
+function remapModeId(modeId) {
+    if (modeId === "accept-edits")
+        return "auto_edit";
+    if (modeId === "dangerously-skip-permissions")
+        return "yolo";
+    if (modeId === "plan")
+        return "default";
+    return modeId;
+}
+function captureSessionNewPrompt(msg, promptState) {
+    if (!("id" in msg) || msg.id === null || msg.id === undefined)
+        return;
+    const params = msg.params;
+    const systemPrompt = params?._meta?._paseo?.systemPrompt;
+    promptState.pendingSystemPrompts.set(msg.id, systemPrompt);
+}
+function injectSystemContext(prompt, systemPrompt) {
+    if (!Array.isArray(prompt))
+        return;
+    const textPart = prompt.find((p) => Boolean(p &&
+        typeof p === "object" &&
+        p.type === "text" &&
+        typeof p.text === "string"));
+    const formatted = `${formatSystemContext(systemPrompt)}
+
+`;
+    if (textPart) {
+        textPart.text = `${formatted}${textPart.text}`;
+    }
+    else {
+        prompt.unshift({ type: "text", text: formatted.trimEnd() });
+    }
+}
+function handleSessionPrompt(params, promptState) {
+    const sessionId = typeof params?.sessionId === "string" ? params.sessionId : null;
+    if (!sessionId)
+        return;
+    if (!promptState.sessionSystemPrompts.has(sessionId))
+        return;
+    if (promptState.injectedSessions.has(sessionId))
+        return;
+    promptState.injectedSessions.add(sessionId);
+    const systemPrompt = promptState.sessionSystemPrompts.get(sessionId);
+    injectSystemContext(params?.prompt, systemPrompt);
+}
+function captureSessionNewMetadata(msg, cache) {
+    if (!("id" in msg) || msg.id === null || msg.id === undefined)
+        return;
+    const params = msg.params;
+    cache.pendingSessionMetadata.set(msg.id, {
+        cwd: typeof params?.cwd === "string" ? params.cwd : undefined,
+        mcpServers: Array.isArray(params?.mcpServers) ? params?.mcpServers : undefined,
+        _meta: params?._meta,
+    });
+}
+function captureSessionLoadMetadata(msg, cache) {
+    const params = msg.params;
+    if (typeof params?.sessionId !== "string")
+        return;
+    const session = getOrCreateSession(cache, params.sessionId);
+    if (typeof params.cwd === "string")
+        session.cwd = params.cwd;
+    if (Array.isArray(params.mcpServers))
+        session.mcpServers = params.mcpServers;
+    if (params._meta !== undefined)
+        session._meta = params._meta;
+}
+function captureSetMode(msg, cache) {
+    const params = msg.params;
+    if (typeof params?.sessionId !== "string" || typeof params?.modeId !== "string")
+        return;
+    const session = getOrCreateSession(cache, params.sessionId);
+    session.lastModeId = params.modeId;
+}
+function captureSetConfigOption(msg, cache) {
+    const params = msg.params;
+    if (typeof params?.sessionId !== "string" || typeof params?.configId !== "string")
+        return;
+    const session = getOrCreateSession(cache, params.sessionId);
+    session.lastConfigOptions.set(params.configId, {
+        value: params.value,
+        type: typeof params.type === "string" ? params.type : undefined,
+    });
+}
+function cacheInitializeParams(msg, cache) {
+    if ("params" in msg) {
+        cache.cachedInitializeParams = msg.params;
+    }
+}
+export function extractSessionId(msg) {
+    if (!("params" in msg) || !msg.params || typeof msg.params !== "object") {
+        return null;
+    }
+    const sid = msg.params.sessionId;
+    return typeof sid === "string" ? sid : null;
+}
+async function adaptOutboundParams(params, proxies) {
+    if (params?.mcpServers && Array.isArray(params.mcpServers)) {
+        await rewriteMcpServers(params.mcpServers, proxies);
+    }
+    if (params?.modeId) {
+        params.modeId = remapModeId(params.modeId);
+    }
+}
+function dispatchOutboundMethod(msg, params, promptState, sessionCache) {
+    switch (msg.method) {
+        case "initialize":
+            cacheInitializeParams(msg, sessionCache);
+            break;
+        case "session/new":
+            captureSessionNewPrompt(msg, promptState);
+            captureSessionNewMetadata(msg, sessionCache);
+            break;
+        case "session/load":
+            captureSessionLoadMetadata(msg, sessionCache);
+            break;
+        case "session/set_mode":
+            captureSetMode(msg, sessionCache);
+            break;
+        case "session/set_config_option":
+            captureSetConfigOption(msg, sessionCache);
+            break;
+        case "session/prompt":
+            handleSessionPrompt(params, promptState);
+            break;
+    }
+}
+export async function processOutboundMessage(msg, proxies, promptState = defaultSystemPromptState, sessionCache = defaultSessionCache) {
+    if (!("method" in msg))
+        return msg;
+    const params = msg.params;
+    await adaptOutboundParams(params, proxies);
+    dispatchOutboundMethod(msg, params, promptState, sessionCache);
+    return msg;
+}
+const ACP_TRACE_ENABLED = process.env.PASEO_AGY_TRACE === "1";
+/**
+ * Logs ACP request/response ids when PASEO_AGY_TRACE=1.
+ *
+ * An ACP request that never receives a response leaves Paseo waiting out its 60s
+ * session RPC timeout with no indication of which call stalled; this names it.
+ */
+function traceAcp(direction, msg) {
+    if (!ACP_TRACE_ENABLED)
+        return;
+    const m = msg;
+    const id = m.id === undefined ? "-" : String(m.id);
+    const kind = m.method ? String(m.method) : m.error ? "error" : "result";
+    console.error(`[paseo-antigravity][acp] ${direction} id=${id} ${kind}`);
+}
+export function resolveHarnessPath(cmd) {
+    try {
+        const real = fs.realpathSync(cmd);
+        const sibling = path.join(path.dirname(real), "localharness_external");
+        if (fs.existsSync(sibling))
+            return sibling;
+    }
+    catch {
+        // Ignore resolution errors
+    }
+    return undefined;
+}
+function defaultSpawnProcess(cmd, args) {
+    const env = {
+        ...process.env,
+        AGY_ACP_FORCE_FILE_STORAGE: "1",
+        BROWSER: "false",
+    };
+    const harness = resolveHarnessPath(cmd);
+    if (harness) {
+        env.ANTIGRAVITY_HARNESS_PATH = harness;
+    }
+    return spawn(cmd, args, {
+        stdio: ["pipe", "pipe", "pipe"],
+        env,
+    });
+}
+export class ChildSlot {
+    currentChild;
+    rlOut = null;
+    rlErr = null;
+    isRecycling = false;
+    isSwallowingUpdates = false;
+    suppressedResponseIds = new Set();
+    sessionCache = createSessionCache();
+    promptState = createSystemPromptState();
+    hangDetector;
+    state = { isClosed: false };
+    readableController = null;
+    cmd;
+    args;
+    spawnFn;
+    recycleTimeoutMs;
+    sanitizer = new StreamSanitizer();
+    inboundState = { lastSessionId: null };
+    pendingRequests = new Map();
+    activeRecycle = null;
+    constructor(params) {
+        this.cmd = params.cmd;
+        this.args = params.args;
+        this.currentChild = params.initialChild;
+        this.spawnFn = params.options?.spawnProcess ?? defaultSpawnProcess;
+        this.recycleTimeoutMs =
+            params.options?.recycleTimeoutMs ??
+                parseEnvMs(process.env.PASEO_AGY_RECYCLE_TIMEOUT_MS, DEFAULT_RECYCLE_TIMEOUT_MS);
+        const userOnHang = params.options?.onHangDeclared;
+        this.hangDetector = new HangDetector({
+            ...params.options,
+            onHangDeclared: (nativeSessionId, promptId) => {
+                this.handleHangDeclared(nativeSessionId, promptId);
+                userOnHang?.(nativeSessionId, promptId);
+            },
+        });
+        this.bindChild(this.currentChild);
+    }
+    setReadableController(controller) {
+        this.readableController = controller;
+    }
+    parseJsonLine(line) {
+        try {
+            return JSON.parse(line);
+        }
+        catch {
+            return null;
+        }
+    }
+    tryHandleInternalRecycle(msg) {
+        if (!("id" in msg) || msg.id === null || msg.id === undefined)
+            return false;
+        const idStr = String(msg.id);
+        if (!idStr.startsWith(RECYCLE_ID_PREFIX))
+            return false;
+        const pending = this.pendingRequests.get(msg.id);
+        if (pending) {
+            clearTimeout(pending.timer);
+            this.pendingRequests.delete(msg.id);
+            if ("error" in msg && msg.error) {
+                pending.reject(new Error(msg.error.message || "Recycle request failed"));
+            }
+            else {
+                pending.resolve(msg);
+            }
+        }
+        return true;
+    }
+    tryHandleSuppressedResponse(msg) {
+        if (!("id" in msg) || msg.id === null || msg.id === undefined)
+            return false;
+        if (this.suppressedResponseIds.has(msg.id)) {
+            this.suppressedResponseIds.delete(msg.id);
+            console.error(`[paseo-antigravity] Dropped late response for hung prompt ${msg.id}`);
+            return true;
+        }
+        return false;
+    }
+    forwardInbound(msg) {
+        const list = processInboundMessage(msg, this.sanitizer, this.inboundState, this.promptState, this.sessionCache);
+        for (const processed of list) {
+            try {
+                this.readableController?.enqueue(processed);
+            }
+            catch {
+                // Controller may already be closed
+            }
+        }
+    }
+    handleStdoutLine(line) {
+        if (this.state.isClosed)
+            return;
+        const msg = this.parseJsonLine(line);
+        if (!msg)
+            return;
+        traceAcp("agy->paseo", msg);
+        if (this.tryHandleInternalRecycle(msg))
+            return;
+        if (this.tryHandleSuppressedResponse(msg))
+            return;
+        if (this.isSwallowingUpdates && "method" in msg && msg.method === "session/update")
+            return;
+        this.hangDetector.processInbound(msg);
+        this.forwardInbound(msg);
+    }
+    handleChildClose(err) {
+        if (this.isRecycling)
+            return;
+        if (this.state.isClosed)
+            return;
+        this.state.isClosed = true;
+        this.hangDetector.dispose();
+        this.rlErr?.close();
+        this.rlOut?.close();
+        try {
+            if (err)
+                this.readableController?.error(err);
+            else
+                this.readableController?.close();
+        }
+        catch {
+            // Stream already closed
+        }
+    }
+    handleHangDeclared(nativeSessionId, promptId) {
+        console.error(`[paseo-antigravity] Session ${nativeSessionId} hung on prompt ${promptId}; turn synthetic end_turn emitted, scheduled process recycle`);
+        this.suppressedResponseIds.add(promptId);
+        const session = getOrCreateSession(this.sessionCache, nativeSessionId);
+        session.needsRecycle = true;
+        const syntheticMsg = {
+            jsonrpc: "2.0",
+            id: promptId,
+            result: { stopReason: "end_turn" },
+        };
+        try {
+            this.readableController?.enqueue(syntheticMsg);
+        }
+        catch {
+            // Controller may be closed
+        }
+    }
+    sendInternalRequest(child, id, method, params) {
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pendingRequests.delete(id);
+                reject(new Error(`Recycle internal request ${method} (${id}) timed out after ${this.recycleTimeoutMs}ms`));
+            }, this.recycleTimeoutMs);
+            this.pendingRequests.set(id, { resolve, reject, timer });
+            const req = { jsonrpc: "2.0", id, method, ...(params !== undefined && { params }) };
+            if (!child.stdin?.writable) {
+                clearTimeout(timer);
+                this.pendingRequests.delete(id);
+                reject(new Error(`Child stdin not writable for ${method}`));
+                return;
+            }
+            child.stdin.write(JSON.stringify(req) + "\n", (err) => {
+                if (err) {
+                    clearTimeout(timer);
+                    this.pendingRequests.delete(id);
+                    reject(err);
+                }
+            });
+        });
+    }
+    async resyncSessionLoad(session, newChild) {
+        this.isSwallowingUpdates = true;
+        try {
+            const loadParams = { sessionId: session.sessionId };
+            if (session.cwd !== undefined)
+                loadParams.cwd = session.cwd;
+            if (session.mcpServers !== undefined)
+                loadParams.mcpServers = session.mcpServers;
+            if (session._meta !== undefined)
+                loadParams._meta = session._meta;
+            await this.sendInternalRequest(newChild, RECYCLE_LOAD_ID, "session/load", loadParams);
+        }
+        finally {
+            this.isSwallowingUpdates = false;
+        }
+    }
+    async resyncSessionMode(session, newChild) {
+        if (!session.lastModeId)
+            return;
+        await this.sendInternalRequest(newChild, RECYCLE_MODE_ID, "session/set_mode", {
+            sessionId: session.sessionId,
+            modeId: session.lastModeId,
+        });
+    }
+    async resyncSessionConfig(session, newChild) {
+        if (!session.lastConfigOptions || session.lastConfigOptions.size === 0)
+            return;
+        for (const [configId, opt] of session.lastConfigOptions.entries()) {
+            const configParams = {
+                sessionId: session.sessionId,
+                configId,
+                value: opt.value,
+            };
+            if (opt.type !== undefined)
+                configParams.type = opt.type;
+            await this.sendInternalRequest(newChild, `${RECYCLE_CONFIG_PREFIX}${configId}`, "session/set_config_option", configParams);
+        }
+    }
+    async performResync(session, newChild) {
+        const initParams = this.sessionCache.cachedInitializeParams ?? {
+            protocolVersion: 1,
+            clientCapabilities: {},
+            clientInfo: { name: "paseo", version: "1.0.0" },
+        };
+        await this.sendInternalRequest(newChild, RECYCLE_INIT_ID, "initialize", initParams);
+        await this.resyncSessionLoad(session, newChild);
+        await this.resyncSessionMode(session, newChild);
+        await this.resyncSessionConfig(session, newChild);
+    }
+    cleanupOldChild() {
+        const oldChild = this.currentChild;
+        this.rlOut?.close();
+        this.rlErr?.close();
+        this.rlOut = null;
+        this.rlErr = null;
+        if (oldChild && !oldChild.killed) {
+            oldChild.kill("SIGKILL");
+        }
+    }
+    handleRecycleFailure(err) {
+        console.error("[paseo-antigravity] Process recycle failed:", err);
+        this.state.isClosed = true;
+        this.hangDetector.dispose();
+        this.rlErr?.close();
+        this.rlOut?.close();
+        if (this.currentChild && !this.currentChild.killed) {
+            this.currentChild.kill("SIGKILL");
+        }
+        try {
+            const errorObj = err instanceof Error ? err : new Error(String(err));
+            this.readableController?.error(errorObj);
+        }
+        catch {
+            // Controller may already be closed
+        }
+    }
+    async recycleProcess(session) {
+        try {
+            this.isRecycling = true;
+            this.cleanupOldChild();
+            const newChild = await this.spawnFn(this.cmd, this.args);
+            this.currentChild = newChild;
+            this.bindChild(newChild);
+            await this.performResync(session, newChild);
+            session.needsRecycle = false;
+            this.hangDetector.clearHung(session.sessionId);
+            this.sanitizer.reset();
+            this.isRecycling = false;
+        }
+        catch (err) {
+            this.handleRecycleFailure(err);
+            throw err;
+        }
+    }
+    async writeToChild(msg) {
+        if (this.state.isClosed || !this.currentChild.stdin?.writable) {
+            throw new Error("Antigravity ACP stream is closed");
+        }
+        if (!this.currentChild.stdin.write(JSON.stringify(msg) + "\n")) {
+            await once(this.currentChild.stdin, "drain");
+        }
+    }
+    async write(msg, proxies) {
+        if (this.state.isClosed) {
+            throw new Error("Antigravity ACP stream is closed");
+        }
+        const targetSessionId = extractSessionId(msg);
+        const session = targetSessionId ? this.sessionCache.sessions.get(targetSessionId) : undefined;
+        if (session?.needsRecycle) {
+            if (!this.activeRecycle) {
+                this.activeRecycle = this.recycleProcess(session);
+            }
+            try {
+                await this.activeRecycle;
+            }
+            finally {
+                this.activeRecycle = null;
+            }
+        }
+        const processed = await processOutboundMessage(msg, proxies, this.promptState, this.sessionCache);
+        this.hangDetector.processOutbound(processed);
+        traceAcp("paseo->agy", processed);
+        await this.writeToChild(processed);
+    }
+    close() {
+        if (this.state.isClosed)
+            return;
+        this.state.isClosed = true;
+        this.hangDetector.dispose();
+        this.rlErr?.close();
+        this.rlOut?.close();
+        this.currentChild.stdin?.end();
+        if (!this.currentChild.killed) {
+            this.currentChild.kill("SIGTERM");
+        }
+        try {
+            this.readableController?.close();
+        }
+        catch {
+            // Controller already closed
+        }
+    }
+    abort() {
+        if (this.state.isClosed)
+            return;
+        this.state.isClosed = true;
+        this.hangDetector.dispose();
+        this.rlErr?.close();
+        this.rlOut?.close();
+        this.currentChild.stdin?.end();
+        if (!this.currentChild.killed) {
+            this.currentChild.kill("SIGKILL");
+        }
+        try {
+            this.readableController?.close();
+        }
+        catch {
+            // Controller already closed
+        }
+    }
+    bindChild(child) {
+        if (child.stdout) {
+            this.rlOut = readline.createInterface({ input: child.stdout, crlfDelay: Infinity });
+            this.rlOut.on("line", (line) => this.handleStdoutLine(line));
+        }
+        if (child.stderr) {
+            child.stderr.on("data", (chunk) => {
+                process.stderr.write(chunk);
+            });
+            this.rlErr = readline.createInterface({ input: child.stderr, crlfDelay: Infinity });
+            this.rlErr.on("line", (line) => {
+                this.hangDetector.processStderrLine(line);
+            });
+        }
+        child.on("close", () => this.handleChildClose());
+        child.on("error", (err) => this.handleChildClose(err));
+    }
+}
+export function createAcpReadableStream(slot) {
+    return new ReadableStream({
+        start(controller) {
+            slot.setReadableController(controller);
+        },
+        cancel() {
+            slot.close();
+        },
+    });
+}
+export function createAcpWritableStream(slot, proxies) {
+    return new WritableStream({
+        async write(msg) {
+            await slot.write(msg, proxies);
+        },
+        close() {
+            slot.close();
+        },
+        abort() {
+            slot.abort();
+        },
+    });
+}
+async function resolveBinaryCommand() {
+    const [initialCmd, ...args] = agyCommand();
+    let cmd = initialCmd;
+    if (!fs.existsSync(cmd)) {
+        try {
+            cmd = await ensureAntigravityBinary();
+        }
+        catch (err) {
+            console.error("[paseo-antigravity] Failed to auto-download binary:", err);
+        }
+    }
+    if (fs.existsSync(cmd)) {
+        try {
+            cmd = ensurePatchedBinary(cmd);
+        }
+        catch (err) {
+            console.error("[paseo-antigravity] Failed to patch binary:", err);
+        }
+    }
+    return [cmd, ...args];
+}
+/**
+ * Creates an in-process ACP connector stream that launches the official `agy_acp_server` binary,
+ * automatically downloading it if not present, and applies mode option filtering, outbound MCP adaptation,
+ * text sanitization, hang detection, and transparent process recycling.
+ *
+ * MCP proxies come from a process-wide pool rather than being owned by this stream.
+ * Antigravity persists the rewritten MCP URL into its per-session database, so a proxy
+ * torn down with the stream would leave resumed sessions pointing at a dead port.
+ */
+export function createAntigravityConnector(proxies = sharedMcpProxyPool, options) {
+    return async () => {
+        const [cmd, ...args] = await resolveBinaryCommand();
+        ensureAuthenticated();
+        const spawnFn = options?.spawnProcess ?? defaultSpawnProcess;
+        const initialChild = await spawnFn(cmd, args);
+        const slot = new ChildSlot({
+            cmd,
+            args,
+            initialChild,
+            proxies,
+            options,
+        });
+        return {
+            readable: createAcpReadableStream(slot),
+            writable: createAcpWritableStream(slot, proxies),
+        };
+    };
+}
+//# sourceMappingURL=connector.js.map