very-happy-cli 0.2.158 → 0.2.160

package/dist/package-BwMrPwqH.cjs

@@ -0,0 +1,173 @@
+'use strict';
+
+var name = "very-happy-cli";
+var version = "0.2.160";
+var description = "Remote multi-agent workspace CLI with deep Claude integration, native terminal streaming, and self-hosting.";
+var author = "Kirill Dubovitskiy";
+var contributors = [
+	"Mereith (very-happy-cli fork)"
+];
+var license = "MIT";
+var engines = {
+	node: "^20.19.0 || ^22.13.0 || >=24.0.0"
+};
+var type = "module";
+var homepage = "https://github.com/Mereithhh/very-happy";
+var bugs = "https://github.com/Mereithhh/very-happy/issues";
+var repository = {
+	type: "git",
+	url: "git+https://github.com/Mereithhh/very-happy.git"
+};
+var bin = {
+	"very-happy": "./bin/very-happy.mjs",
+	"very-happy-mcp": "./bin/very-happy-mcp.mjs"
+};
+var main = "./dist/index.cjs";
+var module$1 = "./dist/index.mjs";
+var types = "./dist/index.d.cts";
+var exports$1 = {
+	"./pi-extension": {
+		types: "./dist/piExtension.d.mts",
+		"default": "./dist/piExtension.mjs"
+	},
+	".": {
+		require: {
+			types: "./dist/index.d.cts",
+			"default": "./dist/index.cjs"
+		},
+		"import": {
+			types: "./dist/index.d.mts",
+			"default": "./dist/index.mjs"
+		}
+	},
+	"./lib": {
+		require: {
+			types: "./dist/lib.d.cts",
+			"default": "./dist/lib.cjs"
+		},
+		"import": {
+			types: "./dist/lib.d.mts",
+			"default": "./dist/lib.mjs"
+		}
+	},
+	"./codex/happyMcpStdioBridge": {
+		require: {
+			types: "./dist/codex/happyMcpStdioBridge.d.cts",
+			"default": "./dist/codex/happyMcpStdioBridge.cjs"
+		},
+		"import": {
+			types: "./dist/codex/happyMcpStdioBridge.d.mts",
+			"default": "./dist/codex/happyMcpStdioBridge.mjs"
+		}
+	}
+};
+var files = [
+	"dist",
+	"bin",
+	"scripts",
+	"tools/licenses",
+	"package.json",
+	"README.md",
+	"LICENSE"
+];
+var scripts = {
+	typecheck: "tsc --noEmit",
+	"bundle:server": "node scripts/bundle-server.cjs",
+	"bundle:server:all": "node scripts/bundle-server.cjs --all-platforms",
+	"bundle:webapp": "node scripts/bundle-webapp.cjs",
+	build: "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && tsc --noEmit && pkgroll",
+	test: "pnpm run build && vitest run --project unit",
+	"test:integration": "pnpm run build && vitest run --project integration-empty --project integration-plan-mode --project integration-authenticated",
+	"cli:install": "node scripts/install-local.cjs",
+	prepublishOnly: "pnpm test",
+	postinstall: "node scripts/unpack-tools.cjs && node scripts/fix-pty-perms.cjs"
+};
+var dependencies = {
+	"@agentclientprotocol/sdk": "^0.14.1",
+	"@anthropic-ai/claude-agent-sdk": "0.3.281",
+	"@anthropic-ai/sandbox-runtime": "^0.0.37",
+	"@modelcontextprotocol/sdk": "1.30.0",
+	"@noble/ed25519": "^3.0.0",
+	"@noble/hashes": "^2.0.1",
+	"@paralleldrive/cuid2": "^2.2.2",
+	"@stablelib/base64": "^2.0.1",
+	"@stablelib/hex": "^2.0.1",
+	"@types/cross-spawn": "^6.0.6",
+	"@types/http-proxy": "^1.17.17",
+	"@types/react": "^19.2.7",
+	"@types/tmp": "^0.2.6",
+	axios: "^1.13.2",
+	chalk: "^5.6.2",
+	"cross-spawn": "^7.0.6",
+	"expo-server-sdk": "^3.15.0",
+	fastify: "5.8.5",
+	"fastify-type-provider-zod": "^6.1.0",
+	"http-proxy": "^1.18.1",
+	"http-proxy-middleware": "^3.0.7",
+	ink: "^6.5.1",
+	inquirer: "^13.2.2",
+	"node-pty": "^1.0.0",
+	open: "^10.2.0",
+	"ps-list": "^8.1.1",
+	react: "^19.2.0",
+	"socket.io-client": "^4.8.1",
+	tar: "^7.5.22",
+	tmp: "^0.2.7",
+	tweetnacl: "^1.0.3",
+	ws: "^8.21.3",
+	zod: "^4.0.0"
+};
+var optionalDependencies = {
+	"very-happy-tools-arm64-darwin": "0.2.160",
+	"very-happy-tools-x64-darwin": "0.2.160",
+	"very-happy-tools-arm64-linux": "0.2.160",
+	"very-happy-tools-x64-linux": "0.2.160",
+	"very-happy-tools-arm64-win32": "0.2.160",
+	"very-happy-tools-x64-win32": "0.2.160"
+};
+var devDependencies = {
+	"@slopus/happy-wire": "workspace:*",
+	"@xterm/addon-serialize": "0.13.0",
+	"@xterm/headless": "5.5.0",
+	"@types/inquirer": "^9.0.9",
+	"@types/node": ">=20",
+	"@types/ws": "^8.18.1",
+	"cross-env": "^10.1.0",
+	dotenv: "^16.6.1",
+	pkgroll: "^2.14.2",
+	"ts-node": "^10",
+	tsx: "^4.20.6",
+	typescript: "5.9.3",
+	vitest: "3.2.6"
+};
+var publishConfig = {
+	registry: "https://registry.npmjs.org"
+};
+var packageManager = "pnpm@10.11.0";
+var packageJson = {
+	name: name,
+	version: version,
+	description: description,
+	author: author,
+	contributors: contributors,
+	license: license,
+	engines: engines,
+	type: type,
+	homepage: homepage,
+	bugs: bugs,
+	repository: repository,
+	bin: bin,
+	main: main,
+	module: module$1,
+	types: types,
+	exports: exports$1,
+	files: files,
+	scripts: scripts,
+	dependencies: dependencies,
+	optionalDependencies: optionalDependencies,
+	devDependencies: devDependencies,
+	publishConfig: publishConfig,
+	packageManager: packageManager
+};
+
+exports.packageJson = packageJson;

