nolo-cli 0.1.26 → 0.1.29

package/client/agentRunLocalExecution.test.ts

@@ -0,0 +1,123 @@
+import { describe, expect, test } from "bun:test";
+
+import type { LocalAgentToolEvent } from "../agent-runtime/localLoop";
+import {
+  classifyTaskRunReviewStatus,
+  formatToolTraceEvent,
+  nextLocalToolRoundLimit,
+  parseLocalToolRoundLimitError,
+  resolveLocalToolRoundRetryLimit,
+  shouldCollectLocalToolEvidence,
+  shouldTraceLocalTools,
+  summarizeLocalToolEvidence,
+} from "./agentRunLocalExecution";
+
+function makeToolEvent(
+  overrides: Partial<LocalAgentToolEvent> & Pick<LocalAgentToolEvent, "type">
+): LocalAgentToolEvent {
+  return {
+    type: overrides.type,
+    round: overrides.round ?? 0,
+    toolCallId: overrides.toolCallId ?? "call-1",
+    toolName: overrides.toolName ?? "readWorkspaceFile",
+    message: overrides.message,
+    metadata: overrides.metadata,
+  };
+}
+
+describe("agentRunLocalExecution", () => {
+  test("traces local tools from explicit option or env flag", () => {
+    expect(shouldTraceLocalTools({ traceTools: true, env: {} })).toBe(true);
+    expect(shouldTraceLocalTools({ traceTools: false, env: { NOLO_TRACE_TOOLS: "1" } })).toBe(
+      true
+    );
+    expect(shouldTraceLocalTools({ env: {} })).toBe(false);
+  });
+
+  test("collects local tool evidence only when task-run row key exists", () => {
+    expect(shouldCollectLocalToolEvidence({ taskRunContext: { rowDbKey: "row-1" } })).toBe(true);
+    expect(shouldCollectLocalToolEvidence({ taskRunContext: {} })).toBe(false);
+    expect(shouldCollectLocalToolEvidence({})).toBe(false);
+  });
+
+  test("summarizes tool evidence with unique tools and event counts", () => {
+    const events: LocalAgentToolEvent[] = [
+      makeToolEvent({ type: "tool-call", toolName: "readWorkspaceFile", toolCallId: "call-1" }),
+      makeToolEvent({ type: "tool-result", toolName: "readWorkspaceFile", toolCallId: "call-1" }),
+      makeToolEvent({ type: "tool-call", round: 1, toolName: "execShell", toolCallId: "call-2" }),
+      makeToolEvent({ type: "tool-error", round: 1, toolName: "execShell", toolCallId: "call-2" }),
+      makeToolEvent({ type: "tool-call", round: 1, toolName: "readWorkspaceFile", toolCallId: "call-3" }),
+    ];
+
+    expect(summarizeLocalToolEvidence(events)).toEqual({
+      toolsUsed: ["readWorkspaceFile", "execShell"],
+      summary: {
+        callCount: 3,
+        resultCount: 1,
+        errorCount: 1,
+        rounds: 2,
+      },
+    });
+    expect(summarizeLocalToolEvidence([])).toBeUndefined();
+  });
+
+  test("parses local tool round limit errors only from matching messages", () => {
+    expect(parseLocalToolRoundLimitError(new Error("Local agent exceeded max tool rounds: 256"))).toBe(
+      256
+    );
+    expect(parseLocalToolRoundLimitError("Local agent exceeded max tool rounds: 4")).toBe(4);
+    expect(parseLocalToolRoundLimitError(new Error("other failure"))).toBeNull();
+  });
+
+  test("resolves retry limit from env positive integers and falls back to default", () => {
+    expect(resolveLocalToolRoundRetryLimit({ env: { NOLO_LOCAL_MAX_TOOL_ROUNDS_LIMIT: "64" } })).toBe(
+      64
+    );
+    expect(resolveLocalToolRoundRetryLimit({ env: { NOLO_LOCAL_MAX_TOOL_ROUNDS_LIMIT: "0" } })).toBe(
+      512
+    );
+    expect(resolveLocalToolRoundRetryLimit({ env: { NOLO_LOCAL_MAX_TOOL_ROUNDS_LIMIT: "abc" } })).toBe(
+      512
+    );
+    expect(resolveLocalToolRoundRetryLimit({ env: {} })).toBe(512);
+  });
+
+  test("increments next local tool round limit by doubling positive values", () => {
+    expect(nextLocalToolRoundLimit(0)).toBe(1);
+    expect(nextLocalToolRoundLimit(-1)).toBe(1);
+    expect(nextLocalToolRoundLimit(8)).toBe(16);
+  });
+
+  test("formats tool trace events for calls, results, and errors", () => {
+    expect(
+      formatToolTraceEvent(
+        makeToolEvent({ type: "tool-call", round: 0, toolName: "readWorkspaceFile", toolCallId: "call-1" })
+      )
+    ).toBe("[nolo:tool] round 1 -> readWorkspaceFile (call-1)\n");
+    expect(
+      formatToolTraceEvent(
+        makeToolEvent({ type: "tool-result", round: 1, toolName: "readWorkspaceFile", toolCallId: "call-1" })
+      )
+    ).toBe("[nolo:tool] round 2 <- readWorkspaceFile (call-1)\n");
+    expect(
+      formatToolTraceEvent(
+        makeToolEvent({
+          type: "tool-error",
+          round: 1,
+          toolName: "execShell",
+          toolCallId: "call-2",
+          message: "timed out",
+        })
+      )
+    ).toBe("[nolo:tool] round 2 !! execShell: timed out\n");
+  });
+
+  test("classifies review status only from explicit or strong signals", () => {
+    expect(classifyTaskRunReviewStatus("Review decision: passed")).toBe("passed");
+    expect(classifyTaskRunReviewStatus("Changes requested for missing test coverage")).toBe(
+      "needs_changes"
+    );
+    expect(classifyTaskRunReviewStatus("无法审查，存在阻塞")).toBe("blocked");
+    expect(classifyTaskRunReviewStatus("I looked at the diff and have notes")).toBeUndefined();
+  });
+});

