nolo-cli 0.1.45 → 0.1.47

package/cli/authCommands.ts

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

package/cli/cliCommandAdapters.ts

@@ -1,28 +0,0 @@
-import type { CliCommandHandler, CliRuntimeContext } from "./cliCommandTypes";
-
-export function withCliEnv<TDeps extends { env: NodeJS.ProcessEnv }>(
-  command: (args: string[], deps: TDeps) => Promise<number>
-): CliCommandHandler {
-  return (args: string[], ctx: CliRuntimeContext) =>
-    command(args, { env: ctx.env } as TDeps);
-}
-
-export function withCliEnvAndScriptDir<TDeps extends { env: NodeJS.ProcessEnv; scriptDir: string }>(
-  command: (args: string[], deps: TDeps) => Promise<number>
-): CliCommandHandler {
-  return (args: string[], ctx: CliRuntimeContext) =>
-    command(args, {
-      env: ctx.env,
-      scriptDir: ctx.scriptDir,
-    } as TDeps);
-}
-
-export function withCliEntrypointEnv<TDeps extends { env: NodeJS.ProcessEnv; cliEntrypointPath: string }>(
-  command: (args: string[], deps: TDeps) => Promise<number>
-): CliCommandHandler {
-  return (args: string[], ctx: CliRuntimeContext) =>
-    command(args, {
-      env: ctx.env,
-      cliEntrypointPath: ctx.entrypointPath,
-    } as TDeps);
-}

package/cli/cliCommandDispatch.ts

@@ -1,66 +0,0 @@
-import { fileURLToPath } from "node:url";
-import type { CliPackageInfo, CliRuntimeContext, CommandEntry } from "./cliCommandTypes";
-
-export async function runResolvedCommand(
-  command: CommandEntry,
-  originalArgs: string[],
-  ctx: CliRuntimeContext,
-  deps: {
-    runScript: (script: string, forwardedArgs: string[], env: NodeJS.ProcessEnv) => Promise<number>;
-  }
-) {
-  if (command.kind === "internal") {
-    if (!command.handler) {
-      throw new Error(`Internal command ${command.path.join(" ")} is missing a handler.`);
-    }
-    return command.handler(originalArgs.slice(command.path.length), ctx);
-  }
-
-  if (!command.script) {
-    throw new Error(`Script command ${command.path.join(" ")} is missing a script.`);
-  }
-
-  const forwardedArgs = [...(command.fixedArgs ?? []), ...originalArgs.slice(command.path.length)];
-  return deps.runScript(command.script, forwardedArgs, ctx.env);
-}
-
-function readOption(args: string[], flag: string) {
-  const index = args.indexOf(flag);
-  return index >= 0 ? args[index + 1] : undefined;
-}
-
-function buildDaemonEnv(args: string[], runtimeEnv: NodeJS.ProcessEnv) {
-  const serverUrl = readOption(args, "--server-url") || readOption(args, "--server");
-  const apiKey = readOption(args, "--machine-key") || readOption(args, "--token");
-  return {
-    ...runtimeEnv,
-    ...(serverUrl ? { NOLO_SERVER: serverUrl } : {}),
-    ...(apiKey ? { AUTH_TOKEN: apiKey } : {}),
-  };
-}
-
-export function looksLikeDaemonShortcut(args: string[]) {
-  return args.includes("--server-url") || args.includes("--machine-key");
-}
-
-export function createCliRuntimeContext(args: {
-  env: NodeJS.ProcessEnv;
-  scriptDir: string;
-  entrypointPath?: string;
-  packageInfo: CliPackageInfo;
-}): CliRuntimeContext {
-  return {
-    env: args.env,
-    scriptDir: args.scriptDir,
-    entrypointPath: args.entrypointPath ?? fileURLToPath(import.meta.url),
-    packageInfo: args.packageInfo,
-  };
-}
-
-export function withDaemonShortcutArgs(args: string[], runtimeEnv: NodeJS.ProcessEnv) {
-  if (!looksLikeDaemonShortcut(args)) return { commandArgs: args, envOverride: null as NodeJS.ProcessEnv | null };
-  return {
-    commandArgs: ["daemon", ...args],
-    envOverride: buildDaemonEnv(args, runtimeEnv),
-  };
-}

package/cli/cliCommandFactories.ts

