happy-coder 0.11.2 → 0.12.0

package/dist/codex/happyMcpStdioBridge.cjs

@@ -31,7 +31,7 @@ async function main() {
     if (httpClient) return httpClient;
     const client = new index_js.Client(
       { name: "happy-stdio-bridge", version: "1.0.0" },
-      { capabilities: { tools: {} } }
+      { capabilities: {} }
     );
     const transport = new streamableHttp_js.StreamableHTTPClientTransport(new URL(baseUrl));
     await client.connect(transport);
@@ -40,8 +40,7 @@ async function main() {
   }
   const server = new mcp_js.McpServer({
     name: "Happy MCP Bridge",
-    version: "1.0.0",
-    description: "STDIO bridge forwarding to Happy HTTP MCP"
+    version: "1.0.0"
   });
   server.registerTool(
     "change_title",

package/dist/codex/happyMcpStdioBridge.mjs

@@ -29,7 +29,7 @@ async function main() {
     if (httpClient) return httpClient;
     const client = new Client(
       { name: "happy-stdio-bridge", version: "1.0.0" },
-      { capabilities: { tools: {} } }
+      { capabilities: {} }
     );
     const transport = new StreamableHTTPClientTransport(new URL(baseUrl));
     await client.connect(transport);
@@ -38,8 +38,7 @@ async function main() {
   }
   const server = new McpServer({
     name: "Happy MCP Bridge",
-    version: "1.0.0",
-    description: "STDIO bridge forwarding to Happy HTTP MCP"
+    version: "1.0.0"
   });
   server.registerTool(
     "change_title",

package/dist/{index-sSOy3f2x.mjs → index-DMBGazgc.mjs}

@@ -1,13 +1,13 @@
 import chalk from 'chalk';
 import os$1, { homedir } from 'node:os';
 import { randomUUID, randomBytes } from 'node:crypto';
-import { l as logger, p as projectPath, d as backoff, e as delay, R as RawJSONLinesSchema, f as AsyncLock, c as configuration, g as readDaemonState, h as clearDaemonState, b as packageJson, r as readSettings, i as readCredentials, j as encodeBase64, u as updateSettings, k as encodeBase64Url, m as decodeBase64, w as writeCredentialsLegacy, n as writeCredentialsDataKey, o as acquireDaemonLock, q as writeDaemonState, A as ApiClient, s as releaseDaemonLock, t as clearCredentials, v as clearMachineId, x as getLatestDaemonLog } from './types-CjceR-4_.mjs';
+import { l as logger, p as projectPath, d as backoff, e as delay, R as RawJSONLinesSchema, f as AsyncLock, c as configuration, g as readDaemonState, h as clearDaemonState, b as packageJson, r as readSettings, i as readCredentials, j as encodeBase64, u as updateSettings, k as encodeBase64Url, m as decodeBase64, w as writeCredentialsLegacy, n as writeCredentialsDataKey, o as acquireDaemonLock, q as writeDaemonState, A as ApiClient, s as releaseDaemonLock, t as clearCredentials, v as clearMachineId, x as getLatestDaemonLog } from './types-7HcYY6Ao.mjs';
 import { spawn, execSync, execFileSync } from 'node:child_process';
 import { resolve, join } from 'node:path';
 import { createInterface } from 'node:readline';
-import { existsSync, readFileSync, mkdirSync, watch, readdirSync, statSync, rmSync } from 'node:fs';
+import { existsSync, readFileSync, mkdirSync, readdirSync, statSync, rmSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
-import fs, { watch as watch$1, access } from 'fs/promises';
+import fs, { watch, access } from 'fs/promises';
 import { useStdout, useInput, Box, Text, render } from 'ink';
 import React, { useState, useRef, useEffect, useCallback } from 'react';
 import { fileURLToPath } from 'node:url';
@@ -220,31 +220,19 @@ const claudeCliPath = resolve(join(projectPath(), "scripts", "claude_local_launc
 async function claudeLocal(opts) {
   const projectDir = getProjectPath(opts.path);
   mkdirSync(projectDir, { recursive: true });
-  const watcher = watch(projectDir);
-  let resolvedSessionId = null;
-  const detectedIdsRandomUUID = /* @__PURE__ */ new Set();
-  const detectedIdsFileSystem = /* @__PURE__ */ new Set();
-  watcher.on("change", (event, filename) => {
-    if (typeof filename === "string" && filename.toLowerCase().endsWith(".jsonl")) {
-      logger.debug("change", event, filename);
-      const sessionId = filename.replace(".jsonl", "");
-      if (detectedIdsFileSystem.has(sessionId)) {
-        return;
-      }
-      detectedIdsFileSystem.add(sessionId);
-      if (resolvedSessionId) {
-        return;
-      }
-      if (detectedIdsRandomUUID.has(sessionId)) {
-        resolvedSessionId = sessionId;
-        opts.onSessionFound(sessionId);
-      }
-    }
-  });
   let startFrom = opts.sessionId;
   if (opts.sessionId && !claudeCheckSession(opts.sessionId, opts.path)) {
     startFrom = null;
   }
+  const newSessionId = startFrom ? null : randomUUID();
+  const effectiveSessionId = startFrom || newSessionId;
+  if (newSessionId) {
+    logger.debug(`[ClaudeLocal] Generated new session ID: ${newSessionId}`);
+    opts.onSessionFound(newSessionId);
+  } else {
+    logger.debug(`[ClaudeLocal] Resuming session: ${startFrom}`);
+    opts.onSessionFound(startFrom);
+  }
   let thinking = false;
   let stopThinkingTimeout = null;
   const updateThinking = (newThinking) => {
@@ -262,6 +250,8 @@ async function claudeLocal(opts) {
       const args = [];
       if (startFrom) {
         args.push("--resume", startFrom);
+      } else {
+        args.push("--session-id", newSessionId);
       }
       args.push("--append-system-prompt", systemPrompt);
       if (opts.mcpServers && Object.keys(opts.mcpServers).length > 0) {
@@ -280,6 +270,8 @@ async function claudeLocal(opts) {
         ...process.env,
         ...opts.claudeEnvVars
       };
+      logger.debug(`[ClaudeLocal] Spawning launcher: ${claudeCliPath}`);
+      logger.debug(`[ClaudeLocal] Args: ${JSON.stringify(args)}`);
       const child = spawn("node", [claudeCliPath, ...args], {
         stdio: ["inherit", "inherit", "inherit", "pipe"],
         signal: opts.abort,
@@ -296,13 +288,6 @@ async function claudeLocal(opts) {
           try {
             const message = JSON.parse(line);
             switch (message.type) {
-              case "uuid":
-                detectedIdsRandomUUID.add(message.value);
-                if (!resolvedSessionId && detectedIdsFileSystem.has(message.value)) {
-                  resolvedSessionId = message.value;
-                  opts.onSessionFound(message.value);
-                }
-                break;
               case "fetch-start":
                 activeFetches.set(message.id, {
                   hostname: message.hostname,
@@ -356,7 +341,6 @@ async function claudeLocal(opts) {
       });
     });
   } finally {
-    watcher.close();
     process.stdin.resume();
     if (stopThinkingTimeout) {
       clearTimeout(stopThinkingTimeout);
@@ -364,7 +348,7 @@ async function claudeLocal(opts) {
     }
     updateThinking(false);
   }
-  return resolvedSessionId;
+  return effectiveSessionId;
 }
 
 class Future {
@@ -460,7 +444,7 @@ function startFileWatcher(file, onFileChange) {
     while (true) {
       try {
         logger.debug(`[FILE_WATCHER] Starting watcher for ${file}`);
-        const watcher = watch$1(file, { persistent: true, signal: abortController.signal });
+        const watcher = watch(file, { persistent: true, signal: abortController.signal });
         for await (const event of watcher) {
           if (abortController.signal.aborted) {
             return;
@@ -482,6 +466,11 @@ function startFileWatcher(file, onFileChange) {
   };
 }
 
+const INTERNAL_CLAUDE_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "file-history-snapshot",
+  "change",
+  "queue-operation"
+]);
 async function createSessionScanner(opts) {
   const projectDir = getProjectPath(opts.workingDirectory);
   let finishedSessions = /* @__PURE__ */ new Set();
@@ -491,26 +480,42 @@ async function createSessionScanner(opts) {
   let processedMessageKeys = /* @__PURE__ */ new Set();
   if (opts.sessionId) {
     let messages = await readSessionLog(projectDir, opts.sessionId);
+    logger.debug(`[SESSION_SCANNER] Marking ${messages.length} existing messages as processed from session ${opts.sessionId}`);
     for (let m of messages) {
       processedMessageKeys.add(messageKey(m));
     }
+    currentSessionId = opts.sessionId;
   }
   const sync = new InvalidateSync(async () => {
     let sessions = [];
     for (let p of pendingSessions) {
       sessions.push(p);
     }
-    if (currentSessionId) {
+    if (currentSessionId && !pendingSessions.has(currentSessionId)) {
       sessions.push(currentSessionId);
     }
+    for (let [sessionId] of watchers) {
+      if (!sessions.includes(sessionId)) {
+        sessions.push(sessionId);
+      }
+    }
     for (let session of sessions) {
-      for (let file of await readSessionLog(projectDir, session)) {
+      const sessionMessages = await readSessionLog(projectDir, session);
+      let skipped = 0;
+      let sent = 0;
+      for (let file of sessionMessages) {
         let key = messageKey(file);
         if (processedMessageKeys.has(key)) {
+          skipped++;
           continue;
         }
         processedMessageKeys.add(key);
+        logger.debug(`[SESSION_SCANNER] Sending new message: type=${file.type}, uuid=${file.type === "summary" ? file.leafUuid : file.uuid}`);
         opts.onMessage(file);
+        sent++;
+      }
+      if (sessionMessages.length > 0) {
+        logger.debug(`[SESSION_SCANNER] Session ${session}: found=${sessionMessages.length}, skipped=${skipped}, sent=${sent}`);
       }
     }
     for (let p of sessions) {
@@ -521,6 +526,7 @@ async function createSessionScanner(opts) {
     }
     for (let p of sessions) {
       if (!watchers.has(p)) {
+        logger.debug(`[SESSION_SCANNER] Starting watcher for session: ${p}`);
         watchers.set(p, startFileWatcher(join(projectDir, `${p}.jsonl`), () => {
           sync.invalidate();
         }));
@@ -594,9 +600,11 @@ async function readSessionLog(projectDir, sessionId) {
         continue;
       }
       let message = JSON.parse(l);
+      if (message.type && INTERNAL_CLAUDE_EVENT_TYPES.has(message.type)) {
+        continue;
+      }
       let parsed = RawJSONLinesSchema.safeParse(message);
       if (!parsed.success) {
-        logger.debugLargeJson(`[SESSION_SCANNER] Failed to parse message`, message);
         continue;
       }
       messages.push(parsed.data);
@@ -961,8 +969,92 @@ class AbortError extends Error {
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = join(__filename, "..");
+function getGlobalClaudeVersion() {
+  try {
+    const cleanEnv = getCleanEnv();
+    const output = execSync("claude --version", {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+      cwd: homedir(),
+      env: cleanEnv
+    }).trim();
+    const match = output.match(/(\d+\.\d+\.\d+)/);
+    logger.debug(`[Claude SDK] Global claude --version output: ${output}`);
+    return match ? match[1] : null;
+  } catch {
+    return null;
+  }
+}
+function getCleanEnv() {
+  const env = { ...process.env };
+  const cwd = process.cwd();
+  const pathSep = process.platform === "win32" ? ";" : ":";
+  const pathKey = process.platform === "win32" ? "Path" : "PATH";
+  const actualPathKey = Object.keys(env).find((k) => k.toLowerCase() === "path") || pathKey;
+  if (env[actualPathKey]) {
+    const cleanPath = env[actualPathKey].split(pathSep).filter((p) => {
+      const normalizedP = p.replace(/\\/g, "/").toLowerCase();
+      const normalizedCwd = cwd.replace(/\\/g, "/").toLowerCase();
+      return !normalizedP.startsWith(normalizedCwd);
+    }).join(pathSep);
+    env[actualPathKey] = cleanPath;
+    logger.debug(`[Claude SDK] Cleaned PATH, removed local paths from: ${cwd}`);
+  }
+  return env;
+}
+function findGlobalClaudePath() {
+  const homeDir = homedir();
+  const cleanEnv = getCleanEnv();
+  try {
+    execSync("claude --version", {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+      cwd: homeDir,
+      env: cleanEnv
+    });
+    logger.debug("[Claude SDK] Global claude command available (checked with clean PATH)");
+    return "claude";
+  } catch {
+  }
+  if (process.platform !== "win32") {
+    try {
+      const result = execSync("which claude", {
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"],
+        cwd: homeDir,
+        env: cleanEnv
+      }).trim();
+      if (result && existsSync(result)) {
+        logger.debug(`[Claude SDK] Found global claude path via which: ${result}`);
+        return result;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
 function getDefaultClaudeCodePath() {
-  return join(__dirname, "..", "..", "..", "node_modules", "@anthropic-ai", "claude-code", "cli.js");
+  const nodeModulesPath = join(__dirname, "..", "..", "..", "node_modules", "@anthropic-ai", "claude-code", "cli.js");
+  if (process.env.HAPPY_CLAUDE_PATH) {
+    logger.debug(`[Claude SDK] Using HAPPY_CLAUDE_PATH: ${process.env.HAPPY_CLAUDE_PATH}`);
+    return process.env.HAPPY_CLAUDE_PATH;
+  }
+  if (process.env.HAPPY_USE_BUNDLED_CLAUDE === "1") {
+    logger.debug(`[Claude SDK] Forced bundled version: ${nodeModulesPath}`);
+    return nodeModulesPath;
+  }
+  const globalPath = findGlobalClaudePath();
+  if (!globalPath) {
+    logger.debug(`[Claude SDK] No global claude found, using bundled: ${nodeModulesPath}`);
+    return nodeModulesPath;
+  }
+  const globalVersion = getGlobalClaudeVersion();
+  logger.debug(`[Claude SDK] Global version: ${globalVersion || "unknown"}`);
+  if (!globalVersion) {
+    logger.debug(`[Claude SDK] Cannot compare versions, using global: ${globalPath}`);
+    return globalPath;
+  }
+  return globalPath;
 }
 function logDebug(message) {
   if (process.env.DEBUG) {
@@ -1227,17 +1319,22 @@ function query(config) {
   } else {
     args.push("--input-format", "stream-json");
   }
-  if (!existsSync(pathToClaudeCodeExecutable)) {
+  const isJsFile = pathToClaudeCodeExecutable.endsWith(".js") || pathToClaudeCodeExecutable.endsWith(".cjs");
+  const isCommandOnly = pathToClaudeCodeExecutable === "claude";
+  if (!isCommandOnly && !existsSync(pathToClaudeCodeExecutable)) {
     throw new ReferenceError(`Claude Code executable not found at ${pathToClaudeCodeExecutable}. Is options.pathToClaudeCodeExecutable set?`);
   }
-  logDebug(`Spawning Claude Code process: ${executable} ${[...executableArgs, pathToClaudeCodeExecutable, ...args].join(" ")}`);
-  const child = spawn(executable, [...executableArgs, pathToClaudeCodeExecutable, ...args], {
+  const spawnCommand = isJsFile ? executable : pathToClaudeCodeExecutable;
+  const spawnArgs = isJsFile ? [...executableArgs, pathToClaudeCodeExecutable, ...args] : args;
+  const spawnEnv = isCommandOnly ? getCleanEnv() : process.env;
+  logDebug(`Spawning Claude Code process: ${spawnCommand} ${spawnArgs.join(" ")} (using ${isCommandOnly ? "clean" : "normal"} env)`);
+  const child = spawn(spawnCommand, spawnArgs, {
     cwd,
     stdio: ["pipe", "pipe", "pipe"],
     signal: config.options?.abort,
-    env: {
-      ...process.env
-    }
+    env: spawnEnv,
+    // Use shell on Windows for global binaries and command-only mode
+    shell: !isJsFile && process.platform === "win32"
   });
   let childStdin = null;
   if (typeof prompt === "string") {
@@ -4583,8 +4680,7 @@ async function startHappyServer(client) {
   };
   const mcp = new McpServer({
     name: "Happy MCP",
-    version: "1.0.0",
-    description: "Happy CLI MCP server with chat session management tools"
+    version: "1.0.0"
   });
   mcp.registerTool("change_title", {
     description: "Change the title of the current chat session",
@@ -4675,7 +4771,7 @@ async function runClaude(credentials, options = {}) {
   const settings = await readSettings();
   let machineId = settings?.machineId;
   if (!machineId) {
-    console.error(`[START] No machine ID found in settings, which is unexepcted since authAndSetupMachineIfNeeded should have created it. Please report this issue on https://github.com/slopus/happy-cli/issues`);
+    console.error(`[START] No machine ID found in settings, which is unexpected since authAndSetupMachineIfNeeded should have created it. Please report this issue on https://github.com/slopus/happy-cli/issues`);
     process.exit(1);
   }
   logger.debug(`Using machineId: ${machineId}`);
@@ -5794,7 +5890,7 @@ async function handleConnectVendor(vendor, displayName) {
     return;
   } else if (subcommand === "codex") {
     try {
-      const { runCodex } = await import('./runCodex-BnjA1TX6.mjs');
+      const { runCodex } = await import('./runCodex-BgCwl6pc.mjs');
       let startedBy = void 0;
       for (let i = 1; i < args.length; i++) {
         if (args[i] === "--started-by") {