very-happy-cli 0.2.159 → 0.2.161

package/dist/claudeLocalLauncher-Bd5I2-j6.cjs

@@ -0,0 +1,154 @@
+'use strict';
+
+var logger = require('./logger-Bc8-u1w0.cjs');
+var claudeLocal = require('./claudeLocal-BDuGFnjJ.cjs');
+var sessionScanner = require('./sessionScanner-D1goKdd3.cjs');
+require('chalk');
+require('node:util');
+require('./configuration-v9f8LM9T.cjs');
+require('node:fs');
+require('node:os');
+require('node:path');
+require('./package-Cl5BEP5x.cjs');
+require('node:fs/promises');
+require('cross-spawn');
+require('node:readline');
+require('node:crypto');
+require('./smallFastModel-D_uxGMo3.cjs');
+require('./path-B7zW-WwE.cjs');
+require('./systemPrompt-BygJcmbi.cjs');
+require('./index-DA7yINuk.cjs');
+require('zod');
+require('@paralleldrive/cuid2');
+require('./trimIdent-4gvk9Wk6.cjs');
+require('./agentGuidance-B5NATuFa.cjs');
+require('./manager-Cly8xVIR.cjs');
+require('@anthropic-ai/sandbox-runtime');
+require('./contentLogMetadata-ZSFk_NjQ.cjs');
+require('./claudeCliPath-U4HHmV4r.cjs');
+require('./projectPath-ChLhdOyt.cjs');
+require('path');
+require('url');
+require('./sync-CVk4QERO.cjs');
+require('./time-CNRE4ChD.cjs');
+require('./types-CRS-srZK.cjs');
+require('./startFileWatcher-CKKx-8ZO.cjs');
+require('fs/promises');
+
+async function claudeLocalLauncher(session) {
+  const scanner = await sessionScanner.createSessionScanner({
+    sessionId: session.sessionId,
+    workingDirectory: session.path,
+    onMessage: (message) => {
+      if (message.type !== "summary") {
+        session.client.sendClaudeSessionMessage(message);
+      }
+    }
+  });
+  const scannerSessionCallback = (sessionId) => {
+    scanner.onNewSession(sessionId);
+  };
+  session.addSessionFoundCallback(scannerSessionCallback);
+  let exitReason = null;
+  let switchRequested = false;
+  const processAbortController = new AbortController();
+  let exutFuture = new sessionScanner.Future();
+  try {
+    async function abort() {
+      if (!processAbortController.signal.aborted) {
+        processAbortController.abort();
+      }
+      await exutFuture.promise;
+    }
+    async function doAbort() {
+      logger.logger.debug("[local]: doAbort");
+      session.onAbort();
+      if (!exitReason) {
+        exitReason = { type: "switch" };
+      }
+      session.client.closeClaudeSessionTurn("cancelled");
+      session.queue.reset();
+      await abort();
+    }
+    async function doSwitch() {
+      logger.logger.debug("[local]: doSwitch");
+      switchRequested = true;
+      if (!processAbortController.signal.aborted) {
+        processAbortController.abort();
+      }
+    }
+    session.client.rpcHandlerManager.registerHandler("abort", doAbort);
+    session.client.rpcHandlerManager.registerHandler("switch", doSwitch);
+    session.queue.setOnMessage((_message, _mode) => {
+      void doSwitch();
+    });
+    if (session.queue.size() > 0) {
+      return { type: "switch" };
+    }
+    const handleSessionStart = (sessionId) => {
+      session.onSessionFound(sessionId);
+      scanner.onNewSession(sessionId);
+    };
+    while (true) {
+      if (exitReason) {
+        return exitReason;
+      }
+      logger.logger.debug("[local]: launch");
+      try {
+        await claudeLocal.claudeLocal({
+          path: session.path,
+          sessionId: session.sessionId,
+          onSessionFound: handleSessionStart,
+          onThinkingChange: session.onThinkingChange,
+          abort: processAbortController.signal,
+          claudeEnvVars: session.claudeEnvVars,
+          claudeArgs: session.claudeArgs,
+          mcpServers: session.mcpServers,
+          allowedTools: session.allowedTools,
+          hookSettingsPath: session.hookSettingsPath,
+          sandboxConfig: session.sandboxConfig
+        });
+        session.consumeOneTimeFlags();
+        if (!exitReason) {
+          session.client.closeClaudeSessionTurn("completed");
+          exitReason = switchRequested || session.queue.size() > 0 ? { type: "switch" } : { type: "exit", code: 0 };
+          break;
+        }
+      } catch (e) {
+        logger.logger.debug("[local]: launch error", e);
+        if (e instanceof claudeLocal.ExitCodeError) {
+          if (exitReason) {
+            break;
+          }
+          if (switchRequested || session.queue.size() > 0) {
+            session.client.closeClaudeSessionTurn("failed");
+            exitReason = { type: "switch" };
+            break;
+          }
+          session.client.closeClaudeSessionTurn("failed");
+          exitReason = { type: "exit", code: e.exitCode };
+          break;
+        }
+        if (!exitReason) {
+          session.client.sendSessionEvent({ type: "message", message: "Process exited unexpectedly" });
+          continue;
+        } else {
+          break;
+        }
+      }
+      logger.logger.debug("[local]: launch done");
+    }
+  } finally {
+    exutFuture.resolve(void 0);
+    session.client.rpcHandlerManager.registerHandler("abort", async () => {
+    });
+    session.client.rpcHandlerManager.registerHandler("switch", async () => {
+    });
+    session.queue.setOnMessage(null);
+    session.removeSessionFoundCallback(scannerSessionCallback);
+    await scanner.cleanup();
+  }
+  return exitReason || { type: "exit", code: 0 };
+}
+
+exports.claudeLocalLauncher = claudeLocalLauncher;

