@surething/cockpit 1.0.216 → 1.0.217

package/dist/chunk-O4P2J44N.mjs

@@ -0,0 +1,314 @@
+import {
+  GLOBAL_STATE_FILE,
+  findCodexSessionPath,
+  findKimiSessionPath,
+  getClaude2SessionPath,
+  getClaudeSessionPath,
+  getOllamaSessionPath,
+  readJsonFile,
+  withFileLock,
+  writeJsonFile
+} from "./chunk-GCYLMG43.mjs";
+
+// packages/feature/agent/src/server/state/globalState.ts
+import { createReadStream, existsSync } 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 (!existsSync(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 (existsSync(claudePath)) {
+    return getClaudeStyleTitle(claudePath);
+  }
+  const claude2Path = getClaude2SessionPath(cwd, sessionId);
+  if (existsSync(claude2Path)) {
+    return getClaudeStyleTitle(claude2Path);
+  }
+  const ollamaPath = getOllamaSessionPath(cwd, sessionId);
+  if (existsSync(ollamaPath)) {
+    return getClaudeStyleTitle(ollamaPath);
+  }
+  const codexPath = findCodexSessionPath(sessionId);
+  if (codexPath && existsSync(codexPath)) {
+    const title = await getCodexTitle(codexPath);
+    return title || "Untitled Session";
+  }
+  const kimiPath = findKimiSessionPath(sessionId);
+  if (kimiPath && existsSync(kimiPath)) {
+    const title = await getKimiTitle(kimiPath);
+    return title || "Untitled Session";
+  }
+  return "Untitled Session";
+}
+async function getLastUserMessage(cwd, sessionId) {
+  const claudePath = getClaudeSessionPath(cwd, sessionId);
+  if (existsSync(claudePath)) {
+    return await getClaudeStyleLastUserMessage(claudePath);
+  }
+  const claude2Path = getClaude2SessionPath(cwd, sessionId);
+  if (existsSync(claude2Path)) {
+    return await getClaudeStyleLastUserMessage(claude2Path);
+  }
+  const ollamaPath = getOllamaSessionPath(cwd, sessionId);
+  if (existsSync(ollamaPath)) {
+    return await getClaudeStyleLastUserMessage(ollamaPath);
+  }
+  const codexPath = findCodexSessionPath(sessionId);
+  if (codexPath && existsSync(codexPath)) {
+    return await getCodexLastUserMessage(codexPath);
+  }
+  const kimiPath = findKimiSessionPath(sessionId);
+  if (kimiPath && existsSync(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 {
+  updateGlobalState,
+  getSessionTitle,
+  getLastUserMessage
+};

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

@@ -1,8 +1,19 @@
 import {
+  AppRuntime,
+  Cause_exports,
+  Effect_exports,
+  Exit_exports,
+  FSError,
+  Option_exports,
+  ValidationError,
   ensureParentDir,
+  errorToStatus,
+  getBubbleOrderPath,
   getTerminalHistoryPath,
-  getTerminalOutputPath
-} from "./chunk-ZJ6CC3MH.mjs";
+  getTerminalOutputPath,
+  readJsonFile,
+  writeJsonFile
+} from "./chunk-GCYLMG43.mjs";
 
 // packages/feature/console/src/server/plugins/browser/BrowserBridge.ts
 import { WebSocket } from "ws";
@@ -33,9 +44,9 @@ function toShortId(fullId) {
 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) {
+function registerBrowser(fullId, ws, projectCwd, tabId) {
   const shortId = toShortId(fullId);
-  registry.set(shortId, { fullId, ws, lastSeen: Date.now() });
+  registry.set(shortId, { fullId, ws, lastSeen: Date.now(), projectCwd, tabId });
   fullIdToShort.set(fullId, shortId);
   return shortId;
 }
@@ -65,7 +76,9 @@ function listBrowsers() {
     result.push({
       shortId,
       fullId: entry.fullId,
-      connected: entry.ws !== null && entry.ws.readyState === WebSocket.OPEN
+      connected: entry.ws !== null && entry.ws.readyState === WebSocket.OPEN,
+      projectCwd: entry.projectCwd,
+      tabId: entry.tabId
     });
   }
   return result;
@@ -80,12 +93,12 @@ function createPendingRequest(reqId, timeout) {
     pendingRequests.set(reqId, { resolve, reject, timer });
   });
 }
-function resolvePendingRequest(reqId, ok, data, error) {
+function resolvePendingRequest(reqId, ok2, data, error) {
   const pending = pendingRequests.get(reqId);
   if (!pending) return;
   clearTimeout(pending.timer);
   pendingRequests.delete(reqId);
-  if (ok) {
+  if (ok2) {
     pending.resolve(data);
   } else {
     pending.reject(new Error(error || "Browser command failed"));
@@ -440,7 +453,8 @@ function listTerminals(getRunning) {
       tabId: entry.tabId,
       command: entry.command,
       pid: cmd?.pid ?? 0,
-      running: !!cmd
+      running: !!cmd,
+      projectCwd: entry.projectCwd
     });
   }
   return result;
@@ -926,6 +940,178 @@ function grepOutput(cmd, pattern, opts = {}) {
   };
 }
 
+// packages/shared/effect-runtime/src/next.ts
+var ok = (body, status = 200) => new Response(JSON.stringify(body), {
+  status,
+  headers: { "content-type": "application/json" }
+});
+var extractErrorMessage = (e) => {
+  const maybeMsg = e.message;
+  if (typeof maybeMsg === "string" && maybeMsg.length > 0) {
+    return maybeMsg;
+  }
+  const cause = e.cause;
+  if (cause instanceof Error && cause.message.length > 0) {
+    return cause.message;
+  }
+  switch (e._tag) {
+    case "ValidationError": {
+      const v = e;
+      return `Invalid ${v.field}: ${v.reason}`;
+    }
+    case "NotFoundError": {
+      const n = e;
+      return `${n.resource} not found: ${n.id}`;
+    }
+    case "PermissionError": {
+      const p = e;
+      return `Permission denied: ${p.action} on ${p.resource}`;
+    }
+    case "DBError": {
+      const d = e;
+      return `${d.db} ${d.op} failed`;
+    }
+    case "FSError": {
+      const f = e;
+      return `${f.op} ${f.path} failed`;
+    }
+    case "WSError": {
+      const w = e;
+      return `${w.proto} ${w.kind} failed`;
+    }
+    case "AgentError": {
+      const a = e;
+      return `${a.provider} ${a.kind} failed`;
+    }
+    default:
+      return e._tag;
+  }
+};
+var errorToResponse = (cause) => {
+  const failure = Cause_exports.failureOption(cause);
+  if (Option_exports.isSome(failure)) {
+    const e = failure.value;
+    const status = errorToStatus(e);
+    return new Response(
+      JSON.stringify({ error: extractErrorMessage(e), tag: e._tag }),
+      {
+        status,
+        headers: { "content-type": "application/json" }
+      }
+    );
+  }
+  console.error("[handler] uncaught defect:\n" + Cause_exports.pretty(cause));
+  return new Response(
+    JSON.stringify({ error: "Internal Server Error", tag: "InternalError" }),
+    {
+      status: 500,
+      headers: { "content-type": "application/json" }
+    }
+  );
+};
+var handler = (fn) => async (req) => {
+  const exit = await AppRuntime.runPromiseExit(fn(req));
+  return Exit_exports.match(exit, {
+    onFailure: (cause) => errorToResponse(cause),
+    onSuccess: (res) => res
+  });
+};
+var parseJsonRaw = (req) => Effect_exports.tryPromise({
+  try: () => req.json(),
+  catch: () => new ValidationError({
+    field: "body",
+    reason: "invalid JSON"
+  })
+});
+
+// packages/feature/console/src/server/api/terminal/bubble-order.ts
+async function readBubbleTitles(cwd, tabId) {
+  try {
+    const raw = await readJsonFile(getBubbleOrderPath(cwd, tabId), []);
+    return normalise(raw).titles;
+  } catch {
+    return {};
+  }
+}
+function normalise(raw) {
+  if (Array.isArray(raw)) return { order: raw, titles: {} };
+  if (raw && typeof raw === "object") {
+    const r = raw;
+    return {
+      order: Array.isArray(r.order) ? r.order : [],
+      titles: r.titles && typeof r.titles === "object" ? r.titles : {}
+    };
+  }
+  return { order: [], titles: {} };
+}
+var GET = handler(
+  (req) => Effect_exports.gen(function* () {
+    const sp = new URL(req.url).searchParams;
+    const cwd = sp.get("cwd");
+    const tabId = sp.get("tabId");
+    if (!cwd || !tabId) {
+      return yield* Effect_exports.fail(
+        new ValidationError({
+          field: !cwd ? "cwd" : "tabId",
+          reason: "missing"
+        })
+      );
+    }
+    const orderPath = getBubbleOrderPath(cwd, tabId);
+    const raw = yield* Effect_exports.tryPromise({
+      try: () => readJsonFile(orderPath, []),
+      catch: (cause) => new FSError({ path: orderPath, op: "read", cause })
+    });
+    const file = normalise(raw);
+    return ok({ order: file.order, titles: file.titles });
+  })
+);
+var POST = handler(
+  (req) => Effect_exports.gen(function* () {
+    const body = yield* parseJsonRaw(req);
+    if (!body.cwd || !body.tabId) {
+      return yield* Effect_exports.fail(
+        new ValidationError({
+          field: !body.cwd ? "cwd" : "tabId",
+          reason: "missing"
+        })
+      );
+    }
+    const hasOrder = Array.isArray(body.order);
+    const hasTitles = body.titles && typeof body.titles === "object";
+    if (!hasOrder && !hasTitles) {
+      return yield* Effect_exports.fail(
+        new ValidationError({ field: "order|titles", reason: "missing \u2014 provide at least one" })
+      );
+    }
+    const orderPath = getBubbleOrderPath(body.cwd, body.tabId);
+    const existing = normalise(
+      yield* Effect_exports.tryPromise({
+        try: () => readJsonFile(orderPath, []),
+        catch: (cause) => new FSError({ path: orderPath, op: "read", cause })
+      })
+    );
+    const next = {
+      order: hasOrder ? body.order : existing.order,
+      titles: hasTitles ? mergeTitles(existing.titles, body.titles) : existing.titles
+    };
+    yield* Effect_exports.tryPromise({
+      try: () => writeJsonFile(orderPath, next),
+      catch: (cause) => new FSError({ path: orderPath, op: "write", cause })
+    });
+    return ok({ success: true });
+  })
+);
+function mergeTitles(base, patch) {
+  const out = { ...base };
+  for (const [k, v] of Object.entries(patch)) {
+    if (typeof v !== "string") continue;
+    if (v === "") delete out[k];
+    else out[k] = v.slice(0, 256);
+  }
+  return out;
+}
+
 export {
   registerBrowser,
   unregisterBrowser,
@@ -965,5 +1151,6 @@ export {
   readTail,
   readHead,
   readAround,
-  grepOutput
+  grepOutput,
+  readBubbleTitles
 };

package/dist/httpApi.mjs

@@ -10,6 +10,7 @@ import {
   listBrowsers,
   listTerminals,
   readAround,
+  readBubbleTitles,
   readHead,
   readSince,
   readTail,
@@ -19,10 +20,10 @@ import {
   unregisterBrowser,
   unregisterTerminal,
   writeStdinToCommand
-} from "./chunk-KRTISG5I.mjs";
+} from "./chunk-W6G6X3FP.mjs";
 import {
   getTerminalHistoryPath
-} from "./chunk-ZJ6CC3MH.mjs";
+} from "./chunk-GCYLMG43.mjs";
 import "./chunk-7P6ASYW6.mjs";
 
 // src/lib/httpApi.ts
@@ -30,6 +31,7 @@ import { parse } from "url";
 import { readFile } from "fs/promises";
 import { randomUUID } from "crypto";
 import { WebSocket } from "ws";
+import { resolve as resolvePath } from "path";
 async function readFinishedOutput(projectCwd, tabId, commandId) {
   try {
     const historyPath = getTerminalHistoryPath(projectCwd, tabId);
@@ -419,7 +421,78 @@ async function handleBrowserApi(req, res) {
   }
   return true;
 }
+async function handleConnectionApi(req, res) {
+  const { pathname } = parse(req.url || "", true);
+  const match = pathname?.match(/^\/api\/connection\/([a-z]+)$/);
+  if (!match || req.method !== "POST") return false;
+  if (match[1] !== "list") return false;
+  const chunks = [];
+  for await (const chunk of req) chunks.push(chunk);
+  let body = {};
+  try {
+    body = JSON.parse(Buffer.concat(chunks).toString());
+  } catch {
+  }
+  const sendJson = (status, data) => {
+    res.writeHead(status, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(data));
+  };
+  const filterCwd = body.cwd ? resolvePath(body.cwd) : void 0;
+  const aliveOnly = !body.all;
+  const terms = listTerminals(getRunningCommand);
+  const browsers = listBrowsers();
+  const sameCwd = (entryCwd) => !filterCwd ? true : !!entryCwd && resolvePath(entryCwd) === filterCwd;
+  const SEP = String.fromCharCode(31);
+  const cwdTabPairs = /* @__PURE__ */ new Set();
+  for (const t of terms) {
+    if (t.projectCwd && t.tabId) cwdTabPairs.add(`${t.projectCwd}${SEP}${t.tabId}`);
+  }
+  for (const b of browsers) {
+    if (b.projectCwd && b.tabId) cwdTabPairs.add(`${b.projectCwd}${SEP}${b.tabId}`);
+  }
+  const titlesByPair = /* @__PURE__ */ new Map();
+  await Promise.all(
+    Array.from(cwdTabPairs).map(async (pair) => {
+      const [cwd, tabId] = pair.split(SEP);
+      titlesByPair.set(pair, await readBubbleTitles(cwd, tabId));
+    })
+  );
+  const titleOf = (cwd, tabId, key) => {
+    if (!cwd || !tabId) return void 0;
+    const t = titlesByPair.get(`${cwd}${SEP}${tabId}`)?.[key];
+    return t || void 0;
+  };
+  const out = [];
+  for (const t of terms) {
+    if (!sameCwd(t.projectCwd)) continue;
+    if (aliveOnly && !t.running) continue;
+    out.push({
+      type: "terminal",
+      shortId: t.shortId,
+      title: titleOf(t.projectCwd, t.tabId, t.commandId),
+      projectCwd: t.projectCwd,
+      tabId: t.tabId,
+      command: t.command,
+      alive: t.running
+    });
+  }
+  for (const b of browsers) {
+    if (!sameCwd(b.projectCwd)) continue;
+    if (aliveOnly && !b.connected) continue;
+    out.push({
+      type: "browser",
+      shortId: b.shortId,
+      title: titleOf(b.projectCwd, b.tabId, b.fullId),
+      projectCwd: b.projectCwd,
+      tabId: b.tabId,
+      alive: b.connected
+    });
+  }
+  sendJson(200, { ok: true, data: out });
+  return true;
+}
 export {
   handleBrowserApi,
+  handleConnectionApi,
   handleTerminalApi
 };