simplemdg-dev-cli 2.0.4 → 2.4.4

package/src/core/install.ts

@@ -0,0 +1,91 @@
+import fs from "fs-extra";
+import fastGlob from "fast-glob";
+import { execa } from "execa";
+import { splitCommand } from "./process";
+import type { TInstallRepositoryOptions, TInstallRepositoryResult } from "./types";
+
+function replaceVariables(content: string, variableValues: Record<string, string>): string {
+  return content.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (fullMatch: string, variableName: string) => {
+    return variableValues[variableName] ?? fullMatch;
+  });
+}
+
+function mergePackageOverrides(packageJson: Record<string, unknown>, temporaryOverrides: Record<string, string>): Record<string, unknown> {
+  if (Object.keys(temporaryOverrides).length === 0) {
+    return packageJson;
+  }
+
+  const currentOverrides = typeof packageJson.overrides === "object" && packageJson.overrides !== null && !Array.isArray(packageJson.overrides)
+    ? packageJson.overrides as Record<string, unknown>
+    : {};
+
+  return {
+    ...packageJson,
+    overrides: {
+      ...currentOverrides,
+      ...temporaryOverrides,
+    },
+  };
+}
+
+export async function installRepository(options: TInstallRepositoryOptions): Promise<TInstallRepositoryResult> {
+  const filePaths = await fastGlob(options.filePatterns, {
+    cwd: options.repositoryPath,
+    absolute: true,
+    onlyFiles: true,
+    ignore: ["node_modules/**", "dist/**", ".git/**"],
+  });
+
+  const originalContents = new Map<string, string>();
+
+  try {
+    for (const filePath of filePaths) {
+      const originalContent = await fs.readFile(filePath, "utf8");
+      originalContents.set(filePath, originalContent);
+      let nextContent = replaceVariables(originalContent, options.variableValues);
+
+      if (filePath.endsWith("package.json")) {
+        const packageJson = JSON.parse(nextContent) as Record<string, unknown>;
+        nextContent = `${JSON.stringify(mergePackageOverrides(packageJson, options.temporaryOverrides), null, 2)}\n`;
+      }
+
+      if (nextContent !== originalContent) {
+        await fs.writeFile(filePath, nextContent, "utf8");
+      }
+    }
+
+    const { command, args } = splitCommand(options.installCommand);
+    const childProcess = execa(command, args, {
+      cwd: options.repositoryPath,
+      reject: false,
+      all: false,
+    });
+
+    let stdout = "";
+    let stderr = "";
+
+    childProcess.stdout?.on("data", (chunk: Buffer) => {
+      const value = chunk.toString();
+      stdout += value;
+      options.onLog?.(value);
+    });
+
+    childProcess.stderr?.on("data", (chunk: Buffer) => {
+      const value = chunk.toString();
+      stderr += value;
+      options.onErrorLog?.(value);
+    });
+
+    const result = await childProcess;
+
+    return {
+      stdout,
+      stderr,
+      exitCode: result.exitCode ?? 0,
+    };
+  } finally {
+    for (const [filePath, content] of originalContents.entries()) {
+      await fs.writeFile(filePath, content, "utf8");
+    }
+  }
+}

package/src/core/navigator.ts