package/dist/claudeLocalLauncher-CDqQI9ak.mjs

@@ -0,0 +1,152 @@
+import { l as logger } from './logger-fXoNzNuB.mjs';
+import { claudeLocal, ExitCodeError } from './claudeLocal-CQa8qnwq.mjs';
+import { c as createSessionScanner, F as Future } from './sessionScanner-CaAHLyNV.mjs';
+import 'chalk';
+import 'node:util';
+import './configuration-DoWFJUPm.mjs';
+import 'node:fs';
+import 'node:os';
+import 'node:path';
+import './package-uOg9SCKi.mjs';
+import 'node:fs/promises';
+import 'cross-spawn';
+import 'node:readline';
+import 'node:crypto';
+import './smallFastModel-BLNgMrwR.mjs';
+import './path-D2wdaNSk.mjs';
+import './systemPrompt-DmtypUc7.mjs';
+import './index-qdS1friN.mjs';
+import 'zod';
+import '@paralleldrive/cuid2';
+import './trimIdent-BAjmv_TG.mjs';
+import './agentGuidance-CQuNlNx8.mjs';
+import './manager-BQ4flvQZ.mjs';
+import '@anthropic-ai/sandbox-runtime';
+import './contentLogMetadata-BlWI0egu.mjs';
+import './claudeCliPath-BqkaH2oR.mjs';
+import './projectPath-BTBIMB57.mjs';
+import 'path';
+import 'url';
+import './sync-CxD-w_40.mjs';
+import './time-BZNdNiIV.mjs';
+import './types-CkqAACXx.mjs';
+import './startFileWatcher-CdegMbJj.mjs';
+import 'fs/promises';
+
+async function claudeLocalLauncher(session) {
+  const scanner = await createSessionScanner({
+    sessionId: session.sessionId,
+    workingDirectory: session.path,
+    onMessage: (message) => {
+      if (message.type !== "summary") {
+        session.client.sendClaudeSessionMessage(message);
+      }
+    }
+  });
+  const scannerSessionCallback = (sessionId) => {
+    scanner.onNewSession(sessionId);
+  };
+  session.addSessionFoundCallback(scannerSessionCallback);
+  let exitReason = null;
+  let switchRequested = false;
+  const processAbortController = new AbortController();
+  let exutFuture = new Future();
+  try {
+    async function abort() {
+      if (!processAbortController.signal.aborted) {
+        processAbortController.abort();
+      }
+      await exutFuture.promise;
+    }
+    async function doAbort() {
+      logger.debug("[local]: doAbort");
+      session.onAbort();
+      if (!exitReason) {
+        exitReason = { type: "switch" };
+      }
+      session.client.closeClaudeSessionTurn("cancelled");
+      session.queue.reset();
+      await abort();
+    }
+    async function doSwitch() {
+      logger.debug("[local]: doSwitch");
+      switchRequested = true;
+      if (!processAbortController.signal.aborted) {
+        processAbortController.abort();
+      }
+    }
+    session.client.rpcHandlerManager.registerHandler("abort", doAbort);
+    session.client.rpcHandlerManager.registerHandler("switch", doSwitch);
+    session.queue.setOnMessage((_message, _mode) => {
+      void doSwitch();
+    });
+    if (session.queue.size() > 0) {
+      return { type: "switch" };
+    }
+    const handleSessionStart = (sessionId) => {
+      session.onSessionFound(sessionId);
+      scanner.onNewSession(sessionId);
+    };
+    while (true) {
+      if (exitReason) {
+        return exitReason;
+      }
+      logger.debug("[local]: launch");
+      try {
+        await claudeLocal({
+          path: session.path,
+          sessionId: session.sessionId,
+          onSessionFound: handleSessionStart,
+          onThinkingChange: session.onThinkingChange,
+          abort: processAbortController.signal,
+          claudeEnvVars: session.claudeEnvVars,
+          claudeArgs: session.claudeArgs,
+          mcpServers: session.mcpServers,
+          allowedTools: session.allowedTools,
+          hookSettingsPath: session.hookSettingsPath,
+          sandboxConfig: session.sandboxConfig
+        });
+        session.consumeOneTimeFlags();
+        if (!exitReason) {
+          session.client.closeClaudeSessionTurn("completed");
+          exitReason = switchRequested || session.queue.size() > 0 ? { type: "switch" } : { type: "exit", code: 0 };
+          break;
+        }
+      } catch (e) {
+        logger.debug("[local]: launch error", e);
+        if (e instanceof ExitCodeError) {
+          if (exitReason) {
+            break;
+          }
+          if (switchRequested || session.queue.size() > 0) {
+            session.client.closeClaudeSessionTurn("failed");
+            exitReason = { type: "switch" };
+            break;
+          }
+          session.client.closeClaudeSessionTurn("failed");
+          exitReason = { type: "exit", code: e.exitCode };
+          break;
+        }
+        if (!exitReason) {
+          session.client.sendSessionEvent({ type: "message", message: "Process exited unexpectedly" });
+          continue;
+        } else {
+          break;
+        }
+      }
+      logger.debug("[local]: launch done");
+    }
+  } finally {
+    exutFuture.resolve(void 0);
+    session.client.rpcHandlerManager.registerHandler("abort", async () => {
+    });
+    session.client.rpcHandlerManager.registerHandler("switch", async () => {
+    });
+    session.queue.setOnMessage(null);
+    session.removeSessionFoundCallback(scannerSessionCallback);
+    await scanner.cleanup();
+  }
+  return exitReason || { type: "exit", code: 0 };
+}
+
+export { claudeLocalLauncher };

