@planu/cli 4.13.0 → 5.0.0

package/dist/storage/license-store.js

@@ -1,91 +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, writeJson, globalDataDir, safeJsonParse } from './base-store.js';
-import { withFileLock } from './file-mutex.js';
-// ---------------------------------------------------------------------------
-// Paths
-// ---------------------------------------------------------------------------
-function licenseFile() {
-    return join(globalDataDir(), 'license.json');
-}
-/**
- * Legacy path used before SPEC-537: data/global/license.json (cwd-relative).
- * We attempt a one-time migration from this path to the new absolute location.
- */
-function legacyLicenseFile() {
-    return join('data', 'global', 'license.json');
-}
-// ---------------------------------------------------------------------------
-// Migration helper (runs once, silently)
-// ---------------------------------------------------------------------------
-async function migrateLegacyLicense() {
-    const legacy = legacyLicenseFile();
-    const current = licenseFile();
-    // Skip if already at the same path (e.g. PLANU_GLOBAL_DATA_DIR override points to cwd)
-    if (legacy === current) {
-        return;
-    }
-    const { readFile, rename, mkdir } = await import('node:fs/promises');
-    const { dirname } = await import('node:path');
-    try {
-        const raw = await readFile(legacy, 'utf-8');
-        const legacyState = safeJsonParse(raw, {});
-        // Only migrate a real license state (must have a licenseKey field)
-        if (typeof legacyState.licenseKey !== 'string' || legacyState.licenseKey.length === 0) {
-            return;
-        }
-        await mkdir(dirname(current), { recursive: true });
-        await rename(legacy, current);
-    }
-    catch {
-        // File does not exist or is not readable — nothing to migrate
-    }
-}
-let migrationDone = false;
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-export async function getLicenseState() {
-    if (!migrationDone) {
-        migrationDone = true;
-        await migrateLegacyLicense();
-    }
-    return readJson(licenseFile(), null);
-}
-export async function saveLicenseState(state) {
-    await withFileLock(licenseFile(), async () => {
-        await writeJson(licenseFile(), state);
-    });
-}
-export async function deleteLicenseState() {
-    const { unlink } = await import('node:fs/promises');
-    try {
-        await unlink(licenseFile());
-    }
-    catch (err) {
-        if (isNodeError(err) && err.code === 'ENOENT') {
-            return;
-        }
-        throw err;
-    }
-}
-export async function countActiveProjects() {
-    try {
-        const entries = await readdir('data/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/migrations/cwd-to-absolute.d.ts

@@ -1,25 +0,0 @@
-import type { CwdMigrationResult as MigrationResult } from '../../types/migration/cwd-to-absolute.js';
-export type { MigrationResult };
-/** Test-only: reset the in-memory short-circuit set. */
-export declare function clearMigratedThisSession(): void;
-declare function pathExists(p: string): Promise<boolean>;
-/**
- * Move a legacy `<cwd>/data/projects/<id>/` tree into the absolute home for
- * `projectId`. Idempotent across calls and processes.
- *
- * Test isolation: when PLANU_PROJECT_DATA_DIR is assigned to a fresh tmp dir
- * (as in `tests/setup.ts`), this migration walks `cwd` from the test's
- * directory and finds nothing — returns `noop` immediately.
- */
-export declare function migrateLegacyDataDir(projectId: string, cwd?: string): Promise<MigrationResult>;
-export declare const MIGRATION_INTERNALS: Readonly<{
-    SENTINEL_FILE: ".migrated-from-cwd";
-    LOCK_FILE: ".migration.lock";
-    MAX_WALK_DEPTH: 8;
-    ANCHOR_FILE: "knowledge.json";
-    LEGACY_SUBPATH: "data/projects";
-}>;
-export declare const __test: {
-    pathExists: typeof pathExists;
-};
-//# sourceMappingURL=cwd-to-absolute.d.ts.map

package/dist/storage/migrations/cwd-to-absolute.js

@@ -1,281 +0,0 @@
-// cwd-to-absolute.ts — One-shot migration of legacy <cwd>/data/projects/{id}/
-// trees into the new absolute home (~/.planu/data/projects/{id}/) introduced
-// in v3.3.0 (SPEC-1007).
-//
-// Idempotent and safe to call before every read/write entry point. Uses three
-// short-circuits in order:
-//   1. In-memory Set<projectId> — same session, repeat calls return immediately.
-//   2. Sentinel file `<absolute>/.migrated-from-cwd` — across sessions.
-//   3. Walk-up of `cwd` ancestors (max 8) for `knowledge.json` anchor.
-//
-// On rename we attempt the atomic `fs.rename`. When the source and destination
-// live on different filesystems (`EXDEV`), we fall back to `fs.cp` + verify +
-// `rm -rf legacy`. Verify failures leave the legacy tree intact.
-//
-// Conflict semantics: if the absolute path already holds populated data and
-// the legacy tree also has populated data, we never auto-merge — the legacy
-// tree is renamed to `<legacy>.legacy-<ISO_TS>` and a warning is logged.
-import { stat, mkdir, rename, cp, rm, writeFile, open } from 'node:fs/promises';
-import { existsSync } from 'node:fs';
-import { join, dirname, isAbsolute } from 'node:path';
-import { projectDataDir } from '../base-store.js';
-const SENTINEL_FILE = '.migrated-from-cwd';
-// LOCK_FILE is appended to absolute path as a sibling (e.g. `${absolute}.migration.lock`)
-// to avoid creating `absolute` itself before the rename can run.
-const LOCK_FILE = '.migration.lock';
-const MAX_WALK_DEPTH = 8;
-const ANCHOR_FILE = 'knowledge.json';
-const LEGACY_SUBPATH = 'data/projects';
-/**
- * Per-session set of projectIds already migrated. Cleared by tests via
- * `clearMigratedThisSession()` so each test gets a fresh slate.
- */
-const migratedThisSession = new Set();
-/** Test-only: reset the in-memory short-circuit set. */
-export function clearMigratedThisSession() {
-    migratedThisSession.clear();
-}
-async function pathExists(p) {
-    try {
-        await stat(p);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function fileExists(p) {
-    try {
-        const s = await stat(p);
-        return s.isFile();
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Walk upward from `startDir` looking for `<dir>/data/projects/<id>/knowledge.json`.
- * Returns the matched legacy data dir (`<dir>/data/projects/<id>`), or null.
- */
-async function walkUpForLegacy(startDir, projectId) {
-    if (!isAbsolute(startDir)) {
-        return null;
-    }
-    let current = startDir;
-    for (let i = 0; i < MAX_WALK_DEPTH; i++) {
-        const candidate = join(current, LEGACY_SUBPATH, projectId);
-        if (await fileExists(join(candidate, ANCHOR_FILE))) {
-            return candidate;
-        }
-        const parent = dirname(current);
-        if (parent === current) {
-            return null;
-        }
-        current = parent;
-    }
-    return null;
-}
-async function writeSentinel(absolute) {
-    await mkdir(absolute, { recursive: true });
-    await writeFile(join(absolute, SENTINEL_FILE), new Date().toISOString(), 'utf-8');
-}
-/**
- * Acquire an exclusive lock by opening LOCK_FILE with O_CREAT|O_EXCL. The lock
- * is a sibling file `<absolute>.migration.lock`, so we never create `<absolute>`
- * itself prematurely (rename(legacy, absolute) must operate on a non-existing
- * destination). Returns a release function. If the lock is already held, polls
- * every 100ms up to 5s.
- */
-async function acquireLock(absolute) {
-    const lockPath = `${absolute}${LOCK_FILE}`;
-    await mkdir(dirname(absolute), { recursive: true });
-    const deadline = Date.now() + 5000;
-    while (Date.now() < deadline) {
-        try {
-            const fh = await open(lockPath, 'wx');
-            await fh.close();
-            return async () => {
-                try {
-                    await rm(lockPath, { force: true });
-                }
-                catch {
-                    // Best-effort
-                }
-            };
-        }
-        catch (err) {
-            if (err instanceof Error &&
-                'code' in err &&
-                err.code === 'EEXIST') {
-                await new Promise((r) => setTimeout(r, 100));
-                continue;
-            }
-            throw err;
-        }
-    }
-    // Timed out — assume the other writer crashed; force-release and retry once.
-    try {
-        await rm(lockPath, { force: true });
-    }
-    catch {
-        // ignore
-    }
-    const fh = await open(lockPath, 'wx');
-    await fh.close();
-    return async () => {
-        try {
-            await rm(lockPath, { force: true });
-        }
-        catch {
-            // ignore
-        }
-    };
-}
-function isExdevError(err) {
-    return err instanceof Error && 'code' in err && err.code === 'EXDEV';
-}
-/**
- * Move a legacy `<cwd>/data/projects/<id>/` tree into the absolute home for
- * `projectId`. Idempotent across calls and processes.
- *
- * Test isolation: when PLANU_PROJECT_DATA_DIR is assigned to a fresh tmp dir
- * (as in `tests/setup.ts`), this migration walks `cwd` from the test's
- * directory and finds nothing — returns `noop` immediately.
- */
-export async function migrateLegacyDataDir(projectId, cwd = process.cwd()) {
-    // Reject obviously invalid input — projectDataDir already validates, but we
-    // want a typed result rather than a thrown error reaching callers.
-    if (!projectId || projectId.includes('..') || projectId.includes('/')) {
-        return {
-            status: 'error',
-            legacyPath: null,
-            absolutePath: '',
-            reason: `Invalid projectId: "${projectId}"`,
-        };
-    }
-    const absolute = projectDataDir(projectId);
-    // 1. In-memory short-circuit.
-    if (migratedThisSession.has(projectId)) {
-        return { status: 'noop', legacyPath: null, absolutePath: absolute };
-    }
-    // 2. Sentinel short-circuit (cross-session).
-    if (existsSync(join(absolute, SENTINEL_FILE))) {
-        migratedThisSession.add(projectId);
-        return { status: 'noop', legacyPath: null, absolutePath: absolute };
-    }
-    // 3. Walk up from cwd looking for legacy.
-    let legacyPath;
-    try {
-        legacyPath = await walkUpForLegacy(cwd, projectId);
-    }
-    catch (err) {
-        return {
-            status: 'error',
-            legacyPath: null,
-            absolutePath: absolute,
-            reason: `Walk-up failed: ${err instanceof Error ? err.message : String(err)}`,
-        };
-    }
-    // No legacy → first-time install. Mark with sentinel so we never re-walk.
-    if (legacyPath === null) {
-        try {
-            await writeSentinel(absolute);
-        }
-        catch {
-            // Best-effort: the absence of a sentinel just means we re-walk next call.
-        }
-        migratedThisSession.add(projectId);
-        return { status: 'noop', legacyPath: null, absolutePath: absolute };
-    }
-    // 4. Acquire lock and re-check sentinel inside the critical section.
-    let release;
-    try {
-        release = await acquireLock(absolute);
-    }
-    catch (err) {
-        return {
-            status: 'error',
-            legacyPath,
-            absolutePath: absolute,
-            reason: `Lock acquisition failed: ${err instanceof Error ? err.message : String(err)}`,
-        };
-    }
-    try {
-        if (existsSync(join(absolute, SENTINEL_FILE))) {
-            migratedThisSession.add(projectId);
-            return { status: 'noop', legacyPath, absolutePath: absolute };
-        }
-        const absoluteHasContent = await fileExists(join(absolute, ANCHOR_FILE));
-        if (absoluteHasContent) {
-            return await runConflictBranch(projectId, legacyPath, absolute);
-        }
-        return await runHappyPath(projectId, legacyPath, absolute);
-    }
-    finally {
-        await release();
-    }
-}
-async function runConflictBranch(projectId, legacyPath, absolute) {
-    const ts = new Date().toISOString().replace(/[:.]/g, '-');
-    const renamed = `${legacyPath}.legacy-${ts}`;
-    try {
-        await rename(legacyPath, renamed);
-    }
-    catch (err) {
-        return {
-            status: 'error',
-            legacyPath,
-            absolutePath: absolute,
-            reason: `Conflict rename failed: ${err instanceof Error ? err.message : String(err)}`,
-        };
-    }
-    console.warn(`[Planu] Migration conflict: legacy ${legacyPath} renamed to ${renamed}; absolute path retained as canonical.`);
-    await writeSentinel(absolute);
-    migratedThisSession.add(projectId);
-    return {
-        status: 'conflict',
-        legacyPath,
-        absolutePath: absolute,
-        reason: `Both legacy and absolute had populated content; legacy renamed to ${renamed}`,
-    };
-}
-async function runHappyPath(projectId, legacyPath, absolute) {
-    await mkdir(dirname(absolute), { recursive: true });
-    try {
-        await rename(legacyPath, absolute);
-    }
-    catch (err) {
-        if (!isExdevError(err)) {
-            return {
-                status: 'error',
-                legacyPath,
-                absolutePath: absolute,
-                reason: `Rename failed: ${err instanceof Error ? err.message : String(err)}`,
-            };
-        }
-        await cp(legacyPath, absolute, { recursive: true, errorOnExist: false });
-        if (!(await fileExists(join(absolute, ANCHOR_FILE)))) {
-            return {
-                status: 'error',
-                legacyPath,
-                absolutePath: absolute,
-                reason: 'Cross-filesystem copy verification failed; legacy tree preserved',
-            };
-        }
-        await rm(legacyPath, { recursive: true, force: true });
-    }
-    await writeSentinel(absolute);
-    migratedThisSession.add(projectId);
-    return { status: 'migrated', legacyPath, absolutePath: absolute };
-}
-// Re-export constants used by callers and tests.
-export const MIGRATION_INTERNALS = Object.freeze({
-    SENTINEL_FILE,
-    LOCK_FILE,
-    MAX_WALK_DEPTH,
-    ANCHOR_FILE,
-    LEGACY_SUBPATH,
-});
-// pathExists is an internal helper; export only when needed in tests.
-export const __test = { pathExists };
-//# sourceMappingURL=cwd-to-absolute.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,128 +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 {
-        return [];
-    }
-}
-// --- 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 {
-        return false;
-    }
-}
-/** 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