oorja-harness-host 0.1.0 → 0.2.1

package/README.md

@@ -10,3 +10,14 @@ machine identity, and command-line presentation.
 Turn output remains buffered in memory until the client confirms that it has
 saved it. On graceful shutdown, the host saves the opaque AI SDK resume state
 provided by each harness session so the next process can resume it.
+
+Harness state is stored in one SQLite database. The host keeps exclusive access
+to that database while it is running; `stop()` saves the sessions and closes
+the database.
+
+```ts
+const host = await HarnessHost.start({
+  // ...
+  stateFile: '/path/to/harness-host.sqlite',
+})
+```

package/dist/database/index.d.ts

@@ -0,0 +1,6 @@
+import { DatabaseSync } from 'node:sqlite';
+export interface Migration {
+    version: number;
+    apply: (database: DatabaseSync) => void;
+}
+export declare const openDatabase: (file: string, migrations: Migration[]) => DatabaseSync;

package/dist/database/index.js

@@ -0,0 +1,29 @@
+import { mkdirSync } from 'node:fs';
+import path from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+export const openDatabase = (file, migrations) => {
+    mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+    const database = new DatabaseSync(file, { timeout: 0 });
+    try {
+        database.exec('PRAGMA locking_mode = EXCLUSIVE');
+        database.exec('PRAGMA journal_mode = DELETE');
+        database.exec('BEGIN EXCLUSIVE');
+        const { user_version: currentVersion } = database
+            .prepare('PRAGMA user_version')
+            .get();
+        for (const migration of migrations) {
+            if (migration.version <= currentVersion)
+                continue;
+            migration.apply(database);
+            database.exec(`PRAGMA user_version = ${migration.version}`);
+        }
+        database.exec('COMMIT');
+        return database;
+    }
+    catch (error) {
+        if (database.isTransaction)
+            database.exec('ROLLBACK');
+        database.close();
+        throw error;
+    }
+};

package/dist/harnesses/doctor.js

@@ -10,12 +10,13 @@ export const runHarnessDoctor = async (cwd, harnessName) => {
         home ? canAccess(home, constants.R_OK | constants.W_OK) : false,
         checkLoopbackPort().then(() => true, () => false),
     ]);
