nolo-cli 0.1.12 → 0.1.14

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/agentRun.test.ts

@@ -0,0 +1,240 @@
+import { describe, expect, test } from "bun:test";
+import { Writable } from "node:stream";
+
+import { runAgentTurn, shouldUseScriptBridge } from "./agentRun";
+
+class CaptureOutput extends Writable {
+  chunks: string[] = [];
+
+  _write(chunk: unknown, _encoding: BufferEncoding, callback: (error?: Error | null) => void) {
+    this.chunks.push(String(chunk));
+    callback();
+  }
+
+  text() {
+    return this.chunks.join("");
+  }
+}
+
+describe("cli agent run client", () => {
+  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("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 result = await runAgentTurn({
+      agentName: "nolo",
+      agentKey: "agent-pub-test",
+      serverUrl: "https://nolo.chat",
+      message: "hello",
+      continueDialogId: "dialog-existing",
+      scriptDir: "C:/missing/scripts",
+      env: { AUTH_TOKEN: "token-123" },
+      output,
+      scriptPathExists: () => false,
+      fetchImpl: async (url, init) => {
+        requests.push({
+          url: String(url),
+          body: JSON.parse(String(init?.body)),
+          auth: new Headers(init?.headers).get("Authorization"),
+        });
+        return Response.json({
+          content: "hi",
+          dialogId: "dialog-1",
+          usage: { input_tokens: 2, output_tokens: 3 },
+        });
+      },
+    });
+
+    expect(requests).toEqual([
+      {
+        url: "https://nolo.chat/api/agent/run",
+        auth: "Bearer token-123",
+        body: {
+          agentKey: "agent-pub-test",
+          userInput: "hello",
+          continueDialogId: "dialog-existing",
+          runtimeContext: {
+            surface: "cli",
+            host: "terminal",
+            runtime: "bun",
+            entrypoint: "nolo-cli",
+            capabilities: ["text-io", "streaming", "slash-commands"],
+          },
+          stream: true,
+        },
+      },
+    ]);
+    expect(result).toEqual({ exitCode: 0, dialogId: "dialog-1" });
+    expect(output.text()).toContain("nolo -> working");
+    expect(output.text()).toContain("nolo > hi");
+    expect(output.text()).not.toContain("tokens=");
+  });
+
+  test("runs forced local turns through the injected runtime adapter without HTTP", async () => {
+    const output = new CaptureOutput();
+    const result = await runAgentTurn({
+      agentName: "frontend",
+      agentKey: "frontend-local",
+      serverUrl: "https://nolo.chat",
+      message: "polish notifications",
+      scriptDir: "C:/missing/scripts",
+      env: { AUTH_TOKEN: "token-123" },
+      output,
+      runtimeMode: "local",
+      localRuntimeAdapter: {
+        host: "cli",
+        capabilities: ["local-provider", "local-persistence"],
+        loadAgentConfig: async (agentRef) => ({
+          key: agentRef,
+          name: "Frontend",
+          prompt: "Fix UI",
+          model: "fake-local",
+        }),
+        loadDialogHistory: async () => [],
+        saveTurn: async () => ({ dialogId: "dialog-local" }),
+        resolveProvider: async () => ({
+          model: "fake-local",
+          complete: async (messages) => ({
+            content: `local:${messages.at(-1)?.content}`,
+            model: "fake-local",
+            trace: messages,
+          }),
+        }),
+        executeTool: async () => {
+          throw new Error("no tools expected");
+        },
+      },
+      scriptPathExists: () => false,
+      fetchImpl: async () => {
+        throw new Error("HTTP should not be called for forced local runs");
+      },
+    });
+
+    expect(result).toEqual({ exitCode: 0, dialogId: "dialog-local" });
+    expect(output.text()).toContain("frontend -> working locally");
+    expect(output.text()).toContain("frontend > local:polish notifications");
+  });
+
+  test("builds the default local adapter when env requests local mode", async () => {
+    const output = new CaptureOutput();
+    const builtModes: string[] = [];
+
+    const result = await runAgentTurn({
+      agentName: "frontend",
+      agentKey: "frontend-local",
+      serverUrl: "https://nolo.chat",
+      message: "polish notifications",
+      scriptDir: "C:/missing/scripts",
+      env: { NOLO_RUNTIME_MODE: "local" },
+      output,
+      localRuntimeAdapterFactory: (env) => {
+        builtModes.push(env.NOLO_RUNTIME_MODE ?? "");
+        return {
+          host: "cli",
+          capabilities: ["local-provider", "local-persistence"],
+          loadAgentConfig: async (agentRef) => ({ key: agentRef, prompt: "Fix UI" }),
+          loadDialogHistory: async () => [],
+          saveTurn: async () => ({ dialogId: "dialog-local-env" }),
+          resolveProvider: async () => ({
+            model: "fake-local",
+            complete: async () => ({ content: "local env ok", model: "fake-local" }),
+          }),
+          executeTool: async () => {
+            throw new Error("no tools expected");
+          },
+        };
+      },
+      scriptPathExists: () => false,
+      fetchImpl: async () => {
+        throw new Error("HTTP should not be called for env local runs");
+      },
+    });
+
+    expect(result).toEqual({ exitCode: 0, dialogId: "dialog-local-env" });
+    expect(builtModes).toEqual(["local"]);
+    expect(output.text()).toContain("frontend -> working locally");
+  });
+
+  test("streams agent text responses to terminal output", 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 () =>
+        new Response(
+          [
+            `data: ${JSON.stringify({ type: "text", content: "你" })}`,
+            "",
+            `data: ${JSON.stringify({ type: "text", content: "好" })}`,
+            "",
+            `data: ${JSON.stringify({ type: "done", dialogId: "dialog-stream" })}`,
+            "",
+          ].join("\n"),
+          {
+            status: 200,
+            headers: { "Content-Type": "text/event-stream" },
+          }
+        ),
+    });
+
+    expect(result).toEqual({ exitCode: 0, dialogId: "dialog-stream" });
+    expect(output.text()).toContain("nolo -> working");
+    expect(output.text()).toContain("nolo > 你好");
+  });
+
+  test("prints an auth hint when installed without repo scripts or AUTH_TOKEN", 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: {},
+      output,
+      scriptPathExists: () => false,
+      fetchImpl: async () => {
+        throw new Error("fetch should not be called");
+      },
+    });
+
+    expect(result.exitCode).toBe(1);
+    expect(output.text()).toContain("Set AUTH_TOKEN");
+  });
+
+  test("prints a friendly connection hint instead of crashing on transport errors", async () => {
+    const output = new CaptureOutput();
+
+    const result = await runAgentTurn({
+      agentName: "nolo",
+      agentKey: "agent-pub-test",
+      serverUrl: "http://127.0.0.1:38123",
+      message: "hello",
+      scriptDir: "C:/missing/scripts",
+      env: { AUTH_TOKEN: "token-123" },
+      output,
+      scriptPathExists: () => false,
+      fetchImpl: async () => {
+        throw new Error("ConnectionRefused");
+      },
+    });
+
+    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");
+  });
+});