@getpaseo/server 0.1.99 → 0.1.101

package/dist/server/server/agent/providers/opencode/server-manager.d.ts

@@ -16,10 +16,10 @@ export interface OpenCodeServerManagerLike {
         port: number;
         url: string;
     }>;
-    acquire(options: {
-        force: boolean;
-        env?: Record<string, string>;
-    }): Promise<OpenCodeServerAcquisition>;
+    acquireCurrent(): Promise<OpenCodeServerAcquisition>;
+    acquireNew(): Promise<OpenCodeServerAcquisition>;
+    acquireDedicated(env: Record<string, string>): Promise<OpenCodeServerAcquisition>;
+    shutdown(): Promise<void>;
 }
 export interface OpenCodeServerGeneration {
     process: ChildProcess;
@@ -27,7 +27,11 @@ export interface OpenCodeServerGeneration {
     url: string;
     refCount: number;
     retired: boolean;
+    ready: Promise<void>;
     managedProcessId?: string;
+    managedProcessRecord?: Promise<{
+        id: string;
+    } | null>;
 }
 export type OpenCodePortAllocator = () => Promise<number>;
 export type OpenCodeCommandPrefixResolver = () => Promise<{
@@ -50,7 +54,7 @@ export declare class OpenCodeServerManager implements OpenCodeServerManagerLike
     private currentServer;
     private retiredServers;
     private startPromise;
-    private forcedRefreshPromise;
+    private newServerPromise;
     private readonly logger;
     private readonly runtimeSettings?;
     private readonly runtimeSettingsKey;
@@ -66,21 +70,20 @@ export declare class OpenCodeServerManager implements OpenCodeServerManagerLike
         port: number;
         url: string;
     }>;
-    acquire(options: {
-        force: boolean;
-        env?: Record<string, string>;
-    }): Promise<OpenCodeServerAcquisition>;
+    acquireCurrent(): Promise<OpenCodeServerAcquisition>;
+    acquireNew(): Promise<OpenCodeServerAcquisition>;
+    acquireDedicated(env: Record<string, string>): Promise<OpenCodeServerAcquisition>;
     private acquireServer;
-    private getForcedRefreshServer;
+    private getNewServer;
     private getCurrentServer;
     private rotateCurrentServer;
-    private startDedicatedServer;
     private startServer;
     shutdown(): Promise<void>;
     private cleanupRetiredServers;
     private killServer;
     private recordManagedServerProcess;
     private removeManagedProcessRecordWhenResolved;
+    private removeManagedServerRecord;
     private removeManagedProcessId;
 }
 //# sourceMappingURL=server-manager.d.ts.map

package/dist/server/server/agent/providers/opencode/server-manager.js

