@50arms/platform-mcp 0.0.0-stage → 0.1.436

package/dist/json-body.js

@@ -0,0 +1,12 @@
+/**
+ * DX-2920 — the ONE place that reads a JSON body's top-level `.error` string.
+ *
+ * WHY THIS EXISTS. the stream client (`session-stream.ts`, classifying a mint refusal such as `409 session_is_worker`) reads a refusal's
+ * error code from the parsed body, and this is the one place that decides what "carries an error code" means. Generic: it knows no
+ * dashboard error name, only that a JSON object may carry a top-level string field named `error`.
+ */
+export function errorCodeOf(body) {
+    return typeof body === "object" && body !== null && typeof body.error === "string"
+        ? body.error
+        : null;
+}

package/dist/key-revoked-halt.js

@@ -0,0 +1,30 @@
+/**
+ * The revocation a `401 key_revoked` result carries, or null for any other result. A `key_revoked` refusal that does not
+ * say who revoked it and when is a contract breach and throws, like a terms refusal without its link.
+ */
+export function keyRevocationOf(result) {
+    if (result.ok || result.status !== 401)
+        return null;
+    const body = result.body;
+    if (body?.error !== "key_revoked")
+        return null;
+    if (typeof body.revokedBy !== "string" || typeof body.revokedAt !== "string") {
+        throw new Error("[platform-mcp] a key_revoked refusal carried no revokedBy / revokedAt");
+    }
+    return { revokedBy: body.revokedBy, revokedAt: body.revokedAt };
+}
+/**
+ * The one halt. `dispatched` is a dispatch's own credential: it makes no further call (every dashboard route, the
+ * dispatch-complete one included, refuses a revoked key; DX-4525), because the worker finds the revocation itself and ends the
+ * dispatch as revoked, not as the agent's failure (`src/worker/dispatch-execution.ts`). An operator session ends by telling the
+ * person; it has no tool that ends it.
+ */
+export function keyRevokedHalt(revocation, dispatched) {
+    const ending = dispatched
+        ? "Then stop and make no further call: the worker ends this dispatch itself and records it as revoked, not as a failure."
+        : "Then end this session: tell the person what you committed and stop.";
+    return (`STOP ALL WORK NOW. ${revocation.revokedBy} revoked your access to the 50 Arms dashboard at ${revocation.revokedAt}.\n\n` +
+        "Commit your work in progress now (commit what you have; do not run agent-finalize.sh and do not merge). " +
+        `${ending}\n\n` +
+        "Do not call plan_connect or any other 50 Arms dashboard tool again, do not request access again and do not look for another route.");
+}

package/dist/lifecycle.js

