negotium 0.2.14 → 0.2.15

package/dist/runtime-helpers.js

@@ -354,6 +354,74 @@ var defaultLifecycle = createLifecycleManager({
 });
 var onShutdown = defaultLifecycle.onShutdown;
 var runShutdown = defaultLifecycle.runShutdown;
+// ../../packages/core/src/runtime/bashrs-completions.ts
+import {
+  closeSync as closeSync2,
+  openSync as openSync2,
+  readdirSync,
+  readFileSync as readFileSync3,
+  readSync,
+  renameSync as renameSync2,
+  rmSync,
+  statSync as statSync2
+} from "fs";
+import { join as join4 } from "path";
+
+// ../../packages/core/src/outbox/utils.ts
+import { mkdirSync as mkdirSync2, watch } from "fs";
+var FALLBACK_INTERVAL_MS = 5000;
+function createOutboxWatchOps(host) {
+  function debouncedFlush(fn, label, delayMs) {
+    let timer = null;
+    let running = false;
+    let pending = false;
+    async function run() {
+      if (running) {
+        pending = true;
+        return;
+      }
+      while (true) {
+        running = true;
+        pending = false;
+        try {
+          await fn();
+        } catch (e) {
+          host.logger.error({ err: e }, `${label}: Unhandled error`);
+        } finally {
+          running = false;
+        }
+        if (!pending)
+          break;
+      }
+    }
+    return () => {
+      if (timer)
+        clearTimeout(timer);
+      timer = setTimeout(() => {
+        timer = null;
+        run();
+      }, delayMs);
+    };
+  }
+  function watchDir(dir, onChange) {
+    try {
+      mkdirSync2(dir, { recursive: true });
+      const watcher = watch(dir, { recursive: true }, () => onChange());
+      watcher.on("error", (e) => {
+        host.logger.warn({ err: e, dir }, "outbox: fs.watch error");
+      });
+      return watcher;
+    } catch (e) {
+      host.logger.warn({ err: e, dir }, "outbox: Failed to watch dir");
+      return null;
+    }
+  }
+  return { debouncedFlush, watchDir };
+}
+var defaultWatchOps = createOutboxWatchOps({ logger });
+var debouncedFlush = defaultWatchOps.debouncedFlush;
+var watchDir = defaultWatchOps.watchDir;
+
 // ../../packages/core/src/platform/config.ts
 import { execFileSync } from "child_process";
 import { randomBytes } from "crypto";
@@ -362,7 +430,7 @@ import {
   chmodSync,
   constants,
   existsSync,
-  mkdirSync as mkdirSync2,
+  mkdirSync as mkdirSync3,
   readFileSync as readFileSync2,
   writeFileSync as writeFileSync2
 } from "fs";
