@purista/harness 1.0.0 → 1.2.0

package/dist/workspace/in-memory.js

@@ -0,0 +1,142 @@
+/** In-process durable workspace store for local development, examples, and tests. */
+export class InMemoryDurableWorkspaceStore {
+    info = {
+        id: 'in_memory_workspace_store',
+        packageName: '@purista/harness',
+        capabilities: [
+            'workspace_store.durable',
+            'workspace_store.checkpoint',
+            'workspace_store.resume',
+            'workspace_store.abort',
+            'workspace_store.cleanup',
+            'workspace_store.inspect',
+            'workspace_store.retention',
+            'workspace_store.quota'
+        ],
+        policy: {
+            retention: {
+                pausedTtlMs: 86_400_000,
+                terminalFailureTtlMs: 86_400_000,
+                terminalSuccessTtlMs: 0,
+                cleanupMode: 'manual_only'
+            },
+            quota: { maxActiveWorkspaces: 100, maxWorkspaceBytes: 10_000_000 }
+        }
+    };
+    capabilities = this.info.capabilities;
+    workspaces = new Map();
+    nextId = 1;
+    configureHarnessContext() { }
+    async startWorkspace(opts) {
+        opts.signal?.throwIfAborted();
+        const workspaceRef = `workspace_${this.nextId++}`;
+        const now = new Date().toISOString();
+        const metadata = { ...(opts.metadata ?? {}) };
+        const workspace = {
+            workspaceRef,
+            state: 'active',
+            runId: opts.runId,
+            sessionId: opts.sessionId,
+            attempt: opts.attempt,
+            createdAt: now,
+            updatedAt: now,
+            metadata,
+            checkpoints: []
+        };
+        this.workspaces.set(workspaceRef, workspace);
+        return { workspaceRef, runId: opts.runId, sessionId: opts.sessionId, state: 'active', startedAt: now, attempt: opts.attempt, metadata };
+    }
+    async pauseWorkspace(opts) {
+        opts.signal?.throwIfAborted();
+        const workspace = this.requireWorkspace(opts.handle.workspaceRef);
+        workspace.state = 'paused';
+        workspace.updatedAt = new Date().toISOString();
+        const checkpoint = {
+            workspaceRef: workspace.workspaceRef,
+            checkpointRef: `${workspace.workspaceRef}:checkpoint:${opts.sequence}`,
+            runId: workspace.runId,
+            sessionId: workspace.sessionId,
+            stepId: opts.stepId,
+            sequence: opts.sequence,
+            attempt: opts.attempt,
+            committedAt: workspace.updatedAt,
+            metadata: {
+                reason: opts.reason,
+                ...(opts.checkpointPayload !== undefined ? { checkpointPayload: opts.checkpointPayload } : {})
+            }
+        };
+        workspace.checkpoints.push(checkpoint);
+        return checkpoint;
+    }
+    async resumeWorkspace(opts) {
+        opts.signal?.throwIfAborted();
+        const workspace = this.requireWorkspace(opts.workspaceRef);
+        if (opts.checkpointRef && !workspace.checkpoints.some((checkpoint) => checkpoint.checkpointRef === opts.checkpointRef)) {
+            throw new Error(`Unknown workspace checkpoint: ${opts.checkpointRef}`);
+        }
+        workspace.state = 'active';
+        workspace.runId = opts.runId;
+        workspace.sessionId = opts.sessionId;
+        workspace.attempt = opts.attempt;
+        workspace.updatedAt = new Date().toISOString();
+        return {
+            workspaceRef: workspace.workspaceRef,
+            runId: workspace.runId,
+            sessionId: workspace.sessionId,
+            state: 'active',
+            startedAt: workspace.updatedAt,
+            attempt: workspace.attempt,
+            metadata: workspace.metadata
+        };
+    }
+    async abortWorkspace(opts) {
+        opts.signal?.throwIfAborted();
+        const workspace = this.requireWorkspace(opts.workspaceRef);
+        workspace.state = 'aborted';
+        workspace.updatedAt = new Date().toISOString();
+        return { workspaceRef: opts.workspaceRef, state: 'aborted', abortedAt: workspace.updatedAt };
+    }
+    async cleanupWorkspace(opts) {
+        opts.signal?.throwIfAborted();
+        const workspace = this.requireWorkspace(opts.workspaceRef);
+        workspace.state = 'cleaned';
+        workspace.updatedAt = new Date().toISOString();
+        this.workspaces.delete(opts.workspaceRef);
+        return { workspaceRef: opts.workspaceRef, state: 'cleaned', completedAt: workspace.updatedAt };
+    }
+    async inspectWorkspace(opts) {
+        opts.signal?.throwIfAborted();
+        const workspaceRef = opts.workspaceRef ?? this.findWorkspaceByCheckpoint(opts.checkpointRef);
+        const workspace = this.requireWorkspace(workspaceRef);
+        const latest = workspace.checkpoints.at(-1);
+        return {
+            workspaceRef: workspace.workspaceRef,
+            state: workspace.state,
+            checkpoints: workspace.checkpoints,
+            ...(latest ? { currentCheckpointRef: latest.checkpointRef } : {}),
+            retention: this.info.policy.retention,
+            quota: this.info.policy.quota,
+            createdAt: workspace.createdAt,
+            updatedAt: workspace.updatedAt,
+            metadata: workspace.metadata
+        };
+    }
+    findWorkspaceByCheckpoint(checkpointRef) {
+        if (!checkpointRef)
+            throw new Error('workspaceRef or checkpointRef is required.');
+        const found = [...this.workspaces.values()].find((workspace) => workspace.checkpoints.some((checkpoint) => checkpoint.checkpointRef === checkpointRef));
+        if (!found)
+            throw new Error(`Unknown workspace checkpoint: ${checkpointRef}`);
+        return found.workspaceRef;
+    }
+    requireWorkspace(workspaceRef) {
+        const workspace = this.workspaces.get(workspaceRef);
+        if (!workspace)
+            throw new Error(`Unknown workspace: ${workspaceRef}`);
+        return workspace;
+    }
+}
+/** Creates a fresh in-process durable workspace store. */
+export function inMemoryDurableWorkspaceStore() {
+    return new InMemoryDurableWorkspaceStore();
+}

