@planu/cli 4.14.1 → 5.1.1

package/dist/engine/webhook/signature.js

@@ -1,49 +0,0 @@
-// engine/webhook/signature.ts — HMAC-SHA256 signature validation for Lemon Squeezy webhooks.
-// Validates the X-Signature header against the raw request body.
-import { createHmac, timingSafeEqual } from 'node:crypto';
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-const SIGNATURE_HEADER = 'x-signature';
-const HMAC_ALGO = 'sha256';
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-/**
- * Validates an HMAC-SHA256 signature from a Lemon Squeezy webhook request.
- * Uses timing-safe comparison to prevent timing attacks.
- *
- * @param rawBody - The raw request body bytes (NOT parsed JSON)
- * @param signatureHeader - The value of the X-Signature header
- * @param secret - The webhook secret configured in Lemon Squeezy dashboard
- * @returns true if signature is valid, false otherwise
- */
-export function validateSignature(rawBody, signatureHeader, secret) {
-    if (!secret || !signatureHeader) {
-        return false;
-    }
-    const expectedHex = createHmac(HMAC_ALGO, secret).update(rawBody).digest('hex');
-    try {
-        const expectedBuf = Buffer.from(expectedHex, 'hex');
-        const receivedBuf = Buffer.from(signatureHeader, 'hex');
-        if (expectedBuf.length !== receivedBuf.length) {
-            return false;
-        }
-        return timingSafeEqual(expectedBuf, receivedBuf);
-    }
-    catch /* v8 ignore start */ {
-        return false;
-    } /* v8 ignore stop */
-}
-/**
- * Extracts the signature header value from a map of HTTP headers.
- * Header names are case-insensitive in HTTP/1.1.
- */
-export function extractSignatureHeader(headers) {
-    const raw = headers[SIGNATURE_HEADER];
-    if (Array.isArray(raw)) {
-        return raw[0] ?? '';
-    }
-    return raw ?? '';
-}
-//# sourceMappingURL=signature.js.map

package/dist/storage/license-store.d.ts

@@ -1,6 +0,0 @@
-import type { LicenseState } from '../types/index.js';
-export declare function getLicenseState(): Promise<LicenseState | null>;
-export declare function saveLicenseState(state: LicenseState): Promise<void>;
-export declare function deleteLicenseState(): Promise<void>;
-export declare function countActiveProjects(): Promise<number>;
-//# sourceMappingURL=license-store.d.ts.map

package/dist/storage/license-store.js

@@ -1,63 +0,0 @@
-// storage/license-store.ts — Persistence layer for license state (~/.planu/data/global/license.json).
-import { readdir } from 'node:fs/promises';
-import { join } from 'node:path';
-import { readJson, globalDataDir } from './base-store.js';
-import { withFileLock } from './file-mutex.js';
-import { resolveStorageLayout } from './storage-layout.js';
-import { deleteSecretField, resolveSecretField, storeSecretField, } from '../security/secret-field.js';
-import { writeSecureJson } from '../security/secure-json.js';
-// ---------------------------------------------------------------------------
-// Paths
-// ---------------------------------------------------------------------------
-function licenseFile() {
-    return join(globalDataDir(), 'license.json');
-}
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-export async function getLicenseState() {
-    const state = await readJson(licenseFile(), null);
-    if (!state) {
-        return null;
-    }
-    return { ...state, licenseKey: await resolveSecretField(state.licenseKey) };
-}
-export async function saveLicenseState(state) {
-    await withFileLock(licenseFile(), async () => {
-        const licenseKey = await storeSecretField('global/license', 'license', state.licenseKey);
-        await writeSecureJson(licenseFile(), { ...state, licenseKey });
-    });
-}
-export async function deleteLicenseState() {
-    const { unlink } = await import('node:fs/promises');
-    try {
-        const state = await readJson(licenseFile(), null);
-        await deleteSecretField(state?.licenseKey);
-        await unlink(licenseFile());
-    }
-    catch (err) {
-        if (isNodeError(err) && err.code === 'ENOENT') {
-            return;
-        }
-        throw err;
-    }
-}
-export async function countActiveProjects() {
-    try {
-        const entries = await readdir(resolveStorageLayout().projects, { withFileTypes: true });
-        return entries.filter((e) => e.isDirectory()).length;
-    }
-    catch (err) {
-        if (isNodeError(err) && err.code === 'ENOENT') {
-            return 0;
-        }
-        throw err;
-    }
-}
-// ---------------------------------------------------------------------------
-// Internal helpers
-// ---------------------------------------------------------------------------
-function isNodeError(err) {
-    return err instanceof Error && 'code' in err;
-}
-//# sourceMappingURL=license-store.js.map

