@planu/cli 4.14.1 → 5.1.1

package/dist/tools/license-gate.js

@@ -1,222 +0,0 @@
-// tools/license-gate.ts — Runtime license enforcement for MCP tool handlers.
-// Provides getCurrentTier() with in-memory cache and withLicenseGate() wrapper.
-import { createHash } from 'node:crypto';
-import { licenseStore } from '../storage/index.js';
-import * as usageStore from '../storage/usage-store.js';
-import { resolveCurrentTier, checkToolAccess, isValidationFresh, isInGracePeriod, validateLicense, computeMachineFingerprint, isOpenAccessActive, } from '../engine/license-validator.js';
-import { evaluateRateLimit, isTrialActive, trialDaysRemaining, recordUsageEvent, } from '../engine/usage-tracker/index.js';
-import { getSessionContext } from '../transports/session-context.js';
-// ---------------------------------------------------------------------------
-// Owner token override (SHA-256 verified, not reversible)
-// ---------------------------------------------------------------------------
-// Salt prefix for owner token hashing (v1). New token hashes must be generated
-// as: sha256(HASH_SALT + token). To regenerate OWNER_TOKEN_HASH run:
-//   node -e "const{createHash}=require('crypto');console.log(createHash('sha256').update('planu-owner-v1'+process.argv[1]).digest('hex'))" <token>
-const HASH_SALT = 'planu-owner-v1';
-// Hash generated without salt (legacy). Kept for migration: if you rotate the
-// owner token, generate a new salted hash and replace OWNER_TOKEN_HASH_V1.
-const OWNER_TOKEN_HASH = '9f9e8410fd0a718540fe1e29f7beaa2506b539c8732915d8eddcb3bcff9b9465';
-function checkOwnerOverride() {
-    const token = process.env.SDD_OWNER_TOKEN;
-    if (!token) {
-        return null;
-    }
-    const trimmed = token.trim();
-    // Try salted hash first (current scheme).
-    const saltedHash = createHash('sha256')
-        .update(HASH_SALT + trimmed)
-        .digest('hex');
-    if (saltedHash === OWNER_TOKEN_HASH) {
-        return 'enterprise';
-    }
-    // Fall back to legacy unsalted hash so existing tokens keep working.
-    // DEPRECATED: regenerate OWNER_TOKEN_HASH with salt when rotating the token.
-    const legacyHash = createHash('sha256').update(trimmed).digest('hex');
-    return legacyHash === OWNER_TOKEN_HASH ? 'enterprise' : null;
-}
-// ---------------------------------------------------------------------------
-// In-memory tier cache (avoids disk read on every tool call)
-// ---------------------------------------------------------------------------
-const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
-let cachedTier = null;
-let cacheTimestamp = 0;
-export async function getCurrentTier() {
-    // Per-session license key (hosted multi-tenant mode via HTTP transport)
-    const sessionCtx = getSessionContext();
-    if (sessionCtx?.licenseKey) {
-        return resolveSessionTier(sessionCtx.licenseKey);
-    }
-    const now = Date.now();
-    if (cachedTier !== null && now - cacheTimestamp < CACHE_TTL_MS) {
-        return cachedTier;
-    }
-    const ownerTier = checkOwnerOverride();
-    if (ownerTier) {
-        cachedTier = ownerTier;
-        cacheTimestamp = now;
-        return cachedTier;
-    }
-    let state = await licenseStore.getLicenseState();
-    // Synchronous online validation when license is stale (>7 days)
-    if (state && !isValidationFresh(state)) {
-        state = await performOnlineValidation(state);
-    }
-    cachedTier = resolveCurrentTier(state);
-    cacheTimestamp = now;
-    return cachedTier;
-}
-export function invalidateTierCache() {
-    cachedTier = null;
-    cacheTimestamp = 0;
-}
-/**
- * Synchronous tier estimate based on environment variables only — no disk I/O.
- * Used at server startup to set the display name before async validation runs.
- * Returns 'enterprise' for owner token, 'pro' if a license key env var is set, 'free' otherwise.
- */
-export function getTierSync() {
-    if (checkOwnerOverride()) {
-        return 'enterprise';
-    }
-    if (process.env.SDD_LICENSE_KEY?.trim()) {
-        return 'pro';
-    }
-    return 'free';
-}
-// ---------------------------------------------------------------------------
-// Per-session license resolution (hosted multi-tenant mode)
-// ---------------------------------------------------------------------------
-const sessionTierCache = new Map();
-const SESSION_TIER_TTL_MS = 10 * 60 * 1000; // 10 min — longer since online validation is expensive
-const RATE_LIMIT_EXEMPT_TOOLS = new Set([
-    'planu_status',
-    'update_status_batch',
-    'configure_code_graph',
-    'code_graph_status',
-]);
-export function shouldBypassDailyRateLimit(toolName) {
-    return RATE_LIMIT_EXEMPT_TOOLS.has(toolName);
-}
-async function resolveSessionTier(licenseKey) {
-    const now = Date.now();
-    const cached = sessionTierCache.get(licenseKey);
-    if (cached && now < cached.expiresAt) {
-        return cached.tier;
-    }
-    try {
-        const result = await validateLicense(licenseKey, 'hosted');
-        const tier = result.valid ? 'pro' : 'free';
-        sessionTierCache.set(licenseKey, { tier, expiresAt: now + SESSION_TIER_TTL_MS });
-        return tier;
-    }
-    catch {
-        // API unreachable — degrade to free (no grace period for session keys)
-        sessionTierCache.set(licenseKey, { tier: 'free', expiresAt: now + 60_000 }); // retry in 1 min
-        return 'free';
-    }
-}
-// ---------------------------------------------------------------------------
-// License gate wrapper
-// ---------------------------------------------------------------------------
-export function withLicenseGate(toolName, handler) {
-    return async (args, extra) => {
-        const tier = await getCurrentTier();
-        const trialContext = await resolveTrialContext(tier);
-        const check = checkToolAccess(toolName, tier, trialContext);
-        if (!check.allowed) {
-            return { content: [{ type: 'text', text: check.message }], isError: true };
-        }
-        return handler(args, extra);
-    };
-}
-/**
- * Resolves trial activity for free-tier users. Returns empty context for paid tiers
- * (no need to query trial state — they already have full access).
- */
-async function resolveTrialContext(tier) {
-    if (tier !== 'free') {
-        return { trialActive: false, trialDaysRemaining: 0 };
-    }
-    try {
-        const trialState = await usageStore.ensureTrialState();
-        return {
-            trialActive: isTrialActive(trialState.firstRunAt),
-            trialDaysRemaining: trialDaysRemaining(trialState.firstRunAt),
-        };
-    }
-    catch {
-        return { trialActive: false, trialDaysRemaining: 0 };
-    }
-}
-// ---------------------------------------------------------------------------
-// Usage tracking wrapper
-// ---------------------------------------------------------------------------
-/**
- * Wraps a handler with rate limiting (free tier only) and usage event recording.
- * For free tier: checks daily limit + cooldown before executing.
- * For all tiers: records a usage event after execution (fire-and-forget).
- */
-export function withUsageTracking(toolName, handler) {
-    return async (args, extra) => {
-        const tier = await getCurrentTier();
-        // During open-access window, skip rate limiting for free tier
-        if (tier === 'free' && !isOpenAccessActive() && !shouldBypassDailyRateLimit(toolName)) {
-            const today = new Date().toISOString().slice(0, 10);
-            const [trialState, callCount, lastCallAt] = await Promise.all([
-                usageStore.ensureTrialState(),
-                usageStore.getDailyCallCount(today),
-                usageStore.getLastCallTimestamp(),
-            ]);
-            const maxCalls = isTrialActive(trialState.firstRunAt) ? 50 : 30;
-            const check = evaluateRateLimit(callCount, maxCalls, lastCallAt, new Date());
-            if (!check.allowed) {
-                return { content: [{ type: 'text', text: check.message }], isError: true };
-            }
-        }
-        // Cast to ToolResult | undefined: TypeScript says ToolResult, but JS runtime may
-        // return undefined if a handler has a missing return path not caught at compile time.
-        // noImplicitReturns in tsconfig prevents new occurrences; this guard handles old ones.
-        const rawResult = (await handler(args, extra));
-        const result = rawResult ?? {
-            content: [{ type: 'text', text: 'Internal error: tool handler returned no result' }],
-            isError: true,
-        };
-        const success = !result.isError;
-        void usageStore
-            .appendUsageEvent(recordUsageEvent(toolName, tier, success))
-            .catch((err) => {
-            console.error('[planu] appendUsageEvent failed:', err);
-        });
-        return result;
-    };
-}
-// ---------------------------------------------------------------------------
-// Synchronous online validation (replaces background fire-and-forget)
-// ---------------------------------------------------------------------------
-async function performOnlineValidation(state) {
-    try {
-        const result = await validateLicense(state.licenseKey, state.instanceId);
-        if (!result.valid) {
-            // License revoked remotely — clear local state
-            await licenseStore.deleteLicenseState();
-            return null;
-        }
-        const refreshed = {
-            ...state,
-            lastValidatedAt: new Date().toISOString(),
-            activationUsage: result.license_key.activation_usage,
-            machineFingerprint: computeMachineFingerprint(),
-        };
-        await licenseStore.saveLicenseState(refreshed);
-        return refreshed;
-    }
-    catch {
-        // API unreachable — allow if within grace period (TTL + 3 days)
-        if (isInGracePeriod(state)) {
-            return state;
-        }
-        // Grace period expired — degrade to free
-        return null;
-    }
-}
-//# sourceMappingURL=license-gate.js.map

