mirror of
https://github.com/wu736139669/hapi.git
synced 2026-11-18 03:27:08 +00:00
fix(opencode): expose model-specific reasoning effort options (#1716)
* fix(cli): discover opencode thought_level via set_config_option on model switch * fix(cli): apply and refresh opencode model switches so thought_level stays discoverable * fix(web): track opencode effort options across model switches * feat(cli,hub,web): dynamic opencode effort options in new-session form * test(cli): avoid platform-specific process event narrowing * fix(opencode): address variant discovery review findings * fix(opencode): synchronize effort options with model targets * fix(opencode): roll back rejected model targets * fix(cli): guard opencode variant probe workspace paths * fix(web): clear stale opencode effort on model switch * fix(cli): clear stale opencode effort metadata * fix(web): reset stale effort options on model switch * fix(web): reset opencode effort poll budget * test(web): enforce opencode effort poll budget
This commit is contained in:
@@ -0,0 +1,21 @@
|
||||
import { logger } from '@/ui/logger';
|
||||
import { RPC_METHODS } from '@hapi/protocol/rpcMethods';
|
||||
import type { RpcHandlerManager } from '@/api/rpc/RpcHandlerManager';
|
||||
import {
|
||||
listOpencodeModelVariants,
|
||||
type ListOpencodeModelVariantsResponse
|
||||
} from '../opencodeModelVariants';
|
||||
import { getErrorMessage, rpcError } from '../rpcResponses';
|
||||
|
||||
export function registerOpencodeModelVariantsHandlers(rpcHandlerManager: RpcHandlerManager): void {
|
||||
rpcHandlerManager.registerHandler<{ cwd?: string | null } | undefined, ListOpencodeModelVariantsResponse>(RPC_METHODS.ListOpencodeModelVariants, async (data) => {
|
||||
logger.debug('List OpenCode model variants request');
|
||||
|
||||
try {
|
||||
return await listOpencodeModelVariants({ cwd: data?.cwd ?? null });
|
||||
} catch (error) {
|
||||
logger.debug('Failed to list OpenCode model variants:', error);
|
||||
return rpcError(getErrorMessage(error, 'Failed to list OpenCode model variants'));
|
||||
}
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,270 @@
|
||||
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
|
||||
import { extractOpencodeAcpPorts, extractOpencodeAcpServers, parseOpencodeProviderVariants, listOpencodeModelVariants } from './opencodeModelVariants'
|
||||
|
||||
describe('parseOpencodeProviderVariants', () => {
|
||||
it('collects variants for models that have at least one variant keyed by providerID/modelId', () => {
|
||||
const payload = {
|
||||
all: [
|
||||
{
|
||||
id: 'opencode-go',
|
||||
models: {
|
||||
'ox-alpha-free': {
|
||||
id: 'ox-alpha-free',
|
||||
providerID: 'opencode-go',
|
||||
variants: { low: {}, high: {}, max: {} }
|
||||
},
|
||||
'bare-model': {
|
||||
id: 'bare-model',
|
||||
providerID: 'opencode-go'
|
||||
}
|
||||
}
|
||||
},
|
||||
{
|
||||
id: 'other',
|
||||
models: {
|
||||
'muse-spark': {
|
||||
id: 'muse-spark',
|
||||
providerID: 'other',
|
||||
variants: { minimal: null }
|
||||
}
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
|
||||
expect(parseOpencodeProviderVariants(payload)).toEqual({
|
||||
'opencode-go/ox-alpha-free': ['low', 'high', 'max'],
|
||||
'other/muse-spark': ['minimal']
|
||||
})
|
||||
})
|
||||
|
||||
it('skips models with empty or invalid variant maps and malformed entries', () => {
|
||||
const payload = {
|
||||
all: [
|
||||
{
|
||||
id: 'p1',
|
||||
models: {
|
||||
'no-variants': { id: 'no-variants', providerID: 'p1', variants: {} },
|
||||
'bad-variants': { id: 'bad-variants', providerID: 'p1', variants: 'nope' },
|
||||
'missing-id': { providerID: 'p1', variants: { low: {} } },
|
||||
'missing-provider': { id: 'x', variants: { low: {} } },
|
||||
ok: { id: 'ok', providerID: 'p1', variants: { high: {} } }
|
||||
}
|
||||
},
|
||||
'not-an-object',
|
||||
{ noModels: true }
|
||||
]
|
||||
}
|
||||
|
||||
expect(parseOpencodeProviderVariants(payload)).toEqual({
|
||||
'p1/ok': ['high']
|
||||
})
|
||||
})
|
||||
|
||||
it('returns an empty map for non-object payloads', () => {
|
||||
expect(parseOpencodeProviderVariants(null)).toEqual({})
|
||||
expect(parseOpencodeProviderVariants('string')).toEqual({})
|
||||
expect(parseOpencodeProviderVariants({})).toEqual({})
|
||||
expect(parseOpencodeProviderVariants({ all: 'nope' })).toEqual({})
|
||||
})
|
||||
})
|
||||
|
||||
describe('extractOpencodeAcpPorts', () => {
|
||||
it('extracts ports from live opencode acp process args', () => {
|
||||
const ps = [
|
||||
'/home/user/.local/bin/hapi-runner opencode --hapi-starting-mode remote --model opencode-go/ox-alpha-free',
|
||||
'opencode acp --cwd /home/user --port 42495 --hostname 127.0.0.1',
|
||||
'opencode acp --cwd /tmp --port 38971 --hostname 127.0.0.1',
|
||||
'opencode serve --port 46123',
|
||||
'bun run hub/src/index.ts'
|
||||
].join('\n');
|
||||
expect(extractOpencodeAcpPorts(ps)).toEqual([42495, 38971]);
|
||||
});
|
||||
|
||||
it('dedupes and rejects malformed ports', () => {
|
||||
const ps = [
|
||||
'opencode acp --port 70000',
|
||||
'opencode acp --port 42495',
|
||||
'opencode acp --port 42495 --hostname 127.0.0.1',
|
||||
'opencode acp --cwd /x'
|
||||
].join('\n');
|
||||
expect(extractOpencodeAcpPorts(ps)).toEqual([42495]);
|
||||
});
|
||||
});
|
||||
|
||||
|
||||
describe('listOpencodeModelVariants resident lifecycle', () => {
|
||||
const providerPayload = {
|
||||
all: [{ id: 'p', models: { m: { id: 'm', providerID: 'p', variants: { low: {}, high: {} } } } }]
|
||||
};
|
||||
|
||||
function makeProc(argv: string[]) {
|
||||
return {
|
||||
argv,
|
||||
kill: vi.fn(),
|
||||
exitCode: null,
|
||||
stdout: new ReadableStream<Uint8Array>({ start(c) { c.close(); } })
|
||||
};
|
||||
}
|
||||
|
||||
let procs: ReturnType<typeof makeProc>[];
|
||||
let mod: typeof import('./opencodeModelVariants');
|
||||
|
||||
beforeEach(async () => {
|
||||
vi.useFakeTimers();
|
||||
vi.resetModules();
|
||||
procs = [];
|
||||
vi.stubGlobal('fetch', vi.fn(async () => new Response(JSON.stringify(providerPayload), { status: 200 })));
|
||||
vi.stubGlobal('Bun', {
|
||||
spawn: vi.fn((argv: string[], opts?: { cwd?: string }) => {
|
||||
const proc = makeProc(argv);
|
||||
(proc as unknown as { spawnCwd?: string }).spawnCwd = opts?.cwd;
|
||||
if (argv[0] === 'ps') {
|
||||
proc.stdout = new ReadableStream<Uint8Array>({
|
||||
start(c) { c.enqueue(new TextEncoder().encode('')); c.close(); }
|
||||
});
|
||||
}
|
||||
procs.push(proc);
|
||||
return proc;
|
||||
})
|
||||
});
|
||||
mod = await import('./opencodeModelVariants');
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
vi.useRealTimers();
|
||||
vi.unstubAllGlobals();
|
||||
});
|
||||
|
||||
const serveProcs = () => procs.filter((p) => p.argv[0] === 'opencode');
|
||||
|
||||
it('spawns serve once, keeps it resident, and answers subsequent calls without respawn', async () => {
|
||||
const first = mod.listOpencodeModelVariants();
|
||||
await vi.advanceTimersByTimeAsync(300);
|
||||
const r1 = await first;
|
||||
expect(r1.success).toBe(true);
|
||||
expect(serveProcs().length).toBe(1);
|
||||
|
||||
await mod.listOpencodeModelVariants();
|
||||
await mod.listOpencodeModelVariants();
|
||||
expect(serveProcs().length).toBe(1);
|
||||
});
|
||||
|
||||
it('reaps the resident serve after the idle timeout and respawns on the next call', async () => {
|
||||
const first = mod.listOpencodeModelVariants();
|
||||
await vi.advanceTimersByTimeAsync(300);
|
||||
await first;
|
||||
const initialServe = serveProcs()[0];
|
||||
|
||||
await vi.advanceTimersByTimeAsync(10 * 60 * 1000);
|
||||
expect(initialServe.kill).toHaveBeenCalled();
|
||||
|
||||
const second = mod.listOpencodeModelVariants();
|
||||
await vi.advanceTimersByTimeAsync(300);
|
||||
const r2 = await second;
|
||||
expect(r2.success).toBe(true);
|
||||
expect(serveProcs().length).toBe(2);
|
||||
expect(serveProcs()[1].kill).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('does not reuse a project server when no cwd was requested', async () => {
|
||||
// Seed the ps scan with a live acp server in /a, then request with cwd=null.
|
||||
vi.stubGlobal('Bun', {
|
||||
spawn: vi.fn((argv: string[]) => {
|
||||
const proc = makeProc(argv);
|
||||
if (argv[0] === 'ps') {
|
||||
proc.stdout = new ReadableStream<Uint8Array>({
|
||||
start(c) {
|
||||
c.enqueue(new TextEncoder().encode('opencode acp --cwd /a --port 42495 --hostname 127.0.0.1'));
|
||||
c.close();
|
||||
}
|
||||
});
|
||||
}
|
||||
procs.push(proc);
|
||||
return proc;
|
||||
})
|
||||
});
|
||||
mod = await import('./opencodeModelVariants');
|
||||
const result = mod.listOpencodeModelVariants();
|
||||
await vi.advanceTimersByTimeAsync(300);
|
||||
const r = await result;
|
||||
// The /a server must be skipped; the answer comes from a fresh spawn.
|
||||
expect(r.success).toBe(true);
|
||||
const liveFetchProc = procs.find((p) => p.argv[0] === 'ps');
|
||||
void liveFetchProc;
|
||||
expect(serveProcs().length).toBe(1);
|
||||
});
|
||||
|
||||
it('kills the resident and respawns when the requested cwd changes', async () => {
|
||||
const first = mod.listOpencodeModelVariants({ cwd: '/a' });
|
||||
await vi.advanceTimersByTimeAsync(300);
|
||||
await first;
|
||||
const firstServe = serveProcs()[0];
|
||||
|
||||
const second = mod.listOpencodeModelVariants({ cwd: '/b' });
|
||||
await vi.advanceTimersByTimeAsync(300);
|
||||
const r2 = await second;
|
||||
expect(r2.success).toBe(true);
|
||||
expect(firstServe.kill).toHaveBeenCalled();
|
||||
const newServe = serveProcs()[1];
|
||||
expect(newServe).toBeDefined();
|
||||
expect(newServe.kill).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('kills an unresponsive resident before replacing it', async () => {
|
||||
const first = mod.listOpencodeModelVariants({ cwd: '/a' });
|
||||
await vi.advanceTimersByTimeAsync(300);
|
||||
await first;
|
||||
const firstServe = serveProcs()[0];
|
||||
|
||||
const fetchMock = vi.mocked(fetch);
|
||||
fetchMock.mockRejectedValueOnce(new Error('server unavailable'));
|
||||
const second = mod.listOpencodeModelVariants({ cwd: '/a' });
|
||||
await vi.advanceTimersByTimeAsync(300);
|
||||
await second;
|
||||
|
||||
expect(firstServe.kill).toHaveBeenCalled();
|
||||
expect(serveProcs().length).toBe(2);
|
||||
});
|
||||
|
||||
it('does not coalesce concurrent calls for different cwds', async () => {
|
||||
const first = mod.listOpencodeModelVariants({ cwd: '/a' });
|
||||
const second = mod.listOpencodeModelVariants({ cwd: '/b' });
|
||||
await vi.advanceTimersByTimeAsync(300);
|
||||
const [r1, r2] = await Promise.all([first, second]);
|
||||
expect(r1.success).toBe(true);
|
||||
expect(r2.success).toBe(true);
|
||||
// One serve per cwd — the two requests must not share a catalog.
|
||||
expect(serveProcs().length).toBe(2);
|
||||
// The loser of the resident slot must not leak: the replaced serve is
|
||||
// killed once the second spawn takes over.
|
||||
expect(serveProcs()[0].kill).toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('registers an exit hook that kills the resident serve', async () => {
|
||||
const exitSpy = vi.spyOn(process, 'on');
|
||||
const first = mod.listOpencodeModelVariants();
|
||||
await vi.advanceTimersByTimeAsync(300);
|
||||
await first;
|
||||
const calls = exitSpy.mock.calls as unknown as Array<[string, (...args: unknown[]) => void]>;
|
||||
const hook = calls.find(([event]) => event === 'exit')?.[1];
|
||||
expect(hook).toBeDefined();
|
||||
const residentServe = serveProcs()[0];
|
||||
hook?.();
|
||||
expect(residentServe.kill).toHaveBeenCalled();
|
||||
exitSpy.mockRestore();
|
||||
});
|
||||
});
|
||||
|
||||
describe('extractOpencodeAcpServers', () => {
|
||||
it('extracts port and cwd pairs', () => {
|
||||
const ps = [
|
||||
'opencode acp --cwd /home/user --port 42495 --hostname 127.0.0.1',
|
||||
'opencode acp --port 38971'
|
||||
].join('\n');
|
||||
expect(extractOpencodeAcpServers(ps)).toEqual([
|
||||
{ port: 42495, cwd: '/home/user' },
|
||||
{ port: 38971, cwd: null }
|
||||
]);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,272 @@
|
||||
import { isObject } from '@hapi/protocol';
|
||||
import type { OpencodeModelVariantsResponse } from '@hapi/protocol/apiTypes';
|
||||
|
||||
export type ListOpencodeModelVariantsResponse = OpencodeModelVariantsResponse;
|
||||
|
||||
const PROBE_TIMEOUT_MS = 10_000;
|
||||
const POLL_INTERVAL_MS = 300;
|
||||
|
||||
/**
|
||||
* Extract a `{ 'providerId/modelId': string[] }` map of model variants from an
|
||||
* OpenCode server `GET /provider` payload. Only models with at least one
|
||||
* variant are collected; malformed entries are skipped defensively.
|
||||
*/
|
||||
export function parseOpencodeProviderVariants(payload: unknown): Record<string, string[]> {
|
||||
if (!isObject(payload) || !Array.isArray(payload.all)) {
|
||||
return {};
|
||||
}
|
||||
|
||||
const out: Record<string, string[]> = {};
|
||||
for (const provider of payload.all) {
|
||||
if (!isObject(provider) || !isObject(provider.models)) {
|
||||
continue;
|
||||
}
|
||||
for (const [, rawModel] of Object.entries(provider.models)) {
|
||||
if (!isObject(rawModel)) continue;
|
||||
const modelId = typeof rawModel.id === 'string' && rawModel.id.trim() ? rawModel.id : '';
|
||||
const providerID = typeof rawModel.providerID === 'string' ? rawModel.providerID : '';
|
||||
if (!providerID || !modelId) continue;
|
||||
if (!isObject(rawModel.variants)) continue;
|
||||
const variants = Object.keys(rawModel.variants).filter((key) => key.length > 0);
|
||||
if (variants.length === 0) continue;
|
||||
out[`${providerID}/${modelId}`] = variants;
|
||||
}
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse `ps` args output for live `opencode acp --port <n>` servers. Pure so
|
||||
* the process-scan path is testable without a real process list.
|
||||
*/
|
||||
export function extractOpencodeAcpPorts(psArgsOutput: string): number[] {
|
||||
return extractOpencodeAcpServers(psArgsOutput).map((server) => server.port);
|
||||
}
|
||||
|
||||
/**
|
||||
* Extract port + cwd from live `opencode acp --cwd <path> --port <n>` process
|
||||
* args. The cwd lets callers skip servers whose project-level opencode config
|
||||
* would produce a different provider catalog than the requesting directory.
|
||||
*/
|
||||
export function extractOpencodeAcpServers(psArgsOutput: string): Array<{ port: number; cwd: string | null }> {
|
||||
const servers = new Map<number, string | null>();
|
||||
for (const line of psArgsOutput.split('\n')) {
|
||||
if (!/\bopencode acp\b/.test(line)) continue;
|
||||
const portMatch = /--port (\d+)/.exec(line);
|
||||
if (!portMatch) continue;
|
||||
const port = Number(portMatch[1]);
|
||||
if (!Number.isInteger(port) || port <= 0 || port > 65535) continue;
|
||||
const cwdMatch = /--cwd (.+?)(?= --|$)/.exec(line);
|
||||
servers.set(port, cwdMatch ? cwdMatch[1].trim() : null);
|
||||
}
|
||||
return [...servers.entries()].map(([port, cwd]) => ({ port, cwd }));
|
||||
}
|
||||
|
||||
async function listRunningOpencodeServers(): Promise<Array<{ port: number; cwd: string | null }>> {
|
||||
try {
|
||||
const proc = Bun.spawn(['ps', '-eo', 'args='], { stdout: 'pipe', stderr: 'ignore' });
|
||||
const output = await new Response(proc.stdout).text();
|
||||
await proc.exited;
|
||||
return extractOpencodeAcpServers(output);
|
||||
} catch {
|
||||
return [];
|
||||
}
|
||||
}
|
||||
|
||||
async function fetchVariantsFromServer(port: number): Promise<Record<string, string[]> | null> {
|
||||
try {
|
||||
const response = await fetch(`http://127.0.0.1:${port}/provider`, { signal: AbortSignal.timeout(1000) });
|
||||
if (!response.ok) return null;
|
||||
return parseOpencodeProviderVariants(await response.json());
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
async function getEphemeralPort(): Promise<number> {
|
||||
const net = await import('node:net');
|
||||
return await new Promise((resolve, reject) => {
|
||||
const server = net.createServer();
|
||||
server.unref();
|
||||
server.on('error', reject);
|
||||
server.listen(0, '127.0.0.1', () => {
|
||||
const address = server.address();
|
||||
const port = typeof address === 'object' && address !== null ? address.port : null;
|
||||
server.close(() => {
|
||||
if (port !== null) {
|
||||
resolve(port);
|
||||
} else {
|
||||
reject(new Error('Failed to acquire ephemeral port'));
|
||||
}
|
||||
});
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Spawned-serve cache: the catalog only changes when the opencode binary or
|
||||
* user config changes, so the natural cache unit is the server process
|
||||
* lifetime, not an arbitrary TTL. A lazily spawned headless `opencode serve`
|
||||
* stays resident and answers subsequent calls instantly; an idle reaper kills
|
||||
* it after IDLE_REAP_MS without a request, and an `exit` hook kills it when
|
||||
* the CLI exits gracefully. The reaper timer is unref'd so it never keeps the
|
||||
* CLI process alive.
|
||||
*/
|
||||
type ResidentServe = { proc: ReturnType<typeof Bun.spawn>; port: number; cwd: string | null };
|
||||
let resident: ResidentServe | null = null;
|
||||
let idleReapTimer: ReturnType<typeof setTimeout> | null = null;
|
||||
// In-flight coalescing is keyed by cwd: concurrent requests for different
|
||||
// directories must not share a catalog (project-level opencode config differs).
|
||||
const inFlightByCwd = new Map<string | null, Promise<ListOpencodeModelVariantsResponse>>();
|
||||
|
||||
const IDLE_REAP_MS = 10 * 60 * 1000;
|
||||
|
||||
let exitCleanupRegistered = false;
|
||||
|
||||
/**
|
||||
* Kill the resident serve when the CLI exits gracefully (same pattern as
|
||||
* autoStartServer's hub cleanup). Signal ownership stays with the runner so
|
||||
* its asynchronous shutdown can finish before the process exits.
|
||||
*/
|
||||
function registerExitCleanup(): void {
|
||||
if (exitCleanupRegistered) return;
|
||||
exitCleanupRegistered = true;
|
||||
const killResident = () => {
|
||||
resident?.proc.kill();
|
||||
resident = null;
|
||||
};
|
||||
process.on('exit', killResident);
|
||||
}
|
||||
|
||||
function scheduleIdleReap(): void {
|
||||
if (idleReapTimer) {
|
||||
clearTimeout(idleReapTimer);
|
||||
}
|
||||
const target = resident;
|
||||
idleReapTimer = setTimeout(() => {
|
||||
// Only reap the serve this timer was scheduled for — a newer call may
|
||||
// have replaced the resident between scheduling and firing.
|
||||
if (resident === target && resident) {
|
||||
resident.proc.kill();
|
||||
resident = null;
|
||||
}
|
||||
idleReapTimer = null;
|
||||
}, IDLE_REAP_MS);
|
||||
idleReapTimer.unref?.();
|
||||
}
|
||||
|
||||
export function listOpencodeModelVariants(request?: { cwd?: string | null }): Promise<ListOpencodeModelVariantsResponse> {
|
||||
const cwd = request?.cwd ?? null;
|
||||
const existing = inFlightByCwd.get(cwd);
|
||||
if (existing) {
|
||||
return existing;
|
||||
}
|
||||
const promise = listOpencodeModelVariantsUncached(cwd).finally(() => {
|
||||
inFlightByCwd.delete(cwd);
|
||||
});
|
||||
inFlightByCwd.set(cwd, promise);
|
||||
return promise;
|
||||
}
|
||||
|
||||
async function listOpencodeModelVariantsUncached(cwd: string | null): Promise<ListOpencodeModelVariantsResponse> {
|
||||
// Prefer a live OpenCode session's server — its /provider catalog is
|
||||
// identical and answering from it skips any spawn entirely. Only servers
|
||||
// running in the same cwd are used: project-level opencode config can
|
||||
// override the provider catalog per directory.
|
||||
for (const server of await listRunningOpencodeServers()) {
|
||||
if (server.cwd !== cwd) continue;
|
||||
const variants = await fetchVariantsFromServer(server.port);
|
||||
if (variants) {
|
||||
return { success: true, variants };
|
||||
}
|
||||
}
|
||||
|
||||
// Resident serve from a previous call — still the same opencode install
|
||||
// and config, so the cached catalog is current by construction. A cwd
|
||||
// mismatch means a different project config: kill and respawn targeted.
|
||||
if (resident) {
|
||||
if (resident.cwd !== cwd) {
|
||||
resident.proc.kill();
|
||||
resident = null;
|
||||
} else {
|
||||
const variants = await fetchVariantsFromServer(resident.port);
|
||||
if (variants) {
|
||||
scheduleIdleReap();
|
||||
return { success: true, variants };
|
||||
}
|
||||
// Server died (e.g. reaped externally) — fall through and respawn.
|
||||
resident.proc.kill();
|
||||
resident = null;
|
||||
}
|
||||
}
|
||||
|
||||
const spawned = await spawnServeWithCatalog(cwd);
|
||||
if (!spawned.success) {
|
||||
return spawned;
|
||||
}
|
||||
// A concurrent different-cwd call may have installed its own resident in
|
||||
// parallel — it is no longer referenced by anyone once we overwrite it.
|
||||
// (Read through an explicit type: TS narrows the module singleton to null
|
||||
// on this path, but a concurrent call may have assigned it.)
|
||||
const previousResident = resident as ResidentServe | null;
|
||||
if (previousResident) {
|
||||
previousResident.proc.kill();
|
||||
}
|
||||
resident = { proc: spawned.proc, port: spawned.port, cwd };
|
||||
registerExitCleanup();
|
||||
scheduleIdleReap();
|
||||
return { success: true, variants: spawned.variants };
|
||||
}
|
||||
|
||||
async function spawnServeWithCatalog(cwd: string | null): Promise<
|
||||
{ success: false; error: string } | { success: true; proc: ReturnType<typeof Bun.spawn>; port: number; variants: Record<string, string[]> }
|
||||
> {
|
||||
let port: number;
|
||||
try {
|
||||
port = await getEphemeralPort();
|
||||
} catch {
|
||||
return { success: false, error: 'Failed to acquire ephemeral port' };
|
||||
}
|
||||
|
||||
let proc: ReturnType<typeof Bun.spawn> | null = null;
|
||||
try {
|
||||
proc = Bun.spawn(['opencode', 'serve', '--port', String(port)], {
|
||||
stdout: 'ignore',
|
||||
stderr: 'ignore',
|
||||
...(cwd ? { cwd } : {}),
|
||||
});
|
||||
|
||||
const deadline = Date.now() + PROBE_TIMEOUT_MS;
|
||||
let payload: unknown = null;
|
||||
while (Date.now() < deadline) {
|
||||
await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
|
||||
// Bail out early instead of burning the full deadline when serve
|
||||
// died on bind (e.g. the ephemeral port was claimed in the gap).
|
||||
if (proc.exitCode !== null) {
|
||||
break;
|
||||
}
|
||||
try {
|
||||
const response = await fetch(`http://127.0.0.1:${port}/provider`, { signal: AbortSignal.timeout(2000) });
|
||||
if (response.ok) {
|
||||
payload = await response.json();
|
||||
break;
|
||||
}
|
||||
} catch {
|
||||
// Server not ready yet — keep polling until the deadline.
|
||||
}
|
||||
}
|
||||
|
||||
if (!payload || proc.exitCode !== null) {
|
||||
proc.kill();
|
||||
return { success: false, error: 'OpenCode provider catalog did not become available in time' };
|
||||
}
|
||||
|
||||
return { success: true, proc, port, variants: parseOpencodeProviderVariants(payload) };
|
||||
} catch (error) {
|
||||
proc?.kill();
|
||||
return {
|
||||
success: false,
|
||||
error: error instanceof Error ? error.message : 'Failed to list OpenCode model variants'
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -4,6 +4,7 @@ import { registerBashHandlers } from './handlers/bash'
|
||||
import { registerCodexModelHandlers } from './handlers/codexModels'
|
||||
import { registerCursorModelHandlers } from './handlers/cursorModels'
|
||||
import { registerOpencodeModelHandlers } from './handlers/opencodeModels'
|
||||
import { registerOpencodeModelVariantsHandlers } from './handlers/opencodeModelVariants'
|
||||
import { registerPiModelHandlers } from './handlers/piModels'
|
||||
import { registerGrokModelHandlers } from './handlers/grokModels'
|
||||
import { registerCopilotModelHandlers } from './handlers/copilotModels'
|
||||
@@ -22,6 +23,7 @@ export function registerCommonHandlers(rpcHandlerManager: RpcHandlerManager, wor
|
||||
registerCodexModelHandlers(rpcHandlerManager)
|
||||
registerCursorModelHandlers(rpcHandlerManager)
|
||||
registerOpencodeModelHandlers(rpcHandlerManager)
|
||||
registerOpencodeModelVariantsHandlers(rpcHandlerManager)
|
||||
registerPiModelHandlers(rpcHandlerManager)
|
||||
registerGrokModelHandlers(rpcHandlerManager)
|
||||
registerCopilotModelHandlers(rpcHandlerManager)
|
||||
|
||||
Reference in New Issue
Block a user