A desktop coding agent with free access to frontier models.
TypeScript
#!/usr/bin/env bun
import { randomUUID } from "node:crypto";
import { managedDesktopPolicy } from "./managed-desktop-policy.js";
import { mkdir } from "node:fs/promises";
import { engineToolsRoot, setToolsRoot } from "./box/box.js";
import { parseCliArgs, printHelp, resolveServerConfig } from "./config.js";
import {
buildEngineAuthProbeHeader,
registerEngineInstance,
removeEngineInstance,
reapOrphanEngineInstances,
} from "./engine-registry.js";
import { createManagedOpencodeServer, type ManagedOpencodeServer } from "./managed-opencode.js";
import { clearEnginePoolForConfig, computeEngineConfigFingerprint, type EnginePool, type EngineSpawnTemplate } from "./engine-pool.js";
import {
clearTrustedOpencodeProcess,
createEnginePoolForConfig,
createServerLogger,
registerTrustedOpencodeProcess,
startServer,
syncAllWorkspacesRuntimeMcpToEngine,
} from "./server.js";
import { ensureLocalWorkspaceFiles } from "./workspace-init.js";
import { findManagedEngineWorkspace } from "./workspaces.js";
import { keepOmniRushRuntimeConfigFileFresh, writeOmniRushRuntimeConfigFile } from "./omnirush-runtime-config.js";
import { migrateOmniRushCloudMcpRuntimeConfig } from "./cloud-mcp-health.js";
import { migrateWorkspaceRuntimeConfigToEngineGlobal } from "./runtime-opencode-config-store.js";
import { migrateLegacyOmniRushUiMcpCommand } from "./omnirush-ui-mcp-migration.js";
import { resolveOpencodeModelsEnv } from "./opencode-models-url.js";
import { assertOpencodeConfigCompat } from "./opencode-config-compat.js";
import { adoptOpencodeCredentials, startEngine2SessionImport } from "./engine2/import.js";
import { startWorkerActivityHeartbeat } from "./worker-activity-heartbeat.js";
import pkg from "../package.json" with { type: "json" };
import { mcpEngineEnv } from "./mcp-allow/state.js";
import { runtimeStorageDir } from "./runtime-db.js";
const args = parseCliArgs(process.argv.slice(2));
if (args.help) {
printHelp();
process.exit(0);
}
if (args.version) {
console.log(pkg.version);
process.exit(0);
}
const config = await resolveServerConfig(args);
const logger = createServerLogger(config);
let managedOpencode: ManagedOpencodeServer | null = null;
let managedOpencodeIdentity: string | null = null;
let managedEngineRecordId: string | null = null;
let enginePool: EnginePool | null = null;
if (!config.readOnly) {
await ensureLocalWorkspaceFiles(config.workspaces);
// A standalone server has no bundled UI-control MCP: remove any persisted
// `npx -y omnirush-ui-mcp` entry rather than letting the engine resolve it.
// First among the runtime-DB migrations (see migrateLegacyOmniRushUiMcpCommand).
await migrateLegacyOmniRushUiMcpCommand(config, null);
await migrateOmniRushCloudMcpRuntimeConfig(config);
await migrateWorkspaceRuntimeConfigToEngineGlobal(config);
}
// Bind the HTTP server before spawning the engine: serve-node may fall back
// to an OS-assigned port on EADDRINUSE, and the engine's spawn-time env
// (OMNIRUSH_SERVER_URL) must point at the port that actually bound, not the
// requested one.
// The Linux sandbox's helpers ship beside the engine (sidecars/box/): known before the server plans any box.
setToolsRoot(engineToolsRoot(null));
const server = await startServer(config);
config.port = server.port;
const serverUrl = `http://${config.host === "0.0.0.0" ? "127.0.0.1" : config.host}:${server.port}`;
const workerActivityHeartbeat = startWorkerActivityHeartbeat(config, logger);
if (!config.opencodeBaseUrl && process.env.OMNIRUSH_MANAGE_OPENCODE === "1") {
const workspace = findManagedEngineWorkspace(config.workspaces);
if (workspace) {
// Reap engines recorded by servers that died without cleanup. Best
// effort: a failed reap must never block startup.
await reapOrphanEngineInstances(config, { logger }).catch(() => undefined);
// Server-managed config file: the engine re-reads it from disk on every
// instance rebuild, and keepOmniRushRuntimeConfigFileFresh synchronizes it
// on every runtime-DB write — so disposes always pick up current state.
const { path: runtimeConfigPath } = await writeOmniRushRuntimeConfigFile(config);
keepOmniRushRuntimeConfigFileFresh(config);
const managedOpencodeCwd = process.env.OMNIRUSH_MANAGED_OPENCODE_CWD?.trim() || workspace.path;
await mkdir(managedOpencodeCwd, { recursive: true });
const opencodeModelsEnv = await resolveOpencodeModelsEnv();
const engineEnv: Record<string, string | undefined> = {
...(process.env.OMNIRUSH_DEV_MODE ? { OMNIRUSH_DEV_MODE: process.env.OMNIRUSH_DEV_MODE } : {}),
...(process.env.OMNIRUSH_UI_CONTROL_DISCOVERY ? { OMNIRUSH_UI_CONTROL_DISCOVERY: process.env.OMNIRUSH_UI_CONTROL_DISCOVERY } : {}),
OMNIRUSH_SERVER_URL: serverUrl,
OMNIRUSH_SERVER_TOKEN: config.token,
OMNIRUSH_POLICY_TOKEN: managedDesktopPolicy(config).evaluationToken,
OPENCODE_CONFIG: runtimeConfigPath,
...opencodeModelsEnv,
// The MCP plugin's policy, report and app-added servers (mcp-allow/state.ts).
...mcpEngineEnv(runtimeStorageDir(config)),
};
const engineSpawnTemplate: EngineSpawnTemplate = {
bin: process.env.OMNIRUSH_OPENCODE_BIN,
cwd: managedOpencodeCwd,
runtimeConfigPath,
env: engineEnv,
reservedPorts: () => {
const poolPorts = enginePool?.connections().map((connection) => Number(new URL(connection.baseUrl).port) || 0) ?? [];
return [...new Set([config.port, ...poolPorts].filter((port) => port > 0))];
},
};
// See embedded.ts: a V2 `permissions` key in a user-owned config file is
// fatal to the bundled engine; report the file before spawning.
await assertOpencodeConfigCompat({
workspaceRoots: config.workspaces
.filter((entry) => entry.workspaceType !== "remote")
.map((entry) => entry.path),
env: { ...process.env, ...engineEnv },
logger,
});
adoptOpencodeCredentials({ ...process.env, ...engineEnv }, (level, message, attributes) => logger.log(level, message, attributes));
managedOpencode = await createManagedOpencodeServer({
bin: process.env.OMNIRUSH_OPENCODE_BIN,
cwd: managedOpencodeCwd,
excludedPorts: [config.port],
env: engineEnv,
});
// Sessions the 2.x engine of OmniRush.ai 2.2.0 – 3.x stored: copied once into this engine's store.
void startEngine2SessionImport({
bin: process.env.OMNIRUSH_OPENCODE_BIN?.trim() || "opencode",
env: { ...process.env, ...engineEnv },
log: (level, message, attributes) => logger.log(level, message, attributes),
});
config.opencodeBaseUrl = managedOpencode.url;
config.opencodeUsername = managedOpencode.username;
config.opencodePassword = managedOpencode.password;
for (const entry of config.workspaces) {
entry.baseUrl ??= managedOpencode.url;
entry.opencodeUsername ??= managedOpencode.username;
entry.opencodePassword ??= managedOpencode.password;
entry.directory ??= entry.path;
}
// The identity only needs to be unique per managed-process boot; a
// random nonce provides that without routing the engine credentials
// through the fast identity hash.
managedOpencodeIdentity = [
managedOpencode.pid ?? "unknown",
randomUUID(),
].join(":");
registerTrustedOpencodeProcess(config, {
baseUrl: managedOpencode.url,
identity: managedOpencodeIdentity,
isAlive: managedOpencode.isAlive,
});
if (managedOpencode.pid) {
managedEngineRecordId = randomUUID();
await registerEngineInstance(config, {
id: managedEngineRecordId,
pid: managedOpencode.pid,
port: Number(new URL(managedOpencode.url).port) || 0,
url: managedOpencode.url,
startedAt: Date.now(),
role: "primary",
serverRunId: managedOpencodeIdentity,
ownerPid: process.pid,
authProbe: buildEngineAuthProbeHeader(managedOpencode.username, managedOpencode.password),
bin: process.env.OMNIRUSH_OPENCODE_BIN?.trim() || "opencode",
}).catch(() => undefined);
}
enginePool = createEnginePoolForConfig({
config,
template: engineSpawnTemplate,
handle: managedOpencode,
fingerprint: await computeEngineConfigFingerprint(engineSpawnTemplate),
registryId: managedEngineRecordId,
trustedIdentity: managedOpencodeIdentity,
});
logger.log("info", `Managed OmniRush listening on ${managedOpencode.url}`);
}
}
// The runtime config file above only covers workspaces[0]. Push every
// workspace's runtime-DB MCPs into the engine so they aren't invisible
// until a manual reload. Best-effort.
if (managedOpencode) {
void syncAllWorkspacesRuntimeMcpToEngine(config).catch((error) => {
logger.log("error", "Startup MCP synchronization crashed.", {
"mcp.trigger": "startup",
"mcp.failure.message": error instanceof Error ? error.message : String(error),
});
});
}
const url = `http://${config.host}:${server.port}`;
logger.log("info", `OmniRush.ai server listening on ${url}`);
if (config.tokenSource === "generated") {
logger.log("info", `Client token: ${config.token}`);
}
if (config.hostTokenSource === "generated") {
logger.log("info", `Host token: ${config.hostToken}`);
}
if (config.workspaces.length === 0) {
logger.log("info", "No workspaces configured. Add --workspace or update server.json.");
} else {
logger.log("info", `Workspaces: ${config.workspaces.length}`);
}
if (args.verbose) {
logger.log("info", `Config path: ${config.configPath ?? "unknown"}`);
logger.log("info", `Read-only: ${config.readOnly ? "true" : "false"}`);
logger.log("info", `Approval: ${config.approval.mode} (${config.approval.timeoutMs}ms)`);
logger.log("info", `CORS origins: ${config.corsOrigins.join(", ")}`);
logger.log("info", `Authorized roots: ${config.authorizedRoots.join(", ")}`);
logger.log("info", `Token source: ${config.tokenSource}`);
logger.log("info", `Host token source: ${config.hostTokenSource}`);
}
const shutdown = async () => {
workerActivityHeartbeat?.stop();
if (managedOpencodeIdentity && !enginePool) {
clearTrustedOpencodeProcess(config, managedOpencodeIdentity);
}
// Await the engine teardown (SIGTERM → 1s → SIGKILL, bounded ~1.5s): a
// synchronous process.exit here used to skip the escalation entirely and
// orphan the OpenCode child to init.
try {
if (enginePool) {
clearEnginePoolForConfig(config);
await enginePool.disposeAll();
} else {
await managedOpencode?.close();
}
} catch {
// Engine already exited.
}
if (managedEngineRecordId && !enginePool) {
await removeEngineInstance(config, managedEngineRecordId).catch(() => undefined);
}
(server as { stop?: (closeActiveConnections?: boolean) => void }).stop?.(true);
};
process.once("SIGINT", () => {
void shutdown().finally(() => process.exit(0));
});
process.once("SIGTERM", () => {
void shutdown().finally(() => process.exit(0));
});