@prismatic-io/lux 0.0.2-preview.4 → 0.0.2-preview.41

package/src/drivers/antigravity/events.ts

@@ -0,0 +1,290 @@
+import { createHash } from "node:crypto";
+import { z } from "zod";
+import {
+  type ParsedDriverEvent,
+  type TokenUsage,
+  toolCallProgress,
+  toolResultProgress,
+} from "../../core/index.js";
+import type { AntigravityDriverConfig } from "./config.js";
+
+const UsageSchema = z.object({
+  input_tokens: z.number().nonnegative().catch(0),
+  output_tokens: z.number().nonnegative().catch(0),
+  thinking_tokens: z.number().nonnegative().catch(0),
+  cache_read_tokens: z.number().nonnegative().catch(0),
+});
+
+const StepUpdateSchema = z.looseObject({
+  step_index: z.number().int().nonnegative(),
+  state: z.string().optional(),
+  step_type: z.string().optional(),
+  tool_name: z.string().optional(),
+  text_delta: z.string().optional(),
+  usage: z.unknown().optional(),
+  tool_info: z
+    .looseObject({
+      name: z.string().optional(),
+      parameters: z.unknown().optional(),
+      output: z.unknown().optional(),
+      error: z
+        .looseObject({ type: z.string().optional(), message: z.string().optional() })
+        .optional(),
+    })
+    .optional(),
+});
+
+const ResultSchema = z.looseObject({
+  conversation_id: z.string().optional(),
+  status: z.string().optional(),
+  response: z.string().optional(),
+  error: z.string().optional(),
+  denied_actions: z
+    .array(z.looseObject({ action: z.string(), display_name: z.string().optional() }))
+    .optional(),
+  num_turns: z.number().optional(),
+  usage: z.unknown().optional(),
+});
+
+const InitSchema = z.looseObject({
+  cwd: z.string().optional(),
+  tools: z.array(z.string()).optional(),
+  permission_mode: z.string().optional(),
+  model: z.string().optional(),
+  agent: z.string().optional(),
+});
+
+const AntigravityEventSchema = z.discriminatedUnion("event", [
+  z.looseObject({
+    event: z.literal("init"),
+    conversation_id: z.string().optional(),
+    init: InitSchema.optional(),
+  }),
+  z.looseObject({ event: z.literal("step_update"), step_update: StepUpdateSchema.optional() }),
+  z.looseObject({ event: z.literal("result"), result: ResultSchema.optional() }),
+]);
+
+const parseUsage = (raw: unknown): TokenUsage | null => {
+  const usage = UsageSchema.safeParse(raw).data;
+  if (!usage) return null;
+  return {
+    input: usage.input_tokens,
+    output: usage.output_tokens,
+    cacheRead: usage.cache_read_tokens,
+    cacheCreation: 0,
+  };
+};
+
+const outputText = (output: unknown): string => {
+  if (typeof output === "string") return output;
+  return output === undefined ? "" : JSON.stringify(output);
+};
+
+const waitingReason =
+  "Antigravity is waiting for a tool permission it cannot receive headlessly; allow the tool in its settings or set skipPermissions";
+
+type StepUpdate = z.infer<typeof StepUpdateSchema>;
+type ResultEvent = z.infer<typeof ResultSchema>;
+type InitEvent = z.infer<typeof AntigravityEventSchema> & { event: "init" };
+
+const readyEvent = (
+  event: InitEvent,
+  config: AntigravityDriverConfig,
+  cliVersion: string | undefined,
+): ParsedDriverEvent => ({
+  tag: "ready",
+  ready: {
+    agentId: "antigravity",
+    model: event.init?.model ?? config.model,
+    detail: {
+      transport: "stream-json",
+      ...(event.conversation_id ? { conversationId: event.conversation_id } : {}),
+      ...(cliVersion ? { cliVersion } : {}),
+      ...(event.init?.cwd ? { cwd: event.init.cwd } : {}),
+      ...(event.init?.tools ? { tools: event.init.tools } : {}),
+      ...(event.init?.permission_mode ? { permissionMode: event.init.permission_mode } : {}),
+      ...(event.init?.agent ? { agent: event.init.agent } : {}),
+      reasoningEffort: config.reasoningEffort,
+      modelResolution: event.init?.model ? "reported" : "requested",
+    },
+  },
+});
+
+const toolStepEvents = (
+  step: StepUpdate,
+  openTools: Set<number>,
+  ts: number,
+): ParsedDriverEvent[] => {
+  const toolUseId = `step-${step.step_index}`;
+  const name = step.tool_info?.name ?? step.tool_name ?? "tool";
+  const events: ParsedDriverEvent[] = [];
+  if (!openTools.has(step.step_index)) {
+    openTools.add(step.step_index);
+    events.push({
+      tag: "progress",
+      progress: toolCallProgress(
+        step.step_index,
+        { name, input: step.tool_info?.parameters ?? {}, toolUseId },
+        ts,
+      ),
+    });
+  }
+  if (step.state === "DONE" || step.state === "ERROR") {
+    openTools.delete(step.step_index);
+    const error = step.tool_info?.error;
+    events.push({
+      tag: "progress",
+      progress: toolResultProgress(
+        step.step_index,
+        {
+          name,
+          toolUseId,
+          content: step.tool_info?.output ?? null,
+          isError: step.state === "ERROR" || error !== undefined,
+          text:
+            error?.message ??
+            (step.state === "ERROR"
+              ? "Antigravity tool failed"
+              : outputText(step.tool_info?.output)),
+        },
+        ts,
+      ),
+    });
+  }
+  return events;
+};
+
+const stepEvents = (
+  step: StepUpdate,
+  openTools: Set<number>,
+  ts: number,
+): ParsedDriverEvent | ParsedDriverEvent[] => {
+  if (step.step_type === "tool") return toolStepEvents(step, openTools, ts);
+  if (step.step_type === "agent_response" && step.text_delta) {
+    return {
+      tag: "progress",
+      progress: {
+        id: `antigravity-message-${step.step_index}-${ts}`,
+        kind: "agent-message",
+        payload: { text: step.text_delta },
+        ts,
+      },
+    };
+  }
+  return {
+    tag: "progress",
+    progress: {
+      id: `antigravity-step-${step.step_index}-${ts}`,
+      kind: "antigravity-step",
+      payload: step,
+      ts,
+    },
+  };
+};
+
+const resultEvent = (
+  result: ResultEvent | undefined,
+  conversationId: string | undefined,
+  usage: TokenUsage | null,
+): ParsedDriverEvent => {
+  if (result?.denied_actions?.length) {
+    return {
+      tag: "error",
+      error: {
+        exitReason: "error",
+        reason: `Antigravity could not complete because tool permissions were denied: ${result.denied_actions.map(({ action }) => action).join(", ")}`,
+        summary: {
+          deniedActions: result.denied_actions,
+          ...(result.response !== undefined ? { response: result.response } : {}),
+          ...(conversationId ? { conversationId } : {}),
+          ...(usage ? { usage } : { usageAvailability: "unavailable" }),
+        },
+      },
+    };
+  }
+  if (result?.status === "SUCCESS") {
+    return {
+      tag: "done",
+      done: {
+        exitReason: "done",
+        summary: {
+          ...(conversationId ? { conversationId } : {}),
+          ...(result.response !== undefined ? { response: result.response } : {}),
+          ...(result.num_turns !== undefined ? { numTurns: result.num_turns } : {}),
+          ...(usage ? { usage } : { usageAvailability: "unavailable" }),
+        },
+      },
+    };
+  }
+  const status = result?.status ?? "UNKNOWN";
+  return {
+    tag: "error",
+    error: {
+      exitReason: "error",
+      reason:
+        status === "WAITING"
+          ? waitingReason
+          : `Antigravity ended with status ${status}${result?.error ? `: ${result.error}` : ""}`,
+      ...(usage ? { summary: { usage } } : {}),
+    },
+  };
+};
+
+export const makeParseEvent = (config: AntigravityDriverConfig, cliVersion?: string) => {
+  const openTools = new Set<number>();
+  let conversationId: string | undefined;
+  let usage: TokenUsage | null = null;
+  let responseStep: number | undefined;
+  let responseHash = createHash("sha256");
+  return (line: string): ParsedDriverEvent | ParsedDriverEvent[] | null => {
+    let raw: unknown;
+    try {
+      raw = JSON.parse(line);
+    } catch {
+      return null;
+    }
+    const parsed = AntigravityEventSchema.safeParse(raw);
+    if (!parsed.success) return null;
+    const event = parsed.data;
+    if (event.event === "init") {
+      conversationId = event.conversation_id;
+      return readyEvent(event, config, cliVersion);
+    }
+    if (event.event === "step_update") {
+      if (!event.step_update) return null;
+      usage = parseUsage(event.step_update.usage) ?? usage;
+      if (event.step_update.step_type === "agent_response") {
+        if (responseStep !== event.step_update.step_index) {
+          responseHash = createHash("sha256");
+          responseStep = event.step_update.step_index;
+        }
+        responseHash.update(event.step_update.text_delta ?? "");
+      }
+      return stepEvents(event.step_update, openTools, Date.now());
+    }
+    const terminal = resultEvent(
+      event.result,
+      conversationId,
+      parseUsage(event.result?.usage) ?? usage,
+    );
+    if (
+      event.result?.response &&
+      createHash("sha256").update(event.result.response).digest("hex") !==
+        responseHash.copy().digest("hex")
+    ) {
+      return [
+        {
+          tag: "progress",
+          progress: {
+            id: "antigravity-final-response",
+            kind: "agent-message",
+            payload: { text: event.result.response },
+            ts: Date.now(),
+          },
+        },
+        terminal,
+      ];
+    }
+    return terminal;
+  };
+};

