@right-link/paperclip-plugin-codex-remote 0.3.1 → 0.3.2

package/dist/cli/index.js

@@ -1,2 +1,190 @@
-export { printCodexStreamEvent } from "./format-event.js";
-//# sourceMappingURL=index.js.map
+// src/cli/format-event.ts
+import pc from "picocolors";
+function asRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  return value;
+}
+function asString(value, fallback = "") {
+  return typeof value === "string" ? value : fallback;
+}
+function asNumber(value, fallback = 0) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function errorText(value) {
+  if (typeof value === "string") return value;
+  const rec = asRecord(value);
+  if (!rec) return "";
+  const msg = typeof rec.message === "string" && rec.message || typeof rec.error === "string" && rec.error || typeof rec.code === "string" && rec.code || "";
+  if (msg) return msg;
+  try {
+    return JSON.stringify(rec);
+  } catch {
+    return "";
+  }
+}
+function printItemStarted(item) {
+  const itemType = asString(item.type);
+  if (itemType === "command_execution") {
+    const command = asString(item.command);
+    console.log(pc.yellow("tool_call: command_execution"));
+    if (command) console.log(pc.gray(command));
+    return true;
+  }
+  if (itemType === "tool_use") {
+    const name = asString(item.name, "unknown");
+    console.log(pc.yellow(`tool_call: ${name}`));
+    if (item.input !== void 0) {
+      try {
+        console.log(pc.gray(JSON.stringify(item.input, null, 2)));
+      } catch {
+        console.log(pc.gray(String(item.input)));
+      }
+    }
+    return true;
+  }
+  return false;
+}
+function printItemCompleted(item) {
+  const itemType = asString(item.type);
+  if (itemType === "agent_message") {
+    const text = asString(item.text);
+    if (text) console.log(pc.green(`assistant: ${text}`));
+    return true;
+  }
+  if (itemType === "reasoning") {
+    const text = asString(item.text);
+    if (text) console.log(pc.gray(`thinking: ${text}`));
+    return true;
+  }
+  if (itemType === "tool_use") {
+    const name = asString(item.name, "unknown");
+    console.log(pc.yellow(`tool_call: ${name}`));
+    if (item.input !== void 0) {
+      try {
+        console.log(pc.gray(JSON.stringify(item.input, null, 2)));
+      } catch {
+        console.log(pc.gray(String(item.input)));
+      }
+    }
+    return true;
+  }
+  if (itemType === "command_execution") {
+    const command = asString(item.command);
+    const status = asString(item.status);
+    const exitCode = typeof item.exit_code === "number" && Number.isFinite(item.exit_code) ? item.exit_code : null;
+    const output = asString(item.aggregated_output).replace(/\s+$/, "");
+    const isError = exitCode !== null && exitCode !== 0 || status === "failed" || status === "errored" || status === "error" || status === "cancelled";
+    const summaryParts = [
+      "tool_result: command_execution",
+      command ? `command="${command}"` : "",
+      status ? `status=${status}` : "",
+      exitCode !== null ? `exit_code=${exitCode}` : ""
+    ].filter(Boolean);
+    console.log((isError ? pc.red : pc.cyan)(summaryParts.join(" ")));
+    if (output) console.log((isError ? pc.red : pc.gray)(output));
+    return true;
+  }
+  if (itemType === "file_change") {
+    const changes = Array.isArray(item.changes) ? item.changes : [];
+    const entries = changes.map((changeRaw) => asRecord(changeRaw)).filter((change) => Boolean(change)).map((change) => {
+      const kind = asString(change.kind, "update");
+      const path = asString(change.path, "unknown");
+      return `${kind} ${path}`;
+    });
+    const preview = entries.length > 0 ? entries.slice(0, 6).join(", ") : "none";
+    const more = entries.length > 6 ? ` (+${entries.length - 6} more)` : "";
+    console.log(pc.cyan(`file_change: ${preview}${more}`));
+    return true;
+  }
+  if (itemType === "error") {
+    const message = errorText(item.message ?? item.error ?? item);
+    if (message) console.log(pc.red(`error: ${message}`));
+    return true;
+  }
+  if (itemType === "tool_result") {
+    const isError = item.is_error === true || asString(item.status) === "error";
+    const text = asString(item.content) || asString(item.result) || asString(item.output);
+    console.log((isError ? pc.red : pc.cyan)(`tool_result${isError ? " (error)" : ""}`));
+    if (text) console.log((isError ? pc.red : pc.gray)(text));
+    return true;
+  }
+  return false;
+}
+function printCodexStreamEvent(raw, _debug) {
+  const line = raw.trim();
+  if (!line) return;
+  let parsed = null;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    console.log(line);
+    return;
+  }
+  const type = asString(parsed.type);
+  if (type === "thread.started") {
+    const threadId = asString(parsed.thread_id);
+    const model = asString(parsed.model);
+    const details = [threadId ? `session: ${threadId}` : "", model ? `model: ${model}` : ""].filter(Boolean).join(", ");
+    console.log(pc.blue(`Codex thread started${details ? ` (${details})` : ""}`));
+    return;
+  }
+  if (type === "turn.started") {
+    console.log(pc.blue("turn started"));
+    return;
+  }
+  if (type === "item.started" || type === "item.completed") {
+    const item = asRecord(parsed.item);
+    if (item) {
+      const handled = type === "item.started" ? printItemStarted(item) : printItemCompleted(item);
+      if (!handled) {
+        const itemType = asString(item.type, "unknown");
+        const id = asString(item.id);
+        const status = asString(item.status);
+        const meta = [id ? `id=${id}` : "", status ? `status=${status}` : ""].filter(Boolean).join(" ");
+        console.log(pc.gray(`${type}: ${itemType}${meta ? ` (${meta})` : ""}`));
+      }
+    } else {
+      console.log(pc.gray(type));
+    }
+    return;
+  }
+  if (type === "turn.completed") {
+    const usage = asRecord(parsed.usage);
+    const input = asNumber(usage?.input_tokens);
+    const output = asNumber(usage?.output_tokens);
+    const cached = asNumber(usage?.cached_input_tokens, asNumber(usage?.cache_read_input_tokens));
+    const cost = asNumber(parsed.total_cost_usd);
+    const isError = parsed.is_error === true;
+    const subtype = asString(parsed.subtype);
+    const errors = Array.isArray(parsed.errors) ? parsed.errors.map(errorText).filter(Boolean) : [];
+    console.log(
+      pc.blue(`tokens: in=${input} out=${output} cached=${cached} cost=$${cost.toFixed(6)}`)
+    );
+    if (subtype || isError || errors.length > 0) {
+      console.log(
+        pc.red(`result: subtype=${subtype || "unknown"} is_error=${isError ? "true" : "false"}`)
+      );
+      if (errors.length > 0) console.log(pc.red(`errors: ${errors.join(" | ")}`));
+    }
+    return;
+  }
+  if (type === "turn.failed") {
+    const usage = asRecord(parsed.usage);
+    const input = asNumber(usage?.input_tokens);
+    const output = asNumber(usage?.output_tokens);
+    const cached = asNumber(usage?.cached_input_tokens, asNumber(usage?.cache_read_input_tokens));
+    const message = errorText(parsed.error ?? parsed.message);
+    console.log(pc.red(`turn failed${message ? `: ${message}` : ""}`));
+    console.log(pc.blue(`tokens: in=${input} out=${output} cached=${cached}`));
+    return;
+  }
+  if (type === "error") {
+    const message = errorText(parsed.message ?? parsed.error ?? parsed);
+    if (message) console.log(pc.red(`error: ${message}`));
+    return;
+  }
+  console.log(line);
+}
+export {
+  printCodexStreamEvent
+};

