@surething/cockpit 1.0.185 → 1.0.186

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":12533956,"timestamp":135032293,"id":17,"parentId":1,"tags":{},"startTime":1775896219529,"traceId":"1eec4646c71498d4"},{"name":"run-typescript","duration":14930423,"timestamp":147571040,"id":1489,"parentId":1,"tags":{},"startTime":1775896232068,"traceId":"1eec4646c71498d4"},{"name":"static-check","duration":828364,"timestamp":162517280,"id":1492,"parentId":1,"tags":{},"startTime":1775896247014,"traceId":"1eec4646c71498d4"},{"name":"static-generation","duration":6118609,"timestamp":163822962,"id":1710,"parentId":1,"tags":{},"startTime":1775896248320,"traceId":"1eec4646c71498d4"},{"name":"collect-build-traces","duration":19401221,"timestamp":163346437,"id":1707,"parentId":1,"tags":{},"startTime":1775896247844,"traceId":"1eec4646c71498d4"},{"name":"telemetry-flush","duration":99,"timestamp":182750988,"id":1719,"parentId":1,"tags":{},"startTime":1775896267248,"traceId":"1eec4646c71498d4"},{"name":"next-build","duration":47889154,"timestamp":134861946,"id":1,"tags":{"buildMode":"default","version":"16.1.6","bundler":"webpack","has-custom-webpack-config":"false","use-build-worker":"true"},"startTime":1775896219359,"traceId":"1eec4646c71498d4"}]

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-VV5VMA4B.mjs

@@ -0,0 +1,410 @@
+// 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");
+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 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 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 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,
+  getTerminalHistoryPath,
+  getTerminalOutputPath,
+  ensureParentDir,
+  readJsonFile,
+  writeJsonFile,
+  updateGlobalState,
+  getSessionTitle,
+  getLastUserMessage
+};

package/dist/scheduledTasks.mjs

@@ -4,7 +4,7 @@ import {
   readJsonFile,
   updateGlobalState,
   writeJsonFile
-} from "./chunk-SWMKAZSL.mjs";
+} from "./chunk-VV5VMA4B.mjs";
 
 // src/lib/scheduledTasks.ts
 import { query } from "@anthropic-ai/claude-agent-sdk";

package/dist/wsServer.mjs

@@ -7,7 +7,7 @@ import {
   getTerminalHistoryPath,
   getTerminalOutputPath,
   readJsonFile
-} from "./chunk-SWMKAZSL.mjs";
+} from "./chunk-VV5VMA4B.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) {

package/kernels/jupyter_bridge.py

