@suwujs/king-ai 0.2.0

package/dist/src/host-sdk.js

@@ -0,0 +1,628 @@
+import { DEFAULT_SSE_MAX_BUFFER_BYTES } from "./sse.js";
+export function createDefaultHostSdkRunOptions(overrides = {}) {
+    const infinite = overrides.infinite ?? overrides.loops === Infinity;
+    return {
+        ...overrides,
+        loops: infinite ? Infinity : Math.max(1, Math.floor(overrides.loops ?? 100)),
+        pollIntervalSeconds: Math.max(1, Math.floor(overrides.pollIntervalSeconds ?? overrides.pollInterval ?? 15)),
+        infinite,
+        engine: overrides.engine ?? overrides.runtime,
+        model: cleanSdkString(overrides.model ?? overrides.codexModel),
+        fastModel: cleanSdkString(overrides.fastModel),
+        configPath: cleanSdkString(overrides.configPath),
+        workerUrl: cleanSdkString(overrides.workerUrl),
+        workerModel: cleanSdkString(overrides.workerModel),
+        workerKey: cleanSdkString(overrides.workerKey) ?? "lmstudio",
+        noBrain: overrides.noBrain ?? (overrides.enableBrain === undefined ? false : !overrides.enableBrain),
+        outputDir: cleanSdkString(overrides.outputDir ?? overrides.output) ?? "./deliverables",
+        keepArtifacts: overrides.keepArtifacts ?? overrides.keep ?? false,
+        errorLimit: Math.max(1, Math.floor(overrides.errorLimit ?? 20))
+    };
+}
+export function createHostSdkRunOptions(overrides = {}) {
+    return createDefaultHostSdkRunOptions(overrides);
+}
+export function createHostSdkTakeoverRunOptions(overrides = {}) {
+    return createDefaultHostSdkRunOptions({
+        infinite: true,
+        loops: Infinity,
+        ...overrides
+    });
+}
+export const createDefaultRunOptions = createDefaultHostSdkRunOptions;
+export const createRunOptions = createHostSdkRunOptions;
+export const createTakeoverRunOptions = createHostSdkTakeoverRunOptions;
+export function createHostSdk(options = {}) {
+    const baseUrl = normalizeBaseUrl(options.baseUrl ?? "http://127.0.0.1:8799");
+    const fetchImpl = options.fetch ?? fetch;
+    return {
+        health: () => getJson(fetchImpl, baseUrl, "/health"),
+        status: () => getJson(fetchImpl, baseUrl, "/status"),
+        statusStream: (streamOptions) => streamHostStatus(fetchImpl, baseUrl, streamOptions),
+        events: () => getJson(fetchImpl, baseUrl, "/events"),
+        usage: () => getJson(fetchImpl, baseUrl, "/usage"),
+        expenses: () => getJson(fetchImpl, baseUrl, "/expenses"),
+        doctor: () => getJson(fetchImpl, baseUrl, "/doctor"),
+        commands: () => getJson(fetchImpl, baseUrl, "/commands"),
+        capabilities: () => getJson(fetchImpl, baseUrl, "/capabilities"),
+        snapshot: (limit = 20, status) => getJson(fetchImpl, baseUrl, pathWithQuery("/host/snapshot", { limit, status })),
+        waitForReady: (waitOptions) => waitForHostReady(fetchImpl, baseUrl, waitOptions),
+        watch: (watchOptions) => watchHost(fetchImpl, baseUrl, watchOptions),
+        hostStream: (streamOptions) => streamHostFrames(fetchImpl, baseUrl, streamOptions),
+        timelineStream: (streamOptions) => streamHostTimeline(fetchImpl, baseUrl, streamOptions),
+        run: (goal, options = {}, spec = {}) => {
+            return postJson(fetchImpl, baseUrl, "/runs/preflight", hostRunSpecFromSdk(goal, createHostSdkRunOptions(options), spec, "run"));
+        },
+        runAndWatch: (goal, options = {}, spec = {}, watchOptions) => {
+            return submitAndWatchHostRun(fetchImpl, baseUrl, hostRunSubmitInputFromSdk(goal, createHostSdkRunOptions(options), spec, "run"), watchOptions);
+        },
+        runAndWatchState: (goal, options = {}, spec = {}, watchOptions) => {
+            return submitAndWatchHostRunState(fetchImpl, baseUrl, hostRunSubmitInputFromSdk(goal, createHostSdkRunOptions(options), spec, "run"), watchOptions);
+        },
+        takeover: async (options, runOptions = {}) => (await prepareHostSdkTakeover(fetchImpl, baseUrl, options, runOptions)).preflight,
+        prepareTakeover: (options, runOptions = {}) => prepareHostSdkTakeover(fetchImpl, baseUrl, options, runOptions),
+        executePreparedTakeover: (prepared, spec = {}, watchOptions) => {
+            const goal = prepared.input.goal;
+            return submitAndWatchHostRun(fetchImpl, baseUrl, hostRunSubmitInputFromSdk(goal, prepared.runOptions, {
+                ...prepared.input,
+                ...spec,
+                options: {
+                    ...prepared.input.options,
+                    ...spec.options
+                }
+            }, "takeover"), watchOptions);
+        },
+        executePreparedTakeoverState: (prepared, spec = {}, watchOptions) => {
+            const goal = prepared.input.goal;
+            return submitAndWatchHostRunState(fetchImpl, baseUrl, hostRunSubmitInputFromSdk(goal, prepared.runOptions, {
+                ...prepared.input,
+                ...spec,
+                options: {
+                    ...prepared.input.options,
+                    ...spec.options
+                }
+            }, "takeover"), watchOptions);
+        },
+        takeoverAndWatch: (options, runOptions = {}, spec = {}, watchOptions) => {
+            const merged = { ...runOptions, ...options };
+            const goal = options.goalOverride ?? `Take over ${options.projectPath ?? options.projectDir ?? options.repoSourceDir ?? "project"}`;
+            return submitAndWatchHostRun(fetchImpl, baseUrl, hostRunSubmitInputFromSdk(goal, createHostSdkTakeoverRunOptions({
+                ...merged,
+                projectDir: options.projectPath ?? merged.projectDir
+            }), spec, "takeover"), watchOptions);
+        },
+        takeoverAndWatchState: (options, runOptions = {}, spec = {}, watchOptions) => {
+            const merged = { ...runOptions, ...options };
+            const goal = options.goalOverride ?? `Take over ${options.projectPath ?? options.projectDir ?? options.repoSourceDir ?? "project"}`;
+            return submitAndWatchHostRunState(fetchImpl, baseUrl, hostRunSubmitInputFromSdk(goal, createHostSdkTakeoverRunOptions({
+                ...merged,
+                projectDir: options.projectPath ?? merged.projectDir
+            }), spec, "takeover"), watchOptions);
+        },
+        runCommand: (request) => runHostSdkCommand(fetchImpl, baseUrl, request),
+        planRun: (input) => postJson(fetchImpl, baseUrl, "/runs/plan", input),
+        preflight: (input) => postJson(fetchImpl, baseUrl, "/runs/preflight", input),
+        prepareRunLayout: (input) => postJson(fetchImpl, baseUrl, "/runs/prepare-layout", input),
+        submitRun: (input) => postJson(fetchImpl, baseUrl, "/runs", input),
+        submitAndExecuteRun: (input) => submitAndExecuteHostRun(fetchImpl, baseUrl, input),
+        submitAndWatchRun: (input, watchOptions) => submitAndWatchHostRun(fetchImpl, baseUrl, input, watchOptions),
+        submitAndWatchRunState: (input, watchOptions) => submitAndWatchHostRunState(fetchImpl, baseUrl, input, watchOptions),
+        runRequests: (limit = 20, status) => getJson(fetchImpl, baseUrl, pathWithQuery("/runs", { limit, status })),
+        runRequestsStream: (streamOptions) => streamHostRunRequests(fetchImpl, baseUrl, streamOptions),
+        runRequest: (id) => getJson(fetchImpl, baseUrl, `/runs/${encodeURIComponent(id)}`),
+        runRequestStream: (id, streamOptions) => streamHostRunRequest(fetchImpl, baseUrl, id, streamOptions),
+        runStateStream: (id, streamOptions) => streamHostRunState(fetchImpl, baseUrl, id, streamOptions),
+        emitRunEvent: (id, event) => postJson(fetchImpl, baseUrl, `/runs/${encodeURIComponent(id)}/events`, { event }),
+        runEvents: (id, eventsOptions = {}) => getJson(fetchImpl, baseUrl, pathWithQuery(`/runs/${encodeURIComponent(id)}/events`, eventsOptions)),
+        watchRun: (id, eventsOptions = {}) => getJson(fetchImpl, baseUrl, pathWithQuery(`/runs/${encodeURIComponent(id)}/events`, eventsOptions)),
+        runResults: (id, resultsOptions = {}) => getJson(fetchImpl, baseUrl, pathWithQuery(`/runs/${encodeURIComponent(id)}/results`, resultsOptions)),
+        runHeartbeat: (id, heartbeatOptions = {}) => getJson(fetchImpl, baseUrl, pathWithQuery(`/runs/${encodeURIComponent(id)}/heartbeat`, heartbeatOptions)),
+        runMeta: (id, metaOptions = {}) => getJson(fetchImpl, baseUrl, pathWithQuery(`/runs/${encodeURIComponent(id)}/meta`, metaOptions)),
+        waitForRun: (id, waitOptions) => waitForHostRun(fetchImpl, baseUrl, id, waitOptions),
+        updateRun: (id, status, detail) => patchJson(fetchImpl, baseUrl, `/runs/${encodeURIComponent(id)}`, { status, detail }),
+        completeRun: (id, detail) => patchJson(fetchImpl, baseUrl, `/runs/${encodeURIComponent(id)}`, { status: "completed", detail }),
+        failRun: (id, detail) => patchJson(fetchImpl, baseUrl, `/runs/${encodeURIComponent(id)}`, { status: "failed", detail }),
+        cancelRun: (id, detail) => deleteJson(fetchImpl, baseUrl, `/runs/${encodeURIComponent(id)}`, { detail }),
+        executeRun: (id) => postJson(fetchImpl, baseUrl, id ? `/runs/${encodeURIComponent(id)}/execute` : "/runs/execute", {}),
+        planExport: (input) => postJson(fetchImpl, baseUrl, "/exports/plan", input),
+        exportArtifacts: (input) => postJson(fetchImpl, baseUrl, "/exports", input),
+        policy: (command, input = {}) => {
+            const path = `/policy/${encodeURIComponent(command)}`;
+            return input.confirmed !== undefined || input.confirmation !== undefined
+                ? postJson(fetchImpl, baseUrl, path, input)
+                : getJson(fetchImpl, baseUrl, path);
+        },
+        timeline: (limit = 20) => getJson(fetchImpl, baseUrl, pathWithQuery("/timeline", { limit }))
+    };
+}
+export function createKingHostSdk(config = {}, adapters) {
+    if (!adapters)
+        return createHostSdk(config);
+    const bindings = {
+        hostEnv: {
+            ...process.env,
+            ...(config.env ?? {})
+        }
+    };
+    const sdk = {
+        async run(goal, options = {}, spec = {}) {
+            await adapters.runGoal(goal, createRunOptions(options), spec, bindings);
+        },
+        prepareTakeover(options) {
+            return adapters.prepareTakeoverPlan(adapters.normalizeTakeoverOptions(options));
+        },
+        async executePreparedTakeover(plan, options = {}) {
+            await adapters.executePreparedTakeoverPlan(plan, createTakeoverRunOptions(options), bindings);
+        },
+        async takeover(options, runOptions = {}) {
+            const plan = sdk.prepareTakeover(options);
+            await sdk.executePreparedTakeover(plan, runOptions);
+        }
+    };
+    return sdk;
+}
+export function createEnvBackedHostSdk(env = process.env, options = {}) {
+    return createHostSdk({
+        ...options,
+        baseUrl: hostBaseUrlFromEnv(env)
+    });
+}
+export function createEnvBackedKingHostSdk(env = process.env, config = {}, adapters) {
+    if (!adapters)
+        return createEnvBackedHostSdk(env, config);
+    return createKingHostSdk({ ...config, env }, adapters);
+}
+export function createBrowserHostSdk(options = {}) {
+    return createHostSdk({
+        ...options,
+        baseUrl: options.baseUrl ?? hostBaseUrlFromLocation(options.location ?? globalLocationLike(), options)
+    });
+}
+export function hostBaseUrlFromEnv(env = process.env) {
+    if (env.KING_AI_HOST_URL)
+        return env.KING_AI_HOST_URL;
+    const host = env.KING_AI_HOST || "127.0.0.1";
+    const port = env.KING_AI_HOST_PORT || "8799";
+    return `http://${host}:${port}`;
+}
+export function hostBaseUrlFromLocation(location, options = {}) {
+    if (options.useCurrentOrigin && location?.origin)
+        return location.origin;
+    const port = options.port ?? location?.port ?? "8799";
+    const hostname = location && isLocalHostName(location.hostname) ? location.hostname : "127.0.0.1";
+    const protocol = location?.protocol === "https:" ? "https:" : "http:";
+    return `${protocol}//${hostname}${port ? `:${port}` : ""}`;
+}
+export async function waitForHostReady(fetchImpl, baseUrl, options = {}) {
+    const timeoutMs = Math.max(1, Math.floor(options.timeoutMs ?? 10_000));
+    const intervalMs = Math.max(1, Math.floor(options.intervalMs ?? 250));
+    const deadline = Date.now() + timeoutMs;
+    let lastError;
+    while (Date.now() <= deadline) {
+        try {
+            const health = await getJson(fetchImpl, baseUrl, "/health");
+            if (health.ok) {
+                const status = await getJson(fetchImpl, baseUrl, "/status");
+                if (!options.requireDaemon || status.ok)
+                    return status;
+                lastError = new Error("host server is reachable but daemon state is not ready");
+            }
+        }
+        catch (err) {
+            lastError = err;
+        }
+        await delay(intervalMs);
+    }
+    const reason = lastError instanceof Error ? `: ${lastError.message}` : "";
+    throw new Error(`host server did not become ready within ${timeoutMs}ms${reason}`);
+}
+export async function waitForHostRun(fetchImpl, baseUrl, id, options = {}) {
+    const timeoutMs = Math.max(1, Math.floor(options.timeoutMs ?? 30_000));
+    const intervalMs = Math.max(1, Math.floor(options.intervalMs ?? 250));
+    const terminals = new Set(options.terminalStatuses ?? ["completed", "failed", "cancelled"]);
+    const deadline = Date.now() + timeoutMs;
+    let last;
+    while (Date.now() <= deadline) {
+        last = await getJson(fetchImpl, baseUrl, `/runs/${encodeURIComponent(id)}`);
+        const status = last.json?.request.status;
+        if (status && terminals.has(status))
+            return last;
+        await delay(intervalMs);
+    }
+    const status = last?.json?.request.status;
+    throw new Error(`host run ${id} did not reach a terminal status within ${timeoutMs}ms${status ? `; last status=${status}` : ""}`);
+}
+export async function submitAndExecuteHostRun(fetchImpl, baseUrl, input) {
+    const submitted = await postJson(fetchImpl, baseUrl, "/runs", input);
+    const id = submitted.json?.request.id;
+    if (!submitted.ok || !id) {
+        return {
+            submitted,
+            executed: {
+                ok: false,
+                command: "execute-run",
+                exitCode: 1,
+                text: "host run was not submitted",
+                error: submitted.error ?? "host run was not submitted"
+            }
+        };
+    }
+    const executed = await postJson(fetchImpl, baseUrl, `/runs/${encodeURIComponent(id)}/execute`, {});
+    return { submitted, executed };
+}
+export async function* submitAndWatchHostRun(fetchImpl, baseUrl, input, options = {}) {
+    const submitted = await postJson(fetchImpl, baseUrl, "/runs", input);
+    yield { event: "submitted", data: submitted };
+    const id = submitted.json?.request.id;
+    if (!submitted.ok || !id)
+        return;
+    const terminalStatuses = new Set(options.terminalStatuses ?? ["completed", "failed", "cancelled"]);
+    for await (const request of streamHostRunRequest(fetchImpl, baseUrl, id, options)) {
+        yield { event: "run", data: request };
+        if (request && terminalStatuses.has(request.status))
+            return;
+    }
+}
+export async function* submitAndWatchHostRunState(fetchImpl, baseUrl, input, options = {}) {
+    const submitted = await postJson(fetchImpl, baseUrl, "/runs", input);
+    yield { event: "submitted", data: submitted };
+    const id = submitted.json?.request.id;
+    if (!submitted.ok || !id)
+        return;
+    const terminalStatuses = new Set(options.terminalStatuses ?? ["completed", "failed", "cancelled"]);
+    for await (const state of streamHostRunState(fetchImpl, baseUrl, id, options)) {
+        yield { event: "state", data: state };
+        const status = state.request?.status;
+        if (status && terminalStatuses.has(status))
+            return;
+    }
+}
+export async function prepareHostSdkTakeover(fetchImpl, baseUrl, options, runOptions = {}) {
+    const merged = { ...runOptions, ...options };
+    const normalizedRunOptions = createHostSdkTakeoverRunOptions({
+        ...merged,
+        projectDir: options.projectPath ?? merged.projectDir
+    });
+    const goal = options.goalOverride ?? `Take over ${options.projectPath ?? options.projectDir ?? options.repoSourceDir ?? "project"}`;
+    const input = hostRunSpecFromSdk(goal, normalizedRunOptions, {}, "takeover");
+    const preflight = await postJson(fetchImpl, baseUrl, "/runs/preflight", input);
+    return {
+        options,
+        runOptions: normalizedRunOptions,
+        input,
+        preflight
+    };
+}
+export async function* streamHostStatus(fetchImpl, baseUrl, options = {}) {
+    const path = pathWithQuery("/status/stream", { interval: options.intervalMs });
+    const response = await fetchImpl(urlFor(baseUrl, path), {
+        headers: {
+            Accept: "text/event-stream"
+        },
+        signal: options.signal
+    });
+    if (!response.ok || !response.body) {
+        throw new Error(`host status stream failed with HTTP ${response.status}`);
+    }
+    for await (const parsed of streamSseFrames(response.body)) {
+        if (parsed.event === "status" && parsed.data)
+            yield parsed.data;
+        if (parsed.event === "error" && parsed.data && typeof parsed.data === "object") {
+            const message = parsed.data.error;
+            throw new Error(typeof message === "string" ? message : "host status stream error");
+        }
+    }
+}
+export async function* streamHostTimeline(fetchImpl, baseUrl, options = {}) {
+    const path = pathWithQuery("/timeline/stream", { interval: options.intervalMs, limit: options.limit });
+    const response = await fetchImpl(urlFor(baseUrl, path), {
+        headers: {
+            Accept: "text/event-stream"
+        },
+        signal: options.signal
+    });
+    if (!response.ok || !response.body) {
+        throw new Error(`host timeline stream failed with HTTP ${response.status}`);
+    }
+    for await (const parsed of streamSseFrames(response.body)) {
+        if (parsed.event === "timeline" && Array.isArray(parsed.data))
+            yield parsed.data;
+        if (parsed.event === "error" && parsed.data && typeof parsed.data === "object") {
+            const message = parsed.data.error;
+            throw new Error(typeof message === "string" ? message : "host timeline stream error");
+        }
+    }
+}
+export async function* streamHostFrames(fetchImpl, baseUrl, options = {}) {
+    const path = pathWithQuery("/host/stream", {
+        interval: options.intervalMs,
+        limit: options.limit,
+        timelineLimit: options.timelineLimit,
+        runLimit: options.runLimit,
+        status: options.status
+    });
+    const response = await fetchImpl(urlFor(baseUrl, path), {
+        headers: {
+            Accept: "text/event-stream"
+        },
+        signal: options.signal
+    });
+    if (!response.ok || !response.body) {
+        throw new Error(`host stream failed with HTTP ${response.status}`);
+    }
+    for await (const parsed of streamSseFrames(response.body)) {
+        if (parsed.event === "status" && parsed.data && typeof parsed.data === "object") {
+            yield { event: "status", data: parsed.data };
+        }
+        if (parsed.event === "timeline" && Array.isArray(parsed.data)) {
+            yield { event: "timeline", data: parsed.data };
+        }
+        if (parsed.event === "runs" && parsed.data && typeof parsed.data === "object") {
+            const requests = parsed.data.requests;
+            if (Array.isArray(requests))
+                yield { event: "runs", data: requests };
+        }
+        if (parsed.event === "error" && parsed.data && typeof parsed.data === "object") {
+            const message = parsed.data.error;
+            throw new Error(typeof message === "string" ? message : "host stream error");
+        }
+    }
+}
+export async function* watchHost(fetchImpl, baseUrl, options = {}) {
+    if (options.includeInitialSnapshot !== false) {
+        const limit = options.limit ?? Math.max(options.timelineLimit ?? 0, options.runLimit ?? 0, 20);
+        yield {
+            event: "snapshot",
+            data: await getJson(fetchImpl, baseUrl, pathWithQuery("/host/snapshot", { limit, status: options.status }))
+        };
+    }
+    yield* streamHostFrames(fetchImpl, baseUrl, options);
+}
+export async function* streamHostRunRequests(fetchImpl, baseUrl, options = {}) {
+    const path = pathWithQuery("/runs/stream", { interval: options.intervalMs, limit: options.limit, status: options.status });
+    const response = await fetchImpl(urlFor(baseUrl, path), {
+        headers: {
+            Accept: "text/event-stream"
+        },
+        signal: options.signal
+    });
+    if (!response.ok || !response.body) {
+        throw new Error(`host run requests stream failed with HTTP ${response.status}`);
+    }
+    for await (const parsed of streamSseFrames(response.body)) {
+        if (parsed.event === "runs" && parsed.data && typeof parsed.data === "object") {
+            const requests = parsed.data.requests;
+            if (Array.isArray(requests))
+                yield requests;
+        }
+        if (parsed.event === "error" && parsed.data && typeof parsed.data === "object") {
+            const message = parsed.data.error;
+            throw new Error(typeof message === "string" ? message : "host run requests stream error");
+        }
+    }
+}
+export async function* streamHostRunRequest(fetchImpl, baseUrl, id, options = {}) {
+    for await (const frame of streamHostRunState(fetchImpl, baseUrl, id, options)) {
+        yield frame.request;
+    }
+}
+export async function* streamHostRunState(fetchImpl, baseUrl, id, options = {}) {
+    const path = pathWithQuery(`/runs/${encodeURIComponent(id)}/stream`, { interval: options.intervalMs });
+    const response = await fetchImpl(urlFor(baseUrl, path), {
+        headers: {
+            Accept: "text/event-stream"
+        },
+        signal: options.signal
+    });
+    if (!response.ok || !response.body) {
+        throw new Error(`host run request stream failed with HTTP ${response.status}`);
+    }
+    for await (const parsed of streamSseFrames(response.body)) {
+        if (parsed.event === "run" && parsed.data && typeof parsed.data === "object") {
+            yield parseHostRunStateFrame(parsed.data);
+        }
+        if (parsed.event === "error" && parsed.data && typeof parsed.data === "object") {
+            const message = parsed.data.error;
+            throw new Error(typeof message === "string" ? message : "host run request stream error");
+        }
+    }
+}
+function parseHostRunStateFrame(data) {
+    const value = data && typeof data === "object" ? data : {};
+    return {
+        request: value.request && typeof value.request === "object" ? value.request : null,
+        heartbeat: value.heartbeat && typeof value.heartbeat === "object" ? value.heartbeat : null,
+        meta: value.meta && typeof value.meta === "object" ? value.meta : null
+    };
+}
+export async function runHostSdkCommand(fetchImpl, baseUrl, request) {
+    const response = await fetchImpl(urlFor(baseUrl, "/commands/run"), {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json"
+        },
+        body: JSON.stringify(request)
+    });
+    const result = await readJson(response);
+    if (!response.ok && !result.error) {
+        result.error = `host command failed with HTTP ${response.status}`;
+    }
+    return result;
+}
+async function getJson(fetchImpl, baseUrl, path) {
+    const response = await fetchImpl(urlFor(baseUrl, path));
+    return readJson(response);
+}
+async function postJson(fetchImpl, baseUrl, path, body) {
+    const response = await fetchImpl(urlFor(baseUrl, path), {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json"
+        },
+        body: JSON.stringify(body)
+    });
+    return readJson(response);
+}
+async function patchJson(fetchImpl, baseUrl, path, body) {
+    const response = await fetchImpl(urlFor(baseUrl, path), {
+        method: "PATCH",
+        headers: {
+            "Content-Type": "application/json"
+        },
+        body: JSON.stringify(body)
+    });
+    return readJson(response);
+}
+async function deleteJson(fetchImpl, baseUrl, path, body) {
+    const response = await fetchImpl(urlFor(baseUrl, path), {
+        method: "DELETE",
+        headers: {
+            "Content-Type": "application/json"
+        },
+        body: JSON.stringify(body)
+    });
+    return readJson(response);
+}
+async function readJson(response) {
+    const text = await response.text();
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new Error(`host SDK expected JSON response from ${response.url || "host server"}`);
+    }
+}
+function normalizeBaseUrl(value) {
+    const url = new URL(value);
+    if (url.protocol !== "http:" && url.protocol !== "https:")
+        throw new Error("host SDK baseUrl must be http or https");
+    return url.toString().replace(/\/+$/, "");
+}
+function cleanSdkString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function globalLocationLike() {
+    const location = globalThis.location;
+    if (!location || typeof location.protocol !== "string" || typeof location.hostname !== "string")
+        return undefined;
+    return {
+        protocol: location.protocol,
+        hostname: location.hostname,
+        port: typeof location.port === "string" ? location.port : undefined,
+        origin: typeof location.origin === "string" ? location.origin : undefined
+    };
+}
+function isLocalHostName(value) {
+    return value === "localhost" || value === "127.0.0.1" || value === "::1" || value === "[::1]";
+}
+function urlFor(baseUrl, path) {
+    return `${baseUrl}${path.startsWith("/") ? path : `/${path}`}`;
+}
+function pathWithQuery(path, query) {
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(query)) {
+        if (value !== undefined && value !== "")
+            params.set(key, String(value));
+    }
+    const serialized = params.toString();
+    return serialized ? `${path}?${serialized}` : path;
+}
+function parseSseFrame(frame) {
+    let event = "message";
+    const data = [];
+    for (const line of frame.split(/\r?\n/)) {
+        if (line.startsWith("event:"))
+            event = line.slice("event:".length).trim();
+        else if (line.startsWith("data:"))
+            data.push(line.slice("data:".length).trimStart());
+    }
+    if (data.length === 0)
+        return { event };
+    try {
+        return { event, data: JSON.parse(data.join("\n")) };
+    }
+    catch {
+        return { event, data: data.join("\n") };
+    }
+}
+function isAsyncIterableBody(body) {
+    return typeof body[Symbol.asyncIterator] === "function";
+}
+async function* readBodyChunks(body) {
+    if (isAsyncIterableBody(body)) {
+        yield* body;
+        return;
+    }
+    const reader = body.getReader();
+    try {
+        while (true) {
+            const chunk = await reader.read();
+            if (chunk.done)
+                return;
+            if (chunk.value)
+                yield chunk.value;
+        }
+    }
+    finally {
+        reader.releaseLock?.();
+    }
+}
+async function* streamSseFrames(body) {
+    const decoder = new TextDecoder();
+    let buffer = "";
+    for await (const chunk of readBodyChunks(body)) {
+        buffer += decoder.decode(chunk, { stream: true });
+        if (Buffer.byteLength(buffer, "utf8") > DEFAULT_SSE_MAX_BUFFER_BYTES) {
+            throw new Error(`SSE frame exceeded ${DEFAULT_SSE_MAX_BUFFER_BYTES} bytes without a terminator`);
+        }
+        let index = buffer.indexOf("\n\n");
+        while (index !== -1) {
+            const frame = buffer.slice(0, index);
+            buffer = buffer.slice(index + 2);
+            yield parseSseFrame(frame);
+            index = buffer.indexOf("\n\n");
+        }
+    }
+}
+function hostRunSpecFromSdk(goal, options, spec, mode) {
+    const loopMode = options.infinite ? "infinite" : spec.options?.loopMode;
+    return {
+        ...spec,
+        goal,
+        mode,
+        projectDir: spec.projectDir ?? options.projectDir,
+        repoSourceDir: spec.repoSourceDir ?? options.repoSourceDir,
+        repoCloneUrl: spec.repoCloneUrl ?? options.repoCloneUrl,
+        workspaceRoot: spec.workspaceRoot ?? options.workspaceRoot,
+        gitRoot: spec.gitRoot ?? options.gitRoot,
+        options: {
+            ...spec.options,
+            engine: options.engine ?? spec.options?.engine,
+            model: options.model ?? spec.options?.model,
+            fastModel: options.fastModel ?? spec.options?.fastModel,
+            codexReasoningEffort: options.codexReasoningEffort ?? spec.options?.codexReasoningEffort,
+            configPath: options.configPath ?? spec.options?.configPath,
+            workerUrl: options.workerUrl ?? spec.options?.workerUrl,
+            workerModel: options.workerModel ?? spec.options?.workerModel,
+            workerKey: options.workerKey ?? spec.options?.workerKey,
+            noBrain: options.noBrain ?? spec.options?.noBrain,
+            loops: options.infinite ? undefined : options.loops ?? spec.options?.loops,
+            loopMode,
+            pollIntervalSeconds: options.pollIntervalSeconds ?? spec.options?.pollIntervalSeconds,
+            outputDir: options.outputDir ?? spec.options?.outputDir,
+            keepArtifacts: options.keepArtifacts ?? spec.options?.keepArtifacts,
+            errorLimit: options.errorLimit ?? spec.options?.errorLimit
+        }
+    };
+}
+function hostRunSubmitInputFromSdk(goal, options, spec, mode) {
+    const { requestId, executor, ...planSpec } = spec;
+    return {
+        ...hostRunSpecFromSdk(goal, options, planSpec, mode),
+        requestId,
+        executor
+    };
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/src/host-server.d.ts

@@ -0,0 +1,26 @@
+import type { Server } from "node:http";
+import type { HostCommandRequest, HostCommandResult } from "./host-control.js";
+import type { HostTimelineEvent } from "./host-timeline.js";
+import type { HostRunListInput, HostRunRequest } from "./host-runs.js";
+import type { RunningState } from "./service.js";
+import type { UsagePricingRule } from "./usage.js";
+export declare const DEFAULT_HOST_SERVER_HOST = "127.0.0.1";
+export declare const DEFAULT_HOST_SERVER_PORT = 8799;
+export type HostStatusServerOptions = {
+    host?: string;
+    port?: number;
+    readState?: () => Promise<RunningState | null>;
+    tokenBudget?: () => number | null | undefined;
+    usagePricing?: () => UsagePricingRule[];
+    readTimeline?: (limit?: number) => Promise<HostTimelineEvent[]>;
+    readRuns?: (input?: HostRunListInput) => Promise<HostRunRequest[]>;
+    runCommand?: (request: HostCommandRequest) => Promise<HostCommandResult>;
+    executeRuns?: boolean;
+    executeRunsIntervalMs?: number;
+    statusStreamIntervalMs?: number;
+};
+export declare function hostServerPortFromEnv(env?: NodeJS.ProcessEnv): number;
+export declare function normalizeHostServerHost(host?: string): string;
+export declare function createHostStatusServer(options?: HostStatusServerOptions): Server;
+export declare function startHostStatusServer(options?: HostStatusServerOptions): Promise<Server>;
+export declare function serveHostStatus(options?: HostStatusServerOptions): Promise<void>;