@wrongstack/cli 1.1.2 → 1.1.5

package/dist/chunk-LYWOV4OX.js

@@ -0,0 +1,252 @@
+
+// src/tool-gateway.ts
+import { Context } from "@wrongstack/core/agent";
+import { ToolExecutor } from "@wrongstack/core/execution";
+import { ToolRegistry } from "@wrongstack/core/registry";
+import {
+  AutoApprovePermissionPolicy,
+  DefaultSecretScrubber,
+  ToolCapabilities
+} from "@wrongstack/core/security";
+import { normalizeTokenSavingTier } from "@wrongstack/core/types";
+import { toErrorMessage } from "@wrongstack/core/utils";
+import { systemSessionId } from "@wrongstack/primitives";
+import { wireKanbanPorts } from "@wrongstack/runtime";
+import { BROWSER_TOOL_NAMES } from "@wrongstack/tools/browser";
+import { runStartupIndex, shutdownCodebaseIndexHost } from "@wrongstack/tools/codebase-index";
+import { registerBuiltinToolTier } from "@wrongstack/tools/tool-tier";
+function resolveGatewayRegistry(existing, config) {
+  wireKanbanPorts();
+  if (existing) return existing;
+  const registry = new ToolRegistry();
+  registerBuiltinToolTier({
+    registry,
+    tier: normalizeTokenSavingTier(config.features.tokenSavingMode)
+  });
+  return registry;
+}
+var READ_ONLY_CAPABILITIES = [
+  ToolCapabilities.FS_READ,
+  ToolCapabilities.NET_OUTBOUND
+];
+function parseCapabilityGrants(raw) {
+  if (raw === void 0 || raw === false) return [];
+  if (raw === true || raw.trim() === "") {
+    throw new Error(
+      `--allow needs a comma-separated capability list, e.g. --allow fs.write (known: ${knownCapabilities()})`
+    );
+  }
+  const known = new Set(Object.values(ToolCapabilities));
+  const grants = raw.split(",").map((s) => s.trim()).filter(Boolean);
+  const unknown = grants.filter((g) => !known.has(g));
+  if (unknown.length > 0) {
+    throw new Error(
+      `--allow: unknown capability ${unknown.map((u) => `"${u}"`).join(", ")} (known: ${knownCapabilities()})`
+    );
+  }
+  return [...new Set(grants)];
+}
+function knownCapabilities() {
+  return Object.values(ToolCapabilities).join(", ");
+}
+function yoloServePolicy(yoloPlus) {
+  return new AutoApprovePermissionPolicy(
+    Object.values(ToolCapabilities),
+    yoloPlus ? { yoloPlus } : void 0
+  );
+}
+function resolveServeFsRestriction(config) {
+  return config.tools?.restrictToProjectRoot ?? true;
+}
+var GATEWAY_SESSION_ID = systemSessionId("tool-gateway");
+function makeServeContext(cwd, projectRoot, signal, restrictFsToRoot = true) {
+  const provider = {
+    id: "mcp-serve",
+    capabilities: { maxContext: 0 },
+    complete: async () => {
+      throw new Error("no model provider in tool-gateway mode");
+    },
+    stream: () => {
+      throw new Error("no model provider in tool-gateway mode");
+    }
+  };
+  const session = {
+    id: GATEWAY_SESSION_ID,
+    append: async () => {
+    }
+  };
+  const tokenCounter = {
+    account: () => {
+    },
+    total: () => ({ input: 0, output: 0 }),
+    estimateCost: () => ({ total: 0 })
+  };
+  return new Context({
+    systemPrompt: [],
+    provider,
+    session,
+    signal,
+    tokenCounter,
+    cwd,
+    projectRoot,
+    allowOutsideProjectRoot: !restrictFsToRoot,
+    model: "mcp-serve",
+    tools: []
+  });
+}
+async function selectExposedTools(registry, ctx, policy, whitelist) {
+  const allowed = [];
+  for (const tool of registry.list()) {
+    if (whitelist && !whitelist.has(tool.name)) continue;
+    const decision = await policy.evaluate(tool, {}, ctx);
+    if (decision.permission === "auto") allowed.push(tool);
+  }
+  return allowed;
+}
+var SESSION_BOUND_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "clarify",
+  "tool_use",
+  "tool_script",
+  "tool_search",
+  "present_artifact",
+  "todo",
+  "plan"
+]);
+var PROCESS_BOUND_TOOL_NAMES = new Set(BROWSER_TOOL_NAMES);
+var INDEX_READING_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "codebase-search",
+  "codebase-context",
+  "codebase-impact-analysis",
+  "codebase-incoming-calls",
+  "codebase-outgoing-calls",
+  "codebase-repo-map",
+  "codebase-stats"
+]);
+var REMOTE_CATCH_UP_INTERVAL_MS = 1e3;
+function readsCodebaseIndex(name) {
+  return INDEX_READING_TOOL_NAMES.has(name);
+}
+function oneShotWithholdReason(name) {
+  if (SESSION_BOUND_TOOL_NAMES.has(name)) return "session";
+  if (PROCESS_BOUND_TOOL_NAMES.has(name)) return "process";
+  return void 0;
+}
+function withheldReason(gateway, registry, name) {
+  const bound = gateway.withheldBy(name);
+  if (bound === "session") {
+    return `Tool "${name}" only works inside an agent session and is not exposed here.`;
+  }
+  if (bound === "process") {
+    return `Tool "${name}" keeps its state in a long-lived process; use \`wstack mcp serve\` or \`wstack tools serve\` for it.`;
+  }
+  const tool = registry.get(name);
+  if (!tool) return `Unknown tool "${name}". List the exposed tools first.`;
+  const missing = (tool.capabilities ?? []).filter((c) => !gateway.capabilities.includes(c));
+  return gateway.mode === "yolo" || missing.length === 0 ? `Tool "${name}" is withheld by policy.` : `Tool "${name}" is withheld: it needs ${missing.join(", ")}. Pass --allow ${missing.join(",")} (or --yolo for every capability); deleting outside the project, git-history and download-and-run commands stay refused.`;
+}
+async function createToolGateway(options) {
+  const { registry, config, cwd, projectRoot } = options;
+  const restrictFsToRoot = resolveServeFsRestriction(config);
+  const controller = new AbortController();
+  const grants = options.yolo ? [] : [...new Set(options.allow ?? [])];
+  const mode = options.yolo ? "yolo" : grants.length > 0 ? "granted" : "safe";
+  const capabilities = options.yolo ? Object.values(ToolCapabilities) : [.../* @__PURE__ */ new Set([...READ_ONLY_CAPABILITIES, ...grants])];
+  const permissionPolicy = options.yolo ? yoloServePolicy(options.yoloPlus) : new AutoApprovePermissionPolicy(capabilities);
+  const executor = new ToolExecutor(registry, {
+    permissionPolicy,
+    secretScrubber: new DefaultSecretScrubber(),
+    maxToolTimeoutMs: config.tools?.maxToolTimeoutMs ?? 3e5,
+    perIterationOutputCapBytes: 1e6,
+    // Kanban tracks work; it does not gate it. Off unless the operator opts in.
+    // See wiring/pipeline.ts for why all four hosts must agree.
+    requireKanbanGovernance: config.tools?.kanbanGovernance ?? false
+  });
+  const selectionCtx = makeServeContext(cwd, projectRoot, controller.signal, restrictFsToRoot);
+  const selected = await selectExposedTools(
+    registry,
+    selectionCtx,
+    permissionPolicy,
+    options.whitelist
+  );
+  const withheld = (name) => {
+    const reason = oneShotWithholdReason(name);
+    if (options.oneShot) return reason !== void 0;
+    if (options.remoteAgent) return reason === "session";
+    return false;
+  };
+  const tools = selected.filter((t) => !withheld(t.name));
+  const byName = new Map(tools.map((t) => [t.name, t]));
+  const catchUpIndex = options.catchUpIndex ?? (async (root, signal) => {
+    await runStartupIndex({ projectRoot: root, signal });
+  });
+  let indexCurrent = false;
+  let lastCatchUpAt = 0;
+  let catchUpInFlight;
+  const runCatchUp = async () => {
+    try {
+      await catchUpIndex(projectRoot, controller.signal);
+    } catch (err) {
+      options.onWarning?.(`codebase index catch-up failed: ${toErrorMessage(err)}`);
+    } finally {
+      indexCurrent = true;
+      lastCatchUpAt = Date.now();
+      catchUpInFlight = void 0;
+    }
+  };
+  const indexNeedsCatchUp = () => {
+    if (options.oneShot) return !indexCurrent;
+    if (options.remoteAgent) return Date.now() - lastCatchUpAt >= REMOTE_CATCH_UP_INTERVAL_MS;
+    return false;
+  };
+  let counter = 0;
+  return {
+    mode,
+    capabilities,
+    projectRoot,
+    tools,
+    get: (name) => byName.get(name),
+    withheldBy: (name) => withheld(name) ? oneShotWithholdReason(name) : void 0,
+    async call(name, input, callOptions) {
+      const tool = byName.get(name);
+      if (!tool) return { kind: "not_exposed" };
+      if (readsCodebaseIndex(name) && (catchUpInFlight || indexNeedsCatchUp())) {
+        catchUpInFlight ??= runCatchUp();
+        await catchUpInFlight;
+      }
+      if (tool.mutating) indexCurrent = false;
+      const use = { type: "tool_use", id: `srv_${++counter}`, name, input };
+      const requestCtx = makeServeContext(
+        callOptions?.cwd ?? cwd,
+        projectRoot,
+        controller.signal,
+        restrictFsToRoot
+      );
+      const batch = await executor.executeBatch([use], requestCtx, "sequential");
+      const output = batch.outputs[0];
+      const result = output?.result;
+      if (!output || !result || result.type === "tool_confirm_pending") {
+        return { kind: "confirm_required" };
+      }
+      const isError = Boolean(result.is_error);
+      return {
+        kind: "result",
+        content: result.content,
+        isError,
+        settlement: output.settlement ?? (isError ? "failed" : "completed"),
+        durationMs: output.durationMs
+      };
+    },
+    async close() {
+      controller.abort();
+      await shutdownCodebaseIndexHost();
+    }
+  };
+}
+
+export {
+  resolveGatewayRegistry,
+  parseCapabilityGrants,
+  withheldReason,
+  createToolGateway
+};
+//# sourceMappingURL=chunk-LYWOV4OX.js.map