very-happy-cli 0.2.159 → 0.2.161

package/dist/assistantTools-BfA0R3_m.cjs

@@ -0,0 +1,380 @@
+'use strict';
+
+var promises = require('node:fs/promises');
+var os = require('node:os');
+var z = require('zod');
+var logger = require('./logger-Bc8-u1w0.cjs');
+var persistence = require('./persistence-CBNMzSa8.cjs');
+var controlClient = require('./controlClient-fEHE85bH.cjs');
+var sessionOps = require('./sessionOps-DJdExmBy.cjs');
+var remoteSessionClient = require('./remoteSessionClient-BNx78NLb.cjs');
+var ids = require('./ids-B6ZC0HGt.cjs');
+var terminals = require('./terminals-B_bfC9c2.cjs');
+var bootstrap = require('./bootstrap-CkgIq8N3.cjs');
+var path = require('node:path');
+
+const PERSONAL_MEMORY_SOFT_LIMIT_CHARS = 2e3;
+function headingTitle(line) {
+  const m = /^##(?!#)\s*(.*?)\s*$/.exec(line);
+  return m ? m[1] : null;
+}
+function applyMemorySectionUpdate(doc, section, content) {
+  const wanted = section.trim();
+  const normalizedContent = content.replace(/\s+$/, "");
+  const sectionBlock = `## ${wanted}
+
+${normalizedContent}
+`;
+  const lines = doc.split("\n");
+  let start = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (headingTitle(lines[i]) === wanted) {
+      start = i;
+      break;
+    }
+  }
+  if (start === -1) {
+    const base = doc.replace(/\s+$/, "");
+    const doc22 = base.length > 0 ? `${base}
+
+${sectionBlock}` : sectionBlock;
+    return { doc: doc22, replaced: false };
+  }
+  let end = lines.length;
+  for (let i = start + 1; i < lines.length; i++) {
+    if (headingTitle(lines[i]) !== null) {
+      end = i;
+      break;
+    }
+  }
+  const before = lines.slice(0, start).join("\n");
+  const after = lines.slice(end).join("\n");
+  let doc2 = before.length > 0 ? `${before.replace(/\s+$/, "")}
+
+` : "";
+  doc2 += sectionBlock;
+  if (after.trim().length > 0) {
+    doc2 += `
+${after.replace(/\s+$/, "")}
+`;
+  }
+  return { doc: doc2, replaced: true };
+}
+function journalPathForDate(home, date) {
+  const y = date.getFullYear();
+  const m = String(date.getMonth() + 1).padStart(2, "0");
+  const d = String(date.getDate()).padStart(2, "0");
+  return `${home}/memory/journal/${y}-${m}-${d}.md`;
+}
+
+function normalizeSpawnDirectory(input, homeDir) {
+  const trimmed = typeof input === "string" ? input.trim() : "";
+  if (trimmed.length === 0) {
+    return { ok: false, error: "directory is required" };
+  }
+  let expanded = trimmed;
+  if (trimmed === "~") {
+    expanded = homeDir;
+  } else if (trimmed.startsWith("~/")) {
+    expanded = path.join(homeDir, trimmed.slice(2));
+  } else if (trimmed.startsWith("~")) {
+    return { ok: false, error: `Unsupported "~user" path: ${trimmed}. Use an absolute path.` };
+  }
+  if (!path.isAbsolute(expanded)) {
+    return { ok: false, error: `directory must be an absolute path (got "${trimmed}")` };
+  }
+  return { ok: true, directory: path.normalize(expanded) };
+}
+
+const ASSISTANT_SESSION_TOOL_NAMES = [
+  "sessions_list",
+  "session_read",
+  "session_send",
+  "session_spawn",
+  "session_kill",
+  "session_archive"
+];
+const ASSISTANT_TOOL_NAMES = [
+  ...ASSISTANT_SESSION_TOOL_NAMES,
+  "terminals_list",
+  "terminal_read",
+  "terminal_send",
+  "memory_update",
+  "journal_append"
+];
+const MCP_CLIENT_TAG = "assistant-mcp";
+function ok(text) {
+  return { content: [{ type: "text", text }], isError: false };
+}
+function fail(text) {
+  return { content: [{ type: "text", text }], isError: true };
+}
+function describeSession(id, persisted, extra) {
+  const meta = persisted?.metadata;
+  const parts = [id];
+  if (extra?.live !== void 0) parts.push(extra.live ? "[running]" : "[not running]");
+  if (meta?.summary?.text) parts.push(`title="${meta.summary.text}"`);
+  if (meta?.path) parts.push(`cwd=${meta.path}`);
+  if (meta?.flavor) parts.push(`agent=${meta.flavor}`);
+  if (meta?.tags?.length) parts.push(`tags=${meta.tags.join(",")}`);
+  if (meta?.variant === "assistant") parts.push("(assistant)");
+  if (extra?.pid) parts.push(`pid=${extra.pid}`);
+  parts.push(sessionOps.sessionWebUrl(id));
+  return parts.join(" ");
+}
+function describeSummary(summary) {
+  const parts = [summary.id, summary.live ? "[running]" : "[not running]"];
+  if (summary.title) parts.push(`title="${summary.title}"`);
+  if (summary.cwd) parts.push(`cwd=${summary.cwd}`);
+  if (summary.flavor) parts.push(`agent=${summary.flavor}`);
+  if (summary.tags?.length) parts.push(`tags=${summary.tags.join(",")}`);
+  if (summary.variant === "assistant") parts.push("(assistant)");
+  if (summary.pid !== void 0) parts.push(`pid=${summary.pid}`);
+  parts.push(summary.url);
+  return parts.join(" ");
+}
+function registerAssistantTools(mcp) {
+  registerAssistantSessionTools(mcp);
+  registerAssistantMachineTools(mcp);
+}
+function registerAssistantSessionTools(mcp) {
+  mcp.registerTool("sessions_list", {
+    description: "List Claude Code sessions on this machine: sessions currently tracked by the local daemon (running) plus recently seen ones. Returns id, title, working directory, agent flavor and web URL for each.",
+    title: "List Sessions",
+    inputSchema: {}
+  }, async () => {
+    try {
+      const sessions = await sessionOps.listSessions();
+      if (sessions.length === 0) return ok("No sessions found on this machine.");
+      return ok(`${sessions.length} session(s):
+${sessions.map(describeSummary).join("\n")}`);
+    } catch (error) {
+      return fail(`Failed to list sessions: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  });
+  mcp.registerTool("session_read", {
+    description: "Read the latest messages of a session as a compact role-tagged transcript (user / assistant / tool summaries; large payloads truncated). Sessions spawned by this machine are read directly; a session spawned by another machine of this account is read through that machine's daemon (it must be online).",
+    title: "Read Session Transcript",
+    inputSchema: {
+      sessionId: z.z.string().describe("The Happy session id to read"),
+      limit: z.z.number().optional().describe("How many recent messages to fetch (default 20, max 100)"),
+      machineId: z.z.string().optional().describe("Machine id the session runs on, when known (skips the lookup across the account's machines)")
+    }
+  }, async (args) => {
+    if (!ids.isValidSessionId(args.sessionId)) return fail("Invalid sessionId");
+    try {
+      const local = persistence.readPersistedSessions()[args.sessionId];
+      if (local && !args.machineId) {
+        const result2 = await sessionOps.readSessionTranscript(args.sessionId, args.limit ?? 20);
+        const body2 = result2.transcript.length > 0 ? result2.transcript : "(no readable conversation content in this range)";
+        return ok(`${describeSummary(result2.summary)}
+--- last ${result2.messageCount} message(s) ---
+${body2}`);
+      }
+      const result = await remoteSessionClient.readRemoteTranscript(args.sessionId, { limit: args.limit ?? 20, ...args.machineId ? { machineId: args.machineId } : {} });
+      const body = result.transcript.length > 0 ? result.transcript : "(no readable conversation content in this range)";
+      return ok(`${describeSummary(result.summary)} machine=${result.host} (${result.machineId})
+--- last ${result.messageCount} message(s)${result.truncated ? ", truncated to fit" : ""} ---
+${body}`);
+    } catch (error) {
+      return fail(`Failed to read session: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  });
+  mcp.registerTool("session_send", {
+    description: "Send a user message into an existing session. Only delivers when a live wrapper will read it: an archived / offline session is refused (the server would store the message unread) unless resume:true brings it back on its machine first. A session spawned by another machine of this account is delivered through that machine's daemon (it must be online). Returns immediately after delivery \u2014 it does NOT wait for the session to respond; use session_read later to check progress.",
+    title: "Send Message to Session",
+    inputSchema: {
+      sessionId: z.z.string().describe("The Happy session id to message"),
+      text: z.z.string().describe("The message text to send"),
+      resume: z.z.boolean().optional().describe("If the session is archived or offline, resume it on its machine (like the web Restore button) and wait until it is live before sending"),
+      machineId: z.z.string().optional().describe("Machine id the session runs on, when known (skips the lookup across the account's machines)")
+    }
+  }, async (args) => {
+    if (!ids.isValidSessionId(args.sessionId)) return fail("Invalid sessionId");
+    if (typeof args.text !== "string" || args.text.trim().length === 0) return fail("text must be non-empty");
+    try {
+      if (!persistence.readPersistedSessions()[args.sessionId] || args.machineId) {
+        const remote = await remoteSessionClient.sendRemoteMessage(args.sessionId, args.text, { resume: args.resume === true, sentFrom: "assistant", ...args.machineId ? { machineId: args.machineId } : {} });
+        if (!remote.delivered) {
+          const detail = remote.error ?? `session is ${remote.status}`;
+          return fail(remote.stored ? `Not delivered (via ${remote.machine.host}): ${detail}` : `Session ${args.sessionId} on ${remote.machine.host} is ${remote.status}: ${detail}`);
+        }
+        return ok(`Message delivered${remote.resumed ? ` (session resumed on ${remote.machine.host})` : ""} to ${args.sessionId} on machine ${remote.machine.host} (${remote.machine.id}) ${sessionOps.sessionWebUrl(args.sessionId)}`);
+      }
+      const persisted = await sessionOps.waitForSessionKey(args.sessionId, 0);
+      const result = await remoteSessionClient.deliverToSession(args.sessionId, persisted, args.text, MCP_CLIENT_TAG, {
+        resume: args.resume === true,
+        resumeHint: "Pass resume:true to bring it back on this machine, or spawn a new session."
+      });
+      if (!result.delivered) {
+        const detail = result.error ?? `session is ${result.status}`;
+        return fail(result.stored ? `Not delivered: ${detail}` : `Session ${args.sessionId} is ${result.status}: ${detail}`);
+      }
+      return ok(`Message delivered${result.resumed ? " (session resumed on this machine)" : ""} to ${describeSession(args.sessionId, persisted, { live: true })}`);
+    } catch (error) {
+      if (error instanceof remoteSessionClient.RemoteSessionOpsError) return fail(`Failed to send (${error.code}): ${error.message}`);
+      return fail(`Failed to send: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  });
+  mcp.registerTool("session_spawn", {
+    description: "Spawn a NEW Claude Code session in a directory via the local daemon, optionally sending its first prompt. Returns the session id and web URL immediately after dispatch \u2014 it does NOT wait for the task to run or finish.",
+    title: "Spawn Session",
+    inputSchema: {
+      directory: z.z.string().describe("Absolute working directory for the new session (a leading ~ is expanded)"),
+      prompt: z.z.string().optional().describe("Optional first message to send once the session is up")
+    }
+  }, async (args) => {
+    const normalized = normalizeSpawnDirectory(typeof args.directory === "string" ? args.directory : "", os.homedir());
+    if (!normalized.ok) return fail(normalized.error);
+    const directory = normalized.directory;
+    try {
+      const result = await controlClient.spawnDaemonSession(directory, void 0, { spawnedBy: "assistant" });
+      if (result?.error || !result?.sessionId) {
+        return fail(`Failed to spawn session: ${result?.error ?? "daemon returned no session id"}`);
+      }
+      const sessionId = result.sessionId;
+      const url = sessionOps.sessionWebUrl(sessionId);
+      if (args.prompt && args.prompt.trim().length > 0) {
+        try {
+          const persisted = await sessionOps.waitForSessionKey(sessionId, 15e3);
+          await sessionOps.sendUserMessage(sessionId, persisted, args.prompt, MCP_CLIENT_TAG);
+          return ok(`Spawned session ${sessionId} in ${directory} and sent the first prompt. It is now working in the background \u2014 check on it later with session_read. ${url}`);
+        } catch (error) {
+          return ok(`Spawned session ${sessionId} in ${directory}, but sending the first prompt failed (${error instanceof Error ? error.message : String(error)}). Use session_send to retry. ${url}`);
+        }
+      }
+      return ok(`Spawned idle session ${sessionId} in ${directory}. ${url}`);
+    } catch (error) {
+      return fail(`Failed to spawn session: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  });
+  mcp.registerTool("session_kill", {
+    description: "Stop a running session process on this machine (SIGTERM via the local daemon). Destructive \u2014 confirm with the user (repeat the session title/cwd) before calling.",
+    title: "Kill Session",
+    inputSchema: {
+      sessionId: z.z.string().describe("The Happy session id to stop")
+    }
+  }, async (args) => {
+    if (!ids.isValidSessionId(args.sessionId)) return fail("Invalid sessionId");
+    try {
+      const persisted = persistence.readPersistedSessions()[args.sessionId];
+      const success = await sessionOps.stopSession(args.sessionId);
+      if (!success) return fail(`Session ${args.sessionId} was not found among the daemon's running sessions.`);
+      return ok(`Stopped ${describeSession(args.sessionId, persisted)}`);
+    } catch (error) {
+      return fail(`Failed to stop session: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  });
+  mcp.registerTool("session_archive", {
+    description: "Mark a session inactive on the server (it disappears from the active list but stays resumable). Confirm with the user before calling.",
+    title: "Archive Session",
+    inputSchema: {
+      sessionId: z.z.string().describe("The Happy session id to archive")
+    }
+  }, async (args) => {
+    if (!ids.isValidSessionId(args.sessionId)) return fail("Invalid sessionId");
+    try {
+      await sessionOps.archiveSession(args.sessionId);
+      const persisted = persistence.readPersistedSessions()[args.sessionId];
+      return ok(`Archived ${describeSession(args.sessionId, persisted)}`);
+    } catch (error) {
+      return fail(`Failed to archive session: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  });
+}
+function registerAssistantMachineTools(mcp) {
+  mcp.registerTool("terminals_list", {
+    description: "List the web terminals (tmux sessions) on this machine with their id, title and working directory.",
+    title: "List Terminals",
+    inputSchema: {}
+  }, async () => {
+    const r = terminals.listVhTerminals();
+    if (!r.ok) return fail(`Failed to list terminals: ${r.error}`);
+    if (r.terminals.length === 0) return ok("No web terminals are open on this machine.");
+    const lines = r.terminals.map((t) => {
+      const parts = [t.id];
+      if (t.title) parts.push(`title="${t.title}"`);
+      if (t.cwd) parts.push(`cwd=${t.cwd}`);
+      return parts.join(" ");
+    });
+    return ok(`${r.terminals.length} terminal(s):
+${lines.join("\n")}`);
+  });
+  mcp.registerTool("terminal_read", {
+    description: "Read the last N lines of a web terminal's screen/history (tmux capture-pane).",
+    title: "Read Terminal",
+    inputSchema: {
+      terminalId: z.z.string().describe("The terminal id (from terminals_list)"),
+      lines: z.z.number().optional().describe("How many history lines to read (default 80, max 2000)")
+    }
+  }, async (args) => {
+    if (!ids.isValidTerminalId(args.terminalId)) return fail("Invalid terminalId");
+    const r = terminals.readVhTerminal(args.terminalId, args.lines ?? 80);
+    if (!r.ok) return fail(`Failed to read terminal ${args.terminalId}: ${r.error}`);
+    return ok(`terminal ${args.terminalId} \u2014 last output:
+${r.text}`);
+  });
+  mcp.registerTool("terminal_send", {
+    description: "Type text into a web terminal via tmux bracketed paste. By default the text is ONLY pasted (nothing executes); set submit=true to also press Enter \u2014 that actually runs it, so confirm with the user first.",
+    title: "Send to Terminal",
+    inputSchema: {
+      terminalId: z.z.string().describe("The terminal id (from terminals_list)"),
+      text: z.z.string().describe("The text to paste into the terminal"),
+      submit: z.z.boolean().optional().describe("Also press Enter after pasting (default false)")
+    }
+  }, async (args) => {
+    if (!ids.isValidTerminalId(args.terminalId)) return fail("Invalid terminalId");
+    if (typeof args.text !== "string" || args.text.length === 0) return fail("text must be non-empty");
+    const submit = args.submit === true;
+    const r = terminals.sendToVhTerminal(args.terminalId, args.text, submit);
+    if (!r.ok) return fail(`Failed to send to terminal ${args.terminalId}: ${r.error}`);
+    return ok(submit ? `Pasted and submitted (Enter sent) in terminal ${args.terminalId}.` : `Pasted into terminal ${args.terminalId} WITHOUT pressing Enter \u2014 the user (or a follow-up terminal_send with submit=true) decides whether it runs.`);
+  });
+  mcp.registerTool("memory_update", {
+    description: `Update one "## <section>" block of your personal memory file (memory/personal.md): replaces the section body if the heading exists, otherwise appends a new section. Keep the whole file under ~${PERSONAL_MEMORY_SOFT_LIMIT_CHARS} characters; most conversations need NO memory write.`,
+    title: "Update Personal Memory",
+    inputSchema: {
+      section: z.z.string().describe('The level-2 heading title (without "## ") to replace or create'),
+      content: z.z.string().describe("The new body for that section (replaces the old body entirely)")
+    }
+  }, async (args) => {
+    if (typeof args.section !== "string" || args.section.trim().length === 0) return fail("section must be non-empty");
+    try {
+      await bootstrap.bootstrapAssistantHome();
+      const path = bootstrap.assistantPersonalMemoryPath();
+      const doc = await promises.readFile(path, "utf8");
+      const { doc: updated, replaced } = applyMemorySectionUpdate(doc, args.section, args.content);
+      await promises.writeFile(path, updated, "utf8");
+      logger.logger.debug(`[assistant] memory_update section="${args.section}" replaced=${replaced} size=${updated.length}`);
+      const sizeNote = updated.length > PERSONAL_MEMORY_SOFT_LIMIT_CHARS ? ` WARNING: the file is now ${updated.length} chars (soft limit ~${PERSONAL_MEMORY_SOFT_LIMIT_CHARS}) \u2014 condense existing entries instead of adding more.` : ` File is now ${updated.length} chars.`;
+      return ok(`${replaced ? "Replaced" : "Appended"} section "${args.section.trim()}" in ${path}.${sizeNote}`);
+    } catch (error) {
+      return fail(`Failed to update memory: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  });
+  mcp.registerTool("journal_append", {
+    description: "Append a timestamped note to today's work journal (memory/journal/YYYY-MM-DD.md). Use before compaction to preserve important progress; append-only.",
+    title: "Append Work Journal",
+    inputSchema: {
+      content: z.z.string().describe("The note to append (plain text/markdown)")
+    }
+  }, async (args) => {
+    if (typeof args.content !== "string" || args.content.trim().length === 0) return fail("content must be non-empty");
+    try {
+      const { home } = await bootstrap.bootstrapAssistantHome();
+      const path = journalPathForDate(home, /* @__PURE__ */ new Date());
+      const stamp = (/* @__PURE__ */ new Date()).toTimeString().slice(0, 5);
+      await promises.appendFile(path, `
+- [${stamp}] ${args.content.trim()}
+`, "utf8");
+      logger.logger.debug(`[assistant] journal_append -> ${path}`);
+      return ok(`Appended to ${path}.`);
+    } catch (error) {
+      return fail(`Failed to append journal: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  });
+}
+
+exports.ASSISTANT_TOOL_NAMES = ASSISTANT_TOOL_NAMES;
+exports.registerAssistantSessionTools = registerAssistantSessionTools;
+exports.registerAssistantTools = registerAssistantTools;