indusagi-coding-agent 0.2.13 → 0.2.14

package/dist/review-agent.js

@@ -442,6 +442,56 @@ import { Agent } from "indusagi/agent";
 import { createZeroUsage as createZeroUsage2 } from "indusagi/ai";
 import * as path2 from "node:path";
 
+// src/kit/run-shell.ts
+import { spawn } from "node:child_process";
+function runShell(command, cwd, signal) {
+  if (signal?.aborted) return Promise.resolve({ output: "Command cancelled.", exitCode: 130 });
+  return new Promise((resolve3) => {
+    let output = "", truncated = false, settled = false;
+    let forceKill;
+    const child = spawn(command, { cwd, shell: true, detached: process.platform !== "win32" });
+    const capture = (chunk) => {
+      output += String(chunk);
+      if (output.length > 1024 * 1024) {
+        output = output.slice(-1024 * 1024);
+        truncated = true;
+      }
+    };
+    const kill = (signalName) => {
+      try {
+        if (process.platform !== "win32" && child.pid) process.kill(-child.pid, signalName);
+        else child.kill(signalName);
+      } catch {
+        try {
+          child.kill(signalName);
+        } catch {
+        }
+      }
+    };
+    const abort = () => {
+      kill("SIGTERM");
+      forceKill = setTimeout(() => kill("SIGKILL"), 1e3);
+      forceKill.unref();
+    };
+    const finish = (exitCode) => {
+      if (settled) return;
+      settled = true;
+      signal?.removeEventListener("abort", abort);
+      if (forceKill) clearTimeout(forceKill);
+      resolve3({ output: (truncated ? "[older output truncated]\n" : "") + output, exitCode: signal?.aborted ? 130 : exitCode });
+    };
+    child.stdout?.on("data", capture);
+    child.stderr?.on("data", capture);
+    child.once("error", (error) => {
+      capture(error.message);
+      finish(1);
+    });
+    child.once("close", (code) => finish(code ?? 1));
+    signal?.addEventListener("abort", abort, { once: true });
+    if (signal?.aborted) abort();
+  });
+}
+
 // src/conductor/catalog/catalog.ts
 import { z } from "zod";
 import { getModels, getProviders, modelRegistry } from "indusagi/ai";
@@ -473,7 +523,74 @@ var GPT_6_ASTRA_BASE = {
     }
   }
 };
