jb/paseo
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: make executable resolution async and centralize spawn

Browse Source 
- Rename findExecutable → findExecutableSync, add async findExecutable
  that uses promisified execFile instead of execFileSync
- Simplify Windows PATH resolution: rely on inherited env from Explorer
  instead of shelling out to PowerShell for registry PATH entries
- Add spawnProcess() helper that centralizes Windows shell/quoting concerns
- Update all agent providers and consumers to use async executable resolution
- Add windowsHide: true across all Windows child process calls
This commit is contained in:
Mohamed Boudra
2026-04-09 18:54:55 +07:00
parent 75542c10d8
commit b8e048c7fa
25 changed files with 453 additions and 715 deletions
Download Patch File Download Diff File Expand all files Collapse all files
packages/server/src/poc-commands/commands-poc.test.ts
+2 -2
View File
@@ -20,11 +20,11 @@ import {
query,
type SDKUserMessage,
} from "@anthropic-ai/claude-agent-sdk";
import { isCommandAvailable } from "../utils/executable.js";
import { isCommandAvailableSync } from "../utils/executable.js";
const hasClaudeCredentials =
!!process.env.CLAUDE_CODE_OAUTH_TOKEN || !!process.env.ANTHROPIC_API_KEY;
const canRunClaudeIntegration = isCommandAvailable("claude") && hasClaudeCredentials;
const canRunClaudeIntegration = isCommandAvailableSync("claude") && hasClaudeCredentials;
// Pattern from claude-agent.ts listModels():
// Use an empty async generator when you just need control methods
packages/server/src/server/agent/provider-launch-config.test.ts
+6 -6
View File
@@ -7,19 +7,19 @@ import {
} from "./provider-launch-config.js";
describe("resolveProviderCommandPrefix", () => {
test("uses resolved default command in default mode", () => {
test("uses resolved default command in default mode", async () => {
const resolveDefault = vi.fn(() => "/usr/local/bin/claude");
const resolved = resolveProviderCommandPrefix(undefined, resolveDefault);
const resolved = await resolveProviderCommandPrefix(undefined, resolveDefault);
expect(resolveDefault).toHaveBeenCalledTimes(1);
expect(resolved).toEqual({ command: "/usr/local/bin/claude", args: [] });
});
test("appends args in append mode", () => {
test("appends args in append mode", async () => {
const resolveDefault = vi.fn(() => "/usr/local/bin/claude");
const resolved = resolveProviderCommandPrefix(
const resolved = await resolveProviderCommandPrefix(
{
mode: "append",
args: ["--chrome"],
@@ -34,10 +34,10 @@ describe("resolveProviderCommandPrefix", () => {
});
});
test("replaces command in replace mode without resolving default", () => {
test("replaces command in replace mode without resolving default", async () => {
const resolveDefault = vi.fn(() => "/usr/local/bin/claude");
const resolved = resolveProviderCommandPrefix(
const resolved = await resolveProviderCommandPrefix(
{
mode: "replace",
argv: ["docker", "run", "--rm", "my-wrapper"],
packages/server/src/server/agent/provider-launch-config.ts
+12 -201
View File
@@ -1,9 +1,6 @@
import { execFileSync, execSync } from "node:child_process";
import { existsSync } from "node:fs";
import { platform } from "node:os";
import path from "node:path";
import { z } from "zod";
import { findExecutableSync, isCommandAvailable } from "../../utils/executable.js";
import type { AgentProvider } from "./agent-sdk-types.js";
import { AgentProviderSchema } from "./provider-manifest.js";
@@ -56,80 +53,20 @@ export type ProviderCommandPrefix = {
args: string[];
};
interface FindExecutableDependencies {
execSync: typeof execSync;
execFileSync: typeof execFileSync;
existsSync: typeof existsSync;
platform: typeof platform;
shell: string | undefined;
}
function resolveWindowsPathEntries(deps: FindExecutableDependencies): string[] {
try {
const output = deps.execFileSync(
"powershell",
[
"-NoProfile",
"-NonInteractive",
"-Command",
[
'$machine = [Environment]::GetEnvironmentVariable("Path", "Machine")',
'$user = [Environment]::GetEnvironmentVariable("Path", "User")',
"if ($machine) { Write-Output $machine }",
"if ($user) { Write-Output $user }",
].join("; "),
],
{ encoding: "utf8" },
);
return output
.split(/\r?\n/)
.flatMap((line) => line.split(";"))
.map((entry) => entry.trim())
.filter((entry) => entry.length > 0);
} catch {
return [];
}
}
function resolveExecutableFromWhichOutput(
name: string,
output: string,
source: "login-shell" | "which",
): string | null {
const lines = output
.split(/\r?\n/)
.map((line) => line.trim())
.filter((line) => line.length > 0);
const candidate = lines.at(-1);
if (!candidate) {
return null;
}
if (!path.isAbsolute(candidate)) {
console.warn(
`[findExecutable] Ignoring non-absolute ${source} output for '${name}': ${JSON.stringify(candidate)}`,
);
return null;
}
return candidate;
}
export function resolveProviderCommandPrefix(
export async function resolveProviderCommandPrefix(
commandConfig: ProviderCommand | undefined,
resolveDefaultCommand: () => string,
): ProviderCommandPrefix {
resolveDefaultCommand: () => string | Promise<string>,
): Promise<ProviderCommandPrefix> {
if (!commandConfig || commandConfig.mode === "default") {
return {
command: resolveDefaultCommand(),
command: await resolveDefaultCommand(),
args: [],
};
}
if (commandConfig.mode === "append") {
return {
command: resolveDefaultCommand(),
command: await resolveDefaultCommand(),
args: [...(commandConfig.args ?? [])],
};
}
@@ -175,142 +112,16 @@ export function applyProviderEnv(
return merged;
}
export function sanitizeTerminalEnv(
env: Record<string, string | undefined>,
): Record<string, string> {
return Object.fromEntries(
Object.entries(env).filter((entry): entry is [string, string] => typeof entry[1] === "string"),
);
export function findExecutable(name: string): string | null {
return findExecutableSync(name);
}
/**
* Resolve an executable name to its absolute path the way the user's shell would.
*
* On Unix we first try `$SHELL -lic "which <name>"` so that rc-file PATH
* additions (asdf, nvm, homebrew, nix, etc.) are visible — exactly as if the
* user opened a terminal and typed the command. If that fails (e.g. the login
* shell itself errors) we fall back to a plain `which`.
*
* On Windows we augment the daemon PATH with machine/user registry PATH values
* and return the first `where.exe` match. Launch-time execution decides whether
* the resolved path needs `cmd.exe` semantics (for example npm shims under
* nvm4w such as `C:\nvm4w\nodejs\codex`).
*/
export function findExecutable(
name: string,
dependencies?: FindExecutableDependencies,
): string | null {
const trimmed = name.trim();
if (!trimmed) {
return null;
}
const deps: FindExecutableDependencies = {
execSync,
execFileSync,
existsSync,
platform,
shell: process.env["SHELL"],
...dependencies,
};
if (trimmed.includes("/") || trimmed.includes("\\")) {
return deps.existsSync(trimmed) ? trimmed : null;
}
if (deps.platform() === "win32") {
try {
const inheritedPath = process.env["Path"] ?? process.env["PATH"] ?? "";
const resolvedPath = [
...inheritedPath.split(";"),
...resolveWindowsPathEntries(deps),
]
.map((entry) => entry.trim())
.filter((entry) => entry.length > 0)
.filter((entry, index, entries) => entries.indexOf(entry) === index)
.join(";");
const env = {
...process.env,
PATH: resolvedPath,
Path: resolvedPath,
};
const out = deps.execFileSync("where.exe", [trimmed], { encoding: "utf8", env }).trim();
return (
out
.split(/\r?\n/)
.map((line) => line.trim())
.find((line) => line.length > 0) ?? null
);
} catch {
return null;
}
}
// Unix: try the user's login shell so rc-file PATH entries are visible.
const shell = deps.shell;
if (shell) {
try {
const out = deps
.execSync(`${shell} -lic "which ${trimmed}"`, {
encoding: "utf8",
timeout: 5000,
})
.trim();
const resolved = resolveExecutableFromWhichOutput(trimmed, out, "login-shell");
if (resolved) {
return resolved;
}
} catch {
// Login shell failed (broken rc, etc.) — fall through to plain which.
}
}
try {
return resolveExecutableFromWhichOutput(
trimmed,
deps.execFileSync("which", [trimmed], { encoding: "utf8" }).trim(),
"which",
);
} catch {
return null;
}
}
/**
* When spawning with `shell: true` on Windows, the command is passed to
* `cmd.exe /d /s /c "command args"`. The `/s` strips outer quotes, so a
* command path with spaces (e.g. `C:\Program Files\...`) is split at the
* space. Wrapping it in quotes produces the correct `"C:\Program Files\..." args`.
*/
export function quoteWindowsCommand(command: string): string {
if (process.platform !== "win32") return command;
if (!command.includes(" ")) return command;
if (command.startsWith('"') && command.endsWith('"')) return command;
return `"${command}"`;
}
/**
* `spawn(..., { shell: true })` on Windows also passes argv through `cmd.exe`.
* Any argument containing spaces must be quoted or it will be split before the
* child process sees it.
*/
export function quoteWindowsArgument(argument: string): string {
if (process.platform !== "win32") return argument;
if (!argument.includes(" ")) return argument;
if (argument.startsWith('"') && argument.endsWith('"')) return argument;
return `"${argument}"`;
}
export function isCommandAvailable(command: string): boolean {
return findExecutable(command) !== null;
}
export function isProviderCommandAvailable(
export async function isProviderCommandAvailable(
commandConfig: ProviderCommand | undefined,
resolveDefaultCommand: () => string,
): boolean {
resolveDefaultCommand: () => string | Promise<string>,
): Promise<boolean> {
try {
const prefix = resolveProviderCommandPrefix(commandConfig, resolveDefaultCommand);
const prefix = await resolveProviderCommandPrefix(commandConfig, resolveDefaultCommand);
return isCommandAvailable(prefix.command);
} catch {
return false;
packages/server/src/server/agent/providers/__tests__/claude-agent.event-stream.integration.test.ts
+2 -2
View File
@@ -17,7 +17,7 @@ import path from "node:path";
import pino from "pino";
import type { AgentSession, AgentStreamEvent } from "../../agent-sdk-types.js";
import { isCommandAvailable } from "../../../../utils/executable.js";
import { isCommandAvailableSync } from "../../../../utils/executable.js";
import { ClaudeAgentClient } from "../claude-agent.js";
// ---------------------------------------------------------------------------
@@ -28,7 +28,7 @@ const logger = pino({ level: "silent" });
const client = new ClaudeAgentClient({ logger });
const hasClaudeCredentials =
!!process.env.CLAUDE_CODE_OAUTH_TOKEN || !!process.env.ANTHROPIC_API_KEY;
const canRun = isCommandAvailable("claude") && hasClaudeCredentials;
const canRun = isCommandAvailableSync("claude") && hasClaudeCredentials;
function tmpCwd(prefix: string): string {
return mkdtempSync(path.join(tmpdir(), prefix));
packages/server/src/server/agent/providers/acp-agent.ts
+14 -17
View File
@@ -1,5 +1,4 @@
import {
spawn,
type ChildProcess,
type ChildProcessWithoutNullStreams,
} from "node:child_process";
@@ -89,6 +88,7 @@ import {
type ProviderRuntimeSettings,
} from "../provider-launch-config.js";
import { findExecutable } from "../../../utils/executable.js";
import { spawnProcess } from "../../../utils/spawn.js";
const DEFAULT_ACP_CAPABILITIES: AgentCapabilityFlags = {
supportsStreaming: true,
@@ -476,16 +476,15 @@ export class ACPAgentClient implements AgentClient {
protected async spawnProcess(
launchEnv?: Record<string, string>,
): Promise<SpawnedACPProcess> {
const { command, args } = this.resolveLaunchCommand();
const child = spawn(command, args, {
const { command, args } = await this.resolveLaunchCommand();
const child = spawnProcess(command, args, {
cwd: process.cwd(),
env: {
...applyProviderEnv(process.env as Record<string, string | undefined>, this.runtimeSettings),
...(launchEnv ?? {}),
},
shell: process.platform === "win32",
stdio: ["pipe", "pipe", "pipe"],
});
}) as ChildProcessWithoutNullStreams;
const stderrChunks: string[] = [];
child.stderr.on("data", (chunk: Buffer | string) => {
@@ -552,9 +551,9 @@ export class ACPAgentClient implements AgentClient {
}
}
protected resolveLaunchCommand(): { command: string; args: string[] } {
const prefix = resolveProviderCommandPrefix(this.runtimeSettings?.command, () => {
const resolved = findExecutable(this.defaultCommand[0]);
protected async resolveLaunchCommand(): Promise<{ command: string; args: string[] }> {
const resolved = await findExecutable(this.defaultCommand[0]);
const prefix = await resolveProviderCommandPrefix(this.runtimeSettings?.command, () => {
if (!resolved) {
throw new Error(`${this.provider} command '${this.defaultCommand[0]}' not found`);
}
@@ -1172,13 +1171,12 @@ export class ACPAgentSession implements AgentSession, ACPClient {
async createTerminal(params: CreateTerminalRequest): Promise<{ terminalId: string }> {
const terminalId = randomUUID();
const env = Object.fromEntries((params.env ?? []).map((entry: EnvVariable) => [entry.name, entry.value]));
const child = spawn(params.command, params.args ?? [], {
const child = spawnProcess(params.command, params.args ?? [], {
cwd: params.cwd ?? this.config.cwd,
env: {
...applyProviderEnv(process.env as Record<string, string | undefined>, this.runtimeSettings),
...env,
},
shell: process.platform === "win32",
stdio: ["ignore", "pipe", "pipe"],
});
@@ -1201,8 +1199,8 @@ export class ACPAgentSession implements AgentSession, ACPClient {
rejectExit,
};
child.stdout.on("data", (chunk: Buffer | string) => appendTerminalOutput(entry, chunk.toString()));
child.stderr.on("data", (chunk: Buffer | string) => appendTerminalOutput(entry, chunk.toString()));
child.stdout!.on("data", (chunk: Buffer | string) => appendTerminalOutput(entry, chunk.toString()));
child.stderr!.on("data", (chunk: Buffer | string) => appendTerminalOutput(entry, chunk.toString()));
child.once("error", (error) => rejectExit(error instanceof Error ? error : new Error(String(error))));
child.once("exit", (code, signal) => {
const exit = { exitCode: code, signal };
@@ -1245,8 +1243,8 @@ export class ACPAgentSession implements AgentSession, ACPClient {
}
private async spawnProcess(): Promise<SpawnedACPProcess> {
const prefix = resolveProviderCommandPrefix(this.runtimeSettings?.command, () => {
const resolved = findExecutable(this.defaultCommand[0]);
const resolved = await findExecutable(this.defaultCommand[0]);
const prefix = await resolveProviderCommandPrefix(this.runtimeSettings?.command, () => {
if (!resolved) {
throw new Error(`${this.provider} command '${this.defaultCommand[0]}' not found`);
}
@@ -1255,15 +1253,14 @@ export class ACPAgentSession implements AgentSession, ACPClient {
const command = prefix.command;
const args = [...prefix.args, ...this.defaultCommand.slice(1)];
const child = spawn(command, args, {
const child = spawnProcess(command, args, {
cwd: this.config.cwd,
env: {
...applyProviderEnv(process.env as Record<string, string | undefined>, this.runtimeSettings),
...(this.launchEnv ?? {}),
},
shell: process.platform === "win32",
stdio: ["pipe", "pipe", "pipe"],
});
}) as ChildProcessWithoutNullStreams;
const stderrChunks: string[] = [];
child.stderr.on("data", (chunk: Buffer | string) => {
packages/server/src/server/agent/providers/claude-agent-commands.real.e2e.test.ts
+2 -2
View File
@@ -2,13 +2,13 @@ import { describe, expect, test } from "vitest";
import pino from "pino";
import type { AgentSlashCommand } from "../agent-sdk-types.js";
import { isCommandAvailable } from "../../../utils/executable.js";
import { isCommandAvailableSync } from "../../../utils/executable.js";
import { ClaudeAgentClient } from "./claude-agent.js";
// Real-Claude contract coverage: validates slash command shape from a live Claude CLI session.
describe("claude agent commands contract (real)", () => {
test("lists slash commands with the expected contract", async () => {
expect(isCommandAvailable("claude")).toBe(true);
expect(isCommandAvailableSync("claude")).toBe(true);
const client = new ClaudeAgentClient({
logger: pino({ level: "silent" }),
packages/server/src/server/agent/providers/claude-agent.integration.test.ts
+3 -3
View File
@@ -6,7 +6,7 @@ import pino from "pino";
import { query, type SDKUserMessage } from "@anthropic-ai/claude-agent-sdk";
import type { AgentSession, AgentStreamEvent, ToolCallTimelineItem } from "../agent-sdk-types.js";
import { isCommandAvailable } from "../../../utils/executable.js";
import { isCommandAvailableSync } from "../../../utils/executable.js";
import { ClaudeAgentClient } from "./claude-agent.js";
import { streamSession } from "./test-utils/session-stream-adapter.js";
@@ -174,11 +174,11 @@ async function cleanupSession(handle: { cwd: string; session: AgentSession }): P
}
describe("ClaudeAgentSession integration", () => {
const canRunClaudeIntegration = isCommandAvailable("claude") && hasClaudeCredentials;
const canRunClaudeIntegration = isCommandAvailableSync("claude") && hasClaudeCredentials;
beforeAll(() => {
if (canRunClaudeIntegration) {
expect(isCommandAvailable("claude")).toBe(true);
expect(isCommandAvailableSync("claude")).toBe(true);
}
});
packages/server/src/server/agent/providers/claude-agent.max-effort.real.e2e.test.ts
+2 -2
View File
@@ -2,7 +2,7 @@ import { describe, expect, test } from "vitest";
import pino from "pino";
import type { AgentStreamEvent, AgentSession } from "../agent-sdk-types.js";
import { isCommandAvailable } from "../../../utils/executable.js";
import { isCommandAvailableSync } from "../../../utils/executable.js";
import { ClaudeAgentClient } from "./claude-agent.js";
import { streamSession } from "./test-utils/session-stream-adapter.js";
@@ -29,7 +29,7 @@ async function collectUntilTerminal(session: AgentSession): Promise<AgentStreamE
}
describe("Claude max effort availability (real)", () => {
test.runIf(isCommandAvailable("claude") && hasClaudeCredentials)(
test.runIf(isCommandAvailableSync("claude") && hasClaudeCredentials)(
"surfaces the Claude stderr diagnostic when bypassPermissions + max effort is unavailable",
async () => {
const client = new ClaudeAgentClient({
packages/server/src/server/agent/providers/claude-agent.ts
+23 -25
View File
@@ -1,4 +1,5 @@
import { execFileSync, spawn } from "node:child_process";
import { execFile, type ChildProcessWithoutNullStreams } from "node:child_process";
import { promisify } from "node:util";
import { randomUUID } from "node:crypto";
import fs from "node:fs";
import { promises } from "node:fs";
@@ -79,14 +80,12 @@ import {
applyProviderEnv,
type ProviderRuntimeSettings,
} from "../provider-launch-config.js";
import {
findExecutable,
quoteWindowsArgument,
quoteWindowsCommand,
} from "../../../utils/executable.js";
import { findExecutable } from "../../../utils/executable.js";
import { spawnProcess } from "../../../utils/spawn.js";
import { getOrchestratorModeInstructions } from "../orchestrator-instructions.js";
const fsPromises = promises;
const execFileAsync = promisify(execFile);
const CLAUDE_SETTING_SOURCES: NonNullable<Options["settingSources"]> = ["user", "project"];
type TurnState = "idle" | "foreground" | "autonomous";
@@ -225,26 +224,21 @@ function applyRuntimeSettingsToClaudeOptions(
const isDefaultRuntime =
resolved.command === "node" || resolved.command === "bun";
const command = isDefaultRuntime ? process.execPath : resolved.command;
const child = spawn(
quoteWindowsCommand(command),
resolved.args.map((argument) => quoteWindowsArgument(argument)),
{
const child = spawnProcess(command, resolved.args, {
cwd: spawnOptions.cwd,
env: {
...applyProviderEnv(spawnOptions.env, runtimeSettings),
...(launchEnv ?? {}),
},
shell: process.platform === "win32",
signal: spawnOptions.signal,
stdio: ["pipe", "pipe", "pipe"],
},
);
});
if (typeof options.stderr === "function") {
child.stderr?.on("data", (chunk: Buffer | string) => {
options.stderr?.(chunk.toString());
});
}
return child;
return child as ChildProcessWithoutNullStreams;
},
};
}
@@ -1144,9 +1138,9 @@ export class ClaudeAgentClient implements AgentClient {
async getDiagnostic(): Promise<{ diagnostic: string }> {
try {
const resolvedBinary = findExecutable("claude") ?? "not found";
const resolvedBinary = await findExecutable("claude") ?? "not found";
const available = await this.isAvailable();
const version = resolveClaudeVersion(this.runtimeSettings);
const version = await resolveClaudeVersion(this.runtimeSettings);
let modelsValue = "Not checked";
let status = formatDiagnosticStatus(available);
@@ -1186,26 +1180,30 @@ export class ClaudeAgentClient implements AgentClient {
}
}
function resolveClaudeVersion(runtimeSettings?: ProviderRuntimeSettings): string | null {
async function resolveClaudeVersion(runtimeSettings?: ProviderRuntimeSettings): Promise<string | null> {
const command = runtimeSettings?.command;
try {
if (command?.mode === "replace") {
return execFileSync(command.argv[0]!, [...command.argv.slice(1), "--version"], {
const { stdout } = await execFileAsync(command.argv[0]!, [...command.argv.slice(1), "--version"], {
encoding: "utf8",
timeout: 5_000,
}).trim() || null;
windowsHide: true,
});
return stdout.trim() || null;
}
const executable = findExecutable("claude");
const executable = await findExecutable("claude");
if (!executable) {
return null;
}
return execFileSync(executable, ["--version"], {
const { stdout } = await execFileAsync(executable, ["--version"], {
encoding: "utf8",
timeout: 5_000,
}).trim() || null;
windowsHide: true,
});
return stdout.trim() || null;
} catch {
return null;
}
@@ -2027,7 +2025,7 @@ class ClaudeAgentSession implements AgentSession {
this.persistence = null;
const input = createAsyncMessageInput<SDKUserMessage>();
const options = this.buildOptions();
const options = await this.buildOptions();
this.logger.debug({ options: summarizeClaudeOptionsForLog(options) }, "claude query");
this.input = input;
this.query = this.queryFactory({ prompt: input.iterable, options });
@@ -2064,7 +2062,7 @@ class ClaudeAgentSession implements AgentSession {
}
}
private buildOptions(): ClaudeOptions {
private async buildOptions(): Promise<ClaudeOptions> {
const thinkingOptionId =
this.config.thinkingOptionId && this.config.thinkingOptionId !== "default"
? this.config.thinkingOptionId
@@ -2083,7 +2081,7 @@ class ClaudeAgentSession implements AgentSession {
.filter((entry): entry is string => typeof entry === "string" && entry.length > 0)
.join("\n\n");
const claudeBinary = findExecutable("claude");
const claudeBinary = await findExecutable("claude");
this.logger.debug(
{
claudeBinary,
packages/server/src/server/agent/providers/claude-sdk-behavior.test.ts
+4 -4
View File
@@ -6,7 +6,7 @@ import { tmpdir } from "node:os";
import path from "node:path";
import { beforeAll, describe, expect, test } from "vitest";
import { query, type SDKMessage, type SDKUserMessage } from "@anthropic-ai/claude-agent-sdk";
import { findExecutable, isCommandAvailable } from "../../../utils/executable.js";
import { findExecutable, isCommandAvailableSync } from "../../../utils/executable.js";
class Pushable<T> implements AsyncIterable<T> {
private queue: T[] = [];
@@ -57,18 +57,18 @@ const hasClaudeCredentials =
!!process.env.CLAUDE_CODE_OAUTH_TOKEN || !!process.env.ANTHROPIC_API_KEY;
describe("Claude SDK direct behavior", () => {
const canRunClaudeIntegration = isCommandAvailable("claude") && hasClaudeCredentials;
const canRunClaudeIntegration = isCommandAvailableSync("claude") && hasClaudeCredentials;
beforeAll(() => {
if (canRunClaudeIntegration) {
expect(isCommandAvailable("claude")).toBe(true);
expect(isCommandAvailableSync("claude")).toBe(true);
}
});
test.runIf(canRunClaudeIntegration)("shows what happens after interrupt()", async () => {
const cwd = tmpCwd();
const input = new Pushable<SDKUserMessage>();
const claudeBinary = findExecutable("claude");
const claudeBinary = await findExecutable("claude");
// Use same options as claude-agent.ts
const q = query({
packages/server/src/server/agent/providers/codex-app-server-agent.ts
+20 -28
View File
@@ -27,7 +27,7 @@ import type {
} from "../agent-sdk-types.js";
import type { Logger } from "pino";
import { execSync, spawn } from "node:child_process";
import { execSync } from "node:child_process";
import type { ChildProcessWithoutNullStreams } from "node:child_process";
import { randomUUID } from "node:crypto";
import { existsSync, Dirent } from "node:fs";
@@ -46,11 +46,8 @@ import {
resolveProviderCommandPrefix,
type ProviderRuntimeSettings,
} from "../provider-launch-config.js";
import {
findExecutable,
quoteWindowsArgument,
quoteWindowsCommand,
} from "../../../utils/executable.js";
import { findExecutable } from "../../../utils/executable.js";
import { spawnProcess } from "../../../utils/spawn.js";
import { extractCodexTerminalSessionId, nonEmptyString } from "./tool-call-mapper-utils.js";
import { buildCodexFeatures, codexModelSupportsFastMode } from "./codex-feature-definitions.js";
import {
@@ -228,8 +225,8 @@ function mergeCodexConfiguredDefaults(
};
}
function resolveCodexBinary(): string {
const found = findExecutable("codex");
async function resolveCodexBinary(): Promise<string> {
const found = await findExecutable("codex");
if (found) {
return found;
}
@@ -238,10 +235,10 @@ function resolveCodexBinary(): string {
);
}
function resolveCodexLaunchPrefix(runtimeSettings?: ProviderRuntimeSettings): {
async function resolveCodexLaunchPrefix(runtimeSettings?: ProviderRuntimeSettings): Promise<{
command: string;
args: string[];
} {
}> {
return resolveProviderCommandPrefix(runtimeSettings?.command, resolveCodexBinary);
}
@@ -2457,7 +2454,7 @@ class CodexAppServerAgentSession implements AgentSession {
config: AgentSessionConfig,
private readonly resumeHandle: { sessionId: string; metadata?: Record<string, unknown> } | null,
logger: Logger,
private readonly spawnAppServer: () => ChildProcessWithoutNullStreams,
private readonly spawnAppServer: () => Promise<ChildProcessWithoutNullStreams>,
) {
this.logger = logger.child({ module: "agent", provider: CODEX_PROVIDER });
if (config.modeId === undefined) {
@@ -2495,7 +2492,7 @@ class CodexAppServerAgentSession implements AgentSession {
async connect(): Promise<void> {
if (this.connected) return;
const child = this.spawnAppServer();
const child = await this.spawnAppServer();
this.client = new CodexAppServerClient(child, this.logger);
this.client.setNotificationHandler((method, params) => this.handleNotification(method, params));
this.registerRequestHandlers();
@@ -3997,24 +3994,19 @@ export class CodexAppServerAgentClient implements AgentClient {
private readonly runtimeSettings?: ProviderRuntimeSettings,
) {}
private spawnAppServer(launchEnv?: Record<string, string>): ChildProcessWithoutNullStreams {
const launchPrefix = resolveCodexLaunchPrefix(this.runtimeSettings);
private async spawnAppServer(launchEnv?: Record<string, string>): Promise<ChildProcessWithoutNullStreams> {
const launchPrefix = await resolveCodexLaunchPrefix(this.runtimeSettings);
this.logger.trace(
{
launchPrefix,
},
"Spawning Codex app server",
);
return spawn(
quoteWindowsCommand(launchPrefix.command),
[...launchPrefix.args, "app-server"].map((argument) => quoteWindowsArgument(argument)),
{
detached: process.platform !== "win32",
shell: process.platform === "win32",
stdio: ["pipe", "pipe", "pipe"],
env: buildCodexAppServerEnv(this.runtimeSettings, launchEnv),
},
);
return spawnProcess(launchPrefix.command, [...launchPrefix.args, "app-server"], {
detached: process.platform !== "win32",
stdio: ["pipe", "pipe", "pipe"],
env: buildCodexAppServerEnv(this.runtimeSettings, launchEnv),
}) as ChildProcessWithoutNullStreams;
}
async createSession(
@@ -4051,7 +4043,7 @@ export class CodexAppServerAgentClient implements AgentClient {
async listPersistedAgents(
options?: ListPersistedAgentsOptions,
): Promise<PersistedAgentDescriptor[]> {
const child = this.spawnAppServer();
const child = await this.spawnAppServer();
const client = new CodexAppServerClient(child, this.logger);
try {
@@ -4121,7 +4113,7 @@ export class CodexAppServerAgentClient implements AgentClient {
}
async listModels(_options?: ListModelsOptions): Promise<AgentModelDefinition[]> {
const child = this.spawnAppServer();
const child = await this.spawnAppServer();
const client = new CodexAppServerClient(child, this.logger);
try {
@@ -4213,13 +4205,13 @@ export class CodexAppServerAgentClient implements AgentClient {
async getDiagnostic(): Promise<{ diagnostic: string }> {
try {
const available = await this.isAvailable();
const resolvedBinary = findExecutable("codex");
const resolvedBinary = await findExecutable("codex");
const entries: Array<{ label: string; value: string }> = [
{
label: "Binary",
value: resolvedBinary ?? "not found",
},
{ label: "Version", value: resolvedBinary ? resolveBinaryVersion(resolvedBinary) : "unknown" },
{ label: "Version", value: resolvedBinary ? await resolveBinaryVersion(resolvedBinary) : "unknown" },
];
let status = formatDiagnosticStatus(available);
packages/server/src/server/agent/providers/copilot-acp-agent.ts
+2 -2
View File
@@ -63,7 +63,7 @@ export class CopilotACPAgentClient extends ACPAgentClient {
async getDiagnostic(): Promise<{ diagnostic: string }> {
try {
const available = await this.isAvailable();
const resolvedBinary = findExecutable("copilot");
const resolvedBinary = await findExecutable("copilot");
let modelsValue = "Not checked";
let status = formatDiagnosticStatus(available);
@@ -97,7 +97,7 @@ export class CopilotACPAgentClient extends ACPAgentClient {
label: "Binary",
value: resolvedBinary ?? "not found",
},
{ label: "Version", value: resolvedBinary ? resolveBinaryVersion(resolvedBinary) : "unknown" },
{ label: "Version", value: resolvedBinary ? await resolveBinaryVersion(resolvedBinary) : "unknown" },
{ label: "Models", value: modelsValue },
{ label: "Status", value: status },
]),
packages/server/src/server/agent/providers/diagnostic-utils.ts
+11 -8
View File
@@ -1,7 +1,10 @@
import { execFileSync } from "node:child_process";
import { execFile } from "node:child_process";
import { promisify } from "node:util";
import type { ProviderRuntimeSettings } from "../provider-launch-config.js";
const execFileAsync = promisify(execFile);
type DiagnosticEntry = {
label: string;
value: string;
@@ -50,14 +53,14 @@ export function toDiagnosticErrorMessage(error: unknown): string {
return "Unknown error";
}
export function resolveBinaryVersion(binaryPath: string): string {
export async function resolveBinaryVersion(binaryPath: string): Promise<string> {
try {
return (
execFileSync(binaryPath, ["--version"], {
encoding: "utf8",
timeout: 5_000,
}).trim() || "unknown"
);
const { stdout } = await execFileAsync(binaryPath, ["--version"], {
encoding: "utf8",
timeout: 5_000,
windowsHide: true,
});
return stdout.trim() || "unknown";
} catch {
return "unknown";
}
packages/server/src/server/agent/providers/opencode-agent-commands.real.e2e.test.ts
+13 -5
View File
@@ -2,12 +2,12 @@ import { describe, expect, test } from "vitest";
import pino from "pino";
import type { AgentSlashCommand } from "../agent-sdk-types.js";
import { isCommandAvailable } from "../../../utils/executable.js";
import { isCommandAvailableSync } from "../../../utils/executable.js";
import { OpenCodeAgentClient } from "./opencode-agent.js";
describe("opencode agent commands contract (real)", () => {
test("lists slash commands with the expected contract", async () => {
expect(isCommandAvailable("opencode")).toBe(true);
expect(isCommandAvailableSync("opencode")).toBe(true);
const client = new OpenCodeAgentClient(pino({ level: "silent" }));
const session = await client.createSession({
@@ -37,13 +37,13 @@ describe("opencode agent commands contract (real)", () => {
}, 60_000);
test("executes a slash command without arguments", async () => {
expect(isCommandAvailable("opencode")).toBe(true);
expect(isCommandAvailableSync("opencode")).toBe(true);
const client = new OpenCodeAgentClient(pino({ level: "silent" }));
const session = await client.createSession({
provider: "opencode",
cwd: process.cwd(),
modeId: "default",
modeId: "plan",
});
try {
@@ -58,14 +58,22 @@ describe("opencode agent commands contract (real)", () => {
const { turnId } = await session.startTurn(`/${command.name}`);
expect(turnId).toBeTruthy();
// Wait for the turn to complete or fail.
// Wait for any terminal event OR a short timeout.
// Some commands trigger full AI turns that may hang waiting for tool
// permissions. The test only needs to verify the invocation path
// doesn't crash with type errors on the `arguments` field.
await new Promise<void>((resolve) => {
const timeout = setTimeout(() => {
unsub();
resolve();
}, 15_000);
const unsub = session.subscribe((event) => {
if (
event.type === "turn_completed" ||
event.type === "turn_failed" ||
event.type === "turn_canceled"
) {
clearTimeout(timeout);
unsub();
resolve();
}
packages/server/src/server/agent/providers/opencode-agent.test.ts
+6 -5
View File
@@ -12,6 +12,7 @@ import path from "node:path";
import { execFileSync } from "node:child_process";
import { createTestLogger } from "../../../test-utils/test-logger.js";
import type { Event as OpenCodeEvent } from "@opencode-ai/sdk/v2/client";
import {
__openCodeInternals,
OpenCodeAgentClient,
@@ -116,15 +117,15 @@ const hasOpenCode = isBinaryInstalled("opencode");
"beforeAll: Retrieved models",
);
// Prefer fast models for tests - nano models are typically fastest
// Prefer cheap models that support tool use (required by OpenCode agents).
// Avoid free-tier OpenRouter models — they often lack tool-use support.
const fastModel = models.find(
(m) =>
m.id.includes("gpt-4.1-nano") ||
m.id.includes("gpt-4.1-mini") ||
m.id.includes("gpt-5-nano") ||
m.id.includes("gpt-5.1-codex-mini") ||
m.id.includes("gpt-4o-mini") ||
m.id.includes("gpt-3.5") ||
m.id.includes("free"),
m.id.includes("gpt-4o-mini"),
);
if (fastModel) {
@@ -442,7 +443,7 @@ describe("OpenCode adapter context-window normalization", () => {
modelID: "gpt-5",
},
},
},
} as OpenCodeEvent,
{
sessionId: "session-1",
messageRoles: new Map(),
packages/server/src/server/agent/providers/opencode-agent.ts
+168 -261
View File
@@ -1,8 +1,11 @@
import { spawn, type ChildProcess } from "node:child_process";
import type { ChildProcess } from "node:child_process";
import { existsSync } from "node:fs";
import {
createOpencodeClient,
type AssistantMessage as OpenCodeAssistantMessage,
type Event as OpenCodeEvent,
type OpencodeClient,
type Part as OpenCodePart,
} from "@opencode-ai/sdk/v2/client";
import net from "node:net";
import type { Logger } from "pino";
@@ -12,7 +15,6 @@ import type {
AgentCapabilityFlags,
AgentClient,
AgentLaunchContext,
AgentMetadata,
AgentMode,
AgentModelDefinition,
AgentPermissionRequest,
@@ -40,11 +42,8 @@ import {
resolveProviderCommandPrefix,
type ProviderRuntimeSettings,
} from "../provider-launch-config.js";
import {
findExecutable,
quoteWindowsArgument,
quoteWindowsCommand,
} from "../../../utils/executable.js";
import { findExecutable } from "../../../utils/executable.js";
import { spawnProcess } from "../../../utils/spawn.js";
import { mapOpencodeToolCall } from "./opencode/tool-call-mapper.js";
import {
formatDiagnosticStatus,
@@ -174,8 +173,8 @@ const OpencodeToolPartToTimelineItemSchema = OpencodeToolPartTimelineEnvelopeSch
}),
);
function resolveOpenCodeBinary(): string {
const found = findExecutable("opencode");
async function resolveOpenCodeBinary(): Promise<string> {
const found = await findExecutable("opencode");
if (found) {
return found;
}
@@ -239,14 +238,15 @@ async function findAvailablePort(): Promise<number> {
});
}
function resolvePartDedupeKey(part: AgentMetadata, partType: "text" | "reasoning"): string | null {
const partId = part.id;
if (typeof partId === "string" && partId.trim().length > 0) {
return `${partType}:${partId}`;
function resolvePartDedupeKey(
part: { id: string; messageID: string },
partType: "text" | "reasoning",
): string | null {
if (part.id.trim().length > 0) {
return `${partType}:${part.id}`;
}
const messageId = part.messageID;
if (typeof messageId === "string" && messageId.trim().length > 0) {
return `${partType}:message:${messageId}`;
if (part.messageID.trim().length > 0) {
return `${partType}:message:${part.messageID}`;
}
return null;
}
@@ -404,15 +404,11 @@ function buildOpenCodeModelContextWindowLookup(providers: {
return lookup;
}
function resolveOpenCodeModelLookupKeyFromAssistantMessageInfo(
info: AgentMetadata | undefined,
function resolveOpenCodeModelLookupKeyFromAssistantMessage(
info: OpenCodeAssistantMessage,
): string | undefined {
if (!info || info.role !== "assistant") {
return undefined;
}
const providerId = readNonEmptyString(info.providerID);
const modelId = readNonEmptyString(info.modelID);
const providerId = info.providerID;
const modelId = info.modelID;
if (!providerId || !modelId) {
return undefined;
}
@@ -485,7 +481,7 @@ export const __openCodeInternals = {
hasNormalizedOpenCodeUsage,
mergeOpenCodeStepFinishUsage,
parseOpenCodeModelLookupKey,
resolveOpenCodeModelLookupKeyFromAssistantMessageInfo,
resolveOpenCodeModelLookupKeyFromAssistantMessage,
resolveOpenCodeSelectedModelContextWindow,
};
@@ -564,19 +560,16 @@ export class OpenCodeServerManager {
private async startServer(): Promise<{ port: number; url: string }> {
this.port = await findAvailablePort();
const url = `http://127.0.0.1:${this.port}`;
const launchPrefix = resolveProviderCommandPrefix(
const launchPrefix = await resolveProviderCommandPrefix(
this.runtimeSettings?.command,
resolveOpenCodeBinary,
);
return new Promise((resolve, reject) => {
this.server = spawn(
quoteWindowsCommand(launchPrefix.command),
[...launchPrefix.args, "serve", "--port", String(this.port)].map((argument) =>
quoteWindowsArgument(argument),
),
this.server = spawnProcess(
launchPrefix.command,
[...launchPrefix.args, "serve", "--port", String(this.port)],
{
shell: process.platform === "win32",
stdio: ["ignore", "pipe", "pipe"],
env: applyProviderEnv(process.env, this.runtimeSettings),
},
@@ -847,7 +840,7 @@ export class OpenCodeAgentClient implements AgentClient {
async getDiagnostic(): Promise<{ diagnostic: string }> {
try {
const available = await this.isAvailable();
const resolvedBinary = findExecutable("opencode");
const resolvedBinary = await findExecutable("opencode");
let serverStatus = "Not running";
let modelsValue = "Not checked";
let status = formatDiagnosticStatus(available);
@@ -889,7 +882,7 @@ export class OpenCodeAgentClient implements AgentClient {
label: "Binary",
value: resolvedBinary ?? "not found",
},
{ label: "Version", value: resolvedBinary ? resolveBinaryVersion(resolvedBinary) : "unknown" },
{ label: "Version", value: resolvedBinary ? await resolveBinaryVersion(resolvedBinary) : "unknown" },
{ label: "Server", value: serverStatus },
{ label: "Models", value: modelsValue },
{ label: "Status", value: status },
@@ -962,51 +955,18 @@ function readNonEmptyString(value: unknown): string | null {
return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
}
function normalizeQuestionOptions(
value: unknown,
): Array<{ label: string; description?: string }> | null {
if (!Array.isArray(value)) {
return null;
}
const options: Array<{ label: string; description?: string }> = [];
for (const item of value) {
if (typeof item === "string" && item.trim().length > 0) {
options.push({ label: item.trim() });
continue;
}
const record = readOpenCodeRecord(item);
const label = readNonEmptyString(record?.label);
if (!label) {
continue;
}
const description = readNonEmptyString(record?.description);
options.push(description ? { label, description } : { label });
}
return options;
}
export function translateOpenCodeEvent(
event: unknown,
event: OpenCodeEvent,
state: OpenCodeEventTranslationState,
): AgentStreamEvent[] {
const events: AgentStreamEvent[] = [];
if (!event || typeof event !== "object") {
return events;
}
const e = event as { type?: string; properties?: AgentMetadata };
const type = e.type;
const props = e.properties ?? {};
switch (type) {
switch (event.type) {
case "session.created":
case "session.updated": {
const sessionId = props.id as string | undefined;
if (sessionId === state.sessionId) {
if (event.properties.info.id === state.sessionId) {
events.push({
type: "thread_started",
sessionId: state.sessionId,
@@ -1017,35 +977,28 @@ export function translateOpenCodeEvent(
}
case "message.updated": {
const info = props.info as AgentMetadata | undefined;
if (!info) {
const info = event.properties.info;
if (info.sessionID !== state.sessionId) {
break;
}
const messageId = info.id as string | undefined;
const messageSessionId = info.sessionID as string | undefined;
const role = info.role as OpenCodeMessageRole | undefined;
if (messageId && messageSessionId === state.sessionId && role) {
state.messageRoles.set(messageId, role);
if (role === "assistant") {
const modelLookupKey = resolveOpenCodeModelLookupKeyFromAssistantMessageInfo(info);
if (modelLookupKey) {
const contextWindowMaxTokens = state.modelContextWindowsByModelKey?.get(modelLookupKey);
if (contextWindowMaxTokens !== undefined) {
state.onAssistantModelContextWindowResolved?.(contextWindowMaxTokens);
}
state.messageRoles.set(info.id, info.role);
if (info.role === "assistant") {
const modelLookupKey = resolveOpenCodeModelLookupKeyFromAssistantMessage(info);
if (modelLookupKey) {
const contextWindowMaxTokens = state.modelContextWindowsByModelKey?.get(modelLookupKey);
if (contextWindowMaxTokens !== undefined) {
state.onAssistantModelContextWindowResolved?.(contextWindowMaxTokens);
}
}
if (
role === "assistant" &&
!state.emittedStructuredMessageIds.has(messageId) &&
typeof info.time === "object" &&
info.time !== null &&
"completed" in info.time
!state.emittedStructuredMessageIds.has(info.id) &&
info.time?.completed !== undefined
) {
const text = stringifyStructuredAssistantMessage(info.structured);
if (text) {
state.emittedStructuredMessageIds.add(messageId);
state.emittedStructuredMessageIds.add(info.id);
events.push({
type: "timeline",
provider: "opencode",
@@ -1058,82 +1011,46 @@ export function translateOpenCodeEvent(
}
case "message.part.updated": {
const part = props.part as AgentMetadata | undefined;
const delta = props.delta as string | undefined;
if (!part) {
const part = event.properties.part;
if (part.sessionID !== state.sessionId) {
break;
}
const partSessionId = part.sessionID as string | undefined;
if (partSessionId !== state.sessionId) {
break;
}
const messageRole = state.messageRoles.get(part.messageID);
state.partTypes.set(part.id, part.type);
const partId = part.id as string | undefined;
const messageId = part.messageID as string | undefined;
const messageRole = messageId ? state.messageRoles.get(messageId) : undefined;
const partType = part.type as string | undefined;
const partTime = part.time as { start?: number; end?: number } | undefined;
if (partId && partType) {
state.partTypes.set(partId, partType);
}
if (partType === "text") {
if (part.type === "text") {
const partKey = resolvePartDedupeKey(part, "text");
if (messageRole === "user") {
break;
}
if (!messageRole && !delta) {
break;
}
if (delta) {
if (partKey) {
state.streamedPartKeys.add(partKey);
}
events.push({
type: "timeline",
provider: "opencode",
item: { type: "assistant_message", text: delta },
});
} else if (partTime?.end) {
if (part.time?.end) {
if (partKey && state.streamedPartKeys.delete(partKey)) {
break;
}
const text = part.text as string | undefined;
if (text) {
if (part.text) {
events.push({
type: "timeline",
provider: "opencode",
item: { type: "assistant_message", text },
item: { type: "assistant_message", text: part.text },
});
}
}
} else if (partType === "reasoning") {
} else if (part.type === "reasoning") {
const partKey = resolvePartDedupeKey(part, "reasoning");
if (delta) {
if (partKey) {
state.streamedPartKeys.add(partKey);
}
events.push({
type: "timeline",
provider: "opencode",
item: { type: "reasoning", text: delta },
});
} else if (partTime?.end) {
if (part.time.end) {
if (partKey && state.streamedPartKeys.delete(partKey)) {
break;
}
const text = part.text as string | undefined;
if (text) {
if (part.text) {
events.push({
type: "timeline",
provider: "opencode",
item: { type: "reasoning", text },
item: { type: "reasoning", text: part.text },
});
}
}
} else if (partType === "tool") {
} else if (part.type === "tool") {
const parsedToolPart = OpencodeToolPartToTimelineItemSchema.safeParse(part);
if (parsedToolPart.success && parsedToolPart.data) {
events.push({
@@ -1142,7 +1059,7 @@ export function translateOpenCodeEvent(
item: parsedToolPart.data,
});
}
} else if (partType === "step-finish") {
} else if (part.type === "step-finish") {
mergeOpenCodeStepFinishUsage(state.accumulatedUsage, part);
if (hasNormalizedOpenCodeUsage(state.accumulatedUsage)) {
events.push({
@@ -1156,111 +1073,84 @@ export function translateOpenCodeEvent(
}
case "message.part.delta": {
const deltaSessionId = props.sessionID as string | undefined;
if (deltaSessionId !== state.sessionId) {
const { sessionID, messageID, partID, field, delta } = event.properties;
if (sessionID !== state.sessionId) {
break;
}
const deltaMessageId = props.messageID as string | undefined;
const deltaMessageRole = deltaMessageId
? state.messageRoles.get(deltaMessageId)
: undefined;
const deltaField = props.field as string | undefined;
const deltaText = props.delta as string | undefined;
if (!deltaText || !deltaField) {
if (!delta || !field) {
break;
}
const partId = props.partID as string | undefined;
const knownPartType = partId ? state.partTypes.get(partId) : undefined;
const isReasoning = knownPartType === "reasoning" || deltaField === "reasoning";
const messageRole = messageID ? state.messageRoles.get(messageID) : undefined;
const knownPartType = partID ? state.partTypes.get(partID) : undefined;
const isReasoning = knownPartType === "reasoning" || field === "reasoning";
if (isReasoning) {
const partKey = partId ? `reasoning:${partId}` : null;
if (partKey) {
state.streamedPartKeys.add(partKey);
if (partID) {
state.streamedPartKeys.add(`reasoning:${partID}`);
}
events.push({
type: "timeline",
provider: "opencode",
item: { type: "reasoning", text: deltaText },
item: { type: "reasoning", text: delta },
});
} else if (deltaField === "text") {
if (deltaMessageRole === "user") {
} else if (field === "text") {
if (messageRole === "user") {
break;
}
const partKey = partId ? `text:${partId}` : null;
if (partKey) {
state.streamedPartKeys.add(partKey);
if (partID) {
state.streamedPartKeys.add(`text:${partID}`);
}
events.push({
type: "timeline",
provider: "opencode",
item: { type: "assistant_message", text: deltaText },
item: { type: "assistant_message", text: delta },
});
}
break;
}
case "permission.asked": {
const sessionId = props.sessionID as string | undefined;
if (sessionId !== state.sessionId) {
if (event.properties.sessionID !== state.sessionId) {
break;
}
const requestId = props.id as string;
const permission = props.permission as string;
const metadata = props.metadata as AgentMetadata | undefined;
const patterns = props.patterns as string[] | undefined;
const permRequest: AgentPermissionRequest = {
id: requestId,
provider: "opencode",
name: permission,
kind: "tool",
title: permission,
description: patterns?.join(", "),
input: metadata,
};
events.push({
type: "permission_requested",
provider: "opencode",
request: permRequest,
request: {
id: event.properties.id,
provider: "opencode",
name: event.properties.permission,
kind: "tool",
title: event.properties.permission,
description: event.properties.patterns?.join(", "),
input: event.properties.metadata,
},
});
break;
}
case "question.asked": {
const sessionId = props.sessionID as string | undefined;
if (sessionId !== state.sessionId) {
if (event.properties.sessionID !== state.sessionId) {
break;
}
const requestId = props.id as string | undefined;
const rawQuestions = Array.isArray(props.questions) ? props.questions : [];
if (!requestId || rawQuestions.length === 0) {
break;
}
const questions = rawQuestions.flatMap((item) => {
const questionRecord = readOpenCodeRecord(item);
const question = readNonEmptyString(questionRecord?.question);
const header = readNonEmptyString(questionRecord?.header);
if (!question || !header) {
const questions = event.properties.questions.flatMap((q) => {
if (!q.question || !q.header) {
return [];
}
const options = normalizeQuestionOptions(questionRecord?.options) ?? [];
return [
{
question,
header,
options,
...(questionRecord?.multiple === true ? { multiSelect: true } : {}),
},
];
const options = q.options?.map((o) => ({
label: o.label,
...(o.description ? { description: o.description } : {}),
})) ?? [];
return [{
question: q.question,
header: q.header,
options,
...(q.multiple === true ? { multiSelect: true } : {}),
}];
});
if (questions.length === 0) {
@@ -1271,7 +1161,7 @@ export function translateOpenCodeEvent(
type: "permission_requested",
provider: "opencode",
request: {
id: requestId,
id: event.properties.id,
provider: "opencode",
name: "question",
kind: "question",
@@ -1279,7 +1169,7 @@ export function translateOpenCodeEvent(
input: { questions },
metadata: {
source: "opencode_question",
...(readOpenCodeRecord(props.tool) ?? {}),
...(event.properties.tool ?? {}),
},
},
});
@@ -1287,8 +1177,7 @@ export function translateOpenCodeEvent(
}
case "session.idle": {
const sessionId = props.sessionID as string | undefined;
if (sessionId === state.sessionId) {
if (event.properties.sessionID === state.sessionId) {
state.streamedPartKeys.clear();
state.partTypes.clear();
events.push({
@@ -1301,18 +1190,35 @@ export function translateOpenCodeEvent(
}
case "session.error": {
const sessionId = props.sessionID as string | undefined;
if (sessionId === state.sessionId) {
if (event.properties.sessionID === state.sessionId) {
state.streamedPartKeys.clear();
state.partTypes.clear();
events.push({
type: "turn_failed",
provider: "opencode",
error: normalizeTurnFailureError(props.error),
error: normalizeTurnFailureError(event.properties.error),
});
}
break;
}
case "session.status": {
if (event.properties.sessionID !== state.sessionId) {
break;
}
const { status } = event.properties;
if (status.type === "idle") {
state.streamedPartKeys.clear();
state.partTypes.clear();
events.push({
type: "turn_completed",
provider: "opencode",
usage: undefined,
});
}
// "retry" and "busy" are transient — no terminal event.
break;
}
}
return events;
@@ -1347,7 +1253,6 @@ class OpenCodeAgentSession implements AgentSession {
private activeForegroundTurnId: string | null = null;
private readonly runningToolCalls = new Map<string, ToolCallTimelineItem>();
private selectedModelContextWindowMaxTokens: number | undefined;
constructor(
config: OpenCodeAgentConfig,
client: OpencodeClient,
@@ -1513,8 +1418,12 @@ class OpenCodeAgentSession implements AgentSession {
const slashCommand = await this.resolveSlashCommandInvocation(prompt);
if (slashCommand) {
// command() blocks until completion, but events stream via SSE in the
// background — fire without awaiting so the event stream isn't starved.
// command() blocks until the server finishes processing. OpenCode's SSE
// endpoint does NOT replay past events, so if the command completes before
// our SSE reader connects, we miss `session.idle` and the turn hangs.
// Handle both success and error in the response handler as a fallback —
// finishForegroundTurn's guard prevents duplicate terminal events if the
// SSE stream already delivered the event.
void this.client.session.command({
sessionID: this.sessionId,
directory: this.config.cwd,
@@ -1530,7 +1439,17 @@ class OpenCodeAgentSession implements AgentSession {
{ type: "turn_failed", provider: "opencode", error: errorMsg },
turnId,
);
} else {
this.finishForegroundTurn(
{ type: "turn_completed", provider: "opencode", usage: undefined },
turnId,
);
}
}).catch((err) => {
this.finishForegroundTurn(
{ type: "turn_failed", provider: "opencode", error: normalizeTurnFailureError(err) },
turnId,
);
});
} else {
const promptResponse = await this.client.session.promptAsync({
@@ -1552,13 +1471,10 @@ class OpenCodeAgentSession implements AgentSession {
});
if (promptResponse.error) {
const errorMsg = normalizeTurnFailureError(promptResponse.error);
this.notifySubscribers({
type: "turn_failed",
provider: "opencode",
error: errorMsg,
});
throw new Error(errorMsg);
this.finishForegroundTurn(
{ type: "turn_failed", provider: "opencode", error: normalizeTurnFailureError(promptResponse.error) },
turnId,
);
}
}
@@ -1576,12 +1492,13 @@ class OpenCodeAgentSession implements AgentSession {
turnId: string,
turnAbortController: AbortController,
): Promise<void> {
const eventsResult = await this.client.event.subscribe({
directory: this.config.cwd,
});
try {
for await (const event of eventsResult.stream) {
const result = await this.client.event.subscribe(
{ directory: this.config.cwd },
{ signal: turnAbortController.signal, sseMaxRetryAttempts: 0 },
);
for await (const event of result.stream) {
if (turnAbortController.signal.aborted || this.activeForegroundTurnId !== turnId) {
break;
}
@@ -1653,6 +1570,9 @@ class OpenCodeAgentSession implements AgentSession {
this.runningToolCalls.clear();
}
this.activeForegroundTurnId = null;
// Abort the SSE connection so the SDK tears down the underlying fetch.
this.abortController?.abort();
this.abortController = null;
this.notifySubscribers(event, turnId);
}
@@ -1708,16 +1628,12 @@ class OpenCodeAgentSession implements AgentSession {
return;
}
const messages = response.data;
for (const message of messages) {
const { info, parts } = message;
const role = info.role as "user" | "assistant";
if (role === "user") {
// Extract user message text from parts
const textParts = parts.filter((p) => (p as { type?: string }).type === "text");
const text = textParts.map((p) => (p as { text?: string }).text ?? "").join("");
for (const { info, parts } of response.data) {
if (info.role === "user") {
const text = parts
.filter((p): p is Extract<OpenCodePart, { type: "text" }> => p.type === "text")
.map((p) => p.text)
.join("");
if (text) {
yield {
@@ -1726,49 +1642,40 @@ class OpenCodeAgentSession implements AgentSession {
item: { type: "user_message", text },
};
}
} else if (role === "assistant") {
} else {
let emittedAssistantText = false;
// Process each part
for (const part of parts) {
const partType = (part as { type?: string }).type;
if (partType === "text") {
const text = (part as { text?: string }).text;
if (text) {
if (part.type === "text") {
if (part.text) {
emittedAssistantText = true;
yield {
type: "timeline",
provider: "opencode",
item: { type: "assistant_message", text },
item: { type: "assistant_message", text: part.text },
};
}
} else if (partType === "reasoning") {
const text = (part as { text?: string }).text;
if (text) {
} else if (part.type === "reasoning") {
if (part.text) {
yield {
type: "timeline",
provider: "opencode",
item: { type: "reasoning", text },
item: { type: "reasoning", text: part.text },
};
}
} else if (partType === "tool") {
} else if (part.type === "tool") {
const parsedToolPart = OpencodeToolPartToTimelineItemSchema.safeParse(part);
if (parsedToolPart.success) {
if (parsedToolPart.data) {
yield {
type: "timeline",
provider: "opencode",
item: parsedToolPart.data,
};
}
if (parsedToolPart.success && parsedToolPart.data) {
yield {
type: "timeline",
provider: "opencode",
item: parsedToolPart.data,
};
}
}
}
if (!emittedAssistantText) {
const text = stringifyStructuredAssistantMessage(
(info as { structured?: unknown }).structured,
);
const text = stringifyStructuredAssistantMessage(info.structured);
if (text) {
yield {
type: "timeline",
@@ -2027,7 +1934,7 @@ class OpenCodeAgentSession implements AgentSession {
);
}
private translateEvent(event: unknown): AgentStreamEvent[] {
private translateEvent(event: OpenCodeEvent): AgentStreamEvent[] {
const translated = translateOpenCodeEvent(event, {
sessionId: this.sessionId,
messageRoles: this.messageRoles,
packages/server/src/server/agent/providers/pi-acp-agent.ts
+3 -3
View File
@@ -326,7 +326,7 @@ export class PiACPAgentClient extends ACPAgentClient {
if (!existsSync(resolvedPiAcpPath)) {
return false;
}
if (!isCommandAvailable(process.env.PI_ACP_PI_COMMAND ?? "pi")) {
if (!(await isCommandAvailable(process.env.PI_ACP_PI_COMMAND ?? "pi"))) {
return false;
}
return (
@@ -340,8 +340,8 @@ export class PiACPAgentClient extends ACPAgentClient {
async getDiagnostic(): Promise<{ diagnostic: string }> {
try {
const piCommand = process.env.PI_ACP_PI_COMMAND ?? "pi";
const piCliPath = findExecutable(piCommand);
const piVersion = piCliPath ? resolveBinaryVersion(piCliPath) : "unknown";
const piCliPath = await findExecutable(piCommand);
const piVersion = piCliPath ? await resolveBinaryVersion(piCliPath) : "unknown";
const authConfigPath = join(homedir(), ".pi", "agent", "auth.json");
const available = await this.isAvailable();
let modelsValue = "Not checked";
packages/server/src/server/daemon-e2e/agent-configs.ts
+6 -6
View File
@@ -7,7 +7,7 @@ import { join, dirname, resolve } from "node:path";
import { fileURLToPath } from "node:url";
import { homedir } from "node:os";
import dotenv from "dotenv";
import { isCommandAvailable } from "../../utils/executable.js";
import { isCommandAvailableSync } from "../../utils/executable.js";
// Load .env.test eagerly so isProviderAvailable() has credentials at collection time.
const serverRoot = resolve(dirname(fileURLToPath(import.meta.url)), "../../..");
@@ -105,21 +105,21 @@ export function isProviderAvailable(provider: AgentProvider): boolean {
switch (provider) {
case "claude":
return (
isCommandAvailable("claude") &&
isCommandAvailableSync("claude") &&
(Boolean(process.env.CLAUDE_CODE_OAUTH_TOKEN) || Boolean(process.env.ANTHROPIC_API_KEY))
);
case "codex":
return (
isCommandAvailable("codex") &&
isCommandAvailableSync("codex") &&
(existsSync(join(homedir(), ".codex", "auth.json")) || Boolean(process.env.OPENAI_API_KEY))
);
case "copilot":
return isCommandAvailable("copilot");
return isCommandAvailableSync("copilot");
case "opencode":
return isCommandAvailable("opencode");
return isCommandAvailableSync("opencode");
case "pi":
return (
isCommandAvailable(process.env.PI_ACP_PI_COMMAND ?? "pi") &&
isCommandAvailableSync(process.env.PI_ACP_PI_COMMAND ?? "pi") &&
(Boolean(process.env.OPENAI_API_KEY) ||
Boolean(process.env.ANTHROPIC_API_KEY) ||
Boolean(process.env.OPENROUTER_API_KEY) ||
packages/server/src/server/editor-targets.test.ts
+6 -6
View File
@@ -2,10 +2,10 @@ import { describe, expect, it, vi } from "vitest";
import { listAvailableEditorTargets, openInEditorTarget } from "./editor-targets.js";
describe("editor-targets", () => {
it("lists available editors in deterministic order", () => {
it("lists available editors in deterministic order", async () => {
const available = new Set(["code", "cursor", "explorer"]);
const editors = listAvailableEditorTargets({
const editors = await listAvailableEditorTargets({
platform: "win32",
findExecutable: (command) => (available.has(command) ? command : null),
});
@@ -17,8 +17,8 @@ describe("editor-targets", () => {
]);
});
it("returns Finder on macOS", () => {
const editors = listAvailableEditorTargets({
it("returns Finder on macOS", async () => {
const editors = await listAvailableEditorTargets({
platform: "darwin",
findExecutable: (command) => (command === "open" ? "/usr/bin/open" : null),
});
@@ -26,8 +26,8 @@ describe("editor-targets", () => {
expect(editors).toEqual([{ id: "finder", label: "Finder" }]);
});
it("returns the generic file manager target on Linux", () => {
const editors = listAvailableEditorTargets({
it("returns the generic file manager target on Linux", async () => {
const editors = await listAvailableEditorTargets({
platform: "linux",
findExecutable: (command) => (command === "xdg-open" ? "/usr/bin/xdg-open" : null),
});
packages/server/src/server/editor-targets.ts
+19 -20
View File
@@ -18,7 +18,7 @@ type EditorTargetDefinition = {
type ListAvailableEditorTargetsDependencies = {
platform?: NodeJS.Platform;
findExecutable?: (command: string) => string | null;
findExecutable?: (command: string) => string | null | Promise<string | null>;
};
type OpenInEditorTargetDependencies = ListAvailableEditorTargetsDependencies & {
@@ -65,28 +65,27 @@ function resolveEditorTargetDefinition(editorId: EditorTargetId): EditorTargetDe
return target;
}
export function listAvailableEditorTargets(
export async function listAvailableEditorTargets(
dependencies: ListAvailableEditorTargetsDependencies = {},
): EditorTargetDescriptorPayload[] {
): Promise<EditorTargetDescriptorPayload[]> {
const platform = dependencies.platform ?? process.platform;
const findExecutableFn = dependencies.findExecutable ?? findExecutable;
return EDITOR_TARGETS.flatMap((target) => {
const results: EditorTargetDescriptorPayload[] = [];
for (const target of EDITOR_TARGETS) {
if (!isTargetSupportedOnPlatform(target, platform)) {
return [];
continue;
}
const executable = findExecutableFn(target.command);
const executable = await findExecutableFn(target.command);
if (!executable) {
return [];
continue;
}
return [
{
id: target.id,
label: target.label,
},
];
});
results.push({
id: target.id,
label: target.label,
});
}
return results;
}
type Launch = {
@@ -94,17 +93,17 @@ type Launch = {
args: string[];
};
function resolveEditorLaunch(input: {
async function resolveEditorLaunch(input: {
editorId: EditorTargetId;
path: string;
platform: NodeJS.Platform;
findExecutableFn: typeof findExecutable;
}): Launch {
findExecutableFn: (command: string) => string | null | Promise<string | null>;
}): Promise<Launch> {
const target = resolveEditorTargetDefinition(input.editorId);
if (!isTargetSupportedOnPlatform(target, input.platform)) {
throw new Error(`Editor target unavailable: ${target.label}`);
}
const executable = input.findExecutableFn(target.command);
const executable = await input.findExecutableFn(target.command);
if (!executable) {
throw new Error(`Editor target unavailable: ${target.label}`);
}
@@ -135,7 +134,7 @@ export async function openInEditorTarget(
throw new Error(`Path does not exist: ${pathToOpen}`);
}
const launch = resolveEditorLaunch({
const launch = await resolveEditorLaunch({
editorId: input.editorId,
path: pathToOpen,
platform,
packages/server/src/server/exports.ts
+2 -1
View File
@@ -33,7 +33,8 @@ export {
export {
applyProviderEnv,
} from "./agent/provider-launch-config.js";
export { findExecutable, quoteWindowsArgument, quoteWindowsCommand } from "../utils/executable.js";
export { findExecutable, findExecutableSync, quoteWindowsArgument, quoteWindowsCommand } from "../utils/executable.js";
export { spawnProcess } from "../utils/spawn.js";
// Provider manifest (source of truth for provider definitions)
export {
packages/server/src/utils/checkout-git.ts
+10 -9
View File
@@ -1,4 +1,5 @@
import { exec, execFile, spawn } from "child_process";
import { exec, execFile } from "child_process";
import { spawnProcess } from "./spawn.js";
import { promisify } from "util";
import { resolve, dirname, basename } from "path";
import { realpathSync } from "fs";
@@ -121,7 +122,7 @@ async function spawnLimitedText(params: {
const accept = new Set(params.acceptExitCodes ?? [0]);
return new Promise((resolvePromise, rejectPromise) => {
const child = spawn(params.cmd, params.args, {
const child = spawnProcess(params.cmd, params.args, {
cwd: params.cwd,
env: params.env,
stdio: ["ignore", "pipe", "pipe"],
@@ -140,7 +141,7 @@ async function spawnLimitedText(params: {
}
};
child.stdout.on("data", (chunk: Buffer) => {
child.stdout!.on("data", (chunk: Buffer) => {
if (truncated) return;
stdoutBytes += chunk.length;
if (stdoutBytes > params.maxBytes) {
@@ -153,7 +154,7 @@ async function spawnLimitedText(params: {
// We don't buffer stderr (it can be large too). Keep it minimal for debugging.
let stderrPreview = "";
child.stderr.on("data", (chunk: Buffer) => {
child.stderr!.on("data", (chunk: Buffer) => {
if (stderrPreview.length > 2048) return;
stderrPreview += chunk.toString("utf8");
});
@@ -1935,9 +1936,9 @@ const ReviewDecisionSchema = z
type CheckRunNode = z.infer<typeof CheckRunNodeSchema>;
type StatusContextNode = z.infer<typeof StatusContextNodeSchema>;
function resolveGhPath(): string {
async function resolveGhPath(): Promise<string> {
if (cachedGhPath === undefined) {
cachedGhPath = findExecutable("gh");
cachedGhPath = await findExecutable("gh");
}
if (cachedGhPath === null) {
throw new Error("GitHub CLI (gh) is not installed or not in PATH");
@@ -2164,7 +2165,7 @@ export async function createPullRequest(
options: CreatePullRequestOptions,
): Promise<{ url: string; number: number }> {
await requireGitRepo(cwd);
const ghPath = resolveGhPath();
const ghPath = await resolveGhPath();
const repo = await resolveGitHubRepo(cwd);
if (!repo) {
throw new Error("Unable to determine GitHub repo from git remote");
@@ -2237,7 +2238,7 @@ async function getPullRequestStatusUncached(cwd: string): Promise<PullRequestSta
}
let ghPath: string;
try {
ghPath = resolveGhPath();
ghPath = await resolveGhPath();
} catch {
return {
status: null,
@@ -2319,7 +2320,7 @@ export async function searchGitHubIssuesAndPrs(
await requireGitRepo(cwd);
let ghPath: string;
try {
ghPath = resolveGhPath();
ghPath = await resolveGhPath();
} catch {
return { items: [], githubFeaturesEnabled: false };
}
packages/server/src/utils/executable.test.ts
+19 -45
View File
@@ -1,12 +1,12 @@
import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
import {
findExecutable,
findExecutableSync,
quoteWindowsArgument,
quoteWindowsCommand,
} from "./executable.js";
type FindExecutableDependencies = NonNullable<Parameters<typeof findExecutable>[1]>;
type FindExecutableDependencies = NonNullable<Parameters<typeof findExecutableSync>[1]>;
function createFindExecutableDependencies(): FindExecutableDependencies {
return {
@@ -22,57 +22,31 @@ beforeEach(() => {
findExecutableDependencies = createFindExecutableDependencies();
});
describe("findExecutable", () => {
test("on Windows, resolves executables using current machine and user PATH entries", () => {
describe("findExecutableSync", () => {
test("on Windows, resolves executables using where.exe with inherited PATH", () => {
findExecutableDependencies.platform = vi.fn(() => "win32");
process.env.Path = "C:\\Windows\\System32";
findExecutableDependencies.execFileSync.mockImplementation(
((command: string, args?: string[]) => {
if (command === "powershell") {
return "C:\\Windows\\System32\r\nC:\\Users\\boudr\\.local\\bin\r\n";
}
if (command === "where.exe") {
return "C:\\Users\\boudr\\.local\\bin\\claude.exe\r\n";
}
throw new Error(`unexpected command ${command}`);
}) as any,
findExecutableDependencies.execFileSync.mockReturnValue(
"C:\\Users\\boudr\\.local\\bin\\claude.exe\r\n",
);
expect(findExecutable("claude", findExecutableDependencies)).toBe(
expect(findExecutableSync("claude", findExecutableDependencies)).toBe(
"C:\\Users\\boudr\\.local\\bin\\claude.exe",
);
const powershellCall = findExecutableDependencies.execFileSync.mock.calls[0];
expect(powershellCall?.[0]).toBe("powershell");
expect(powershellCall?.[1]).toContain("-NoProfile");
expect(powershellCall?.[1]).toContain("-NonInteractive");
expect(powershellCall?.[1]).toContain(
'$machine = [Environment]::GetEnvironmentVariable("Path", "Machine"); $user = [Environment]::GetEnvironmentVariable("Path", "User"); if ($machine) { Write-Output $machine }; if ($user) { Write-Output $user }',
);
const whereCall = findExecutableDependencies.execFileSync.mock.calls[1];
expect(whereCall?.[0]).toBe("where.exe");
expect(whereCall?.[1]).toEqual(["claude"]);
expect(whereCall?.[2]?.encoding).toBe("utf8");
const env = whereCall?.[2]?.env as Record<string, string | undefined>;
expect(env.PATH).toContain("C:\\Users\\boudr\\.local\\bin");
expect(env.Path).toContain("C:\\Users\\boudr\\.local\\bin");
expect(findExecutableDependencies.execFileSync).toHaveBeenCalledOnce();
const call = findExecutableDependencies.execFileSync.mock.calls[0];
expect(call?.[0]).toBe("where.exe");
expect(call?.[1]).toEqual(["claude"]);
expect(call?.[2]?.encoding).toBe("utf8");
expect(call?.[2]?.windowsHide).toBe(true);
});
test("on Windows, preserves the first where.exe match", () => {
findExecutableDependencies.platform = vi.fn(() => "win32");
process.env.Path = "C:\\Windows\\System32";
findExecutableDependencies.execFileSync.mockImplementation(
((command: string) => {
if (command === "powershell") {
return "C:\\Windows\\System32\r\nC:\\nvm4w\\nodejs\r\n";
}
if (command === "where.exe") {
return "C:\\nvm4w\\nodejs\\codex\r\nC:\\nvm4w\\nodejs\\codex.cmd\r\n";
}
throw new Error(`unexpected command ${command}`);
}) as any,
findExecutableDependencies.execFileSync.mockReturnValue(
"C:\\nvm4w\\nodejs\\codex\r\nC:\\nvm4w\\nodejs\\codex.cmd\r\n",
);
expect(findExecutable("codex", findExecutableDependencies)).toBe("C:\\nvm4w\\nodejs\\codex");
expect(findExecutableSync("codex", findExecutableDependencies)).toBe("C:\\nvm4w\\nodejs\\codex");
});
test("on Unix, uses the last line from which output", () => {
@@ -80,7 +54,7 @@ describe("findExecutable", () => {
"/usr/local/bin/codex\n",
);
expect(findExecutable("codex", findExecutableDependencies)).toBe("/usr/local/bin/codex");
expect(findExecutableSync("codex", findExecutableDependencies)).toBe("/usr/local/bin/codex");
expect(findExecutableDependencies.execFileSync).toHaveBeenCalledWith(
"which",
["codex"],
@@ -92,7 +66,7 @@ describe("findExecutable", () => {
findExecutableDependencies.execFileSync.mockReturnValue("codex\n");
const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
expect(findExecutable("codex", findExecutableDependencies)).toBeNull();
expect(findExecutableSync("codex", findExecutableDependencies)).toBeNull();
expect(warnSpy).toHaveBeenCalledOnce();
warnSpy.mockRestore();
@@ -101,7 +75,7 @@ describe("findExecutable", () => {
test("returns direct paths when they exist", () => {
findExecutableDependencies.existsSync.mockReturnValue(true);
expect(findExecutable("/usr/local/bin/codex", findExecutableDependencies)).toBe(
expect(findExecutableSync("/usr/local/bin/codex", findExecutableDependencies)).toBe(
"/usr/local/bin/codex",
);
expect(findExecutableDependencies.existsSync).toHaveBeenCalledWith("/usr/local/bin/codex");
packages/server/src/utils/executable.ts
+56 -52
View File
@@ -1,40 +1,17 @@
import { execFileSync } from "node:child_process";
import { execFile, execFileSync } from "node:child_process";
import { existsSync } from "node:fs";
import { platform } from "node:os";
import path from "node:path";
import { promisify } from "node:util";
const execFileAsync = promisify(execFile);
export interface FindExecutableDependencies {
execFileSync: typeof execFileSync;
existsSync: typeof existsSync;
platform: typeof platform;
}
function resolveWindowsPathEntries(deps: FindExecutableDependencies): string[] {
try {
const output = deps.execFileSync(
"powershell",
[
"-NoProfile",
"-NonInteractive",
"-Command",
[
'$machine = [Environment]::GetEnvironmentVariable("Path", "Machine")',
'$user = [Environment]::GetEnvironmentVariable("Path", "User")',
"if ($machine) { Write-Output $machine }",
"if ($user) { Write-Output $user }",
].join("; "),
],
{ encoding: "utf8" },
);
return output
.split(/\r?\n/)
.flatMap((line) => line.split(";"))
.map((entry) => entry.trim())
.filter((entry) => entry.length > 0);
} catch {
return [];
}
}
function resolveExecutableFromWhichOutput(
name: string,
output: string,
@@ -61,15 +38,13 @@ function resolveExecutableFromWhichOutput(
}
/**
* On Unix we use plain `which` — the daemon's process.env.PATH is enriched
* with the login shell environment at Electron desktop startup.
* On Unix we use `which`. On Windows we use `where.exe`.
*
* On Windows we augment the daemon PATH with machine/user registry PATH values
* and return the first `where.exe` match. Launch-time execution decides whether
* the resolved path needs `cmd.exe` semantics (for example npm shims under
* nvm4w such as `C:\nvm4w\nodejs\codex`).
* Both rely on the inherited process.env.PATH — on macOS/Linux, Electron
* enriches it at startup via inheritLoginShellEnv(); on Windows, Electron
* inherits the full user environment from Explorer.
*/
export function findExecutable(
export function findExecutableSync(
name: string,
dependencies?: FindExecutableDependencies,
): string | null {
@@ -91,21 +66,10 @@ export function findExecutable(
if (deps.platform() === "win32") {
try {
const inheritedPath = process.env["Path"] ?? process.env["PATH"] ?? "";
const resolvedPath = [
...inheritedPath.split(";"),
...resolveWindowsPathEntries(deps),
]
.map((entry) => entry.trim())
.filter((entry) => entry.length > 0)
.filter((entry, index, entries) => entries.indexOf(entry) === index)
.join(";");
const env = {
...process.env,
PATH: resolvedPath,
Path: resolvedPath,
};
const out = deps.execFileSync("where.exe", [trimmed], { encoding: "utf8", env }).trim();
const out = deps.execFileSync("where.exe", [trimmed], {
encoding: "utf8",
windowsHide: true,
}).trim();
return (
out
.split(/\r?\n/)
@@ -128,8 +92,48 @@ export function findExecutable(
}
}
export function isCommandAvailable(command: string): boolean {
return findExecutable(command) !== null;
export function isCommandAvailableSync(command: string): boolean {
return findExecutableSync(command) !== null;
}
export async function findExecutable(name: string): Promise<string | null> {
const trimmed = name.trim();
if (!trimmed) {
return null;
}
if (trimmed.includes("/") || trimmed.includes("\\")) {
return existsSync(trimmed) ? trimmed : null;
}
if (platform() === "win32") {
try {
const { stdout } = await execFileAsync("where.exe", [trimmed], {
encoding: "utf8",
windowsHide: true,
});
return (
stdout
.trim()
.split(/\r?\n/)
.map((line) => line.trim())
.find((line) => line.length > 0) ?? null
);
} catch {
return null;
}
}
try {
const { stdout } = await execFileAsync("which", [trimmed], { encoding: "utf8" });
return resolveExecutableFromWhichOutput(trimmed, stdout.trim(), "which");
} catch {
return null;
}
}
export async function isCommandAvailable(command: string): Promise<boolean> {
return (await findExecutable(command)) !== null;
}
/**
packages/server/src/utils/spawn.ts
+42
View File
@@ -0,0 +1,42 @@
import {
spawn,
type ChildProcess,
type SpawnOptions,
} from "node:child_process";
/**
* Platform-aware spawn that centralizes Windows shell and quoting concerns.
*
* On Windows:
* - Enables `shell: true` (routes through cmd.exe) unless the caller explicitly sets `shell`
* - Quotes the command and arguments so paths with spaces survive cmd.exe parsing
* - Always sets `windowsHide: true` to prevent console window flashes
*
* On other platforms the call is passed through to `spawn` unchanged (with `windowsHide: true`).
*/
export function spawnProcess(
command: string,
args: string[],
options?: SpawnOptions,
): ChildProcess {
const isWindows = process.platform === "win32";
const resolvedCommand = isWindows ? quoteForCmd(command) : command;
const resolvedArgs = isWindows ? args.map(quoteForCmd) : args;
return spawn(resolvedCommand, resolvedArgs, {
...options,
shell: options?.shell ?? isWindows,
windowsHide: true,
});
}
/**
* Quote a string for cmd.exe if it contains spaces and isn't already quoted.
* No-op for strings without spaces or strings that are already double-quoted.
*/
function quoteForCmd(value: string): string {
if (!value.includes(" ")) return value;
if (value.startsWith('"') && value.endsWith('"')) return value;
return `"${value}"`;
}