very-happy-cli 0.2.159 → 0.2.160

package/dist/spawnHappyCLI-DBhwZT7O.cjs

@@ -0,0 +1,66 @@
+'use strict';
+
+var spawn = require('cross-spawn');
+var path = require('node:path');
+var projectPath = require('./projectPath-ChLhdOyt.cjs');
+var logger = require('./logger-CS0mw3fa.cjs');
+var node_fs = require('node:fs');
+
+let cachedRuntime = null;
+function getRuntime() {
+  if (cachedRuntime) return cachedRuntime;
+  if (typeof globalThis.Bun !== "undefined") {
+    cachedRuntime = "bun";
+    return cachedRuntime;
+  }
+  if (typeof globalThis.Deno !== "undefined") {
+    cachedRuntime = "deno";
+    return cachedRuntime;
+  }
+  if (process?.versions?.bun) {
+    cachedRuntime = "bun";
+    return cachedRuntime;
+  }
+  if (process?.versions?.deno) {
+    cachedRuntime = "deno";
+    return cachedRuntime;
+  }
+  if (process?.versions?.node) {
+    cachedRuntime = "node";
+    return cachedRuntime;
+  }
+  cachedRuntime = "unknown";
+  return cachedRuntime;
+}
+const isBun = () => getRuntime() === "bun";
+
+function spawnHappyCLI(args, options = {}) {
+  const projectRoot = projectPath.projectPath();
+  const entrypoint = path.join(projectRoot, "dist", "index.mjs");
+  let directory;
+  if ("cwd" in options) {
+    directory = options.cwd;
+  } else {
+    directory = process.cwd();
+  }
+  const fullCommand = `happy ${args.join(" ")}`;
+  logger.logger.debug(`[SPAWN HAPPY CLI] Spawning: ${fullCommand} in ${directory}`);
+  const nodeArgs = [
+    "--no-warnings",
+    "--no-deprecation",
+    entrypoint,
+    ...args
+  ];
+  if (!node_fs.existsSync(entrypoint)) {
+    const errorMessage = `Entrypoint ${entrypoint} does not exist`;
+    logger.logger.debug(`[SPAWN HAPPY CLI] ${errorMessage}`);
+    throw new Error(errorMessage);
+  }
+  const runtime = isBun() ? "bun" : "node";
+  return spawn.spawn(runtime, nodeArgs, {
+    windowsHide: true,
+    ...options
+  });
+}
+
+exports.spawnHappyCLI = spawnHappyCLI;

package/dist/specialCommands-BSqhYg5X.mjs

@@ -0,0 +1,52 @@
+function parseCompact(message) {
+  const trimmed = message.trim();
+  if (trimmed === "/compact") {
+    return {
+      isCompact: true,
+      originalMessage: trimmed
+    };
+  }
+  if (trimmed.startsWith("/compact ")) {
+    return {
+      isCompact: true,
+      originalMessage: trimmed
+    };
+  }
+  return {
+    isCompact: false,
+    originalMessage: message
+  };
+}
+function parseClear(message) {
+  const trimmed = message.trim();
+  return {
+    isClear: trimmed === "/clear"
+  };
+}
+function parseSpecialCommand(message) {
+  const compactResult = parseCompact(message);
+  if (compactResult.isCompact) {
+    return {
+      type: "compact",
+      originalMessage: compactResult.originalMessage
+    };
+  }
+  const clearResult = parseClear(message);
+  if (clearResult.isClear) {
+    return {
+      type: "clear"
+    };
+  }
+  const trimmed = message.trim().toLowerCase();
+  if (trimmed === "/mcp") {
+    return { type: "mcp" };
+  }
+  if (trimmed === "/skills") {
+    return { type: "skills" };
+  }
+  return {
+    type: null
+  };
+}
+
+export { parseSpecialCommand as p };

package/dist/specialCommands-DSsTeRej.cjs

