oorja-harness-host 0.0.0-stage → 0.2.0

package/README.md

@@ -1,3 +1,23 @@
-# Temporary Holding Version
+# Harness Host
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Runtime support for hosting AI coding harness sessions on a computer connected
+to a Supakit room.
+
+The package owns live harness sessions, adapters, preparation, resume state,
+and the shared message contract. Applications own channel connections, routing,
+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/claudeCode/index.d.ts

@@ -0,0 +1,8 @@
+import { createClaudeCode } from '@ai-sdk/harness-claude-code';
+export type ClaudeCodeConfig = NonNullable<Parameters<typeof createClaudeCode>[0]>;
+export declare const createClaudeCodeRuntime: ({ cwd, config }: {
+    cwd: string;
+    config?: ClaudeCodeConfig;
+}) => import("../../index.js").HarnessRuntime;
+export declare const prepareClaudeCode: (cwd: string) => Promise<string>;
+export declare const runClaudeCodeDoctor: (cwd: string) => Promise<import("../types.js").HarnessDoctorCheck[]>;

package/dist/harnesses/claudeCode/index.js

@@ -0,0 +1,16 @@
+import { createClaudeCode } from '@ai-sdk/harness-claude-code';
+import { HarnessId } from '../../messages.js';
+import { runHarnessDoctor } from '../doctor.js';
+import { prepareHarness } from '../prepare.js';
+import { createHarnessRuntime } from '../runtime.js';
+export const createClaudeCodeRuntime = ({ cwd, config }) => createHarnessRuntime({
+    harnessId: HarnessId.CLAUDE_CODE,
+    cwd,
+    createHarness: (port) => createClaudeCode({
+        ...config,
+        port,
+        portEndpoint: { url: `ws://127.0.0.1:${port}` },
+    }),
+});
+export const prepareClaudeCode = (cwd) => prepareHarness(cwd, createClaudeCode());
+export const runClaudeCodeDoctor = (cwd) => runHarnessDoctor(cwd, 'Claude Code');

package/dist/harnesses/codex/index.d.ts

@@ -0,0 +1,8 @@
+import { createCodex } from '@ai-sdk/harness-codex';
+export type CodexConfig = NonNullable<Parameters<typeof createCodex>[0]>;
+export declare const createCodexRuntime: ({ cwd, config }: {
+    cwd: string;
+    config?: CodexConfig;
+}) => import("../../index.js").HarnessRuntime;
+export declare const prepareCodex: (cwd: string) => Promise<string>;
+export declare const runCodexDoctor: (cwd: string) => Promise<import("../types.js").HarnessDoctorCheck[]>;

package/dist/harnesses/codex/index.js

@@ -0,0 +1,16 @@
+import { createCodex } from '@ai-sdk/harness-codex';
+import { HarnessId } from '../../messages.js';
+import { runHarnessDoctor } from '../doctor.js';
+import { prepareHarness } from '../prepare.js';
+import { createHarnessRuntime } from '../runtime.js';
+export const createCodexRuntime = ({ cwd, config }) => createHarnessRuntime({
+    harnessId: HarnessId.CODEX,
+    cwd,
+    createHarness: (port) => createCodex({
+        ...config,
+        port,
+        portEndpoint: { url: `ws://127.0.0.1:${port}` },
+    }),
+});
+export const prepareCodex = (cwd) => prepareHarness(cwd, createCodex());
+export const runCodexDoctor = (cwd) => runHarnessDoctor(cwd, 'Codex');

package/dist/harnesses/doctor.d.ts

@@ -0,0 +1,2 @@
+import type { HarnessDoctorCheck } from './types.js';
+export declare const runHarnessDoctor: (cwd: string, harnessName: string) => Promise<HarnessDoctorCheck[]>;

package/dist/harnesses/doctor.js

