nolo-cli 0.1.32 → 0.1.34

package/cli/authCommands.ts

@@ -9,7 +9,6 @@ import {
   loadProfileConfig,
   saveDefaultProfile,
 } from "./client/profileConfig";
-import { parseUserIdFromAuthToken } from "./cliEnvHelpers";
 import { DEFAULT_NOLO_SERVER_URL } from "./defaultServer";
 
 function getArg(args: string[], flag: string) {
@@ -68,47 +67,17 @@ async function saveTokenLogin(args: {
   configPath: string;
   serverUrl: string;
   authToken: string;
-  fetchImpl: typeof fetch;
   output: Pick<Console, "log">;
   error: Pick<Console, "error">;
 }) {
-  const authToken = args.authToken.trim();
-  if (!authToken) {
+  if (!args.authToken.trim()) {
     args.error.error("No auth token provided.");
     return 1;
   }
 
-  const userId = parseUserIdFromAuthToken(authToken);
-  if (!userId) {
-    args.error.error("Auth token payload is missing userId.");
-    return 1;
-  }
-
-  try {
-    const res = await args.fetchImpl(
-      `${args.serverUrl}/api/v1/db/query/${encodeURIComponent(userId)}?limit=1`,
-      {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${authToken}`,
-          "Content-Type": "application/json",
-        },
-        body: JSON.stringify({ type: "agent" }),
-      }
-    );
-    if (res.status === 401 || res.status === 403) {
-      args.error.error(
-        `Auth token is not valid for ${args.serverUrl}. Log in against the matching server or use a token issued by that server.`
-      );
-      return 1;
-    }
-  } catch {
-    // Allow saving when the server is temporarily unreachable.
-  }
-
   saveDefaultProfile(args.configPath, {
     serverUrl: args.serverUrl,
-    authToken,
+    authToken: args.authToken.trim(),
   });
   args.output.log(`Saved profile default -> ${args.serverUrl}`);
   return 0;
@@ -175,7 +144,6 @@ async function runWebLogin(args: {
         configPath: args.configPath,
         serverUrl: approvedServer,
         authToken: poll.token,
-        fetchImpl: args.fetchImpl,
         output: args.output,
         error: args.error,
       });
@@ -205,7 +173,6 @@ export async function runLoginCommand(args: string[], deps: LoginCommandDeps = {
       configPath,
       serverUrl,
       authToken: tokenArg,
-      fetchImpl: deps.fetchImpl ?? fetch,
       output: outputTarget,
       error: errorTarget,
     });
@@ -220,7 +187,6 @@ export async function runLoginCommand(args: string[], deps: LoginCommandDeps = {
         configPath,
         serverUrl,
         authToken,
-        fetchImpl: deps.fetchImpl ?? fetch,
         output: outputTarget,
         error: errorTarget,
       });

package/cli/cliCommandDispatch.ts

@@ -31,7 +31,7 @@ function readOption(args: string[], flag: string) {
 
 function buildDaemonEnv(args: string[], runtimeEnv: NodeJS.ProcessEnv) {
   const serverUrl = readOption(args, "--server-url") || readOption(args, "--server");
-  const apiKey = readOption(args, "--api-key") || readOption(args, "--token");
+  const apiKey = readOption(args, "--machine-key") || readOption(args, "--token");
   return {
     ...runtimeEnv,
     ...(serverUrl ? { NOLO_SERVER: serverUrl } : {}),
@@ -40,7 +40,7 @@ function buildDaemonEnv(args: string[], runtimeEnv: NodeJS.ProcessEnv) {
 }
 
 export function looksLikeDaemonShortcut(args: string[]) {
-  return args.includes("--server-url") || args.includes("--api-key");
+  return args.includes("--server-url") || args.includes("--machine-key");
 }
 
 export function createCliRuntimeContext(args: {

package/cli/cliEnvHelpers.ts

@@ -3,63 +3,13 @@ import { NOLO_CLUSTER_SERVERS } from "../database/config";
 
 export type EnvLike = Record<string, string | undefined>;
 
-function trimTrailingSlashes(value: string) {
-  return value.trim().replace(/\/+$/, "");
-}
-
-function firstDefinedEnvValue(env: EnvLike, keys: string[]) {
-  for (const key of keys) {
-    const value = env[key];
-    if (typeof value === "string" && value.length > 0) return value;
-  }
-  return "";
-}
-
-export function hasFlag(args: string[], flag: string) {
-  return args.includes(flag);
-}
-
-export function readCliOptionValue(args: string[], flag: string): string {
-  for (let i = 0; i < args.length; i += 1) {
-    const arg = args[i];
-    if (arg === flag) {
-      const next = args[i + 1];
-      if (typeof next === "string" && !next.startsWith("-")) return next;
-      return "";
-    }
-    if (arg.startsWith(`${flag}=`)) return arg.slice(flag.length + 1);
-  }
-  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"]) ||
-      DEFAULT_NOLO_SERVER_URL,
-  );
+  return (env.NOLO_SERVER || env.BASE_URL || DEFAULT_NOLO_SERVER_URL).replace(/\/+$/, "");
 }
 
-export function resolveServerUrlFromArgs(args: string[], env: EnvLike) {
-  return trimTrailingSlashes(
-    readCliOptionValue(args, "--server-url") ||
-      readCliOptionValue(args, "--server") ||
-      readCliOptionValue(args, "--base-url") ||
-      firstDefinedEnvValue(env, ["NOLO_SERVER_URL", "NOLO_SERVER", "BASE_URL"]) ||
-      DEFAULT_NOLO_SERVER_URL,
-  );
-}
-
-type ServerResolverInput = string[] | EnvLike;
+type ResolverInput = string[] | EnvLike;
 
-function isCliArgs(value: ServerResolverInput): value is string[] {
+function isCliArgs(value: ResolverInput): value is string[] {
   return Array.isArray(value);
 }
 
@@ -73,9 +23,12 @@ function buildServerCandidates(values: Array<string | null | undefined>) {
 
 export function resolveServerUrl(env: EnvLike): string;
 export function resolveServerUrl(args: string[], env: EnvLike): string;
-export function resolveServerUrl(input: ServerResolverInput, env?: EnvLike) {
+export function resolveServerUrl(input: ResolverInput, env?: EnvLike) {
   if (isCliArgs(input)) {
-    return resolveServerUrlFromArgs(input, env ?? {});
+    const explicit =
+      readOption(input, "--server-url") ||
+      readOption(input, "--server");
+    return explicit?.replace(/\/+$/, "") || resolveServerUrlFromEnv(env ?? {});
   }
   return resolveServerUrlFromEnv(input);
 }
@@ -87,13 +40,13 @@ export function resolveServerCandidates(
   preferred?: string | null,
 ): string[];
 export function resolveServerCandidates(
-  input: ServerResolverInput,
+  input: ResolverInput,
   envOrPreferred?: EnvLike | string | null,
   preferred?: string | null,
 ) {
   if (isCliArgs(input)) {
     const env = (envOrPreferred ?? {}) as EnvLike;
-    const explicitServer = resolveServerUrlFromArgs(input, env);
+    const explicitServer = resolveServerUrl(input, env);
     return buildServerCandidates([
       explicitServer,
       preferred?.trim(),
@@ -104,6 +57,7 @@ export function resolveServerCandidates(
       ...NOLO_CLUSTER_SERVERS,
     ]);
   }
+
   const env = input;
   return buildServerCandidates([
     typeof envOrPreferred === "string" ? envOrPreferred.trim() : undefined,
@@ -115,71 +69,44 @@ export function resolveServerCandidates(
   ]);
 }
 
+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: ServerResolverInput,
+  input: ResolverInput,
   envOrExtraEnvKeys?: EnvLike | string[],
   extraEnvKeys: string[] = [],
 ) {
   if (isCliArgs(input)) {
-    return resolveAuthTokenFromArgs(input, (envOrExtraEnvKeys ?? {}) as EnvLike, extraEnvKeys);
+    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 resolveAuthTokenFromEnv(env: EnvLike, extraEnvKeys: string[] = []) {
-  return (
-    firstDefinedEnvValue(env, [...extraEnvKeys, "BENCHMARK_AUTH_TOKEN", "AUTH_TOKEN", "AUTH"]) ||
-    ""
-  );
-}
-
-export function resolveAuthTokenFromArgs(
-  args: string[],
-  env: EnvLike,
-  extraEnvKeys: string[] = [],
-) {
-  return (
-    readCliOptionValue(args, "--api-key") ||
-    readCliOptionValue(args, "--token") ||
-    firstDefinedEnvValue(env, [
-      ...extraEnvKeys,
-      "BENCHMARK_AUTH_TOKEN",
-      "NOLO_TASK_RUN_TOKEN",
-      "NOLO_MACHINE_API_KEY",
-      "AUTH_TOKEN",
-      "AUTH",
-    ]) ||
-    ""
-  );
-}
-
-export function decodeJwtPayload(token: string): Record<string, unknown> | null {
-  const trimmed = token.trim();
-  if (!trimmed) return null;
-  const parts = trimmed.split(".").filter(Boolean);
-  const payloadCandidates = parts.length >= 3 ? [parts[1], parts[0]] : [parts[0]];
-  for (const payload of payloadCandidates) {
-    try {
-      return JSON.parse(Buffer.from(payload, "base64").toString("utf8"));
-    } catch {
-      continue;
-    }
-  }
-  return null;
-}
-
 export function parseUserIdFromAuthToken(token: string) {
-  const parsed = decodeJwtPayload(token);
-  return typeof parsed?.userId === "string" ? parsed.userId : "";
+  const payload = token.trim().split(".")[0];
+  if (!payload) return "";
+  try {
+    const parsed = JSON.parse(Buffer.from(payload, "base64").toString("utf8"));
+    return typeof parsed?.userId === "string" ? parsed.userId : "";
+  } catch {
+    return "";
+  }
 }
 
 export function readOption(args: string[], flag: string) {
   const index = args.indexOf(flag);
   return index >= 0 ? args[index + 1] : undefined;
 }
-
-export function readOptionValue(args: string[], flag: string) {
-  return readCliOptionValue(args, flag);
-}