simplemdg-dev-cli 2.0.4 → 2.4.4

package/src/commands/npmrc.command.ts

@@ -0,0 +1,581 @@
+import path from "node:path";
+import { readFile } from "node:fs/promises";
+import { Command } from "commander";
+import prompts from "prompts";
+import {
+  readCache,
+  rememberNpmrcHost,
+  rememberNpmrcOutputFileName,
+  rememberNpmrcPackages,
+  rememberNpmrcScope,
+  rememberNpmrcTokenEntry,
+} from "../core/cache";
+import {
+  normalizeGitLabHost,
+  normalizeNpmScope,
+  parsePackageInputList,
+  readPackageJsonName,
+  writeNpmrcFile,
+} from "../core/npmrc";
+import { searchableSelectChoice, searchableSelectOrInput } from "../core/prompts";
+import { resolveRepositoryPath } from "../core/repository";
+import type { TNpmrcPackageEntry, TNpmrcTokenEntry } from "../core/types";
+
+const DEFAULT_PROJECT_NAME = "default";
+
+const DEFAULT_HOST = "gitlab.simplemdg.com";
+const DEFAULT_SCOPE = "@simplemdg";
+
+type TNpmrcCreateOptions = {
+  cwd?: string;
+  scope?: string;
+  host?: string;
+  packageId?: string;
+  packageName?: string;
+  token?: string;
+  tokenLabel?: string;
+  out?: string;
+  noSaveToken?: boolean;
+  alwaysAuth?: boolean;
+};
+
+type TNpmrcImportOptions = {
+  cwd?: string;
+  project?: string;
+  scope?: string;
+  host?: string;
+  ids?: string;
+  file?: string;
+};
+
+type TNpmrcTokenOptions = {
+  scope?: string;
+  host?: string;
+  token?: string;
+  label?: string;
+};
+
+function validatePackageId(value: string): true | string {
+  return /^\d+$/.test(value.trim()) ? true : "Package ID must be a number";
+}
+
+function validateNotEmpty(label: string): (value: string) => true | string {
+  return (value: string) => value.trim() ? true : `${label} is required`;
+}
+
+function maskToken(token: string): string {
+  const trimmedToken = token.trim();
+
+  if (trimmedToken.length <= 8) {
+    return "********";
+  }
+
+  return `${trimmedToken.slice(0, 4)}...${trimmedToken.slice(-4)}`;
+}
+
+function buildPackageEntryTitle(entry: TNpmrcPackageEntry): string {
+  return `${entry.packageName} (${entry.packageId}) - ${entry.scope} @ ${entry.host}`;
+}
+
+function buildTokenTitle(entry: TNpmrcTokenEntry): string {
+  return `${entry.label} - ${entry.scope} @ ${entry.host} - ${maskToken(entry.token)}`;
+}
+
+function uniquePackageEntries(entries: TNpmrcPackageEntry[]): TNpmrcPackageEntry[] {
+  const result: TNpmrcPackageEntry[] = [];
+  const keys = new Set<string>();
+
+  for (const entry of entries) {
+    const key = `${entry.host}|${entry.scope}|${entry.packageId}`;
+
+    if (keys.has(key)) {
+      continue;
+    }
+
+    keys.add(key);
+    result.push(entry);
+  }
+
+  return result;
+}
+
+async function resolveCurrentProjectName(cwd: string, explicitProjectName?: string): Promise<string> {
+  if (explicitProjectName?.trim()) {
+    return explicitProjectName.trim();
+  }
+
+  const repositoryPath = await resolveRepositoryPath(cwd);
+  const packageJsonName = await readPackageJsonName(repositoryPath);
+
+  return packageJsonName ?? path.basename(repositoryPath) ?? DEFAULT_PROJECT_NAME;
+}
+
+async function askHost(providedHost?: string): Promise<string> {
+  if (providedHost?.trim()) {
+    return normalizeGitLabHost(providedHost);
+  }
+
+  const cache = await readCache();
+  return normalizeGitLabHost(await searchableSelectOrInput({
+    message: "GitLab host",
+    values: cache.npmrc.hosts,
+    initialValue: cache.npmrc.hosts[0] ?? DEFAULT_HOST,
+    validate: validateNotEmpty("Host"),
+    customValueTitle: (value) => `Use typed host: ${value}`,
+  }));
+}
+
+async function askScope(providedScope?: string): Promise<string> {
+  if (providedScope?.trim()) {
+    return normalizeNpmScope(providedScope);
+  }
+
+  const cache = await readCache();
+  return normalizeNpmScope(await searchableSelectOrInput({
+    message: "NPM scope",
+    values: cache.npmrc.scopes,
+    initialValue: cache.npmrc.scopes[0] ?? DEFAULT_SCOPE,
+    validate: validateNotEmpty("Scope"),
+    customValueTitle: (value) => `Use typed scope: ${value}`,
+  }));
+}
+
+async function askPackageEntry(options: {
+  projectName: string;
+  host: string;
+  scope: string;
+  providedPackageId?: string;
+  providedPackageName?: string;
+}): Promise<TNpmrcPackageEntry> {
+  const now = new Date().toISOString();
+
+  if (options.providedPackageId?.trim()) {
+    const validationResult = validatePackageId(options.providedPackageId);
+
+    if (validationResult !== true) {
+      throw new Error(validationResult);
+    }
+
+    const packageName = options.providedPackageName?.trim() || options.providedPackageId.trim();
+
+    return {
+      packageId: options.providedPackageId.trim(),
+      packageName,
+      host: options.host,
+      scope: options.scope,
+      updatedAt: now,
+    };
+  }
+
+  const cache = await readCache();
+  const projectPackages = cache.npmrc.packageIdsByProject[options.projectName]?.packages ?? [];
+  const legacyProjectIds = cache.npmrc.packageIdsByProject[options.projectName]?.packageIds ?? [];
+  const legacyProjectPackages = legacyProjectIds.map<TNpmrcPackageEntry>((packageId) => ({
+    packageId,
+    packageName: packageId,
+    host: options.host,
+    scope: options.scope,
+    updatedAt: now,
+  }));
+  const globalPackages = cache.npmrc.packages ?? [];
+  const legacyGlobalPackages = cache.npmrc.packageIds.map<TNpmrcPackageEntry>((packageId) => ({
+    packageId,
+    packageName: packageId,
+    host: options.host,
+    scope: options.scope,
+    updatedAt: now,
+  }));
+  const packages = uniquePackageEntries([
+    ...projectPackages,
+    ...legacyProjectPackages,
+    ...globalPackages,
+    ...legacyGlobalPackages,
+  ]);
+
+  const selectedPackageId = await searchableSelectChoice({
+    message: `GitLab package for ${options.projectName}`,
+    choices: packages.map((entry) => ({
+      title: buildPackageEntryTitle(entry),
+      value: entry.packageId,
+    })),
+    validateCustomValue: validatePackageId,
+    customValueTitle: (value) => `Use typed package ID: ${value}`,
+  });
+
+  const cachedPackage = packages.find((entry) => entry.packageId === selectedPackageId);
+
+  if (cachedPackage) {
+    return {
+      ...cachedPackage,
+      host: cachedPackage.host || options.host,
+      scope: cachedPackage.scope || options.scope,
+      updatedAt: now,
+    };
+  }
+
+  const response = await prompts({
+    type: "text",
+    name: "packageName",
+    message: `Package name for ${selectedPackageId}`,
+    initial: options.providedPackageName ?? selectedPackageId,
+    validate: validateNotEmpty("Package name"),
+  });
+
+  if (!response.packageName) {
+    throw new Error("Package name is required");
+  }
+
+  return {
+    packageId: selectedPackageId,
+    packageName: String(response.packageName).trim(),
+    host: options.host,
+    scope: options.scope,
+    updatedAt: now,
+  };
+}
+
+async function askToken(options: {
+  host: string;
+  scope: string;
+  providedToken?: string;
+  providedLabel?: string;
+}): Promise<TNpmrcTokenEntry> {
+  const now = new Date().toISOString();
+
+  if (options.providedToken?.trim()) {
+    return {
+      host: options.host,
+      scope: options.scope,
+      token: options.providedToken.trim(),
+      label: options.providedLabel?.trim() || `${options.scope} @ ${options.host}`,
+      updatedAt: now,
+    };
+  }
+
+  const cache = await readCache();
+  const scopedTokens = cache.npmrc.tokenEntries.filter((entry) => {
+    return entry.host === options.host && entry.scope === options.scope;
+  });
+  const allTokens = cache.npmrc.tokenEntries;
+  const legacyTokens = cache.npmrc.tokens.map<TNpmrcTokenEntry>((token, index) => ({
+    host: options.host,
+    scope: options.scope,
+    token,
+    label: `Legacy token ${index + 1}`,
+    updatedAt: now,
+  }));
+  const tokens = [...scopedTokens, ...allTokens, ...legacyTokens];
+
+  if (tokens.length > 0) {
+    const selectedToken = await searchableSelectChoice({
+      message: `GitLab npm auth token for ${options.scope} @ ${options.host}`,
+      choices: tokens.map((entry) => ({
+        title: buildTokenTitle(entry),
+        value: entry.token,
+      })),
+      validateCustomValue: validateNotEmpty("Token"),
+      customValueTitle: (value) => `Use typed token: ${maskToken(value)}`,
+    });
+    const cachedToken = tokens.find((entry) => entry.token === selectedToken);
+
+    if (cachedToken) {
+      return {
+        ...cachedToken,
+        host: options.host,
+        scope: options.scope,
+        updatedAt: now,
+      };
+    }
+
+    return {
+      host: options.host,
+      scope: options.scope,
+      token: selectedToken,
+      label: options.providedLabel?.trim() || `${options.scope} @ ${options.host}`,
+      updatedAt: now,
+    };
+  }
+
+  const response = await prompts({
+    type: "password",
+    name: "token",
+    message: `GitLab npm auth token for ${options.scope} @ ${options.host}`,
+    validate: (value: string) => value.trim() ? true : "Token is required",
+  });
+
+  if (!response.token) {
+    throw new Error("Token is required");
+  }
+
+  return {
+    host: options.host,
+    scope: options.scope,
+    token: String(response.token).trim(),
+    label: options.providedLabel?.trim() || `${options.scope} @ ${options.host}`,
+    updatedAt: now,
+  };
+}
+
+async function createNpmrc(options: TNpmrcCreateOptions): Promise<void> {
+  const cwd = options.cwd ?? process.cwd();
+  const projectName = await resolveCurrentProjectName(cwd);
+  const cache = await readCache();
+  const host = await askHost(options.host);
+  const scope = await askScope(options.scope);
+  const packageEntry = await askPackageEntry({
+    projectName,
+    host,
+    scope,
+    providedPackageId: options.packageId,
+    providedPackageName: options.packageName,
+  });
+  const tokenEntry = await askToken({
+    host,
+    scope,
+    providedToken: options.token,
+    providedLabel: options.tokenLabel,
+  });
+  const outputFileName = options.out ?? await searchableSelectOrInput({
+    message: "Output npmrc file",
+    values: cache.npmrc.outputFileNames,
+    initialValue: ".npmrc",
+    validate: validateNotEmpty("Output file"),
+    customValueTitle: (value) => `Use typed file name: ${value}`,
+  });
+
+  const outputPath = await writeNpmrcFile({
+    host,
+    scope,
+    packageId: packageEntry.packageId,
+    token: tokenEntry.token,
+    outputFileName,
+    alwaysAuth: options.alwaysAuth ?? true,
+  });
+
+  await rememberNpmrcHost(host);
+  await rememberNpmrcScope(scope);
+  await rememberNpmrcPackages(projectName, [packageEntry]);
+  await rememberNpmrcOutputFileName(outputFileName);
+
+  if (options.noSaveToken !== true) {
+    await rememberNpmrcTokenEntry(tokenEntry);
+  }
+
+  console.log(`Created ${outputPath}`);
+  console.log(`${scope}:registry=https://${host}/api/v4/projects/${packageEntry.packageId}/packages/npm/`);
+  console.log(`Package: ${packageEntry.packageName} (${packageEntry.packageId})`);
+  console.log(`Token: ${tokenEntry.label} (${maskToken(tokenEntry.token)})`);
+}
+
+async function importPackages(options: TNpmrcImportOptions): Promise<void> {
+  const projectName = await resolveCurrentProjectName(options.cwd ?? process.cwd(), options.project);
+  const host = await askHost(options.host);
+  const scope = await askScope(options.scope);
+  let rawInput = options.ids ?? "";
+
+  if (options.file?.trim()) {
+    const filePath = path.resolve(options.cwd ?? process.cwd(), options.file);
+    const fileContent = await readFile(filePath, "utf8");
+    rawInput = `${rawInput}\n${fileContent}`;
+  }
+
+  if (!rawInput.trim()) {
+    const response = await prompts({
+      type: "text",
+      name: "packages",
+      message: `Packages for ${projectName}. Use: name|id, name,id, or id only`,
+      validate: (value: string) => parsePackageInputList(value).length > 0 ? true : "Enter at least one package ID",
+    });
+
+    if (!response.packages) {
+      throw new Error("No packages entered");
+    }
+
+    rawInput = response.packages as string;
+  }
+
+  const parsedPackages = parsePackageInputList(rawInput);
+
+  if (parsedPackages.length === 0) {
+    throw new Error("No valid packages found. Package IDs must be numbers.");
+  }
+
+  const packageEntries = parsedPackages.map<TNpmrcPackageEntry>((entry) => ({
+    packageId: entry.packageId,
+    packageName: entry.packageName,
+    host,
+    scope,
+    updatedAt: new Date().toISOString(),
+  }));
+
+  await rememberNpmrcHost(host);
+  await rememberNpmrcScope(scope);
+  await rememberNpmrcPackages(projectName, packageEntries);
+
+  console.log(`Imported ${packageEntries.length} package(s) for ${projectName}:`);
+  for (const entry of packageEntries) {
+    console.log(`- ${entry.packageName} (${entry.packageId}) - ${entry.scope} @ ${entry.host}`);
+  }
+}
+
+async function updateToken(options: TNpmrcTokenOptions): Promise<void> {
+  const host = await askHost(options.host);
+  const scope = await askScope(options.scope);
+  const response = options.token?.trim()
+    ? { token: options.token.trim(), label: options.label?.trim() || `${scope} @ ${host}` }
+    : await prompts([
+      {
+        type: "password",
+        name: "token",
+        message: `New GitLab npm auth token for ${scope} @ ${host}`,
+        validate: (value: string) => value.trim() ? true : "Token is required",
+      },
+      {
+        type: "text",
+        name: "label",
+        message: "Token label",
+        initial: options.label?.trim() || `${scope} @ ${host}`,
+        validate: validateNotEmpty("Token label"),
+      },
+    ]);
+
+  if (!response.token) {
+    throw new Error("Token is required");
+  }
+
+  const tokenEntry: TNpmrcTokenEntry = {
+    host,
+    scope,
+    token: String(response.token).trim(),
+    label: String(response.label || `${scope} @ ${host}`).trim(),
+    updatedAt: new Date().toISOString(),
+  };
+
+  await rememberNpmrcHost(host);
+  await rememberNpmrcScope(scope);
+  await rememberNpmrcTokenEntry(tokenEntry);
+
+  console.log(`Updated token for ${scope} @ ${host}: ${tokenEntry.label} (${maskToken(tokenEntry.token)})`);
+}
+
+async function listNpmrcCache(): Promise<void> {
+  const cache = await readCache();
+
+  console.log("NPMRC cache");
+  console.log("");
+  console.log(`Hosts: ${cache.npmrc.hosts.join(", ") || "N/A"}`);
+  console.log(`Scopes: ${cache.npmrc.scopes.join(", ") || "N/A"}`);
+  console.log(`Output files: ${cache.npmrc.outputFileNames.join(", ") || "N/A"}`);
+  console.log("");
+  console.log("Tokens:");
+
+  if (cache.npmrc.tokenEntries.length === 0 && cache.npmrc.tokens.length === 0) {
+    console.log("- N/A");
+  } else {
+    for (const entry of cache.npmrc.tokenEntries) {
+      console.log(`- ${entry.label}: ${entry.scope} @ ${entry.host} - ${maskToken(entry.token)}`);
+    }
+
+    if (cache.npmrc.tokens.length > 0) {
+      console.log(`- Legacy tokens: ${cache.npmrc.tokens.length}`);
+    }
+  }
+
+  console.log("");
+  console.log("Global packages:");
+
+  if (cache.npmrc.packages.length === 0 && cache.npmrc.packageIds.length === 0) {
+    console.log("- N/A");
+  } else {
+    for (const entry of cache.npmrc.packages) {
+      console.log(`- ${entry.packageName} (${entry.packageId}) - ${entry.scope} @ ${entry.host}`);
+    }
+
+    for (const packageId of cache.npmrc.packageIds.filter((packageId) => {
+      return !cache.npmrc.packages.some((entry) => entry.packageId === packageId);
+    })) {
+      console.log(`- ${packageId} (${packageId})`);
+    }
+  }
+
+  console.log("");
+  console.log("Packages by project:");
+
+  const projects = Object.values(cache.npmrc.packageIdsByProject);
+
+  if (projects.length === 0) {
+    console.log("- N/A");
+    return;
+  }
+
+  for (const project of projects) {
+    console.log(`- ${project.projectName}:`);
+
+    if ((project.packages?.length ?? 0) === 0 && project.packageIds.length === 0) {
+      console.log("  - N/A");
+      continue;
+    }
+
+    for (const entry of project.packages ?? []) {
+      console.log(`  - ${entry.packageName} (${entry.packageId}) - ${entry.scope} @ ${entry.host}`);
+    }
+
+    for (const packageId of project.packageIds.filter((packageId) => {
+      return !(project.packages ?? []).some((entry) => entry.packageId === packageId);
+    })) {
+      console.log(`  - ${packageId} (${packageId})`);
+    }
+  }
+}
+
+export function registerNpmrcCommands(program: Command): void {
+  const npmrcCommand = program
+    .command("npmrc")
+    .description("Create and cache .npmrc config for GitLab npm package registry");
+
+  npmrcCommand
+    .command("create")
+    .alias("init")
+    .description("Create .npmrc for @simplemdg GitLab package registry")
+    .option("--cwd <path>", "Repository path", process.cwd())
+    .option("--scope <scope>", "NPM scope. Example: @simplemdg")
+    .option("--host <host>", "GitLab host")
+    .option("--package-id <packageId>", "GitLab project/package ID")
+    .option("--package-name <packageName>", "Human-readable package name for cache")
+    .option("--token <token>", "GitLab package registry token")
+    .option("--token-label <label>", "Human-readable token label")
+    .option("--out <fileName>", "Output file", ".npmrc")
+    .option("--no-save-token", "Do not cache token")
+    .option("--no-always-auth", "Write always-auth=false")
+    .action(createNpmrc);
+
+  npmrcCommand
+    .command("import")
+    .alias("add")
+    .description("Import many GitLab packages into cache with package names")
+    .option("--cwd <path>", "Repository path", process.cwd())
+    .option("--project <name>", "Project cache name")
+    .option("--scope <scope>", "NPM scope. Example: @simplemdg")
+    .option("--host <host>", "GitLab host")
+    .option("--ids <ids>", "Packages separated by line. Examples: name|123 or name,123 or 123")
+    .option("--file <path>", "Text file containing packages")
+    .action(importPackages);
+
+  npmrcCommand
+    .command("token")
+    .alias("update-token")
+    .description("Add or update cached token for a scope and host")
+    .option("--scope <scope>", "NPM scope. Example: @simplemdg")
+    .option("--host <host>", "GitLab host")
+    .option("--token <token>", "New token")
+    .option("--label <label>", "Token label")
+    .action(updateToken);
+
+  npmrcCommand
+    .command("list")
+    .description("List cached npmrc values with package names")
+    .action(listNpmrcCache);
+
+  npmrcCommand
+    .action(createNpmrc);
+}