pi-wasm-kit 0.0.0-stage → 0.2.0

package/dist/storage/node.js

@@ -0,0 +1,105 @@
+import { open, readFile, mkdir, unlink, truncate } from 'node:fs/promises';
+import { dirname } from 'node:path';
+export async function openNodeJournal(path) {
+    await mkdir(dirname(path), { recursive: true });
+    const lockPath = `${path}.lock`;
+    let lock;
+    try {
+        lock = await open(lockPath, 'wx', 0o600);
+    }
+    catch (error) {
+        if (error.code !== 'EEXIST')
+            throw error;
+        // Serialize stale-lock reclamation, then reread the owner under that guard.
+        // An abandoned reclaim guard fails closed and requires operator inspection.
+        const guardPath = `${lockPath}.reclaim`;
+        let guard;
+        try {
+            guard = await open(guardPath, 'wx', 0o600);
+        }
+        catch {
+            throw new Error('Journal owner is being recovered; retry or inspect the reclaim lock');
+        }
+        try {
+            const pid = Number(await readFile(lockPath, 'utf8'));
+            if (!Number.isInteger(pid) || pid <= 0)
+                throw new Error('Journal lock is incomplete; inspect it before removing');
+            try {
+                process.kill(pid, 0);
+                throw new Error('Journal already has an owner');
+            }
+            catch (probe) {
+                if (probe.code !== 'ESRCH')
+                    throw probe;
+            }
+            await unlink(lockPath);
+            lock = await open(lockPath, 'wx', 0o600);
+            // Publish ownership before releasing the reclaim guard.
+            await lock.writeFile(String(process.pid));
+            await lock.sync();
+        }
+        finally {
+            await guard.close();
+            await unlink(guardPath);
+        }
+    }
+    await lock.write(String(process.pid), 0);
+    await lock.sync();
+    let file;
+    try {
+        file = await open(path, 'a+', 0o600);
+    }
+    catch (error) {
+        await lock.close();
+        await unlink(lockPath);
+        throw error;
+    }
+    let closed = false;
+    let tail = Promise.resolve();
+    let expected = 1;
+    return {
+        async load() {
+            if (closed)
+                throw new Error('Journal is closed');
+            const bytes = await readFile(path);
+            const end = bytes.lastIndexOf(10) + 1;
+            if (end !== bytes.length) {
+                await truncate(path, end);
+                await file.sync();
+            }
+            const lines = bytes.subarray(0, end).toString('utf8').split('\n').filter(Boolean);
+            const commits = lines.map((line, index) => {
+                const commit = JSON.parse(line);
+                if (commit.seq !== index + 1 || !Array.isArray(commit.writes))
+                    throw new Error('Corrupt journal');
+                return commit;
+            });
+            expected = commits.length + 1;
+            return commits;
+        },
+        append(commit) {
+            if (closed)
+                return Promise.reject(new Error('Journal is closed'));
+            const serialized = JSON.stringify(commit) + '\n';
+            const seq = commit.seq;
+            const write = tail.then(async () => {
+                if (seq !== expected)
+                    throw new Error('Journal sequence conflict');
+                await file.writeFile(serialized);
+                await file.sync();
+                expected++;
+            });
+            tail = write;
+            return write;
+        },
+        async close() { if (closed)
+            return; closed = true; try {
+            await tail;
+        }
+        finally {
+            await file.close();
+            await lock.close();
+            await unlink(lockPath);
+        } },
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,66 @@
+import type { AssistantMessage, AssistantMessageEvent, Model, TranscriptContext } from '@earendil-works/pi-ai';
+import type { StorageWrite, ConversationView, SettledSubmissionRecord, AgentEvent as PiEvent, AgentState, ToolExecutionResult, HarnessSettings } from '@earendil-works/pi-durable';
+export interface JournalCommit {
+    seq: number;
+    writes: readonly StorageWrite[];
+}
+/** One exclusive owner. append resolves only after an atomic durable commit. */
+export interface Journal {
+    load(): Promise<JournalCommit[]>;
+    append(commit: JournalCommit): Promise<void>;
+    close(): Promise<void>;
+}
+export interface ModelRequest {
+    model: Model<any>;
+    context: TranscriptContext;
+    options?: Record<string, unknown>;
+}
+export type ModelHandler = (request: ModelRequest, signal: AbortSignal, emit: (event: AssistantMessageEvent) => void) => Promise<AssistantMessage>;
+export interface ToolContext {
+    taskId: number;
+    conversationId: number;
+    signal: AbortSignal;
+    callId: string;
+    output(text: string): void;
+}
+export interface HostTool {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+    /** Set only when retrying after interruption is safe. */
+    replay?: 'safe';
+    execute(args: Record<string, unknown>, context: ToolContext): Promise<string | ToolExecutionResult> | string | ToolExecutionResult;
+}
+export interface AgentOptions {
+    journal: Journal;
+    model: ModelHandler;
+    tools?: HostTool[];
+    /** CommonJS sources exporting Pi extensions. Reinstall the same definitions on recovery. */
+    extensions?: string[];
+    settings?: Omit<HarnessSettings, 'extensions'>;
+    /** Open without scheduling persisted work, e.g. to admit a cancellation before recovery. */
+    autoResume?: boolean;
+    instructions?: string;
+    modelId?: string;
+    contextWindow?: number;
+    memoryLimitBytes?: number;
+    cpuSliceMs?: number;
+    onEvent?: (event: AgentEvent) => void;
+}
+export type AgentEvent = {
+    type: 'commit';
+    seq: number;
+} | {
+    type: 'error';
+    message: string;
+} | {
+    type: 'events';
+    conversationId: number;
+    events: readonly PiEvent[];
+};
+export type AgentView = ConversationView;
+export type SubmissionResult = SettledSubmissionRecord;
+export type AgentConfiguration = Partial<Pick<AgentState, 'model' | 'thinkingLevel' | 'instructions' | 'cwd'>> & {
+    extensions?: string[];
+    tools?: string[];
+};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,77 @@
 {
   "name": "pi-wasm-kit",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "description": "Pi Durable inside a QuickJS WebAssembly sandbox, with browser and Node hosts.",
+  "scripts": {
+    "build": "node scripts/build.mjs && tsc",
+    "typecheck": "tsc --noEmit && tsc -p tsconfig.demo.json",
+    "test": "npm run build && node --test test/*.test.mjs",
+    "dev": "vite --host 127.0.0.1",
+    "test:e2e": "playwright test",
+    "check": "npm test && npm run typecheck && npm run build:demo && npm run test:e2e",
+    "prepack": "npm run build",
+    "build:demo": "npm run build && vite build",
+    "preview": "vite preview --host 127.0.0.1",
+    "test:package": "node scripts/package-smoke.mjs"
+  },
+  "keywords": [
+    "pi",
+    "durable",
+    "wasm",
+    "quickjs",
+    "agents",
+    "browser"
+  ],
+  "author": "leepokai",
+  "license": "MIT",
+  "type": "module",
+  "dependencies": {
+    "@earendil-works/chord": "1.1.0",
+    "@earendil-works/pi-ai": "1.1.0",
+    "@earendil-works/pi-durable": "1.1.0",
+    "@jitl/quickjs-wasmfile-release-sync": "0.32.0",
+    "abort-controller": "3.0.0",
+    "quickjs-emscripten-core": "0.32.0"
+  },
+  "devDependencies": {
+    "@playwright/test": "1.64.0",
+    "@types/node": "26.6.4",
+    "esbuild": "0.28.2",
+    "typescript": "7.0.2",
+    "vite": "8.3.4"
+  },
+  "engines": {
+    "node": ">=22.19"
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "NOTICE"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./node": {
+      "types": "./dist/storage/node.d.ts",
+      "import": "./dist/storage/node.js"
+    },
+    "./browser": {
+      "types": "./dist/storage/browser.d.ts",
+      "import": "./dist/storage/browser.js"
+    },
+    "./openai": {
+      "types": "./dist/providers/openai.d.ts",
+      "import": "./dist/providers/openai.js"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/leepokai/pi-wasm-kit.git"
+  },
+  "homepage": "https://github.com/leepokai/pi-wasm-kit#readme",
+  "bugs": {
+    "url": "https://github.com/leepokai/pi-wasm-kit/issues"
+  }
+}