intentdna 1.9.0 → 1.9.3

package/dist/mcp/tools-run.js

@@ -0,0 +1,419 @@
+import { join, resolve } from "node:path";
+import { DNAStateManager } from "../hooks/state-manager.js";
+import { safePathComponent, writeCanonicalHookRuntimeProjection, } from "../hooks/state.js";
+import { createCanonicalRuntimeComposition } from "../runtime/canonical-runtime-composition.js";
+import { HarnessPullAdapter, } from "../runtime/harness-pull-adapter.js";
+import { ProductionLocalVerifierExecutionPort } from "../runtime/local-verifier-execution.js";
+import { LocalAttemptWorkspaceAuthority } from "../runtime/workspace-isolation.js";
+import { WORKFLOW_RUNTIME_INPUT_VARIABLE_NAMES } from "../runtime/workflow-runtime-manifest.js";
+import { errorResult, textResult } from "./server.js";
+const HARNESS_PROVIDER = Object.freeze({
+    provider: "harness",
+    model: null,
+    options: Object.freeze({}),
+    credential_references: Object.freeze([]),
+});
+const HARNESS_CAPABILITIES = Object.freeze({
+    driver: Object.freeze({
+        worktree_isolation: true,
+        parallelism: true,
+        cancellation: false,
+        hook_identity: true,
+        caller_attestation: false,
+        human_interaction: false,
+        direct_structured_submission: true,
+        network_policy_enforcement: false,
+    }),
+    submission_modes: Object.freeze(["relayed_submit"]),
+    stopped_execution_authority: false,
+});
+class MCPRunToolError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = "MCPRunToolError";
+        this.code = code;
+    }
+}
+function jsonResult(value) {
+    return textResult(JSON.stringify({ ok: true, result: value }));
+}
+function errorCode(error) {
+    if (error !== null
+        && typeof error === "object"
+        && "code" in error
+        && typeof error.code === "string"
+        && error.code.length > 0) {
+        return error.code;
+    }
+    return "internal_error";
+}
+function jsonError(error) {
+    return errorResult(JSON.stringify({
+        ok: false,
+        error: {
+            code: errorCode(error),
+            message: error instanceof Error ? error.message : String(error),
+        },
+    }));
+}
+function guarded(handler) {
+    return async (args) => {
+        try {
+            rejectClientCapabilities(args);
+            return jsonResult(await handler(args));
+        }
+        catch (error) {
+            return jsonError(error);
+        }
+    };
+}
+function rejectClientCapabilities(args) {
+    if (Object.prototype.hasOwnProperty.call(args, "capabilities")) {
+        throw new MCPRunToolError("invalid_request", "harness capabilities are fixed by the MCP host and cannot be supplied by clients");
+    }
+}
+function requiredString(args, name) {
+    const value = args[name];
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new MCPRunToolError("invalid_request", `${name} must be a non-empty string`);
+    }
+    return value;
+}
+function runId(args) {
+    return requiredString(args, "run_id");
+}
+function claimToken(args) {
+    return requiredString(args, "lease_token");
+}
+function workerSessionId(args) {
+    return requiredString(args, "worker_session_id");
+}
+function optionalString(args, name) {
+    const value = args[name];
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string") {
+        throw new MCPRunToolError("invalid_request", `${name} must be a string`);
+    }
+    return value;
+}
+function requiredRecord(args, name) {
+    const value = args[name];
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        throw new MCPRunToolError("invalid_request", `${name} must be an object`);
+    }
+    return value;
+}
+function requiredStringArray(args, name) {
+    const value = args[name];
+    if (!Array.isArray(value)
+        || value.length === 0
+        || value.some((entry) => typeof entry !== "string" || entry.trim().length === 0)) {
+        throw new MCPRunToolError("invalid_request", `${name} must be a non-empty array of non-empty strings`);
+    }
+    return value;
+}
+function positiveInteger(args, name, fallback) {
+    const value = args[name] ?? fallback;
+    if (!Number.isSafeInteger(value) || value <= 0) {
+        throw new MCPRunToolError("invalid_request", `${name} must be a positive integer`);
+    }
+    return value;
+}
+function submissionMode(args) {
+    const value = requiredString(args, "submission_mode");
+    if (value !== "relayed_submit" && value !== "attested_independent_submit") {
+        throw new MCPRunToolError("invalid_request", "submission_mode is invalid");
+    }
+    return value;
+}
+function jsonValue(value, name) {
+    try {
+        const serialized = JSON.stringify(value);
+        if (serialized === undefined)
+            throw new Error("not JSON serializable");
+        return JSON.parse(serialized);
+    }
+    catch {
+        throw new MCPRunToolError("invalid_request", `${name} must be JSON serializable`);
+    }
+}
+function logicalWorkflowStepId(stepId) {
+    const prefix = "worker:";
+    if (!stepId.startsWith(prefix) || stepId.length === prefix.length) {
+        throw new MCPRunToolError("invalid_service_response", `canonical worker step id is invalid: ${stepId}`);
+    }
+    return stepId.slice(prefix.length);
+}
+async function writeHarnessAttemptProjection(context) {
+    const compiled = context.metadata?.compiled_ir;
+    const packet = context.attached.packet;
+    if (compiled === null || compiled === undefined || packet === null)
+        return;
+    const workflowName = context.metadata?.target.key;
+    const manifest = compiled.workflow_runtime;
+    const binding = workflowName === undefined
+        ? undefined
+        : manifest?.workflows[workflowName];
+    const compiledIRHash = compiled.compiled_ir_hash ?? compiled.ir.compiled_ir_hash;
+    if (workflowName === undefined
+        || manifest === undefined
+        || binding === undefined
+        || compiledIRHash === undefined
+        || manifest.compiled_ir_hash !== compiledIRHash) {
+        throw new MCPRunToolError("invalid_service_response", "harness run metadata is missing a valid pinned workflow projection");
+    }
+    const workingDirectory = packet.workspace.working_directory;
+    const state = new DNAStateManager(workingDirectory, context.worker_session_id);
+    const inputs = {};
+    for (const name of binding.runtime_input_refs) {
+        const value = context.run.run.run_binding.binding.validated_inputs[name];
+        if (typeof value === "string")
+            inputs[name] = value;
+    }
+    for (const name of WORKFLOW_RUNTIME_INPUT_VARIABLE_NAMES) {
+        const value = context.run.run.run_binding.binding.validated_inputs[name];
+        if (typeof value === "string" && binding.runtime_input_refs.includes(name)) {
+            inputs[name] = value;
+        }
+    }
+    try {
+        await writeCanonicalHookRuntimeProjection(workingDirectory, {
+            schema_version: "intentdna.canonical_hook_projection.v2",
+            run_id: context.run.run.run_id,
+            step_id: packet.step_id,
+            attempt_id: packet.attempt_id,
+            worker_session_id: context.worker_session_id,
+            compiled_ir_hash: compiledIRHash,
+            compiled_ir: compiled,
+            lease_token: context.lease_token,
+            owner_id: context.owner_id,
+        });
+        await state.writeWorkflowState({
+            active: true,
+            workflow_asset: binding.workflow_asset,
+            workflow: workflowName,
+            current_step: logicalWorkflowStepId(packet.step_id),
+            current_role: packet.role,
+            iteration: packet.workflow_round,
+            session_id: context.worker_session_id,
+            worker_session_id: context.worker_session_id,
+            run_id: context.run.run.run_id,
+            step_id: packet.step_id,
+            attempt_id: packet.attempt_id,
+            started_at: packet.created_at,
+            inputs,
+            resolved_variables: binding.resolved_variables,
+            resolved_variables_source: "compiled_manifest",
+            workflow_runtime_manifest_hash: manifest.manifest_hash,
+            workflow_runtime_compiled_ir_hash: manifest.compiled_ir_hash,
+            workflow_inputs_pinned: true,
+        });
+    }
+    catch (error) {
+        await state.cleanup().catch(() => undefined);
+        throw error;
+    }
+}
+export function createMCPHarnessAdapter(projectDirectory) {
+    const runtimeRoot = join(projectDirectory, ".dna", "runtime");
+    const composition = createCanonicalRuntimeComposition({
+        project_directory: projectDirectory,
+        workspace_authority: new LocalAttemptWorkspaceAuthority({
+            lock_root: join(runtimeRoot, "workspace-locks"),
+        }),
+        verifier_execution_port: new ProductionLocalVerifierExecutionPort({
+            root_directory: join(runtimeRoot, "verifier-execution-authority"),
+        }),
+    });
+    return new HarnessPullAdapter({
+        service: composition.service,
+        capabilities: HARNESS_CAPABILITIES,
+        attempt_projection_sink: writeHarnessAttemptProjection,
+        validate_worker_session_id: (workerSessionId) => {
+            safePathComponent(workerSessionId, "worker_session_id");
+        },
+        driver_id: `mcp-harness:${process.pid}`,
+    });
+}
+function tool(name, description, properties, required, handler) {
+    return {
+        name,
+        description,
+        inputSchema: { type: "object", properties, required },
+        handler: guarded(handler),
+    };
+}
+export function createRunTools(projectDir) {
+    const projectDirectory = resolve(projectDir);
+    const adapter = createMCPHarnessAdapter(projectDirectory);
+    const identityProperties = {
+        run_id: { type: "string" },
+        attempt_id: { type: "string" },
+        lease_token: { type: "string" },
+        owner_id: { type: "string" },
+    };
+    return [
+        tool("dna_run_start", "Compile and start a canonical harness run in this MCP project's durable runtime", {
+            dna_sources: { type: "array", items: { type: "string" }, minItems: 1 },
+            target: {
+                type: "object",
+                properties: {
+                    kind: { type: "string", enum: ["workflow", "controller"] },
+                    key: { type: "string" },
+                },
+                required: ["kind", "key"],
+            },
+            inputs: { type: "object" },
+            max_concurrency: { type: "integer", minimum: 1 },
+            input_policy: { type: "string", enum: ["strict", "declared_only"] },
+            context: { type: ["string", "null"] },
+            attempt_policy: { type: "object" },
+            metadata: {},
+            run_id: { type: "string" },
+        }, ["dna_sources", "target", "inputs"], async (args) => {
+            if (Object.prototype.hasOwnProperty.call(args, "provider")
+                || Object.prototype.hasOwnProperty.call(args, "project_root")
+                || Object.prototype.hasOwnProperty.call(args, "workspace_root")) {
+                throw new MCPRunToolError("invalid_request", "provider, project_root, and workspace_root are fixed by the MCP host");
+            }
+            const target = requiredRecord(args, "target");
+            const kind = target.kind;
+            const key = target.key;
+            if ((kind !== "workflow" && kind !== "controller")
+                || typeof key !== "string"
+                || key.trim().length === 0) {
+                throw new MCPRunToolError("invalid_request", "target must contain a valid kind and key");
+            }
+            const inputPolicy = optionalString(args, "input_policy");
+            if (inputPolicy !== undefined && inputPolicy !== "strict" && inputPolicy !== "declared_only") {
+                throw new MCPRunToolError("invalid_request", "input_policy is invalid");
+            }
+            const context = args.context;
+            if (context !== undefined && context !== null && typeof context !== "string") {
+                throw new MCPRunToolError("invalid_request", "context must be a string or null");
+            }
+            const attemptPolicy = args.attempt_policy === undefined
+                ? undefined
+                : requiredRecord(args, "attempt_policy");
+            if (attemptPolicy !== undefined
+                && (!(attemptPolicy.timeout_ms === null || (Number.isSafeInteger(attemptPolicy.timeout_ms)
+                    && attemptPolicy.timeout_ms > 0))
+                    || !Number.isSafeInteger(attemptPolicy.cancellation_grace_ms)
+                    || attemptPolicy.cancellation_grace_ms < 0)) {
+                throw new MCPRunToolError("invalid_request", "attempt_policy must contain timeout_ms and a non-negative cancellation_grace_ms");
+            }
+            const request = {
+                dna_sources: requiredStringArray(args, "dna_sources"),
+                target: { kind, key },
+                inputs: requiredRecord(args, "inputs"),
+                environment: {
+                    project_root: projectDirectory,
+                    workspace_root: projectDirectory,
+                },
+                provider: HARNESS_PROVIDER,
+                max_concurrency: positiveInteger(args, "max_concurrency", 1),
+                ...(inputPolicy === undefined ? {} : { input_policy: inputPolicy }),
+                ...(context === undefined ? {} : { context: context }),
+                ...(attemptPolicy === undefined
+                    ? {}
+                    : {
+                        attempt_policy: {
+                            timeout_ms: attemptPolicy.timeout_ms,
+                            cancellation_grace_ms: attemptPolicy.cancellation_grace_ms,
+                        },
+                    }),
+                ...(args.metadata === undefined
+                    ? {}
+                    : { metadata: jsonValue(args.metadata, "metadata") }),
+                ...(args.run_id === undefined ? {} : { run_id: runId(args) }),
+            };
+            return adapter.start(request);
+        }),
+        tool("dna_run_next", "Resume a canonical run and acquire its next harness attempt", { run_id: { type: "string" } }, ["run_id"], (args) => adapter.next(runId(args))),
+        tool("dna_attempt_attach", "Attach a worker session to a claimed canonical harness attempt", {
+            ...identityProperties,
+            worker_session_id: { type: "string" },
+            submission_mode: {
+                type: "string",
+                enum: ["relayed_submit", "attested_independent_submit"],
+            },
+        }, [
+            "run_id",
+            "attempt_id",
+            "lease_token",
+            "owner_id",
+            "worker_session_id",
+            "submission_mode",
+        ], (args) => adapter.attach({
+            run_id: runId(args),
+            attempt_id: requiredString(args, "attempt_id"),
+            lease_token: claimToken(args),
+            owner_id: requiredString(args, "owner_id"),
+            worker_session_id: workerSessionId(args),
+            submission_mode: submissionMode(args),
+        })),
+        tool("dna_attempt_heartbeat", "Renew the lease for an attached canonical harness attempt", {
+            lease_token: { type: "string" },
+            owner_id: { type: "string" },
+        }, ["lease_token", "owner_id"], (args) => adapter.heartbeat({
+            lease_token: claimToken(args),
+            owner_id: requiredString(args, "owner_id"),
+        })),
+        tool("dna_attempt_submit", "Submit one structured execution result for an attached canonical harness attempt", {
+            ...identityProperties,
+            submission_key: { type: "string" },
+            submission_mode: {
+                type: "string",
+                enum: ["relayed_submit", "attested_independent_submit"],
+            },
+            execution: { type: "object" },
+            evidence_refs: { type: "array", items: { type: "object" } },
+        }, [
+            "run_id",
+            "attempt_id",
+            "lease_token",
+            "owner_id",
+            "submission_key",
+            "submission_mode",
+            "execution",
+        ], async (args) => {
+            const execution = requiredRecord(args, "execution");
+            if (execution.executor?.kind !== "worker") {
+                throw new MCPRunToolError("invalid_request", "harness execution.executor must identify the attached worker session");
+            }
+            const attachedWorkerSessionId = execution.executor.worker_session_id;
+            const evidenceRefs = args.evidence_refs;
+            if (evidenceRefs !== undefined && !Array.isArray(evidenceRefs)) {
+                throw new MCPRunToolError("invalid_request", "evidence_refs must be an array");
+            }
+            const request = {
+                run_id: runId(args),
+                attempt_id: requiredString(args, "attempt_id"),
+                lease_token: claimToken(args),
+                owner_id: requiredString(args, "owner_id"),
+                submission_key: requiredString(args, "submission_key"),
+                submission_mode: submissionMode(args),
+                execution,
+                ...(evidenceRefs === undefined
+                    ? {}
+                    : { evidence_refs: evidenceRefs }),
+            };
+            const response = await adapter.submit(request);
+            await new DNAStateManager(request.execution.workspace.root, attachedWorkerSessionId).cleanup();
+            return response;
+        }),
+        tool("dna_run_status", "Inspect the durable state of a canonical harness run", { run_id: { type: "string" } }, ["run_id"], (args) => adapter.status(runId(args))),
+        tool("dna_run_cancel", "Cancel a canonical harness run when the MCP host has trusted stopped-execution authority", {
+            run_id: { type: "string" },
+            reason: { type: ["string", "null"] },
+        }, ["run_id"], (args) => {
+            const reason = args.reason;
+            if (reason !== undefined && reason !== null && typeof reason !== "string") {
+                throw new MCPRunToolError("invalid_request", "reason must be a string or null");
+            }
+            return adapter.cancel(runId(args), reason === undefined ? undefined : reason);
+        }),
+    ];
+}

package/dist/mcp/tools-state.d.ts

@@ -4,7 +4,7 @@
  * Tools for reading/writing DNA governance state via MCP:
  *   - dna_status: Overview of DNA state
  *   - dna_workflow_read: Read current workflow state
- *   - dna_workflow_write: Update workflow state
+ *   - dna_workflow_write: Close legacy workflow state
  *   - dna_trace_query: Query legacy diagnostic trace data with filters
  */
 import type { ToolDef } from "./server.js";