@integrity-labs/agt-cli 0.28.387 → 0.28.388

package/dist/bin/agt.js

@@ -40,7 +40,7 @@ import {
   success,
   table,
   warn
-} from "../chunk-ZNFB4AKQ.js";
+} from "../chunk-3TKW2SSS.js";
 import {
   AnchorSessionClient,
   CHANNEL_REGISTRY,
@@ -70,7 +70,7 @@ import {
   renderTemplate,
   resolveChannels,
   serializeManifestForSlackCli
-} from "../chunk-LAO2CUZU.js";
+} from "../chunk-IJF4W6LC.js";
 import "../chunk-XWVM4KPK.js";
 
 // src/bin/agt.ts
@@ -4829,7 +4829,7 @@ import { execFileSync, execSync } from "child_process";
 import { existsSync as existsSync10, realpathSync as realpathSync2 } from "fs";
 import chalk18 from "chalk";
 import ora16 from "ora";
-var cliVersion = true ? "0.28.387" : "dev";
+var cliVersion = true ? "0.28.388" : "dev";
 async function fetchLatestVersion() {
   const host2 = getHost();
   if (!host2) return null;
@@ -6001,7 +6001,7 @@ function handleError(err) {
 }
 
 // src/bin/agt.ts
-var cliVersion2 = true ? "0.28.387" : "dev";
+var cliVersion2 = true ? "0.28.388" : "dev";
 var program = new Command();
 program.name("agt").description("Augmented CLI \u2014 agent provisioning and management").version(cliVersion2).option("--json", "Emit machine-readable JSON output (suppress spinners and colors)").option("--skip-update-check", "Skip the automatic update check on startup");
 program.hook("preAction", async (thisCommand, actionCommand) => {

package/dist/{chunk-ZNFB4AKQ.js → chunk-3TKW2SSS.js}

@@ -25,7 +25,7 @@ import {
   resolveConnectivityProbe,
   worseConnectivityOutcome,
   wrapScheduledTaskPrompt
-} from "./chunk-LAO2CUZU.js";
+} from "./chunk-IJF4W6LC.js";
 import {
   parsePsRows
 } from "./chunk-XWVM4KPK.js";
@@ -6184,7 +6184,7 @@ function requireHost() {
 }
 
 // src/lib/api-client.ts
-var agtCliVersion = true ? "0.28.387" : "dev";
+var agtCliVersion = true ? "0.28.388" : "dev";
 var lastConfigHash = null;
 function setConfigHash(hash) {
   lastConfigHash = hash && hash.length > 0 ? hash : null;
@@ -8638,4 +8638,4 @@ export {
   managerInstallSystemUnitCommand,
   managerUninstallSystemUnitCommand
 };
-//# sourceMappingURL=chunk-ZNFB4AKQ.js.map
+//# sourceMappingURL=chunk-3TKW2SSS.js.map

package/dist/{chunk-LAO2CUZU.js → chunk-IJF4W6LC.js}

@@ -9412,6 +9412,120 @@ function buildPart(p2, redact, maxPartChars) {
   return { kind: "other" };
 }
 
+// ../../packages/core/dist/provisioning/frameworks/opencode/opencode-run.js
+var OpencodeRunError = class extends Error {
+  admitted;
+  constructor(message, admitted, options) {
+    super(message, options);
+    this.name = "OpencodeRunError";
+    this.admitted = admitted;
+  }
+};
+function runCrossedAdmission(stdout) {
+  for (const line2 of stdout.split("\n")) {
+    const trimmed = line2.trim();
+    if (!trimmed)
+      continue;
+    try {
+      JSON.parse(trimmed);
+      return true;
+    } catch {
+    }
+  }
+  return false;
+}
+function buildOpencodeRunArgs(params, opts = {}) {
+  const args = [
+    "run",
+    "--attach",
+    params.serveUrl,
+    "--dir",
+    params.projectDir,
+    "--session",
+    params.sessionID,
+    "--format",
+    "json"
+  ];
+  if (opts.includePasswordArg && params.password) {
+    args.push("-p", params.password);
+  }
+  if (params.model) {
+    args.push("--model", `${params.model.providerID}/${params.model.id}`);
+  }
+  if (params.agent) {
+    args.push("--agent", params.agent);
+  }
+  args.push(params.text);
+  return args;
+}
+function parseOpencodeRunReply(stdout) {
+  const parts = [];
+  for (const line2 of stdout.split("\n")) {
+    const trimmed = line2.trim();
+    if (!trimmed)
+      continue;
+    let evt;
+    try {
+      evt = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    const e = evt;
+    if (e?.type === "text" && e.part && e.part.type === "text" && typeof e.part.text === "string") {
+      parts.push(e.part.text);
+    }
+  }
+  const reply = parts.join("").trim();
+  return reply.length > 0 ? reply : null;
+}
+function parseOpencodeRunError(stdout) {
+  for (const line2 of stdout.split("\n")) {
+    const trimmed = line2.trim();
+    if (!trimmed)
+      continue;
+    let evt;
+    try {
+      evt = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    const e = evt;
+    if (e?.type === "error") {
+      const msg = e.error?.data?.message;
+      if (typeof msg === "string" && msg.length > 0)
+        return msg;
+      const name = e.error?.name;
+      if (typeof name === "string" && name.length > 0)
+        return name;
+      return "opencode run reported an error event";
+    }
+  }
+  return null;
+}
+function parseRunToolCalls(stdout) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const line2 of stdout.split("\n")) {
+    const trimmed = line2.trim();
+    if (!trimmed)
+      continue;
+    let evt;
+    try {
+      evt = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    const e = evt;
+    if (e.part && e.part.type === "tool" && typeof e.part.tool === "string") {
+      if (!seen.has(e.part.tool)) {
+        seen.add(e.part.tool);
+        out.push(e.part.tool);
+      }
+    }
+  }
+  return out;
+}
+
 // ../../packages/core/dist/provisioning/frameworks/opencode/inbound-bridge.js
 var InboundError = class extends Error {
   /** True once `prompt()` has durably admitted the turn. Retry is unsafe. */
@@ -9446,6 +9560,7 @@ var OpencodeInboundBridge = class {
   sessionDefaults;
   delivery;
   awaitReply;
+  runTurn;
   /** conversationKey → sessionID (one session per thread/DM). */
   sessions = /* @__PURE__ */ new Map();
   /** conversationKey → in-flight createSession, so concurrent inbound for the
@@ -9457,6 +9572,10 @@ var OpencodeInboundBridge = class {
     this.sessionDefaults = opts.sessionDefaults;
     this.delivery = opts.delivery ?? "queue";
     this.awaitReply = opts.awaitReply ?? true;
+    this.runTurn = opts.runTurn;
+    if (this.runTurn && this.delivery === "steer") {
+      console.warn("[opencode-bridge] delivery:'steer' is ignored when runTurn is set - opencode run cannot steer an in-flight turn; falling back to queue semantics.");
+    }
   }
   /** Resolve (creating on first use) the opencode session for a conversation. */
   async ensureSession(conversationKey) {
@@ -9506,6 +9625,24 @@ var OpencodeInboundBridge = class {
         cause: err
       });
     }
+    if (this.runTurn) {
+      const runner = this.runTurn;
+      const framed = frameInboundPrompt(msg);
+      const model = this.sessionDefaults?.model ?? null;
+      if (!awaitReply) {
+        void runner({ sessionID, text: framed, model }).catch((err) => {
+          console.error(`[opencode-bridge] fire-and-forget run turn failed for session ${sessionID}:`, err instanceof Error ? err.name : typeof err);
+        });
+        return { status: "admitted", sessionID, admittedSeq: 0 };
+      }
+      try {
+        const { admittedSeq: seq, reply } = await runner({ sessionID, text: framed, model });
+        return { status: "replied", sessionID, admittedSeq: seq, reply };
+      } catch (err) {
+        const admitted = err instanceof OpencodeRunError ? err.admitted : false;
+        throw new InboundError(admitted ? "opencode run turn failed after admission (not retried; avoids duplicate)" : "opencode run turn failed before admission (treated as retryable)", { admitted, sessionID, cause: err });
+      }
+    }
     let admittedSeq;
     try {
       ({ admittedSeq } = await this.client.prompt({
@@ -9982,6 +10119,7 @@ async function execFilePromiseLong(cmd, args, opts) {
 
 // src/lib/opencode-session.ts
 var OPENCODE_BIN = process.env["AGT_OPENCODE_BIN"]?.trim() || "opencode";
+var OPENCODE_RUN_TIMEOUT_MS = Number(process.env["AGT_OPENCODE_RUN_TIMEOUT_MS"]) || 18e4;
 var sessions = /* @__PURE__ */ new Map();
 var bridges = /* @__PURE__ */ new Map();
 function opencodeTmuxSession(codeName) {
@@ -10181,7 +10319,8 @@ async function startOpencodeSession(config) {
       port: null,
       password: null,
       lastFailureTail: "opencode isolation not implemented (ADR-0047)",
-      model: null
+      model: null,
+      projectDir: config.projectDir
     };
     sessions.set(codeName, blocked);
     return blocked;
@@ -10197,7 +10336,9 @@ async function startOpencodeSession(config) {
     // ENG-7931: parse the resolved model from the provisioned opencode.json
     // (config.projectDir IS the provision dir the serve reads) so the bridge can
     // pass it explicitly on session-create + prompt.
-    model: readOpencodeModelFromConfigDir(config.projectDir)
+    model: readOpencodeModelFromConfigDir(config.projectDir),
+    // ENG-8032: retained so getBridge can drive turns via `opencode run --dir`.
+    projectDir: config.projectDir
   };
   sessions.set(codeName, session);
   try {
@@ -10315,13 +10456,74 @@ function getBridge(codeName, port, password) {
   if (cached && cached.port === port && cached.password === password) return cached.bridge;
   const client = new HttpOpencodeClient({ baseUrl: baseUrlFor(port), password });
   const model = sessions.get(codeName)?.model ?? null;
+  const projectDir = sessions.get(codeName)?.projectDir ?? null;
   const bridge = new OpencodeInboundBridge({
     client,
-    sessionDefaults: model ? { model } : void 0
+    sessionDefaults: model ? { model } : void 0,
+    runTurn: projectDir ? makeRunTurn(codeName, port, password, projectDir) : void 0
   });
   bridges.set(codeName, { port, password, bridge });
   return bridge;
 }
+function makeRunTurn(codeName, port, password, projectDir) {
+  return ({ sessionID, text, model }) => new Promise((resolve, reject) => {
+    const args = buildOpencodeRunArgs({
+      bin: OPENCODE_BIN,
+      serveUrl: baseUrlFor(port),
+      projectDir,
+      password,
+      sessionID,
+      text,
+      model: model ?? null
+    });
+    const child = spawn(OPENCODE_BIN, args, {
+      cwd: projectDir,
+      // Password off argv (would show in `ps`); it rides the env instead.
+      env: { ...process.env, OPENCODE_SERVER_PASSWORD: password },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const finish = (fn) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      fn();
+    };
+    const fail = (message, cause) => reject(new OpencodeRunError(message, runCrossedAdmission(stdout), { cause }));
+    const timer = setTimeout(() => {
+      finish(() => {
+        try {
+          child.kill("SIGKILL");
+        } catch {
+        }
+        fail(`opencode run timed out after ${OPENCODE_RUN_TIMEOUT_MS}ms`);
+      });
+    }, OPENCODE_RUN_TIMEOUT_MS);
+    child.stdout.on("data", (d) => {
+      stdout += d.toString();
+    });
+    child.stderr.on("data", (d) => {
+      stderr += d.toString();
+    });
+    child.on("error", (err) => finish(() => fail(`opencode run spawn failed: ${err instanceof Error ? err.message : err}`, err)));
+    child.on("close", (code) => finish(() => {
+      const runError = parseOpencodeRunError(stdout);
+      if (code !== 0 || runError) {
+        const tail = runError ?? (stderr.trim() || stdout.trim()).slice(-500);
+        fail(`opencode run failed (exit ${code ?? "null"}): ${tail}`);
+        return;
+      }
+      const reply = parseOpencodeRunReply(stdout);
+      const tools = parseRunToolCalls(stdout);
+      if (tools.length > 0) {
+        console.error(`[opencode-run] ${codeName} tools: ${tools.join(", ")}`);
+      }
+      resolve({ admittedSeq: 0, reply });
+    }));
+  });
+}
 function stopOpencodeSession(codeName, log2) {
   const tmuxSession = opencodeTmuxSession(codeName);
   try {
@@ -12175,4 +12377,4 @@ export {
   stopAllSessionsAndWait,
   getProjectDir
 };
-//# sourceMappingURL=chunk-LAO2CUZU.js.map
+//# sourceMappingURL=chunk-IJF4W6LC.js.map