autoremediator 0.21.1 → 0.22.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rawlings
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -67,10 +67,15 @@ fixed that was not verified.
 | **CLI and [SDK](docs/reference/sdk.md)** | Local runs, scripts, pipelines |
 | **[GitHub Action](docs/integrations/github-action.md)** | A nightly pull request that fixes what audit finds |
 | **[GitHub App](docs/integrations/github-app.md)** | Remediation across every repository you install it on |
+| **[Coding agents](docs/integrations/coding-agents.md)** | `npx autoremediator init` sets up Claude Code, Cursor, VS Code, Copilot, Codex and Gemini CLI; a Claude Code plugin is included |
+| **[Other CI](docs/integrations/other-ci.md)** | GitLab, Bitbucket Pipelines, Azure DevOps, Docker and Dagger |
+| **[A2A](docs/integrations/a2a.md)** | An Agent2Agent card and endpoint so other agents can delegate to it |
 | **[MCP server](docs/integrations/mcp-server.md)** | Give your editor or agent a safe way to fix dependencies |
 | **[HTTP server](docs/integrations/http-server.md)** | Call it from internal services |
 | **[VS Code](packages/vscode-extension/README.md)** | Findings and one-click fixes in `package.json` |
 
+Beyond fixing a CVE: assemble a [CRA evidence pack](docs/guides/evidence-pack.md), have a model write and prove an [exploit reproduction](docs/guides/proof-of-fix-generation.md), spot [silent security fixes](docs/guides/silent-fix-radar.md), keep dependencies [fresh](docs/guides/freshness.md) in small verified steps, and compile rules into a [policy](docs/guides/policy-in-plain-language.md). Also: [guard](docs/guides/guard.md) packages before an agent installs them, [diet](docs/guides/dependency-diet.md) what you depend on, [bisect](docs/guides/bisect.md) a broken lockfile, respond to a [compromised package](docs/guides/incident-response.md), and let a repository [earn autonomy](docs/guides/earned-autonomy.md).
+
 Works with npm, pnpm, Yarn, Bun and Deno projects. Requires Node.js 26 or later.
 
 > [!WARNING]

package/dist/a2a/agent-card.d.ts

@@ -0,0 +1,89 @@
+/**
+ * A2A (Agent2Agent) Agent Card, protocol version 1.0.
+ *
+ * Field names and shapes follow the A2A 1.0.0 specification (section 4.4, "Agent Discovery
+ * Objects") and its normative proto (`a2a.proto`, package `lf.a2a.v1`) in JSON form. Nothing here
+ * adds a field the specification does not define. See `docs/integrations/a2a.md` for sources.
+ */
+import { type Operation } from "../catalog/index.js";
+/** The A2A protocol version the card advertises and the endpoint implements. */
+export declare const A2A_PROTOCOL_VERSION = "1.0";
+/** Where the card is served (A2A 1.0 section 8.2). */
+export declare const AGENT_CARD_PATH = "/.well-known/agent-card.json";
+/** Where the JSON-RPC binding is served. The card's `supportedInterfaces` points here. */
+export declare const A2A_ENDPOINT_PATH = "/a2a";
+/** Key of the bearer scheme in `securitySchemes`. */
+export declare const BEARER_SCHEME_NAME = "bearerAuth";
+export interface AgentInterface {
+    url: string;
+    protocolBinding: string;
+    protocolVersion: string;
+}
+export interface AgentSkill {
+    id: string;
+    name: string;
+    description: string;
+    tags: string[];
+    inputModes: string[];
+    outputModes: string[];
+}
+export interface AgentCardSignature {
+    /** Base64url of the JSON protected header (`alg`, `typ`, `kid`). */
+    protected: string;
+    /** Base64url of the JWS signature. */
+    signature: string;
+}
+export interface SecurityRequirement {
+    schemes: Record<string, {
+        list: string[];
+    }>;
+}
+export interface SecurityScheme {
+    httpAuthSecurityScheme: {
+        description?: string;
+        scheme: string;
+        bearerFormat?: string;
+    };
+}
+export interface AgentCard {
+    name: string;
+    description: string;
+    supportedInterfaces: AgentInterface[];
+    provider: {
+        organization: string;
+        url: string;
+    };
+    version: string;
+    documentationUrl: string;
+    capabilities: {
+        streaming: boolean;
+        pushNotifications: boolean;
+        extendedAgentCard: boolean;
+    };
+    securitySchemes: Record<string, SecurityScheme>;
+    securityRequirements: SecurityRequirement[];
+    defaultInputModes: string[];
+    defaultOutputModes: string[];
+    skills: AgentSkill[];
+    signatures?: AgentCardSignature[];
+}
+/**
+ * The operations offered over A2A: a curated subset of the catalog. Anything that edits the project
+ * outside a run's own plan/apply flow (rollback, attempts, portfolio, jobs) stays on the HTTP API
+ * and MCP.
+ */
+export declare const A2A_SKILL_NAMES: readonly ["remediate", "planRemediation", "remediateFromScan", "guardPackage", "evaluatePackage", "scanDelta", "checkReachability", "verifyRun", "getRun", "listRuns", "toVex"];
+/** The catalog operations behind the A2A skills. Throws if the catalog no longer has one. */
+export declare function a2aSkillOperations(): Operation[];
+/** Strip trailing slashes; only an absolute http(s) URL is a usable base. */
+export declare function normalizeBaseUrl(baseUrl: string): string;
+/**
+ * Build the Agent Card. Pure: the same inputs give the same card. Skills come from catalog
+ * operations, so ids, names and descriptions cannot drift from what the server runs.
+ */
+export declare function buildAgentCard(input: {
+    baseUrl: string;
+    version: string;
+    skills?: readonly Operation[];
+}): AgentCard;
+//# sourceMappingURL=agent-card.d.ts.map

