@rarebit-one/harness-kernel 0.5.1

package/dist/connectors/mcpClient.d.ts

@@ -0,0 +1,22 @@
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+import type { ConnectorConfig } from "../types.js";
+/**
+ * The client identity announced to every MCP server we connect to, suffixed
+ * with the connector's own name. Servers use it for logging and telemetry.
+ */
+export declare const MCP_CLIENT_NAME = "harness-kernel";
+/** A live MCP connection, narrowed to what the tool registry needs. */
+export interface McpConnection {
+    listTools(): Promise<unknown>;
+    callTool(name: string, args?: Record<string, unknown>): Promise<unknown>;
+    close(): Promise<void>;
+}
+/** Connect to an MCP connector using the transport implied by its config. */
+export declare function connectMcp(config: ConnectorConfig): Promise<McpConnection>;
+/**
+ * Connect over an arbitrary transport. Exposed so tests (and future callers) can
+ * supply an in-memory transport pair without spawning a process or hitting the
+ * network.
+ */
+export declare function connectWithTransport(name: string, transport: Transport): Promise<McpConnection>;
+//# sourceMappingURL=mcpClient.d.ts.map

package/dist/connectors/mcpClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcpClient.d.ts","sourceRoot":"","sources":["../../src/connectors/mcpClient.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,+CAA+C,CAAA;AAC9E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAElD;;;GAGG;AACH,eAAO,MAAM,eAAe,mBAAmB,CAAA;AAE/C,uEAAuE;AACvE,MAAM,WAAW,aAAa;IAC5B,SAAS,IAAI,OAAO,CAAC,OAAO,CAAC,CAAA;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IACxE,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACvB;AAwCD,6EAA6E;AAC7E,wBAAsB,UAAU,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,aAAa,CAAC,CAEhF;AAED;;;;GAIG;AACH,wBAAsB,oBAAoB,CACxC,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,SAAS,GACnB,OAAO,CAAC,aAAa,CAAC,CASxB"}

package/dist/connectors/mcpClient.js

@@ -0,0 +1,63 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport, getDefaultEnvironment, } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+/**
+ * The client identity announced to every MCP server we connect to, suffixed
+ * with the connector's own name. Servers use it for logging and telemetry.
+ */
+export const MCP_CLIENT_NAME = "harness-kernel";
+/** Bearer auth is attached as a request header for the HTTP-family transports. */
+function bearerInit(config) {
+    if (config.auth?.type === "bearer" && config.auth.token) {
+        return { requestInit: { headers: { Authorization: `Bearer ${config.auth.token}` } } };
+    }
+    return {};
+}
+function buildTransport(config) {
+    switch (config.transport) {
+        case "stdio": {
+            if (!config.command) {
+                throw new Error(`connector ${config.name}: stdio transport requires a command`);
+            }
+            // stdio servers receive credentials via env, not headers.
+            const env = config.auth?.type === "bearer" && config.auth.token
+                ? { ...getDefaultEnvironment(), MCP_AUTH_TOKEN: config.auth.token }
+                : undefined;
+            return new StdioClientTransport({ command: config.command, args: config.args ?? [], env });
+        }
+        case "streamable_http": {
+            if (!config.endpoint) {
+                throw new Error(`connector ${config.name}: streamable_http transport requires an endpoint`);
+            }
+            return new StreamableHTTPClientTransport(new URL(config.endpoint), bearerInit(config));
+        }
+        case "sse": {
+            if (!config.endpoint) {
+                throw new Error(`connector ${config.name}: sse transport requires an endpoint`);
+            }
+            return new SSEClientTransport(new URL(config.endpoint), bearerInit(config));
+        }
+        default:
+            throw new Error(`connector ${config.name}: unknown transport ${String(config.transport)}`);
+    }
+}
+/** Connect to an MCP connector using the transport implied by its config. */
+export async function connectMcp(config) {
+    return connectWithTransport(config.name, buildTransport(config));
+}
+/**
+ * Connect over an arbitrary transport. Exposed so tests (and future callers) can
+ * supply an in-memory transport pair without spawning a process or hitting the
+ * network.
+ */
+export async function connectWithTransport(name, transport) {
+    const client = new Client({ name: `${MCP_CLIENT_NAME}/${name}`, version: "0.1.0" });
+    await client.connect(transport);
+    return {
+        listTools: () => client.listTools(),
+        callTool: (toolName, args = {}) => client.callTool({ name: toolName, arguments: args }),
+        close: () => client.close(),
+    };
+}
+//# sourceMappingURL=mcpClient.js.map

