@getpaseo/server 0.1.101 → 0.1.102

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

@@ -16,6 +16,7 @@ export declare function createLoggedNdJsonStream(output: NodeWritableStream, inp
     logger: Logger;
     provider: string;
 }): ACPStream;
+export type ACPExtensionCommandsParser = (method: string, params: Record<string, unknown>) => AgentSlashCommand[] | null;
 interface ACPAgentClientOptions {
     provider: string;
     logger: Logger;
@@ -32,6 +33,7 @@ interface ACPAgentClientOptions {
     beforeModeWriter?: (context: ACPProviderModeWriterContext) => Promise<ACPBeforeModeWriteResult>;
     thinkingOptionWriter?: (connection: ClientSideConnection, sessionId: string, thinkingOptionId: string) => Promise<void>;
     capabilities?: AgentCapabilityFlags;
+    extensionCommandsParser?: ACPExtensionCommandsParser;
     waitForInitialCommands?: boolean;
     initialCommandsWaitTimeoutMs?: number;
     terminateProcess?: ProcessTerminator;
@@ -52,6 +54,7 @@ interface ACPAgentSessionOptions {
     beforeModeWriter?: (context: ACPProviderModeWriterContext) => Promise<ACPBeforeModeWriteResult>;
     thinkingOptionWriter?: (connection: ClientSideConnection, sessionId: string, thinkingOptionId: string) => Promise<void>;
     capabilities: AgentCapabilityFlags;
+    extensionCommandsParser?: ACPExtensionCommandsParser;
     handle?: AgentPersistenceHandle;
     agentId?: string;
     launchEnv?: Record<string, string>;
@@ -177,6 +180,7 @@ export declare class ACPAgentClient implements AgentClient {
     private readonly thinkingOptionWriter?;
     private readonly waitForInitialCommands;
     private readonly initialCommandsWaitTimeoutMs;
+    private readonly extensionCommandsParser?;
     protected readonly terminateProcess: ProcessTerminator;
     constructor(options: ACPAgentClientOptions);
     createSession(config: AgentSessionConfig, launchContext?: AgentLaunchContext): Promise<AgentSession>;
@@ -251,6 +255,7 @@ export declare class ACPAgentSession implements AgentSession, ACPClient {
     private commandsReadySettled;
     private waitForInitialCommands;
     private initialCommandsWaitTimeoutMs;
+    private readonly extensionCommandsParser?;
     private currentTurnUsage;
     private activeForegroundTurnId;
     private closed;
@@ -261,6 +266,13 @@ export declare class ACPAgentSession implements AgentSession, ACPClient {
     constructor(config: AgentSessionConfig, options: ACPAgentSessionOptions);
     get id(): string | null;
     initializeNewSession(): Promise<void>;
+    /**
+     * IMPORTANT: Some ACP providers (e.g., Devin CLI) require all three params
+     * (sessionId, cwd, mcpServers) to be present in session/load or
+     * unstable_resumeSession — even when mcpServers is an empty array — and
+     * return "Invalid params" if any are omitted. Never drop cwd or mcpServers
+     * from these calls regardless of capabilities.
+     */
     initializeResumedSession(): Promise<void>;
     run(prompt: AgentPromptInput, options?: AgentRunOptions): Promise<AgentRunResult>;
     startTurn(prompt: AgentPromptInput, options?: AgentRunOptions): Promise<{
@@ -292,6 +304,7 @@ export declare class ACPAgentSession implements AgentSession, ACPClient {
     requestPermission(params: RequestPermissionRequest): Promise<RequestPermissionResponse>;
     sessionUpdate(params: SessionNotification): Promise<void>;
     extNotification(method: string, params: Record<string, unknown>): Promise<void>;
+    private applyResolvedCommands;
     readTextFile(params: ReadTextFileRequest): Promise<{
         content: string;
     }>;

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

@@ -318,6 +318,7 @@ export class ACPAgentClient {
         this.thinkingOptionWriter = options.thinkingOptionWriter;
         this.waitForInitialCommands = options.waitForInitialCommands ?? false;
         this.initialCommandsWaitTimeoutMs = options.initialCommandsWaitTimeoutMs ?? 1500;
+        this.extensionCommandsParser = options.extensionCommandsParser;
     }
     async createSession(config, launchContext) {
         this.assertProvider(config);
@@ -339,6 +340,7 @@ export class ACPAgentClient {
             capabilities: this.capabilities,
             agentId: launchContext?.agentId,
             launchEnv: launchContext?.env,
+            extensionCommandsParser: this.extensionCommandsParser,
             waitForInitialCommands: this.waitForInitialCommands,
             initialCommandsWaitTimeoutMs: this.initialCommandsWaitTimeoutMs,
         });
@@ -379,6 +381,7 @@ export class ACPAgentClient {
             handle,
             agentId: launchContext?.agentId,
             launchEnv: launchContext?.env,
+            extensionCommandsParser: this.extensionCommandsParser,
             waitForInitialCommands: this.waitForInitialCommands,
             initialCommandsWaitTimeoutMs: this.initialCommandsWaitTimeoutMs,
         });
@@ -386,7 +389,7 @@ export class ACPAgentClient {
         return session;
     }
     async fetchCatalog(options) {
-        const { cwd } = options;
+        const cwd = options.scope === "global" ? homedir() : options.cwd;
         const timeoutMs = options.timeoutMs ?? ACP_CATALOG_TIMEOUT_MS;
         let probe = null;
         try {
@@ -784,6 +787,7 @@ export class ACPAgentSession {
         this.currentTitle = config.title ?? null;
         this.waitForInitialCommands = options.waitForInitialCommands ?? false;
         this.initialCommandsWaitTimeoutMs = options.initialCommandsWaitTimeoutMs ?? 1500;
+        this.extensionCommandsParser = options.extensionCommandsParser;
     }
     get id() {
         return this.sessionId;
@@ -802,6 +806,13 @@ export class ACPAgentSession {
         this.applySessionState(response);
         await this.applyConfiguredOverrides();
     }
+    /**
+     * IMPORTANT: Some ACP providers (e.g., Devin CLI) require all three params
+     * (sessionId, cwd, mcpServers) to be present in session/load or
+     * unstable_resumeSession — even when mcpServers is an empty array — and
+     * return "Invalid params" if any are omitted. Never drop cwd or mcpServers
+     * from these calls regardless of capabilities.
+     */
     async initializeResumedSession() {
         const handle = this.initialHandle;
         if (!handle) {
@@ -1408,6 +1419,31 @@ export class ACPAgentSession {
             method,
             rawEvent: params,
         }, "provider.acp.extension_notification");
+        const parsedCommands = this.extensionCommandsParser?.(method, params);
+        if (parsedCommands) {
+            this.applyResolvedCommands(parsedCommands, {
+                sessionId: typeof params.sessionId === "string" ? params.sessionId : undefined,
+            });
+        }
+    }
+    // Cache an asynchronously-delivered slash-command batch and unblock any
+    // listCommands() call that is waiting on the initial batch. Used when a
+    // provider supplies an extensionCommandsParser whose result arrives after
+    // session/new (e.g. via a vendor extension notification). The ready gate is
+    // always settled — even for an empty batch — so a provider that legitimately
+    // reports no commands does not leave listCommands() blocked for the full
+    // initial-commands timeout. An optional sessionId scopes the batch to this
+    // session; notifications addressed to a different session are ignored.
+    applyResolvedCommands(commands, options) {
+        if (options?.sessionId !== undefined &&
+            this.sessionId !== null &&
+            options.sessionId !== this.sessionId) {
+            return;
+        }
+        if (commands.length > 0) {
+            this.cachedCommands = commands;
+        }
+        this.settleCommandsReady();
     }
     async readTextFile(params) {
         const raw = await fs.readFile(params.path, "utf8");

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

@@ -22,6 +22,7 @@ import { getAgentStreamEventTurnId, } from "../../agent-sdk-types.js";
 import { importSessionFromPersistence } from "../../provider-session-import.js";
 import { checkProviderLaunchAvailable, createProviderEnv, createProviderEnvSpec, resolveProviderLaunch, } from "../../provider-launch-config.js";
 import { withTimeout } from "../../../../utils/promise-timeout.js";
+import { terminateWithTreeKill } from "../../../../utils/tree-kill.js";
 import { execCommand } from "../../../../utils/spawn.js";
 import { composeSystemPromptParts } from "../../system-prompt.js";
 const fsPromises = promises;
@@ -1289,6 +1290,13 @@ function readLegacyResultUsageTokens(usage) {
 function isClaudeSubagentToolName(name) {
     return name === "Task" || name === "Agent";
 }
+function readClaudeParentToolUseId(message) {
+    if (!("parent_tool_use_id" in message)) {
+        return null;
+    }
+    const parentToolUseId = message.parent_tool_use_id;
+    return typeof parentToolUseId === "string" && parentToolUseId.length > 0 ? parentToolUseId : null;
+}
 class ClaudeContextUsageState {
     constructor(initialContextWindowMaxTokens) {
         this.completedResultTurns = 0;
@@ -1414,6 +1422,7 @@ class ClaudeAgentSession {
         this.provider = "claude";
         this.capabilities = CLAUDE_CAPABILITIES;
         this.query = null;
+        this.childProcess = null;
         this.input = null;
         this.planResumeMode = null;
         this.availableModes = DEFAULT_MODES;
@@ -1887,6 +1896,19 @@ class ClaudeAgentSession {
         await this.awaitWithTimeout(this.query?.return?.(), "close query return");
         this.query = null;
         this.input = null;
+        // Terminate the entire process tree (claude + MCP children) to prevent
+        // orphan accumulation. The SDK's internal cleanup may only kill the
+        // direct child process.
+        if (this.childProcess) {
+            const result = await terminateWithTreeKill(this.childProcess, {
+                gracefulTimeoutMs: 2000,
+                forceTimeoutMs: 2000,
+            });
+            if (result === "kill-timeout") {
+                this.logger.warn({ pid: this.childProcess.pid, agentId: this.agentId }, "Claude process tree did not report exit after SIGKILL");
+            }
+            this.childProcess = null;
+        }
         if (this.persistSession === false && this.claudeSessionId) {
             // Claude Code currently ignores --no-session-persistence outside --print mode
             // (see `claude --help`), so the SDK's persistSession=false is silently dropped
@@ -2225,6 +2247,18 @@ class ClaudeAgentSession {
             catch {
                 /* ignore */
             }
+            // Tree-kill the old process tree now that the SDK has cleaned up.
+            // If we skip this, MCP children of the previous claude process can
+            // survive as orphans when the session spawns a replacement query.
+            if (this.childProcess) {
+                await terminateWithTreeKill(this.childProcess, {
+                    gracefulTimeoutMs: 2000,
+                    forceTimeoutMs: 2000,
+                }).catch(() => {
+                    /* process may already be dead */
+                });
+                this.childProcess = null;
+            }
         }
         // Preserve claudeSessionId across query recreation so buildOptions() passes
         // resume: sessionId and the new query continues the existing conversation.
@@ -2237,6 +2271,9 @@ class ClaudeAgentSession {
             runtimeSettings: this.runtimeSettings,
             launchEnv: this.launchEnv,
             queryFactory: this.queryFactory,
+            onChildProcess: (child) => {
+                this.childProcess = child;
+            },
         });
         const fastMode = this.resolveFastModeSetting();
         if (fastMode !== null) {
@@ -2809,17 +2846,19 @@ class ClaudeAgentSession {
             suppressAssistantText: true,
             suppressReasoning: true,
         });
-        const assistantTimelineEvents = this.timelineAssembler
-            .consume({
-            message,
-            runId: turnId,
-            messageIdHint,
-        })
-            .map((item) => ({
-            type: "timeline",
-            item,
-            provider: "claude",
-        }));
+        const assistantTimelineEvents = readClaudeParentToolUseId(message)
+            ? []
+            : this.timelineAssembler
+                .consume({
+                message,
+                runId: turnId,
+                messageIdHint,
+            })
+                .map((item) => ({
+                type: "timeline",
+                item,
+                provider: "claude",
+            }));
         return [...messageEvents, ...assistantTimelineEvents];
     }
     async handleMissingResumedConversation(message, activeQuery) {
@@ -2867,9 +2906,7 @@ class ClaudeAgentSession {
         }
     }
     translateMessageToEvents(message, options) {
-        const parentToolUseId = "parent_tool_use_id" in message
-            ? message.parent_tool_use_id
-            : null;
+        const parentToolUseId = readClaudeParentToolUseId(message);
         if (parentToolUseId) {
             return this.sidechainTracker.handleMessage(message, parentToolUseId);
         }

package/dist/server/server/agent/providers/claude/query.d.ts

@@ -1,3 +1,4 @@
+import { type ChildProcess } from "node:child_process";
 import { query, type Options, type Query } from "@anthropic-ai/claude-agent-sdk";
 import { type ProviderRuntimeSettings } from "../../provider-launch-config.js";
 export type ClaudeOptions = Options;
@@ -9,6 +10,8 @@ export interface ClaudeQueryContext {
     runtimeSettings?: ProviderRuntimeSettings;
     launchEnv?: Record<string, string>;
     queryFactory?: ClaudeQueryFactory;
+    /** Called with the spawned child process so the caller can tree-kill it on close. */
+    onChildProcess?: (child: ChildProcess) => void;
 }
 export declare function claudeQuery(input: ClaudeQueryInput, context?: ClaudeQueryContext): Query;
 //# sourceMappingURL=query.d.ts.map

package/dist/server/server/agent/providers/claude/query.js

@@ -24,7 +24,8 @@ function resolveClaudeSpawnCommand(spawnOptions, runtimeSettings) {
         args: [...commandConfig.argv.slice(1), ...spawnOptions.args],
     };
 }
-function applyRuntimeSettingsToClaudeOptions(options, runtimeSettings, launchEnv) {
+function applyRuntimeSettingsToClaudeOptions(options, context) {
+    const { runtimeSettings, launchEnv, onChildProcess } = context;
     return {
         ...options,
         spawnClaudeCodeProcess: (spawnOptions) => {
@@ -62,6 +63,7 @@ function applyRuntimeSettingsToClaudeOptions(options, runtimeSettings, launchEnv
                 // The command is always a resolved binary path, so shell routing is unnecessary.
                 shell: false,
             });
+            onChildProcess?.(child);
             if (typeof options.stderr === "function") {
                 child.stderr?.on("data", (chunk) => {
                     options.stderr?.(chunk.toString());
@@ -78,7 +80,7 @@ export function claudeQuery(input, context = {}) {
     const launchQuery = context.queryFactory ?? query;
     return launchQuery({
         ...input,
-        options: applyRuntimeSettingsToClaudeOptions(input.options, context.runtimeSettings, context.launchEnv),
+        options: applyRuntimeSettingsToClaudeOptions(input.options, context),
     });
 }
 //# sourceMappingURL=query.js.map

package/dist/server/server/agent/providers/generic-acp-agent.d.ts

@@ -1,6 +1,6 @@
 import type { Logger } from "pino";
 import { z } from "zod";
-import { ACPAgentClient } from "./acp-agent.js";
+import { ACPAgentClient, type ACPExtensionCommandsParser } from "./acp-agent.js";
 export declare const GenericACPProviderParamsSchema: z.ZodObject<{
     supportsMcpServers: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$loose>;
@@ -14,6 +14,7 @@ interface GenericACPAgentClientOptions {
     waitForInitialCommands?: boolean;
     initialCommandsWaitTimeoutMs?: number;
     diagnosticPhaseTimeoutMs?: number;
+    extensionCommandsParser?: ACPExtensionCommandsParser;
 }
 export declare class GenericACPAgentClient extends ACPAgentClient {
     private readonly command;

package/dist/server/server/agent/providers/generic-acp-agent.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { checkProviderLaunchAvailable, resolveProviderLaunch } from "../provider-launch-config.js";
-import { ACPAgentClient, DEFAULT_ACP_CAPABILITIES } from "./acp-agent.js";
+import { ACPAgentClient, DEFAULT_ACP_CAPABILITIES, } from "./acp-agent.js";
 import { buildBinaryDiagnosticRows, formatProviderDiagnostic, toDiagnosticErrorMessage, } from "./diagnostic-utils.js";
 export const GenericACPProviderParamsSchema = z
     .object({
@@ -19,6 +19,7 @@ export class GenericACPAgentClient extends ACPAgentClient {
             capabilities: buildGenericACPCapabilities(options),
             waitForInitialCommands: options.waitForInitialCommands,
             initialCommandsWaitTimeoutMs: options.initialCommandsWaitTimeoutMs,
+            extensionCommandsParser: options.extensionCommandsParser,
         });
         this.command = options.command;
         this.providerId = options.providerId;

package/dist/server/server/agent/providers/kiro-acp-agent.d.ts

@@ -0,0 +1,17 @@
+import type { Logger } from "pino";
+import type { ACPExtensionCommandsParser } from "./acp-agent.js";
+import { GenericACPAgentClient } from "./generic-acp-agent.js";
+interface KiroACPAgentClientOptions {
+    logger: Logger;
+    command: [string, ...string[]];
+    env?: Record<string, string>;
+    providerId?: string;
+    label?: string;
+    providerParams?: unknown;
+}
+export declare const parseKiroExtensionCommands: ACPExtensionCommandsParser;
+export declare class KiroACPAgentClient extends GenericACPAgentClient {
+    constructor(options: KiroACPAgentClientOptions);
+}
+export {};
+//# sourceMappingURL=kiro-acp-agent.d.ts.map

package/dist/server/server/agent/providers/kiro-acp-agent.js

@@ -0,0 +1,78 @@
+import { GenericACPAgentClient } from "./generic-acp-agent.js";
+// Kiro CLI publishes its slash commands and skills asynchronously through the
+// `_kiro.dev/commands/available` extension notification shortly after
+// `session/new` resolves. Wait for that first batch so listCommands() doesn't
+// resolve to an empty list before Kiro has reported its commands.
+const KIRO_INITIAL_COMMANDS_WAIT_TIMEOUT_MS = 10000;
+// ACP extension method (per the `_`-prefixed vendor namespace convention) that
+// Kiro CLI uses to publish its slash commands and skills after session/new.
+const KIRO_COMMANDS_AVAILABLE_METHOD = "_kiro.dev/commands/available";
+function isRecord(value) {
+    return value != null && typeof value === "object" && !Array.isArray(value);
+}
+// Maps a `_kiro.dev/commands/available` payload onto Paseo slash commands.
+// Kiro reports built-in slash commands under `commands` (names arrive with a
+// leading "/", e.g. "/agent") and skills/prompts under `prompts` (names without
+// a slash, tagged with a `skill:` serverName). Paseo stores command names
+// without the leading slash — the composer prepends it on insertion.
+function mapKiroAvailableCommands(params) {
+    const result = [];
+    const seen = new Set();
+    const pushEntry = (entry) => {
+        if (!isRecord(entry)) {
+            return;
+        }
+        const rawName = typeof entry.name === "string" ? entry.name.trim() : "";
+        const name = rawName.replace(/^\/+/, "");
+        if (!name || seen.has(name)) {
+            return;
+        }
+        seen.add(name);
+        const description = typeof entry.description === "string" ? entry.description : "";
+        const meta = isRecord(entry.meta) ? entry.meta : null;
+        const argumentHint = meta && typeof meta.hint === "string" ? meta.hint : "";
+        const serverName = typeof entry.serverName === "string" ? entry.serverName : "";
+        const kind = serverName.startsWith("skill:") ? "skill" : "command";
+        result.push({ name, description, argumentHint, kind });
+    };
+    if (Array.isArray(params.commands)) {
+        for (const entry of params.commands) {
+            pushEntry(entry);
+        }
+    }
+    if (Array.isArray(params.prompts)) {
+        for (const entry of params.prompts) {
+            pushEntry(entry);
+        }
+    }
+    return result;
+}
+// Provider-specific parser injected into the generic ACP session via the
+// `extensionCommandsParser` option (mirrors how Cursor/Copilot inject their
+// behavior through constructor options). Kiro advertises its slash commands and
+// skills through the `_kiro.dev/commands/available` extension notification
+// instead of the standard `available_commands_update` session update; this
+// recognizes that one method and returns the parsed commands (possibly empty),
+// or null for any other notification so the base session ignores it.
+export const parseKiroExtensionCommands = (method, params) => {
+    if (method !== KIRO_COMMANDS_AVAILABLE_METHOD) {
+        return null;
+    }
+    return mapKiroAvailableCommands(params);
+};
+export class KiroACPAgentClient extends GenericACPAgentClient {
+    constructor(options) {
+        super({
+            logger: options.logger,
+            command: options.command,
+            env: options.env,
+            providerId: options.providerId,
+            label: options.label,
+            providerParams: options.providerParams,
+            waitForInitialCommands: true,
+            initialCommandsWaitTimeoutMs: KIRO_INITIAL_COMMANDS_WAIT_TIMEOUT_MS,
+            extensionCommandsParser: parseKiroExtensionCommands,
+        });
+    }
+}
+//# sourceMappingURL=kiro-acp-agent.js.map

package/dist/server/server/agent/providers/mock-load-test-agent.js

@@ -439,12 +439,14 @@ export class MockLoadTestAgentSession {
         }
         const profile = resolveModelProfile(this.modelId);
         const turnId = randomUUID();
+        const assistantMessageId = randomUUID();
         let resolve;
         const completed = new Promise((promiseResolve) => {
             resolve = promiseResolve;
         });
         const turn = {
             turnId,
+            assistantMessageId,
             prompt,
             startedAt: Date.now(),
             cycle: 0,
@@ -655,6 +657,7 @@ export class MockLoadTestAgentSession {
         this.emitTimeline(turn.turnId, {
             type: "assistant_message",
             text: finalText,
+            messageId: turn.assistantMessageId,
         });
         this.activeTurn = null;
         this.emit({
@@ -669,6 +672,7 @@ export class MockLoadTestAgentSession {
                 {
                     type: "assistant_message",
                     text: finalText,
+                    messageId: turn.assistantMessageId,
                 },
             ],
             canceled: false,
@@ -768,6 +772,7 @@ export class MockLoadTestAgentSession {
                 ? {
                     type: "assistant_message",
                     text: `stress-update-${index}`,
+                    messageId: turn.assistantMessageId,
                 }
                 : {
                     type: "todo",
@@ -834,6 +839,7 @@ export class MockLoadTestAgentSession {
             this.emitTimeline(turn.turnId, {
                 type: "assistant_message",
                 text: `data:image/png;base64,${payload}`,
+                messageId: turn.assistantMessageId,
             });
         }
         this.activeTurn = null;
@@ -892,6 +898,7 @@ export class MockLoadTestAgentSession {
                 this.emitTimeline(turn.turnId, {
                     type: "assistant_message",
                     text: event.text,
+                    messageId: turn.assistantMessageId,
                 });
                 return;
             }
@@ -933,6 +940,7 @@ export class MockLoadTestAgentSession {
         this.emitTimeline(turn.turnId, {
             type: "assistant_message",
             text: "\n\n_(end of synthetic stream)_\n",
+            messageId: turn.assistantMessageId,
         });
         this.finishTurnWithText(turn, "Synthetic load test complete");
     }

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 { resolvePaseoHome } from "../../../paseo-home.js";
+const OPENCODE_HOME_DIRNAME = "opencode-home";
+export function resolveOpenCodeHomeDir(env = process.env) {
+    return path.join(resolvePaseoHome(env), OPENCODE_HOME_DIRNAME);
+}
+//# sourceMappingURL=paths.js.map

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

@@ -46,6 +46,7 @@ export interface OpenCodeServerManagerOptions {
     terminateProcess?: ProcessTerminator;
     portAllocator?: OpenCodePortAllocator;
     resolveCommandPrefix?: OpenCodeCommandPrefixResolver;
+    resolveHomeDir?: () => string;
     spawnServerProcess?: OpenCodeServerProcessSpawner;
 }
 export declare class OpenCodeServerManager implements OpenCodeServerManagerLike {
@@ -62,6 +63,7 @@ export declare class OpenCodeServerManager implements OpenCodeServerManagerLike
     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;

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

@@ -1,9 +1,12 @@
+import { mkdirSync } from "node:fs";
+import { stat } from "node:fs/promises";
 import net from "node:net";
-import os from "node:os";
+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 {
@@ -21,6 +24,7 @@ export class OpenCodeServerManager {
         this.resolveCommandPrefix =
             options.resolveCommandPrefix ??
                 (() => resolveProviderCommandPrefix(this.runtimeSettings?.command, resolveOpenCodeBinary));
+        this.resolveHomeDir = options.resolveHomeDir ?? resolveOpenCodeHomeDir;
         this.spawnServerProcess = options.spawnServerProcess ?? spawnProcess;
     }
     static getInstance(logger, runtimeSettings, options = {}) {
@@ -164,7 +168,11 @@ export class OpenCodeServerManager {
         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();
+        // 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",
@@ -371,10 +379,31 @@ OpenCodeServerManager.instance = null;
 OpenCodeServerManager.exitHandlerRegistered = false;
 async function resolveOpenCodeBinary() {
     const found = await findExecutable("opencode");
-    if (found) {
-        return found;
+    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;
     }
-    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 findAvailablePort() {
     return new Promise((resolve, reject) => {

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 OpenCodeServerManagerLike } from "./opencode/server-manager.js";
+import { resolveOpenCodeHomeDir } from "./opencode/paths.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;
@@ -100,11 +101,13 @@ export declare const __openCodeInternals: {
     resolveOpenCodeSelectedModelContextWindow: typeof resolveOpenCodeSelectedModelContextWindow;
     isSelectableOpenCodeAgent: typeof isSelectableOpenCodeAgent;
     mapOpenCodeAgentToMode: typeof mapOpenCodeAgentToMode;
+    resolveOpenCodeHomeDir: typeof resolveOpenCodeHomeDir;
     readonly OpenCodeAgentSession: typeof OpenCodeAgentSession;
 };
 interface OpenCodeAgentClientDeps {
     serverManager?: OpenCodeServerManagerLike;
     createClient?: OpenCodeClientFactory;
+    resolveHomeDir?: () => string;
     managedProcesses?: ManagedProcessRegistry;
 }
 type OpenCodeClientFactory = (options: {
@@ -118,6 +121,7 @@ export declare class OpenCodeAgentClient implements AgentClient {
     readonly isCreateConfigUnattended: typeof isOpenCodeCreateConfigUnattended;
     private readonly serverManager;
     private readonly createOpenCodeClient;
+    private readonly resolveHomeDir;
     private readonly logger;
     private readonly runtimeSettings?;
     private readonly modelContextWindows;