very-happy-cli 0.2.159 → 0.2.161

package/dist/doctorReadiness-C208SMN9.mjs

@@ -0,0 +1,142 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { c as commandOnPath } from './detectCLI-CSGMlV51.mjs';
+
+const SUPPORTED_NODE_LABEL = "20.19+ within 20.x, 22.13+ within 22.x, or 24+";
+const MIN_TMUX_ENV_MAJOR = 3;
+const MIN_TMUX_ENV_MINOR = 2;
+function enabled(value) {
+  return ["1", "true", "yes"].includes(value?.trim().toLowerCase() ?? "");
+}
+function resolveClaudeCredentialReadiness(env = process.env, fileExists = existsSync, readText = (path) => readFileSync(path, "utf8"), userHome = homedir()) {
+  if (enabled(env.CLAUDE_CODE_USE_BEDROCK)) return { configured: true, source: "Amazon Bedrock" };
+  if (enabled(env.CLAUDE_CODE_USE_VERTEX)) return { configured: true, source: "Google Vertex AI" };
+  if (enabled(env.CLAUDE_CODE_USE_FOUNDRY)) return { configured: true, source: "Microsoft Foundry" };
+  if (env.ANTHROPIC_AUTH_TOKEN?.trim()) return { configured: true, source: "ANTHROPIC_AUTH_TOKEN" };
+  if (env.ANTHROPIC_API_KEY?.trim()) return { configured: true, source: "ANTHROPIC_API_KEY" };
+  if (env.CLAUDE_CODE_OAUTH_TOKEN?.trim()) return { configured: true, source: "CLAUDE_CODE_OAUTH_TOKEN" };
+  const configDir = env.CLAUDE_CONFIG_DIR?.trim() || join(userHome, ".claude");
+  const settingsPath = join(configDir, "settings.json");
+  try {
+    if (fileExists(settingsPath)) {
+      const settings = JSON.parse(readText(settingsPath));
+      if (typeof settings.apiKeyHelper === "string" && settings.apiKeyHelper.trim()) {
+        return { configured: true, source: "Claude apiKeyHelper" };
+      }
+    }
+  } catch {
+  }
+  if (fileExists(join(configDir, ".credentials.json"))) {
+    return { configured: true, source: "Claude local credentials" };
+  }
+  return { configured: false };
+}
+function toolProbeLabel(tool) {
+  return tool.version ? `${tool.command} (${tool.version})` : tool.command;
+}
+function shareableSettingsSummary(value) {
+  const settings = value && typeof value === "object" ? value : {};
+  const sandbox = settings.sandboxConfig && typeof settings.sandboxConfig === "object" ? settings.sandboxConfig : {};
+  return {
+    ...typeof settings.schemaVersion === "number" ? { schemaVersion: settings.schemaVersion } : {},
+    ...typeof settings.onboardingCompleted === "boolean" ? { onboardingCompleted: settings.onboardingCompleted } : {},
+    machineIdConfigured: typeof settings.machineId === "string" && settings.machineId.length > 0,
+    serverUrlConfigured: typeof settings.serverUrl === "string" && settings.serverUrl.length > 0,
+    webappUrlConfigured: typeof settings.webappUrl === "string" && settings.webappUrl.length > 0,
+    sandboxEnabled: sandbox.enabled === true,
+    chromeMode: settings.chromeMode === true,
+    boardLlm: settings.boardLlm === true,
+    todoProviderConfigured: Boolean(settings.todoProvider),
+    terminalAutoRestore: typeof settings.terminalAutoRestore === "boolean" ? settings.terminalAutoRestore : "default"
+  };
+}
+function firstUsefulLine(output) {
+  if (typeof output !== "string") return void 0;
+  const line = output.split(/\r?\n/).map((value) => value.trim()).find(Boolean);
+  if (!line) return void 0;
+  return Array.from(line).slice(0, 160).join("");
+}
+function nodeSupported(version) {
+  const match = /^v?(\d+)\.(\d+)\.(\d+)/.exec(version.trim());
+  if (!match) return false;
+  const [major, minor, patch] = match.slice(1).map(Number);
+  if (major === 20) return minor >= 19;
+  if (major === 22) return minor >= 13;
+  return major >= 24;
+}
+function normalizedEndpoint(value) {
+  try {
+    const parsed = new URL(value);
+    return `${parsed.origin}${parsed.pathname.replace(/\/+$/, "")}`;
+  } catch {
+    return value.replace(/\/+$/, "");
+  }
+}
+function daemonEndpointsMatch(stateServerUrl, stateWebappUrl, configuredServerUrl, configuredWebappUrl) {
+  return Boolean(
+    stateServerUrl && stateWebappUrl && normalizedEndpoint(stateServerUrl) === normalizedEndpoint(configuredServerUrl) && normalizedEndpoint(stateWebappUrl) === normalizedEndpoint(configuredWebappUrl)
+  );
+}
+function tmuxSupportsSessionEnv(version) {
+  if (!version) return false;
+  if (/master/i.test(version)) return true;
+  const match = /(\d+)\.(\d+)/.exec(version);
+  if (!match) return false;
+  const major = Number(match[1]);
+  const minor = Number(match[2]);
+  return major > MIN_TMUX_ENV_MAJOR || major === MIN_TMUX_ENV_MAJOR && minor >= MIN_TMUX_ENV_MINOR;
+}
+function probe(command, run) {
+  try {
+    const result = run(command, command === "tmux" ? ["-V"] : ["--version"], {
+      encoding: "utf8",
+      timeout: 2e3,
+      windowsHide: true
+    });
+    const version = firstUsefulLine(result.stdout) ?? firstUsefulLine(result.stderr);
+    return {
+      command,
+      available: !result.error && result.status === 0,
+      ...version ? { version } : {}
+    };
+  } catch {
+    return { command, available: false };
+  }
+}
+function daemonReadiness(authenticated, running, hasState) {
+  if (running && hasState) {
+    return { level: "ready", message: "\u2713 Daemon is running" };
+  }
+  if (hasState) {
+    return { level: "warning", message: "\u26A0\uFE0F  Daemon state exists but process not running (stale)" };
+  }
+  if (!authenticated) {
+    return {
+      level: "next",
+      message: "\u25CB Daemon not started yet \u2014 pair this machine, then run `very-happy daemon start`"
+    };
+  }
+  return {
+    level: "warning",
+    message: "\u26A0\uFE0F  Daemon is not running \u2014 run `very-happy daemon start`"
+  };
+}
+function collectRuntimeReadiness(run = spawnSync, currentNodeVersion = process.version, onPath = commandOnPath) {
+  const tmux = probe("tmux", run);
+  return {
+    node: {
+      version: currentNodeVersion,
+      supported: nodeSupported(currentNodeVersion)
+    },
+    tmux: {
+      ...tmux,
+      supportsSessionEnv: tmux.available && tmuxSupportsSessionEnv(tmux.version)
+    },
+    agents: ["claude", "codex", "gemini", "opencode", "openclaw", "pi"].map((command) => probe(command, run)),
+    piAdapter: { available: onPath("pi-acp") }
+  };
+}
+
+export { SUPPORTED_NODE_LABEL as S, toolProbeLabel as a, daemonReadiness as b, collectRuntimeReadiness as c, daemonEndpointsMatch as d, resolveClaudeCredentialReadiness as r, shareableSettingsSummary as s, tmuxSupportsSessionEnv as t };

