@planu/cli 4.14.1 → 5.1.1

package/scripts/lib/pending-release-file.mjs

@@ -0,0 +1,93 @@
+import { mkdir, readFile, rename, rm, stat, writeFile } from 'node:fs/promises';
+
+const DEFAULT_TIMEOUT_MS = 5_000;
+const POLL_INTERVAL_MS = 10;
+const ABANDONED_LOCK_MS = 30_000;
+
+function delay(milliseconds) {
+  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error?.code !== 'ESRCH';
+  }
+}
+
+async function removeAbandonedLock(lockPath) {
+  try {
+    const owner = JSON.parse(await readFile(`${lockPath}/owner.json`, 'utf8'));
+    if (Number.isInteger(owner.pid) && owner.pid > 0 && !isProcessAlive(owner.pid)) {
+      await rm(lockPath, { recursive: true, force: true });
+      return true;
+    }
+  } catch {
+    try {
+      const lockStat = await stat(lockPath);
+      if (Date.now() - lockStat.mtimeMs > ABANDONED_LOCK_MS) {
+        await rm(lockPath, { recursive: true, force: true });
+        return true;
+      }
+    } catch {
+      return true;
+    }
+  }
+  return false;
+}
+
+async function acquireLock(pendingPath, { timeoutMs, signal }) {
+  const lockPath = `${pendingPath}.lock`;
+  const deadline = Date.now() + timeoutMs;
+  while (true) {
+    if (signal?.aborted) throw new Error('pending release lock acquisition aborted');
+    try {
+      await mkdir(lockPath);
+      await writeFile(
+        `${lockPath}/owner.json`,
+        `${JSON.stringify({ pid: process.pid, createdAt: new Date().toISOString() })}\n`,
+        { flag: 'wx', mode: 0o600 },
+      );
+      return lockPath;
+    } catch (error) {
+      if (error?.code !== 'EEXIST') {
+        await rm(lockPath, { recursive: true, force: true });
+        throw error;
+      }
+      if (await removeAbandonedLock(lockPath)) continue;
+      if (Date.now() >= deadline) {
+        throw new Error(`timed out waiting for pending release lock: ${lockPath}`);
+      }
+      await delay(POLL_INTERVAL_MS);
+    }
+  }
+}
+
+export async function withPendingReleaseLock(pendingPath, options, task) {
+  const lockPath = await acquireLock(pendingPath, {
+    timeoutMs: options?.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+    signal: options?.signal,
+  });
+  try {
+    return await task();
+  } finally {
+    await rm(lockPath, { recursive: true, force: true });
+  }
+}
+
+export async function writePendingReleaseLedger(pendingPath, entries) {
+  const temporaryPath = `${pendingPath}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    await writeFile(temporaryPath, `${JSON.stringify(entries, null, 2)}\n`, {
+      encoding: 'utf8',
+      flag: 'wx',
+      mode: 0o644,
+    });
+    await rename(temporaryPath, pendingPath);
+  } catch (error) {
+    await rm(temporaryPath, { force: true });
+    throw error;
+  }
+}

package/src/i18n/messages/en.json

@@ -346,45 +346,6 @@
       "actionFailed": "{action} failed: {details}",
       "error": "Manage trash failed: {message}"
     },
-    "activate_license": {
-      "description": "Activate or deactivate a Planu Pro license key to unlock all tools and increased limits.",
-      "keyRequired": "Error: licenseKey is required.",
-      "activationFailed": "License activation failed: {error}",
-      "activatedSuccess": "License activated successfully!",
-      "plan": "Plan: {tier}",
-      "customer": "Customer: {name}",
-      "instance": "Instance: {name}",
-      "proAccess": "You now have access to all 65 Planu tools and increased limits.",
-      "tierAccess": "You now have {tier} access with all tools and unlimited projects/specs.",
-      "commonCauses": "Common causes:",
-      "causeInvalidKey": "Invalid license key — check for typos",
-      "causeAlreadyActivated": "License already activated on another machine — deactivate first",
-      "causeNetwork": "Network issue — check your internet connection",
-      "deactivationCancelled": "Deactivation cancelled. Set confirm: true to proceed.",
-      "noActiveLicense": "No active license found. You are on the Free plan.",
-      "deactivatedSuccess": "License deactivated successfully.",
-      "deactivatedFreePlan": "You are now on the Free plan ({count} tools, 2 projects, 5 active specs).",
-      "keyReusable": "Your license key can be activated on another machine."
-    },
-    "license_status": {
-      "description": "Check your current license status, tier, limits, and available tools.",
-      "title": "Planu License Status",
-      "version": "Version:",
-      "plan": "Plan:",
-      "customer": "Customer:",
-      "variant": "Variant:",
-      "activated": "Activated:",
-      "lastValidated": "Last validated:",
-      "toolsAvailable": "Tools available:",
-      "limitsTitle": "Limits",
-      "projects": "Projects:",
-      "activeSpecs": "Active specs:",
-      "perProject": "per project",
-      "activationSlots": "Activation slots:",
-      "upgradeTitle": "Upgrade",
-      "upgradeMessage": "Unlock all {count} tools, 10 projects, and unlimited specs.",
-      "activateHint": "Already have a key? Use `activate_license` to activate it."
-    },
     "spec_templates": {
       "description": "List and browse available spec templates — filter by category, complexity, or tags.",
       "listTitle": "Available Spec Templates",
@@ -502,8 +463,6 @@
       "approvedChanges": "Approved Changes",
       "pendingChanges": "Pending Changes",
       "versionCreated": "Version Created",
-      "changelogUpdated": "Changelog Updated",
-      "yes": "Yes",
       "livingSpec": "Living Spec",
       "coverage": "coverage",
       "nextValidate": "Run `validate` to check implementation coverage",

package/src/i18n/messages/es.json

@@ -346,45 +346,6 @@
       "actionFailed": "{action} falló: {details}",
       "error": "Error al gestionar papelera: {message}"
     },
-    "activate_license": {
-      "description": "Activar o desactivar una clave de licencia Planu Pro para desbloquear todas las herramientas y límites aumentados.",
-      "keyRequired": "Error: licenseKey es requerido.",
-      "activationFailed": "Error al activar licencia: {error}",
-      "activatedSuccess": "¡Licencia activada exitosamente!",
-      "plan": "Plan: {tier}",
-      "customer": "Cliente: {name}",
-      "instance": "Instancia: {name}",
-      "proAccess": "Ahora tienes acceso a las 65 herramientas de Planu y límites aumentados.",
-      "tierAccess": "Ahora tienes acceso {tier} con todas las herramientas y proyectos/specs ilimitados.",
-      "commonCauses": "Causas comunes:",
-      "causeInvalidKey": "Clave de licencia inválida — verifica errores de tipeo",
-      "causeAlreadyActivated": "Licencia ya activada en otra máquina — desactívala primero",
-      "causeNetwork": "Problema de red — verifica tu conexión a internet",
-      "deactivationCancelled": "Desactivación cancelada. Establece confirm: true para proceder.",
-      "noActiveLicense": "No se encontró licencia activa. Estás en el plan Free.",
-      "deactivatedSuccess": "Licencia desactivada exitosamente.",
-      "deactivatedFreePlan": "Ahora estás en el plan Free ({count} herramientas, 2 proyectos, 5 specs activas).",
-      "keyReusable": "Tu clave de licencia puede ser activada en otra máquina."
-    },
-    "license_status": {
-      "description": "Verificar el estado actual de tu licencia, tier, límites y herramientas disponibles.",
-      "title": "Estado de Licencia Planu",
-      "version": "Versión:",
-      "plan": "Plan:",
-      "customer": "Cliente:",
-      "variant": "Variante:",
-      "activated": "Activada:",
-      "lastValidated": "Última validación:",
-      "toolsAvailable": "Herramientas disponibles:",
-      "limitsTitle": "Límites",
-      "projects": "Proyectos:",
-      "activeSpecs": "Specs activas:",
-      "perProject": "por proyecto",
-      "activationSlots": "Slots de activación:",
-      "upgradeTitle": "Upgrade",
-      "upgradeMessage": "Desbloquea las {count} herramientas, 10 proyectos y specs ilimitadas.",
-      "activateHint": "¿Ya tienes una clave? Usa `activate_license` para activarla."
-    },
     "spec_templates": {
       "description": "Listar y explorar plantillas de specs disponibles — filtrar por categoría, complejidad o tags.",
       "listTitle": "Plantillas de Specs Disponibles",
@@ -502,8 +463,6 @@
       "approvedChanges": "Cambios Aprobados",
       "pendingChanges": "Cambios Pendientes",
       "versionCreated": "Versión Creada",
-      "changelogUpdated": "Changelog Actualizado",
-      "yes": "Sí",
       "livingSpec": "Spec Viva",
       "coverage": "cobertura",
       "nextValidate": "Ejecuta `validate` para verificar la cobertura de implementación",

package/src/i18n/messages/pt.json

@@ -346,45 +346,6 @@
       "actionFailed": "{action} falhou: {details}",
       "error": "Erro ao gerenciar lixeira: {message}"
     },
-    "activate_license": {
-      "description": "Ativar ou desativar uma chave de licença Planu Pro para desbloquear todas as ferramentas e limites aumentados.",
-      "keyRequired": "Erro: licenseKey é obrigatório.",
-      "activationFailed": "Falha na ativação da licença: {error}",
-      "activatedSuccess": "Licença ativada com sucesso!",
-      "plan": "Plano: {tier}",
-      "customer": "Cliente: {name}",
-      "instance": "Instância: {name}",
-      "proAccess": "Agora você tem acesso a todas as 65 ferramentas do Planu e limites aumentados.",
-      "tierAccess": "Agora você tem acesso {tier} com todas as ferramentas e projetos/specs ilimitados.",
-      "commonCauses": "Causas comuns:",
-      "causeInvalidKey": "Chave de licença inválida — verifique erros de digitação",
-      "causeAlreadyActivated": "Licença já ativada em outra máquina — desative primeiro",
-      "causeNetwork": "Problema de rede — verifique sua conexão com a internet",
-      "deactivationCancelled": "Desativação cancelada. Defina confirm: true para prosseguir.",
-      "noActiveLicense": "Nenhuma licença ativa encontrada. Você está no plano Free.",
-      "deactivatedSuccess": "Licença desativada com sucesso.",
-      "deactivatedFreePlan": "Agora você está no plano Free ({count} ferramentas, 2 projetos, 5 specs ativas).",
-      "keyReusable": "Sua chave de licença pode ser ativada em outra máquina."
-    },
-    "license_status": {
-      "description": "Verificar o status atual da sua licença, tier, limites e ferramentas disponíveis.",
-      "title": "Status da Licença Planu",
-      "version": "Versão:",
-      "plan": "Plano:",
-      "customer": "Cliente:",
-      "variant": "Variante:",
-      "activated": "Ativada:",
-      "lastValidated": "Última validação:",
-      "toolsAvailable": "Ferramentas disponíveis:",
-      "limitsTitle": "Limites",
-      "projects": "Projetos:",
-      "activeSpecs": "Specs ativas:",
-      "perProject": "por projeto",
-      "activationSlots": "Slots de ativação:",
-      "upgradeTitle": "Upgrade",
-      "upgradeMessage": "Desbloqueie todas as {count} ferramentas, 10 projetos e specs ilimitadas.",
-      "activateHint": "Já tem uma chave? Use `activate_license` para ativá-la."
-    },
     "spec_templates": {
       "description": "Listar e explorar modelos de specs disponíveis — filtrar por categoria, complexidade ou tags.",
       "listTitle": "Modelos de Specs Disponíveis",
@@ -502,8 +463,6 @@
       "approvedChanges": "Mudanças Aprovadas",
       "pendingChanges": "Mudanças Pendentes",
       "versionCreated": "Versão Criada",
-      "changelogUpdated": "Changelog Atualizado",
-      "yes": "Sim",
       "livingSpec": "Spec Viva",
       "coverage": "cobertura",
       "nextValidate": "Execute `validate` para verificar a cobertura da implementação",

package/dist/cli/commands/activate.d.ts

@@ -1,14 +0,0 @@
-import type { CliCommand } from '../../types/cli.js';
-type ToolFormat = 'standard' | 'zed';
-interface ConfigTarget {
-    name: string;
-    path: string;
-    format: ToolFormat;
-}
-declare function buildTargets(): ConfigTarget[];
-declare function hasPlanu(config: unknown, format: ToolFormat): boolean;
-declare function updateStandardToken(filePath: string, licenseKey: string): void;
-declare function updateZedToken(filePath: string, licenseKey: string): void;
-export { buildTargets, hasPlanu, updateStandardToken, updateZedToken };
-export declare const activateCommand: CliCommand;
-//# sourceMappingURL=activate.d.ts.map

package/dist/cli/commands/activate.js

@@ -1,174 +0,0 @@
-// cli/commands/activate.ts — planu activate <key>: add/update license in all installed configs (SPEC-237)
-import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import { bold, green, yellow, dim, cyan } from '../colors.js';
-import { activateLicense } from '../../engine/license-validator.js';
-// ---------------------------------------------------------------------------
-// Constants — same paths as install.ts
-// ---------------------------------------------------------------------------
-const PLANU_KEY = 'planu';
-function buildTargets() {
-    const home = homedir();
-    return [
-        {
-            name: 'Claude Code',
-            path: join(home, '.claude.json'),
-            format: 'standard',
-        },
-        {
-            name: 'Cursor',
-            path: join(home, '.cursor', 'mcp.json'),
-            format: 'standard',
-        },
-        {
-            name: 'Windsurf',
-            path: join(home, '.codeium', 'windsurf', 'mcp_config.json'),
-            format: 'standard',
-        },
-        {
-            name: 'Zed',
-            path: join(home, '.config', 'zed', 'settings.json'),
-            format: 'zed',
-        },
-        {
-            name: 'Cline',
-            path: join(home, '.vscode', 'globalStorage', 'saoudrizwan.claude-dev', 'settings', 'cline_mcp_settings.json'),
-            format: 'standard',
-        },
-        {
-            name: 'Continue',
-            path: join(home, '.continue', 'config.json'),
-            format: 'standard',
-        },
-    ];
-}
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-function readJson(filePath) {
-    if (!existsSync(filePath)) {
-        return null;
-    }
-    const raw = readFileSync(filePath, 'utf-8').trim();
-    if (!raw) {
-        return null;
-    }
-    return JSON.parse(raw);
-}
-function hasPlanu(config, format) {
-    if (format === 'zed') {
-        const zed = config;
-        return Boolean(zed.context_servers?.[PLANU_KEY]);
-    }
-    const std = config;
-    return Boolean(std.mcpServers?.[PLANU_KEY]);
-}
-function updateStandardToken(filePath, licenseKey) {
-    const parsed = readJson(filePath);
-    if (!parsed) {
-        return;
-    }
-    const raw = parsed;
-    const entry = raw.mcpServers?.[PLANU_KEY];
-    if (!entry) {
-        return;
-    }
-    entry.env = { ...(entry.env ?? {}), SDD_OWNER_TOKEN: licenseKey };
-    writeFileSync(filePath, JSON.stringify(raw, null, 2) + '\n', 'utf-8');
-}
-function updateZedToken(filePath, licenseKey) {
-    const parsed = readJson(filePath);
-    if (!parsed) {
-        return;
-    }
-    const raw = parsed;
-    const entry = raw.context_servers?.[PLANU_KEY];
-    if (!entry) {
-        return;
-    }
-    entry.env = { ...(entry.env ?? {}), SDD_OWNER_TOKEN: licenseKey };
-    writeFileSync(filePath, JSON.stringify(raw, null, 2) + '\n', 'utf-8');
-}
-// Exported for tests
-export { buildTargets, hasPlanu, updateStandardToken, updateZedToken };
-// ---------------------------------------------------------------------------
-// Command
-// ---------------------------------------------------------------------------
-export const activateCommand = {
-    name: 'activate',
-    description: 'Activate a Pro license key in all installed Planu configs',
-    usage: 'planu activate <license-key>',
-    async run(args, _flags) {
-        const licenseKey = args[0];
-        if (!licenseKey) {
-            process.stderr.write(`${yellow('!')} Usage: planu activate <license-key>\n` +
-                `Example: planu activate PLN-XXXX-XXXX-XXXX\n`);
-            process.exitCode = 1;
-            return;
-        }
-        process.stdout.write(`\n${bold('Planu License Activation')}\n\n`);
-        process.stdout.write(`${dim('Validating license key...')}\n`);
-        // Validate key via license API
-        let customerEmail;
-        let variantName;
-        try {
-            const result = await activateLicense(licenseKey, 'planu-cli');
-            if (!result.activated) {
-                const errMsg = result.error ?? 'Invalid license key';
-                process.stderr.write(`${yellow('!')} License validation failed: ${errMsg}\n`);
-                process.exitCode = 1;
-                return;
-            }
-            customerEmail = result.meta.customer_email;
-            variantName = result.meta.variant_name;
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            process.stderr.write(`${yellow('!')} License API error: ${msg}\n`);
-            process.exitCode = 1;
-            return;
-        }
-        process.stdout.write(`${green('+')} ${variantName} license — ${customerEmail}\n\n`);
-        process.stdout.write(`${cyan('Updating Planu configs:')}\n`);
-        const targets = buildTargets();
-        let updated = 0;
-        for (const target of targets) {
-            let config;
-            try {
-                config = readJson(target.path);
-            }
-            catch {
-                process.stdout.write(`  ${yellow('!')} ${target.name}: could not read config\n`);
-                continue;
-            }
-            if (config === null || !hasPlanu(config, target.format)) {
-                process.stdout.write(`  ${dim('\u25a1')} ${target.name} — Planu not installed here\n`);
-                continue;
-            }
-            try {
-                if (target.format === 'zed') {
-                    updateZedToken(target.path, licenseKey);
-                }
-                else {
-                    updateStandardToken(target.path, licenseKey);
-                }
-                process.stdout.write(`  ${green('+')} ${target.name} — updated\n`);
-                updated++;
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                process.stdout.write(`  ${yellow('!')} ${target.name}: failed to write — ${msg}\n`);
-            }
-        }
-        process.stdout.write('\n');
-        if (updated === 0) {
-            process.stdout.write(`${yellow('!')} Planu is not installed in any tool. Run ${cyan('planu install')} first.\n\n`);
-            process.exitCode = 1;
-            return;
-        }
-        process.stdout.write(`${green('+')} License activated in ${String(updated)} config(s). ` +
-            `${dim('Restart your AI tools to apply.')}\n\n`);
-    },
-};
-//# sourceMappingURL=activate.js.map