@@ -11,7 +11,7 @@ export class OpenCodeServerManager {
         this.currentServer = null;
         this.retiredServers = new Set();
         this.startPromise = null;
-        this.forcedRefreshPromise = null;
+        this.newServerPromise = null;
         this.logger = options.logger;
         this.runtimeSettings = options.runtimeSettings;
         this.runtimeSettingsKey = JSON.stringify(this.runtimeSettings ?? {});
@@ -55,20 +55,32 @@ export class OpenCodeServerManager {
         process.on("SIGINT", cleanup);
     }
     async ensureRunning() {
-        const acquisition = await this.acquire({ force: false });
+        const acquisition = await this.acquireCurrent();
         acquisition.release();
         return acquisition.server;
     }
-    async acquire(options) {
-        if (options.env) {
-            const server = await this.startDedicatedServer(options.env);
-            return this.acquireServer(server);
-        }
-        const server = options.force
-            ? await this.getForcedRefreshServer()
-            : await this.getCurrentServer();
+    async acquireCurrent() {
+        const server = await this.getCurrentServer();
+        return this.acquireServer(server);
+    }
+    async acquireNew() {
+        const server = await this.getNewServer();
         return this.acquireServer(server);
     }
+    async acquireDedicated(env) {
+        const server = await this.startServer(env);
+        server.retired = true;
+        this.retiredServers.add(server);
+        const acquisition = this.acquireServer(server);
+        try {
+            await server.ready;
+            return acquisition;
+        }
+        catch (error) {
+            acquisition.release();
+            throw error;
+        }
+    }
     acquireServer(server) {
         server.refCount += 1;
         let released = false;
@@ -84,38 +96,52 @@ export class OpenCodeServerManager {
             },
         };
     }
-    async getForcedRefreshServer() {
-        if (this.forcedRefreshPromise) {
-            return this.forcedRefreshPromise;
+    async getNewServer() {
+        if (this.newServerPromise) {
+            return this.newServerPromise;
         }
-        this.forcedRefreshPromise = Promise.resolve()
+        this.newServerPromise = Promise.resolve()
             .then(async () => {
             await this.rotateCurrentServer();
-            return this.getCurrentServer();
+            const server = await this.startServer();
+            if (!server.retired) {
+                this.currentServer = server;
+            }
+            await server.ready;
+            return server;
         })
             .finally(() => {
-            this.forcedRefreshPromise = null;
+            this.newServerPromise = null;
         });
-        return this.forcedRefreshPromise;
+        return this.newServerPromise;
     }
     async getCurrentServer() {
+        if (this.newServerPromise) {
+            return this.newServerPromise;
+        }
         if (this.startPromise) {
-            return this.startPromise;
+            const server = await this.startPromise;
+            await server.ready;
+            return server;
         }
         if (this.currentServer && !this.currentServer.process.killed) {
+            await this.currentServer.ready;
             return this.currentServer;
         }
-        this.startPromise = this.startServer();
-        try {
-            const result = await this.startPromise;
-            if (!result.retired) {
-                this.currentServer = result;
+        this.startPromise = this.startServer().then((server) => {
+            if (!server.retired) {
+                this.currentServer = server;
             }
-            return result;
-        }
-        finally {
-            this.startPromise = null;
-        }
+            return server;
+        });
+        const currentStart = this.startPromise;
+        const result = await currentStart.finally(() => {
+            if (this.startPromise === currentStart) {
+                this.startPromise = null;
+            }
+        });
+        await result.ready;
+        return result;
     }
     async rotateCurrentServer() {
         const existing = this.currentServer;
@@ -133,79 +159,89 @@ export class OpenCodeServerManager {
             this.cleanupRetiredServers();
         }
     }
-    async startDedicatedServer(env) {
-        const server = await this.startServer(env);
-        server.retired = true;
-        this.retiredServers.add(server);
-        return server;
-    }
     async startServer(launchEnv) {
         const port = await this.portAllocator();
         const url = `http://127.0.0.1:${port}`;
         const launchPrefix = await this.resolveCommandPrefix();
         const serverArgs = [...launchPrefix.args, "serve", "--port", String(port)];
         const serverCwd = os.homedir();
-        return new Promise((resolve, reject) => {
-            const serverProcess = this.spawnServerProcess(launchPrefix.command, serverArgs, {
-                cwd: serverCwd,
-                detached: process.platform !== "win32",
-                stdio: ["ignore", "pipe", "pipe"],
-                ...createProviderEnvSpec({
-                    runtimeSettings: this.runtimeSettings,
-                    overlays: [launchEnv],
-                }),
-            });
-            const managedProcessRecord = this.recordManagedServerProcess({
-                process: serverProcess,
-                command: launchPrefix.command,
-                args: serverArgs,
-                port,
-            });
-            let started = false;
-            let stderrBuffer = "";
-            let stdoutBuffer = "";
-            const STARTUP_BUFFER_CAP = 8192;
-            const appendCapped = (current, chunk) => {
-                if (current.length >= STARTUP_BUFFER_CAP) {
-                    return current;
-                }
-                const remaining = STARTUP_BUFFER_CAP - current.length;
-                return current + chunk.slice(0, remaining);
-            };
-            const buildStartupErrorMessage = (headline) => {
-                const sections = [headline];
-                const stderrTrimmed = stderrBuffer.trim();
-                if (stderrTrimmed.length > 0) {
-                    sections.push(`stderr: ${stderrTrimmed}`);
-                }
-                const stdoutTrimmed = stdoutBuffer.trim();
-                if (stdoutTrimmed.length > 0) {
-                    sections.push(`stdout: ${stdoutTrimmed}`);
+        const serverProcess = this.spawnServerProcess(launchPrefix.command, serverArgs, {
+            cwd: serverCwd,
+            detached: process.platform !== "win32",
+            stdio: ["ignore", "pipe", "pipe"],
+            ...createProviderEnvSpec({
+                runtimeSettings: this.runtimeSettings,
+                overlays: [launchEnv],
+            }),
+        });
+        const managedProcessRecord = this.recordManagedServerProcess({
+            process: serverProcess,
+            command: launchPrefix.command,
+            args: serverArgs,
+            port,
+        });
+        const server = {
+            process: serverProcess,
+            port,
+            url,
+            refCount: 0,
+            retired: false,
+            ready: Promise.resolve(),
+            managedProcessRecord,
+        };
+        void managedProcessRecord.then((record) => {
+            if (record && server.managedProcessRecord === managedProcessRecord) {
+                server.managedProcessId = record.id;
+            }
+            return undefined;
+        });
+        let started = false;
+        let settled = false;
+        let stderrBuffer = "";
+        let stdoutBuffer = "";
+        const STARTUP_BUFFER_CAP = 8192;
+        const appendCapped = (current, chunk) => {
+            if (current.length >= STARTUP_BUFFER_CAP) {
+                return current;
+            }
+            const remaining = STARTUP_BUFFER_CAP - current.length;
+            return current + chunk.slice(0, remaining);
+        };
+        const buildStartupErrorMessage = (headline) => {
+            const sections = [headline];
+            const stderrTrimmed = stderrBuffer.trim();
+            if (stderrTrimmed.length > 0) {
+                sections.push(`stderr: ${stderrTrimmed}`);
+            }
+            const stdoutTrimmed = stdoutBuffer.trim();
+            if (stdoutTrimmed.length > 0) {
+                sections.push(`stdout: ${stdoutTrimmed}`);
+            }
+            return sections.join("\n");
+        };
+        const ready = new Promise((resolve, reject) => {
+            let timeout;
+            const failStartup = (error) => {
+                if (settled) {
+                    return;
                 }
-                return sections.join("\n");
+                settled = true;
+                clearTimeout(timeout);
+                reject(error);
             };
-            const timeout = setTimeout(() => {
+            timeout = setTimeout(() => {
                 if (!started) {
-                    reject(new Error(buildStartupErrorMessage("OpenCode server startup timeout")));
+                    failStartup(new Error(buildStartupErrorMessage("OpenCode server startup timeout")));
                 }
             }, 30000);
             serverProcess.stdout?.on("data", (data) => {
                 const output = data.toString();
                 stdoutBuffer = appendCapped(stdoutBuffer, output);
-                if (output.includes("listening on") && !started) {
+                if (output.includes("listening on") && !settled) {
                     started = true;
+                    settled = true;
                     clearTimeout(timeout);
-                    void (async () => {
-                        const record = await managedProcessRecord;
-                        resolve({
-                            process: serverProcess,
-                            port,
-                            url,
-                            refCount: 0,
-                            retired: false,
-                            ...(record ? { managedProcessId: record.id } : {}),
-                        });
-                    })();
+                    resolve();
                 }
             });
             serverProcess.stderr?.on("data", (data) => {
@@ -214,16 +250,13 @@ export class OpenCodeServerManager {
                 this.logger.error({ stderr: output.trim() }, "OpenCode server stderr");
             });
             serverProcess.on("error", (error) => {
-                clearTimeout(timeout);
-                this.removeManagedProcessRecordWhenResolved(managedProcessRecord);
                 const headline = error instanceof Error ? error.message : String(error);
-                reject(new Error(buildStartupErrorMessage(headline)));
+                failStartup(new Error(buildStartupErrorMessage(headline)));
             });
             serverProcess.on("exit", (code) => {
-                this.removeManagedProcessRecordWhenResolved(managedProcessRecord);
+                this.removeManagedServerRecord(server);
                 if (!started) {
-                    clearTimeout(timeout);
-                    reject(new Error(buildStartupErrorMessage(`OpenCode server exited with code ${code}`)));
+                    failStartup(new Error(buildStartupErrorMessage(`OpenCode server exited with code ${code}`)));
                 }
                 if (this.currentServer?.process === serverProcess) {
                     this.currentServer = null;
@@ -235,6 +268,15 @@ export class OpenCodeServerManager {
                 }
             });
         });
+        server.ready = ready.catch(async (error) => {
+            await this.killServer(server);
+            if (this.currentServer === server) {
+                this.currentServer = null;
+            }
+            this.retiredServers.delete(server);
+            throw error;
+        });
+        return server;
     }
     async shutdown() {
         const servers = [
@@ -271,6 +313,10 @@ export class OpenCodeServerManager {
         if (server.managedProcessId) {
             await this.removeManagedProcessId(server.managedProcessId);
             server.managedProcessId = undefined;
+            server.managedProcessRecord = undefined;
+        }
+        else {
+            this.removeManagedServerRecord(server);
         }
     }
     async recordManagedServerProcess(options) {
@@ -300,6 +346,18 @@ export class OpenCodeServerManager {
             return undefined;
         });
     }
+    removeManagedServerRecord(server) {
+        const record = server.managedProcessRecord;
+        server.managedProcessRecord = undefined;
+        if (server.managedProcessId) {
+            void this.removeManagedProcessId(server.managedProcessId);
+            server.managedProcessId = undefined;
+            return;
+        }
+        if (record) {
+            this.removeManagedProcessRecordWhenResolved(record);
+        }
+    }
     async removeManagedProcessId(id) {
         try {
             await this.managedProcesses?.remove(id);

package/dist/server/server/agent/providers/opencode/test-server-manager.d.ts

@@ -1,6 +1,6 @@
 import type { OpenCodeServerAcquisition, OpenCodeServerManagerLike } from "./server-manager.js";
 export interface TestOpenCodeServerAcquisition {
-    force: boolean;
+    kind: "current" | "new" | "dedicated";
     env?: Record<string, string>;
     released: boolean;
 }
@@ -15,10 +15,11 @@ export declare class TestOpenCodeServerManager implements OpenCodeServerManagerL
         port: number;
         url: string;
     }>;
-    acquire(options: {
-        force: boolean;
-        env?: Record<string, string>;
-    }): Promise<OpenCodeServerAcquisition>;
+    acquireCurrent(): Promise<OpenCodeServerAcquisition>;
+    acquireNew(): Promise<OpenCodeServerAcquisition>;
+    acquireDedicated(env: Record<string, string>): Promise<OpenCodeServerAcquisition>;
+    private recordAcquisition;
+    shutdown(): Promise<void>;
 }
 export declare function createTestOpenCodeServerManager(): TestOpenCodeServerManager;
 //# sourceMappingURL=test-server-manager.d.ts.map

package/dist/server/server/agent/providers/opencode/test-server-manager.js

@@ -8,11 +8,20 @@ export class TestOpenCodeServerManager {
         this.ensureRunningCount += 1;
         return this.server;
     }
-    async acquire(options) {
+    async acquireCurrent() {
+        return this.recordAcquisition({ kind: "current" });
+    }
+    async acquireNew() {
+        return this.recordAcquisition({ kind: "new" });
+    }
+    async acquireDedicated(env) {
+        return this.recordAcquisition({ kind: "dedicated", env });
+    }
+    recordAcquisition(input) {
         const acquisition = {
-            force: options.force,
-            env: options.env,
+            kind: input.kind,
             released: false,
+            ...(input.env ? { env: input.env } : {}),
         };
         this.acquisitions.push(acquisition);
         return {
@@ -22,6 +31,7 @@ export class TestOpenCodeServerManager {
             },
         };
     }
+    async shutdown() { }
 }
 export function createTestOpenCodeServerManager() {
     return new TestOpenCodeServerManager();

package/dist/server/server/agent/providers/opencode/test-utils/{test-opencode-runtime.d.ts → test-opencode-harness.d.ts}

@@ -1,12 +1,12 @@
 import type { OpencodeClient } from "@opencode-ai/sdk/v2/client";
-import type { OpenCodeRuntime, OpenCodeServerAcquisition } from "../runtime.js";
+import type { OpenCodeServerAcquisition, OpenCodeServerManagerLike } from "../server-manager.js";
 interface OpenCodeResponse {
     data?: unknown;
     error?: unknown;
 }
-export declare class TestOpenCodeRuntime implements OpenCodeRuntime {
+export declare class TestOpenCodeHarness implements OpenCodeServerManagerLike {
     readonly acquisitions: Array<{
-        force: boolean;
+        kind: "current" | "new" | "dedicated";
         env?: Record<string, string>;
         releaseCount: number;
     }>;
@@ -20,18 +20,18 @@ export declare class TestOpenCodeRuntime implements OpenCodeRuntime {
         url: string;
     };
     enqueueClient(client: TestOpenCodeClient): void;
-    acquireServer(options: {
-        force: boolean;
-        env?: Record<string, string>;
-    }): Promise<OpenCodeServerAcquisition>;
-    ensureServerRunning(): Promise<{
+    acquireCurrent(): Promise<OpenCodeServerAcquisition>;
+    acquireNew(): Promise<OpenCodeServerAcquisition>;
+    acquireDedicated(env: Record<string, string>): Promise<OpenCodeServerAcquisition>;
+    private recordAcquisition;
+    ensureRunning(): Promise<{
         port: number;
         url: string;
     }>;
-    createClient(options: {
+    readonly createClient: (options: {
         baseUrl: string;
         directory: string;
-    }): OpencodeClient;
+    }) => OpencodeClient;
     shutdown(): Promise<void>;
 }
 export declare class TestOpenCodeClient {
@@ -89,4 +89,4 @@ export declare class TestOpenCodeClient {
 export declare function createEventStream(events: unknown[]): AsyncGenerator<unknown>;
 export declare function idleEvent(): unknown;
 export {};
-//# sourceMappingURL=test-opencode-runtime.d.ts.map
+//# sourceMappingURL=test-opencode-harness.d.ts.map

package/dist/server/server/agent/providers/opencode/test-utils/{test-opencode-runtime.js → test-opencode-harness.js}

@@ -1,15 +1,33 @@
-export class TestOpenCodeRuntime {
+export class TestOpenCodeHarness {
     constructor() {
         this.acquisitions = [];
         this.clientCreations = [];
         this.clients = [];
         this.server = { port: 1234, url: "http://127.0.0.1:1234" };
+        this.createClient = (options) => {
+            this.clientCreations.push(options);
+            const client = this.clients.shift() ?? new TestOpenCodeClient();
+            return client.asSdkClient();
+        };
     }
     enqueueClient(client) {
         this.clients.push(client);
     }
-    async acquireServer(options) {
-        const acquisition = { force: options.force, env: options.env, releaseCount: 0 };
+    async acquireCurrent() {
+        return this.recordAcquisition({ kind: "current" });
+    }
+    async acquireNew() {
+        return this.recordAcquisition({ kind: "new" });
+    }
+    async acquireDedicated(env) {
+        return this.recordAcquisition({ kind: "dedicated", env });
+    }
+    recordAcquisition(input) {
+        const acquisition = {
+            kind: input.kind,
+            releaseCount: 0,
+            ...(input.env ? { env: input.env } : {}),
+        };
         this.acquisitions.push(acquisition);
         return {
             server: this.server,
@@ -18,14 +36,9 @@ export class TestOpenCodeRuntime {
             },
         };
     }
-    async ensureServerRunning() {
+    async ensureRunning() {
         return this.server;
     }
-    createClient(options) {
-        this.clientCreations.push(options);
-        const client = this.clients.shift() ?? new TestOpenCodeClient();
-        return client.asSdkClient();
-    }
     async shutdown() { }
 }
 export class TestOpenCodeClient {
@@ -244,4 +257,4 @@ export function idleEvent() {
         properties: { sessionID: "session-1" },
     };
 }
-//# sourceMappingURL=test-opencode-runtime.js.map
+//# sourceMappingURL=test-opencode-harness.js.map

package/dist/server/server/agent/providers/opencode-agent.d.ts

@@ -3,7 +3,7 @@ import type { Logger } from "pino";
 import { type AgentCapabilityFlags, type AgentClient, type AgentCreateSessionOptions, type AgentFeature, type AgentLaunchContext, type AgentMode, type AgentModelDefinition, type AgentPermissionRequest, type AgentPermissionResponse, type AgentPersistenceHandle, type AgentPromptInput, type AgentRunOptions, type AgentRunResult, type AgentRuntimeInfo, type AgentSession, type AgentSessionConfig, type AgentSlashCommand, type AgentStreamEvent, type AgentTimelineItem, type AgentUsage, type FetchCatalogOptions, type ImportableProviderSession, type ImportProviderSessionContext, type ImportProviderSessionInput, type ListImportableSessionsOptions, type ResolveAgentCreateConfigInput, type ResolveAgentCreateConfigResult, type ProviderCatalog, type ToolCallTimelineItem } from "../agent-sdk-types.js";
 import { isDefaultAgentCreateConfigUnattended } from "../create-agent-mode.js";
 import { type ProviderRuntimeSettings } from "../provider-launch-config.js";
-import { type OpenCodeRuntime } from "./opencode/runtime.js";
+import { type OpenCodeServerManagerLike } from "./opencode/server-manager.js";
 import type { ManagedProcessRegistry } from "../../managed-processes/managed-processes.js";
 declare function resolveOpenCodeCreateConfig(input: ResolveAgentCreateConfigInput): ResolveAgentCreateConfigResult;
 declare function isOpenCodeCreateConfigUnattended(input: Parameters<typeof isDefaultAgentCreateConfigUnattended>[0]): boolean;
@@ -103,15 +103,21 @@ export declare const __openCodeInternals: {
     readonly OpenCodeAgentSession: typeof OpenCodeAgentSession;
 };
 interface OpenCodeAgentClientDeps {
-    runtime?: OpenCodeRuntime;
+    serverManager?: OpenCodeServerManagerLike;
+    createClient?: OpenCodeClientFactory;
     managedProcesses?: ManagedProcessRegistry;
 }
+type OpenCodeClientFactory = (options: {
+    baseUrl: string;
+    directory: string;
+}) => OpencodeClient;
 export declare class OpenCodeAgentClient implements AgentClient {
     readonly provider: "opencode";
     readonly capabilities: AgentCapabilityFlags;
     readonly resolveCreateConfig: typeof resolveOpenCodeCreateConfig;
     readonly isCreateConfigUnattended: typeof isOpenCodeCreateConfigUnattended;
-    private readonly runtime;
+    private readonly serverManager;
+    private readonly createOpenCodeClient;
     private readonly logger;
     private readonly runtimeSettings?;
     private readonly modelContextWindows;