package/dist/storage/session-store.d.ts

@@ -1,20 +0,0 @@
-import type { Session, SessionMemory, SessionListItem } from '../types/index.js';
-/** Save a session to disk. */
-export declare function save(session: Session): Promise<void>;
-/** Load a session by ID. Returns null if not found. */
-export declare function load(projectId: string, sessionId: string): Promise<Session | null>;
-/** List sessions for a project, ordered by lastSavedAt desc. */
-export declare function list(projectId: string): Promise<Session[]>;
-/** Get the most recent session for a project. */
-export declare function getLatest(projectId: string): Promise<Session | null>;
-/** Delete a session by ID. Returns true if removed. */
-export declare function deleteSession(projectId: string, sessionId: string): Promise<boolean>;
-/** List sessions as lightweight items for display. */
-export declare function listItems(projectId: string, limit?: number): Promise<SessionListItem[]>;
-/** Clean up old sessions: keep max 50, remove sessions older than 30 days. */
-export declare function cleanup(projectId: string): Promise<number>;
-/** Load cross-conversation memory for a project. */
-export declare function loadMemory(projectId: string): Promise<SessionMemory>;
-/** Save cross-conversation memory. */
-export declare function saveMemory(memory: SessionMemory): Promise<void>;
-//# sourceMappingURL=session-store.d.ts.map

package/dist/storage/session-store.js

