@surething/cockpit 1.0.185 → 1.0.187

package/.next-prod/trace-build

@@ -1 +1 @@
-[{"name":"run-webpack","duration":12233940,"timestamp":135977825,"id":17,"parentId":1,"tags":{},"startTime":1774985301518,"traceId":"128f34f423fa7eff"},{"name":"run-typescript","duration":14047698,"timestamp":148215929,"id":1485,"parentId":1,"tags":{},"startTime":1774985313756,"traceId":"128f34f423fa7eff"},{"name":"static-check","duration":821462,"timestamp":162279208,"id":1488,"parentId":1,"tags":{},"startTime":1774985327819,"traceId":"128f34f423fa7eff"},{"name":"static-generation","duration":5938483,"timestamp":163304302,"id":1706,"parentId":1,"tags":{},"startTime":1774985328844,"traceId":"128f34f423fa7eff"},{"name":"collect-build-traces","duration":18347018,"timestamp":163101469,"id":1703,"parentId":1,"tags":{},"startTime":1774985328642,"traceId":"128f34f423fa7eff"},{"name":"telemetry-flush","duration":57,"timestamp":181451632,"id":1715,"parentId":1,"tags":{},"startTime":1774985346992,"traceId":"128f34f423fa7eff"},{"name":"next-build","duration":45648200,"timestamp":135803500,"id":1,"tags":{"buildMode":"default","version":"16.1.6","bundler":"webpack","has-custom-webpack-config":"false","use-build-worker":"true"},"startTime":1774985301344,"traceId":"128f34f423fa7eff"}]
+[{"name":"run-webpack","duration":12420537,"timestamp":501859389,"id":17,"parentId":1,"tags":{},"startTime":1776839973569,"traceId":"4bfc0cde73c5d18d"},{"name":"run-typescript","duration":14652216,"timestamp":514284927,"id":1489,"parentId":1,"tags":{},"startTime":1776839985994,"traceId":"4bfc0cde73c5d18d"},{"name":"static-check","duration":819642,"timestamp":528952587,"id":1492,"parentId":1,"tags":{},"startTime":1776840000662,"traceId":"4bfc0cde73c5d18d"},{"name":"static-generation","duration":6351022,"timestamp":529963320,"id":1710,"parentId":1,"tags":{},"startTime":1776840001672,"traceId":"4bfc0cde73c5d18d"},{"name":"collect-build-traces","duration":18951972,"timestamp":529772937,"id":1707,"parentId":1,"tags":{},"startTime":1776840001482,"traceId":"4bfc0cde73c5d18d"},{"name":"telemetry-flush","duration":64,"timestamp":548728240,"id":1719,"parentId":1,"tags":{},"startTime":1776840020437,"traceId":"4bfc0cde73c5d18d"},{"name":"next-build","duration":47033463,"timestamp":501694857,"id":1,"tags":{"buildMode":"default","version":"16.1.6","bundler":"webpack","has-custom-webpack-config":"false","use-build-worker":"true"},"startTime":1776839973404,"traceId":"4bfc0cde73c5d18d"}]

package/bin/postinstall.mjs

@@ -47,4 +47,24 @@ if (isNpmInstall) {
       }
     }
   } catch {}
+
+  // jupyter_bridge.py → ~/.cockpit/kernels/jupyter_bridge.py
+  try {
+    const kernelSrc = join(projectRoot, 'kernels', 'jupyter_bridge.py');
+    const cockpitDir = join(homedir(), '.cockpit');
+    const kernelDestDir = join(cockpitDir, 'kernels');
+    accessSync(kernelSrc);
+    mkdirSync(kernelDestDir, { recursive: true });
+    cpSync(kernelSrc, join(kernelDestDir, 'jupyter_bridge.py'), { force: true });
+
+    if (process.platform !== 'win32') {
+      const realUser = process.env.SUDO_USER;
+      if (realUser) {
+        try { execSync(`chown -R "${realUser}" "${cockpitDir}"`); } catch {}
+      }
+      if (process.platform === 'darwin') {
+        try { execSync(`xattr -cr "${kernelDestDir}"`); } catch {}
+      }
+    }
+  } catch {}
 }

