@getpaseo/server 0.1.70 → 0.1.72

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

@@ -1,17 +1,18 @@
+import { readdir, readFile } from "node:fs/promises";
 import { homedir } from "node:os";
-import { createOpencodeClient, } from "@opencode-ai/sdk/v2/client";
-import net from "node:net";
-import { z } from "zod";
-import { createProviderEnvSpec, resolveProviderCommandPrefix, } from "../provider-launch-config.js";
+import path from "node:path";
 import { findExecutable, isCommandAvailable } from "../../../utils/executable.js";
-import { terminateWithTreeKill } from "../../../utils/tree-kill.js";
+import { z } from "zod";
+import { createProviderEnvSpec } from "../provider-launch-config.js";
 import { withTimeout } from "../../../utils/promise-timeout.js";
-import { execCommand, spawnProcess } from "../../../utils/spawn.js";
+import { execCommand } from "../../../utils/spawn.js";
 import { buildToolCallDisplayModel } from "../../../shared/tool-call-display.js";
 import { mapOpencodeToolCall } from "./opencode/tool-call-mapper.js";
+import { OpenCodeServerManager } from "./opencode/server-manager.js";
 import { formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnosticError, resolveBinaryVersion, toDiagnosticErrorMessage, } from "./diagnostic-utils.js";
 import { runProviderTurn } from "./provider-runner.js";
 import { renderPromptAttachmentAsText } from "../prompt-attachments.js";
+import { createSdkOpenCodeClient, } from "./opencode/runtime.js";
 const OPENCODE_CAPABILITIES = {
     supportsStreaming: true,
     supportsSessionPersistence: true,
@@ -22,6 +23,7 @@ const OPENCODE_CAPABILITIES = {
 };
 const OPENCODE_BUILD_MODE_ID = "build";
 const OPENCODE_FULL_ACCESS_MODE_ID = "full-access";
+const OPENCODE_STORAGE_SESSION_LIMIT = 200;
 const DEFAULT_MODES = [
     {
         id: OPENCODE_BUILD_MODE_ID,
@@ -39,10 +41,46 @@ const DEFAULT_MODES = [
         description: "Automatically approves all tool permission prompts for the session",
     },
 ];
+const OpenCodeStoredSessionSchema = z
+    .object({
+    id: z.string().min(1),
+    directory: z.string().min(1),
+    title: z.string().nullable().optional(),
+    time: z
+        .object({
+        created: z.number().optional(),
+        updated: z.number().optional(),
+    })
+        .optional(),
+})
+    .passthrough();
+const OpenCodeStoredMessageSchema = z
+    .object({
+    id: z.string().min(1),
+    sessionID: z.string().min(1),
+    role: z.string().optional(),
+    time: z
+        .object({
+        created: z.number().optional(),
+        completed: z.number().optional(),
+    })
+        .optional(),
+})
+    .passthrough();
+const OpenCodeStoredPartSchema = z
+    .object({
+    type: z.string().optional(),
+    text: z.string().optional(),
+    time: z
+        .object({
+        start: z.number().optional(),
+        end: z.number().optional(),
+    })
+        .optional(),
+})
+    .passthrough();
 const MCP_ALREADY_PRESENT_ERROR_TOKENS = ["already", "exists", "connected"];
 const OPENCODE_PROVIDER_LIST_TIMEOUT_MS = 30000;
-const OPENCODE_SERVER_GRACEFUL_SHUTDOWN_TIMEOUT_MS = 5000;
-const OPENCODE_SERVER_FORCE_SHUTDOWN_TIMEOUT_MS = 1000;
 const OPENCODE_HANDLED_BUILTIN_SLASH_COMMANDS = [
     { name: "compact", description: "Compact the current session", argumentHint: "" },
     { name: "summarize", description: "Compact the current session", argumentHint: "" },
@@ -121,13 +159,6 @@ const OpencodeToolPartToTimelineItemSchema = OpencodeToolPartTimelineEnvelopeSch
     output: part.output,
     error: part.error,
 }));
