@openscout/scout 0.2.76 → 0.2.78

package/dist/runtime/mesh-discover.mjs

@@ -74,33 +74,49 @@ function requestBrokerOverUnixSocket(socketPath, baseUrl, path, options) {
     if (body !== undefined) {
       headers["content-length"] = Buffer.byteLength(body).toString();
     }
+    let settled = false;
+    const cleanupAbortListener = () => {
+      options.signal?.removeEventListener("abort", handleAbort);
+    };
+    const rejectOnce = (error) => {
+      if (settled)
+        return;
+      settled = true;
+      cleanupAbortListener();
+      reject(error);
+    };
     const request = httpRequest({
       socketPath,
       path: `${url.pathname}${url.search}`,
       method: options.method ?? (body === undefined ? "GET" : "POST"),
       headers
     }, (response) => {
-      let text = "";
-      response.setEncoding("utf8");
+      const chunks = [];
       response.on("data", (chunk) => {
-        text += String(chunk);
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+      });
+      response.on("aborted", () => {
+        rejectOnce(new Error("Scout broker response aborted"));
       });
+      response.on("error", rejectOnce);
       response.on("end", () => {
-        options.signal?.removeEventListener("abort", handleAbort);
+        if (settled)
+          return;
+        settled = true;
+        cleanupAbortListener();
         resolve({
           ok: Boolean(response.statusCode && response.statusCode >= 200 && response.statusCode < 300),
           status: response.statusCode ?? 0,
-          text
+          text: Buffer.concat(chunks).toString("utf8")
         });
       });
     });
     const handleAbort = () => {
-      request.destroy(options.signal?.reason instanceof Error ? options.signal.reason : new Error("Scout broker request aborted"));
+      const error = options.signal?.reason instanceof Error ? options.signal.reason : new Error("Scout broker request aborted");
+      rejectOnce(error);
+      request.destroy(error);
     };
-    request.on("error", (error) => {
-      options.signal?.removeEventListener("abort", handleAbort);
-      reject(error);
-    });
+    request.on("error", rejectOnce);
     if (options.signal) {
       if (options.signal.aborted) {
         handleAbort();
@@ -177,6 +193,175 @@ async function requestScoutBrokerJsonWithTrace(baseUrl, path, options = {}) {
   return { value: undefined, trace };
 }
 
+// packages/runtime/src/schema-version.ts
+var CONTROL_PLANE_SCHEMA_VERSION = 17;
+
+// packages/runtime/src/sqlite-adapter.ts
+import { createRequire } from "module";
+
+// packages/runtime/src/runtime-adapters.ts
+function detectRuntimeHost(globalScope = globalThis) {
+  return typeof globalScope.Bun === "undefined" ? "node" : "bun";
+}
+function normalizeRuntimeHost(value) {
+  const normalized = value?.trim().toLowerCase();
+  if (normalized === "bun")
+    return "bun";
+  if (normalized === "node")
+    return "node";
+  return null;
+}
+function normalizeRuntimeServiceAdapter(value) {
+  const normalized = value?.trim().toLowerCase().replaceAll("_", "-");
+  if (normalized === "macos-scoutd" || normalized === "macos-launchd")
+    return "macos-scoutd";
+  if (normalized === "linux-systemd-user" || normalized === "systemd-user")
+    return "linux-systemd-user";
+  if (normalized === "headless-foreground" || normalized === "foreground" || normalized === "headless") {
+    return "headless-foreground";
+  }
+  if (normalized === "windows-service")
+    return "windows-service";
+  return null;
+}
+function defaultServiceAdapterForPlatform(platform = process.platform, env = process.env) {
+  const explicit = normalizeRuntimeServiceAdapter(env.OPENSCOUT_SERVICE_ADAPTER);
+  if (explicit)
+    return explicit;
+  if (normalizeRuntimeHost(env.OPENSCOUT_RUNTIME_HOST) === "node") {
+    return "headless-foreground";
+  }
+  if (platform === "darwin")
+    return "macos-scoutd";
+  if (platform === "linux")
+    return "headless-foreground";
+  if (platform === "win32")
+    return "windows-service";
+  return "headless-foreground";
+}
+function planRuntimeAdapters(options = {}) {
+  const env = options.env ?? process.env;
+  const host = options.host ?? normalizeRuntimeHost(env.OPENSCOUT_RUNTIME_HOST) ?? detectRuntimeHost();
+  return {
+    host,
+    database: host === "bun" ? "bun-sqlite" : "node-sqlite",
+    httpServer: host === "bun" ? "bun-serve" : "node-http-ws",
+    files: host === "bun" ? "bun-file" : "node-fs",
+    process: host === "bun" ? "bun-spawn" : "node-child-process",
+    service: defaultServiceAdapterForPlatform(options.platform, env)
+  };
+}
+
+// packages/runtime/src/sqlite-adapter.ts
+var require2 = createRequire(import.meta.url);
+function controlPlaneSqliteAdapterKind() {
+  return planRuntimeAdapters().database;
+}
+function openControlPlaneSqliteDatabase(path, options) {
+  return openRuntimeSqliteDatabase(path, options);
+}
+function openRuntimeSqliteDatabase(path, options) {
+  const adapter = controlPlaneSqliteAdapterKind();
+  if (adapter === "bun-sqlite") {
+    const { Database } = require2("bun:sqlite");
+    return new Database(path, options);
+  }
+  const { DatabaseSync } = require2("node:sqlite");
+  return new NodeSqliteDatabaseAdapter(new DatabaseSync(path, {
+    open: true,
+    readOnly: options?.readonly === true
+  }));
+}
+function prepareNodeSqliteSql(sql) {
+  const numberedParamIndexes = [];
+  const normalizedSql = sql.replace(/\?(\d+)/g, (_match, rawIndex) => {
+    numberedParamIndexes.push(Number.parseInt(rawIndex, 10) - 1);
+    return "?";
+  });
+  return {
+    sql: normalizedSql,
+    numberedParamIndexes: numberedParamIndexes.length > 0 ? numberedParamIndexes : null
+  };
+}
+function bindNodeSqliteParams(numberedParamIndexes, params) {
+  if (!numberedParamIndexes) {
+    return params;
+  }
+  return numberedParamIndexes.map((index) => params[index]);
+}
+
+class NodeSqliteStatementAdapter {
+  statement;
+  numberedParamIndexes;
+  constructor(statement, numberedParamIndexes) {
+    this.statement = statement;
+    this.numberedParamIndexes = numberedParamIndexes;
+  }
+  all(...params) {
+    return this.statement.all(...bindNodeSqliteParams(this.numberedParamIndexes, params));
+  }
+  get(...params) {
+    return this.statement.get(...bindNodeSqliteParams(this.numberedParamIndexes, params)) ?? null;
+  }
+  run(...params) {
+    return this.statement.run(...bindNodeSqliteParams(this.numberedParamIndexes, params));
+  }
+}
+
+class NodeSqliteDatabaseAdapter {
+  database;
+  transactionDepth = 0;
+  savepointId = 0;
+  constructor(database) {
+    this.database = database;
+  }
+  exec(sql) {
+    return this.database.exec(sql);
+  }
+  query(sql) {
+    const prepared = prepareNodeSqliteSql(sql);
+    return new NodeSqliteStatementAdapter(this.database.prepare(prepared.sql), prepared.numberedParamIndexes);
+  }
+  close() {
+    this.database.close();
+  }
+  transaction(callback) {
+    return (...args) => {
+      if (this.transactionDepth > 0) {
+        return this.runSavepoint(callback, args);
+      }
+      this.database.exec("BEGIN IMMEDIATE;");
+      this.transactionDepth += 1;
+      try {
+        const result = callback(...args);
+        this.database.exec("COMMIT;");
+        return result;
+      } catch (error) {
+        this.database.exec("ROLLBACK;");
+        throw error;
+      } finally {
+        this.transactionDepth -= 1;
+      }
+    };
+  }
+  runSavepoint(callback, args) {
+    const savepointName = `openscout_nested_${this.savepointId++}`;
+    this.database.exec(`SAVEPOINT ${savepointName};`);
+    this.transactionDepth += 1;
+    try {
+      const result = callback(...args);
+      this.database.exec(`RELEASE SAVEPOINT ${savepointName};`);
+      return result;
+    } catch (error) {
+      this.database.exec(`ROLLBACK TO SAVEPOINT ${savepointName};`);
+      this.database.exec(`RELEASE SAVEPOINT ${savepointName};`);
+      throw error;
+    } finally {
+      this.transactionDepth -= 1;
+    }
+  }
+}
+
 // packages/runtime/src/support-paths.ts
 import { homedir } from "os";
 import { join } from "path";
@@ -787,7 +972,7 @@ var SCOUT_HOST_PROBE_SCHEMA_VERSIONS = {
   "git.mergeBase": 1,
   "git.logLastCommitUnix": 1,
   "git.worktreeListPorcelain": 1,
-  "tmux.sessions": 1,
+  "tmux.sessions": 2,
   "tmux.panes": 1,
   "zellij.sessions": 1,
   "ps.runtime": 1,
@@ -1546,6 +1731,8 @@ var tailscaleStatusProbe = defineProbe({
 
 // packages/runtime/src/tailscale.ts
 var DEFAULT_TAILSCALE_STATUS_TIMEOUT_MS2 = 1500;
+var SYNC_TAILSCALE_STATUS_CACHE_MS = 30000;
+var syncStatusCache = null;
 function readStatusJsonFromFileSync(filePath) {
   const raw = readFileSync2(filePath, "utf8");
   return parseTailscaleStatusJson(raw);
@@ -1570,6 +1757,15 @@ function readStatusJsonSync(env = process.env) {
   if (!tailscaleBin) {
     return null;
   }
+  const cacheKey = [
+    tailscaleBin,
+    env.OPENSCOUT_TAILSCALE_AUTO_HOSTS ?? "",
+    env.OPENSCOUT_TAILSCALE_STATUS_TIMEOUT_MS ?? ""
+  ].join("\x00");
+  const cached = syncStatusCache;
+  if (env === process.env && cached?.key === cacheKey && Date.now() - cached.at < SYNC_TAILSCALE_STATUS_CACHE_MS) {
+    return cached.value;
+  }
   try {
     const stdout = execFileSync(tailscaleBin, ["status", "--json"], {
       encoding: "utf8",
@@ -1577,8 +1773,13 @@ function readStatusJsonSync(env = process.env) {
       timeout: statusTimeoutMs2(env),
       windowsHide: true
     });
-    return parseTailscaleStatusJson(stdout);
+    const value = parseTailscaleStatusJson(stdout);
+    if (env === process.env)
+      syncStatusCache = { key: cacheKey, at: Date.now(), value };
+    return value;
   } catch {
+    if (env === process.env)
+      syncStatusCache = { key: cacheKey, at: Date.now(), value: null };
     return null;
   }
 }
@@ -1798,44 +1999,6 @@ function findExecutableOnSearchPath(name, env) {
   return null;
 }
 
-// packages/runtime/src/runtime-adapters.ts
-function normalizeRuntimeHost(value) {
-  const normalized = value?.trim().toLowerCase();
-  if (normalized === "bun")
-    return "bun";
-  if (normalized === "node")
-    return "node";
-  return null;
-}
-function normalizeRuntimeServiceAdapter(value) {
-  const normalized = value?.trim().toLowerCase().replaceAll("_", "-");
-  if (normalized === "macos-scoutd" || normalized === "macos-launchd")
-    return "macos-scoutd";
-  if (normalized === "linux-systemd-user" || normalized === "systemd-user")
-    return "linux-systemd-user";
-  if (normalized === "headless-foreground" || normalized === "foreground" || normalized === "headless") {
-    return "headless-foreground";
-  }
-  if (normalized === "windows-service")
-    return "windows-service";
-  return null;
-}
-function defaultServiceAdapterForPlatform(platform = process.platform, env = process.env) {
-  const explicit = normalizeRuntimeServiceAdapter(env.OPENSCOUT_SERVICE_ADAPTER);
-  if (explicit)
-    return explicit;
-  if (normalizeRuntimeHost(env.OPENSCOUT_RUNTIME_HOST) === "node") {
-    return "headless-foreground";
-  }
-  if (platform === "darwin")
-    return "macos-scoutd";
-  if (platform === "linux")
-    return "headless-foreground";
-  if (platform === "win32")
-    return "windows-service";
-  return "headless-foreground";
-}
-
 // packages/runtime/src/broker-process-manager.ts
 function isTmpPath(p) {
   return /^\/(?:private\/)?tmp\//.test(p);
@@ -2001,12 +2164,12 @@ function resolveBrokerServiceLabel(mode) {
   }
   switch (mode) {
     case "prod":
-      return "com.openscout";
+      return "app.openscout";
     case "custom":
-      return "com.openscout.custom";
+      return "app.openscout.custom";
     case "dev":
     default:
-      return "dev.openscout";
+      return "app.openscout";
   }
 }
 function resolveBrokerServiceConfig() {
@@ -2173,13 +2336,16 @@ function readRuntimeFreshness(value) {
     state,
     intentional: readBoolean(value.intentional) ?? false,
     basis,
+    reasonCode: readString2(value.reasonCode) ?? null,
     artifactCommit: readString2(value.artifactCommit) ?? null,
     expectedCommit: readString2(value.expectedCommit) ?? null,
     pin: readString2(value.pin) ?? null,
     pinReason: readString2(value.pinReason) ?? null,
     manifestPath: readString2(value.manifestPath) ?? null,
     version: readString2(value.version) ?? null,
-    builtAt: readString2(value.builtAt) ?? null,
+    actualBuiltAt: readString2(value.actualBuiltAt) ?? readString2(value.builtAt) ?? null,
+    expectedBuiltAt: readString2(value.expectedBuiltAt) ?? null,
+    builtAt: readString2(value.builtAt) ?? readString2(value.actualBuiltAt) ?? null,
     sourceDirty: readBoolean(value.sourceDirty) ?? null,
     detail
   };
@@ -2309,7 +2475,30 @@ function spawnScoutdJson(scoutdPath, command, env, timeoutMs) {
     });
   });
 }
+var SCHEMA_GUARDED_SERVICE_COMMANDS = new Set([
+  "install",
+  "start",
+  "restart"
+]);
+function assertBrokerServiceSchemaCompatible(config) {
+  const databasePath = join5(config.controlHome, "control-plane.sqlite");
+  if (!existsSync5(databasePath))
+    return;
+  const database = openControlPlaneSqliteDatabase(databasePath, { readonly: true });
+  try {
+    const row = database.query("PRAGMA user_version").get();
+    const databaseVersion = row?.user_version ?? 0;
+    if (databaseVersion > CONTROL_PLANE_SCHEMA_VERSION) {
+      throw new Error(`Refusing to change the Scout service: candidate runtime schema v${CONTROL_PLANE_SCHEMA_VERSION} ` + `is older than control-plane database schema v${databaseVersion}. ` + "The existing service was left untouched. Update or rebase this checkout before restarting Scout.");
+    }
+  } finally {
+    database.close?.();
+  }
+}
 async function runScoutdServiceCommand(command, config, timeoutMs = SCOUTD_DEFAULT_TIMEOUT_MS, runScoutdJson = spawnScoutdJson) {
+  if (SCHEMA_GUARDED_SERVICE_COMMANDS.has(command)) {
+    assertBrokerServiceSchemaCompatible(config);
+  }
   const scoutd = resolveScoutdCommand(config);
   if (!scoutd) {
     throw new Error("Unable to locate scoutd for broker service management. Build scoutd with `npm run scoutd:build`, install a package that includes scoutd, or set OPENSCOUT_SCOUTD_BIN.");
@@ -2544,6 +2733,9 @@ function formatBrokerServiceStatus(status) {
   ];
   if (status.runtimeFreshness) {
     lines.push(`runtime freshness detail: ${status.runtimeFreshness.detail}`);
+    if (status.runtimeFreshness.reasonCode) {
+      lines.push(`runtime freshness reason: ${status.runtimeFreshness.reasonCode}`);
+    }
   }
   if (status.health.socketFallbackError) {
     lines.push(`socket fallback: ${status.health.socketFallbackError}`);