package/dist/index.js

@@ -1,84 +1,28 @@
-export const type = "codex_remote";
-export const label = "Codex (remote)";
-export const SANDBOX_INSTALL_COMMAND = "npm install -g @openai/codex";
-export const DEFAULT_CODEX_REMOTE_MODEL = "gpt-5.3-codex";
-export const DEFAULT_CODEX_REMOTE_BYPASS_APPROVALS_AND_SANDBOX = true;
-export const CODEX_REMOTE_FAST_MODE_SUPPORTED_MODELS = ["gpt-5.4"];
-function normalizeModelId(model) {
-    return typeof model === "string" ? model.trim() : "";
-}
-export function isCodexRemoteKnownModel(model) {
-    const normalizedModel = normalizeModelId(model);
-    if (!normalizedModel)
-        return false;
-    return models.some((entry) => entry.id === normalizedModel);
-}
-export function isCodexRemoteManualModel(model) {
-    const normalizedModel = normalizeModelId(model);
-    return Boolean(normalizedModel) && !isCodexRemoteKnownModel(normalizedModel);
-}
-export function isCodexRemoteFastModeSupported(model) {
-    if (isCodexRemoteManualModel(model))
-        return true;
-    const normalizedModel = typeof model === "string" ? model.trim() : "";
-    return CODEX_REMOTE_FAST_MODE_SUPPORTED_MODELS.includes(normalizedModel);
-}
-export const models = [
-    { id: "gpt-5.4", label: "gpt-5.4" },
-    { id: DEFAULT_CODEX_REMOTE_MODEL, label: DEFAULT_CODEX_REMOTE_MODEL },
-    { id: "gpt-5.3-codex-spark", label: "gpt-5.3-codex-spark" },
-    { id: "gpt-5", label: "gpt-5" },
-    { id: "o3", label: "o3" },
-    { id: "o4-mini", label: "o4-mini" },
-    { id: "gpt-5-mini", label: "gpt-5-mini" },
-    { id: "gpt-5-nano", label: "gpt-5-nano" },
-    { id: "o3-mini", label: "o3-mini" },
-    { id: "codex-mini-latest", label: "Codex Mini" },
-];
-export const modelProfiles = [
-    {
-        key: "cheap",
-        label: "Cheap",
-        description: "Use the lowest-cost known Codex local model lane without changing the primary model.",
-        adapterConfig: {
-            model: "gpt-5.3-codex-spark",
-            // Spark is the cheap lane by model price; high effort keeps Codex coding behavior usable for delegated work.
-            modelReasoningEffort: "high",
-        },
-        source: "adapter_default",
-    },
-];
-export const agentConfigurationDoc = `# codex_remote agent configuration
-
-Adapter: codex_remote
-
-Core fields:
-- cwd (string, optional): default absolute working directory fallback for the agent process (created if missing when possible)
-- instructionsFilePath (string, optional): absolute path to a markdown instructions file prepended to stdin prompt at runtime
-- model (string, optional): Codex model id
-- modelReasoningEffort (string, optional): reasoning effort override (minimal|low|medium|high|xhigh) passed via -c model_reasoning_effort=...
-- promptTemplate (string, optional): run prompt template
-- search (boolean, optional): run codex with --search
-- fastMode (boolean, optional): enable Codex Fast mode; supported on GPT-5.4 and passed through for manual model IDs
-- dangerouslyBypassApprovalsAndSandbox (boolean, optional): run with bypass flag
-- command (string, optional): defaults to "codex"
-- extraArgs (string[], optional): additional CLI args
-- env (object, optional): KEY=VALUE environment variables
-- workspaceStrategy (object, optional): execution workspace strategy; currently supports { type: "git_worktree", baseRef?, branchTemplate?, worktreeParentDir? }
-- workspaceRuntime (object, optional): reserved for workspace runtime metadata; workspace runtime services are manually controlled from the workspace UI and are not auto-started by heartbeats
-
-Operational fields:
-- timeoutSec (number, optional): run timeout in seconds
-- graceSec (number, optional): SIGTERM grace period in seconds
-
-Notes:
-- Prompts are piped via stdin (Codex receives "-" prompt argument).
-- If instructionsFilePath is configured, Paperclip prepends that file's contents to the stdin prompt on every run.
-- Codex exec automatically applies repo-scoped AGENTS.md instructions from the active workspace. Paperclip cannot suppress that discovery in exec mode, so repo AGENTS.md files may still apply even when you only configured an explicit instructionsFilePath.
-- Paperclip injects desired local skills into the effective CODEX_HOME/skills/ directory at execution time so Codex can discover "$paperclip" and related skills without polluting the project working directory. In managed-home mode (the default) this is ~/.paperclip/instances/<id>/companies/<companyId>/codex-home/skills/; when CODEX_HOME is explicitly overridden in adapter config, that override is used instead.
-- Unless explicitly overridden in adapter config, Paperclip runs Codex with a per-company managed CODEX_HOME under the active Paperclip instance and seeds auth/config from the shared Codex home (the CODEX_HOME env var, when set, or ~/.codex).
-- Some model/tool combinations reject certain effort levels (for example minimal with web search enabled).
-- Fast mode is supported on GPT-5.4 and manual model IDs. When enabled for those models, Paperclip applies \`service_tier="fast"\` and \`features.fast_mode=true\`.
-- When Paperclip realizes a workspace/runtime for a run, it injects PAPERCLIP_WORKSPACE_* and PAPERCLIP_RUNTIME_* env vars for agent-side tooling.
-`;
-//# sourceMappingURL=index.js.map
+import {
+  CODEX_REMOTE_FAST_MODE_SUPPORTED_MODELS,
+  DEFAULT_CODEX_REMOTE_BYPASS_APPROVALS_AND_SANDBOX,
+  DEFAULT_CODEX_REMOTE_MODEL,
+  SANDBOX_INSTALL_COMMAND,
+  agentConfigurationDoc,
+  isCodexRemoteFastModeSupported,
+  isCodexRemoteKnownModel,
+  isCodexRemoteManualModel,
+  label,
+  modelProfiles,
+  models,
+  type
+} from "./chunk-YJYVA7CY.js";
+export {
+  CODEX_REMOTE_FAST_MODE_SUPPORTED_MODELS,
+  DEFAULT_CODEX_REMOTE_BYPASS_APPROVALS_AND_SANDBOX,
+  DEFAULT_CODEX_REMOTE_MODEL,
+  SANDBOX_INSTALL_COMMAND,
+  agentConfigurationDoc,
+  isCodexRemoteFastModeSupported,
+  isCodexRemoteKnownModel,
+  isCodexRemoteManualModel,
+  label,
+  modelProfiles,
+  models,
+  type
+};

