mergen-server 1.4.0

package/dist/intelligence/arch-graph.js

@@ -0,0 +1,117 @@
+import fs from "fs";
+import path from "path";
+const IMPORT_RE = /(?:import|export)(?:[\s\S]*?\bfrom\b)?\s+['"]([^'"]+)['"]/g;
+function extractImports(source) {
+  const paths = [];
+  let m;
+  IMPORT_RE.lastIndex = 0;
+  while ((m = IMPORT_RE.exec(source)) !== null) {
+    paths.push(m[1]);
+  }
+  return paths;
+}
+function resolveImport(rawPath, importerDir) {
+  if (!rawPath.startsWith(".")) return null;
+  const withoutExt = rawPath.replace(/\.(js|ts|mjs)$/, "");
+  const candidates = [
+    path.resolve(importerDir, withoutExt + ".ts"),
+    path.resolve(importerDir, withoutExt, "index.ts")
+  ];
+  for (const c of candidates) {
+    if (fs.existsSync(c)) return c;
+  }
+  return null;
+}
+function collectTsFiles(dir, acc = []) {
+  if (!fs.existsSync(dir)) return acc;
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (["dist", "node_modules", "__stubs__", "evals"].includes(entry.name)) continue;
+      collectTsFiles(full, acc);
+    } else if (entry.isFile() && entry.name.endsWith(".ts") && !entry.name.endsWith(".d.ts")) {
+      acc.push(full);
+    }
+  }
+  return acc;
+}
+const _cache = /* @__PURE__ */ new Map();
+function buildGraph(srcDir) {
+  const cached = _cache.get(srcDir);
+  if (cached && Date.now() - cached.builtAt < 6e4) return cached;
+  const files = collectTsFiles(srcDir).sort();
+  const forward = /* @__PURE__ */ new Map();
+  const reverse = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    forward.set(file, /* @__PURE__ */ new Set());
+    reverse.set(file, /* @__PURE__ */ new Set());
+  }
+  for (const file of files) {
+    let source;
+    try {
+      source = fs.readFileSync(file, "utf8");
+    } catch {
+      continue;
+    }
+    const imports = extractImports(source);
+    for (const raw of imports) {
+      const resolved = resolveImport(raw, path.dirname(file));
+      if (!resolved || !forward.has(resolved)) continue;
+      forward.get(file).add(resolved);
+      reverse.get(resolved).add(file);
+    }
+  }
+  const graph = { root: srcDir, forward, reverse, files, builtAt: Date.now() };
+  _cache.set(srcDir, graph);
+  return graph;
+}
+function invalidateGraph(srcDir) {
+  _cache.delete(srcDir);
+}
+function queryGraph(graph, query) {
+  const { file, direction, maxDepth = 3 } = query;
+  const adjacency = direction === "depends-on" ? graph.forward : graph.reverse;
+  const direct = [...adjacency.get(file) ?? []];
+  const visited = /* @__PURE__ */ new Set([file]);
+  const frontier = [...direct];
+  const transitive = [];
+  let depth = 1;
+  while (frontier.length > 0 && depth < maxDepth) {
+    depth++;
+    const next = [];
+    for (const f of frontier) {
+      if (visited.has(f)) continue;
+      visited.add(f);
+      transitive.push(f);
+      const neighbors = adjacency.get(f) ?? /* @__PURE__ */ new Set();
+      for (const n of neighbors) {
+        if (!visited.has(n)) next.push(n);
+      }
+    }
+    frontier.length = 0;
+    frontier.push(...next);
+  }
+  return { file, direction, direct, transitive, depth };
+}
+function getZone(filePath) {
+  const p = filePath.replace(/\\/g, "/");
+  if (p.includes("/sensor/")) return "sensor";
+  if (p.includes("/intelligence/")) return "intelligence";
+  if (p.includes("/routes/")) return "routes";
+  if (p.includes("/datadog/")) return "datadog";
+  return "other";
+}
+const ZONE_DISPLAY = {
+  sensor: "Sensor (data ingestion / storage)",
+  intelligence: "Intelligence (MCP tools / analysis)",
+  routes: "Routes (Express handlers)",
+  datadog: "Datadog (external integration)",
+  other: "Other"
+};
+export {
+  ZONE_DISPLAY,
+  buildGraph,
+  getZone,
+  invalidateGraph,
+  queryGraph
+};

package/dist/intelligence/autonomy.js