package/dist/tools/license-status.d.ts

@@ -1,3 +0,0 @@
-import type { LicenseStatusInput, ToolResult } from '../types/index.js';
-export declare function handleLicenseStatus(_args: LicenseStatusInput): Promise<ToolResult>;
-//# sourceMappingURL=license-status.d.ts.map

package/dist/tools/license-status.js

@@ -1,93 +0,0 @@
-// tools/license-status.ts — Handler for license_status MCP tool.
-// Shows current tier, limits, usage, and upgrade URL.
-import { licenseStore } from '../storage/index.js';
-import { getTierLimits, loadLicensePlans } from '../engine/license-validator.js';
-import { getCurrentTier } from './license-gate.js';
-import { readFileSync } from 'node:fs';
-import { join, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-function getVersion() {
-    try {
-        const dir = dirname(fileURLToPath(import.meta.url));
-        const pkg = JSON.parse(readFileSync(join(dir, '../../package.json'), 'utf-8'));
-        return pkg.version;
-    }
-    catch {
-        return 'unknown';
-    }
-}
-export async function handleLicenseStatus(_args) {
-    const [state, tier] = await Promise.all([licenseStore.getLicenseState(), getCurrentTier()]);
-    const limits = getTierLimits(tier);
-    const config = loadLicensePlans();
-    const projectCount = await licenseStore.countActiveProjects();
-    const lines = [];
-    lines.push(`## Planu License Status`);
-    lines.push('');
-    const tierLabel = tier.charAt(0).toUpperCase() + tier.slice(1);
-    const totalTools = config.freeTools.length + config.proTools.length + config.alwaysAllowed.length;
-    lines.push(`**Version:** ${getVersion()}`);
-    lines.push(`**Plan:** ${tierLabel}`);
-    if (state?.customerName) {
-        lines.push(`**Customer:** ${state.customerName} (${state.customerEmail})`);
-        lines.push(`**Variant:** ${state.variantName}`);
-        lines.push(`**Activated:** ${state.activatedAt}`);
-        lines.push(`**Last validated:** ${state.lastValidatedAt}`);
-    }
-    if (tier === 'free') {
-        const freeAvailable = config.freeTools.length + config.alwaysAllowed.length;
-        lines.push(`**Tools available:** ${String(freeAvailable)} of ${String(totalTools)}`);
-    }
-    else {
-        lines.push(`**Tools available:** ${String(totalTools)} of ${String(totalTools)}`);
-    }
-    lines.push('');
-    lines.push('### Limits');
-    lines.push(`- Projects: ${String(projectCount)} / ${limits.maxProjects >= 999999 ? '∞' : String(limits.maxProjects)}`);
-    lines.push(`- Active specs: ${limits.maxActiveSpecs >= 999999 ? '∞' : String(limits.maxActiveSpecs)} per project`);
-    if (state?.customerName && state.activationLimit > 0) {
-        lines.push(`- Activation slots: ${String(state.activationUsage)} / ${String(state.activationLimit)}`);
-    }
-    if (tier === 'free') {
-        lines.push('');
-        lines.push('### Upgrade');
-        lines.push(`Unlock all ${String(totalTools)} tools, 10 projects, and unlimited specs.`);
-        lines.push(`→ ${config.upgradeUrl}`);
-        lines.push('');
-        lines.push('Already have a key? Use `activate_license` to activate it.');
-    }
-    const structured = {
-        version: getVersion(),
-        plan: tierLabel,
-        toolsAvailable: tier === 'free' ? config.freeTools.length + config.alwaysAllowed.length : totalTools,
-        toolsTotal: totalTools,
-        limits: {
-            maxProjects: limits.maxProjects,
-            currentProjects: projectCount,
-            maxActiveSpecs: limits.maxActiveSpecs,
-        },
-    };
-    if (state?.customerName) {
-        structured.customer = {
-            name: state.customerName,
-            email: state.customerEmail,
-            variant: state.variantName,
-            activatedAt: state.activatedAt,
-            lastValidatedAt: state.lastValidatedAt,
-        };
-        if (state.customerName && state.activationLimit > 0) {
-            structured.activationSlots = {
-                used: state.activationUsage,
-                total: state.activationLimit,
-            };
-        }
-    }
-    if (tier === 'free') {
-        structured.upgradeUrl = config.upgradeUrl;
-    }
-    return {
-        content: [{ type: 'text', text: lines.join('\n') }],
-        structuredContent: structured,
-    };
-}
-//# sourceMappingURL=license-status.js.map

package/dist/tools/list-sessions.d.ts

@@ -1,3 +0,0 @@
-import type { ToolResult, ListSessionsInput } from '../types/index.js';
-export declare function handleListSessions(params: ListSessionsInput): Promise<ToolResult>;
-//# sourceMappingURL=list-sessions.d.ts.map

package/dist/tools/list-sessions.js

@@ -1,46 +0,0 @@
-import { hashProjectPath } from '../storage/base-store.js';
-import * as sessionStore from '../storage/session-store.js';
-import { t, ti } from '../i18n/index.js';
-export async function handleListSessions(params) {
-    const projectId = hashProjectPath(params.projectPath);
-    const limit = params.limit ?? 10;
-    try {
-        const items = await sessionStore.listItems(projectId, limit);
-        const lines = [];
-        lines.push(t('tools.response.sessionsTitle'));
-        lines.push('');
-        if (items.length === 0) {
-            lines.push(t('tools.response.noSessions'));
-        }
-        else {
-            lines.push(ti('tools.response.sessionsFound', { count: items.length }));
-            lines.push('');
-            for (const session of items) {
-                lines.push(`- **${session.id}** | created: ${session.startedAt} | saved: ${session.lastSavedAt}`);
-            }
-        }
-        lines.push('');
-        lines.push('🚀 **Next Steps**');
-        lines.push('1. Use `restore_session` to resume a session');
-        lines.push('2. Use `export_session` to save session data');
-        const sessionTips = {
-            naming: 'Name sessions at start: claude -n auth-refactor  |  Or rename during: /rename auth-refactor',
-            resume: 'Resume by name: claude --resume auth-refactor  |  Most recent: claude --continue',
-            fromPr: 'Resume PR session: claude --from-pr 123 (auto-linked when PR created inside Claude Code)',
-            pickerShortcuts: 'In /resume picker: P=preview, R=rename, B=filter by branch, /=search',
-            btw: 'Use /btw for quick side questions — answer appears in overlay, never enters conversation history',
-        };
-        return {
-            content: [{ type: 'text', text: lines.join('\n') }],
-            sessionTips,
-        };
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return {
-            content: [{ type: 'text', text: `Error listing sessions: ${message}` }],
-            isError: true,
-        };
-    }
-}
-//# sourceMappingURL=list-sessions.js.map

package/dist/tools/planu-session-checkpoint.d.ts

@@ -1,6 +0,0 @@
-import type { ToolResult } from '../types/index.js';
-export declare function handlePlanSessionCheckpoint(input: {
-    projectPath?: string;
-    dryRun?: boolean;
-}): Promise<ToolResult>;
-//# sourceMappingURL=planu-session-checkpoint.d.ts.map

package/dist/tools/planu-session-checkpoint.js

@@ -1,42 +0,0 @@
-import { runCheckpoint } from '../engine/session-safeguard/checkpoint-runner.js';
-import { readPlanuConfig } from '../engine/planu-config-writer.js';
-import { readFile } from 'node:fs/promises';
-import { join } from 'node:path';
-const DEFAULT_AUTOPUSH_BRANCHES = ['feat/*', 'fix/*', 'chore/*'];
-function resolveProjectPath(input) {
-    return input ?? process.cwd();
-}
-async function loadProjectConfig(projectPath) {
-    const configPath = join(projectPath, 'planu', 'config.json');
-    const config = await readPlanuConfig(configPath, readFile);
-    return {
-        autopush: config?.autopush ?? false,
-        autopushBranches: config?.autopushBranches ?? DEFAULT_AUTOPUSH_BRANCHES,
-    };
-}
-export async function handlePlanSessionCheckpoint(input) {
-    const projectPath = resolveProjectPath(input.projectPath);
-    const { autopush, autopushBranches } = await loadProjectConfig(projectPath);
-    const result = await runCheckpoint({
-        projectPath,
-        dryRun: input.dryRun ?? false,
-        autopush,
-        autopushBranches,
-    });
-    const lines = [result.humanSummary, ''];
-    if (result.unpushedCommits && result.unpushedCommits.oldestAgeHours >= 2) {
-        const u = result.unpushedCommits;
-        lines.push(`WARNING: ${String(u.count)} commit(s) unpushed for ${String(u.oldestAgeHours)}h on branch ${u.branch}. Run git push or enable autopush.`);
-    }
-    if (result.pushed?.pushed === true) {
-        lines.push(`Pushed ${String(result.pushed.commitsPushed)} commit(s) to ${result.pushed.ref}`);
-    }
-    lines.push('');
-    lines.push(`session-context refreshed: ${String(result.sessionContextRefreshed)}`);
-    lines.push(`learnings flushed: ${String(result.learningsFlushed)}`);
-    lines.push(`unpushed commits: ${String(result.unpushedCommits?.count ?? 0)}`);
-    return {
-        content: [{ type: 'text', text: lines.join('\n').trim() }],
-    };
-}
-//# sourceMappingURL=planu-session-checkpoint.js.map

package/dist/tools/restore-session.d.ts

@@ -1,3 +0,0 @@
-import type { ToolResult, RestoreSessionInput } from '../types/index.js';
-export declare function handleRestoreSession(params: RestoreSessionInput): Promise<ToolResult>;
-//# sourceMappingURL=restore-session.d.ts.map

package/dist/tools/restore-session.js

@@ -1,71 +0,0 @@
-import { hashProjectPath } from '../storage/base-store.js';
-import * as sessionStore from '../storage/session-store.js';
-import { diffSessions, formatDiffSummary } from '../engine/session/session-diff.js';
-import { compactJson } from './output-formatter.js';
-export async function handleRestoreSession(params) {
-    const projectId = hashProjectPath(params.projectPath);
-    // Handle fromPr shortcut — returns the resume command without touching session storage
-    if (params.fromPr !== undefined) {
-        const n = params.fromPr;
-        const result = {
-            resumeCommand: `claude --from-pr ${n}`,
-            description: `Resumes the Claude Code session that created or was linked to PR #${n}`,
-            tip: 'Sessions auto-link when you use gh pr create inside Claude Code',
-        };
-        return { content: [{ type: 'text', text: compactJson(result) }] };
-    }
-    try {
-        let session;
-        if (params.sessionId) {
-            session = await sessionStore.load(projectId, params.sessionId);
-        }
-        else {
-            session = await sessionStore.getLatest(projectId);
-        }
-        if (!session) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: compactJson({
-                            message: 'No sessions found for this project. Start working and sessions will be saved automatically.',
-                            projectId,
-                        }),
-                    },
-                ],
-            };
-        }
-        // Try to compute diff with the second-latest session
-        let diffSummary = '';
-        const allSessions = await sessionStore.list(projectId);
-        if (allSessions.length >= 2) {
-            const previous = allSessions[1];
-            if (previous) {
-                const diff = diffSessions(previous, session);
-                diffSummary = formatDiffSummary(diff);
-            }
-        }
-        const result = {
-            sessionId: session.id,
-            startedAt: session.startedAt,
-            lastSavedAt: session.lastSavedAt,
-            contextSummary: session.contextSummary,
-            activeSpecs: session.activeSpecs,
-            pendingDecisions: session.decisions.slice(-5),
-            toolCallCount: session.toolCallCount,
-            diffSummary: diffSummary || undefined,
-            message: 'Session restored successfully.',
-        };
-        return {
-            content: [{ type: 'text', text: compactJson(result, 60) }],
-        };
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return {
-            content: [{ type: 'text', text: `Error restoring session: ${message}` }],
-            isError: true,
-        };
-    }
-}
-//# sourceMappingURL=restore-session.js.map