package/dist/connectors/mcpClient.js.map

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

package/dist/context/types.d.ts

@@ -0,0 +1,68 @@
+import type { WorkflowDefinition } from "../types.js";
+/**
+ * Pluggable context assembly.
+ *
+ * A run's context started life as a single pre-assembled string on the run
+ * spec. That works when context is one static thing, and stops working the
+ * moment it isn't: a live perception feed, a retrieval index, and a file
+ * excerpt are three sources with different latencies and different failure
+ * modes, and none of them should have to be flattened by the caller before the
+ * kernel will accept them.
+ *
+ * So the string becomes a chain. Providers are asked in parallel for fragments;
+ * fragments are ordered and rendered into the prompt. A private real-time
+ * source plugs in here without the kernel knowing anything about it.
+ */
+/** One piece of assembled context. */
+export interface ContextFragment {
+    /** Which provider produced it — rendered as the section heading. */
+    source: string;
+    text: string;
+    /** Higher sorts first. Defaults to 0; ties keep provider order. */
+    priority?: number;
+    /** Free-form detail for callers that post-process fragments. */
+    meta?: Record<string, unknown>;
+}
+/**
+ * What a provider is told about the run. A narrow, read-only view — every field
+ * is optional so an engine's own richer run spec structurally satisfies it
+ * without the kernel having to convert between them.
+ */
+export interface ContextSpec {
+    runId?: string;
+    workspaceId?: string;
+    workflowPath?: string;
+    /** The prepared working tree, for providers that read from disk. */
+    workdir?: string;
+    inputs?: Record<string, unknown>;
+    workflow?: WorkflowDefinition;
+}
+/**
+ * A source of run context. Implementations should be cheap to construct and do
+ * their work in `assemble`, which may be called concurrently with other
+ * providers.
+ */
+export interface ContextProvider {
+    readonly name: string;
+    assemble(spec: ContextSpec): Promise<ContextFragment[]>;
+}
+/**
+ * Ask every provider for fragments and return them in render order.
+ *
+ * Providers run **in parallel** — they are independent sources and a slow one
+ * shouldn't serialise behind the others. A provider that throws is logged and
+ * skipped rather than failing the run: context is additive by nature, and
+ * losing one optional source is not a reason to abandon work that the remaining
+ * sources can still support. (This is the one place the kernel degrades instead
+ * of failing loud, and it is deliberate — a *missing model* is a broken run,
+ * a missing context fragment is a thinner prompt.)
+ */
+export declare function assembleContext(providers: ContextProvider[], spec: ContextSpec, log?: (line: string) => void): Promise<ContextFragment[]>;
+/**
+ * Render fragments into the prompt text an engine embeds. Each fragment becomes
+ * a titled section so the model can tell sources apart; an empty list renders
+ * as an empty string, which keeps a provider-less run byte-identical to one
+ * that never had providers.
+ */
+export declare function renderContext(fragments: ContextFragment[]): string;
+//# sourceMappingURL=types.d.ts.map

package/dist/context/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/context/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAErD;;;;;;;;;;;;;GAaG;AAEH,sCAAsC;AACtC,MAAM,WAAW,eAAe;IAC9B,oEAAoE;IACpE,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;IACZ,mEAAmE;IACnE,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,gEAAgE;IAChE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC/B;AAED;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,oEAAoE;IACpE,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAChC,QAAQ,CAAC,EAAE,kBAAkB,CAAA;CAC9B;AAED;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC,CAAA;CACxD;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,eAAe,CACnC,SAAS,EAAE,eAAe,EAAE,EAC5B,IAAI,EAAE,WAAW,EACjB,GAAG,GAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAe,GACrC,OAAO,CAAC,eAAe,EAAE,CAAC,CAsB5B;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,eAAe,EAAE,GAAG,MAAM,CAElE"}

package/dist/context/types.js