package/dist/cliUpdate-DsKXPFYp.cjs

@@ -0,0 +1,120 @@
+'use strict';
+
+const DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS = 60 * 60 * 1e3;
+const MIN_CLI_UPDATE_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
+function withCurrentCliUpdateState(current, state) {
+  const { cliUpdate: _staleCliUpdate, ...rest } = current ?? {};
+  return {
+    ...rest,
+    status: current?.status ?? "running",
+    ...state ? { cliUpdate: state } : {}
+  };
+}
+function resolveCliUpdateCheckInterval(raw) {
+  if (raw === void 0 || raw.trim() === "") return DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS;
+  if (!/^\d+$/.test(raw.trim())) return DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS;
+  const value = Number(raw.trim());
+  return Number.isSafeInteger(value) && value >= MIN_CLI_UPDATE_CHECK_INTERVAL_MS ? value : DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS;
+}
+function parseExactVersion(value) {
+  const match = /^(?:v)?(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z.-]+))?(?:\+([0-9A-Za-z.-]+))?$/.exec(value.trim());
+  if (!match) return null;
+  const preParts = match[4]?.split(".") ?? null;
+  const buildParts = match[5]?.split(".") ?? null;
+  if (preParts?.some((part) => !part || /^\d+$/.test(part) && part.length > 1 && part.startsWith("0"))) return null;
+  if (buildParts?.some((part) => !part)) return null;
+  const pre = preParts?.map((part) => /^\d+$/.test(part) ? Number(part) : part) ?? null;
+  const suffix = `${match[4] ? `-${match[4]}` : ""}${match[5] ? `+${match[5]}` : ""}`;
+  return { exact: `${match[1]}.${match[2]}.${match[3]}${suffix}`, core: [Number(match[1]), Number(match[2]), Number(match[3])], pre };
+}
+function compareExactVersions(left, right) {
+  const a = parseExactVersion(left);
+  const b = parseExactVersion(right);
+  if (!a || !b) return null;
+  for (let index = 0; index < 3; index += 1) {
+    if (a.core[index] !== b.core[index]) return a.core[index] < b.core[index] ? -1 : 1;
+  }
+  if (a.pre === null || b.pre === null) return a.pre === b.pre ? 0 : a.pre === null ? 1 : -1;
+  const count = Math.max(a.pre.length, b.pre.length);
+  for (let index = 0; index < count; index += 1) {
+    const av = a.pre[index];
+    const bv = b.pre[index];
+    if (av === void 0 || bv === void 0) return av === bv ? 0 : av === void 0 ? -1 : 1;
+    if (av === bv) continue;
+    if (typeof av === "number" && typeof bv === "string") return -1;
+    if (typeof av === "string" && typeof bv === "number") return 1;
+    return av < bv ? -1 : 1;
+  }
+  return 0;
+}
+function deriveCliUpdateState(currentVersion, policy) {
+  if (!parseExactVersion(currentVersion)) return null;
+  const recommended = policy.recommendedVersion && parseExactVersion(policy.recommendedVersion) ? policy.recommendedVersion.replace(/^v/, "") : null;
+  const minimum = policy.minimumVersion && parseExactVersion(policy.minimumVersion) ? policy.minimumVersion.replace(/^v/, "") : null;
+  const autoUpdate = policy.autoUpdateVersion && parseExactVersion(policy.autoUpdateVersion) ? policy.autoUpdateVersion.replace(/^v/, "") : null;
+  if (!recommended && !minimum) return null;
+  const belowMinimum = minimum ? compareExactVersions(currentVersion, minimum) === -1 : false;
+  const belowRecommended = recommended ? compareExactVersions(currentVersion, recommended) === -1 : false;
+  return {
+    currentVersion: currentVersion.replace(/^v/, ""),
+    recommendedVersion: recommended ? parseExactVersion(recommended).exact : null,
+    minimumVersion: minimum ? parseExactVersion(minimum).exact : null,
+    status: belowMinimum ? "required" : belowRecommended ? "available" : "current",
+    autoUpdateVersion: autoUpdate ? parseExactVersion(autoUpdate).exact : null,
+    checkedAt: policy.checkedAt
+  };
+}
+function cliInstallCommand(version) {
+  const parsed = parseExactVersion(version);
+  if (!parsed) return null;
+  return `npm install -g --allow-scripts=very-happy-cli,node-pty very-happy-cli@${parsed.exact}`;
+}
+function deriveLocalCliUpdateSummary(installedVersion, runningDaemonVersion, policy) {
+  const daemonComparison = runningDaemonVersion ? compareExactVersions(runningDaemonVersion, installedVersion) : 0;
+  const minimumComparison = policy?.minimumVersion ? compareExactVersions(installedVersion, policy.minimumVersion) : 0;
+  const recommendedComparison = policy?.recommendedVersion ? compareExactVersions(installedVersion, policy.recommendedVersion) : 0;
+  const installedStatus = minimumComparison === -1 ? "required" : recommendedComparison === -1 ? "available" : minimumComparison === null || recommendedComparison === null ? "unknown" : "current";
+  const targetVersion = installedStatus === "required" ? policy?.recommendedVersion ?? policy?.minimumVersion ?? null : installedStatus === "available" ? policy?.recommendedVersion ?? null : null;
+  return {
+    daemonMismatch: daemonComparison !== 0,
+    installedStatus,
+    targetVersion,
+    installCommand: targetVersion ? cliInstallCommand(targetVersion) : null
+  };
+}
+async function fetchCliUpdateState(serverUrl, currentVersion, fetcher = fetch, timeoutMs = 2e3) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetcher(`${serverUrl}/v1/version/cli`, {
+      signal: controller.signal,
+      headers: { accept: "application/json" }
+    });
+    if (!response.ok) return null;
+    const raw = await response.json();
+    if (!Number.isFinite(raw.checkedAt)) return null;
+    if (!["configured", "registry", "unavailable"].includes(String(raw.source))) return null;
+    if (raw.recommendedVersion !== null && raw.recommendedVersion !== void 0 && typeof raw.recommendedVersion !== "string") return null;
+    if (raw.minimumVersion !== null && raw.minimumVersion !== void 0 && typeof raw.minimumVersion !== "string") return null;
+    if (raw.autoUpdateVersion !== null && raw.autoUpdateVersion !== void 0 && typeof raw.autoUpdateVersion !== "string") return null;
+    return deriveCliUpdateState(currentVersion, {
+      recommendedVersion: raw.recommendedVersion ?? null,
+      minimumVersion: raw.minimumVersion ?? null,
+      autoUpdateVersion: raw.autoUpdateVersion ?? null,
+      checkedAt: raw.checkedAt,
+      source: raw.source
+    });
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+exports.DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS = DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS;
+exports.compareExactVersions = compareExactVersions;
+exports.deriveLocalCliUpdateSummary = deriveLocalCliUpdateSummary;
+exports.fetchCliUpdateState = fetchCliUpdateState;
+exports.parseExactVersion = parseExactVersion;
+exports.resolveCliUpdateCheckInterval = resolveCliUpdateCheckInterval;
+exports.withCurrentCliUpdateState = withCurrentCliUpdateState;

