@bivy/bivy 0.10.1-staging.283 → 0.10.1-staging.285

package/bin/bivy.mjs

@@ -922,9 +922,10 @@ async function resolveRunSpec(agentId, extraArgs) {
   return { spec: { agent: id, label: agent.label, command, args: [...(agent.args ?? []), ...extraArgs] } };
 }
 
-// Pull bivy's own `--name`/`--model` flags (space or `=` form) out of the run
-// args so they aren't blindly forwarded. Only honored before a `--` separator,
-// past which everything is the raw command the user asked to run.
+// Pull bivy's own run flags out of the args so they aren't blindly forwarded.
+// Only honored before a `--` separator, past which everything is the raw command
+// the user asked to run. `--chat` selects the governed app-session path instead
+// of the native PTY path; `--no-open` keeps that path headless after creation.
 // Does a token look like a git remote (URL, scp-style, owner/repo, or a path)
 // rather than an agent id? Lets `--clone <remote>` disambiguate from bare
 // `--clone` (= current folder's repo) without a required `=`.
@@ -936,10 +937,14 @@ function looksLikeRemote(value) {
 function extractRunFlags(args) {
   const rest = [];
   let name, model, node, workspace;
+  let chat = false;
+  let noOpen = false;
   let clone; // undefined = no clone; true = current repo; string = explicit remote
   for (let i = 0; i < args.length; i++) {
     const a = args[i];
     if (a === "--") { rest.push(...args.slice(i)); break; }
+    if (a === "--chat") { chat = true; continue; }
+    if (a === "--no-open") { noOpen = true; continue; }
     if (a === "--name" && args[i + 1] !== undefined) { name = args[++i]; continue; }
     if (a.startsWith("--name=")) { name = a.slice("--name=".length); continue; }
     if (a === "--model" && args[i + 1] !== undefined) { model = args[++i]; continue; }
@@ -952,7 +957,7 @@ function extractRunFlags(args) {
     if (a === "--clone") { clone = looksLikeRemote(args[i + 1]) ? args[++i] : true; continue; }
     rest.push(a);
   }
-  return { name: name?.trim() || undefined, model: model?.trim() || undefined, node: node?.trim() || undefined, workspace: workspace?.trim() || undefined, clone, rest };
+  return { name: name?.trim() || undefined, model: model?.trim() || undefined, node: node?.trim() || undefined, workspace: workspace?.trim() || undefined, chat, noOpen, clone, rest };
 }
 
 // A safe-ish workspace dir name from a remote or path (basename minus .git).
@@ -1793,12 +1798,67 @@ complete -c bivy -n '__fish_seen_subcommand_from run' -a '${agents.join(" ")}'`)
 // flag on top of it.
 async function cmdRun(args = []) {
   if (!(await ensureDeps())) process.exit(1);
-  const { name, model, node, workspace, clone, rest } = extractRunFlags(args);
+  const { name, model, node, workspace, chat, noOpen, clone, rest } = extractRunFlags(args);
   // Bare `bivy` (empty rest) resolves to the configured default agent; an
   // explicit `bivy run <agent>` keeps that agent verbatim.
   const [agentIdArg, ...extraArgs] = rest;
   const agentId = agentIdArg || resolveDefaultAgent();
 
+  if (chat) {
+    if (node) {
+      console.error(c.red("--chat currently starts a governed session on this node; it can't be combined with --node."));
+      process.exit(1);
+      return;
+    }
+    if (agentId === "--" || extraArgs.length) {
+      console.error(c.red("--chat starts a governed agent integration and does not accept native agent arguments or the raw '-- <command>' form."));
+      process.exit(1);
+      return;
+    }
+    let requestedWorkspace;
+    try { requestedWorkspace = resolveWorkspaceDir({ clone, workspace }); }
+    catch (error) { console.error(c.red(error?.message || String(error))); process.exit(1); return; }
+    const config = loadConfig();
+    // Preserve `bivy run`'s cwd contract: from inside a git checkout, a chat run
+    // targets that checkout; elsewhere it uses the node's configured workspace.
+    const sessionWorkspace = requestedWorkspace || defaultRunWorkspace(config);
+    if (!(await ensureNodeRunning(config))) {
+      console.error(c.red(`Could not start the Bivy node at ${url(config)}.`));
+      process.exit(1);
+      return;
+    }
+    try {
+      const created = await localApi(config, "/api/session", {
+        method: "POST",
+        body: JSON.stringify({ agent: agentId, ...(model ? { model: { provider: "", id: model } } : {}), ...(sessionWorkspace ? { workspace: sessionWorkspace } : {}) }),
+      });
+      if (name) {
+        await localApi(config, "/api/sessions/rename", {
+          method: "POST",
+          body: JSON.stringify({ sessionId: created.id, name }),
+        });
+      }
+      const sessionPath = `/sessions/${encodeURIComponent(created.id)}`;
+      const remote = await openRemoteApp({ open: !noOpen, remotePath: sessionPath });
+      console.log(c.green(`Started chat session ${created.id} (${created.agentName || created.runtimeId || agentId}).`));
+      if (remote && (noOpen || !canOpenBrowser())) console.log(`Open it in the Bivy app: ${c.cyan(remote.openUrl)}`);
+      else if (!remote) {
+        console.log(c.yellow("Remote app access is not configured on this node."));
+        console.log(`Run ${c.cyan("bivy relay:setup")}, then open session ${c.cyan(created.id)} in the app.`);
+      }
+      return;
+    } catch (error) {
+      console.error(c.red(`Could not start chat session: ${error?.message || String(error)}`));
+      process.exit(1);
+      return;
+    }
+  }
+  if (noOpen) {
+    console.error(c.red("--no-open is only valid together with --chat."));
+    process.exit(1);
+    return;
+  }
+
   // A cloned/explicit workspace lives on THIS machine, so it only applies to the
   // local node. For a remote --node run the checkout would need to be made there.
   if (node && (clone !== undefined || workspace)) {
@@ -4573,9 +4633,10 @@ async function main() {
       // args (including its own --help) pass straight through to it — e.g.
       // 'bivy run claude --help' must show Claude's help, not bivy's.
       if (args[0] === "-h" || args[0] === "--help") {
-        console.log(`Usage: bivy run <agent> [--name <label>] [--model <model>] [--node <name>] [--clone [remote]] [--workspace <dir>] | -- <command>
+        console.log(`Usage: bivy run <agent> [--chat [--no-open]] [--name <label>] [--model <model>] [--node <name>] [--clone [remote]] [--workspace <dir>] | -- <command>
 
 Run a native agent (real CLI/TUI) as a relay-visible session.
+Use --chat to start the governed session used by the app instead; --no-open prints its URL without launching a browser.
 Agents: ${[...AGENT_INTEGRATIONS.keys()].join(", ")}, or -- <command> for anything else.
 An agent's own --help passes through, e.g. 'bivy run claude --help'.`);
         break;

package/bin/codex-app-server-shim.mjs

@@ -372,8 +372,30 @@ function onNotification(m) {
       else turnCompletionTimer = setTimeout(finishCompletedTurn, 500);
       return;
     }
-    case "turn/failed":
+    case "turn/failed": {
+      // A failed turn is TERMINAL in the app-server — no `turn/completed` follows
+      // it — so end the turn here rather than merely stashing the error for a
+      // completion event that never arrives. Stashing (the old behavior) left the
+      // turn open on the Bivy side: ProtocolRuntime never saw session.done/error,
+      // never emitted agent_end, and the daemon pinned the session "working" until
+      // the stall watchdog force-recovered it minutes later (the "Codex gets stuck,
+      // I have to prompt it again" symptom). session.error makes ProtocolRuntime
+      // emit agent_end, settling the turn immediately.
+      const message = params?.error?.message || params?.message || "Codex turn failed";
+      pendingTurnCompletion = false;
+      if (turnCompletionTimer) clearTimeout(turnCompletionTimer);
+      turnCompletionTimer = null;
+      activeObservedItems.clear();
+      bivy({ type: "session.status", status: "idle" });
+      bivy({ type: "session.error", error: message });
+      sawError = null;
+      return;
+    }
     case "error":
+      // A non-turn-scoped error notification (e.g. transient reconnect noise, per
+      // the codex exec parser's read of this event). Stash it so a following
+      // turn/completed surfaces it; a genuinely turn-ending failure arrives as
+      // turn/failed above, which never leaves the turn open.
       sawError = params?.error?.message || params?.message || "Codex turn failed";
       return;
     default:

package/dist/server.js

@@ -43,6 +43,7 @@ import { decideOAuthLoginSweep } from "./runtime/oauth/oauth-login-sweep.js";
 import { listCodexSessions, loadCodexTranscript } from "./runtime/codex-sessions.js";
 import { dedupeSessionSummaries } from "./session-identity.js";
 import { deriveSessionState } from "./session/session-state.js";
+import { resolveStreamingBehavior } from "./session/record.js";
 import { createSessionEngine } from "./session/engine.js";
 import { exportProviderAuth, exportAccountApiKeys, exportSyncableProviderAuth, exportProviderAuthTombstones, importProviderAuth, removeProvider, setProviderApiKey, listCredentialRecords, setProviderApiKeyLabeled, setProviderReferenceLabeled, removeProviderCredential, setCredentialSync, getCredentialPresets, setActiveCredentialPreset, setCredentialPresetMapping, exportSyncableRecords, exportRecordTombstones, importCredentialRecords } from "./credentials/api.js";
 import { listProviders } from "./runtime/provider-catalog.js";
@@ -888,7 +889,14 @@ function streamingBehaviorFrom(value) {
     return value === "steer" || value === "followUp" ? value : undefined;
 }
 function promptOptionsFor(record, requested, images) {
-    const streamingBehavior = streamingBehaviorFrom(requested) ?? (record.session.isStreaming ? "steer" : undefined);
+    // Default to steering only when a turn is genuinely in flight — judged from
+    // Bivy's own `isWorking` AND the runtime's `isStreaming`, not `isStreaming`
+    // alone (which can be stuck-true after a turn ends and would silently steer a
+    // fresh message into a dead turn). See resolveStreamingBehavior.
+    const streamingBehavior = resolveStreamingBehavior(streamingBehaviorFrom(requested), {
+        isWorking: record.isWorking,
+        isStreaming: record.session.isStreaming,
+    });
     return { ...(streamingBehavior ? { streamingBehavior } : {}), ...(images?.length ? { images } : {}) };
 }
 function promptForAgent(_record, promptText) {

package/dist/session/record.js

@@ -1 +1,18 @@
-export {};
+/**
+ * Resolve the streamingBehavior for a prompt when the client didn't request one.
+ * A prompt sent while a turn is genuinely in flight defaults to *steering* it
+ * (inject guidance into the running turn); otherwise it starts a fresh turn.
+ *
+ * "In flight" is judged from BOTH Bivy's own authoritative turn flag (`isWorking`,
+ * set on the first turn event and cleared on `agent_end`) AND the runtime's
+ * `isStreaming` — never `isStreaming` alone. `isStreaming` is the SDK/runtime's
+ * bit and can be stuck-true after a turn has actually ended. When it is,
+ * defaulting to "steer" injects the user's message into a turn that no longer
+ * exists, so it silently vanishes and the session looks wedged. Requiring both
+ * flags means a message to an already-ended turn starts a fresh turn instead.
+ */
+export function resolveStreamingBehavior(requested, turn) {
+    if (requested)
+        return requested;
+    return turn.isWorking && turn.isStreaming ? "steer" : undefined;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bivy/bivy",
-  "version": "0.10.1-staging.283",
+  "version": "0.10.1-staging.285",
   "type": "module",
   "license": "AGPL-3.0-only",
   "description": "Run coding agents on machines you own. Open-source, self-hostable agent workspace.",