@sma1lboy/kobe 0.5.8 → 0.5.10

package/dist/bin/kobed.js

@@ -362,7 +362,8 @@ var init_binary = __esm(() => {
 });
 
 // src/engine/claude-code-local/history.ts
-import { readFile, readdir, unlink } from "fs/promises";
+import { randomUUID } from "crypto";
+import { appendFile, mkdir, readFile, readdir, unlink, writeFile } from "fs/promises";
 import { homedir as homedir3 } from "os";
 import path2 from "path";
 function encodeCwd(cwd) {
@@ -459,6 +460,76 @@ function extractUsage(v) {
 function isObject(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
+async function appendInterruptedUserPrompt(sessionId, cwd, prompt, deps = defaultDeps2) {
+  if (!prompt || prompt.trim().length === 0)
+    return;
+  const projectDir = path2.join(deps.projectsDir(), encodeCwd(cwd));
+  const filePath = path2.join(projectDir, `${sessionId}.jsonl`);
+  let lines = [];
+  try {
+    const raw = await readFile(filePath, "utf8");
+    lines = raw.split(`
+`).filter((l) => l.length > 0);
+  } catch (err) {
+    if (err.code !== "ENOENT")
+      throw err;
+    await mkdir(projectDir, { recursive: true });
+  }
+  let lastConvIdx = -1;
+  let lastConvRecord = null;
+  let lastConvRole = null;
+  for (let i = lines.length - 1;i >= 0; i--) {
+    let parsed;
+    try {
+      parsed = JSON.parse(lines[i]);
+    } catch {
+      continue;
+    }
+    if (!isObject(parsed))
+      continue;
+    const inner = isObject(parsed.message) ? parsed.message : parsed;
+    const role = inner.role;
+    if (role === "user" || role === "assistant") {
+      lastConvIdx = i;
+      lastConvRecord = parsed;
+      lastConvRole = role;
+      break;
+    }
+  }
+  const now = new Date().toISOString();
+  if (lastConvRole === "user" && lastConvRecord && lastConvIdx >= 0) {
+    const inner = isObject(lastConvRecord.message) ? lastConvRecord.message : lastConvRecord;
+    const existing = typeof inner.content === "string" ? inner.content : "";
+    if (existing === prompt || existing.endsWith(`
+
+${prompt}`))
+      return;
+    inner.content = existing.length > 0 ? `${existing}
+
+${prompt}` : prompt;
+    lastConvRecord.timestamp = now;
+    lines[lastConvIdx] = JSON.stringify(lastConvRecord);
+    await writeFile(filePath, `${lines.join(`
+`)}
+`);
+    return;
+  }
+  const parentUuid = lastConvRecord && typeof lastConvRecord.uuid === "string" ? lastConvRecord.uuid : null;
+  const record = {
+    type: "user",
+    message: { role: "user", content: prompt },
+    uuid: randomUUID(),
+    parentUuid,
+    sessionId,
+    cwd,
+    timestamp: now,
+    isSidechain: false,
+    userType: "external",
+    version: "1.0.0"
+  };
+  await appendFile(filePath, `${JSON.stringify(record)}
+`);
+}
 var defaultDeps2;
 var init_history = __esm(() => {
   defaultDeps2 = {
@@ -866,13 +937,21 @@ class ClaudeCodeLocal {
   }
   async stop(handle) {
     const sid = handle.sessionId;
-    await this.registry.kill(sid, this.stopGraceMs);
     const session = this.running.get(sid);
+    const shouldRescue = !!session && !session.completedNaturally && session.prompt.trim().length > 0;
+    const rescuePrompt = session?.prompt ?? "";
+    const rescueCwd = session?.cwd ?? handle.cwd;
+    await this.registry.kill(sid, this.stopGraceMs);
     if (session) {
       session.closed = true;
       this.notify(session);
       this.running.delete(sid);
     }
+    if (shouldRescue) {
+      try {
+        await appendInterruptedUserPrompt(sid, rescueCwd, rescuePrompt);
+      } catch {}
+    }
   }
   async start(args) {
     const binaryPath = await this.binaryPathResolver();
@@ -905,14 +984,17 @@ class ClaudeCodeLocal {
         spawned,
         queue,
         waiters: [],
-        closed: false
+        closed: false,
+        completedNaturally: false,
+        prompt: args.prompt
       };
       this.running.set(sessionId, session);
       this.registry.register({
         sessionId,
         cwd: args.cwd,
         proc: spawned.proc,
-        startedAt: Date.now()
+        startedAt: Date.now(),
+        prompt: args.prompt
       });
       resolveHandle({ sessionId, cwd: args.cwd });
     };
@@ -934,6 +1016,9 @@ class ClaudeCodeLocal {
       try {
         for await (const ev of events) {
           queue.push(ev);
+          if (ev.type === "done" && session) {
+            session.completedNaturally = true;
+          }
           if (session)
             this.notify(session);
         }
@@ -988,11 +1073,11 @@ var init_claude_code_local = __esm(() => {
 });
 
 // src/orchestrator/bridge/server.ts
-import { mkdir, unlink as unlink2 } from "fs/promises";
+import { mkdir as mkdir2, unlink as unlink2 } from "fs/promises";
 import { createServer } from "net";
 import { dirname as dirname2 } from "path";
 async function startBridgeServer(orch, socketPath) {
-  await mkdir(dirname2(socketPath), { recursive: true });
+  await mkdir2(dirname2(socketPath), { recursive: true });
   await unlink2(socketPath).catch(() => {});
   const conns = new Set;
   const server = createServer((conn) => {
@@ -1125,7 +1210,7 @@ var exports_bridge = {};
 __export(exports_bridge, {
   startBridge: () => startBridge
 });
-import { writeFile } from "fs/promises";
+import { writeFile as writeFile2 } from "fs/promises";
 import { homedir as homedir5 } from "os";
 import { join as join3 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
@@ -1145,7 +1230,7 @@ async function startBridge(orch, opts = {}) {
       }
     }
   };
-  await writeFile(mcpConfigPath, JSON.stringify(mcpConfig, null, 2), "utf8");
+  await writeFile2(mcpConfigPath, JSON.stringify(mcpConfig, null, 2), "utf8");
   process.env.KOBE_MCP_CONFIG = mcpConfigPath;
   return {
     socketPath,
@@ -2421,6 +2506,86 @@ var init_claude_settings = __esm(() => {
   SETTINGS_PATH = join4(homedir6(), ".claude", "settings.json");
 });
 
+// src/session/usage-metrics.ts
+function totalContextTokens(u) {
+  return u.input_tokens + (u.cache_read_input_tokens ?? 0) + (u.cache_creation_input_tokens ?? 0);
+}
+function parseTimestampMs(value) {
+  const ms = new Date(value).getTime();
+  return Number.isFinite(ms) ? ms : null;
+}
+function mergeIntervals(intervals) {
+  if (intervals.length === 0)
+    return [];
+  const sorted = [...intervals].sort((a, b) => a.startMs - b.startMs);
+  const first = sorted[0];
+  if (!first)
+    return [];
+  const merged = [{ startMs: first.startMs, endMs: first.endMs }];
+  for (let i = 1;i < sorted.length; i++) {
+    const current = sorted[i];
+    const last = merged[merged.length - 1];
+    if (!current || !last)
+      continue;
+    if (current.startMs <= last.endMs) {
+      last.endMs = Math.max(last.endMs, current.endMs);
+    } else {
+      merged.push({ startMs: current.startMs, endMs: current.endMs });
+    }
+  }
+  return merged;
+}
+function durationMs(intervals) {
+  return intervals.reduce((total, interval) => total + (interval.endMs - interval.startMs), 0);
+}
+function deriveSessionUsageMetrics(past) {
+  let latestUsage;
+  let latestUsageTimestampMs = null;
+  let lastUserTimestampMs = null;
+  let inputTokens = 0;
+  let outputTokens = 0;
+  const intervals = [];
+  for (const message of past) {
+    const timestampMs = parseTimestampMs(message.timestamp);
+    if (message.role === "user" && timestampMs !== null) {
+      lastUserTimestampMs = timestampMs;
+      continue;
+    }
+    if (message.role !== "assistant" || !message.usage)
+      continue;
+    if (timestampMs !== null && (latestUsageTimestampMs === null || timestampMs > latestUsageTimestampMs)) {
+      latestUsageTimestampMs = timestampMs;
+      latestUsage = message.usage;
+    } else if (latestUsage === undefined) {
+      latestUsage = message.usage;
+    }
+    inputTokens += message.usage.input_tokens;
+    outputTokens += message.usage.output_tokens;
+    if (timestampMs !== null && lastUserTimestampMs !== null && timestampMs > lastUserTimestampMs) {
+      intervals.push({ startMs: lastUserTimestampMs, endMs: timestampMs });
+    }
+  }
+  if (!latestUsage)
+    return;
+  const totalDurationMs = durationMs(mergeIntervals(intervals));
+  if (totalDurationMs <= 0)
+    return latestUsage;
+  return {
+    ...latestUsage,
+    total_speed_tokens_per_second: (inputTokens + outputTokens) / (totalDurationMs / 1000)
+  };
+}
+function withTotalSpeedForTurn(usage, startedAtIso, endedAtIso) {
+  const startMs = startedAtIso ? parseTimestampMs(startedAtIso) : null;
+  const endMs = parseTimestampMs(endedAtIso);
+  if (startMs === null || endMs === null || endMs <= startMs)
+    return usage;
+  return {
+    ...usage,
+    total_speed_tokens_per_second: (usage.input_tokens + usage.output_tokens) / ((endMs - startMs) / 1000)
+  };
+}
+
 // src/env.ts
 import { homedir as homedir7 } from "os";
 import { join as join5 } from "path";
@@ -3034,6 +3199,7 @@ class Orchestrator {
   worktrees;
   metadataSuggester;
   handles = new Map;
+  firstSpawnLatches = new Map;
   subscribers = new Map;
   pumps = new Map;
   pendingInputBroker = new InMemoryPendingInputBroker;
@@ -3266,8 +3432,16 @@ class Orchestrator {
       const renameTabId = this.resolveTab(task, tabId).id;
       this.maybeRenameTempBranch(task.id, renameTabId, prompt);
     }
-    const targetTab = this.resolveTab(task, tabId);
+    let targetTab = this.resolveTab(task, tabId);
     const key = tabKey(task.id, targetTab.id);
+    if (!targetTab.sessionId) {
+      const inflight = this.firstSpawnLatches.get(key);
+      if (inflight) {
+        await inflight.catch(() => {});
+        task = this.requireTask(id);
+        targetTab = this.resolveTab(task, tabId);
+      }
+    }
     if (this.handles.has(key) === false) {
       const running = this.countRunning();
       if (running >= CONCURRENCY_CAP) {
@@ -3288,18 +3462,28 @@ class Orchestrator {
         model: modelToUse
       });
     } else {
-      handle = await this.engine.spawn(task.worktreePath, promptToSend, {
-        permissionMode: task.permissionMode,
-        model: modelToUse
+      let releaseLatch = () => {};
+      const latch = new Promise((resolve2) => {
+        releaseLatch = resolve2;
       });
-      await this.updateTab(task.id, targetTab.id, { sessionId: handle.sessionId });
-      if (task.title === PLACEHOLDER_TASK_TITLE && prompt && prompt.trim().length > 0) {
-        const derived = deriveTitleFromPrompt(prompt);
-        if (derived)
-          await this.store.update(task.id, { title: derived });
-      }
-      if (prompt && prompt.trim().length > 0) {
-        this.maybeUpgradeTitle(task.id, prompt);
+      this.firstSpawnLatches.set(key, latch);
+      try {
+        handle = await this.engine.spawn(task.worktreePath, promptToSend, {
+          permissionMode: task.permissionMode,
+          model: modelToUse
+        });
+        await this.updateTab(task.id, targetTab.id, { sessionId: handle.sessionId });
+        if (task.title === PLACEHOLDER_TASK_TITLE && prompt && prompt.trim().length > 0) {
+          const derived = deriveTitleFromPrompt(prompt);
+          if (derived)
+            await this.store.update(task.id, { title: derived });
+        }
+        if (prompt && prompt.trim().length > 0) {
+          this.maybeUpgradeTitle(task.id, prompt);
+        }
+      } finally {
+        releaseLatch();
+        this.firstSpawnLatches.delete(key);
       }
     }
     this.handles.set(key, handle);
@@ -3366,6 +3550,12 @@ class Orchestrator {
     }
     this.dispatchEvent(task.id, targetTab.id, { type: "done" });
   }
+  async steerTask(id, prompt, tabId) {
+    const task = this.requireTask(id);
+    const targetTab = this.resolveTab(task, tabId);
+    await this.interruptTask(task.id, targetTab.id);
+    await this.runTask(task.id, prompt, targetTab.id);
+  }
   async pauseTask(id) {
     const task = this.requireTask(id);
     if (task.status !== "in_progress") {
@@ -3478,6 +3668,14 @@ class Orchestrator {
       return [];
     }
   }
+  async readHistoryWithMetrics(sessionId) {
+    const messages = await this.readHistory(sessionId);
+    const usageMetrics = deriveSessionUsageMetrics(messages);
+    return {
+      messages,
+      ...usageMetrics ? { usageMetrics } : {}
+    };
+  }
   async listSessions(id) {
     const task = this.requireTask(id);
     if (!task.worktreePath)
@@ -3796,7 +3994,7 @@ var init_core = __esm(() => {
 });
 
 // src/orchestrator/index/store.ts
-import { mkdir as mkdir2, open, readFile as readFile3, rename, unlink as unlink3 } from "fs/promises";
+import { mkdir as mkdir3, open, readFile as readFile3, rename, unlink as unlink3 } from "fs/promises";
 import { homedir as homedir8 } from "os";
 import { dirname as dirname4, join as join6 } from "path";
 
@@ -3870,7 +4068,7 @@ class TaskIndexStore {
     return next;
   }
   async doSave() {
-    await mkdir2(dirname4(this.path), { recursive: true });
+    await mkdir3(dirname4(this.path), { recursive: true });
     const payload = this.snapshot();
     const json = `${JSON.stringify(payload, null, 2)}
 `;
@@ -4421,7 +4619,7 @@ init_paths();
 // src/daemon/server.ts
 init_repos();
 init_paths();
-import { mkdir as mkdir3, readFile as readFile5, unlink as unlink4, writeFile as writeFile3 } from "fs/promises";
+import { mkdir as mkdir4, readFile as readFile5, unlink as unlink4, writeFile as writeFile4 } from "fs/promises";
 import { createServer as createServer2 } from "net";
 import { dirname as dirname5 } from "path";
 
@@ -4761,8 +4959,8 @@ async function startDaemonServer(orch, options = {}) {
   const startedAt = options.startedAt ?? new Date;
   const clients = new Set;
   let nextClientId = 1;
-  await mkdir3(dirname5(socketPath), { recursive: true });
-  await mkdir3(dirname5(pidPath), { recursive: true });
+  await mkdir4(dirname5(socketPath), { recursive: true });
+  await mkdir4(dirname5(pidPath), { recursive: true });
   await unlink4(socketPath).catch(() => {});
   const server = createServer2((socket) => {
     const client = {
@@ -4820,7 +5018,7 @@ async function startDaemonServer(orch, options = {}) {
       resolve2();
     });
   });
-  await writeFile3(pidPath, `${process.pid}
+  await writeFile4(pidPath, `${process.pid}
 `, "utf8");
   async function stopSoon() {
     await options.onStop?.();
@@ -4990,6 +5188,10 @@ async function startDaemonServer(orch, options = {}) {
         await orch.interruptTask(requireString2(payload, "taskId"), optionalString2(payload, "tabId"));
         return {};
       }
+      case "chat.steer": {
+        await orch.steerTask(requireString2(payload, "taskId"), requireString2(payload, "text"), optionalString2(payload, "tabId"));
+        return {};
+      }
       case "chat.input.pending": {
         return { pending: orch.peekPendingInput(requireString2(payload, "taskId")) };
       }
@@ -5009,6 +5211,7 @@ async function startDaemonServer(orch, options = {}) {
         const result = await readTaskHistory(orch, taskId, sessionId, limit, before);
         return {
           messages: serializeMessages(result.messages),
+          ...result.usageMetrics ? { usageMetrics: result.usageMetrics } : {},
           nextBefore: result.nextBefore,
           hasMore: result.hasMore
         };
@@ -5156,6 +5359,7 @@ async function readTaskHistory(orch, taskId, requestedSessionId, limit, before)
   if (!sessionId)
     return { messages: [], nextBefore: null, hasMore: false };
   const messages = await orch.readHistory(sessionId);
+  const usageMetrics = deriveSessionUsageMetrics(messages);
   const beforeIdx = before ? messages.findIndex((m) => `${m.timestamp}:${m.sessionId}` === before) : -1;
   const end = beforeIdx >= 0 ? beforeIdx : messages.length;
   const start = Math.max(0, end - limit);
@@ -5163,7 +5367,7 @@ async function readTaskHistory(orch, taskId, requestedSessionId, limit, before)
   const hasMore = start > 0;
   const first = page[0];
   const nextBefore = hasMore && first ? `${first.timestamp}:${first.sessionId}` : null;
-  return { messages: page, nextBefore, hasMore };
+  return { messages: page, ...usageMetrics ? { usageMetrics } : {}, nextBefore, hasMore };
 }
 function writeFrame(client, frame) {
   client.socket.write(frameToLine(frame));