oorja-harness-host 0.0.0-stage → 0.1.0

package/README.md

@@ -1,3 +1,12 @@
-# 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.

package/dist/HarnessHost.d.ts

@@ -0,0 +1,37 @@
+import { type HarnessCommand, type HarnessEvent, type HostState } from './messages.js';
+import type { ResumeStateStore } from './resumeState.js';
+import type { HarnessRuntime } from './runtime.js';
+export type HarnessHostOptions = {
+    hostId: string;
+    hostname: string;
+    runtimes: HarnessRuntime[];
+    resumeStates: ResumeStateStore;
+    emit: (event: HarnessEvent) => void;
+    onError: (error: unknown) => void;
+};
+export declare class HarnessHost {
+    private readonly options;
+    private readonly runtimes;
+    private readonly sessions;
+    private readonly openingSessions;
+    private stopping;
+    constructor(options: HarnessHostOptions);
+    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;
+}

package/dist/HarnessHost.js

@@ -0,0 +1,337 @@
+import { randomUUID } from 'node:crypto';
+import { smoothStream } from 'ai';
+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';
+export class HarnessHost {
+    options;
+    runtimes;
+    sessions = new Map();
+    openingSessions = new Map();
+    stopping = false;
+    constructor(options) {
+        this.options = options;
+        this.runtimes = new Map(options.runtimes.map((runtime) => [runtime.harnessId, runtime]));
+    }
+    getState = () => ({
+        type: MessageType.HOST_STATE,
+        hostId: this.options.hostId,
+        hostname: this.options.hostname,
+        harnesses: [...this.runtimes.keys()],
+        models: HARNESS_MODELS,
+        sessions: [...this.sessions.values()].map(toSessionState),
+    });
+    handleCommand = async (command) => {
+        if (this.stopping)
+            return;
+        try {
+            switch (command.type) {
+                case MessageType.MESSAGE_SUBMIT:
+                    await this.submitMessage(command);
+                    break;
+                case MessageType.TURN_ABORT:
+                    this.abortTurn(command);
+                    break;
+                case MessageType.TURN_SNAPSHOT_REQUEST:
+                    this.sendTurnSnapshot(command);
+                    break;
+                case MessageType.TURN_SAVED:
+                    this.handleTurnSaved(command);
+                    break;
+                case MessageType.SESSION_MODEL_SET:
+                    this.setSessionModel(command);
+                    break;
+                case MessageType.SESSION_DESTROY:
+                    await this.destroySession(command);
+                    break;
+            }
+        }
+        catch (error) {
+            this.options.onError(error);
+        }
+    };
+    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();
+    };
+    submitMessage = async (command) => {
+        const session = await this.getSession(command);
+        if (this.stopping)
+            return;
+        if (session.activeTurn) {
+            await this.steer(session, command.message);
+            return;
+        }
+        const turn = {
+            id: randomUUID(),
+            status: SessionStatus.RUNNING,
+            startedAt: Date.now(),
+            abortController: new AbortController(),
+            completion: new Future(),
+        };
+        session.activeTurn = turn;
+        session.turnBuffer.set(turn.id, { id: turn.id, parts: [] });
+        await this.runTurn(session, command, turn);
+    };
+    steer = async (session, message) => {
+        const turn = session.activeTurn;
+        session.pendingMessages.push(message);
+        this.emitState();
+        try {
+            await session.runtime.steer(message.content);
+            if (session.activeTurn === turn) {
+                this.publishTurnPart(session, {
+                    type: MessageType.TURN_PART,
+                    hostId: this.options.hostId,
+                    harnessId: session.harnessId,
+                    sessionId: session.sessionId,
+                    turnId: turn.id,
+                    sequence: session.turnBuffer.get(turn.id).parts.length + 1,
+                    part: {
+                        type: HarnessTurnPartType.USER_MESSAGE,
+                        payload: message,
+                    },
+                });
+            }
+        }
+        finally {
+            session.pendingMessages = session.pendingMessages.filter(({ id }) => id !== message.id);
+            this.emitState();
+        }
+    };
+    runTurn = async (session, command, turn) => {
+        let outcome = TurnOutcome.COMPLETED;
+        let turnError;
+        try {
+            if (command.model)
+                this.setModel(session, command.model);
+            const model = session.model;
+            session.activity = createTurnActivity(turn.id, model);
+            this.publishTurnPart(session, {
+                type: MessageType.TURN_PART,
+                hostId: this.options.hostId,
+                harnessId: session.harnessId,
+                sessionId: session.sessionId,
+                turnId: turn.id,
+                sequence: 1,
+                part: {
+                    type: HarnessTurnPartType.USER_MESSAGE,
+                    payload: command.message,
+                },
+            });
+            this.emitState();
+            const stream = await session.runtime.stream(command.message.content, turn.abortController.signal, model);
+            const smoothedStream = stream.pipeThrough(smoothStream({ chunking: 'line', delayInMs: 10 })({ tools: {} }));
+            for await (const part of smoothedStream) {
+                if (part.type === 'abort')
+                    outcome = TurnOutcome.ABORTED;
+                if (part.type === 'error') {
+                    outcome = TurnOutcome.FAILED;
+                    turnError = errorMessage(part.error);
+                }
+                this.publishTurnPart(session, {
+                    type: MessageType.TURN_PART,
+                    hostId: this.options.hostId,
+                    harnessId: session.harnessId,
+                    sessionId: session.sessionId,
+                    turnId: turn.id,
+                    sequence: session.turnBuffer.get(turn.id).parts.length + 1,
+                    part: {
+                        type: HarnessTurnPartType.STREAM,
+                        payload: part,
+                    },
+                });
+            }
+        }
+        catch (error) {
+            if (turn.abortController.signal.aborted) {
+                outcome = TurnOutcome.ABORTED;
+            }
+            else {
+                outcome = TurnOutcome.FAILED;
+                turnError = errorMessage(error);
+                this.options.onError(error);
+            }
+        }
+        finally {
+            if (session.activeTurn === turn) {
+                turn.completion.resolve?.();
+                session.activeTurn = undefined;
+                session.pendingMessages = [];
+                if (session.activity) {
+                    session.activity = { ...session.activity, tools: [] };
+                    this.emitActivity(session);
+                }
+            }
+            const bufferedTurn = session.turnBuffer.get(turn.id);
+            bufferedTurn.outcome = outcome;
+            bufferedTurn.error = turnError;
+            const ended = {
+                type: MessageType.TURN_ENDED,
+                hostId: this.options.hostId,
+                harnessId: session.harnessId,
+                sessionId: session.sessionId,
+                turnId: turn.id,
+                sequence: bufferedTurn.parts.length + 1,
+                outcome,
+                ...(turnError ? { error: turnError } : {}),
+            };
+            this.options.emit(ended);
+            this.emitState();
+        }
+    };
+    abortTurn = (command) => {
+        const session = this.sessions.get(command.sessionId);
+        if (!session?.activeTurn)
+            throw new Error('Harness session is not active');
+        session.activeTurn.status = SessionStatus.ABORTING;
+        session.activeTurn.abortController.abort();
+        this.emitState();
+    };
+    sendTurnSnapshot = (command) => {
+        const turn = this.sessions.get(command.sessionId)?.turnBuffer.get(command.turnId);
+        if (!turn)
+            return;
+        this.options.emit({
+            type: MessageType.TURN_SNAPSHOT,
+            hostId: this.options.hostId,
+            harnessId: command.harnessId,
+            sessionId: command.sessionId,
+            turnId: command.turnId,
+            sequence: turn.parts.length + (turn.outcome ? 1 : 0),
+            parts: turn.parts,
+            ...(turn.outcome ? { outcome: turn.outcome } : {}),
+            ...(turn.error ? { error: turn.error } : {}),
+        });
+    };
+    handleTurnSaved = (command) => {
+        const session = this.sessions.get(command.sessionId);
+        const turn = session?.turnBuffer.get(command.turnId);
+        if (!session || !turn?.outcome)
+            return;
+        session.turnBuffer.delete(command.turnId);
+        this.emitState();
+    };
+    destroySession = async (command) => {
+        const session = this.sessions.get(command.sessionId);
+        if (session) {
+            session.activeTurn?.abortController.abort();
+            await session.activeTurn?.completion.promise;
+            await session.runtime.destroy();
+            this.sessions.delete(command.sessionId);
+        }
+        await this.options.resumeStates.remove(command.harnessId, command.sessionId);
+        this.emitState();
+    };
+    setSessionModel = (command) => {
+        const session = this.sessions.get(command.sessionId);
+        if (!session)
+            throw new Error('Harness session does not exist');
+        this.setModel(session, command.model);
+        this.emitState();
+    };
+    setModel = (session, model) => {
+        if (!HARNESS_MODELS[session.harnessId].models.includes(model)) {
+            throw new Error(`Model is not available: ${model}`);
+        }
+        session.model = model;
+    };
+    getSession = async (command) => {
+        const existing = this.sessions.get(command.sessionId);
+        if (existing)
+            return existing;
+        const opening = this.openingSessions.get(command.sessionId);
+        if (opening)
+            return opening;
+        const runtime = this.runtimes.get(command.harnessId);
+        if (!runtime)
+            throw new Error(`Harness is not available: ${command.harnessId}`);
+        const pending = this.openSession(runtime, command.sessionId);
+        this.openingSessions.set(command.sessionId, pending);
+        try {
+            return await pending;
+        }
+        finally {
+            this.openingSessions.delete(command.sessionId);
+        }
+    };
+    openSession = async (runtime, sessionId) => {
+        const resumeFrom = await this.options.resumeStates.load(runtime.harnessId, sessionId);
+        const session = {
+            harnessId: runtime.harnessId,
+            sessionId,
+            model: HARNESS_MODELS[runtime.harnessId].defaultModel,
+            runtime: await runtime.createSession(sessionId, resumeFrom),
+            pendingMessages: [],
+            turnBuffer: new Map(),
+        };
+        this.sessions.set(sessionId, session);
+        return session;
+    };
+    publishTurnPart = (session, event) => {
+        session.turnBuffer.get(event.turnId).parts.push(event.part);
+        this.options.emit(event);
+        if (session.activity && event.part.type === HarnessTurnPartType.STREAM) {
+            const activity = updateTurnActivity(session.activity, event.part.payload);
+            if (activity !== session.activity) {
+                session.activity = activity;
+                this.emitActivity(session);
+            }
+        }
+    };
+    emitActivity = (session) => {
+        this.options.emit({
+            type: MessageType.SESSION_ACTIVITY,
+            hostId: this.options.hostId,
+            harnessId: session.harnessId,
+            sessionId: session.sessionId,
+            activity: session.activity,
+        });
+    };
+    saveSession = async (session) => {
+        try {
+            const state = await session.runtime.stop();
+            await this.options.resumeStates.save(session.harnessId, session.sessionId, state);
+        }
+        catch (error) {
+            this.options.onError(error);
+            await this.options.resumeStates.markFailed(session.harnessId, session.sessionId, errorMessage(error));
+            throw error;
+        }
+    };
+    emitState = () => this.options.emit(this.getState());
+}
+const toSessionState = ({ harnessId, sessionId, model, pendingMessages, turnBuffer, activeTurn, activity, }) => ({
+    harnessId,
+    sessionId,
+    model,
+    pendingMessages: [...pendingMessages],
+    status: activeTurn?.status ?? SessionStatus.IDLE,
+    activity,
+    turnBuffer: [...turnBuffer.values()].map((turn) => ({
+        turnId: turn.id,
+        lastSequence: turn.parts.length + (turn.outcome ? 1 : 0),
+        completed: turn.outcome !== undefined,
+    })),
+    ...(activeTurn ? { turnId: activeTurn.id, elapsedMs: Date.now() - activeTurn.startedAt } : {}),
+});
+const errorMessage = (error) => {
+    if (error instanceof Error)
+        return error.message;
+    if (typeof error === 'string')
+        return error;
+    if (error && typeof error === 'object') {
+        const harnessError = error;
+        if (typeof harnessError.data?.message === 'string')
+            return harnessError.data.message;
+        if (typeof harnessError.message === 'string')
+            return harnessError.message;
+    }
+    return JSON.stringify(error) ?? String(error);
+};