@@ -533,7 +601,7 @@ var BG_BASH_MAX_PORT = parsePortEnv(process.env.BG_BASH_MAX_PORT, 9799);
 function loadOrCreateLocalSecret(envKey, filename, options = {}) {
   const envValue = envText(envKey);
   const secretFile = resolve(SECRETS_DIR, filename);
-  mkdirSync2(dirname2(secretFile), { recursive: true });
+  mkdirSync3(dirname2(secretFile), { recursive: true });
   if (envValue) {
     if (options.persistEnvValue) {
       writeFileSync2(secretFile, `${envValue}
@@ -587,27 +655,27 @@ var BASHRS_SPILL_ROOT = resolve(RUN_DIR, "bashrs");
 var PLAYWRIGHT_BASE_PORT = parsePortEnv(process.env.PLAYWRIGHT_BASE_PORT, 9100);
 var PLAYWRIGHT_MAX_PORT = parsePortEnv(process.env.PLAYWRIGHT_MAX_PORT, 9499);
 var PLAYWRIGHT_PORTS_DIR = resolve(RUN_DIR, "playwright-ports");
-mkdirSync2(STATE_DIR, { recursive: true });
-mkdirSync2(DATA_DIR, { recursive: true });
-mkdirSync2(UPLOADS_DIR, { recursive: true });
-mkdirSync2(VAULT_DIR, { recursive: true, mode: 448 });
-mkdirSync2(LOG_DIR, { recursive: true });
-mkdirSync2(PROGRESS_DIR, { recursive: true });
-mkdirSync2(DM_CMD_DIR, { recursive: true });
-mkdirSync2(DM_RESP_DIR, { recursive: true });
-mkdirSync2(SESSION_INBOX_DIR, { recursive: true });
-mkdirSync2(SESSION_ASKS_DIR, { recursive: true });
-mkdirSync2(PLAYWRIGHT_PORTS_DIR, { recursive: true });
-mkdirSync2(WORKSPACE_DIR, { recursive: true });
-mkdirSync2(TOPIC_WORKSPACE_DIR, { recursive: true });
-mkdirSync2(SHARED_WIKI_DIR, { recursive: true });
-mkdirSync2(CRON_WORKSPACE_DIR, { recursive: true });
-mkdirSync2(DM_WORKSPACE_DIR, { recursive: true });
-mkdirSync2(SESSION_WORKSPACE_DIR, { recursive: true });
-mkdirSync2(BROWSER_DIR, { recursive: true });
-mkdirSync2(BROWSER_PROFILES_DIR, { recursive: true });
-mkdirSync2(BINARIES_DIR, { recursive: true });
-mkdirSync2(SECRETS_DIR, { recursive: true, mode: 448 });
+mkdirSync3(STATE_DIR, { recursive: true });
+mkdirSync3(DATA_DIR, { recursive: true });
+mkdirSync3(UPLOADS_DIR, { recursive: true });
+mkdirSync3(VAULT_DIR, { recursive: true, mode: 448 });
+mkdirSync3(LOG_DIR, { recursive: true });
+mkdirSync3(PROGRESS_DIR, { recursive: true });
+mkdirSync3(DM_CMD_DIR, { recursive: true });
+mkdirSync3(DM_RESP_DIR, { recursive: true });
+mkdirSync3(SESSION_INBOX_DIR, { recursive: true });
+mkdirSync3(SESSION_ASKS_DIR, { recursive: true });
+mkdirSync3(PLAYWRIGHT_PORTS_DIR, { recursive: true });
+mkdirSync3(WORKSPACE_DIR, { recursive: true });
+mkdirSync3(TOPIC_WORKSPACE_DIR, { recursive: true });
+mkdirSync3(SHARED_WIKI_DIR, { recursive: true });
+mkdirSync3(CRON_WORKSPACE_DIR, { recursive: true });
+mkdirSync3(DM_WORKSPACE_DIR, { recursive: true });
+mkdirSync3(SESSION_WORKSPACE_DIR, { recursive: true });
+mkdirSync3(BROWSER_DIR, { recursive: true });
+mkdirSync3(BROWSER_PROFILES_DIR, { recursive: true });
+mkdirSync3(BINARIES_DIR, { recursive: true });
+mkdirSync3(SECRETS_DIR, { recursive: true, mode: 448 });
 var ACTIVE_QUERY_STALE_MS = 10 * 60 * 1000;
 var AGENTS_PROMPTS_DIR = resolve(PROJECT_ROOT, "src/prompts/agents");
 var RESOURCES_DIR = resolve(PROJECT_ROOT, "src/resources");
@@ -630,10 +698,19 @@ var PDFTOTEXT_BIN = envText("PDFTOTEXT_BIN") ?? "pdftotext";
 var _envMaxTellDepth = Number.parseInt(process.env.MAX_TELL_DEPTH ?? "", 10);
 var MAX_TELL_DEPTH = Number.isInteger(_envMaxTellDepth) && _envMaxTellDepth > 0 ? _envMaxTellDepth : 20;
 
+// ../../packages/core/src/query/session-inbox-path.ts
+import { join as join2 } from "path";
+var TOPIC_ID_FILE_PREFIX = "topic-id-";
+var JSONL_SUFFIX = ".jsonl";
+function sessionInboxPath(userId, topicId) {
+  const key = Buffer.from(topicId, "utf8").toString("base64url");
+  return join2(SESSION_INBOX_DIR, userId, `${TOPIC_ID_FILE_PREFIX}${key}${JSONL_SUFFIX}`);
+}
+
 // ../../packages/core/src/storage/storage-host.ts
-import { mkdirSync as mkdirSync3 } from "fs";
+import { mkdirSync as mkdirSync4 } from "fs";
 import { homedir as homedir2 } from "os";
-import { dirname as dirname3, join as join2, resolve as resolve2 } from "path";
+import { dirname as dirname3, join as join3, resolve as resolve2 } from "path";
 
 // ../../packages/core/src/storage/sqlite.ts
 var isBun = typeof process.versions.bun === "string";
@@ -698,13 +775,13 @@ function envPath(name, fallback) {
   return resolve2(value || fallback);
 }
 function defaultStateDir() {
-  return envPath("NEGOTIUM_STATE_DIR", join2(homedir2(), ".negotium"));
+  return envPath("NEGOTIUM_STATE_DIR", join3(homedir2(), ".negotium"));
 }
 function defaultDataDir() {
-  return envPath("NEGOTIUM_DATA_DIR", join2(defaultStateDir(), "data"));
+  return envPath("NEGOTIUM_DATA_DIR", join3(defaultStateDir(), "data"));
 }
 function defaultSessionsDatabasePath() {
-  return envPath("SESSIONS_DB_PATH", join2(resolveStorageDataDir(), "sessions.db"));
+  return envPath("SESSIONS_DB_PATH", join3(resolveStorageDataDir(), "sessions.db"));
 }
 var SQLITE_INIT_RETRY_MS = 25;
 var SQLITE_INIT_TIMEOUT_MS = 5000;
@@ -741,7 +818,7 @@ function defaultDatabase() {
     return fallbackDatabase;
   if (fallbackDatabase)
     fallbackDatabase.close();
-  mkdirSync3(dirname3(path), { recursive: true });
+  mkdirSync4(dirname3(path), { recursive: true });
   fallbackDatabase = new Database(path, { create: true });
   fallbackDatabasePath = path;
   initializeDatabase(fallbackDatabase);
@@ -799,6 +876,340 @@ var internalStorageDatabase = new Proxy({}, {
 // ../../packages/core/src/storage/forum-db.ts
 var db = internalStorageDatabase;
 
+// ../../packages/core/src/storage/runtime-leases.ts
+import { randomUUID } from "crypto";
+
+// ../../packages/core/src/storage/runtime-topic-state.ts
+registerStorageSchemaInitializer((database) => {
+  database.exec(`
+    CREATE TABLE IF NOT EXISTS runtime_topic_state (
+      topic_id TEXT PRIMARY KEY,
+      epoch INTEGER NOT NULL DEFAULT 0,
+      maintenance INTEGER NOT NULL DEFAULT 0 CHECK (maintenance IN (0, 1)),
+      maintenance_owner TEXT,
+      heartbeat_at INTEGER
+    )
+  `);
+}, 32);
+
+// ../../packages/core/src/storage/runtime-leases.ts
+var RUNTIME_INSTANCE_ID = `${process.pid}-${randomUUID()}`;
+registerStorageSchemaInitializer((database) => {
+  database.exec(`
+    CREATE TABLE IF NOT EXISTS runtime_turn_leases (
+      topic_id TEXT PRIMARY KEY,
+      query_id TEXT NOT NULL UNIQUE,
+      owner_id TEXT NOT NULL,
+      origin TEXT NOT NULL,
+      started_at INTEGER NOT NULL,
+      heartbeat_at INTEGER NOT NULL,
+      abort_requested INTEGER NOT NULL DEFAULT 0 CHECK (abort_requested IN (0, 1)),
+      abort_reason TEXT CHECK (abort_reason IS NULL OR abort_reason IN ('internal', 'external'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_runtime_turn_leases_heartbeat ON runtime_turn_leases(heartbeat_at);
+  `);
+}, 33);
+
+// ../../packages/core/src/storage/runtime-process-leases.ts
+var PROCESS_LEASE_STALE_MS = 5000;
+var PROCESS_LEASE_HEARTBEAT_MS = 1000;
+registerStorageSchemaInitializer((database) => {
+  database.exec(`
+    CREATE TABLE IF NOT EXISTS runtime_process_leases (
+      role TEXT PRIMARY KEY,
+      owner_id TEXT NOT NULL UNIQUE,
+      pid INTEGER NOT NULL,
+      started_at INTEGER NOT NULL,
+      heartbeat_at INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_runtime_process_leases_heartbeat ON runtime_process_leases(heartbeat_at);
+  `);
+}, 34);
+function rowToLease(row) {
+  return {
+    role: row.role,
+    ownerId: row.owner_id,
+    pid: Number(row.pid),
+    startedAt: Number(row.started_at),
+    heartbeatAt: Number(row.heartbeat_at)
+  };
+}
+function isProcessAlive(pid) {
+  if (!Number.isSafeInteger(pid) || pid <= 0)
+    return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code !== "ESRCH";
+  }
+}
+function removeDeadRuntimeProcessLease(role) {
+  const row = db.query("SELECT * FROM runtime_process_leases WHERE role = ?").get(role);
+  if (!row)
+    return;
+  const lease = rowToLease(row);
+  if (isProcessAlive(lease.pid))
+    return;
+  db.query(`DELETE FROM runtime_process_leases
+     WHERE role = ? AND owner_id = ? AND pid = ? AND heartbeat_at = ?`).run(lease.role, lease.ownerId, lease.pid, lease.heartbeatAt);
+}
+function heartbeatRuntimeProcessLease(role, ownerId, now = Date.now()) {
+  const result = db.query(`UPDATE runtime_process_leases
+       SET heartbeat_at = ?
+       WHERE role = ? AND owner_id = ?`).run(now, role, ownerId);
+  return Number(result.changes ?? 0) > 0;
+}
+function releaseRuntimeProcessLease(role, ownerId) {
+  const result = db.query("DELETE FROM runtime_process_leases WHERE role = ? AND owner_id = ?").run(role, ownerId);
+  return Number(result.changes ?? 0) > 0;
+}
+function acquireRuntimeProcessLease(role, options = {}) {
+  const normalizedRole = role.trim();
+  if (!normalizedRole)
+    throw new Error("runtime process lease role must not be empty");
+  removeDeadRuntimeProcessLease(normalizedRole);
+  const ownerId = options.ownerId ?? `${RUNTIME_INSTANCE_ID}:${normalizedRole}`;
+  const pid = options.pid ?? process.pid;
+  const now = options.now ?? Date.now();
+  const staleMs = options.staleMs ?? PROCESS_LEASE_STALE_MS;
+  const result = db.query(`INSERT INTO runtime_process_leases (role, owner_id, pid, started_at, heartbeat_at)
+       VALUES (?, ?, ?, ?, ?)
+       ON CONFLICT(role) DO UPDATE SET
+         owner_id = excluded.owner_id,
+         pid = excluded.pid,
+         started_at = excluded.started_at,
+         heartbeat_at = excluded.heartbeat_at
+       WHERE runtime_process_leases.heartbeat_at < ?`).run(normalizedRole, ownerId, pid, now, now, now - staleMs);
+  if (Number(result.changes ?? 0) === 0)
+    return null;
+  let stopped = false;
+  const heartbeatMs = options.heartbeatMs ?? PROCESS_LEASE_HEARTBEAT_MS;
+  const timer = setInterval(() => {
+    if (stopped)
+      return;
+    if (heartbeatRuntimeProcessLease(normalizedRole, ownerId))
+      return;
+    stopped = true;
+    clearInterval(timer);
+    options.onLost?.();
+  }, heartbeatMs);
+  timer.unref?.();
+  return {
+    role: normalizedRole,
+    ownerId,
+    pid,
+    startedAt: now,
+    heartbeatAt: now,
+    stop() {
+      if (stopped)
+        return;
+      stopped = true;
+      clearInterval(timer);
+      releaseRuntimeProcessLease(normalizedRole, ownerId);
+    }
+  };
+}
+
+// ../../packages/core/src/runtime/bashrs-completions.ts
+var defaultSink = ({ userId, topicId, bashId, message }) => {
+  appendJsonlEntry(sessionInboxPath(userId, topicId), {
+    type: "tell",
+    from: "__bg_bash__",
+    message,
+    depth: 0,
+    requestId: bashId,
+    timestamp: new Date().toISOString()
+  });
+};
+var completionSink = defaultSink;
+function setBashrsCompletionSink(sink) {
+  completionSink = sink ?? defaultSink;
+}
+var PROCESS_ROLE = "worker:bashrs-completions";
+var RETENTION_MS = 15 * 60000;
+var TAIL_BYTES = 8 * 1024;
+function isJobResult(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const v = value;
+  return typeof v.bash_id === "string" && typeof v.owner === "string";
+}
+function readTail(filePath) {
+  try {
+    const { size } = statSync2(filePath);
+    const fd = openSync2(filePath, "r");
+    try {
+      const start = Math.max(0, size - TAIL_BYTES);
+      const buf = Buffer.alloc(size - start);
+      readSync(fd, buf, 0, buf.length, start);
+      return { text: buf.toString("utf8"), truncated: start > 0 };
+    } finally {
+      closeSync2(fd);
+    }
+  } catch {
+    return { text: "", truncated: false };
+  }
+}
+function buildMessage(dir, result) {
+  const stdout = readTail(join4(dir, "stdout.log"));
+  const stderr = readTail(join4(dir, "stderr.log"));
+  const parts = [];
+  if (stdout.text.trim() || stdout.truncated) {
+    parts.push(`stdout${stdout.truncated ? ` (truncated, full output: ${join4(dir, "stdout.log")})` : ""}:
+${stdout.text.trim()}`);
+  }
+  if (stderr.text.trim() || stderr.truncated) {
+    parts.push(`stderr${stderr.truncated ? ` (truncated, full output: ${join4(dir, "stderr.log")})` : ""}:
+${stderr.text.trim()}`);
+  }
+  const header = watchHeader(result) ?? `[background_bash ${result.bash_id} finished]`;
+  const exitLine = result.unknown ? "exit code: unknown (bash-rs restarted while this job was running)" : `exit code: ${result.exit_code ?? "unknown"}`;
+  return `${header}
+${exitLine}
+${parts.join(`
+`) || "(no output)"}`;
+}
+function watchHeader(result) {
+  if (result.matched_line) {
+    return `[background_bash_watch ${result.bash_id} matched]
+matched line: ${result.matched_line.slice(0, 500)}`;
+  }
+  if (result.watch_outcome === "timeout") {
+    return `[background_bash_watch ${result.bash_id} timed out without a match]`;
+  }
+  if (result.watch_outcome === "exited") {
+    return `[background_bash_watch ${result.bash_id} exited before matching]`;
+  }
+  return null;
+}
+function parseOwner(owner) {
+  const nul = owner.indexOf("\x00");
+  if (nul < 0)
+    return null;
+  const userId = owner.slice(0, nul);
+  const topicId = owner.slice(nul + 1);
+  if (!userId || !topicId)
+    return null;
+  return { userId, topicId };
+}
+function injectedMarker(dir) {
+  return join4(dir, "result.json.injected");
+}
+async function flushBashrsCompletions() {
+  let entries;
+  try {
+    entries = readdirSync(BASHRS_SPILL_ROOT);
+  } catch {
+    return;
+  }
+  const now = Date.now();
+  for (const bashId of entries) {
+    const dir = join4(BASHRS_SPILL_ROOT, bashId);
+    const resultPath = join4(dir, "result.json");
+    const marker = injectedMarker(dir);
+    try {
+      const markerStat = statSync2(marker);
+      if (now - markerStat.mtimeMs > RETENTION_MS) {
+        rmSync(dir, { recursive: true, force: true });
+      }
+      continue;
+    } catch {}
+    let raw;
+    try {
+      raw = readFileSync3(resultPath, "utf8");
+    } catch {
+      continue;
+    }
+    let result;
+    try {
+      result = JSON.parse(raw);
+    } catch (err) {
+      logger.warn({ err, dir }, "bashrs-completions: corrupt result.json, skipping");
+      continue;
+    }
+    if (!isJobResult(result)) {
+      logger.warn({ dir }, "bashrs-completions: result.json missing bash_id/owner, skipping");
+      continue;
+    }
+    const parsed = parseOwner(result.owner);
+    if (!parsed) {
+      continue;
+    }
+    try {
+      completionSink({
+        userId: parsed.userId,
+        topicId: parsed.topicId,
+        bashId: result.bash_id,
+        message: buildMessage(dir, result)
+      });
+      renameSync2(resultPath, marker);
+      logger.info({ bashId: result.bash_id, userId: parsed.userId, topicId: parsed.topicId }, "bashrs-completions: delivered");
+    } catch (err) {
+      logger.warn({ err, dir }, "bashrs-completions: delivery failed, will retry");
+    }
+  }
+}
+var watcher = null;
+var fallbackTimer = null;
+var debouncedTrigger = null;
+var leadershipTimer = null;
+var workerLease = null;
+var workerStarted = false;
+function stopLeaderResources() {
+  if (watcher) {
+    watcher.close();
+    watcher = null;
+  }
+  if (fallbackTimer) {
+    clearInterval(fallbackTimer);
+    fallbackTimer = null;
+  }
+  debouncedTrigger = null;
+}
+function tryBecomeLeader() {
+  if (!workerStarted || workerLease)
+    return;
+  const acquired = acquireRuntimeProcessLease(PROCESS_ROLE, {
+    onLost: () => {
+      if (workerLease !== acquired)
+        return;
+      workerLease = null;
+      stopLeaderResources();
+      logger.warn("bashrs-completions: worker leadership lost");
+    }
+  });
+  if (!acquired)
+    return;
+  workerLease = acquired;
+  debouncedTrigger = debouncedFlush(flushBashrsCompletions, "bashrs-completions", 200);
+  watcher = watchDir(BASHRS_SPILL_ROOT, () => debouncedTrigger?.());
+  fallbackTimer = setInterval(() => debouncedTrigger?.(), FALLBACK_INTERVAL_MS);
+  fallbackTimer.unref?.();
+  logger.info({ dir: BASHRS_SPILL_ROOT, role: PROCESS_ROLE }, "bashrs-completions: worker leadership acquired");
+  flushBashrsCompletions();
+}
+function startBashrsCompletionsWorker() {
+  if (workerStarted)
+    return () => {};
+  workerStarted = true;
+  tryBecomeLeader();
+  leadershipTimer = setInterval(tryBecomeLeader, PROCESS_LEASE_HEARTBEAT_MS);
+  leadershipTimer.unref?.();
+  return () => {
+    if (!workerStarted)
+      return;
+    workerStarted = false;
+    if (leadershipTimer) {
+      clearInterval(leadershipTimer);
+      leadershipTimer = null;
+    }
+    stopLeaderResources();
+    workerLease?.stop();
+    workerLease = null;
+    logger.info("bashrs-completions: worker stopped");
+  };
+}
 // ../../packages/core/src/storage/api-messages.ts
 function initializeApiMessagesSchema() {
   db.exec(`
@@ -1099,7 +1510,9 @@ export {
   topicAppLink,
   textResult,
   taskPanelMessageId,
+  startBashrsCompletionsWorker,
   shouldWarnForContext,
+  setBashrsCompletionSink,
   sanitizeTopicName,
   sanitizeId,
   sanitizeFileName,
@@ -1145,4 +1558,4 @@ export {
   CLAUDE_EFFORT_VALUES
 };
 
-//# debugId=856D33930FED17E364756E2164756E21
+//# debugId=A7EE5EAA6DA08CC064756E2164756E21