very-happy-cli 0.2.158 → 0.2.160

package/dist/constants-VJ0N6WuG.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+var trimIdent = require('./trimIdent-4gvk9Wk6.cjs');
+
+const GEMINI_API_KEY_ENV = "GEMINI_API_KEY";
+const GOOGLE_API_KEY_ENV = "GOOGLE_API_KEY";
+const GEMINI_MODEL_ENV = "GEMINI_MODEL";
+const DEFAULT_GEMINI_MODEL = "gemini-2.5-pro";
+const CHANGE_TITLE_INSTRUCTION = trimIdent.trimIdent(
+  `Based on this message, call functions.happy__change_title to change chat session title that would represent the current task. If chat idea would change dramatically - call this function again to update the title.`
+);
+
+exports.CHANGE_TITLE_INSTRUCTION = CHANGE_TITLE_INSTRUCTION;
+exports.DEFAULT_GEMINI_MODEL = DEFAULT_GEMINI_MODEL;
+exports.GEMINI_API_KEY_ENV = GEMINI_API_KEY_ENV;
+exports.GEMINI_MODEL_ENV = GEMINI_MODEL_ENV;
+exports.GOOGLE_API_KEY_ENV = GOOGLE_API_KEY_ENV;

package/dist/contentLogMetadata-BlWI0egu.mjs