package/dist/editPaths-BVfS_FFL.mjs

@@ -0,0 +1,68 @@
+const CLAUDE_EDIT_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
+function pathOf(input) {
+  if (!input || typeof input !== "object") return null;
+  const record = input;
+  const candidate = record.file_path ?? record.notebook_path;
+  return typeof candidate === "string" && candidate.trim() !== "" ? candidate : null;
+}
+function extractClaudeEditPaths(body) {
+  if (!body || typeof body !== "object") return [];
+  const line = body;
+  if (line.type !== "assistant") return [];
+  const content = line.message?.content;
+  if (!Array.isArray(content)) return [];
+  const stamp = line.timestamp;
+  const at = typeof stamp === "string" ? Date.parse(stamp) : typeof stamp === "number" ? stamp : NaN;
+  const edits = [];
+  for (const block of content) {
+    if (!block || typeof block !== "object") continue;
+    const b = block;
+    if (b.type !== "tool_use" || typeof b.name !== "string" || !CLAUDE_EDIT_TOOLS.has(b.name)) continue;
+    const path = pathOf(b.input);
+    if (path) edits.push({ path, tool: b.name, ...Number.isFinite(at) ? { at } : {} });
+  }
+  return edits;
+}
+function extractCodexPatchPaths(changes) {
+  if (!changes || typeof changes !== "object" || Array.isArray(changes)) return [];
+  return Object.keys(changes).filter((path) => path.trim() !== "").map((path) => ({ path, tool: "CodexPatch" }));
+}
+function extractAcpEditPaths(toolKind, args) {
+  if (!args || typeof args !== "object") return [];
+  const a = args;
+  if (a.piTool === "write" || a.piTool === "edit") {
+    const raw = a.rawInput;
+    const path = raw && typeof raw.path === "string" && raw.path.trim() !== "" ? raw.path : null;
+    return path ? [{ path, tool: a.piTool }] : [];
+  }
+  if (typeof a.piTool === "string") return [];
+  if (toolKind !== "edit" || !Array.isArray(a.locations)) return [];
+  const edits = [];
+  for (const location of a.locations) {
+    const path = location && typeof location === "object" ? location.path : void 0;
+    if (typeof path === "string" && path.trim() !== "" && !edits.some((e) => e.path === path)) edits.push({ path, tool: "edit" });
+  }
+  return edits;
+}
+class EditReportThrottle {
+  constructor(intervalMs = 5e3) {
+    this.intervalMs = intervalMs;
+  }
+  lastReportedAt = /* @__PURE__ */ new Map();
+  /** Returns the edits that should be reported now and remembers them. */
+  take(edits, now = Date.now()) {
+    const due = [];
+    for (const edit of edits) {
+      const last = this.lastReportedAt.get(edit.path);
+      if (last !== void 0 && now - last < this.intervalMs) continue;
+      this.lastReportedAt.set(edit.path, now);
+      due.push(edit);
+    }
+    if (this.lastReportedAt.size > 512) {
+      for (const [path, at] of this.lastReportedAt) if (now - at > this.intervalMs * 10) this.lastReportedAt.delete(path);
+    }
+    return due;
+  }
+}
+
+export { EditReportThrottle as E, extractCodexPatchPaths as a, extractClaudeEditPaths as b, extractAcpEditPaths as e };