@@ -0,0 +1,397 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { recordExecutionAudit } from "../sensor/audit-log.js";
+import { hasPermission } from "../sensor/rbac.js";
+import { getStores } from "../storage/store-registry.js";
+import logger from "../sensor/logger.js";
+import { SAFETY_POLICY_FILE } from "../sensor/paths.js";
+const DEFAULT_SAFETY_POLICY = {
+  // version 2: replaced overbroad bare-word 'delete' and 'truncate' with precise
+  // multi-word patterns ('delete from', 'truncate table') that don't false-positive
+  // on service names like 'delete-cache' or make targets like 'truncate-logs'.
+  // Database service names (postgres, mysql, redis, mongo) remain as they correctly
+  // block commands that target known production data stores by name.
+  version: 2,
+  blockedKeywords: [
+    "rm -rf",
+    "drop table",
+    "drop database",
+    "truncate table",
+    "delete from",
+    "kubectl delete",
+    "production-db",
+    "postgres",
+    "mysql",
+    "redis",
+    "mongo"
+  ],
+  blockedServices: [
+    "payments",
+    "auth-service",
+    "database"
+  ]
+};
+let _safetyPolicy = null;
+let _safetyPolicyWatcherStarted = false;
+function _watchSafetyPolicy() {
+  if (_safetyPolicyWatcherStarted) return;
+  _safetyPolicyWatcherStarted = true;
+  fs.watchFile(SAFETY_POLICY_FILE, { interval: 5e3, persistent: false }, () => {
+    _safetyPolicy = null;
+    logger.info({ path: SAFETY_POLICY_FILE }, "autonomy: safety-policy.json changed \u2014 reloading on next call");
+  });
+}
+function _resetSafetyPolicyForTesting(override) {
+  _safetyPolicy = override ?? null;
+}
+function loadSafetyPolicy(force = false) {
+  if (_safetyPolicy && !force) return _safetyPolicy;
+  _watchSafetyPolicy();
+  if (!fs.existsSync(SAFETY_POLICY_FILE)) {
+    try {
+      fs.mkdirSync(path.dirname(SAFETY_POLICY_FILE), { recursive: true });
+      fs.writeFileSync(SAFETY_POLICY_FILE, JSON.stringify(DEFAULT_SAFETY_POLICY, null, 2), "utf8");
+      logger.info({ path: SAFETY_POLICY_FILE }, "autonomy: created default safety-policy.json");
+    } catch (err) {
+      logger.warn({ err }, "autonomy: failed to write default safety policy");
+    }
+    _safetyPolicy = DEFAULT_SAFETY_POLICY;
+    return _safetyPolicy;
+  }
+  try {
+    const raw = fs.readFileSync(SAFETY_POLICY_FILE, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed && Array.isArray(parsed.blockedKeywords) && Array.isArray(parsed.blockedServices)) {
+      if ((parsed.version ?? 0) < DEFAULT_SAFETY_POLICY.version) {
+        logger.info(
+          { oldVersion: parsed.version ?? 0, newVersion: DEFAULT_SAFETY_POLICY.version, path: SAFETY_POLICY_FILE },
+          "autonomy: safety-policy.json is outdated \u2014 upgrading to current defaults"
+        );
+        _safetyPolicy = DEFAULT_SAFETY_POLICY;
+        try {
+          fs.writeFileSync(SAFETY_POLICY_FILE, JSON.stringify(DEFAULT_SAFETY_POLICY, null, 2), "utf8");
+        } catch (err) {
+          logger.warn({ err }, "autonomy: failed to write upgraded safety policy");
+        }
+      } else {
+        _safetyPolicy = parsed;
+      }
+    } else {
+      _safetyPolicy = DEFAULT_SAFETY_POLICY;
+    }
+  } catch (err) {
+    logger.warn({ err }, "autonomy: failed to load safety policy \u2014 using defaults");
+    _safetyPolicy = DEFAULT_SAFETY_POLICY;
+  }
+  return _safetyPolicy;
+}
+function checkSafetyPolicy(command) {
+  const policy = loadSafetyPolicy();
+  const normalized = normalizeWhitespace(command).toLowerCase();
+  for (const keyword of policy.blockedKeywords) {
+    if (normalized.includes(keyword.toLowerCase())) {
+      return {
+        allowed: false,
+        blockReason: `Command matches safety-policy blocked keyword/pattern: '${keyword}'`,
+        matchedRule: `safety_keyword:${keyword}`
+      };
+    }
+  }
+  for (const service of policy.blockedServices) {
+    if (normalized.includes(service.toLowerCase())) {
+      return {
+        allowed: false,
+        blockReason: `Command targets safety-policy blocked service: '${service}'`,
+        matchedRule: `safety_service:${service}`
+      };
+    }
+  }
+  return { allowed: true };
+}
+const ALLOWED_COMMANDS = [
+  // Package managers
+  { pattern: /^npm (install|ci|rebuild|run \S+|update \S+)(\s|$)/i, description: "npm install / ci / rebuild / run / update" },
+  { pattern: /^yarn (install|run \S+|add \S+)(\s|$)/i, description: "yarn install / run / add" },
+  { pattern: /^pnpm (install|run \S+|update \S+|add \S+)(\s|$)/i, description: "pnpm install / run / update / add" },
+  // pip install: only allow package-name installs. Block URL schemes (https://, git+),
+  // and flags that write to arbitrary paths (--target, --prefix).
+  { pattern: /^pip3? install (?!https?:\/\/|git\+|--target[\s=]|--prefix[\s=])[\w.-]/i, description: "pip install <package-name> (no URL or path installs)" },
+  // Git — safe, read-side / restore operations only
+  { pattern: /^git checkout [a-f0-9]{4,40}(\s|$)/i, description: "git checkout <sha>" },
+  { pattern: /^git fetch(\s|$)/i, description: "git fetch" },
+  { pattern: /^git stash (push|pop)(\s|$)/i, description: "git stash push / pop" },
+  { pattern: /^git pull --ff-only(\s|$)/i, description: "git pull --ff-only" },
+  // Container orchestration
+  { pattern: /^docker (restart|stop|start|logs) \S+/i, description: "docker restart/stop/start/logs <container>" },
+  { pattern: /^kubectl rollout (restart|undo) /i, description: "kubectl rollout restart / undo" },
+  { pattern: /^kubectl scale deployment /i, description: "kubectl scale deployment" },
+  // Service control
+  { pattern: /^systemctl (restart|stop|start|reload) \S+/i, description: "systemctl restart/stop/start/reload" },
+  { pattern: /^service \S+ (restart|stop|start)/i, description: "service <name> restart/stop/start" },
+  // Build — restricted to known-safe targets only. Makefile targets can execute
+  // arbitrary shell code, so we permit only a fixed set rather than \S+ (any target).
+  { pattern: /^make (build|test|install|restart|reload|start|stop|clean|lint|check)(\s|$)/i, description: "make <build|test|install|restart|reload|start|stop|clean|lint|check>" }
+];
+const ALLOWED_COMMAND_DESCRIPTIONS = ALLOWED_COMMANDS.map((r) => r.description);
+function normalizeWhitespace(cmd) {
+  return cmd.trim().replace(/\s+/g, " ");
+}
+const SHELL_METACHAR_RE = /[;&|`$(){}[\]<>\\!\n\r]/;
+function checkAllowlist(command) {
+  const normalized = normalizeWhitespace(command);
+  if (SHELL_METACHAR_RE.test(normalized)) {
+    return {
+      allowed: false,
+      blockReason: "Command contains shell metacharacter \u2014 possible injection attempt"
+    };
+  }
+  const match = ALLOWED_COMMANDS.find((r) => r.pattern.test(normalized));
+  if (match) return { allowed: true, matchedRule: match.description };
+  return {
+    allowed: false,
+    blockReason: `Command does not match any allowed pattern. Allowed forms: ${ALLOWED_COMMAND_DESCRIPTIONS.join(", ")}`
+  };
+}
+const MAX_OUTPUT_BYTES = 16 * 1024;
+const EXEC_TIMEOUT_MS = 6e4;
+function validateCwd(raw) {
+  if (!raw) return void 0;
+  const resolved = path.resolve(raw);
+  const safePrefixes = [process.cwd(), os.homedir()];
+  const isUnderSafeRoot = safePrefixes.some(
+    (p) => resolved === p || resolved.startsWith(p + path.sep)
+  );
+  if (!isUnderSafeRoot) {
+    logger.warn({ cwd: raw, resolved }, "autonomy: rejected cwd outside safe root");
+    return void 0;
+  }
+  try {
+    if (!fs.statSync(resolved).isDirectory()) return void 0;
+  } catch {
+    return void 0;
+  }
+  return resolved;
+}
+function _auditExecution(cmd, result, actor = "unknown") {
+  try {
+    recordExecutionAudit({
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      event: "autonomy.execute",
+      actor,
+      cmd: cmd.slice(0, 500),
+      ok: result.ok,
+      exitCode: result.exitCode ?? -1,
+      durationMs: result.durationMs,
+      blocked: result.blocked,
+      blockReason: result.blockReason ?? "",
+      timedOut: result.timedOut
+    });
+  } catch {
+  }
+}
+async function executeRemediation(command, opts = {}) {
+  const start = Date.now();
+  const actor = opts.actor ?? "unknown";
+  if (!hasPermission(actor, "responder")) {
+    const result = {
+      ok: false,
+      exitCode: null,
+      stdout: "",
+      stderr: "",
+      durationMs: 0,
+      timedOut: false,
+      blocked: true,
+      blockReason: `Actor '${actor}' does not have the 'responder' role required for fix execution`
+    };
+    _auditExecution(command, result, actor);
+    logger.warn({ actor, command }, "autonomy: command blocked by RBAC (insufficient role)");
+    await getStores().blunders.record({ blunderType: "rbac_block", command, blockReason: result.blockReason, service: null, tag: null, actor, pid: null, confidenceScore: null });
+    return result;
+  }
+  const { allowed, matchedRule, blockReason } = checkAllowlist(command);
+  if (!allowed) {
+    const result = {
+      ok: false,
+      exitCode: null,
+      stdout: "",
+      stderr: "",
+      durationMs: Date.now() - start,
+      timedOut: false,
+      blocked: true,
+      blockReason
+    };
+    _auditExecution(command, result, actor);
+    logger.warn({ command, blockReason }, "autonomy: command blocked by allowlist");
+    const blunderType = typeof blockReason === "string" && /inject/i.test(blockReason) ? "injection_attempt" : "allowlist_block";
+    await getStores().blunders.record({ blunderType, command, blockReason: blockReason ?? "", service: null, tag: null, actor, pid: null, confidenceScore: null });
+    return result;
+  }
+  const safetyCheck = checkSafetyPolicy(command);
+  if (!safetyCheck.allowed) {
+    const result = {
+      ok: false,
+      exitCode: null,
+      stdout: "",
+      stderr: "",
+      durationMs: Date.now() - start,
+      timedOut: false,
+      blocked: true,
+      blockReason: safetyCheck.blockReason
+    };
+    _auditExecution(command, result, actor);
+    logger.warn({ command, blockReason: safetyCheck.blockReason }, "autonomy: command blocked by safety policy");
+    await getStores().blunders.record({
+      blunderType: "pipeline_block",
+      command,
+      blockReason: safetyCheck.blockReason ?? "",
+      service: null,
+      tag: null,
+      actor,
+      pid: null,
+      confidenceScore: null,
+      triggeredRules: safetyCheck.matchedRule ? [safetyCheck.matchedRule] : null
+    });
+    return result;
+  }
+  logger.debug({ command, matchedRule }, "autonomy: command passed allowlist");
+  if (opts.dryRun) {
+    const result = {
+      ok: true,
+      exitCode: 0,
+      stdout: `[dry-run] would execute: ${command}`,
+      stderr: "",
+      durationMs: 0,
+      timedOut: false,
+      blocked: false
+    };
+    _auditExecution(command, result, actor);
+    return result;
+  }
+  const safeCwd = validateCwd(opts.cwd) ?? process.cwd();
+  logger.info({ command, cwd: safeCwd }, "autonomy: executing remediation command");
+  const [bin, ...cmdArgs] = normalizeWhitespace(command).split(" ").filter(Boolean);
+  const execEnv = {
+    PATH: process.env.PATH ?? "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
+    HOME: process.env.HOME ?? os.homedir(),
+    USER: process.env.USER ?? os.userInfo().username,
+    LOGNAME: process.env.LOGNAME ?? os.userInfo().username,
+    TMPDIR: process.env.TMPDIR ?? os.tmpdir(),
+    NO_COLOR: "1",
+    TERM: "dumb"
+  };
+  const { spawnSandboxed } = await import("./sandbox.js");
+  const { child: proc, sandboxed } = await spawnSandboxed(bin, cmdArgs, {
+    cwd: safeCwd,
+    env: execEnv,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  return new Promise((resolve) => {
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    let watcher = null;
+    if (!sandboxed && proc.pid) {
+      const rootPid = proc.pid;
+      void import("./process-tree.js").then(({ watchDescendants, killTree }) => {
+        watcher = watchDescendants(rootPid, {
+          onSpawn: (descendant) => {
+            const check = checkSafetyPolicy(descendant.command);
+            if (check.allowed) return;
+            logger.error(
+              { command, descendantPid: descendant.pid, descendantCommand: descendant.command },
+              "autonomy: descendant process matched a destructive pattern \u2014 terminating the process tree (post-spawn detect-and-kill, not pre-exec)"
+            );
+            void killTree(rootPid);
+            void getStores().blunders.record({
+              blunderType: "pipeline_block",
+              command: descendant.command,
+              blockReason: `Descendant of autonomous remediation command matched a destructive pattern (post-spawn detect-and-kill): ${check.blockReason ?? ""}`,
+              service: null,
+              tag: "process_tree_descendant",
+              actor,
+              pid: String(descendant.pid),
+              confidenceScore: null
+            });
+          }
+        });
+      }).catch(() => {
+      });
+    }
+    proc.stdout?.on("data", (chunk) => {
+      if (stdout.length < MAX_OUTPUT_BYTES) stdout += chunk.toString("utf8");
+    });
+    proc.stderr?.on("data", (chunk) => {
+      if (stderr.length < MAX_OUTPUT_BYTES) stderr += chunk.toString("utf8");
+    });
+    const timer = setTimeout(() => {
+      timedOut = true;
+      proc.kill("SIGTERM");
+      setTimeout(() => proc.kill("SIGKILL"), 2e3);
+    }, EXEC_TIMEOUT_MS);
+    proc.on("close", (code) => {
+      clearTimeout(timer);
+      watcher?.stop();
+      const result = {
+        ok: code === 0 && !timedOut,
+        exitCode: code,
+        stdout: stdout.slice(0, MAX_OUTPUT_BYTES),
+        stderr: stderr.slice(0, MAX_OUTPUT_BYTES),
+        durationMs: Date.now() - start,
+        timedOut,
+        blocked: false
+      };
+      _auditExecution(command, result, actor);
+      logger.info(
+        { exitCode: code, durationMs: result.durationMs, timedOut, actor, sandboxed },
+        "autonomy: command completed"
+      );
+      resolve(result);
+    });
+    proc.on("error", (err) => {
+      clearTimeout(timer);
+      watcher?.stop();
+      const result = {
+        ok: false,
+        exitCode: null,
+        stdout,
+        stderr: stderr + "\n" + String(err),
+        durationMs: Date.now() - start,
+        timedOut: false,
+        blocked: false
+      };
+      _auditExecution(command, result, actor);
+      resolve(result);
+    });
+  });
+}
+const CLI_PREFIXES = /^(npm|yarn|pnpm|pip3?|python3?|node|git|docker|kubectl|make|cargo|go|brew|apt|systemctl|service)\s/i;
+function extractCommand(fixHint) {
+  if (!fixHint) return null;
+  const backtickMatches = [...fixHint.matchAll(/`([^`]{4,200})`/g)];
+  for (const m of backtickMatches) {
+    const candidate = m[1].trim();
+    if (CLI_PREFIXES.test(candidate)) return candidate;
+  }
+  const prompt = fixHint.match(/\$\s+([^\n]{4,200})/);
+  if (prompt) {
+    const candidate = prompt[1].trim();
+    if (CLI_PREFIXES.test(candidate)) return candidate;
+  }
+  const lines = fixHint.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (CLI_PREFIXES.test(trimmed)) return trimmed;
+  }
+  return null;
+}
+export {
+  ALLOWED_COMMAND_DESCRIPTIONS,
+  DEFAULT_SAFETY_POLICY,
+  _resetSafetyPolicyForTesting,
+  checkSafetyPolicy,
+  executeRemediation,
+  extractCommand,
+  loadSafetyPolicy,
+  validateCwd
+};

