very-happy-cli 0.2.150 → 0.2.152

package/dist/{sessions-CpIdDhH7.cjs → sessions-Tad8elmy.cjs}

@@ -1,23 +1,24 @@
 'use strict';
 
 var chalk = require('chalk');
-var index = require('./index-K6mUS0jF.cjs');
-var index$1 = require('./types-D2Gkpe0N.cjs');
+var index = require('./index-ZIW1jrYm.cjs');
+var index$1 = require('./types-CN28qJl7.cjs');
 require('node:os');
 require('node:crypto');
-require('./limits-Dyma1REp.cjs');
+require('./limits-BNTWyUaZ.cjs');
 require('node:fs/promises');
 require('node:fs');
 require('node:path');
 require('zod');
 require('tweetnacl');
 require('node:util');
+require('@paralleldrive/cuid2');
 require('cross-spawn');
 require('node:readline');
 require('./projectPath-ChLhdOyt.cjs');
 require('path');
 require('url');
-require('./agentGuidance-Dla-BXO8.cjs');
+require('./agentGuidance-CqBn77AI.cjs');
 require('fs/promises');
 require('ink');
 require('react');
@@ -27,7 +28,6 @@ require('node:events');
 require('socket.io-client');
 require('os');
 require('child_process');
-require('@paralleldrive/cuid2');
 require('node:child_process');
 require('fs');
 require('@anthropic-ai/sandbox-runtime');