package/client/agentRunLocalExecution.ts

@@ -0,0 +1,124 @@
+import type { LocalAgentToolEvent } from "../agent-runtime/localLoop";
+import type { EnvLike } from "../cliEnvHelpers";
+
+type TaskRunReviewStatus = "passed" | "needs_changes" | "blocked";
+
+export type TaskRunToolEvidence = {
+  toolsUsed: string[];
+  summary: {
+    callCount: number;
+    resultCount: number;
+    errorCount: number;
+    rounds: number;
+  };
+};
+
+type TraceLocalToolOptions = {
+  traceTools?: boolean;
+  env: EnvLike;
+};
+
+type CollectLocalToolEvidenceOptions = {
+  taskRunContext?: {
+    rowDbKey?: string;
+  };
+};
+
+type ResolveLocalToolRoundRetryLimitOptions = {
+  env: EnvLike;
+};
+
+const DEFAULT_LOCAL_AGENT_TOOL_ROUND_RETRY_LIMIT = 512;
+
+function parsePositiveInteger(value: string | undefined) {
+  if (!value) return null;
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed <= 0) return null;
+  return parsed;
+}
+
+export function shouldTraceLocalTools(options: TraceLocalToolOptions) {
+  return Boolean(options.traceTools || options.env.NOLO_TRACE_TOOLS === "1");
+}
+
+export function shouldCollectLocalToolEvidence(options: CollectLocalToolEvidenceOptions) {
+  return Boolean(options.taskRunContext?.rowDbKey);
+}
+
+export function summarizeLocalToolEvidence(
+  events: LocalAgentToolEvent[]
+): TaskRunToolEvidence | undefined {
+  if (events.length === 0) return undefined;
+  const toolsUsed = [
+    ...new Set(
+      events
+        .filter((event) => event.type === "tool-call")
+        .map((event) => event.toolName)
+        .filter(Boolean)
+    ),
+  ];
+  const rounds = new Set(events.map((event) => event.round)).size;
+  return {
+    toolsUsed,
+    summary: {
+      callCount: events.filter((event) => event.type === "tool-call").length,
+      resultCount: events.filter((event) => event.type === "tool-result").length,
+      errorCount: events.filter((event) => event.type === "tool-error").length,
+      rounds,
+    },
+  };
+}
+
+export function parseLocalToolRoundLimitError(error: unknown) {
+  const message = error instanceof Error ? error.message : String(error);
+  const match = message.match(/Local agent exceeded max tool rounds:\s*(\d+)/);
+  if (!match) return null;
+  return Number(match[1]);
+}
+
+export function resolveLocalToolRoundRetryLimit(
+  options: ResolveLocalToolRoundRetryLimitOptions
+) {
+  return (
+    parsePositiveInteger(options.env.NOLO_LOCAL_MAX_TOOL_ROUNDS_LIMIT) ??
+    DEFAULT_LOCAL_AGENT_TOOL_ROUND_RETRY_LIMIT
+  );
+}
+
+export function nextLocalToolRoundLimit(current: number) {
+  return current <= 0 ? 1 : current * 2;
+}
+
+export function formatToolTraceEvent(event: LocalAgentToolEvent) {
+  const round = event.round + 1;
+  if (event.type === "tool-call") {
+    return `[nolo:tool] round ${round} -> ${event.toolName} (${event.toolCallId})\n`;
+  }
+  if (event.type === "tool-error") {
+    return `[nolo:tool] round ${round} !! ${event.toolName}: ${event.message ?? "failed"}\n`;
+  }
+  return `[nolo:tool] round ${round} <- ${event.toolName} (${event.toolCallId})\n`;
+}
+
+export function classifyTaskRunReviewStatus(summary?: string): TaskRunReviewStatus | undefined {
+  const normalized = summary?.toLowerCase().trim();
+  if (!normalized) return undefined;
+
+  const explicit = normalized.match(/review\s+decision\s*:\s*(passed|needs_changes|blocked)/);
+  if (explicit?.[1]) return explicit[1] as TaskRunReviewStatus;
+
+  if (/\b(blocked|cannot review|unable to review)\b|无法审查|阻塞/.test(normalized)) {
+    return "blocked";
+  }
+  if (
+    /\b(needs changes|request changes|changes requested|not approved)\b|需要修改|需修改|发现问题/.test(
+      normalized
+    )
+  ) {
+    return "needs_changes";
+  }
+  if (/\b(approved|lgtm|no issues|passed)\b|通过|无问题/.test(normalized)) {
+    return "passed";
+  }
+  return undefined;
+}

