paseo-acp-agy 1.1.0

package/dist/antigravity-process.js

@@ -0,0 +1,535 @@
+import { spawn } from "node:child_process";
+import { EventEmitter } from "node:events";
+import fs from "node:fs";
+import path from "node:path";
+import { logger } from "./logger.js";
+import { getEffectiveEffortForModel, } from "./protocol.js";
+import { buildAgyArgs } from "./permissions.js";
+function resolveDefaultAgyBinary() {
+    if (process.env.AGY_BIN_PATH)
+        return process.env.AGY_BIN_PATH;
+    if (process.env.HOME) {
+        const localPath = path.join(process.env.HOME, ".local", "bin", "agy");
+        if (fs.existsSync(localPath))
+            return localPath;
+    }
+    return "agy";
+}
+export class AntigravityProcess extends EventEmitter {
+    child = null;
+    binaryPath;
+    cwd;
+    model;
+    effort;
+    mode;
+    conversationId;
+    permissions;
+    env;
+    isClosed = false;
+    needsRestart = false;
+    transitionPromise = null;
+    currentTurnPromise = null;
+    initialInfo = null;
+    constructor(options = {}) {
+        super();
+        this.binaryPath = options.binaryPath || resolveDefaultAgyBinary();
+        this.cwd = options.cwd || process.cwd();
+        this.model = options.model;
+        this.effort = options.effort;
+        this.mode = options.mode;
+        this.conversationId = options.conversationId;
+        this.permissions = options.permissions || { sandbox: false, dangerouslySkipPermissions: false };
+        this.env = { ...process.env, ...options.env };
+        // EventEmitter treats "error" specially. Keep a defensive listener for
+        // callers/tests that emit it directly; child failures use process_error.
+        this.on("error", (err) => {
+            logger.error("AntigravityProcess error", { error: err.message });
+        });
+    }
+    get isRunning() {
+        const child = this.child;
+        return child !== null && this.isProcessTreeAlive(child);
+    }
+    get isExecutingTurn() {
+        return this.currentTurnPromise !== null;
+    }
+    get currentConversationId() {
+        return this.conversationId;
+    }
+    get currentModel() {
+        return this.model;
+    }
+    get currentEffort() {
+        return this.effort;
+    }
+    get currentMode() {
+        return this.mode;
+    }
+    setModel(model) {
+        if (this.model !== model) {
+            this.model = model;
+            this.scheduleRestart();
+        }
+    }
+    setEffort(effort) {
+        if (this.effort !== effort) {
+            this.effort = effort;
+            this.scheduleRestart();
+        }
+    }
+    setMode(mode) {
+        if (this.mode !== mode) {
+            this.mode = mode;
+            this.scheduleRestart();
+        }
+    }
+    setConversationId(conversationId) {
+        if (this.conversationId !== conversationId) {
+            this.conversationId = conversationId;
+            this.scheduleRestart();
+        }
+    }
+    scheduleRestart() {
+        if (!this.child)
+            return;
+        this.needsRestart = true;
+        logger.info("Scheduled agy restart for updated session configuration", {
+            model: this.model,
+            effort: this.effort,
+            mode: this.mode,
+            conversationId: this.conversationId,
+            turnActive: this.isExecutingTurn,
+        });
+    }
+    isProcessTreeAlive(child) {
+        const pid = child.pid;
+        if (pid && process.platform !== "win32") {
+            try {
+                process.kill(-pid, 0);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }
+        return child.exitCode === null && child.signalCode === null;
+    }
+    signalProcessTree(child, signal) {
+        const pid = child.pid;
+        if (pid && process.platform !== "win32") {
+            try {
+                process.kill(-pid, signal);
+                return true;
+            }
+            catch (err) {
+                if (err.code === "ESRCH")
+                    return true;
+                logger.warn("Failed to signal agy process group; falling back to child PID", {
+                    pid,
+                    signal,
+                    error: err.message,
+                });
+            }
+        }
+        try {
+            return child.kill(signal);
+        }
+        catch {
+            return false;
+        }
+    }
+    async waitForProcessTreeExit(child, timeoutMs) {
+        const deadline = Date.now() + timeoutMs;
+        while (Date.now() < deadline) {
+            if (!this.isProcessTreeAlive(child))
+                return true;
+            await new Promise((resolve) => setTimeout(resolve, 25));
+        }
+        return !this.isProcessTreeAlive(child);
+    }
+    async terminateChild(child, gracefulTimeoutMs = 2_000) {
+        if (!this.isProcessTreeAlive(child)) {
+            if (this.child === child)
+                this.child = null;
+            return;
+        }
+        this.signalProcessTree(child, "SIGTERM");
+        if (!(await this.waitForProcessTreeExit(child, gracefulTimeoutMs))) {
+            logger.warn("agy process tree did not exit after SIGTERM; sending SIGKILL", {
+                pid: child.pid,
+            });
+            this.signalProcessTree(child, "SIGKILL");
+            if (!(await this.waitForProcessTreeExit(child, 1_000))) {
+                logger.error("agy process tree remained alive after SIGKILL", { pid: child.pid });
+            }
+        }
+        if (this.child === child)
+            this.child = null;
+    }
+    async applyPendingRestart(owner) {
+        if (!this.needsRestart)
+            return;
+        if (this.currentTurnPromise && this.currentTurnPromise !== owner) {
+            throw new Error("Cannot restart agy while another prompt turn is active");
+        }
+        if (owner?.child) {
+            throw new Error("Cannot restart agy after the active turn has started executing");
+        }
+        if (!this.child) {
+            this.needsRestart = false;
+            return;
+        }
+        if (!this.transitionPromise) {
+            const oldChild = this.child;
+            this.transitionPromise = (async () => {
+                logger.info("Restarting agy process with updated session configuration", {
+                    model: this.model,
+                    effort: this.effort,
+                    mode: this.mode,
+                    conversationId: this.conversationId,
+                });
+                await this.terminateChild(oldChild);
+                this.initialInfo = null;
+                this.needsRestart = false;
+            })().finally(() => {
+                this.transitionPromise = null;
+            });
+        }
+        await this.transitionPromise;
+    }
+    async start() {
+        if (this.isClosed)
+            throw new Error("Cannot start a closed Antigravity process");
+        if (this.transitionPromise)
+            await this.transitionPromise;
+        if (this.isRunning)
+            return;
+        const extraArgs = [];
+        if (this.model)
+            extraArgs.push("--model", this.model);
+        const effectiveEffort = getEffectiveEffortForModel(this.model, this.effort);
+        if (effectiveEffort)
+            extraArgs.push("--effort", effectiveEffort);
+        if (this.conversationId)
+            extraArgs.push("--conversation", this.conversationId);
+        const args = buildAgyArgs({
+            sandbox: this.permissions.sandbox,
+            dangerouslySkipPermissions: this.permissions.dangerouslySkipPermissions,
+            mode: this.mode,
+        }, extraArgs);
+        logger.info("Spawning agy process", {
+            binary: this.binaryPath,
+            args,
+            cwd: this.cwd,
+            effectiveEffort,
+        });
+        const child = spawn(this.binaryPath, args, {
+            cwd: this.cwd,
+            env: this.env,
+            stdio: ["pipe", "pipe", "pipe"],
+            detached: process.platform !== "win32",
+        });
+        this.child = child;
+        if (!child.stdin || !child.stdout || !child.stderr) {
+            if (this.child === child)
+                this.child = null;
+            this.signalProcessTree(child, "SIGKILL");
+            throw new Error("Failed to create stdio pipes for agy process");
+        }
+        child.stdout.setEncoding("utf-8");
+        child.stderr.setEncoding("utf-8");
+        let stdoutBuffer = "";
+        let stderrBuffer = "";
+        child.stdout.on("data", (chunk) => {
+            stdoutBuffer += chunk;
+            const lines = stdoutBuffer.split("\n");
+            stdoutBuffer = lines.pop() || "";
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                try {
+                    this.handleEvent(JSON.parse(trimmed), child);
+                }
+                catch (err) {
+                    logger.warn("Failed to parse line from agy stdout", {
+                        line: trimmed,
+                        error: err.message,
+                    });
+                }
+            }
+        });
+        child.stderr.on("data", (chunk) => {
+            stderrBuffer += chunk;
+            const lines = stderrBuffer.split("\n");
+            stderrBuffer = lines.pop() || "";
+            for (const line of lines) {
+                if (line.trim())
+                    logger.warn("agy stderr: " + line.trim());
+            }
+        });
+        child.on("error", (err) => {
+            logger.error("agy child process emitted error", { error: err.message });
+            if (this.currentTurnPromise?.child === child) {
+                this.currentTurnPromise.reject(err);
+                this.currentTurnPromise = null;
+            }
+            this.emit("process_error", err);
+        });
+        child.on("close", (code, signal) => {
+            logger.info("agy process exited", { code, signal, pid: child.pid });
+            if (this.currentTurnPromise?.child === child) {
+                this.currentTurnPromise.reject(new Error(`agy process exited prematurely with code ${code} signal ${signal}`));
+                this.currentTurnPromise = null;
+            }
+            // The leader can die while a tool subprocess remains in its process
+            // group. Keep the group identity long enough to reap those descendants.
+            if (this.isProcessTreeAlive(child)) {
+                void this.terminateChild(child).catch((err) => {
+                    logger.error("Failed to clean descendant processes after agy exit", {
+                        pid: child.pid,
+                        error: err.message,
+                    });
+                });
+            }
+            else if (this.child === child) {
+                this.child = null;
+            }
+            this.emit("exit", { code, signal, pid: child.pid });
+        });
+    }
+    handleEvent(event, child) {
+        const ownsProcess = this.child === child;
+        const ownsTurn = this.currentTurnPromise?.child === child;
+        if (!ownsProcess && !ownsTurn) {
+            logger.debug("Ignoring event from stale agy child", { event: event.event, pid: child.pid });
+            return;
+        }
+        logger.debug("Received agy event", { event: event.event, pid: child.pid });
+        switch (event.event) {
+            case "init": {
+                const initEvent = event;
+                if (ownsProcess && initEvent.conversation_id) {
+                    this.conversationId = initEvent.conversation_id;
+                    this.initialInfo = initEvent.init;
+                    this.emit("init", initEvent);
+                }
+                break;
+            }
+            case "step_update": {
+                const stepEvent = event;
+                if (ownsProcess && stepEvent.step_update?.conversation_id) {
+                    this.conversationId = stepEvent.step_update.conversation_id;
+                }
+                if (ownsTurn)
+                    this.emit("step_update", stepEvent);
+                break;
+            }
+            case "result": {
+                if (!ownsTurn || !this.currentTurnPromise)
+                    break;
+                const resultEvent = event;
+                if (resultEvent.result?.conversation_id) {
+                    this.conversationId = resultEvent.result.conversation_id;
+                }
+                this.emit("result", resultEvent);
+                const active = this.currentTurnPromise;
+                this.currentTurnPromise = null;
+                active.resolve(resultEvent);
+                break;
+            }
+            default:
+                logger.warn("Unknown agy event received", { raw: event });
+        }
+    }
+    async ensureReady(expectedConversationId, timeoutMs = 10_000) {
+        if (this.currentTurnPromise) {
+            throw new Error("Cannot validate an Antigravity session while a prompt turn is active");
+        }
+        await this.applyPendingRestart();
+        if (!this.isRunning)
+            await this.start();
+        const child = this.child;
+        if (!child)
+            throw new Error("Antigravity process failed to start");
+        if (this.initialInfo !== null) {
+            if (expectedConversationId && this.conversationId !== expectedConversationId) {
+                const actual = this.conversationId;
+                await this.terminateChild(child);
+                this.conversationId = expectedConversationId;
+                throw new Error(`Antigravity resumed unexpected conversation ${actual || "<none>"}; expected ${expectedConversationId}`);
+            }
+            return;
+        }
+        await new Promise((resolve, reject) => {
+            let settled = false;
+            const cleanup = () => {
+                this.off("init", onInit);
+                child.off("error", onError);
+                child.off("close", onClose);
+                clearTimeout(timer);
+            };
+            const finishReject = (err) => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                reject(err);
+            };
+            const finishResolve = () => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                resolve();
+            };
+            const onInit = (event) => {
+                if (this.child !== child)
+                    return;
+                if (expectedConversationId && event.conversation_id !== expectedConversationId) {
+                    const actual = event.conversation_id;
+                    cleanup();
+                    settled = true;
+                    void this.terminateChild(child).finally(() => {
+                        this.conversationId = expectedConversationId;
+                        reject(new Error(`Antigravity resumed unexpected conversation ${actual}; expected ${expectedConversationId}`));
+                    });
+                    return;
+                }
+                finishResolve();
+            };
+            const onError = (err) => finishReject(err);
+            const onClose = (code, signal) => finishReject(new Error(`Antigravity exited before initialization: code=${code} signal=${signal}`));
+            const timer = setTimeout(() => {
+                if (settled)
+                    return;
+                cleanup();
+                settled = true;
+                void this.terminateChild(child).finally(() => {
+                    if (expectedConversationId)
+                        this.conversationId = expectedConversationId;
+                    reject(new Error(`Timed out waiting ${timeoutMs}ms for Antigravity initialization`));
+                });
+            }, timeoutMs);
+            this.on("init", onInit);
+            child.once("error", onError);
+            child.once("close", onClose);
+            if (this.initialInfo !== null) {
+                onInit({
+                    event: "init",
+                    conversation_id: this.conversationId || "",
+                    init: this.initialInfo,
+                });
+            }
+        });
+    }
+    async sendPrompt(text, onStepUpdate) {
+        if (this.currentTurnPromise) {
+            throw new Error("A prompt turn is already in progress on this session");
+        }
+        let resolveTurn;
+        let rejectTurn;
+        const turnPromise = new Promise((resolve, reject) => {
+            resolveTurn = resolve;
+            rejectTurn = reject;
+        });
+        const active = {
+            child: null,
+            cancelled: false,
+            resolve: resolveTurn,
+            reject: rejectTurn,
+        };
+        // Reserve before the first await so concurrent prompt/cancel calls see the
+        // turn while the child is still starting or restarting.
+        this.currentTurnPromise = active;
+        let stepListener = null;
+        const failBeforeWrite = (err) => {
+            if (stepListener)
+                this.off("step_update", stepListener);
+            if (this.currentTurnPromise === active)
+                this.currentTurnPromise = null;
+            active.reject(err);
+        };
+        try {
+            await this.applyPendingRestart(active);
+            if (active.cancelled) {
+                failBeforeWrite(new Error("Prompt turn cancelled before execution"));
+                return turnPromise;
+            }
+            if (!this.isRunning)
+                await this.start();
+            if (active.cancelled) {
+                failBeforeWrite(new Error("Prompt turn cancelled before execution"));
+                return turnPromise;
+            }
+            const child = this.child;
+            if (!child || !child.stdin || !child.stdin.writable) {
+                failBeforeWrite(new Error("Cannot send prompt: agy process stdin is not writable"));
+                return turnPromise;
+            }
+            active.child = child;
+            if (onStepUpdate) {
+                stepListener = onStepUpdate;
+                this.on("step_update", stepListener);
+                const originalResolve = active.resolve;
+                const originalReject = active.reject;
+                active.resolve = (result) => {
+                    if (stepListener)
+                        this.off("step_update", stepListener);
+                    originalResolve(result);
+                };
+                active.reject = (err) => {
+                    if (stepListener)
+                        this.off("step_update", stepListener);
+                    originalReject(err);
+                };
+            }
+            if (active.cancelled) {
+                failBeforeWrite(new Error("Prompt turn cancelled before execution"));
+                return turnPromise;
+            }
+            const payload = {
+                event: "user",
+                message: { content: text },
+            };
+            logger.debug("Writing prompt to agy stdin", { promptPreview: text.slice(0, 100) });
+            child.stdin.write(JSON.stringify(payload) + "\n");
+        }
+        catch (err) {
+            failBeforeWrite(err);
+        }
+        return turnPromise;
+    }
+    cancelCurrentTurn() {
+        const active = this.currentTurnPromise;
+        if (!active)
+            return false;
+        active.cancelled = true;
+        logger.info("Cancelling active agy turn", { hasChild: Boolean(active.child) });
+        if (active.child)
+            this.signalProcessTree(active.child, "SIGINT");
+        return true;
+    }
+    async close() {
+        if (this.isClosed)
+            return;
+        this.isClosed = true;
+        if (this.transitionPromise)
+            await this.transitionPromise;
+        const active = this.currentTurnPromise;
+        if (active) {
+            active.cancelled = true;
+            this.currentTurnPromise = null;
+            active.reject(new Error("Session closed while turn was in progress"));
+        }
+        const child = this.child;
+        if (child) {
+            try {
+                await this.terminateChild(child);
+            }
+            catch (err) {
+                logger.error("Error during agy process cleanup", { error: err.message });
+            }
+        }
+    }
+}

