harnery 0.22.1 → 0.23.0

package/dist/core/workflow/workspaces/inspect.js

@@ -0,0 +1,255 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { readWorkItem } from "../../work/state.js";
+import { readWorkflowProof } from "../proof.js";
+import { readWorkflowRunManifest } from "../run-state.js";
+import { deriveWorkspaceLifecycle } from "./lifecycle.js";
+import { fileSha256, readCleanupAttempts, readIntegrationAttempts, readWorkflowSupplement, readWorkspaceEvents, workflowRunDir, } from "./state.js";
+import { isWorkspaceBoundExecutionEvidence } from "./validate.js";
+const RUN_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,199}$/;
+/**
+ * Read one workflow's workspace state from validated durable authority.
+ *
+ * Corrupt, contradictory, or foreign records throw instead of being projected
+ * as healthy. Use inspectWorkflowWorkspace when a UI needs a typed error row.
+ */
+export function readWorkflowWorkspaceStatus(coordRoot, runId) {
+    assertRunId(runId);
+    const root = resolve(coordRoot);
+    const runDir = workflowRunDir(root, runId);
+    const manifest = readWorkflowRunManifest(root, runId);
+    const journal = readWorkspaceJournal(runDir, runId);
+    const proofPath = join(runDir, "proof.json");
+    const proof = existsSync(proofPath) ? readWorkflowProof(root, runId) : undefined;
+    const proofSha256 = proof ? fileSha256(proofPath) : undefined;
+    const binding = manifest.execution.workspace_binding;
+    const fallback = manifest.execution.workspace_fallback;
+    if (!binding) {
+        const lifecycle = deriveWorkspaceLifecycle({
+            manifest,
+            workflow_journal: journal,
+            proof,
+            proof_sha256: proofSha256,
+            allocation_unsupported: fallback !== undefined,
+        });
+        return {
+            schema_version: 1,
+            run_id: runId,
+            run_name: manifest.name,
+            work_item_id: manifest.work_item_id,
+            started_at: manifest.started_at,
+            selection: fallback ? "compatibility" : "shared",
+            requested_isolation: manifest.execution.isolation,
+            effective_isolation: "shared",
+            provider: fallback?.provider,
+            compatibility: fallback
+                ? {
+                    reason: fallback.selection_reason,
+                    unsupported: [...fallback.unsupported],
+                    unknowns: [...fallback.unknowns],
+                }
+                : undefined,
+            lifecycle,
+            verification: {
+                status: "not_applicable",
+                workflow_status: proof?.run.status,
+                drift: [...(fallback?.drift ?? [])],
+                unsupported: [...(fallback?.unsupported ?? [])],
+                unknowns: [...(fallback?.unknowns ?? [])],
+            },
+            integration: { state: "none", changed_paths: [] },
+            cleanup: { state: "not_requested", attempts: 0 },
+            repository: { dirty_paths: [], conflicts: [], operations_in_progress: [] },
+            integrity: {
+                status: "verified",
+                proof_sha256: proofSha256,
+                provider_event_chain_sha256: null,
+            },
+        };
+    }
+    const providerEvents = readWorkspaceEvents(root, binding.provider.id, binding.binding_id);
+    const integrationPlan = readWorkflowSupplement(root, runId, "integration/plan.json");
+    const integrationAuthorization = readWorkflowSupplement(root, runId, "integration/authorization.json");
+    const integrationAttempts = readIntegrationAttempts(root, runId);
+    const integrationReceipt = readWorkflowSupplement(root, runId, "integration/receipt.json");
+    const cleanupIntent = readWorkflowSupplement(root, runId, "cleanup/intent.json");
+    const cleanupAttempts = readCleanupAttempts(root, runId);
+    const cleanupReceipt = readWorkflowSupplement(root, runId, "cleanup/receipt.json");
+    const cancellationReceipt = readWorkflowSupplement(root, runId, "cancellation/outcome.json");
+    const workEvents = binding.owner.kind === "work_attempt"
+        ? readWorkItem(root, binding.owner.work_item_id).events
+        : undefined;
+    const lifecycle = deriveWorkspaceLifecycle({
+        binding,
+        provider_events: providerEvents,
+        manifest,
+        workflow_journal: journal,
+        proof,
+        proof_sha256: proofSha256,
+        integration_plan: integrationPlan,
+        integration_authorization: integrationAuthorization,
+        integration_attempts: integrationAttempts,
+        integration_receipt: integrationReceipt,
+        cleanup_intent: cleanupIntent,
+        cleanup_attempts: cleanupAttempts,
+        cleanup_receipt: cleanupReceipt,
+        work_events: workEvents,
+        cancellation_receipt: cancellationReceipt,
+    });
+    const latestCleanup = cleanupAttempts.at(-1);
+    const attestation = latestAttestation(proof, latestCleanup?.attestation, cleanupReceipt);
+    return {
+        schema_version: 1,
+        run_id: runId,
+        run_name: manifest.name,
+        work_item_id: manifest.work_item_id,
+        started_at: manifest.started_at,
+        selection: "isolated",
+        requested_isolation: manifest.execution.isolation,
+        effective_isolation: binding.isolation,
+        provider: binding.provider,
+        allocation: {
+            binding_id: binding.binding_id,
+            workspace_id: binding.workspace_id,
+            workspace_root: binding.workspace_root,
+            active_root: binding.active_root,
+            created_at: binding.created_at,
+        },
+        lifecycle,
+        verification: {
+            status: verificationStatus(proof, attestation),
+            workflow_status: proof?.run.status,
+            attested_at: attestation?.recorded_at,
+            drift: [...(attestation?.provider_drift ?? [])],
+            unsupported: [...(attestation?.unsupported ?? [])],
+            unknowns: [...(attestation?.unknowns ?? [])],
+        },
+        integration: {
+            state: lifecycle.integration_state,
+            changed_paths: [...(integrationPlan?.provider_preview.changed_paths ?? [])],
+            target_ref: integrationPlan?.provider_preview.target_ref,
+            target_commit: integrationReceipt?.target_commit ?? integrationPlan?.provider_preview.target_commit,
+            receipt_id: integrationReceipt?.receipt_id,
+        },
+        cleanup: {
+            state: cleanupState(cleanupIntent, latestCleanup?.status, cleanupReceipt),
+            attempts: cleanupAttempts.length,
+            reason: latestCleanup?.reason,
+            receipt_id: cleanupReceipt?.receipt_id,
+        },
+        repository: {
+            dirty_paths: [...(attestation?.repository?.dirty_paths ?? [])],
+            conflicts: [...(attestation?.repository?.conflicts ?? [])],
+            operations_in_progress: [...(attestation?.repository?.operation_in_progress ?? [])],
+        },
+        integrity: {
+            status: "verified",
+            proof_sha256: proofSha256,
+            provider_event_chain_sha256: lifecycle.provider_event_chain_sha256,
+        },
+    };
+}
+export function inspectWorkflowWorkspace(coordRoot, runId) {
+    try {
+        return { ok: true, value: readWorkflowWorkspaceStatus(coordRoot, runId) };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            run_id: runId,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+export function listWorkflowWorkspaceInspections(coordRoot) {
+    const workflowsRoot = join(resolve(coordRoot), ".harnery", "workflows");
+    if (!existsSync(workflowsRoot))
+        return [];
+    return readdirSync(workflowsRoot)
+        .filter((runId) => RUN_ID.test(runId) && existsSync(join(workflowsRoot, runId, "run.json")))
+        .sort((a, b) => b.localeCompare(a))
+        .map((runId) => inspectWorkflowWorkspace(coordRoot, runId));
+}
+export function renderWorkflowWorkspaceStatus(status) {
+    const lines = [
+        `run ${status.run_id} (${status.run_name}): ${status.selection}`,
+        `isolation: requested ${status.requested_isolation}; effective ${status.effective_isolation}`,
+        `lifecycle: ${status.lifecycle.state}; resource ${status.lifecycle.resource_state ?? "not applicable"}; integration ${status.lifecycle.integration_state}; cancellation ${status.lifecycle.cancellation}`,
+    ];
+    if (status.provider) {
+        lines.push(`provider: ${status.provider.id}@${status.provider.version}`);
+    }
+    if (status.compatibility) {
+        lines.push(`compatibility: ${status.compatibility.reason}`);
+    }
+    if (status.allocation) {
+        lines.push(`binding: ${status.allocation.binding_id}; workspace ${status.allocation.workspace_id}`, `workspace root: ${status.allocation.workspace_root}`, `active root: ${status.allocation.active_root}`);
+    }
+    lines.push(`verification: ${status.verification.status}; workflow ${status.verification.workflow_status ?? "not terminal"}; ${status.verification.drift.length} drift; ${status.verification.unknowns.length} unknown`, `repository: ${status.repository.dirty_paths.length} dirty; ${status.repository.conflicts.length} conflict; ${status.repository.operations_in_progress.length} operation in progress`, `integration: ${status.integration.state}; ${status.integration.changed_paths.length} changed path`, `cleanup: ${status.cleanup.state}; ${status.cleanup.attempts} attempt`);
+    if (status.cleanup.reason)
+        lines.push(`cleanup reason: ${status.cleanup.reason}`);
+    return `${lines.join("\n")}\n`;
+}
+function readWorkspaceJournal(runDir, runId) {
+    const path = join(runDir, "journal.jsonl");
+    if (!existsSync(path))
+        return [];
+    return readFileSync(path, "utf8")
+        .split("\n")
+        .filter(Boolean)
+        .map((line, index) => {
+        let record;
+        try {
+            record = JSON.parse(line);
+        }
+        catch (error) {
+            throw new Error(`cannot parse workflow journal event ${index + 1}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        if (typeof record.event !== "string" ||
+            (record.run_id !== undefined && record.run_id !== runId)) {
+            throw new Error(`workflow journal event ${index + 1} is foreign or unsupported`);
+        }
+        return {
+            event: record.event,
+            ok: typeof record.ok === "boolean" ? record.ok : undefined,
+            status: journalStatus(record.status),
+            work_event_seq: typeof record.work_event_seq === "number" ? record.work_event_seq : undefined,
+            work_event_sha256: typeof record.work_event_sha256 === "string" ? record.work_event_sha256 : undefined,
+        };
+    });
+}
+function latestAttestation(proof, cleanupAttempt, cleanupReceipt) {
+    if (cleanupReceipt)
+        return cleanupReceipt.attestation;
+    if (cleanupAttempt)
+        return cleanupAttempt;
+    if (proof && isWorkspaceBoundExecutionEvidence(proof.execution, proof.run.id)) {
+        return proof.execution.terminal_attestation;
+    }
+    return undefined;
+}
+function verificationStatus(proof, attestation) {
+    if (!proof || !attestation)
+        return "pending";
+    return attestation.status;
+}
+function cleanupState(intent, attemptStatus, receipt) {
+    if (receipt)
+        return "released";
+    if (attemptStatus === "preserved_dirty")
+        return "preserved_dirty";
+    if (attemptStatus && ["blocked", "unsupported", "partial"].includes(attemptStatus)) {
+        return "blocked";
+    }
+    return intent || attemptStatus ? "pending" : "not_requested";
+}
+function journalStatus(value) {
+    return typeof value === "string" &&
+        ["blocked", "lost", "cancelled", "unsupported", "preserved_dirty"].includes(value)
+        ? value
+        : undefined;
+}
+function assertRunId(runId) {
+    if (!RUN_ID.test(runId))
+        throw new Error("workflow run id is invalid");
+}

package/dist/core/workflow/workspaces/integration.d.ts

@@ -0,0 +1,24 @@
+import { type NormalizedPolicy, type PolicySpec } from "../../policy/index.js";
+import type { IntegrationApplyReceipt, IntegrationPlan, WorkspaceProvider } from "./types.js";
+export interface PrepareIntegrationInput {
+    coordRoot: string;
+    runId: string;
+    provider: WorkspaceProvider;
+    policy: PolicySpec | NormalizedPolicy;
+    targetRoot?: string;
+    review?: {
+        actor: string;
+        reason?: string;
+    };
+    acceptedUnknowns?: readonly string[];
+    approvalAddressee?: string;
+}
+export interface ApplyIntegrationInput {
+    coordRoot: string;
+    runId: string;
+    provider: WorkspaceProvider;
+    plan?: IntegrationPlan;
+}
+export declare function prepareIntegration(input: PrepareIntegrationInput): Promise<IntegrationPlan>;
+export declare function applyIntegration(input: ApplyIntegrationInput): Promise<IntegrationApplyReceipt>;
+//# sourceMappingURL=integration.d.ts.map

package/dist/core/workflow/workspaces/integration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integration.d.ts","sourceRoot":"","sources":["../../../../src/core/workflow/workspaces/integration.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,gBAAgB,EAGrB,KAAK,UAAU,EAGhB,MAAM,uBAAuB,CAAC;AAgB/B,OAAO,KAAK,EAEV,uBAAuB,EAEvB,eAAe,EAOf,iBAAiB,EAClB,MAAM,YAAY,CAAC;AAUpB,MAAM,WAAW,uBAAuB;IACtC,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,MAAM,EAAE,UAAU,GAAG,gBAAgB,CAAC;IACtC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC5C,gBAAgB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,qBAAqB;IACpC,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,IAAI,CAAC,EAAE,eAAe,CAAC;CACxB;AAED,wBAAsB,kBAAkB,CAAC,KAAK,EAAE,uBAAuB,GAAG,OAAO,CAAC,eAAe,CAAC,CA2GjG;AAED,wBAAsB,gBAAgB,CACpC,KAAK,EAAE,qBAAqB,GAC3B,OAAO,CAAC,uBAAuB,CAAC,CAuNlC"}