@@ -0,0 +1,54 @@
+'use strict';
+
+function parseCompact(message) {
+  const trimmed = message.trim();
+  if (trimmed === "/compact") {
+    return {
+      isCompact: true,
+      originalMessage: trimmed
+    };
+  }
+  if (trimmed.startsWith("/compact ")) {
+    return {
+      isCompact: true,
+      originalMessage: trimmed
+    };
+  }
+  return {
+    isCompact: false,
+    originalMessage: message
+  };
+}
+function parseClear(message) {
+  const trimmed = message.trim();
+  return {
+    isClear: trimmed === "/clear"
+  };
+}
+function parseSpecialCommand(message) {
+  const compactResult = parseCompact(message);
+  if (compactResult.isCompact) {
+    return {
+      type: "compact",
+      originalMessage: compactResult.originalMessage
+    };
+  }
+  const clearResult = parseClear(message);
+  if (clearResult.isClear) {
+    return {
+      type: "clear"
+    };
+  }
+  const trimmed = message.trim().toLowerCase();
+  if (trimmed === "/mcp") {
+    return { type: "mcp" };
+  }
+  if (trimmed === "/skills") {
+    return { type: "skills" };
+  }
+  return {
+    type: null
+  };
+}
+
+exports.parseSpecialCommand = parseSpecialCommand;

package/dist/startFileWatcher-B4VsLgjD.cjs

