happy-coder 0.11.2 → 0.12.0-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-DmJ8WyYo.cjs → index-BCQGaH21.cjs}

@@ -3,7 +3,7 @@
 var chalk = require('chalk');
 var os = require('node:os');
 var node_crypto = require('node:crypto');
-var types = require('./types-Bg43e3vc.cjs');
+var types = require('./types-C7skJO9Y.cjs');
 var node_child_process = require('node:child_process');
 var node_path = require('node:path');
 var node_readline = require('node:readline');
@@ -242,31 +242,19 @@ const claudeCliPath = node_path.resolve(node_path.join(types.projectPath(), "scr
 async function claudeLocal(opts) {
   const projectDir = getProjectPath(opts.path);
   fs.mkdirSync(projectDir, { recursive: true });
-  const watcher = fs.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")) {
-      types.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 : node_crypto.randomUUID();
+  const effectiveSessionId = startFrom || newSessionId;
+  if (newSessionId) {
+    types.logger.debug(`[ClaudeLocal] Generated new session ID: ${newSessionId}`);
+    opts.onSessionFound(newSessionId);
+  } else {
+    types.logger.debug(`[ClaudeLocal] Resuming session: ${startFrom}`);
+    opts.onSessionFound(startFrom);
+  }
   let thinking = false;
   let stopThinkingTimeout = null;
   const updateThinking = (newThinking) => {
@@ -284,6 +272,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) {
@@ -302,6 +292,8 @@ async function claudeLocal(opts) {
         ...process.env,
         ...opts.claudeEnvVars
       };
+      types.logger.debug(`[ClaudeLocal] Spawning launcher: ${claudeCliPath}`);
+      types.logger.debug(`[ClaudeLocal] Args: ${JSON.stringify(args)}`);
       const child = node_child_process.spawn("node", [claudeCliPath, ...args], {
         stdio: ["inherit", "inherit", "inherit", "pipe"],
         signal: opts.abort,
@@ -318,13 +310,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,
@@ -378,7 +363,6 @@ async function claudeLocal(opts) {
       });
     });
   } finally {
-    watcher.close();
     process.stdin.resume();
     if (stopThinkingTimeout) {
       clearTimeout(stopThinkingTimeout);
@@ -386,7 +370,7 @@ async function claudeLocal(opts) {
     }
     updateThinking(false);
   }
-  return resolvedSessionId;
+  return effectiveSessionId;
 }
 
 class Future {
@@ -504,6 +488,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();
@@ -513,26 +502,42 @@ async function createSessionScanner(opts) {
   let processedMessageKeys = /* @__PURE__ */ new Set();
   if (opts.sessionId) {
     let messages = await readSessionLog(projectDir, opts.sessionId);
+    types.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);
+        types.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) {
+        types.logger.debug(`[SESSION_SCANNER] Session ${session}: found=${sessionMessages.length}, skipped=${skipped}, sent=${sent}`);
       }
     }
     for (let p of sessions) {
@@ -543,6 +548,7 @@ async function createSessionScanner(opts) {
     }
     for (let p of sessions) {
       if (!watchers.has(p)) {
+        types.logger.debug(`[SESSION_SCANNER] Starting watcher for session: ${p}`);
         watchers.set(p, startFileWatcher(node_path.join(projectDir, `${p}.jsonl`), () => {
           sync.invalidate();
         }));
@@ -616,9 +622,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 = types.RawJSONLinesSchema.safeParse(message);
       if (!parsed.success) {
-        types.logger.debugLargeJson(`[SESSION_SCANNER] Failed to parse message`, message);
         continue;
       }
       messages.push(parsed.data);
@@ -981,10 +989,94 @@ class AbortError extends Error {
   }
 }
 
-const __filename$1 = node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-DmJ8WyYo.cjs', document.baseURI).href)));
+const __filename$1 = node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-BCQGaH21.cjs', document.baseURI).href)));
 const __dirname$1 = node_path.join(__filename$1, "..");
+function getGlobalClaudeVersion() {
+  try {
+    const cleanEnv = getCleanEnv();
+    const output = node_child_process.execSync("claude --version", {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+      cwd: os.homedir(),
+      env: cleanEnv
+    }).trim();
+    const match = output.match(/(\d+\.\d+\.\d+)/);
+    types.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;
+    types.logger.debug(`[Claude SDK] Cleaned PATH, removed local paths from: ${cwd}`);
+  }
+  return env;
+}
+function findGlobalClaudePath() {
+  const homeDir = os.homedir();
+  const cleanEnv = getCleanEnv();
+  try {
+    node_child_process.execSync("claude --version", {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+      cwd: homeDir,
+      env: cleanEnv
+    });
+    types.logger.debug("[Claude SDK] Global claude command available (checked with clean PATH)");
+    return "claude";
+  } catch {
+  }
+  if (process.platform !== "win32") {
+    try {
+      const result = node_child_process.execSync("which claude", {
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"],
+        cwd: homeDir,
+        env: cleanEnv
+      }).trim();
+      if (result && fs.existsSync(result)) {
+        types.logger.debug(`[Claude SDK] Found global claude path via which: ${result}`);
+        return result;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
 function getDefaultClaudeCodePath() {
-  return node_path.join(__dirname$1, "..", "..", "..", "node_modules", "@anthropic-ai", "claude-code", "cli.js");
+  const nodeModulesPath = node_path.join(__dirname$1, "..", "..", "..", "node_modules", "@anthropic-ai", "claude-code", "cli.js");
+  if (process.env.HAPPY_CLAUDE_PATH) {
+    types.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") {
+    types.logger.debug(`[Claude SDK] Forced bundled version: ${nodeModulesPath}`);
+    return nodeModulesPath;
+  }
+  const globalPath = findGlobalClaudePath();
+  if (!globalPath) {
+    types.logger.debug(`[Claude SDK] No global claude found, using bundled: ${nodeModulesPath}`);
+    return nodeModulesPath;
+  }
+  const globalVersion = getGlobalClaudeVersion();
+  types.logger.debug(`[Claude SDK] Global version: ${globalVersion || "unknown"}`);
+  if (!globalVersion) {
+    types.logger.debug(`[Claude SDK] Cannot compare versions, using global: ${globalPath}`);
+    return globalPath;
+  }
+  return globalPath;
 }
 function logDebug(message) {
   if (process.env.DEBUG) {
@@ -1249,17 +1341,22 @@ function query(config) {
   } else {
     args.push("--input-format", "stream-json");
   }
-  if (!fs.existsSync(pathToClaudeCodeExecutable)) {
+  const isJsFile = pathToClaudeCodeExecutable.endsWith(".js") || pathToClaudeCodeExecutable.endsWith(".cjs");
+  const isCommandOnly = pathToClaudeCodeExecutable === "claude";
+  if (!isCommandOnly && !fs.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 = node_child_process.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 = node_child_process.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") {
@@ -4605,8 +4702,7 @@ async function startHappyServer(client) {
   };
   const mcp = new mcp_js.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",
@@ -5816,7 +5912,7 @@ async function handleConnectVendor(vendor, displayName) {
     return;
   } else if (subcommand === "codex") {
     try {
-      const { runCodex } = await Promise.resolve().then(function () { return require('./runCodex-DQPZNHzH.cjs'); });
+      const { runCodex } = await Promise.resolve().then(function () { return require('./runCodex-BwpHgdkt.cjs'); });
       let startedBy = void 0;
       for (let i = 1; i < args.length; i++) {
         if (args[i] === "--started-by") {