nolo-cli 0.1.31 → 0.1.32

package/cli/buildPublishImportAnalysis.ts

@@ -0,0 +1,242 @@
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
+
+function extractPackageNameFromImportPath(importPath: string): string {
+  if (importPath.startsWith("@")) {
+    const parts = importPath.split("/");
+    return parts.slice(0, 2).join("/");
+  }
+
+  const firstSlash = importPath.indexOf("/");
+  return firstSlash === -1 ? importPath : importPath.slice(0, firstSlash);
+}
+
+function extractModuleSpecifiers(content: string): string[] {
+  const specifiers = new Set<string>();
+  const importOrExportRegex =
+    /(?:import|export)\s+(?:(?:type\s+)?(?:\{[^}]*\}|\*\s+as\s+\w+|\w+)\s+from\s+)?['"]([^'"]+)['"]/g;
+  const dynamicImportRegex = /import\(\s*['"]([^'"]+)['"]\s*\)/g;
+
+  let match: RegExpExecArray | null;
+  while ((match = importOrExportRegex.exec(content)) !== null) {
+    specifiers.add(match[1]);
+  }
+
+  while ((match = dynamicImportRegex.exec(content)) !== null) {
+    specifiers.add(match[1]);
+  }
+
+  return Array.from(specifiers);
+}
+
+export function extractExternalImports(content: string): string[] {
+  const imports = new Set<string>();
+  for (const importPath of extractModuleSpecifiers(content)) {
+    if (
+      importPath.startsWith(".") ||
+      importPath.startsWith("node:") ||
+      importPath.startsWith("/")
+    ) {
+      continue;
+    }
+    imports.add(extractPackageNameFromImportPath(importPath));
+  }
+  return Array.from(imports);
+}
+
+export function extractLocalRelativeImports(content: string): string[] {
+  return extractModuleSpecifiers(content).filter(
+    (importPath) => importPath.startsWith(".") && !importPath.startsWith("/")
+  );
+}
+
+export function extractWorkspaceDependencies(
+  manifest: Record<string, any>
+): string[] {
+  const deps: string[] = [];
+  for (const field of ["dependencies", "devDependencies", "peerDependencies"]) {
+    if (!manifest[field]) {
+      continue;
+    }
+    for (const [name, version] of Object.entries(manifest[field])) {
+      if (typeof version === "string" && version.startsWith("workspace:")) {
+        deps.push(name);
+      }
+    }
+  }
+  return deps;
+}
+
+export function findSiblingWorkspacePackageNames(sourceDir: string): string[] {
+  const packagesDir = join(sourceDir, "..");
+  const names: string[] = [];
+
+  for (const entry of readdirSync(packagesDir)) {
+    const pkgPath = join(packagesDir, entry, "package.json");
+    if (!existsSync(pkgPath)) {
+      continue;
+    }
+    try {
+      const manifest = JSON.parse(readFileSync(pkgPath, "utf8"));
+      if (typeof manifest.name === "string" && manifest.name.length > 0) {
+        names.push(manifest.name);
+      }
+    } catch {
+      // Ignore malformed sibling manifests while scanning workspace package names.
+    }
+  }
+
+  return names;
+}
+
+export function extractWorkspaceImports(
+  content: string,
+  workspacePackageNames: Set<string>
+): string[] {
+  const imports = new Set<string>();
+
+  for (const packageName of extractExternalImports(content)) {
+    if (workspacePackageNames.has(packageName)) {
+      imports.add(packageName);
+    }
+  }
+
+  const relativeWorkspaceImportRegex =
+    /(?:from\s+['"]\.\.\/([^./'"][^/'"]*)(?:\/[^'"]*)?['"]|import\(\s*['"]\.\.\/([^./'"][^/'"]*)(?:\/[^'"]*)?['"]\s*\))/g;
+
+  let match: RegExpExecArray | null;
+  while ((match = relativeWorkspaceImportRegex.exec(content)) !== null) {
+    const packageName = match[1] || match[2];
+    if (packageName && workspacePackageNames.has(packageName)) {
+      imports.add(packageName);
+    }
+  }
+
+  return Array.from(imports);
+}
+
+export function collectWorkspaceDependencies(
+  sourceDir: string,
+  manifest: Record<string, any>,
+  filesToCopy: string[]
+): string[] {
+  const workspaceDeps = new Set(extractWorkspaceDependencies(manifest));
+  const workspacePackageNames = new Set(findSiblingWorkspacePackageNames(sourceDir));
+
+  for (const filePath of collectTypeScriptSourceFiles(sourceDir, filesToCopy)) {
+    const content = readFileSync(filePath, "utf8");
+    for (const dep of extractWorkspaceImports(content, workspacePackageNames)) {
+      workspaceDeps.add(dep);
+    }
+  }
+
+  return Array.from(workspaceDeps);
+}
+
+export function findTypeScriptFiles(dir: string): string[] {
+  const files: string[] = [];
+
+  for (const entry of readdirSync(dir)) {
+    const fullPath = join(dir, entry);
+    const stat = statSync(fullPath);
+    if (stat.isDirectory()) {
+      files.push(...findTypeScriptFiles(fullPath));
+      continue;
+    }
+    if (stat.isFile() && fullPath.endsWith(".ts")) {
+      files.push(fullPath);
+    }
+  }
+
+  return files;
+}
+
+export function collectTypeScriptSourceFiles(
+  sourceDir: string,
+  filesToCopy: string[]
+): string[] {
+  const files: string[] = [];
+
+  for (const entry of filesToCopy) {
+    const sourcePath = join(sourceDir, entry);
+    if (!existsSync(sourcePath)) {
+      continue;
+    }
+    const stat = statSync(sourcePath);
+    if (stat.isDirectory()) {
+      files.push(...findTypeScriptFiles(sourcePath));
+      continue;
+    }
+    if (stat.isFile() && sourcePath.endsWith(".ts")) {
+      files.push(sourcePath);
+    }
+  }
+
+  return files;
+}
+
+function escapeRegex(text: string): string {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function createWorkspaceSpecifier(relativeFilePath: string, packageName: string, path = ""): string {
+  const fileDir = dirname(relativeFilePath);
+  const relativePackagePath = relative(fileDir === "." ? "" : fileDir, packageName).replace(
+    /\\/g,
+    "/"
+  );
+  const prefix = relativePackagePath.startsWith(".")
+    ? relativePackagePath
+    : `./${relativePackagePath}`;
+  return `${prefix}${path}`;
+}
+
+export function rewriteCrossPackageImports(
+  content: string,
+  workspaceDeps: string[],
+  relativeFilePath = ""
+): string {
+  if (workspaceDeps.length === 0) {
+    return content;
+  }
+
+  const patterns = workspaceDeps.map(escapeRegex);
+  const relativeDepth =
+    dirname(relativeFilePath) === "."
+      ? 1
+      : dirname(relativeFilePath).split(/[\\/]/).filter(Boolean).length + 1;
+  const crossPackagePrefixPattern = `(?:\\.\\./){${relativeDepth}}`;
+
+  const relativeImportRegex = new RegExp(
+    `(from\\s+['"])${crossPackagePrefixPattern}((?!\\.)${patterns.join("|")})(/[^'"]*)?(['"])`,
+    "g"
+  );
+  const bareImportRegex = new RegExp(
+    `(from\\s+['"])(${patterns.join("|")})(/[^'"]*)?(['"])`,
+    "g"
+  );
+  const dynamicRelativeImportRegex = new RegExp(
+    `(import\\(\\s*['"])${crossPackagePrefixPattern}((?!\\.)${patterns.join("|")})(/[^'"]*)?(['"]\\s*\\))`,
+    "g"
+  );
+  const dynamicBareImportRegex = new RegExp(
+    `(import\\(\\s*['"])(${patterns.join("|")})(/[^'"]*)?(['"]\\s*\\))`,
+    "g"
+  );
+
+  let result = content;
+  result = result.replace(relativeImportRegex, (_, prefix, packageName, path, suffix) => {
+    return `${prefix}${createWorkspaceSpecifier(relativeFilePath, packageName, path)}${suffix}`;
+  });
+  result = result.replace(bareImportRegex, (_, prefix, packageName, path, suffix) => {
+    return `${prefix}${createWorkspaceSpecifier(relativeFilePath, packageName, path)}${suffix}`;
+  });
+  result = result.replace(dynamicRelativeImportRegex, (_, prefix, packageName, path, suffix) => {
+    return `${prefix}${createWorkspaceSpecifier(relativeFilePath, packageName, path)}${suffix}`;
+  });
+  result = result.replace(dynamicBareImportRegex, (_, prefix, packageName, path, suffix) => {
+    return `${prefix}${createWorkspaceSpecifier(relativeFilePath, packageName, path)}${suffix}`;
+  });
+
+  return result;
+}

package/cli/cliCommandAdapters.ts

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,66 @@
+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, "--api-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("--api-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

@@ -0,0 +1,66 @@
+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

@@ -0,0 +1,49 @@
+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

@@ -0,0 +1,185 @@
+import { DEFAULT_NOLO_SERVER_URL } from "./defaultServer";
+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,
+  );
+}
+
+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;
+
+function isCliArgs(value: ServerResolverInput): 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: 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[] = []) {
+  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 : "";
+}
+
+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);
+}

package/cli/cliIoTypes.ts

@@ -0,0 +1,3 @@
+export type OutputLike = {
+  write(chunk: string): unknown;
+};