package/dist/editPaths-Bqp4OFPw.cjs

@@ -0,0 +1,73 @@
+'use strict';
+
+const CLAUDE_EDIT_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
+function pathOf(input) {
+  if (!input || typeof input !== "object") return null;
+  const record = input;
+  const candidate = record.file_path ?? record.notebook_path;
+  return typeof candidate === "string" && candidate.trim() !== "" ? candidate : null;
+}
+function extractClaudeEditPaths(body) {
+  if (!body || typeof body !== "object") return [];
+  const line = body;
+  if (line.type !== "assistant") return [];
+  const content = line.message?.content;
+  if (!Array.isArray(content)) return [];
+  const stamp = line.timestamp;
+  const at = typeof stamp === "string" ? Date.parse(stamp) : typeof stamp === "number" ? stamp : NaN;
+  const edits = [];
+  for (const block of content) {
+    if (!block || typeof block !== "object") continue;
+    const b = block;
+    if (b.type !== "tool_use" || typeof b.name !== "string" || !CLAUDE_EDIT_TOOLS.has(b.name)) continue;
+    const path = pathOf(b.input);
+    if (path) edits.push({ path, tool: b.name, ...Number.isFinite(at) ? { at } : {} });
+  }
+  return edits;
+}
+function extractCodexPatchPaths(changes) {
+  if (!changes || typeof changes !== "object" || Array.isArray(changes)) return [];
+  return Object.keys(changes).filter((path) => path.trim() !== "").map((path) => ({ path, tool: "CodexPatch" }));
+}
+function extractAcpEditPaths(toolKind, args) {
+  if (!args || typeof args !== "object") return [];
+  const a = args;
+  if (a.piTool === "write" || a.piTool === "edit") {
+    const raw = a.rawInput;
+    const path = raw && typeof raw.path === "string" && raw.path.trim() !== "" ? raw.path : null;
+    return path ? [{ path, tool: a.piTool }] : [];
+  }
+  if (typeof a.piTool === "string") return [];
+  if (toolKind !== "edit" || !Array.isArray(a.locations)) return [];
+  const edits = [];
+  for (const location of a.locations) {
+    const path = location && typeof location === "object" ? location.path : void 0;
+    if (typeof path === "string" && path.trim() !== "" && !edits.some((e) => e.path === path)) edits.push({ path, tool: "edit" });
+  }
+  return edits;
+}
+class EditReportThrottle {
+  constructor(intervalMs = 5e3) {
+    this.intervalMs = intervalMs;
+  }
+  lastReportedAt = /* @__PURE__ */ new Map();
+  /** Returns the edits that should be reported now and remembers them. */
+  take(edits, now = Date.now()) {
+    const due = [];
+    for (const edit of edits) {
+      const last = this.lastReportedAt.get(edit.path);
+      if (last !== void 0 && now - last < this.intervalMs) continue;
+      this.lastReportedAt.set(edit.path, now);
+      due.push(edit);
+    }
+    if (this.lastReportedAt.size > 512) {
+      for (const [path, at] of this.lastReportedAt) if (now - at > this.intervalMs * 10) this.lastReportedAt.delete(path);
+    }
+    return due;
+  }
+}
+
+exports.EditReportThrottle = EditReportThrottle;
+exports.extractAcpEditPaths = extractAcpEditPaths;
+exports.extractClaudeEditPaths = extractClaudeEditPaths;
+exports.extractCodexPatchPaths = extractCodexPatchPaths;

