@getpaseo/server 0.1.97-beta.3 → 0.1.98

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

@@ -1,4 +1,5 @@
 import net from "node:net";
+import os from "node:os";
 import { findExecutable } from "../../../../executable-resolution/executable-resolution.js";
 import { spawnProcess } from "../../../../utils/spawn.js";
 import { terminateWithTreeKill } from "../../../../utils/tree-kill.js";
@@ -6,19 +7,30 @@ import { createProviderEnvSpec, resolveProviderCommandPrefix, } from "../../prov
 const OPENCODE_SERVER_GRACEFUL_SHUTDOWN_TIMEOUT_MS = 5000;
 const OPENCODE_SERVER_FORCE_SHUTDOWN_TIMEOUT_MS = 1000;
 export class OpenCodeServerManager {
-    constructor(logger, runtimeSettings) {
+    constructor(options) {
         this.currentServer = null;
         this.retiredServers = new Set();
         this.startPromise = null;
         this.forcedRefreshPromise = null;
-        this.logger = logger;
-        this.runtimeSettings = runtimeSettings;
-        this.runtimeSettingsKey = JSON.stringify(runtimeSettings ?? {});
+        this.logger = options.logger;
+        this.runtimeSettings = options.runtimeSettings;
+        this.runtimeSettingsKey = JSON.stringify(this.runtimeSettings ?? {});
+        this.managedProcesses = options.managedProcesses;
+        this.terminateProcess = options.terminateProcess ?? terminateWithTreeKill;
+        this.portAllocator = options.portAllocator ?? findAvailablePort;
+        this.resolveCommandPrefix =
+            options.resolveCommandPrefix ??
+                (() => resolveProviderCommandPrefix(this.runtimeSettings?.command, resolveOpenCodeBinary));
+        this.spawnServerProcess = options.spawnServerProcess ?? spawnProcess;
     }
-    static getInstance(logger, runtimeSettings) {
+    static getInstance(logger, runtimeSettings, options = {}) {
         const nextSettingsKey = JSON.stringify(runtimeSettings ?? {});
         if (!OpenCodeServerManager.instance) {
-            OpenCodeServerManager.instance = new OpenCodeServerManager(logger, runtimeSettings);
+            OpenCodeServerManager.instance = new OpenCodeServerManager({
+                logger,
+                runtimeSettings,
+                ...options,
+            });
             OpenCodeServerManager.registerExitHandler();
         }
         else if (OpenCodeServerManager.instance.runtimeSettingsKey !== nextSettingsKey) {
@@ -128,11 +140,14 @@ export class OpenCodeServerManager {
         return server;
     }
     async startServer(launchEnv) {
-        const port = await findAvailablePort();
+        const port = await this.portAllocator();
         const url = `http://127.0.0.1:${port}`;
-        const launchPrefix = await resolveProviderCommandPrefix(this.runtimeSettings?.command, resolveOpenCodeBinary);
+        const launchPrefix = await this.resolveCommandPrefix();
+        const serverArgs = [...launchPrefix.args, "serve", "--port", String(port)];
+        const serverCwd = os.homedir();
         return new Promise((resolve, reject) => {
-            const serverProcess = spawnProcess(launchPrefix.command, [...launchPrefix.args, "serve", "--port", String(port)], {
+            const serverProcess = this.spawnServerProcess(launchPrefix.command, serverArgs, {
+                cwd: serverCwd,
                 detached: process.platform !== "win32",
                 stdio: ["ignore", "pipe", "pipe"],
                 ...createProviderEnvSpec({
@@ -140,6 +155,12 @@ export class OpenCodeServerManager {
                     overlays: [launchEnv],
                 }),
             });
+            const managedProcessRecord = this.recordManagedServerProcess({
+                process: serverProcess,
+                command: launchPrefix.command,
+                args: serverArgs,
+                port,
+            });
             let started = false;
             let stderrBuffer = "";
             let stdoutBuffer = "";
@@ -174,13 +195,17 @@ export class OpenCodeServerManager {
                 if (output.includes("listening on") && !started) {
                     started = true;
                     clearTimeout(timeout);
-                    resolve({
-                        process: serverProcess,
-                        port,
-                        url,
-                        refCount: 0,
-                        retired: false,
-                    });
+                    void (async () => {
+                        const record = await managedProcessRecord;
+                        resolve({
+                            process: serverProcess,
+                            port,
+                            url,
+                            refCount: 0,
+                            retired: false,
+                            ...(record ? { managedProcessId: record.id } : {}),
+                        });
+                    })();
                 }
             });
             serverProcess.stderr?.on("data", (data) => {
@@ -190,10 +215,12 @@ export class OpenCodeServerManager {
             });
             serverProcess.on("error", (error) => {
                 clearTimeout(timeout);
+                this.removeManagedProcessRecordWhenResolved(managedProcessRecord);
                 const headline = error instanceof Error ? error.message : String(error);
                 reject(new Error(buildStartupErrorMessage(headline)));
             });
             serverProcess.on("exit", (code) => {
+                this.removeManagedProcessRecordWhenResolved(managedProcessRecord);
                 if (!started) {
                     clearTimeout(timeout);
                     reject(new Error(buildStartupErrorMessage(`OpenCode server exited with code ${code}`)));
@@ -231,7 +258,7 @@ export class OpenCodeServerManager {
             (server.process.signalCode !== null && server.process.signalCode !== undefined)) {
             return;
         }
-        const result = await terminateWithTreeKill(server.process, {
+        const result = await this.terminateProcess(server.process, {
             gracefulTimeoutMs: OPENCODE_SERVER_GRACEFUL_SHUTDOWN_TIMEOUT_MS,
             forceTimeoutMs: OPENCODE_SERVER_FORCE_SHUTDOWN_TIMEOUT_MS,
             onForceSignal: () => {
@@ -241,6 +268,45 @@ export class OpenCodeServerManager {
         if (result === "kill-timeout") {
             this.logger.warn({ timeoutMs: OPENCODE_SERVER_FORCE_SHUTDOWN_TIMEOUT_MS }, "OpenCode server did not report exit after SIGKILL");
         }
+        if (server.managedProcessId) {
+            await this.removeManagedProcessId(server.managedProcessId);
+            server.managedProcessId = undefined;
+        }
+    }
+    async recordManagedServerProcess(options) {
+        const pid = options.process.pid;
+        if (!this.managedProcesses || typeof pid !== "number" || pid <= 0) {
+            return null;
+        }
+        try {
+            return await this.managedProcesses.record({
+                owner: { provider: "opencode", kind: "helper-server" },
+                pid,
+                command: options.command,
+                args: options.args,
+                metadata: { port: options.port },
+            });
+        }
+        catch (error) {
+            this.logger.warn({ err: error, pid, port: options.port }, "Failed to record OpenCode helper process");
+            return null;
+        }
+    }
+    removeManagedProcessRecordWhenResolved(record) {
+        void record.then((resolved) => {
+            if (resolved) {
+                return this.removeManagedProcessId(resolved.id);
+            }
+            return undefined;
+        });
+    }
+    async removeManagedProcessId(id) {
+        try {
+            await this.managedProcesses?.remove(id);
+        }
+        catch (error) {
+            this.logger.warn({ err: error, id }, "Failed to remove OpenCode helper process record");
+        }
     }
 }
 OpenCodeServerManager.instance = null;

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

@@ -4,6 +4,7 @@ import { type AgentCapabilityFlags, type AgentClient, type AgentCreateSessionOpt
 import { isDefaultAgentCreateConfigUnattended } from "../create-agent-mode.js";
 import { type ProviderRuntimeSettings } from "../provider-launch-config.js";
 import { type OpenCodeRuntime } from "./opencode/runtime.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;
 type OpenCodeAgentConfig = AgentSessionConfig & {
@@ -103,6 +104,7 @@ export declare const __openCodeInternals: {
 };
 interface OpenCodeAgentClientDeps {
     runtime?: OpenCodeRuntime;
+    managedProcesses?: ManagedProcessRegistry;
 }
 export declare class OpenCodeAgentClient implements AgentClient {
     readonly provider: "opencode";

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

@@ -11,7 +11,7 @@ import { execCommand } from "../../../utils/spawn.js";
 import { buildToolCallDisplayModel } from "@getpaseo/protocol/tool-call-display";
 import { mapOpencodeToolCall } from "./opencode/tool-call-mapper.js";
 import { OpenCodeServerManager } from "./opencode/server-manager.js";
-import { formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnosticError, buildBinaryDiagnosticRows, toDiagnosticErrorMessage, } from "./diagnostic-utils.js";
+import { formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnosticError, buildBinaryDiagnosticRows, buildCommandResolutionDiagnosticRows, toDiagnosticErrorMessage, } from "./diagnostic-utils.js";
 import { runProviderTurn } from "./provider-runner.js";
 import { renderPromptAttachmentAsText } from "../prompt-attachments.js";
 import { composeSystemPromptParts } from "../system-prompt.js";
@@ -398,14 +398,14 @@ function mapOpenCodeAgentToMode(agent) {
     };
 }
 function mergeOpenCodeModes(discoveredModes) {
-    const modesById = new Map(DEFAULT_MODES.map((mode) => [mode.id, mode]));
-    for (const mode of discoveredModes) {
-        if (mode.id === OPENCODE_LEGACY_FULL_ACCESS_MODE_ID) {
-            continue;
-        }
-        modesById.set(mode.id, mode);
+    const filtered = discoveredModes.filter((mode) => mode.id !== OPENCODE_LEGACY_FULL_ACCESS_MODE_ID);
+    // When discovery returns results, trust them exactly — don't inject hardcoded
+    // defaults that the user may have intentionally disabled in their OpenCode config.
+    // Fall back to DEFAULT_MODES only when discovery produced nothing.
+    if (filtered.length > 0) {
+        return sortOpenCodeModes(filtered);
     }
-    return sortOpenCodeModes(Array.from(modesById.values()));
+    return sortOpenCodeModes([...DEFAULT_MODES]);
 }
 function sortOpenCodeModes(modes) {
     const order = new Map(DEFAULT_MODES.map((mode, index) => [mode.id, index]));
@@ -880,7 +880,9 @@ export class OpenCodeAgentClient {
         this.runtimeSettings = runtimeSettings;
         this.runtime =
             deps.runtime ??
-                new ProductionOpenCodeRuntime(OpenCodeServerManager.getInstance(this.logger, runtimeSettings));
+                new ProductionOpenCodeRuntime(OpenCodeServerManager.getInstance(this.logger, runtimeSettings, {
+                    managedProcesses: deps.managedProcesses,
+                }));
     }
     async createSession(config, launchContext, options) {
         const openCodeConfig = this.assertConfig(config);
@@ -1146,6 +1148,9 @@ export class OpenCodeAgentClient {
             }
             return {
                 diagnostic: formatProviderDiagnostic("OpenCode", [
+                    ...(await buildCommandResolutionDiagnosticRows(launch, {
+                        knownBinaryNames: ["opencode"],
+                    })),
                     ...(await buildBinaryDiagnosticRows(launch, availability)),
                     { label: "Server", value: serverStatus },
                     { label: "Auth", value: authValue },

package/dist/server/server/agent/providers/pi/agent.d.ts

@@ -6,11 +6,7 @@ import type { PiRuntime, PiRuntimeSession } from "./runtime.js";
 import type { PiSessionState } from "./rpc-types.js";
 export declare const PiProviderParamsSchema: z.ZodObject<{
     sessionDir: z.ZodOptional<z.ZodString>;
-}, "strict", z.ZodTypeAny, {
-    sessionDir?: string | undefined;
-}, {
-    sessionDir?: string | undefined;
-}>;
+}, z.core.$strict>;
 interface PiRpcAgentClientOptions {
     logger: Logger;
     runtimeSettings?: ProviderRuntimeSettings;

package/dist/server/server/agent/providers/pi/agent.js

@@ -3,12 +3,13 @@ import { existsSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
 import { join } from "node:path";
 import { z } from "zod";
+import { withTimeout } from "../../../../utils/promise-timeout.js";
 import { importSessionFromPersistence } from "../../provider-session-import.js";
 import { runProviderTurn } from "../provider-runner.js";
 import { checkProviderLaunchAvailable, resolveProviderLaunch, } from "../../provider-launch-config.js";
 import { renderPromptAttachmentAsText } from "../../prompt-attachments.js";
 import { composeSystemPromptParts } from "../../system-prompt.js";
-import { buildBinaryDiagnosticRows, formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnosticError, toDiagnosticErrorMessage, } from "../diagnostic-utils.js";
+import { buildBinaryDiagnosticRows, buildCommandResolutionDiagnosticRows, formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnosticError, toDiagnosticErrorMessage, } from "../diagnostic-utils.js";
 import { getUserMessageText, streamPiHistory, } from "./history-mapper.js";
 import { PiCliRuntime } from "./cli-runtime.js";
 import { revertPiConversation } from "./rewind.js";
@@ -1567,24 +1568,33 @@ export class PiRpcAgentClient {
         });
     }
     async isAvailable() {
-        const launch = await this.resolvePiLaunch();
-        const availability = await checkProviderLaunchAvailable(launch);
-        if (!availability.available) {
-            return false;
-        }
-        const runtimeSession = await this.runtime.startSession({ cwd: homedir() }).catch(() => null);
-        if (!runtimeSession) {
-            return false;
-        }
         try {
-            return (await runtimeSession.getAvailableModels()).length > 0;
+            return await withTimeout((async () => {
+                const launch = await this.resolvePiLaunch();
+                const availability = await checkProviderLaunchAvailable(launch);
+                if (!availability.available) {
+                    return false;
+                }
+                const runtimeSession = await this.runtime
+                    .startSession({ cwd: homedir() })
+                    .catch(() => null);
+                if (!runtimeSession) {
+                    return false;
+                }
+                try {
+                    return (await runtimeSession.getAvailableModels()).length > 0;
+                }
+                catch {
+                    return false;
+                }
+                finally {
+                    await runtimeSession.close().catch(() => undefined);
+                }
+            })(), 2000, "Pi availability check timed out");
         }
         catch {
             return false;
         }
-        finally {
-            await runtimeSession.close().catch(() => undefined);
-        }
     }
     async getDiagnostic() {
         try {
@@ -1633,6 +1643,9 @@ export class PiRpcAgentClient {
             }
             return {
                 diagnostic: formatProviderDiagnostic("Pi", [
+                    ...(await buildCommandResolutionDiagnosticRows(launch, {
+                        knownBinaryNames: [launch.command],
+                    })),
                     ...(await buildBinaryDiagnosticRows(launch, availability)),
                     { label: "Configured providers", value: configuredProvidersValue },
                     {