@otto-code/server 0.5.0

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

@@ -0,0 +1,2 @@
+export declare function resolveOpenCodeHomeDir(env?: NodeJS.ProcessEnv): string;
+//# sourceMappingURL=paths.d.ts.map

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

@@ -0,0 +1,7 @@
+import path from "node:path";
+import { resolveOttoHome } from "../../../otto-home.js";
+const OPENCODE_HOME_DIRNAME = "opencode-home";
+export function resolveOpenCodeHomeDir(env = process.env) {
+    return path.join(resolveOttoHome(env), OPENCODE_HOME_DIRNAME);
+}
+//# sourceMappingURL=paths.js.map

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

@@ -0,0 +1,18 @@
+export interface OpenCodeRewindClient {
+    session: {
+        revert(input: {
+            sessionID: string;
+            directory: string;
+            messageID: string;
+        }): Promise<{
+            error?: unknown;
+        }>;
+    };
+}
+export declare function revertOpenCodeConversationAndFiles(input: {
+    client: OpenCodeRewindClient;
+    sessionId: string;
+    cwd: string;
+    messageId: string;
+}): Promise<void>;
+//# sourceMappingURL=rewind.d.ts.map

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

@@ -0,0 +1,14 @@
+import { toDiagnosticErrorMessage } from "../diagnostic-utils.js";
+export async function revertOpenCodeConversationAndFiles(input) {
+    // OpenCode keeps unrevert available only until a later prompt triggers its cleanup,
+    // which permanently drops reverted messages. Otto v1 only exposes revert.
+    const response = await input.client.session.revert({
+        sessionID: input.sessionId,
+        directory: input.cwd,
+        messageID: input.messageId,
+    });
+    if (response.error) {
+        throw new Error(toDiagnosticErrorMessage(response.error));
+    }
+}
+//# sourceMappingURL=rewind.js.map

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

