@surething/cockpit 1.0.208 → 1.0.209

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

@@ -1,3 +1,93 @@
+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) {
+  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();
+  return driver;
+}
+async function runCypherWithDriver(driver, cypher, params) {
+  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] = 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();
+  }
+}
+function 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: serializeValue(node.identity),
+      _labels: node.labels,
+      ...Object.fromEntries(
+        Object.entries(node.properties).map(([k, v]) => [k, 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: serializeValue(rel.identity),
+      _relType: rel.type,
+      _start: serializeValue(rel.start),
+      _end: serializeValue(rel.end),
+      ...Object.fromEntries(
+        Object.entries(rel.properties).map(([k, v]) => [k, serializeValue(v)])
+      )
+    };
+  }
+  if (val && typeof val === "object" && "segments" in val) {
+    const path = val;
+    return {
+      _type: "path",
+      segments: path.segments.map((s) => ({
+        start: serializeValue(s.start),
+        relationship: serializeValue(s.relationship),
+        end: serializeValue(s.end)
+      }))
+    };
+  }
+  if (Array.isArray(val)) return val.map((v) => serializeValue(v));
+  if (val && typeof val === "object" && val.constructor === Object) {
+    return Object.fromEntries(
+      Object.entries(val).map(([k, v]) => [k, serializeValue(v)])
+    );
+  }
+  return val;
+}
+
 // packages/shared/utils/src/paths.ts
 import { homedir } from "os";
 import { join } from "path";
