signafaide-mcp 0.0.0-stage → 0.2.1

package/README.md

@@ -1,3 +1,18 @@
-# Temporary Holding Version
+# signafaide-mcp
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The signafAIde MCP server for coding agents, over stdio. It is a separate package so that
+`npm install signafaide` stays small: the SDK itself never needs the MCP SDK or zod.
+
+`npx signafaide agent setup` installs it for you in each coding agent's configuration, pinned to
+the SDK's version:
+
+```json
+{"command": "npx", "args": ["-y", "signafaide-mcp@0.2.1"]}
+```
+
+Tools: `signafaide_setup` (previews the install command and code edit, changes nothing),
+`signafaide_verify`, `signafaide_status`, `signafaide_explain_error`, and `signafaide_init`
+(creates the external sandbox; call it only after the user has agreed, with
+`confirm_user_agreed: true` and `user_words`, what the user wrote; without both it creates nothing).
+
+Apache-2.0. Source: the `js/` folder of the signafAIde SDK repository.

package/dist/chunk-T43S3SPH.js

@@ -0,0 +1,187 @@
+// src/version.ts
+var VERSION = "0.2.1";
+
+// src/telemetry.ts
+var HEADER = "X-Signafaide-Client";
+var SDK = "signafaide-js";
+var ADAPTERS = /* @__PURE__ */ new Set();
+var processEnv = () => typeof process !== "undefined" && process.env ? process.env : {};
+var hasPrefix = (env, prefix, skip = []) => Object.keys(env).some((k) => k.startsWith(prefix) && !skip.some((s) => k.startsWith(s)));
+var term = (env) => (env.TERM_PROGRAM ?? "").toLowerCase();
+var AGENTS = [
+  ["claude-code", (e) => e.CLAUDECODE === "1" || hasPrefix(e, "CLAUDE_CODE_")],
+  ["codex", (e) => hasPrefix(e, "CODEX_", ["CODEX_COMPANION_"])],
+  ["gemini-cli", (e) => hasPrefix(e, "GEMINI_CLI")],
+  ["copilot", (e) => hasPrefix(e, "COPILOT_") || hasPrefix(e, "GITHUB_COPILOT_")],
+  ["windsurf", (e) => hasPrefix(e, "WINDSURF_") || term(e) === "windsurf"],
+  ["cursor", (e) => hasPrefix(e, "CURSOR_") || term(e) === "cursor"]
+];
+function detectAgent(env = processEnv()) {
+  return AGENTS.find(([, test]) => test(env))?.[0] ?? "unknown";
+}
+function telemetryEnabled(env = processEnv()) {
+  return (env.SIGNAFAIDE_TELEMETRY ?? "").trim() !== "0";
+}
+function adapterField() {
+  return [...ADAPTERS].sort().join(",") || "none";
+}
+function runtimeName() {
+  const g = globalThis;
+  if (g.Bun?.version) return `bun ${g.Bun.version}`;
+  if (g.Deno?.version?.deno) return `deno ${g.Deno.version.deno}`;
+  if (typeof process !== "undefined" && process.versions?.node) return `node ${process.versions.node}`;
+  return "js unknown";
+}
+function clientHeader(opts = {}) {
+  const on = telemetryEnabled(opts.env);
+  const parts = [runtimeName()];
+  if (on) parts.push(`adapter=${opts.adapter || "none"}`, `agent=${opts.agent || "unknown"}`);
+  parts.push(`via=${opts.via ?? "sdk"}`);
+  if (on && opts.strict) parts.push("strict=1");
+  return `${SDK}/${VERSION} (${parts.join("; ")})`;
+}
+
+// src/http.ts
+var DEFAULT_URL = "https://api.signafaide.co.uk";
+var NON_RETRYABLE = /* @__PURE__ */ new Set(["quota_exceeded", "invalid_key", "plan_required", "bad_signature", "invalid_record", "content_mismatch", "chain_conflict", "unknown_agent", "key_mismatch", "bad_response"]);
+var fetchTransport = async (req) => {
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(new Error("timeout")), req.timeoutMs);
+  const onAbort = () => ctrl.abort(new Error("aborted"));
+  if (req.signal?.aborted) onAbort();
+  else req.signal?.addEventListener("abort", onAbort, { once: true });
+  try {
+    const resp = await fetch(req.url, { method: req.method, headers: req.headers, body: req.body, signal: ctrl.signal });
+    return { status: resp.status, contentType: resp.headers.get("content-type") ?? "", text: await resp.text() };
+  } finally {
+    clearTimeout(timer);
+    req.signal?.removeEventListener("abort", onAbort);
+  }
+};
+var SignafaideError = class extends Error {
+  code;
+  status;
+  docs;
+  body;
+  constructor(message, opts = {}) {
+    super(message);
+    this.name = "SignafaideError";
+    this.code = opts.code ?? "error";
+    this.status = opts.status ?? 0;
+    this.docs = opts.docs;
+    this.body = opts.body ?? {};
+  }
+  get retryable() {
+    return this.code === "network" || this.code === "rate_limited" || this.status >= 500;
+  }
+  /** The service refused for a reason retrying cannot change (quota, key, revoked agent key...). */
+  get permanent() {
+    return !this.retryable && NON_RETRYABLE.has(this.code);
+  }
+};
+var Client = class {
+  constructor(url = DEFAULT_URL, apiKey, timeoutMs = 1e4, clientId, opts = {}) {
+    this.apiKey = apiKey;
+    this.timeoutMs = timeoutMs;
+    this.url = url.replace(/\/+$/, "");
+    this.clientId = clientId ?? clientHeader({});
+    this.transport = opts.transport ?? fetchTransport;
+    this.signal = opts.signal;
+    this.timeoutLabel = opts.timeoutLabel;
+  }
+  apiKey;
+  timeoutMs;
+  url;
+  clientId;
+  transport;
+  signal;
+  /** Said instead of "no answer within <timeout> s" when the request shares a larger limit. */
+  timeoutLabel;
+  async request(method, path, opts = {}) {
+    const auth = opts.auth ?? true;
+    let url = this.url + path;
+    const q = Object.entries(opts.query ?? {}).filter((e) => e[1] != null);
+    if (q.length) url += "?" + new URLSearchParams(q).toString();
+    const headers = { Accept: "application/json", [HEADER]: this.clientId };
+    if (typeof process !== "undefined" && process.versions?.node) headers["User-Agent"] = `signafaide-js/${VERSION}`;
+    if (opts.body !== void 0) headers["Content-Type"] = "application/json";
+    if (auth) {
+      if (!this.apiKey) throw new SignafaideError("No API key: run `signafaide init` or set SIGNAFAIDE_API_KEY.", { code: "invalid_key" });
+      headers.Authorization = `Bearer ${this.apiKey}`;
+    }
+    let resp;
+    try {
+      resp = await this.transport({ method, url, headers, body: opts.body === void 0 ? void 0 : JSON.stringify(opts.body), timeoutMs: this.timeoutMs, signal: this.signal });
+    } catch (e) {
+      const err = e;
+      const raw = err.cause?.code ?? err.code ?? err.message ?? String(e);
+      const reason = /abort|timeout/i.test(`${err.name} ${raw}`) ? this.timeoutLabel ?? `no answer within ${this.timeoutMs / 1e3} s` : raw;
+      throw new SignafaideError(`Cannot reach the signafAIde service at ${this.url} (${reason}); check the network or SIGNAFAIDE_URL.`, { code: "network" });
+    }
+    const { status, text, contentType: ctype } = resp;
+    if (status < 200 || status >= 300) throw serviceError(status, text);
+    return ctype.includes("json") || /^[[{]/.test(text) ? JSON.parse(text) : text;
+  }
+  sandbox() {
+    return this.request("POST", "/v1/sandbox", { body: {}, auth: false });
+  }
+  /** §2.4: the registration with its proof of possession (and rotation signature). */
+  registerAgent(name, publicKey, validFrom, proof, rotation) {
+    return this.request("POST", "/v1/agents", { body: { name, public_key: publicKey, valid_from: validFrom, proof, ...rotation ? { rotation } : {} } });
+  }
+  /** `{project, env}` of this API key (§6). */
+  project() {
+    return this.request("GET", "/v1/project");
+  }
+  submit(records) {
+    return this.request("POST", "/v1/records", { body: { records } });
+  }
+  head(agent) {
+    return this.request("GET", `/v1/heads/${encodeURIComponent(agent)}`);
+  }
+  /** `{record, receipt, anchor}` of one record of the key's project. */
+  record(recordHash) {
+    return this.request("GET", `/v1/records/${encodeURIComponent(recordHash)}`);
+  }
+  /** A verification pack (§7) of the whole project, or of one agent. */
+  export(agent, from, to) {
+    return this.request("GET", "/v1/export", { query: { agent, from, to } });
+  }
+  usage() {
+    return this.request("GET", "/v1/usage");
+  }
+  /** Usage event (`verify`, `export`). Not part of SPEC §6 yet. */
+  async event(name) {
+    await this.request("POST", "/v1/events", { body: { name }, auth: !!this.apiKey });
+  }
+  serviceKeys() {
+    return this.request("GET", "/.well-known/signafaide-keys.json", { auth: false });
+  }
+};
+function serviceError(status, text) {
+  try {
+    const body = JSON.parse(text);
+    const err = body.error;
+    if (typeof err?.message === "string") return new SignafaideError(err.message, { code: err.code ?? "error", status, docs: err.docs, body });
+  } catch {
+  }
+  return new SignafaideError(`The service answered HTTP ${status}: ${text.trim().slice(0, 200) || "no body"}.`, { code: "http_error", status });
+}
+async function fetchJson(url, timeoutMs = 1e4) {
+  const u = new URL(url);
+  return new Client(u.origin, void 0, timeoutMs, `signafaide-js/${VERSION}`).request("GET", u.pathname + u.search, { auth: false });
+}
+
+export {
+  VERSION,
+  detectAgent,
+  telemetryEnabled,
+  adapterField,
+  clientHeader,
+  DEFAULT_URL,
+  NON_RETRYABLE,
+  fetchTransport,
+  SignafaideError,
+  Client,
+  fetchJson
+};