package/dist/a2a/agent-card.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-card.d.ts","sourceRoot":"","sources":["../../src/a2a/agent-card.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAyB,KAAK,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAE5E,gFAAgF;AAChF,eAAO,MAAM,oBAAoB,QAAQ,CAAC;AAE1C,sDAAsD;AACtD,eAAO,MAAM,eAAe,iCAAiC,CAAC;AAE9D,0FAA0F;AAC1F,eAAO,MAAM,iBAAiB,SAAS,CAAC;AAExC,qDAAqD;AACrD,eAAO,MAAM,kBAAkB,eAAe,CAAC;AAM/C,MAAM,WAAW,cAAc;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,eAAe,EAAE,MAAM,CAAC;IACxB,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB;AAED,MAAM,WAAW,kBAAkB;IACjC,oEAAoE;IACpE,SAAS,EAAE,MAAM,CAAC;IAClB,sCAAsC;IACtC,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC;CAC7C;AAED,MAAM,WAAW,cAAc;IAC7B,sBAAsB,EAAE;QAAE,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CACzF;AAED,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,mBAAmB,EAAE,cAAc,EAAE,CAAC;IACtC,QAAQ,EAAE;QAAE,YAAY,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC;IAChD,OAAO,EAAE,MAAM,CAAC;IAChB,gBAAgB,EAAE,MAAM,CAAC;IACzB,YAAY,EAAE;QACZ,SAAS,EAAE,OAAO,CAAC;QACnB,iBAAiB,EAAE,OAAO,CAAC;QAC3B,iBAAiB,EAAE,OAAO,CAAC;KAC5B,CAAC;IACF,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IAChD,oBAAoB,EAAE,mBAAmB,EAAE,CAAC;IAC5C,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,kBAAkB,EAAE,MAAM,EAAE,CAAC;IAC7B,MAAM,EAAE,UAAU,EAAE,CAAC;IACrB,UAAU,CAAC,EAAE,kBAAkB,EAAE,CAAC;CACnC;AAED;;;;GAIG;AACH,eAAO,MAAM,eAAe,YAC1B,WAAW,EACX,iBAAiB,EACjB,mBAAmB,EACnB,cAAc,EACd,iBAAiB,EACjB,WAAW,EACX,mBAAmB,EACnB,WAAW,EACX,QAAQ,EACR,UAAU,EACV,OAAO,CACC,CAAC;AAgBX,6FAA6F;AAC7F,wBAAgB,kBAAkB,IAAI,SAAS,EAAE,CAMhD;AAED,6EAA6E;AAC7E,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAWxD;AAcD;;;GAGG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE;IACpC,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,SAAS,SAAS,EAAE,CAAC;CAC/B,GAAG,SAAS,CAyCZ"}

package/dist/a2a/agent-card.js

