it4-tools 0.1.2 → 0.1.4

package/README.md

@@ -26,31 +26,26 @@ Fluxo:
    que não é IT4.
 4. **`npm i -g @it4solution/tools`** — instala o **core** do CLI (bin `it4`).
 
-O CLI é **core + plugins por capacidade**: o core traz só `auth`/`config`.
-Instale os plugins que for usar (o mesmo `~/.npmrc` configurado acima
-autentica o download deles):
+O CLI é **core + plugins por capacidade**, e os plugins (`create`, `skills`,
+`publish`, `task`, `library`, `docs`, `workspace`) já aparecem no `it4 --help` e se
+**instalam sozinhos no primeiro uso**, do mesmo feed que o `~/.npmrc` acima autentica.
+Não há nada para instalar à mão.
 
-```bash
-it4 plugins install @it4solution/plugin-create          # cria projetos
-it4 plugins install @it4solution/plugin-skills          # skills do Claude Code
-it4 plugins install @it4solution/plugin-publish-nuget   # publica libs .NET
-it4 plugins                                             # lista o que está instalado
-```
-
-Depois disso, `it4 --help` mostra os comandos disponíveis. Pra re-logar
+`it4 --help` mostra os comandos disponíveis. Pra re-logar
 quando o PAT expirar (em ~90 dias), rode de novo `npx -y it4-tools`
-ou `it4 auth login` (mesmo caminho).
+ou `it4 auth` (mesmo caminho).
 
 ## Flags
 
-| Flag                    | Default         | Descrição                                                                                           |
-| ----------------------- | --------------- | --------------------------------------------------------------------------------------------------- |
-| `--no-install`          | —               | Configura `.npmrc` mas não instala o CLI globalmente.                                               |
-| `--cli-version <v>`     | `latest`        | Versão específica do `@it4solution/tools` a instalar.                                               |
-| `--pat-validity <dias>` | `90`            | Validade do PAT em dias (máx 365).                                                                  |
-| `--scope <s>`           | `vso.packaging` | Scope do PAT (`vso.packaging` = read; `vso.packaging_write` = read+write, necessário pra publicar). |
-| `--dry-run`             | —               | Autentica e mostra o `.npmrc` que seria escrito, sem salvar.                                        |
-| `--help`, `-h`          | —               | Mostra essa ajuda.                                                                                  |
+| Flag                    | Default         | Descrição                                                                                            |
+| ----------------------- | --------------- | ---------------------------------------------------------------------------------------------------- |
+| `--no-install`          | —               | Configura `.npmrc` mas não instala o CLI globalmente.                                                |
+| `--cli-version <v>`     | `latest`        | Versão específica do `@it4solution/tools` a instalar.                                                |
+| `--pat-validity <dias>` | `90`            | Validade do PAT em dias (máx 365).                                                                   |
+| `--scope <s>`           | `vso.packaging` | Scope do PAT (`vso.packaging` = read; `vso.packaging_write` = read+write, necessário pra publicar).  |
+| `--no-nuget`            | —               | Não grava a credencial do feed NuGet no NuGet.Config do usuário (sem `dotnet`, o passo já é pulado). |
+| `--dry-run`             | —               | Mostra o `.npmrc` que seria escrito (segredos mascarados), sem logar, criar PAT nem salvar.          |
+| `--help`, `-h`          | —               | Mostra essa ajuda.                                                                                   |
 
 ## Troubleshooting
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "it4-tools",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Bootstrap público: autentica no Azure Artifacts da IT4 e instala @it4solution/tools.",
   "license": "ISC",
   "author": "Diego Andrade",