@@ -0,0 +1,71 @@
+'use strict';
+
+var logger = require('./logger-CS0mw3fa.cjs');
+var fs = require('fs/promises');
+
+function startFileWatcher(file, onFileChange, options = {}) {
+  const abortController = new AbortController();
+  const missingFileTimeoutMs = options.missingFileTimeoutMs ?? 6e4;
+  const wait = (ms) => new Promise((resolve) => {
+    if (abortController.signal.aborted) {
+      resolve();
+      return;
+    }
+    const timer = setTimeout(() => {
+      abortController.signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      resolve();
+    };
+    abortController.signal.addEventListener("abort", onAbort, { once: true });
+  });
+  void (async () => {
+    let missingSince = null;
+    let failureCount = 0;
+    while (true) {
+      try {
+        logger.logger.debug(`[FILE_WATCHER] Starting watcher for ${file}`);
+        const watcher = fs.watch(file, { persistent: true, signal: abortController.signal });
+        for await (const event of watcher) {
+          if (abortController.signal.aborted) {
+            return;
+          }
+          missingSince = null;
+          failureCount = 0;
+          logger.logger.debug(`[FILE_WATCHER] File changed: ${file}`);
+          onFileChange(file);
+        }
+      } catch (e) {
+        if (abortController.signal.aborted) {
+          return;
+        }
+        const isMissing = e?.code === "ENOENT";
+        if (isMissing) {
+          const now = Date.now();
+          if (missingSince === null) {
+            missingSince = now;
+          }
+          const absentMs = now - missingSince;
+          if (absentMs >= missingFileTimeoutMs) {
+            logger.logger.debug(`[FILE_WATCHER] Giving up on ${file}: never appeared after ${Math.round(absentMs / 1e3)}s`);
+            options.onGaveUp?.();
+            return;
+          }
+        } else {
+          missingSince = null;
+        }
+        failureCount++;
+        const backoffMs = Math.min(1e3 * 2 ** Math.min(failureCount - 1, 4), 15e3);
+        logger.logger.debug(`[FILE_WATCHER] Watch error: ${e.message}, retrying in ${backoffMs}ms`);
+        await wait(backoffMs);
+      }
+    }
+  })();
+  return () => {
+    abortController.abort();
+  };
+}
+
+exports.startFileWatcher = startFileWatcher;

package/dist/startFileWatcher-DErVWZE4.mjs

@@ -0,0 +1,69 @@
+import { l as logger } from './logger-6HYUEXNk.mjs';
+import { watch } from 'fs/promises';
+
+function startFileWatcher(file, onFileChange, options = {}) {
+  const abortController = new AbortController();
+  const missingFileTimeoutMs = options.missingFileTimeoutMs ?? 6e4;
+  const wait = (ms) => new Promise((resolve) => {
+    if (abortController.signal.aborted) {
+      resolve();
+      return;
+    }
+    const timer = setTimeout(() => {
+      abortController.signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      resolve();
+    };
+    abortController.signal.addEventListener("abort", onAbort, { once: true });
+  });
+  void (async () => {
+    let missingSince = null;
+    let failureCount = 0;
+    while (true) {
+      try {
+        logger.debug(`[FILE_WATCHER] Starting watcher for ${file}`);
+        const watcher = watch(file, { persistent: true, signal: abortController.signal });
+        for await (const event of watcher) {
+          if (abortController.signal.aborted) {
+            return;
+          }
+          missingSince = null;
+          failureCount = 0;
+          logger.debug(`[FILE_WATCHER] File changed: ${file}`);
+          onFileChange(file);
+        }
+      } catch (e) {
+        if (abortController.signal.aborted) {
+          return;
+        }
+        const isMissing = e?.code === "ENOENT";
+        if (isMissing) {
+          const now = Date.now();
+          if (missingSince === null) {
+            missingSince = now;
+          }
+          const absentMs = now - missingSince;
+          if (absentMs >= missingFileTimeoutMs) {
+            logger.debug(`[FILE_WATCHER] Giving up on ${file}: never appeared after ${Math.round(absentMs / 1e3)}s`);
+            options.onGaveUp?.();
+            return;
+          }
+        } else {
+          missingSince = null;
+        }
+        failureCount++;
+        const backoffMs = Math.min(1e3 * 2 ** Math.min(failureCount - 1, 4), 15e3);
+        logger.debug(`[FILE_WATCHER] Watch error: ${e.message}, retrying in ${backoffMs}ms`);
+        await wait(backoffMs);
+      }
+    }
+  })();
+  return () => {
+    abortController.abort();
+  };
+}
+
+export { startFileWatcher as s };

package/dist/startupPlan-BLMbfQIH.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+function planClaudeStartup(input) {
+  const daemonSpawned = input.startedBy === "daemon";
+  return {
+    registerMachine: !daemonSpawned,
+    ensureDaemonRunning: !daemonSpawned,
+    sessionClientBeforeWebhook: !input.reconnect
+  };
+}
+
+exports.planClaudeStartup = planClaudeStartup;

package/dist/startupPlan-DFMyNgAs.mjs

@@ -0,0 +1,10 @@
+function planClaudeStartup(input) {
+  const daemonSpawned = input.startedBy === "daemon";
+  return {
+    registerMachine: !daemonSpawned,
+    ensureDaemonRunning: !daemonSpawned,
+    sessionClientBeforeWebhook: !input.reconnect
+  };
+}
+
+export { planClaudeStartup as p };

package/dist/streamRelay-BiKw59Cc.cjs

@@ -0,0 +1,233 @@
+'use strict';
+
+var index = require('./index-DA7yINuk.cjs');
+
+const STREAM_FLUSH_MS = 80;
+const PROGRESS_FLUSH_MS = 250;
+const STREAM_FLUSH_MAX_BYTES = 16 * 1024;
+class StreamRelay {
+  send;
+  setTimer;
+  clearTimer;
+  now;
+  /** The block currently accumulating deltas. At most one is open at a time
+   *  in practice; a switch flushes the previous one first, so out-of-order
+   *  SDK frames degrade to "slightly chunkier", never to interleaved text. */
+  pending = null;
+  flushHandle = null;
+  progress = {};
+  progressDirty = false;
+  progressHandle = null;
+  /** Message id of the block currently open, so `content_block_delta` (which
+   *  carries only an index) can be attributed. Reset per assistant message. */
+  currentMid = null;
+  openBlocks = /* @__PURE__ */ new Set();
+  /** True while nothing has been ingested since the last sweep. Both the SDK
+   *  `result` frame and the launcher's `finally` call endTurn (the second is
+   *  the safety net for turns that die before producing a result), so
+   *  without this a normal turn would emit two sweeps. */
+  idleSinceTurnEnd = true;
+  constructor(options) {
+    this.send = options.send;
+    this.setTimer = options.setTimer ?? ((fn, ms) => setTimeout(fn, ms));
+    this.clearTimer = options.clearTimer ?? ((handle) => clearTimeout(handle));
+    this.now = options.now ?? (() => Date.now());
+  }
+  /** Feed one SDK frame. Unknown shapes are ignored, never thrown on: this
+   *  channel must not be able to take a turn down. */
+  ingest(message) {
+    this.idleSinceTurnEnd = false;
+    try {
+      if (message.type === "stream_event") {
+        this.ingestStreamEvent(message.event);
+        return;
+      }
+      if (message.type === "system" && message.subtype === "thinking_tokens") {
+        if (typeof message.estimated_tokens === "number") {
+          this.setProgress({ thinkingTokens: message.estimated_tokens });
+        }
+        return;
+      }
+      if (message.type === "system" && message.subtype === "status") {
+        const status = message.status === "requesting" || message.status === "compacting" ? message.status : void 0;
+        this.progress.status = status;
+        this.progressDirty = true;
+        this.scheduleProgress();
+        return;
+      }
+    } catch {
+    }
+  }
+  /** The turn produced its result. Flushes everything and tells the web to
+   *  sweep drafts that no persisted message ever claimed. */
+  endTurn() {
+    if (this.idleSinceTurnEnd) {
+      this.clearTimers();
+      return;
+    }
+    this.idleSinceTurnEnd = true;
+    this.flushPending();
+    this.closeOpenBlocks();
+    this.flushProgress();
+    this.progress = {};
+    this.currentMid = null;
+    this.send({ t: "turn-end" });
+  }
+  /** Release timers without emitting anything (session teardown). */
+  dispose() {
+    this.clearTimers();
+    this.pending = null;
+    this.openBlocks.clear();
+  }
+  clearTimers() {
+    if (this.flushHandle !== null) this.clearTimer(this.flushHandle);
+    if (this.progressHandle !== null) this.clearTimer(this.progressHandle);
+    this.flushHandle = null;
+    this.progressHandle = null;
+  }
+  ingestStreamEvent(event) {
+    const e = event;
+    if (!e || typeof e.type !== "string") return;
+    if (e.type === "message_start") {
+      const mid = e.message?.id;
+      this.flushPending();
+      this.closeOpenBlocks();
+      this.currentMid = typeof mid === "string" && mid.length > 0 ? mid : null;
+      const usage = e.message?.usage;
+      if (usage || ["inputTokens", "cacheTokens", "outputTokens", "thinkingTokens"].some((key) => key in this.progress)) {
+        const count = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : 0;
+        this.setProgress({
+          inputTokens: count(usage?.input_tokens),
+          cacheTokens: count(usage?.cache_creation_input_tokens) + count(usage?.cache_read_input_tokens),
+          outputTokens: count(usage?.output_tokens),
+          thinkingTokens: 0
+        });
+      }
+      return;
+    }
+    if (e.type === "content_block_start") {
+      const kind = e.content_block?.type === "thinking" ? "thinking" : e.content_block?.type === "text" ? "text" : null;
+      if (!kind || !this.currentMid || typeof e.index !== "number") return;
+      this.openBlock(this.currentMid, e.index, kind);
+      return;
+    }
+    if (e.type === "content_block_delta") {
+      const delta = e.delta;
+      const text = delta?.type === "text_delta" ? delta.text : delta?.type === "thinking_delta" ? delta.thinking : null;
+      if (typeof text !== "string" || text.length === 0) return;
+      if (!this.currentMid || typeof e.index !== "number") return;
+      this.appendDelta(this.currentMid, e.index, text);
+      return;
+    }
+    if (e.type === "content_block_stop") {
+      if (!this.currentMid || typeof e.index !== "number") return;
+      this.closeBlock(this.currentMid, e.index);
+      return;
+    }
+    if (e.type === "message_delta") {
+      const outputTokens = e.usage?.output_tokens;
+      if (typeof outputTokens === "number") {
+        this.setProgress({ outputTokens });
+      }
+      return;
+    }
+  }
+  // ---- Block-level API (see module comment) --------------------------------
+  /** Open a draft block. A different `mid` than the one currently open closes
+   *  whatever the previous message left open, exactly like the SDK's
+   *  `message_start` does. Re-opening an already open block is a no-op. */
+  openBlock(mid, idx, kind) {
+    this.idleSinceTurnEnd = false;
+    if (this.currentMid !== mid) {
+      this.flushPending();
+      this.closeOpenBlocks();
+      this.currentMid = mid;
+    }
+    if (this.openBlocks.has(idx)) return;
+    this.flushPending();
+    this.openBlocks.add(idx);
+    this.send({ t: "block-start", mid, idx, kind });
+  }
+  /** Append text to an OPEN block; deltas for a block that was never opened
+   *  (or belongs to another message) are dropped — the SDK path relies on
+   *  this to ignore `input_json_delta` for tool_use blocks. */
+  appendDelta(mid, idx, text) {
+    this.idleSinceTurnEnd = false;
+    if (text.length === 0) return;
+    if (this.currentMid !== mid || !this.openBlocks.has(idx)) return;
+    if (this.pending && (this.pending.mid !== mid || this.pending.idx !== idx)) {
+      this.flushPending();
+    }
+    if (!this.pending) {
+      this.pending = { mid, idx, text: "", bytes: 0 };
+    }
+    this.pending.text += text;
+    this.pending.bytes += Buffer.byteLength(text, "utf8");
+    if (this.pending.bytes >= STREAM_FLUSH_MAX_BYTES || this.pending.text.length >= index.STREAM_DELTA_MAX_CHARS) {
+      this.flushPending();
+      return;
+    }
+    if (this.flushHandle === null) {
+      this.flushHandle = this.setTimer(() => {
+        this.flushHandle = null;
+        this.flushPending();
+      }, STREAM_FLUSH_MS);
+    }
+  }
+  /** Close an open block: pending text goes out first, then `block-end`. */
+  closeBlock(mid, idx) {
+    this.idleSinceTurnEnd = false;
+    if (this.currentMid !== mid || !this.openBlocks.has(idx)) return;
+    this.flushPending();
+    this.openBlocks.delete(idx);
+    this.send({ t: "block-end", mid, idx });
+  }
+  /** Merge quantified progress; flushed on the progress cadence. */
+  setProgress(patch) {
+    this.idleSinceTurnEnd = false;
+    this.progress = { ...this.progress, ...patch };
+    this.progressDirty = true;
+    this.scheduleProgress();
+  }
+  // -------------------------------------------------------------------------
+  flushPending() {
+    if (this.flushHandle !== null) {
+      this.clearTimer(this.flushHandle);
+      this.flushHandle = null;
+    }
+    const pending = this.pending;
+    this.pending = null;
+    if (!pending || pending.text.length === 0) return;
+    this.send({ t: "block-delta", mid: pending.mid, idx: pending.idx, text: pending.text });
+  }
+  /** Close blocks the SDK never stopped (interrupt, error, message switch) so
+   *  the web's draft does not keep a blinking cursor forever. */
+  closeOpenBlocks() {
+    if (!this.currentMid || this.openBlocks.size === 0) {
+      this.openBlocks.clear();
+      return;
+    }
+    for (const idx of [...this.openBlocks].sort((a, b) => a - b)) {
+      this.send({ t: "block-end", mid: this.currentMid, idx });
+    }
+    this.openBlocks.clear();
+  }
+  scheduleProgress() {
+    if (this.progressHandle !== null) return;
+    this.progressHandle = this.setTimer(() => {
+      this.progressHandle = null;
+      this.flushProgress();
+    }, PROGRESS_FLUSH_MS);
+  }
+  flushProgress() {
+    if (this.progressHandle !== null) {
+      this.clearTimer(this.progressHandle);
+      this.progressHandle = null;
+    }
+    if (!this.progressDirty) return;
+    this.progressDirty = false;
+    this.send({ t: "progress", ...this.progress });
+  }
+}
+
+exports.StreamRelay = StreamRelay;