package/dist/cliUpdate-Y34VGe9Y.mjs

@@ -0,0 +1,112 @@
+const DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS = 60 * 60 * 1e3;
+const MIN_CLI_UPDATE_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
+function withCurrentCliUpdateState(current, state) {
+  const { cliUpdate: _staleCliUpdate, ...rest } = current ?? {};
+  return {
+    ...rest,
+    status: current?.status ?? "running",
+    ...state ? { cliUpdate: state } : {}
+  };
+}
+function resolveCliUpdateCheckInterval(raw) {
+  if (raw === void 0 || raw.trim() === "") return DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS;
+  if (!/^\d+$/.test(raw.trim())) return DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS;
+  const value = Number(raw.trim());
+  return Number.isSafeInteger(value) && value >= MIN_CLI_UPDATE_CHECK_INTERVAL_MS ? value : DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS;
+}
+function parseExactVersion(value) {
+  const match = /^(?:v)?(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z.-]+))?(?:\+([0-9A-Za-z.-]+))?$/.exec(value.trim());
+  if (!match) return null;
+  const preParts = match[4]?.split(".") ?? null;
+  const buildParts = match[5]?.split(".") ?? null;
+  if (preParts?.some((part) => !part || /^\d+$/.test(part) && part.length > 1 && part.startsWith("0"))) return null;
+  if (buildParts?.some((part) => !part)) return null;
+  const pre = preParts?.map((part) => /^\d+$/.test(part) ? Number(part) : part) ?? null;
+  const suffix = `${match[4] ? `-${match[4]}` : ""}${match[5] ? `+${match[5]}` : ""}`;
+  return { exact: `${match[1]}.${match[2]}.${match[3]}${suffix}`, core: [Number(match[1]), Number(match[2]), Number(match[3])], pre };
+}
+function compareExactVersions(left, right) {
+  const a = parseExactVersion(left);
+  const b = parseExactVersion(right);
+  if (!a || !b) return null;
+  for (let index = 0; index < 3; index += 1) {
+    if (a.core[index] !== b.core[index]) return a.core[index] < b.core[index] ? -1 : 1;
+  }
+  if (a.pre === null || b.pre === null) return a.pre === b.pre ? 0 : a.pre === null ? 1 : -1;
+  const count = Math.max(a.pre.length, b.pre.length);
+  for (let index = 0; index < count; index += 1) {
+    const av = a.pre[index];
+    const bv = b.pre[index];
+    if (av === void 0 || bv === void 0) return av === bv ? 0 : av === void 0 ? -1 : 1;
+    if (av === bv) continue;
+    if (typeof av === "number" && typeof bv === "string") return -1;
+    if (typeof av === "string" && typeof bv === "number") return 1;
+    return av < bv ? -1 : 1;
+  }
+  return 0;
+}
+function deriveCliUpdateState(currentVersion, policy) {
+  if (!parseExactVersion(currentVersion)) return null;
+  const recommended = policy.recommendedVersion && parseExactVersion(policy.recommendedVersion) ? policy.recommendedVersion.replace(/^v/, "") : null;
+  const minimum = policy.minimumVersion && parseExactVersion(policy.minimumVersion) ? policy.minimumVersion.replace(/^v/, "") : null;
+  const autoUpdate = policy.autoUpdateVersion && parseExactVersion(policy.autoUpdateVersion) ? policy.autoUpdateVersion.replace(/^v/, "") : null;
+  if (!recommended && !minimum) return null;
+  const belowMinimum = minimum ? compareExactVersions(currentVersion, minimum) === -1 : false;
+  const belowRecommended = recommended ? compareExactVersions(currentVersion, recommended) === -1 : false;
+  return {
+    currentVersion: currentVersion.replace(/^v/, ""),
+    recommendedVersion: recommended ? parseExactVersion(recommended).exact : null,
+    minimumVersion: minimum ? parseExactVersion(minimum).exact : null,
+    status: belowMinimum ? "required" : belowRecommended ? "available" : "current",
+    autoUpdateVersion: autoUpdate ? parseExactVersion(autoUpdate).exact : null,
+    checkedAt: policy.checkedAt
+  };
+}
+function cliInstallCommand(version) {
+  const parsed = parseExactVersion(version);
+  if (!parsed) return null;
+  return `npm install -g --allow-scripts=very-happy-cli,node-pty very-happy-cli@${parsed.exact}`;
+}
+function deriveLocalCliUpdateSummary(installedVersion, runningDaemonVersion, policy) {
+  const daemonComparison = runningDaemonVersion ? compareExactVersions(runningDaemonVersion, installedVersion) : 0;
+  const minimumComparison = policy?.minimumVersion ? compareExactVersions(installedVersion, policy.minimumVersion) : 0;
+  const recommendedComparison = policy?.recommendedVersion ? compareExactVersions(installedVersion, policy.recommendedVersion) : 0;
+  const installedStatus = minimumComparison === -1 ? "required" : recommendedComparison === -1 ? "available" : minimumComparison === null || recommendedComparison === null ? "unknown" : "current";
+  const targetVersion = installedStatus === "required" ? policy?.recommendedVersion ?? policy?.minimumVersion ?? null : installedStatus === "available" ? policy?.recommendedVersion ?? null : null;
+  return {
+    daemonMismatch: daemonComparison !== 0,
+    installedStatus,
+    targetVersion,
+    installCommand: targetVersion ? cliInstallCommand(targetVersion) : null
+  };
+}
+async function fetchCliUpdateState(serverUrl, currentVersion, fetcher = fetch, timeoutMs = 2e3) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetcher(`${serverUrl}/v1/version/cli`, {
+      signal: controller.signal,
+      headers: { accept: "application/json" }
+    });
+    if (!response.ok) return null;
+    const raw = await response.json();
+    if (!Number.isFinite(raw.checkedAt)) return null;
+    if (!["configured", "registry", "unavailable"].includes(String(raw.source))) return null;
+    if (raw.recommendedVersion !== null && raw.recommendedVersion !== void 0 && typeof raw.recommendedVersion !== "string") return null;
+    if (raw.minimumVersion !== null && raw.minimumVersion !== void 0 && typeof raw.minimumVersion !== "string") return null;
+    if (raw.autoUpdateVersion !== null && raw.autoUpdateVersion !== void 0 && typeof raw.autoUpdateVersion !== "string") return null;
+    return deriveCliUpdateState(currentVersion, {
+      recommendedVersion: raw.recommendedVersion ?? null,
+      minimumVersion: raw.minimumVersion ?? null,
+      autoUpdateVersion: raw.autoUpdateVersion ?? null,
+      checkedAt: raw.checkedAt,
+      source: raw.source
+    });
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+export { DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS as D, compareExactVersions as c, deriveLocalCliUpdateSummary as d, fetchCliUpdateState as f, parseExactVersion as p, resolveCliUpdateCheckInterval as r, withCurrentCliUpdateState as w };