@@ -1,66 +0,0 @@
-import {
-  withCliEntrypointEnv,
-  withCliEnv,
-  withCliEnvAndScriptDir,
-} from "./cliCommandAdapters";
-import { withDaemonShortcutArgs } from "./cliCommandDispatch";
-import {
-  createInternalCommand,
-  type CliRuntimeContext,
-  type CliCommandHandler,
-  type CommandEntry,
-} from "./cliCommandTypes";
-
-export function createEnvCommand<TDeps extends { env: NodeJS.ProcessEnv }>(
-  path: string[],
-  description: string,
-  command: (args: string[], deps: TDeps) => Promise<number>
-): CommandEntry {
-  return createInternalCommand(path, description, withCliEnv(command) as CliCommandHandler);
-}
-
-export function createEnvScriptDirCommand<TDeps extends { env: NodeJS.ProcessEnv; scriptDir: string }>(
-  path: string[],
-  description: string,
-  command: (args: string[], deps: TDeps) => Promise<number>
-): CommandEntry {
-  return createInternalCommand(path, description, withCliEnvAndScriptDir(command) as CliCommandHandler);
-}
-
-export function createEntrypointEnvCommand<TDeps extends { env: NodeJS.ProcessEnv; cliEntrypointPath: string }>(
-  path: string[],
-  description: string,
-  command: (args: string[], deps: TDeps) => Promise<number>
-): CommandEntry {
-  return createInternalCommand(path, description, withCliEntrypointEnv(command) as CliCommandHandler);
-}
-
-export function createArgsCommand(
-  path: string[],
-  description: string,
-  command: (args: string[]) => Promise<number>
-): CommandEntry {
-  return createInternalCommand(path, description, (args) => command(args));
-}
-
-export function createContextCommand(
-  path: string[],
-  description: string,
-  command: (args: string[], ctx: CliRuntimeContext) => Promise<number>
-): CommandEntry {
-  return createInternalCommand(path, description, command as CliCommandHandler);
-}
-
-export function createDaemonShortcutCommand<TDeps extends { env: NodeJS.ProcessEnv; cliEntrypointPath: string }>(
-  path: string[],
-  description: string,
-  command: (args: string[], deps: TDeps) => Promise<number>
-): CommandEntry {
-  return createInternalCommand(path, description, (args, ctx) => {
-    const normalized = withDaemonShortcutArgs(args, ctx.env);
-    return command(["--ws"], {
-      env: normalized.envOverride ?? ctx.env,
-      cliEntrypointPath: ctx.entrypointPath,
-    } as TDeps);
-  });
-}

package/cli/cliCommandTypes.ts

@@ -1,49 +0,0 @@
-import type { readPackageInfo } from "./updateCommands";
-
-export type CliPackageInfo = ReturnType<typeof readPackageInfo>;
-
-export type CliRuntimeContext = {
-  env: NodeJS.ProcessEnv;
-  scriptDir: string;
-  entrypointPath: string;
-  packageInfo: CliPackageInfo;
-};
-
-export type CliCommandHandler = (args: string[], ctx: CliRuntimeContext) => Promise<number>;
-
-export type CommandEntry = {
-  path: string[];
-  description: string;
-  kind: "internal" | "script";
-  script?: string;
-  fixedArgs?: string[];
-  handler?: CliCommandHandler;
-};
-
-export function createScriptCommand(
-  path: string[],
-  script: string,
-  description: string,
-  fixedArgs?: string[]
-): CommandEntry {
-  return {
-    path,
-    kind: "script",
-    script,
-    description,
-    ...(fixedArgs ? { fixedArgs } : {}),
-  };
-}
-
-export function createInternalCommand(
-  path: string[],
-  description: string,
-  handler: CliCommandHandler
-): CommandEntry {
-  return {
-    path,
-    kind: "internal",
-    description,
-    handler,
-  };
-}

package/cli/cliEnvHelpers.ts