package/dist/path-B7zW-WwE.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+var os = require('node:os');
+var path = require('node:path');
+
+function getClaudeConfigDir() {
+  return process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), ".claude");
+}
+function getClaudeProjectsRoot() {
+  return path.join(getClaudeConfigDir(), "projects");
+}
+function getProjectPath(workingDirectory) {
+  const projectId = path.resolve(workingDirectory).replace(/[^a-zA-Z0-9-]/g, "-");
+  return path.join(getClaudeProjectsRoot(), projectId);
+}
+
+exports.getClaudeProjectsRoot = getClaudeProjectsRoot;
+exports.getProjectPath = getProjectPath;

package/dist/path-D2wdaNSk.mjs

@@ -0,0 +1,15 @@
+import { homedir } from 'node:os';
+import { resolve, join } from 'node:path';
+
+function getClaudeConfigDir() {
+  return process.env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude");
+}
+function getClaudeProjectsRoot() {
+  return join(getClaudeConfigDir(), "projects");
+}
+function getProjectPath(workingDirectory) {
+  const projectId = resolve(workingDirectory).replace(/[^a-zA-Z0-9-]/g, "-");
+  return join(getClaudeProjectsRoot(), projectId);
+}
+
+export { getClaudeProjectsRoot as a, getProjectPath as g };

package/dist/peerTools-BTqw97Gb.mjs