package/dist/server/adapter.js

@@ -1,157 +1,162 @@
-/**
- * External adapter entry point.
- *
- * Paperclip's adapter-plugin store loads an external adapter package by
- * importing its main entry and calling `createServerAdapter()`, which must
- * return a complete `ServerAdapterModule`. This module assembles the
- * standalone codex_remote adapter from the package's own building blocks plus
- * the sandbox preflight / remote-default behavior that previously lived in a
- * host-side registry wrapper — so nothing needs to change in upstream
- * Paperclip to register this adapter.
- */
-import { buildSandboxNpmInstallCommand, getAdapterSessionManagement, } from "@paperclipai/adapter-utils";
-import { execute as baseExecute } from "./execute.js";
-import { testEnvironment as baseTestEnvironment } from "./test.js";
-import { listCodexSkills, syncCodexSkills } from "./skills.js";
-import { sessionCodec, getQuotaWindows } from "./index.js";
-import { models, modelProfiles, agentConfigurationDoc, type } from "../index.js";
-export const CODEX_REMOTE_TYPE = type;
-const DEFAULT_REMOTE_TIMEOUT_SEC = 300;
-const CODEX_RUNTIME_PACKAGE = "@openai/codex";
-const CODEX_RUNTIME_FALLBACK_COMMAND = "codex";
+import {
+  buildSandboxNpmInstallCommand,
+  execute,
+  getAdapterSessionManagement,
+  getQuotaWindows,
+  listCodexSkills,
+  sessionCodec,
+  syncCodexSkills,
+  testEnvironment
+} from "../chunk-FULSN5VN.js";
+import {
+  agentConfigurationDoc,
+  modelProfiles,
+  models,
+  type
+} from "../chunk-YJYVA7CY.js";
+import "../chunk-ZLN6QQMX.js";
+
+// src/server/adapter.ts
+var CODEX_REMOTE_TYPE = type;
+var DEFAULT_REMOTE_TIMEOUT_SEC = 300;
+var CODEX_RUNTIME_PACKAGE = "@openai/codex";
+var CODEX_RUNTIME_FALLBACK_COMMAND = "codex";
 function requireRemoteTarget(ctx) {
-    const target = ctx.executionTarget;
-    if (!target || target.kind !== "remote") {
-        throw new Error("codex_remote requires a remote execution target.");
-    }
-    if (target.transport === "sandbox" && !target.runner) {
-        throw new Error("codex_remote requires a sandbox runner from the environment provider.");
-    }
-    return target;
+  const target = ctx.executionTarget;
+  if (!target || target.kind !== "remote") {
+    throw new Error("codex_remote requires a remote execution target.");
+  }
+  if (target.transport === "sandbox" && !target.runner) {
+    throw new Error("codex_remote requires a sandbox runner from the environment provider.");
+  }
+  return target;
 }
 function isSandboxTarget(target) {
-    return target.transport === "sandbox";
+  return target.transport === "sandbox";
 }
 function failureResult(error, prefix) {
-    const message = error instanceof Error ? error.message : String(error);
-    return {
-        exitCode: 1,
-        signal: null,
-        timedOut: false,
-        errorMessage: `${prefix}: ${message}`,
-        resultJson: {
-            error: message,
-            phase: prefix,
-        },
-    };
+  const message = error instanceof Error ? error.message : String(error);
+  return {
+    exitCode: 1,
+    signal: null,
+    timedOut: false,
+    errorMessage: `${prefix}: ${message}`,
+    resultJson: {
+      error: message,
+      phase: prefix
+    }
+  };
 }