package/dist/workspace/index.d.ts

@@ -0,0 +1 @@
+export { InMemoryDurableWorkspaceStore, inMemoryDurableWorkspaceStore } from './in-memory.js';

package/dist/workspace/index.js

@@ -0,0 +1 @@
+export { InMemoryDurableWorkspaceStore, inMemoryDurableWorkspaceStore } from './in-memory.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@purista/harness",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "Self-hosted enterprise agent harness for typed tools, agents, workflows, state, sandboxing, and telemetry.",
   "type": "module",
   "main": "dist/index.js",
@@ -39,22 +39,25 @@
   "scripts": {
     "clean": "rm -rf dist",
     "build": "npm run clean && tsc -p tsconfig.json",
+    "lint": "npm run typecheck",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "test:types": "tsc -p tsconfig.type-tests.json",
     "test": "vitest run",
     "test:unit": "vitest run src",
+    "test:coverage": "vitest run --coverage",
     "test:contracts": "vitest run src/ports test/sandbox.test.ts",
     "test:integration": "vitest run test/harness.test.ts test/tools.test.ts test/skills.test.ts test/telemetry-flow.test.ts",
     "test:failure": "vitest run test/failure"
   },
   "dependencies": {
-    "@opentelemetry/semantic-conventions": "^1.40.0",
+    "@opentelemetry/semantic-conventions": "^1.41.1",
+    "yaml": "^2.9.0",
     "zod": "^4.4.3"
   },
   "peerDependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@opentelemetry/api": "^1.9.1",
-    "just-bash": "^2.14.4"
+    "just-bash": "^3.0.1"
   },
   "peerDependenciesMeta": {
     "@modelcontextprotocol/sdk": {
@@ -67,9 +70,12 @@
   "devDependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@opentelemetry/context-async-hooks": "^2.7.1",
-    "@types/node": "^25.6.0",
-    "just-bash": "^2.14.4",
+    "@types/node": "^25.9.1",
+    "just-bash": "^3.0.1",
     "typescript": "^6.0.3",
-    "vitest": "^4.1.5"
+    "vitest": "^4.1.8"
+  },
+  "engines": {
+    "node": ">=24.15.0"
   }
 }