package/dist/activity.d.ts

@@ -0,0 +1,25 @@
+import type { TextStreamPart, ToolSet } from 'ai';
+export type ChangedFile = {
+    path: string;
+    event: 'create' | 'modify' | 'delete';
+};
+export type TurnActivity = {
+    turnId: string;
+    model?: string;
+    steps: number;
+    inputTokens?: number;
+    outputTokens?: number;
+    tools: Array<{
+        id: string;
+        name: string;
+    }>;
+    files: ChangedFile[];
+    compaction?: {
+        trigger: 'auto' | 'manual';
+        summary: string;
+        tokensBefore?: number;
+        tokensAfter?: number;
+    };
+};
+export declare const createTurnActivity: (turnId: string, model?: string) => TurnActivity;
+export declare const updateTurnActivity: (activity: TurnActivity, part: TextStreamPart<ToolSet>) => TurnActivity;

package/dist/activity.js

@@ -0,0 +1,71 @@
+export const createTurnActivity = (turnId, model) => ({
+    turnId,
+    model,
+    steps: 0,
+    tools: [],
+    files: [],
+});
+export const updateTurnActivity = (activity, part) => {
+    switch (part.type) {
+        case 'tool-input-start':
+            if (isActivityTool(part.toolName))
+                return activity;
+            return {
+                ...activity,
+                tools: [...activity.tools.filter((tool) => tool.id !== part.id), { id: part.id, name: part.toolName }],
+            };
+        case 'tool-call':
+            if (isActivityTool(part.toolName))
+                return activity;
+            return {
+                ...activity,
+                tools: [
+                    ...activity.tools.filter((tool) => tool.id !== part.toolCallId),
+                    { id: part.toolCallId, name: part.toolName },
+                ],
+            };
+        case 'tool-result': {
+            const tools = activity.tools.filter((tool) => tool.id !== part.toolCallId);
+            if (part.toolName === 'fileChange') {
+                const file = part.output;
+                return { ...activity, tools, files: [...activity.files.filter((current) => current.path !== file.path), file] };
+            }
+            if (part.toolName === 'compaction') {
+                return { ...activity, tools, compaction: part.output };
+            }
+            if (part.toolName === 'write' || part.toolName === 'edit') {
+                const input = part.input;
+                const path = input.path ?? input.file_path;
+                if (path) {
+                    return {
+                        ...activity,
+                        tools,
+                        files: [...activity.files.filter((file) => file.path !== path), { path, event: 'modify' }],
+                    };
+                }
+            }
+            return { ...activity, tools };
+        }
+        case 'tool-error':
+            return { ...activity, tools: activity.tools.filter((tool) => tool.id !== part.toolCallId) };
+        case 'finish-step':
+            return {
+                ...activity,
+                model: part.response.modelId || activity.model,
+                steps: activity.steps + 1,
+                inputTokens: addTokens(activity.inputTokens, part.usage.inputTokens),
+                outputTokens: addTokens(activity.outputTokens, part.usage.outputTokens),
+            };
+        case 'finish':
+            return {
+                ...activity,
+                tools: [],
+                inputTokens: part.totalUsage.inputTokens,
+                outputTokens: part.totalUsage.outputTokens,
+            };
+        default:
+            return activity;
+    }
+};
+const isActivityTool = (name) => name === 'fileChange' || name === 'compaction';
+const addTokens = (total, count) => count === undefined ? total : (total ?? 0) + count;

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');