package/client/agentRunRuntimeSelection.test.ts

@@ -0,0 +1,158 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  findServerPlatformTools,
+  isKnownServerPlatformAgent,
+  normalizeAgentRef,
+  resolveRequestedRuntimeMode,
+  resolveServerPlatformToolNames,
+  shouldAttemptAutoLocal,
+  shouldShowUsage,
+  shouldSkipAutoLocalForServerPlatformTools,
+  shouldUseScriptBridge,
+  type OutputLike,
+} from "./agentRunRuntimeSelection";
+
+class CaptureOutput implements OutputLike {
+  chunks: string[] = [];
+
+  write(chunk: string) {
+    this.chunks.push(chunk);
+  }
+
+  text() {
+    return this.chunks.join("");
+  }
+}
+
+describe("agentRunRuntimeSelection", () => {
+  test("uses the repo script bridge only when no auth token is available", () => {
+    expect(shouldUseScriptBridge({ hasAuthToken: false, scriptPathExists: true })).toBe(true);
+    expect(shouldUseScriptBridge({ hasAuthToken: true, scriptPathExists: true })).toBe(false);
+    expect(shouldUseScriptBridge({ hasAuthToken: false, scriptPathExists: false })).toBe(false);
+  });
+
+  test("identifies server platform tools that local runtime cannot provide", () => {
+    expect(findServerPlatformTools(["readWorkspaceFile", "queryTableRows", "updateTableRow"])).toEqual([
+      "queryTableRows",
+      "updateTableRow",
+    ]);
+    expect(findServerPlatformTools(["readWorkspaceFile", "execShell"])).toEqual([]);
+  });
+
+  test("merges server platform tool declarations from toolNames and runtime policy", () => {
+    expect(
+      resolveServerPlatformToolNames({
+        toolNames: ["queryTableRows", "readWorkspaceFile"],
+        runtimeToolPolicy: { agentTools: ["taskRun", "execShell", "updateTableRow"] },
+      })
+    ).toEqual(["queryTableRows", "taskRun", "updateTableRow"]);
+  });
+
+  test("normalizes agent refs before alias matching", () => {
+    expect(normalizeAgentRef("  Nolo   Fullstack  ")).toBe("nolo fullstack");
+    expect(isKnownServerPlatformAgent({ agentKey: "  Nolo   Fullstack  " })).toBe(true);
+  });
+
+  test("detects known server platform agents by canonical key", () => {
+    expect(isKnownServerPlatformAgent({ agentKey: "agent-b2e06f801f-01NOLOFULLSTK00000001J740Q" })).toBe(true);
+    expect(isKnownServerPlatformAgent({ agentKey: "agent-user-1-custom" })).toBe(false);
+  });
+
+  test("shows usage only when debug or usage env is enabled", () => {
+    expect(shouldShowUsage({})).toBe(false);
+    expect(shouldShowUsage({ NOLO_DEBUG: "1" })).toBe(true);
+    expect(shouldShowUsage({ NOLO_SHOW_USAGE: "1" })).toBe(true);
+  });
+
+  test("resolves requested runtime mode from explicit option before env", () => {
+    expect(resolveRequestedRuntimeMode({ runtimeMode: "local", env: { NOLO_RUNTIME_MODE: "server" } })).toBe(
+      "local"
+    );
+    expect(resolveRequestedRuntimeMode({ env: { NOLO_RUNTIME_MODE: "server" } })).toBe("server");
+    expect(resolveRequestedRuntimeMode({ env: { NOLO_RUNTIME_MODE: "weird" } })).toBe("auto");
+  });
+
+  test("attempts auto-local when an adapter/factory exists or local env is configured", () => {
+    expect(shouldAttemptAutoLocal({ env: {}, localRuntimeAdapter: { loadAgentConfig: async () => undefined } })).toBe(
+      true
+    );
+    expect(shouldAttemptAutoLocal({ env: {}, localRuntimeAdapterFactory: {} })).toBe(true);
+    expect(shouldAttemptAutoLocal({ env: { OPENAI_API_KEY: "key-1" } })).toBe(true);
+    expect(shouldAttemptAutoLocal({ env: { NOLO_LOCAL_AGENT_KEY: "agent-1" } })).toBe(true);
+    expect(shouldAttemptAutoLocal({ env: {} })).toBe(false);
+  });
+
+  test("skips auto-local immediately for known server platform agents", async () => {
+    const output = new CaptureOutput();
+
+    await expect(
+      shouldSkipAutoLocalForServerPlatformTools({
+        agentKey: "agent-b2e06f801f-01NOLOFULLSTK00000001J740Q",
+        env: {},
+        output,
+      })
+    ).resolves.toBe(true);
+
+    expect(output.text()).toContain("known platform agent");
+  });
+
+  test("skips auto-local when loaded agent config declares server platform tools", async () => {
+    const output = new CaptureOutput();
+
+    await expect(
+      shouldSkipAutoLocalForServerPlatformTools({
+        agentKey: "agent-user-1-tools",
+        env: {},
+        output,
+        localRuntimeAdapter: {
+          loadAgentConfig: async () => ({
+            toolNames: ["queryTableRows", "readWorkspaceFile"],
+            runtimeToolPolicy: { agentTools: ["addTableRow", "execShell"] },
+          }),
+        },
+      })
+    ).resolves.toBe(true);
+
+    expect(output.text()).toContain("queryTableRows, addTableRow");
+  });
+
+  test("does not skip auto-local when no adapter exists, loading fails, or no server tools are declared", async () => {
+    const output = new CaptureOutput();
+
+    await expect(
+      shouldSkipAutoLocalForServerPlatformTools({
+        agentKey: "agent-user-1-none",
+        env: {},
+        output,
+      })
+    ).resolves.toBe(false);
+
+    await expect(
+      shouldSkipAutoLocalForServerPlatformTools({
+        agentKey: "agent-user-1-error",
+        env: {},
+        output,
+        localRuntimeAdapter: {
+          loadAgentConfig: async () => {
+            throw new Error("load failed");
+          },
+        },
+      })
+    ).resolves.toBe(false);
+
+    await expect(
+      shouldSkipAutoLocalForServerPlatformTools({
+        agentKey: "agent-user-1-local",
+        env: {},
+        output,
+        resolveLocalRuntimeAdapter: () => ({
+          loadAgentConfig: async () => ({
+            toolNames: ["readWorkspaceFile"],
+            runtimeToolPolicy: { agentTools: ["execShell"] },
+          }),
+        }),
+      })
+    ).resolves.toBe(false);
+  });
+});