@@ -117,6 +207,10 @@ function withFileLock(filePath, fn) {
 }
 
 export {
+  __export,
+  createNeo4jDriver,
+  runCypherWithDriver,
+  serializeValue,
   GLOBAL_STATE_FILE,
   SCHEDULED_TASKS_FILE,
   REVIEW_DIR,

package/dist/httpApi.mjs

@@ -0,0 +1,239 @@
+import {
+  createPendingRequest,
+  getBrowserByShortId,
+  getRunningCommand,
+  getTerminalByShortId,
+  listBrowsers,
+  listTerminals,
+  registerTerminal,
+  sendCommandToBrowser,
+  unregisterBrowser,
+  unregisterTerminal
+} from "./chunk-FBR4KJI5.mjs";
+import {
+  getTerminalHistoryPath
+} from "./chunk-TXBVUZVH.mjs";
+
+// src/lib/httpApi.ts
+import { parse } from "url";
+import { readFile } from "fs/promises";
+import { randomUUID } from "crypto";
+import { WebSocket } from "ws";
+async function readFinishedOutput(projectCwd, tabId, commandId) {
+  try {
+    const historyPath = getTerminalHistoryPath(projectCwd, tabId);
+    const content = await readFile(historyPath, "utf-8");
+    for (const line of content.trim().split("\n").reverse()) {
+      try {
+        const entry = JSON.parse(line);
+        if (entry.id === commandId) {
+          let output = entry.output || "";
+          if (entry.outputFile) {
+            try {
+              output = await readFile(entry.outputFile, "utf-8");
+            } catch {
+            }
+          }
+          return { output, exitCode: entry.exitCode ?? 0 };
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
+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") {
+    return false;
+  }
+  const chunks = [];
+  for await (const chunk of req) chunks.push(chunk);
+  let body;
+  try {
+    body = JSON.parse(Buffer.concat(chunks).toString());
+  } catch {
+    body = {};
+  }
+  const sendJson = (status, data) => {
+    res.writeHead(status, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(data));
+  };
+  if (action === "list") {
+    sendJson(200, { ok: true, data: listTerminals(getRunningCommand) });
+    return true;
+  }
+  if (action === "register") {
+    const { tabId, commandId, command, projectCwd } = body;
+    if (!tabId || !commandId || !command) {
+      sendJson(400, {
+        ok: false,
+        error: "Missing tabId/commandId/command"
+      });
+      return true;
+    }
+    const shortId = registerTerminal(tabId, commandId, command, projectCwd);
+    sendJson(200, { ok: true, data: { shortId } });
+    return true;
+  }
+  if (action === "unregister") {
+    const { commandId } = body;
+    if (!commandId) {
+      sendJson(400, { ok: false, error: "Missing commandId" });
+      return true;
+    }
+    unregisterTerminal(commandId);
+    sendJson(200, { ok: true });
+    return true;
+  }
+  const { id } = body;
+  if (!id) {
+    sendJson(400, { ok: false, error: "Missing terminal id" });
+    return true;
+  }
+  const entry = getTerminalByShortId(id);
+  if (!entry) {
+    sendJson(404, { ok: false, error: `Terminal "${id}" not found` });
+    return true;
+  }
+  const cmd = getRunningCommand(entry.commandId);
+  if (action === "output") {
+    if (cmd) {
+      const output = cmd.outputLines.join("\n") + (cmd.outputPartial ? "\n" + cmd.outputPartial : "");
+      sendJson(200, {
+        ok: true,
+        data: {
+          output,
+          command: entry.command,
+          pid: cmd.pid,
+          running: true
+        }
+      });
+    } else {
+      if (!entry.projectCwd) {
+        sendJson(404, { ok: false, error: "Command projectCwd unknown" });
+        return true;
+      }
+      const historyOutput = await readFinishedOutput(
+        entry.projectCwd,
+        entry.tabId,
+        entry.commandId
+      );
+      if (historyOutput !== void 0) {
+        sendJson(200, {
+          ok: true,
+          data: {
+            output: historyOutput.output,
+            command: entry.command,
+            exitCode: historyOutput.exitCode,
+            running: false
+          }
+        });
+      } else {
+        sendJson(404, { ok: false, error: "Command output not available" });
+      }
+    }
+    return true;
+  }
+  if (action === "stdin") {
+    if (!cmd) {
+      sendJson(404, { ok: false, error: "Command no longer running" });
+      return true;
+    }
+    const { data } = body;
+    if (data === void 0) {
+      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 {
+      sendJson(500, { ok: false, error: "stdin not writable" });
+      return true;
+    }
+    sendJson(200, { ok: true });
+    return true;
+  }
+  sendJson(400, { ok: false, error: `Unknown action: ${action}` });
+  return true;
+}
+async function handleBrowserApi(req, res) {
+  const { pathname } = parse(req.url || "", true);
+  const match = pathname?.match(/^\/api\/browser\/([a-z][a-z_]*)$/);
+  if (!match || req.method !== "POST") return false;
+  const action = match[1];
+  const chunks = [];
+  for await (const chunk of req) chunks.push(chunk);
+  let body;
+  try {
+    body = JSON.parse(Buffer.concat(chunks).toString());
+  } catch {
+    body = {};
+  }
+  const { id, params: cmdParams = {}, timeout = 1e4 } = body;
+  const sendJson = (status, data) => {
+    res.writeHead(status, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(data));
+  };
+  if (action === "list") {
+    sendJson(200, { ok: true, data: listBrowsers() });
+    return true;
+  }
+  if (action === "unregister") {
+    if (!id) {
+      sendJson(400, { ok: false, error: "Missing browser id" });
+      return true;
+    }
+    const browser2 = getBrowserByShortId(id);
+    if (browser2) {
+      if (browser2.ws && browser2.ws.readyState === WebSocket.OPEN) {
+        browser2.ws.close();
+      }
+      unregisterBrowser(browser2.fullId);
+    }
+    sendJson(200, { ok: true });
+    return true;
+  }
+  if (!id) {
+    sendJson(400, { ok: false, error: "Missing browser id" });
+    return true;
+  }
+  const browser = getBrowserByShortId(id);
+  if (!browser) {
+    sendJson(404, { ok: false, error: `Browser "${id}" not found` });
+    return true;
+  }
+  if (!browser.ws || browser.ws.readyState !== WebSocket.OPEN) {
+    sendJson(503, {
+      ok: false,
+      error: `Browser "${id}" is disconnected`
+    });
+    return true;
+  }
+  const reqId = `r-${randomUUID().slice(0, 8)}`;
+  const sent = sendCommandToBrowser(id, reqId, action, cmdParams);
+  if (!sent) {
+    sendJson(503, { ok: false, error: "Failed to send command" });
+    return true;
+  }
+  try {
+    const data = await createPendingRequest(reqId, timeout);
+    sendJson(200, { ok: true, data });
+  } catch (err) {
+    sendJson(504, { ok: false, error: err.message });
+  }
+  return true;
+}
+export {
+  handleBrowserApi,
+  handleTerminalApi
+};