@surething/cockpit 1.0.213 → 1.0.214

package/dist/{chunk-FBR4KJI5.mjs → chunk-KRTISG5I.mjs}

@@ -2,7 +2,7 @@ import {
   ensureParentDir,
   getTerminalHistoryPath,
   getTerminalOutputPath
-} from "./chunk-TXBVUZVH.mjs";
+} from "./chunk-ZJ6CC3MH.mjs";
 
 // packages/feature/console/src/server/plugins/browser/BrowserBridge.ts
 import { WebSocket } from "ws";
@@ -481,23 +481,38 @@ import fs from "fs/promises";
 var MAX_OUTPUT_LINES = 5e3;
 var OUTPUT_FILE_THRESHOLD = 4096;
 var PTY_RING_BUFFER_MAX = 2 * 1024 * 1024;
+function countNewlines(s) {
+  let n = 0;
+  for (let i = 0; i < s.length; i++) {
+    if (s.charCodeAt(i) === 10) n++;
+  }
+  return n;
+}
 var PtyRingBuffer = class {
   constructor(max = PTY_RING_BUFFER_MAX) {
     this.chunks = [];
     this.totalLen = 0;
+    /** Monotonic count of `\n` chars ever appended. Never decreases. */
+    this._totalLinesEverWritten = 0;
+    /** Global line number of the first complete line currently in the ring. */
+    this._firstAvailableLine = 0;
     this.max = max;
   }
   append(data) {
     if (!data) return;
     this.chunks.push(data);
     this.totalLen += data.length;
+    this._totalLinesEverWritten += countNewlines(data);
     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._firstAvailableLine += countNewlines(oldest);
         this.chunks.shift();
         this.totalLen -= oldest.length;
       } else {
+        const cut = oldest.slice(0, overflow);
+        this._firstAvailableLine += countNewlines(cut);
         this.chunks[0] = oldest.slice(overflow);
         this.totalLen -= overflow;
       }
@@ -509,6 +524,14 @@ var PtyRingBuffer = class {
   get length() {
     return this.totalLen;
   }
+  /** Total `\n` chars ever written — monotonic global "next line number". */
+  get totalLinesEverWritten() {
+    return this._totalLinesEverWritten;
+  }
+  /** Global line number of the first complete line still in the ring. */
+  get firstAvailableLine() {
+    return this._firstAvailableLine;
+  }
 };
 function findSafeStart(s) {
   const lf = s.indexOf("\n");
@@ -541,6 +564,7 @@ function registerCommand(cmd) {
     ...cmd,
     outputLines: [],
     outputPartial: "",
+    totalLinesEverWritten: 0,
     // Only PTY commands get a ring buffer — pipe mode replay still uses outputLines.
     ...cmd.ptyProcess ? { ptyRingBuffer: new PtyRingBuffer() } : {}
   };
@@ -552,6 +576,10 @@ function registerCommand(cmd) {
     const pty = cmd.ptyProcess;
     pty.onData((data) => {
       entry.ptyRingBuffer?.append(data);
+      if (entry.ptyRingBuffer) {
+        entry.totalLinesEverWritten = entry.ptyRingBuffer.totalLinesEverWritten;
+      }
+      entry.lastOutputAt = Date.now();
       notifyOutputListeners(cmd.commandId, data);
     });
     const ptyPid = cmd.pid;
@@ -595,6 +623,7 @@ function appendCommandOutput(commandId, data) {
   cmd.outputPartial = parts.pop() || "";
   if (parts.length > 0) {
     cmd.outputLines.push(...parts);
+    cmd.totalLinesEverWritten += parts.length;
     if (cmd.outputLines.length > MAX_OUTPUT_LINES) {
       cmd.outputLines.splice(0, cmd.outputLines.length - MAX_OUTPUT_LINES);
       if (cmd.outputLines.length > 0) {
@@ -602,8 +631,13 @@ function appendCommandOutput(commandId, data) {
       }
     }
   }
+  cmd.lastOutputAt = Date.now();
   notifyOutputListeners(commandId, data);
 }
+function getFirstAvailableLine(cmd) {
+  if (cmd.ptyRingBuffer) return cmd.ptyRingBuffer.firstAvailableLine;
+  return cmd.totalLinesEverWritten - cmd.outputLines.length;
+}
 function getBufferedOutput(cmd) {
   const lines = cmd.outputLines.join("\n");
   if (cmd.outputPartial) {
@@ -726,6 +760,172 @@ async function finalizeCommand(commandId, exitCode, pid) {
   await fs.writeFile(historyPath, existingLines.join("\n") + "\n", "utf-8");
 }
 
+// packages/feature/console/src/server/terminal/writeStdin.ts
+function writeStdinToCommand(cmd, data) {
+  if (cmd.usePty && cmd.ptyProcess) {
+    try {
+      cmd.ptyProcess.write(data);
+    } catch {
+    }
+    return true;
+  }
+  if (data === "" && cmd.pid) {
+    try {
+      process.kill(-cmd.pid, "SIGINT");
+    } catch {
+      try {
+        process.kill(cmd.pid, "SIGINT");
+      } catch {
+      }
+    }
+    return true;
+  }
+  if (data === "" && cmd.pid) {
+    try {
+      process.kill(cmd.pid, "SIGTSTP");
+    } catch {
+    }
+    return true;
+  }
+  if (data === "") {
+    try {
+      cmd.process.stdin?.end();
+    } catch {
+    }
+    return true;
+  }
+  if (cmd.process.stdin?.writable) {
+    cmd.process.stdin.write(data);
+    return true;
+  }
+  return false;
+}
+
+// packages/feature/console/src/server/terminal/outputQuery.ts
+var ANSI_RE = /[\x1b\x9B][[\]()#;?]*(?:(?:(?:[a-zA-Z0-9]*(?:;[a-zA-Z0-9]*)*)?\x07)|(?:(?:\d{1,4}(?:;\d{0,4})*)?[\dA-PRZcf-ntqry=><~]))/g;
+function stripAnsi(s) {
+  return s.replace(ANSI_RE, "");
+}
+function collapseCarriageReturn(line) {
+  const s = line.replace(/\r+$/, "");
+  const idx = s.lastIndexOf("\r");
+  return idx === -1 ? s : s.slice(idx + 1);
+}
+function getLinesView(cmd, opts = {}) {
+  const stripAnsiFlag = opts.stripAnsi ?? true;
+  const collapseCrFlag = opts.collapseCr ?? true;
+  if (cmd.ptyRingBuffer) {
+    let snap = cmd.ptyRingBuffer.snapshot();
+    if (stripAnsiFlag) snap = stripAnsi(snap);
+    const parts = snap.split("\n");
+    parts.pop();
+    let lines2 = parts;
+    if (collapseCrFlag) {
+      lines2 = lines2.map(collapseCarriageReturn);
+    }
+    return {
+      lines: lines2,
+      firstLineGlobal: cmd.ptyRingBuffer.firstAvailableLine,
+      nextLineGlobal: cmd.ptyRingBuffer.firstAvailableLine + lines2.length
+    };
+  }
+  let lines = cmd.outputLines.slice();
+  if (stripAnsiFlag) lines = lines.map(stripAnsi);
+  if (collapseCrFlag) lines = lines.map(collapseCarriageReturn);
+  const firstLineGlobal = getFirstAvailableLine(cmd);
+  return {
+    lines,
+    firstLineGlobal,
+    nextLineGlobal: firstLineGlobal + lines.length
+  };
+}
+function emptyResult(view) {
+  return {
+    matches: [],
+    next: view.nextLineGlobal,
+    firstAvailable: view.firstLineGlobal,
+    totalLines: view.nextLineGlobal,
+    truncated: false
+  };
+}
+function sliceView(view, localStart, localEnd, truncated) {
+  const clampedStart = Math.max(0, Math.min(localStart, view.lines.length));
+  const clampedEnd = Math.max(clampedStart, Math.min(localEnd, view.lines.length));
+  const matches = [];
+  for (let i = clampedStart; i < clampedEnd; i++) {
+    matches.push({
+      lineno: view.firstLineGlobal + i,
+      text: view.lines[i]
+    });
+  }
+  return {
+    matches,
+    next: view.nextLineGlobal,
+    firstAvailable: view.firstLineGlobal,
+    totalLines: view.nextLineGlobal,
+    truncated
+  };
+}
+function readSince(cmd, since, opts = {}) {
+  const view = getLinesView(cmd, opts);
+  if (view.lines.length === 0) return emptyResult(view);
+  const localStart = since - view.firstLineGlobal;
+  const truncated = since < view.firstLineGlobal;
+  return sliceView(view, Math.max(0, localStart), view.lines.length, truncated);
+}
+function readTail(cmd, n, opts = {}) {
+  const view = getLinesView(cmd, opts);
+  if (view.lines.length === 0) return emptyResult(view);
+  const localStart = Math.max(0, view.lines.length - n);
+  const truncated = view.firstLineGlobal > 0 && n > view.lines.length;
+  return sliceView(view, localStart, view.lines.length, truncated);
+}
+function readHead(cmd, n, opts = {}) {
+  const view = getLinesView(cmd, opts);
+  if (view.lines.length === 0) return emptyResult(view);
+  const truncated = view.firstLineGlobal > 0;
+  return sliceView(view, 0, Math.min(n, view.lines.length), truncated);
+}
+function readAround(cmd, lineno, context, opts = {}) {
+  const view = getLinesView(cmd, opts);
+  if (view.lines.length === 0) return emptyResult(view);
+  const wantStart = Math.max(0, lineno - context);
+  const wantEnd = lineno + context + 1;
+  const localStart = wantStart - view.firstLineGlobal;
+  const localEnd = wantEnd - view.firstLineGlobal;
+  const truncated = wantStart < view.firstLineGlobal;
+  return sliceView(view, Math.max(0, localStart), Math.max(0, localEnd), truncated);
+}
+function grepOutput(cmd, pattern, opts = {}) {
+  const view = getLinesView(cmd, opts);
+  if (view.lines.length === 0) return emptyResult(view);
+  const flags = opts.ignoreCase ? "i" : "";
+  let re;
+  try {
+    re = new RegExp(pattern, flags);
+  } catch {
+    return emptyResult(view);
+  }
+  const since = opts.since ?? 0;
+  const maxMatches = opts.maxMatches ?? 1e3;
+  const matches = [];
+  for (let i = 0; i < view.lines.length; i++) {
+    const lineno = view.firstLineGlobal + i;
+    if (lineno < since) continue;
+    if (re.test(view.lines[i])) {
+      matches.push({ lineno, text: view.lines[i] });
+      if (matches.length >= maxMatches) break;
+    }
+  }
+  return {
+    matches,
+    next: view.nextLineGlobal,
+    firstAvailable: view.firstLineGlobal,
+    totalLines: view.nextLineGlobal,
+    truncated: since < view.firstLineGlobal
+  };
+}
+
 export {
   registerBrowser,
   unregisterBrowser,
@@ -746,13 +946,24 @@ export {
   notifyOutputListeners,
   addExitListener,
   notifyExitListeners,
+  countNewlines,
   PtyRingBuffer,
   findSafeStart,
   registerCommand,
   appendCommandOutput,
+  getFirstAvailableLine,
   getRunningCommands,
   getRunningCommand,
   getRegistrySize,
   getAllProjectCwds,
-  finalizeCommand
+  finalizeCommand,
+  writeStdinToCommand,
+  stripAnsi,
+  collapseCarriageReturn,
+  getLinesView,
+  readSince,
+  readTail,
+  readHead,
+  readAround,
+  grepOutput
 };

package/dist/{chunk-TXBVUZVH.mjs → chunk-ZJ6CC3MH.mjs}

@@ -1,9 +1,3 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
 // packages/feature/console/src/server/plugins/neo4j/neo4jCore.ts
 import neo4j from "neo4j-driver";
 async function createNeo4jDriver(connectionString) {
@@ -207,7 +201,6 @@ function withFileLock(filePath, fn) {
 }
 
 export {
-  __export,
   createNeo4jDriver,
   runCypherWithDriver,
   serializeValue,

package/dist/httpApi.mjs

@@ -1,18 +1,29 @@
 import {
+  addExitListener,
+  addOutputListener,
   createPendingRequest,
   getBrowserByShortId,
+  getFirstAvailableLine,
   getRunningCommand,
   getTerminalByShortId,
+  grepOutput,
   listBrowsers,
   listTerminals,
+  readAround,
+  readHead,
+  readSince,
+  readTail,
   registerTerminal,
   sendCommandToBrowser,
+  stripAnsi,
   unregisterBrowser,
-  unregisterTerminal
-} from "./chunk-FBR4KJI5.mjs";
+  unregisterTerminal,
+  writeStdinToCommand
+} from "./chunk-KRTISG5I.mjs";
 import {
   getTerminalHistoryPath
-} from "./chunk-TXBVUZVH.mjs";
+} from "./chunk-ZJ6CC3MH.mjs";
+import "./chunk-7P6ASYW6.mjs";
 
 // src/lib/httpApi.ts
 import { parse } from "url";
@@ -43,12 +54,21 @@ async function readFinishedOutput(projectCwd, tabId, commandId) {
   }
   return void 0;
 }
+var HANDLED_TERMINAL_ACTIONS = /* @__PURE__ */ new Set([
+  "list",
+  "register",
+  "unregister",
+  "output",
+  "stdin",
+  "meta",
+  "wait"
+]);
 async function handleTerminalApi(req, res) {
   const { pathname } = parse(req.url || "", true);
   const match = pathname?.match(/^\/api\/terminal\/([a-z]+)$/);
   if (!match || req.method !== "POST") return false;
   const action = match[1];
-  if (action !== "list" && action !== "register" && action !== "unregister") {
+  if (!HANDLED_TERMINAL_ACTIONS.has(action)) {
     return false;
   }
   const chunks = [];
@@ -103,14 +123,56 @@ async function handleTerminalApi(req, res) {
   const cmd = getRunningCommand(entry.commandId);
   if (action === "output") {
     if (cmd) {
-      const output = cmd.outputLines.join("\n") + (cmd.outputPartial ? "\n" + cmd.outputPartial : "");
+      const noAnsi = body.noAnsi ?? true;
+      const collapseCr = body.collapseCr ?? true;
+      const viewOpts = { stripAnsi: noAnsi, collapseCr };
+      let result;
+      if (typeof body.grep === "string" && body.grep.length > 0) {
+        result = grepOutput(cmd, body.grep, {
+          ...viewOpts,
+          ignoreCase: !!body.ignoreCase,
+          since: typeof body.since === "number" ? body.since : 0
+        });
+      } else if (typeof body.around === "number") {
+        result = readAround(
+          cmd,
+          body.around,
+          typeof body.context === "number" ? body.context : 5,
+          viewOpts
+        );
+      } else if (typeof body.tail === "number") {
+        result = readTail(cmd, body.tail, viewOpts);
+      } else if (typeof body.head === "number") {
+        result = readHead(cmd, body.head, viewOpts);
+      } else {
+        result = readSince(
+          cmd,
+          typeof body.since === "number" ? body.since : 0,
+          viewOpts
+        );
+      }
+      const maxBytes = body.maxBytes ?? 65536;
+      let acc = 0;
+      const trimmed = [];
+      for (let i = result.matches.length - 1; i >= 0; i--) {
+        const t = result.matches[i].text;
+        const len = t.length + 1;
+        if (acc + len > maxBytes && trimmed.length > 0) break;
+        trimmed.unshift(result.matches[i]);
+        acc += len;
+      }
+      const byteTruncated = trimmed.length < result.matches.length;
       sendJson(200, {
         ok: true,
         data: {
-          output,
+          matches: trimmed,
+          next: result.next,
+          firstAvailable: result.firstAvailable,
+          totalLines: result.totalLines,
+          truncated: result.truncated || byteTruncated,
+          running: true,
           command: entry.command,
-          pid: cmd.pid,
-          running: true
+          pid: cmd.pid
         }
       });
     } else {
@@ -124,10 +186,11 @@ async function handleTerminalApi(req, res) {
         entry.commandId
       );
       if (historyOutput !== void 0) {
+        const out = body.noAnsi ? stripAnsi(historyOutput.output) : historyOutput.output;
         sendJson(200, {
           ok: true,
           data: {
-            output: historyOutput.output,
+            output: out,
             command: entry.command,
             exitCode: historyOutput.exitCode,
             running: false
@@ -149,23 +212,146 @@ async function handleTerminalApi(req, res) {
       sendJson(400, { ok: false, error: "Missing data" });
       return true;
     }
-    if (cmd.usePty && cmd.ptyProcess) {
-      try {
-        cmd.ptyProcess.write(data);
-      } catch {
-      }
-    } else if (cmd.process.stdin?.writable) {
-      cmd.process.stdin.write(data);
-    } else {
+    const ok2 = writeStdinToCommand(cmd, data);
+    if (!ok2) {
       sendJson(500, { ok: false, error: "stdin not writable" });
       return true;
     }
     sendJson(200, { ok: true });
     return true;
   }
+  if (action === "meta") {
+    if (cmd) {
+      sendJson(200, {
+        ok: true,
+        data: {
+          shortId: id,
+          commandId: cmd.commandId,
+          command: cmd.command,
+          cwd: cmd.cwd,
+          tabId: cmd.tabId,
+          pid: cmd.pid,
+          usePty: !!cmd.usePty,
+          running: true,
+          startedAt: cmd.timestamp,
+          lastOutputAt: cmd.lastOutputAt ? new Date(cmd.lastOutputAt).toISOString() : null,
+          totalLines: cmd.totalLinesEverWritten,
+          firstAvailable: getFirstAvailableLine(cmd),
+          exitCode: null
+        }
+      });
+    } else {
+      sendJson(200, {
+        ok: true,
+        data: {
+          shortId: id,
+          commandId: entry.commandId,
+          command: entry.command,
+          tabId: entry.tabId,
+          running: false
+          // Exit info / history rebuild left for a future enhancement that
+          // reads the JSONL placeholder; meta on a stopped command is mostly
+          // useful for confirming "this id existed".
+        }
+      });
+    }
+    return true;
+  }
+  if (action === "wait") {
+    if (!cmd) {
+      sendJson(404, { ok: false, error: "Command no longer running" });
+      return true;
+    }
+    const timeoutSec = body.timeout ?? 30;
+    if (!body.pattern && typeof body.idle !== "number" && !body.waitExit) {
+      sendJson(400, {
+        ok: false,
+        error: "wait requires one of: pattern / idle / waitExit"
+      });
+      return true;
+    }
+    const outcome = await waitForCondition(cmd.commandId, {
+      pattern: body.pattern,
+      idle: body.idle,
+      waitExit: body.waitExit,
+      timeoutSec,
+      printOutput: !!body.printOutput
+    });
+    sendJson(200, { ok: true, data: outcome });
+    return true;
+  }
   sendJson(400, { ok: false, error: `Unknown action: ${action}` });
   return true;
 }
+async function waitForCondition(commandId, opts) {
+  return new Promise((resolve) => {
+    let resolved = false;
+    let unsubOutput;
+    let unsubExit;
+    let idleHandle;
+    const buf = [];
+    const cleanup = () => {
+      if (unsubOutput) unsubOutput();
+      if (unsubExit) unsubExit();
+      clearTimeout(timeoutHandle);
+      if (idleHandle) clearTimeout(idleHandle);
+    };
+    const finish = (result) => {
+      if (resolved) return;
+      resolved = true;
+      cleanup();
+      const output = opts.printOutput ? buf.join("") : void 0;
+      resolve({ ...result, output });
+    };
+    let patternRe;
+    if (opts.pattern) {
+      try {
+        patternRe = new RegExp(opts.pattern);
+      } catch (e) {
+        finish({ outcome: "timeout" });
+        resolve({
+          outcome: "timeout",
+          match: `invalid regex: ${e.message}`
+        });
+        return;
+      }
+    }
+    const scheduleIdle = () => {
+      if (typeof opts.idle !== "number") return;
+      if (idleHandle) clearTimeout(idleHandle);
+      idleHandle = setTimeout(
+        () => finish({ outcome: "idle" }),
+        opts.idle * 1e3
+      );
+    };
+    if (patternRe || typeof opts.idle === "number" || opts.printOutput) {
+      unsubOutput = addOutputListener(commandId, (data) => {
+        if (opts.printOutput) buf.push(data);
+        if (patternRe) {
+          const stripped = stripAnsi(data);
+          const lines = stripped.split("\n");
+          for (const line of lines) {
+            if (patternRe.test(line)) {
+              finish({ outcome: "pattern", match: line });
+              return;
+            }
+          }
+        }
+        scheduleIdle();
+      });
+    }
+    if (opts.waitExit) {
+      unsubExit = addExitListener(commandId, (code) => {
+        finish({ outcome: "exit", exitCode: code });
+      });
+    }
+    scheduleIdle();
+    const timeoutHandle = setTimeout(
+      () => finish({ outcome: "timeout" }),
+      opts.timeoutSec * 1e3
+    );
+  });
+}
 async function handleBrowserApi(req, res) {
   const { pathname } = parse(req.url || "", true);
   const match = pathname?.match(/^\/api\/browser\/([a-z][a-z_]*)$/);

package/dist/scheduledTasks.mjs

@@ -18,7 +18,7 @@ import {
   Tracer_exports,
   getSessionTitle,
   updateGlobalState
-} from "./chunk-OWUW2O3D.mjs";
+} from "./chunk-CZWJPTRO.mjs";
 import {
   CLAUDE2_DIR,
   SCHEDULED_TASKS_FILE,
@@ -26,7 +26,8 @@ import {
   readJsonFile,
   runCypherWithDriver,
   writeJsonFile
-} from "./chunk-TXBVUZVH.mjs";
+} from "./chunk-ZJ6CC3MH.mjs";
+import "./chunk-7P6ASYW6.mjs";
 
 // packages/feature/agent/src/server/scheduledTasks.ts
 import { query as query2 } from "@anthropic-ai/claude-agent-sdk";

package/dist/{server-E7G55DY7.mjs → server-OSOMFNXR.mjs}

@@ -3,41 +3,55 @@ import {
   addExitListener,
   addOutputListener,
   appendCommandOutput,
+  collapseCarriageReturn,
+  countNewlines,
   createPendingRequest,
   finalizeCommand,
   finalizeTerminal,
   findSafeStart,
   getAllProjectCwds,
   getBrowserByShortId,
+  getFirstAvailableLine,
+  getLinesView,
   getRegistrySize,
   getRunningCommand,
   getRunningCommands,
   getTerminalByShortId,
   getTerminalShortId,
+  grepOutput,
   kernelManager,
   listBrowsers,
   listTerminals,
   notifyExitListeners,
   notifyOutputListeners,
+  readAround,
+  readHead,
+  readSince,
+  readTail,
   registerBrowser,
   registerCommand,
   registerTerminal,
   resolvePendingRequest,
   sendCommandToBrowser,
+  stripAnsi,
   unregisterBrowser,
   unregisterTerminal,
-  updateBrowserWs
-} from "./chunk-FBR4KJI5.mjs";
+  updateBrowserWs,
+  writeStdinToCommand
+} from "./chunk-KRTISG5I.mjs";
 import {
   createNeo4jDriver,
   runCypherWithDriver,
   serializeValue
-} from "./chunk-TXBVUZVH.mjs";
+} from "./chunk-ZJ6CC3MH.mjs";
+import "./chunk-7P6ASYW6.mjs";
 export {
   PtyRingBuffer,
   addExitListener,
   addOutputListener,
   appendCommandOutput,
+  collapseCarriageReturn,
+  countNewlines,
   createNeo4jDriver,
   createPendingRequest,
   finalizeCommand,
@@ -45,16 +59,23 @@ export {
   findSafeStart,
   getAllProjectCwds,
   getBrowserByShortId,
+  getFirstAvailableLine,
+  getLinesView,
   getRegistrySize,
   getRunningCommand,
   getRunningCommands,
   getTerminalByShortId,
   getTerminalShortId,
+  grepOutput,
   kernelManager,
   listBrowsers,
   listTerminals,
   notifyExitListeners,
   notifyOutputListeners,
+  readAround,
+  readHead,
+  readSince,
+  readTail,
   registerBrowser,
   registerCommand,
   registerTerminal,
@@ -62,7 +83,9 @@ export {
   runCypherWithDriver,
   sendCommandToBrowser,
   serializeValue,
+  stripAnsi,
   unregisterBrowser,
   unregisterTerminal,
-  updateBrowserWs
+  updateBrowserWs,
+  writeStdinToCommand
 };