package/client/agentRunRuntimeSelection.ts

@@ -0,0 +1,155 @@
+import type { AgentRuntimeRequestedMode } from "../agentRuntimeLocal";
+import {
+  FRONTEND_IMPLEMENTER_AGENT_KEY,
+  NOLO_FULLSTACK_AGENT_KEY,
+  NOLO_PROJECT_MANAGER_AGENT_KEY,
+  NOLO_REVIEW_AGENT_KEY,
+} from "../agentAliases";
+import type { EnvLike } from "../cliEnvHelpers";
+import type { OutputLike } from "../cliIoTypes";
+export type { OutputLike } from "../cliIoTypes";
+
+export type ScriptBridgeDecision = {
+  hasAuthToken: boolean;
+  scriptPathExists: boolean;
+};
+
+export type RuntimeSelectionAgentConfig = {
+  toolNames?: string[];
+  runtimeToolPolicy?: {
+    agentTools?: string[];
+  };
+};
+
+export type RuntimeSelectionAdapter = {
+  loadAgentConfig(agentKey: string): Promise<RuntimeSelectionAgentConfig | undefined>;
+};
+
+export type RuntimeSelectionOptions = {
+  agentKey: string;
+  env: EnvLike;
+  output: OutputLike;
+  runtimeMode?: AgentRuntimeRequestedMode;
+  localRuntimeAdapter?: RuntimeSelectionAdapter;
+  localRuntimeAdapterFactory?: unknown;
+  resolveLocalRuntimeAdapter?: () => RuntimeSelectionAdapter | undefined;
+};
+
+const SERVER_PLATFORM_TOOL_NAMES = new Set([
+  "addTableRow",
+  "addTableRows",
+  "deleteTableRow",
+  "deleteTableRows",
+  "queryTableRows",
+  "streamParallelAgents",
+  "taskRun",
+  "updateTableRow",
+  "updateTableRows",
+]);
+
+const KNOWN_SERVER_PLATFORM_AGENT_KEYS = new Set([
+  FRONTEND_IMPLEMENTER_AGENT_KEY,
+  NOLO_FULLSTACK_AGENT_KEY,
+  NOLO_PROJECT_MANAGER_AGENT_KEY,
+  NOLO_REVIEW_AGENT_KEY,
+]);
+
+const KNOWN_SERVER_PLATFORM_AGENT_ALIASES = new Set([
+  "code-review",
+  "frontend",
+  "frontend-agent",
+  "frontend-implementer",
+  "full-stack",
+  "fullstack",
+  "nolo code review",
+  "nolo frontend",
+  "nolo fullstack",
+  "nolo reviewer",
+  "nolo-code-review",
+  "nolo-frontend",
+  "nolo-fullstack",
+  "nolo-reviewer",
+  "review",
+  "reviewer",
+]);
+
+export function shouldUseScriptBridge(decision: ScriptBridgeDecision) {
+  return !decision.hasAuthToken && decision.scriptPathExists;
+}
+
+export function findServerPlatformTools(toolNames?: string[]) {
+  if (!Array.isArray(toolNames)) return [];
+  return toolNames.filter((toolName) => SERVER_PLATFORM_TOOL_NAMES.has(toolName));
+}
+
+export function resolveServerPlatformToolNames(agentConfig: RuntimeSelectionAgentConfig | undefined) {
+  return findServerPlatformTools([
+    ...(Array.isArray(agentConfig?.toolNames) ? agentConfig.toolNames : []),
+    ...(Array.isArray(agentConfig?.runtimeToolPolicy?.agentTools)
+      ? agentConfig.runtimeToolPolicy.agentTools
+      : []),
+  ]);
+}
+
+export function normalizeAgentRef(ref?: string) {
+  return ref?.trim().toLowerCase().replace(/\s+/g, " ");
+}
+
+export function isKnownServerPlatformAgent(options: Pick<RuntimeSelectionOptions, "agentKey">) {
+  if (KNOWN_SERVER_PLATFORM_AGENT_KEYS.has(options.agentKey)) return true;
+  const normalizedKey = normalizeAgentRef(options.agentKey);
+  return Boolean(normalizedKey && KNOWN_SERVER_PLATFORM_AGENT_ALIASES.has(normalizedKey));
+}
+
+export function shouldShowUsage(env: EnvLike) {
+  return env.NOLO_DEBUG === "1" || env.NOLO_SHOW_USAGE === "1";
+}
+
+export function resolveRequestedRuntimeMode(
+  options: Pick<RuntimeSelectionOptions, "env" | "runtimeMode">
+) {
+  const envMode = options.env.NOLO_RUNTIME_MODE;
+  if (options.runtimeMode) return options.runtimeMode;
+  if (envMode === "local" || envMode === "server" || envMode === "auto") return envMode;
+  return "auto";
+}
+
+export function shouldAttemptAutoLocal(
+  options: Pick<RuntimeSelectionOptions, "env" | "localRuntimeAdapter" | "localRuntimeAdapterFactory">
+) {
+  if (options.localRuntimeAdapter || options.localRuntimeAdapterFactory) return true;
+  return Boolean(
+    options.env.NOLO_LOCAL_OPENAI_API_KEY ||
+      options.env.OPENAI_API_KEY ||
+      options.env.NOLO_LOCAL_OPENAI_BASE_URL ||
+      options.env.OPENAI_BASE_URL ||
+      options.env.NOLO_LOCAL_AGENT_KEY
+  );
+}
+
+export async function shouldSkipAutoLocalForServerPlatformTools(
+  options: RuntimeSelectionOptions
+) {
+  if (isKnownServerPlatformAgent(options)) {
+    options.output.write(
+      `[nolo] auto runtime: skipping local runtime because ${options.agentKey} is a known platform agent. ` +
+        "Use --local explicitly to force local workspace tools.\n"
+    );
+    return true;
+  }
+  const adapter = options.localRuntimeAdapter || options.resolveLocalRuntimeAdapter?.();
+  if (!adapter) return false;
+  let agentConfig;
+  try {
+    agentConfig = await adapter.loadAgentConfig(options.agentKey);
+  } catch {
+    return false;
+  }
+  const serverTools = resolveServerPlatformToolNames(agentConfig);
+  if (serverTools.length === 0) return false;
+  options.output.write(
+    `[nolo] auto runtime: skipping local runtime because ${options.agentKey} declares server platform tools ` +
+      `(${serverTools.join(", ")}). Use --local explicitly to force local workspace tools.\n`
+  );
+  return true;
+}

package/client/profileConfig.test.ts

@@ -4,8 +4,10 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 
 import {
+  buildCliRuntimeEnv,
   buildEnvFromProfile,
   loadProfileConfig,
+  normalizeProfileServerUrl,
   saveDefaultProfile,
 } from "./profileConfig";
 
@@ -37,4 +39,68 @@ describe("cli profile config", () => {
       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");
+  });
 });