@@ -0,0 +1,43 @@
+/**
+ * Ask every provider for fragments and return them in render order.
+ *
+ * Providers run **in parallel** — they are independent sources and a slow one
+ * shouldn't serialise behind the others. A provider that throws is logged and
+ * skipped rather than failing the run: context is additive by nature, and
+ * losing one optional source is not a reason to abandon work that the remaining
+ * sources can still support. (This is the one place the kernel degrades instead
+ * of failing loud, and it is deliberate — a *missing model* is a broken run,
+ * a missing context fragment is a thinner prompt.)
+ */
+export async function assembleContext(providers, spec, log = () => { }) {
+    const settled = await Promise.allSettled(providers.map((p) => p.assemble(spec)));
+    const fragments = [];
+    settled.forEach((outcome, index) => {
+        const provider = providers[index];
+        if (!provider)
+            return;
+        if (outcome.status === "fulfilled") {
+            fragments.push(...outcome.value);
+            return;
+        }
+        const reason = outcome.reason;
+        const message = reason instanceof Error ? reason.message : String(reason);
+        log(`context provider ${provider.name} failed: ${message}`);
+    });
+    // Stable sort by descending priority: providers that declare nothing keep the
+    // order they were registered in.
+    return fragments
+        .map((fragment, index) => ({ fragment, index }))
+        .sort((a, b) => (b.fragment.priority ?? 0) - (a.fragment.priority ?? 0) || a.index - b.index)
+        .map(({ fragment }) => fragment);
+}
+/**
+ * Render fragments into the prompt text an engine embeds. Each fragment becomes
+ * a titled section so the model can tell sources apart; an empty list renders
+ * as an empty string, which keeps a provider-less run byte-identical to one
+ * that never had providers.
+ */
+export function renderContext(fragments) {
+    return fragments.map((f) => `### ${f.source}\n${f.text}`).join("\n\n");
+}
+//# sourceMappingURL=types.js.map

package/dist/context/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/context/types.ts"],"names":[],"mappings":"AAqDA;;;;;;;;;;GAUG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe,CACnC,SAA4B,EAC5B,IAAiB,EACjB,MAA8B,GAAG,EAAE,GAAE,CAAC;IAEtC,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,UAAU,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;IAEhF,MAAM,SAAS,GAAsB,EAAE,CAAA;IACvC,OAAO,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE;QACjC,MAAM,QAAQ,GAAG,SAAS,CAAC,KAAK,CAAC,CAAA;QACjC,IAAI,CAAC,QAAQ;YAAE,OAAM;QACrB,IAAI,OAAO,CAAC,MAAM,KAAK,WAAW,EAAE,CAAC;YACnC,SAAS,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,CAAA;YAChC,OAAM;QACR,CAAC;QACD,MAAM,MAAM,GAAY,OAAO,CAAC,MAAM,CAAA;QACtC,MAAM,OAAO,GAAG,MAAM,YAAY,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;QACzE,GAAG,CAAC,oBAAoB,QAAQ,CAAC,IAAI,YAAY,OAAO,EAAE,CAAC,CAAA;IAC7D,CAAC,CAAC,CAAA;IAEF,8EAA8E;IAC9E,iCAAiC;IACjC,OAAO,SAAS;SACb,GAAG,CAAC,CAAC,QAAQ,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC,CAAC;SAC/C,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,QAAQ,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC,QAAQ,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC;SAC5F,GAAG,CAAC,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC,QAAQ,CAAC,CAAA;AACpC,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,aAAa,CAAC,SAA4B;IACxD,OAAO,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAA;AACxE,CAAC"}

package/dist/engines/capability.d.ts