-export function applyCodexRemoteDefaults(config) {
-    const hasExplicitTimeout = typeof config.timeoutSec === "number" && Number.isFinite(config.timeoutSec) && config.timeoutSec > 0;
-    return {
-        ...config,
-        timeoutSec: hasExplicitTimeout ? config.timeoutSec : DEFAULT_REMOTE_TIMEOUT_SEC,
-        dangerouslyBypassApprovalsAndSandbox: true,
-        // Codex Remote is sandbox-runtime only. The agent owns repository cloning
-        // and Git finalization when the task requires them, so do not upload the
-        // host workspace or request provider Git-clone realization.
-        remoteWorkspaceSync: false,
-    };
+function applyCodexRemoteDefaults(config) {
+  const hasExplicitTimeout = typeof config.timeoutSec === "number" && Number.isFinite(config.timeoutSec) && config.timeoutSec > 0;
+  return {
+    ...config,
+    timeoutSec: hasExplicitTimeout ? config.timeoutSec : DEFAULT_REMOTE_TIMEOUT_SEC,
+    dangerouslyBypassApprovalsAndSandbox: true,
+    // Codex Remote is sandbox-runtime only. The agent owns repository cloning
+    // and Git finalization when the task requires them, so do not upload the
+    // host workspace or request provider Git-clone realization.
+    remoteWorkspaceSync: false
+  };
 }
 async function verifySandboxWorkspace(input) {
-    const shell = input.target.shellCommand === "sh" ? "sh" : "bash";
-    const marker = input.bridgeChannel ? "BRIDGE_SESSION_OK" : "WORKSPACE_OK";
-    const label = input.bridgeChannel ? "bridge channel" : "main session";
-    const result = await input.target.runner.execute({
-        command: shell,
-        args: [
-            "-c",
-            `mkdir -p ${JSON.stringify(input.target.remoteCwd)} && ls -la ${JSON.stringify(input.target.remoteCwd)} 2>&1 && echo ${marker}`,
-        ],
-        cwd: "/",
-        env: input.bridgeChannel ? { PAPERCLIP_SANDBOX_EXEC_CHANNEL: "bridge" } : undefined,
-        timeoutMs: input.bridgeChannel ? 90_000 : 30_000,
-    });
-    if (result.timedOut || (result.exitCode ?? 1) !== 0) {
-        const detail = [result.stderr, result.stdout].filter(Boolean).join("\n").trim();
-        throw new Error(`codex_remote sandbox workspace verify (${label}) failed with exit=${result.exitCode ?? "null"} timedOut=${result.timedOut}${detail ? `: ${detail}` : ""}`);
-    }
-    await input.ctx.onLog("stdout", `[paperclip] codex_remote workspace verify (${label}): exit=${result.exitCode} timedOut=${result.timedOut}\n${result.stdout || ""}\n${result.stderr || ""}`);
+  const shell = input.target.shellCommand === "sh" ? "sh" : "bash";
+  const marker = input.bridgeChannel ? "BRIDGE_SESSION_OK" : "WORKSPACE_OK";
+  const label = input.bridgeChannel ? "bridge channel" : "main session";
+  const result = await input.target.runner.execute({
+    command: shell,
+    args: [
+      "-c",
+      `mkdir -p ${JSON.stringify(input.target.remoteCwd)} && ls -la ${JSON.stringify(input.target.remoteCwd)} 2>&1 && echo ${marker}`
+    ],
+    cwd: "/",
+    env: input.bridgeChannel ? { PAPERCLIP_SANDBOX_EXEC_CHANNEL: "bridge" } : void 0,
+    timeoutMs: input.bridgeChannel ? 9e4 : 3e4
+  });
+  if (result.timedOut || (result.exitCode ?? 1) !== 0) {
+    const detail = [result.stderr, result.stdout].filter(Boolean).join("\n").trim();
+    throw new Error(
+      `codex_remote sandbox workspace verify (${label}) failed with exit=${result.exitCode ?? "null"} timedOut=${result.timedOut}${detail ? `: ${detail}` : ""}`
+    );
+  }
+  await input.ctx.onLog(
+    "stdout",
+    `[paperclip] codex_remote workspace verify (${label}): exit=${result.exitCode} timedOut=${result.timedOut}
+${result.stdout || ""}
+${result.stderr || ""}`
+  );
 }
 async function executeCodexRemote(ctx) {
-    const target = requireRemoteTarget(ctx);
-    const config = applyCodexRemoteDefaults(ctx.config);
-    const codexRunTimeoutMs = typeof config.timeoutSec === "number" && config.timeoutSec > 0
-        ? config.timeoutSec * 1_000
-        : DEFAULT_REMOTE_TIMEOUT_SEC * 1_000;
-    if (isSandboxTarget(target)) {
-        try {
-            await verifySandboxWorkspace({ ctx, target });
-            await verifySandboxWorkspace({ ctx, target, bridgeChannel: true });
-        }
-        catch (error) {
-            return failureResult(error, "codex_remote_prepare_failed");
-        }
-    }
+  const target = requireRemoteTarget(ctx);
+  const config = applyCodexRemoteDefaults(ctx.config);
+  const codexRunTimeoutMs = typeof config.timeoutSec === "number" && config.timeoutSec > 0 ? config.timeoutSec * 1e3 : DEFAULT_REMOTE_TIMEOUT_SEC * 1e3;
+  if (isSandboxTarget(target)) {
     try {
-        return await baseExecute({
-            ...ctx,
-            executionTarget: isSandboxTarget(target)
-                ? {
-                    ...target,
-                    timeoutMs: codexRunTimeoutMs,
-                }
-                : target,
-            config,
-        });
-    }
-    catch (error) {
-        return failureResult(error, "codex_remote_execute_failed");
+      await verifySandboxWorkspace({ ctx, target });
+      await verifySandboxWorkspace({ ctx, target, bridgeChannel: true });
+    } catch (error) {
+      return failureResult(error, "codex_remote_prepare_failed");
     }
+  }
+  try {
+    return await execute({
+      ...ctx,
+      executionTarget: isSandboxTarget(target) ? {
+        ...target,
+        timeoutMs: codexRunTimeoutMs
+      } : target,
+      config
+    });
+  } catch (error) {
+    return failureResult(error, "codex_remote_execute_failed");
+  }
 }
 function hasPathSeparator(value) {
-    return value.includes("/") || value.includes("\\");
+  return value.includes("/") || value.includes("\\");
 }
 function shellQuote(value) {
-    return `'${value.replace(/'/g, `'\\''`)}'`;
+  return `'${value.replace(/'/g, `'\\''`)}'`;
 }
 function readConfiguredCommand(config) {
-    const value = typeof config.command === "string" ? config.command.trim() : "";
-    return value.length > 0 ? value : CODEX_RUNTIME_FALLBACK_COMMAND;
+  const value = typeof config.command === "string" ? config.command.trim() : "";
+  return value.length > 0 ? value : CODEX_RUNTIME_FALLBACK_COMMAND;
 }
 function buildRuntimeCommandSpec(config) {
-    const command = readConfiguredCommand(config);
-    const canSelfInstall = !hasPathSeparator(command) && command === CODEX_RUNTIME_FALLBACK_COMMAND;
-    const installLine = buildSandboxNpmInstallCommand(CODEX_RUNTIME_PACKAGE);
-    return {
-        command,
-        detectCommand: command,
-        installCommand: canSelfInstall
-            ? `if ! command -v ${shellQuote(command)} >/dev/null 2>&1; then ${installLine}; fi`
-            : null,
-    };
+  const command = readConfiguredCommand(config);
+  const canSelfInstall = !hasPathSeparator(command) && command === CODEX_RUNTIME_FALLBACK_COMMAND;
+  const installLine = buildSandboxNpmInstallCommand(CODEX_RUNTIME_PACKAGE);
+  return {
+    command,
+    detectCommand: command,
+    installCommand: canSelfInstall ? `if ! command -v ${shellQuote(command)} >/dev/null 2>&1; then ${installLine}; fi` : null
+  };
 }