@@ -0,0 +1,127 @@
+/**
+ * A2A (Agent2Agent) Agent Card, protocol version 1.0.
+ *
+ * Field names and shapes follow the A2A 1.0.0 specification (section 4.4, "Agent Discovery
+ * Objects") and its normative proto (`a2a.proto`, package `lf.a2a.v1`) in JSON form. Nothing here
+ * adds a field the specification does not define. See `docs/integrations/a2a.md` for sources.
+ */
+import { getOperation, roleFor } from "../catalog/index.js";
+/** The A2A protocol version the card advertises and the endpoint implements. */
+export const A2A_PROTOCOL_VERSION = "1.0";
+/** Where the card is served (A2A 1.0 section 8.2). */
+export const AGENT_CARD_PATH = "/.well-known/agent-card.json";
+/** Where the JSON-RPC binding is served. The card's `supportedInterfaces` points here. */
+export const A2A_ENDPOINT_PATH = "/a2a";
+/** Key of the bearer scheme in `securitySchemes`. */
+export const BEARER_SCHEME_NAME = "bearerAuth";
+const JSON_MEDIA_TYPE = "application/json";
+const PROJECT_URL = "https://github.com/Rawlings/autoremediator";
+/**
+ * The operations offered over A2A: a curated subset of the catalog. Anything that edits the project
+ * outside a run's own plan/apply flow (rollback, attempts, portfolio, jobs) stays on the HTTP API
+ * and MCP.
+ */
+export const A2A_SKILL_NAMES = [
+    "remediate",
+    "planRemediation",
+    "remediateFromScan",
+    "guardPackage",
+    "evaluatePackage",
+    "scanDelta",
+    "checkReachability",
+    "verifyRun",
+    "getRun",
+    "listRuns",
+    "toVex",
+];
+const SKILL_TAGS = {
+    remediate: ["vulnerability", "remediation", "npm", "cve"],
+    planRemediation: ["vulnerability", "remediation", "planning", "cve"],
+    remediateFromScan: ["vulnerability", "remediation", "scanner", "sarif"],
+    guardPackage: ["supply-chain", "malware", "npm", "install-guard"],
+    evaluatePackage: ["supply-chain", "npm", "package-health"],
+    scanDelta: ["vulnerability", "git", "delta"],
+    checkReachability: ["vulnerability", "reachability", "triage"],
+    verifyRun: ["verification", "remediation", "runs"],
+    getRun: ["runs", "audit"],
+    listRuns: ["runs", "audit"],
+    toVex: ["vex", "cyclonedx", "reporting"],
+};
+/** The catalog operations behind the A2A skills. Throws if the catalog no longer has one. */
+export function a2aSkillOperations() {
+    return A2A_SKILL_NAMES.map((name) => {
+        const operation = getOperation(name);
+        if (!operation)
+            throw new Error(`A2A skill "${name}" is not in the operation catalog`);
+        return operation;
+    });
+}
+/** Strip trailing slashes; only an absolute http(s) URL is a usable base. */
+export function normalizeBaseUrl(baseUrl) {
+    let parsed;
+    try {
+        parsed = new URL(baseUrl);
+    }
+    catch {
+        throw new Error(`Invalid base URL: ${baseUrl}`);
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        throw new Error(`Base URL must be http or https: ${baseUrl}`);
+    }
+    return `${parsed.origin}${parsed.pathname.replace(/\/+$/, "")}`;
+}
+function toSkill(operation) {
+    const tags = SKILL_TAGS[operation.name] ?? [operation.name];
+    return {
+        id: operation.name,
+        name: operation.title,
+        description: `${operation.description} Requires the "${roleFor(operation)}" role.`,
+        tags,
+        inputModes: [JSON_MEDIA_TYPE],
+        outputModes: [JSON_MEDIA_TYPE],
+    };
+}
+/**
+ * Build the Agent Card. Pure: the same inputs give the same card. Skills come from catalog
+ * operations, so ids, names and descriptions cannot drift from what the server runs.
+ */
+export function buildAgentCard(input) {
+    const baseUrl = normalizeBaseUrl(input.baseUrl);
+    const operations = input.skills ?? a2aSkillOperations();
+    return {
+        name: "autoremediator",
+        description: "Remediates vulnerable npm dependencies and screens packages before an agent installs them. " +
+            "Delegate by sending a SendMessage request whose message carries one data part " +
+            '{"operation": <skill id>, "input": {...}}; the operation runs and its result comes back as a ' +
+            "JSON artifact on a completed task. Skills map one-to-one to operations of the " +
+            "autoremediator HTTP API and MCP server. Streaming, push notifications and an extended card " +
+            "are not supported.",
+        supportedInterfaces: [
+            {
+                url: `${baseUrl}${A2A_ENDPOINT_PATH}`,
+                protocolBinding: "JSONRPC",
+                protocolVersion: A2A_PROTOCOL_VERSION,
+            },
+        ],
+        provider: { organization: "Rawlings", url: PROJECT_URL },
+        version: input.version,
+        documentationUrl: `${PROJECT_URL}/blob/master/docs/integrations/a2a.md`,
+        capabilities: { streaming: false, pushNotifications: false, extendedAgentCard: false },
+        securitySchemes: {
+            [BEARER_SCHEME_NAME]: {
+                httpAuthSecurityScheme: {
+                    description: "Bearer token: either a static token from AUTOREMEDIATOR_API_TOKENS or an HS256 JWT " +
+                        "with a role claim (admin, operator or reader). The role decides which skills a token " +
+                        "may use; each skill's description names the role it needs.",
+                    scheme: "Bearer",
+                    bearerFormat: "JWT",
+                },
+            },
+        },
+        securityRequirements: [{ schemes: { [BEARER_SCHEME_NAME]: { list: [] } } }],
+        defaultInputModes: [JSON_MEDIA_TYPE],
+        defaultOutputModes: [JSON_MEDIA_TYPE],
+        skills: operations.map((operation) => toSkill(operation)),
+    };
+}
+//# sourceMappingURL=agent-card.js.map