@@ -0,0 +1,67 @@
+import { z } from "zod";
+/**
+ * The standing, workspace-scoped authority an engine grants an in-run agent,
+ * uniformly regardless of engine. It is bound to exactly ONE run: that run's
+ * workspace id and its sandbox working tree.
+ *
+ * The agent can NEVER name another workspace: the context is fixed at
+ * construction and every capability defensively rejects a mismatching
+ * `workspace_id`. That invariant is enforced here, by {@link denyCrossWorkspace}
+ * and {@link resolveWithin}, and both are exported so an application building
+ * its own capabilities inherits exactly the same guarantees rather than
+ * reimplementing them slightly differently.
+ *
+ * The kernel defines only the capabilities that carry no product semantics
+ * (currently {@link writeFileCapability}). What an application emits — an
+ * issue, a piece of knowledge — is the application's vocabulary and lives
+ * there, injected into the engines through their capability-tool seams.
+ */
+export interface CapabilityContext {
+    /** The one workspace this authority is scoped to (the run's own). */
+    workspaceId: string;
+    /** The run's sandbox working tree; write_file lands here → captured by the change set. */
+    workdir: string;
+}
+/** The uniform result of a capability call, JSON-encoded back to the agent. */
+export interface CapabilityResult {
+    ok: boolean;
+    error?: string;
+}
+/**
+ * A transport-neutral capability: name + description + a Zod raw shape (the
+ * advertised input schema) + a handler over RAW input. The handler — not the
+ * transport — is the security boundary: it does its own coercion and enforces
+ * the workspace scope, so the guarantees hold identically whether the tool is
+ * reached via the Claude Code SDK MCP server, a codex `config.toml` stdio server,
+ * or a direct call in a test.
+ */
+export interface CapabilityTool {
+    name: string;
+    description: string;
+    /** Zod raw shape advertised to the model; note it deliberately omits `workspace_id`. */
+    schema: z.ZodRawShape;
+    handler(input: Record<string, unknown>): Promise<CapabilityResult>;
+}
+/**
+ * Reject any call that names a workspace other than the one this authority is
+ * bound to. `workspace_id` is NOT part of any tool's advertised schema, so a
+ * well-behaved agent never sends it; this is defense-in-depth against a
+ * programmatic or adversarial caller trying to redirect an emit cross-workspace.
+ * Returns an error result to short-circuit, or null when the call may proceed.
+ */
+export declare function denyCrossWorkspace(input: Record<string, unknown>, workspaceId: string): CapabilityResult | null;
+/** Lexical guard: refuse a relative path that escapes the sandbox via `..` or is absolute. */
+export declare function resolveWithin(dir: string, relPath: string): string;
+/**
+ * The generic sandbox-write capability: put a UTF-8 file into THIS run's working
+ * tree. It stays in the kernel because it carries no product semantics — it
+ * touches only the workspace scope and the workdir, and the change is picked up
+ * by whatever diffs the tree afterwards. Nothing about it is specific to what a
+ * given application does with the result.
+ *
+ * Application-specific capabilities (emitting an issue, promoting knowledge)
+ * live in the application and are composed alongside this one — see
+ * `capabilityToolsFor` on the engines.
+ */
+export declare function writeFileCapability(ctx: CapabilityContext): CapabilityTool;
+//# sourceMappingURL=capability.d.ts.map

package/dist/engines/capability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capability.d.ts","sourceRoot":"","sources":["../../src/engines/capability.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,iBAAiB;IAChC,qEAAqE;IACrE,WAAW,EAAE,MAAM,CAAA;IACnB,0FAA0F;IAC1F,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,+EAA+E;AAC/E,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,OAAO,CAAA;IACX,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,wFAAwF;IACxF,MAAM,EAAE,CAAC,CAAC,WAAW,CAAA;IACrB,OAAO,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAA;CACnE;AAID;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,WAAW,EAAE,MAAM,GAClB,gBAAgB,GAAG,IAAI,CAQzB;AAED,8FAA8F;AAC9F,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAOlE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,iBAAiB,GAAG,cAAc,CA4B1E"}

package/dist/engines/capability.js

@@ -0,0 +1,73 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+const str = (v) => (typeof v === "string" ? v : "");
+/**
+ * Reject any call that names a workspace other than the one this authority is
+ * bound to. `workspace_id` is NOT part of any tool's advertised schema, so a
+ * well-behaved agent never sends it; this is defense-in-depth against a
+ * programmatic or adversarial caller trying to redirect an emit cross-workspace.
+ * Returns an error result to short-circuit, or null when the call may proceed.
+ */
+export function denyCrossWorkspace(input, workspaceId) {
+    for (const key of ["workspace_id", "workspaceId"]) {
+        const v = input[key];
+        if (typeof v === "string" && v !== workspaceId) {
+            return { ok: false, error: `cross-workspace operation denied (bound to ${workspaceId})` };
+        }
+    }
+    return null;
+}
+/** Lexical guard: refuse a relative path that escapes the sandbox via `..` or is absolute. */
+export function resolveWithin(dir, relPath) {
+    const base = path.resolve(dir);
+    const target = path.resolve(base, relPath);
+    if (target !== base && !target.startsWith(base + path.sep)) {
+        throw new Error(`path escapes sandbox: ${relPath}`);
+    }
+    return target;
+}
+/**
+ * The generic sandbox-write capability: put a UTF-8 file into THIS run's working
+ * tree. It stays in the kernel because it carries no product semantics — it
+ * touches only the workspace scope and the workdir, and the change is picked up
+ * by whatever diffs the tree afterwards. Nothing about it is specific to what a
+ * given application does with the result.
+ *
+ * Application-specific capabilities (emitting an issue, promoting knowledge)
+ * live in the application and are composed alongside this one — see
+ * `capabilityToolsFor` on the engines.
+ */
+export function writeFileCapability(ctx) {
+    return {
+        name: "write_file",
+        description: "Write a UTF-8 file into THIS run's workspace sandbox (creating parent directories). The " +
+            "change is captured in the run's change set and committed to the workspace after the run, " +
+            "honoring the approval gate. Paths are relative to the workspace root; escaping it is refused.",
+        schema: {
+            path: z.string().describe("Workspace-relative file path."),
+            content: z.string().describe("UTF-8 file content."),
+        },
+        handler: async (input) => {
+            const denied = denyCrossWorkspace(input, ctx.workspaceId);
+            if (denied)
+                return denied;
+            const rel = str(input.path);
+            if (!rel)
+                return { ok: false, error: "path is required" };
+            if (typeof input.content !== "string")
+                return { ok: false, error: "content is required" };
+            let target;
+            try {
+                target = resolveWithin(ctx.workdir, rel);
+            }
+            catch (err) {
+                return { ok: false, error: err instanceof Error ? err.message : String(err) };
+            }
+            await mkdir(path.dirname(target), { recursive: true });
+            await writeFile(target, input.content);
+            return { ok: true };
+        },
+    };
+}
+//# sourceMappingURL=capability.js.map

