@wrongstack/cli 1.1.2 → 1.1.5

package/dist/chunk-QLYPIJ7X.js

@@ -0,0 +1,258 @@
+import {
+  createToolGateway,
+  parseCapabilityGrants,
+  resolveGatewayRegistry
+} from "./chunk-LYWOV4OX.js";
+
+// src/mcp-serve.ts
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { pathToFileURL } from "node:url";
+import { toErrorMessage } from "@wrongstack/core/utils";
+import {
+  DEFAULT_MCP_INSERTION_MAX_BYTES,
+  MCPServer,
+  serveHttp,
+  serveStdio
+} from "@wrongstack/mcp";
+function parseToolsFlag(flags, positional) {
+  const raw = flags["tools"];
+  const csv = typeof raw === "string" ? raw : raw === true ? positional?.[0] ?? "" : "";
+  if (!csv) return null;
+  const set = new Set(
+    csv.split(",").map((s) => s.trim()).filter(Boolean)
+  );
+  return set.size > 0 ? set : null;
+}
+function resolveServeHttpPort(flags) {
+  const raw = typeof flags["port"] === "string" ? flags["port"] : typeof flags["http"] === "string" ? flags["http"] : void 0;
+  if (raw === void 0 || raw.trim() === "") return 0;
+  const port = Number(raw);
+  if (!Number.isInteger(port) || port < 0 || port > 65535) {
+    throw new Error(`invalid --port "${raw}" \u2014 expected an integer between 0 and 65535`);
+  }
+  return port;
+}
+async function loadSelectedMcpServeContent(flags, cwd) {
+  const resources = [];
+  const prompts = [];
+  const resourceUris = /* @__PURE__ */ new Set();
+  const promptNames = /* @__PURE__ */ new Set();
+  for (const selected of commaSeparatedFlag(flags, "resources")) {
+    const file = path.resolve(cwd, selected);
+    const data = await readSelectedFile(file);
+    const uri = pathToFileURL(file).toString();
+    if (resourceUris.has(uri)) throw new Error(`Duplicate MCP resource selection: ${selected}`);
+    resourceUris.add(uri);
+    const mimeType = mimeTypeFor(file);
+    resources.push({
+      uri,
+      name: path.basename(file),
+      mimeType,
+      size: data.byteLength,
+      contents: [
+        isTextMime(mimeType) ? { uri, mimeType, text: data.toString("utf8") } : { uri, mimeType, blob: data.toString("base64") }
+      ]
+    });
+  }
+  for (const selected of commaSeparatedFlag(flags, "prompts")) {
+    const file = path.resolve(cwd, selected);
+    const data = await readSelectedFile(file);
+    const name = path.basename(file, path.extname(file)).replace(/[^A-Za-z0-9_.-]+/g, "-").replace(/^-+|-+$/g, "");
+    if (!name) throw new Error(`Cannot derive an MCP prompt name from: ${selected}`);
+    if (promptNames.has(name)) throw new Error(`Duplicate MCP prompt name: ${name}`);
+    promptNames.add(name);
+    const template = data.toString("utf8");
+    const argumentNames = Array.from(
+      template.matchAll(/\{\{([A-Za-z_][A-Za-z0-9_.-]*)\}\}/g),
+      (match) => match[1]
+    ).filter((value, index, all) => !!value && all.indexOf(value) === index);
+    prompts.push({
+      name,
+      description: `Explicitly selected local prompt: ${path.basename(file)}`,
+      arguments: argumentNames.map((argument) => ({ name: argument, required: true })),
+      template
+    });
+  }
+  return { resources, prompts };
+}
+function commaSeparatedFlag(flags, name) {
+  const value = flags[name];
+  if (value === void 0) return [];
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new Error(`--${name} requires a comma-separated file list`);
+  }
+  return value.split(",").map((item) => item.trim()).filter(Boolean);
+}
+async function readSelectedFile(file) {
+  const stat2 = await fs.stat(file);
+  if (!stat2.isFile()) throw new Error(`Selected MCP content is not a regular file: ${file}`);
+  if (stat2.size > DEFAULT_MCP_INSERTION_MAX_BYTES) {
+    throw new Error(
+      `Selected MCP content exceeds ${DEFAULT_MCP_INSERTION_MAX_BYTES} bytes: ${file}`
+    );
+  }
+  return fs.readFile(file);
+}
+function mimeTypeFor(file) {
+  switch (path.extname(file).toLowerCase()) {
+    case ".md":
+    case ".mdx":
+      return "text/markdown";
+    case ".json":
+      return "application/json";
+    case ".yaml":
+    case ".yml":
+      return "application/yaml";
+    case ".html":
+      return "text/html";
+    case ".css":
+      return "text/css";
+    case ".js":
+    case ".mjs":
+      return "text/javascript";
+    case ".ts":
+    case ".tsx":
+      return "text/typescript";
+    case ".txt":
+    case ".log":
+      return "text/plain";
+    case ".png":
+      return "image/png";
+    case ".jpg":
+    case ".jpeg":
+      return "image/jpeg";
+    case ".gif":
+      return "image/gif";
+    case ".webp":
+      return "image/webp";
+    default:
+      return "application/octet-stream";
+  }
+}
+function isTextMime(mimeType) {
+  return mimeType.startsWith("text/") || mimeType === "application/json" || mimeType === "application/yaml";
+}
+async function serveMcpStdio(deps, positional) {
+  const flags = deps.flags ?? {};
+  const yolo = flags["yolo"] === true || flags["allow-all"] === true;
+  const whitelist = parseToolsFlag(flags, positional);
+  if (flags["tools"] !== void 0 && whitelist === null) {
+    process.stderr.write(
+      "wrongstack MCP server: --tools requires a comma-separated tool list (e.g. `--tools read,grep` or `--tools=read,grep`)\n"
+    );
+    return 1;
+  }
+  const log = (m) => process.stderr.write(`${m}
+`);
+  let selectedContent;
+  try {
+    selectedContent = await loadSelectedMcpServeContent(flags, deps.cwd);
+  } catch (err) {
+    log(`wrongstack MCP server: ${err instanceof Error ? err.message : String(err)}`);
+    return 1;
+  }
+  let allow;
+  try {
+    allow = parseCapabilityGrants(flags["allow"]);
+  } catch (err) {
+    log(`wrongstack MCP server: ${toErrorMessage(err)}`);
+    return 1;
+  }
+  const gateway = await createToolGateway({
+    registry: resolveGatewayRegistry(deps.toolRegistry, deps.config),
+    config: deps.config,
+    cwd: deps.cwd,
+    projectRoot: deps.projectRoot,
+    yolo,
+    allow,
+    whitelist
+  });
+  const allowed = gateway.tools;
+  if (allowed.length === 0) {
+    log(
+      "wrongstack MCP server: no tools to expose (all withheld by policy or filtered out). Pass --yolo to expose write/exec tools, or --tools <names> to whitelist."
+    );
+  }
+  const host = {
+    listTools: () => allowed.map((t) => ({
+      name: t.name,
+      description: t.description,
+      inputSchema: t.inputSchema ?? { type: "object" }
+    })),
+    callTool: async (name, callArgs) => {
+      const outcome = await gateway.call(name, callArgs);
+      if (outcome.kind === "not_exposed") {
+        return { content: `Tool "${name}" is not exposed by this server`, isError: true };
+      }
+      if (outcome.kind === "confirm_required") {
+        return {
+          content: `Tool "${name}" requires interactive confirmation, which is unavailable over MCP`,
+          isError: true
+        };
+      }
+      return { content: outcome.content, isError: outcome.isError };
+    }
+  };
+  const server = new MCPServer({
+    host,
+    resources: selectedContent.resources,
+    prompts: selectedContent.prompts,
+    logger: { warn: (m) => log(`[mcp-serve] ${m}`) }
+  });
+  const mode = gateway.mode === "yolo" ? "yolo: all tools" : gateway.mode === "granted" ? `granted: ${gateway.capabilities.join(", ")}` : "safe: read-only tools";
+  if (flags["http"] === true || typeof flags["http"] === "string" || flags["port"] || flags["host"]) {
+    let port;
+    try {
+      port = resolveServeHttpPort(flags);
+    } catch (err) {
+      log(`wrongstack MCP server: ${err instanceof Error ? err.message : String(err)}`);
+      return 1;
+    }
+    const httpHost = typeof flags["host"] === "string" ? flags["host"] : "127.0.0.1";
+    const tokenFromArg = typeof flags["token"] === "string" ? flags["token"] : void 0;
+    const token = tokenFromArg ?? process.env.WRONGSTACK_MCP_TOKEN?.trim() ?? void 0;
+    if (tokenFromArg) {
+      log(
+        "[mcp-serve] --token puts the auth token in this process command line, which other local processes can read. Prefer WRONGSTACK_MCP_TOKEN."
+      );
+    }
+    let handle2;
+    try {
+      handle2 = await serveHttp(server, {
+        port,
+        host: httpHost,
+        token,
+        logger: { warn: (m) => log(`[mcp-serve] ${m}`) }
+      });
+    } catch (err) {
+      log(`wrongstack MCP server: ${err instanceof Error ? err.message : String(err)}`);
+      return 1;
+    }
+    log(
+      `wrongstack MCP server ready at ${handle2.url} \u2014 exposing ${allowed.length} tool(s), ${selectedContent.resources.length} resource(s), ${selectedContent.prompts.length} prompt(s) (${mode})${token ? " [token auth]" : ""}.`
+    );
+    await new Promise((resolve2) => {
+      const stop = () => resolve2();
+      process.once("SIGINT", stop);
+      process.once("SIGTERM", stop);
+    });
+    await handle2.close();
+    await gateway.close();
+    return 0;
+  }
+  log(
+    `wrongstack MCP server ready on stdio \u2014 exposing ${allowed.length} tool(s), ${selectedContent.resources.length} resource(s), ${selectedContent.prompts.length} prompt(s) (${mode}).`
+  );
+  const handle = serveStdio(server);
+  await handle.done;
+  await gateway.close();
+  return 0;
+}
+
+export {
+  parseToolsFlag,
+  resolveServeHttpPort,
+  serveMcpStdio
+};
+//# sourceMappingURL=chunk-QLYPIJ7X.js.map

