buddy-builder 1.4.4 → 1.4.5

package/dist/main.cjs

@@ -30,7 +30,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var import_electron6 = require("electron");
 var path5 = __toESM(require("path"), 1);
 var fs3 = __toESM(require("fs"), 1);
-var import_child_process4 = require("child_process");
+var import_child_process5 = require("child_process");
 
 // node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -13818,7 +13818,9 @@ var ContentBlockSchema = external_exports.union([
 ]);
 var UsageSchema = external_exports.object({
   input_tokens: external_exports.number(),
-  output_tokens: external_exports.number()
+  output_tokens: external_exports.number(),
+  cache_read_input_tokens: external_exports.number().optional(),
+  cache_creation_input_tokens: external_exports.number().optional()
 }).catchall(external_exports.unknown());
 var InitMessageSchema = external_exports.object({
   type: external_exports.literal("system"),
@@ -13911,6 +13913,11 @@ var SessionConfigSchema = external_exports.object({
   permissionMode: external_exports.enum(PermissionModes).optional(),
   resumeSessionId: external_exports.string().optional(),
   maxTurns: external_exports.number().positive().optional(),
+  maxBudgetUsd: external_exports.number().positive().optional(),
+  fallbackModel: external_exports.string().optional(),
+  addDirs: external_exports.array(external_exports.string()).optional(),
+  effort: external_exports.enum(["low", "medium", "high", "max"]).optional(),
+  worktree: external_exports.union([external_exports.boolean(), external_exports.string()]).optional(),
   noSessionPersistence: external_exports.boolean().optional(),
   env: external_exports.record(external_exports.string(), external_exports.string()).optional()
 });
@@ -13966,7 +13973,7 @@ function openInTerminal(cwd, command) {
 
 // src/main/manager.ts
 var import_crypto2 = require("crypto");
-var import_child_process3 = require("child_process");
+var import_child_process4 = require("child_process");
 var os2 = __toESM(require("os"), 1);
 
 // src/emitter.ts
@@ -14106,7 +14113,15 @@ var import_fs = require("fs");
 var import_path = require("path");
 var import_os = require("os");
 var import_crypto = require("crypto");
+var import_child_process3 = require("child_process");
 var DEFAULT_CLAUDE_PATH = process.platform === "win32" ? "claude.exe" : "claude";
+var resolvedClaudePath = null;
+if (process.platform === "win32") {
+  try {
+    resolvedClaudePath = (0, import_child_process3.execSync)("where claude", { encoding: "utf-8", timeout: 3e3 }).trim().split(/\r?\n/)[0].replace(/\//g, "\\") || null;
+  } catch {
+  }
+}
 function buildArgs(config2, settingsFilePath) {
   const args = [
     "--print",
@@ -14115,15 +14130,23 @@ function buildArgs(config2, settingsFilePath) {
     "--output-format",
     "stream-json",
     "--verbose",
-    "--include-partial-messages",
     "--settings",
     settingsFilePath
   ];
   if (config2.model) args.push("--model", config2.model);
   args.push("--dangerously-skip-permissions");
+  if (config2.systemPrompt) args.push("--append-system-prompt", config2.systemPrompt);
   if (config2.resumeSessionId) args.push("--resume", config2.resumeSessionId);
   if (config2.maxTurns != null) args.push("--max-turns", String(config2.maxTurns));
+  if (config2.maxBudgetUsd != null) args.push("--max-budget-usd", String(config2.maxBudgetUsd));
+  if (config2.fallbackModel) args.push("--fallback-model", config2.fallbackModel);
+  if (config2.effort) args.push("--effort", config2.effort);
+  if (config2.worktree === true) args.push("--worktree");
+  else if (typeof config2.worktree === "string" && config2.worktree) args.push("--worktree", config2.worktree);
   if (config2.noSessionPersistence) args.push("--no-session-persistence");
+  for (const dir of config2.addDirs ?? []) {
+    args.push("--add-dir", dir);
+  }
   for (const tool of config2.allowedTools ?? []) {
     args.push("--allowedTools", tool);
   }
@@ -14133,7 +14156,10 @@ function buildArgs(config2, settingsFilePath) {
   return args;
 }
 function spawnClaude(config2, hookPort, settingsJson) {
-  const claudePath = config2.claudePath ?? DEFAULT_CLAUDE_PATH;
+  let claudePath = resolvedClaudePath ?? config2.claudePath ?? DEFAULT_CLAUDE_PATH;
+  if (process.platform === "win32") {
+    claudePath = claudePath.replace(/\//g, "\\");
+  }
   const settingsDir = (0, import_path.join)((0, import_os.tmpdir)(), "buddy-builder");
   (0, import_fs.mkdirSync)(settingsDir, { recursive: true });
   const settingsFile = (0, import_path.join)(settingsDir, `settings-${(0, import_crypto.randomUUID)()}.json`);
@@ -14676,6 +14702,7 @@ function applyEvent(entries, event) {
     case "stateChange":
     case "warn":
     case "nameChanged":
+    case "effortChanged":
     case "popoutChanged":
       return false;
   }
@@ -14964,9 +14991,11 @@ function wireSession(managed, session, sink, onAssistantTurn) {
   });
   session.on("message", (msg) => {
     if (msg.message.usage) {
-      managed.totalInputTokens += msg.message.usage.input_tokens;
-      managed.totalOutputTokens += msg.message.usage.output_tokens;
-      sink({ kind: "usage", sessionId: id, inputTokens: msg.message.usage.input_tokens, outputTokens: msg.message.usage.output_tokens });
+      const u = msg.message.usage;
+      const totalIn = u.input_tokens + (u.cache_read_input_tokens ?? 0) + (u.cache_creation_input_tokens ?? 0);
+      managed.totalInputTokens += totalIn;
+      managed.totalOutputTokens += u.output_tokens;
+      sink({ kind: "usage", sessionId: id, inputTokens: totalIn, outputTokens: u.output_tokens });
     }
   });
   session.on("stop", (ev) => {
@@ -15024,7 +15053,7 @@ async function requestAutoName(managed, claudePath, sink) {
     const env = { ...process.env };
     delete env.CLAUDECODE;
     const rawTitle = await new Promise((resolve, reject) => {
-      const child = (0, import_child_process3.spawn)(
+      const child = (0, import_child_process4.spawn)(
         claudePath,
         ["-p", prompt, "--no-session-persistence", "--max-turns", "1"],
         { stdio: ["ignore", "pipe", "pipe"], env, cwd: os2.tmpdir() }
@@ -15112,6 +15141,7 @@ function createSessionManager(sink, claudePath) {
       totalInputTokens: 0,
       totalOutputTokens: 0,
       totalCost: 0,
+      effort: null,
       autoNamed: true,
       // don't auto-name until resumed
       userNamed: !!m.name,
@@ -15142,6 +15172,40 @@ function createSessionManager(sink, claudePath) {
       });
     }
   }
+  async function killAndResume(managed, configOverrides, successMsg, errorPrefix) {
+    if (!managed.session) throw new Error("Session is dead");
+    if (managed.session.state !== "idle") throw new Error("Session must be idle");
+    if (!managed.claudeSessionId) throw new Error("No Claude session ID");
+    const exitPromise = new Promise((resolve) => {
+      const check2 = () => {
+        if (!managed.session) resolve();
+        else setTimeout(check2, 50);
+      };
+      check2();
+    });
+    managed.session.kill();
+    await Promise.race([exitPromise, new Promise((_, reject) => setTimeout(() => reject(new Error("Timed out waiting for session exit")), 3e3))]);
+    try {
+      const config2 = {
+        claudePath,
+        permissionMode: managed.permissionMode,
+        resumeSessionId: managed.claudeSessionId,
+        cwd: managed.cwd ?? void 0,
+        ...configOverrides
+      };
+      const session = await createSession(config2);
+      managed.session = session;
+      session.setToolPolicy(buildToolPolicy(managed.policy, managed.permissionMode));
+      ensureEntries(managed).push({ kind: "system", text: successMsg, ts: Date.now() });
+      managed.lastActiveAt = Date.now();
+      wireSession(managed, session, sink, () => onAssistantTurn(managed));
+      sink({ kind: "stateChange", sessionId: managed.id, from: "dead", to: session.state });
+    } catch (err) {
+      const msg = `${errorPrefix}: ${err instanceof Error ? err.message : String(err)}`;
+      ensureEntries(managed).push({ kind: "system", text: msg, ts: Date.now() });
+      sink({ kind: "error", sessionId: managed.id, message: msg });
+    }
+  }
   return {
     async create(options) {
       const id = (0, import_crypto2.randomUUID)();
@@ -15155,7 +15219,12 @@ function createSessionManager(sink, claudePath) {
         cwd: cwd ?? void 0,
         model: options?.model,
         systemPrompt: options?.systemPrompt,
-        maxTurns: options?.maxTurns
+        maxTurns: options?.maxTurns,
+        maxBudgetUsd: options?.maxBudgetUsd,
+        fallbackModel: options?.fallbackModel,
+        addDirs: options?.addDirs ? [...options.addDirs] : void 0,
+        effort: options?.effort,
+        worktree: options?.worktree
       };
       const session = await createSession(config2);
       const initialPreset = PERMISSION_MODE_PRESETS[permMode];
@@ -15184,6 +15253,7 @@ function createSessionManager(sink, claudePath) {
         totalInputTokens: 0,
         totalOutputTokens: 0,
         totalCost: 0,
+        effort: options?.effort ?? null,
         autoNamed: !!options?.name,
         userNamed: !!options?.name,
         turnCount: 0
@@ -15269,6 +15339,66 @@ function createSessionManager(sink, claudePath) {
       wireSession(managed, session, sink, () => onAssistantTurn(managed));
       sink({ kind: "stateChange", sessionId: id, from: "dead", to: session.state });
     },
+    async changeModel(id, model) {
+      const managed = getManaged(id);
+      await killAndResume(managed, { model }, `Model changed to ${model}.`, `Failed to change model`);
+    },
+    async changeEffort(id, effort) {
+      const managed = getManaged(id);
+      await killAndResume(managed, { effort, model: managed.model ?? void 0 }, `Effort level changed to ${effort}.`, `Failed to change effort`);
+      managed.effort = effort;
+      sink({ kind: "effortChanged", sessionId: id, effort });
+    },
+    async fork(id) {
+      const source = getManaged(id);
+      if (!source.claudeSessionId) throw new Error("No Claude session ID \u2014 cannot fork");
+      const forkId = (0, import_crypto2.randomUUID)();
+      counter++;
+      const now = Date.now();
+      const config2 = {
+        claudePath,
+        permissionMode: source.permissionMode,
+        resumeSessionId: source.claudeSessionId,
+        cwd: source.cwd ?? void 0,
+        model: source.model ?? void 0
+      };
+      const session = await createSession(config2);
+      const policy = { ...source.policy };
+      const managed = {
+        id: forkId,
+        name: `${source.name} (fork)`,
+        projectName: source.projectName,
+        session,
+        claudeSessionId: null,
+        // will be set on ready event
+        cwd: source.cwd,
+        transcriptPath: null,
+        policy,
+        permissionMode: source.permissionMode,
+        entries: [{ kind: "system", text: `Forked from "${source.name}".`, ts: now }],
+        favorite: false,
+        createdAt: now,
+        lastActiveAt: now,
+        model: source.model,
+        claudeCodeVersion: null,
+        tools: [],
+        mcpServers: [],
+        skills: [],
+        agents: [],
+        slashCommands: [],
+        totalInputTokens: 0,
+        totalOutputTokens: 0,
+        totalCost: 0,
+        effort: source.effort,
+        autoNamed: false,
+        userNamed: false,
+        turnCount: 0
+      };
+      sessions.set(forkId, managed);
+      session.setToolPolicy(buildToolPolicy(policy, source.permissionMode));
+      wireSession(managed, session, sink, () => onAssistantTurn(managed));
+      return forkId;
+    },
     getResumeInfo(id) {
       const managed = getManaged(id);
       if (!managed.claudeSessionId) throw new Error("No Claude session ID to resume");
@@ -15289,6 +15419,71 @@ function createSessionManager(sink, claudePath) {
     getEntries(id) {
       return ensureEntries(getManaged(id));
     },
+    exportSession(id, format) {
+      const managed = getManaged(id);
+      const entries = ensureEntries(managed);
+      if (format === "json") {
+        return JSON.stringify({
+          sessionId: managed.id,
+          name: managed.name,
+          projectName: managed.projectName,
+          cwd: managed.cwd,
+          model: managed.model,
+          createdAt: managed.createdAt,
+          entries: entries.map((e) => ({ ...e }))
+        }, null, 2);
+      }
+      const lines = [];
+      lines.push(`# ${managed.name}`);
+      lines.push("");
+      if (managed.cwd) lines.push(`**Project:** ${managed.cwd}`);
+      if (managed.model) lines.push(`**Model:** ${managed.model}`);
+      lines.push(`**Created:** ${new Date(managed.createdAt).toISOString()}`);
+      lines.push("");
+      lines.push("---");
+      lines.push("");
+      for (const e of entries) {
+        switch (e.kind) {
+          case "user":
+            lines.push(`## User`);
+            lines.push("");
+            lines.push(e.text);
+            lines.push("");
+            break;
+          case "text":
+            lines.push(`## Assistant`);
+            lines.push("");
+            lines.push(e.text);
+            lines.push("");
+            break;
+          case "tool":
+            lines.push(`### Tool: ${e.toolName}`);
+            lines.push("");
+            if (e.detail) lines.push(`> ${e.detail}`);
+            if (e.toolResult) {
+              lines.push("```");
+              lines.push(e.toolResult.slice(0, 2e3));
+              lines.push("```");
+            }
+            lines.push("");
+            break;
+          case "system":
+            lines.push(`*${e.text}*`);
+            lines.push("");
+            break;
+          case "result":
+            lines.push(`---`);
+            lines.push(`*Cost: $${e.cost.toFixed(4)} \xB7 ${e.turns} turns \xB7 ${(e.durationMs / 1e3).toFixed(1)}s*`);
+            lines.push("");
+            break;
+          case "compact":
+            lines.push(`*Context compacted (${e.trigger})*`);
+            lines.push("");
+            break;
+        }
+      }
+      return lines.join("\n");
+    },
     getMeta(id) {
       const s = getManaged(id);
       return {
@@ -16010,6 +16205,15 @@ function createPopoutWindow(sessionId) {
   register({ kind: "popout", win, sessionId });
   dispatch({ kind: "popoutChanged", sessionId, poppedOut: true });
   dlog(`[popout] created id=${win.id} session=${sessionId}`);
+  win.webContents.on("console-message", (_e, level, message, line, sourceId) => {
+    if (level >= 2) dlog(`[popout-console][ERROR] ${message} (${sourceId}:${line})`);
+  });
+  win.webContents.on("did-fail-load", (_e, code, desc) => {
+    dlog(`[popout] DID-FAIL-LOAD code=${code} desc=${desc}`);
+  });
+  win.webContents.on("preload-error", (_e, preloadPath, error48) => {
+    dlog(`[popout] PRELOAD-ERROR path=${preloadPath} error=${error48}`);
+  });
   win.webContents.on("render-process-gone", (_e, details) => {
     dlog(`[popout] RENDER-PROCESS-GONE id=${win.id} reason=${details.reason} exitCode=${details.exitCode}`);
   });
@@ -16093,11 +16297,15 @@ function buildHandlers(mgr) {
       mgr.setFavorite(sessionId, favorite);
     },
     resumeSession: ({ sessionId }) => mgr.resume(sessionId),
+    changeModel: ({ sessionId, model }) => mgr.changeModel(sessionId, model),
+    forkSession: ({ sessionId }) => mgr.fork(sessionId),
+    changeEffort: ({ sessionId, effort }) => mgr.changeEffort(sessionId, effort),
     resumeInTerminal: ({ sessionId }) => {
       const { claudeSessionId, cwd, permissionMode } = mgr.getResumeInfo(sessionId);
       const skipPerms = permissionMode === "bypassPermissions" ? " --dangerously-skip-permissions" : "";
       openInTerminal(cwd ?? process.env.HOME ?? process.env.USERPROFILE ?? ".", `claude --resume ${claudeSessionId}${skipPerms}`);
     },
+    exportSession: ({ sessionId, format }) => mgr.exportSession(sessionId, format),
     deleteSession: ({ sessionId }) => {
       mgr.remove(sessionId);
     },
@@ -16310,14 +16518,14 @@ import_electron6.app.whenReady().then(() => {
   let claudePath = config2.claudePath;
   try {
     const shell2 = process.env.SHELL || "/bin/zsh";
-    const rawPath = (0, import_child_process4.execSync)(`${shell2} -ilc "echo \\$PATH"`, { encoding: "utf-8" });
+    const rawPath = (0, import_child_process5.execSync)(`${shell2} -ilc "echo \\$PATH"`, { encoding: "utf-8" });
     const shellPath = rawPath.trim().split("\n").filter(Boolean).pop();
     if (shellPath) {
       process.env.PATH = shellPath;
       console.log("[shell] inherited PATH from login shell");
     }
     if (claudePath === "claude") {
-      const raw = (0, import_child_process4.execSync)(`${shell2} -ilc "which claude"`, { encoding: "utf-8" });
+      const raw = (0, import_child_process5.execSync)(`${shell2} -ilc "which claude"`, { encoding: "utf-8" });
       claudePath = raw.trim().split("\n").filter(Boolean).pop() ?? "claude";
       console.log("[claude] resolved path:", claudePath);
     }