nolo-cli 0.1.31 → 0.1.33

package/{agentRunParsing.ts → cli/agentRunCommand.ts}

@@ -1,21 +1,51 @@
+import { DEFAULT_NOLO_SERVER_URL } from "./defaultServer";
+import { runAgentTurn, type RunAgentTurnResult } from "./client/agentRun";
+import type { AgentRuntimeHostAdapter, AgentRuntimeRequestedMode } from "./agentRuntimeLocal";
 import { existsSync, readFileSync } from "node:fs";
 import { extname, resolve } from "node:path";
-
-import {
-  buildAgentRunDialogLineageFields,
-  normalizeAgentRunDialogLineage,
-} from "./ai/agent/agentRunDialogLineage";
-import { parseSkillDocProtocol, type WorkflowReferenceConfig } from "./ai/skills/skillDocProtocol";
-
+import { parseSkillDocProtocol, type WorkflowReferenceConfig } from "../ai/skills/skillDocProtocol";
 import { resolveCliAgentKeyInput } from "./agentAliases";
-import type { AgentRuntimeRequestedMode } from "./agentRuntimeLocal";
+import {
+  ensureWorkspacePackageLinks,
+  formatPreparedTaskWorktree,
+  prepareTaskWorktree,
+  type PreparedTaskWorktree,
+} from "./client/taskWorktree";
 import type { TaskRunPromptContext } from "./client/taskRunPrompt";
 
+type EnvLike = Record<string, string | undefined>;
+
+type OutputLike = {
+  write(chunk: string): unknown;
+};
+
+type AgentRunCommandDeps = {
+  env?: EnvLike;
+  scriptDir: string;
+  output?: OutputLike;
+  runner?: typeof runAgentTurn;
+  localRuntimeAdapterFactory?: (env: EnvLike, options?: { cwd?: string }) => AgentRuntimeHostAdapter;
+  prepareTaskWorktree?: typeof prepareTaskWorktree;
+  ensureWorkspacePackageLinks?: typeof ensureWorkspacePackageLinks;
+  inspectLocalRunWorkspace?: typeof inspectLocalRunWorkspace;
+  resolveWorkflowReference?: typeof resolveWorkflowReference;
+};
+
+type LocalRunWorkspaceInspection = {
+  cwd: string;
+  clean: boolean;
+  status: string;
+  commit?: {
+    hash: string;
+    subject: string;
+  };
+};
+
 type ParseAgentRunArgsOptions = {
   readTextFile?: (path: string) => string;
 };
 