package/dist/engines/capability.js.map

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

package/dist/engines/capabilityEmissions.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The out-of-process emissions file.
+ *
+ * An external-process engine (codex / a CLI) cannot share memory with the run
+ * that spawned it, so the runner-hosted stdio capability server persists what
+ * the run emitted to a JSON file OUTSIDE the sandbox tree — where the change
+ * set will not capture it — and the engine reads it back afterwards. That round
+ * trip is the whole mechanism, and it is generic.
+ *
+ * What it carries is **not** the kernel's business. This module moves an opaque
+ * JSON value; it does not know or check its shape. It previously declared an
+ * `Emissions { issues, knowledge }` interface, which put one application's run
+ * protocol inside the kernel — `write_file` changes are still excluded on
+ * purpose, because those DO belong in the tree and travel via the change set.
+ */
+/** Persist the current emissions (the stdio server rewrites the full state per call). */
+export declare function writeEmissions(file: string, emissions: unknown): Promise<void>;
+/**
+ * Read back what the capability server persisted.
+ *
+ * Returns `undefined` for an absent or malformed file rather than an empty
+ * object: "nothing was written" and "something was written and it was empty"
+ * are different facts, and a defaulted `{}` would erase the difference. The
+ * caller casts to whatever its own capability surface agreed to write.
+ */
+export declare function readEmissions(file: string): Promise<unknown>;
+//# sourceMappingURL=capabilityEmissions.d.ts.map

package/dist/engines/capabilityEmissions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilityEmissions.d.ts","sourceRoot":"","sources":["../../src/engines/capabilityEmissions.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AAEH,yFAAyF;AACzF,wBAAsB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAEpF;AAED;;;;;;;GAOG;AACH,wBAAsB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAMlE"}

package/dist/engines/capabilityEmissions.js