@@ -0,0 +1,52 @@
+import { constants } from 'node:fs';
+import { access } from 'node:fs/promises';
+import { createServer } from 'node:net';
+import { LocalSandboxSession } from '../sandbox/local.js';
+export const runHarnessDoctor = async (cwd, harnessName) => {
+    const sandbox = new LocalSandboxSession(cwd);
+    const home = process.env.HOME;
+    const [pnpm, homeIsWritable, loopbackIsAvailable] = await Promise.all([
+        Promise.resolve(sandbox.run({ command: 'pnpm --version' })).catch(() => undefined),
+        home ? canAccess(home, constants.R_OK | constants.W_OK) : false,
+        checkLoopbackPort().then(() => true, () => false),
+    ]);
+    const nodeMajor = Number(process.versions.node.split('.')[0]);
+    return [
+        {
+            name: 'node',
+            ok: nodeMajor >= 22,
+            detail: `Node ${process.versions.node}; requires Node 22 or newer`,
+        },
+        {
+            name: 'pnpm',
+            ok: pnpm?.exitCode === 0,
+            detail: pnpm?.exitCode === 0 ? `pnpm ${pnpm.stdout.trim()}` : `pnpm is required for ${harnessName} bootstrap`,
+        },
+        {
+            name: 'home',
+            ok: homeIsWritable,
+            detail: home ? `${home} must be readable and writable` : 'HOME is not set',
+        },
+        {
+            name: 'loopback-port',
+            ok: loopbackIsAvailable,
+            detail: loopbackIsAvailable
+                ? 'Can bind an ephemeral port on 127.0.0.1'
+                : 'Could not bind an ephemeral port on 127.0.0.1',
+        },
+    ];
+};
+const checkLoopbackPort = () => new Promise((resolve, reject) => {
+    const server = createServer();
+    server.once('error', reject);
+    server.listen(0, '127.0.0.1', () => server.close((error) => (error ? reject(error) : resolve())));
+});
+const canAccess = async (target, mode) => {
+    try {
+        await access(target, mode);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};

package/dist/harnesses/index.d.ts

@@ -0,0 +1,8 @@
+import { HarnessId } from '../messages.js';
+import type { HarnessRuntime } from '../runtime.js';
+import type { HarnessDoctorResult, HarnessPrepareResult } from './types.js';
+export declare const ALL_HARNESSES: "all";
+export type HarnessSelection = HarnessId | typeof ALL_HARNESSES;
+export declare const doctorHarnessHost: (cwd: string) => Promise<HarnessDoctorResult[]>;
+export declare const prepareHarnessHost: (cwd: string, selections?: readonly HarnessSelection[]) => Promise<HarnessPrepareResult[]>;
+export declare const createHarnessRuntimes: (cwd: string) => HarnessRuntime[];

package/dist/harnesses/index.js

@@ -0,0 +1,42 @@
+import { createClaudeCodeRuntime, prepareClaudeCode, runClaudeCodeDoctor, } from './claudeCode/index.js';
+import { createCodexRuntime, prepareCodex, runCodexDoctor } from './codex/index.js';
+import { createOpenCodeRuntime, prepareOpenCode, runOpenCodeDoctor } from './openCode/index.js';
+import { HarnessId } from '../messages.js';
+export const ALL_HARNESSES = 'all';
+export const doctorHarnessHost = async (cwd) => Promise.all(harnesses.map(async ({ harnessId, doctor }) => ({
+    harnessId,
+    checks: await doctor(cwd),
+})));
+export const prepareHarnessHost = async (cwd, selections = [ALL_HARNESSES]) => {
+    const results = [];
+    for (const harness of selectHarnesses(selections)) {
+        results.push({ harnessId: harness.harnessId, detail: await harness.prepare(cwd) });
+    }
+    return results;
+};
+export const createHarnessRuntimes = (cwd) => harnesses.map(({ createRuntime }) => createRuntime(cwd));
+const codex = {
+    harnessId: HarnessId.CODEX,
+    createRuntime: (cwd) => createCodexRuntime({ cwd }),
+    doctor: runCodexDoctor,
+    prepare: prepareCodex,
+};
+const claudeCode = {
+    harnessId: HarnessId.CLAUDE_CODE,
+    createRuntime: (cwd) => createClaudeCodeRuntime({ cwd }),
+    doctor: runClaudeCodeDoctor,
+    prepare: prepareClaudeCode,
+};
+const openCode = {
+    harnessId: HarnessId.OPENCODE,
+    createRuntime: (cwd) => createOpenCodeRuntime({ cwd }),
+    doctor: runOpenCodeDoctor,
+    prepare: prepareOpenCode,
+};
+const harnesses = [codex, claudeCode, openCode];
+const selectHarnesses = (selections) => {
+    if (selections.includes(ALL_HARNESSES))
+        return harnesses;
+    const selected = new Set(selections);
+    return harnesses.filter(({ harnessId }) => selected.has(harnessId));
+};

package/dist/harnesses/openCode/index.d.ts

@@ -0,0 +1,8 @@
+import { createOpenCode } from '@ai-sdk/harness-opencode';
+export type OpenCodeConfig = NonNullable<Parameters<typeof createOpenCode>[0]>;
+export declare const createOpenCodeRuntime: ({ cwd, config }: {
+    cwd: string;
+    config?: OpenCodeConfig;
+}) => import("../../index.js").HarnessRuntime;
+export declare const prepareOpenCode: (cwd: string) => Promise<string>;
+export declare const runOpenCodeDoctor: (cwd: string) => Promise<import("../types.js").HarnessDoctorCheck[]>;

package/dist/harnesses/openCode/index.js

@@ -0,0 +1,17 @@
+import { createOpenCode } from '@ai-sdk/harness-opencode';
+import { HarnessId } from '../../messages.js';
+import { runHarnessDoctor } from '../doctor.js';
+import { prepareHarness } from '../prepare.js';
+import { createHarnessRuntime } from '../runtime.js';
+export const createOpenCodeRuntime = ({ cwd, config }) => createHarnessRuntime({
+    harnessId: HarnessId.OPENCODE,
+    cwd,
+    createHarness: (port) => createOpenCode({
+        ...config,
+        provider: config?.provider ?? 'opencode',
+        port,
+        portEndpoint: { url: `ws://127.0.0.1:${port}` },
+    }),
+});
+export const prepareOpenCode = (cwd) => prepareHarness(cwd, createOpenCode());
+export const runOpenCodeDoctor = (cwd) => runHarnessDoctor(cwd, 'OpenCode');

package/dist/harnesses/prepare.d.ts

@@ -0,0 +1,2 @@
+import { type HarnessAgentAdapter } from '@ai-sdk/harness/agent';
+export declare const prepareHarness: (cwd: string, harness: HarnessAgentAdapter) => Promise<string>;

package/dist/harnesses/prepare.js

@@ -0,0 +1,11 @@
+import { createHarnessSandboxTemplate } from '@ai-sdk/harness/agent';
+import { LocalSandboxSession } from '../sandbox/local.js';
+export const prepareHarness = async (cwd, harness) => {
+    const template = await createHarnessSandboxTemplate({
+        harnesses: [harness],
+        sandboxConfig: { workDir: '.' },
+    });
+    if (template)
+        await template.prepare({ session: new LocalSandboxSession(cwd) });
+    return 'Installed locally and ready to use.';
+};

package/dist/harnesses/runtime.d.ts

@@ -0,0 +1,8 @@
+import { type HarnessAgentAdapter } from '@ai-sdk/harness/agent';
+import { HarnessId } from '../messages.js';
+import type { HarnessRuntime } from '../runtime.js';
+export declare const createHarnessRuntime: ({ harnessId, cwd, createHarness, }: {
+    harnessId: HarnessId;
+    cwd: string;
+    createHarness: (port: number) => HarnessAgentAdapter;
+}) => HarnessRuntime;

package/dist/harnesses/runtime.js

@@ -0,0 +1,47 @@
+import { createServer } from 'node:net';
+import { HarnessAgent } from '@ai-sdk/harness/agent';
+import { jsonSchema } from 'ai';
+import { HARNESS_MODELS } from '../host/models.js';
+import { LocalSandboxSession } from '../sandbox/local.js';
+export const createHarnessRuntime = ({ harnessId, cwd, createHarness, }) => ({
+    harnessId,
+    createSession: async (sessionId, resumeFrom) => {
+        const port = await allocateLoopbackPort();
+        const agent = new HarnessAgent({
+            model: HARNESS_MODELS[harnessId].defaultModel,
+            harness: createHarness(port),
+            permissionMode: 'allow-all',
+            sandboxConfig: { workDir: '.' },
+            callOptionsSchema: jsonSchema({
+                type: 'object',
+                properties: { model: { type: 'string' } },
+                additionalProperties: false,
+            }),
+            prepareCall: ({ options, ...call }) => ({ ...call, model: options.model ?? call.model }),
+        });
+        const session = await agent.createSession({
+            sessionId,
+            resumeFrom,
+            sandboxSession: new LocalSandboxSession(cwd),
+        });
+        return {
+            stream: async (prompt, abortSignal, model) => (await agent.stream({ session, prompt, abortSignal, options: { model } })).fullStream,
+            steer: (text) => agent.experimental_steer({ session, text }),
+            stop: () => session.stop(),
+            destroy: () => session.destroy(),
+        };
+    },
+});
+const allocateLoopbackPort = () => new Promise((resolve, reject) => {
+    const server = createServer();
+    server.once('error', reject);
+    server.listen(0, '127.0.0.1', () => {
+        const address = server.address();
+        if (address === null || typeof address === 'string') {
+            server.close();
+            reject(new Error('Unable to allocate a loopback port'));
+            return;
+        }
+        server.close((error) => (error ? reject(error) : resolve(address.port)));
+    });
+});

package/dist/harnesses/types.d.ts

@@ -0,0 +1,21 @@
+import type { HarnessId } from '../messages.js';
+import type { HarnessRuntime } from '../runtime.js';
+export type HarnessDoctorCheck = {
+    name: string;
+    ok: boolean;
+    detail: string;
+};
+export type HarnessDoctorResult = {
+    harnessId: HarnessId;
+    checks: HarnessDoctorCheck[];
+};
+export type HarnessPrepareResult = {
+    harnessId: HarnessId;
+    detail: string;
+};
+export type HarnessImplementation = {
+    harnessId: HarnessId;
+    createRuntime: (cwd: string) => HarnessRuntime;
+    doctor: (cwd: string) => Promise<HarnessDoctorCheck[]>;
+    prepare: (cwd: string) => Promise<string>;
+};

package/dist/harnesses/types.js

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

package/dist/host/Future.d.ts

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

package/dist/host/Future.js

@@ -0,0 +1,15 @@
+export class Future {
+    promise;
+    resolve;
+    reject;
+    onFinally;
+    constructor(futureBase, onFinally) {
+        this.onFinally = onFinally;
+        this.promise = new Promise(async (resolve, reject) => {
+            this.resolve = resolve;
+            this.reject = reject;
+            if (futureBase)
+                await futureBase(resolve, reject);
+        }).finally(() => this.onFinally?.());
+    }
+}

package/dist/host/HarnessHost.d.ts

@@ -0,0 +1,39 @@
+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[];
+    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;
+    private constructor();
+    static start: (options: HarnessHostOptions) => Promise<HarnessHost>;
+    getState: () => HostState;
+    handleCommand: (command: HarnessCommand) => Promise<void>;
+    stop: () => Promise<void>;
+    private submitMessage;
+    private steer;
+    private runTurn;
+    private abortTurn;
+    private sendTurnSnapshot;
+    private handleTurnSaved;
+    private destroySession;
+    private setSessionModel;
+    private setModel;
+    private getSession;
+    private openSession;
+    private publishTurnPart;
+    private emitActivity;
+    private saveSession;
+    private emitState;
+}