nolo-cli 0.1.29 → 0.1.31

package/cliEnvHelpers.ts

@@ -32,6 +32,14 @@ export function readCliOptionValue(args: string[], flag: string): string {
   return "";
 }
 
+export function hasExplicitServerOverride(args: string[]) {
+  return Boolean(
+    readCliOptionValue(args, "--server-url") ||
+      readCliOptionValue(args, "--server") ||
+      readCliOptionValue(args, "--base-url")
+  );
+}
+
 export function resolveServerUrlFromEnv(env: EnvLike) {
   return trimTrailingSlashes(
     firstDefinedEnvValue(env, ["NOLO_SERVER_URL", "NOLO_SERVER", "BASE_URL"]) ||
@@ -49,19 +57,13 @@ export function resolveServerUrlFromArgs(args: string[], env: EnvLike) {
   );
 }
 
-export function resolveServerUrl(env: EnvLike) {
-  return resolveServerUrlFromEnv(env);
+type ServerResolverInput = string[] | EnvLike;
+
+function isCliArgs(value: ServerResolverInput): value is string[] {
+  return Array.isArray(value);
 }
 
-export function resolveServerCandidates(env: EnvLike, preferred?: string | null) {
-  const values = [
-    preferred?.trim(),
-    env.NOLO_SERVER,
-    env.BASE_URL,
-    env.NOLO_SERVER_URL,
-    DEFAULT_NOLO_SERVER_URL,
-    ...NOLO_CLUSTER_SERVERS,
-  ];
+function buildServerCandidates(values: Array<string | null | undefined>) {
   return [...new Set(
     values
       .filter((value): value is string => typeof value === "string" && value.trim().length > 0)
@@ -69,8 +71,61 @@ export function resolveServerCandidates(env: EnvLike, preferred?: string | null)
   )];
 }
 
-export function resolveAuthToken(env: EnvLike) {
-  return resolveAuthTokenFromEnv(env);
+export function resolveServerUrl(env: EnvLike): string;
+export function resolveServerUrl(args: string[], env: EnvLike): string;
+export function resolveServerUrl(input: ServerResolverInput, env?: EnvLike) {
+  if (isCliArgs(input)) {
+    return resolveServerUrlFromArgs(input, env ?? {});
+  }
+  return resolveServerUrlFromEnv(input);
+}
+
+export function resolveServerCandidates(env: EnvLike, preferred?: string | null): string[];
+export function resolveServerCandidates(
+  args: string[],
+  env: EnvLike,
+  preferred?: string | null,
+): string[];
+export function resolveServerCandidates(
+  input: ServerResolverInput,
+  envOrPreferred?: EnvLike | string | null,
+  preferred?: string | null,
+) {
+  if (isCliArgs(input)) {
+    const env = (envOrPreferred ?? {}) as EnvLike;
+    const explicitServer = resolveServerUrlFromArgs(input, env);
+    return buildServerCandidates([
+      explicitServer,
+      preferred?.trim(),
+      env.NOLO_SERVER,
+      env.BASE_URL,
+      env.NOLO_SERVER_URL,
+      DEFAULT_NOLO_SERVER_URL,
+      ...NOLO_CLUSTER_SERVERS,
+    ]);
+  }
+  const env = input;
+  return buildServerCandidates([
+    typeof envOrPreferred === "string" ? envOrPreferred.trim() : undefined,
+    env.NOLO_SERVER,
+    env.BASE_URL,
+    env.NOLO_SERVER_URL,
+    DEFAULT_NOLO_SERVER_URL,
+    ...NOLO_CLUSTER_SERVERS,
+  ]);
+}
+
+export function resolveAuthToken(env: EnvLike, extraEnvKeys?: string[]): string;
+export function resolveAuthToken(args: string[], env: EnvLike, extraEnvKeys?: string[]): string;
+export function resolveAuthToken(
+  input: ServerResolverInput,
+  envOrExtraEnvKeys?: EnvLike | string[],
+  extraEnvKeys: string[] = [],
+) {
+  if (isCliArgs(input)) {
+    return resolveAuthTokenFromArgs(input, (envOrExtraEnvKeys ?? {}) as EnvLike, extraEnvKeys);
+  }
+  return resolveAuthTokenFromEnv(input, (envOrExtraEnvKeys as string[] | undefined) ?? []);
 }
 
 export function resolveAuthTokenFromEnv(env: EnvLike, extraEnvKeys: string[] = []) {

package/cliRuntimeDoctorReport.ts

@@ -0,0 +1,193 @@
+import { resolveAgentRuntimeDecision } from "./agent-runtime/runtimeDecision";
+import type { AgentRuntimeDecision } from "./agent-runtime/types";
+import type { LocalRuntimeProbeResult } from "./agentCommandSupport";
+import type { EnvLike } from "./cliEnvHelpers";
+
+export type CliRuntimeDoctorProbe = {
+  levelDb: {
+    ok: boolean;
+    path: string;
+    error?: string;
+  };
+  agentConfig: {
+    key: string;
+    cacheReady: boolean;
+    found: boolean;
+  };
+  provider: {
+    available: boolean;
+    label: string;
+  };
+  sync: {
+    available: boolean;
+  };
+  serverFallback: {
+    available: boolean;
+    url: string;
+  };
+};
+
+export type CliRuntimeDoctorReport = {
+  decision: AgentRuntimeDecision;
+  levelDb: {
+    status: "ok" | "failed";
+    path: string;
+    error?: string;
+  };
+  agentConfig: {
+    status: "found" | "missing";
+    value: string;
+  };
+  provider: {
+    status: "available" | "missing";
+    label: string;
+  };
+  sync: {
+    status: "available" | "unavailable";
+  };
+  serverFallback: {
+    status: "available" | "unavailable";
+    value: string;
+  };
+};
+
+function readLocalAgentKey(env: EnvLike) {
+  return env.NOLO_LOCAL_AGENT_KEY || env.NOLO_AGENT || "";
+}
+
+function detectLocalProvider(env: EnvLike) {
+  return Boolean(
+    env.OPENAI_API_KEY ||
+      env.ANTHROPIC_API_KEY ||
+      env.GOOGLE_API_KEY ||
+      env.NOLO_LOCAL_OPENAI_BASE_URL ||
+      env.OLLAMA_BASE_URL
+  );
+}
+
+function detectProviderLabel(env: EnvLike) {
+  if (env.NOLO_LOCAL_OPENAI_BASE_URL) {
+    return `openai-compatible endpoint ${env.NOLO_LOCAL_OPENAI_BASE_URL}`;
+  }
+  if (env.OLLAMA_BASE_URL) {
+    return `ollama-compatible endpoint ${env.OLLAMA_BASE_URL}`;
+  }
+  if (env.OPENAI_API_KEY) return "openai via env OPENAI_API_KEY";
+  if (env.ANTHROPIC_API_KEY) return "anthropic via env ANTHROPIC_API_KEY";
+  if (env.GOOGLE_API_KEY) return "google via env GOOGLE_API_KEY";
+  return "missing";
+}
+
+export function buildCliRuntimeDoctorProbe(input: {
+  env: EnvLike;
+  localProbe: LocalRuntimeProbeResult;
+  authToken: string;
+  serverUrl: string;
+}): CliRuntimeDoctorProbe {
+  const agentKey = input.localProbe.agentKey || readLocalAgentKey(input.env);
+  const cacheReady = Boolean(input.env.NOLO_AGENT_CACHE_READY);
+  return {
+    levelDb: {
+      ok: input.localProbe.ok,
+      path: input.localProbe.dbPath,
+      ...(input.localProbe.error ? { error: input.localProbe.error } : {}),
+    },
+    agentConfig: {
+      key: agentKey,
+      cacheReady,
+      found: input.localProbe.ok && input.localProbe.agentFound && (Boolean(agentKey) || cacheReady),
+    },
+    provider: {
+      available: detectLocalProvider(input.env),
+      label: detectProviderLabel(input.env),
+    },
+    sync: {
+      available: Boolean(input.authToken),
+    },
+    serverFallback: {
+      available: Boolean(input.authToken || input.env.NOLO_SERVER || input.env.BASE_URL),
+      url: input.serverUrl,
+    },
+  };
+}
+
+export function buildCliRuntimeDoctorReport(
+  probe: CliRuntimeDoctorProbe
+): CliRuntimeDoctorReport {
+  const missingLocalCapabilities = [
+    ...(probe.levelDb.ok ? [] : ["leveldb"]),
+    ...(probe.agentConfig.found ? [] : ["agent-config"]),
+    ...(probe.provider.available ? [] : ["provider"]),
+  ];
+  const decision = resolveAgentRuntimeDecision({
+    requestedMode: "auto",
+    syncRequested: false,
+    host: "cli",
+    hasLocalAgentConfig: probe.agentConfig.found,
+    hasLocalProvider: probe.provider.available,
+    hasLocalPersistence: true,
+    missingLocalCapabilities,
+    requiresServer: false,
+    serverFallbackAvailable: probe.serverFallback.available,
+  });
+
+  return {
+    decision,
+    levelDb: {
+      status: probe.levelDb.ok ? "ok" : "failed",
+      path: probe.levelDb.path,
+      ...(probe.levelDb.error ? { error: probe.levelDb.error } : {}),
+    },
+    agentConfig: {
+      status: probe.agentConfig.found ? "found" : "missing",
+      value: probe.agentConfig.key || (probe.agentConfig.cacheReady ? "cache ready" : "no local agent key"),
+    },
+    provider: {
+      status: probe.provider.available ? "available" : "missing",
+      label: probe.provider.label,
+    },
+    sync: {
+      status: probe.sync.available ? "available" : "unavailable",
+    },
+    serverFallback: {
+      status: probe.serverFallback.available ? "available" : "unavailable",
+      value: probe.serverFallback.available ? probe.serverFallback.url : "unavailable",
+    },
+  };
+}
+
+export function formatCliRuntimeDoctorReport(
+  report: CliRuntimeDoctorReport
+): string {
+  const lines = [
+    `Runtime: ${report.decision.mode}`,
+    `Reason: ${report.decision.reason}`,
+    `LevelDB: ${report.levelDb.status}`,
+    `DB path: ${report.levelDb.path}`,
+  ];
+  if (report.levelDb.error) {
+    lines.push(`DB error: ${report.levelDb.error}`);
+  }
+  if (report.agentConfig.status === "found") {
+    lines.push(`Agent config: found (${report.agentConfig.value})`);
+  } else if (report.agentConfig.value === "no local agent key") {
+    lines.push("Agent config: missing (no local agent key)");
+  } else {
+    lines.push(`Agent config: missing (${report.agentConfig.value})`);
+  }
+  lines.push(`Provider: ${report.provider.status} (${report.provider.label})`);
+  lines.push("Persistence: LevelDB local store");
+  lines.push(
+    `Sync: ${report.sync.status}${
+      report.sync.status === "available" ? "" : " (not authenticated)"
+    }`
+  );
+  lines.push(`Server fallback: ${report.serverFallback.value}`);
+  if (report.decision.missingLocalCapabilities.length > 0) {
+    lines.push("Missing local capabilities:");
+    for (const capability of report.decision.missingLocalCapabilities) {
+      lines.push(`- ${capability}`);
+    }
+  }
+  return `${lines.join("\n")}\n`;
+}

package/client/agentConfigResolver.test.ts

@@ -17,7 +17,6 @@ describe("agent config resolver", () => {
       toolNames: ["legacyTool", "readFile"],
       tools: ["readFile", "applyEdit"],
       runtimeBinding: { machineId: "machine-1", localWorkspaceMode: "task-worktree" },
-      delegation: { target: "local" },
       temperature: 0.2,
       top_p: 0.9,
       max_tokens: 4096,
@@ -36,7 +35,6 @@ describe("agent config resolver", () => {
       toolNames: ["legacyTool", "readFile", "applyEdit"],
       runtimeBinding: { machineId: "machine-1", localWorkspaceMode: "task-worktree" },
       localWorkspaceMode: "task-worktree",
-      delegation: { target: "local" },
       temperature: 0.2,
       top_p: 0.9,
       max_tokens: 4096,

package/client/agentRun.test.ts

@@ -49,8 +49,8 @@ describe("cli agent run client", () => {
   });
 
   test("calls the Nolo HTTP API directly when AUTH_TOKEN is present", async () => {
-    const output = new CaptureOutput();
-    const requests: Array<{ url: string; body: any; auth: string | null }> = [];
+    const output = new CaptureOutput();
+    const requests: Array<{ url: string; body: any; auth: string | null }> = [];
 
     const result = await runAgentTurn({
       agentName: "nolo",
@@ -97,10 +97,89 @@ describe("cli agent run client", () => {
     ]);
     expect(result).toEqual({ exitCode: 0, dialogId: "dialog-1" });
     expect(output.text()).toContain("nolo -> working");
-    expect(output.text()).toContain("nolo > hi");
+    expect(output.text()).toContain("nolo > hi");
     expect(output.text()).not.toContain("tokens=");
   });
 
+  test("retries machine-bound cluster runs on a sibling server when the primary registry is unavailable", async () => {
+    const output = new CaptureOutput();
+    const requests: string[] = [];
+
+    const result = await runAgentTurn({
+      agentName: "frontend",
+      agentKey: "frontend-implementer",
+      serverUrl: "https://nolo.chat",
+      message: "hello",
+      scriptDir: "C:/missing/scripts",
+      env: { AUTH_TOKEN: "token-123" },
+      output,
+      runtimeMode: "server",
+      scriptPathExists: () => false,
+      fetchImpl: async (url) => {
+        requests.push(String(url));
+        if (String(url) === "https://nolo.chat/api/agent/run") {
+          return Response.json({
+            error: "Runtime binding unavailable",
+            reason: "bound_machine_unavailable",
+            message: "Bound runtime machine is not available on this cluster node.",
+          }, { status: 409 });
+        }
+        return Response.json({
+          content: "cluster ok",
+          dialogId: "dialog-us",
+        });
+      },
+    });
+
+    expect(result).toEqual({ exitCode: 0, dialogId: "dialog-us" });
+    expect(requests).toEqual([
+      "https://nolo.chat/api/agent/run",
+      "https://us.nolo.chat/api/agent/run",
+    ]);
+    expect(output.text()).toContain("retrying https://us.nolo.chat");
+    expect(output.text()).toContain("frontend > cluster ok");
+  });
+
+  test("follows an explicit retryServerBase hint before cluster sibling fallback", async () => {
+    const output = new CaptureOutput();
+    const requests: string[] = [];
+
+    const result = await runAgentTurn({
+      agentName: "frontend",
+      agentKey: "frontend-implementer",
+      serverUrl: "https://router.nolo.chat",
+      message: "hello",
+      scriptDir: "C:/missing/scripts",
+      env: { AUTH_TOKEN: "token-123" },
+      output,
+      runtimeMode: "server",
+      scriptPathExists: () => false,
+      fetchImpl: async (url) => {
+        requests.push(String(url));
+        if (String(url) === "https://router.nolo.chat/api/agent/run") {
+          return Response.json({
+            error: "Runtime binding unavailable",
+            reason: "bound_machine_unavailable",
+            message: "Bound runtime machine is not available on this cluster node.",
+            retryServerBase: "https://us.nolo.chat",
+          }, { status: 409 });
+        }
+        return Response.json({
+          content: "sticky ok",
+          dialogId: "dialog-sticky",
+        });
+      },
+    });
+
+    expect(result).toEqual({ exitCode: 0, dialogId: "dialog-sticky" });
+    expect(requests).toEqual([
+      "https://router.nolo.chat/api/agent/run",
+      "https://us.nolo.chat/api/agent/run",
+    ]);
+    expect(output.text()).toContain("retrying https://us.nolo.chat");
+    expect(output.text()).toContain("frontend > sticky ok");
+  });
+
   test("prepends task-run context for HTTP agent runs", async () => {
     const output = new CaptureOutput();
     const requests: Array<{ body: any }> = [];
@@ -249,6 +328,66 @@ describe("cli agent run client", () => {
     expect(result).toEqual({ exitCode: 0, dialogId: "dialog-1" });
   });
 
+  test("drops inherited lineage when continueDialogId is authoritative for HTTP runs and trims it", async () => {
+    const output = new CaptureOutput();
+    const requests: Array<{ body: any }> = [];
+
+    await runAgentTurn({
+      agentName: "nolo",
+      agentKey: "agent-pub-test",
+      serverUrl: "https://nolo.chat",
+      message: "hello",
+      continueDialogId: "  dialog-existing  ",
+      inheritedFromDialogKey: "dialog-user-1-dialog-2",
+      parentDialogId: "dialog-2",
+      scriptDir: "C:/missing/scripts",
+      env: { AUTH_TOKEN: "token-123" },
+      output,
+      runtimeMode: "server",
+      scriptPathExists: () => false,
+      fetchImpl: async (_url, init) => {
+        requests.push({ body: JSON.parse(String(init?.body)) });
+        return Response.json({ content: "ok", dialogId: "dialog-1" });
+      },
+    });
+
+    expect(requests[0]?.body).toMatchObject({
+      continueDialogId: "dialog-existing",
+    });
+    expect(requests[0]?.body).not.toHaveProperty("inheritedFromDialogKey");
+    expect(requests[0]?.body).not.toHaveProperty("parentDialogId");
+  });
+
+  test("treats blank continueDialogId as absent for HTTP runs", async () => {
+    const output = new CaptureOutput();
+    const requests: Array<{ body: any }> = [];
+
+    await runAgentTurn({
+      agentName: "nolo",
+      agentKey: "agent-pub-test",
+      serverUrl: "https://nolo.chat",
+      message: "hello",
+      continueDialogId: "   ",
+      inheritedFromDialogKey: "dialog-user-1-dialog-2",
+      parentDialogId: "dialog-2",
+      scriptDir: "C:/missing/scripts",
+      env: { AUTH_TOKEN: "token-123" },
+      output,
+      runtimeMode: "server",
+      scriptPathExists: () => false,
+      fetchImpl: async (_url, init) => {
+        requests.push({ body: JSON.parse(String(init?.body)) });
+        return Response.json({ content: "ok", dialogId: "dialog-1" });
+      },
+    });
+
+    expect(requests[0]?.body).not.toHaveProperty("continueDialogId");
+    expect(requests[0]?.body).toMatchObject({
+      inheritedFromDialogKey: "dialog-user-1-dialog-2",
+      parentDialogId: "dialog-2",
+    });
+  });
+
   test("records background task-run handoff as running instead of completed", async () => {
     const output = new CaptureOutput();
     const writebacks: any[] = [];
@@ -1064,8 +1203,8 @@ describe("cli agent run client", () => {
     expect(output.text()).toContain("Set AUTH_TOKEN");
   });
 
-  test("prints a friendly connection hint instead of crashing on transport errors", async () => {
-    const output = new CaptureOutput();
+  test("prints a friendly connection hint instead of crashing on transport errors", async () => {
+    const output = new CaptureOutput();
 
     const result = await runAgentTurn({
       agentName: "nolo",
@@ -1081,8 +1220,30 @@ describe("cli agent run client", () => {
       },
     });
 
-    expect(result).toEqual({ exitCode: 1 });
-    expect(output.text()).toContain("Could not reach http://127.0.0.1:38123/api/agent/run");
-    expect(output.text()).toContain("set NOLO_SERVER");
-  });
-});
+    expect(result).toEqual({ exitCode: 1 });
+    expect(output.text()).toContain("Could not reach http://127.0.0.1:38123/api/agent/run");
+    expect(output.text()).toContain("set NOLO_SERVER");
+  });
+
+  test("mentions sandboxed network isolation for remote transport failures", async () => {
+    const output = new CaptureOutput();
+
+    const result = await runAgentTurn({
+      agentName: "nolo",
+      agentKey: "agent-pub-test",
+      serverUrl: "https://nolo.chat",
+      message: "hello",
+      scriptDir: "C:/missing/scripts",
+      env: { AUTH_TOKEN: "token-123" },
+      output,
+      scriptPathExists: () => false,
+      fetchImpl: async () => {
+        throw new TypeError("Unable to connect. Is the computer able to access the url?");
+      },
+    });
+
+    expect(result).toEqual({ exitCode: 1 });
+    expect(output.text()).toContain("sandboxed agent session");
+    expect(output.text()).toContain("host machine can reach the server");
+  });
+});