very-happy-cli 0.2.115 → 0.2.117

package/dist/sessions-YWt9YEN8.cjs

@@ -0,0 +1,322 @@
+'use strict';
+
+var chalk = require('chalk');
+var index = require('./index-DcESl4cI.cjs');
+var persistence = require('./types-DD3AK6Nb.cjs');
+require('node:os');
+require('node:crypto');
+require('cross-spawn');
+require('node:path');
+require('node:readline');
+require('node:fs');
+require('./agentGuidance-BifkGXdE.cjs');
+require('node:fs/promises');
+require('fs/promises');
+require('ink');
+require('react');
+require('@anthropic-ai/claude-agent-sdk');
+require('axios');
+require('node:events');
+require('socket.io-client');
+require('tweetnacl');
+require('os');
+require('child_process');
+require('@paralleldrive/cuid2');
+require('node:child_process');
+require('fs');
+require('path');
+require('@anthropic-ai/sandbox-runtime');
+require('expo-server-sdk');
+require('crypto');
+require('ps-list');
+require('tmp');
+require('open');
+require('fastify');
+require('zod');
+require('fastify-type-provider-zod');
+require('node:module');
+require('@modelcontextprotocol/sdk/server/mcp.js');
+require('node:http');
+require('@modelcontextprotocol/sdk/server/streamableHttp.js');
+require('./limits-KdWKmwtH.cjs');
+require('http');
+require('util');
+require('inquirer');
+require('node:url');
+require('node:readline/promises');
+require('node:util');
+require('url');
+require('node-pty');
+
+const ACTIONS = ["list", "read", "stop", "archive", "approve", "deny"];
+const ACTIONS_NEEDING_ID = /* @__PURE__ */ new Set(["read", "stop", "archive", "approve", "deny"]);
+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 };
+}
+function parseSessionsArgs(args) {
+  const options = defaultOptions();
+  let actionSeen = false;
+  const positionals = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--help" || arg === "-h") {
+      return defaultOptions();
+    } else if (arg === "--json") {
+      options.json = true;
+    } else if (arg === "--all") {
+      options.all = true;
+    } else if (arg === "--include-archived") {
+      options.includeArchived = true;
+    } else if (arg === "--for-session") {
+      options.forSession = true;
+    } else if (arg === "--reason") {
+      const value = args[++i];
+      if (value === void 0) throw new Error("--reason requires a value");
+      options.reason = value;
+    } else if (arg === "--tag") {
+      const value = args[++i];
+      if (value === void 0) throw new Error("--tag requires a value");
+      options.tag = value;
+    } else if (arg === "--limit") {
+      const value = args[++i];
+      if (value === void 0) throw new Error("--limit requires a value");
+      const parsed = Number(value);
+      if (!Number.isInteger(parsed) || parsed < 1) throw new Error("--limit must be a positive integer");
+      options.limit = parsed;
+    } else if (arg.startsWith("-")) {
+      throw new Error(`Unknown argument: ${arg}`);
+    } else if (!actionSeen) {
+      if (!ACTIONS.includes(arg)) {
+        throw new Error(`Unknown action: ${arg} (expected ${ACTIONS.join(", ")})`);
+      }
+      options.action = arg;
+      actionSeen = true;
+    } else {
+      positionals.push(arg);
+    }
+  }
+  if (!actionSeen) return defaultOptions();
+  const expectedPositionals = ACTIONS_NEEDING_REQUEST_ID.has(options.action) ? 2 : ACTIONS_NEEDING_ID.has(options.action) ? 1 : 0;
+  if (positionals.length > expectedPositionals) {
+    throw new Error(`Unexpected ${expectedPositionals > 0 ? "extra " : ""}argument: ${positionals[expectedPositionals]}`);
+  }
+  if (ACTIONS_NEEDING_ID.has(options.action)) {
+    const id = positionals[0];
+    if (id === void 0) throw new Error(`${options.action} requires a session id`);
+    if (!persistence.isValidSessionId(id)) throw new Error(`Invalid session id: ${id}`);
+    options.sessionId = id;
+  }
+  if (ACTIONS_NEEDING_REQUEST_ID.has(options.action)) {
+    const requestId = positionals[1];
+    if (requestId === void 0) throw new Error(`${options.action} requires a session id and a request id`);
+    if (!REQUEST_ID_RE.test(requestId)) throw new Error(`Invalid request id: ${requestId}`);
+    options.requestId = requestId;
+  }
+  if (options.action !== "list") {
+    if (options.tag !== void 0) throw new Error("--tag only applies to `sessions list`");
+    if (options.all) throw new Error("--all only applies to `sessions list`");
+    if (options.includeArchived) throw new Error("--include-archived only applies to `sessions list --all`");
+  } else if (options.includeArchived && !options.all) {
+    throw new Error("--include-archived only applies to `sessions list --all`");
+  }
+  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`");
+  return options;
+}
+const SESSIONS_HELP = `
+${chalk.bold("very-happy sessions")} - Inspect and control sessions on this machine (for automation)
+
+${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 stop <id> [--json]
+  very-happy sessions archive <id> [--json]
+  very-happy sessions approve <id> <requestId> [--for-session] [--json]
+  very-happy sessions deny <id> <requestId> [--reason <text>] [--json]
+
+${chalk.bold("Actions:")}
+  list       Running sessions plus recently seen ones, newest first.
+             With --all: every session on the account (newest 150, server
+             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.
+  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
+             the same RPC the web permission card sends. --for-session makes
+             it \`approved_for_session\` (the card's "allow for this session").
+  deny       Answer it with deny (optional --reason is shown to the agent).
+
+${chalk.bold("Options:")}
+  --all              list only: account-wide over REST instead of this
+                     machine's daemon + local keys.
+  --include-archived list --all only: also show server-archived rows.
+  --tag <name>       list only: keep sessions carrying this origin tag (see
+                     \`spawn --spawned-by\`). With --all only decryptable rows
+                     can match.
+  --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}).
+  --for-session      approve only: approved_for_session instead of approved.
+  --reason <text>    deny only: reason forwarded to the wrapper.
+  --json             Machine-readable output.
+  -h, --help         Show this help
+
+${chalk.bold("Scope:")}
+  read / approve / deny need the session key from ~/.happy/sessions.json,
+  which exists for sessions this machine's daemon spawned and is pruned after
+  14 days (the message payloads and the permission RPC are encrypted with it).
+  \`list --all\` sees every session on the account but can only decrypt those
+  same ones; the rest come back with decryptable=false. Reading, listing in
+  full and answering another machine's session from here needs the CLI to hold
+  the account content key \u2014 a credentials change, not a flag.
+
+${chalk.bold("Exit codes:")}
+  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,
+     session not online, or the operation failed (including \`stop\` on a
+     session the daemon is not running)
+`;
+function formatWait(ms) {
+  const minutes = Math.floor(ms / 6e4);
+  if (minutes < 1) return `${Math.floor(ms / 1e3)}s`;
+  if (minutes < 60) return `${minutes}m`;
+  return `${Math.floor(minutes / 60)}h${minutes % 60}m`;
+}
+function formatAccountSummaryLine(summary) {
+  const state = summary.attention ? "[attention]" : summary.live ? "[running here]" : summary.active ? "[active elsewhere]" : summary.archived ? "[archived]" : "[idle]";
+  const parts = [summary.id, state];
+  if (!summary.decryptable) {
+    parts.push("(not decryptable from this machine)");
+  } else {
+    if (summary.title) parts.push(`title="${summary.title}"`);
+    if (summary.flavor) parts.push(`agent=${summary.flavor}`);
+    if (summary.tags?.length) parts.push(`tags=${summary.tags.join(",")}`);
+    if (summary.variant) parts.push(`variant=${summary.variant}`);
+    if (summary.machineId) parts.push(`machine=${summary.machineId}`);
+    if (summary.cwd) parts.push(`cwd=${summary.cwd}`);
+    for (const request of summary.pending ?? []) {
+      parts.push(`pending=${request.id}:${request.tool}${request.waitingMs !== void 0 ? `(${formatWait(request.waitingMs)})` : ""}`);
+    }
+  }
+  parts.push(summary.url);
+  return parts.join(" ");
+}
+function permissionFailureRecord(sessionId, requestId, error) {
+  return { sessionId, requestId, error: error instanceof Error ? error.message : String(error) };
+}
+function formatSummaryLine(summary) {
+  const parts = [summary.id, summary.live ? "[running]" : "[not running]"];
+  if (summary.title) parts.push(`title="${summary.title}"`);
+  if (summary.flavor) parts.push(`agent=${summary.flavor}`);
+  if (summary.tags?.length) parts.push(`tags=${summary.tags.join(",")}`);
+  if (summary.variant) parts.push(`variant=${summary.variant}`);
+  if (summary.cwd) parts.push(`cwd=${summary.cwd}`);
+  if (summary.pid !== void 0) parts.push(`pid=${summary.pid}`);
+  parts.push(summary.url);
+  return parts.join(" ");
+}
+async function handleSessionsCommand(args) {
+  let options;
+  try {
+    options = parseSessionsArgs(args);
+  } catch (error) {
+    console.error(chalk.red("Error:"), error instanceof Error ? error.message : String(error));
+    console.error(`Run ${chalk.cyan("very-happy sessions --help")} for usage.`);
+    process.exit(1);
+  }
+  if (options.action === "help") {
+    console.log(SESSIONS_HELP);
+    process.exit(0);
+  }
+  try {
+    if (options.action === "list" && options.all) {
+      const sessions = await index.listAccountSessions({ tag: options.tag, recentLimit: options.limit, includeArchived: options.includeArchived });
+      if (options.json) {
+        console.log(JSON.stringify({ sessions, scope: "account" }));
+      } else if (sessions.length === 0) {
+        console.log(options.tag ? `No decryptable sessions tagged "${options.tag}" on this account.` : "No sessions found on this account.");
+      } else {
+        for (const summary of sessions) console.log(formatAccountSummaryLine(summary));
+        const foreign = sessions.filter((summary) => !summary.decryptable).length;
+        if (foreign > 0) {
+          console.log(chalk.dim(`${foreign} session(s) belong to another machine and cannot be decrypted here (no local key).`));
+        }
+      }
+      process.exit(0);
+    }
+    if (options.action === "list") {
+      const sessions = await index.listSessions({ tag: options.tag, recentLimit: options.limit });
+      if (options.json) {
+        console.log(JSON.stringify({ sessions }));
+      } else if (sessions.length === 0) {
+        console.log(options.tag ? `No sessions tagged "${options.tag}" on this machine.` : "No sessions found on this machine.");
+      } else {
+        for (const summary of sessions) console.log(formatSummaryLine(summary));
+      }
+      process.exit(0);
+    }
+    const sessionId = options.sessionId;
+    if (options.action === "read") {
+      const result = await index.readSessionTranscript(sessionId, options.limit ?? 20);
+      if (options.json) {
+        console.log(JSON.stringify(result));
+      } 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)");
+      }
+      process.exit(0);
+    }
+    if (options.action === "stop") {
+      const stopped = await index.stopSession(sessionId);
+      if (!stopped) {
+        if (options.json) console.log(JSON.stringify({ sessionId, stopped: false }));
+        console.error(chalk.red("Error:"), `Session ${sessionId} is not among the daemon's running sessions.`);
+        process.exit(1);
+      }
+      if (options.json) console.log(JSON.stringify({ sessionId, stopped: true }));
+      else console.log(`Stopped ${sessionId}`);
+      process.exit(0);
+    }
+    if (options.action === "approve" || options.action === "deny") {
+      const requestId = options.requestId;
+      const verdict = options.action === "approve" ? { kind: "approve", forSession: options.forSession } : { kind: "deny", reason: options.reason };
+      let result;
+      try {
+        result = await index.resolvePermissionRequest(sessionId, requestId, verdict);
+      } catch (error) {
+        if (options.json) console.log(JSON.stringify(permissionFailureRecord(sessionId, requestId, error)));
+        throw error;
+      }
+      if (result.outcome.status !== "acknowledged") {
+        if (options.json) console.log(JSON.stringify(result));
+        console.error(chalk.red("Error:"), `${options.action} of ${requestId} on ${sessionId} was not delivered (${result.outcome.status}): ${result.outcome.message}`);
+        process.exit(1);
+      }
+      if (options.json) {
+        console.log(JSON.stringify(result));
+      } else {
+        const verb = options.action === "approve" ? "Approved" : "Denied";
+        console.log(`${verb} ${requestId} on ${sessionId} (${result.payload.decision})${result.settled ? "" : " \u2014 wrapper acknowledged, but the request was still listed as pending when we stopped waiting"}`);
+      }
+      process.exit(0);
+    }
+    await index.archiveSession(sessionId);
+    if (options.json) console.log(JSON.stringify({ sessionId, archived: true }));
+    else console.log(`Archived ${sessionId}`);
+    process.exit(0);
+  } catch (error) {
+    console.error(chalk.red("Error:"), error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+
+exports.SESSIONS_HELP = SESSIONS_HELP;
+exports.handleSessionsCommand = handleSessionsCommand;
+exports.parseSessionsArgs = parseSessionsArgs;
+exports.permissionFailureRecord = permissionFailureRecord;

package/dist/{spawn-qb344Y5E.mjs → spawn-CsrHZd3y.mjs}

@@ -1,8 +1,8 @@
 import chalk from 'chalk';
 import { readFileSync, statSync } from 'node:fs';
 import { resolve } from 'node:path';
-import { c as checkIfDaemonRunningAndCleanupStaleState, s as spawnDaemonSession, a as sessionWebUrl, i as isValidSpawnOrigin, b as sanitizeSpawnPermissionMode, A as ALLOWED_SPAWN_PERMISSION_MODES, w as waitForSessionKey, d as sendUserMessage } from './index-BHNEb4bc.mjs';
-import { l as logger } from './types-B3qx8Ga1.mjs';
+import { c as checkIfDaemonRunningAndCleanupStaleState, s as spawnDaemonSession, a as sessionWebUrl, i as isValidSpawnOrigin, b as sanitizeSpawnPermissionMode, A as ALLOWED_SPAWN_PERMISSION_MODES, S as SPAWN_AGENTS, w as waitForSessionKey, d as sendUserMessage } from './index-BYZKuQoy.mjs';
+import { l as logger } from './types-jSfU_0o1.mjs';
 import 'node:os';
 import 'node:crypto';
 import 'cross-spawn';
@@ -46,7 +46,6 @@ import 'node:util';
 import 'url';
 import 'node-pty';
 
-const SPAWN_AGENTS = ["claude", "codex", "gemini", "openclaw"];
 function parseEnvAssignment(raw) {
   const eq = raw.indexOf("=");
   if (eq <= 0) throw new Error(`--env expects KEY=VALUE, got: ${raw}`);
@@ -132,7 +131,7 @@ ${chalk.bold("Options:")}
                             to approve \u2014 if nothing is watching, it just hangs.
                             Unattended dispatchers want bypassPermissions.
   --agent <name>         Backend to run: claude (default), codex, gemini,
-                            openclaw.
+                            openclaw, pi (needs pi-acp on the daemon's PATH).
   --env KEY=VALUE        Extra environment for the session process. Repeatable.
                             \${VAR} is expanded against the daemon's environment;
                             an unresolved reference fails the spawn.

package/dist/{spawn-CfYddkS_.cjs → spawn-tSvo3stN.cjs}

@@ -3,8 +3,8 @@
 var chalk = require('chalk');
 var node_fs = require('node:fs');
 var path = require('node:path');
-var index = require('./index-tPXwlc_t.cjs');
-var persistence = require('./types-CpnzfHHS.cjs');
+var index = require('./index-DcESl4cI.cjs');
+var persistence = require('./types-DD3AK6Nb.cjs');
 require('node:os');
 require('node:crypto');
 require('cross-spawn');
@@ -48,7 +48,6 @@ require('node:util');
 require('url');
 require('node-pty');
 
-const SPAWN_AGENTS = ["claude", "codex", "gemini", "openclaw"];
 function parseEnvAssignment(raw) {
   const eq = raw.indexOf("=");
   if (eq <= 0) throw new Error(`--env expects KEY=VALUE, got: ${raw}`);
@@ -89,8 +88,8 @@ function parseSpawnArgs(args) {
     } else if (arg === "--agent") {
       const value = args[++i];
       if (value === void 0) throw new Error("--agent requires a value");
-      if (!SPAWN_AGENTS.includes(value)) {
-        throw new Error(`--agent must be one of: ${SPAWN_AGENTS.join(", ")}`);
+      if (!index.SPAWN_AGENTS.includes(value)) {
+        throw new Error(`--agent must be one of: ${index.SPAWN_AGENTS.join(", ")}`);
       }
       options.agent = value;
     } else if (arg === "--env") {
@@ -134,7 +133,7 @@ ${chalk.bold("Options:")}
                             to approve \u2014 if nothing is watching, it just hangs.
                             Unattended dispatchers want bypassPermissions.
   --agent <name>         Backend to run: claude (default), codex, gemini,
-                            openclaw.
+                            openclaw, pi (needs pi-acp on the daemon's PATH).
   --env KEY=VALUE        Extra environment for the session process. Repeatable.
                             \${VAR} is expanded against the daemon's environment;
                             an unresolved reference fails the spawn.
@@ -257,8 +256,8 @@ async function handleSpawnCommand(args) {
   process.exit(0);
 }
 
+exports.SPAWN_AGENTS = index.SPAWN_AGENTS;
 exports.sessionWebUrl = index.sessionWebUrl;
-exports.SPAWN_AGENTS = SPAWN_AGENTS;
 exports.handleSpawnCommand = handleSpawnCommand;
 exports.parseEnvAssignment = parseEnvAssignment;
 exports.parseSpawnArgs = parseSpawnArgs;