@@ -0,0 +1,164 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import { searchableSelectChoice } from "./prompts";
+
+const BACK_VALUE = "__SMDG_NAV_BACK__";
+const EXIT_VALUE = "__SMDG_NAV_EXIT__";
+
+// Commands that exist only for internal/background use and should never be
+// offered in the interactive menu.
+const INTERNAL_COMMAND_NAMES = new Set(["apps-cache-refresh"]);
+
+function isHidden(command: Command): boolean {
+  return Boolean((command as unknown as { _hidden?: boolean })._hidden);
+}
+
+function getNavigableChildren(command: Command): Command[] {
+  return command.commands.filter((child) => {
+    if (child.name() === "help") {
+      return false;
+    }
+
+    if (isHidden(child)) {
+      return false;
+    }
+
+    return !INTERNAL_COMMAND_NAMES.has(child.name());
+  });
+}
+
+function isGroup(command: Command): boolean {
+  return getNavigableChildren(command).length > 0;
+}
+
+function buildBreadcrumb(command: Command): string {
+  const names: string[] = [];
+  let current: Command | null | undefined = command;
+
+  while (current) {
+    names.unshift(current.name());
+    current = current.parent;
+  }
+
+  // The bin is published as `smdg`; show that shorter name in breadcrumbs.
+  if (names[0] === "simplemdg") {
+    names[0] = "smdg";
+  }
+
+  return names.join(" ");
+}
+
+function buildChoiceTitle(command: Command): string {
+  const aliases = command.aliases();
+  const aliasText = aliases.length ? chalk.gray(` (${aliases.join(", ")})`) : "";
+  const marker = isGroup(command) ? chalk.cyan(" ›") : "";
+  const description = command.description();
+  const descriptionText = description ? `  ${chalk.gray(`— ${description}`)}` : "";
+
+  return `${chalk.bold(command.name())}${aliasText}${marker}${descriptionText}`;
+}
+
+async function dispatchLeaf(leaf: Command): Promise<void> {
+  console.log(chalk.gray(`→ ${buildBreadcrumb(leaf)}`));
+  console.log("");
+  // Parsing the leaf with no user args runs its action with default options.
+  // Each leaf already prompts interactively for whatever it still needs.
+  await leaf.parseAsync([], { from: "user" });
+}
+
+/**
+ * Drive interactive navigation starting from a group command. Shows the list of
+ * subcommands, lets the user descend into nested groups, and finally runs the
+ * selected leaf command (which collects its own options interactively).
+ */
+export async function runGroupNavigator(startGroup: Command): Promise<void> {
+  const stack: Command[] = [startGroup];
+
+  while (stack.length > 0) {
+    const current = stack[stack.length - 1];
+    const children = getNavigableChildren(current);
+
+    if (children.length === 0) {
+      await dispatchLeaf(current);
+      return;
+    }
+
+    const choices = children.map((child) => ({
+      title: buildChoiceTitle(child),
+      value: child.name(),
+    }));
+
+    if (stack.length > 1) {
+      choices.push({ title: chalk.yellow("← Back"), value: BACK_VALUE });
+    }
+
+    choices.push({ title: chalk.gray("✕ Exit"), value: EXIT_VALUE });
+
+    let picked: string;
+
+    try {
+      picked = await searchableSelectChoice({
+        message: `${chalk.cyan(buildBreadcrumb(current))} — type to filter, then select`,
+        choices,
+        allowCustomValue: false,
+        limit: 20,
+      });
+    } catch {
+      // ESC / cancel: step back one level, or exit when at the top.
+      if (stack.length > 1) {
+        stack.pop();
+        continue;
+      }
+
+      return;
+    }
+
+    if (picked === EXIT_VALUE) {
+      return;
+    }
+
+    if (picked === BACK_VALUE) {
+      stack.pop();
+      continue;
+    }
+
+    const selected = children.find((child) => child.name() === picked);
+
+    if (!selected) {
+      return;
+    }
+
+    if (isGroup(selected)) {
+      stack.push(selected);
+      continue;
+    }
+
+    await dispatchLeaf(selected);
+    return;
+  }
+}
+
+/**
+ * Attach the interactive navigator to every group command in the tree. After
+ * this, invoking a group without a subcommand (e.g. `smdg cf` or `smdg cf db`)
+ * opens a searchable menu of its subcommands instead of printing help.
+ *
+ * Leaf commands keep their own action handlers untouched. Existing default
+ * actions on group commands are replaced by the navigator so navigation stays
+ * consistent across the whole CLI.
+ */
+export function enableInteractiveNavigation(program: Command): void {
+  const attach = (command: Command): void => {
+    for (const child of command.commands) {
+      if (isGroup(child)) {
+        child.action(async () => {
+          await runGroupNavigator(child);
+        });
+      }
+
+      attach(child);
+    }
+  };
+
+  attach(program);
+}