package/dist/tools/spec-history.d.ts

@@ -1,3 +0,0 @@
-import type { SpecHistoryInput, ToolResult } from '../types/index.js';
-export declare function handleSpecHistory(params: SpecHistoryInput): Promise<ToolResult>;
-//# sourceMappingURL=spec-history.d.ts.map

package/dist/tools/spec-history.js

@@ -1,59 +0,0 @@
-import { readChangelog } from '../engine/spec-changelog/index.js';
-import { compactResult } from './output-formatter.js';
-const VALID_ENTRY_TYPES = [
-    'criteria_added',
-    'criteria_removed',
-    'status_changed',
-    'scope_changed',
-    'progress_updated',
-    'reconciled',
-];
-function parseFilterTypes(filter) {
-    return filter
-        .split(',')
-        .map((s) => s.trim())
-        .filter((t) => VALID_ENTRY_TYPES.includes(t));
-}
-export async function handleSpecHistory(params) {
-    const { specId, specDir, filter } = params;
-    try {
-        const changelog = await readChangelog({ specDir, specId });
-        if (!changelog) {
-            return compactResult(JSON.stringify({
-                specId,
-                entries: [],
-                totalEntries: 0,
-                filtered: false,
-                message: `No hay CHANGELOG.md para ${specId}. El changelog se crea automaticamente cuando se ejecuta reconcile_spec o update_status sobre la spec.`,
-            }, null, 2));
-        }
-        let entries = changelog.entries;
-        let filtered = false;
-        if (filter) {
-            const filterTypes = parseFilterTypes(filter);
-            if (filterTypes.length > 0) {
-                entries = entries.filter((e) => filterTypes.includes(e.type));
-                filtered = true;
-            }
-        }
-        const message = entries.length === 0 && filtered
-            ? 'No hay entradas del tipo solicitado'
-            : `${entries.length} entrada${entries.length !== 1 ? 's' : ''} encontrada${entries.length !== 1 ? 's' : ''} en el changelog de ${specId}`;
-        const result = {
-            specId,
-            entries,
-            totalEntries: entries.length,
-            filtered,
-            message,
-        };
-        return compactResult(JSON.stringify(result, null, 2));
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return {
-            content: [{ type: 'text', text: `Error reading spec history: ${message}` }],
-            isError: true,
-        };
-    }
-}
-//# sourceMappingURL=spec-history.js.map

package/dist/tools/webhook.d.ts

@@ -1,6 +0,0 @@
-import type { ToolResult, StartWebhookInput, StopWebhookInput, WebhookStatusInput, WebhookServerState } from '../types/index.js';
-export declare function handleStartWebhook(args: StartWebhookInput): Promise<ToolResult>;
-export declare function handleStopWebhook(_args: StopWebhookInput): Promise<ToolResult>;
-export declare function handleWebhookStatus(args: WebhookStatusInput): ToolResult;
-export declare function formatStateForDisplay(state: WebhookServerState): string;
-//# sourceMappingURL=webhook.d.ts.map