@@ -0,0 +1,37 @@
+import { readFile, writeFile } from "node:fs/promises";
+/**
+ * The out-of-process emissions file.
+ *
+ * An external-process engine (codex / a CLI) cannot share memory with the run
+ * that spawned it, so the runner-hosted stdio capability server persists what
+ * the run emitted to a JSON file OUTSIDE the sandbox tree — where the change
+ * set will not capture it — and the engine reads it back afterwards. That round
+ * trip is the whole mechanism, and it is generic.
+ *
+ * What it carries is **not** the kernel's business. This module moves an opaque
+ * JSON value; it does not know or check its shape. It previously declared an
+ * `Emissions { issues, knowledge }` interface, which put one application's run
+ * protocol inside the kernel — `write_file` changes are still excluded on
+ * purpose, because those DO belong in the tree and travel via the change set.
+ */
+/** Persist the current emissions (the stdio server rewrites the full state per call). */
+export async function writeEmissions(file, emissions) {
+    await writeFile(file, JSON.stringify(emissions));
+}
+/**
+ * Read back what the capability server persisted.
+ *
+ * Returns `undefined` for an absent or malformed file rather than an empty
+ * object: "nothing was written" and "something was written and it was empty"
+ * are different facts, and a defaulted `{}` would erase the difference. The
+ * caller casts to whatever its own capability surface agreed to write.
+ */
+export async function readEmissions(file) {
+    try {
+        return JSON.parse(await readFile(file, "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=capabilityEmissions.js.map

package/dist/engines/capabilityEmissions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilityEmissions.js","sourceRoot":"","sources":["../../src/engines/capabilityEmissions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAEtD;;;;;;;;;;;;;;GAcG;AAEH,yFAAyF;AACzF,MAAM,CAAC,KAAK,UAAU,cAAc,CAAC,IAAY,EAAE,SAAkB;IACnE,MAAM,SAAS,CAAC,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC,CAAA;AAClD,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa,CAAC,IAAY;IAC9C,IAAI,CAAC;QACH,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,CAAA;IACjD,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,SAAS,CAAA;IAClB,CAAC;AACH,CAAC"}

package/dist/engines/capabilityMcp.d.ts

@@ -0,0 +1,23 @@
+import type { McpSdkServerConfigWithInstance } from "@anthropic-ai/claude-agent-sdk";
+import type { CapabilityTool } from "./capability.js";
+/**
+ * The MCP server name the kernel-hosted capability surface is registered under.
+ * Tools are therefore reachable by the model as `mcp__workspace__<tool>` — see
+ * {@link capabilityToolIds}. It names what the authority is scoped to (the run's
+ * workspace), not who is hosting it.
+ */
+export declare const CAPABILITY_SERVER_NAME = "workspace";
+/** Fully-qualified tool ids the Agent SDK exposes for a capability server. */
+export declare function capabilityToolIds(tools: CapabilityTool[]): string[];
+/**
+ * Wrap the transport-neutral {@link CapabilityTool}s in an in-process Anthropic
+ * Agent SDK MCP server, so the Claude Code engine gets the exact same
+ * workspace-scoped authority the native engine has — no separate process, no
+ * network. The SDK is imported lazily (this module is only reached from the
+ * Claude Code driver, which never runs on a warm shared host).
+ *
+ * The capability handler is the security boundary; this adapter only marshals
+ * the SDK's parsed args into it and JSON-encodes the result back to the model.
+ */
+export declare function capabilitySdkServer(tools: CapabilityTool[]): Promise<McpSdkServerConfigWithInstance>;
+//# sourceMappingURL=capabilityMcp.d.ts.map

package/dist/engines/capabilityMcp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilityMcp.d.ts","sourceRoot":"","sources":["../../src/engines/capabilityMcp.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,gCAAgC,CAAA;AACpF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAErD;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,cAAc,CAAA;AAEjD,8EAA8E;AAC9E,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,cAAc,EAAE,GAAG,MAAM,EAAE,CAEnE;AAED;;;;;;;;;GASG;AACH,wBAAsB,mBAAmB,CACvC,KAAK,EAAE,cAAc,EAAE,GACtB,OAAO,CAAC,8BAA8B,CAAC,CAezC"}

package/dist/engines/capabilityMcp.js

@@ -0,0 +1,36 @@
+/**
+ * The MCP server name the kernel-hosted capability surface is registered under.
+ * Tools are therefore reachable by the model as `mcp__workspace__<tool>` — see
+ * {@link capabilityToolIds}. It names what the authority is scoped to (the run's
+ * workspace), not who is hosting it.
+ */
+export const CAPABILITY_SERVER_NAME = "workspace";
+/** Fully-qualified tool ids the Agent SDK exposes for a capability server. */
+export function capabilityToolIds(tools) {
+    return tools.map((t) => `mcp__${CAPABILITY_SERVER_NAME}__${t.name}`);
+}
+/**
+ * Wrap the transport-neutral {@link CapabilityTool}s in an in-process Anthropic
+ * Agent SDK MCP server, so the Claude Code engine gets the exact same
+ * workspace-scoped authority the native engine has — no separate process, no
+ * network. The SDK is imported lazily (this module is only reached from the
+ * Claude Code driver, which never runs on a warm shared host).
+ *
+ * The capability handler is the security boundary; this adapter only marshals
+ * the SDK's parsed args into it and JSON-encodes the result back to the model.
+ */
+export async function capabilitySdkServer(tools) {
+    const { createSdkMcpServer, tool } = await import("@anthropic-ai/claude-agent-sdk");
+    return createSdkMcpServer({
+        name: CAPABILITY_SERVER_NAME,
+        version: "0.1.0",
+        tools: tools.map((cap) => tool(cap.name, cap.description, cap.schema, async (args) => {
+            const result = await cap.handler(args);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result) }],
+                ...(result.ok ? {} : { isError: true }),
+            };
+        })),
+    });
+}
+//# sourceMappingURL=capabilityMcp.js.map