package/dist/chunk-RN5CFAVQ.js

@@ -0,0 +1,292 @@
+import {
+  withheldReason
+} from "./chunk-LYWOV4OX.js";
+
+// src/tool-gateway-http.ts
+import { randomUUID } from "node:crypto";
+import { realpath } from "node:fs/promises";
+import { createServer } from "node:http";
+import * as path from "node:path";
+import { toErrorMessage } from "@wrongstack/core/utils";
+import {
+  bearerTokenMatches,
+  hostHeaderIsAcceptable,
+  isJsonContentType,
+  isLoopbackHost,
+  originIsAcceptable
+} from "@wrongstack/mcp";
+var BODY_CAP_BYTES = 4 * 1024 * 1024;
+var DEFAULT_MAX_CONCURRENT_CALLS = 16;
+var CALLBACK_TIMEOUT_MS = 3e4;
+function serveToolGatewayHttp(opts) {
+  const host = opts.host ?? "127.0.0.1";
+  if (!opts.token || opts.token.length < 16) {
+    return Promise.reject(
+      new Error("tools serve: a bearer token of at least 16 characters is required")
+    );
+  }
+  const maxConcurrent = opts.maxConcurrentCalls ?? DEFAULT_MAX_CONCURRENT_CALLS;
+  const pending = /* @__PURE__ */ new Set();
+  let inFlight = 0;
+  const server = createServer((req, res) => {
+    void handle(req, res).catch((err) => {
+      opts.log?.(`tools serve: request failed: ${toErrorMessage(err)}`);
+      if (!res.headersSent) send(res, 500, { ok: false, error: "internal_error" });
+    });
+  });
+  async function handle(req, res) {
+    if (!originIsAcceptable(req, host))
+      return send(res, 403, { ok: false, error: "cross_origin_forbidden" });
+    if (!hostHeaderIsAcceptable(req, host))
+      return send(res, 403, { ok: false, error: "untrusted_host_header" });
+    const url = new URL(req.url ?? "/", "http://local");
+    if (req.method === "GET" && url.pathname === "/health") return send(res, 200, { ok: true });
+    if (!bearerTokenMatches(req.headers.authorization, opts.token)) {
+      return send(res, 401, { ok: false, error: "unauthorized" });
+    }
+    let parts;
+    try {
+      parts = url.pathname.split("/").filter(Boolean).map(decodeURIComponent);
+    } catch {
+      return send(res, 400, { ok: false, error: "invalid_path_encoding" });
+    }
+    if (parts[0] !== "v1" || parts[1] !== "tools")
+      return send(res, 404, { ok: false, error: "not_found" });
+    const name = parts[2];
+    if (req.method === "GET" && parts.length === 2) {
+      return send(res, 200, {
+        mode: opts.gateway.mode,
+        capabilities: opts.gateway.capabilities,
+        tools: opts.gateway.tools.map(describe)
+      });
+    }
+    if (req.method === "GET" && name && parts.length === 3) {
+      const tool = opts.gateway.get(name);
+      if (!tool) return send(res, 404, notExposedBody(name));
+      return send(res, 200, describe(tool));
+    }
+    if (req.method === "POST" && name && parts.length === 4 && parts[3] === "call") {
+      return call(req, res, name);
+    }
+    return send(res, req.method === "GET" || req.method === "POST" ? 404 : 405, {
+      ok: false,
+      error: req.method === "GET" || req.method === "POST" ? "not_found" : "method_not_allowed"
+    });
+  }
+  async function call(req, res, name) {
+    if (!isJsonContentType(req.headers["content-type"])) {
+      return send(res, 415, { ok: false, error: "content_type_must_be_json" });
+    }
+    const body = await readBody(req);
+    if (body === "too_large") return send(res, 413, { ok: false, error: "payload_too_large" });
+    let parsed;
+    try {
+      parsed = parseCallRequest(body, opts.allowRemoteCallbacks === true);
+    } catch (err) {
+      return send(res, 400, { ok: false, error: "bad_request", message: toErrorMessage(err) });
+    }
+    if (!opts.gateway.get(name)) {
+      return send(res, 404, { call_id: parsed.callId, ...notExposedBody(name) });
+    }
+    let cwd;
+    if (parsed.workdir !== void 0) {
+      const resolved = await resolveWorkdir(parsed.workdir, opts.gateway.projectRoot);
+      if ("error" in resolved) {
+        return send(res, 400, {
+          call_id: parsed.callId,
+          ok: false,
+          tool: name,
+          error: "bad_workdir",
+          message: resolved.error
+        });
+      }
+      cwd = resolved.cwd;
+    }
+    if (inFlight >= maxConcurrent) {
+      return send(res, 429, { call_id: parsed.callId, ok: false, error: "too_many_calls" });
+    }
+    inFlight++;
+    const settle = run(name, parsed, cwd).finally(() => {
+      inFlight--;
+    });
+    if (!parsed.callback) {
+      return send(res, 200, await settle);
+    }
+    send(res, 202, { call_id: parsed.callId, status: "accepted" });
+    const delivery = settle.then((result) => deliverCallback(parsed.callback, result)).catch(
+      (err) => opts.log?.(`tools serve: callback for ${parsed.callId} failed: ${toErrorMessage(err)}`)
+    );
+    pending.add(delivery);
+    void delivery.finally(() => pending.delete(delivery));
+  }
+  async function run(name, req, cwd) {
+    const base = { call_id: req.callId, tool: name };
+    try {
+      const outcome = await opts.gateway.call(name, req.input, { cwd });
+      if (outcome.kind === "not_exposed") return { ...base, ...notExposedBody(name) };
+      if (outcome.kind === "confirm_required") {
+        return {
+          ...base,
+          ok: false,
+          error: "confirm_required",
+          message: `Tool "${name}" needs an interactive confirmation for this input, which this server cannot give.`
+        };
+      }
+      return {
+        ...base,
+        ok: !outcome.isError && outcome.settlement === "completed",
+        settlement: outcome.settlement,
+        duration_ms: outcome.durationMs,
+        content: outcome.content
+      };
+    } catch (err) {
+      return { ...base, ok: false, error: "tool_threw", message: toErrorMessage(err) };
+    }
+  }
+  async function deliverCallback(callback, result) {
+    const doFetch = opts.fetchImpl ?? fetch;
+    const res = await doFetch(callback.url, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        ...callback.token ? { authorization: `Bearer ${callback.token}` } : {}
+      },
+      body: JSON.stringify(result),
+      signal: AbortSignal.timeout(CALLBACK_TIMEOUT_MS),
+      redirect: "error"
+    });
+    if (!res.ok) throw new Error(`callback answered HTTP ${res.status}`);
+  }
+  function notExposedBody(name) {
+    return {
+      ok: false,
+      tool: name,
+      error: "not_exposed",
+      message: withheldReason(opts.gateway, opts.registry, name)
+    };
+  }
+  return new Promise((resolve2, reject) => {
+    server.once("error", reject);
+    server.listen(opts.port ?? 0, host, () => {
+      server.removeListener("error", reject);
+      if (opts.unref) server.unref();
+      const port = server.address().port;
+      const shown = host === "::1" ? "[::1]" : host;
+      resolve2({
+        url: `http://${shown}:${port}/`,
+        port,
+        host,
+        close: async () => {
+          await new Promise((done) => server.close(() => done()));
+          await Promise.allSettled([...pending]);
+        }
+      });
+    });
+  });
+}
+function describe(tool) {
+  return {
+    name: tool.name,
+    description: tool.description,
+    input_schema: tool.inputSchema ?? { type: "object" },
+    capabilities: tool.capabilities ?? [],
+    mutating: tool.mutating
+  };
+}
+function parseCallRequest(body, allowRemoteCallbacks) {
+  const text = body.trim();
+  const raw = text === "" ? {} : JSON.parse(text);
+  if (!isRecord(raw)) throw new Error("the body must be a JSON object");
+  const input = raw["input"] ?? {};
+  if (!isRecord(input)) throw new Error(`"input" must be a JSON object (the tool's input)`);
+  const callId = raw["call_id"] ?? randomUUID();
+  if (typeof callId !== "string" || callId.length === 0 || callId.length > 200) {
+    throw new Error('"call_id" must be a non-empty string of at most 200 characters');
+  }
+  const cb = raw["callback"];
+  const workdir = raw["workdir"];
+  if (workdir !== void 0 && workdir !== null && (typeof workdir !== "string" || workdir === "")) {
+    throw new Error('"workdir" must be a non-empty path');
+  }
+  const base = { input, callId, ...typeof workdir === "string" ? { workdir } : {} };
+  if (cb === void 0) return base;
+  if (!isRecord(cb) || typeof cb["url"] !== "string") {
+    throw new Error('"callback" must be { "url": string, "token"?: string }');
+  }
+  let target;
+  try {
+    target = new URL(cb["url"]);
+  } catch {
+    throw new Error('"callback.url" is not a valid URL');
+  }
+  if (target.protocol !== "http:" && target.protocol !== "https:") {
+    throw new Error('"callback.url" must be http(s)');
+  }
+  if (!allowRemoteCallbacks && !isLoopbackHost(target.hostname.replace(/^\[(.*)\]$/, "$1"))) {
+    throw new Error(
+      '"callback.url" must be a loopback address (start the server with --allow-remote-callbacks)'
+    );
+  }
+  const token = cb["token"];
+  if (token !== void 0 && typeof token !== "string")
+    throw new Error('"callback.token" must be a string');
+  return { ...base, callback: { url: target.toString(), token } };
+}
+async function resolveWorkdir(workdir, projectRoot) {
+  let root;
+  let target;
+  try {
+    root = await realpath(projectRoot);
+    target = await realpath(path.resolve(projectRoot, workdir));
+  } catch {
+    return { error: `workdir "${workdir}" does not exist on the WrongStack side` };
+  }
+  const fold = (p) => process.platform === "win32" ? p.toLowerCase() : p;
+  const rel = path.relative(fold(root), fold(target));
+  if (rel.startsWith("..") || path.isAbsolute(rel)) {
+    return {
+      error: `workdir "${workdir}" is outside the project this server serves (${root}); start \`wstack tools serve\` in the task's directory`
+    };
+  }
+  return { cwd: target };
+}
+function readBody(req) {
+  return new Promise((resolve2, reject) => {
+    const chunks = [];
+    let size = 0;
+    let tooLarge = false;
+    req.on("data", (chunk) => {
+      if (tooLarge) return;
+      size += chunk.byteLength;
+      if (size > BODY_CAP_BYTES) {
+        tooLarge = true;
+        resolve2("too_large");
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => {
+      if (!tooLarge) resolve2(Buffer.concat(chunks).toString("utf8"));
+    });
+    req.on("error", reject);
+  });
+}
+function send(res, status, body) {
+  res.writeHead(status, {
+    "content-type": "application/json",
+    // This endpoint executes tools: nothing about it should be embedded,
+    // sniffed into another type, or leak its URL onward. No CORS headers.
+    "x-content-type-options": "nosniff",
+    "x-frame-options": "DENY",
+    "referrer-policy": "no-referrer"
+  });
+  res.end(JSON.stringify(body));
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export {
+  serveToolGatewayHttp
+};
+//# sourceMappingURL=chunk-RN5CFAVQ.js.map

package/dist/{chunk-WDXNBYGD.js → chunk-TDP7CZGE.js}

@@ -61,6 +61,11 @@ var SDDState = class {
     if (this.versioning === null) this.versioning = new SpecVersioning();
     return this.versioning;
   }
+  /** Drain fire-and-forget tracker writes before deleting or replacing the store. */
+  async flushTaskWrites() {
+    await this.taskTracker?.flushPersistence();
+    await this.taskStore?.flush?.();
+  }
   clearTaskState() {
     this.taskStore = null;
     this.taskTracker = null;
@@ -406,4 +411,4 @@ export {
   getTaskGraphId,
   getTaskTrackerExport
 };
-//# sourceMappingURL=chunk-WDXNBYGD.js.map
+//# sourceMappingURL=chunk-TDP7CZGE.js.map

package/dist/{chunk-6VPWQ4TG.js → chunk-UROB7MK5.js}

@@ -63,6 +63,7 @@ var helpCmd = async (_args, deps) => {
       ["wstack sage sync", "Keep project SAGE memory synchronized through HQ"],
       ["wstack plugin", "Plugins: list, install, enable, disable, remove"],
       ["wstack tools | skills", "List registered tools / discovered skills"],
+      ["wstack tools run <tool>", "Call a built-in tool from a script or external agent"],
       ["wstack typesafe", "TypeSafe account: status, login, test"],
       ["wstack update", "Self-update (--check-only)"]
     ]),
@@ -157,4 +158,4 @@ export {
   versionCmd,
   helpCmd
 };
-//# sourceMappingURL=chunk-6VPWQ4TG.js.map
+//# sourceMappingURL=chunk-UROB7MK5.js.map