package/src/drivers/antigravity/index.ts

@@ -0,0 +1,132 @@
+import { realpath } from "node:fs/promises";
+import {
+  type AgentDriver,
+  type Answer,
+  type Artifact,
+  type DriverEventMap,
+  defineDriver,
+  discoverCliVersion,
+  type ReadyState,
+  type StartContext,
+  selectModelAndReasoningEffort,
+} from "../../core/index.js";
+import { walkArtifacts } from "../shared/artifacts.js";
+import { subprocessDriver } from "../subprocess/index.js";
+import {
+  type AntigravityDriverConfig,
+  AntigravityDriverConfigSchema,
+  buildAntigravityArgs,
+  formatAntigravityPrompt,
+} from "./config.js";
+import { makeParseEvent } from "./events.js";
+import { prepareAntigravityRuntime } from "./runtime.js";
+
+class AntigravityDriver implements AgentDriver {
+  private inner: AgentDriver | null = null;
+  private pendingAttach: Array<(inner: AgentDriver) => void> = [];
+  private cwd: string | null = null;
+  private artifactsDir: string | null = null;
+  private runtime: Awaited<ReturnType<typeof prepareAntigravityRuntime>> | null = null;
+  private started = false;
+  private readonly config: AntigravityDriverConfig;
+
+  constructor(config: AntigravityDriverConfig) {
+    this.config = config;
+  }
+
+  on<K extends keyof DriverEventMap>(event: K, handler: (e: DriverEventMap[K]) => void): void {
+    if (this.inner) this.inner.on(event, handler);
+    else this.pendingAttach.push((inner) => inner.on(event, handler));
+  }
+
+  off<K extends keyof DriverEventMap>(event: K, handler: (e: DriverEventMap[K]) => void): void {
+    if (this.inner) this.inner.off(event, handler);
+    else this.pendingAttach.push((inner) => inner.off(event, handler));
+  }
+
+  async start(ctx: StartContext): Promise<ReadyState> {
+    if (this.started) throw new Error("Antigravity driver cannot be started twice");
+    this.started = true;
+    this.cwd = await realpath(this.config.cwd ?? ctx.artifactsDir);
+    this.artifactsDir = ctx.artifactsDir;
+    const cliVersion = await discoverCliVersion(this.config.command);
+    this.runtime = await prepareAntigravityRuntime(this.config, ctx.isolatedHome);
+    try {
+      const inner = await subprocessDriver.create({
+        command: this.config.command,
+        args: buildAntigravityArgs(this.config, this.cwd),
+        cwd: this.cwd,
+        env: this.runtime.env,
+        protocol: "custom",
+        parseEvent: makeParseEvent(this.config, cliVersion),
+        formatPrompt: (prompt) =>
+          formatAntigravityPrompt(
+            `The task workspace is ${JSON.stringify(this.cwd)}. Treat that directory as the current directory for this task and create task artifacts there.\n\n${prompt}`,
+          ),
+        closeStdinAfterPrompt: true,
+        idleTimeout: this.config.idleTimeout,
+        maxLineBytes: this.config.maxLineBytes,
+        maxInterrupts: 1,
+      });
+      for (const attach of this.pendingAttach) attach(inner);
+      this.pendingAttach = [];
+      this.inner = inner;
+      return await inner.start(ctx);
+    } catch (error) {
+      await this.close();
+      throw error;
+    }
+  }
+
+  async respond(_answer: Answer): Promise<void> {
+    throw new Error("Antigravity headless sessions cannot receive mid-run responses");
+  }
+
+  async quiesce(): Promise<void> {
+    await this.inner?.close();
+  }
+
+  async collect(): Promise<Artifact[]> {
+    await this.quiesce();
+    if (!this.cwd) return [];
+    try {
+      await this.runtime?.collect(this.cwd);
+    } finally {
+      await this.runtime?.close();
+    }
+    const artifacts = await walkArtifacts(this.cwd);
+    return this.cwd === this.artifactsDir
+      ? artifacts
+      : artifacts.map((artifact) => ({ ...artifact, root: this.cwd as string }));
+  }
+
+  async close(): Promise<void> {
+    try {
+      await this.inner?.close();
+    } finally {
+      await this.runtime?.close();
+    }
+  }
+}
+
+export const antigravityDriver = defineDriver({
+  name: "antigravity",
+  configSchema: AntigravityDriverConfigSchema,
+  runtime: (config) => ({
+    commands: [config.command],
+    capabilities: {
+      interactive: false,
+      "tool-calls": true,
+      "tool-results": true,
+      artifacts: true,
+      usage: true,
+      cost: false,
+      isolation: false,
+    },
+  }),
+  selectHarness: selectModelAndReasoningEffort,
+  create: (config) => new AntigravityDriver(config),
+});
+
+export type { AntigravityDriverConfig };
+export { AntigravityDriverConfigSchema, buildAntigravityArgs, makeParseEvent };