package/dist/attachments.d.ts

@@ -0,0 +1 @@
+export declare function saveBase64Image(data: string, mimeType?: string): string | null;

package/dist/attachments.js

@@ -0,0 +1,102 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import crypto from "node:crypto";
+import { logger } from "./logger.js";
+const DEFAULT_MAX_ATTACHMENT_BYTES = 20 * 1024 * 1024;
+function getStateRoot() {
+    if (process.env.AGY_ACP_STATE_DIR)
+        return process.env.AGY_ACP_STATE_DIR;
+    const stateHome = process.env.XDG_STATE_HOME || path.join(os.homedir(), ".local", "state");
+    return path.join(stateHome, "agy-acp");
+}
+function getAttachmentsDir() {
+    const attachmentsDir = path.join(getStateRoot(), "attachments");
+    try {
+        fs.mkdirSync(attachmentsDir, { recursive: true, mode: 0o700 });
+        fs.chmodSync(attachmentsDir, 0o700);
+    }
+    catch { }
+    return attachmentsDir;
+}
+const MIME_TO_EXT = {
+    "image/png": ".png",
+    "image/jpeg": ".jpg",
+    "image/jpg": ".jpg",
+    "image/webp": ".webp",
+    "image/gif": ".gif",
+    "image/svg+xml": ".svg",
+    "image/bmp": ".bmp",
+    "image/tiff": ".tiff",
+};
+function maxAttachmentBytes() {
+    const configured = Number.parseInt(process.env.AGY_ACP_MAX_ATTACHMENT_BYTES || "", 10);
+    return Number.isFinite(configured) && configured > 0 ? configured : DEFAULT_MAX_ATTACHMENT_BYTES;
+}
+function normalizeBase64(data) {
+    const comma = data.indexOf(",");
+    const stripped = data.startsWith("data:") && comma >= 0 ? data.slice(comma + 1) : data;
+    return stripped.replace(/\s+/g, "");
+}
+function decodeValidatedBase64(data) {
+    if (!data || !/^[A-Za-z0-9+/]*={0,2}$/.test(data))
+        return null;
+    const unpadded = data.replace(/=+$/, "");
+    if (unpadded.length % 4 === 1)
+        return null;
+    try {
+        const buffer = Buffer.from(data, "base64");
+        if (buffer.toString("base64").replace(/=+$/, "") !== unpadded)
+            return null;
+        return buffer;
+    }
+    catch {
+        return null;
+    }
+}
+export function saveBase64Image(data, mimeType = "image/png") {
+    const normalizedMime = mimeType.toLowerCase();
+    const ext = MIME_TO_EXT[normalizedMime];
+    if (!ext) {
+        logger.warn("Rejected attachment with unsupported MIME type", { mimeType: normalizedMime });
+        return null;
+    }
+    const normalized = normalizeBase64(data);
+    const maxBytes = maxAttachmentBytes();
+    if (normalized.length > Math.ceil(maxBytes / 3) * 4 + 4) {
+        logger.warn("Rejected attachment exceeding configured size limit", {
+            encodedLength: normalized.length,
+            maxBytes,
+        });
+        return null;
+    }
+    const buffer = decodeValidatedBase64(normalized);
+    if (!buffer) {
+        logger.warn("Rejected attachment with invalid base64 payload");
+        return null;
+    }
+    if (buffer.length === 0 || buffer.length > maxBytes) {
+        logger.warn("Rejected attachment outside configured decoded size limit", {
+            sizeBytes: buffer.length,
+            maxBytes,
+        });
+        return null;
+    }
+    const dir = getAttachmentsDir();
+    const hash = crypto.createHash("sha256").update(buffer).digest("hex").slice(0, 16);
+    const filePath = path.join(dir, `attachment_${hash}${ext}`);
+    if (!fs.existsSync(filePath)) {
+        try {
+            fs.writeFileSync(filePath, buffer, { mode: 0o600, flag: "wx" });
+            fs.chmodSync(filePath, 0o600);
+            logger.info("Saved attached image for session", { filePath, sizeBytes: buffer.length });
+        }
+        catch (err) {
+            if (!fs.existsSync(filePath)) {
+                logger.error("Failed to save attached image", { error: err.message });
+                return null;
+            }
+        }
+    }
+    return filePath;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+import { ACPServer } from "./acp-server.js";
+import { logger } from "./logger.js";
+import { formatDiagnosticVersion, resolveBuildMetadata } from "./version.js";
+const args = process.argv.slice(2);
+if (args.includes("--version") || args.includes("-v")) {
+    if (args.includes("--json")) {
+        process.stdout.write(JSON.stringify(resolveBuildMetadata(), null, 2) + "\n");
+    }
+    else {
+        process.stdout.write(`${formatDiagnosticVersion()}\n`);
+    }
+    process.exit(0);
+}
+if (args.includes("--help") || args.includes("-h")) {
+    process.stdout.write(`paseo-acp-agy - ACP adapter for Google Antigravity CLI
+
+Usage:
+  paseo-acp-agy [options]
+  agy-acp [options]
+  npx -y paseo-acp-agy [options]
+
+Options:
+  --acp          Start ACP server over stdio (default)
+  -v, --version  Show version
+  --json         Show version in JSON format (with --version)
+  -h, --help     Show help
+
+Environment Variables:
+  AGY_ACP_LOG_LEVEL                 debug | info | warn | error (default: info)
+  AGY_ACP_LOG_DIR                   Directory for log files
+  AGY_ACP_SANDBOX                   Set to 'true' to run agy in sandbox mode
+  AGY_ACP_DANGEROUSLY_SKIP_PERMISSIONS Set to 'true' to auto-approve tool permissions
+  AGY_BIN_PATH                      Path to agy binary (default: agy in PATH or ~/.local/bin/agy)
+`);
+    process.exit(0);
+}
+const server = new ACPServer();
+const cleanup = async () => {
+    try {
+        await server.stop();
+        logger.close();
+    }
+    catch (err) {
+        // ignore
+    }
+    process.exit(0);
+};
+process.on("SIGINT", cleanup);
+process.on("SIGTERM", cleanup);
+server.start();