@@ -1,136 +0,0 @@
-import { readJson, writeJson, projectDataDir } from './base-store.js';
-import { withFileLock } from './file-mutex.js';
-import { readdir, unlink } from 'node:fs/promises';
-// --- internal helpers ---
-function sanitizeId(id) {
-    const sanitized = id.replace(/[/\\]/g, '_').replace(/\.\./g, '_');
-    if (!sanitized || sanitized === '.' || sanitized === '..') {
-        throw new Error(`Invalid ID: ${id}`);
-    }
-    return sanitized;
-}
-function sessionsDir(projectId) {
-    return `${projectDataDir(projectId)}/sessions`;
-}
-function sessionFile(projectId, sessionId) {
-    return `${sessionsDir(projectId)}/session-${sanitizeId(sessionId)}.json`;
-}
-function memoryFile(projectId) {
-    return `${projectDataDir(projectId)}/session-memory.json`;
-}
-async function listSessionFiles(projectId) {
-    try {
-        const dir = sessionsDir(projectId);
-        const entries = await readdir(dir);
-        return entries.filter((f) => f.startsWith('session-') && f.endsWith('.json'));
-    }
-    catch (error) {
-        if (error.code === 'ENOENT' ||
-            (error instanceof Error && error.message === 'ENOENT')) {
-            return [];
-        }
-        throw error;
-    }
-}
-// --- public API ---
-/** Save a session to disk. */
-export async function save(session) {
-    const file = sessionFile(session.projectId, session.id);
-    await withFileLock(file, () => writeJson(file, session));
-}
-/** Load a session by ID. Returns null if not found. */
-export async function load(projectId, sessionId) {
-    return readJson(sessionFile(projectId, sessionId), null);
-}
-/** List sessions for a project, ordered by lastSavedAt desc. */
-export async function list(projectId) {
-    const files = await listSessionFiles(projectId);
-    const sessions = [];
-    for (const f of files) {
-        const id = f.replace('session-', '').replace('.json', '');
-        const s = await load(projectId, id);
-        if (s) {
-            sessions.push(s);
-        }
-    }
-    sessions.sort((a, b) => b.lastSavedAt.localeCompare(a.lastSavedAt));
-    return sessions;
-}
-/** Get the most recent session for a project. */
-export async function getLatest(projectId) {
-    const all = await list(projectId);
-    return all[0] ?? null;
-}
-/** Delete a session by ID. Returns true if removed. */
-export async function deleteSession(projectId, sessionId) {
-    try {
-        await unlink(sessionFile(projectId, sessionId));
-        return true;
-    }
-    catch (error) {
-        if (error.code === 'ENOENT' ||
-            (error instanceof Error && error.message === 'ENOENT')) {
-            return false;
-        }
-        throw error;
-    }
-}
-/** List sessions as lightweight items for display. */
-export async function listItems(projectId, limit = 10) {
-    const all = await list(projectId);
-    return all.slice(0, limit).map((s) => ({
-        id: s.id,
-        startedAt: s.startedAt,
-        lastSavedAt: s.lastSavedAt,
-        contextSummary: s.contextSummary.slice(0, 200),
-        toolCallCount: s.toolCallCount,
-    }));
-}
-// --- cleanup (AC-10) ---
-const MAX_SESSIONS = 50;
-const MAX_AGE_MS = 30 * 24 * 60 * 60 * 1000; // 30 days
-/** Clean up old sessions: keep max 50, remove sessions older than 30 days. */
-export async function cleanup(projectId) {
-    const all = await list(projectId);
-    let removed = 0;
-    const now = Date.now();
-    // Remove sessions older than 30 days
-    for (const s of all) {
-        const age = now - new Date(s.lastSavedAt).getTime();
-        if (age > MAX_AGE_MS) {
-            await deleteSession(projectId, s.id);
-            removed++;
-        }
-    }
-    // Remove excess beyond MAX_SESSIONS (oldest first, list is already desc)
-    const remaining = all.length - removed;
-    if (remaining > MAX_SESSIONS) {
-        const toRemove = all.slice(MAX_SESSIONS).filter((s) => {
-            const age = now - new Date(s.lastSavedAt).getTime();
-            return age <= MAX_AGE_MS; // not already removed above
-        });
-        for (const s of toRemove) {
-            await deleteSession(projectId, s.id);
-            removed++;
-        }
-    }
-    if (removed > 0) {
-        console.warn(`[Planu] Cleaned up ${String(removed)} old sessions for project ${projectId}`);
-    }
-    return removed;
-}
-// --- session memory (AC-11) ---
-/** Load cross-conversation memory for a project. */
-export async function loadMemory(projectId) {
-    return readJson(memoryFile(projectId), {
-        projectId,
-        decisions: [],
-        updatedAt: new Date().toISOString(),
-    });
-}
-/** Save cross-conversation memory. */
-export async function saveMemory(memory) {
-    const file = memoryFile(memory.projectId);
-    await withFileLock(file, () => writeJson(file, memory));
-}
-//# sourceMappingURL=session-store.js.map

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

@@ -1,6 +0,0 @@
-import type { ActivateLicenseInput, ToolResult } from '../types/index.js';
-export declare function handleActivateLicense(args: ActivateLicenseInput): Promise<ToolResult>;
-export declare function handleDeactivateLicense(args: {
-    confirm: boolean;
-}): Promise<ToolResult>;
-//# sourceMappingURL=activate-license.d.ts.map

package/dist/tools/activate-license.js