package/src/drivers/antigravity/runtime.ts

@@ -0,0 +1,94 @@
+import { chmod, copyFile, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { homedir, platform } from "node:os";
+import { join } from "node:path";
+import { temporaryDirectory } from "tempy";
+import { agentEnvironment } from "../../core/agent-environment.js";
+import { exec } from "../../core/exec.js";
+import { captureAntigravityArtifacts } from "./artifacts.js";
+import type { AntigravityDriverConfig } from "./config.js";
+
+export const prepareAntigravityRuntime = async (
+  config: AntigravityDriverConfig,
+  isolatedHome?: string,
+): Promise<{
+  env: Record<string, string> | undefined;
+  collect: (destination: string) => Promise<void>;
+  close: () => Promise<void>;
+}> => {
+  if (config.permissionMode === "inherit")
+    return {
+      env:
+        config.inheritEnv === undefined
+          ? config.env
+          : agentEnvironment(process.env, config.inheritEnv, config.env),
+      collect: async (destination) => {
+        if (isolatedHome) await captureAntigravityArtifacts(isolatedHome, destination);
+      },
+      close: async () => {},
+    };
+
+  const runtimeHome = temporaryDirectory({ prefix: "lux-antigravity-home-" });
+  const close = () => rm(runtimeHome, { recursive: true, force: true });
+  try {
+    await chmod(runtimeHome, 0o700);
+    const cliRoot = join(runtimeHome, ".gemini", "antigravity-cli");
+    await mkdir(cliRoot, { recursive: true, mode: 0o700 });
+    await writeFile(
+      join(cliRoot, "settings.json"),
+      JSON.stringify({
+        enableTerminalSandbox: true,
+        toolPermission: "proceed-in-sandbox",
+        permissions: config.permissions,
+      }),
+      { mode: 0o600 },
+    );
+    const source =
+      config.authTokenFile ??
+      join(config.env?.HOME ?? homedir(), ".gemini", "antigravity-cli", "antigravity-oauth-token");
+    try {
+      // Copy only the CLI's own token, never settings, conversations, or plugins.
+      // A private copy prevents token refresh from mutating the caller's login.
+      const target = join(cliRoot, "antigravity-oauth-token");
+      await copyFile(source, target);
+      await chmod(target, 0o600);
+      // Reject empty files early without including credential contents in diagnostics.
+      if ((await readFile(target)).length === 0) throw new Error("Antigravity token file is empty");
+    } catch (error) {
+      if (config.authTokenFile || (error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+      if (config.reuseKeychain) {
+        if (platform() !== "darwin") throw new Error("Antigravity Keychain reuse requires macOS");
+        const credential = await exec(
+          "/usr/bin/security",
+          ["find-generic-password", "-s", "gemini", "-a", "antigravity", "-w"],
+          { timeoutMs: 10_000, maxBuffer: 1_000_000 },
+        );
+        if (credential.exitCode !== 0 || credential.stdoutTruncated)
+          throw new Error("Could not read the authorized Antigravity Keychain credential");
+        let token = credential.stdout.trim();
+        if (token.startsWith("go-keyring-base64:"))
+          token = Buffer.from(token.slice("go-keyring-base64:".length), "base64").toString("utf8");
+        try {
+          const parsed = JSON.parse(token);
+          if (!parsed?.token?.refresh_token || !parsed.auth_method) throw new Error();
+        } catch {
+          throw new Error("Antigravity Keychain credential has an unsupported format");
+        }
+        await writeFile(join(cliRoot, "antigravity-oauth-token"), token, { mode: 0o600 });
+      }
+    }
+    return {
+      env: {
+        ...(config.inheritEnv === undefined
+          ? config.env
+          : agentEnvironment(process.env, config.inheritEnv, config.env)),
+        HOME: runtimeHome,
+        ...(process.platform === "win32" ? { USERPROFILE: runtimeHome } : {}),
+      },
+      collect: (destination) => captureAntigravityArtifacts(runtimeHome, destination),
+      close,
+    };
+  } catch (error) {
+    await close();
+    throw error;
+  }
+};

package/src/drivers/claude-code/deferred-process.ts

@@ -0,0 +1,118 @@
+import { spawnManagedProcess } from "../../core/exec.js";
+import type { ParsedDriverEvent } from "../../core/index.js";
+
+type DeferredProcessOptions = {
+  command: string;
+  args: string[];
+  cwd: string;
+  env: NodeJS.ProcessEnv;
+  input?: string;
+  signal: AbortSignal;
+  idleTimeoutMs: number;
+  turnTimeoutMs?: number;
+  parse: (line: string) => ParsedDriverEvent | ParsedDriverEvent[] | null;
+  onEvent: (event: ParsedDriverEvent) => Promise<void>;
+};
+
+const MAX_LINE_BYTES = 10_000_000;
+const MAX_STDERR_CHARS = 10_000;
+
+/** Deliver progress live, but only resume or finish after the CLI has stopped writing. */
+export const runDeferredProcess = async (options: DeferredProcessOptions) => {
+  const managed = spawnManagedProcess(options.command, options.args, {
+    cwd: options.cwd,
+    env: options.env,
+    signal: options.signal,
+  });
+  let failure: Error | undefined;
+  let idleTimer: NodeJS.Timeout | undefined;
+  let turnTimer: NodeJS.Timeout | undefined;
+  let terminal: ParsedDriverEvent | undefined;
+  let stderr = "";
+  const clearTimers = () => {
+    clearTimeout(idleTimer);
+    clearTimeout(turnTimer);
+  };
+  const fail = (error: Error) => {
+    failure ??= error;
+    clearTimers();
+    void managed.terminate();
+  };
+  const bumpIdle = () => {
+    clearTimeout(idleTimer);
+    idleTimer = setTimeout(
+      () => fail(new Error(`no event for ${options.idleTimeoutMs}ms`)),
+      options.idleTimeoutMs,
+    );
+  };
+  bumpIdle();
+  if (options.turnTimeoutMs !== undefined) {
+    turnTimer = setTimeout(
+      () => fail(new Error(`Claude turn exceeded ${options.turnTimeoutMs}ms elapsed time`)),
+      options.turnTimeoutMs,
+    );
+  }
+  managed.child.stderr.setEncoding("utf8");
+  managed.child.stderr.on("data", (chunk: string) => {
+    stderr = (stderr + chunk).slice(-MAX_STDERR_CHARS);
+  });
+  const handleLine = async (line: string) => {
+    if (failure || terminal || !line.trim()) return;
+    if (Buffer.byteLength(line) > MAX_LINE_BYTES) {
+      throw new Error(`stdout line exceeded ${MAX_LINE_BYTES} bytes`);
+    }
+    const parsed = options.parse(line);
+    if (!parsed) return;
+    const events = Array.isArray(parsed) ? parsed : [parsed];
+    if (events.length === 0) return;
+    bumpIdle();
+    for (const event of events) {
+      if (event.tag === "ready" || event.tag === "progress") await options.onEvent(event);
+      else {
+        terminal = event;
+        break;
+      }
+    }
+  };
+  managed.child.stdout.setEncoding("utf8");
+  const readOutput = async () => {
+    let pending = "";
+    try {
+      for await (const chunk of managed.child.stdout) {
+        pending += chunk;
+        let newline = pending.indexOf("\n");
+        while (newline !== -1) {
+          const line = pending.slice(0, newline);
+          pending = pending.slice(newline + 1);
+          await handleLine(line);
+          newline = pending.indexOf("\n");
+        }
+        if (Buffer.byteLength(pending) > MAX_LINE_BYTES) {
+          throw new Error(`stdout line exceeded ${MAX_LINE_BYTES} bytes`);
+        }
+      }
+      if (pending) await handleLine(pending);
+    } catch (error) {
+      fail(error instanceof Error ? error : new Error(String(error)));
+    }
+  };
+  const output = readOutput();
+  managed.child.stdin.end(options.input);
+  try {
+    await managed.spawned;
+    const result = await managed.exited;
+    await output;
+    if (failure) throw failure;
+    if (options.signal.aborted) throw new Error("Claude turn aborted");
+    if (result.signal) throw new Error(`claude exited from signal ${result.signal}`);
+    if (result.exitCode !== 0 && terminal?.tag !== "error") {
+      throw new Error(`claude exited ${result.exitCode}`);
+    }
+    return terminal;
+  } finally {
+    clearTimers();
+    await managed.terminate();
+    await output;
+    if (stderr.trim()) process.stderr.write(`[claude-code] ${stderr.trimEnd()}\n`);
+  }
+};