@@ -0,0 +1,91 @@
+import type { ChildProcess } from "node:child_process";
+import type { Logger } from "pino";
+import { type SpawnProcessOptions } from "../../../../utils/spawn.js";
+import { type ProcessTerminator } from "../../../../utils/tree-kill.js";
+import type { ManagedProcessRegistry } from "../../../managed-processes/managed-processes.js";
+import { type ProviderRuntimeSettings } from "../../provider-launch-config.js";
+export interface OpenCodeServerAcquisition {
+    server: {
+        port: number;
+        url: string;
+    };
+    release: () => void;
+}
+export interface OpenCodeServerManagerLike {
+    ensureRunning(): Promise<{
+        port: number;
+        url: string;
+    }>;
+    acquireCurrent(): Promise<OpenCodeServerAcquisition>;
+    acquireNew(): Promise<OpenCodeServerAcquisition>;
+    acquireDedicated(env: Record<string, string>): Promise<OpenCodeServerAcquisition>;
+    shutdown(): Promise<void>;
+}
+export interface OpenCodeServerGeneration {
+    process: ChildProcess;
+    port: number;
+    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<{
+    command: string;
+    args: string[];
+}>;
+export type OpenCodeServerProcessSpawner = (command: string, args: string[], options: SpawnProcessOptions) => ChildProcess;
+export interface OpenCodeServerManagerOptions {
+    logger: Logger;
+    runtimeSettings?: ProviderRuntimeSettings;
+    managedProcesses?: ManagedProcessRegistry;
+    terminateProcess?: ProcessTerminator;
+    portAllocator?: OpenCodePortAllocator;
+    resolveCommandPrefix?: OpenCodeCommandPrefixResolver;
+    resolveHomeDir?: () => string;
+    spawnServerProcess?: OpenCodeServerProcessSpawner;
+}
+export declare class OpenCodeServerManager implements OpenCodeServerManagerLike {
+    private static instance;
+    private static exitHandlerRegistered;
+    private currentServer;
+    private retiredServers;
+    private startPromise;
+    private newServerPromise;
+    private readonly logger;
+    private readonly runtimeSettings?;
+    private readonly runtimeSettingsKey;
+    private readonly managedProcesses?;
+    private readonly terminateProcess;
+    private readonly portAllocator;
+    private readonly resolveCommandPrefix;
+    private readonly resolveHomeDir;
+    private readonly spawnServerProcess;
+    constructor(options: OpenCodeServerManagerOptions);
+    static getInstance(logger: Logger, runtimeSettings?: ProviderRuntimeSettings, options?: Omit<OpenCodeServerManagerOptions, "logger" | "runtimeSettings">): OpenCodeServerManager;
+    private static registerExitHandler;
+    ensureRunning(): Promise<{
+        port: number;
+        url: string;
+    }>;
+    acquireCurrent(): Promise<OpenCodeServerAcquisition>;
+    acquireNew(): Promise<OpenCodeServerAcquisition>;
+    acquireDedicated(env: Record<string, string>): Promise<OpenCodeServerAcquisition>;
+    private acquireServer;
+    private getNewServer;
+    private getCurrentServer;
+    private rotateCurrentServer;
+    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

@@ -0,0 +1,425 @@
+import { mkdirSync } from "node:fs";
+import { stat } from "node:fs/promises";
+import net from "node:net";
+import path from "node:path";
+import { findExecutable } from "../../../../executable-resolution/executable-resolution.js";
+import { spawnProcess } from "../../../../utils/spawn.js";
+import { terminateWithTreeKill } from "../../../../utils/tree-kill.js";
+import { createProviderEnvSpec, resolveProviderCommandPrefix, } from "../../provider-launch-config.js";
+import { resolveOpenCodeHomeDir } from "./paths.js";
+const OPENCODE_SERVER_GRACEFUL_SHUTDOWN_TIMEOUT_MS = 5000;
+const OPENCODE_SERVER_FORCE_SHUTDOWN_TIMEOUT_MS = 1000;
+export class OpenCodeServerManager {
+    constructor(options) {
+        this.currentServer = null;
+        this.retiredServers = new Set();
+        this.startPromise = null;
+        this.newServerPromise = null;
+        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.resolveHomeDir = options.resolveHomeDir ?? resolveOpenCodeHomeDir;
+        this.spawnServerProcess = options.spawnServerProcess ?? spawnProcess;
+    }
+    static getInstance(logger, runtimeSettings, options = {}) {
+        const nextSettingsKey = JSON.stringify(runtimeSettings ?? {});
+        if (!OpenCodeServerManager.instance) {
+            OpenCodeServerManager.instance = new OpenCodeServerManager({
+                logger,
+                runtimeSettings,
+                ...options,
+            });
+            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;
+    }
+    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.acquireCurrent();
+        acquisition.release();
+        return acquisition.server;
+    }
+    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;
+        return {
+            server: { port: server.port, url: server.url },
+            release: () => {
+                if (released) {
+                    return;
+                }
+                released = true;
+                server.refCount -= 1;
+                this.cleanupRetiredServers();
+            },
+        };
+    }
+    async getNewServer() {
+        if (this.newServerPromise) {
+            return this.newServerPromise;
+        }
+        this.newServerPromise = Promise.resolve()
+            .then(async () => {
+            await this.rotateCurrentServer();
+            const server = await this.startServer();
+            if (!server.retired) {
+                this.currentServer = server;
+            }
+            await server.ready;
+            return server;
+        })
+            .finally(() => {
+            this.newServerPromise = null;
+        });
+        return this.newServerPromise;
+    }
+    async getCurrentServer() {
+        if (this.newServerPromise) {
+            return this.newServerPromise;
+        }
+        if (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().then((server) => {
+            if (!server.retired) {
+                this.currentServer = server;
+            }
+            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;
+        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(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)];
+        // Use a neutral OpenCode home as the server cwd. Launching from the user's
+        // home directory causes OpenCode to treat it as the default workspace and
+        // index the entire home tree.
+        const serverCwd = this.resolveHomeDir();
+        mkdirSync(serverCwd, { recursive: true });
+        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;
+                }
+                settled = true;
+                clearTimeout(timeout);
+                reject(error);
+            };
+            timeout = setTimeout(() => {
+                if (!started) {
+                    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") && !settled) {
+                    started = true;
+                    settled = true;
+                    clearTimeout(timeout);
+                    resolve();
+                }
+            });
+            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) => {
+                const headline = error instanceof Error ? error.message : String(error);
+                failStartup(new Error(buildStartupErrorMessage(headline)));
+            });
+            serverProcess.on("exit", (code) => {
+                this.removeManagedServerRecord(server);
+                if (!started) {
+                    failStartup(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);
+                    }
+                }
+            });
+        });
+        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 = [
+            ...(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.exitCode !== null && server.process.exitCode !== undefined) ||
+            (server.process.signalCode !== null && server.process.signalCode !== undefined)) {
+            return;
+        }
+        const result = await this.terminateProcess(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");
+        }
+        if (server.managedProcessId) {
+            await this.removeManagedProcessId(server.managedProcessId);
+            server.managedProcessId = undefined;
+            server.managedProcessRecord = undefined;
+        }
+        else {
+            this.removeManagedServerRecord(server);
+        }
+    }
+    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;
+        });
+    }
+    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);
+        }
+        catch (error) {
+            this.logger.warn({ err: error, id }, "Failed to remove OpenCode helper process record");
+        }
+    }
+}
+OpenCodeServerManager.instance = null;
+OpenCodeServerManager.exitHandlerRegistered = false;
+async function resolveOpenCodeBinary() {
+    const found = await findExecutable("opencode");
+    if (!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.");
+    }
+    if (process.platform === "win32" && path.extname(found).toLowerCase() === ".cmd") {
+        // Global npm: <prefix>/opencode.cmd → <prefix>/node_modules/opencode-ai/bin/opencode.exe
+        const globalCandidate = path.join(path.dirname(found), "node_modules", "opencode-ai", "bin", "opencode.exe");
+        if (await pathExists(globalCandidate))
+            return globalCandidate;
+        // Local/pnpm: <project>/node_modules/.bin/opencode.cmd → <project>/node_modules/opencode-ai/bin/opencode.exe
+        const localCandidate = path.join(path.dirname(found), "..", "opencode-ai", "bin", "opencode.exe");
+        if (await pathExists(localCandidate))
+            return localCandidate;
+        console.warn("[opencode-server] Found opencode.cmd but could not resolve the real opencode.exe. " +
+            "The process may not be properly terminated on exit. Path: %s", found);
+    }
+    return found;
+}
+async function pathExists(filePath) {
+    try {
+        await stat(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function findAvailablePort() {
+    return new Promise((resolve, reject) => {
+        const server = net.createServer();
+        server.listen(0, "127.0.0.1", () => {
+            const address = server.address();
+            server.close(() => {
+                if (typeof address === "object" && address) {
+                    resolve(address.port);
+                }
+                else {
+                    reject(new Error("Failed to allocate port"));
+                }
+            });
+        });
+        server.on("error", reject);
+    });
+}
+//# sourceMappingURL=server-manager.js.map

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

@@ -0,0 +1,25 @@
+import type { OpenCodeServerAcquisition, OpenCodeServerManagerLike } from "./server-manager.js";
+export interface TestOpenCodeServerAcquisition {
+    kind: "current" | "new" | "dedicated";
+    env?: Record<string, string>;
+    released: boolean;
+}
+export declare class TestOpenCodeServerManager implements OpenCodeServerManagerLike {
+    readonly acquisitions: TestOpenCodeServerAcquisition[];
+    readonly server: {
+        port: number;
+        url: string;
+    };
+    ensureRunningCount: number;
+    ensureRunning(): Promise<{
+        port: number;
+        url: string;
+    }>;
+    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

@@ -0,0 +1,39 @@
+export class TestOpenCodeServerManager {
+    constructor() {
+        this.acquisitions = [];
+        this.server = { port: 1234, url: "http://127.0.0.1:1234" };
+        this.ensureRunningCount = 0;
+    }
+    async ensureRunning() {
+        this.ensureRunningCount += 1;
+        return this.server;
+    }
+    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,
+            released: false,
+            ...(input.env ? { env: input.env } : {}),
+        };
+        this.acquisitions.push(acquisition);
+        return {
+            server: this.server,
+            release: () => {
+                acquisition.released = true;
+            },
+        };
+    }
+    async shutdown() { }
+}
+export function createTestOpenCodeServerManager() {
+    return new TestOpenCodeServerManager();
+}
+//# sourceMappingURL=test-server-manager.js.map