@@ -1,132 +0,0 @@
-// tools/activate-license.ts — Handler for activate_license MCP tool.
-// Activates a license key via Lemon Squeezy API and persists the state locally.
-import { hostname, platform, userInfo } from 'node:os';
-import { basename } from 'node:path';
-import { licenseStore } from '../storage/index.js';
-import { activateLicense, computeMachineFingerprint, deactivateLicense, loadLicensePlans, variantToTier, } from '../engine/license-validator.js';
-import { invalidateTierCache } from './license-gate.js';
-import { t, ti } from '../i18n/index.js';
-function buildInstanceName() {
-    const host = hostname();
-    const user = userInfo().username;
-    const os = platform();
-    const project = basename(process.cwd());
-    return `planu-${host} · ${user}@${os} · ${project}`;
-}
-export async function handleActivateLicense(args) {
-    const { licenseKey, instanceName } = args;
-    if (!licenseKey || licenseKey.trim().length === 0) {
-        return {
-            content: [{ type: 'text', text: t('tools.activate_license.keyRequired') }],
-            isError: true,
-        };
-    }
-    const name = instanceName ?? buildInstanceName();
-    try {
-        const response = await activateLicense(licenseKey.trim(), name);
-        if (!response.activated) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: ti('tools.activate_license.activationFailed', {
-                            error: response.error ?? 'Unknown error',
-                        }),
-                    },
-                ],
-                isError: true,
-            };
-        }
-        const tier = variantToTier(response.meta.variant_name);
-        const now = new Date().toISOString();
-        const state = {
-            licenseKey: response.license_key.key,
-            instanceId: response.instance.id,
-            tier,
-            activatedAt: now,
-            lastValidatedAt: now,
-            variantName: response.meta.variant_name,
-            customerName: response.meta.customer_name,
-            customerEmail: response.meta.customer_email,
-            machineFingerprint: computeMachineFingerprint(),
-            activationLimit: response.license_key.activation_limit,
-            activationUsage: response.license_key.activation_usage,
-        };
-        await licenseStore.saveLicenseState(state);
-        invalidateTierCache();
-        const tierLabel = tier.charAt(0).toUpperCase() + tier.slice(1);
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: [
-                        `✅ ${t('tools.activate_license.activatedSuccess')}`,
-                        '',
-                        ti('tools.activate_license.plan', { tier: tierLabel }),
-                        ti('tools.activate_license.customer', { name: response.meta.customer_name }),
-                        ti('tools.activate_license.instance', { name }),
-                        '',
-                        tier === 'pro'
-                            ? t('tools.activate_license.proAccess')
-                            : ti('tools.activate_license.tierAccess', { tier }),
-                    ].join('\n'),
-                },
-            ],
-        };
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: [
-                        ti('tools.activate_license.activationFailed', { error: message }),
-                        '',
-                        t('tools.activate_license.commonCauses'),
-                        `• ${t('tools.activate_license.causeInvalidKey')}`,
-                        `• ${t('tools.activate_license.causeAlreadyActivated')}`,
-                        `• ${t('tools.activate_license.causeNetwork')}`,
-                    ].join('\n'),
-                },
-            ],
-            isError: true,
-        };
-    }
-}
-export async function handleDeactivateLicense(args) {
-    if (!args.confirm) {
-        return {
-            content: [{ type: 'text', text: t('tools.activate_license.deactivationCancelled') }],
-        };
-    }
-    const state = await licenseStore.getLicenseState();
-    if (!state) {
-        return {
-            content: [{ type: 'text', text: t('tools.activate_license.noActiveLicense') }],
-        };
-    }
-    try {
-        await deactivateLicense(state.licenseKey, state.instanceId);
-    }
-    catch {
-        // Even if remote deactivation fails, we clear local state
-    }
-    await licenseStore.deleteLicenseState();
-    invalidateTierCache();
-    return {
-        content: [
-            {
-                type: 'text',
-                text: [
-                    `✅ ${t('tools.activate_license.deactivatedSuccess')}`,
-                    ti('tools.activate_license.deactivatedFreePlan', {
-                        count: String(loadLicensePlans().freeTools.length),
-                    }),
-                    t('tools.activate_license.keyReusable'),
-                ].join('\n'),
-            },
-        ],
-    };
-}
-//# sourceMappingURL=activate-license.js.map

package/dist/tools/checkpoint-handler.d.ts

@@ -1,3 +0,0 @@
-import type { ToolResult, SessionCheckpointInput } from '../types/index.js';
-export declare function handleSessionCheckpoint(args: SessionCheckpointInput): Promise<ToolResult>;
-//# sourceMappingURL=checkpoint-handler.d.ts.map

package/dist/tools/checkpoint-handler.js