-    const nodeMajor = Number(process.versions.node.split('.')[0]);
+    const [nodeMajor, nodeMinor] = process.versions.node.split('.').map(Number);
+    const nodeIsSupported = nodeMajor > 24 || (nodeMajor === 24 && nodeMinor >= 15);
     return [
         {
             name: 'node',
-            ok: nodeMajor >= 22,
-            detail: `Node ${process.versions.node}; requires Node 22 or newer`,
+            ok: nodeIsSupported,
+            detail: `Node ${process.versions.node}; requires Node 24.15 or newer`,
         },
         {
             name: 'pnpm',

package/dist/harnesses/runtime.js

@@ -1,7 +1,7 @@
 import { createServer } from 'node:net';
 import { HarnessAgent } from '@ai-sdk/harness/agent';
 import { jsonSchema } from 'ai';
-import { HARNESS_MODELS } from '../models.js';
+import { HARNESS_MODELS } from '../host/models.js';
 import { LocalSandboxSession } from '../sandbox/local.js';
 export const createHarnessRuntime = ({ harnessId, cwd, createHarness, }) => ({
     harnessId,

package/dist/{utils.d.ts → host/Future.d.ts}

@@ -1,5 +1,5 @@
 export declare class Future<T> {
-    promise: Promise<T>;
+    readonly promise: Promise<T>;
     resolve?: (arg: T) => void;
     reject?: (error: unknown) => void;
     onFinally?: () => void;

package/dist/{HarnessHost.d.ts → host/HarnessHost.d.ts}

@@ -1,21 +1,23 @@
-import { type HarnessCommand, type HarnessEvent, type HostState } from './messages.js';
-import type { ResumeStateStore } from './resumeState.js';
-import type { HarnessRuntime } from './runtime.js';
+import { type HarnessCommand, type HarnessEvent, type HostState } from '../messages.js';
+import type { HarnessRuntime } from '../runtime.js';
 export type HarnessHostOptions = {
     hostId: string;
     hostname: string;
+    stateFile: string;
     runtimes: HarnessRuntime[];
-    resumeStates: ResumeStateStore;
     emit: (event: HarnessEvent) => void;
     onError: (error: unknown) => void;
 };
 export declare class HarnessHost {
     private readonly options;
+    private readonly database;
+    private readonly repo;
     private readonly runtimes;
     private readonly sessions;
     private readonly openingSessions;
     private stopping;
-    constructor(options: HarnessHostOptions);
+    private constructor();
+    static start: (options: HarnessHostOptions) => Promise<HarnessHost>;
     getState: () => HostState;
     handleCommand: (command: HarnessCommand) => Promise<void>;
     stop: () => Promise<void>;

package/dist/{HarnessHost.js → host/HarnessHost.js}

@@ -1,19 +1,42 @@
 import { randomUUID } from 'node:crypto';
 import { smoothStream } from 'ai';
-import { HarnessTurnPartType, MessageType, SessionStatus, TurnOutcome, } from './messages.js';
+import { HarnessTurnPartType, MessageType, SessionStatus, TurnOutcome, } from '../messages.js';
 import { createTurnActivity, updateTurnActivity, } from './activity.js';
 import { HARNESS_MODELS } from './models.js';
-import { Future } from './utils.js';
+import { HarnessRepo, harnessMigrations } from '../repo/index.js';
+import { openDatabase } from '../database/index.js';
+import { Future } from './Future.js';
 export class HarnessHost {
     options;
+    database;
+    repo;
     runtimes;
     sessions = new Map();
     openingSessions = new Map();
     stopping = false;
-    constructor(options) {
+    constructor(options, database, repo) {
         this.options = options;
+        this.database = database;
+        this.repo = repo;
         this.runtimes = new Map(options.runtimes.map((runtime) => [runtime.harnessId, runtime]));
     }
+    static start = async (options) => {
+        const database = openDatabase(options.stateFile, harnessMigrations);
+        try {
+            const repo = new HarnessRepo(database);
+            const storedHostId = repo.getHostId();
+            if (storedHostId && storedHostId !== options.hostId) {
+                throw new Error(`Harness state belongs to host ${storedHostId}, not ${options.hostId}`);
+            }
+            if (!storedHostId)
+                repo.saveHostId(options.hostId);
+            return new HarnessHost(options, database, repo);
+        }
+        catch (error) {
+            database.close();
+            throw error;
+        }
+    };
     getState = () => ({
         type: MessageType.HOST_STATE,
         hostId: this.options.hostId,
@@ -53,12 +76,17 @@ export class HarnessHost {
     };
     stop = async () => {
         this.stopping = true;
-        await Promise.allSettled(this.openingSessions.values());
-        const sessions = [...this.sessions.values()];
-        sessions.forEach(({ activeTurn }) => activeTurn?.abortController.abort());
-        await Promise.allSettled(sessions.map(({ activeTurn }) => activeTurn?.completion.promise));
-        await Promise.allSettled(sessions.map(this.saveSession));
-        this.sessions.clear();
+        try {
+            await Promise.allSettled(this.openingSessions.values());
+            const sessions = [...this.sessions.values()];
+            sessions.forEach(({ activeTurn }) => activeTurn?.abortController.abort());
+            await Promise.allSettled(sessions.map(({ activeTurn }) => activeTurn?.completion.promise));
+            await Promise.allSettled(sessions.map(this.saveSession));
+            this.sessions.clear();
+        }
+        finally {
+            this.database.close();
+        }
     };
     submitMessage = async (command) => {
         const session = await this.getSession(command);
@@ -226,7 +254,7 @@ export class HarnessHost {
             await session.runtime.destroy();
             this.sessions.delete(command.sessionId);
         }
-        await this.options.resumeStates.remove(command.harnessId, command.sessionId);
+        this.repo.deleteSession(command.harnessId, command.sessionId);
         this.emitState();
     };
     setSessionModel = (command) => {
@@ -262,7 +290,11 @@ export class HarnessHost {
         }
     };
     openSession = async (runtime, sessionId) => {
-        const resumeFrom = await this.options.resumeStates.load(runtime.harnessId, sessionId);
+        const failure = this.repo.getResumeFailure(runtime.harnessId, sessionId);
+        if (failure) {
+            throw new Error(`Cannot resume ${runtime.harnessId} session ${sessionId}: checkpoint failed at ${failure.timestamp}: ${failure.message}`);
+        }
+        const resumeFrom = this.repo.getResumeState(runtime.harnessId, sessionId);
         const session = {
             harnessId: runtime.harnessId,
             sessionId,
@@ -297,11 +329,11 @@ export class HarnessHost {
     saveSession = async (session) => {
         try {
             const state = await session.runtime.stop();
-            await this.options.resumeStates.save(session.harnessId, session.sessionId, state);
+            this.repo.saveResumeState(session.harnessId, session.sessionId, state);
         }
         catch (error) {
             this.options.onError(error);
-            await this.options.resumeStates.markFailed(session.harnessId, session.sessionId, errorMessage(error));
+            this.repo.saveResumeFailure(session.harnessId, session.sessionId, errorMessage(error));
             throw error;
         }
     };

package/dist/{models.d.ts → host/models.d.ts}

@@ -1,2 +1,2 @@
-import { HarnessId, type HarnessModels } from './messages.js';
+import { HarnessId, type HarnessModels } from '../messages.js';
 export declare const HARNESS_MODELS: Record<HarnessId, HarnessModels>;

package/dist/{models.js → host/models.js}

@@ -1,4 +1,4 @@
-import { HarnessId } from './messages.js';
+import { HarnessId } from '../messages.js';
 // Curated choices for now. Hosts can load this catalog from a service later.
 export const HARNESS_MODELS = {
     [HarnessId.CLAUDE_CODE]: {

package/dist/index.d.ts

@@ -1,10 +1,8 @@
-export { HarnessHost, type HarnessHostOptions } from './HarnessHost.js';
+export { HarnessHost, type HarnessHostOptions } from './host/HarnessHost.js';
 export { ALL_HARNESSES, createHarnessRuntimes, doctorHarnessHost, prepareHarnessHost, type HarnessSelection, } from './harnesses/index.js';
 export { createClaudeCodeRuntime, type ClaudeCodeConfig, } from './harnesses/claudeCode/index.js';
 export { createCodexRuntime, type CodexConfig } from './harnesses/codex/index.js';
 export { createOpenCodeRuntime, type OpenCodeConfig } from './harnesses/openCode/index.js';
 export * from './messages.js';
-export { createFileResumeStateStore } from './resumeState/file.js';
-export type { ResumeStateStore } from './resumeState.js';
 export type { HarnessRuntime, RuntimeSession } from './runtime.js';
-export type { ChangedFile, TurnActivity } from './activity.js';
+export type { ChangedFile, TurnActivity } from './host/activity.js';

package/dist/index.js

@@ -1,7 +1,6 @@
-export { HarnessHost } from './HarnessHost.js';
+export { HarnessHost } from './host/HarnessHost.js';
 export { ALL_HARNESSES, createHarnessRuntimes, doctorHarnessHost, prepareHarnessHost, } from './harnesses/index.js';
 export { createClaudeCodeRuntime, } from './harnesses/claudeCode/index.js';
 export { createCodexRuntime } from './harnesses/codex/index.js';
 export { createOpenCodeRuntime } from './harnesses/openCode/index.js';
 export * from './messages.js';
-export { createFileResumeStateStore } from './resumeState/file.js';

package/dist/messages.d.ts

@@ -1,5 +1,5 @@
 import type { TextStreamPart, ToolSet } from 'ai';
-import type { TurnActivity } from './activity.js';
+import type { TurnActivity } from './host/activity.js';
 export declare enum HarnessId {
     CLAUDE_CODE = "claude-code",
     CODEX = "codex",

package/dist/repo/HarnessRepo.d.ts

@@ -0,0 +1,21 @@
+import type { DatabaseSync } from 'node:sqlite';
+import type { HarnessAgentResumeSessionState } from '@ai-sdk/harness/agent';
+import type { HarnessId } from '../messages.js';
+export declare class HarnessRepo {
+    private readonly database;
+    constructor(database: DatabaseSync);
+    getHostId: () => string | undefined;
+    saveHostId: (hostId: string) => void;
+    getResumeState: (harnessId: HarnessId, sessionId: string) => HarnessAgentResumeSessionState | undefined;
+    getResumeFailure: (harnessId: HarnessId, sessionId: string) => ResumeFailure | undefined;
+    saveResumeState: (harnessId: HarnessId, sessionId: string, state: HarnessAgentResumeSessionState) => void;
+    saveResumeFailure: (harnessId: HarnessId, sessionId: string, message: string) => void;
+    deleteSession: (harnessId: HarnessId, sessionId: string) => void;
+    private deleteResumeFailure;
+    private transaction;
+}
+type ResumeFailure = {
+    message: string;
+    timestamp: string;
+};
+export {};

package/dist/repo/HarnessRepo.js

@@ -0,0 +1,76 @@
+export class HarnessRepo {
+    database;
+    constructor(database) {
+        this.database = database;
+    }
+    getHostId = () => {
+        const row = this.database
+            .prepare('SELECT id FROM host WHERE singleton = 1')
+            .get();
+        return row?.id;
+    };
+    saveHostId = (hostId) => {
+        this.database
+            .prepare('INSERT INTO host (singleton, id) VALUES (1, ?)')
+            .run(hostId);
+    };
+    getResumeState = (harnessId, sessionId) => {
+        const row = this.database
+            .prepare('SELECT state FROM resume_state WHERE harness_id = ? AND session_id = ?')
+            .get(harnessId, sessionId);
+        return row
+            ? JSON.parse(row.state)
+            : undefined;
+    };
+    getResumeFailure = (harnessId, sessionId) => this.database
+        .prepare('SELECT message, timestamp FROM resume_failure WHERE harness_id = ? AND session_id = ?')
+        .get(harnessId, sessionId);
+    saveResumeState = (harnessId, sessionId, state) => {
+        this.transaction(() => {
+            this.database
+                .prepare(`
+          INSERT INTO resume_state (harness_id, session_id, state)
+          VALUES (?, ?, ?)
+          ON CONFLICT (harness_id, session_id)
+          DO UPDATE SET state = excluded.state
+        `)
+                .run(harnessId, sessionId, JSON.stringify(state));
+            this.deleteResumeFailure(harnessId, sessionId);
+        });
+    };
+    saveResumeFailure = (harnessId, sessionId, message) => {
+        this.database
+            .prepare(`
+        INSERT INTO resume_failure (harness_id, session_id, message, timestamp)
+        VALUES (?, ?, ?, ?)
+        ON CONFLICT (harness_id, session_id)
+        DO UPDATE SET message = excluded.message, timestamp = excluded.timestamp
+      `)
+            .run(harnessId, sessionId, message, new Date().toISOString());
+    };
+    deleteSession = (harnessId, sessionId) => {
+        this.transaction(() => {
+            this.database
+                .prepare('DELETE FROM resume_state WHERE harness_id = ? AND session_id = ?')
+                .run(harnessId, sessionId);
+            this.deleteResumeFailure(harnessId, sessionId);
+        });
+    };
+    deleteResumeFailure = (harnessId, sessionId) => {
+        this.database
+            .prepare('DELETE FROM resume_failure WHERE harness_id = ? AND session_id = ?')
+            .run(harnessId, sessionId);
+    };
+    transaction = (operation) => {
+        this.database.exec('BEGIN');
+        try {
+            const result = operation();
+            this.database.exec('COMMIT');
+            return result;
+        }
+        catch (error) {
+            this.database.exec('ROLLBACK');
+            throw error;
+        }
+    };
+}

package/dist/repo/index.d.ts

@@ -0,0 +1,2 @@
+export { HarnessRepo } from './HarnessRepo.js';
+export { harnessMigrations } from './migrations/index.js';

package/dist/repo/index.js

@@ -0,0 +1,2 @@
+export { HarnessRepo } from './HarnessRepo.js';
+export { harnessMigrations } from './migrations/index.js';

package/dist/repo/migrations/001-initial.d.ts

@@ -0,0 +1,2 @@
+import type { Migration } from '../../database/index.js';
+export declare const initialMigration: Migration;

package/dist/repo/migrations/001-initial.js

@@ -0,0 +1,26 @@
+export const initialMigration = {
+    version: 1,
+    apply: (database) => {
+        database.exec(`
+      CREATE TABLE host (
+        singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
+        id TEXT NOT NULL
+      ) STRICT;
+
+      CREATE TABLE resume_state (
+        harness_id TEXT NOT NULL,
+        session_id TEXT NOT NULL,
+        state TEXT NOT NULL,
+        PRIMARY KEY (harness_id, session_id)
+      ) STRICT;
+
+      CREATE TABLE resume_failure (
+        harness_id TEXT NOT NULL,
+        session_id TEXT NOT NULL,
+        message TEXT NOT NULL,
+        timestamp TEXT NOT NULL,
+        PRIMARY KEY (harness_id, session_id)
+      ) STRICT;
+    `);
+    },
+};

package/dist/repo/migrations/index.d.ts

@@ -0,0 +1,2 @@
+import type { Migration } from '../../database/index.js';
+export declare const harnessMigrations: Migration[];

package/dist/repo/migrations/index.js

@@ -0,0 +1,2 @@
+import { initialMigration } from './001-initial.js';
+export const harnessMigrations = [initialMigration];

package/dist/sandbox/local.d.ts

@@ -1,4 +1,5 @@
-import type { Experimental_SandboxSession } from 'ai';
+import type { Experimental_SandboxProcess, Experimental_SandboxSession } from 'ai';
+import type { Experimental_SandboxSpawnOptions as SandboxSpawnOptions, Experimental_SandboxSpawnOptionsWithStdin as SandboxSpawnOptionsWithStdin, Experimental_SandboxSpawnOptionsWithoutStdin as SandboxSpawnOptionsWithoutStdin, Experimental_WritableSandboxProcess as WritableSandboxProcess } from '@ai-sdk/provider-utils';
 export declare class LocalSandboxSession implements Experimental_SandboxSession {
     private readonly cwd;
     readonly description: string;
@@ -10,6 +11,8 @@ export declare class LocalSandboxSession implements Experimental_SandboxSession
     writeBinaryFile: Experimental_SandboxSession['writeBinaryFile'];
     writeFile: Experimental_SandboxSession['writeFile'];
     writeTextFile: Experimental_SandboxSession['writeTextFile'];
-    spawn: Experimental_SandboxSession['spawn'];
+    spawn(options: SandboxSpawnOptionsWithStdin): Promise<WritableSandboxProcess>;
+    spawn(options: SandboxSpawnOptionsWithoutStdin): Promise<Experimental_SandboxProcess>;
+    spawn(options: SandboxSpawnOptions): Promise<Experimental_SandboxProcess | WritableSandboxProcess>;
     run: Experimental_SandboxSession['run'];
 }

package/dist/sandbox/local.js

@@ -1,7 +1,7 @@
 import { spawn as spawnChild } from 'node:child_process';
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
-import { Readable } from 'node:stream';
+import { Readable, Writable } from 'node:stream';
 export class LocalSandboxSession {
     cwd;
     description;
@@ -63,7 +63,7 @@ export class LocalSandboxSession {
             abortSignal,
         });
     };
-    spawn = async ({ command, workingDirectory, env, abortSignal }) => {
+    async spawn({ command, workingDirectory, env, abortSignal, stdin = false, }) {
         if (abortSignal?.aborted)
             throw abortSignal.reason;
         const child = spawnChild(command, {
@@ -72,7 +72,7 @@ export class LocalSandboxSession {
             shell: true,
             // Terminal Ctrl-C must reach the host first so it can save the harness session.
             detached: process.platform !== 'win32',
-            stdio: ['ignore', 'pipe', 'pipe'],
+            stdio: [stdin ? 'pipe' : 'ignore', 'pipe', 'pipe'],
         });
         const stdout = Readable.toWeb(child.stdout);
         const stderr = Readable.toWeb(child.stderr);
@@ -111,8 +111,14 @@ export class LocalSandboxSession {
         };
         abortSignal?.addEventListener('abort', handleAbort, { once: true });
         void wait.finally(() => abortSignal?.removeEventListener('abort', handleAbort)).catch(() => { });
-        return { pid: child.pid, stdout, stderr, wait: () => wait, kill };
-    };
+        const sandboxProcess = { pid: child.pid, stdout, stderr, wait: () => wait, kill };
+        if (!stdin)
+            return sandboxProcess;
+        return {
+            ...sandboxProcess,
+            stdin: Writable.toWeb(child.stdin),
+        };
+    }
     run = async (options) => {
         const process = await this.spawn(options);
         const [stdout, stderr, result] = await Promise.all([

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oorja-harness-host",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Host AI coding harness sessions on a Supakit-connected computer.",
   "type": "module",
   "exports": {
@@ -14,16 +14,17 @@
     "dist"
   ],
   "scripts": {
-    "build": "tsc -b && tsc-alias -p tsconfig.json --resolve-full-paths --resolve-full-extension .js",
+    "build": "pnpm run clean && tsc -b --force && tsc-alias -p tsconfig.json --resolve-full-paths --resolve-full-extension .js",
     "clean": "shx rm -rf dist",
     "prepack": "pnpm run build"
   },
   "dependencies": {
-    "@ai-sdk/harness": "1.0.164",
-    "@ai-sdk/harness-claude-code": "1.0.168",
-    "@ai-sdk/harness-codex": "1.0.166",
-    "@ai-sdk/harness-opencode": "1.0.166",
-    "ai": "7.0.153"
+    "@ai-sdk/harness": "1.0.167",
+    "@ai-sdk/harness-claude-code": "1.0.171",
+    "@ai-sdk/harness-codex": "1.0.169",
+    "@ai-sdk/harness-opencode": "1.0.169",
+    "@ai-sdk/provider-utils": "5.0.70",
+    "ai": "7.0.156"
   },
   "devDependencies": {
     "@types/node": "^22.10.2",
@@ -32,7 +33,7 @@
     "typescript": "^5.9.2"
   },
   "engines": {
-    "node": ">=22.10.0"
+    "node": ">=24.15.0"
   },
   "packageManager": "pnpm@11.5.2"
 }

package/dist/resumeState/file.d.ts

@@ -1,2 +0,0 @@
-import type { ResumeStateStore } from '../resumeState.js';
-export declare const createFileResumeStateStore: (directory: string) => ResumeStateStore;

package/dist/resumeState/file.js

@@ -1,60 +0,0 @@
-import { mkdir, readFile, rename, unlink, writeFile } from 'node:fs/promises';
-import path from 'node:path';
-export const createFileResumeStateStore = (directory) => ({
-    load: async (harnessId, sessionId) => {
-        try {
-            const failure = JSON.parse(await readFile(failurePath(directory, harnessId, sessionId), 'utf8'));
-            throw new Error(`Cannot resume ${harnessId} session ${sessionId}: checkpoint failed at ${failure.timestamp}: ${failure.message}`);
-        }
-        catch (error) {
-            if (!isMissingFile(error))
-                throw error;
-        }
-        try {
-            const stored = JSON.parse(await readFile(statePath(directory, harnessId, sessionId), 'utf8'));
-            return stored.state;
-        }
-        catch (error) {
-            if (isMissingFile(error))
-                return;
-            throw error;
-        }
-    },
-    save: async (harnessId, sessionId, state) => {
-        const destination = statePath(directory, harnessId, sessionId);
-        await saveRecord(destination, { harnessId, sessionId, state });
-        await removeFile(failurePath(directory, harnessId, sessionId));
-    },
-    markFailed: async (harnessId, sessionId, message) => {
-        const failure = {
-            harnessId,
-            sessionId,
-            timestamp: new Date().toISOString(),
-            message,
-        };
-        await saveRecord(failurePath(directory, harnessId, sessionId), failure);
-    },
-    remove: async (harnessId, sessionId) => {
-        await removeFile(statePath(directory, harnessId, sessionId));
-        await removeFile(failurePath(directory, harnessId, sessionId));
-    },
-});
-const statePath = (directory, harnessId, sessionId) => path.join(directory, `${encode(harnessId)}-${encode(sessionId)}.json`);
-const failurePath = (directory, harnessId, sessionId) => path.join(directory, `${encode(harnessId)}-${encode(sessionId)}.failure.json`);
-const saveRecord = async (destination, record) => {
-    await mkdir(path.dirname(destination), { recursive: true, mode: 0o700 });
-    const temporary = `${destination}.${process.pid}.tmp`;
-    await writeFile(temporary, JSON.stringify(record), { encoding: 'utf8', mode: 0o600 });
-    await rename(temporary, destination);
-};
-const removeFile = async (file) => {
-    try {
-        await unlink(file);
-    }
-    catch (error) {
-        if (!isMissingFile(error))
-            throw error;
-    }
-};
-const encode = (value) => Buffer.from(value).toString('base64url');
-const isMissingFile = (error) => error instanceof Error && 'code' in error && error.code === 'ENOENT';

package/dist/resumeState.d.ts

@@ -1,8 +0,0 @@
-import type { HarnessAgentResumeSessionState } from '@ai-sdk/harness/agent';
-import type { HarnessId } from './messages.js';
-export type ResumeStateStore = {
-    load: (harnessId: HarnessId, sessionId: string) => Promise<HarnessAgentResumeSessionState | undefined>;
-    save: (harnessId: HarnessId, sessionId: string, state: HarnessAgentResumeSessionState) => Promise<void>;
-    markFailed: (harnessId: HarnessId, sessionId: string, message: string) => Promise<void>;
-    remove: (harnessId: HarnessId, sessionId: string) => Promise<void>;
-};

package/dist/resumeState.js

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