-export type ParsedAgentRunArgs = {
+type ParsedAgentRunArgs = {
   agentKey: string;
   message: string;
   imageUrls: string[];
@@ -38,7 +68,7 @@ export type ParsedAgentRunArgs = {
   workflowRef?: string;
 };
 
-export type ResolvedWorkflowReference = {
+type ResolvedWorkflowReference = {
   ref: string;
   content: string;
   config?: Partial<WorkflowReferenceConfig>;
@@ -112,52 +142,6 @@ function positionalArgs(args: string[]) {
   return values;
 }
 
-function parseDialogReference(rawInput: string) {
-  const normalized = rawInput.trim();
-  if (normalized.startsWith("dialog-")) {
-    const parts = normalized.split("-");
-    return {
-      dialogKey: normalized,
-      dialogId: parts.at(-1) ?? normalized,
-    };
-  }
-  const dialogMatch = normalized.match(/dialog-([a-zA-Z0-9]+)-([a-zA-Z0-9]+)/);
-  if (dialogMatch) {
-    return {
-      dialogKey: `dialog-${dialogMatch[1]}-${dialogMatch[2]}`,
-      dialogId: dialogMatch[2],
-    };
-  }
-  return {
-    dialogId: normalized,
-  };
-}
-
-function workflowRefToCandidatePath(cwd: string, ref: string) {
-  const normalized = ref.trim();
-  if (!normalized) return "";
-  if (normalized.endsWith(".md") || normalized.includes("/") || normalized.includes("\\")) {
-    const directPath = resolve(cwd, normalized);
-    if (existsSync(directPath)) return directPath;
-  }
-  const fileName = normalized.replace(/[^a-zA-Z0-9\u4e00-\u9fa5]+/g, "-").replace(/^-+|-+$/g, "");
-  return resolve(cwd, "docs", "workflows", `${fileName}.md`);
-}
-
-function mimeTypeForPath(path: string) {
-  switch (extname(path).toLowerCase()) {
-    case ".jpg":
-    case ".jpeg":
-      return "image/jpeg";
-    case ".webp":
-      return "image/webp";
-    case ".gif":
-      return "image/gif";
-    default:
-      return "image/png";
-  }
-}
-
 export function parseAgentRunArgs(
   args: string[],
   options: ParseAgentRunArgsOptions = {}
@@ -172,10 +156,7 @@ export function parseAgentRunArgs(
   if (!agentKey || !rawMessage.trim()) return null;
   const message = rawMessage.trim();
   const runtimeMode = runtimeModeFromArgs(args);
-  const rawContinueDialogId = readFlagValue(args, "--continue") ?? readFlagValue(args, "--dialog");
-  const continueDialogId = normalizeAgentRunDialogLineage({
-    continueDialogId: rawContinueDialogId,
-  }).continueDialogId;
+  const continueDialogId = readFlagValue(args, "--continue") ?? readFlagValue(args, "--dialog");
   const spaceId = readFlagValue(args, "--space");
   const category = readFlagValue(args, "--category");
   const inheritedFromDialog = readFlagValue(args, "--inherit-from-dialog");
@@ -226,23 +207,28 @@ export function parseAgentRunArgs(
     background: args.includes("--bg"),
     noStream: args.includes("--no-stream"),
     noDefaultTestRoot,
-    ...buildAgentRunDialogLineageFields({
-      continueDialogId,
-      inheritedFromDialogKey: inheritedRef?.dialogKey,
-      parentDialogId: inheritedRef?.dialogId,
-    }),
+    ...(continueDialogId ? { continueDialogId } : {}),
     ...(!continueDialogId && spaceId ? { spaceId } : {}),
-    ...(category
-      ? { category }
-      : !continueDialogId && !noDefaultTestRoot
-        ? { category: DEFAULT_TEST_DIALOG_CATEGORY_ID }
-        : {}),
+    ...(category ? { category } : !continueDialogId && !noDefaultTestRoot ? { category: DEFAULT_TEST_DIALOG_CATEGORY_ID } : {}),
+    ...(inheritedRef?.dialogKey ? { inheritedFromDialogKey: inheritedRef.dialogKey } : {}),
+    ...(inheritedRef?.dialogId ? { parentDialogId: inheritedRef.dialogId } : {}),
     ...(cwd ? { cwd } : {}),
     ...(typeof maxToolRounds === "number" ? { maxToolRounds } : {}),
     ...(typeof timeoutMs === "number" ? { timeoutMs } : {}),
   };
 }
 
+function workflowRefToCandidatePath(cwd: string, ref: string) {
+  const normalized = ref.trim();
+  if (!normalized) return "";
+  if (normalized.endsWith(".md") || normalized.includes("/") || normalized.includes("\\")) {
+    const directPath = resolve(cwd, normalized);
+    if (existsSync(directPath)) return directPath;
+  }
+  const fileName = normalized.replace(/[^a-zA-Z0-9\u4e00-\u9fa5]+/g, "-").replace(/^-+|-+$/g, "");
+  return resolve(cwd, "docs", "workflows", `${fileName}.md`);
+}
+
 export async function resolveWorkflowReference(ref: string, cwd = process.cwd()): Promise<ResolvedWorkflowReference> {
   const path = workflowRefToCandidatePath(cwd, ref);
   if (!path || !existsSync(path)) {
@@ -283,6 +269,41 @@ export function prependWorkflowReferencePrompt(message: string, workflow?: Resol
   ].join("\n");
 }
 
+function parseDialogReference(rawInput: string) {
+  const normalized = rawInput.trim();
+  if (normalized.startsWith("dialog-")) {
+    const parts = normalized.split("-");
+    return {
+      dialogKey: normalized,
+      dialogId: parts.at(-1) ?? normalized,
+    };
+  }
+  const dialogMatch = normalized.match(/dialog-([a-zA-Z0-9]+)-([a-zA-Z0-9]+)/);
+  if (dialogMatch) {
+    return {
+      dialogKey: `dialog-${dialogMatch[1]}-${dialogMatch[2]}`,
+      dialogId: dialogMatch[2],
+    };
+  }
+  return {
+    dialogId: normalized,
+  };
+}
+
+function mimeTypeForPath(path: string) {
+  switch (extname(path).toLowerCase()) {
+    case ".jpg":
+    case ".jpeg":
+      return "image/jpeg";
+    case ".webp":
+      return "image/webp";
+    case ".gif":
+      return "image/gif";
+    default:
+      return "image/png";
+  }
+}
+
 export function normalizeCliImageInput(input: string) {
   if (/^(https?:|data:|file:)/i.test(input)) return input;
   const absolutePath = resolve(input);
@@ -290,3 +311,211 @@ export function normalizeCliImageInput(input: string) {
   const base64 = readFileSync(absolutePath).toString("base64");
   return `data:${mimeTypeForPath(absolutePath)};base64,${base64}`;
 }
+
+async function runGitForLocalSummary(args: {
+  cwd: string;
+  gitArgs: string[];
+}) {
+  const proc = Bun.spawn(["git", ...args.gitArgs], {
+    cwd: args.cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited,
+  ]);
+  if (exitCode !== 0) {
+    throw new Error((stderr || stdout || `git ${args.gitArgs.join(" ")} failed`).trim());
+  }
+  return stdout.trim();
+}
+
+async function inspectLocalRunWorkspace(cwd: string): Promise<LocalRunWorkspaceInspection> {
+  const status = await runGitForLocalSummary({
+    cwd,
+    gitArgs: ["status", "--short"],
+  });
+  const rawCommit = await runGitForLocalSummary({
+    cwd,
+    gitArgs: ["log", "-1", "--format=%h%x00%s"],
+  }).catch(() => "");
+  const [hash, subject] = rawCommit.split("\0");
+  return {
+    cwd,
+    clean: status.trim() === "",
+    status,
+    ...(hash ? { commit: { hash, subject: subject ?? "" } } : {}),
+  };
+}
+
+function shouldPrintLocalRunSummary(args: {
+  parsed: ParsedAgentRunArgs;
+  localRuntimeCwd?: string;
+}) {
+  return Boolean(args.localRuntimeCwd && args.parsed.runtimeMode === "local");
+}
+
+function formatLocalRunSummary(args: {
+  dialogId?: string;
+  inspection: LocalRunWorkspaceInspection;
+}) {
+  return [
+    "",
+    "[nolo] local run summary",
+    `workspace: ${args.inspection.cwd}`,
+    ...(args.dialogId ? [`dialog: ${args.dialogId}`] : []),
+    ...(args.inspection.commit
+      ? [`commit: ${args.inspection.commit.hash} ${args.inspection.commit.subject}`]
+      : []),
+    `dirty: ${args.inspection.clean ? "clean" : "dirty"}`,
+    ...(!args.inspection.clean && args.inspection.status.trim()
+      ? [`status:\n${args.inspection.status.trim()}`]
+      : []),
+    "",
+  ].join("\n");
+}
+
+function resolveServerUrl(env: EnvLike) {
+  return (env.NOLO_SERVER || env.BASE_URL || DEFAULT_NOLO_SERVER_URL).replace(/\/+$/, "");
+}
+
+function shouldPrepareTaskWorktree(parsed: ParsedAgentRunArgs) {
+  return !parsed.cwd && (parsed.useTaskWorktree || parsed.allowShell);
+}
+
+function buildTaskWorktreeEnv(args: {
+  env: EnvLike;
+  worktreePath?: string;
+  allowShell: boolean;
+}) {
+  return {
+    ...args.env,
+    ...(args.allowShell ? { NOLO_LOCAL_SHELL_MODE: "worktree" } : {}),
+    ...(args.worktreePath ? { NOLO_LOCAL_WORKTREE: args.worktreePath } : {}),
+  };
+}
+
+function writeUsage(output: OutputLike) {
+  output.write(
+    "Usage: nolo agent run <agent> <message> [--local|--server|--auto] [--continue <dialogId>] [--cwd <path>] [--max-tool-rounds <n>]\n" +
+      "       nolo agent run --agent <agent> --msg <message> [--image <url-or-path>] [--space <spaceId>] [--category <name>] [--inherit-from-dialog <dialog>] [--task-row-dbkey <key>] [--bg] [--timeout-ms <n>] [--no-stream]\n"
+  );
+}
+
+export async function runAgentRunCommand(args: string[], deps: AgentRunCommandDeps) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  const parsed = parseAgentRunArgs(args);
+  if (!parsed) {
+    writeUsage(output);
+    return 1;
+  }
+
+  const runner = deps.runner ?? runAgentTurn;
+  let workflowReference: ResolvedWorkflowReference | undefined;
+  if (parsed.workflowRef) {
+    try {
+      workflowReference = await (deps.resolveWorkflowReference ?? resolveWorkflowReference)(
+        parsed.workflowRef
+      );
+    } catch (error) {
+      output.write(`[nolo] ${error instanceof Error ? error.message : String(error)}\n`);
+      return 1;
+    }
+  }
+  let localRuntimeCwd = parsed.cwd;
+  if (shouldPrepareTaskWorktree(parsed)) {
+    try {
+      const preparedWorktree = await (deps.prepareTaskWorktree ?? prepareTaskWorktree)({
+        agentKey: parsed.agentKey,
+        env,
+      });
+      localRuntimeCwd = preparedWorktree.path;
+      output.write(formatPreparedTaskWorktree(preparedWorktree));
+    } catch (error) {
+      output.write(
+        "[nolo] Could not prepare a local task worktree.\n" +
+          "Run from inside a git repository, or set NOLO_LOCAL_WORKTREE to an existing isolated checkout.\n" +
+          `Reason: ${error instanceof Error ? error.message : String(error)}\n`
+      );
+      return 1;
+    }
+  }
+  const shouldBindLocalWorkspace =
+    !!localRuntimeCwd &&
+    (parsed.runtimeMode === "local" || parsed.allowShell || parsed.useTaskWorktree);
+  if (shouldBindLocalWorkspace) {
+    try {
+      await (deps.ensureWorkspacePackageLinks ?? ensureWorkspacePackageLinks)(
+        localRuntimeCwd!
+      );
+    } catch (error) {
+      output.write(
+        "[nolo] Dependency preflight failed for local task worktree.\n" +
+          "The worktree may have node_modules entries that point outside the task checkout, or paths that cannot be repaired safely.\n" +
+          `Reason: ${error instanceof Error ? error.message : String(error)}\n`
+      );
+      return 1;
+    }
+  }
+  const runEnv = shouldBindLocalWorkspace
+    ? buildTaskWorktreeEnv({
+        env,
+        worktreePath: localRuntimeCwd,
+        allowShell: parsed.allowShell,
+      })
+    : env;
+  const result: RunAgentTurnResult = await runner({
+    agentName: parsed.agentKey,
+    agentKey: parsed.agentKey,
+    serverUrl: resolveServerUrl(env),
+    message: prependWorkflowReferencePrompt(parsed.message, workflowReference),
+    imageUrls: parsed.imageUrls.map(normalizeCliImageInput),
+    scriptDir: deps.scriptDir,
+    env: runEnv,
+    output,
+    ...(deps.localRuntimeAdapterFactory
+      ? { localRuntimeAdapterFactory: deps.localRuntimeAdapterFactory }
+      : {}),
+    ...(localRuntimeCwd ? { localRuntimeCwd } : {}),
+    ...(parsed.runtimeMode ? { runtimeMode: parsed.runtimeMode } : {}),
+    ...(parsed.continueDialogId ? { continueDialogId: parsed.continueDialogId } : {}),
+    ...(parsed.spaceId ? { spaceId: parsed.spaceId } : {}),
+    ...(parsed.category ? { category: parsed.category } : {}),
+    ...(parsed.inheritedFromDialogKey ? { inheritedFromDialogKey: parsed.inheritedFromDialogKey } : {}),
+    ...(parsed.parentDialogId ? { parentDialogId: parsed.parentDialogId } : {}),
+    background: parsed.background,
+    noStream: parsed.noStream,
+    noDefaultTestRoot: parsed.noDefaultTestRoot,
+    ...(typeof parsed.maxToolRounds === "number" ? { maxToolRounds: parsed.maxToolRounds } : {}),
+    ...(typeof parsed.timeoutMs === "number" ? { timeoutMs: parsed.timeoutMs } : {}),
+    traceTools: parsed.traceTools,
+    ...(parsed.taskRunContext ? { taskRunContext: parsed.taskRunContext } : {}),
+  });
+
+  if (result.dialogId) {
+    if (parsed.background) {
+      output.write(`\n[nolo] background dialog ${result.dialogId}\n`);
+      output.write(`[nolo] read: nolo dialog read ${result.dialogId}\n`);
+    } else {
+      output.write(`\n[nolo] dialog ${result.dialogId}\n`);
+    }
+  }
+  if (shouldPrintLocalRunSummary({ parsed, localRuntimeCwd })) {
+    try {
+      const inspect = deps.inspectLocalRunWorkspace ?? inspectLocalRunWorkspace;
+      const inspection = await inspect(localRuntimeCwd!);
+      output.write(formatLocalRunSummary({
+        dialogId: result.dialogId,
+        inspection,
+      }));
+    } catch (error) {
+      output.write(
+        `\n[nolo] local run summary unavailable: ${error instanceof Error ? error.message : String(error)}\n`
+      );
+    }
+  }
+  return result.exitCode;
+}

package/cli/agentRuntimeLocal.ts

@@ -0,0 +1,45 @@
+export {
+  buildOpenAiCompatibleChatCompletionRequest,
+  buildPlatformChatCompletionRequest,
+  canUsePlatformChatProvider,
+  hasDirectOpenAiCompatibleProvider,
+  createHybridRecordStore,
+  executeLocalToolWithPolicy,
+  activateWorkspaceSession,
+  createWorkspaceSession,
+  buildAgentRuntimeAgentLookupKeys,
+  buildAgentRuntimeDialogWritePlan,
+  dialogMessageRecordToAgentRuntimeMessage,
+  formatWorkspaceSessionActivation,
+  pickAgentRuntimeInferenceOptions,
+  parseOpenAiCompatibleChatCompletionResponse,
+  parsePlatformChatCompletionData,
+  parsePlatformChatCompletionResponse,
+  resolveAgentRuntimeConfigFromRecord,
+  resolvePlatformChatProviderConfig,
+  resolveLocalToolPolicy,
+  resolveOpenAiCompatibleProviderConfig,
+  shouldUsePlatformChatProvider,
+  shouldCacheHybridRemoteRecord,
+  shouldFetchAgentRuntimeRecordRemotely,
+} from "../agent-runtime";
+export { runLocalAgentTurn } from "../agent-runtime/localLoop";
+export {
+  buildLocalWorkspaceOpenAiTools,
+  buildLocalWorkspacePolicyToolNames,
+  buildLocalWorkspaceToolset,
+  createLocalWorkspaceToolExecutors,
+} from "../agent-runtime/localWorkspaceTools";
+export type {
+  AgentRuntimeAgentConfig,
+  AgentRuntimeHostAdapter,
+  AgentRuntimeRequestedMode,
+  AgentRuntimeSaveTurnInput,
+  HybridRecordKvDb,
+  HybridRecordStore,
+  LocalToolPolicyDecision,
+  PreparedTaskWorkspace,
+  PrepareTaskWorkspace,
+  WorkspaceSession,
+  WorkspaceSessionMode,
+} from "../agent-runtime";

package/cli/authCommands.ts

@@ -0,0 +1,230 @@
+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,
+  getDefaultProfileConfigPath,
+  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;
+}
+
+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 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;
+  }
+
+  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: tokenArg,
+      output: outputTarget,
+      error: errorTarget,
+    });
+  }
+
+  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() {
+  const config = loadProfileConfig();
+  const profile = getCurrentProfile(config);
+  if (!config || !profile) {
+    console.log("Not logged in. Run: nolo login");
+    return 1;
+  }
+
+  console.log(`profile: ${config.currentProfile}`);
+  console.log(`server: ${profile.serverUrl}`);
+  console.log(`token: ${profile.authToken.slice(0, 8)}...`);
+  return 0;
+}
+
+export function runLogoutCommand() {
+  const configPath = getDefaultProfileConfigPath();
+  rmSync(configPath, { force: true });
+  console.log("Logged out.");
+  return 0;
+}