@@ -0,0 +1,272 @@
+import { randomUUID } from 'node:crypto';
+import { userInfo, hostname } from 'node:os';
+import { z } from 'zod';
+import { i as isValidSessionId } from './ids-DU6sLx4C.mjs';
+import { f as listDaemonPeers } from './controlClient-BGbDcgWS.mjs';
+import { readPersistedSessions } from './persistence-HGW_ZVs9.mjs';
+import { s as sessionWebUrl, g as sendUserMessage } from './sessionOps-SuHW8Dfe.mjs';
+import { b as sendRemotePeerMessage, d as deliverToSession, a as listRemotePeers } from './remoteSessionClient-CYnXRynE.mjs';
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { resolve, isAbsolute, dirname } from 'node:path';
+
+const SESSION_PEER_SENT_FROM = "session-peer";
+const CLI_PEER_SENDER_ID = "cli";
+const MESSAGE_FOOTER = "This message comes from another agent session on this machine, not from the user.";
+const MESSAGE_FOOTER_PREFIX = "This message comes from another agent session";
+function messageFooterFor(sender) {
+  return sender.machine ? `${MESSAGE_FOOTER_PREFIX} on machine ${sanitizeHeaderValue(sender.machine, 128)}, not from the user.` : MESSAGE_FOOTER;
+}
+function sanitizeHeaderValue(value, max = 200) {
+  if (!value) return "";
+  const collapsed = value.replace(/\s+/g, " ").trim().slice(0, max);
+  return collapsed.replace(/[%"\];]/g, (ch) => `%${ch.charCodeAt(0).toString(16).toUpperCase().padStart(2, "0")}`);
+}
+function senderFields(sender) {
+  const parts = [];
+  if (sender.flavor) parts.push(`agent ${sanitizeHeaderValue(sender.flavor, 32)}`);
+  if (sender.cwd) parts.push(`cwd ${sanitizeHeaderValue(sender.cwd, 400)}`);
+  if (sender.machine) parts.push(`machine ${sanitizeHeaderValue(sender.machine, 128)}`);
+  return parts.map((part) => `; ${part}`).join("");
+}
+function quotedTitle(sender) {
+  return `"${sanitizeHeaderValue(sender.title, 120)}"`;
+}
+function formatSessionPeerMessage(input) {
+  const header = `[Very Happy session message ${input.id} from ${quotedTitle(input.from)} ${input.from.sessionId}${senderFields(input.from)}${input.replyTo ? `; re ${sanitizeHeaderValue(input.replyTo, 64)}` : ""}]`;
+  const base = messageFooterFor(input.from);
+  const routed = input.from.machine ? " (it is routed to that machine for you)" : "";
+  const footer = input.from.sessionId === CLI_PEER_SENDER_ID ? `${base} It was sent from the command line (\`very-happy sessions message\`), so there is no session to reply to; act on it here.` : `${base} Reply with session_message(to: "${input.from.sessionId}")${routed} \u2014 or \`very-happy sessions message ${input.from.sessionId} "<text>"\` \u2014 only when you have something to add (a question, a decision, a heads-up). Do not reply just to acknowledge or thank; the exchange ends when nothing is left to coordinate.`;
+  return `${header}
+${input.body.trim()}
+
+${footer}`;
+}
+function formatDuration(ms) {
+  const seconds = Math.max(0, Math.round(ms / 1e3));
+  if (seconds < 90) return `${seconds}s`;
+  const minutes = Math.round(seconds / 60);
+  if (minutes < 90) return `${minutes}m`;
+  return `${Math.round(minutes / 60)}h`;
+}
+function formatEditConflictNotice(input) {
+  const paths = input.paths && input.paths.length > 0 ? input.paths : [input.path];
+  const more = paths.length - 1;
+  const header = `[Very Happy edit conflict ${input.id}; file ${sanitizeHeaderValue(paths[0], 600)}${more > 0 ? `; more ${more}` : ""}; peer ${quotedTitle(input.peer)} ${input.peer.sessionId}${senderFields(input.peer)}; peer edited ${formatDuration(input.peerEditedAgoMs)} ago]`;
+  const window = formatDuration(input.windowMs);
+  const mirror = input.peer.flavor === "terminal-mirror";
+  const what = more > 0 ? `the same ${paths.length} files` : "the same file";
+  const advice = mirror ? `The peer is a terminal session (agent terminal-mirror): it cannot be messaged, and the person at that terminal owns those edits \u2014 re-read the file before changing it further and keep your change minimal.` : `No lock is held \u2014 coordinate before continuing: session_message(to: "${input.peer.sessionId}", body: "\u2026") saying what you are changing in ${more > 0 ? "these files" : "that file"} and asking what they are changing. One message that covers everything; do not send one per file.`;
+  const list = more > 0 ? `
+Files:
+${paths.map((p) => `- ${p}`).join("\n")}` : "";
+  return `${header}
+Another session on this machine edited ${what} within the last ${window}. Both sessions received this notice. ${advice}${list}`;
+}
+
+const realFs = {
+  existsSync,
+  isDirectory: (path) => {
+    try {
+      return statSync(path).isDirectory();
+    } catch {
+      return false;
+    }
+  },
+  readFileSync: (path) => readFileSync(path, "utf8")
+};
+function resolveRepoIdentity(cwd, fs = realFs) {
+  let dir = resolve(cwd);
+  for (let depth = 0; depth < 64; depth++) {
+    const dotGit = resolve(dir, ".git");
+    try {
+      if (fs.existsSync(dotGit)) {
+        if (fs.isDirectory(dotGit)) return { root: dir, common: dotGit };
+        const gitdir = fs.readFileSync(dotGit).match(/^gitdir:\s*(.+?)\s*$/m)?.[1];
+        if (gitdir) {
+          const absolute = isAbsolute(gitdir) ? gitdir : resolve(dir, gitdir);
+          const worktree = absolute.match(/^(.*[\\/]\.git)[\\/]worktrees[\\/][^\\/]+[\\/]?$/);
+          return { root: dir, common: worktree ? worktree[1] : absolute };
+        }
+        return { root: dir, common: dotGit };
+      }
+    } catch {
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return { root: null, common: null };
+}
+const PEER_SCOPES = ["repo", "cwd", "machine"];
+function isPeerInScope(scope, self, other) {
+  if (scope === "machine") return true;
+  if (scope === "cwd") return resolve(self.cwd) === resolve(other.cwd);
+  if (self.repo.common && other.repo.common) return self.repo.common === other.repo.common;
+  return resolve(self.cwd) === resolve(other.cwd);
+}
+
+const SESSION_PEER_TOOL_NAMES = ["session_message", "session_peers"];
+const SESSION_PEER_TOOL_SCHEMAS = {
+  session_message: {
+    title: "Message Another Session",
+    readOnly: false,
+    description: "Send a message to another agent session (find ids with session_peers). It lands in that session's chat with your title, session id and cwd, and tells the peer how to reply to you. Use it to coordinate when you both edit the same files: say what you are changing and ask what they are changing. Returns as soon as the message is queued; the reply arrives later as a message from that session. Sessions on this machine are reached directly; a session spawned by another machine of this account is routed to that machine's daemon (it must be online). Terminal-mirror sessions cannot receive messages.",
+    inputSchema: {
+      to: z.string().min(1).max(128).describe("Target session id (from session_peers, or a peer's message header)"),
+      body: z.string().min(1).max(16e3).describe("The message text"),
+      replyTo: z.string().min(1).max(64).optional().describe("Id of the peer message you are answering (from its header), if any"),
+      machineId: z.string().min(1).max(128).optional().describe("Machine id the target session runs on, when known (skips the lookup across the account's machines)")
+    }
+  },
+  session_peers: {
+    title: "List Peer Sessions",
+    readOnly: true,
+    description: 'List the other agent sessions running on this machine and the files each edited in the last 30 minutes. Default scope "repo": sessions in the same git repository, including its other worktrees (sameWorktree says whether they share your checkout). "cwd": the same directory only. "machine": every live session here. With machineId, list the live sessions on that other machine of this account instead (scope "machine" unless you pass a cwd that exists there).',
+    inputSchema: {
+      scope: z.enum(["repo", "cwd", "machine"]).optional().describe("repo (default) | cwd | machine"),
+      machineId: z.string().min(1).max(128).optional().describe("Another machine of this account (from the web's machine list) to list instead of this one"),
+      cwd: z.string().min(1).max(4096).optional().describe("With machineId: a directory on that machine to compute repo/cwd scope from")
+    }
+  }
+};
+const PEER_MESSAGE_RATE_LIMIT = 8;
+const PEER_MESSAGE_RATE_WINDOW_MS = 10 * 6e4;
+async function listPeerSessions(context, scope = "repo") {
+  const self = context.self();
+  const repoOf = context.repoOf ?? resolveRepoIdentity;
+  const selfRepo = repoOf(self.cwd);
+  const sessions = await (context.listPeers ?? listDaemonPeers)();
+  const peers = sessions.filter((session) => session.sessionId !== self.sessionId).filter((session) => {
+    const cwd = session.cwd ?? "";
+    if (!cwd) return scope === "machine";
+    return isPeerInScope(scope, { cwd: self.cwd, repo: selfRepo }, { cwd, repo: repoOf(cwd) });
+  }).map((session) => ({
+    ...session,
+    url: sessionWebUrl(session.sessionId),
+    sameWorktree: !!session.cwd && !!selfRepo.root && repoOf(session.cwd).root === selfRepo.root
+  }));
+  return { self: { sessionId: self.sessionId, cwd: self.cwd, repoRoot: selfRepo.root, scope }, scope, peers };
+}
+function defaultDeliver(to, persisted, text, localId) {
+  return deliverToSession(to, persisted, text, "session-message", {
+    sentFrom: SESSION_PEER_SENT_FROM,
+    resumeHint: "It has to be running to read a peer message; spawn a new session or ask the person."
+  }, {
+    send: (sessionId, key, body, client, options) => sendUserMessage(sessionId, key, body, client, { ...options, localId })
+  });
+}
+function checkPeerSendBudget(sentTo, to, now, limit = PEER_MESSAGE_RATE_LIMIT, windowMs = PEER_MESSAGE_RATE_WINDOW_MS) {
+  const recent = (sentTo.get(to) ?? []).filter((t) => now - t <= windowMs);
+  sentTo.set(to, recent);
+  return { ok: recent.length < limit, count: recent.length };
+}
+async function sendPeerMessage(context, args) {
+  const self = context.self();
+  if (!isValidSessionId(args.to)) throw new Error("Invalid session id");
+  if (args.to === self.sessionId) throw new Error("That is this session; message a peer instead");
+  const body = typeof args.body === "string" ? args.body.trim() : "";
+  if (!body) throw new Error("body must be non-empty");
+  const now = (context.now ?? Date.now)();
+  const persisted = (context.readPersisted ?? readPersistedSessions)()[args.to];
+  if (!persisted || args.machineId) {
+    const remote = context.remoteMessage === void 0 ? sendRemotePeerMessage : context.remoteMessage;
+    if (remote === null) {
+      throw new Error(`Session ${args.to} is not on this machine (no local key)`);
+    }
+    if (context.sentTo) {
+      const budget = checkPeerSendBudget(context.sentTo, args.to, now);
+      if (!budget.ok) throw new Error(replyLoopRefusal(budget.count, args.to));
+    }
+    const result2 = await remote({ to: args.to, body, replyTo: args.replyTo, from: self, machineId: args.machineId });
+    context.sentTo?.get(args.to)?.push(now);
+    return result2;
+  }
+  const live = (await (context.listPeers ?? listDaemonPeers)()).find((session) => session.sessionId === args.to);
+  if (!live) throw new Error(`Session ${args.to} is not running on this machine; nothing would read the message`);
+  if (live.kind === "mirror") throw new Error(`Session ${args.to} is a terminal mirror (a person typing claude in a terminal); it cannot receive messages`);
+  if (context.sentTo) {
+    const budget = checkPeerSendBudget(context.sentTo, args.to, now);
+    if (!budget.ok) throw new Error(replyLoopRefusal(budget.count, args.to));
+  }
+  const messageId = randomUUID().slice(0, 8);
+  const text = formatSessionPeerMessage({ id: messageId, from: self, body, replyTo: args.replyTo });
+  const result = await (context.deliver ?? defaultDeliver)(args.to, persisted, text, `session-message-${messageId}`);
+  context.sentTo?.get(args.to)?.push(now);
+  return {
+    delivered: result.delivered,
+    stored: result.stored,
+    status: result.status,
+    messageId,
+    to: args.to,
+    url: sessionWebUrl(args.to),
+    ...result.error ? { error: result.error } : {}
+  };
+}
+function replyLoopRefusal(count, to) {
+  return `Refused: this session already sent ${count} messages to ${to} in the last ${Math.round(PEER_MESSAGE_RATE_WINDOW_MS / 6e4)} minutes. That is a reply loop, not coordination \u2014 STOP replying to that session now; do not send acknowledgements or thanks. Continue your own work.`;
+}
+async function executeSessionPeerTool(name, args, context) {
+  switch (name) {
+    case "session_message":
+      return sendPeerMessage(context, {
+        to: String(args?.to ?? ""),
+        body: String(args?.body ?? ""),
+        ...args?.replyTo ? { replyTo: String(args.replyTo) } : {},
+        ...args?.machineId ? { machineId: String(args.machineId) } : {}
+      });
+    case "session_peers": {
+      const scope = args?.scope;
+      if (scope !== void 0 && !PEER_SCOPES.includes(scope)) throw new Error(`scope must be one of ${PEER_SCOPES.join(", ")}`);
+      if (args?.machineId) {
+        return (context.remotePeers ?? listRemotePeers)(String(args.machineId), {
+          ...scope !== void 0 ? { scope } : {},
+          ...typeof args.cwd === "string" && args.cwd ? { cwd: args.cwd } : {}
+        });
+      }
+      return listPeerSessions(context, scope ?? "repo");
+    }
+  }
+}
+function cliPeerSelf(env, cwd, persisted) {
+  const sessionId = env.VH_PEER_SESSION_ID;
+  if (sessionId && isValidSessionId(sessionId)) {
+    const meta = persisted[sessionId]?.metadata;
+    return { sessionId, title: meta?.summary?.text, flavor: meta?.flavor, cwd: meta?.path ?? cwd };
+  }
+  let user = "user";
+  try {
+    user = userInfo().username;
+  } catch {
+  }
+  return { sessionId: CLI_PEER_SENDER_ID, title: `cli ${user}@${hostname()}`, flavor: "cli", cwd };
+}
+function createSessionPeerToolExecutor(client) {
+  const context = {
+    self: () => {
+      const meta = client.getMetadata();
+      return { sessionId: client.sessionId, title: meta?.summary?.text, flavor: meta?.flavor, cwd: meta?.path ?? process.cwd() };
+    },
+    // One budget per session process: the reply-loop guard.
+    sentTo: /* @__PURE__ */ new Map()
+  };
+  return (name, args) => executeSessionPeerTool(name, args, context);
+}
+function registerSessionPeerTools(server, execute) {
+  for (const name of SESSION_PEER_TOOL_NAMES) {
+    const spec = SESSION_PEER_TOOL_SCHEMAS[name];
+    server.registerTool(name, {
+      description: spec.description,
+      title: spec.title,
+      inputSchema: spec.inputSchema,
+      annotations: { readOnlyHint: spec.readOnly, idempotentHint: spec.readOnly, openWorldHint: false, destructiveHint: false }
+    }, async (args) => {
+      try {
+        return { content: [{ type: "text", text: JSON.stringify(await execute(name, args ?? {})) }], isError: false };
+      } catch (error) {
+        return { content: [{ type: "text", text: error instanceof Error ? error.message : "Session peer operation failed" }], isError: true };
+      }
+    });
+  }
+}
+
+export { CLI_PEER_SENDER_ID as C, PEER_SCOPES as P, SESSION_PEER_TOOL_NAMES as S, createSessionPeerToolExecutor as a, SESSION_PEER_SENT_FROM as b, cliPeerSelf as c, formatEditConflictNotice as f, listPeerSessions as l, registerSessionPeerTools as r, sendPeerMessage as s };