@wrongstack/cli 1.1.4 → 1.1.6

package/dist/chunk-PGC44T7N.js

@@ -0,0 +1,255 @@
+
+// src/fleet/wrongforge-client.ts
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+import { toErrorMessage } from "@wrongstack/core/utils";
+var WRONGFORGE_AGENT_ID = "wrongforge";
+var DEFAULT_URL = "http://127.0.0.1:8787";
+var MIN_KEY_LENGTH = 16;
+var POLL_WAIT_MS = 25e3;
+var POLL_LIMIT = 1e3;
+var MAX_POLL_FAILURES = 6;
+var WRONGFORGE_READ_SIDE_TOOLS = [
+  "read",
+  "ls",
+  "glob",
+  "grep",
+  "web_fetch",
+  "todo_read",
+  "todo_write",
+  "report_progress"
+];
+var WfHttpError = class extends Error {
+  constructor(status, code, message) {
+    super(message);
+    this.status = status;
+    this.code = code;
+  }
+  status;
+  code;
+};
+var WfAborted = class extends Error {
+  constructor() {
+    super("cancelled by the delegating agent");
+  }
+};
+function resolveWrongForgeEndpoint(env = process.env) {
+  const url = (env["WRONGFORGE_URL"]?.trim() || DEFAULT_URL).replace(/\/+$/, "");
+  let apiKey = env["WRONGFORGE_API_KEY"]?.trim() || env["AGENT_API_KEY"]?.trim();
+  if (!apiKey) {
+    const home = env["WRONGFORGE_HOME"]?.trim() || path.join(homedir(), ".wrongforge");
+    try {
+      apiKey = readFileSync(path.join(home, "api-key"), "utf8").replace(/^\uFEFF/, "").trim();
+    } catch {
+      return void 0;
+    }
+  }
+  return apiKey && apiKey.length >= MIN_KEY_LENGTH ? { url, apiKey } : void 0;
+}
+var safeWfId = (s) => s.replace(/[^A-Za-z0-9._-]/g, "-").slice(0, 80);
+function wrongForgeCall(ep, doFetch = fetch) {
+  return async (method, route, body, signal) => {
+    let res;
+    try {
+      res = await doFetch(`${ep.url}${route}`, {
+        method,
+        headers: {
+          authorization: `Bearer ${ep.apiKey}`,
+          ...body !== void 0 ? { "content-type": "application/json" } : {}
+        },
+        ...body !== void 0 ? { body: JSON.stringify(body) } : {},
+        ...signal ? { signal } : {}
+      });
+    } catch (err) {
+      if (signal?.aborted) throw new WfAborted();
+      throw new WfHttpError(
+        0,
+        "unreachable",
+        `WrongForge is not reachable at ${ep.url} (${toErrorMessage(err)}); is \`npm run serve\` running?`
+      );
+    }
+    const text = await res.text();
+    let parsed;
+    try {
+      parsed = text ? JSON.parse(text) : {};
+    } catch {
+      parsed = {};
+    }
+    if (!res.ok) {
+      const e = parsed.error;
+      throw new WfHttpError(
+        res.status,
+        e?.code ?? `http_${res.status}`,
+        e?.message ?? text.slice(0, 300)
+      );
+    }
+    return parsed;
+  };
+}
+async function* followTask(call, taskId, signal, opts = {}) {
+  let after = 0;
+  let failures = 0;
+  for (; ; ) {
+    if (signal.aborted) throw new WfAborted();
+    let page;
+    try {
+      page = await call(
+        "GET",
+        `/v1/tasks/${encodeURIComponent(taskId)}/events?after=${after}&limit=${POLL_LIMIT}&wait_ms=${POLL_WAIT_MS}`,
+        void 0,
+        signal
+      );
+      failures = 0;
+    } catch (err) {
+      if (signal.aborted || err instanceof WfAborted) throw new WfAborted();
+      if (++failures >= MAX_POLL_FAILURES) throw err;
+      await sleep(opts.retryDelayMs ?? 2e3, signal);
+      continue;
+    }
+    for (const ev of page.events) yield ev;
+    if (page.status) opts.onPoll?.(page.status);
+    after = page.next_after;
+    if (page.terminal && page.events.length < POLL_LIMIT) return;
+  }
+}
+async function terminalTaskRecord(call, taskId, signal, opts = {}) {
+  let failures = 0;
+  for (; ; ) {
+    try {
+      return (await call(
+        "GET",
+        `/v1/tasks/${encodeURIComponent(taskId)}`,
+        void 0,
+        signal
+      )).task;
+    } catch (err) {
+      if (signal.aborted || err instanceof WfAborted) throw new WfAborted();
+      if (++failures >= MAX_POLL_FAILURES) throw err;
+      await sleep(opts.retryDelayMs ?? 2e3, signal);
+    }
+  }
+}
+function cancelTask(call, taskId, reason) {
+  void call("POST", `/v1/tasks/${encodeURIComponent(taskId)}/cancel`, { reason }).catch(
+    () => void 0
+  );
+}
+function chooseModel(requested, agentName, info) {
+  const id = requested?.trim();
+  if (!id || id === WRONGFORGE_AGENT_ID || id === agentName) return {};
+  if (info && info.models.length > 0) {
+    if (info.models.includes(id)) return { id };
+    return {
+      error: `WrongForge does not serve model "${id}"; it serves ${info.models.join(", ")}${info.defaultModel ? ` (default ${info.defaultModel})` : ""}`
+    };
+  }
+  return /^claude-[a-z0-9.-]+$/i.test(id) ? { id } : {};
+}
+function toProgress(ev) {
+  const d = ev.data;
+  const str = (v) => typeof v === "string" ? v : "";
+  const rec = (v) => v === void 0 ? void 0 : v && typeof v === "object" && !Array.isArray(v) ? v : { value: v };
+  switch (ev.type) {
+    case "task.started":
+      return [
+        {
+          type: "thought",
+          text: `[started] WrongForge \xB7 ${str(d["model"]) || "default model"} \xB7 ${str(d["workdir"])}
+`
+        }
+      ];
+    case "task.queued":
+      return str(d["waiting_for"]) ? [
+        {
+          type: "thought",
+          text: `[queued] WrongForge is busy (waiting for ${str(d["waiting_for"])})
+`
+        }
+      ] : [];
+    case "agent.text":
+      return str(d["text"]) ? [{ type: "message", text: str(d["text"]) }] : [];
+    case "agent.report":
+      return str(d["message"]) ? [{ type: "thought", text: `[progress] ${str(d["message"])}
+` }] : [];
+    case "tool.started":
+      return [
+        {
+          type: "tool_call",
+          toolCall: {
+            toolCallId: str(d["tool_call_id"]),
+            title: str(d["name"]),
+            status: "in_progress",
+            rawInput: rec(d["input"])
+          }
+        }
+      ];
+    case "tool.finished":
+    case "tool.failed": {
+      const failed = ev.type === "tool.failed" || d["ok"] === false;
+      return [
+        {
+          type: "tool_call_update",
+          toolCall: {
+            toolCallId: str(d["tool_call_id"]),
+            title: str(d["name"]),
+            status: failed ? "failed" : "completed",
+            rawOutput: ev.type === "tool.failed" ? { error: d["error"] } : rec(d["output"])
+          }
+        }
+      ];
+    }
+    case "agent.todos": {
+      const todos = Array.isArray(d["todos"]) ? d["todos"] : [];
+      return [
+        {
+          type: "plan",
+          entries: todos.map((t) => ({
+            content: str(t["content"]),
+            priority: "medium",
+            status: t["status"] === "completed" || t["status"] === "in_progress" ? t["status"] : "pending"
+          }))
+        }
+      ];
+    }
+    default:
+      return [];
+  }
+}
+function wfTokens(usage) {
+  return {
+    input: usage?.input_tokens ?? 0,
+    output: usage?.output_tokens ?? 0,
+    cacheRead: usage?.cache_read_tokens ?? 0,
+    cacheWrite: usage?.cache_write_tokens ?? 0
+  };
+}
+function sleep(ms, signal) {
+  if (signal.aborted) return Promise.resolve();
+  return new Promise((resolve) => {
+    const t = setTimeout(done, ms);
+    function done() {
+      clearTimeout(t);
+      signal.removeEventListener("abort", done);
+      resolve();
+    }
+    signal.addEventListener("abort", done, { once: true });
+  });
+}
+
+export {
+  WRONGFORGE_AGENT_ID,
+  WRONGFORGE_READ_SIDE_TOOLS,
+  WfHttpError,
+  WfAborted,
+  resolveWrongForgeEndpoint,
+  safeWfId,
+  wrongForgeCall,
+  followTask,
+  terminalTaskRecord,
+  cancelTask,
+  chooseModel,
+  toProgress,
+  wfTokens
+};
+//# sourceMappingURL=chunk-PGC44T7N.js.map

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