@astrosheep/keiyaku 1.0.0 → 1.0.2

package/build/agents/launch-snapshot_v2.js

@@ -0,0 +1,348 @@
+import * as path from "node:path";
+import { FlowError } from "../flow-error.js";
+import { buildCodexAppServerWorkspaceWriteSandboxPolicy, } from "./providers/codex-app-server.js";
+const ACCESS_VALUES = new Set(["read", "write", "auto"]);
+const NETWORK_VALUES = new Set(["disabled", "enabled"]);
+const WEB_SEARCH_VALUES = new Set(["disabled", "cached", "live"]);
+const AKUMA_SOURCES = new Set(["builtin", "user", "project"]);
+const PROVIDER_SOURCES = new Set(["builtin", "global", "project"]);
+const CLAUDE_SETTING_SOURCES = new Set(["project", "user", "local"]);
+function snapshotError(fieldPath, message) {
+    return new Error(`Invalid resolved Akuma launch snapshot at ${fieldPath}: ${message}`);
+}
+function isPlainObject(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function objectAt(value, fieldPath) {
+    if (!isPlainObject(value))
+        throw snapshotError(fieldPath, "must be a plain JSON object");
+    return value;
+}
+function exactKeys(value, allowed, fieldPath) {
+    const allowedSet = new Set(allowed);
+    for (const key of Object.keys(value)) {
+        if (!allowedSet.has(key))
+            throw snapshotError(`${fieldPath}.${key}`, "is an unknown field");
+    }
+}
+function requiredString(value, key, fieldPath, allowBlank = false) {
+    const item = value[key];
+    if (typeof item !== "string" || (!allowBlank && item.trim().length === 0)) {
+        throw snapshotError(`${fieldPath}.${key}`, allowBlank ? "must be a string" : "must be a nonblank string");
+    }
+    return item;
+}
+function optionalString(value, key, fieldPath) {
+    if (!(key in value))
+        return undefined;
+    return requiredString(value, key, fieldPath);
+}
+function requiredEnum(value, key, fieldPath, values) {
+    const item = requiredString(value, key, fieldPath);
+    if (!values.has(item))
+        throw snapshotError(`${fieldPath}.${key}`, `has invalid value '${item}'`);
+    return item;
+}
+function cloneJson(value, fieldPath, ancestors = new Set()) {
+    if (value === null || typeof value === "string" || typeof value === "boolean")
+        return value;
+    if (typeof value === "number") {
+        if (!Number.isFinite(value))
+            throw snapshotError(fieldPath, "contains a non-finite number");
+        return value;
+    }
+    if (typeof value !== "object")
+        throw snapshotError(fieldPath, "contains a non-JSON value");
+    if (ancestors.has(value))
+        throw snapshotError(fieldPath, "contains a cycle");
+    ancestors.add(value);
+    try {
+        if (Array.isArray(value)) {
+            return Object.freeze(value.map((item, index) => cloneJson(item, `${fieldPath}[${index}]`, ancestors)));
+        }
+        if (!isPlainObject(value))
+            throw snapshotError(fieldPath, "contains a non-plain JSON object");
+        const result = {};
+        for (const [key, item] of Object.entries(value)) {
+            Object.defineProperty(result, key, {
+                value: cloneJson(item, `${fieldPath}.${key}`, ancestors),
+                enumerable: true,
+                configurable: true,
+                writable: true,
+            });
+        }
+        return Object.freeze(result);
+    }
+    finally {
+        ancestors.delete(value);
+    }
+}
+function cloneJsonObject(value, fieldPath) {
+    const cloned = cloneJson(value, fieldPath);
+    if (!isPlainObject(cloned)) {
+        throw snapshotError(fieldPath, "must be a plain JSON object");
+    }
+    return cloned;
+}
+function effortOptionsFrom(akuma) {
+    if (!("effortOptions" in akuma))
+        return undefined;
+    if (!Array.isArray(akuma.effortOptions)) {
+        throw snapshotError("akuma.effortOptions", "must be an array");
+    }
+    const options = akuma.effortOptions.map((value, index) => {
+        if (typeof value !== "string" || value.trim().length === 0) {
+            throw snapshotError(`akuma.effortOptions[${index}]`, "must be a nonblank string");
+        }
+        return value;
+    });
+    if (new Set(options).size !== options.length) {
+        throw snapshotError("akuma.effortOptions", "must contain unique strings");
+    }
+    return Object.freeze(options);
+}
+function assertEffortAllowed(effort, options) {
+    if (effort === undefined || options === undefined || options.includes(effort))
+        return;
+    throw new FlowError("INVALID_EFFORT_OVERRIDE", `Effort '${effort}' is not permitted; legal values: ${options.join(", ")}.`);
+}
+function parsePolicy(value) {
+    const policy = objectAt(value, "akuma.policy");
+    exactKeys(policy, ["access", "network", "webSearch"], "akuma.policy");
+    const result = {};
+    if ("access" in policy)
+        result.access = requiredEnum(policy, "access", "akuma.policy", ACCESS_VALUES);
+    if ("network" in policy)
+        result.network = requiredEnum(policy, "network", "akuma.policy", NETWORK_VALUES);
+    if ("webSearch" in policy)
+        result.webSearch = requiredEnum(policy, "webSearch", "akuma.policy", WEB_SEARCH_VALUES);
+    return Object.freeze(result);
+}
+function parseAkuma(value) {
+    const akuma = objectAt(value, "akuma");
+    exactKeys(akuma, ["name", "source", "body", "description", "model", "effort", "effortOptions", "policy"], "akuma");
+    if (!("policy" in akuma))
+        throw snapshotError("akuma.policy", "is required");
+    const effortOptions = effortOptionsFrom(akuma);
+    const effort = optionalString(akuma, "effort", "akuma");
+    if (effort !== undefined && effortOptions !== undefined && !effortOptions.includes(effort)) {
+        throw snapshotError("akuma.effort", "must be a member of akuma.effortOptions");
+    }
+    const result = {
+        name: requiredString(akuma, "name", "akuma"),
+        source: requiredEnum(akuma, "source", "akuma", AKUMA_SOURCES),
+        body: requiredString(akuma, "body", "akuma", true),
+        ...(optionalString(akuma, "description", "akuma") !== undefined ? { description: optionalString(akuma, "description", "akuma") } : {}),
+        ...(optionalString(akuma, "model", "akuma") !== undefined ? { model: optionalString(akuma, "model", "akuma") } : {}),
+        ...(effort !== undefined ? { effort } : {}),
+        ...(effortOptions !== undefined ? { effortOptions } : {}),
+        policy: parsePolicy(akuma.policy),
+    };
+    return Object.freeze(result);
+}
+function parseProviderCommon(provider) {
+    return {
+        name: requiredString(provider, "name", "provider"),
+        source: requiredEnum(provider, "source", "provider", PROVIDER_SOURCES),
+    };
+}
+function optionalJsonObject(provider, key) {
+    return key in provider ? cloneJsonObject(provider[key], `provider.${key}`) : undefined;
+}
+function parseSandboxPolicy(value) {
+    const sandbox = objectAt(value, "provider.sandboxPolicy");
+    exactKeys(sandbox, ["type", "writableRoots", "networkAccess", "excludeTmpdirEnvVar", "excludeSlashTmp"], "provider.sandboxPolicy");
+    if (sandbox.type !== "workspaceWrite")
+        throw snapshotError("provider.sandboxPolicy.type", "must equal 'workspaceWrite'");
+    if (!Array.isArray(sandbox.writableRoots) || sandbox.writableRoots.length === 0) {
+        throw snapshotError("provider.sandboxPolicy.writableRoots", "must be a nonempty array");
+    }
+    const roots = sandbox.writableRoots.map((root, index) => {
+        if (typeof root !== "string" || !path.isAbsolute(root) || path.resolve(root) !== root) {
+            throw snapshotError(`provider.sandboxPolicy.writableRoots[${index}]`, "must be a lexically normalized absolute path");
+        }
+        return root;
+    });
+    if (new Set(roots).size !== roots.length) {
+        throw snapshotError("provider.sandboxPolicy.writableRoots", "must not contain duplicates");
+    }
+    for (const key of ["networkAccess", "excludeTmpdirEnvVar", "excludeSlashTmp"]) {
+        if (typeof sandbox[key] !== "boolean")
+            throw snapshotError(`provider.sandboxPolicy.${key}`, "must be a boolean");
+    }
+    Object.freeze(roots);
+    return Object.freeze({
+        type: "workspaceWrite",
+        writableRoots: roots,
+        networkAccess: sandbox.networkAccess,
+        excludeTmpdirEnvVar: sandbox.excludeTmpdirEnvVar,
+        excludeSlashTmp: sandbox.excludeSlashTmp,
+    });
+}
+function parseProvider(value) {
+    const provider = objectAt(value, "provider");
+    const kind = requiredString(provider, "kind", "provider");
+    const common = parseProviderCommon(provider);
+    switch (kind) {
+        case "codex-sdk": {
+            exactKeys(provider, ["name", "source", "kind", "executable", "profile", "config", "threadOptions"], "provider");
+            if (!("threadOptions" in provider))
+                throw snapshotError("provider.threadOptions", "is required");
+            const executable = optionalString(provider, "executable", "provider");
+            const profile = optionalString(provider, "profile", "provider");
+            const config = optionalJsonObject(provider, "config");
+            return Object.freeze({ ...common, kind, ...(executable !== undefined ? { executable } : {}), ...(profile !== undefined ? { profile } : {}), ...(config !== undefined ? { config } : {}), threadOptions: cloneJsonObject(provider.threadOptions, "provider.threadOptions") });
+        }
+        case "codex-app-server": {
+            exactKeys(provider, ["name", "source", "kind", "executable", "profile", "config", "model", "effort", "sandboxPolicy", "approvalPolicy"], "provider");
+            if (!("sandboxPolicy" in provider))
+                throw snapshotError("provider.sandboxPolicy", "is required");
+            if (provider.approvalPolicy !== "never")
+                throw snapshotError("provider.approvalPolicy", "must equal 'never'");
+            const executable = optionalString(provider, "executable", "provider");
+            const profile = optionalString(provider, "profile", "provider");
+            const config = optionalJsonObject(provider, "config");
+            const model = optionalString(provider, "model", "provider");
+            const effort = optionalString(provider, "effort", "provider");
+            return Object.freeze({ ...common, kind, ...(executable !== undefined ? { executable } : {}), ...(profile !== undefined ? { profile } : {}), ...(config !== undefined ? { config } : {}), ...(model !== undefined ? { model } : {}), ...(effort !== undefined ? { effort } : {}), sandboxPolicy: parseSandboxPolicy(provider.sandboxPolicy), approvalPolicy: "never" });
+        }
+        case "claude-agent-sdk": {
+            exactKeys(provider, ["name", "source", "kind", "executable", "model", "effort", "settingSources", "permissionMode", "allowDangerouslySkipPermissions", "disallowedTools"], "provider");
+            const modes = new Set(["default", "plan", "acceptEdits", "bypassPermissions"]);
+            const permissionMode = requiredEnum(provider, "permissionMode", "provider", modes);
+            if (permissionMode === "bypassPermissions") {
+                if (provider.allowDangerouslySkipPermissions !== true)
+                    throw snapshotError("provider.allowDangerouslySkipPermissions", "must be true for bypassPermissions");
+            }
+            else if ("allowDangerouslySkipPermissions" in provider) {
+                throw snapshotError("provider.allowDangerouslySkipPermissions", "is only valid for bypassPermissions");
+            }
+            let settingSources;
+            if ("settingSources" in provider) {
+                if (!Array.isArray(provider.settingSources))
+                    throw snapshotError("provider.settingSources", "must be an array");
+                settingSources = Object.freeze(provider.settingSources.map((source, index) => {
+                    if (typeof source !== "string" || !CLAUDE_SETTING_SOURCES.has(source))
+                        throw snapshotError(`provider.settingSources[${index}]`, "has an invalid setting source");
+                    return source;
+                }));
+            }
+            let disallowedTools;
+            if ("disallowedTools" in provider) {
+                if (!Array.isArray(provider.disallowedTools) || provider.disallowedTools.length !== 1 || provider.disallowedTools[0] !== "WebSearch") {
+                    throw snapshotError("provider.disallowedTools", "must equal ['WebSearch']");
+                }
+                disallowedTools = Object.freeze(["WebSearch"]);
+            }
+            const executable = optionalString(provider, "executable", "provider");
+            const model = optionalString(provider, "model", "provider");
+            const effort = optionalString(provider, "effort", "provider");
+            return Object.freeze({ ...common, kind, ...(executable !== undefined ? { executable } : {}), ...(model !== undefined ? { model } : {}), ...(effort !== undefined ? { effort } : {}), ...(settingSources !== undefined ? { settingSources } : {}), permissionMode, ...(permissionMode === "bypassPermissions" ? { allowDangerouslySkipPermissions: true } : {}), ...(disallowedTools !== undefined ? { disallowedTools } : {}) });
+        }
+        case "opencode-sdk": {
+            exactKeys(provider, ["name", "source", "kind", "executable", "model", "effort"], "provider");
+            const executable = optionalString(provider, "executable", "provider");
+            const model = optionalString(provider, "model", "provider");
+            const effort = optionalString(provider, "effort", "provider");
+            return Object.freeze({ ...common, kind, ...(executable !== undefined ? { executable } : {}), ...(model !== undefined ? { model } : {}), ...(effort !== undefined ? { effort } : {}) });
+        }
+        case "pi": {
+            exactKeys(provider, ["name", "source", "kind", "model", "thinkingLevel"], "provider");
+            const model = optionalString(provider, "model", "provider");
+            const thinkingLevel = optionalString(provider, "thinkingLevel", "provider");
+            return Object.freeze({ ...common, kind, ...(model !== undefined ? { model } : {}), ...(thinkingLevel !== undefined ? { thinkingLevel } : {}) });
+        }
+        default:
+            throw snapshotError("provider.kind", `has invalid value '${kind}'`);
+    }
+}
+export function parseResolvedAkumaLaunchSnapshot(value) {
+    const snapshot = objectAt(value, "resolved Akuma launch snapshot");
+    exactKeys(snapshot, ["version", "akuma", "provider"], "resolved Akuma launch snapshot");
+    if (snapshot.version !== 1)
+        throw snapshotError("version", "must equal 1");
+    if (!("akuma" in snapshot))
+        throw snapshotError("akuma", "is required");
+    if (!("provider" in snapshot))
+        throw snapshotError("provider", "is required");
+    return Object.freeze({ version: 1, akuma: parseAkuma(snapshot.akuma), provider: parseProvider(snapshot.provider) });
+}
+export function resolveAkumaLaunchSnapshot(selected, input) {
+    const model = input.model ?? selected.profile.model;
+    const effort = input.effort ?? selected.profile.effort;
+    assertEffortAllowed(effort, selected.profile.effortOptions);
+    const policy = {
+        ...(selected.profile.access !== undefined ? { access: selected.profile.access } : {}),
+        ...(selected.profile.network !== undefined ? { network: selected.profile.network } : {}),
+        ...(selected.profile.webSearch !== undefined ? { webSearch: selected.profile.webSearch } : {}),
+    };
+    const akuma = {
+        name: selected.name,
+        source: selected.definition.source,
+        body: selected.definition.body,
+        ...(selected.profile.description !== undefined ? { description: selected.profile.description } : {}),
+        ...(model !== undefined ? { model } : {}),
+        ...(effort !== undefined ? { effort } : {}),
+        ...(selected.profile.effortOptions !== undefined ? { effortOptions: selected.profile.effortOptions } : {}),
+        policy,
+    };
+    const instance = selected.profile.providerInstance;
+    const common = { name: selected.profile.provider, source: selected.profile.providerSource, kind: instance.kind };
+    let provider;
+    switch (instance.kind) {
+        case "codex-sdk": {
+            const threadOptions = { ...(instance.threadOptions ?? {}) };
+            threadOptions.sandboxMode = selected.profile.access === "read" ? "read-only" : selected.profile.access === "auto" ? "danger-full-access" : "workspace-write";
+            threadOptions.networkAccessEnabled = selected.profile.network === "enabled";
+            threadOptions.webSearchMode = "disabled";
+            if (model !== undefined)
+                threadOptions.model = model;
+            if (effort !== undefined)
+                threadOptions.modelReasoningEffort = effort;
+            threadOptions.workingDirectory = input.executionCwd;
+            threadOptions.skipGitRepoCheck = true;
+            provider = { ...common, ...(instance.executable !== undefined ? { executable: instance.executable } : {}), ...(instance.profile !== undefined ? { profile: instance.profile } : {}), ...(instance.config !== undefined ? { config: instance.config } : {}), threadOptions };
+            break;
+        }
+        case "codex-app-server": {
+            const roots = [path.resolve(input.executionCwd), ...(instance.writableRoots ?? []).map((root) => path.resolve(input.projectRoot, root))];
+            const writableRoots = [...new Set(roots)];
+            provider = { ...common, ...(instance.executable !== undefined ? { executable: instance.executable } : {}), ...(instance.profile !== undefined ? { profile: instance.profile } : {}), ...(instance.config !== undefined ? { config: instance.config } : {}), ...(model !== undefined ? { model } : {}), ...(effort !== undefined ? { effort } : {}), sandboxPolicy: buildCodexAppServerWorkspaceWriteSandboxPolicy({ writableRoots, networkAccess: selected.profile.network === "enabled" }), approvalPolicy: "never" };
+            break;
+        }
+        case "claude-agent-sdk": {
+            const permissionMode = selected.profile.access === "read" ? "plan" : selected.profile.access === "write" ? "acceptEdits" : selected.profile.access === "auto" ? "bypassPermissions" : "default";
+            provider = { ...common, ...(instance.executable !== undefined ? { executable: instance.executable } : {}), ...(model !== undefined ? { model } : {}), ...(effort !== undefined ? { effort } : {}), ...(instance.settingSources !== undefined ? { settingSources: instance.settingSources } : {}), permissionMode, ...(permissionMode === "bypassPermissions" ? { allowDangerouslySkipPermissions: true } : {}), ...(selected.profile.webSearch === "disabled" ? { disallowedTools: ["WebSearch"] } : {}) };
+            break;
+        }
+        case "opencode-sdk":
+            provider = { ...common, ...(instance.executable !== undefined ? { executable: instance.executable } : {}), ...(model !== undefined ? { model } : {}), ...(effort !== undefined ? { effort } : {}) };
+            break;
+        case "pi":
+            provider = { ...common, ...(model !== undefined ? { model } : {}), ...(effort !== undefined ? { thinkingLevel: effort } : {}) };
+            break;
+    }
+    return parseResolvedAkumaLaunchSnapshot({ version: 1, akuma, provider });
+}
+export function applySnapshotEffort(snapshot, effort) {
+    assertEffortAllowed(effort, snapshot.akuma.effortOptions);
+    const akuma = { ...snapshot.akuma, effort };
+    let provider;
+    switch (snapshot.provider.kind) {
+        case "codex-sdk":
+            provider = { ...snapshot.provider, threadOptions: { ...snapshot.provider.threadOptions, modelReasoningEffort: effort } };
+            break;
+        case "codex-app-server":
+        case "claude-agent-sdk":
+        case "opencode-sdk":
+            provider = { ...snapshot.provider, effort };
+            break;
+        case "pi":
+            provider = { ...snapshot.provider, thinkingLevel: effort };
+            break;
+    }
+    return parseResolvedAkumaLaunchSnapshot({ version: 1, akuma, provider });
+}

package/build/agents/opencode-sdk.js

@@ -1,142 +1,18 @@
 import { spawn } from "node:child_process";
 import net from "node:net";
-import { coerceString } from "./index.js";
-import { createAbortError } from "./harness/runtime.js";
+import { createOpencodeClient, } from "@opencode-ai/sdk/v2";
+import { coerceString, createAbortError } from "./harness/runtime.js";
+export { createOpencodeClient, };
 const DEFAULT_HOSTNAME = "127.0.0.1";
-const DEFAULT_PORT = 4096;
 const DEFAULT_STARTUP_TIMEOUT_MS = 10_000;
 const SERVER_READY_POLL_INTERVAL_MS = 100;
 const SERVER_SHUTDOWN_FORCE_KILL_MS = 1000;
 const OPENCODE_SERVE_SUBCOMMAND = "serve";
 const OPENCODE_HOSTNAME_FLAG = "--hostname";
 const OPENCODE_PORT_FLAG = "--port";
-const RESPONSE_HEADER_ACCEPT = "accept";
-const RESPONSE_HEADER_CONTENT_TYPE = "content-type";
-const JSON_CONTENT_TYPE = "application/json";
-const EVENT_STREAM_CONTENT_TYPE = "text/event-stream";
-const SESSION_PATH = "/session";
-const EVENT_PATH = "/event";
-const CONFIG_PATH = "/config";
-const SESSION_MESSAGE_PATH_SUFFIX = "/message";
-const EVENT_DELIMITER = "\n\n";
-const EVENT_DATA_PREFIX = "data:";
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-function normalizeBaseUrl(baseUrl) {
-    return coerceString(baseUrl)?.replace(/\/+$/, "") ?? `http://${DEFAULT_HOSTNAME}:${DEFAULT_PORT}`;
-}
-function buildSessionPath(sessionId) {
-    return `${SESSION_PATH}/${encodeURIComponent(sessionId)}`;
-}
-async function createJsonRequest(fetcher, baseUrl, requestPath, init = {}) {
-    const response = await fetcher(`${baseUrl}${requestPath}`, {
-        ...init,
-        headers: {
-            [RESPONSE_HEADER_ACCEPT]: JSON_CONTENT_TYPE,
-            [RESPONSE_HEADER_CONTENT_TYPE]: JSON_CONTENT_TYPE,
-            ...(init.headers ?? {}),
-        },
-    });
-    if (!response.ok) {
-        const body = await response.text();
-        throw new Error(body.trim() || `OpenCode request failed: ${response.status}`);
-    }
-    if (response.status === 204) {
-        return undefined;
-    }
-    return response.json();
-}
-function createSseStream(response) {
-    if (!response.body) {
-        throw new Error("OpenCode event stream missing response body");
-    }
-    const reader = response.body.getReader();
-    const decoder = new TextDecoder();
-    return {
-        async *[Symbol.asyncIterator]() {
-            let buffer = "";
-            while (true) {
-                const { done, value } = await reader.read();
-                buffer += decoder.decode(value ?? new Uint8Array(), { stream: !done });
-                let delimiterIndex = buffer.indexOf(EVENT_DELIMITER);
-                while (delimiterIndex !== -1) {
-                    const rawEvent = buffer.slice(0, delimiterIndex);
-                    buffer = buffer.slice(delimiterIndex + EVENT_DELIMITER.length);
-                    const data = rawEvent
-                        .split("\n")
-                        .filter((line) => line.startsWith(EVENT_DATA_PREFIX))
-                        .map((line) => line.slice(EVENT_DATA_PREFIX.length).trim())
-                        .join("\n");
-                    if (data) {
-                        yield JSON.parse(data);
-                    }
-                    delimiterIndex = buffer.indexOf(EVENT_DELIMITER);
-                }
-                if (done) {
-                    const data = buffer
-                        .split("\n")
-                        .filter((line) => line.startsWith(EVENT_DATA_PREFIX))
-                        .map((line) => line.slice(EVENT_DATA_PREFIX.length).trim())
-                        .join("\n");
-                    if (data) {
-                        yield JSON.parse(data);
-                    }
-                    return;
-                }
-            }
-        },
-    };
-}
-export function createOpencodeClient(options = {}) {
-    const fetcher = options.fetch ?? globalThis.fetch;
-    if (typeof fetcher !== "function") {
-        throw new Error("OpenCode SDK requires global fetch support");
-    }
-    const baseUrl = normalizeBaseUrl(options.baseUrl);
-    return {
-        config: {
-            async get() {
-                return createJsonRequest(fetcher, baseUrl, CONFIG_PATH);
-            },
-        },
-        session: {
-            async create(input = {}) {
-                return createJsonRequest(fetcher, baseUrl, SESSION_PATH, {
-                    method: "POST",
-                    body: JSON.stringify(input.body ?? {}),
-                });
-            },
-            async get(input) {
-                return createJsonRequest(fetcher, baseUrl, buildSessionPath(input.path.id));
-            },
-            async prompt(input) {
-                return createJsonRequest(fetcher, baseUrl, `${buildSessionPath(input.path.id)}${SESSION_MESSAGE_PATH_SUFFIX}`, {
-                    method: "POST",
-                    body: JSON.stringify(input.body),
-                });
-            },
-            async messages(input) {
-                return createJsonRequest(fetcher, baseUrl, `${buildSessionPath(input.path.id)}${SESSION_MESSAGE_PATH_SUFFIX}`);
-            },
-        },
-        event: {
-            async subscribe() {
-                const response = await fetcher(`${baseUrl}${EVENT_PATH}`, {
-                    method: "GET",
-                    headers: {
-                        [RESPONSE_HEADER_ACCEPT]: EVENT_STREAM_CONTENT_TYPE,
-                    },
-                });
-                if (!response.ok) {
-                    const body = await response.text();
-                    throw new Error(body.trim() || `OpenCode event subscribe failed: ${response.status}`);
-                }
-                return { stream: createSseStream(response) };
-            },
-        },
-    };
-}
 function getAvailablePort(hostname) {
     return new Promise((resolve, reject) => {
         const server = net.createServer();
@@ -147,24 +23,17 @@ function getAvailablePort(hostname) {
                 server.close(() => reject(new Error("Unable to determine OpenCode server port")));
                 return;
             }
-            server.close((error) => {
-                if (error) {
-                    reject(error);
-                    return;
-                }
-                resolve(address.port);
-            });
+            server.close((error) => error ? reject(error) : resolve(address.port));
         });
     });
 }