@@ -0,0 +1,51 @@
+function serializedByteLength(value) {
+  try {
+    const serialized = JSON.stringify(value);
+    return serialized === void 0 ? void 0 : Buffer.byteLength(serialized, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+function contentLogMetadata(value) {
+  if (typeof value === "string") {
+    return {
+      valueType: "string",
+      valueBytes: Buffer.byteLength(value, "utf8")
+    };
+  }
+  if (Array.isArray(value)) {
+    return {
+      valueType: "array",
+      itemCount: value.length,
+      payloadBytes: serializedByteLength(value)
+    };
+  }
+  if (value && typeof value === "object") {
+    return {
+      valueType: "object",
+      keyCount: Object.keys(value).length,
+      payloadBytes: serializedByteLength(value)
+    };
+  }
+  return { valueType: value === null ? "null" : typeof value };
+}
+function errorLogMetadata(error) {
+  if (error instanceof Error) {
+    const code = error.code;
+    return {
+      errorType: error.name || "Error",
+      ...typeof code === "string" ? { errorCode: code } : {}
+    };
+  }
+  if (error && typeof error === "object") {
+    const record = error;
+    const code = record.code;
+    return {
+      errorType: "object",
+      ...typeof code === "string" || typeof code === "number" ? { errorCode: code } : {}
+    };
+  }
+  return { errorType: error === null ? "null" : typeof error };
+}
+
+export { contentLogMetadata as c, errorLogMetadata as e };

package/dist/contentLogMetadata-ZSFk_NjQ.cjs

@@ -0,0 +1,54 @@
+'use strict';
+
+function serializedByteLength(value) {
+  try {
+    const serialized = JSON.stringify(value);
+    return serialized === void 0 ? void 0 : Buffer.byteLength(serialized, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+function contentLogMetadata(value) {
+  if (typeof value === "string") {
+    return {
+      valueType: "string",
+      valueBytes: Buffer.byteLength(value, "utf8")
+    };
+  }
+  if (Array.isArray(value)) {
+    return {
+      valueType: "array",
+      itemCount: value.length,
+      payloadBytes: serializedByteLength(value)
+    };
+  }
+  if (value && typeof value === "object") {
+    return {
+      valueType: "object",
+      keyCount: Object.keys(value).length,
+      payloadBytes: serializedByteLength(value)
+    };
+  }
+  return { valueType: value === null ? "null" : typeof value };
+}
+function errorLogMetadata(error) {
+  if (error instanceof Error) {
+    const code = error.code;
+    return {
+      errorType: error.name || "Error",
+      ...typeof code === "string" ? { errorCode: code } : {}
+    };
+  }
+  if (error && typeof error === "object") {
+    const record = error;
+    const code = record.code;
+    return {
+      errorType: "object",
+      ...typeof code === "string" || typeof code === "number" ? { errorCode: code } : {}
+    };
+  }
+  return { errorType: error === null ? "null" : typeof error };
+}
+
+exports.contentLogMetadata = contentLogMetadata;
+exports.errorLogMetadata = errorLogMetadata;

package/dist/context-DsDr6E2t.cjs

@@ -0,0 +1,69 @@
+'use strict';
+
+var promises = require('node:fs/promises');
+var node_fs = require('node:fs');
+var path = require('node:path');
+var node_crypto = require('node:crypto');
+var z = require('zod');
+var configuration = require('./configuration-BSYpcPwE.cjs');
+
+const TeamScopeSchema = z.z.object({
+  serverUrl: z.z.string(),
+  scopeToken: z.z.string().min(1),
+  teamId: z.z.string().min(1),
+  botId: z.z.string().min(1),
+  taskId: z.z.string().optional(),
+  attemptId: z.z.string().optional()
+});
+function teamScopePath(sessionId) {
+  const supplied = process.env.VH_TEAM_SCOPE_FILE;
+  if (supplied) {
+    if (!path.isAbsolute(supplied)) throw new Error("VH_TEAM_SCOPE_FILE must be absolute");
+    return supplied;
+  }
+  if (!sessionId || !/^[a-zA-Z0-9_-]+$/.test(sessionId)) throw new Error("Teams requires a managed session or VH_TEAM_SCOPE_FILE");
+  return path.join(configuration.configuration.happyHomeDir, "teams", "scopes", `${sessionId}.json`);
+}
+async function readTeamScope(path) {
+  let file;
+  try {
+    file = await promises.open(path, node_fs.constants.O_RDONLY | (node_fs.constants.O_NOFOLLOW ?? 0));
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw new Error("Cannot open team scope");
+  }
+  try {
+    const stat = await file.stat();
+    if (typeof process.getuid === "function" && stat.uid !== process.getuid()) throw new Error("Team scope owner mismatch");
+    if (!stat.isFile() || process.platform !== "win32" && (stat.mode & 63) !== 0) throw new Error("Team scope must be a private 0600 file");
+    const scope = TeamScopeSchema.parse(JSON.parse(await file.readFile("utf8")));
+    scope.serverUrl = configuration.normalizeHttpEndpoint(scope.serverUrl, "team scope");
+    if (scope.serverUrl !== configuration.configuration.serverUrl) throw new Error("Team scope belongs to another server");
+    return scope;
+  } catch {
+    throw new Error("Invalid or unsafe team scope file");
+  } finally {
+    await file.close();
+  }
+}
+async function writeTeamScope(path$1, scope) {
+  await promises.mkdir(path.dirname(path$1), { recursive: true, mode: 448 });
+  const temporary = `${path$1}.${node_crypto.randomUUID()}.new`;
+  const file = await promises.open(temporary, "wx", 384);
+  try {
+    await file.writeFile(JSON.stringify(TeamScopeSchema.parse(scope)));
+    await file.sync();
+  } finally {
+    await file.close();
+  }
+  try {
+    await promises.rename(temporary, path$1);
+  } finally {
+    await promises.unlink(temporary).catch(() => {
+    });
+  }
+}
+
+exports.readTeamScope = readTeamScope;
+exports.teamScopePath = teamScopePath;
+exports.writeTeamScope = writeTeamScope;

package/dist/context-H0Bcb9S_.mjs

@@ -0,0 +1,65 @@
+import { open, mkdir, rename, unlink } from 'node:fs/promises';
+import { constants } from 'node:fs';
+import { isAbsolute, join, dirname } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { z } from 'zod';
+import { n as normalizeHttpEndpoint, c as configuration } from './configuration-RfeNjFmd.mjs';
+
+const TeamScopeSchema = z.object({
+  serverUrl: z.string(),
+  scopeToken: z.string().min(1),
+  teamId: z.string().min(1),
+  botId: z.string().min(1),
+  taskId: z.string().optional(),
+  attemptId: z.string().optional()
+});
+function teamScopePath(sessionId) {
+  const supplied = process.env.VH_TEAM_SCOPE_FILE;
+  if (supplied) {
+    if (!isAbsolute(supplied)) throw new Error("VH_TEAM_SCOPE_FILE must be absolute");
+    return supplied;
+  }
+  if (!sessionId || !/^[a-zA-Z0-9_-]+$/.test(sessionId)) throw new Error("Teams requires a managed session or VH_TEAM_SCOPE_FILE");
+  return join(configuration.happyHomeDir, "teams", "scopes", `${sessionId}.json`);
+}
+async function readTeamScope(path) {
+  let file;
+  try {
+    file = await open(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw new Error("Cannot open team scope");
+  }
+  try {
+    const stat = await file.stat();
+    if (typeof process.getuid === "function" && stat.uid !== process.getuid()) throw new Error("Team scope owner mismatch");
+    if (!stat.isFile() || process.platform !== "win32" && (stat.mode & 63) !== 0) throw new Error("Team scope must be a private 0600 file");
+    const scope = TeamScopeSchema.parse(JSON.parse(await file.readFile("utf8")));
+    scope.serverUrl = normalizeHttpEndpoint(scope.serverUrl, "team scope");
+    if (scope.serverUrl !== configuration.serverUrl) throw new Error("Team scope belongs to another server");
+    return scope;
+  } catch {
+    throw new Error("Invalid or unsafe team scope file");
+  } finally {
+    await file.close();
+  }
+}
+async function writeTeamScope(path, scope) {
+  await mkdir(dirname(path), { recursive: true, mode: 448 });
+  const temporary = `${path}.${randomUUID()}.new`;
+  const file = await open(temporary, "wx", 384);
+  try {
+    await file.writeFile(JSON.stringify(TeamScopeSchema.parse(scope)));
+    await file.sync();
+  } finally {
+    await file.close();
+  }
+  try {
+    await rename(temporary, path);
+  } finally {
+    await unlink(temporary).catch(() => {
+    });
+  }
+}
+
+export { readTeamScope as r, teamScopePath as t, writeTeamScope as w };

package/dist/controlClient-BGbDcgWS.mjs

@@ -0,0 +1,260 @@
+import { l as logger } from './logger-6HYUEXNk.mjs';
+import { readDaemonState, clearDaemonState } from './persistence-HGW_ZVs9.mjs';
+import { c as configuration } from './configuration-RfeNjFmd.mjs';
+
+function daemonControlHeaders(controlToken) {
+  return {
+    "Content-Type": "application/json",
+    ...controlToken ? { Authorization: `Bearer ${controlToken}` } : {}
+  };
+}
+async function daemonPost(path, body) {
+  const state = await readDaemonState();
+  if (!state?.httpPort) {
+    const errorMessage = "No daemon running, no state file found";
+    logger.debug(`[CONTROL CLIENT] ${errorMessage}`);
+    return {
+      error: errorMessage
+    };
+  }
+  try {
+    process.kill(state.pid, 0);
+  } catch (error) {
+    const errorMessage = "Daemon is not running, file is stale";
+    logger.debug(`[CONTROL CLIENT] ${errorMessage}`);
+    return {
+      error: errorMessage
+    };
+  }
+  try {
+    const timeout = process.env.HAPPY_DAEMON_HTTP_TIMEOUT ? parseInt(process.env.HAPPY_DAEMON_HTTP_TIMEOUT) : 1e4;
+    const response = await fetch(`http://127.0.0.1:${state.httpPort}${path}`, {
+      method: "POST",
+      // A state written by an old daemon has no token and must remain callable;
+      // a new daemon always writes one and rejects requests without it.
+      headers: daemonControlHeaders(state.controlToken),
+      body: JSON.stringify(body || {}),
+      // Mostly increased for stress test
+      signal: AbortSignal.timeout(timeout)
+    });
+    if (!response.ok) {
+      const failure = await response.json().catch(() => null);
+      const reason = typeof failure?.error === "string" && failure.error ? failure.error : `HTTP ${response.status}`;
+      const errorMessage = `Request failed: ${path}, ${reason}`;
+      logger.debug(`[CONTROL CLIENT] ${errorMessage}`);
+      return {
+        error: errorMessage
+      };
+    }
+    return await response.json();
+  } catch (error) {
+    const errorMessage = `Request failed: ${path}, ${error instanceof Error ? error.message : "Unknown error"}`;
+    logger.debug(`[CONTROL CLIENT] ${errorMessage}`);
+    return {
+      error: errorMessage
+    };
+  }
+}
+const SESSION_STARTED_RETRY_TIMEOUT_MS = 3e3;
+const SESSION_STARTED_RETRY_INTERVAL_MS = 100;
+async function notifyDaemonSessionStarted(sessionId, metadata, encryption) {
+  const payload = { sessionId, metadata, encryption };
+  const deadline = Date.now() + SESSION_STARTED_RETRY_TIMEOUT_MS;
+  let result;
+  while (true) {
+    result = await daemonPost("/session-started", payload);
+    if (!result?.error) {
+      return result;
+    }
+    if (Date.now() >= deadline) {
+      return result;
+    }
+    await new Promise((resolve) => setTimeout(resolve, SESSION_STARTED_RETRY_INTERVAL_MS));
+  }
+}
+async function listDaemonSessions() {
+  const result = await daemonPost("/list");
+  return result.children || [];
+}
+async function stopDaemonSession(sessionId) {
+  const result = await daemonPost("/stop-session", { sessionId });
+  return result.success || false;
+}
+async function spawnDaemonSession(directory, sessionId, opts) {
+  const result = await daemonPost("/spawn-session", {
+    directory,
+    sessionId,
+    spawnedBy: opts?.spawnedBy,
+    permissionMode: opts?.permissionMode,
+    agent: opts?.agent,
+    environmentVariables: opts?.environmentVariables,
+    resumeClaudeSessionId: opts?.resumeClaudeSessionId,
+    resumeCodexThreadId: opts?.resumeCodexThreadId,
+    parentSessionId: opts?.parentSessionId
+  });
+  return result;
+}
+const ROUTE_NOT_FOUND_RE = /, (Not Found|HTTP 404)$/;
+async function resumeDaemonSession(sessionId, opts) {
+  const result = await daemonPost("/resume-session", {
+    sessionId,
+    ...opts?.model !== void 0 ? { model: opts.model } : {},
+    ...opts?.permissionMode !== void 0 ? { permissionMode: opts.permissionMode } : {}
+  });
+  if (result?.error) {
+    const raw = String(result.error);
+    const error = ROUTE_NOT_FOUND_RE.test(raw) ? "daemon too old to resume sessions (no /resume-session route); upgrade very-happy-cli and run `very-happy daemon start`" : raw.replace(/^Request failed: \/resume-session, /, "");
+    return { success: false, error };
+  }
+  if (result?.success === true && typeof result.sessionId === "string") {
+    return { success: true, sessionId: result.sessionId };
+  }
+  return { success: false, error: typeof result?.error === "string" ? result.error : "unexpected daemon response" };
+}
+async function notifyDaemonSessionEvent(sessionId, event, spawnedBy) {
+  return daemonPost("/session-event", { sessionId, event, spawnedBy });
+}
+async function notifyDaemonClaudeAuthFailed(sessionId) {
+  return daemonPost("/session-event", { sessionId, event: "auth_failed" });
+}
+async function notifyDaemonTurnEvent(sessionId, event) {
+  return daemonPost("/session-event", { sessionId, event });
+}
+async function notifyDaemonBackgroundTasks(sessionId, backgroundTasks) {
+  return daemonPost("/session-event", { sessionId, event: "background_tasks", backgroundTasks });
+}
+function reportSessionEditToDaemon(edit) {
+  void daemonPost("/session-edit", edit).then((result) => {
+    if (result?.error) logger.debug(`[CONTROL CLIENT] session-edit not recorded: ${result.error}`);
+  }).catch((error) => {
+    logger.debug("[CONTROL CLIENT] session-edit failed:", error);
+  });
+}
+async function listDaemonPeers() {
+  const result = await daemonPost("/peers");
+  if (result?.error) {
+    const reason = String(result.error);
+    if (/404|Not Found/i.test(reason)) {
+      throw new Error("The running daemon does not support session peers; restart it on a CLI that does (`very-happy daemon start` after updating)");
+    }
+    throw new Error(reason);
+  }
+  return Array.isArray(result?.sessions) ? result.sessions : [];
+}
+async function stopDaemonHttp() {
+  await daemonPost("/stop");
+}
+async function pushClipboardViaDaemon(text, terminalId) {
+  const result = await daemonPost("/clipboard", { text, ...terminalId ? { terminalId } : {} });
+  if (result?.error && result.delivered === void 0) {
+    return { delivered: false, error: result.error };
+  }
+  return result;
+}
+async function pushFilePreviewViaDaemon(terminalId, path, mode = "file") {
+  const result = await daemonPost("/file-preview", { terminalId, path, mode });
+  if (result?.error) return { delivered: false, error: result.error };
+  return { delivered: result?.delivered === true, ...result?.delivered === true ? {} : { error: "preview was not delivered" } };
+}
+async function setTerminalTitleViaDaemon(terminalId, title, ifAbsent = false) {
+  const result = await daemonPost("/terminal-title", { terminalId, title, ifAbsent });
+  if (result?.error) {
+    return { ok: false, error: result.error };
+  }
+  return { ok: result?.status === "ok", error: result?.status === "ok" ? void 0 : "unexpected daemon response" };
+}
+async function checkIfDaemonRunningAndCleanupStaleState() {
+  const state = await readDaemonState();
+  if (!state) {
+    return false;
+  }
+  try {
+    process.kill(state.pid, 0);
+  } catch {
+    logger.debug("[DAEMON RUN] Daemon PID not running, cleaning up state");
+    await cleanupDaemonState();
+    return false;
+  }
+  if (state.httpPort) {
+    try {
+      const response = await fetch(`http://127.0.0.1:${state.httpPort}/list`, {
+        method: "POST",
+        headers: daemonControlHeaders(state.controlToken),
+        body: "{}",
+        signal: AbortSignal.timeout(2e3)
+      });
+      if (response.ok) {
+        return true;
+      }
+    } catch {
+      logger.debug(`[DAEMON RUN] PID ${state.pid} is alive but HTTP health check failed on port ${state.httpPort}, cleaning up stale state`);
+      await cleanupDaemonState();
+      return false;
+    }
+  }
+  return true;
+}
+async function isDaemonRunningCurrentlyInstalledHappyVersion() {
+  logger.debug("[DAEMON CONTROL] Checking if daemon is running same version");
+  const runningDaemon = await checkIfDaemonRunningAndCleanupStaleState();
+  if (!runningDaemon) {
+    logger.debug("[DAEMON CONTROL] No daemon running, returning false");
+    return false;
+  }
+  const state = await readDaemonState();
+  if (!state) {
+    logger.debug("[DAEMON CONTROL] No daemon state found, returning false");
+    return false;
+  }
+  const currentCliVersion = configuration.currentCliVersion;
+  logger.debug(`[DAEMON CONTROL] Current CLI version: ${currentCliVersion}, Daemon started with version: ${state.startedWithCliVersion}`);
+  return currentCliVersion === state.startedWithCliVersion;
+}
+async function cleanupDaemonState() {
+  try {
+    await clearDaemonState();
+    logger.debug("[DAEMON RUN] Daemon state file removed");
+  } catch (error) {
+    logger.debug("[DAEMON RUN] Error cleaning up daemon metadata", error);
+  }
+}
+async function stopDaemon() {
+  try {
+    const state = await readDaemonState();
+    if (!state) {
+      logger.debug("No daemon state found");
+      return;
+    }
+    logger.debug(`Stopping daemon with PID ${state.pid}`);
+    try {
+      await stopDaemonHttp();
+      await waitForProcessDeath(state.pid, 2e3);
+      logger.debug("Daemon stopped gracefully via HTTP");
+      return;
+    } catch (error) {
+      logger.debug("HTTP stop failed, will force kill", error);
+    }
+    try {
+      process.kill(state.pid, "SIGKILL");
+      logger.debug("Force killed daemon");
+    } catch (error) {
+      logger.debug("Daemon already dead");
+    }
+  } catch (error) {
+    logger.debug("Error stopping daemon", error);
+  }
+}
+async function waitForProcessDeath(pid, timeout) {
+  const start = Date.now();
+  while (Date.now() - start < timeout) {
+    try {
+      process.kill(pid, 0);
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    } catch {
+      return;
+    }
+  }
+  throw new Error("Process did not die within timeout");
+}
+
+export { stopDaemon as a, pushFilePreviewViaDaemon as b, checkIfDaemonRunningAndCleanupStaleState as c, setTerminalTitleViaDaemon as d, spawnDaemonSession as e, listDaemonPeers as f, reportSessionEditToDaemon as g, notifyDaemonTurnEvent as h, isDaemonRunningCurrentlyInstalledHappyVersion as i, notifyDaemonBackgroundTasks as j, notifyDaemonSessionEvent as k, listDaemonSessions as l, notifyDaemonClaudeAuthFailed as m, notifyDaemonSessionStarted as n, cleanupDaemonState as o, pushClipboardViaDaemon as p, resumeDaemonSession as r, stopDaemonSession as s };