@surething/cockpit 1.0.205 → 1.0.207

package/dist/chunk-VCZEGP64.mjs

@@ -0,0 +1,984 @@
+import {
+  ensureParentDir,
+  getTerminalHistoryPath,
+  getTerminalOutputPath
+} from "./chunk-RSHKDWJM.mjs";
+
+// packages/feature/console/src/server/plugins/browser/BrowserBridge.ts
+import { WebSocket } from "ws";
+
+// packages/shared/utils/src/shortId.ts
+function crc32(str) {
+  let crc = 4294967295;
+  for (let i = 0; i < str.length; i++) {
+    crc ^= str.charCodeAt(i);
+    for (let j = 0; j < 8; j++) {
+      crc = crc >>> 1 ^ (crc & 1 ? 3988292384 : 0);
+    }
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+function toShortId(fullId) {
+  const hash = crc32(fullId);
+  let id = "";
+  let val = hash;
+  for (let i = 0; i < 4; i++) {
+    id += String.fromCharCode(97 + val % 26);
+    val = Math.floor(val / 26);
+  }
+  return id;
+}
+
+// packages/feature/console/src/server/plugins/browser/BrowserBridge.ts
+var g_browser = globalThis;
+var registry = g_browser.__cockpitBrowserRegistry ?? (g_browser.__cockpitBrowserRegistry = /* @__PURE__ */ new Map());
+var fullIdToShort = g_browser.__cockpitBrowserFullIdToShort ?? (g_browser.__cockpitBrowserFullIdToShort = /* @__PURE__ */ new Map());
+function registerBrowser(fullId, ws) {
+  const shortId = toShortId(fullId);
+  registry.set(shortId, { fullId, ws, lastSeen: Date.now() });
+  fullIdToShort.set(fullId, shortId);
+  return shortId;
+}
+function unregisterBrowser(fullId) {
+  const shortId = fullIdToShort.get(fullId);
+  if (shortId) {
+    registry.delete(shortId);
+    fullIdToShort.delete(fullId);
+  }
+}
+function getBrowserByShortId(shortId) {
+  return registry.get(shortId);
+}
+function updateBrowserWs(fullId, ws) {
+  const shortId = fullIdToShort.get(fullId);
+  if (shortId) {
+    const entry = registry.get(shortId);
+    if (entry) {
+      entry.ws = ws;
+      entry.lastSeen = Date.now();
+    }
+  }
+}
+function listBrowsers() {
+  const result = [];
+  for (const [shortId, entry] of registry) {
+    result.push({
+      shortId,
+      fullId: entry.fullId,
+      connected: entry.ws !== null && entry.ws.readyState === WebSocket.OPEN
+    });
+  }
+  return result;
+}
+var pendingRequests = g_browser.__cockpitBrowserPending ?? (g_browser.__cockpitBrowserPending = /* @__PURE__ */ new Map());
+function createPendingRequest(reqId, timeout) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      pendingRequests.delete(reqId);
+      reject(new Error(`Timeout after ${timeout}ms`));
+    }, timeout);
+    pendingRequests.set(reqId, { resolve, reject, timer });
+  });
+}
+function resolvePendingRequest(reqId, ok, data, error) {
+  const pending = pendingRequests.get(reqId);
+  if (!pending) return;
+  clearTimeout(pending.timer);
+  pendingRequests.delete(reqId);
+  if (ok) {
+    pending.resolve(data);
+  } else {
+    pending.reject(new Error(error || "Browser command failed"));
+  }
+}
+function sendCommandToBrowser(shortId, reqId, action, params) {
+  const entry = registry.get(shortId);
+  if (!entry || !entry.ws || entry.ws.readyState !== WebSocket.OPEN) {
+    return false;
+  }
+  entry.ws.send(JSON.stringify({
+    type: "browser:cmd",
+    reqId,
+    action,
+    params
+  }));
+  return true;
+}
+
+// packages/feature/console/src/server/plugins/database/PgPoolManager.ts
+import pg from "pg";
+var { Pool } = pg;
+var PgPoolManager = class {
+  constructor() {
+    this.pools = /* @__PURE__ */ new Map();
+  }
+  /** Get or create a pool for a given bubble id + connection string */
+  async getPool(id, connectionString) {
+    const managed = this.pools.get(id);
+    if (managed && managed.connectionString === connectionString) {
+      return managed.pool;
+    }
+    if (managed) {
+      await managed.pool.end().catch(() => {
+      });
+    }
+    const pool = new Pool({
+      connectionString,
+      max: 5,
+      idleTimeoutMillis: 6e4,
+      connectionTimeoutMillis: 1e4
+    });
+    this.pools.set(id, { pool, connectionString, createdAt: Date.now() });
+    return pool;
+  }
+  /** Disconnect and remove a pool */
+  async disconnect(id) {
+    const managed = this.pools.get(id);
+    if (managed) {
+      await managed.pool.end().catch(() => {
+      });
+      this.pools.delete(id);
+    }
+  }
+};
+var g = globalThis;
+var pgPoolManager = g.__pgPoolManager ?? (g.__pgPoolManager = new PgPoolManager());
+
+// packages/feature/console/src/server/plugins/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;
+var IDLE_CHECK_INTERVAL = 60 * 1e3;
+var JupyterKernelManager = class {
+  constructor() {
+    this.instances = /* @__PURE__ */ new Map();
+    this.idleTimer = null;
+    process.on("exit", () => {
+      this.shutdownAll();
+    });
+  }
+  /**
+   * Find python3 executable
+   */
+  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
+   */
+  async getOrCreate(bubbleId, cwd) {
+    const existing = this.instances.get(bubbleId);
+    if (existing) {
+      existing.lastUsedAt = Date.now();
+      await existing.readyPromise;
+      return existing;
+    }
+    const python = this.findPython();
+    const bridgePath = this.resolveBridgePath();
+    const bridge = spawn(python, ["-u", bridgePath], {
+      cwd,
+      env: {
+        ...process.env,
+        JUPYTER_CWD: cwd,
+        PYTHONUNBUFFERED: "1"
+      },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const readline = createInterface({ input: bridge.stdout });
+    let resolveReady;
+    let rejectReady;
+    const readyPromise = new Promise((resolve, reject) => {
+      resolveReady = resolve;
+      rejectReady = reject;
+    });
+    const instance = {
+      bubbleId,
+      cwd,
+      bridge,
+      readline,
+      ready: false,
+      readyPromise,
+      lastUsedAt: Date.now(),
+      outputListeners: /* @__PURE__ */ new Set()
+    };
+    this.instances.set(bubbleId, instance);
+    readline.on("line", (line) => {
+      let msg;
+      try {
+        msg = JSON.parse(line);
+      } catch {
+        return;
+      }
+      const type = msg.type;
+      if (type === "ready") {
+        instance.ready = true;
+        resolveReady();
+      } else if (type === "error") {
+        const errorMsg = msg.message;
+        instance.errorMessage = errorMsg;
+        console.error(`[jupyter-kernel] ${bubbleId}: ${errorMsg}`);
+        if (!instance.ready) {
+          rejectReady(new Error(errorMsg));
+        }
+        const output = {
+          msg_id: "",
+          msg_type: "kernel_error",
+          content: { message: errorMsg }
+        };
+        for (const listener of instance.outputListeners) {
+          listener(output);
+        }
+      } else if (msg.msg_id !== void 0) {
+        const output = {
+          msg_id: msg.msg_id,
+          msg_type: msg.msg_type,
+          content: msg.content
+        };
+        for (const listener of instance.outputListeners) {
+          listener(output);
+        }
+      }
+    });
+    bridge.stderr?.on("data", (data) => {
+      const text = data.toString().trim();
+      if (text) {
+        console.error(`[jupyter-kernel] ${bubbleId} stderr: ${text}`);
+      }
+    });
+    bridge.on("exit", (code) => {
+      console.log(`[jupyter-kernel] ${bubbleId} bridge exited with code ${code}`);
+      readline.close();
+      this.instances.delete(bubbleId);
+      if (!instance.ready) {
+        rejectReady(new Error(`Bridge exited with code ${code}`));
+      }
+      const output = {
+        msg_id: "",
+        msg_type: "kernel_died",
+        content: { exit_code: code }
+      };
+      for (const listener of instance.outputListeners) {
+        listener(output);
+      }
+    });
+    bridge.on("error", (err) => {
+      console.error(`[jupyter-kernel] ${bubbleId} spawn error:`, err.message);
+      instance.errorMessage = err.message.includes("ENOENT") ? "Python not found. Ensure python3 is installed and in PATH." : err.message;
+      if (!instance.ready) {
+        rejectReady(new Error(instance.errorMessage));
+      }
+    });
+    this.startIdleTimer();
+    try {
+      await readyPromise;
+    } catch {
+    }
+    return instance;
+  }
+  /**
+   * Execute code in a kernel
+   */
+  async execute(bubbleId, code, msgId, cwd) {
+    let instance = this.instances.get(bubbleId);
+    if (!instance) {
+      if (!cwd) throw new Error("Kernel not found and no cwd provided");
+      instance = await this.getOrCreate(bubbleId, cwd);
+    }
+    if (!instance.ready) {
+      throw new Error(instance.errorMessage || "Kernel not ready");
+    }
+    instance.lastUsedAt = Date.now();
+    const cmd = JSON.stringify({ cmd: "execute", msg_id: msgId, code });
+    instance.bridge.stdin.write(cmd + "\n");
+  }
+  /**
+   * Interrupt the kernel
+   */
+  async interrupt(bubbleId) {
+    const instance = this.instances.get(bubbleId);
+    if (!instance || !instance.ready) return;
+    const cmd = JSON.stringify({ cmd: "interrupt" });
+    instance.bridge.stdin.write(cmd + "\n");
+  }
+  /**
+   * Shutdown a kernel
+   */
+  async shutdown(bubbleId) {
+    const instance = this.instances.get(bubbleId);
+    if (!instance) return;
+    try {
+      if (instance.bridge.stdin?.writable) {
+        instance.bridge.stdin.write(JSON.stringify({ cmd: "shutdown" }) + "\n");
+      }
+    } catch {
+    }
+    setTimeout(() => {
+      try {
+        instance.bridge.kill("SIGKILL");
+      } catch {
+      }
+    }, 3e3);
+    instance.readline.close();
+    this.instances.delete(bubbleId);
+    if (this.instances.size === 0) {
+      this.stopIdleTimer();
+    }
+  }
+  /**
+   * Shutdown all kernels
+   */
+  shutdownAll() {
+    for (const [id] of this.instances) {
+      this.shutdown(id);
+    }
+    this.stopIdleTimer();
+  }
+  /**
+   * Subscribe to kernel output messages
+   */
+  addOutputListener(bubbleId, listener) {
+    const instance = this.instances.get(bubbleId);
+    if (!instance) return () => {
+    };
+    instance.outputListeners.add(listener);
+    return () => {
+      instance.outputListeners.delete(listener);
+    };
+  }
+  /**
+   * Check if a kernel exists for a bubble
+   */
+  has(bubbleId) {
+    return this.instances.has(bubbleId);
+  }
+  /**
+   * Get kernel error message if any
+   */
+  getError(bubbleId) {
+    return this.instances.get(bubbleId)?.errorMessage;
+  }
+  // ============================================
+  // Idle timeout
+  // ============================================
+  startIdleTimer() {
+    if (this.idleTimer) return;
+    this.idleTimer = setInterval(() => {
+      const now = Date.now();
+      for (const [id, instance] of this.instances) {
+        if (now - instance.lastUsedAt > IDLE_TIMEOUT) {
+          console.log(`[jupyter-kernel] idle timeout: ${id}`);
+          this.shutdown(id);
+        }
+      }
+      if (this.instances.size === 0) {
+        this.stopIdleTimer();
+      }
+    }, IDLE_CHECK_INTERVAL);
+    if (typeof this.idleTimer.unref === "function") {
+      this.idleTimer.unref();
+    }
+  }
+  stopIdleTimer() {
+    if (this.idleTimer) {
+      clearInterval(this.idleTimer);
+      this.idleTimer = null;
+    }
+  }
+};
+var g2 = globalThis;
+var kernelManager = g2[GLOBAL_KEY] ?? (g2[GLOBAL_KEY] = new JupyterKernelManager());
+
+// packages/feature/console/src/server/plugins/mysql/MySQLPoolManager.ts
+import mysql from "mysql2/promise";
+var MySQLPoolManager = class {
+  constructor() {
+    this.pools = /* @__PURE__ */ new Map();
+  }
+  /** Get or create a pool for a given bubble id + connection string */
+  async getPool(id, connectionString) {
+    const managed = this.pools.get(id);
+    if (managed && managed.connectionString === connectionString) {
+      return managed.pool;
+    }
+    if (managed) {
+      await managed.pool.end().catch(() => {
+      });
+    }
+    const pool = mysql.createPool({
+      uri: connectionString,
+      connectionLimit: 5,
+      idleTimeout: 6e4,
+      connectTimeout: 1e4
+    });
+    this.pools.set(id, { pool, connectionString, createdAt: Date.now() });
+    return pool;
+  }
+  /** Disconnect and remove a pool */
+  async disconnect(id) {
+    const managed = this.pools.get(id);
+    if (managed) {
+      await managed.pool.end().catch(() => {
+      });
+      this.pools.delete(id);
+    }
+  }
+};
+var g3 = globalThis;
+var mysqlPoolManager = g3.__mysqlPoolManager ?? (g3.__mysqlPoolManager = new MySQLPoolManager());
+
+// packages/feature/console/src/server/plugins/neo4j/Neo4jManager.ts
+import neo4j from "neo4j-driver";
+var Neo4jManager = class {
+  constructor() {
+    this.drivers = /* @__PURE__ */ new Map();
+  }
+  async getDriver(id, connectionString) {
+    const existing = this.drivers.get(id);
+    if (existing) {
+      if (existing.connectionString === connectionString) return existing.driver;
+      await this.disconnect(id);
+    }
+    const url = new URL(connectionString);
+    const scheme = url.protocol.replace(":", "");
+    const host = url.hostname;
+    const port = url.port || "7687";
+    const user = decodeURIComponent(url.username || "neo4j");
+    const password = decodeURIComponent(url.password || "");
+    const uri = `${scheme}://${host}:${port}`;
+    const driver = neo4j.driver(uri, neo4j.auth.basic(user, password));
+    await driver.verifyConnectivity();
+    this.drivers.set(id, { driver, connectionString, createdAt: Date.now() });
+    return driver;
+  }
+  async disconnect(id) {
+    const managed = this.drivers.get(id);
+    if (managed) {
+      await managed.driver.close().catch(() => {
+      });
+      this.drivers.delete(id);
+    }
+  }
+  async runCypher(id, connectionString, cypher, params) {
+    const driver = await this.getDriver(id, connectionString);
+    const session = driver.session();
+    try {
+      const start = Date.now();
+      const result = await session.run(cypher, params || {});
+      const duration = Date.now() - start;
+      const records = result.records.map((record) => {
+        const obj = {};
+        for (const key of record.keys) {
+          obj[key] = this.serializeValue(record.get(key));
+        }
+        return obj;
+      });
+      return {
+        records,
+        keys: result.records.length > 0 ? result.records[0].keys : [],
+        duration,
+        counters: result.summary.counters.updates()
+      };
+    } finally {
+      await session.close();
+    }
+  }
+  serializeValue(val) {
+    if (val === null || val === void 0) return null;
+    if (neo4j.isInt(val)) return val.toNumber();
+    if (val && typeof val === "object" && "labels" in val && "properties" in val) {
+      const node = val;
+      return {
+        _type: "node",
+        _id: this.serializeValue(node.identity),
+        _labels: node.labels,
+        ...Object.fromEntries(
+          Object.entries(node.properties).map(([k, v]) => [k, this.serializeValue(v)])
+        )
+      };
+    }
+    if (val && typeof val === "object" && "type" in val && "start" in val && "end" in val && "properties" in val) {
+      const rel = val;
+      return {
+        _type: "relationship",
+        _id: this.serializeValue(rel.identity),
+        _relType: rel.type,
+        _start: this.serializeValue(rel.start),
+        _end: this.serializeValue(rel.end),
+        ...Object.fromEntries(
+          Object.entries(rel.properties).map(([k, v]) => [k, this.serializeValue(v)])
+        )
+      };
+    }
+    if (val && typeof val === "object" && "segments" in val) {
+      const path = val;
+      return {
+        _type: "path",
+        segments: path.segments.map((s) => ({
+          start: this.serializeValue(s.start),
+          relationship: this.serializeValue(s.relationship),
+          end: this.serializeValue(s.end)
+        }))
+      };
+    }
+    if (Array.isArray(val)) return val.map((v) => this.serializeValue(v));
+    if (val && typeof val === "object" && val.constructor === Object) {
+      return Object.fromEntries(
+        Object.entries(val).map(([k, v]) => [k, this.serializeValue(v)])
+      );
+    }
+    return val;
+  }
+};
+var g4 = globalThis;
+var neo4jManager = g4.__neo4jManager ?? (g4.__neo4jManager = new Neo4jManager());
+
+// packages/feature/console/src/server/plugins/redis/RedisManager.ts
+import Redis from "ioredis";
+var RedisManager = class {
+  constructor() {
+    this.clients = /* @__PURE__ */ new Map();
+  }
+  /** Get or create a Redis client for a given bubble id + connection string */
+  async getClient(id, connectionString) {
+    const managed = this.clients.get(id);
+    if (managed && managed.connectionString === connectionString) {
+      if (managed.client.status === "ready") return managed.client;
+      await managed.client.quit().catch(() => {
+      });
+    } else if (managed) {
+      await managed.client.quit().catch(() => {
+      });
+    }
+    const client = new Redis(connectionString, {
+      lazyConnect: true,
+      connectTimeout: 1e4,
+      maxRetriesPerRequest: 1
+    });
+    await client.connect();
+    this.clients.set(id, { client, connectionString, createdAt: Date.now() });
+    return client;
+  }
+  /** Disconnect and remove a client */
+  async disconnect(id) {
+    const managed = this.clients.get(id);
+    if (managed) {
+      await managed.client.quit().catch(() => {
+      });
+      this.clients.delete(id);
+    }
+  }
+};
+var g5 = globalThis;
+var redisManager = g5.__redisManager ?? (g5.__redisManager = new RedisManager());
+
+// packages/feature/console/src/server/terminal/TerminalBridge.ts
+var REGISTRY_KEY = /* @__PURE__ */ Symbol.for("terminal_bridge_registry");
+var REVERSE_KEY = /* @__PURE__ */ Symbol.for("terminal_bridge_reverse");
+var OUTPUT_LISTENERS_KEY = /* @__PURE__ */ Symbol.for("terminal_bridge_output_listeners");
+var EXIT_LISTENERS_KEY = /* @__PURE__ */ Symbol.for("terminal_bridge_exit_listeners");
+function getRegistry() {
+  const g6 = globalThis;
+  if (!g6[REGISTRY_KEY]) g6[REGISTRY_KEY] = /* @__PURE__ */ new Map();
+  return g6[REGISTRY_KEY];
+}
+function getReverseIndex() {
+  const g6 = globalThis;
+  if (!g6[REVERSE_KEY]) g6[REVERSE_KEY] = /* @__PURE__ */ new Map();
+  return g6[REVERSE_KEY];
+}
+function getOutputListeners() {
+  const g6 = globalThis;
+  if (!g6[OUTPUT_LISTENERS_KEY]) g6[OUTPUT_LISTENERS_KEY] = /* @__PURE__ */ new Map();
+  return g6[OUTPUT_LISTENERS_KEY];
+}
+function getExitListeners() {
+  const g6 = globalThis;
+  if (!g6[EXIT_LISTENERS_KEY]) g6[EXIT_LISTENERS_KEY] = /* @__PURE__ */ new Map();
+  return g6[EXIT_LISTENERS_KEY];
+}
+function registerTerminal(tabId, commandId, command, projectCwd) {
+  const fullId = tabId + commandId;
+  const shortId = toShortId(fullId);
+  getRegistry().set(shortId, { shortId, commandId, tabId, command, projectCwd, registeredAt: Date.now() });
+  getReverseIndex().set(commandId, shortId);
+  return shortId;
+}
+function finalizeTerminal(commandId, exitCode) {
+  const shortId = getReverseIndex().get(commandId);
+  if (shortId) {
+    const entry = getRegistry().get(shortId);
+    if (entry) {
+      entry.exitCode = exitCode;
+    }
+    getOutputListeners().delete(commandId);
+    getExitListeners().delete(commandId);
+  }
+}
+function unregisterTerminal(commandId) {
+  const shortId = getReverseIndex().get(commandId);
+  if (shortId) {
+    getRegistry().delete(shortId);
+    getReverseIndex().delete(commandId);
+    getOutputListeners().delete(commandId);
+    getExitListeners().delete(commandId);
+  }
+}
+function getTerminalByShortId(shortId) {
+  return getRegistry().get(shortId);
+}
+function getTerminalShortId(commandId) {
+  return getReverseIndex().get(commandId);
+}
+function listTerminals(getRunning) {
+  const result = [];
+  for (const [, entry] of getRegistry()) {
+    const cmd = getRunning?.(entry.commandId);
+    result.push({
+      shortId: entry.shortId,
+      commandId: entry.commandId,
+      tabId: entry.tabId,
+      command: entry.command,
+      pid: cmd?.pid ?? 0,
+      running: !!cmd
+    });
+  }
+  return result;
+}
+function addOutputListener(commandId, cb) {
+  const listeners = getOutputListeners();
+  if (!listeners.has(commandId)) listeners.set(commandId, /* @__PURE__ */ new Set());
+  listeners.get(commandId).add(cb);
+  return () => {
+    listeners.get(commandId)?.delete(cb);
+    if (listeners.get(commandId)?.size === 0) listeners.delete(commandId);
+  };
+}
+function notifyOutputListeners(commandId, data) {
+  const cbs = getOutputListeners().get(commandId);
+  if (cbs) {
+    for (const cb of cbs) cb(data);
+  }
+}
+function addExitListener(commandId, cb) {
+  const listeners = getExitListeners();
+  if (!listeners.has(commandId)) listeners.set(commandId, /* @__PURE__ */ new Set());
+  listeners.get(commandId).add(cb);
+  return () => {
+    listeners.get(commandId)?.delete(cb);
+    if (listeners.get(commandId)?.size === 0) listeners.delete(commandId);
+  };
+}
+function notifyExitListeners(commandId, exitCode) {
+  const cbs = getExitListeners().get(commandId);
+  if (cbs) {
+    for (const cb of cbs) cb(exitCode);
+  }
+}
+
+// packages/feature/console/src/server/terminal/RunningCommandRegistry.ts
+import fs from "fs/promises";
+var MAX_OUTPUT_LINES = 5e3;
+var OUTPUT_FILE_THRESHOLD = 4096;
+var PTY_RING_BUFFER_MAX = 2 * 1024 * 1024;
+var PtyRingBuffer = class {
+  constructor(max = PTY_RING_BUFFER_MAX) {
+    this.chunks = [];
+    this.totalLen = 0;
+    this.max = max;
+  }
+  append(data) {
+    if (!data) return;
+    this.chunks.push(data);
+    this.totalLen += data.length;
+    while (this.totalLen > this.max && this.chunks.length > 0) {
+      const overflow = this.totalLen - this.max;
+      const oldest = this.chunks[0];
+      if (oldest.length <= overflow) {
+        this.chunks.shift();
+        this.totalLen -= oldest.length;
+      } else {
+        this.chunks[0] = oldest.slice(overflow);
+        this.totalLen -= overflow;
+      }
+    }
+  }
+  snapshot() {
+    return this.chunks.length === 1 ? this.chunks[0] : this.chunks.join("");
+  }
+  get length() {
+    return this.totalLen;
+  }
+};
+function findSafeStart(s) {
+  const lf = s.indexOf("\n");
+  if (lf !== -1) return lf + 1;
+  const esc = s.indexOf("\x1B");
+  if (esc !== -1) return esc;
+  return 0;
+}
+var GLOBAL_KEY2 = /* @__PURE__ */ Symbol.for("terminal_running_commands");
+var SERVER_ID_KEY = /* @__PURE__ */ Symbol.for("terminal_server_id");
+function getServerId() {
+  const g6 = globalThis;
+  if (!g6[SERVER_ID_KEY]) {
+    g6[SERVER_ID_KEY] = `srv_${Date.now()}_${process.pid}`;
+    console.log(`[registry] server started, id=${g6[SERVER_ID_KEY]}, pid=${process.pid}`);
+  }
+  return g6[SERVER_ID_KEY];
+}
+getServerId();
+function getRegistry2() {
+  const g6 = globalThis;
+  if (!g6[GLOBAL_KEY2]) {
+    g6[GLOBAL_KEY2] = /* @__PURE__ */ new Map();
+  }
+  return g6[GLOBAL_KEY2];
+}
+function registerCommand(cmd) {
+  console.log(`[registry] register: id=${cmd.commandId}, cmd="${cmd.command}", pid=${cmd.pid}, pty=${!!cmd.ptyProcess}, server=${getServerId()}`);
+  const entry = {
+    ...cmd,
+    outputLines: [],
+    outputPartial: "",
+    // Only PTY commands get a ring buffer — pipe mode replay still uses outputLines.
+    ...cmd.ptyProcess ? { ptyRingBuffer: new PtyRingBuffer() } : {}
+  };
+  getRegistry2().set(cmd.commandId, entry);
+  registerTerminal(cmd.tabId, cmd.commandId, cmd.command, cmd.projectCwd);
+  writeHistoryPlaceholder(cmd.commandId, cmd.command, cmd.timestamp, cmd.cwd, cmd.projectCwd, cmd.tabId, !!cmd.usePty).catch(() => {
+  });
+  if (cmd.ptyProcess) {
+    const pty = cmd.ptyProcess;
+    pty.onData((data) => {
+      entry.ptyRingBuffer?.append(data);
+      notifyOutputListeners(cmd.commandId, data);
+    });
+    const ptyPid = cmd.pid;
+    pty.onExit(async ({ exitCode }) => {
+      try {
+        await finalizeCommand(cmd.commandId, exitCode, ptyPid);
+      } catch (e) {
+        console.error("[registry] finalize error:", e);
+      }
+    });
+  } else {
+    const child = cmd.process;
+    child.stdout?.on("data", (data) => {
+      appendCommandOutput(cmd.commandId, data.toString());
+    });
+    child.stderr?.on("data", (data) => {
+      appendCommandOutput(cmd.commandId, data.toString());
+    });
+    const childPid = cmd.pid;
+    child.on("close", async (code) => {
+      try {
+        await finalizeCommand(cmd.commandId, code ?? 0, childPid);
+      } catch (e) {
+        console.error("[registry] finalize error:", e);
+      }
+    });
+    child.on("error", async () => {
+      try {
+        await finalizeCommand(cmd.commandId, 1, childPid);
+      } catch (e) {
+        console.error("[registry] finalize error:", e);
+      }
+    });
+  }
+}
+function appendCommandOutput(commandId, data) {
+  const cmd = getRegistry2().get(commandId);
+  if (!cmd) return;
+  const text = cmd.outputPartial + data;
+  const parts = text.split("\n");
+  cmd.outputPartial = parts.pop() || "";
+  if (parts.length > 0) {
+    cmd.outputLines.push(...parts);
+    if (cmd.outputLines.length > MAX_OUTPUT_LINES) {
+      cmd.outputLines.splice(0, cmd.outputLines.length - MAX_OUTPUT_LINES);
+      if (cmd.outputLines.length > 0) {
+        cmd.outputLines[0] = "\x1B[0m" + cmd.outputLines[0];
+      }
+    }
+  }
+  notifyOutputListeners(commandId, data);
+}
+function getBufferedOutput(cmd) {
+  const lines = cmd.outputLines.join("\n");
+  if (cmd.outputPartial) {
+    return lines ? lines + "\n" + cmd.outputPartial : cmd.outputPartial;
+  }
+  return lines;
+}
+function getRunningCommands(projectCwd) {
+  const results = [];
+  for (const cmd of getRegistry2().values()) {
+    if (cmd.projectCwd === projectCwd) {
+      results.push({
+        commandId: cmd.commandId,
+        command: cmd.command,
+        cwd: cmd.cwd,
+        tabId: cmd.tabId,
+        pid: cmd.pid,
+        timestamp: cmd.timestamp,
+        ...cmd.usePty ? { usePty: true } : {}
+      });
+    }
+  }
+  return results;
+}
+function getRunningCommand(commandId) {
+  return getRegistry2().get(commandId);
+}
+function getRegistrySize() {
+  return getRegistry2().size;
+}
+function getAllProjectCwds() {
+  const cwds = /* @__PURE__ */ new Set();
+  for (const cmd of getRegistry2().values()) {
+    cwds.add(cmd.projectCwd);
+  }
+  return [...cwds];
+}
+async function writeHistoryPlaceholder(commandId, command, timestamp, cwd, projectCwd, tabId, usePty) {
+  const historyPath = getTerminalHistoryPath(projectCwd, tabId);
+  await ensureParentDir(historyPath);
+  const entry = {
+    id: commandId,
+    command,
+    output: "",
+    timestamp,
+    cwd,
+    ...usePty ? { usePty: true } : {},
+    running: true
+  };
+  let existingLines = [];
+  try {
+    const content = await fs.readFile(historyPath, "utf-8");
+    existingLines = content.trim().split("\n").filter(Boolean);
+  } catch {
+  }
+  if (existingLines.length >= 100) {
+    const removedLines = existingLines.slice(0, existingLines.length - 99);
+    for (const line of removedLines) {
+      try {
+        const old = JSON.parse(line);
+        if (old.outputFile) await fs.unlink(old.outputFile).catch(() => {
+        });
+      } catch {
+      }
+    }
+    existingLines = existingLines.slice(-99);
+  }
+  existingLines.push(JSON.stringify(entry));
+  await fs.writeFile(historyPath, existingLines.join("\n") + "\n", "utf-8");
+}
+async function finalizeCommand(commandId, exitCode, pid) {
+  const registry2 = getRegistry2();
+  const cmd = registry2.get(commandId);
+  if (!cmd) return;
+  if (pid !== void 0 && cmd.pid !== pid) return;
+  console.log(`[registry] finalize: id=${commandId}, exitCode=${exitCode}, cmd="${cmd.command}", server=${getServerId()}`);
+  notifyExitListeners(commandId, exitCode);
+  finalizeTerminal(commandId, exitCode);
+  const output = getBufferedOutput(cmd);
+  cmd.ptyRingBuffer = void 0;
+  registry2.delete(commandId);
+  const entry = {
+    id: cmd.commandId,
+    command: cmd.command,
+    output: "",
+    exitCode,
+    timestamp: cmd.timestamp,
+    cwd: cmd.cwd,
+    ...cmd.usePty ? { usePty: true } : {}
+  };
+  const historyPath = getTerminalHistoryPath(cmd.projectCwd, cmd.tabId);
+  await ensureParentDir(historyPath);
+  if (output.length > OUTPUT_FILE_THRESHOLD) {
+    const outputPath = getTerminalOutputPath(cmd.projectCwd, cmd.commandId);
+    await fs.writeFile(outputPath, output, "utf-8");
+    entry.outputFile = outputPath;
+  } else {
+    entry.output = output;
+  }
+  let existingLines = [];
+  try {
+    const content = await fs.readFile(historyPath, "utf-8");
+    existingLines = content.trim().split("\n").filter(Boolean);
+  } catch {
+  }
+  let replaced = false;
+  for (let i = 0; i < existingLines.length; i++) {
+    try {
+      if (JSON.parse(existingLines[i]).id === commandId) {
+        existingLines[i] = JSON.stringify(entry);
+        replaced = true;
+        break;
+      }
+    } catch {
+    }
+  }
+  if (!replaced) {
+    existingLines.push(JSON.stringify(entry));
+  }
+  await fs.writeFile(historyPath, existingLines.join("\n") + "\n", "utf-8");
+}
+
+export {
+  registerBrowser,
+  unregisterBrowser,
+  getBrowserByShortId,
+  updateBrowserWs,
+  listBrowsers,
+  createPendingRequest,
+  resolvePendingRequest,
+  sendCommandToBrowser,
+  pgPoolManager,
+  kernelManager,
+  mysqlPoolManager,
+  neo4jManager,
+  redisManager,
+  registerTerminal,
+  finalizeTerminal,
+  unregisterTerminal,
+  getTerminalByShortId,
+  getTerminalShortId,
+  listTerminals,
+  addOutputListener,
+  notifyOutputListeners,
+  addExitListener,
+  notifyExitListeners,
+  PtyRingBuffer,
+  findSafeStart,
+  registerCommand,
+  appendCommandOutput,
+  getRunningCommands,
+  getRunningCommand,
+  getRegistrySize,
+  getAllProjectCwds,
+  finalizeCommand
+};