@@ -1,130 +0,0 @@
-// tools/checkpoint-handler.ts — Handler for session_checkpoint tool (SPEC-220).
-import { execFileSync } from 'node:child_process';
-import { saveSessionState, getStagedFiles, getActiveSpecIds, } from '../storage/session-state-store.js';
-import { hashProjectPath } from '../storage/base-store.js';
-import { listSpecs } from '../storage/spec-store.js';
-// ---------------------------------------------------------------------------
-// Internal helpers
-// ---------------------------------------------------------------------------
-const SEPARATOR = '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━';
-function formatList(items) {
-    if (items.length === 0) {
-        return '(none)';
-    }
-    return items.map((i) => `- ${i}`).join('\n');
-}
-function buildHandoffBlock(savedAt, activeSpecs, decisions, nextSteps, stagedFiles) {
-    const lines = [
-        `Saved: ${savedAt}`,
-        '',
-        `Active specs: ${activeSpecs.length > 0 ? activeSpecs.join(', ') : '(none)'}`,
-        '',
-        'Decisions:',
-        formatList(decisions),
-        '',
-        'Next steps:',
-        formatList(nextSteps),
-        '',
-        `Staged files: ${stagedFiles.length > 0 ? stagedFiles.join(', ') : '(none)'}`,
-    ];
-    return lines.join('\n');
-}
-async function resolveActiveSpecs(projectPath, projectId) {
-    // Try spec store first (in-progress specs)
-    try {
-        const resolvedId = projectId !== '' ? projectId : hashProjectPath(projectPath);
-        const specs = await listSpecs(resolvedId);
-        const inProgress = specs
-            .filter((s) => s.status === 'implementing')
-            .map((s) => `${s.id} (${s.status})`);
-        if (inProgress.length > 0) {
-            return inProgress;
-        }
-    }
-    catch {
-        // Fallback to filesystem scan
-    }
-    return getActiveSpecIds(projectPath);
-}
-// ---------------------------------------------------------------------------
-// Pending HTML changes notification (SPEC-326)
-// ---------------------------------------------------------------------------
-function checkPlanuUncommittedChanges(projectPath) {
-    try {
-        const output = execFileSync('git', ['status', '--porcelain', 'planu/'], {
-            cwd: projectPath,
-            encoding: 'utf-8',
-            timeout: 5_000,
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        return output.trim().length > 0;
-    }
-    catch {
-        return false;
-    }
-}
-// ---------------------------------------------------------------------------
-// Worktree teardown recommendation (SPEC-279)
-// ---------------------------------------------------------------------------
-function buildWorktreeTeardownRecommendation(activeSpecs) {
-    const specNames = activeSpecs.map((s) => s.replace(/ \(implementing\)$/, '')).join(', ');
-    return {
-        type: 'worktree-teardown',
-        message: `Parallel sprint detected — ${String(activeSpecs.length)} specs in progress (${specNames}). Run these steps to close the sprint safely:`,
-        steps: [
-            'For each worktree: bash scripts/auto-merge.sh  (full pipeline + merge to develop)',
-            'bash scripts/prune-worktrees.sh  (clean up merged/orphan worktrees)',
-            'pnpm test:coverage  (verify thresholds before promoting to main)',
-            'git checkout main && git merge --ff-only develop && git push origin main',
-        ],
-    };
-}
-// ---------------------------------------------------------------------------
-// Handler
-// ---------------------------------------------------------------------------
-export async function handleSessionCheckpoint(args) {
-    const { projectPath, projectId, decisions = [], nextSteps = [] } = args;
-    const savedAt = new Date().toISOString();
-    const stagedFiles = getStagedFiles(projectPath);
-    const activeSpecs = await resolveActiveSpecs(projectPath, projectId);
-    await saveSessionState(projectPath, {
-        savedAt,
-        activeSpecs,
-        recentDecisions: decisions.slice(0, 5),
-        stagedFiles,
-        nextSteps,
-    });
-    const handoff = buildHandoffBlock(savedAt, activeSpecs, decisions, nextSteps, stagedFiles);
-    // SPEC-256: always include /btw tip in checkpoint recommendations
-    const recommendations = [
-        {
-            type: 'context-tip',
-            message: 'Use /btw for side questions during implementation — keeps context clean for the task. Example: /btw what does useEffect cleanup do?',
-            command: '/btw your question here',
-        },
-    ];
-    // SPEC-279: emit worktree teardown instructions when a parallel sprint is detected
-    if (activeSpecs.length >= 2) {
-        recommendations.push(buildWorktreeTeardownRecommendation(activeSpecs));
-    }
-    // SPEC-326: Pending HTML changes notification
-    const planuChanges = checkPlanuUncommittedChanges(projectPath);
-    const planuReminder = planuChanges
-        ? '\n\n📁 Spec changes pending — commit to save: `git add planu/specs/ planu/conventions.json && git commit -m "chore(planu): save spec updates"`'
-        : '';
-    const text = [
-        `Session checkpoint saved — ${savedAt}`,
-        '',
-        'Session Handoff Block (paste in new session):',
-        SEPARATOR,
-        handoff,
-        SEPARATOR,
-    ].join('\n') + planuReminder;
-    return {
-        content: [{ type: 'text', text }],
-        structuredContent: {
-            recommendations,
-        },
-    };
-}
-//# sourceMappingURL=checkpoint-handler.js.map

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

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

package/dist/tools/export-session.js

@@ -1,90 +0,0 @@
-import { hashProjectPath } from '../storage/base-store.js';
-import * as sessionStore from '../storage/session-store.js';
-function formatAsMarkdown(session) {
-    const lines = [];
-    lines.push(`# Session Export: ${session.id}`);
-    lines.push('');
-    lines.push(`## Summary`);
-    lines.push(`- **Project**: ${session.projectId}`);
-    lines.push(`- **Started**: ${session.startedAt}`);
-    lines.push(`- **Last Saved**: ${session.lastSavedAt}`);
-    lines.push(`- **Tool Calls**: ${String(session.toolCallCount)}`);
-    lines.push('');
-    if (session.activeSpecs.length > 0) {
-        lines.push('## Active Specs');
-        for (const spec of session.activeSpecs) {
-            lines.push(`- **${spec.specId}** (${spec.status}): ${spec.summary}`);
-        }
-        lines.push('');
-    }
-    if (session.decisions.length > 0) {
-        lines.push('## Decisions');
-        for (const d of session.decisions) {
-            const specRef = d.specId ? ` [${d.specId}]` : '';
-            lines.push(`- **${d.decision}**${specRef}`);
-            if (d.rationale) {
-                lines.push(`  - _${d.rationale}_`);
-            }
-        }
-        lines.push('');
-    }
-    if (session.modifiedFiles.length > 0) {
-        lines.push('## Modified Files');
-        for (const f of session.modifiedFiles) {
-            lines.push(`- \`${f.path}\` (${f.action})`);
-        }
-        lines.push('');
-    }
-    if (Object.keys(session.metadata).length > 0) {
-        lines.push('## Metadata');
-        lines.push('```json');
-        lines.push(JSON.stringify(session.metadata, null, 2));
-        lines.push('```');
-    }
-    return lines.join('\n');
-}
-export async function handleExportSession(params) {
-    const projectId = hashProjectPath(params.projectPath);
-    const format = params.format ?? 'markdown';
-    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: 'No sessions found for this project.' }],
-            };
-        }
-        if (format === 'json') {
-            const summary = [
-                `✅ **Session exported:** ${session.id}`,
-                '',
-                `**Project:** ${session.projectId}`,
-                `**Started:** ${session.startedAt}`,
-                `**Tool Calls:** ${String(session.toolCallCount)}`,
-                `**Active Specs:** ${String(session.activeSpecs.length)}`,
-                `**Decisions:** ${String(session.decisions.length)}`,
-                `**Modified Files:** ${String(session.modifiedFiles.length)}`,
-            ].join('\n');
-            return {
-                content: [{ type: 'text', text: summary }],
-                structuredContent: session,
-            };
-        }
-        return {
-            content: [{ type: 'text', text: formatAsMarkdown(session) }],
-        };
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return {
-            content: [{ type: 'text', text: `Error exporting session: ${message}` }],
-            isError: true,
-        };
-    }
-}
-//# sourceMappingURL=export-session.js.map

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

@@ -1,18 +0,0 @@
-import type { PricingTier, ToolResult } from '../types/index.js';
-export declare function getCurrentTier(): Promise<PricingTier>;
-export declare function invalidateTierCache(): void;
-/**
- * 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 declare function getTierSync(): PricingTier;
-export declare function shouldBypassDailyRateLimit(toolName: string): boolean;
-export declare function withLicenseGate<T>(toolName: string, handler: (args: T, extra?: unknown) => Promise<ToolResult>): (args: T, extra?: unknown) => Promise<ToolResult>;
-/**
- * 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 declare function withUsageTracking<T>(toolName: string, handler: (args: T, extra?: unknown) => Promise<ToolResult>): (args: T, extra?: unknown) => Promise<ToolResult>;
-//# sourceMappingURL=license-gate.d.ts.map