package/dist/ensureDaemonRunning-CO7d1gOC.mjs

@@ -0,0 +1,61 @@
+import { l as logger } from './logger-fXoNzNuB.mjs';
+import { i as isDaemonRunningCurrentlyInstalledHappyVersion, c as checkIfDaemonRunningAndCleanupStaleState, a as stopDaemon } from './controlClient-DjoKTtgK.mjs';
+import { s as spawnHappyCLI } from './spawnHappyCLI-cqWQbwsb.mjs';
+import { readDaemonState } from './persistence-oET5n61f.mjs';
+import { c as configuration } from './configuration-DoWFJUPm.mjs';
+import { d as daemonEndpointsMatch } from './doctorReadiness-C208SMN9.mjs';
+
+function extractNoSandboxFlag(args) {
+  let noSandbox = false;
+  const remainingArgs = [];
+  for (const arg of args) {
+    if (arg === "--no-sandbox") {
+      noSandbox = true;
+    } else {
+      remainingArgs.push(arg);
+    }
+  }
+  return {
+    noSandbox,
+    args: remainingArgs
+  };
+}
+
+const DAEMON_READY_TIMEOUT_MS = 5e3;
+const DAEMON_READY_POLL_INTERVAL_MS = 100;
+async function ensureDaemonRunning() {
+  logger.debug("Ensuring Happy background service is running & matches our version...");
+  const versionMatches = await isDaemonRunningCurrentlyInstalledHappyVersion();
+  const state = await readDaemonState();
+  const endpointsMatch = Boolean(state) && daemonEndpointsMatch(
+    state?.serverUrl,
+    state?.webappUrl,
+    configuration.serverUrl,
+    configuration.webappUrl
+  );
+  if (versionMatches && endpointsMatch) {
+    return;
+  }
+  if (await checkIfDaemonRunningAndCleanupStaleState()) {
+    logger.debug("Stopping daemon whose version or configured relay no longer matches...");
+    await stopDaemon();
+  }
+  logger.debug("Starting Happy background service...");
+  const daemonProcess = spawnHappyCLI(["daemon", "start-sync"], {
+    detached: true,
+    stdio: "ignore",
+    env: process.env
+  });
+  daemonProcess.unref();
+  const deadline = Date.now() + DAEMON_READY_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    if (await checkIfDaemonRunningAndCleanupStaleState()) {
+      logger.debug("Happy background service is ready");
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, DAEMON_READY_POLL_INTERVAL_MS));
+  }
+  logger.debug(`Happy background service did not become ready within ${DAEMON_READY_TIMEOUT_MS}ms; continuing anyway`);
+}
+
+export { extractNoSandboxFlag as a, ensureDaemonRunning as e };