package/dist/client-Brn-UwVk.mjs

@@ -0,0 +1,100 @@
+import { randomUUID } from 'node:crypto';
+import { c as configuration } from './configuration-DoWFJUPm.mjs';
+import { readSettings, readPersistedSessions, readCredentialsForConfiguredRelay } from './persistence-oET5n61f.mjs';
+import { r as readTeamScope, t as teamScopePath, w as writeTeamScope } from './context-C9GHPLEm.mjs';
+
+async function teamRequest(path, method, token, scoped, body) {
+  const response = await fetch(`${configuration.serverUrl}${path}`, {
+    method,
+    redirect: "error",
+    headers: { "content-type": "application/json", ...scoped ? { "x-happy-team-token": token } : { authorization: `Bearer ${token}` } },
+    body: body === void 0 ? void 0 : JSON.stringify(body),
+    signal: AbortSignal.timeout(25e3)
+  }).catch(() => {
+    throw new Error("Teams connection failed; outcome may be unknown. Reuse the request ID when retrying.");
+  });
+  if (!response.ok) throw new Error(`Teams request failed (HTTP ${response.status})`);
+  try {
+    return await response.json();
+  } catch {
+    throw new Error("Teams returned an invalid response");
+  }
+}
+class TeamConnectionPreflightError extends Error {
+}
+const initializationLocks = /* @__PURE__ */ new Map();
+async function serializeInitialization(path, work) {
+  const previous = initializationLocks.get(path) ?? Promise.resolve();
+  const next = previous.catch(() => {
+  }).then(work);
+  initializationLocks.set(path, next);
+  try {
+    return await next;
+  } finally {
+    if (initializationLocks.get(path) === next) initializationLocks.delete(path);
+  }
+}
+function createTeamsClient(sessionId) {
+  const scopePath = () => teamScopePath(sessionId ?? process.env.HAPPY_SESSION_ID);
+  return {
+    async initialize(input, options) {
+      const path = scopePath();
+      return serializeInitialization(path, async () => {
+        const priorScope = await readTeamScope(path);
+        if (priorScope && !options?.resumeAdoption) throw new Error("This session already has a team scope; use scoped team tools");
+        if (process.env.VH_TEAM_SCOPE_FILE) throw new Error("Assigned team scope is missing or already managed; ask the owner to restore it");
+        const sid = sessionId ?? process.env.HAPPY_SESSION_ID;
+        if (!sid) throw new Error("A managed session identity is required");
+        const machineId = (await readSettings()).machineId;
+        if (!machineId) throw new TeamConnectionPreflightError("Connect this machine to Very Happy before joining a team");
+        if (input.machineId && input.machineId !== machineId) throw new TeamConnectionPreflightError("Teams must use this session\u2019s local machine");
+        const persisted = readPersistedSessions()[sid];
+        if (!persisted || persisted.metadata.machineId !== machineId) throw new TeamConnectionPreflightError("Team identity must be a persisted session on this machine");
+        const credentials = await readCredentialsForConfiguredRelay();
+        if (!credentials) throw new TeamConnectionPreflightError("Sign in to Very Happy before creating or joining a team");
+        if (priorScope && !options?.expectedTeamId) throw new Error("This session already belongs to another team scope");
+        let teamId = input.teamId ?? options?.expectedTeamId;
+        if (!teamId) {
+          const created = await teamRequest("/v1/teams", "POST", credentials.token, false, { name: input.name, machineId, requestId: input.requestId });
+          teamId = created.team.id;
+        } else {
+          const existing = await teamRequest(`/v1/teams/${encodeURIComponent(teamId)}`, "GET", credentials.token, false);
+          if (existing.team?.machineId !== machineId) throw new TeamConnectionPreflightError("Team belongs to another machine");
+        }
+        if (options?.onTeamResolved) await options.onTeamResolved(teamId);
+        if (priorScope) {
+          if (priorScope.teamId !== teamId || priorScope.taskId) throw new Error("This session already belongs to another team scope");
+          const inspected = await teamRequest(`/v1/teams/${encodeURIComponent(teamId)}/agent`, "GET", priorScope.scopeToken, true);
+          const bot = inspected.team?.bots?.find((candidate) => candidate.id === priorScope.botId);
+          if (!bot?.root || bot.managed || bot.sessionId !== sid) throw new Error("Existing scope is not this session\u2019s root identity");
+          return { team: inspected.team, botId: priorScope.botId };
+        }
+        const result = await teamRequest(
+          `/v1/teams/${encodeURIComponent(teamId)}/actions`,
+          "POST",
+          credentials.token,
+          false,
+          { requestId: input.requestId, action: { type: "join", name: input.name, sessionId: sid, ...input.botId ? { botId: input.botId } : {} } }
+        );
+        if (!result.credential?.token || !result.credential?.botId) throw new Error("Team join did not issue a credential");
+        await writeTeamScope(path, { serverUrl: configuration.serverUrl, teamId, botId: result.credential.botId, scopeToken: result.credential.token });
+        return { team: result.team, botId: result.credential.botId };
+      });
+    },
+    async inspect() {
+      const scope = await readTeamScope(scopePath());
+      if (!scope) throw new Error("Join or create a team first");
+      const { credential: _credential, ...safe } = await teamRequest(`/v1/teams/${encodeURIComponent(scope.teamId)}/agent`, "GET", scope.scopeToken, true);
+      return safe;
+    },
+    async action(action, requestId = randomUUID()) {
+      const scope = await readTeamScope(scopePath());
+      if (!scope) throw new Error("Join or create a team first");
+      const result = await teamRequest(`/v1/teams/${encodeURIComponent(scope.teamId)}/agent`, "POST", scope.scopeToken, true, { requestId, action });
+      const { credential: _credential, ...safe } = result;
+      return safe;
+    }
+  };
+}
+
+export { TeamConnectionPreflightError as T, createTeamsClient as c, teamRequest as t };