package/dist/intelligence/azure-broker.js

@@ -0,0 +1,57 @@
+import { issueFederationToken } from "./oidc-issuer.js";
+import { createAzureProxySession } from "./azure-proxy-sessions.js";
+const FEDERATED_ASSERTION_TYPE = "urn:ietf:params:oauth:client-assertion-type:jwt-bearer";
+const DEFAULT_FEDERATION_AUDIENCE = "api://AzureADTokenExchange";
+async function requestAzureCredential(agentId, scopeName, scopeConfig, requestedDurationSeconds) {
+  const federationToken = await issueFederationToken({
+    agentId,
+    audience: scopeConfig.federationAudience ?? DEFAULT_FEDERATION_AUDIENCE,
+    // Azure access tokens are typically ~3600s regardless of what's asked
+    // for; the federation JWT itself only needs to live long enough to be
+    // exchanged, so it doesn't need to match the credential's own duration.
+    ttlSeconds: 300
+  });
+  const tokenUrl = `https://login.microsoftonline.com/${encodeURIComponent(scopeConfig.tenantId)}/oauth2/v2.0/token`;
+  const body = new URLSearchParams({
+    grant_type: "client_credentials",
+    client_id: scopeConfig.clientId,
+    client_assertion_type: FEDERATED_ASSERTION_TYPE,
+    client_assertion: federationToken,
+    scope: scopeConfig.azureScope
+  });
+  const res = await fetch(tokenUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: body.toString(),
+    signal: AbortSignal.timeout(1e4)
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`azure-broker: ${tokenUrl} returned ${res.status}: ${text.slice(0, 500)}`);
+  }
+  const tokenResponse = await res.json();
+  const cappedSeconds = Math.min(
+    tokenResponse.expires_in,
+    requestedDurationSeconds ?? scopeConfig.maxDurationSeconds,
+    scopeConfig.maxDurationSeconds
+  );
+  const { proxyToken, proxyPath } = createAzureProxySession({
+    azureAccessToken: tokenResponse.access_token,
+    azureApiBase: scopeConfig.azureApiBase,
+    expiresInSeconds: cappedSeconds,
+    scopeName,
+    agentId
+  });
+  return {
+    provider: "azure",
+    proxyToken,
+    proxyPath,
+    clientId: scopeConfig.clientId,
+    expiration: new Date(Date.now() + cappedSeconds * 1e3),
+    scope: scopeName,
+    durationEnforced: true
+  };
+}
+export {
+  requestAzureCredential
+};