package/dist/ensureDaemonRunning-Dg9aZfjs.cjs

@@ -0,0 +1,64 @@
+'use strict';
+
+var logger = require('./logger-Bc8-u1w0.cjs');
+var controlClient = require('./controlClient-fEHE85bH.cjs');
+var spawnHappyCLI = require('./spawnHappyCLI-BhYj84rv.cjs');
+var persistence = require('./persistence-CBNMzSa8.cjs');
+var configuration = require('./configuration-v9f8LM9T.cjs');
+var doctorReadiness = require('./doctorReadiness-BCZGcN0a.cjs');
+
+function extractNoSandboxFlag(args) {
+  let noSandbox = false;
+  const remainingArgs = [];
+  for (const arg of args) {
+    if (arg === "--no-sandbox") {
+      noSandbox = true;
+    } else {
+      remainingArgs.push(arg);
+    }
+  }
+  return {
+    noSandbox,
+    args: remainingArgs
+  };
+}
+
+const DAEMON_READY_TIMEOUT_MS = 5e3;
+const DAEMON_READY_POLL_INTERVAL_MS = 100;
+async function ensureDaemonRunning() {
+  logger.logger.debug("Ensuring Happy background service is running & matches our version...");
+  const versionMatches = await controlClient.isDaemonRunningCurrentlyInstalledHappyVersion();
+  const state = await persistence.readDaemonState();
+  const endpointsMatch = Boolean(state) && doctorReadiness.daemonEndpointsMatch(
+    state?.serverUrl,
+    state?.webappUrl,
+    configuration.configuration.serverUrl,
+    configuration.configuration.webappUrl
+  );
+  if (versionMatches && endpointsMatch) {
+    return;
+  }
+  if (await controlClient.checkIfDaemonRunningAndCleanupStaleState()) {
+    logger.logger.debug("Stopping daemon whose version or configured relay no longer matches...");
+    await controlClient.stopDaemon();
+  }
+  logger.logger.debug("Starting Happy background service...");
+  const daemonProcess = spawnHappyCLI.spawnHappyCLI(["daemon", "start-sync"], {
+    detached: true,
+    stdio: "ignore",
+    env: process.env
+  });
+  daemonProcess.unref();
+  const deadline = Date.now() + DAEMON_READY_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    if (await controlClient.checkIfDaemonRunningAndCleanupStaleState()) {
+      logger.logger.debug("Happy background service is ready");
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, DAEMON_READY_POLL_INTERVAL_MS));
+  }
+  logger.logger.debug(`Happy background service did not become ready within ${DAEMON_READY_TIMEOUT_MS}ms; continuing anyway`);
+}
+
+exports.ensureDaemonRunning = ensureDaemonRunning;
+exports.extractNoSandboxFlag = extractNoSandboxFlag;

package/dist/handleResumeCommand-BiTPK0qd.mjs