package/dist/a2a/agent-card.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-card.js","sourceRoot":"","sources":["../../src/a2a/agent-card.ts"],"names":[],"mappings":"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"}

package/dist/a2a/index.d.ts

@@ -0,0 +1,7 @@
+export { A2A_ENDPOINT_PATH, A2A_PROTOCOL_VERSION, A2A_SKILL_NAMES, AGENT_CARD_PATH, BEARER_SCHEME_NAME, a2aSkillOperations, buildAgentCard, normalizeBaseUrl, } from "./agent-card.js";
+export type { AgentCard, AgentCardSignature, AgentInterface, AgentSkill, SecurityRequirement, SecurityScheme, } from "./agent-card.js";
+export { agentCardFor, handleA2aRequest, handleAgentCardRequest, resolveBaseUrl, } from "./server.js";
+export type { A2aTask } from "./server.js";
+export { canonicalize, signAgentCard, signingKeyFromEnv, signingKeyFromPem, verifyAgentCard, } from "./sign.js";
+export type { JwsAlgorithm, SigningKey } from "./sign.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/a2a/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/a2a/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,oBAAoB,EACpB,eAAe,EACf,eAAe,EACf,kBAAkB,EAClB,kBAAkB,EAClB,cAAc,EACd,gBAAgB,GACjB,MAAM,iBAAiB,CAAC;AACzB,YAAY,EACV,SAAS,EACT,kBAAkB,EAClB,cAAc,EACd,UAAU,EACV,mBAAmB,EACnB,cAAc,GACf,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,YAAY,EACZ,gBAAgB,EAChB,sBAAsB,EACtB,cAAc,GACf,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EACL,YAAY,EACZ,aAAa,EACb,iBAAiB,EACjB,iBAAiB,EACjB,eAAe,GAChB,MAAM,WAAW,CAAC;AACnB,YAAY,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC"}

package/dist/a2a/index.js

@@ -0,0 +1,4 @@
+export { A2A_ENDPOINT_PATH, A2A_PROTOCOL_VERSION, A2A_SKILL_NAMES, AGENT_CARD_PATH, BEARER_SCHEME_NAME, a2aSkillOperations, buildAgentCard, normalizeBaseUrl, } from "./agent-card.js";
+export { agentCardFor, handleA2aRequest, handleAgentCardRequest, resolveBaseUrl, } from "./server.js";
+export { canonicalize, signAgentCard, signingKeyFromEnv, signingKeyFromPem, verifyAgentCard, } from "./sign.js";
+//# sourceMappingURL=index.js.map

package/dist/a2a/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/a2a/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,oBAAoB,EACpB,eAAe,EACf,eAAe,EACf,kBAAkB,EAClB,kBAAkB,EAClB,cAAc,EACd,gBAAgB,GACjB,MAAM,iBAAiB,CAAC;AASzB,OAAO,EACL,YAAY,EACZ,gBAAgB,EAChB,sBAAsB,EACtB,cAAc,GACf,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,YAAY,EACZ,aAAa,EACb,iBAAiB,EACjB,iBAAiB,EACjB,eAAe,GAChB,MAAM,WAAW,CAAC"}

package/dist/a2a/server.d.ts