package/src/core/npmrc.ts

@@ -0,0 +1,171 @@
+import path from "node:path";
+import fs from "fs-extra";
+
+export type TNpmrcConfig = {
+  host: string;
+  scope: string;
+  packageId: string;
+  token: string;
+  outputFileName: string;
+  alwaysAuth: boolean;
+};
+
+function trimSlashes(value: string): string {
+  return value.trim().replace(/^\/+/, "").replace(/\/+$/, "");
+}
+
+export function normalizeNpmScope(scope: string): string {
+  const trimmedScope = scope.trim();
+  if (!trimmedScope) {
+    throw new Error("Scope is required");
+  }
+
+  return trimmedScope.startsWith("@") ? trimmedScope : `@${trimmedScope}`;
+}
+
+export function normalizeGitLabHost(host: string): string {
+  return trimSlashes(host.replace(/^https?:\/\//, ""));
+}
+
+export function buildGitLabNpmRegistryUrl(options: { host: string; packageId: string }): string {
+  const host = normalizeGitLabHost(options.host);
+  const packageId = options.packageId.trim();
+
+  if (!/^\d+$/.test(packageId)) {
+    throw new Error("Package ID must be a number");
+  }
+
+  return `https://${host}/api/v4/projects/${packageId}/packages/npm/`;
+}
+
+export function buildGitLabNpmAuthRegistryPath(options: { host: string; packageId: string }): string {
+  const host = normalizeGitLabHost(options.host);
+  const packageId = options.packageId.trim();
+
+  if (!/^\d+$/.test(packageId)) {
+    throw new Error("Package ID must be a number");
+  }
+
+  return `//${host}/api/v4/projects/${packageId}/packages/npm/`;
+}
+
+function removeExistingManagedLines(options: {
+  currentContent: string;
+  scope: string;
+  host: string;
+}): string[] {
+  const normalizedScope = normalizeNpmScope(options.scope);
+  const normalizedHost = normalizeGitLabHost(options.host);
+
+  return options.currentContent
+    .split(/\r?\n/)
+    .filter((line) => {
+      const trimmedLine = line.trim();
+
+      if (!trimmedLine) {
+        return false;
+      }
+
+      if (trimmedLine.startsWith(`${normalizedScope}:registry=`)) {
+        return false;
+      }
+
+      if (trimmedLine.includes(`${normalizedHost}/api/v4/projects/`) && trimmedLine.includes("/packages/npm/:_authToken=")) {
+        return false;
+      }
+
+      if (trimmedLine === "always-auth=true" || trimmedLine === "always-auth=false") {
+        return false;
+      }
+
+      return true;
+    });
+}
+
+export async function writeNpmrcFile(options: TNpmrcConfig): Promise<string> {
+  const outputPath = path.resolve(process.cwd(), options.outputFileName);
+  const existingContent = await fs.pathExists(outputPath) ? await fs.readFile(outputPath, "utf8") : "";
+  const preservedLines = removeExistingManagedLines({
+    currentContent: existingContent,
+    scope: options.scope,
+    host: options.host,
+  });
+
+  const scope = normalizeNpmScope(options.scope);
+  const registryUrl = buildGitLabNpmRegistryUrl({ host: options.host, packageId: options.packageId });
+  const authRegistryPath = buildGitLabNpmAuthRegistryPath({ host: options.host, packageId: options.packageId });
+
+  const managedLines = [
+    `${scope}:registry=${registryUrl}`,
+    `${authRegistryPath}:_authToken=${options.token.trim()}`,
+    `always-auth=${options.alwaysAuth ? "true" : "false"}`,
+  ];
+
+  const nextContent = [...preservedLines, ...managedLines].join("\n") + "\n";
+
+  await fs.writeFile(outputPath, nextContent, "utf8");
+  return outputPath;
+}
+
+export function parsePackageIdList(input: string): string[] {
+  return [...new Set(input
+    .split(/[\s,;]+/)
+    .map((value) => value.trim())
+    .filter(Boolean)
+    .filter((value) => /^\d+$/.test(value)))] ;
+}
+
+export async function readPackageJsonName(repositoryPath: string): Promise<string | undefined> {
+  const packageJsonPath = path.join(repositoryPath, "package.json");
+
+  if (!(await fs.pathExists(packageJsonPath))) {
+    return undefined;
+  }
+
+  const packageJson = await fs.readJson(packageJsonPath).catch(() => undefined) as { name?: string } | undefined;
+  return packageJson?.name;
+}
+
+export type TParsedPackageInput = {
+  packageId: string;
+  packageName: string;
+};
+
+export function parsePackageInputList(input: string): TParsedPackageInput[] {
+  const entries: TParsedPackageInput[] = [];
+  const keys = new Set<string>();
+
+  for (const rawLine of input.split(/\r?\n/)) {
+    const trimmedLine = rawLine.trim();
+
+    if (!trimmedLine) {
+      continue;
+    }
+
+    const tokens = trimmedLine.split(/[|,;\t]+/).map((value) => value.trim()).filter(Boolean);
+    const firstNumericTokenIndex = tokens.findIndex((value) => /^\d+$/.test(value));
+
+    if (firstNumericTokenIndex >= 0) {
+      const packageId = tokens[firstNumericTokenIndex];
+      const packageNameTokens = tokens.filter((_, index) => index !== firstNumericTokenIndex);
+      const packageName = packageNameTokens.join(" - ").trim() || packageId;
+      const key = packageId;
+
+      if (!keys.has(key)) {
+        keys.add(key);
+        entries.push({ packageId, packageName });
+      }
+
+      continue;
+    }
+
+    for (const packageId of parsePackageIdList(trimmedLine)) {
+      if (!keys.has(packageId)) {
+        keys.add(packageId);
+        entries.push({ packageId, packageName: packageId });
+      }
+    }
+  }
+
+  return entries;
+}

package/src/core/process.ts

@@ -0,0 +1,75 @@
+import { execa } from "execa";
+
+export type TCommandResult = {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+};
+
+export async function runCommand(command: string, args: string[], options?: { cwd?: string; reject?: boolean }): Promise<TCommandResult> {
+  const result = await execa(command, args, {
+    cwd: options?.cwd,
+    reject: options?.reject ?? false,
+    all: false,
+    shell: false,
+  });
+
+  return {
+    stdout: result.stdout,
+    stderr: result.stderr,
+    exitCode: result.exitCode ?? 0,
+  };
+}
+
+export async function runCommandInherit(command: string, args: string[], options?: { cwd?: string }): Promise<number> {
+  const result = await execa(command, args, {
+    cwd: options?.cwd,
+    stdio: "inherit",
+    reject: false,
+    shell: false,
+  });
+
+  return result.exitCode ?? 0;
+}
+
+export function splitCommand(commandLine: string): { command: string; args: string[] } {
+  const tokens: string[] = [];
+  let current = "";
+  let quote: '"' | "'" | undefined;
+
+  for (let index = 0; index < commandLine.length; index += 1) {
+    const character = commandLine[index];
+
+    if ((character === '"' || character === "'") && !quote) {
+      quote = character;
+      continue;
+    }
+
+    if (quote && character === quote) {
+      quote = undefined;
+      continue;
+    }
+
+    if (!quote && /\s/.test(character)) {
+      if (current) {
+        tokens.push(current);
+        current = "";
+      }
+      continue;
+    }
+
+    current += character;
+  }
+
+  if (current) {
+    tokens.push(current);
+  }
+
+  const [command, ...args] = tokens;
+
+  if (!command) {
+    throw new Error("Command is required");
+  }
+
+  return { command, args };
+}