@neetru/cli 2.9.13 → 2.10.1

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 Convenção: [Keep a Changelog](https://keepachangelog.com/) + [SemVer](https://semver.org/).
 
+## [2.10.0] — 2026-05-27 (rename: `neetru marketplace` → `neetru archive` · fonte agora pública)
+
+### BREAKING
+
+- **`neetru marketplace` foi renomeado para `neetru archive`.** Subcomandos preservados (`skills install/update/list/uninstall`, `sdk init/templates/add`, `browse`). NÃO há alias de retrocompat — o comando antigo deixa de existir nesta versão. Quem rodava `neetru marketplace skills install` em scripts CI precisa trocar para `neetru archive skills install`.
+- **Cache local mudou de `~/.neetru/marketplace-cache/` para `~/.neetru/archive-cache/`.** Caches antigos podem ser apagados manualmente (não há migração automática — `archive skills install` cria o novo limpo). A função `getSkillsSourceDir` mantém retrocompat detectando o nível `claude-skills/` caso o cache de uma versão anterior do `archive-cache` ainda tenha esse layout.
+- **Variável de ambiente `NEETRU_MARKETPLACE_SYMLINK` virou `NEETRU_ARCHIVE_SYMLINK`** (Windows). Quem usava precisa renomear.
+
+### Mudado
+
+- **Fonte de skills migrou de `github.com/Neetru/neetru-libs` (privado) para `github.com/Neetru/neetru-libs-public` (público).** O `neetru-libs` privado mantém `packages/` (`@neetru/db-classifier`, `sql-guard`, `pii-mask`, `neetru-glossario`) — só `claude-skills/` foi exposto, via `git subtree push --prefix=claude-skills`. Resultado: `neetru archive skills install` deixa de exigir `gh auth setup-git` ou `GITHUB_TOKEN` — clone anônimo funciona.
+- **Layout do clone público é mais flat:** `plugins/<plugin>/skills/<skill>/SKILL.md` no topo (em vez de `claude-skills/plugins/...`). O resolver detecta o layout legado automaticamente — caches antigos continuam resolvendo até o próximo `archive skills update`.
+
+### Por quê
+
+- O 2.9.13 quebrava em `git clone` quando `neetru-libs` virou privado (HTTP 401 sem credencial git configurada). O fix arquitetural certo era separar o catálogo público de skills do código proprietário em `packages/` — `neetru-libs-public` é esse catálogo. A renomeação `marketplace → archive` aproveitou o break pra alinhar o nome do comando ao conceito real (catálogo/arquivo de artefatos, não um marketplace transacional).
+
 ## [2.9.13] — 2026-05-26 (feat: force-cleanup recovery + mfa-status observability)
 
 ### Adicionado

package/dist/commands/archive.d.ts

@@ -0,0 +1,37 @@
+export declare function getCacheDir(): string;
+/**
+ * Resolve o diretorio fonte das skills no cache local.
+ *
+ * Layout esperado no repo `neetru-libs-public` (top-level):
+ *
+ *   1. Estruturado (atual): plugins/PLUGIN/skills/SKILL/SKILL.md
+ *      - descobre todos os plugins/PLUGIN/skills/ e retorna o primeiro.
+ *   2. Plugin direto (legado): skills/SKILL/SKILL.md
+ *      - fallback se nao houver plugins/.
+ *
+ * Retrocompat: caches antigos (`marketplace-cache` ou versoes anteriores do
+ * archive-cache) podem ter o nivel `claude-skills/` no topo. Se detectarmos
+ * esse layout, adicionamos o prefixo na resolucao — assim um cache stale
+ * nao quebra o comando antes do proximo `archive skills update`.
+ */
+export declare function getSkillsSourceDir(): string;
+export declare function getClaudeSkillsDir(): string;
+export interface SkillInfo {
+    name: string;
+    description: string;
+    version: string;
+    installed: boolean;
+}
+export declare function listAvailableSkills(): Promise<SkillInfo[]>;
+export declare function runSkillsInstall(): Promise<void>;
+export declare function runSkillsUpdate(): Promise<void>;
+export declare function runSkillsList(): Promise<void>;
+export declare function runSkillsUninstall(opts?: {
+    yes?: boolean;
+}): Promise<void>;
+export declare function runSdkInit(): Promise<void>;
+export declare function runSdkTemplates(): Promise<void>;
+export declare function runSdkAddTemplate(template: string, opts?: {
+    force?: boolean;
+}): Promise<void>;
+export declare function runArchiveBrowse(): Promise<void>;

package/dist/commands/archive.js

@@ -0,0 +1,591 @@
+/**
+ * `neetru archive` — central de artefatos do ecossistema Neetru.
+ *
+ * Dois grupos principais:
+ *   skills  — instalar/atualizar/listar/remover Skills do Claude Code
+ *   sdk     — adicionar @neetru/sdk ao projeto atual ou bootstrapar novo
+ *   browse  — abre https://github.com/Neetru/neetru-libs-public no browser
+ *
+ * Fonte canônica de skills: https://github.com/Neetru/neetru-libs-public
+ *   (espelho público da pasta `claude-skills/` do `neetru-libs` privado,
+ *    sincronizado via `git subtree push --prefix=claude-skills`).
+ * Cache local: ~/.neetru/archive-cache/
+ * Destino das skills: ~/.claude/skills/<nome-da-skill>/
+ *
+ * Decisão de design (Windows): symlinks requerem privilégio de admin
+ * ou Developer Mode habilitado. O comando usa cópia recursiva por
+ * default no Windows — sem surpresa pra quem não tem Developer Mode.
+ * Se NEETRU_ARCHIVE_SYMLINK=1, tenta symlink mesmo no Windows.
+ */
+import * as fs from 'node:fs';
+import * as fsp from 'node:fs/promises';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { spawnSync } from 'node:child_process';
+import chalk from 'chalk';
+import ora from 'ora';
+import inquirer from 'inquirer';
+import { log } from '../utils/logger.js';
+import { safeExit } from '../utils/safe-exit.js';
+// ─── constantes ────────────────────────────────────────────────────────────────
+const LIBS_REPO_URL = 'https://github.com/Neetru/neetru-libs-public.git';
+const LIBS_REPO_HTTPS = 'https://github.com/Neetru/neetru-libs-public';
+const SDK_PACKAGE = '@neetru/sdk';
+const SDK_VERSION = '^2.1.0';
+export function getCacheDir() {
+    return path.join(os.homedir(), '.neetru', 'archive-cache');
+}
+/**
+ * Resolve o diretorio fonte das skills no cache local.
+ *
+ * Layout esperado no repo `neetru-libs-public` (top-level):
+ *
+ *   1. Estruturado (atual): plugins/PLUGIN/skills/SKILL/SKILL.md
+ *      - descobre todos os plugins/PLUGIN/skills/ e retorna o primeiro.
+ *   2. Plugin direto (legado): skills/SKILL/SKILL.md
+ *      - fallback se nao houver plugins/.
+ *
+ * Retrocompat: caches antigos (`marketplace-cache` ou versoes anteriores do
+ * archive-cache) podem ter o nivel `claude-skills/` no topo. Se detectarmos
+ * esse layout, adicionamos o prefixo na resolucao — assim um cache stale
+ * nao quebra o comando antes do proximo `archive skills update`.
+ */
+export function getSkillsSourceDir() {
+    const cacheRoot = getCacheDir();
+    const legacyRoot = path.join(cacheRoot, 'claude-skills');
+    const rootCandidate = fs.existsSync(path.join(legacyRoot, 'plugins'))
+        ? legacyRoot
+        : cacheRoot;
+    const pluginsRoot = path.join(rootCandidate, 'plugins');
+    try {
+        const pluginDirs = fs.readdirSync(pluginsRoot, { withFileTypes: true })
+            .filter((e) => e.isDirectory())
+            .map((e) => path.join(pluginsRoot, e.name, 'skills'))
+            .filter((p) => fs.existsSync(p));
+        if (pluginDirs.length > 0) {
+            // Retorna o primeiro plugin's skills dir (no estado atual: só 1 plugin "neetru")
+            // Futuramente: expandir pra agregar de múltiplos plugins se houver demanda.
+            return pluginDirs[0];
+        }
+    }
+    catch {
+        // pluginsRoot não existe — cai pro fallback
+    }
+    return path.join(rootCandidate, 'skills');
+}
+export function getClaudeSkillsDir() {
+    return path.join(os.homedir(), '.claude', 'skills');
+}
+function isWindows() {
+    return process.platform === 'win32';
+}
+// ─── helpers de filesystem ─────────────────────────────────────────────────────
+async function ensureDir(dir) {
+    await fsp.mkdir(dir, { recursive: true });
+}
+async function dirExists(p) {
+    try {
+        const stat = await fsp.stat(p);
+        return stat.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function pathExists(p) {
+    try {
+        await fsp.access(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Cópia recursiva pura em Node (sem dependência extra). */
+async function copyDirRecursive(src, dest) {
+    await ensureDir(dest);
+    const entries = await fsp.readdir(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            await copyDirRecursive(srcPath, destPath);
+        }
+        else {
+            await fsp.copyFile(srcPath, destPath);
+        }
+    }
+}
+async function removeDir(p) {
+    await fsp.rm(p, { recursive: true, force: true });
+}
+// ─── git helpers (spawnSync — sem shell injection) ─────────────────────────────
+function gitAvailable() {
+    const r = spawnSync('git', ['--version'], { stdio: 'ignore' });
+    return r.status === 0;
+}
+function gitClone(dest) {
+    const r = spawnSync('git', ['clone', '--depth', '1', LIBS_REPO_URL, dest], {
+        encoding: 'utf8',
+    });
+    return { ok: r.status === 0, stderr: r.stderr ?? '' };
+}
+function gitPull(dir) {
+    const r = spawnSync('git', ['pull', '--ff-only'], {
+        cwd: dir,
+        encoding: 'utf8',
+    });
+    return { ok: r.status === 0, stderr: r.stderr ?? '' };
+}
+// ─── symlink vs cópia ──────────────────────────────────────────────────────────
+/**
+ * true se deve tentar symlink.
+ * Linux/macOS: sim por default.
+ * Windows: só com NEETRU_MARKETPLACE_SYMLINK=1 (requer Developer Mode ou admin).
+ */
+function useSymlink() {
+    if (process.env.NEETRU_MARKETPLACE_SYMLINK === '1')
+        return true;
+    return !isWindows();
+}
+async function linkOrCopy(src, dest) {
+    if (useSymlink()) {
+        try {
+            await fsp.symlink(src, dest, 'dir');
+            return 'symlink';
+        }
+        catch {
+            // fallback pra cópia (sem acesso pra symlink)
+        }
+    }
+    await copyDirRecursive(src, dest);
+    return 'copy';
+}
+async function parseSkillMd(skillMdPath) {
+    try {
+        const raw = await fsp.readFile(skillMdPath, 'utf8');
+        // Primeira linha de parágrafo após o heading
+        const descMatch = raw.match(/^#{1,3}\s+.+\n+([^#\n].+)/m);
+        const versionMatch = raw.match(/version[:\s]+([0-9]+\.[0-9]+\.[0-9]+[\w.-]*)/i);
+        return {
+            description: descMatch?.[1]?.slice(0, 80).trim() ?? '(sem descrição)',
+            version: versionMatch?.[1] ?? '—',
+        };
+    }
+    catch {
+        return { description: '(SKILL.md ilegível)', version: '—' };
+    }
+}
+export async function listAvailableSkills() {
+    const sourceDir = getSkillsSourceDir();
+    const claudeDir = getClaudeSkillsDir();
+    if (!(await dirExists(sourceDir)))
+        return [];
+    const entries = await fsp.readdir(sourceDir, { withFileTypes: true });
+    const skills = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const skillMdPath = path.join(sourceDir, entry.name, 'SKILL.md');
+        const { description, version } = await parseSkillMd(skillMdPath);
+        const installed = await pathExists(path.join(claudeDir, entry.name));
+        skills.push({ name: entry.name, description, version, installed });
+    }
+    return skills;
+}
+// ─── neetru archiveskills install ─────────────────────────────────────────
+export async function runSkillsInstall() {
+    if (!gitAvailable()) {
+        log.error('git não encontrado. Instale o git e tente novamente.');
+        log.dim('  → https://git-scm.com/downloads');
+        safeExit(1);
+    }
+    const cacheDir = getCacheDir();
+    const claudeDir = getClaudeSkillsDir();
+    const spinner = ora({ text: 'Verificando cache local…', color: 'cyan' }).start();
+    await ensureDir(cacheDir);
+    await ensureDir(claudeDir);
+    const isFirstRun = !(await dirExists(path.join(cacheDir, '.git')));
+    if (isFirstRun) {
+        spinner.text = `Clonando ${LIBS_REPO_URL}…`;
+        const { ok, stderr } = gitClone(cacheDir);
+        if (!ok) {
+            spinner.fail('Falha ao clonar repositório.');
+            log.error(stderr.trim() || 'Verifique sua conexão e acesso ao GitHub.');
+            safeExit(1);
+        }
+    }
+    else {
+        spinner.text = 'Sincronizando cache (git pull)…';
+        const { ok, stderr } = gitPull(cacheDir);
+        if (!ok) {
+            spinner.warn(`Aviso no git pull: ${stderr.trim().split('\n')[0]}`);
+        }
+    }
+    spinner.succeed('Cache sincronizado.');
+    const skills = await listAvailableSkills();
+    if (skills.length === 0) {
+        log.warn('Nenhuma skill encontrada no cache.');
+        log.dim('  Estrutura esperada: plugins/<plugin>/skills/<skill>/SKILL.md');
+        log.dim('  (ou legado: skills/<skill>/SKILL.md)');
+        return;
+    }
+    console.log();
+    log.heading('Instalando skills');
+    let installed = 0;
+    let updated = 0;
+    let skipped = 0;
+    for (const skill of skills) {
+        const srcPath = path.join(getSkillsSourceDir(), skill.name);
+        const destPath = path.join(claudeDir, skill.name);
+        if (skill.installed) {
+            const isLink = fs.existsSync(destPath) && fs.lstatSync(destPath).isSymbolicLink();
+            if (isLink) {
+                console.log(`  ${chalk.dim('─')} ${chalk.bold(skill.name)} — symlink ativo`);
+                skipped++;
+            }
+            else {
+                // Cópia existente → re-copia pra atualizar
+                await removeDir(destPath);
+                await copyDirRecursive(srcPath, destPath);
+                console.log(`  ${chalk.yellow('↑')} ${chalk.bold(skill.name)} — atualizado`);
+                updated++;
+            }
+        }
+        else {
+            const mode = await linkOrCopy(srcPath, destPath);
+            const modeLabel = mode === 'symlink' ? chalk.dim('symlink') : chalk.dim('cópia');
+            console.log(`  ${chalk.green('✓')} ${chalk.bold(skill.name)} — instalado (${modeLabel})`);
+            console.log(`    ${chalk.dim('→')} ${chalk.dim(destPath)}`);
+            installed++;
+        }
+    }
+    console.log();
+    const parts = [];
+    if (installed > 0)
+        parts.push(`${installed} nova(s)`);
+    if (updated > 0)
+        parts.push(`${updated} atualizada(s)`);
+    if (skipped > 0)
+        parts.push(`${skipped} sem alteração`);
+    log.success(parts.join(', ') + '.');
+    log.dim('  Reinicie o Claude Code para carregar as skills.');
+}
+// ─── neetru archiveskills update ──────────────────────────────────────────
+export async function runSkillsUpdate() {
+    const cacheDir = getCacheDir();
+    const hasCache = await dirExists(path.join(cacheDir, '.git'));
+    if (!hasCache) {
+        log.warn('Cache não encontrado. Rodando install completo…');
+        await runSkillsInstall();
+        return;
+    }
+    const spinner = ora({ text: 'Atualizando neetru-libs (git pull)…', color: 'cyan' }).start();
+    const { ok, stderr } = gitPull(cacheDir);
+    if (!ok) {
+        spinner.fail('Falha ao atualizar cache.');
+        log.error(stderr.trim() || 'Verifique sua conexão.');
+        safeExit(1);
+    }
+    spinner.succeed('Repositório atualizado.');
+    // Re-copia skills instaladas como cópia (symlinks já apontam pro cache atualizado)
+    const claudeDir = getClaudeSkillsDir();
+    const skills = await listAvailableSkills();
+    let recoped = 0;
+    for (const skill of skills) {
+        if (!skill.installed)
+            continue;
+        const destPath = path.join(claudeDir, skill.name);
+        const isLink = fs.existsSync(destPath) && fs.lstatSync(destPath).isSymbolicLink();
+        if (isLink)
+            continue; // symlink aponta pro cache — já atualizado pelo git pull
+        const srcPath = path.join(getSkillsSourceDir(), skill.name);
+        await removeDir(destPath);
+        await copyDirRecursive(srcPath, destPath);
+        console.log(`  ${chalk.yellow('↑')} ${chalk.bold(skill.name)} — re-copiado`);
+        recoped++;
+    }
+    if (recoped === 0) {
+        log.success('Skills atualizadas via cache (symlinks).');
+    }
+    else {
+        log.success(`${recoped} skill(s) re-copiada(s).`);
+    }
+    log.dim('  Reinicie o Claude Code se novas skills foram adicionadas.');
+}
+// ─── neetru archiveskills list ────────────────────────────────────────────
+export async function runSkillsList() {
+    const hasCache = await dirExists(getSkillsSourceDir());
+    if (!hasCache) {
+        log.warn('Sem cache local. Rode: neetru archive skills install');
+        return;
+    }
+    const skills = await listAvailableSkills();
+    if (skills.length === 0) {
+        log.warn('Nenhuma skill encontrada no cache.');
+        return;
+    }
+    console.log();
+    log.heading('Skills do ecossistema Neetru');
+    console.log();
+    const col1 = Math.max(6, ...skills.map((s) => s.name.length)) + 2;
+    const col2 = Math.max(7, ...skills.map((s) => s.version.length)) + 2;
+    console.log(`  ${chalk.dim('NOME'.padEnd(col1))}${chalk.dim('VERSÃO'.padEnd(col2))}${chalk.dim('STATUS'.padEnd(13))}${chalk.dim('DESCRIÇÃO')}`);
+    console.log(`  ${chalk.dim('─'.repeat(col1 + col2 + 40))}`);
+    for (const skill of skills) {
+        const statusLabel = skill.installed ? chalk.green('instalada') : chalk.dim('disponível');
+        const name = chalk.bold(skill.name.padEnd(col1));
+        const version = chalk.dim(skill.version.padEnd(col2));
+        const desc = chalk.dim(skill.description);
+        console.log(`  ${name}${version}${statusLabel.padEnd(13)}  ${desc}`);
+    }
+    console.log();
+}
+// ─── neetru archiveskills uninstall ───────────────────────────────────────
+export async function runSkillsUninstall(opts = {}) {
+    const claudeDir = getClaudeSkillsDir();
+    const skills = await listAvailableSkills();
+    const installed = skills.filter((s) => s.installed);
+    if (installed.length === 0) {
+        log.info('Nenhuma skill Neetru instalada.');
+        return;
+    }
+    console.log();
+    log.heading('Skills a remover');
+    for (const s of installed) {
+        console.log(`  ${chalk.red('·')} ${chalk.bold(s.name)}`);
+        console.log(`    ${chalk.dim(path.join(claudeDir, s.name))}`);
+    }
+    console.log();
+    if (!opts.yes) {
+        const { confirm } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'confirm',
+                message: `Remover ${installed.length} skill(s) de ${chalk.dim('~/.claude/skills/')}?`,
+                default: false,
+            },
+        ]);
+        if (!confirm) {
+            log.dim('Operação cancelada.');
+            return;
+        }
+    }
+    for (const skill of installed) {
+        const destPath = path.join(claudeDir, skill.name);
+        await removeDir(destPath);
+        console.log(`  ${chalk.red('✗')} ${chalk.bold(skill.name)} removido`);
+    }
+    console.log();
+    log.success('Skills removidas. Reinicie o Claude Code.');
+}
+// ─── neetru archivesdk init ───────────────────────────────────────────────
+export async function runSdkInit() {
+    const cwd = process.cwd();
+    const pkgJsonPath = path.join(cwd, 'package.json');
+    const hasPkgJson = await pathExists(pkgJsonPath);
+    if (!hasPkgJson) {
+        log.warn('Nenhum package.json no diretório atual.');
+        const { create } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'create',
+                message: 'Criar package.json básico aqui?',
+                default: true,
+            },
+        ]);
+        if (!create) {
+            log.dim('Cancellado. Navegue pro diretório do projeto primeiro.');
+            return;
+        }
+        const pkgContent = JSON.stringify({
+            name: path.basename(cwd).toLowerCase().replace(/[^a-z0-9-]/g, '-'),
+            version: '0.1.0',
+            type: 'module',
+            scripts: { dev: 'tsx src/index.ts' },
+            dependencies: {},
+        }, null, 2);
+        await fsp.writeFile(pkgJsonPath, pkgContent, 'utf8');
+        log.success('package.json criado.');
+    }
+    // Verifica se SDK já está presente
+    const pkgRaw = await fsp.readFile(pkgJsonPath, 'utf8');
+    const pkg = JSON.parse(pkgRaw);
+    const alreadyInstalled = pkg.dependencies?.[SDK_PACKAGE] ?? pkg.devDependencies?.[SDK_PACKAGE];
+    if (alreadyInstalled) {
+        log.info(`${SDK_PACKAGE} já presente: ${chalk.cyan(alreadyInstalled)}`);
+    }
+    else {
+        const spinner = ora({ text: `Instalando ${SDK_PACKAGE}@${SDK_VERSION}…`, color: 'cyan' }).start();
+        const r = spawnSync('npm', ['install', `${SDK_PACKAGE}@${SDK_VERSION}`], {
+            cwd,
+            encoding: 'utf8',
+        });
+        if (r.status !== 0) {
+            spinner.fail('Falha ao instalar @neetru/sdk.');
+            log.error((r.stderr ?? '').trim() || 'Verifique sua conexão com o npm.');
+            safeExit(1);
+        }
+        spinner.succeed(`${SDK_PACKAGE}@${SDK_VERSION} instalado.`);
+    }
+    // Cria boilerplate src/neetru.ts
+    const srcDir = path.join(cwd, 'src');
+    await ensureDir(srcDir);
+    const boilerplatePath = path.join(srcDir, 'neetru.ts');
+    const exists = await pathExists(boilerplatePath);
+    if (!exists) {
+        const boilerplate = [
+            '/**',
+            ' * neetru.ts — ponto de entrada do @neetru/sdk.',
+            ' *',
+            ' * Gerado por: neetru archive sdk init',
+            ' *',
+            " * Substitua os valores pelas suas variáveis de ambiente.",
+            " * Em modo dev (NEETRU_ENV=dev) o SDK usa mocks in-memory automaticamente.",
+            ' */',
+            "import { createNeetruClient } from '@neetru/sdk';",
+            '',
+            'export const neetru = createNeetruClient({',
+            "  apiKey: process.env.NEETRU_API_KEY ?? '',",
+            "  env: (process.env.NEETRU_ENV as 'dev' | 'prod') ?? 'dev',",
+            '});',
+            '',
+            '// Exemplos de uso:',
+            '//',
+            '// const user = await neetru.auth.signIn({ email, password });',
+            '// const catalog = await neetru.catalog.list();',
+            '// const ok = await neetru.entitlements.check({ tenantId, feature: \'export\' });',
+            '// await neetru.telemetry.track({ event: \'user.signed_in\', tenantId });',
+            '',
+        ].join('\n');
+        await fsp.writeFile(boilerplatePath, boilerplate, 'utf8');
+        log.success(`Boilerplate criado: ${chalk.cyan('src/neetru.ts')}`);
+    }
+    else {
+        log.info('src/neetru.ts já existe — não sobrescrito.');
+    }
+    console.log();
+    log.heading('Próximos passos');
+    console.log(`  ${chalk.dim('1.')} Adicione ao .env.local:`);
+    console.log(`     ${chalk.cyan('NEETRU_API_KEY=nrt_<keyId>_<secret>')}`);
+    console.log(`     ${chalk.cyan('NEETRU_ENV=dev')}`);
+    console.log(`  ${chalk.dim('2.')} Importe onde precisar:`);
+    console.log(`     ${chalk.cyan("import { neetru } from './src/neetru'")}`);
+    console.log(`  ${chalk.dim('3.')} Docs: ${chalk.cyan('https://github.com/Neetru/neetru-sdk')}`);
+    console.log();
+}
+// ─── neetru archivesdk templates ──────────────────────────────────────────
+export async function runSdkTemplates() {
+    const { fileURLToPath } = await import('node:url');
+    const { dirname, resolve } = await import('node:path');
+    const __fname = fileURLToPath(import.meta.url);
+    const __dir = dirname(__fname);
+    // Em dev (tsx): src/commands/ → ../templates
+    // Em prod (dist/): dist/commands/ → ../templates (não existe ali) → ../templates
+    const templatesDir = resolve(__dir, '..', 'templates');
+    const hasTemplates = await dirExists(templatesDir);
+    if (!hasTemplates) {
+        log.warn(`Diretório de templates não encontrado em: ${templatesDir}`);
+        return;
+    }
+    const entries = await fsp.readdir(templatesDir, { withFileTypes: true });
+    const templates = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+    if (templates.length === 0) {
+        log.warn('Nenhum template disponível.');
+        return;
+    }
+    console.log();
+    log.heading('Templates SDK disponíveis');
+    for (const tmpl of templates) {
+        console.log(`  ${chalk.cyan('·')} ${chalk.bold(tmpl)}`);
+        console.log(`    ${chalk.dim(`neetru archive sdk add ${tmpl}`)}`);
+    }
+    console.log();
+}
+// ─── neetru archivesdk add <template> ─────────────────────────────────────
+/**
+ * HIGH-4: templates permitidos são os que existem no diretório canônico.
+ * Lista estática reflete o conteúdo de /templates — atualizar quando novos
+ * templates forem adicionados ao pacote.
+ */
+const ALLOWED_SDK_TEMPLATES = ['auth', 'billing', 'support', 'usage', 'users'];
+export async function runSdkAddTemplate(template, opts = {}) {
+    // HIGH-4: rejeita nomes fora da whitelist antes de resolver qualquer path.
+    // Impede path traversal (ex: "../../etc/passwd") e templates não-canônicos.
+    if (!ALLOWED_SDK_TEMPLATES.includes(template)) {
+        log.error(`Template "${template}" não reconhecido.`);
+        log.dim(`  Disponíveis: ${ALLOWED_SDK_TEMPLATES.join(', ')}`);
+        safeExit(1);
+        return;
+    }
+    const { fileURLToPath } = await import('node:url');
+    const { dirname, resolve, sep } = await import('node:path');
+    const __fname = fileURLToPath(import.meta.url);
+    const __dir = dirname(__fname);
+    const templatesDir = resolve(__dir, '..', 'templates');
+    // Defesa em profundidade: mesmo com whitelist, verifica que o path resolvido
+    // fica dentro de templatesDir (não pode sair por symlink ou encoding estranho).
+    const srcTemplate = resolve(templatesDir, template);
+    if (!srcTemplate.startsWith(resolve(templatesDir) + sep)) {
+        log.error('Caminho do template inválido.');
+        safeExit(1);
+        return;
+    }
+    if (!(await dirExists(srcTemplate))) {
+        log.error(`Template "${template}" não encontrado.`);
+        log.dim('  → Templates disponíveis: neetru archive sdk templates');
+        safeExit(1);
+    }
+    const cwd = process.cwd();
+    const destDir = path.join(cwd, 'src');
+    await ensureDir(destDir);
+    const entries = await fsp.readdir(srcTemplate, { withFileTypes: true });
+    let copied = 0;
+    for (const entry of entries) {
+        if (!entry.isFile())
+            continue;
+        const destPath = path.join(destDir, entry.name);
+        if (!opts.force && (await pathExists(destPath))) {
+            log.warn(`${entry.name} já existe — pulado (use --force para sobrescrever).`);
+            continue;
+        }
+        await fsp.copyFile(path.join(srcTemplate, entry.name), destPath);
+        console.log(`  ${chalk.green('✓')} src/${entry.name}`);
+        copied++;
+    }
+    if (copied > 0) {
+        log.success(`Template "${template}" adicionado ao projeto.`);
+    }
+    else {
+        log.info('Nenhum arquivo novo copiado (todos já existiam).');
+    }
+}
+// ─── neetru archivebrowse ─────────────────────────────────────────────────
+export async function runArchiveBrowse() {
+    const opener = resolveOpener();
+    if (!opener) {
+        log.info(`Acesse manualmente: ${chalk.cyan(LIBS_REPO_HTTPS)}`);
+        return;
+    }
+    const spinner = ora({ text: 'Abrindo browser…', color: 'cyan' }).start();
+    const r = spawnSync(opener, [LIBS_REPO_HTTPS], { stdio: 'ignore' });
+    if (r.status === 0 || r.status === null) {
+        spinner.succeed(`Aberto: ${chalk.cyan(LIBS_REPO_HTTPS)}`);
+    }
+    else {
+        spinner.stop();
+        log.info(`Acesse: ${chalk.cyan(LIBS_REPO_HTTPS)}`);
+    }
+}
+function resolveOpener() {
+    if (isWindows())
+        return 'explorer';
+    if (process.platform === 'darwin')
+        return 'open';
+    // Linux
+    const r = spawnSync('which', ['xdg-open'], { encoding: 'utf8', stdio: 'pipe' });
+    if (r.status === 0)
+        return 'xdg-open';
+    return null;
+}
+//# sourceMappingURL=archive.js.map