nolo-cli 0.1.11 → 0.1.13

package/ai/agent/cliPrompt.ts

@@ -0,0 +1,10 @@
+/**
+ * 构建包含 system prompt 的完整 prompt。
+ *
+ * CLI agent 与普通 model 共用 prompt / model / 最近文本上下文这些能力面，
+ * 但 CLI 不走本地 tool-calls 协议，因此这里只做文本级结构化拼接。
+ */
+export function buildCliPrompt(systemPrompt: string | undefined, taskPrompt: string): string {
+  if (!systemPrompt?.trim()) return taskPrompt;
+  return `[角色设定]\n${systemPrompt.trim()}\n\n[当前任务]\n${taskPrompt.trim()}`;
+}

package/ai/agent/machineRunPermissions.ts

@@ -0,0 +1,95 @@
+export type MachineRunPermissionMode = "read_only" | "full_access";
+
+export type MachineRunPermissionPolicy = {
+  mode: MachineRunPermissionMode;
+  allowFilesystemRead: boolean;
+  allowFilesystemWrite: boolean;
+  allowShell: boolean;
+  writableRoots: string[];
+};
+
+const DEFAULT_POLICY: MachineRunPermissionPolicy = {
+  mode: "read_only",
+  allowFilesystemRead: true,
+  allowFilesystemWrite: false,
+  allowShell: false,
+  writableRoots: [],
+};
+
+const WRITE_DENIED =
+  "Machine permission denied: this bound machine agent is read-only for filesystem writes. Enable machine write permission for this agent before asking it to modify files.";
+
+const SHELL_DENIED =
+  "Machine permission denied: this bound machine agent cannot run arbitrary shell commands. Enable machine shell permission for this agent before asking it to execute commands.";
+
+function asObject(value: unknown): Record<string, any> {
+  return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, any> : {};
+}
+
+function normalizeWritableRoots(value: unknown): string[] {
+  if (!Array.isArray(value)) return [];
+  return value
+    .filter((item): item is string => typeof item === "string")
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+export function resolveMachineRunPermissionPolicy(agentConfig: any): MachineRunPermissionPolicy {
+  const runtimeBinding = asObject(agentConfig?.runtimeBinding);
+  const raw = asObject(
+    agentConfig?.machinePermissions ??
+      runtimeBinding.permissions ??
+      runtimeBinding.machinePermissions ??
+      agentConfig?.boundRuntimeMachine?.permissions
+  );
+
+  const mode: MachineRunPermissionMode =
+    raw.mode === "full_access" || raw.allowFilesystemWrite === true || raw.allowShell === true
+      ? "full_access"
+      : "read_only";
+
+  if (mode === "full_access") {
+    return {
+      mode,
+      allowFilesystemRead: raw.allowFilesystemRead !== false,
+      allowFilesystemWrite: true,
+      allowShell: raw.allowShell !== false,
+      writableRoots: normalizeWritableRoots(raw.writableRoots),
+    };
+  }
+
+  return {
+    ...DEFAULT_POLICY,
+    allowFilesystemRead: raw.allowFilesystemRead !== false,
+  };
+}
+
+const WRITE_INTENT_RE =
+  /\b(write|overwrite|edit|modify|delete|remove|rename|move|create|save|patch|apply patch|mkdir|touch|rm|rmdir|del|erase|copy-item|move-item|remove-item|set-content|add-content|new-item)\b|[\u5199\u5220\u6539\u4FEE\u4FDD\u5B58\u521B\u5EFA\u79FB\u52A8]/i;
+
+const SHELL_INTENT_RE =
+  /\b(run|execute|exec|shell|terminal|powershell|pwsh|bash|zsh|cmd\.exe|npm|bun|node|python|git|curl|wget|ssh|scp|chmod|chown|sudo)\b|[\u8FD0\u884C\u6267\u884C\u547D\u4EE4\u7EC8\u7AEF]/i;
+
+export function assertMachineRunAllowed(userInput: string, policy: MachineRunPermissionPolicy) {
+  const task = String(userInput || "");
+  if (!policy.allowFilesystemWrite && WRITE_INTENT_RE.test(task)) {
+    throw new Error(WRITE_DENIED);
+  }
+  if (!policy.allowShell && SHELL_INTENT_RE.test(task)) {
+    throw new Error(SHELL_DENIED);
+  }
+}
+
+export function buildMachinePermissionPromptBlock(policy: MachineRunPermissionPolicy) {
+  return [
+    "--- Machine permission policy ---",
+    `Mode: ${policy.mode}`,
+    `Filesystem reads are ${policy.allowFilesystemRead ? "allowed" : "not allowed"}.`,
+    `File writes are ${policy.allowFilesystemWrite ? "allowed" : "not allowed"}.`,
+    `Arbitrary shell commands are ${policy.allowShell ? "allowed" : "not allowed"}.`,
+    policy.writableRoots.length
+      ? `Writable roots: ${policy.writableRoots.join(", ")}`
+      : "Writable roots: none.",
+    "If the user asks for an operation outside this policy, refuse instead of attempting it.",
+  ].join("\n");
+}

package/ai/agent.ts

@@ -0,0 +1,2 @@
+import { ulid } from "ulid";
+export const createAgent = () => ({ id: ulid() });

package/ai/index.ts

@@ -0,0 +1 @@
+export const test = 1;

package/authCommands.ts

@@ -1,6 +1,7 @@
 import { createInterface } from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
 import { rmSync } from "node:fs";
+import { spawn } from "node:child_process";
 
 import {
   getCurrentProfile,
@@ -8,40 +9,203 @@ import {
   loadProfileConfig,
   saveDefaultProfile,
 } from "./client/profileConfig";
+import { DEFAULT_NOLO_SERVER_URL } from "./defaultServer";
 
 function getArg(args: string[], flag: string) {
   const index = args.indexOf(flag);
   return index >= 0 ? args[index + 1] : undefined;
 }
 
-export async function runLoginCommand(args: string[]) {
-  const configPath = getDefaultProfileConfigPath();
-  const serverArg = getArg(args, "--server");
-  const tokenArg = getArg(args, "--token");
-  const rl = createInterface({ input, output });
+type LoginCommandDeps = {
+  configPath?: string;
+  fetchImpl?: typeof fetch;
+  openBrowser?: (url: string) => Promise<boolean> | boolean;
+  sleep?: (ms: number) => Promise<void>;
+  now?: () => number;
+  question?: (prompt: string) => Promise<string>;
+  output?: Pick<Console, "log">;
+  error?: Pick<Console, "error">;
+};
+
+const postJson = async (
+  fetchImpl: typeof fetch,
+  url: string,
+  body: Record<string, unknown>
+) =>
+  fetchImpl(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+
+const defaultSleep = (ms: number) =>
+  new Promise<void>((resolve) => setTimeout(resolve, ms));
+
+const defaultOpenBrowser = async (url: string) => {
+  const command =
+    process.platform === "darwin"
+      ? "open"
+      : process.platform === "win32"
+        ? "cmd"
+        : "xdg-open";
+  const args =
+    process.platform === "win32" ? ["/c", "start", "", url] : [url];
 
   try {
-    const serverUrl = (
-      serverArg ||
-      (await rl.question("server [https://nolo.chat]: ")) ||
-      "https://nolo.chat"
-    ).replace(/\/+$/, "");
-
-    const authToken = tokenArg || (await rl.question("paste auth token: "));
-    if (!authToken.trim()) {
-      console.error("No auth token provided.");
-      return 1;
+    const child = spawn(command, args, {
+      detached: true,
+      stdio: "ignore",
+    });
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+async function saveTokenLogin(args: {
+  configPath: string;
+  serverUrl: string;
+  authToken: string;
+  output: Pick<Console, "log">;
+  error: Pick<Console, "error">;
+}) {
+  if (!args.authToken.trim()) {
+    args.error.error("No auth token provided.");
+    return 1;
+  }
+
+  saveDefaultProfile(args.configPath, {
+    serverUrl: args.serverUrl,
+    authToken: args.authToken.trim(),
+  });
+  args.output.log(`Saved profile default -> ${args.serverUrl}`);
+  return 0;
+}
+
+async function runWebLogin(args: {
+  configPath: string;
+  serverUrl: string;
+  fetchImpl: typeof fetch;
+  openBrowser: (url: string) => Promise<boolean> | boolean;
+  sleep: (ms: number) => Promise<void>;
+  now: () => number;
+  output: Pick<Console, "log">;
+  error: Pick<Console, "error">;
+  noBrowser: boolean;
+}) {
+  const startResponse = await postJson(
+    args.fetchImpl,
+    `${args.serverUrl}/api/v1/users/cli-login/start`,
+    { clientName: "nolo-cli" }
+  );
+  const start = await startResponse.json().catch(() => ({} as any));
+  if (!startResponse.ok || !start?.deviceCode || !start?.verificationUriComplete) {
+    args.error.error(
+      `Failed to start web login (${startResponse.status}). Use --token to paste a token manually.`
+    );
+    return 1;
+  }
+
+  args.output.log("Open this URL to authorize nolo-cli:");
+  args.output.log(start.verificationUriComplete);
+  args.output.log(`Code: ${start.userCode}`);
+
+  if (!args.noBrowser) {
+    const opened = await args.openBrowser(start.verificationUriComplete);
+    if (!opened) {
+      args.output.log("Could not open a browser automatically. Paste the URL above.");
     }
+  }
+
+  const intervalMs = Math.max(1, Number(start.interval) || 2) * 1000;
+  const timeoutMs = Math.max(1, Number(start.expiresIn) || 600) * 1000;
+  const deadline = args.now() + timeoutMs;
+
+  while (args.now() <= deadline) {
+    const pollResponse = await postJson(
+      args.fetchImpl,
+      `${args.serverUrl}/api/v1/users/cli-login/poll`,
+      { deviceCode: start.deviceCode }
+    );
+    const poll = await pollResponse.json().catch(() => ({} as any));
+
+    if (pollResponse.status === 202) {
+      await args.sleep(intervalMs);
+      continue;
+    }
+
+    if (pollResponse.ok && poll?.token) {
+      const approvedServer =
+        typeof poll.serverUrl === "string" && poll.serverUrl.trim()
+          ? poll.serverUrl.trim().replace(/\/+$/, "")
+          : args.serverUrl;
+      return saveTokenLogin({
+        configPath: args.configPath,
+        serverUrl: approvedServer,
+        authToken: poll.token,
+        output: args.output,
+        error: args.error,
+      });
+    }
+
+    args.error.error(
+      `Web login failed: ${poll?.error || `HTTP ${pollResponse.status}`}. Use --token to paste a token manually.`
+    );
+    return 1;
+  }
 
-    saveDefaultProfile(configPath, {
+  args.error.error("Web login timed out. Run `nolo login` again or use --token.");
+  return 1;
+}
+
+export async function runLoginCommand(args: string[], deps: LoginCommandDeps = {}) {
+  const configPath = deps.configPath ?? getDefaultProfileConfigPath();
+  const serverArg = getArg(args, "--server");
+  const tokenArg = getArg(args, "--token");
+  const noBrowser = args.includes("--no-browser");
+  const outputTarget = deps.output ?? console;
+  const errorTarget = deps.error ?? console;
+  const serverUrl = (serverArg || DEFAULT_NOLO_SERVER_URL).replace(/\/+$/, "");
+
+  if (tokenArg) {
+    return saveTokenLogin({
+      configPath,
       serverUrl,
-      authToken: authToken.trim(),
+      authToken: tokenArg,
+      output: outputTarget,
+      error: errorTarget,
     });
-    console.log(`Saved profile default -> ${serverUrl}`);
-    return 0;
-  } finally {
-    rl.close();
   }
+
+  if (args.includes("--manual")) {
+    const rl = createInterface({ input, output });
+    const question = deps.question ?? ((prompt: string) => rl.question(prompt));
+    try {
+      const authToken = await question("paste auth token: ");
+      return saveTokenLogin({
+        configPath,
+        serverUrl,
+        authToken,
+        output: outputTarget,
+        error: errorTarget,
+      });
+    } finally {
+      rl.close();
+    }
+  }
+
+  return runWebLogin({
+    configPath,
+    serverUrl,
+    fetchImpl: deps.fetchImpl ?? fetch,
+    openBrowser: deps.openBrowser ?? defaultOpenBrowser,
+    sleep: deps.sleep ?? defaultSleep,
+    now: deps.now ?? Date.now,
+    output: outputTarget,
+    error: errorTarget,
+    noBrowser,
+  });
 }
 
 export function runWhoamiCommand() {

package/client/compactDialog.ts

@@ -0,0 +1,222 @@
+// packages/cli/client/compactDialog.ts
+// HTTP-only compact helper for CLI TUI (no Redux store available).
+
+import { ulid } from "ulid";
+
+const DB_PATH = "/api/v1/db";
+
+/**
+ * Extract userId from a JWT-style auth token without verifying the signature.
+ * Mirrors the logic of `parseToken` in `auth/token.ts` without the crypto imports.
+ * @internal - exported for testing only
+ */
+export function parseTokenUserId(token: string): string | null {
+  try {
+    const parts = token.split(".");
+    if (parts.length < 2) return null;
+    const payloadBase64 = parts[1];
+    const payload = JSON.parse(
+      Buffer.from(payloadBase64, "base64").toString("utf8")
+    );
+    return typeof payload?.userId === "string" ? payload.userId : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Extract the custom ID (ULID) from a dialog key like `dialog-{userId}-{id}`.
+ * Mirrors `extractCustomId` from `core/prefix` without importing it.
+ */
+function extractCustomId(key: string): string {
+  const parts = key.split("-");
+  return parts.slice(2).join("-");
+}
+
+async function readDialogRecord(
+  fetchImpl: typeof fetch,
+  serverUrl: string,
+  authToken: string,
+  dialogKey: string
+): Promise<Record<string, unknown>> {
+  const res = await fetchImpl(`${serverUrl}${DB_PATH}/read/${dialogKey}`, {
+    headers: { Authorization: `Bearer ${authToken}` },
+  });
+  if (!res.ok) {
+    throw new Error(`Failed to read dialog "${dialogKey}": HTTP ${res.status}`);
+  }
+  const data = await res.json();
+  return data as Record<string, unknown>;
+}
+
+/**
+ * Fields carried forward from the source dialog into the fork.
+ * Conversation summary/compression state is intentionally excluded so the new
+ * dialog starts clean: summary, summarizedBeforeId, proactiveSummary,
+ * proactiveSummaryBeforeId, compressionCount, summaryPending must NOT be
+ * inherited — they describe the old conversation, not the fork.
+ */
+const FORKED_CARRY_FIELDS = [
+  "cybots",
+  "type",
+  "title",
+  "spaceId",
+  "category",
+  "referenceKeys",
+  "triggerType",
+  "schedule",
+  "taskPrompt",
+  "executionMode",
+] as const;
+
+function buildForkedDialogRecord(
+  current: Record<string, unknown>,
+  userId: string
+): Record<string, unknown> & { dbKey: string; id: string } {
+  const newId = ulid();
+  const dbKey = `dialog-${userId}-${newId}`;
+  const now = new Date().toISOString();
+
+  // Explicitly pick only the allowed fields — never spread `current` wholesale.
+  const carried: Record<string, unknown> = {};
+  for (const field of FORKED_CARRY_FIELDS) {
+    if (current[field] !== undefined) {
+      carried[field] = current[field];
+    }
+  }
+
+  return {
+    ...carried,
+    id: newId,
+    dbKey,
+    inheritedFromDialogKey: current.dbKey,
+    inheritedFromDialogTitle: current.title,
+    createdAt: now,
+    updatedAt: now,
+    // reset per-dialog stats
+    inputTokens: 0,
+    outputTokens: 0,
+    totalCost: 0,
+  };
+}
+
+async function writeDialogRecord(
+  fetchImpl: typeof fetch,
+  serverUrl: string,
+  authToken: string,
+  record: Record<string, unknown> & { dbKey: string }
+): Promise<void> {
+  const res = await fetchImpl(`${serverUrl}${DB_PATH}/write/`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${authToken}`,
+    },
+    body: JSON.stringify({ data: record, customKey: record.dbKey }),
+  });
+  if (!res.ok) {
+    throw new Error(
+      `Failed to write forked dialog "${record.dbKey}": HTTP ${res.status}`
+    );
+  }
+}
+
+/**
+ * Best-effort: register the forked dialog in the space sidebar.
+ * Failure here is non-fatal since the dialog is already stored.
+ */
+async function addDialogToSpaceIfNeeded(
+  fetchImpl: typeof fetch,
+  serverUrl: string,
+  authToken: string,
+  record: Record<string, unknown> & { dbKey: string }
+): Promise<void> {
+  const rawSpaceId = record.spaceId;
+  if (!rawSpaceId || typeof rawSpaceId !== "string") return;
+
+  const normalizedSpaceId = rawSpaceId.startsWith("space-")
+    ? rawSpaceId.slice("space-".length)
+    : rawSpaceId;
+  const spaceKey = `space-${normalizedSpaceId}`;
+  const now = Date.now();
+
+  const contentEntry = {
+    title: typeof record.title === "string" ? record.title : record.id,
+    type: "dialog",
+    contentKey: record.dbKey,
+    pinned: false,
+    createdAt: now,
+    updatedAt: now,
+  };
+
+  try {
+    const res = await fetchImpl(`${serverUrl}${DB_PATH}/patch/${spaceKey}`, {
+      method: "PATCH",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${authToken}`,
+      },
+      body: JSON.stringify({ contents: { [record.dbKey]: contentEntry } }),
+    });
+    if (!res.ok) {
+      console.warn(
+        `[nolo] compact: addDialogToSpace failed for ${spaceKey}: HTTP ${res.status}`
+      );
+    }
+  } catch (error) {
+    console.warn(`[nolo] compact: addDialogToSpace error: ${error}`);
+  }
+}
+
+export type CompactDialogResult = {
+  dialogId: string;
+  dialogKey: string;
+  spaceId?: string;
+};
+
+/**
+ * Compact the current dialog by forking it:
+ * 1. Read the current dialog config from the server.
+ * 2. Build a new dialog record that inherits from the old one.
+ * 3. Write the new record to the server.
+ * 4. Register the new dialog in the space sidebar (best-effort).
+ *
+ * Returns the new dialog's ID so the TUI can switch to it.
+ */
+export async function compactDialog(options: {
+  serverUrl: string;
+  authToken: string;
+  dialogId: string;
+  fetchImpl?: typeof fetch;
+}): Promise<CompactDialogResult> {
+  const fetchImpl = options.fetchImpl ?? fetch;
+
+  const userId = parseTokenUserId(options.authToken);
+  if (!userId) {
+    throw new Error(
+      "[nolo] compact: cannot compact — invalid or missing auth token"
+    );
+  }
+
+  const dialogKey = `dialog-${userId}-${options.dialogId}`;
+  const current = await readDialogRecord(
+    fetchImpl,
+    options.serverUrl,
+    options.authToken,
+    dialogKey
+  );
+  const next = buildForkedDialogRecord(current, userId);
+  await writeDialogRecord(fetchImpl, options.serverUrl, options.authToken, next);
+  await addDialogToSpaceIfNeeded(
+    fetchImpl,
+    options.serverUrl,
+    options.authToken,
+    next
+  );
+
+  return {
+    dialogId: extractCustomId(next.dbKey),
+    dialogKey: next.dbKey,
+    spaceId: typeof next.spaceId === "string" ? next.spaceId : undefined,
+  };
+}

package/commandRegistry.ts

@@ -73,6 +73,8 @@ export function renderHelpText() {
     "  nolo",
     "  nolo chat",
     "  nolo login",
+    "  nolo login --no-browser",
+    "  nolo login --token <auth-token>",
     "  nolo whoami",
     "  nolo connect",
     "  nolo connect --watch",

package/connector-experimental/capabilities.ts

@@ -0,0 +1,73 @@
+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[], capability: 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"],
+];
+
+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, capability] 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(capability);
+  }
+
+  if (env.NOLO_LOCAL_LLM_ENDPOINT || env.LLAMA_SERVER_URL) {
+    capabilities.push("local-llm");
+  }
+
+  return capabilities;
+}

package/connector-experimental/codexBinary.ts

@@ -0,0 +1,41 @@
+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";
+}