@@ -54,7 +54,7 @@ const ACTIONS_NEEDING_ID = /* @__PURE__ */ new Set(["read", "stop", "archive", "
 const ACTIONS_NEEDING_REQUEST_ID = /* @__PURE__ */ new Set(["approve", "deny"]);
 const REQUEST_ID_RE = /^[a-zA-Z0-9_.:-]{1,128}$/;
 function defaultOptions() {
-  return { action: "help", all: false, includeArchived: false, forSession: false, json: false };
+  return { action: "help", all: false, includeArchived: false, forSession: false, full: false, answer: false, wait: false, json: false };
 }
 function parseSessionsArgs(args) {
   const options = defaultOptions();
@@ -72,6 +72,18 @@ function parseSessionsArgs(args) {
       options.includeArchived = true;
     } else if (arg === "--for-session") {
       options.forSession = true;
+    } else if (arg === "--full") {
+      options.full = true;
+    } else if (arg === "--answer") {
+      options.answer = true;
+    } else if (arg === "--wait") {
+      options.wait = true;
+    } else if (arg === "--timeout") {
+      const value = args[++i];
+      if (value === void 0) throw new Error("--timeout requires a value");
+      const parsed = Number(value);
+      if (!Number.isFinite(parsed) || parsed <= 0) throw new Error("--timeout must be a positive number of seconds");
+      options.timeoutSec = parsed;
     } else if (arg === "--reason") {
       const value = args[++i];
       if (value === void 0) throw new Error("--reason requires a value");
@@ -124,6 +136,12 @@ function parseSessionsArgs(args) {
   }
   if (options.forSession && options.action !== "approve") throw new Error("--for-session only applies to `sessions approve`");
   if (options.reason !== void 0 && options.action !== "deny") throw new Error("--reason only applies to `sessions deny`");
+  if (options.action !== "read") {
+    if (options.full) throw new Error("--full only applies to `sessions read`");
+    if (options.answer) throw new Error("--answer only applies to `sessions read`");
+    if (options.wait) throw new Error("--wait only applies to `sessions read`");
+  }
+  if (options.timeoutSec !== void 0 && !options.wait) throw new Error("--timeout only applies to `sessions read --wait`");
   return options;
 }
 const SESSIONS_HELP = `
@@ -131,7 +149,8 @@ ${chalk.bold("very-happy sessions")} - Inspect and control sessions on this mach
 
 ${chalk.bold("Usage:")}
   very-happy sessions list [--all [--include-archived]] [--tag <name>] [--limit <n>] [--json]
-  very-happy sessions read <id> [--limit <n>] [--json]
+  very-happy sessions read <id> [--limit <n>] [--full] [--answer]
+                          [--wait [--timeout <s>]] [--json]
   very-happy sessions stop <id> [--json]
   very-happy sessions archive <id> [--json]
   very-happy sessions approve <id> <requestId> [--for-session] [--json]
@@ -143,7 +162,9 @@ ${chalk.bold("Actions:")}
              REST), attention first. Each row says whether this machine could
              decrypt it (\`decryptable\`); rows from other machines show only
              id / active / archived / timestamps / url.
-  read       The tail of a session as a role-tagged transcript.
+  read       The tail of a session as a role-tagged transcript, plus where
+             the latest turn stands (\`turn\` in --json: ended, status and
+             \`answer\` = the agent's reply to the latest prompt).
   stop       SIGTERM the session's process via the local daemon.
   archive    Mark the session inactive server-side (it stays resumable).
   approve    Answer a pending permission request \`requestId\` with approve \u2014
@@ -161,6 +182,14 @@ ${chalk.bold("Options:")}
   --limit <n>        list: how many NOT-running / not-attention sessions to
                      include (default ${index.DEFAULT_RECENT_LIMIT}; running and attention rows are
                      never cut). read: how many messages (default 20, max ${index.MAX_READ_LIMIT}).
+  --full             read only: do not truncate entries (default caps each
+                     line at 500 chars).
+  --answer           read only: print just the agent's reply to the latest
+                     prompt (the text after its last tool call), untruncated.
+  --wait             read only: block until the latest turn has ended
+                     (claude / codex / pi), then read. Pairs with
+                     \`spawn --prompt\` / \`send\` for "ask and collect".
+  --timeout <s>      read --wait only: give up after <s> seconds (default 600).
   --for-session      approve only: approved_for_session instead of approved.
   --reason <text>    deny only: reason forwarded to the wrapper.
   --json             Machine-readable output.
@@ -176,6 +205,8 @@ ${chalk.bold("Scope:")}
   the account content key \u2014 a credentials change, not a flag.
 
 ${chalk.bold("Exit codes:")}
+  2  read --wait: the turn had not ended when --timeout ran out (the
+     partial state is still printed)
   0  success (approve/deny: the wrapper acknowledged the verdict; check
      \`settled\` in --json to see whether the request has left the pending set)
   1  bad arguments, unknown session, no local key, request not pending,
@@ -263,15 +294,30 @@ async function handleSessionsCommand(args) {
     }
     const sessionId = options.sessionId;
     if (options.action === "read") {
-      const result = await index.readSessionTranscript(sessionId, options.limit ?? 20);
+      let timedOut = false;
+      if (options.wait) {
+        try {
+          await index.waitForTurnEnd(sessionId, { timeoutMs: (options.timeoutSec ?? 600) * 1e3 });
+        } catch (error) {
+          if (!(error instanceof index.TurnWaitTimeoutError)) throw error;
+          timedOut = true;
+          console.error(chalk.yellow("Timeout:"), error.message);
+        }
+      }
+      const result = await index.readSessionTranscript(sessionId, options.limit ?? 20, { full: options.full });
       if (options.json) {
-        console.log(JSON.stringify(result));
+        console.log(JSON.stringify(options.answer ? { sessionId, turn: result.turn } : result));
+      } else if (options.answer) {
+        if (result.turn.answer.length > 0) console.log(result.turn.answer);
+        else console.error(chalk.dim("(the agent has not replied to the latest prompt yet)"));
       } else {
         console.log(formatSummaryLine(result.summary));
         console.log(`--- last ${result.messageCount} message(s) ---`);
         console.log(result.transcript.length > 0 ? result.transcript : "(no readable conversation content in this range)");
+        const turn = result.turn;
+        console.log(chalk.dim(`--- latest turn: ${turn.ended ? `ended (${turn.status ?? "unknown"})` : "running"}${turn.error ? ` \u2014 ${turn.error}` : ""} ---`));
       }
-      process.exit(0);
+      process.exit(timedOut ? 2 : 0);
     }
     if (options.action === "stop") {
       const stopped = await index.stopSession(sessionId);

package/dist/{spawn-DQuOmUP7.mjs → spawn-BOlb5y1_.mjs}

@@ -1,14 +1,13 @@
 import chalk from 'chalk';
 import { readFileSync, statSync } from 'node:fs';
 import { resolve } from 'node:path';
-import { c as checkIfDaemonRunningAndCleanupStaleState, s as spawnDaemonSession } from './types-BD542hb1.mjs';
-import { s as sessionWebUrl, i as isValidSpawnOrigin, a as sanitizeSpawnPermissionMode, A as ALLOWED_SPAWN_PERMISSION_MODES, S as SPAWN_AGENTS, w as waitForSessionKey, b as sendUserMessage } from './index-CpNYvMTJ.mjs';
-import { l as logger } from './limits-FThmm7WR.mjs';
+import { f as forkSession, g as getProjectPath, F as ForkSourceMissingError, C as CodexAppServerClient, h as forkCodexThread, j as checkIfDaemonRunningAndCleanupStaleState, s as spawnDaemonSession, k as stopDaemonSession } from './types-xKrxbCRv.mjs';
+import { d as readPersistedSessions, l as logger } from './limits-CKR_HJnO.mjs';
+import { k as readSessionMetadata, m as resolveSpawnPermissionMode, e as sessionWebUrl, n as resolveFirstMessageMeta, o as isValidSpawnOrigin, i as sanitizeSpawnPermissionMode, A as ALLOWED_SPAWN_PERMISSION_MODES, S as SPAWN_AGENTS, u as waitForSessionKey, d as sendUserMessage } from './index-BauTv2jB.mjs';
 import 'axios';
 import 'node:events';
 import 'socket.io-client';
 import 'zod';
-import '@paralleldrive/cuid2';
 import 'node:crypto';
 import 'child_process';
 import 'util';
@@ -19,6 +18,7 @@ import 'cross-spawn';
 import './projectPath-CSpqWdxp.mjs';
 import 'url';
 import 'os';
+import '@paralleldrive/cuid2';
 import 'node:fs/promises';
 import 'node:os';
 import 'node:child_process';
@@ -28,7 +28,8 @@ import 'tweetnacl';
 import 'node:readline';
 import '@anthropic-ai/sandbox-runtime';
 import 'expo-server-sdk';
-import './agentGuidance-DrfhtVP1.mjs';
+import 'node:util';
+import './agentGuidance-Daxn5Nvj.mjs';
 import 'ink';
 import 'react';
 import '@anthropic-ai/claude-agent-sdk';
@@ -38,7 +39,6 @@ import 'open';
 import 'fastify';
 import 'fastify-type-provider-zod';
 import 'node:module';
-import 'node:util';
 import '@modelcontextprotocol/sdk/server/mcp.js';
 import 'node:http';
 import '@modelcontextprotocol/sdk/server/streamableHttp.js';
@@ -47,6 +47,46 @@ import 'inquirer';
 import 'node:url';
 import 'node:readline/promises';
 
+function nonEmpty(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function resolveForkSource(sessionId, persisted) {
+  if (!persisted) {
+    throw new Error(`Session ${sessionId} has no local record \u2014 only sessions spawned by this machine's daemon (in the last 14 days) can be forked from here.`);
+  }
+  const metadata = persisted.metadata;
+  const directory = metadata?.path;
+  if (!nonEmpty(directory)) throw new Error(`Session ${sessionId} has no working directory in its metadata.`);
+  const permissionMode = nonEmpty(metadata.permissionMode) ? metadata.permissionMode : void 0;
+  if (metadata.flavor === "codex") {
+    if (!nonEmpty(metadata.codexThreadId)) throw new Error(`Codex session ${sessionId} has no thread id yet (it never ran a turn) \u2014 nothing to fork.`);
+    return { agent: "codex", directory, codexThreadId: metadata.codexThreadId, permissionMode, parentSessionId: sessionId };
+  }
+  if (metadata.flavor && metadata.flavor !== "claude") {
+    throw new Error(`Session ${sessionId} runs ${metadata.flavor}; only claude and codex sessions can be forked.`);
+  }
+  if (!nonEmpty(metadata.claudeSessionId)) throw new Error(`Session ${sessionId} has no Claude conversation id yet (it never ran a turn) \u2014 nothing to fork.`);
+  return { agent: "claude", directory, claudeSessionId: metadata.claudeSessionId, permissionMode, parentSessionId: sessionId };
+}
+async function forkProviderConversation(source) {
+  if (source.agent === "claude") {
+    try {
+      return { resumeClaudeSessionId: await forkSession(getProjectPath(source.directory), source.claudeSessionId) };
+    } catch (error) {
+      if (error instanceof ForkSourceMissingError) throw new Error("Claude session file not found on this machine");
+      throw error;
+    }
+  }
+  const client = new CodexAppServerClient();
+  await client.connect();
+  try {
+    const result = await forkCodexThread(client, { threadId: source.codexThreadId, cwd: source.directory });
+    return { resumeCodexThreadId: result.newCodexThreadId };
+  } finally {
+    await client.disconnect();
+  }
+}
+
 function parseEnvAssignment(raw) {
   const eq = raw.indexOf("=");
   if (eq <= 0) throw new Error(`--env expects KEY=VALUE, got: ${raw}`);
@@ -96,6 +136,15 @@ function parseSpawnArgs(args) {
       if (value === void 0) throw new Error("--env requires a value");
       const [key, val] = parseEnvAssignment(value);
       options.env = { ...options.env ?? {}, [key]: val };
+    } else if (arg === "--model" || arg === "-m") {
+      const value = args[++i];
+      if (value === void 0 || value.trim().length === 0) throw new Error("--model requires a value");
+      options.model = value;
+    } else if (arg === "--fork") {
+      const value = args[++i];
+      if (value === void 0) throw new Error("--fork requires a session id");
+      if (!/^[a-zA-Z0-9_-]{1,128}$/.test(value)) throw new Error(`Invalid session id for --fork: ${value}`);
+      options.fork = value;
     } else if (arg === "--json") {
       options.json = true;
     } else if (arg === "--help" || arg === "-h") {
@@ -116,7 +165,9 @@ ${chalk.bold("very-happy spawn")} - Spawn a remote session via the local daemon
 ${chalk.bold("Usage:")}
   very-happy spawn --dir <path> [--prompt <text> | --prompt-file <file>]
                    [--spawned-by <name>] [--permission-mode <mode>]
-                   [--agent <name>] [--env KEY=VALUE]... [--json]
+                   [--agent <name>] [--model <id>] [--env KEY=VALUE]... [--json]
+  very-happy spawn --fork <sessionId> [--prompt \u2026] [--permission-mode <mode>]
+                   [--model <id>] [--spawned-by <name>] [--json]
 
 ${chalk.bold("Options:")}
   --dir, -d <path>       Working directory for the new session (required)
@@ -127,22 +178,34 @@ ${chalk.bold("Options:")}
                             the web list and is searchable as #<name>.
   --permission-mode <m>  Permission mode for the new session: default,
                             acceptEdits, plan, yolo, bypassPermissions.
-                            WITHOUT this the session runs in 'default' and stops
-                            at the first un-allowlisted tool waiting for someone
-                            to approve \u2014 if nothing is watching, it just hangs.
-                            Unattended dispatchers want bypassPermissions.
+                            Default = the web launcher's: yolo for claude /
+                            codex / pi, 'default' for gemini / openclaw. A fork
+                            keeps its source's mode. 'default' stops at the first
+                            un-allowlisted tool until someone approves it (see
+                            \`sessions approve\`).
   --agent <name>         Backend to run: claude (default), codex, gemini,
                             openclaw, pi (needs pi-acp on the daemon's PATH).
+  --model, -m <id>       Model for the session, sent with the first message
+                            (needs --prompt). Default = the web launcher's:
+                            claude-opus-5-5 for claude (the machine default when
+                            its Claude Code is too old for it); other agents use
+                            their own default. 'default' = the machine default.
+  --fork <sessionId>     Fork an existing session of THIS machine (same as the
+                            web's fork): copies its conversation and continues
+                            it in a new session, in the same directory and with
+                            the same agent (so --dir / --agent are not needed).
   --env KEY=VALUE        Extra environment for the session process. Repeatable.
                             \${VAR} is expanded against the daemon's environment;
                             an unresolved reference fails the spawn.
-  --json                 Machine-readable output: {"sessionId", "url"}
+  --json                 Machine-readable output: {"sessionId", "url",
+                            "permissionMode", \u2026}
   -h, --help             Show this help
 
 ${chalk.bold("Behavior:")}
   Requires the Very Happy daemon to be running on this machine (same semantics
   as spawning from the web: an offline machine cannot spawn). Without
-  --prompt / --prompt-file the session is spawned idle.
+  --prompt / --prompt-file the session is spawned idle. To collect the reply:
+  \`very-happy sessions read <id> --wait --answer\`.
 
 ${chalk.bold("Exit codes:")}
   0  success
@@ -150,9 +213,11 @@ ${chalk.bold("Exit codes:")}
   2  session spawned but first message failed (session URL still printed)
 `);
 }
-async function sendFirstMessage(sessionId, text) {
+async function sendFirstMessage(sessionId, text, metaFor) {
   const persisted = await waitForSessionKey(sessionId, 15e3);
-  await sendUserMessage(sessionId, persisted, text, "cli-spawn");
+  const meta = metaFor(persisted.metadata?.capabilities ?? null);
+  await sendUserMessage(sessionId, persisted, text, "cli-spawn", meta);
+  return meta;
 }
 async function handleSpawnCommand(args) {
   let options;
@@ -167,12 +232,32 @@ async function handleSpawnCommand(args) {
     printHelp();
     process.exit(0);
   }
-  if (!options.dir) {
-    console.error(chalk.red("Error:"), "--dir is required");
+  let forkSource = null;
+  if (options.fork !== void 0) {
+    try {
+      const persisted = readPersistedSessions()[options.fork];
+      const current = persisted ? await readSessionMetadata(options.fork, persisted) : null;
+      forkSource = resolveForkSource(options.fork, persisted && current ? { ...persisted, metadata: { ...persisted.metadata, ...current } } : persisted);
+    } catch (error) {
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+    if (options.dir !== void 0 && resolve(options.dir) !== forkSource.directory) {
+      console.error(chalk.red("Error:"), `--dir ${resolve(options.dir)} differs from the forked session's directory ${forkSource.directory}; a fork always continues in its source directory.`);
+      process.exit(1);
+    }
+    if (options.agent !== void 0 && options.agent !== forkSource.agent) {
+      console.error(chalk.red("Error:"), `--agent ${options.agent} differs from the forked session's agent ${forkSource.agent}.`);
+      process.exit(1);
+    }
+  } else if (!options.dir) {
+    console.error(chalk.red("Error:"), "--dir is required (or --fork <sessionId>)");
     console.error(`Run ${chalk.cyan("very-happy spawn --help")} for usage.`);
     process.exit(1);
   }
-  const directory = resolve(options.dir);
+  const directory = forkSource ? forkSource.directory : resolve(options.dir);
+  const agent = forkSource ? forkSource.agent : options.agent;
+  const permissionMode = options.permissionMode ?? forkSource?.permissionMode ?? resolveSpawnPermissionMode(agent, void 0);
   let prompt = options.prompt;
   if (options.promptFile !== void 0) {
     try {
@@ -186,6 +271,10 @@ async function handleSpawnCommand(args) {
     console.error(chalk.red("Error:"), "Prompt is empty");
     process.exit(1);
   }
+  if (options.model !== void 0 && prompt === void 0) {
+    console.error(chalk.red("Error:"), "--model needs --prompt / --prompt-file (the model is sent with the first message); for an idle session pass it later with `very-happy send --model`.");
+    process.exit(1);
+  }
   try {
     if (!statSync(directory).isDirectory()) {
       console.error(chalk.red("Error:"), `Not a directory: ${directory}`);
@@ -200,12 +289,23 @@ async function handleSpawnCommand(args) {
     console.error(`Start it with ${chalk.cyan("very-happy daemon start")} and retry.`);
     process.exit(1);
   }
-  logger.debug(`[SPAWN CMD] Spawning session in ${directory}`);
+  let resumeIds = {};
+  if (forkSource) {
+    try {
+      resumeIds = await forkProviderConversation(forkSource);
+    } catch (error) {
+      console.error(chalk.red("Error:"), `Failed to fork session ${forkSource.parentSessionId}: ${error instanceof Error ? error.message : String(error)}`);
+      process.exit(1);
+    }
+  }
+  logger.debug(`[SPAWN CMD] Spawning session in ${directory}${forkSource ? ` (fork of ${forkSource.parentSessionId})` : ""}`);
   const result = await spawnDaemonSession(directory, void 0, {
     spawnedBy: options.spawnedBy,
-    permissionMode: options.permissionMode,
-    agent: options.agent,
-    environmentVariables: options.env
+    permissionMode,
+    agent,
+    environmentVariables: options.env,
+    ...resumeIds,
+    ...forkSource ? { parentSessionId: forkSource.parentSessionId } : {}
   });
   if (result?.error || !result?.success || !result?.sessionId) {
     const message = result?.error || "Daemon returned no session ID";
@@ -214,24 +314,38 @@ async function handleSpawnCommand(args) {
   }
   const sessionId = result.sessionId;
   const url = sessionWebUrl(sessionId);
+  if (forkSource && result.resumed !== true) {
+    await stopDaemonSession(sessionId).catch(() => false);
+    console.error(chalk.red("Error:"), "The running daemon is too old to fork from the CLI (it spawned a fresh session, now stopped). Restart the daemon on this CLI version and retry.");
+    process.exit(1);
+  }
   let promptError = null;
+  let sentMeta = null;
   if (prompt !== void 0) {
     try {
-      await sendFirstMessage(sessionId, prompt);
+      sentMeta = await sendFirstMessage(sessionId, prompt, (capabilities) => resolveFirstMessageMeta({
+        agent,
+        permissionMode,
+        explicitModel: options.model,
+        capabilities
+      }));
     } catch (error) {
       promptError = error instanceof Error ? error.message : String(error);
     }
   }
   if (options.json) {
-    const payload = { sessionId, url };
+    const payload = { sessionId, url, permissionMode };
     if (options.spawnedBy !== void 0) {
       payload.spawnedBy = options.spawnedBy;
     }
-    if (options.permissionMode !== void 0) {
-      payload.permissionMode = options.permissionMode;
+    if (agent !== void 0) {
+      payload.agent = agent;
+    }
+    if (forkSource) {
+      payload.forkedFrom = forkSource.parentSessionId;
     }
-    if (options.agent !== void 0) {
-      payload.agent = options.agent;
+    if (sentMeta && sentMeta.model !== void 0) {
+      payload.model = sentMeta.model;
     }
     if (prompt !== void 0) {
       payload.promptDelivered = promptError === null;