@zhivex-ai/harness 1.3.0-rc.3 → 1.3.0

package/dist/engine/mcp-stdio-v1.d.ts

@@ -0,0 +1,11 @@
+/** Experimental, host-only OCI MCP API. Never load host policy from a workspace. */
+export { createMcpStdioAdmissionAuthority, McpStdioAdmissionError } from '../integrations/mcp-stdio-admission.js';
+export type { McpStdioLaunchProposal, McpStdioLaunchReceipt } from '../integrations/mcp-stdio-admission.js';
+export { prepareMcpWorkspaceSnapshot, discardMcpWorkspaceSnapshot } from '../execution/mcp-workspace-snapshot.js';
+export type { McpWorkspaceSnapshot } from '../execution/mcp-workspace-snapshot.js';
+export { recoverDockerMcpResources } from '../execution/mcp-resource-recovery.js';
+export { createMcpReconciliationAuthority } from '../persistence/mcp-reconciliation.js';
+export type { McpReconciliationDecision, McpReconciliationReview } from '../persistence/mcp-reconciliation.js';
+export type { HarnessIsolatedMcpSession } from '../integrations/mcp-host-session.js';
+export type { IsolatedMcpLaunchOptions } from '../integrations/mcp-stdio-session.js';
+export { launchIsolatedMcpSession } from '../integrations/mcp-stdio-session.js';

package/dist/engine/mcp-stdio-v1.js

@@ -0,0 +1,108 @@
+import {
+  McpStdioAdmissionError,
+  createMcpStdioAdmissionAuthority,
+  discardMcpWorkspaceSnapshot,
+  launchDockerMcpTools,
+  matchesMcpResourceScope,
+  mcpResourceOutputSchema,
+  mcpResourcePlanSchema,
+  prepareMcpWorkspaceSnapshot,
+  recoverDockerMcpResources
+} from "../index-6m08wvab.js";
+import"../index-azmwjp95.js";
+import"../index-z0qxmkm2.js";
+import"../index-yb239ghk.js";
+import"../index-gq9xagx2.js";
+import"../index-8705zxpr.js";
+import"../index-xqxeypt5.js";
+import"../index-1bx83sw4.js";
+// src/persistence/mcp-reconciliation.ts
+import { z } from "zod";
+var digest = z.string().regex(/^[a-f0-9]{64}$/);
+var identitySchema = z.object({
+  schemaVersion: z.literal(1),
+  kind: z.literal("isolated-mcp-call"),
+  proposalHash: digest,
+  argumentsHash: digest,
+  toolNameHash: digest
+}).strict();
+var decisionSchema = z.object({
+  toolCallId: z.string().regex(/^mcp_execution_[a-f0-9]{64}$/),
+  expectedRevision: z.number().int().nonnegative(),
+  outcome: z.enum(["effect_confirmed", "no_effect_confirmed"]),
+  evidenceDigest: z.string().regex(/^sha256:[a-f0-9]{64}$/)
+}).strict();
+function createMcpReconciliationAuthority(options) {
+  const { store, runId, hostId, authorize } = options;
+  const scope = Object.freeze(structuredClone(options.scope));
+  if (!store.loadToolCall || !store.saveToolCall || !store.listToolCalls || !runId || !hostId || !scope.userId || !scope.tenantId) {
+    throw new Error("MCP reconciliation requires a scoped durable host authority.");
+  }
+  const load = store.loadToolCall.bind(store), save = store.saveToolCall.bind(store), list = store.listToolCalls.bind(store);
+  const read = async (decision) => {
+    const row = await load(runId, decision.toolCallId, scope);
+    if (!row || row.toolName !== "isolated_mcp_call" || row.revision !== decision.expectedRevision || !(row.status === "pending" || row.status === "running" || row.error?.message === "MCP_OUTCOME_UNKNOWN")) {
+      throw new Error("MCP reconciliation target is stale or has no unresolved outcome.");
+    }
+    const identity = identitySchema.parse(row.input);
+    const resources = (await list(runId, scope)).filter((entry) => entry.toolName === "isolated_mcp_resources");
+    if (!resources.length || resources.some((entry) => {
+      const plan = mcpResourcePlanSchema.parse(entry.input);
+      return !matchesMcpResourceScope(plan, runId, scope, hostId) || mcpResourceOutputSchema.parse(entry.output).phase !== "closed";
+    }))
+      throw new Error("MCP reconciliation requires confirmed resource cleanup.");
+    return { row, identity };
+  };
+  return Object.freeze({
+    async reconcile(input) {
+      const decision = Object.freeze(decisionSchema.parse(input));
+      const initial = await read(decision);
+      const review = Object.freeze({
+        ...decision,
+        runId,
+        scope,
+        proposalHash: initial.identity.proposalHash,
+        argumentsHash: initial.identity.argumentsHash,
+        toolNameHash: initial.identity.toolNameHash
+      });
+      if (await authorize(review) !== true)
+        throw new Error("MCP reconciliation was not authorized.");
+      const current = await read(decision);
+      if (JSON.stringify(current.identity) !== JSON.stringify(initial.identity))
+        throw new Error("MCP reconciliation identity changed.");
+      const now = Date.now();
+      await save({
+        ...current.row,
+        status: "failed",
+        error: { message: "MCP_OUTCOME_RECONCILED" },
+        completedAt: now,
+        updatedAt: now,
+        output: {
+          schemaVersion: 1,
+          kind: "isolated-mcp-reconciliation",
+          outcome: decision.outcome,
+          evidenceDigest: decision.evidenceDigest,
+          previousStatus: current.row.status,
+          previousError: current.row.error?.message ?? null,
+          reviewedRevision: decision.expectedRevision,
+          actor: scope.userId,
+          resolvedAt: now
+        }
+      }, { expectedRevision: decision.expectedRevision });
+    }
+  });
+}
+// src/integrations/mcp-stdio-session.ts
+async function launchIsolatedMcpSession(options) {
+  const session = await launchDockerMcpTools(options);
+  return Object.freeze({ hostSession: session.hostSession, close: session.close });
+}
+export {
+  McpStdioAdmissionError,
+  createMcpReconciliationAuthority,
+  createMcpStdioAdmissionAuthority,
+  discardMcpWorkspaceSnapshot,
+  launchIsolatedMcpSession,
+  prepareMcpWorkspaceSnapshot,
+  recoverDockerMcpResources
+};

package/dist/engine/models.d.ts

@@ -0,0 +1,3 @@
+/** Browser-safe model metadata. No credentials, transports, filesystem or processes. */
+export { bundledModelCatalog, bundledDefaultModel, catalogModelSchema, modelCatalogSchema, catalogModels, modelDescription } from "../models/catalog.js";
+export type { CatalogModel, ModelCatalog } from "../models/catalog.js";