negotium 0.1.37 → 0.1.39

package/dist/query-runtime.js

@@ -429,6 +429,7 @@ var AbortReason;
   AbortReason2["None"] = "none";
   AbortReason2["Internal"] = "internal";
   AbortReason2["External"] = "external";
+  AbortReason2["Infrastructure"] = "infrastructure";
 })(AbortReason ||= {});
 
 // ../../packages/core/src/query/active-rooms.ts
@@ -590,15 +591,323 @@ var interSessionQueue = new InterSessionQueue;
 function wsAbortReason(reason) {
   return reason === "internal" /* Internal */ ? "superseded" : "stopped";
 }
+// ../../packages/core/src/query/state.ts
+import { mkdirSync as mkdirSync3, renameSync, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
+import { basename, join as join3 } from "path";
+
+// ../../packages/core/src/platform/config.ts
+import { execFileSync } from "child_process";
+import { randomBytes } from "crypto";
+import {
+  accessSync,
+  chmodSync,
+  constants,
+  existsSync,
+  mkdirSync as mkdirSync2,
+  readFileSync,
+  writeFileSync
+} from "fs";
+import { homedir as homedir2 } from "os";
+import { dirname as dirname2, join as join2, resolve as resolve2 } from "path";
+import { fileURLToPath } from "url";
+
+// ../../packages/core/src/platform/config-helpers.ts
+function readEnvText(env, key) {
+  const value = env[key]?.trim();
+  return value || undefined;
+}
+function parseRuntimePort(value, fallback) {
+  if (!value)
+    return fallback;
+  const port = Number.parseInt(value, 10);
+  return Number.isInteger(port) && port > 0 && port <= 65535 ? port : fallback;
+}
+
+// ../../packages/core/src/types.ts
+var SUPPORTED_AGENTS = ["maestro", "claude", "codex"];
+function isAgentKind(value) {
+  return typeof value === "string" && SUPPORTED_AGENTS.includes(value);
+}
+
+// ../../packages/core/src/platform/config.ts
+function envText(envKey) {
+  return readEnvText(process.env, envKey);
+}
+function resolveAgentEnv(envKey, fallback, legacyEnvKey) {
+  const value = envText(envKey) ?? (legacyEnvKey ? envText(legacyEnvKey) : undefined);
+  return isAgentKind(value) ? value : fallback;
+}
+var HOME = homedir2();
+function resolveProjectRoot() {
+  const moduleDir = dirname2(fileURLToPath(import.meta.url));
+  const packagedRuntime = resolve2(moduleDir, "runtime");
+  if (existsSync(resolve2(packagedRuntime, "src")))
+    return packagedRuntime;
+  return resolve2(moduleDir, "../..");
+}
+var PROJECT_ROOT = resolveProjectRoot();
+function resolveDependencyBin(name) {
+  let dir = PROJECT_ROOT;
+  while (true) {
+    const candidate = resolve2(dir, "node_modules", ".bin", name);
+    if (existsSync(candidate))
+      return candidate;
+    const parent = dirname2(dir);
+    if (parent === dir)
+      return candidate;
+    dir = parent;
+  }
+}
+var STATE_DIR_ENV = envText("NEGOTIUM_STATE_DIR");
+var STATE_DIR = STATE_DIR_ENV ? resolve2(STATE_DIR_ENV) : resolve2(HOME, ".negotium");
+function resolveLocalStateDir(envKey, stateName) {
+  const envValue = envText(envKey);
+  if (envValue)
+    return resolve2(envValue);
+  return resolve2(STATE_DIR, stateName);
+}
+function parsePortEnv(envValue, fallback) {
+  return parseRuntimePort(envValue, fallback);
+}
+var WORKSPACE_DIR = resolveLocalStateDir("NEGOTIUM_WORKSPACE_DIR", "workspace");
+var TOPIC_WORKSPACE_DIR = resolve2(WORKSPACE_DIR, "topics");
+var SHARED_WIKI_DIR = resolve2(WORKSPACE_DIR, "wiki");
+var CONTEXTS_DIR = resolve2(WORKSPACE_DIR, "contexts");
+var BROWSER_PROFILES_DIR = resolve2(WORKSPACE_DIR, "browser-profiles");
+var DM_WORKSPACE_DIR = resolve2(WORKSPACE_DIR, "dm");
+var SESSION_WORKSPACE_DIR = resolve2(WORKSPACE_DIR, "sessions");
+var CLAUDE_EXECUTABLE_ENV = envText("NEGOTIUM_CLAUDE_EXECUTABLE");
+var CLAUDE_EXECUTABLE = CLAUDE_EXECUTABLE_ENV ? resolve2(CLAUDE_EXECUTABLE_ENV) : undefined;
+function resolveBrowserMcpBin(envValue) {
+  const override = envValue?.trim();
+  if (override) {
+    if (!/(^|\/)(mcp-patchright|mcp-patchright-http\.mjs)$/.test(override)) {
+      throw new Error("NEGOTIUM_BROWSER_MCP_BIN must point to the authenticated mcp-patchright wrapper.");
+    }
+    return override;
+  }
+  return PATCHRIGHT_MCP_BIN;
+}
+var PATCHRIGHT_MCP_BIN = resolve2(PROJECT_ROOT, "scripts/mcp-patchright-http.mjs");
+var PLAYWRIGHT_MCP_BIN = resolveBrowserMcpBin(envText("NEGOTIUM_BROWSER_MCP_BIN"));
+var BROWSER_RS_VERSION = "v0.1.13";
+var BROWSER_RS_MIN_SECURE_VERSION = "0.1.13";
+function versionAtLeast(actualVersion, minimumVersion) {
+  const actual = actualVersion.split(".").map(Number);
+  const minimum = minimumVersion.split(".").map(Number);
+  if (actual.some(Number.isNaN) || minimum.some(Number.isNaN))
+    return false;
+  for (let index = 0;index < minimum.length; index += 1) {
+    if ((actual[index] ?? 0) > (minimum[index] ?? 0))
+      return true;
+    if ((actual[index] ?? 0) < (minimum[index] ?? 0))
+      return false;
+  }
+  return true;
+}
+function browserRsMeetsMinimumVersion(candidate) {
+  try {
+    const output = execFileSync(candidate, ["--version"], {
+      encoding: "utf8",
+      timeout: 2000,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    const match = output.match(/^browser-rs (\d+)\.(\d+)\.(\d+)$/);
+    if (!match)
+      return false;
+    return versionAtLeast(match.slice(1).join("."), BROWSER_RS_MIN_SECURE_VERSION);
+  } catch {
+    return false;
+  }
+}
+function resolveBrowserRsBin(envValue) {
+  const override = envValue?.trim();
+  if (!override && !versionAtLeast(BROWSER_RS_VERSION.replace(/^v/, ""), BROWSER_RS_MIN_SECURE_VERSION)) {
+    return;
+  }
+  const candidate = override ? resolve2(override) : resolve2(STATE_DIR, "bin", "browser-rs", BROWSER_RS_VERSION, "browser-rs");
+  try {
+    accessSync(candidate, constants.X_OK);
+    return browserRsMeetsMinimumVersion(candidate) ? candidate : undefined;
+  } catch {
+    return;
+  }
+}
+var BROWSER_RS_BIN = resolveBrowserRsBin(envText("NEGOTIUM_BROWSER_RS_BIN"));
+var TSX_BIN = resolveDependencyBin("tsx");
+var TSCONFIG_PATH = resolve2(PROJECT_ROOT, "tsconfig.json");
+var SESSION_COMM_SERVER = resolve2(PROJECT_ROOT, "src/mcp/session-comm/server.ts");
+var TASK_SERVER = resolve2(PROJECT_ROOT, "src/mcp/task-server.ts");
+var BROWSER_MCP_SSE_PROXY_SERVER = resolve2(PROJECT_ROOT, "src/mcp/browser-sse-proxy-server.ts");
+var CANONICAL_MCP_PROXY_SERVER = resolve2(PROJECT_ROOT, "src/mcp/canonical-proxy-server.ts");
+var WIKI_SERVER = resolve2(PROJECT_ROOT, "src/mcp/wiki-server.ts");
+var TOKEN_STATS_SERVER = resolve2(PROJECT_ROOT, "src/mcp/token-stats-server.ts");
+var COMPACTION_LOG_SERVER = resolve2(PROJECT_ROOT, "src/mcp/compaction-log-server.ts");
+var SYSTEM_HEALTH_SERVER = resolve2(PROJECT_ROOT, "src/mcp/system-health-server.ts");
+var AGENT_HEALTH_SERVER = resolve2(PROJECT_ROOT, "src/mcp/agent-health-server.ts");
+var BACKGROUND_BASH_SERVER = resolve2(PROJECT_ROOT, "src/mcp/background-bash-server.ts");
+var VAULT_SERVER = resolve2(PROJECT_ROOT, "src/mcp/vault-server.ts");
+var BG_BASH_BASE_PORT = parsePortEnv(process.env.BG_BASH_BASE_PORT, 9700);
+var BG_BASH_MAX_PORT = parsePortEnv(process.env.BG_BASH_MAX_PORT, 9799);
+function loadOrCreateLocalSecret(envKey, filename, options = {}) {
+  const envValue = envText(envKey);
+  const secretFile = resolve2(STATE_DIR, filename);
+  mkdirSync2(dirname2(secretFile), { recursive: true });
+  if (envValue) {
+    if (options.persistEnvValue) {
+      writeFileSync(secretFile, `${envValue}
+`, { mode: 384 });
+      chmodSync(secretFile, 384);
+    }
+    return envValue;
+  }
+  if (existsSync(secretFile)) {
+    const stored = readFileSync(secretFile, "utf-8").trim();
+    if (stored) {
+      chmodSync(secretFile, 384);
+      return stored;
+    }
+  }
+  const secret = randomBytes(32).toString("base64url");
+  try {
+    writeFileSync(secretFile, `${secret}
+`, { mode: 384, flag: "wx" });
+    return secret;
+  } catch (error) {
+    if (error.code !== "EEXIST")
+      throw error;
+    const stored = readFileSync(secretFile, "utf-8").trim();
+    if (!stored)
+      throw new Error(`Secret file exists but is empty: ${secretFile}`);
+    chmodSync(secretFile, 384);
+    return stored;
+  }
+}
+var RUNTIME_MCP_SECRET = loadOrCreateLocalSecret("RUNTIME_MCP_SECRET", "runtime-mcp-secret");
+var NODE_CONTROL_TOKEN = loadOrCreateLocalSecret("NEGOTIUM_CONTROL_TOKEN", "node-control-token");
+var VAULT_MASTER_KEY = loadOrCreateLocalSecret("NEGOTIUM_VAULT_MASTER_KEY", "vault-master-key", { persistEnvValue: true });
+delete process.env.NEGOTIUM_VAULT_MASTER_KEY;
+var NEGOTIUM_PORT = parseInt(process.env.NEGOTIUM_PORT || "7777", 10);
+var hostname = process.env.HOSTNAME || "127.0.0.1";
+var DATA_DIR = resolveLocalStateDir("NEGOTIUM_DATA_DIR", "data");
+var LOG_DIR = resolveLocalStateDir("NEGOTIUM_LOG_DIR", "logs");
+var SESSIONS_DB = process.env.SESSIONS_DB_PATH ? resolve2(process.env.SESSIONS_DB_PATH) : resolve2(DATA_DIR, "sessions.db");
+var DEBUG_FILE = resolve2(DATA_DIR, "debug-users.json");
+var USERS_LOG_DIR = resolve2(DATA_DIR, "users");
+var RUN_DIR = resolveLocalStateDir("NEGOTIUM_RUN_DIR", "run");
+var PROGRESS_DIR = resolve2(RUN_DIR, "progress");
+var DM_CMD_DIR = resolve2(RUN_DIR, "dm-commands");
+var DM_RESP_DIR = resolve2(RUN_DIR, "dm-responses");
+var SESSION_INBOX_DIR = resolve2(RUN_DIR, "session-inbox");
+var SESSION_ASKS_DIR = resolve2(RUN_DIR, "session-asks");
+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 = resolve2(RUN_DIR, "playwright-ports");
+mkdirSync2(STATE_DIR, { recursive: true });
+mkdirSync2(DATA_DIR, { recursive: true });
+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(CONTEXTS_DIR, { recursive: true });
+mkdirSync2(BROWSER_PROFILES_DIR, { recursive: true });
+mkdirSync2(DM_WORKSPACE_DIR, { recursive: true });
+mkdirSync2(SESSION_WORKSPACE_DIR, { recursive: true });
+var ACTIVE_QUERY_STALE_MS = 10 * 60 * 1000;
+var AGENTS_PROMPTS_DIR = resolve2(PROJECT_ROOT, "src/prompts/agents");
+var RESOURCES_DIR = resolve2(PROJECT_ROOT, "src/resources");
+var FALLBACK_AGENT = resolveAgentEnv("FALLBACK_AGENT", "maestro", "DEFAULT_AGENT");
+var SESSION_AGENT = resolveAgentEnv("SESSION_AGENT", FALLBACK_AGENT);
+var GATEWAY_AGENT = resolveAgentEnv("GATEWAY_AGENT", FALLBACK_AGENT);
+var FALLBACK_MODEL = envText("FALLBACK_MODEL") ?? envText("DEFAULT_MODEL");
+function resolveModelEnv(envKey, agentConst) {
+  return envText(envKey) ?? (agentConst === FALLBACK_AGENT ? FALLBACK_MODEL : undefined);
+}
+var SESSION_MODEL = resolveModelEnv("SESSION_MODEL", SESSION_AGENT);
+var GATEWAY_MODEL = resolveModelEnv("GATEWAY_MODEL", GATEWAY_AGENT);
+var FFMPEG_BIN = envText("FFMPEG_BIN");
+var FFPROBE_BIN = envText("FFPROBE_BIN");
+var PYTHON_BIN = envText("PYTHON_BIN") ?? "python3";
+var FASTER_WHISPER_WRAPPER = envText("FASTER_WHISPER_WRAPPER") ?? resolve2(PROJECT_ROOT, "scripts/faster-whisper-wrapper.py");
+var WHISPER_MODEL = envText("WHISPER_MODEL_FILE") ?? "turbo";
+var TESSERACT_BIN = envText("TESSERACT_BIN") ?? "tesseract";
+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/security/sanitize.ts
+function sanitizeId(id) {
+  return id.replace(/[^a-zA-Z0-9_-]/g, "_") || "_";
+}
+
+// ../../packages/core/src/query/state.ts
+function createQueryStateStore(options) {
+  const sanitize = options.sanitizeTopicId ?? sanitizeId;
+  const queryStateDirPath = (userId) => join3(options.usersLogDir, String(userId), "active-queries");
+  const queryStateFile = (userId, topicId) => join3(queryStateDirPath(userId), `${sanitize(topicId)}.json`);
+  const legacyQueryStateFile = (userId, topicName) => {
+    if (!topicName || topicName === "." || topicName === ".." || basename(topicName) !== topicName) {
+      return null;
+    }
+    return join3(queryStateDirPath(userId), `${topicName}.json`);
+  };
+  return {
+    write(userId, topicId, topicName, task) {
+      const dir = queryStateDirPath(userId);
+      mkdirSync3(dir, { recursive: true });
+      const state = { topicId, topicName, since: new Date().toISOString() };
+      if (task)
+        state.task = [...task.replace(/\n+/g, " ").trim()].slice(0, 100).join("");
+      const target = queryStateFile(userId, topicId);
+      const tmp = `${target}.${process.pid}.${Date.now()}.tmp`;
+      writeFileSync2(tmp, JSON.stringify(state));
+      renameSync(tmp, target);
+    },
+    clear(userId, topicId, legacyTopicName) {
+      const paths = [
+        queryStateFile(userId, topicId),
+        legacyQueryStateFile(userId, legacyTopicName)
+      ].filter((path) => Boolean(path));
+      for (const path of new Set(paths)) {
+        try {
+          unlinkSync(path);
+        } catch (error) {
+          if (error?.code !== "ENOENT") {
+            options.logger?.warn({ err: error, userId, topicId, path }, "Failed to clear query state file");
+          }
+        }
+      }
+    }
+  };
+}
+var defaultQueryStateStore = createQueryStateStore({
+  usersLogDir: USERS_LOG_DIR,
+  logger
+});
+function writeQueryState(userId, topicId, topicName, task) {
+  defaultQueryStateStore.write(userId, topicId, topicName, task);
+}
+function clearQueryState(userId, topicId, legacyTopicName) {
+  defaultQueryStateStore.clear(userId, topicId, legacyTopicName);
+}
 export {
   wsAbortReason,
+  writeQueryState,
   isolatedTurnRoomId,
   isUserOrigin,
   isIsolatedTurnRoomId,
   createRoomQueryRegistry,
+  createQueryStateStore,
+  clearQueryState,
   InterSessionQueue,
   DeferredInjectBatcher,
   AbortReason
 };
 
-//# debugId=A26B022AD368149164756E2164756E21
+//# debugId=C8DEEEED5A27B0EF64756E2164756E21