cool-workflow 0.1.98 → 0.2.0

package/dist/shell/app-run-cli.js

@@ -0,0 +1,88 @@
+"use strict";
+// shell/app-run-cli.ts — `cw_app_run` and `cw_sandbox_choose`/`cw_sandbox_resolve`.
+//
+// GAP #24 port: v2 declared the cw_app_run + cw_sandbox_choose/resolve MCP
+// tool rows but left their handlers as notYetImplemented. This restores the
+// old build's `appRun` + `sandboxChoose` (src/capability-core.ts) as thin
+// shell bodies over the same v2 `plan` + `showSandboxProfileCli` the CLI
+// front door already uses, so the MCP surface no longer throws.
+//
+// Both are MCP-only in the old build (no CLI path row), so only an
+// mcp.handler is wired for them in capability-table.ts.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sandboxChooseCli = sandboxChooseCli;
+exports.appRunCli = appRunCli;
+const pipeline_1 = require("./pipeline");
+const workflow_app_loader_1 = require("./workflow-app-loader");
+const exec_backend_cli_1 = require("./exec-backend-cli");
+const operator_ux_1 = require("./operator-ux");
+const run_store_1 = require("./run-store");
+/** Keys that steer the run/tool call itself, never workflow inputs — the
+ *  old build's `withoutRuntimeKeys` (src/capability-core.ts). */
+const RUNTIME_KEYS = new Set(["cwd", "sandbox", "sandboxProfile", "sandboxProfileId", "appId", "workflowId", "inputs"]);
+function withoutRuntimeKeys(args) {
+    const out = {};
+    for (const [key, value] of Object.entries(args)) {
+        if (RUNTIME_KEYS.has(key))
+            continue;
+        out[key] = value;
+    }
+    return out;
+}
+function optionalString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function sandboxProfileIdFrom(args) {
+    return optionalString(args.sandbox || args.sandboxProfile || args.sandboxProfileId || args.profileId);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** `cw_sandbox_choose` / `cw_sandbox_resolve` — resolve + validate a profile
+ *  choice. Byte-exact port of the old build's `sandboxChoose`
+ *  (src/capability-core.ts): defaults to "readonly", returns the resolved
+ *  profile object under `profile`. */
+function sandboxChooseCli(args) {
+    const profileId = sandboxProfileIdFrom(args) || "readonly";
+    const profile = (0, exec_backend_cli_1.showSandboxProfileCli)(profileId, args);
+    return {
+        profileId,
+        sandboxProfileId: profile.id,
+        valid: true,
+        profile,
+    };
+}
+/** `cw_app_run` — create a run from an app id + structured inputs. Byte-exact
+ *  port of the old build's `appRun` (src/capability-core.ts): merges
+ *  `inputs` with the non-runtime args, plans a fresh run, and returns the
+ *  run descriptor + a compact operator status. */
+function appRunCli(args) {
+    const appId = String(args.appId || args.workflowId || "");
+    if (!appId)
+        throw new Error("cw_app_run requires an app id (appId)");
+    const inputs = isRecord(args.inputs) ? args.inputs : {};
+    const planOptions = { ...inputs, ...withoutRuntimeKeys(args) };
+    if (typeof args.cwd === "string" && args.cwd.trim())
+        planOptions.cwd = args.cwd;
+    if (planOptions.repo && !planOptions.cwd)
+        planOptions.cwd = planOptions.repo;
+    const sandboxProfileId = sandboxProfileIdFrom(args);
+    const resolvedSandbox = sandboxProfileId ? (0, exec_backend_cli_1.showSandboxProfileCli)(sandboxProfileId, args) : undefined;
+    const app = (0, workflow_app_loader_1.loadWorkflowApp)(appId);
+    const run = (0, pipeline_1.plan)(app, planOptions);
+    const status = (0, operator_ux_1.summarizeOperatorRun)((0, run_store_1.loadRunFromCwd)(run.id, run.cwd));
+    const appMeta = (run.workflow.app || {});
+    return {
+        runId: run.id,
+        workflowId: run.workflow.id,
+        appId: appMeta.id || appId,
+        appVersion: appMeta.version,
+        statePath: run.paths.state,
+        reportPath: run.paths.report,
+        pendingTasks: run.tasks.filter((task) => task.status === "pending").length,
+        operatorStatus: status,
+        nextActions: status.nextActions,
+        sandboxProfileId,
+        sandboxProfile: resolvedSandbox,
+    };
+}

package/dist/shell/audit-cli.js

@@ -0,0 +1,259 @@
+"use strict";
+// shell/audit-cli.ts — CLI/MCP-reachable body for `cw audit verify`.
+//
+// MILESTONE 8. Byte-exact port of the old build's capability-core.ts's
+// `auditVerify`. A run id with no run directory at all is a hard load
+// failure (loadRunFromCwd throws) — absence-is-ok only applies once a
+// run exists but never wrote a trust-audit chain file, not to a missing
+// run entirely.
+//
+// Evidence: SPEC/ledger-trust.md "CLI: `cw audit verify`";
+// plugins/cool-workflow/src/capability-core.ts:1223-1249.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.auditVerifyCli = auditVerifyCli;
+exports.auditSummaryCli = auditSummaryCli;
+exports.auditMultiAgentCli = auditMultiAgentCli;
+exports.auditPolicyCli = auditPolicyCli;
+exports.auditJudgeCli = auditJudgeCli;
+exports.auditWorkerCli = auditWorkerCli;
+exports.auditProvenanceCli = auditProvenanceCli;
+exports.auditRoleCli = auditRoleCli;
+exports.auditBlackboardCli = auditBlackboardCli;
+exports.auditAttestCli = auditAttestCli;
+exports.auditDecisionCli = auditDecisionCli;
+const path = __importStar(require("node:path"));
+const trust_audit_1 = require("./trust-audit");
+const run_store_1 = require("./run-store");
+const trust_policy_io_1 = require("./trust-policy-io");
+const report_1 = require("./report");
+const audit_provenance_1 = require("./audit-provenance");
+const worker_isolation_1 = require("./worker-isolation");
+const sandbox_profile_1 = require("./sandbox-profile");
+function invocationCwd(args) {
+    return typeof args.cwd === "string" && args.cwd.trim() ? path.resolve(args.cwd) : process.cwd();
+}
+function auditVerifyCli(runId, args) {
+    if (!runId)
+        throw new Error("audit verify requires a run id (cw audit verify <run-id>)");
+    const run = (0, run_store_1.loadRunFromCwd)(runId, invocationCwd(args));
+    const v = (0, trust_audit_1.verifyTrustAudit)(run);
+    return {
+        schemaVersion: 1,
+        runId: run.id,
+        present: v.present,
+        verified: v.verified,
+        eventCount: v.eventCount,
+        chained: v.chained,
+        unchained: v.unchained,
+        corruptLines: v.corruptLines,
+        failedChecks: v.checks.filter((c) => !c.pass).map((c) => ({ name: c.name, code: c.code })),
+    };
+}
+/** MILESTONE 11 (reporting/observability, workbench audit panels) —
+ *  `cw audit summary`/`audit multi-agent`/`audit policy`/`audit judge`.
+ *  These read the same trust-audit summary functions the report.md
+ *  writer and multi-agent trust-policy layer already build, so panel
+ *  data can never drift from the standalone commands' output. */
+function auditSummaryCli(runId, args) {
+    const run = (0, run_store_1.loadRunFromCwd)(runId, invocationCwd(args));
+    return (0, trust_audit_1.summarizeTrustAudit)(run);
+}
+function auditMultiAgentCli(runId, args) {
+    const run = (0, run_store_1.loadRunFromCwd)(runId, invocationCwd(args));
+    return (0, trust_policy_io_1.summarizeMultiAgentTrust)(run);
+}
+function auditPolicyCli(runId, args) {
+    const run = (0, run_store_1.loadRunFromCwd)(runId, invocationCwd(args));
+    const summary = (0, trust_policy_io_1.summarizeMultiAgentTrust)(run);
+    return { schemaVersion: 1, runId: run.id, rolePolicies: summary.rolePolicies, permissionDecisions: summary.permissionDecisions, policyViolations: summary.policyViolations };
+}
+function auditJudgeCli(runId, args) {
+    const run = (0, run_store_1.loadRunFromCwd)(runId, invocationCwd(args));
+    const summary = (0, trust_policy_io_1.summarizeMultiAgentTrust)(run);
+    return { schemaVersion: 1, runId: run.id, judgeRationales: summary.judgeRationales, panelDecisions: summary.panelDecisions };
+}
+// ---------------------------------------------------------------------------
+// Phase B: the audit worker/provenance/role/blackboard/attest/decision verbs
+// the old flat build had (cli/handlers/audit.ts + orchestrator/
+// audit-operations.ts). Ported here as thin loadRun -> delegate wrappers over
+// audit-provenance.ts + trust-audit.ts primitives.
+// ---------------------------------------------------------------------------
+function optionalString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : Array.isArray(value) && typeof value[0] === "string" ? value[0] : undefined;
+}
+/** Sanitized env-var NAMES only (`FOO=bar` -> `FOO`); the value is dropped. */
+function valuesOption(value) {
+    const raw = value === undefined || value === null || value === true ? [] : Array.isArray(value) ? value : [value];
+    return raw.map((entry) => String(entry).split("=")[0]).filter(Boolean);
+}
+/** Byte-exact port of the old build's inferAuditDecisionKind. */
+function inferAuditDecisionKind(options) {
+    if (options.command)
+        return "sandbox.command";
+    if (options.network || options.networkTarget)
+        return "sandbox.network";
+    if (options.env || options.envVar)
+        return "sandbox.env";
+    return "sandbox.path";
+}
+/** `cw audit worker <run> <worker>` — every audited event for one worker. */
+function auditWorkerCli(runId, workerId, args) {
+    const run = (0, run_store_1.loadRunFromCwd)(runId, invocationCwd(args));
+    return (0, audit_provenance_1.workerTrustAudit)(run, workerId);
+}
+/** `cw audit provenance <run> [--worker|--candidate|--commit <id>]`. */
+function auditProvenanceCli(runId, args) {
+    const run = (0, run_store_1.loadRunFromCwd)(runId, invocationCwd(args));
+    return (0, audit_provenance_1.evidenceProvenance)(run, {
+        workerId: optionalString(args.worker ?? args.workerId),
+        candidateId: optionalString(args.candidate ?? args.candidateId),
+        commitId: optionalString(args.commit ?? args.commitId),
+    });
+}
+/** `cw audit role <run> <role>` — per-role policy + audit slice. */
+function auditRoleCli(runId, roleId, args) {
+    const run = (0, run_store_1.loadRunFromCwd)(runId, invocationCwd(args));
+    const summary = (0, trust_policy_io_1.summarizeMultiAgentTrust)(run);
+    const events = (0, trust_audit_1.listTrustAuditEvents)(run).filter((event) => event.agentRoleId === roleId);
+    return {
+        schemaVersion: 1,
+        runId: run.id,
+        roleId,
+        role: run.multiAgent?.roles?.find((entry) => entry.id === roleId),
+        rolePolicies: summary.rolePolicies.filter((entry) => entry.subjectId === roleId),
+        permissionDecisions: events.filter((event) => event.kind === "multi-agent.permission"),
+        blackboardWrites: events.filter((event) => event.kind === "blackboard.write"),
+        messageProvenance: events.filter((event) => event.kind === "blackboard.message-provenance"),
+        judgeRationales: events.filter((event) => event.kind === "judge.rationale"),
+        panelDecisions: events.filter((event) => event.kind === "judge.panel-decision"),
+        policyViolations: events.filter((event) => event.kind === "policy.violation"),
+        events,
+        nextAction: `node scripts/cw.js audit multi-agent ${run.id} --json`,
+    };
+}
+/** `cw audit blackboard <run>` — blackboard write/provenance audit. */
+function auditBlackboardCli(runId, args) {
+    const run = (0, run_store_1.loadRunFromCwd)(runId, invocationCwd(args));
+    const summary = (0, trust_policy_io_1.summarizeMultiAgentTrust)(run);
+    return {
+        schemaVersion: 1,
+        runId: run.id,
+        blackboardWrites: summary.blackboardWrites,
+        messageProvenance: summary.messageProvenance,
+        policyViolations: summary.policyViolations.filter((event) => event.blackboardId),
+        nextAction: summary.nextAction,
+    };
+}
+/** `cw audit attest <run> [--worker …] [--command|--network|--env|--note …]`
+ *  — record a host/operator sandbox attestation. */
+function auditAttestCli(runId, args) {
+    const run = (0, run_store_1.loadRunFromCwd)(runId, invocationCwd(args));
+    const workerId = optionalString(args.worker ?? args.workerId);
+    const worker = workerId ? (0, worker_isolation_1.getWorkerScope)(run, workerId) : undefined;
+    const event = (0, audit_provenance_1.recordHostAttestation)(run, {
+        actor: optionalString(args.actor) || "host",
+        workerId,
+        taskId: worker?.taskId || optionalString(args.task ?? args.taskId),
+        sandboxProfileId: worker?.sandboxProfileId || optionalString(args.sandboxProfileId),
+        policySnapshot: worker?.sandboxPolicy,
+        command: optionalString(args.command),
+        networkTarget: optionalString(args.network ?? args.networkTarget),
+        metadata: {
+            note: optionalString(args.note ?? args.message),
+            hostEnforced: args.hostEnforced === undefined ? undefined : Boolean(args.hostEnforced),
+            envVars: valuesOption(args.env ?? args.envVar ?? args.envVars),
+        },
+    });
+    (0, run_store_1.saveCheckpoint)(run);
+    return event;
+}
+/** `cw audit decision <run> <worker> --path|--command|--network|--env <t>`
+ *  — validate a sandbox decision against the worker's policy, record it
+ *  (fail-closed: a denied decision records a structured worker failure), and
+ *  return the audit event. Byte-behavior port of the old recordAuditDecision. */
+function auditDecisionCli(runId, workerId, args) {
+    const run = (0, run_store_1.loadRunFromCwd)(runId, invocationCwd(args));
+    return recordAuditDecision(run, workerId, args);
+}
+function recordAuditDecision(run, workerId, options) {
+    const worker = (0, worker_isolation_1.getWorkerScope)(run, workerId);
+    if (!worker)
+        throw new Error(`Unknown worker id for run ${run.id}: ${workerId}`);
+    const kind = optionalString(options.kind) || inferAuditDecisionKind(options);
+    const target = optionalString(options.path ?? options.command ?? options.network ?? options.networkTarget ?? options.env ?? options.envVar);
+    if (!target)
+        throw new Error("Missing audit decision target: provide --path, --command, --network, or --env");
+    const policy = worker.sandboxPolicy;
+    let denied = null;
+    if (kind === "sandbox.command") {
+        denied = policy ? (0, sandbox_profile_1.validateSandboxCommand)(policy, target, workerId) : null;
+    }
+    else if (kind === "sandbox.network") {
+        denied = policy ? (0, sandbox_profile_1.validateSandboxNetwork)(policy, target, workerId) : null;
+    }
+    else if (kind === "sandbox.env") {
+        const name = target.includes("=") ? target.split("=")[0] : target;
+        const allowed = Boolean(policy?.env.inherit || policy?.env.expose.includes(name));
+        denied = allowed ? null : { code: "sandbox-env-denied", message: `Worker ${workerId} env var is outside sandbox profile ${policy?.id || "unknown"}: ${name}` };
+    }
+    else {
+        denied = (0, worker_isolation_1.validateWorkerBoundary)(run, workerId, { path: target });
+    }
+    const feedbackIds = [];
+    if (denied) {
+        const failurePath = denied.path || (kind === "sandbox.path" ? path.resolve(target) : undefined);
+        const failure = (0, worker_isolation_1.recordWorkerFailure)(run, workerId, { code: denied.code, message: denied.message, at: new Date().toISOString(), path: failurePath, retryable: false }, { code: denied.code, path: failurePath, retryable: false, persist: false });
+        feedbackIds.push(...(failure.feedbackIds || []));
+    }
+    const envVars = kind === "sandbox.env" ? [target.includes("=") ? target.split("=")[0] : target] : undefined;
+    const event = (0, audit_provenance_1.recordSandboxPolicyDecision)(run, {
+        kind,
+        decision: denied ? "denied" : "allowed",
+        workerId,
+        taskId: worker.taskId,
+        sandboxProfileId: worker.sandboxProfileId,
+        policySnapshot: policy,
+        command: kind === "sandbox.command" ? target : undefined,
+        networkTarget: kind === "sandbox.network" ? target : undefined,
+        normalizedPath: kind === "sandbox.path" ? target : undefined,
+        envVars,
+        feedbackIds,
+        metadata: { code: denied?.code },
+    });
+    (0, report_1.writeReport)(run);
+    (0, run_store_1.saveCheckpoint)(run);
+    return event;
+}

