remote-codex 0.11.3 → 0.11.4

package/apps/supervisor-api/dist/worker-index.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/apps/supervisor-api/dist/worker-index.js

@@ -0,0 +1,197 @@
+import {
+  buildApp
+} from "./chunk-ZWZQVPDT.js";
+
+// src/worker-index.ts
+import fs2 from "fs";
+
+// src/worker-environment.ts
+import fs from "fs";
+import path from "path";
+var DEFAULT_ENABLED_PROVIDER_RUNTIMES = ["codex", "claude", "opencode"];
+function requireEnv(env, name) {
+  const value = env[name];
+  if (!value || !value.trim()) {
+    throw new Error(`${name} is required in worker mode.`);
+  }
+  return value;
+}
+function assertPath(expected, actual, name) {
+  if (path.resolve(actual ?? "") !== expected) {
+    throw new Error(`${name} must be ${expected} in worker mode.`);
+  }
+}
+function ensureDirectory(filesystem, dir, name) {
+  filesystem.mkdirSync(dir, { recursive: true, mode: 448 });
+  const stat = filesystem.statSync(dir);
+  if (!stat.isDirectory()) {
+    throw new Error(`${name} must be a directory: ${dir}`);
+  }
+  filesystem.accessSync(dir, fs.constants.R_OK | fs.constants.W_OK);
+}
+function assertPathInside(parent, child, name) {
+  const resolvedParent = path.resolve(parent);
+  const resolvedChild = path.resolve(child);
+  const relative = path.relative(resolvedParent, resolvedChild);
+  if (relative.startsWith("..") || path.isAbsolute(relative)) {
+    throw new Error(`${name} must be inside ${resolvedParent} in worker mode.`);
+  }
+}
+function ensureNotWorldWritable(filesystem, filePath, name) {
+  if (!filesystem.existsSync(filePath)) {
+    return;
+  }
+  const stat = filesystem.statSync(filePath);
+  if ("mode" in stat && typeof stat.mode === "number" && (stat.mode & 2) !== 0) {
+    throw new Error(`${name} must not be world-writable in worker mode: ${filePath}`);
+  }
+}
+function enabledProviderRuntimes(env) {
+  const raw = env.REMOTE_CODEX_ENABLED_AGENT_PROVIDERS;
+  if (raw === void 0) {
+    return DEFAULT_ENABLED_PROVIDER_RUNTIMES;
+  }
+  return raw.split(",").map((provider) => provider.trim().toLowerCase()).filter(Boolean);
+}
+function parseBoolean(value) {
+  return value !== void 0 && ["1", "true", "yes", "on"].includes(value.toLowerCase());
+}
+function validateMcpConfigPaths(env, filesystem) {
+  const home = env.HOME ?? "/home/agent";
+  const providerConfigs = [
+    {
+      enabled: enabledProviderRuntimes(env).includes("codex"),
+      home: env.CODEX_HOME ?? path.join(home, ".codex"),
+      file: "config.toml",
+      name: "Codex MCP config path"
+    },
+    {
+      enabled: enabledProviderRuntimes(env).includes("claude"),
+      home: env.CLAUDE_HOME ?? path.join(home, ".claude"),
+      file: "settings.json",
+      name: "Claude MCP config path"
+    },
+    {
+      enabled: enabledProviderRuntimes(env).includes("opencode"),
+      home: env.OPENCODE_HOME ?? path.join(home, ".opencode"),
+      file: "opencode.json",
+      name: "OpenCode MCP config path"
+    }
+  ];
+  for (const config of providerConfigs) {
+    if (!config.enabled) {
+      continue;
+    }
+    assertPathInside(home, config.home, config.name);
+    ensureNotWorldWritable(
+      filesystem,
+      path.join(config.home, config.file),
+      config.name
+    );
+  }
+}
+function validateGatewayEnvironment(env) {
+  if (enabledProviderRuntimes(env).length === 0) {
+    return;
+  }
+  const baseUrl = requireEnv(env, "REMOTE_CODEX_LLM_GATEWAY_BASE_URL");
+  requireEnv(env, "REMOTE_CODEX_LLM_GATEWAY_TOKEN");
+  try {
+    new URL(baseUrl);
+  } catch {
+    throw new Error("REMOTE_CODEX_LLM_GATEWAY_BASE_URL must be a valid URL.");
+  }
+}
+function validateHarnessEnvironment(env) {
+  if (!parseBoolean(env.REMOTE_CODEX_CHEMISTRY_TOOLS_ENABLED)) {
+    return;
+  }
+  const baseUrl = requireEnv(env, "ELAGENTE_HARNESS_BASE_URL");
+  requireEnv(env, "INACT_X_APP_KEY");
+  try {
+    new URL(baseUrl);
+  } catch {
+    throw new Error("ELAGENTE_HARNESS_BASE_URL must be a valid URL.");
+  }
+}
+function validateWorkerEntrypointEnvironment(env = process.env, filesystem = fs) {
+  if (env.REMOTE_CODEX_RUNTIME_ROLE !== "worker") {
+    throw new Error("REMOTE_CODEX_RUNTIME_ROLE must be worker for the worker entrypoint.");
+  }
+  requireEnv(env, "REMOTE_CODEX_SANDBOX_ID");
+  requireEnv(env, "REMOTE_CODEX_USER_ID");
+  requireEnv(env, "REMOTE_CODEX_WORKER_AUTH_TOKEN");
+  assertPath("/workspace", env.WORKSPACE_ROOT, "WORKSPACE_ROOT");
+  assertPath("/home/agent", env.HOME, "HOME");
+  ensureDirectory(filesystem, "/workspace", "WORKSPACE_ROOT");
+  ensureDirectory(filesystem, "/home/agent", "HOME");
+  ensureDirectory(filesystem, env.CODEX_HOME ?? "/home/agent/.codex", "CODEX_HOME");
+  ensureDirectory(filesystem, env.CLAUDE_HOME ?? "/home/agent/.claude", "CLAUDE_HOME");
+  ensureDirectory(filesystem, env.OPENCODE_HOME ?? "/home/agent/.opencode", "OPENCODE_HOME");
+  validateMcpConfigPaths(env, filesystem);
+  validateGatewayEnvironment(env);
+  validateHarnessEnvironment(env);
+}
+function workerStartupLogPayload(env = process.env) {
+  return {
+    sandboxId: env.REMOTE_CODEX_SANDBOX_ID ?? null,
+    userId: env.REMOTE_CODEX_USER_ID ?? null,
+    workspaceRoot: env.WORKSPACE_ROOT ?? null,
+    home: env.HOME ?? null,
+    gatewayConfigured: Boolean(env.REMOTE_CODEX_LLM_GATEWAY_BASE_URL),
+    harnessConfigured: Boolean(env.ELAGENTE_HARNESS_BASE_URL),
+    chemistryToolsEnabled: parseBoolean(env.REMOTE_CODEX_CHEMISTRY_TOOLS_ENABLED)
+  };
+}
+
+// src/worker-index.ts
+if (fs2.existsSync(".env")) {
+  process.loadEnvFile?.(".env");
+}
+process.env.REMOTE_CODEX_RUNTIME_ROLE ??= "worker";
+process.env.HOST ??= "0.0.0.0";
+process.env.WORKSPACE_ROOT ??= "/workspace";
+process.env.HOME ??= "/home/agent";
+process.env.CODEX_HOME ??= "/home/agent/.codex";
+process.env.CLAUDE_HOME ??= "/home/agent/.claude";
+process.env.CLAUDE_CONFIG_DIR ??= "/home/agent/.claude";
+process.env.OPENCODE_HOME ??= "/home/agent/.opencode";
+process.env.REMOTE_CODEX_DISABLE_BUILD_RESTART ??= "true";
+validateWorkerEntrypointEnvironment();
+var app = buildApp();
+var { host, port } = app.services.config;
+var shutdownStarted = false;
+async function shutdown(signal) {
+  if (shutdownStarted) {
+    return;
+  }
+  shutdownStarted = true;
+  const hardExit = setTimeout(() => {
+    app.log.error({ signal }, "Remote Codex Worker graceful shutdown timed out.");
+    process.exit(1);
+  }, 55e3);
+  hardExit.unref();
+  try {
+    app.log.info({ signal }, "Remote Codex Worker shutting down.");
+    await app.close();
+    process.exit(0);
+  } catch (error) {
+    app.log.error({ error, signal }, "Remote Codex Worker shutdown failed.");
+    process.exit(1);
+  }
+}
+process.once("SIGTERM", () => {
+  void shutdown("SIGTERM");
+});
+process.once("SIGINT", () => {
+  void shutdown("SIGINT");
+});
+app.listen({ host, port }).then(() => {
+  app.log.info(
+    workerStartupLogPayload(process.env),
+    `Remote Codex Worker listening on http://${host}:${port}`
+  );
+}).catch((error) => {
+  app.log.error(error);
+  process.exit(1);
+});