repofence 0.2.0 → 0.2.2

package/dist/cli.js

@@ -119,9 +119,9 @@ program
 // Auth command
 program
     .command('auth')
-    .description('Autentica el CLI con token emitido por la web repofence')
-    .option('--token <token>', 'Token emitido por la web repofence')
-    .option('--web', 'Abrir la web de login/pago y obtener token manualmente')
+    .description('Authenticate the CLI with a token from repofence.com')
+    .option('--token <token>', 'Token from repofence.com (after purchase)')
+    .option('--web', 'Open login/checkout in the browser to get a token')
     .action(async (options) => {
     const cwd = process.cwd();
     try {

package/dist/commands/auth.js

@@ -8,6 +8,7 @@ const chalk_1 = __importDefault(require("chalk"));
 const promises_1 = __importDefault(require("readline/promises"));
 const process_1 = require("process");
 const auth_1 = require("../core/auth");
+const api_client_1 = require("../core/api-client");
 const open_1 = __importDefault(require("open"));
 const promptToken = async () => {
     const rl = promises_1.default.createInterface({ input: process_1.stdin, output: process_1.stdout });
@@ -15,6 +16,7 @@ const promptToken = async () => {
     rl.close();
     return answer;
 };
+const isJwt = (token) => token.split('.').length === 3;
 const authCommand = async (_cwd, options) => {
     if (options.web) {
         const authBase = process.env.REPOFENCE_AUTH_URL || 'https://repofence.com/pricing';
@@ -34,12 +36,30 @@ const authCommand = async (_cwd, options) => {
         console.log(chalk_1.default.dim('─'.repeat(60)) + '\n');
         return;
     }
-    const token = options.token ?? (await promptToken());
-    if (!token) {
-        throw new Error('No se proporcionó token; vuelve a intentarlo con --token <valor>.');
+    const rawToken = options.token ?? (await promptToken());
+    if (!rawToken) {
+        throw new Error('No token provided; try again with --token <value>.');
+    }
+    // Raw license tokens (hex) need to be exchanged for a JWT via /activate.
+    // Already-valid JWTs (e.g. from refresh) are saved directly.
+    if (isJwt(rawToken)) {
+        await (0, auth_1.saveToken)(rawToken);
+        console.log(chalk_1.default.green(`✅ Token saved to ${auth_1.tokenPath}`));
+        return;
+    }
+    process.stdout.write('Activating license...');
+    try {
+        const client = new api_client_1.ApiClient();
+        const { token: jwt } = await client.activateToken(rawToken);
+        await (0, auth_1.saveToken)(jwt);
+        process.stdout.write('\r');
+        console.log(chalk_1.default.green(`✅ License activated and token saved to ${auth_1.tokenPath}`));
+    }
+    catch (error) {
+        process.stdout.write('\r');
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to activate license: ${message}`);
     }
-    await (0, auth_1.saveToken)(token);
-    console.log(chalk_1.default.green(`✅ Token guardado en ${auth_1.tokenPath}`));
 };
 exports.authCommand = authCommand;
 //# sourceMappingURL=auth.js.map

package/dist/commands/init.js

@@ -185,17 +185,17 @@ async function initCommand(cwd, options) {
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
-            console.error(chalk_1.default.red(`❌ Error al descargar pack "${packId}" (${resolvedBase}): ${message}`));
+            console.error(chalk_1.default.red(`❌ Failed to download pack "${packId}" (${resolvedBase}): ${message}`));
             throw error;
         }
         const isValid = await (0, pack_manager_1.validateSignature)(pack);
         if (!isValid) {
-            throw new Error('La firma del pack no es válida.');
+            throw new Error('Invalid pack signature.');
         }
         await (0, pack_manager_1.installPack)(pack, { force, verbose, target: ide }, profile.installBaseDir);
         packInstalled = true;
         if (verbose) {
-            console.log(chalk_1.default.green(`✓ Pack "${pack.packId}" instalado`));
+            console.log(chalk_1.default.green(`✓ Pack "${pack.packId}" installed`));
         }
     }
     else {

package/dist/commands/status.js

@@ -13,13 +13,13 @@ const printManifest = async (target) => {
     const manifest = await (0, pack_manager_1.readManifest)(profile.installBaseDir);
     console.log(chalk_1.default.bold(`\n[${profile.displayName}]`));
     if (!manifest) {
-        console.log(chalk_1.default.yellow(`⚠️  No se encontró manifest de pack en ${(0, pack_manager_1.manifestFilePath)(profile.installBaseDir)}`));
+        console.log(chalk_1.default.yellow(`⚠️  No pack manifest found at ${(0, pack_manager_1.manifestFilePath)(profile.installBaseDir)}`));
         return;
     }
     console.log(chalk_1.default.cyan(`Pack: ${manifest.pack_id} v${manifest.pack_version}`));
-    console.log(chalk_1.default.cyan(`Instalado: ${manifest.installed_at}`));
-    console.log(chalk_1.default.cyan(`Expira: ${manifest.expires_at ?? 'sin expirar'}`));
-    console.log(chalk_1.default.cyan(`Artefactos:`));
+    console.log(chalk_1.default.cyan(`Installed: ${manifest.installed_at}`));
+    console.log(chalk_1.default.cyan(`Expires: ${manifest.expires_at ?? 'never'}`));
+    console.log(chalk_1.default.cyan(`Artifacts:`));
     manifest.commands.forEach((cmd) => console.log(`  - ${cmd}`));
     console.log(chalk_1.default.gray(`Manifest: ${(0, pack_manager_1.manifestFilePath)(profile.installBaseDir)}`));
 };
@@ -28,10 +28,10 @@ const statusCommand = async (cwd, options = {}) => {
     const target = options.ide || 'all';
     const token = await (0, auth_1.readToken)();
     if (token) {
-        console.log(chalk_1.default.green(`✅ Token presente (${auth_1.tokenPath})`));
+        console.log(chalk_1.default.green(`✅ Token present (${auth_1.tokenPath})`));
     }
     else {
-        console.log(chalk_1.default.yellow('⚠️  Token no configurado. Ejecuta `repofence auth --token <valor>`'));
+        console.log(chalk_1.default.yellow('⚠️  No token configured. Run `repofence auth --token <value>`'));
     }
     if (target === 'all') {
         await printManifest('cursor');

package/dist/core/api-client.js

@@ -21,16 +21,16 @@ const DEMO_PACK = {
     files: [
         {
             path: 'repofence-spec.md',
-            contentBase64: Buffer.from('# repofence spec (demo)\n\n_TODO: contenido del pack_\n').toString('base64'),
+            contentBase64: Buffer.from('# repofence spec (demo)\n\n_TODO: pack content_\n').toString('base64'),
         },
         {
             path: 'repofence-plan.md',
-            contentBase64: Buffer.from('# repofence plan (demo)\n\n_TODO: contenido del pack_\n').toString('base64'),
+            contentBase64: Buffer.from('# repofence plan (demo)\n\n_TODO: pack content_\n').toString('base64'),
         },
     ],
 };
 const notImplemented = () => {
-    throw new Error('API client no implementado. Usa REPOFENCE_MOCK=1 para datos dummy.');
+    throw new Error('API client not implemented. Set REPOFENCE_MOCK=1 for dummy data.');
 };
 /**
  * Production hosts expose routes under `/api/v1/...`.
@@ -86,6 +86,15 @@ class ApiClient {
         }
         return json;
     }
+    async activateToken(rawToken) {
+        if (process.env.REPOFENCE_MOCK === '1') {
+            return { token: 'demo-token', license_id: 'lic-demo', packs: ['core'] };
+        }
+        return this.request('/v1/auth/activate', {
+            method: 'POST',
+            body: JSON.stringify({ token: rawToken }),
+        });
+    }
     async loginWithEmail(email) {
         if (process.env.REPOFENCE_MOCK === '1') {
             return { token: 'demo-token', license_id: 'lic-demo', packs: ['core'] };

package/dist/core/auth.js

@@ -16,7 +16,7 @@ exports.tokenPath = tokenFile;
 const saveToken = async (token) => {
     const normalized = token.trim();
     if (!normalized) {
-        throw new Error('Token vacío; provee un token válido.');
+        throw new Error('Empty token; provide a valid token.');
     }
     await ensureDir();
     await promises_1.default.writeFile(tokenFile, normalized, { mode: 0o600 });

package/dist/core/pack-manager.js

@@ -49,7 +49,7 @@ const sha256Base64 = (buf) => crypto_1.default.createHash('sha256').update(buf).
 const downloadBuffer = async (url) => {
     const res = await fetch(url);
     if (!res.ok) {
-        throw new Error(`Descarga fallida (${res.status}) ${res.statusText}`);
+        throw new Error(`Download failed (${res.status}) ${res.statusText}`);
     }
     const arrayBuffer = await res.arrayBuffer();
     return Buffer.from(arrayBuffer);
@@ -137,29 +137,29 @@ const installFromArchive = async (pack, options, baseDir) => {
     const dir = commandsDir(baseDir);
     await promises_1.default.mkdir(dir, { recursive: true });
     const archiveUrl = pack.archiveUrl;
-    // Descargar manifest y recalcular hash (robustez)
+    // Download manifest and recalculate hash (robustness)
     let manifestHashCalculated = undefined;
     if (pack.manifestUrl) {
         const manifestBuf = await downloadBuffer(pack.manifestUrl);
         manifestHashCalculated = sha256Base64(manifestBuf);
         if (pack.manifestHash && pack.manifestHash !== manifestHashCalculated) {
-            throw new Error(`Hash de manifest inválido. Esperado ${pack.manifestHash} obtenido ${manifestHashCalculated}`);
+            throw new Error(`Invalid manifest hash. Expected ${pack.manifestHash}, got ${manifestHashCalculated}`);
         }
     }
     const archiveBuf = await downloadBuffer(archiveUrl);
     if (pack.archiveHash) {
         const hash = sha256Base64(archiveBuf);
         if (hash !== pack.archiveHash) {
-            throw new Error(`Hash de archive inválido. Esperado ${pack.archiveHash} obtenido ${hash}`);
+            throw new Error(`Invalid archive hash. Expected ${pack.archiveHash}, got ${hash}`);
         }
     }
-    // Extraer lista de archivos y luego extraer contenido
+    // List files, then extract archive contents
     const tmpDir = await promises_1.default.mkdtemp(path_1.default.join(os_1.default.tmpdir(), 'repofence-archive-'));
     const archivePath = path_1.default.join(tmpDir, 'pack.tar.gz');
     const extractedPath = path_1.default.join(tmpDir, 'extracted');
     await promises_1.default.mkdir(extractedPath, { recursive: true });
     await promises_1.default.writeFile(archivePath, archiveBuf);
-    // Validación de firma (manifestHash ya viene en el pack; archiveHash validada arriba)
+    // Signature validation (manifestHash from pack; archiveHash validated above)
     await (0, exports.validateSignature)({
         ...pack,
         manifestHash: pack.manifestHash || manifestHashCalculated,
@@ -173,7 +173,7 @@ const installFromArchive = async (pack, options, baseDir) => {
         : await installCursorFromExtracted(extractedPath, pack, baseDir);
     await promises_1.default.rm(tmpDir, { recursive: true, force: true });
     if (options.verbose) {
-        console.log(`[repofence] instalado desde archive ${archiveUrl}`);
+        console.log(`[repofence] installed from archive ${archiveUrl}`);
     }
     return manifest;
 };
@@ -209,7 +209,7 @@ const installClaudeFromExtracted = async (extractedPath, pack, baseDir, options)
         const { skillName, content } = toClaudeSkillMarkdown(rel, sourceMarkdown);
         const targetPath = path_1.default.join(dir, skillName, 'SKILL.md');
         if (!options.force && (await fileExists(targetPath))) {
-            throw new Error(`El skill ya existe: ${targetPath} (usa --force para sobrescribir)`);
+            throw new Error(`Skill already exists: ${targetPath} (use --force to overwrite)`);
         }
         await promises_1.default.mkdir(path_1.default.dirname(targetPath), { recursive: true });
         await promises_1.default.writeFile(targetPath, content, 'utf8');
@@ -227,7 +227,7 @@ const installClaudeFromExtracted = async (extractedPath, pack, baseDir, options)
 };
 const installPack = async (pack, options = {}, baseDir) => {
     const target = options.target || 'cursor';
-    // Si viene archiveUrl, descargar tar.gz y extraer.
+    // If archiveUrl is set, download tar.gz and extract.
     if (pack.archiveUrl) {
         return installFromArchive(pack, options, baseDir);
     }
@@ -240,13 +240,13 @@ const installPack = async (pack, options = {}, baseDir) => {
             const { skillName, content } = toClaudeSkillMarkdown(file.path, source);
             const targetPath = path_1.default.join(dir, skillName, 'SKILL.md');
             if (!options.force && (await fileExists(targetPath))) {
-                throw new Error(`El skill ya existe: ${targetPath} (usa --force para sobrescribir)`);
+                throw new Error(`Skill already exists: ${targetPath} (use --force to overwrite)`);
             }
             await promises_1.default.mkdir(path_1.default.dirname(targetPath), { recursive: true });
             await promises_1.default.writeFile(targetPath, content, 'utf8');
             artifacts.push(path_1.default.relative(dir, targetPath));
             if (options.verbose) {
-                console.log(`[repofence] skill escrito ${targetPath}`);
+                console.log(`[repofence] wrote skill ${targetPath}`);
             }
         }
         const manifest = {
@@ -262,13 +262,13 @@ const installPack = async (pack, options = {}, baseDir) => {
     for (const file of pack.files) {
         const target = path_1.default.join(dir, file.path);
         if (!options.force && (await fileExists(target))) {
-            throw new Error(`El archivo ya existe: ${target} (usa --force para sobrescribir)`);
+            throw new Error(`File already exists: ${target} (use --force to overwrite)`);
         }
         await promises_1.default.mkdir(path_1.default.dirname(target), { recursive: true });
         const buffer = Buffer.from(file.contentBase64, 'base64');
         await promises_1.default.writeFile(target, buffer);
         if (options.verbose) {
-            console.log(`[repofence] escrito ${target}`);
+            console.log(`[repofence] wrote ${target}`);
         }
     }
     const manifest = {
@@ -286,11 +286,11 @@ const manifestFilePath = (baseDir) => manifestPath(baseDir);
 exports.manifestFilePath = manifestFilePath;
 const validateSignature = async (_pack) => {
     const pack = _pack;
-    // Si no hay firma ni hashes, no validamos (modo demo/mock).
+    // If there is no signature or hashes, skip validation (demo/mock mode).
     if (!pack.signature || !pack.manifestHash) {
         return true;
     }
-    // Construir payload igual que en backend: manifestHash[:archiveHash]
+    // Build payload same as backend: manifestHash[:archiveHash]
     const payloadToVerify = pack.archiveHash
         ? `${pack.manifestHash}:${pack.archiveHash}`
         : pack.manifestHash;
@@ -302,12 +302,12 @@ const validateSignature = async (_pack) => {
         const keyObject = crypto_1.default.createPublicKey(publicKeyPem);
         const isValid = crypto_1.default.verify(null, Buffer.from(payloadToVerify), keyObject, Buffer.from(pack.signature, 'base64'));
         if (!isValid) {
-            throw new Error('Firma de pack inválida.');
+            throw new Error('Invalid pack signature.');
         }
         return true;
     }
     catch (error) {
-        const msg = error instanceof Error ? error.message : 'error_validando_firma';
+        const msg = error instanceof Error ? error.message : 'signature_validation_error';
         throw new Error(msg);
     }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "repofence",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Repofence CLI (packs + backend auth)",
   "main": "dist/cli.js",
   "bin": {
@@ -33,10 +33,12 @@
   "dependencies": {
     "@aws-sdk/client-s3": "^3.705.0",
     "@aws-sdk/s3-request-presigner": "^3.705.0",
+    "@supabase/supabase-js": "^2.103.0",
     "chalk": "^4.1.2",
     "commander": "^11.1.0",
     "dotenv": "^16.4.5",
     "open": "^11.0.0",
+    "resend": "^6.10.0",
     "tar": "^6.2.1"
   },
   "devDependencies": {