package/dist/engines/capabilityMcp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilityMcp.js","sourceRoot":"","sources":["../../src/engines/capabilityMcp.ts"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,WAAW,CAAA;AAEjD,8EAA8E;AAC9E,MAAM,UAAU,iBAAiB,CAAC,KAAuB;IACvD,OAAO,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,QAAQ,sBAAsB,KAAK,CAAC,CAAC,IAAI,EAAE,CAAC,CAAA;AACtE,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,CAAC,KAAK,UAAU,mBAAmB,CACvC,KAAuB;IAEvB,MAAM,EAAE,kBAAkB,EAAE,IAAI,EAAE,GAAG,MAAM,MAAM,CAAC,gCAAgC,CAAC,CAAA;IACnF,OAAO,kBAAkB,CAAC;QACxB,IAAI,EAAE,sBAAsB;QAC5B,OAAO,EAAE,OAAO;QAChB,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CACvB,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE;YACzD,MAAM,MAAM,GAAG,MAAM,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,CAAA;YACtC,OAAO;gBACL,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,CAAC;gBACzD,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;aACxC,CAAA;QACH,CAAC,CAAC,CACH;KACF,CAAC,CAAA;AACJ,CAAC"}

package/dist/engines/capabilityStdio.d.ts

@@ -0,0 +1,46 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+import type { CapabilityTool } from "./capability.js";
+/**
+ * Hosts a capability surface as a standalone MCP server over an arbitrary
+ * transport — for engines that run as an EXTERNAL process (codex, or any CLI)
+ * and reach the run's authority through a configured stdio MCP server rather
+ * than an in-process SDK server.
+ *
+ * This is the generic mechanism only. It does not know which capabilities it is
+ * serving or what a call means: the tools are handed in, and `afterCall` is the
+ * hook an application uses to persist whatever the call accumulated, since a
+ * child process cannot share memory with the run that spawned it.
+ *
+ * Because the tool set is injected, the application owns the entrypoint script
+ * that the external engine spawns — a child process cannot be handed a closure.
+ * Build the server there and connect it with {@link serveCapability}.
+ */
+export interface CapabilityStdioOptions {
+    /** The capabilities to expose. Order is preserved in the advertised list. */
+    tools: CapabilityTool[];
+    /**
+     * Run after every handler call, successful or not. The usual job is to flush
+     * accumulated state to a file outside the sandbox so the spawning process can
+     * read it once the child exits.
+     */
+    afterCall?: () => Promise<void>;
+}
+/** The spawn contract an external engine fills in via the environment. */
+export interface CapabilityStdioConfig {
+    workspaceId: string;
+    workdir: string;
+    /** Absolute path (OUTSIDE the sandbox) where a run's emissions are persisted. */
+    emissionsFile: string;
+}
+/** Build the capability MCP server for external-process hosting (not yet connected). */
+export declare function buildCapabilityStdioServer(options: CapabilityStdioOptions): McpServer;
+/** Connect a built capability server over the given transport (stdio in production). */
+export declare function serveCapability(options: CapabilityStdioOptions, transport?: Transport): Promise<McpServer>;
+/**
+ * Read the spawn contract from the environment the spawning engine sets. The
+ * variable names are part of that contract — see the codex engine, which writes
+ * them into the config it hands the external process.
+ */
+export declare function capabilityStdioConfigFromEnv(): CapabilityStdioConfig;
+//# sourceMappingURL=capabilityStdio.d.ts.map

package/dist/engines/capabilityStdio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilityStdio.d.ts","sourceRoot":"","sources":["../../src/engines/capabilityStdio.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAEnE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,+CAA+C,CAAA;AAC9E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAGrD;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,sBAAsB;IACrC,6EAA6E;IAC7E,KAAK,EAAE,cAAc,EAAE,CAAA;IACvB;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAChC;AAED,0EAA0E;AAC1E,MAAM,WAAW,qBAAqB;IACpC,WAAW,EAAE,MAAM,CAAA;IACnB,OAAO,EAAE,MAAM,CAAA;IACf,iFAAiF;IACjF,aAAa,EAAE,MAAM,CAAA;CACtB;AAED,wFAAwF;AACxF,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,sBAAsB,GAAG,SAAS,CAkBrF;AAED,wFAAwF;AACxF,wBAAsB,eAAe,CACnC,OAAO,EAAE,sBAAsB,EAC/B,SAAS,GAAE,SAAsC,GAChD,OAAO,CAAC,SAAS,CAAC,CAIpB;AAED;;;;GAIG;AACH,wBAAgB,4BAA4B,IAAI,qBAAqB,CAQpE"}