-async function waitForServerReady(client, timeoutMs, signal) {
+async function waitForServerReady(client, directory, timeoutMs, signal) {
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {
-        if (signal?.aborted) {
+        if (signal?.aborted)
             throw createAbortError("OpenCode server startup aborted");
-        }
         try {
-            await client.config.get();
+            await client.config.get({ directory }, { throwOnError: true });
             return;
         }
         catch {
@@ -178,55 +47,59 @@ export async function createOpencodeServer(options = {}) {
     const port = options.port ?? (await getAvailablePort(hostname));
     const url = `http://${hostname}:${port}`;
     const executable = coerceString(options.executable) ?? "opencode";
+    const directory = coerceString(options.directory);
     const startupTimeoutMs = options.startupTimeoutMs ?? DEFAULT_STARTUP_TIMEOUT_MS;
     const child = spawn(executable, [OPENCODE_SERVE_SUBCOMMAND, OPENCODE_HOSTNAME_FLAG, hostname, OPENCODE_PORT_FLAG, String(port)], {
-        cwd: coerceString(options.directory),
-        env: {
-            ...process.env,
-            ...(options.env ?? {}),
-        },
+        cwd: directory,
+        env: { ...process.env, ...(options.env ?? {}) },
         stdio: ["ignore", "pipe", "pipe"],
     });
     let exited = false;
     let stderr = "";
-    child.stderr.on("data", (chunk) => {
-        stderr += String(chunk);
-    });
-    child.on("close", () => {
-        exited = true;
-    });
-    const client = createOpencodeClient({ baseUrl: url });
+    child.stderr.on("data", (chunk) => { stderr += String(chunk); });
+    child.on("error", (error) => { stderr += `${stderr ? " " : ""}${error.message}`; });
+    child.on("close", () => { exited = true; });
+    const client = createOpencodeClient({ baseUrl: url, directory });
+    const stop = async () => {
+        if (exited)
+            return;
+        await new Promise((resolve) => {
+            let settled = false;
+            let forceKill;
+            const finish = () => {
+                if (settled)
+                    return;
+                settled = true;
+                if (forceKill)
+                    clearTimeout(forceKill);
+                resolve();
+            };
+            child.once("close", finish);
+            child.kill("SIGTERM");
+            forceKill = setTimeout(() => {
+                if (!exited)
+                    child.kill("SIGKILL");
+            }, SERVER_SHUTDOWN_FORCE_KILL_MS);
+            forceKill.unref();
+        });
+    };
     try {
-        await waitForServerReady(client, startupTimeoutMs, options.signal);
+        await waitForServerReady(client, directory, startupTimeoutMs, options.signal);
     }
     catch (error) {
-        if (!exited) {
-            child.kill("SIGTERM");
-        }
-        const suffix = stderr.trim().length > 0 ? ` ${stderr.trim()}` : "";
+        await stop();
+        const suffix = stderr.trim() ? ` ${stderr.trim()}` : "";
         throw new Error(`${error instanceof Error ? error.message : String(error)}${suffix}`);
     }
     return {
         url,
-        async close() {
-            if (exited)
-                return;
-            await new Promise((resolve) => {
-                child.once("close", () => resolve());
-                child.kill("SIGTERM");
-                setTimeout(() => {
-                    if (!exited) {
-                        child.kill("SIGKILL");
-                    }
-                }, SERVER_SHUTDOWN_FORCE_KILL_MS);
-            });
-        },
+        close: stop,
     };
 }
 export async function createOpencode(options = {}) {
     const server = await createOpencodeServer(options);
     return {
-        client: createOpencodeClient({ baseUrl: server.url }),
+        client: createOpencodeClient({ baseUrl: server.url, directory: options.directory }),
         server,
     };
 }