@@ -0,0 +1,240 @@
+import { existsSync } from 'node:fs';
+import { s as spawnHappyCLI } from './spawnHappyCLI-cqWQbwsb.mjs';
+import axios, { AxiosError } from 'axios';
+import tweetnacl from 'tweetnacl';
+import { z } from 'zod';
+import { d as decodeBase64, a as decryptWithDataKey, b as decryptLegacy } from './authRelay-DSAvg1uv.mjs';
+import { c as configuration } from './configuration-DoWFJUPm.mjs';
+import { g as getLocalHappyAgentCredentialPath, r as readLocalHappyAgentCredentials } from './localHappyAgentAuth-DCsetiyG.mjs';
+import 'cross-spawn';
+import 'node:path';
+import './projectPath-BTBIMB57.mjs';
+import 'path';
+import 'url';
+import './logger-fXoNzNuB.mjs';
+import 'chalk';
+import 'node:util';
+import 'node:crypto';
+import 'node:os';
+import './package-uOg9SCKi.mjs';
+import 'node:fs/promises';
+
+const ResumableMetadataSchema = z.object({
+  path: z.string().min(1),
+  flavor: z.string().optional(),
+  claudeSessionId: z.string().optional(),
+  codexThreadId: z.string().optional()
+}).passthrough();
+function resolveSessionRecordByPrefix(records, sessionId) {
+  const trimmed = sessionId.trim();
+  if (!trimmed) {
+    throw new Error("Happy session ID is required: very-happy resume <session-id>");
+  }
+  const matches = records.filter((record) => record.id.startsWith(trimmed));
+  if (matches.length === 0) {
+    throw new Error(`No Happy session found matching "${trimmed}"`);
+  }
+  if (matches.length > 1) {
+    throw new Error(`Ambiguous Happy session "${trimmed}" matches ${matches.length} sessions. Be more specific.`);
+  }
+  return matches[0];
+}
+function decryptBoxBundle(bundle, recipientSecretKey) {
+  if (bundle.length < 56) {
+    return null;
+  }
+  const ephemeralPublicKey = bundle.slice(0, 32);
+  const nonce = bundle.slice(32, 56);
+  const ciphertext = bundle.slice(56);
+  const decrypted = tweetnacl.box.open(ciphertext, nonce, ephemeralPublicKey, recipientSecretKey);
+  return decrypted ? new Uint8Array(decrypted) : null;
+}
+function readAgentCredentials() {
+  const credentialPath = getLocalHappyAgentCredentialPath();
+  const credentials = readLocalHappyAgentCredentials();
+  if (!credentials) {
+    throw new Error(
+      `Cannot use the legacy CLI resume path without ${credentialPath}. This credential is produced only by the source-only internal control-plane prototype; do not install the unrelated npm package named happy-agent. Use the Web session controls instead.`
+    );
+  }
+  return credentials;
+}
+function resolveSessionEncryption(session, credentials) {
+  if (session.dataEncryptionKey) {
+    const encrypted = decodeBase64(session.dataEncryptionKey);
+    const sessionKey = decryptBoxBundle(encrypted.slice(1), credentials.contentKeyPair.secretKey);
+    if (!sessionKey) {
+      throw new Error(`Failed to decrypt data key for Happy session ${session.id}`);
+    }
+    return {
+      key: sessionKey,
+      variant: "dataKey"
+    };
+  }
+  return {
+    key: credentials.secret,
+    variant: "legacy"
+  };
+}
+function decryptSessionMetadata(session, credentials) {
+  const encryption = resolveSessionEncryption(session, credentials);
+  const encryptedMetadata = decodeBase64(session.metadata);
+  const metadata = encryption.variant === "dataKey" ? decryptWithDataKey(encryptedMetadata, encryption.key) : decryptLegacy(encryptedMetadata, encryption.key);
+  if (!metadata) {
+    throw new Error(`Failed to decrypt metadata for Happy session ${session.id}`);
+  }
+  try {
+    return ResumableMetadataSchema.parse(metadata);
+  } catch {
+    throw new Error(`Happy session ${session.id} is missing resumable metadata.`);
+  }
+}
+async function fetchSessions(credentials) {
+  try {
+    const response = await axios.get(`${configuration.serverUrl}/v1/sessions`, {
+      headers: {
+        Authorization: `Bearer ${credentials.token}`,
+        "X-Happy-Client": `cli-coding-session/${configuration.currentCliVersion}`
+      }
+    });
+    return response.data.sessions;
+  } catch (error) {
+    if (error instanceof AxiosError) {
+      if (error.response?.status === 401) {
+        throw new Error(
+          "Legacy CLI resume authentication expired. Re-provision it from the source-only internal control-plane prototype; do not install the unrelated npm package named happy-agent."
+        );
+      }
+      throw new Error(`Failed to load Happy sessions: ${error.message}`);
+    }
+    throw error;
+  }
+}
+async function resolveHappySession(sessionId) {
+  const credentials = readAgentCredentials();
+  const sessions = await fetchSessions(credentials);
+  const matched = resolveSessionRecordByPrefix(sessions, sessionId);
+  return {
+    id: matched.id,
+    active: matched.active,
+    metadata: decryptSessionMetadata(matched, credentials)
+  };
+}
+
+function parseResumeCommandArgs(args) {
+  if (args.includes("-h") || args.includes("--help")) {
+    return {
+      showHelp: true,
+      sessionId: ""
+    };
+  }
+  if (args.length === 0) {
+    throw new Error("Happy session ID is required: very-happy resume <session-id>");
+  }
+  if (args.length > 1) {
+    throw new Error(`Unexpected arguments for very-happy resume: ${args.slice(1).join(" ")}`);
+  }
+  return {
+    showHelp: false,
+    sessionId: args[0]
+  };
+}
+function resolveFlavor(metadata) {
+  if (metadata.flavor === "codex" || metadata.codexThreadId) {
+    return "codex";
+  }
+  if (metadata.flavor === "claude" || metadata.claudeSessionId) {
+    return "claude";
+  }
+  return null;
+}
+function buildResumeLaunch(session, options = {}) {
+  const { metadata } = session;
+  const flavor = resolveFlavor(metadata);
+  if (flavor === "codex") {
+    const args = ["codex"];
+    if (options.freshConversation) ; else {
+      if (!metadata.codexThreadId) {
+        throw new Error(`Happy session ${session.id} is missing its Codex thread ID.`);
+      }
+      args.push("--resume", metadata.codexThreadId);
+    }
+    if (options.startedBy) {
+      args.push("--started-by", options.startedBy);
+    }
+    return {
+      cwd: metadata.path,
+      args
+    };
+  }
+  if (flavor === "claude") {
+    const args = ["claude"];
+    if (options.claudeStartingMode) {
+      args.push("--happy-starting-mode", options.claudeStartingMode);
+    }
+    if (options.startedBy) {
+      args.push("--started-by", options.startedBy);
+    }
+    if (options.freshConversation) ; else {
+      if (!metadata.claudeSessionId) {
+        throw new Error(`Happy session ${session.id} is missing its Claude session ID.`);
+      }
+      args.push("--resume", metadata.claudeSessionId);
+    }
+    return {
+      cwd: metadata.path,
+      args
+    };
+  }
+  throw new Error(`Happy session ${session.id} uses unsupported flavor "${metadata.flavor ?? "unknown"}".`);
+}
+function formatResumeHelp() {
+  return [
+    "very-happy resume - Resume a previous Happy session",
+    "",
+    "Usage:",
+    "  very-happy resume <happy-session-id>",
+    "",
+    "Examples:",
+    "  very-happy resume cmmij8olq00dp5jcxr3wtbpau",
+    "  very-happy resume cmmij8",
+    "",
+    "This reuses the saved worktree/path and resumes the underlying agent session",
+    "when the backend supports it."
+  ].join("\n");
+}
+function spawnResumeChild(launch) {
+  return new Promise((resolve, reject) => {
+    const child = spawnHappyCLI(launch.args, {
+      cwd: launch.cwd,
+      env: process.env,
+      stdio: "inherit"
+    });
+    child.once("error", reject);
+    child.once("exit", (code, signal) => {
+      if (signal) {
+        reject(new Error(`Resumed session exited via signal ${signal}`));
+        return;
+      }
+      resolve(code);
+    });
+  });
+}
+async function handleResumeCommand(args) {
+  const parsed = parseResumeCommandArgs(args);
+  if (parsed.showHelp) {
+    console.log(formatResumeHelp());
+    return;
+  }
+  const session = await resolveHappySession(parsed.sessionId);
+  const launch = buildResumeLaunch(session);
+  if (!existsSync(launch.cwd)) {
+    throw new Error(`Saved session path does not exist: ${launch.cwd}`);
+  }
+  const exitCode = await spawnResumeChild(launch);
+  if (typeof exitCode === "number" && exitCode !== 0) {
+    process.exit(exitCode);
+  }
+}
+
+export { buildResumeLaunch, formatResumeHelp, handleResumeCommand, parseResumeCommandArgs };