package/dist/{JupyterKernelManager-475VNVA5.mjs → JupyterKernelManager-VBKKSRVJ.mjs}

@@ -1,6 +1,8 @@
-// src/lib/kernels/JupyterKernelManager.ts
+// src/lib/bubbles/jupyter/JupyterKernelManager.ts
 import { spawn } from "child_process";
 import { join } from "path";
+import { homedir } from "os";
+import { existsSync } from "fs";
 import { createInterface } from "readline";
 var GLOBAL_KEY = /* @__PURE__ */ Symbol.for("jupyter_kernel_manager");
 var IDLE_TIMEOUT = 10 * 60 * 1e3;
@@ -19,6 +21,25 @@ var JupyterKernelManager = class {
   findPython() {
     return "python3";
   }
+  /**
+   * Resolve jupyter_bridge.py path.
+   * Production: ~/.cockpit/kernels/jupyter_bridge.py (copied by postinstall)
+   * Dev: COCKPIT_ROOT/kernels/jupyter_bridge.py or legacy src path
+   */
+  resolveBridgePath() {
+    const installedPath = join(homedir(), ".cockpit", "kernels", "jupyter_bridge.py");
+    if (existsSync(installedPath)) {
+      return installedPath;
+    }
+    const root = process.env.COCKPIT_ROOT;
+    if (root) {
+      const devPath = join(root, "kernels", "jupyter_bridge.py");
+      if (existsSync(devPath)) {
+        return devPath;
+      }
+    }
+    return join(__dirname, "jupyter_bridge.py");
+  }
   /**
    * Get or create a kernel for a bubble
    */
@@ -30,7 +51,7 @@ var JupyterKernelManager = class {
       return existing;
     }
     const python = this.findPython();
-    const bridgePath = join(__dirname, "jupyter_bridge.py");
+    const bridgePath = this.resolveBridgePath();
     const bridge = spawn(python, ["-u", bridgePath], {
       cwd,
       env: {

package/dist/chunk-KLV3PBIZ.mjs

@@ -0,0 +1,427 @@
+// src/lib/paths.ts
+import { homedir } from "os";
+import { join } from "path";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { existsSync, writeFileSync, mkdirSync, readdirSync } from "fs";
+import { execSync } from "child_process";
+var HOME_DIR = homedir();
+var COCKPIT_DIR = join(HOME_DIR, ".cockpit");
+var COCKPIT_PROJECTS_DIR = join(COCKPIT_DIR, "projects");
+var GLOBAL_STATE_FILE = join(COCKPIT_DIR, "state.json");
+var PINNED_SESSIONS_FILE = join(COCKPIT_DIR, "pinned-sessions.json");
+var NOTE_FILE = join(COCKPIT_DIR, "note.md");
+var SCHEDULED_TASKS_FILE = join(COCKPIT_DIR, "scheduled-tasks.json");
+var SETTINGS_FILE = join(COCKPIT_DIR, "settings.json");
+var REVIEW_DIR = join(COCKPIT_DIR, "review");
+var REVIEW_SIGNAL_FILE = join(REVIEW_DIR, "_signal");
+var CLAUDE_DIR = join(HOME_DIR, ".claude");
+var CLAUDE_PROJECTS_DIR = join(CLAUDE_DIR, "projects");
+var CLAUDE2_DIR = join(HOME_DIR, ".claude2");
+var CLAUDE2_PROJECTS_DIR = join(CLAUDE2_DIR, "projects");
+function encodePath(path) {
+  return path.replace(/[/.]/g, "-");
+}
+function getCockpitProjectDir(cwd) {
+  return join(COCKPIT_PROJECTS_DIR, encodePath(cwd));
+}
+function getTerminalHistoryPath(cwd, tabId) {
+  return join(getCockpitProjectDir(cwd), `terminal-history-${tabId}.jsonl`);
+}
+function getTerminalOutputPath(cwd, commandId) {
+  return join(getCockpitProjectDir(cwd), `terminal-output-${commandId}.txt`);
+}
+function getClaudeProjectDir(cwd) {
+  return join(CLAUDE_PROJECTS_DIR, encodePath(cwd));
+}
+function getClaudeSessionPath(cwd, sessionId) {
+  return join(getClaudeProjectDir(cwd), `${sessionId}.jsonl`);
+}
+function getClaude2ProjectDir(cwd) {
+  return join(CLAUDE2_PROJECTS_DIR, encodePath(cwd));
+}
+function getClaude2SessionPath(cwd, sessionId) {
+  return join(getClaude2ProjectDir(cwd), `${sessionId}.jsonl`);
+}
+function getOllamaSessionsDir(cwd) {
+  return join(COCKPIT_DIR, "ollama-sessions", encodePath(cwd));
+}
+function getOllamaSessionPath(cwd, sessionId) {
+  return join(getOllamaSessionsDir(cwd), `${sessionId}.jsonl`);
+}
+function findCodexSessionPath(threadId) {
+  const codexSessionsDir = join(HOME_DIR, ".codex", "sessions");
+  if (!existsSync(codexSessionsDir)) return null;
+  const suffix = `-${threadId}.jsonl`;
+  try {
+    const result = execSync(
+      `find ${JSON.stringify(codexSessionsDir)} -name "*${threadId}.jsonl" -type f 2>/dev/null`,
+      { encoding: "utf8", timeout: 3e3 }
+    ).trim();
+    if (result) {
+      return result.split("\n")[0];
+    }
+  } catch {
+  }
+  return null;
+}
+function findKimiSessionPath(sessionId) {
+  const sessionsDir = join(HOME_DIR, ".kimi", "sessions");
+  if (!existsSync(sessionsDir)) return null;
+  try {
+    for (const hash of readdirSync(sessionsDir)) {
+      const candidate = join(sessionsDir, hash, sessionId, "context.jsonl");
+      if (existsSync(candidate)) return candidate;
+    }
+  } catch {
+  }
+  return null;
+}
+async function ensureDir(dirPath) {
+  if (!existsSync(dirPath)) {
+    await mkdir(dirPath, { recursive: true });
+  }
+}
+async function ensureParentDir(filePath) {
+  const dir = join(filePath, "..");
+  await ensureDir(dir);
+}
+async function readJsonFile(filePath, defaultValue) {
+  try {
+    const content = await readFile(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return defaultValue;
+  }
+}
+async function writeJsonFile(filePath, data) {
+  await ensureParentDir(filePath);
+  await writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
+}
+var fileLocks = /* @__PURE__ */ new Map();
+function withFileLock(filePath, fn) {
+  const prev = fileLocks.get(filePath) ?? Promise.resolve();
+  const run = prev.then(fn);
+  const chain = run.then(() => {
+  }, () => {
+  });
+  fileLocks.set(filePath, chain);
+  chain.then(() => {
+    if (fileLocks.get(filePath) === chain) {
+      fileLocks.delete(filePath);
+    }
+  });
+  return run;
+}
+
+// src/lib/global-state.ts
+import { createReadStream, existsSync as existsSync2 } from "fs";
+import { createInterface } from "readline";
+var MAX_SESSIONS = 15;
+var MAX_TEXT_LEN = 50;
+function truncate(s) {
+  if (!s) return s;
+  const chars = [...s];
+  return chars.length <= MAX_TEXT_LEN ? s : chars.slice(0, MAX_TEXT_LEN).join("") + "\u2026";
+}
+async function updateGlobalState(cwd, sessionId, status, title, lastUserMessage) {
+  if (!existsSync2(cwd)) {
+    return;
+  }
+  return withFileLock(GLOBAL_STATE_FILE, async () => {
+    const state = await readJsonFile(GLOBAL_STATE_FILE, { sessions: [] });
+    for (const s of state.sessions) {
+      if (!s.status) {
+        const legacy = s;
+        s.status = legacy.isLoading ? "loading" : "normal";
+        delete legacy.isLoading;
+      }
+    }
+    const existingIndex = state.sessions.findIndex(
+      (s) => s.cwd === cwd && s.sessionId === sessionId
+    );
+    const existed = existingIndex >= 0;
+    const existing = existed ? state.sessions[existingIndex] : void 0;
+    const newSession = {
+      cwd,
+      sessionId,
+      lastActive: Date.now(),
+      status,
+      title: truncate(title || existing?.title),
+      lastUserMessage: truncate(lastUserMessage || existing?.lastUserMessage)
+    };
+    if (existingIndex >= 0) {
+      state.sessions[existingIndex] = newSession;
+    } else {
+      state.sessions.push(newSession);
+    }
+    state.sessions.sort((a, b) => b.lastActive - a.lastActive);
+    state.sessions = state.sessions.slice(0, MAX_SESSIONS);
+    await writeJsonFile(GLOBAL_STATE_FILE, state);
+  });
+}
+async function getSessionTitle(cwd, sessionId) {
+  const claudePath = getClaudeSessionPath(cwd, sessionId);
+  if (existsSync2(claudePath)) {
+    return getClaudeStyleTitle(claudePath);
+  }
+  const claude2Path = getClaude2SessionPath(cwd, sessionId);
+  if (existsSync2(claude2Path)) {
+    return getClaudeStyleTitle(claude2Path);
+  }
+  const ollamaPath = getOllamaSessionPath(cwd, sessionId);
+  if (existsSync2(ollamaPath)) {
+    return getClaudeStyleTitle(ollamaPath);
+  }
+  const codexPath = findCodexSessionPath(sessionId);
+  if (codexPath && existsSync2(codexPath)) {
+    const title = await getCodexTitle(codexPath);
+    return title || "Untitled Session";
+  }
+  const kimiPath = findKimiSessionPath(sessionId);
+  if (kimiPath && existsSync2(kimiPath)) {
+    const title = await getKimiTitle(kimiPath);
+    return title || "Untitled Session";
+  }
+  return "Untitled Session";
+}
+async function getLastUserMessage(cwd, sessionId) {
+  const claudePath = getClaudeSessionPath(cwd, sessionId);
+  if (existsSync2(claudePath)) {
+    return await getClaudeStyleLastUserMessage(claudePath);
+  }
+  const claude2Path = getClaude2SessionPath(cwd, sessionId);
+  if (existsSync2(claude2Path)) {
+    return await getClaudeStyleLastUserMessage(claude2Path);
+  }
+  const ollamaPath = getOllamaSessionPath(cwd, sessionId);
+  if (existsSync2(ollamaPath)) {
+    return await getClaudeStyleLastUserMessage(ollamaPath);
+  }
+  const codexPath = findCodexSessionPath(sessionId);
+  if (codexPath && existsSync2(codexPath)) {
+    return await getCodexLastUserMessage(codexPath);
+  }
+  const kimiPath = findKimiSessionPath(sessionId);
+  if (kimiPath && existsSync2(kimiPath)) {
+    return await getKimiLastUserMessage(kimiPath);
+  }
+  return void 0;
+}
+function filterCommandTags(text) {
+  let filtered = text.replace(/<command-[^>]*>[\s\S]*?<\/command-[^>]*>/g, "");
+  filtered = filtered.replace(/<local-command-[^>]*>[\s\S]*?<\/local-command-[^>]*>/g, "");
+  filtered = filtered.trim();
+  return filtered;
+}
+function isValidUserMessage(text) {
+  if (text.startsWith("This session is being continued")) return false;
+  if (text.startsWith("Caveat: The messages below")) return false;
+  if (!text.trim()) return false;
+  return true;
+}
+async function getClaudeStyleTitle(filePath) {
+  try {
+    const fileStream = createReadStream(filePath);
+    const rl = createInterface({ input: fileStream, crlfDelay: Infinity });
+    let summary = "";
+    const userMessages = [];
+    for await (const line of rl) {
+      if (!line.trim()) continue;
+      try {
+        const entry = JSON.parse(line);
+        if (entry.type === "summary" && entry.summary) {
+          summary = entry.summary;
+        }
+        if (entry.type === "user") {
+          const message = entry.message;
+          if (!message?.content) continue;
+          if (typeof message.content === "string") {
+            userMessages.push(message.content);
+          } else if (Array.isArray(message.content)) {
+            for (const block of message.content) {
+              if (block.type === "text" && block.text) userMessages.push(block.text);
+            }
+          }
+        }
+      } catch {
+      }
+    }
+    return generateTitle(summary, userMessages);
+  } catch {
+    return "Untitled Session";
+  }
+}
+async function getClaudeStyleLastUserMessage(filePath) {
+  try {
+    const fileStream = createReadStream(filePath);
+    const rl = createInterface({ input: fileStream, crlfDelay: Infinity });
+    let lastUserMessage;
+    for await (const line of rl) {
+      if (!line.trim()) continue;
+      try {
+        const entry = JSON.parse(line);
+        if (entry.type !== "user") continue;
+        const message = entry.message;
+        if (!message?.content) continue;
+        let text = "";
+        if (typeof message.content === "string") {
+          text = message.content;
+        } else if (Array.isArray(message.content)) {
+          for (const block of message.content) {
+            if (block.type === "text" && block.text) {
+              text = block.text;
+              break;
+            }
+          }
+        }
+        if (!text) continue;
+        const filtered = filterCommandTags(text);
+        if (filtered && isValidUserMessage(filtered)) {
+          lastUserMessage = filtered;
+        }
+      } catch {
+      }
+    }
+    return lastUserMessage;
+  } catch {
+    return void 0;
+  }
+}
+async function getCodexLastUserMessage(filePath) {
+  try {
+    const fileStream = createReadStream(filePath);
+    const rl = createInterface({ input: fileStream, crlfDelay: Infinity });
+    let last;
+    for await (const line of rl) {
+      if (!line.trim()) continue;
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (entry.type !== "response_item") continue;
+      const payload = entry.payload;
+      if (!payload || payload.type !== "message" || payload.role !== "user") continue;
+      const text = payload.content?.filter((c) => c.type === "input_text" && c.text).map((c) => c.text).join("") || "";
+      if (!text || text.startsWith("<") || text.startsWith("#")) continue;
+      const filtered = filterCommandTags(text);
+      if (filtered && isValidUserMessage(filtered)) {
+        last = filtered;
+      }
+    }
+    return last;
+  } catch {
+    return void 0;
+  }
+}
+async function getCodexTitle(filePath) {
+  try {
+    const fileStream = createReadStream(filePath);
+    const rl = createInterface({ input: fileStream, crlfDelay: Infinity });
+    for await (const line of rl) {
+      if (!line.trim()) continue;
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (entry.type !== "response_item") continue;
+      const payload = entry.payload;
+      if (!payload || payload.type !== "message" || payload.role !== "user") continue;
+      const text = payload.content?.filter((c) => c.type === "input_text" && c.text).map((c) => c.text).join("") || "";
+      if (!text || text.startsWith("<") || text.startsWith("#")) continue;
+      return text.slice(0, 80);
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function getKimiLastUserMessage(filePath) {
+  try {
+    const fileStream = createReadStream(filePath);
+    const rl = createInterface({ input: fileStream, crlfDelay: Infinity });
+    let last;
+    for await (const line of rl) {
+      if (!line.trim()) continue;
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (entry.role !== "user") continue;
+      const text = typeof entry.content === "string" ? entry.content : Array.isArray(entry.content) ? entry.content.filter((c) => (c.type === "input_text" || c.type === "text") && c.text).map((c) => c.text).join("") : "";
+      if (!text || text.startsWith("<system") || text.startsWith("<environment") || text.startsWith("# AGENTS.md") || text.startsWith("<permissions")) {
+        continue;
+      }
+      const filtered = filterCommandTags(text);
+      if (filtered && isValidUserMessage(filtered)) {
+        last = filtered;
+      }
+    }
+    return last;
+  } catch {
+    return void 0;
+  }
+}
+async function getKimiTitle(filePath) {
+  try {
+    const fileStream = createReadStream(filePath);
+    const rl = createInterface({ input: fileStream, crlfDelay: Infinity });
+    for await (const line of rl) {
+      if (!line.trim()) continue;
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (entry.role !== "user") continue;
+      const text = typeof entry.content === "string" ? entry.content : Array.isArray(entry.content) ? entry.content.filter((c) => (c.type === "input_text" || c.type === "text") && c.text).map((c) => c.text).join("") : "";
+      if (!text || text.startsWith("<system") || text.startsWith("<environment") || text.startsWith("# AGENTS.md") || text.startsWith("<permissions")) {
+        continue;
+      }
+      return text.slice(0, 80);
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function generateTitle(summary, userMessages) {
+  if (summary) return summary;
+  let commandName = "";
+  for (const msg of userMessages) {
+    const filtered = filterCommandTags(msg);
+    if (!filtered) continue;
+    if (filtered.startsWith("/") && !commandName) {
+      commandName = filtered;
+      continue;
+    }
+    if (commandName) {
+      return `${commandName} ${filtered}`;
+    }
+    return filtered;
+  }
+  if (commandName) return commandName;
+  return "Untitled Session";
+}
+
+export {
+  GLOBAL_STATE_FILE,
+  SCHEDULED_TASKS_FILE,
+  REVIEW_DIR,
+  REVIEW_SIGNAL_FILE,
+  CLAUDE2_DIR,
+  getTerminalHistoryPath,
+  getTerminalOutputPath,
+  ensureParentDir,
+  readJsonFile,
+  writeJsonFile,
+  updateGlobalState,
+  getSessionTitle,
+  getLastUserMessage
+};

package/dist/scheduledTasks.mjs

@@ -1,10 +1,11 @@
 import {
+  CLAUDE2_DIR,
   SCHEDULED_TASKS_FILE,
   getSessionTitle,
   readJsonFile,
   updateGlobalState,
   writeJsonFile
-} from "./chunk-SWMKAZSL.mjs";
+} from "./chunk-KLV3PBIZ.mjs";
 
 // src/lib/scheduledTasks.ts
 import { query } from "@anthropic-ai/claude-agent-sdk";
@@ -72,7 +73,11 @@ async function sendChatMessage(task) {
         "mcp__*"
       ],
       permissionMode: "bypassPermissions",
-      allowDangerouslySkipPermissions: true
+      allowDangerouslySkipPermissions: true,
+      // For claude2 engine, override config directory to ~/.claude2
+      ...task.engine === "claude2" && {
+        env: { ...process.env, CLAUDE_CONFIG_DIR: CLAUDE2_DIR }
+      }
     };
     await updateGlobalState(task.cwd, task.sessionId, "loading", void 0, task.message).catch(() => {
     });

package/dist/wsServer.mjs

@@ -7,7 +7,7 @@ import {
   getTerminalHistoryPath,
   getTerminalOutputPath,
   readJsonFile
-} from "./chunk-SWMKAZSL.mjs";
+} from "./chunk-KLV3PBIZ.mjs";
 
 // src/lib/wsServer.ts
 import { WebSocketServer, WebSocket as WebSocket2 } from "ws";
@@ -426,7 +426,7 @@ function registerCommand(cmd) {
   if (cmd.ptyProcess) {
     const pty = cmd.ptyProcess;
     pty.onData((data) => {
-      appendCommandOutput(cmd.commandId, data);
+      notifyOutputListeners(cmd.commandId, data);
     });
     const ptyPid = cmd.pid;
     pty.onExit(async ({ exitCode }) => {
@@ -1385,7 +1385,7 @@ async function handleJupyter(ws, bubbleId, cwd) {
       ws.send(JSON.stringify({ type: "ping" }));
     }
   }, HEARTBEAT_INTERVAL);
-  const { kernelManager } = await import("./JupyterKernelManager-475VNVA5.mjs");
+  const { kernelManager } = await import("./JupyterKernelManager-VBKKSRVJ.mjs");
   try {
     const instance = await kernelManager.getOrCreate(bubbleId, cwd);
     if (instance.errorMessage) {