@@ -0,0 +1,162 @@
+#!/usr/bin/env python3
+"""
+Jupyter kernel bridge for Cockpit.
+Manages a single IPython kernel, communicates via JSON-over-stdio.
+
+stdin (commands):
+  {"cmd": "execute", "msg_id": "xxx", "code": "print('hello')"}
+  {"cmd": "interrupt"}
+  {"cmd": "complete", "msg_id": "xxx", "code": "pri", "cursor_pos": 3}
+  {"cmd": "shutdown"}
+
+stdout (kernel messages):
+  {"type": "ready", "kernel_id": "..."}
+  {"msg_id": "xxx", "msg_type": "stream", "content": {"name": "stdout", "text": "hello\n"}}
+  {"msg_id": "xxx", "msg_type": "execute_result", "content": {"execution_count": 1, "data": {...}, "metadata": {}}}
+  {"msg_id": "xxx", "msg_type": "display_data", "content": {"data": {...}, "metadata": {}}}
+  {"msg_id": "xxx", "msg_type": "error", "content": {"ename": "...", "evalue": "...", "traceback": [...]}}
+  {"msg_id": "xxx", "msg_type": "status", "content": {"execution_state": "idle"}}
+  {"type": "error", "message": "..."}
+"""
+
+import sys
+import json
+import threading
+import os
+
+def emit(obj):
+    """Write a JSON line to stdout."""
+    sys.stdout.write(json.dumps(obj, ensure_ascii=False) + '\n')
+    sys.stdout.flush()
+
+def main():
+    # Check dependencies
+    try:
+        import jupyter_client
+    except ImportError:
+        emit({"type": "error", "message": "jupyter_client not found. Run: pip install ipykernel"})
+        sys.exit(1)
+
+    cwd = os.environ.get('JUPYTER_CWD', os.getcwd())
+
+    # Start kernel
+    try:
+        km = jupyter_client.KernelManager(kernel_name='python3')
+        km.start_kernel(cwd=cwd)
+    except Exception as e:
+        emit({"type": "error", "message": f"Failed to start kernel: {e}"})
+        sys.exit(1)
+
+    kc = km.client()
+    kc.start_channels()
+
+    # Wait for kernel to be ready
+    try:
+        kc.wait_for_ready(timeout=30)
+    except Exception as e:
+        emit({"type": "error", "message": f"Kernel not ready: {e}"})
+        km.shutdown_kernel(now=True)
+        sys.exit(1)
+
+    emit({"type": "ready", "kernel_id": str(km.kernel_id)})
+
+    # Track which msg_ids are active (execute requests in progress)
+    active_executions = {}  # parent_msg_id -> original msg_id from client
+    shutdown_flag = threading.Event()
+
+    def iopub_listener():
+        """Background thread: read IOPub messages and emit them."""
+        while not shutdown_flag.is_set():
+            try:
+                msg = kc.get_iopub_msg(timeout=1)
+            except Exception:
+                continue
+
+            msg_type = msg.get('msg_type', '')
+            parent_id = msg.get('parent_header', {}).get('msg_id', '')
+            content = msg.get('content', {})
+
+            # Map parent_msg_id back to client's msg_id
+            client_msg_id = active_executions.get(parent_id, parent_id)
+
+            if msg_type in ('stream', 'execute_result', 'display_data', 'update_display_data', 'error'):
+                out = {
+                    "msg_id": client_msg_id,
+                    "msg_type": msg_type,
+                    "content": content,
+                }
+                emit(out)
+            elif msg_type == 'status':
+                state = content.get('execution_state', '')
+                emit({
+                    "msg_id": client_msg_id,
+                    "msg_type": "status",
+                    "content": {"execution_state": state},
+                })
+                if state == 'idle' and parent_id in active_executions:
+                    del active_executions[parent_id]
+
+    listener = threading.Thread(target=iopub_listener, daemon=True)
+    listener.start()
+
+    # Main loop: read commands from stdin
+    try:
+        for line in sys.stdin:
+            line = line.strip()
+            if not line:
+                continue
+
+            try:
+                cmd = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+
+            action = cmd.get('cmd', '')
+
+            if action == 'execute':
+                code = cmd.get('code', '')
+                client_msg_id = cmd.get('msg_id', '')
+                reply = kc.execute(code, allow_stdin=False)
+                # reply is the kernel's msg_id — map it to client's msg_id
+                active_executions[reply] = client_msg_id
+
+            elif action == 'interrupt':
+                try:
+                    km.interrupt_kernel()
+                except Exception as e:
+                    emit({"type": "error", "message": f"Interrupt failed: {e}"})
+
+            elif action == 'complete':
+                code = cmd.get('code', '')
+                cursor_pos = cmd.get('cursor_pos', len(code))
+                client_msg_id = cmd.get('msg_id', '')
+                reply_id = kc.complete(code, cursor_pos)
+                try:
+                    reply = kc.get_shell_msg(timeout=5)
+                    emit({
+                        "msg_id": client_msg_id,
+                        "msg_type": "complete_reply",
+                        "content": reply.get('content', {}),
+                    })
+                except Exception:
+                    emit({
+                        "msg_id": client_msg_id,
+                        "msg_type": "complete_reply",
+                        "content": {"matches": [], "status": "error"},
+                    })
+
+            elif action == 'shutdown':
+                break
+
+    except (EOFError, KeyboardInterrupt):
+        pass
+    finally:
+        shutdown_flag.set()
+        try:
+            kc.stop_channels()
+            km.shutdown_kernel(now=True)
+        except Exception:
+            pass
+
+if __name__ == '__main__':
+    main()