package/dist/intelligence/azure-proxy-sessions.js

@@ -0,0 +1,49 @@
+import { randomBytes } from "crypto";
+import logger from "../sensor/logger.js";
+const _sessions = /* @__PURE__ */ new Map();
+const SWEEP_INTERVAL_MS = 5 * 6e4;
+setInterval(() => {
+  const now = Date.now();
+  for (const [token, session] of _sessions) {
+    if (now > session.expiresAt) _sessions.delete(token);
+  }
+}, SWEEP_INTERVAL_MS).unref();
+function createAzureProxySession(params) {
+  const proxyToken = randomBytes(32).toString("hex");
+  _sessions.set(proxyToken, {
+    azureAccessToken: params.azureAccessToken,
+    azureApiBase: params.azureApiBase,
+    expiresAt: Date.now() + params.expiresInSeconds * 1e3,
+    scopeName: params.scopeName,
+    agentId: params.agentId,
+    revoked: false
+  });
+  logger.info(
+    { scope: params.scopeName, agentId: params.agentId, expiresInSeconds: params.expiresInSeconds },
+    "azure-proxy-sessions: session created"
+  );
+  return { proxyToken, proxyPath: `/credentials/azure-proxy/${proxyToken}` };
+}
+function lookupAzureProxySession(proxyToken) {
+  const session = _sessions.get(proxyToken);
+  if (!session) return { status: "not_found" };
+  if (session.revoked) return { status: "revoked" };
+  if (Date.now() > session.expiresAt) return { status: "expired" };
+  return { status: "ok", session };
+}
+function revokeAzureProxySession(proxyToken) {
+  const session = _sessions.get(proxyToken);
+  if (!session) return false;
+  session.revoked = true;
+  logger.info({ scope: session.scopeName, agentId: session.agentId }, "azure-proxy-sessions: session revoked");
+  return true;
+}
+function _resetAzureProxySessionsForTesting() {
+  _sessions.clear();
+}
+export {
+  _resetAzureProxySessionsForTesting,
+  createAzureProxySession,
+  lookupAzureProxySession,
+  revokeAzureProxySession
+};

package/dist/intelligence/baseline.js

@@ -0,0 +1 @@
+export * from '../__stubs__/closed-source.js';