package/dist/shell/audit-provenance.js

@@ -0,0 +1,83 @@
+"use strict";
+// shell/audit-provenance.ts — the trust-audit READ + record helpers the
+// old flat build shipped inside src/trust-audit.ts but v2's
+// shell/trust-audit.ts dropped: workerTrustAudit, evidenceProvenance, and
+// the two thin record wrappers (recordHostAttestation,
+// recordSandboxPolicyDecision). These are pure wrappers over the primitives
+// shell/trust-audit.ts DOES export (listTrustAuditEvents,
+// recordTrustAuditEvent), so they live in their own module rather than
+// re-open the audited trust-audit.ts chain writer.
+//
+// Byte-behavior port of the old build's src/trust-audit.ts:354-620.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workerTrustAudit = workerTrustAudit;
+exports.evidenceProvenance = evidenceProvenance;
+exports.recordHostAttestation = recordHostAttestation;
+exports.recordSandboxPolicyDecision = recordSandboxPolicyDecision;
+const trust_audit_1 = require("./trust-audit");
+/** `cw audit worker <run> <worker>` body — every audited event that
+ *  touched one worker. Port of old workerTrustAudit. */
+function workerTrustAudit(run, workerId) {
+    return { workerId, events: (0, trust_audit_1.listTrustAuditEvents)(run).filter((event) => event.workerId === workerId) };
+}
+/** `cw audit provenance <run>` body — the evidence chain (worker output ->
+ *  candidate -> selection -> commit) and the audit events that produced it,
+ *  filtered by candidate/commit/worker. Port of old evidenceProvenance. */
+function evidenceProvenance(run, options = {}) {
+    const events = (0, trust_audit_1.listTrustAuditEvents)(run).filter((event) => {
+        if (options.candidateId && event.candidateId !== options.candidateId)
+            return false;
+        if (options.commitId && event.commitId !== options.commitId)
+            return false;
+        if (options.workerId && event.workerId !== options.workerId)
+            return false;
+        return true;
+    });
+    const evidence = [];
+    for (const node of run.nodes || [])
+        evidence.push(...(node.evidence || []));
+    for (const candidate of run.candidates || [])
+        evidence.push(...(candidate.evidence || []));
+    for (const selection of run.candidateSelections || [])
+        evidence.push(...(selection.evidence || []));
+    for (const commit of run.commits || [])
+        evidence.push(...(commit.evidence || []));
+    const filtered = evidence.filter((entry) => {
+        const provenance = entry.provenance;
+        if (options.candidateId && provenance?.candidateId !== options.candidateId)
+            return false;
+        if (options.commitId && provenance?.commitId !== options.commitId)
+            return false;
+        if (options.workerId && provenance?.workerId !== options.workerId)
+            return false;
+        return true;
+    });
+    return { runId: run.id, evidence: filtered, events };
+}
+/** Record a host/operator sandbox attestation event. Port of old
+ *  recordHostAttestation. */
+function recordHostAttestation(run, input) {
+    return (0, trust_audit_1.recordTrustAuditEvent)(run, {
+        ...input,
+        kind: input.kind || "sandbox.host-attestation",
+        decision: "recorded",
+        source: "host-attested",
+    });
+}
+/** Record a cw-validated sandbox policy decision event. Port of old
+ *  recordSandboxPolicyDecision. */
+function recordSandboxPolicyDecision(run, input) {
+    const { envVars, ...rest } = input;
+    const event = (0, trust_audit_1.recordTrustAuditEvent)(run, {
+        ...rest,
+        source: input.source || "cw-validated",
+        metadata: { ...(input.metadata || {}), ...(envVars && envVars.length ? { envVars } : {}) },
+    });
+    // The old event shape carried the sanitized env-var NAMES on the event
+    // itself; the record wrapper stamps them so `audit decision --env` can echo
+    // them back (the value is never stored — only the name, already stripped
+    // upstream).
+    if (envVars && envVars.length)
+        event.envVars = envVars;
+    return event;
+}