657 lines
22 KiB
TypeScript
657 lines
22 KiB
TypeScript
import { EventEmitter } from 'node:events';
|
|
import { mkdirSync } from 'node:fs';
|
|
import { join } from 'node:path';
|
|
import {
|
|
execFile,
|
|
spawn as nodeSpawn,
|
|
type ChildProcess,
|
|
type SpawnOptionsWithoutStdio,
|
|
} from 'node:child_process';
|
|
import {
|
|
ensureBundledCourseSkills,
|
|
ensureBundledSuperpowersPlugin,
|
|
getManagedOpencodeConfigDir,
|
|
} from './superpowers';
|
|
import { logger } from '../utils/logger';
|
|
import {
|
|
prependPythonToPath,
|
|
type PythonRuntime,
|
|
} from '../utils/python-runtime';
|
|
import { promisify } from 'node:util';
|
|
|
|
export type OpencodeLifecycleState = 'stopped' | 'starting' | 'running' | 'error';
|
|
|
|
export interface OpencodeStatus {
|
|
state: OpencodeLifecycleState;
|
|
port: number;
|
|
url?: string;
|
|
pid?: number;
|
|
error?: string;
|
|
startedAt?: number;
|
|
}
|
|
|
|
type SpawnFn = (
|
|
command: string,
|
|
args: string[],
|
|
options: SpawnOptionsWithoutStdio,
|
|
) => ChildProcess;
|
|
|
|
type ConfigProvider = () => Promise<Record<string, unknown>> | Record<string, unknown>;
|
|
type RuntimeConfigProvider = () =>
|
|
| Promise<{ config: Record<string, unknown>; env?: Record<string, string> }>
|
|
| { config: Record<string, unknown>; env?: Record<string, string> };
|
|
type RuntimeConfig = { config: Record<string, unknown>; env: Record<string, string> };
|
|
type SpawnCommand = {
|
|
command: string;
|
|
args: string[];
|
|
env: Record<string, string>;
|
|
shell?: boolean;
|
|
};
|
|
type PortOwner = {
|
|
pid: number;
|
|
executablePath?: string;
|
|
commandLine?: string;
|
|
};
|
|
type FindPortOwner = (port: number) => Promise<PortOwner | null>;
|
|
type KillProcess = (pid: number) => boolean;
|
|
|
|
type RuntimeProviderDiagnostics = {
|
|
id: string;
|
|
name?: string;
|
|
npm?: string;
|
|
baseURL?: string;
|
|
modelIds: string[];
|
|
hasApiKey: boolean;
|
|
apiKeyEnv?: string;
|
|
headerNames: string[];
|
|
};
|
|
|
|
type RuntimeMcpServerDiagnostics = {
|
|
id: string;
|
|
type?: string;
|
|
enabled?: boolean;
|
|
command: string[];
|
|
envKeys: string[];
|
|
};
|
|
|
|
export function summarizeRuntimeConfigForDiagnostics(
|
|
config: Record<string, unknown>,
|
|
env: Record<string, string>,
|
|
): {
|
|
model: string | null;
|
|
smallModel: string | null;
|
|
providerIds: string[];
|
|
enabledProviderIds: string[];
|
|
envKeys: string[];
|
|
providers: RuntimeProviderDiagnostics[];
|
|
mcpServerIds: string[];
|
|
mcpServers: RuntimeMcpServerDiagnostics[];
|
|
} {
|
|
const providerRecord = config.provider && typeof config.provider === 'object' && !Array.isArray(config.provider)
|
|
? config.provider as Record<string, unknown>
|
|
: {};
|
|
const providerIds = Object.keys(providerRecord);
|
|
const enabledProviderIds = Array.isArray(config.enabled_providers)
|
|
? config.enabled_providers.filter((item): item is string => typeof item === 'string')
|
|
: providerIds;
|
|
const providers = providerIds.map((providerId) => {
|
|
const rawProvider = providerRecord[providerId];
|
|
const provider = rawProvider && typeof rawProvider === 'object' && !Array.isArray(rawProvider)
|
|
? rawProvider as Record<string, unknown>
|
|
: {};
|
|
const options = provider.options && typeof provider.options === 'object' && !Array.isArray(provider.options)
|
|
? provider.options as Record<string, unknown>
|
|
: {};
|
|
const models = provider.models && typeof provider.models === 'object' && !Array.isArray(provider.models)
|
|
? provider.models as Record<string, unknown>
|
|
: {};
|
|
const headers = options.headers && typeof options.headers === 'object' && !Array.isArray(options.headers)
|
|
? options.headers as Record<string, unknown>
|
|
: {};
|
|
const apiKey = typeof options.apiKey === 'string' ? options.apiKey : undefined;
|
|
const apiKeyEnv = apiKey?.match(/^\{env:([^}]+)\}$/)?.[1];
|
|
return {
|
|
id: providerId,
|
|
...(typeof provider.name === 'string' ? { name: provider.name } : {}),
|
|
...(typeof provider.npm === 'string' ? { npm: provider.npm } : {}),
|
|
...(typeof options.baseURL === 'string' ? { baseURL: options.baseURL } : {}),
|
|
modelIds: Object.keys(models),
|
|
hasApiKey: Boolean(apiKey),
|
|
...(apiKeyEnv ? { apiKeyEnv } : {}),
|
|
headerNames: Object.keys(headers),
|
|
};
|
|
});
|
|
const mcpRecord = config.mcp && typeof config.mcp === 'object' && !Array.isArray(config.mcp)
|
|
? config.mcp as Record<string, unknown>
|
|
: {};
|
|
const mcpServerIds = Object.keys(mcpRecord);
|
|
const mcpServers = mcpServerIds.map((serverId) => {
|
|
const rawServer = mcpRecord[serverId];
|
|
const server = rawServer && typeof rawServer === 'object' && !Array.isArray(rawServer)
|
|
? rawServer as Record<string, unknown>
|
|
: {};
|
|
const command = Array.isArray(server.command)
|
|
? server.command.filter((item): item is string => typeof item === 'string')
|
|
: [];
|
|
const serverEnv = server.env && typeof server.env === 'object' && !Array.isArray(server.env)
|
|
? server.env as Record<string, unknown>
|
|
: {};
|
|
return {
|
|
id: serverId,
|
|
...(typeof server.type === 'string' ? { type: server.type } : {}),
|
|
...(typeof server.enabled === 'boolean' ? { enabled: server.enabled } : {}),
|
|
command,
|
|
envKeys: Object.keys(serverEnv).sort(),
|
|
};
|
|
});
|
|
|
|
return {
|
|
model: typeof config.model === 'string' ? config.model : null,
|
|
smallModel: typeof config.small_model === 'string' ? config.small_model : null,
|
|
providerIds,
|
|
enabledProviderIds,
|
|
envKeys: Object.keys(env).sort(),
|
|
providers,
|
|
mcpServerIds,
|
|
mcpServers,
|
|
};
|
|
}
|
|
|
|
export interface OpencodeManagerOptions {
|
|
port: number;
|
|
binPath: string;
|
|
userDataDir?: string;
|
|
bundledSuperpowersDir?: string;
|
|
bundledCourseSkillsDir?: string;
|
|
pythonRuntime?: PythonRuntime;
|
|
spawn?: SpawnFn;
|
|
configProvider?: ConfigProvider;
|
|
runtimeConfigProvider?: RuntimeConfigProvider;
|
|
startupTimeoutMs?: number;
|
|
findPortOwner?: FindPortOwner;
|
|
killProcess?: KillProcess;
|
|
}
|
|
|
|
const execFileAsync = promisify(execFile);
|
|
const ATTACHED_SERVER_STOP_TIMEOUT_MS = 2_000;
|
|
const ATTACHED_SERVER_STOP_POLL_MS = 100;
|
|
|
|
function sleep(ms: number): Promise<void> {
|
|
return new Promise((resolve) => {
|
|
setTimeout(resolve, ms);
|
|
});
|
|
}
|
|
|
|
function normalizeComparablePath(value: string | undefined): string | null {
|
|
const trimmed = value?.trim();
|
|
if (!trimmed) return null;
|
|
return trimmed.replace(/^"+|"+$/g, '').replace(/\\/g, '/').toLowerCase();
|
|
}
|
|
|
|
function isManagedOpencodePortOwner(owner: PortOwner, binPath: string): boolean {
|
|
const expectedPath = normalizeComparablePath(binPath);
|
|
if (!expectedPath) return false;
|
|
|
|
const executablePath = normalizeComparablePath(owner.executablePath);
|
|
if (executablePath && executablePath === expectedPath) return true;
|
|
|
|
const commandLine = normalizeComparablePath(owner.commandLine);
|
|
return Boolean(commandLine?.includes(expectedPath));
|
|
}
|
|
|
|
function normalizePortOwner(input: unknown): PortOwner | null {
|
|
if (!input || typeof input !== 'object' || Array.isArray(input)) return null;
|
|
const record = input as Record<string, unknown>;
|
|
const rawPid = record.pid ?? record.ProcessId ?? record.processId;
|
|
const pid = typeof rawPid === 'number'
|
|
? rawPid
|
|
: typeof rawPid === 'string'
|
|
? Number(rawPid)
|
|
: NaN;
|
|
if (!Number.isInteger(pid) || pid <= 0) return null;
|
|
return {
|
|
pid,
|
|
...(typeof record.executablePath === 'string' ? { executablePath: record.executablePath } : {}),
|
|
...(typeof record.ExecutablePath === 'string' ? { executablePath: record.ExecutablePath } : {}),
|
|
...(typeof record.commandLine === 'string' ? { commandLine: record.commandLine } : {}),
|
|
...(typeof record.CommandLine === 'string' ? { commandLine: record.CommandLine } : {}),
|
|
};
|
|
}
|
|
|
|
async function findWindowsPortOwner(port: number): Promise<PortOwner | null> {
|
|
const script = [
|
|
`$connection = Get-NetTCPConnection -LocalPort ${port} -State Listen -ErrorAction SilentlyContinue | Select-Object -First 1`,
|
|
'if (-not $connection) { exit 0 }',
|
|
'$process = Get-CimInstance Win32_Process -Filter "ProcessId=$($connection.OwningProcess)" -ErrorAction SilentlyContinue',
|
|
'if (-not $process) { [pscustomobject]@{ pid = [int]$connection.OwningProcess } | ConvertTo-Json -Compress; exit 0 }',
|
|
'[pscustomobject]@{ pid = [int]$process.ProcessId; executablePath = $process.ExecutablePath; commandLine = $process.CommandLine } | ConvertTo-Json -Compress',
|
|
].join('\n');
|
|
const { stdout } = await execFileAsync(
|
|
'powershell.exe',
|
|
['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-Command', script],
|
|
{ encoding: 'utf8', windowsHide: true },
|
|
);
|
|
const trimmed = stdout.trim();
|
|
if (!trimmed) return null;
|
|
return normalizePortOwner(JSON.parse(trimmed) as unknown);
|
|
}
|
|
|
|
async function findUnixPortOwner(port: number): Promise<PortOwner | null> {
|
|
const { stdout } = await execFileAsync(
|
|
'lsof',
|
|
['-nP', `-iTCP:${port}`, '-sTCP:LISTEN', '-Fp'],
|
|
{ encoding: 'utf8' },
|
|
);
|
|
const lines = stdout.split(/\r?\n/);
|
|
let pid: number | null = null;
|
|
for (const line of lines) {
|
|
if (line.startsWith('p')) {
|
|
const nextPid = Number(line.slice(1));
|
|
if (Number.isInteger(nextPid) && nextPid > 0) {
|
|
pid = nextPid;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (!pid) return null;
|
|
|
|
try {
|
|
const { stdout: commandOutput } = await execFileAsync(
|
|
'ps',
|
|
['-p', String(pid), '-o', 'command='],
|
|
{ encoding: 'utf8' },
|
|
);
|
|
const commandLine = commandOutput.trim();
|
|
return commandLine ? { pid, commandLine } : { pid };
|
|
} catch {
|
|
return { pid };
|
|
}
|
|
}
|
|
|
|
async function findListeningPortOwner(port: number): Promise<PortOwner | null> {
|
|
try {
|
|
return process.platform === 'win32'
|
|
? await findWindowsPortOwner(port)
|
|
: await findUnixPortOwner(port);
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
function killProcessByPid(pid: number): boolean {
|
|
if (pid === process.pid) return false;
|
|
try {
|
|
return process.kill(pid);
|
|
} catch {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
export class OpencodeManager extends EventEmitter {
|
|
private readonly spawnProcess: SpawnFn;
|
|
private readonly configProvider?: ConfigProvider;
|
|
private readonly runtimeConfigProvider?: RuntimeConfigProvider;
|
|
private readonly findPortOwner: FindPortOwner;
|
|
private readonly killProcess: KillProcess;
|
|
private readonly startupTimeoutMs: number;
|
|
private proc: ChildProcess | null = null;
|
|
private startPromise: Promise<OpencodeStatus> | null = null;
|
|
private status: OpencodeStatus;
|
|
|
|
constructor(private readonly options: OpencodeManagerOptions) {
|
|
super();
|
|
this.spawnProcess = options.spawn ?? nodeSpawn;
|
|
this.configProvider = options.configProvider;
|
|
this.runtimeConfigProvider = options.runtimeConfigProvider;
|
|
this.findPortOwner = options.findPortOwner ?? findListeningPortOwner;
|
|
this.killProcess = options.killProcess ?? killProcessByPid;
|
|
this.startupTimeoutMs = options.startupTimeoutMs ?? 10_000;
|
|
this.status = { state: 'stopped', port: options.port };
|
|
}
|
|
|
|
getStatus(): OpencodeStatus {
|
|
return { ...this.status };
|
|
}
|
|
|
|
getManagedConfigDir(): string | null {
|
|
const userDataDir = this.options.userDataDir?.trim();
|
|
return userDataDir ? getManagedOpencodeConfigDir(userDataDir) : null;
|
|
}
|
|
|
|
async start(): Promise<OpencodeStatus> {
|
|
if (this.status.state === 'running') return this.getStatus();
|
|
if (this.startPromise) return await this.startPromise;
|
|
|
|
this.startPromise = this.startRuntime();
|
|
try {
|
|
return await this.startPromise;
|
|
} finally {
|
|
this.startPromise = null;
|
|
}
|
|
}
|
|
|
|
async stop(): Promise<void> {
|
|
const proc = this.proc;
|
|
if (proc) {
|
|
if (!proc.kill()) {
|
|
throw new Error(`Failed to stop opencode process ${proc.pid ?? 'unknown'}`);
|
|
}
|
|
if (typeof proc.pid === 'number') {
|
|
const released = await this.waitForPortOwnerToRelease(proc.pid);
|
|
if (!released) {
|
|
throw new Error(`Timed out waiting for opencode port ${this.options.port} to be released`);
|
|
}
|
|
}
|
|
} else {
|
|
await this.stopAttachedServerIfManaged();
|
|
}
|
|
this.proc = null;
|
|
this.setStatus({ state: 'stopped', port: this.options.port });
|
|
}
|
|
|
|
async restart(): Promise<OpencodeStatus> {
|
|
await this.stop();
|
|
return await this.start();
|
|
}
|
|
|
|
async checkHealth(): Promise<{ ok: boolean; status: OpencodeStatus }> {
|
|
return {
|
|
ok: this.status.state === 'running',
|
|
status: this.getStatus(),
|
|
};
|
|
}
|
|
|
|
private async startRuntime(): Promise<OpencodeStatus> {
|
|
this.setStatus({ state: 'starting', port: this.options.port });
|
|
|
|
const providedRuntimeConfig = this.resolveRuntimeConfig();
|
|
const runtimeConfig = providedRuntimeConfig && typeof (providedRuntimeConfig as Promise<unknown>).then === 'function'
|
|
? await providedRuntimeConfig
|
|
: providedRuntimeConfig;
|
|
const runtimeArgs = ['serve', '--hostname=127.0.0.1', `--port=${this.options.port}`];
|
|
const runtimeEnv = this.resolveRuntimeEnv(runtimeConfig.env);
|
|
const spawnCommand = this.resolveSpawnCommand(runtimeArgs, runtimeEnv);
|
|
logger.info('[opencode-runtime] Starting runtime with provider config', {
|
|
port: this.options.port,
|
|
command: spawnCommand.command,
|
|
args: spawnCommand.args,
|
|
...summarizeRuntimeConfigForDiagnostics(runtimeConfig.config, runtimeConfig.env),
|
|
});
|
|
const childEnv = {
|
|
...process.env,
|
|
...spawnCommand.env,
|
|
OPENCODE_CONFIG_CONTENT: JSON.stringify(runtimeConfig.config),
|
|
};
|
|
// Meowa credentials belong to Electron Main and must never be inherited by
|
|
// the model runtime or exposed through the Agent's shell environment.
|
|
delete childEnv.MEOWART_API_KEY;
|
|
delete childEnv.MEOWART_DEV_KEY;
|
|
const proc = this.spawnProcess(spawnCommand.command, spawnCommand.args, {
|
|
env: childEnv,
|
|
stdio: ['ignore', 'pipe', 'pipe'],
|
|
windowsHide: true,
|
|
shell: spawnCommand.shell,
|
|
});
|
|
this.proc = proc;
|
|
|
|
return await new Promise<OpencodeStatus>((resolve, reject) => {
|
|
let settled = false;
|
|
let stderr = '';
|
|
const appendStderr = (message: string) => {
|
|
stderr = `${stderr}${message}`;
|
|
if (stderr.length > 8_000) {
|
|
stderr = stderr.slice(-8_000);
|
|
}
|
|
};
|
|
const formatStartupError = (message: string) => {
|
|
const detail = stderr.trim();
|
|
return detail ? `${message}\n${detail}` : message;
|
|
};
|
|
const finish = (callback: () => void) => {
|
|
if (settled) return;
|
|
settled = true;
|
|
clearTimeout(timer);
|
|
callback();
|
|
};
|
|
|
|
const timer = setTimeout(() => {
|
|
finish(() => {
|
|
const error = formatStartupError(`Timed out waiting for opencode server after ${this.startupTimeoutMs}ms`);
|
|
this.setStatus({ state: 'error', port: this.options.port, error });
|
|
proc.kill();
|
|
reject(new Error(error));
|
|
});
|
|
}, this.startupTimeoutMs);
|
|
|
|
proc.stdout?.on('data', (chunk: Buffer) => {
|
|
const text = chunk.toString();
|
|
const match = text.match(/opencode server listening\s+on\s+(https?:\/\/[^\s]+)/);
|
|
if (!match) return;
|
|
|
|
finish(() => {
|
|
this.setStatus({
|
|
state: 'running',
|
|
port: this.options.port,
|
|
url: match[1],
|
|
pid: proc.pid,
|
|
startedAt: Date.now(),
|
|
});
|
|
resolve(this.getStatus());
|
|
});
|
|
});
|
|
|
|
proc.stderr?.on('data', (chunk: Buffer) => {
|
|
const message = chunk.toString();
|
|
appendStderr(message);
|
|
this.emit('stderr', message);
|
|
});
|
|
|
|
proc.on('error', (error) => {
|
|
finish(() => {
|
|
this.proc = null;
|
|
this.setStatus({ state: 'error', port: this.options.port, error: error.message });
|
|
reject(error);
|
|
});
|
|
});
|
|
|
|
proc.on('exit', (code) => {
|
|
this.proc = null;
|
|
if (!settled) {
|
|
clearTimeout(timer);
|
|
void this.findExistingServer().then((existingServer) => {
|
|
if (existingServer) {
|
|
finish(() => {
|
|
logger.warn(
|
|
'[opencode-runtime] Attached to an existing server; newly generated provider config may not be active',
|
|
{
|
|
port: this.options.port,
|
|
url: existingServer.url,
|
|
},
|
|
);
|
|
this.setStatus(existingServer);
|
|
resolve(this.getStatus());
|
|
});
|
|
return;
|
|
}
|
|
|
|
finish(() => {
|
|
const error = formatStartupError(code == null ? 'opencode process exited' : `Exited with code ${code}`);
|
|
this.setStatus({ state: 'error', port: this.options.port, error });
|
|
reject(new Error(error));
|
|
});
|
|
});
|
|
return;
|
|
}
|
|
|
|
if (this.status.state !== 'stopped') {
|
|
this.setStatus({
|
|
state: 'stopped',
|
|
port: this.options.port,
|
|
error: code == null ? undefined : `Exited with code ${code}`,
|
|
});
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
private async findExistingServer(): Promise<OpencodeStatus | null> {
|
|
if (typeof globalThis.fetch !== 'function') return null;
|
|
|
|
const url = `http://127.0.0.1:${this.options.port}`;
|
|
const controller = new AbortController();
|
|
const timeout = setTimeout(() => controller.abort(), Math.min(this.startupTimeoutMs, 1_000));
|
|
|
|
try {
|
|
const response = await globalThis.fetch(`${url}/global/health`, {
|
|
signal: controller.signal,
|
|
});
|
|
if (!response.ok) return null;
|
|
|
|
const body = await response.json().catch(() => null);
|
|
if (!body || typeof body !== 'object') return null;
|
|
if ((body as { healthy?: unknown }).healthy !== true) return null;
|
|
|
|
return {
|
|
state: 'running',
|
|
port: this.options.port,
|
|
url,
|
|
startedAt: Date.now(),
|
|
};
|
|
} catch {
|
|
return null;
|
|
} finally {
|
|
clearTimeout(timeout);
|
|
}
|
|
}
|
|
|
|
private async stopAttachedServerIfManaged(): Promise<void> {
|
|
const owner = await this.findPortOwner(this.options.port);
|
|
if (!owner || !isManagedOpencodePortOwner(owner, this.options.binPath)) {
|
|
return;
|
|
}
|
|
|
|
if (!this.killProcess(owner.pid)) {
|
|
throw new Error(`Failed to stop attached opencode process ${owner.pid}`);
|
|
}
|
|
|
|
logger.warn('[opencode-runtime] Stopped attached bundled opencode server on managed port', {
|
|
port: this.options.port,
|
|
pid: owner.pid,
|
|
});
|
|
const released = await this.waitForPortOwnerToRelease(owner.pid);
|
|
if (!released) {
|
|
throw new Error(`Timed out waiting for opencode port ${this.options.port} to be released`);
|
|
}
|
|
}
|
|
|
|
private async waitForPortOwnerToRelease(pid: number): Promise<boolean> {
|
|
const deadline = Date.now() + ATTACHED_SERVER_STOP_TIMEOUT_MS;
|
|
while (Date.now() < deadline) {
|
|
const owner = await this.findPortOwner(this.options.port);
|
|
if (!owner || owner.pid !== pid) return true;
|
|
await sleep(ATTACHED_SERVER_STOP_POLL_MS);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private resolveRuntimeEnv(runtimeEnv: Record<string, string>): Record<string, string> {
|
|
const userDataDir = this.options.userDataDir?.trim();
|
|
if (!userDataDir) {
|
|
return this.options.pythonRuntime
|
|
? prependPythonToPath(runtimeEnv, this.options.pythonRuntime)
|
|
: runtimeEnv;
|
|
}
|
|
|
|
const baseDir = join(userDataDir, 'opencode');
|
|
const configHome = join(baseDir, 'config');
|
|
const dataHome = join(baseDir, 'data');
|
|
const cacheHome = join(baseDir, 'cache');
|
|
const managedConfigDir = this.getManagedConfigDir() ?? getManagedOpencodeConfigDir(userDataDir);
|
|
|
|
mkdirSync(configHome, { recursive: true });
|
|
mkdirSync(dataHome, { recursive: true });
|
|
mkdirSync(cacheHome, { recursive: true });
|
|
mkdirSync(managedConfigDir, { recursive: true });
|
|
ensureBundledSuperpowersPlugin({
|
|
managedConfigDir,
|
|
sourceDir: this.options.bundledSuperpowersDir,
|
|
});
|
|
ensureBundledCourseSkills({
|
|
managedConfigDir,
|
|
sourceDir: this.options.bundledCourseSkillsDir,
|
|
});
|
|
const environment = {
|
|
...runtimeEnv,
|
|
OPENCODE_CONFIG_DIR: managedConfigDir,
|
|
// Makelore exposes its managed and project-owned Skills explicitly. Avoid
|
|
// rescanning unrelated user-wide ~/.claude and ~/.agents Skill libraries
|
|
// during every project's cold bootstrap.
|
|
OPENCODE_DISABLE_EXTERNAL_SKILLS: '1',
|
|
NIANCODE_GAME_ASSETS_CLI: join(managedConfigDir, 'skills', 'game-assets', 'meowart_api.py'),
|
|
XDG_CONFIG_HOME: configHome,
|
|
XDG_DATA_HOME: dataHome,
|
|
XDG_CACHE_HOME: cacheHome,
|
|
};
|
|
return this.options.pythonRuntime
|
|
? prependPythonToPath(environment, this.options.pythonRuntime)
|
|
: environment;
|
|
}
|
|
|
|
private setStatus(next: OpencodeStatus): void {
|
|
this.status = next;
|
|
this.emit('status', this.getStatus());
|
|
}
|
|
|
|
private resolveSpawnCommand(runtimeArgs: string[], runtimeEnv: Record<string, string>): SpawnCommand {
|
|
const binPath = this.options.binPath;
|
|
if (process.platform !== 'win32') {
|
|
return {
|
|
command: binPath,
|
|
args: runtimeArgs,
|
|
env: runtimeEnv,
|
|
};
|
|
}
|
|
|
|
if (/\.(?:exe|cmd|bat)$/i.test(binPath)) {
|
|
return {
|
|
command: binPath,
|
|
args: runtimeArgs,
|
|
env: runtimeEnv,
|
|
shell: /\.(?:cmd|bat)$/i.test(binPath),
|
|
};
|
|
}
|
|
|
|
return {
|
|
command: process.execPath,
|
|
args: [binPath, ...runtimeArgs],
|
|
env: {
|
|
...runtimeEnv,
|
|
ELECTRON_RUN_AS_NODE: '1',
|
|
},
|
|
};
|
|
}
|
|
|
|
private resolveRuntimeConfig(): RuntimeConfig | Promise<RuntimeConfig> {
|
|
if (this.runtimeConfigProvider) {
|
|
const providedRuntimeConfig = this.runtimeConfigProvider();
|
|
if (providedRuntimeConfig && typeof (providedRuntimeConfig as Promise<unknown>).then === 'function') {
|
|
return providedRuntimeConfig.then((runtimeConfig) => ({
|
|
config: runtimeConfig.config,
|
|
env: runtimeConfig.env ?? {},
|
|
}));
|
|
}
|
|
return {
|
|
config: providedRuntimeConfig.config,
|
|
env: providedRuntimeConfig.env ?? {},
|
|
};
|
|
}
|
|
|
|
const providedConfig = this.configProvider ? this.configProvider() : {};
|
|
if (providedConfig && typeof (providedConfig as Promise<unknown>).then === 'function') {
|
|
return providedConfig.then((config) => ({ config, env: {} }));
|
|
}
|
|
|
|
return { config: providedConfig, env: {} };
|
|
}
|
|
}
|