+var GPT_6_SOL_BASE = {
+  id: "gpt-6-sol",
+  name: "GPT-6 Sol",
+  api: "openai-responses",
+  reasoning: true,
+  reasoningEfforts: ["high"],
+  input: ["text", "image"],
+  cost: {
+    input: 10,
+    cacheRead: 1,
+    cacheWrite: 12.5,
+    output: 50
+  },
+  contextWindow: 105e4,
+  maxTokens: 128e3,
+  longContextPricing: {
+    threshold: 272e3,
+    multipliers: {
+      input: 2,
+      cacheRead: 2,
+      cacheWrite: 2,
+      output: 1.5
+    }
+  }
+};
+var GPT_6_LUNA_BASE = {
+  id: "gpt-6-luna",
+  name: "GPT-6 Luna",
+  api: "openai-responses",
+  reasoning: true,
+  reasoningEfforts: ["low", "medium", "high", "xhigh", "max"],
+  input: ["text", "image"],
+  cost: {
+    input: 0.1,
+    cacheRead: 0.01,
+    cacheWrite: 0.125,
+    output: 0.5
+  },
+  contextWindow: 105e4,
+  maxTokens: 128e3,
+  longContextPricing: {
+    threshold: 272e3,
+    multipliers: { input: 2, cacheRead: 2, cacheWrite: 2, output: 1.5 }
+  }
+};
 var CODING_AGENT_MODELS = [
+  {
+    ...GPT_6_SOL_BASE,
+    provider: "openai",
+    baseUrl: "https://api.openai.com/v1"
+  },
+  {
+    ...GPT_6_SOL_BASE,
+    api: "openai-codex-responses",
+    provider: "openai-codex",
+    baseUrl: "https://chatgpt.com/backend-api"
+  },
+  {
+    ...GPT_6_LUNA_BASE,
+    provider: "openai",
+    baseUrl: "https://api.openai.com/v1"
+  },
+  {
+    ...GPT_6_LUNA_BASE,
+    api: "openai-codex-responses",
+    provider: "openai-codex",
+    baseUrl: "https://chatgpt.com/backend-api"
+  },
   {
     ...GPT_6_ASTRA_BASE,
     provider: "openai",
@@ -509,8 +626,15 @@ function applyCodingAgentModelOverlay(registry) {
   return registry;
 }
 function isReasoningEffortSupported(modelId, effort) {
-  if (modelId?.split("/").at(-1) !== "gpt-6-astra") return true;
-  return GPT_6_ASTRA_BASE.reasoningEfforts.includes(effort);
+  const id = modelId?.split("/").at(-1);
+  if (id === "gpt-6-astra") {
+    return GPT_6_ASTRA_BASE.reasoningEfforts.includes(effort);
+  }
+  if (id === "gpt-6-sol") return effort === "high";
+  if (id === "gpt-6-luna") {
+    return GPT_6_LUNA_BASE.reasoningEfforts.includes(effort);
+  }
+  return true;
 }
 
 // src/conductor/catalog/catalog.ts
@@ -917,6 +1041,125 @@ function parseSessionText(sessionId, text) {
   };
 }
 
+// src/security/private-state.ts
+import {
+  chmodSync,
+  closeSync,
+  constants,
+  fchmodSync,
+  fstatSync,
+  lstatSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync
+} from "node:fs";
+import { randomUUID } from "node:crypto";
+import { dirname } from "node:path";
+var PRIVATE_DIRECTORY_MODE = 448;
+var PRIVATE_FILE_MODE = 384;
+var NO_FOLLOW = constants.O_NOFOLLOW ?? 0;
+function isPosix() {
+  return process.platform !== "win32";
+}
+function assertOwned(uid, path3) {
+  if (!isPosix() || process.getuid === void 0) return;
+  if (uid !== process.getuid()) {
+    throw new Error(`Refusing sensitive path not owned by the current user: ${path3}`);
+  }
+}
+function ensurePrivateDirectorySync(path3) {
+  try {
+    const current = lstatSync(path3);
+    if (current.isSymbolicLink() || !current.isDirectory()) {
+      throw new Error(`Refusing non-directory sensitive state path: ${path3}`);
+    }
+    assertOwned(current.uid, path3);
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+    mkdirSync(path3, { recursive: true, mode: PRIVATE_DIRECTORY_MODE });
+  }
+  if (isPosix()) chmodSync(path3, PRIVATE_DIRECTORY_MODE);
+}
+function validateExistingFile(path3) {
+  try {
+    const current = lstatSync(path3);
+    if (current.isSymbolicLink() || !current.isFile()) {
+      throw new Error(`Refusing non-regular sensitive file: ${path3}`);
+    }
+    assertOwned(current.uid, path3);
+  } catch (error) {
+    if (error.code === "ENOENT") return;
+    throw error;
+  }
+}
+function readPrivateFileSync(path3) {
+  ensurePrivateDirectorySync(dirname(path3));
+  try {
+    validateExistingFile(path3);
+    const fd = openSync(path3, constants.O_RDONLY | NO_FOLLOW);
+    try {
+      const current = fstatSync(fd);
+      if (!current.isFile()) throw new Error(`Refusing non-regular sensitive file: ${path3}`);
+      assertOwned(current.uid, path3);
+      if (isPosix()) fchmodSync(fd, PRIVATE_FILE_MODE);
+      return readFileSync(fd, "utf8");
+    } finally {
+      closeSync(fd);
+    }
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+}
+function atomicWritePrivateFileSync(path3, content) {
+  const parent = dirname(path3);
+  ensurePrivateDirectorySync(parent);
+  validateExistingFile(path3);
+  const temporary = `${path3}.tmp-${process.pid}-${randomUUID()}`;
+  let fd;
+  try {
+    fd = openSync(
+      temporary,
+      constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | NO_FOLLOW,
+      PRIVATE_FILE_MODE
+    );
+    writeFileSync(fd, content, "utf8");
+    if (isPosix()) fchmodSync(fd, PRIVATE_FILE_MODE);
+    closeSync(fd);
+    fd = void 0;
+    renameSync(temporary, path3);
+    if (isPosix()) chmodSync(path3, PRIVATE_FILE_MODE);
+  } catch (error) {
+    if (fd !== void 0) closeSync(fd);
+    try {
+      rmSync(temporary, { force: true });
+    } catch {
+    }
+    throw error;
+  }
+}
+function appendPrivateFileSync(path3, content) {
+  ensurePrivateDirectorySync(dirname(path3));
+  validateExistingFile(path3);
+  const fd = openSync(
+    path3,
+    constants.O_WRONLY | constants.O_APPEND | constants.O_CREAT | NO_FOLLOW,
+    PRIVATE_FILE_MODE
+  );
+  try {
+    const current = fstatSync(fd);
+    if (!current.isFile()) throw new Error(`Refusing non-regular sensitive file: ${path3}`);
+    assertOwned(current.uid, path3);
+    if (isPosix()) fchmodSync(fd, PRIVATE_FILE_MODE);
+    writeFileSync(fd, content, "utf8");
+  } finally {
+    closeSync(fd);
+  }
+}
+
 // src/conductor/transcript-store/store.ts
 function memoryBackend() {
   const files = /* @__PURE__ */ new Map();
@@ -944,24 +1187,15 @@ function fsBackend(dir) {
   return {
     locate: (sessionId) => `${dir}/${sessionId}.ndjson`,
     read: async (sessionId) => {
-      const fs = await import("node:fs/promises");
-      try {
-        return await fs.readFile(await fileOf(sessionId), "utf8");
-      } catch {
-        return null;
-      }
+      return readPrivateFileSync(await fileOf(sessionId));
     },
     append: async (sessionId, line) => {
-      const fs = await import("node:fs/promises");
-      await fs.mkdir(dir, { recursive: true });
-      await fs.appendFile(await fileOf(sessionId), `${line}
-`, "utf8");
+      appendPrivateFileSync(await fileOf(sessionId), `${line}
+`);
     },
     rewrite: async (sessionId, text) => {
-      const fs = await import("node:fs/promises");
-      await fs.mkdir(dir, { recursive: true });
-      await fs.writeFile(await fileOf(sessionId), text.length === 0 ? "" : `${text}
-`, "utf8");
+      atomicWritePrivateFileSync(await fileOf(sessionId), text.length === 0 ? "" : `${text}
+`);
     }
   };
 }
@@ -1479,7 +1713,7 @@ async function loadSpawn() {
     return void 0;
   }
 }
-function captureOutput(spawn2, bin, args, cwd, signal) {
+function captureOutput(spawn3, bin, args, cwd, signal) {
   return new Promise((resolve3) => {
     let settled = false;
     const finish = (value) => {
@@ -1490,7 +1724,7 @@ function captureOutput(spawn2, bin, args, cwd, signal) {
     };
     let child;
     try {
-      child = spawn2(bin, args, { cwd, shell: false });
+      child = spawn3(bin, args, { cwd, shell: false });
     } catch {
       finish();
       return;
@@ -1519,9 +1753,9 @@ function captureOutput(spawn2, bin, args, cwd, signal) {
   });
 }
 async function runTscDiagnostics(cwd, signal) {
-  const spawn2 = await loadSpawn();
-  if (!spawn2 || signal?.aborted) return [];
-  const output = await captureOutput(spawn2, path.join(cwd, "node_modules", ".bin", "tsc"), ["--noEmit", "--pretty", "false"], cwd, signal);
+  const spawn3 = await loadSpawn();
+  if (!spawn3 || signal?.aborted) return [];
+  const output = await captureOutput(spawn3, path.join(cwd, "node_modules", ".bin", "tsc"), ["--noEmit", "--pretty", "false"], cwd, signal);
   return output === void 0 ? [] : parseTscOutput(output, cwd);
 }
 function parseTscOutput(output, cwd) {
@@ -1541,9 +1775,9 @@ function parseTscOutput(output, cwd) {
 }
 async function runEslintDiagnostics(files, cwd, signal) {
   if (files.length === 0) return [];
-  const spawn2 = await loadSpawn();
-  if (!spawn2 || signal?.aborted) return [];
-  const output = await captureOutput(spawn2, path.join(cwd, "node_modules", ".bin", "eslint"), ["--format", "json", ...files], cwd, signal);
+  const spawn3 = await loadSpawn();
+  if (!spawn3 || signal?.aborted) return [];
+  const output = await captureOutput(spawn3, path.join(cwd, "node_modules", ".bin", "eslint"), ["--format", "json", ...files], cwd, signal);
   return output === void 0 ? [] : parseEslintOutput(output, cwd);
 }
 function parseEslintOutput(output, cwd) {
@@ -1808,6 +2042,8 @@ var SessionConductorImpl = class {
   #matcher;
   #state;
   #busy = false;
+  #activeWork;
+  #shellAbort;
   #draining = false;
   #queue = [];
   #boundModel;
@@ -1867,6 +2103,7 @@ var SessionConductorImpl = class {
   abort() {
     this.clearQueue();
     this.#condenseAbort?.abort();
+    this.#shellAbort?.abort();
     this.agent.abort();
     const fault = conductorFault("aborted", "turn aborted by caller");
     this.#dispatch({ type: "fault", fault });
@@ -1879,13 +2116,22 @@ var SessionConductorImpl = class {
       return this.#state;
     }
     this.#busy = true;
-    try {
-      await this.#runTurn(input);
-      await this.#drainQueue();
-      return this.#state;
-    } finally {
-      this.#busy = false;
-    }
+    const work = (async () => {
+      try {
+        await this.#runTurn(input);
+        await this.#drainQueue();
+        return this.#state;
+      } finally {
+        this.#busy = false;
+      }
+    })();
+    this.#activeWork = work;
+    return work;
+  }
+  async #stopWork() {
+    if (!this.#busy) return;
+    this.abort();
+    await this.#activeWork;
   }
   async #drainQueue() {
     if (this.#draining) return;
@@ -1974,8 +2220,16 @@ var SessionConductorImpl = class {
     }
     this.#applyModel(card);
   }
-  cycleModel(id) {
-    this.selectModel(id);
+  cycleModel(id, direction = 1) {
+    if (id.trim()) {
+      this.selectModel(id);
+      return;
+    }
+    const cards = this.availableModels();
+    if (!cards.length) return;
+    const at = cards.findIndex((card) => card.id === this.#state.modelId);
+    const index = at < 0 ? 0 : (at + direction + cards.length) % cards.length;
+    this.selectModel(cards[index].id);
   }
   #applyModel(card) {
     const model = withGatewayBaseUrl(card.model, this.#gatewayBaseUrls);
@@ -1990,28 +2244,36 @@ var SessionConductorImpl = class {
   registerTools(tools) {
     this.agent.setTools([...this.#deckTools, ...tools]);
   }
-  async condense() {
+  async condense(instructions) {
     if (this.#busy) return "busy";
     this.#busy = true;
     this.#condenseAbort = new AbortController();
-    try {
-      const result = await this.#runCondense(true, this.#condenseAbort.signal);
-      await this.#drainQueue();
-      return result;
-    } finally {
-      this.#busy = false;
-      this.#condenseAbort = void 0;
-    }
+    const work = (async () => {
+      try {
+        const result = await this.#runCondense(true, this.#condenseAbort.signal, instructions);
+        await this.#drainQueue();
+        return result;
+      } finally {
+        this.#busy = false;
+        this.#condenseAbort = void 0;
+      }
+    })();
+    this.#activeWork = work;
+    return work;
   }
   cancelCondense() {
     this.#condenseAbort?.abort();
   }
-  async #runCondense(force, signal) {
+  async #runCondense(force, signal, instructions) {
     const before = [...this.agent.state.messages];
     this.#dispatch({ type: "phase", phase: "condensing" });
     try {
-      const after = await (this.deps.condense ?? noopCondense)(before, { force, model: this.#boundModel, contextTokens: this.#state.contextTokens, signal });
-      if (signal?.aborted) return "cancelled";
+      const after = await (this.deps.condense ?? noopCondense)(before, { force, model: this.#boundModel, contextTokens: this.#state.contextTokens, signal, instructions });
+      if (signal?.aborted) {
+        this.#dispatch({ type: "settled" });
+        this.#hub.emit({ kind: "idle" });
+        return "cancelled";
+      }
       if (after.length >= before.length) {
         this.#dispatch({ type: "settled" });
         return "nothing";
@@ -2038,10 +2300,12 @@ var SessionConductorImpl = class {
   }
   async #move(id, message) {
     try {
+      await this.#stopWork();
       await this.store.branchAt(id);
       this.agent.replaceMessages(this.store.messages());
       this.#dispatch({ type: "head", head: this.store.head });
       this.#dispatch({ type: "settled" });
+      this.#hub.emit({ kind: "reset" });
       this.#hub.emit({ kind: "idle" });
     } catch (error) {
       const fault = conductorFault("persistence", message, error);
@@ -2056,18 +2320,33 @@ var SessionConductorImpl = class {
     return { canRestore: this.options.checkpoint?.hasSnapshot(id) ?? false };
   }
   async executeBash(command, opts = {}) {
-    const { spawn: spawn2 } = await import("node:child_process");
-    const outcome = await new Promise((resolve3) => {
-      const child = spawn2(command, { cwd: this.#workspace, shell: true });
-      let output = "";
-      child.stdout?.on("data", (chunk) => output += String(chunk));
-      child.stderr?.on("data", (chunk) => output += String(chunk));
-      child.on("error", (error) => resolve3({ output: output + errorText(error), exitCode: 1 }));
-      child.on("close", (code) => resolve3({ output, exitCode: code ?? 1 }));
-    });
-    if (!opts.excludeFromContext) await this.store.append({ role: "user", content: `$ ${command}
-${outcome.output}`.trimEnd(), timestamp: Date.now() }, "note");
-    return outcome;
+    if (this.#busy) throw new Error("A turn is running \u2014 stop it before running a shell command.");
+    this.#busy = true;
+    this.#shellAbort = new AbortController();
+    const signal = opts.signal ? AbortSignal.any([opts.signal, this.#shellAbort.signal]) : this.#shellAbort.signal;
+    const work = (async () => {
+      try {
+        this.#dispatch({ type: "phase", phase: "tooling" });
+        const outcome = await runShell(command, this.#workspace, signal);
+        if (!opts.excludeFromContext) {
+          const message = { role: "user", content: `$ ${command}
+${outcome.output}`.trimEnd(), timestamp: Date.now() };
+          const entry = await this.store.append(message, "note");
+          this.agent.replaceMessages([...this.agent.state.messages, message]);
+          this.#dispatch({ type: "head", head: this.store.head });
+          this.#hub.emit({ kind: "persisted", entryId: entry.id });
+        }
+        this.#dispatch({ type: "settled" });
+        this.#hub.emit({ kind: "idle" });
+        await this.#drainQueue();
+        return outcome;
+      } finally {
+        this.#busy = false;
+        this.#shellAbort = void 0;
+      }
+    })();
+    this.#activeWork = work;
+    return work;
   }
   stats() {
     const messages = this.agent.state.messages;
@@ -2137,6 +2416,7 @@ ${outcome.output}`.trimEnd(), timestamp: Date.now() }, "note");
     this.#sessionName = name;
   }
   async resume(id) {
+    await this.#stopWork();
     if (!await this.store.load(id)) {
       const fault = conductorFault("persistence", `no session "${id}" to resume`);
       this.#dispatch({ type: "fault", fault });
@@ -2145,19 +2425,23 @@ ${outcome.output}`.trimEnd(), timestamp: Date.now() }, "note");
     }
     this.agent.replaceMessages(this.store.messages());
     this.#state = { ...this.#state, head: this.store.head, usage: this.store.usage ?? createZeroUsage2(), phase: "idle" };
+    this.#hub.emit({ kind: "reset" });
     this.#hub.emit({ kind: "idle" });
   }
   async newSession() {
-    this.agent.abort();
+    await this.#stopWork();
     this.agent.replaceMessages([]);
     this.store.startNewSession(newSessionId());
     this.#queue.length = 0;
     this.#sessionName = void 0;
     this.#state = { phase: "idle", head: this.store.head, usage: createZeroUsage2(), contextTokens: 0, modelId: this.#state.modelId };
+    this.#hub.emit({ kind: "reset" });
     this.#hub.emit({ kind: "idle" });
   }
   #dispatch(action) {
+    const phase = this.#state.phase;
     this.#state = reduceState(this.#state, action);
+    if (phase !== this.#state.phase) this.#hub.emit({ kind: "phase", phase: this.#state.phase });
   }
 };
 
@@ -2260,7 +2544,7 @@ var todoCard = {
 };
 
 // src/capability-deck/cards/bg-process-card.ts
-import { spawn } from "node:child_process";
+import { spawn as spawn2 } from "node:child_process";
 import { Type as Type2 } from "@sinclair/typebox";
 var MAX_BUFFERED_LINES = 2e3;
 var DaemonTable = class {
@@ -2272,7 +2556,7 @@ var DaemonTable = class {
   }
   start(command) {
     const id = `bg-${this.nextSeq++}`;
-    const child = spawn(command, {
+    const child = spawn2(command, {
       cwd: this.cwd,
       shell: true,
       stdio: ["ignore", "pipe", "pipe"],