nolo-cli 0.1.45 → 0.1.46

package/client/localRuntimeDryRun.test.ts

@@ -1,135 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { mkdtempSync, readFileSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-
-import { runLocalAgentTurn } from "../agent-runtime/localLoop";
-import { createCliLocalRuntimeAdapter } from "./localRuntimeAdapter";
-
-describe("CLI local runtime dry run", () => {
-  const DEFAULT_PRIVATE_LOCAL_TOOL_NAMES = [
-    "listFiles",
-    "readFile",
-    "writeFile",
-    "editFile",
-    "globFiles",
-    "searchFiles",
-    "execShell",
-    "listDialogs",
-    "readDialog",
-    "listAgents",
-    "readAgent",
-    "listSpaces",
-    "readSpace",
-    "readDoc",
-    "readSkillDoc",
-    "listTables",
-    "queryTableRows",
-    "cliWhoami",
-    "cliDoctor",
-  ];
-
-  test("lets a declared workspace file tool write a file and save the tool trace", async () => {
-    const workspaceRoot = mkdtempSync(join(tmpdir(), "nolo-local-runtime-dry-run-"));
-    try {
-      const records = new Map<string, any>([
-        ["agent-user-1-frontend", {
-          dbKey: "agent-user-1-frontend",
-          id: "frontend",
-          name: "Frontend Implementer",
-          prompt: "Use workspace file tools to edit files.",
-          model: "qwen-coder",
-          tools: [
-            { type: "function", function: { name: "writeFile" } },
-          ],
-        }],
-      ]);
-      const batchOps: any[] = [];
-      let completeCount = 0;
-      const adapter = createCliLocalRuntimeAdapter({
-        env: {
-          NOLO_LOCAL_USER_ID: "user-1",
-          NOLO_LOCAL_OPENAI_BASE_URL: "http://127.0.0.1:11434/v1",
-        },
-        db: {
-          get: async (key) => {
-            if (!records.has(key)) throw new Error(`not found: ${key}`);
-            return records.get(key);
-          },
-          put: async (key, value) => {
-            records.set(key, value);
-          },
-          batch: async (ops) => {
-            batchOps.push(...ops);
-            for (const op of ops) {
-              if (op.type === "put") records.set(op.key, op.value);
-            }
-          },
-          iterator: () => (async function* () {})(),
-        },
-        cwd: workspaceRoot,
-        now: () => 1710000000000,
-        createId: () => "dialog-dry-run",
-        fetchImpl: async (_url, init) => {
-          const body = JSON.parse(String(init?.body));
-          completeCount += 1;
-          if (completeCount === 1) {
-            expect(body.tools.map((tool: any) => tool.function.name)).toEqual(DEFAULT_PRIVATE_LOCAL_TOOL_NAMES);
-            return Response.json({
-              model: "qwen-coder",
-              choices: [{
-                message: {
-                  content: "",
-                  tool_calls: [{
-                    id: "call-1",
-                    type: "function",
-                    function: {
-                      name: "writeFile",
-                      arguments: JSON.stringify({
-                        path: "src/notification.css",
-                        content: ".notification { border-radius: 8px; }\n",
-                      }),
-                    },
-                  }],
-                },
-              }],
-            });
-          }
-          expect(body.messages.at(-1)).toMatchObject({
-            role: "tool",
-            content: "wrote src/notification.css",
-            tool_call_id: "call-1",
-          });
-          return Response.json({
-            model: "qwen-coder",
-            choices: [{ message: { content: "updated" } }],
-          });
-        },
-      });
-
-      const result = await runLocalAgentTurn({
-        adapter,
-        agentRef: "frontend",
-        input: "fix notification UI",
-      });
-
-      expect(result).toMatchObject({
-        dialogId: "dialog-dry-run",
-        content: "updated",
-        toolCallCount: 1,
-      });
-      expect(readFileSync(join(workspaceRoot, "src/notification.css"), "utf8")).toBe(
-        ".notification { border-radius: 8px; }\n"
-      );
-      expect(batchOps.map((op) => op.key)).toEqual([
-        "dialog-user-1-dialog-dry-run",
-        "dialog-dialog-dry-run-msg-1710000000000-001",
-        "dialog-dialog-dry-run-msg-1710000000000-002",
-        "dialog-dialog-dry-run-msg-1710000000000-003",
-        "dialog-dialog-dry-run-msg-1710000000000-004",
-      ]);
-    } finally {
-      rmSync(workspaceRoot, { recursive: true, force: true });
-    }
-  });
-});

package/client/localToolPolicy.test.ts

@@ -1,48 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import { executeLocalToolWithPolicy, resolveLocalToolPolicy } from "./localToolPolicy";
-
-describe("CLI local tool policy", () => {
-  test("allows execShell by default", () => {
-    expect(resolveLocalToolPolicy({
-      env: {},
-      agentToolNames: [],
-      toolName: "execShell",
-    })).toEqual({ allowed: true, toolName: "execShell" });
-  });
-
-  test("allows execShell even without env allowlist", () => {
-    expect(resolveLocalToolPolicy({
-      env: { NOLO_LOCAL_ALLOWED_TOOLS: "execShell" },
-      agentToolNames: ["execShell"],
-      toolName: "execShell",
-    })).toEqual({ allowed: true, toolName: "execShell" });
-  });
-
-  test("requires both env allowlist and agent declaration", () => {
-    expect(resolveLocalToolPolicy({
-      env: { NOLO_LOCAL_ALLOWED_TOOLS: "readFile" },
-      agentToolNames: ["readFile"],
-      toolName: "readFile",
-    })).toEqual({ allowed: true, toolName: "readFile" });
-
-    expect(resolveLocalToolPolicy({
-      env: { NOLO_LOCAL_ALLOWED_TOOLS: "readFile" },
-      agentToolNames: [],
-      toolName: "readFile",
-    })).toMatchObject({ allowed: false });
-  });
-
-  test("executes only registered tools after policy allows them", async () => {
-    const result = await executeLocalToolWithPolicy({
-      env: { NOLO_LOCAL_ALLOWED_TOOLS: "readFile" },
-      agentToolNames: ["readFile"],
-      call: { id: "call-1", name: "readFile", arguments: "{\"path\":\"README.md\"}" },
-      executors: {
-        readFile: async (call) => ({ content: `read:${call.arguments}` }),
-      },
-    });
-
-    expect(result.content).toContain("README.md");
-  });
-});

package/client/localToolPolicy.ts

@@ -1,8 +0,0 @@
-export {
-  executeLocalToolWithPolicy,
-  resolveLocalToolPolicy,
-} from "../agentRuntimeLocal";
-
-export type {
-  LocalToolPolicyDecision,
-} from "../agentRuntimeLocal";

package/client/profileConfig.test.ts

@@ -1,106 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { mkdtempSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-
-import {
-  buildCliRuntimeEnv,
-  buildEnvFromProfile,
-  loadProfileConfig,
-  normalizeProfileServerUrl,
-  saveDefaultProfile,
-} from "./profileConfig";
-
-describe("cli profile config", () => {
-  test("saves and loads the default profile", () => {
-    const dir = mkdtempSync(join(tmpdir(), "nolo-profile-"));
-    try {
-      const path = join(dir, "config.json");
-
-      saveDefaultProfile(path, {
-        serverUrl: "https://nolo.chat",
-        authToken: "token-123",
-        agentKey: "agent-pub-abc",
-        agentName: "app-builder",
-      });
-
-      const config = loadProfileConfig(path);
-      expect(config.currentProfile).toBe("default");
-      expect(config.profiles.default.serverUrl).toBe("https://nolo.chat");
-      expect(config.profiles.default.authToken).toBe("token-123");
-      expect(buildEnvFromProfile(config)).toEqual({
-        NOLO_PROFILE: "default",
-        NOLO_SERVER: "https://nolo.chat",
-        AUTH_TOKEN: "token-123",
-        NOLO_AGENT: "agent-pub-abc",
-        NOLO_AGENT_NAME: "app-builder",
-      });
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  test("loadProfileConfig normalizes legacy nolo.chat http profiles", () => {
-    const dir = mkdtempSync(join(tmpdir(), "nolo-profile-load-"));
-    try {
-      const path = join(dir, "config.json");
-      saveDefaultProfile(path, {
-        serverUrl: "http://nolo.chat",
-        authToken: "token-123",
-      });
-
-      const config = loadProfileConfig(path);
-      expect(config?.profiles.default.serverUrl).toBe("https://nolo.chat");
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  test("normalizes nolo.chat profiles to https when saving", () => {
-    expect(normalizeProfileServerUrl("http://nolo.chat")).toBe("https://nolo.chat");
-    expect(normalizeProfileServerUrl("http://us.nolo.chat/")).toBe("https://us.nolo.chat");
-    expect(normalizeProfileServerUrl("https://nolo.chat")).toBe("https://nolo.chat");
-    expect(normalizeProfileServerUrl("http://127.0.0.1:38123")).toBe("http://127.0.0.1:38123");
-  });
-
-  test("runtime env prefers the saved profile token over ambient AUTH_TOKEN", () => {
-    const runtimeEnv = buildCliRuntimeEnv(
-      {
-        AUTH_TOKEN: "ambient-token",
-      } as NodeJS.ProcessEnv,
-      {
-        currentProfile: "default",
-        profiles: {
-          default: {
-            serverUrl: "https://nolo.chat",
-            authToken: "profile-token",
-          },
-        },
-      }
-    );
-
-    expect(runtimeEnv.AUTH_TOKEN).toBe("profile-token");
-    expect(runtimeEnv.NOLO_SERVER).toBe("https://nolo.chat");
-  });
-
-  test("runtime env still honors an explicit server override", () => {
-    const runtimeEnv = buildCliRuntimeEnv(
-      {
-        NOLO_SERVER: "https://us.nolo.chat",
-      } as NodeJS.ProcessEnv,
-      {
-        currentProfile: "default",
-        profiles: {
-          default: {
-            serverUrl: "https://nolo.chat",
-            authToken: "profile-token",
-          },
-        },
-      }
-    );
-
-    expect(runtimeEnv.AUTH_TOKEN).toBe("profile-token");
-    expect(runtimeEnv.NOLO_SERVER).toBe("https://us.nolo.chat");
-    expect(runtimeEnv.BASE_URL).toBe("https://us.nolo.chat");
-  });
-});

package/client/profileConfig.ts

@@ -1,101 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { homedir } from "node:os";
-
-export type NoloProfile = {
-  serverUrl: string;
-  authToken: string;
-  agentKey?: string;
-  agentName?: string;
-};
-
-export type NoloProfileConfig = {
-  currentProfile: string;
-  profiles: Record<string, NoloProfile>;
-};
-
-export function normalizeProfileServerUrl(serverUrl: string) {
-  const normalized = serverUrl.trim().replace(/\/+$/, "");
-  if (!normalized) return normalized;
-  try {
-    const url = new URL(normalized);
-    if (url.protocol === "http:" && /\.?nolo\.chat$/i.test(url.hostname)) {
-      url.protocol = "https:";
-      return url.toString().replace(/\/+$/, "");
-    }
-  } catch {
-    return normalized;
-  }
-  return normalized;
-}
-
-export function getDefaultProfileConfigPath() {
-  return join(homedir(), ".nolo", "config.json");
-}
-
-export function loadProfileConfig(path = getDefaultProfileConfigPath()): NoloProfileConfig | null {
-  if (!existsSync(path)) return null;
-  const raw = readFileSync(path, "utf8");
-  const parsed = JSON.parse(raw) as NoloProfileConfig;
-  if (!parsed.currentProfile || !parsed.profiles?.[parsed.currentProfile]) return null;
-  for (const profile of Object.values(parsed.profiles)) {
-    if (!profile?.serverUrl) continue;
-    profile.serverUrl = normalizeProfileServerUrl(profile.serverUrl);
-  }
-  return parsed;
-}
-
-export function saveDefaultProfile(
-  path: string,
-  profile: NoloProfile
-): NoloProfileConfig {
-  const config: NoloProfileConfig = {
-    currentProfile: "default",
-    profiles: {
-      default: profile,
-    },
-  };
-  config.profiles.default.serverUrl = normalizeProfileServerUrl(
-    config.profiles.default.serverUrl
-  );
-  mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, `${JSON.stringify(config, null, 2)}\n`, "utf8");
-  return config;
-}
-
-export function buildEnvFromProfile(config: NoloProfileConfig | null) {
-  if (!config) return {};
-  const profile = config.profiles[config.currentProfile];
-  if (!profile) return {};
-  return {
-    NOLO_PROFILE: config.currentProfile,
-    NOLO_SERVER: profile.serverUrl,
-    AUTH_TOKEN: profile.authToken,
-    ...(profile.agentKey ? { NOLO_AGENT: profile.agentKey } : {}),
-    ...(profile.agentName ? { NOLO_AGENT_NAME: profile.agentName } : {}),
-  };
-}
-
-export function buildCliRuntimeEnv(
-  processEnv: NodeJS.ProcessEnv,
-  config: NoloProfileConfig | null
-) {
-  const profileEnv = buildEnvFromProfile(config);
-  const explicitServerUrl =
-    processEnv.NOLO_SERVER || processEnv.NOLO_SERVER_URL || processEnv.BASE_URL;
-  return {
-    ...processEnv,
-    ...profileEnv,
-    ...(explicitServerUrl
-      ? {
-          NOLO_SERVER: explicitServerUrl,
-          BASE_URL: explicitServerUrl,
-        }
-      : {}),
-  };
-}
-
-export function getCurrentProfile(config: NoloProfileConfig | null) {
-  if (!config) return null;
-  return config.profiles[config.currentProfile] ?? null;
-}

package/client/streamingOutput.test.ts

@@ -1,22 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import { createStreamingTextWriter, splitStreamingText } from "./streamingOutput";
-
-describe("streamingOutput", () => {
-  test("splits text into user-visible characters instead of UTF-16 code units", () => {
-    expect(splitStreamingText("A你👍🏽B")).toEqual(["A", "你", "👍🏽", "B"]);
-  });
-
-  test("flushes text in small character batches", () => {
-    const chunks: string[] = [];
-    const writer = createStreamingTextWriter({
-      write: (chunk) => chunks.push(chunk),
-      batchSize: 2,
-    });
-
-    writer.push("abcd");
-    writer.flushAll();
-
-    expect(chunks).toEqual(["ab", "cd"]);
-  });
-});

package/client/streamingOutput.ts

@@ -1,38 +0,0 @@
-type OutputLike = {
-  write(chunk: string): unknown;
-};
-
-export function splitStreamingText(content: string): string[] {
-  const Segmenter = Intl.Segmenter;
-  if (typeof Segmenter === "function") {
-    const segmenter = new Segmenter(undefined, { granularity: "grapheme" });
-    return Array.from(segmenter.segment(content), (part) => part.segment);
-  }
-  return Array.from(content);
-}
-
-export function createStreamingTextWriter({
-  write,
-  batchSize = 3,
-}: {
-  write: OutputLike["write"];
-  batchSize?: number;
-}) {
-  const queue: string[] = [];
-  const safeBatchSize = Math.max(1, batchSize);
-
-  const flushNext = () => {
-    if (!queue.length) return;
-    write(queue.splice(0, safeBatchSize).join(""));
-  };
-
-  return {
-    push(content: string) {
-      queue.push(...splitStreamingText(content));
-      flushNext();
-    },
-    flushAll() {
-      while (queue.length) flushNext();
-    },
-  };
-}

package/commandRegistry.ts

@@ -1,98 +0,0 @@
-export type { CliPackageInfo, CliRuntimeContext, CommandEntry } from "./cliCommandTypes";
-export {
-  createCliRuntimeContext,
-  looksLikeDaemonShortcut,
-  runResolvedCommand,
-} from "./cliCommandDispatch";
-import type { CommandEntry } from "./cliCommandTypes";
-import { getInternalCommandEntries } from "./internalCommandEntries";
-import { getScriptCommandEntries } from "./scriptCommandEntries";
-
-export const COMMANDS: CommandEntry[] = [
-  ...getInternalCommandEntries(renderHelpText),
-  ...getScriptCommandEntries(),
-];
-
-export const GROUP_ORDER = [
-  "run",
-  "chat",
-  "doc",
-  "skill-doc",
-  "skill",
-  "agent",
-  "doctor",
-  "dialog",
-  "memory",
-  "space",
-  "table",
-  "llama",
-  "model-runtime",
-  "dev",
-] as const;
-
-export function renderHelpText() {
-  const lines = [
-    "nolo — Agent-first terminal workspace",
-    "",
-    "Usage:",
-    "  nolo",
-    "  nolo <command> [subcommand] [...args]",
-    "  nolo doctor",
-    "  nolo update",
-    "",
-    "Examples:",
-    "  nolo",
-    "  nolo chat",
-    "  nolo login",
-    "  nolo login --no-browser",
-    "  nolo login --token <auth-token>",
-    "  nolo whoami",
-    "  nolo connect",
-    "  nolo connect --watch",
-    "  nolo connect --ws",
-    "  nolo connect --ws --server-url https://api.nolo.chat --machine-key sk_machine_xxx",
-    "  nolo connect --daemon --server-url https://api.nolo.chat --machine-key sk_machine_xxx",
-    "  nolo machine status",
-    "  nolo doctor",
-    "  nolo doctor runtime",
-    "  nolo update",
-    '  nolo run "review this repository"  # no Nolo login required; uses local Codex CLI',
-    '  nolo doc create --title "Trip Notes" --body "hello" --sync local,us --dry-run',
-    '  nolo skill-doc create --title "Agent Query Skill" --description "Inspect recent agent dialogs" --sync local,main,us',
-    "  nolo agent list --json",
-    "  nolo space list --json",
-    "  nolo agent pull agent-pub-01APPBUILDER00000001YAII3I",
-  "  nolo agent read agent-pub-01APPBUILDER00000001YAII3I",
-    "  nolo agent usage qoder",
-  '  nolo agent run frontend --msg "polish notifications"',
-    "  nolo agent bind-current agent-user-1-agent-1",
-    "  nolo agent runtime-doctor agent-user-1-agent-1",
-    '  nolo agent smoke-current agent-user-1-agent-1 --msg "ping"',
-    '  nolo chat --agent agent-pub-01APPBUILDER00000001YAII3I --msg "你好"',
-    "  nolo memory delete --source-dialog 01ABC... --yes --json",
-    "  nolo space read 01KKY77TT0DA9NY7TNW3R7255N --content-key page-user-id --brief",
-    "  nolo space delete --name-prefix rn_owner_verify_0504 --yes",
-    "  nolo table query --table 01ABCXYZ",
-    '  nolo table query --table meta-your-user-TASKBOARD --columns \'["title","status","owner","priority","codeStatus"]\' --no-base-fields --output items',
-    '  nolo table update-row --table meta-your-user-TASKBOARD --row 01ROWID --changes \'{"status":"done"}\'',
-    "  nolo llama status",
-  ];
-
-  for (const group of GROUP_ORDER) {
-    const commands = COMMANDS.filter((entry) => entry.path[0] === group);
-    if (commands.length === 0) continue;
-    lines.push("", group);
-    for (const entry of commands) {
-      lines.push(`  ${entry.path.join(" ")}  ${entry.description}`);
-    }
-  }
-
-  return lines.join("\n");
-}
-
-export function resolveCommand(args: string[]) {
-  const sorted = [...COMMANDS].sort((a, b) => b.path.length - a.path.length);
-  return sorted.find((entry) =>
-    entry.path.every((part, index) => args[index] === part)
-  );
-}

package/connector-experimental/capabilities.ts

@@ -1,75 +0,0 @@
-import { spawnSync } from "node:child_process";
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-import { resolveLaunchableCodexCommand } from "./codexBinary";
-
-type EnvLike = Record<string, string | undefined>;
-
-type DetectRuntimeCapabilitiesOptions = {
-  commandExists?: (command: string) => boolean;
-  commandLaunchable?: (command: string, args: string[]) => boolean;
-  env?: EnvLike;
-  probeLaunchable?: boolean;
-};
-
-type CommandProbe = {
-  command: string;
-  args: string[];
-};
-
-const COMMAND_CAPABILITIES: Array<[probes: CommandProbe[], capabilities: string[]]> = [
-  [[{ command: "codex", args: ["--version"] }], ["codex-cli"]],
-  [[{ command: "claude", args: ["--version"] }], ["claude-code"]],
-  [
-    [
-      { command: "gh", args: ["--version"] },
-      { command: "gh", args: ["copilot", "--", "--help"] },
-    ],
-    ["copilot-cli"],
-  ],
-  [[{ command: "gemini", args: ["--version"] }], ["gemini-cli"]],
-  [[{ command: "kimi", args: ["--version"] }], ["kimi-cli"]],
-  [[{ command: "agy", args: ["--help"] }], ["agy-cli"]],
-  [[{ command: "qoder", args: ["--version"] }], ["qoder-cli", "qoder-usage"]],
-];
-
-function defaultCommandExists(command: string) {
-  const pathEntries = (process.env.PATH ?? "").split(process.platform === "win32" ? ";" : ":");
-  const extensions = process.platform === "win32" ? [".exe", ".cmd", ".bat", ""] : [""];
-  return pathEntries.some((entry) =>
-    extensions.some((extension) => existsSync(join(entry, `${command}${extension}`)))
-  );
-}
-
-function defaultCommandLaunchable(command: string, args: string[]) {
-  const executable = command === "codex" ? resolveLaunchableCodexCommand() : command;
-  const result = spawnSync(executable, args, {
-    stdio: "pipe",
-    timeout: 3_000,
-    windowsHide: true,
-  });
-  return !result.error && result.status === 0;
-}
-
-export function detectRuntimeCapabilities(
-  options: DetectRuntimeCapabilitiesOptions = {}
-): string[] {
-  const commandExists = options.commandExists ?? defaultCommandExists;
-  const commandLaunchable = options.commandLaunchable ?? defaultCommandLaunchable;
-  const env = options.env ?? process.env;
-  const capabilities: string[] = [];
-
-  for (const [probes, detectedCapabilities] of COMMAND_CAPABILITIES) {
-    if (!probes.every((probe) => commandExists(probe.command))) continue;
-    if (options.probeLaunchable && !probes.every((probe) => commandLaunchable(probe.command, probe.args))) {
-      continue;
-    }
-    capabilities.push(...detectedCapabilities);
-  }
-
-  if (env.NOLO_LOCAL_LLM_ENDPOINT || env.LLAMA_SERVER_URL) {
-    capabilities.push("local-llm");
-  }
-
-  return capabilities;
-}

package/connector-experimental/codexBinary.ts

@@ -1,41 +0,0 @@
-import { copyFileSync, existsSync, mkdirSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
-
-type EnvLike = Record<string, string | undefined>;
-
-const WINDOWS_APPS_CODEX_PATTERN = /\\WindowsApps\\OpenAI\.Codex_[^\\]+\\app\\resources$/i;
-
-function pathEntries(env: EnvLike) {
-  return (env.PATH ?? process.env.PATH ?? "").split(process.platform === "win32" ? ";" : ":");
-}
-
-function findWindowsAppsCodex(env: EnvLike) {
-  if (process.platform !== "win32") return "";
-  for (const entry of pathEntries(env)) {
-    if (!WINDOWS_APPS_CODEX_PATTERN.test(entry)) continue;
-    const candidate = join(entry, "codex.exe");
-    if (existsSync(candidate)) return candidate;
-  }
-  return "";
-}
-
-function copyCodexToUserBin(source: string, env: EnvLike) {
-  const target =
-    env.NOLO_CODEX_SHIM_PATH ??
-    join(homedir(), ".nolo", "bin", "codex.exe");
-  if (existsSync(target)) return target;
-  mkdirSync(dirname(target), { recursive: true });
-  copyFileSync(source, target);
-  return target;
-}
-
-export function resolveLaunchableCodexCommand(env: EnvLike = process.env) {
-  const explicit = env.NOLO_CODEX_BIN?.trim();
-  if (explicit) return explicit;
-
-  const windowsAppsCodex = findWindowsAppsCodex(env);
-  if (windowsAppsCodex) return copyCodexToUserBin(windowsAppsCodex, env);
-
-  return "codex";
-}