@@ -1,116 +0,0 @@
-import { DEFAULT_NOLO_SERVER_URL } from "./defaultServer";
-import { NOLO_CLUSTER_SERVERS } from "../database/config";
-
-export type EnvLike = Record<string, string | undefined>;
-
-export function resolveServerUrlFromEnv(env: EnvLike) {
-  return (env.NOLO_SERVER || env.BASE_URL || DEFAULT_NOLO_SERVER_URL).replace(/\/+$/, "");
-}
-
-type ResolverInput = string[] | EnvLike;
-
-function isCliArgs(value: ResolverInput): value is string[] {
-  return Array.isArray(value);
-}
-
-function buildServerCandidates(values: Array<string | null | undefined>) {
-  return [...new Set(
-    values
-      .filter((value): value is string => typeof value === "string" && value.trim().length > 0)
-      .map((value) => value.replace(/\/+$/, ""))
-  )];
-}
-
-export function resolveServerUrl(env: EnvLike): string;
-export function resolveServerUrl(args: string[], env: EnvLike): string;
-export function resolveServerUrl(input: ResolverInput, env?: EnvLike) {
-  if (isCliArgs(input)) {
-    const explicit =
-      readOption(input, "--server-url") ||
-      readOption(input, "--server");
-    return explicit?.replace(/\/+$/, "") || resolveServerUrlFromEnv(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: ResolverInput,
-  envOrPreferred?: EnvLike | string | null,
-  preferred?: string | null,
-) {
-  if (isCliArgs(input)) {
-    const env = (envOrPreferred ?? {}) as EnvLike;
-    const explicitServer = resolveServerUrl(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 resolveAuthTokenFromEnv(env: EnvLike, extraEnvKeys: string[] = []) {
-  for (const key of ["AUTH_TOKEN", "AUTH", ...extraEnvKeys]) {
-    const value = env[key];
-    if (typeof value === "string" && value.trim()) return value;
-  }
-  return "";
-}
-
-export function resolveAuthToken(env: EnvLike, extraEnvKeys?: string[]): string;
-export function resolveAuthToken(args: string[], env: EnvLike, extraEnvKeys?: string[]): string;
-export function resolveAuthToken(
-  input: ResolverInput,
-  envOrExtraEnvKeys?: EnvLike | string[],
-  extraEnvKeys: string[] = [],
-) {
-  if (isCliArgs(input)) {
-    const env = (envOrExtraEnvKeys ?? {}) as EnvLike;
-    return (
-      readOption(input, "--token") ||
-      readOption(input, "--machine-key") ||
-      resolveAuthTokenFromEnv(env, extraEnvKeys)
-    );
-  }
-  return resolveAuthTokenFromEnv(input, (envOrExtraEnvKeys as string[] | undefined) ?? []);
-}
-
-export function parseUserIdFromAuthToken(token: string) {
-  const parts = token.trim().split(".").filter(Boolean);
-  const payloadCandidates = parts.length >= 3 ? [parts[1], parts[0]] : [parts[0]];
-  for (const payload of payloadCandidates) {
-    if (!payload) continue;
-    try {
-      const parsed = JSON.parse(Buffer.from(payload, "base64").toString("utf8"));
-      if (typeof parsed?.userId === "string") return parsed.userId;
-    } catch {
-      // Try the next token shape.
-    }
-  }
-  return "";
-}
-
-export function readOption(args: string[], flag: string) {
-  const index = args.indexOf(flag);
-  return index >= 0 ? args[index + 1] : undefined;
-}

package/cli/cliSpaceHelpers.ts

@@ -1,39 +0,0 @@
-export function normalizeSpaceIdInput(rawInput: string) {
-  const raw = rawInput.trim();
-  if (!raw) return "";
-
-  if (raw.startsWith("http://") || raw.startsWith("https://")) {
-    const url = new URL(raw);
-    const match = url.pathname.match(/^\/space\/([^/?#]+)/);
-    if (match?.[1]) return decodeURIComponent(match[1]);
-  }
-
-  return raw.startsWith("space-") ? raw.slice("space-".length) : raw;
-}
-
-export function buildSpaceLookup(rawInput: string) {
-  const spaceId = normalizeSpaceIdInput(rawInput);
-  return {
-    spaceId,
-    spaceKey: spaceId.startsWith("space-") ? spaceId : `space-${spaceId}`,
-  };
-}
-
-export function getSpaceContentKeys(spaceRecord: any): Set<string> {
-  const keys = new Set<string>();
-  const contents = spaceRecord?.contents;
-  if (!contents || typeof contents !== "object") return keys;
-
-  for (const [entryKey, value] of Object.entries(contents)) {
-    if (typeof entryKey === "string" && entryKey.trim()) {
-      keys.add(entryKey.trim());
-    }
-    if (value && typeof value === "object") {
-      const contentKey = (value as any).contentKey;
-      if (typeof contentKey === "string" && contentKey.trim()) {
-        keys.add(contentKey.trim());
-      }
-    }
-  }
-  return keys;
-}

package/cli/client/agentConfigResolver.ts

@@ -1 +0,0 @@
-export { resolveAgentRuntimeConfigFromRecord } from "../agentRuntimeLocal";