@sagentlab/navarch-runtime 0.1.107 → 0.1.111

package/dist/adapters/antigravity.cjs

@@ -0,0 +1,348 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.antigravityAdapter = exports.ANTIGRAVITY_PROCESS_WRAPPER = void 0;
+exports.runAntigravityAdapter = runAntigravityAdapter;
+exports.normalizeAntigravityOutput = normalizeAntigravityOutput;
+const node_child_process_1 = require("node:child_process");
+const node_path_1 = __importDefault(require("node:path"));
+const node_string_decoder_1 = require("node:string_decoder");
+const config_cjs_1 = require("../config.cjs");
+const kill_agent_cjs_1 = require("../kill-agent.cjs");
+const antigravity_mcp_cjs_1 = require("./antigravity-mcp.cjs");
+/** Documented agy 1.3.1 contract, not Gemini CLI's similarly named format.
+ * https://antigravity.google/docs/cli/headless/
+ * https://antigravity.google/docs/changelog (1.1.27, 1.1.28, 1.2.6, 1.2.10)
+ * One stdin user event + EOF per process; later lease-local turns may resume
+ * only the exact validated AG conversation. No interactive approval protocol.
+ */
+async function runAntigravityAdapter(options) {
+    if (options.signal?.aborted)
+        return failure("", { killedByLeaseLoss: true, exitCode: null });
+    if (options.antigravityHostGuard && !options.dockerExec)
+        return failure(config_cjs_1.ANTIGRAVITY_HOST_GUARD_MESSAGE);
+    if (!options.cwd || !node_path_1.default.isAbsolute(options.cwd))
+        return failure("Antigravity requires an absolute session working directory.");
+    const args = antigravityArgs(options);
+    if (typeof args === "string")
+        return failure(args);
+    const started = performance.now();
+    // --version is local and does not start a model turn or sign in. Require the
+    // verified contract rather than inheriting older silent-success behavior.
+    const version = await runProcess({ ...options, timeoutMs: options.timeoutMs > 0 ? Math.min(options.timeoutMs, 10_000) : 10_000, env: agentEnvironment(options.env), onOutput: undefined, onActivity: undefined }, ["--version"], "");
+    if (version.exitCode !== 0 || version.timedOut || version.killedByLeaseLoss)
+        return version;
+    const match = /\b(\d+)\.(\d+)\.(\d+)\b/.exec(version.stdout);
+    const current = match ? match.slice(1).map(Number) : [];
+    if (current.length !== 3 || (current[0] < 1) || (current[0] === 1 && (current[1] < 3 || (current[1] === 3 && current[2] < 1)))) {
+        return failure("Antigravity CLI 1.3.1 or later is required. Verify the official agy installation with agy --version.");
+    }
+    if (options.signal?.aborted)
+        return failure("", { killedByLeaseLoss: true, exitCode: null });
+    const remaining = options.timeoutMs > 0 ? options.timeoutMs - (performance.now() - started) : 0;
+    if (options.timeoutMs > 0 && remaining <= 0)
+        return failure("Antigravity startup exceeded the session deadline.", { timedOut: true, exitCode: null });
+    let mcp;
+    let raw = failure("Antigravity did not start.");
+    try {
+        mcp = await (0, antigravity_mcp_cjs_1.prepareAntigravityMcp)(options);
+        const turnRemaining = options.timeoutMs > 0 ? options.timeoutMs - (performance.now() - started) : 0;
+        if (options.timeoutMs > 0 && turnRemaining <= 0)
+            raw = failure("Antigravity setup exceeded the session deadline.", { timedOut: true, exitCode: null });
+        else if (options.signal?.aborted)
+            raw = failure("", { killedByLeaseLoss: true, exitCode: null });
+        else
+            raw = await runProcess({ ...options, timeoutMs: turnRemaining,
+                env: agentEnvironment(options.env),
+            }, args, `${JSON.stringify({ event: "user", message: { content: options.prompt } })}\n`);
+    }
+    catch {
+        // Configuration and network errors can contain bearer values. Diagnostics
+        // identify the phase only; source values are never copied into a report.
+        raw = failure("Antigravity MCP setup failed. The workspace must allow a new .agents/mcp_config.json; existing files and symlinks are never overwritten, and a repository-local .gitignore must ignore .agents/mcp_config.json. Check the lease MCP configuration and use an isolated session directory.");
+    }
+    finally {
+        if (mcp) {
+            try {
+                await mcp.close();
+            }
+            catch {
+                raw = { ...raw, exitCode: raw.exitCode === 0 ? 1 : raw.exitCode, stderr: `${raw.stderr}\nAntigravity MCP cleanup could not be verified; session failed closed.` };
+            }
+        }
+    }
+    if (mcp?.failed()) {
+        raw = { ...raw, exitCode: 1, stderr: `${raw.stderr}\nAntigravity lease MCP relay failed.` };
+    }
+    return normalizeAntigravityOutput(raw, options);
+}
+function agentEnvironment(env) {
+    const out = {};
+    for (const [name, value] of Object.entries(env)) {
+        if (typeof value === "string" && !name.startsWith("NAVARCH_OPENCODE_MCP_") && !name.startsWith("NAVARCH_AGY_MCP_") && !["NAVARCH_MACHINE_TOKEN", "NAVARCH_ENROLLMENT_SECRET", "NAVARCH_ENROLLMENT_TOKEN"].includes(name))
+            out[name] = value;
+    }
+    return out;
+}
+function failure(stderr, overrides = {}) {
+    return { exitCode: 1, timedOut: false, killedByLeaseLoss: false, stdout: "", stderr, ...overrides };
+}
+/** Extra args are deliberately bounded: no prompt/protocol/timeout/session overrides. */
+function antigravityArgs(options) {
+    const args = ["--input-format", "stream-json", "--output-format", "stream-json"];
+    const valueFlags = new Set(["--agent", "--model", "--effort"]);
+    const boolFlags = new Set(["--sandbox", "--dangerously-skip-permissions"]);
+    const values = new Map();
+    for (let i = 0; i < options.extraArgs.length; i++) {
+        const token = options.extraArgs[i];
+        const eq = token.indexOf("=");
+        const name = eq >= 0 ? token.slice(0, eq) : token;
+        if (valueFlags.has(name)) {
+            const value = eq >= 0 ? token.slice(eq + 1) : options.extraArgs[++i];
+            if (!value || value.startsWith("-") || values.has(name))
+                return "Antigravity extra arguments contain a missing or duplicate value.";
+            values.set(name, value);
+        }
+        else if (boolFlags.has(name) && eq < 0) {
+            if (args.includes(name))
+                return "Antigravity extra arguments contain a duplicate flag.";
+            args.push(name);
+        }
+        else {
+            return "Unsupported Antigravity extra argument. Only --agent, --model, --effort, --sandbox and --dangerously-skip-permissions are allowed; Navarch owns input/output, timeout and conversation identity.";
+        }
+    }
+    const model = options.model && options.model !== "default" ? options.model : values.get("--model");
+    if (values.has("--model") && options.model && options.model !== "default" && values.get("--model") !== options.model)
+        return "Antigravity model arguments conflict with the selected execution model.";
+    if (model)
+        values.set("--model", model);
+    const effort = options.reasoningEffort ?? values.get("--effort");
+    if (effort) {
+        if (!["low", "medium", "high"].includes(effort))
+            return "Antigravity supports low, medium or high reasoning effort only.";
+        if (values.has("--effort") && values.get("--effort") !== effort)
+            return "Antigravity reasoning effort arguments conflict.";
+        values.set("--effort", effort);
+    }
+    for (const [name, value] of values)
+        args.push(name, value);
+    const resume = options.antigravityResume;
+    if (resume) {
+        if (resume.provider !== "antigravity" || !validId(resume.conversationId) || resume.cwd !== node_path_1.default.resolve(options.cwd) || resume.model !== (model ?? "default") || !metric(resume.numTurns) || resume.numTurns < 1) {
+            return "Antigravity resume identity does not match this provider, workspace and model. Start a new session explicitly.";
+        }
+        args.push("--conversation", resume.conversationId);
+    }
+    return args;
+}
+function object(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validId(value) {
+    return typeof value === "string" && /^[A-Za-z0-9][A-Za-z0-9_-]{0,199}$/.test(value);
+}
+function metric(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function hasDeniedActions(value) {
+    // The changelog specifies the field but not an item schema. Empty array is
+    // the only explicit no-denial value; unknown shapes fail closed.
+    return "denied_actions" in value && (!Array.isArray(value.denied_actions) || value.denied_actions.length > 0);
+}
+/** Require one complete, well-formed turn. OS exit 0 alone never means success. */
+function normalizeAntigravityOutput(raw, options) {
+    if (raw.killedByLeaseLoss || raw.timedOut || raw.exitCode === null)
+        return raw;
+    let id;
+    let result;
+    let invalid = false;
+    let denied = false;
+    for (const line of raw.stdout.split(/\r?\n/).filter((line) => line.trim())) {
+        let event;
+        try {
+            event = JSON.parse(line);
+        }
+        catch {
+            invalid = true;
+            continue;
+        }
+        if (!object(event) || result) {
+            invalid = true;
+            continue;
+        }
+        denied ||= hasDeniedActions(event);
+        if (event.event === "init") {
+            if (id || !validId(event.conversation_id) || !object(event.init))
+                invalid = true;
+            else
+                id = event.conversation_id;
+        }
+        else if (event.event === "step_update") {
+            const step = event.step_update;
+            if (!id || !object(step) || step.conversation_id !== id || !metric(step.step_index) || !["ACTIVE", "DONE"].includes(String(step.state)) || typeof step.step_type !== "string" || ("text_delta" in step && typeof step.text_delta !== "string"))
+                invalid = true;
+            if (object(step)) {
+                denied ||= hasDeniedActions(step);
+                if (object(step.tool_info) && object(step.tool_info.error)) {
+                    const error = step.tool_info.error;
+                    denied ||= /permission|denied|approval|refused/i.test(`${String(error.type ?? "")} ${String(error.message ?? "")}`);
+                }
+            }
+        }
+        else if (event.event === "result" && object(event.result)) {
+            result = event.result;
+            denied ||= hasDeniedActions(result);
+        }
+        else
+            invalid = true;
+    }
+    const diagnosticFailure = /^\s*AGY_ERROR\s*:/m.test(raw.stderr)
+        || /(?:soft[- ]denied|permission[^\n]*(?:denied|required)|(?:denied|refused)[^\n]*(?:action|tool)|not permitted|print-timeout|(?:timeout|timed out)[^\n]*(?:partial|response)|partial[^\n]*(?:timeout|timed out))/i.test(raw.stderr);
+    const previous = options.antigravityResume;
+    if (!result || !id || result.conversation_id !== id || typeof result.response !== "string" || !metric(result.num_turns) || result.num_turns < 1)
+        invalid = true;
+    if (result && "error" in result && typeof result.error !== "string")
+        invalid = true;
+    if (previous && (id !== previous.conversationId || result?.num_turns !== previous.numTurns + 1))
+        invalid = true;
+    if (!previous && result?.num_turns !== 1)
+        invalid = true;
+    const out = { ...raw };
+    const usage = result && object(result.usage) ? result.usage : undefined;
+    const totalIn = usage && metric(usage.input_tokens) ? usage.input_tokens : undefined;
+    const totalOut = usage && metric(usage.output_tokens) ? usage.output_tokens : undefined;
+    // Resume counters are cumulative. Never sum the whole historical bill again.
+    if (!invalid) {
+        if (totalIn !== undefined && (!previous || previous.tokensIn !== undefined)) {
+            const delta = totalIn - (previous?.tokensIn ?? 0);
+            if (delta < 0)
+                invalid = true;
+            else
+                out.tokensIn = delta;
+        }
+        if (totalOut !== undefined && (!previous || previous.tokensOut !== undefined)) {
+            const delta = totalOut - (previous?.tokensOut ?? 0);
+            if (delta < 0)
+                invalid = true;
+            else
+                out.tokensOut = delta;
+        }
+    }
+    // Vendor docs do not establish cached-token inclusion consistently. Keep
+    // the raw input/output measures; neither fabricate USD nor a cache split.
+    const succeeded = raw.exitCode === 0 && !invalid && !denied && !diagnosticFailure && result?.status === "SUCCESS" && !(typeof result.error === "string" && result.error);
+    if (!succeeded) {
+        out.exitCode = raw.exitCode === 0 ? 1 : raw.exitCode;
+        const detail = denied ? "A required action was denied by Antigravity permission policy."
+            : invalid ? "Antigravity returned an invalid, incomplete or mismatched event stream."
+                : diagnosticFailure ? "Antigravity reported a CLI error, permission denial or partial timeout."
+                    : `Antigravity did not complete successfully (status ${typeof result?.status === "string" ? result.status : "missing"}).`;
+        out.stderr = `${raw.stderr}\n${detail}`.trim();
+        // Only structured CLI errors and CLI stderr participate, never assistant prose.
+        const cliError = `${typeof result?.error === "string" ? result.error : ""}\n${raw.stderr}`;
+        if (/RESOURCE_EXHAUSTED|\brate[ _-]+limit|too many requests/i.test(cliError)) {
+            out.capacityError = "Antigravity rate limit or provider capacity exhausted; retry after the machine cooldown.";
+        }
+        if (/authentication required|not logged in|unauthenticated|please.*(?:login|sign in)/i.test(cliError)) {
+            out.authError = "Antigravity authentication is required. Authenticate agy interactively on this machine; Gemini CLI credentials are not reused.";
+        }
+        return out;
+    }
+    out.reportText = String(result.response).trim();
+    const modelArg = options.extraArgs.findIndex((arg) => arg === "--model");
+    const extraModel = modelArg >= 0 ? options.extraArgs[modelArg + 1] : options.extraArgs.find((arg) => arg.startsWith("--model="))?.slice(8);
+    out.antigravityResume = {
+        provider: "antigravity", conversationId: id, cwd: node_path_1.default.resolve(options.cwd),
+        model: options.model && options.model !== "default" ? options.model : extraModel ?? "default",
+        numTurns: result.num_turns, tokensIn: totalIn, tokensOut: totalOut,
+    };
+    return out;
+}
+async function runProcess(options, args, input) {
+    if (options.dockerExec)
+        return runDocker(options, args, input);
+    return new Promise((resolve) => {
+        let stdout = "", stderr = "", timedOut = false, killedByLeaseLoss = false;
+        const stdoutDecoder = new node_string_decoder_1.StringDecoder("utf8"), stderrDecoder = new node_string_decoder_1.StringDecoder("utf8");
+        const child = (0, node_child_process_1.spawn)(options.bin, args, { cwd: options.cwd, detached: process.platform !== "win32", env: agentEnvironment({ ...process.env, ...options.env }) });
+        child.stdin?.on("error", () => undefined);
+        child.stdin?.end(input);
+        options.onProcessStarted?.(child.pid);
+        let escalation;
+        const stop = () => {
+            (0, kill_agent_cjs_1.killAgent)(child, "SIGINT");
+            escalation ??= setTimeout(() => (0, kill_agent_cjs_1.killAgent)(child), 1_000);
+        };
+        const timer = options.timeoutMs > 0 ? setTimeout(() => { timedOut = true; stop(); }, options.timeoutMs) : undefined;
+        const onAbort = () => { killedByLeaseLoss = true; stop(); };
+        options.signal?.addEventListener("abort", onAbort, { once: true });
+        if (options.signal?.aborted)
+            onAbort();
+        child.stdout.on("data", (chunk) => { const text = stdoutDecoder.write(chunk); stdout += text; options.onActivity?.(); options.onOutput?.("stdout", text); });
+        child.stderr.on("data", (chunk) => { const text = stderrDecoder.write(chunk); stderr += text; options.onActivity?.(); options.onOutput?.("stderr", text); });
+        let settled = false;
+        const finish = (code) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            clearTimeout(escalation);
+            options.signal?.removeEventListener("abort", onAbort);
+            // Stop the owned process group even when agy exits before its tools.
+            (0, kill_agent_cjs_1.killAgent)(child);
+            stdout += stdoutDecoder.end();
+            stderr += stderrDecoder.end();
+            resolve({ exitCode: code, timedOut, killedByLeaseLoss, stdout, stderr });
+        };
+        child.on("error", () => { stderr += "\nAntigravity process could not be started; check NAVARCH_ANTIGRAVITY_BIN."; finish(null); });
+        child.on("exit", () => (0, kill_agent_cjs_1.killAgent)(child));
+        child.on("close", finish);
+    });
+}
+/** Node is already required by the MCP relay. A separate process group also
+ * prevents redirected-stdio background tools outliving a successful Docker turn. */
+exports.ANTIGRAVITY_PROCESS_WRAPPER = `const{spawn}=require('node:child_process');const c=spawn(process.argv[1],process.argv.slice(2),{detached:process.platform!=='win32',stdio:['pipe','inherit','inherit']});let timer;function kill(signal='SIGKILL'){try{if(c.pid&&process.platform!=='win32'){process.kill(-c.pid,signal);return;}}catch{}c.kill(signal);}c.stdin.on('error',()=>{});process.stdin.pipe(c.stdin);for(const signal of ['SIGINT','SIGTERM'])process.on(signal,()=>{kill(signal);timer??=setTimeout(()=>kill(),1000);});c.on('exit',()=>kill());c.on('error',()=>{process.stderr.write('Antigravity process could not start\\n');process.exitCode=1;process.stdin.destroy();});c.on('close',(code)=>{clearTimeout(timer);kill();process.exitCode=code??1;process.stdin.destroy();});`;
+async function runDocker(options, args, input) {
+    const { containerName, runner } = options.dockerExec;
+    let killedByLeaseLoss = false, timedOut = false;
+    const abort = new AbortController();
+    let killing;
+    let killFailed = false;
+    const kill = () => {
+        abort.abort();
+        killing ??= runner.run("docker", ["kill", containerName], { timeoutMs: 10_000 })
+            .then((result) => { if (result.code !== 0)
+            killFailed = true; }, () => { killFailed = true; });
+    };
+    const onAbort = () => { killedByLeaseLoss = true; kill(); };
+    options.signal?.addEventListener("abort", onAbort, { once: true });
+    const timer = options.timeoutMs > 0 ? setTimeout(() => { timedOut = true; kill(); }, options.timeoutMs) : undefined;
+    if (options.signal?.aborted)
+        onAbort();
+    try {
+        if (abort.signal.aborted)
+            return failure("", { exitCode: null, timedOut, killedByLeaseLoss });
+        const command = `[ -f /tmp/session.env ] && . /tmp/session.env; cd ${quote(options.cwd)} && exec ${["node", "-e", exports.ANTIGRAVITY_PROCESS_WRAPPER, options.bin, ...args].map(quote).join(" ")}`;
+        const result = await runner.run("docker", ["exec", "-i", ...Object.keys(options.env).flatMap((name) => ["--env", name]), containerName, "sh", "-c", command], {
+            input, env: agentEnvironment({ ...process.env, ...options.env }), signal: abort.signal,
+            onActivity: options.onActivity, onStdout: (chunk) => options.onOutput?.("stdout", chunk), onStderr: (chunk) => options.onOutput?.("stderr", chunk),
+        });
+        await killing;
+        return { exitCode: result.code, timedOut, killedByLeaseLoss, stdout: result.stdout,
+            stderr: result.stderr + (killFailed ? "\nAntigravity container termination could not be verified." : "") };
+    }
+    catch {
+        await killing;
+        return failure(killFailed ? "Antigravity Docker process failed; container termination could not be verified." : "Antigravity Docker process failed.", { exitCode: null, timedOut, killedByLeaseLoss });
+    }
+    finally {
+        clearTimeout(timer);
+        options.signal?.removeEventListener("abort", onAbort);
+        await killing;
+    }
+}
+function quote(value) { return `'${value.replace(/'/g, `'\\''`)}'`; }
+exports.antigravityAdapter = { agentType: "antigravity", run: runAntigravityAdapter };