-export function createServerAdapter() {
-    return {
-        type: CODEX_REMOTE_TYPE,
-        execute: (ctx) => executeCodexRemote(ctx),
-        testEnvironment: (ctx) => baseTestEnvironment({
-            ...ctx,
-            adapterType: CODEX_REMOTE_TYPE,
-            config: applyCodexRemoteDefaults(ctx.config),
-        }),
-        listSkills: listCodexSkills,
-        syncSkills: syncCodexSkills,
-        sessionCodec,
-        sessionManagement: getAdapterSessionManagement(CODEX_REMOTE_TYPE) ?? undefined,
-        models,
-        modelProfiles,
-        supportsLocalAgentJwt: true,
-        supportsInstructionsBundle: true,
-        instructionsPathKey: "instructionsFilePath",
-        requiresMaterializedRuntimeSkills: false,
-        getRuntimeCommandSpec: (config) => buildRuntimeCommandSpec(config),
-        getQuotaWindows,
-        agentConfigurationDoc,
-    };
+function createServerAdapter() {
+  return {
+    type: CODEX_REMOTE_TYPE,
+    execute: (ctx) => executeCodexRemote(ctx),
+    testEnvironment: (ctx) => testEnvironment({
+      ...ctx,
+      adapterType: CODEX_REMOTE_TYPE,
+      config: applyCodexRemoteDefaults(ctx.config)
+    }),
+    listSkills: listCodexSkills,
+    syncSkills: syncCodexSkills,
+    sessionCodec,
+    sessionManagement: getAdapterSessionManagement(CODEX_REMOTE_TYPE) ?? void 0,
+    models,
+    modelProfiles,
+    supportsLocalAgentJwt: true,
+    supportsInstructionsBundle: true,
+    instructionsPathKey: "instructionsFilePath",
+    requiresMaterializedRuntimeSkills: false,
+    getRuntimeCommandSpec: (config) => buildRuntimeCommandSpec(config),
+    getQuotaWindows,
+    agentConfigurationDoc
+  };
 }
-//# sourceMappingURL=adapter.js.map
+export {
+  CODEX_REMOTE_TYPE,
+  applyCodexRemoteDefaults,
+  createServerAdapter
+};