-async function resolveOpenCodeBinary() {
-    const found = await findExecutable("opencode");
-    if (found) {
-        return found;
-    }
-    throw new Error("OpenCode binary not found. Install OpenCode (https://github.com/opencode-ai/opencode) and ensure it is available in your shell PATH.");
-}
 function toOpenCodeMcpConfig(config) {
     if (config.type === "stdio") {
         return {
@@ -237,22 +268,6 @@ function isAlreadyPresentMcpError(error) {
     const normalized = toDiagnosticErrorMessage(error).toLowerCase();
     return MCP_ALREADY_PRESENT_ERROR_TOKENS.some((token) => normalized.includes(token));
 }
-async function findAvailablePort() {
-    return new Promise((resolve, reject) => {
-        const server = net.createServer();
-        server.listen(0, () => {
-            const address = server.address();
-            if (address && typeof address === "object") {
-                const port = address.port;
-                server.close(() => resolve(port));
-            }
-            else {
-                server.close(() => reject(new Error("Failed to get port")));
-            }
-        });
-        server.on("error", reject);
-    });
-}
 function resolvePartDedupeKey(part, partType) {
     if (part.id.trim().length > 0) {
         return `${partType}:${part.id}`;
@@ -485,6 +500,133 @@ function buildOpenCodePromptParts(prompt) {
     }
     return output;
 }
+function resolveOpenCodeStorageRoot() {
+    const xdgDataHome = process.env.XDG_DATA_HOME;
+    const dataHome = typeof xdgDataHome === "string" && xdgDataHome.trim().length > 0
+        ? xdgDataHome
+        : path.join(homedir(), ".local", "share");
+    return path.join(dataHome, "opencode", "storage");
+}
+async function collectOpenCodePersistedAgentsFromStorage(storageRoot, options) {
+    const sessions = await readOpenCodeStoredSessions(path.join(storageRoot, "session"));
+    const limit = options?.limit ?? OPENCODE_STORAGE_SESSION_LIMIT;
+    const candidates = sessions
+        .filter((session) => !options?.cwd || session.directory === options.cwd)
+        .sort((left, right) => getOpenCodeSessionTimestamp(right) - getOpenCodeSessionTimestamp(left))
+        .slice(0, limit);
+    return await Promise.all(candidates.map((session) => buildOpenCodePersistedAgentDescriptor(storageRoot, session)));
+}
+async function readOpenCodeStoredSessions(sessionRoot) {
+    const files = await findJsonFiles(sessionRoot);
+    const sessions = [];
+    for (const file of files) {
+        const parsed = await readJsonFile(file, OpenCodeStoredSessionSchema);
+        if (parsed) {
+            sessions.push(parsed);
+        }
+    }
+    return sessions;
+}
+async function buildOpenCodePersistedAgentDescriptor(storageRoot, session) {
+    const timeline = await readOpenCodeSessionTimeline(storageRoot, session.id);
+    return {
+        provider: "opencode",
+        sessionId: session.id,
+        cwd: session.directory,
+        title: normalizeOpenCodeSessionTitle(session.title),
+        lastActivityAt: new Date(getOpenCodeSessionTimestamp(session)),
+        persistence: {
+            provider: "opencode",
+            sessionId: session.id,
+            nativeHandle: session.id,
+            metadata: {
+                provider: "opencode",
+                cwd: session.directory,
+                title: normalizeOpenCodeSessionTitle(session.title),
+            },
+        },
+        timeline,
+    };
+}
+async function readOpenCodeSessionTimeline(storageRoot, sessionId) {
+    const messageRoot = path.join(storageRoot, "message", sessionId);
+    const messageFiles = await findJsonFiles(messageRoot);
+    const messages = [];
+    for (const file of messageFiles) {
+        const parsed = await readJsonFile(file, OpenCodeStoredMessageSchema);
+        if (parsed?.sessionID === sessionId) {
+            messages.push(parsed);
+        }
+    }
+    const timeline = [];
+    for (const message of messages.sort((left, right) => getOpenCodeMessageTimestamp(left) - getOpenCodeMessageTimestamp(right))) {
+        const text = await readOpenCodeMessageText(storageRoot, message.id);
+        if (!text) {
+            continue;
+        }
+        if (message.role === "user") {
+            timeline.push({ type: "user_message", text, messageId: message.id });
+        }
+        else if (message.role === "assistant") {
+            timeline.push({ type: "assistant_message", text });
+        }
+    }
+    return timeline;
+}
+async function readOpenCodeMessageText(storageRoot, messageId) {
+    const partRoot = path.join(storageRoot, "part", messageId);
+    const partFiles = await findJsonFiles(partRoot);
+    const parts = [];
+    for (const file of partFiles) {
+        const parsed = await readJsonFile(file, OpenCodeStoredPartSchema);
+        if (parsed?.type === "text" && typeof parsed.text === "string") {
+            parts.push(parsed);
+        }
+    }
+    return parts
+        .sort((left, right) => getOpenCodePartTimestamp(left) - getOpenCodePartTimestamp(right))
+        .map((part) => part.text?.trim() ?? "")
+        .filter(Boolean)
+        .join("\n\n");
+}
+async function findJsonFiles(root) {
+    let entries;
+    try {
+        entries = await readdir(root, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const files = await Promise.all(entries.map(async (entry) => {
+        const entryPath = path.join(root, entry.name);
+        if (entry.isDirectory()) {
+            return findJsonFiles(entryPath);
+        }
+        return entry.isFile() && entry.name.endsWith(".json") ? [entryPath] : [];
+    }));
+    return files.flat();
+}
+async function readJsonFile(file, schema) {
+    try {
+        return schema.parse(JSON.parse(await readFile(file, "utf8")));
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeOpenCodeSessionTitle(title) {
+    const normalized = title?.trim();
+    return normalized ? normalized : null;
+}
+function getOpenCodeSessionTimestamp(session) {
+    return session.time?.updated ?? session.time?.created ?? 0;
+}
+function getOpenCodeMessageTimestamp(message) {
+    return message.time?.created ?? message.time?.completed ?? 0;
+}
+function getOpenCodePartTimestamp(part) {
+    return part.time?.start ?? part.time?.end ?? 0;
+}
 export const __openCodeInternals = {
     buildOpenCodePromptParts,
     buildOpenCodeModelContextWindowLookup,
@@ -502,243 +644,40 @@ export const __openCodeInternals = {
         return OpenCodeAgentSession;
     },
 };
-export class OpenCodeServerManager {
-    constructor(logger, runtimeSettings) {
-        this.currentServer = null;
-        this.retiredServers = new Set();
-        this.startPromise = null;
-        this.forcedRefreshPromise = null;
-        this.logger = logger;
-        this.runtimeSettings = runtimeSettings;
-        this.runtimeSettingsKey = JSON.stringify(runtimeSettings ?? {});
+class ProductionOpenCodeRuntime {
+    constructor(serverManager) {
+        this.serverManager = serverManager;
     }
-    static getInstance(logger, runtimeSettings) {
-        const nextSettingsKey = JSON.stringify(runtimeSettings ?? {});
-        if (!OpenCodeServerManager.instance) {
-            OpenCodeServerManager.instance = new OpenCodeServerManager(logger, runtimeSettings);
-            OpenCodeServerManager.registerExitHandler();
-        }
-        else if (OpenCodeServerManager.instance.runtimeSettingsKey !== nextSettingsKey) {
-            logger.warn({
-                existingRuntimeSettings: OpenCodeServerManager.instance.runtimeSettingsKey,
-                requestedRuntimeSettings: nextSettingsKey,
-            }, "OpenCode server manager already initialized with different runtime settings");
-        }
-        return OpenCodeServerManager.instance;
+    async acquireServer(options) {
+        return this.serverManager.acquire(options);
     }
-    static registerExitHandler() {
-        if (OpenCodeServerManager.exitHandlerRegistered) {
-            return;
-        }
-        OpenCodeServerManager.exitHandlerRegistered = true;
-        const cleanup = () => {
-            const instance = OpenCodeServerManager.instance;
-            void instance?.shutdown();
-        };
-        process.on("exit", cleanup);
-        process.on("SIGTERM", cleanup);
-        process.on("SIGINT", cleanup);
-    }
-    async ensureRunning() {
-        const acquisition = await this.acquire({ force: false });
-        acquisition.release();
-        return acquisition.server;
-    }
-    async acquire(options) {
-        const server = options.force
-            ? await this.getForcedRefreshServer()
-            : await this.getCurrentServer();
-        server.refCount += 1;
-        let released = false;
-        return {
-            server: { port: server.port, url: server.url },
-            release: () => {
-                if (released) {
-                    return;
-                }
-                released = true;
-                server.refCount -= 1;
-                this.cleanupRetiredServers();
-            },
-        };
+    async ensureServerRunning() {
+        return this.serverManager.ensureRunning();
     }
-    async getForcedRefreshServer() {
-        if (this.forcedRefreshPromise) {
-            return this.forcedRefreshPromise;
-        }
-        this.forcedRefreshPromise = Promise.resolve()
-            .then(async () => {
-            await this.rotateCurrentServer();
-            return this.getCurrentServer();
-        })
-            .finally(() => {
-            this.forcedRefreshPromise = null;
-        });
-        return this.forcedRefreshPromise;
-    }
-    async getCurrentServer() {
-        if (this.startPromise) {
-            return this.startPromise;
-        }
-        if (this.currentServer && !this.currentServer.process.killed) {
-            return this.currentServer;
-        }
-        this.startPromise = this.startServer();
-        try {
-            const result = await this.startPromise;
-            if (!result.retired) {
-                this.currentServer = result;
-            }
-            return result;
-        }
-        finally {
-            this.startPromise = null;
-        }
-    }
-    async rotateCurrentServer() {
-        const existing = this.currentServer;
-        if (existing) {
-            existing.retired = true;
-            this.retiredServers.add(existing);
-            this.currentServer = null;
-            this.cleanupRetiredServers();
-        }
-        if (this.startPromise) {
-            const pending = await this.startPromise;
-            pending.retired = true;
-            this.retiredServers.add(pending);
-            this.currentServer = null;
-            this.cleanupRetiredServers();
-        }
-    }
-    async startServer() {
-        const port = await findAvailablePort();
-        const url = `http://127.0.0.1:${port}`;
-        const launchPrefix = await resolveProviderCommandPrefix(this.runtimeSettings?.command, resolveOpenCodeBinary);
-        return new Promise((resolve, reject) => {
-            const serverProcess = spawnProcess(launchPrefix.command, [...launchPrefix.args, "serve", "--port", String(port)], {
-                detached: process.platform !== "win32",
-                stdio: ["ignore", "pipe", "pipe"],
-                ...createProviderEnvSpec({ runtimeSettings: this.runtimeSettings }),
-            });
-            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}`);
-                }
-                return sections.join("\n");
-            };
-            const timeout = setTimeout(() => {
-                if (!started) {
-                    reject(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) {
-                    started = true;
-                    clearTimeout(timeout);
-                    resolve({
-                        process: serverProcess,
-                        port,
-                        url,
-                        refCount: 0,
-                        retired: false,
-                    });
-                }
-            });
-            serverProcess.stderr?.on("data", (data) => {
-                const output = data.toString();
-                stderrBuffer = appendCapped(stderrBuffer, output);
-                this.logger.error({ stderr: output.trim() }, "OpenCode server stderr");
-            });
-            serverProcess.on("error", (error) => {
-                clearTimeout(timeout);
-                const headline = error instanceof Error ? error.message : String(error);
-                reject(new Error(buildStartupErrorMessage(headline)));
-            });
-            serverProcess.on("exit", (code) => {
-                if (!started) {
-                    clearTimeout(timeout);
-                    reject(new Error(buildStartupErrorMessage(`OpenCode server exited with code ${code}`)));
-                }
-                if (this.currentServer?.process === serverProcess) {
-                    this.currentServer = null;
-                }
-                for (const retired of Array.from(this.retiredServers)) {
-                    if (retired.process === serverProcess) {
-                        this.retiredServers.delete(retired);
-                    }
-                }
-            });
-        });
+    createClient(options) {
+        return createSdkOpenCodeClient(options);
     }
     async shutdown() {
-        const servers = [
-            ...(this.currentServer ? [this.currentServer] : []),
-            ...Array.from(this.retiredServers),
-        ];
-        await Promise.all(servers.map((server) => this.killServer(server)));
-        this.currentServer = null;
-        this.retiredServers.clear();
-    }
-    cleanupRetiredServers() {
-        for (const server of Array.from(this.retiredServers)) {
-            if (server.refCount === 0) {
-                this.retiredServers.delete(server);
-                void this.killServer(server);
-            }
-        }
-    }
-    async killServer(server) {
-        if (server.process.killed) {
-            return;
-        }
-        const result = await terminateWithTreeKill(server.process, {
-            gracefulTimeoutMs: OPENCODE_SERVER_GRACEFUL_SHUTDOWN_TIMEOUT_MS,
-            forceTimeoutMs: OPENCODE_SERVER_FORCE_SHUTDOWN_TIMEOUT_MS,
-            onForceSignal: () => {
-                this.logger.warn({ timeoutMs: OPENCODE_SERVER_GRACEFUL_SHUTDOWN_TIMEOUT_MS }, "OpenCode server did not exit after SIGTERM; sending SIGKILL");
-            },
-        });
-        if (result === "kill-timeout") {
-            this.logger.warn({ timeoutMs: OPENCODE_SERVER_FORCE_SHUTDOWN_TIMEOUT_MS }, "OpenCode server did not report exit after SIGKILL");
-        }
+        await this.serverManager.shutdown();
     }
 }
-OpenCodeServerManager.instance = null;
-OpenCodeServerManager.exitHandlerRegistered = false;
 export class OpenCodeAgentClient {
-    constructor(logger, runtimeSettings) {
+    constructor(logger, runtimeSettings, storageRoot, deps = {}) {
         this.provider = "opencode";
         this.capabilities = OPENCODE_CAPABILITIES;
         this.modelContextWindows = new Map();
         this.logger = logger.child({ module: "agent", provider: "opencode" });
         this.runtimeSettings = runtimeSettings;
-        this.serverManager = OpenCodeServerManager.getInstance(this.logger, runtimeSettings);
+        this.storageRoot = storageRoot ?? resolveOpenCodeStorageRoot();
+        this.runtime =
+            deps.runtime ??
+                new ProductionOpenCodeRuntime(OpenCodeServerManager.getInstance(this.logger, runtimeSettings));
     }
     async createSession(config, _launchContext, options) {
         const openCodeConfig = this.assertConfig(config);
-        const acquisition = await this.serverManager.acquire({ force: false });
+        const acquisition = await this.runtime.acquireServer({ force: false });
         const { url } = acquisition.server;
-        const client = createOpencodeClient({
+        const client = this.runtime.createClient({
             baseUrl: url,
             directory: openCodeConfig.cwd,
         });
@@ -770,9 +709,9 @@ export class OpenCodeAgentClient {
             ...overrides,
         };
         const openCodeConfig = this.assertConfig(config);
-        const acquisition = await this.serverManager.acquire({ force: false });
+        const acquisition = await this.runtime.acquireServer({ force: false });
         const { url } = acquisition.server;
-        const client = createOpencodeClient({
+        const client = this.runtime.createClient({
             baseUrl: url,
             directory: openCodeConfig.cwd,
         });
@@ -786,9 +725,9 @@ export class OpenCodeAgentClient {
         }
     }
     async listModels(options) {
-        const acquisition = await this.serverManager.acquire({ force: options.force });
+        const acquisition = await this.runtime.acquireServer({ force: options.force });
         const { url } = acquisition.server;
-        const client = createOpencodeClient({
+        const client = this.runtime.createClient({
             baseUrl: url,
             directory: options.cwd,
         });
@@ -832,10 +771,10 @@ export class OpenCodeAgentClient {
         }
     }
     async listModes(options) {
-        const acquisition = await this.serverManager.acquire({ force: options.force });
+        const acquisition = await this.runtime.acquireServer({ force: options.force });
         const { url } = acquisition.server;
         const directory = options.cwd;
-        const client = createOpencodeClient({ baseUrl: url, directory });
+        const client = this.runtime.createClient({ baseUrl: url, directory });
         try {
             const response = await withTimeout(client.app.agents({ directory }), 10000, "OpenCode app.agents timed out after 10s");
             if (response.error || !response.data) {
@@ -854,9 +793,8 @@ export class OpenCodeAgentClient {
             acquisition.release();
         }
     }
-    async listPersistedAgents(_options) {
-        // TODO: Implement by listing sessions from OpenCode
-        return [];
+    async listPersistedAgents(options) {
+        return collectOpenCodePersistedAgentsFromStorage(this.storageRoot, options);
     }
     async isAvailable() {
         const command = this.runtimeSettings?.command;
@@ -873,7 +811,7 @@ export class OpenCodeAgentClient {
             let modelsValue = "Not checked";
             let status = formatDiagnosticStatus(available);
             try {
-                const { url } = await this.serverManager.ensureRunning();
+                const { url } = await this.runtime.ensureServerRunning();
                 serverStatus = `Running (${url})`;
             }
             catch (error) {