@@ -0,0 +1,46 @@
+import type http from "node:http";
+import { type ApiDeps } from "../catalog/index.js";
+import { type AgentCard } from "./agent-card.js";
+type TaskState = "TASK_STATE_COMPLETED" | "TASK_STATE_FAILED";
+interface A2aPart {
+    text?: string;
+    data?: unknown;
+    mediaType?: string;
+}
+interface A2aMessage {
+    messageId: string;
+    contextId?: string;
+    taskId?: string;
+    role: string;
+    parts: A2aPart[];
+}
+export interface A2aTask {
+    id: string;
+    contextId: string;
+    status: {
+        state: TaskState;
+        message?: A2aMessage;
+        timestamp: string;
+    };
+    artifacts?: Array<{
+        artifactId: string;
+        name: string;
+        parts: A2aPart[];
+    }>;
+    history?: A2aMessage[];
+    metadata?: Record<string, unknown>;
+}
+/**
+ * The URL the card advertises: `AUTOREMEDIATOR_A2A_BASE_URL` when set (use it behind a TLS proxy),
+ * otherwise the request's `Host` over http. The caller has already checked the host against the
+ * allowed list; the shape check here keeps userinfo or paths out of the advertised URL.
+ */
+export declare function resolveBaseUrl(req: http.IncomingMessage, env?: NodeJS.ProcessEnv): string;
+/** The card for this request, signed when `AUTOREMEDIATOR_A2A_SIGNING_KEY` is set. */
+export declare function agentCardFor(req: http.IncomingMessage, env?: NodeJS.ProcessEnv): AgentCard;
+/** `GET /.well-known/agent-card.json`: public, like `/health` and `/openapi.json`. */
+export declare function handleAgentCardRequest(req: http.IncomingMessage, res: http.ServerResponse): void;
+/** `POST /a2a`: the JSON-RPC endpoint the Agent Card's `supportedInterfaces` points at. */
+export declare function handleA2aRequest(req: http.IncomingMessage, res: http.ServerResponse, deps?: Partial<ApiDeps>): Promise<void>;
+export {};
+//# sourceMappingURL=server.d.ts.map

package/dist/a2a/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/a2a/server.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAElC,OAAO,EAIL,KAAK,OAAO,EAEb,MAAM,qBAAqB,CAAC;AAK7B,OAAO,EAKL,KAAK,SAAS,EACf,MAAM,iBAAiB,CAAC;AAoBzB,KAAK,SAAS,GAAG,sBAAsB,GAAG,mBAAmB,CAAC;AAE9D,UAAU,OAAO;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,UAAU,UAAU;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,OAAO,EAAE,CAAC;CAClB;AAED,MAAM,WAAW,OAAO;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE;QAAE,KAAK,EAAE,SAAS,CAAC;QAAC,OAAO,CAAC,EAAE,UAAU,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;IACtE,SAAS,CAAC,EAAE,KAAK,CAAC;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,OAAO,EAAE,CAAA;KAAE,CAAC,CAAC;IAC1E,OAAO,CAAC,EAAE,UAAU,EAAE,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAQD;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,GAAG,EAAE,IAAI,CAAC,eAAe,EACzB,GAAG,GAAE,MAAM,CAAC,UAAwB,GACnC,MAAM,CAKR;AAED,sFAAsF;AACtF,wBAAgB,YAAY,CAC1B,GAAG,EAAE,IAAI,CAAC,eAAe,EACzB,GAAG,GAAE,MAAM,CAAC,UAAwB,GACnC,SAAS,CAIX;AAED,sFAAsF;AACtF,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,IAAI,CAAC,eAAe,EAAE,GAAG,EAAE,IAAI,CAAC,cAAc,GAAG,IAAI,CAEhG;AAoQD,2FAA2F;AAC3F,wBAAsB,gBAAgB,CACpC,GAAG,EAAE,IAAI,CAAC,eAAe,EACzB,GAAG,EAAE,IAAI,CAAC,cAAc,EACxB,IAAI,GAAE,OAAO,CAAC,OAAO,CAAM,GAC1B,OAAO,CAAC,IAAI,CAAC,CAyDf"}

package/dist/a2a/server.js