package/dist/engines/capabilityStdio.js

@@ -0,0 +1,39 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CAPABILITY_SERVER_NAME } from "./capabilityMcp.js";
+/** Build the capability MCP server for external-process hosting (not yet connected). */
+export function buildCapabilityStdioServer(options) {
+    const server = new McpServer({ name: CAPABILITY_SERVER_NAME, version: "0.1.0" });
+    for (const cap of options.tools) {
+        server.registerTool(cap.name, { description: cap.description, inputSchema: cap.schema }, async (args) => {
+            const result = await cap.handler(args);
+            await options.afterCall?.();
+            return {
+                content: [{ type: "text", text: JSON.stringify(result) }],
+                ...(result.ok ? {} : { isError: true }),
+            };
+        });
+    }
+    return server;
+}
+/** Connect a built capability server over the given transport (stdio in production). */
+export async function serveCapability(options, transport = new StdioServerTransport()) {
+    const server = buildCapabilityStdioServer(options);
+    await server.connect(transport);
+    return server;
+}
+/**
+ * Read the spawn contract from the environment the spawning engine sets. The
+ * variable names are part of that contract — see the codex engine, which writes
+ * them into the config it hands the external process.
+ */
+export function capabilityStdioConfigFromEnv() {
+    const workspaceId = process.env.HARNESS_WORKSPACE_ID;
+    const workdir = process.env.HARNESS_WORKDIR;
+    const emissionsFile = process.env.HARNESS_EMISSIONS_FILE;
+    if (!workspaceId || !workdir || !emissionsFile) {
+        throw new Error("HARNESS_WORKSPACE_ID, HARNESS_WORKDIR and HARNESS_EMISSIONS_FILE are required");
+    }
+    return { workspaceId, workdir, emissionsFile };
+}
+//# sourceMappingURL=capabilityStdio.js.map

package/dist/engines/capabilityStdio.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilityStdio.js","sourceRoot":"","sources":["../../src/engines/capabilityStdio.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,2CAA2C,CAAA;AAGhF,OAAO,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAA;AAoC3D,wFAAwF;AACxF,MAAM,UAAU,0BAA0B,CAAC,OAA+B;IACxE,MAAM,MAAM,GAAG,IAAI,SAAS,CAAC,EAAE,IAAI,EAAE,sBAAsB,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,CAAA;IAEhF,KAAK,MAAM,GAAG,IAAI,OAAO,CAAC,KAAK,EAAE,CAAC;QAChC,MAAM,CAAC,YAAY,CACjB,GAAG,CAAC,IAAI,EACR,EAAE,WAAW,EAAE,GAAG,CAAC,WAAW,EAAE,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,EACzD,KAAK,EAAE,IAA6B,EAAE,EAAE;YACtC,MAAM,MAAM,GAAG,MAAM,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,CAAA;YACtC,MAAM,OAAO,CAAC,SAAS,EAAE,EAAE,CAAA;YAC3B,OAAO;gBACL,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,MAAe,EAAE,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,CAAC;gBAClE,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;aACxC,CAAA;QACH,CAAC,CACF,CAAA;IACH,CAAC;IACD,OAAO,MAAM,CAAA;AACf,CAAC;AAED,wFAAwF;AACxF,MAAM,CAAC,KAAK,UAAU,eAAe,CACnC,OAA+B,EAC/B,YAAuB,IAAI,oBAAoB,EAAE;IAEjD,MAAM,MAAM,GAAG,0BAA0B,CAAC,OAAO,CAAC,CAAA;IAClD,MAAM,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAA;IAC/B,OAAO,MAAM,CAAA;AACf,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,4BAA4B;IAC1C,MAAM,WAAW,GAAG,OAAO,CAAC,GAAG,CAAC,oBAAoB,CAAA;IACpD,MAAM,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,eAAe,CAAA;IAC3C,MAAM,aAAa,GAAG,OAAO,CAAC,GAAG,CAAC,sBAAsB,CAAA;IACxD,IAAI,CAAC,WAAW,IAAI,CAAC,OAAO,IAAI,CAAC,aAAa,EAAE,CAAC;QAC/C,MAAM,IAAI,KAAK,CAAC,+EAA+E,CAAC,CAAA;IAClG,CAAC;IACD,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,aAAa,EAAE,CAAA;AAChD,CAAC"}