@@ -24,6 +24,9 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
+  "scripts": {
+    "test": "node --test test/npmrc.test.js test/nuget.test.js"
+  },
   "dependencies": {
     "@azure/identity": "^4.4.1",
     "@clack/prompts": "^1.4.0",

package/src/index.js

@@ -3,7 +3,20 @@ import { spawn } from "node:child_process";
 import { cancel, confirm, intro, isCancel, log, outro, spinner } from "@clack/prompts";
 import pc from "picocolors";
 import { exchangeForPat, getBearerToken } from "./auth.js";
-import { buildNpmrc, NPMRC_PATH, readNpmrc, summarizeChanges, writeNpmrc } from "./npmrc.js";
+import {
+  hasDotnet,
+  NUGET_SOURCE_NAME,
+  userNuGetConfigPath,
+  writeNuGetCredential,
+} from "./nuget.js";
+import {
+  buildNpmrc,
+  maskSecrets,
+  NPMRC_PATH,
+  readNpmrc,
+  summarizeChanges,
+  writeNpmrc,
+} from "./npmrc.js";
 
 const DEFAULTS = {
   install: true,
@@ -11,6 +24,7 @@ const DEFAULTS = {
   patValidityDays: 90,
   scope: "vso.packaging",
   dryRun: false,
+  nuget: true,
 };
 
 function printHelp() {
@@ -21,11 +35,14 @@ Uso:
 
 Opções:
   --no-install                Configura .npmrc mas não instala @it4solution/tools.
+  --no-nuget                  Não grava a credencial do feed NuGet (NuGet.Config do
+                              usuário). Sem dotnet instalado, o passo já é pulado.
   --cli-version <v>           Versão do CLI a instalar (default: latest).
   --pat-validity <dias>       Validade do PAT em dias (default: 90, máx 365).
   --scope <s>                 Scope do PAT: vso.packaging | vso.packaging_write
                               (default: vso.packaging).
-  --dry-run                   Mostra o .npmrc resultante sem escrever.
+  --dry-run                   Mostra o .npmrc resultante sem logar, sem criar PAT
+                              e sem escrever (segredos mascarados).
   -h, --help                  Mostra essa ajuda.
 
 Detalhes: README.md ou docs/specs/04-auth-bootstrap.md
@@ -40,6 +57,9 @@ function parseArgs(argv) {
       case "--no-install":
         args.install = false;
         break;
+      case "--no-nuget":
+        args.nuget = false;
+        break;
       case "--dry-run":
         args.dryRun = true;
         break;
@@ -78,18 +98,13 @@ function parseArgs(argv) {
   return args;
 }
 
-const PLUGINS = [
-  ["@it4solution/plugin-create", "cria projetos (frontend, backend, monorepo)"],
-  ["@it4solution/plugin-skills", "instala/atualiza skills do Claude Code"],
-  ["@it4solution/plugin-publish-nuget", "publica libs .NET (nuget)"],
-];
-
 function printPluginsHint() {
-  log.info("O CLI é core + plugins. Instale só as capacidades que for usar:");
-  for (const [name, desc] of PLUGINS) {
-    log.message(`  ${pc.cyan(`it4 plugins install ${name}`)}  ${pc.dim(`# ${desc}`)}`);
-  }
-  log.message(`  ${pc.dim("Liste o que está instalado com")} ${pc.cyan("it4 plugins")}.`);
+  log.info(
+    "O CLI é core + plugins, e os plugins se instalam sozinhos no primeiro uso de cada comando.",
+  );
+  log.message(
+    `  ${pc.cyan("it4 --help")}  ${pc.dim("# lista todos os comandos, instalados ou não")}`,
+  );
 }
 
 function printSkillHint() {
@@ -126,11 +141,61 @@ function runNpmInstallGlobalCli(version) {
   });
 }
 
+/**
+ * O mesmo PAT (`vso.packaging`) vale para o feed NuGet. Gravado no NuGet.Config
+ * do usuário, dispensa PAT no NuGet.config do repo. Falha aqui não derruba o
+ * setup: o npm já está configurado.
+ */
+async function configureNuGet(pat) {
+  if (!(await hasDotnet())) {
+    log.info("dotnet não encontrado: pulei a credencial NuGet (só o npm foi configurado).");
+    return;
+  }
+  const s = spinner();
+  s.start("Gravando credencial do feed NuGet...");
+  try {
+    const configFile = await writeNuGetCredential(pat);
+    const storage = process.platform === "win32" ? "cifrada pelo Windows" : "fora de qualquer repo";
+    s.stop(`Credencial NuGet gravada em ${configFile} (${storage}).`);
+  } catch (err) {
+    s.stop("Falha ao gravar a credencial NuGet.", 1);
+    log.warn(`${err.message} O npm já está configurado; rode de novo para tentar o NuGet.`);
+  }
+}
+
+const DRY_RUN_PAT = "<PAT-criado-no-setup-real>";
+
+/**
+ * Dry-run sem efeito colateral: nada de device flow nem de PAT. Criar o PAT aqui
+ * emitiria uma credencial válida por 90 dias só para exibi-la.
+ */
+async function dryRun(opts) {
+  const existing = await readNpmrc();
+  const newContent = buildNpmrc(existing, DRY_RUN_PAT);
+  const summary = summarizeChanges(existing, "");
+  log.info(`Dry-run: não loga, não cria PAT e não escreve ${NPMRC_PATH}.`);
+  log.info(`Conteúdo que seria escrito (segredos mascarados):\n\n${maskSecrets(newContent)}`);
+  if (summary.replaced) {
+    log.warn(`Linhas IT4 antigas que seriam removidas: ${summary.removedLines.length}.`);
+  }
+  if (opts.nuget && (await hasDotnet())) {
+    log.info(
+      `Credencial NuGet: a fonte "${NUGET_SOURCE_NAME}" seria gravada em ${userNuGetConfigPath()}.`,
+    );
+  }
+  outro(pc.dim("Dry-run completo."));
+}
+
 async function main() {
   const opts = parseArgs(process.argv);
 
   intro(pc.bgBlue(pc.white(" IT4 Tools — setup ")));
 
+  if (opts.dryRun) {
+    await dryRun(opts);
+    return;
+  }
+
   log.step("Autenticação Azure AD (device code flow)");
   let bearer;
   try {
@@ -168,16 +233,6 @@ async function main() {
   const newContent = buildNpmrc(existing, pat.pat);
   const summary = summarizeChanges(existing, pat.pat);
 
-  if (opts.dryRun) {
-    log.info(`Dry-run — não vou escrever ${NPMRC_PATH}.`);
-    log.info(`Conteúdo que seria escrito:\n\n${newContent}`);
-    if (summary.replaced) {
-      log.warn(`Linhas IT4 antigas que seriam removidas: ${summary.removedLines.length}.`);
-    }
-    outro(pc.dim("Dry-run completo."));
-    return;
-  }
-
   await writeNpmrc(newContent);
   if (summary.replaced) {
     log.success(
@@ -187,6 +242,8 @@ async function main() {
     log.success(`~/.npmrc configurado.`);
   }
 
+  if (opts.nuget) await configureNuGet(pat.pat);
+
   if (!opts.install) {
     outro(`Pronto. Rode ${pc.cyan("npm i -g @it4solution/tools")} quando quiser instalar o CLI.`);
     return;

package/src/npmrc.js

@@ -49,6 +49,29 @@ export function buildNpmrc(existingContent, pat) {
   return result.join("\n") + "\n";
 }
 
+const SECRET_LINE = /^(\s*[^=]*?(?:_authToken|_password|_auth)\s*=\s*)(.*)$/i;
+
+/**
+ * Mascara os segredos de um conteúdo de .npmrc antes de exibi-lo.
+ *
+ * O preview do dry-run mostra o arquivo inteiro, inclusive linhas de outros
+ * registries que o dev já tinha: sem máscara, esses tokens iriam parar no
+ * terminal e no transcript de quem rodou (humano ou agente).
+ */
+export function maskSecrets(content) {
+  return content
+    .split(/\r?\n/)
+    .map((line) => line.replace(SECRET_LINE, (_, key, value) => `${key}${maskValue(value)}`))
+    .join("\n");
+}
+
+function maskValue(value) {
+  const v = value.trim();
+  if (v.startsWith("<")) return v;
+  if (v.length <= 8) return "****";
+  return `${v.slice(0, 4)}...${v.slice(-4)}`;
+}
+
 export function summarizeChanges(existingContent, pat) {
   const before = (existingContent ?? "").split(/\r?\n/).filter((l) => isIt4Line(l));
   const replaced = before.length > 0;

package/src/nuget.js

@@ -0,0 +1,97 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+/**
+ * Fonte NuGet da IT4 como os repos a declaram. O NuGet casa credencial com fonte
+ * pelo NOME, não pela URL: gravada com este nome na config do usuário, ela vale
+ * para todo repo que declara a fonte sem credencial própria.
+ *
+ * Mesma lógica de `plugin-publish-nuget/src/lib/nuget.ts`, duplicada porque o
+ * bootstrap é público e não depende dos pacotes do feed.
+ */
+export const NUGET_SOURCE_NAME = "IT4-artifacts-packages";
+export const NUGET_SOURCE_URL =
+  "https://it4solution.pkgs.visualstudio.com/IT4360/_packaging/IT4-packages/nuget/v3/index.json";
+
+export function userNuGetConfigPath(
+  platform = process.platform,
+  env = process.env,
+  home = os.homedir(),
+) {
+  if (platform === "win32") {
+    const appData = env.APPDATA ?? path.win32.join(home, "AppData", "Roaming");
+    return path.win32.join(appData, "NuGet", "NuGet.Config");
+  }
+  return path.posix.join(home, ".nuget", "NuGet", "NuGet.Config");
+}
+
+/**
+ * Argumentos do `dotnet nuget add|update source`. No Windows a senha sai
+ * cifrada (DPAPI, default do dotnet); texto claro só onde o dotnet não cifra.
+ */
+export function buildSourceArgs(action, { pat, configFile }, platform = process.platform) {
+  const target =
+    action === "add"
+      ? [NUGET_SOURCE_URL, "--name", NUGET_SOURCE_NAME]
+      : [NUGET_SOURCE_NAME, "--source", NUGET_SOURCE_URL];
+  const args = [
+    "nuget",
+    action,
+    "source",
+    ...target,
+    "--username",
+    "it4-tools",
+    "--password",
+    pat,
+    "--configfile",
+    configFile,
+  ];
+  if (platform !== "win32") args.push("--store-password-in-clear-text");
+  return args;
+}
+
+// Mesmo conteúdo que o NuGet gera no primeiro uso: sem o nuget.org, criar o
+// arquivo tiraria a fonte pública do restore do dev.
+const DEFAULT_USER_CONFIG = `<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+  <packageSources>
+    <add key="nuget.org" value="https://api.nuget.org/v3/index.json" protocolVersion="3" />
+  </packageSources>
+</configuration>
+`;
+
+/** `dotnet` é executável de verdade: sem shell, o PAT não passa pela linha do cmd. */
+function runDotnet(args) {
+  return new Promise((resolve) => {
+    const child = spawn("dotnet", args, { stdio: ["ignore", "pipe", "pipe"] });
+    let output = "";
+    child.stdout.on("data", (chunk) => (output += chunk));
+    child.stderr.on("data", (chunk) => (output += chunk));
+    child.on("error", (err) => resolve({ code: -1, output: err.message }));
+    child.on("close", (code) => resolve({ code: code ?? 1, output }));
+  });
+}
+
+export async function hasDotnet() {
+  return (await runDotnet(["--version"])).code === 0;
+}
+
+/** Grava a credencial da fonte IT4 no NuGet.Config do usuário. Devolve o caminho. */
+export async function writeNuGetCredential(pat) {
+  const configFile = userNuGetConfigPath();
+  try {
+    await fs.access(configFile);
+  } catch {
+    await fs.mkdir(path.dirname(configFile), { recursive: true });
+    await fs.writeFile(configFile, DEFAULT_USER_CONFIG, "utf8");
+  }
+  const added = await runDotnet(buildSourceArgs("add", { pat, configFile }));
+  if (added.code !== 0) {
+    // A fonte já existe na config do usuário: atualiza URL e credencial.
+    const updated = await runDotnet(buildSourceArgs("update", { pat, configFile }));
+    if (updated.code !== 0) throw new Error(updated.output.trim() || added.output.trim());
+  }
+  return configFile;
+}