@@ -0,0 +1,312 @@
+/**
+ * A2A over the HTTP server: the public Agent Card, and a JSON-RPC 2.0 endpoint implementing the two
+ * methods of the 1.0 binding autoremediator supports, `SendMessage` and `GetTask`.
+ *
+ * A `SendMessage` message carries a data part `{"operation": <skill id>, "input": {...}}`. The
+ * operation runs to completion before the reply, so a reply is always a task in a terminal state.
+ * Authorization is the HTTP API's: the same bearer tokens, the role `roleFor` assigns the operation,
+ * and the same path confinement.
+ */
+import { randomUUID } from "node:crypto";
+import { defaultApiDeps, inputJsonSchema, roleFor, } from "../catalog/index.js";
+import { authorizeRole, callerIdentity } from "../platform/http-auth.js";
+import { HttpError, readBody, sendJson } from "../platform/http-security.js";
+import { confinePaths, getAllowedRoots, PathNotAllowedError } from "../platform/path-guard.js";
+import { PACKAGE_VERSION } from "../version.js";
+import { A2A_PROTOCOL_VERSION, a2aSkillOperations, buildAgentCard, normalizeBaseUrl, } from "./agent-card.js";
+import { signAgentCard, signingKeyFromEnv } from "./sign.js";
+import { TaskStore, truncateMessage } from "./task-store.js";
+const JSON_MEDIA_TYPE = "application/json";
+/** JSON-RPC 2.0 and A2A error codes (A2A 1.0 sections 5.4 and 9.5). */
+const ERROR = {
+    parse: -32_700,
+    invalidRequest: -32_600,
+    methodNotFound: -32_601,
+    invalidParams: -32_602,
+    taskNotFound: -32_001,
+    unsupportedOperation: -32_004,
+    contentTypeNotSupported: -32_005,
+    versionNotSupported: -32_009,
+};
+// ---------------------------------------------------------------------------
+// Agent Card
+// ---------------------------------------------------------------------------
+const SAFE_HOST = /^(?:\[[0-9a-f:.]+\]|[a-z0-9.-]+)(?::\d{1,5})?$/i;
+/**
+ * The URL the card advertises: `AUTOREMEDIATOR_A2A_BASE_URL` when set (use it behind a TLS proxy),
+ * otherwise the request's `Host` over http. The caller has already checked the host against the
+ * allowed list; the shape check here keeps userinfo or paths out of the advertised URL.
+ */
+export function resolveBaseUrl(req, env = process.env) {
+    const configured = env["AUTOREMEDIATOR_A2A_BASE_URL"];
+    if (configured)
+        return normalizeBaseUrl(configured);
+    const host = req.headers.host ?? "";
+    return SAFE_HOST.test(host) ? `http://${host}` : "http://127.0.0.1";
+}
+/** The card for this request, signed when `AUTOREMEDIATOR_A2A_SIGNING_KEY` is set. */
+export function agentCardFor(req, env = process.env) {
+    const card = buildAgentCard({ baseUrl: resolveBaseUrl(req, env), version: PACKAGE_VERSION });
+    const key = signingKeyFromEnv(env);
+    return key ? signAgentCard(card, key) : card;
+}
+/** `GET /.well-known/agent-card.json`: public, like `/health` and `/openapi.json`. */
+export function handleAgentCardRequest(req, res) {
+    sendJson(res, 200, agentCardFor(req));
+}
+// ---------------------------------------------------------------------------
+// Tasks
+// ---------------------------------------------------------------------------
+const TASK_TTL_MS = 60 * 60 * 1000;
+/** One result larger than this is returned to its caller but not kept (4 MB). */
+const MAX_TASK_BYTES = 4 * 1024 * 1024;
+/** Finished tasks, in memory. Lost on restart; bounded by count, age and total size (64 MB). */
+const tasks = new TaskStore({
+    maxTasks: 500,
+    maxBytes: 64 * 1024 * 1024,
+    ttlMs: TASK_TTL_MS,
+});
+/**
+ * Keep a finished task for `GetTask`, for the caller that ran it only. The record holds a short copy
+ * of the caller's message, not the message, and a result too big to keep is replaced by a notice.
+ */
+function rememberTask(task, role, owner) {
+    const kept = {
+        ...task,
+        ...(task.history ? { history: task.history.map((message) => truncateMessage(message)) } : {}),
+    };
+    if (Buffer.byteLength(JSON.stringify(kept)) > MAX_TASK_BYTES && kept.artifacts) {
+        kept.artifacts = kept.artifacts.map((artifact) => ({
+            ...artifact,
+            parts: [
+                {
+                    data: { omitted: "The result was too large to keep; it was returned by SendMessage." },
+                    mediaType: JSON_MEDIA_TYPE,
+                },
+            ],
+        }));
+    }
+    tasks.remember(kept, role, owner);
+}
+function trimHistory(task, historyLength) {
+    if (typeof historyLength !== "number" || !Number.isInteger(historyLength) || historyLength < 0) {
+        return task;
+    }
+    const { history, ...rest } = task;
+    if (historyLength === 0 || !history)
+        return rest;
+    return { ...rest, history: history.slice(-historyLength) };
+}
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function rpcError(res, id, code, message) {
+    sendJson(res, 200, { jsonrpc: "2.0", id, error: { code, message } });
+}
+function describeIssues(error) {
+    return error.issues
+        .map((issue) => `${issue.path.length > 0 ? `${issue.path.map(String).join(".")}: ` : ""}${issue.message}`)
+        .join("; ");
+}
+function requestedVersionIsSupported(req) {
+    const header = req.headers["a2a-version"];
+    // Not sent: assume the version this agent implements. (The specification only says an empty
+    // value means 0.3, so an absent header is a lenient reading.)
+    if (header === undefined)
+        return true;
+    return (Array.isArray(header) ? header[0] : header) === A2A_PROTOCOL_VERSION;
+}
+function parseMessage(value) {
+    if (!isRecord(value))
+        return "params.message is required (object)";
+    if (typeof value["messageId"] !== "string" || value["messageId"] === "") {
+        return "message.messageId is required (string)";
+    }
+    if (value["role"] !== "ROLE_USER")
+        return 'message.role must be "ROLE_USER"';
+    if (!Array.isArray(value["parts"]) || value["parts"].length === 0) {
+        return "message.parts is required (non-empty array)";
+    }
+    return value;
+}
+/** The `{operation, input}` object carried by the message's first data part. */
+function findInvocation(message) {
+    for (const part of message.parts) {
+        if (isRecord(part) && isRecord(part.data) && typeof part.data["operation"] === "string") {
+            return { operation: part.data["operation"], input: part.data["input"] ?? {} };
+        }
+    }
+    return 'message needs a data part {"operation": <skill id>, "input": {...}}';
+}
+function acceptsJson(configuration) {
+    if (!isRecord(configuration))
+        return true;
+    const modes = configuration["acceptedOutputModes"];
+    if (!Array.isArray(modes) || modes.length === 0)
+        return true;
+    return modes.some((mode) => mode === JSON_MEDIA_TYPE || mode === "application/*" || mode === "*/*");
+}
+/** Refuse (HTTP) when the caller's role is too low; returns whether the request may proceed. */
+function authorize(req, res, role, label) {
+    const decision = authorizeRole(req, role, label);
+    if (!decision.ok)
+        sendJson(res, decision.status, { error: decision.error });
+    return decision.ok;
+}
+async function sendMessage(req, res, id, params, deps, operations) {
+    const message = parseMessage(params["message"]);
+    if (typeof message === "string")
+        return rpcError(res, id, ERROR.invalidParams, message);
+    if (message.taskId !== undefined) {
+        return rpcError(res, id, ERROR.unsupportedOperation, "Continuing an existing task is not supported: every SendMessage starts a new task");
+    }
+    if (!acceptsJson(params["configuration"])) {
+        return rpcError(res, id, ERROR.contentTypeNotSupported, `Only ${JSON_MEDIA_TYPE} output is produced`);
+    }
+    const invocation = findInvocation(message);
+    if (typeof invocation === "string")
+        return rpcError(res, id, ERROR.invalidParams, invocation);
+    const operation = operations.get(invocation.operation);
+    if (!operation) {
+        return rpcError(res, id, ERROR.invalidParams, `Unknown operation "${invocation.operation}". Available: ${[...operations.keys()].join(", ")}`);
+    }
+    if (!isRecord(invocation.input)) {
+        return rpcError(res, id, ERROR.invalidParams, "input must be an object");
+    }
+    const parsed = operation.input.safeParse(invocation.input);
+    if (!parsed.success)
+        return rpcError(res, id, ERROR.invalidParams, describeIssues(parsed.error));
+    const role = roleFor(operation);
+    if (!authorize(req, res, role, `A2A SendMessage ${operation.name}`))
+        return;
+    let confined;
+    try {
+        confined = confinePaths(inputJsonSchema(operation), parsed.data, getAllowedRoots());
+    }
+    catch (error) {
+        if (error instanceof PathNotAllowedError) {
+            sendJson(res, 403, { error: error.message });
+            return;
+        }
+        throw error;
+    }
+    const base = {
+        id: randomUUID(),
+        contextId: message.contextId ?? randomUUID(),
+        history: [message],
+        metadata: { operation: operation.name },
+    };
+    const timestamp = new Date().toISOString();
+    let task;
+    try {
+        const result = await operation.handler(confined, {
+            api: { ...defaultApiDeps, ...deps },
+            source: "openapi",
+            operationNames: [...operations.keys()],
+        });
+        // Round-trip so the artifact holds exactly what a JSON consumer would receive.
+        const serialized = JSON.stringify(result ?? null);
+        const data = JSON.parse(serialized);
+        task = {
+            ...base,
+            status: { state: "TASK_STATE_COMPLETED", timestamp },
+            artifacts: [
+                {
+                    artifactId: randomUUID(),
+                    name: operation.name,
+                    parts: [{ data, mediaType: JSON_MEDIA_TYPE }],
+                },
+            ],
+        };
+    }
+    catch (error) {
+        const text = error instanceof Error ? error.message : String(error);
+        task = {
+            ...base,
+            status: {
+                state: "TASK_STATE_FAILED",
+                message: {
+                    messageId: randomUUID(),
+                    contextId: base.contextId,
+                    taskId: base.id,
+                    role: "ROLE_AGENT",
+                    parts: [{ text }],
+                },
+                timestamp,
+            },
+        };
+    }
+    rememberTask(task, role, callerIdentity(req));
+    const configuration = isRecord(params["configuration"]) ? params["configuration"] : {};
+    sendJson(res, 200, {
+        jsonrpc: "2.0",
+        id,
+        result: { task: trimHistory(task, configuration["historyLength"]) },
+    });
+}
+function getTask(req, res, id, params) {
+    if (typeof params["id"] !== "string" || params["id"] === "") {
+        return rpcError(res, id, ERROR.invalidParams, "params.id is required (string)");
+    }
+    const stored = tasks.get(params["id"]);
+    if (!stored)
+        return rpcError(res, id, ERROR.taskNotFound, "Task not found");
+    if (!authorize(req, res, stored.role, "A2A GetTask"))
+        return;
+    // Someone else's task looks the same as one that does not exist.
+    if (stored.owner !== callerIdentity(req)) {
+        return rpcError(res, id, ERROR.taskNotFound, "Task not found");
+    }
+    sendJson(res, 200, {
+        jsonrpc: "2.0",
+        id,
+        result: trimHistory(stored.task, params["historyLength"]),
+    });
+}
+/** `POST /a2a`: the JSON-RPC endpoint the Agent Card's `supportedInterfaces` points at. */
+export async function handleA2aRequest(req, res, deps = {}) {
+    // Anyone who reaches the endpoint must hold a valid token; the operation's own role is checked
+    // once the request says which operation it wants.
+    if (!authorize(req, res, "reader", "POST /a2a"))
+        return;
+    let body;
+    try {
+        body = await readBody(req);
+    }
+    catch (error) {
+        if (error instanceof HttpError && error.status === 400) {
+            return rpcError(res, null, ERROR.parse, "Invalid JSON body");
+        }
+        if (error instanceof HttpError) {
+            sendJson(res, error.status, { error: error.message });
+            if (error.status === 413)
+                res.once("finish", () => req.destroy());
+            return;
+        }
+        return rpcError(res, null, ERROR.parse, "Invalid JSON body");
+    }
+    if (!isRecord(body) || body["jsonrpc"] !== "2.0" || typeof body["method"] !== "string") {
+        return rpcError(res, null, ERROR.invalidRequest, "Not a JSON-RPC 2.0 request");
+    }
+    const id = body["id"];
+    if (typeof id !== "string" && typeof id !== "number") {
+        return rpcError(res, null, ERROR.invalidRequest, "id is required (string or number)");
+    }
+    if (!requestedVersionIsSupported(req)) {
+        return rpcError(res, id, ERROR.versionNotSupported, `Only A2A-Version ${A2A_PROTOCOL_VERSION} is supported`);
+    }
+    const params = body["params"] ?? {};
+    if (!isRecord(params))
+        return rpcError(res, id, ERROR.invalidParams, "params must be an object");
+    switch (body["method"]) {
+        case "SendMessage": {
+            const operations = new Map(a2aSkillOperations().map((operation) => [operation.name, operation]));
+            return sendMessage(req, res, id, params, deps, operations);
+        }
+        case "GetTask": {
+            return getTask(req, res, id, params);
+        }
+        default: {
+            return rpcError(res, id, ERROR.methodNotFound, `Method not supported: ${body["method"]}. Supported: SendMessage, GetTask`);
+        }
+    }
+}
+//# sourceMappingURL=server.js.map