@@ -0,0 +1,113 @@
+/**
+ * DX-3465 (PLN-11 R-25) / DX-4525 - the "lifecycle" tool set: the one agent-specific dispatch callback that is
+ * still a dedicated tool, `50arms_slack_reply`.
+ *
+ * Every other dispatch callback is a `50arms_api` call: an agent makes
+ * the dispatch-complete, gate sign-off, evaluator-summary, template-app load / save, Slack update and
+ * recovery calls through it (`src/dispatch/callback-routes.ts` names each route), so a dispatch learns ONE channel to the dashboard and reads its
+ * spec instead of carrying a tool schema per job. This one stays a tool because it reads local files (`files[]`) and
+ * uploads their bytes, which no `50arms_api` call can do.
+ *
+ * Registered UNCONDITIONALLY at module load (so the DX-1606 tool-defs generator, which never calls `boot()`, still
+ * introspects it for token-cost accounting). Whether a session SEES it is decided by `toolsFor` (`tool-access.ts`) from the
+ * key's permissions and the callback URL present (`presentCallbacksFromEnv`), applied by `tool-surface.ts` (DX-4523).
+ */
+import { readFile, stat } from "node:fs/promises";
+import { basename, isAbsolute } from "node:path";
+import { z } from "zod";
+import { CALLBACK_ENV } from "./tool-access.js";
+import { CREDENTIAL_TOKEN_ENV } from "./credential.js";
+/** The callbacks whose URL the worker injected into this process's environment (an empty value reads as absent): what `toolsFor` takes as this dispatch's callbacks. */
+export function presentCallbacksFromEnv() {
+    return new Set(Object.keys(CALLBACK_ENV).filter((name) => (process.env[CALLBACK_ENV[name]] ?? "") !== ""));
+}
+async function postJson(url, body, bearer) {
+    return fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Authorization: `Bearer ${bearer}` },
+        body: JSON.stringify(body),
+    });
+}
+/**
+ * DX-4525 - the dispatch's own credential, the one `50arms_api` calls the dashboard with: a dispatch declares it in
+ * `DANX_DASHBOARD_CREDENTIAL` (`credential.ts`) and it never signs out. Read here, not through the late-bound `SessionAccess`,
+ * so the tool works wherever the module is imported; a missing one is a loud failure, never an unauthenticated post.
+ */
+function dispatchCredential(calledAs) {
+    const token = process.env[CREDENTIAL_TOKEN_ENV];
+    if (typeof token !== "string" || token.trim() === "") {
+        throw new Error(`${calledAs}: ${CREDENTIAL_TOKEN_ENV} is not set for this dispatch`);
+    }
+    return token.trim();
+}
+/** Must match `MAX_DECODED_BYTES` in danxbot's `src/issues/attachment-limits.ts` (duplicated, not imported: this package is published on its own). */
+const MAX_ATTACHMENT_BYTES = 25 * 1024 * 1024;
+/**
+ * DX-4251 — read each attached path HERE, in the MCP server process beside the
+ * agent, and return its bytes. The dashboard that serves the reply route can
+ * run on a different host than the agent (dedicated topology), so a path could
+ * never be resolved over there.
+ */
+async function readAttachments(paths) {
+    if (paths === undefined)
+        return [];
+    return Promise.all(paths.map(async (entry, idx) => {
+        if (!isAbsolute(entry)) {
+            throw new Error(`field "files"[${idx}] must be an absolute path (got "${entry}")`);
+        }
+        const info = await stat(entry);
+        // DX-4251: a directory stats as size 0 (Windows) or 4096 (Linux); name it, never read it as a file.
+        if (!info.isFile())
+            throw new Error(`field "files"[${idx}] "${entry}" is not a file`);
+        if (info.size === 0)
+            throw new Error(`field "files"[${idx}] "${entry}" is an empty file`);
+        if (info.size > MAX_ATTACHMENT_BYTES) {
+            throw new Error(`field "files"[${idx}] "${entry}" is ${info.size} bytes, over the ${MAX_ATTACHMENT_BYTES}-byte attachment limit`);
+        }
+        return { filename: basename(entry), base64: (await readFile(entry)).toString("base64") };
+    }));
+}
+/** A refused callback's body is the only place the server says why — relay it, never just the status. */
+async function responseFailure(label, response) {
+    const text = await response.text();
+    return new Error(`${label} returned HTTP ${response.status}${text ? `: ${text}` : ""}`);
+}
+/**
+ * Registers the lifecycle tool on `server` via the caller's `strictTool` wrapper (so it gets the same DX-3238 strict-shape
+ * guard the rest of this package's tools use).
+ */
+export function registerLifecycleTools(renamedTool) {
+    // ---------------- 50arms_slack_reply (and `danxbot_slack_reply` until DX-6864) ----------------
+    renamedTool("50arms_slack_reply", 
+    // DX-4253 — no ordering against another tool here: the Slack persona (`src/agent/persona.ts`) and the
+    // `slack-agent` profile own the order (reply, link, attach, complete).
+    "Post the final user-facing reply to the originating Slack thread, once per dispatch. Files in `files[]` " +
+        "post with the text as one thread message. For a progress update, `50arms_api` `POST /api/slack/update` `{text}`.", {
+        text: z.string().describe("The final reply text to post to the Slack thread."),
+        files: z
+            .array(z.string())
+            .optional()
+            .describe("Absolute paths of your own files to attach; bytes are uploaded."),
+    }, (calledAs) => async (args) => {
+        const url = process.env[CALLBACK_ENV.slackReply];
+        if (!url)
+            throw new Error(`${calledAs} called outside a Slack dispatch`);
+        const files = await readAttachments(args.files);
+        const body = { text: args.text };
+        if (files.length > 0)
+            body.files = files;
+        const response = await postJson(url, body, dispatchCredential(calledAs));
+        if (!response.ok)
+            throw await responseFailure("Slack reply API", response);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: files.length > 0
+                        ? `Reply posted to Slack thread with ${files.length} file(s)`
+                        : "Reply posted to Slack thread",
+                },
+            ],
+        };
+    });
+}