@planu/cli 4.14.1 → 5.0.0

package/dist/engine/webhook/event-handlers.js

@@ -1,89 +0,0 @@
-// engine/webhook/event-handlers.ts — Handles individual Lemon Squeezy webhook events.
-// Each handler receives parsed payload and applies the corresponding business logic.
-// ---------------------------------------------------------------------------
-// Individual event handlers
-// ---------------------------------------------------------------------------
-/**
- * Handles subscription_cancelled: the customer cancelled their subscription.
- * The tier should be reverted to free when the subscription period ends.
- */
-export function handleSubscriptionCancelled(payload) {
-    const attrs = payload.data.attributes;
-    const endsAt = attrs.ends_at ?? 'unknown date';
-    const productName = attrs.product_name ?? 'Planu subscription';
-    return {
-        success: true,
-        eventType: 'subscription_cancelled',
-        statusCode: 200,
-        message: [
-            `Subscription cancellation recorded: ${productName}`,
-            `Access continues until: ${endsAt}`,
-            'Tier will revert to free upon expiry.',
-        ].join(' | '),
-    };
-}
-/**
- * Handles subscription_updated: plan tier may have changed (upgrade/downgrade).
- */
-export function handleSubscriptionUpdated(payload) {
-    const attrs = payload.data.attributes;
-    const variantName = attrs.variant_name ?? 'unknown variant';
-    const status = attrs.status ?? 'unknown';
-    return {
-        success: true,
-        eventType: 'subscription_updated',
-        statusCode: 200,
-        message: [`Subscription updated: variant=${variantName}`, `status=${status}`].join(' | '),
-    };
-}
-/**
- * Handles license_key_created: a new license key was issued (after purchase).
- * This is informational — the user will activate the key via activate_license tool.
- */
-export function handleLicenseKeyCreated(payload) {
-    const attrs = payload.data.attributes;
-    const productName = attrs.product_name ?? 'Planu';
-    const userEmail = attrs.user_email ?? 'unknown';
-    return {
-        success: true,
-        eventType: 'license_key_created',
-        statusCode: 200,
-        message: [
-            `License key created for: ${productName}`,
-            `customer=${userEmail}`,
-            'Key can be activated using activate_license tool.',
-        ].join(' | '),
-    };
-}
-/**
- * Returns a generic "acknowledged" result for unhandled but recognised events.
- */
-export function handleUnknownEvent(eventType) {
-    return {
-        success: true,
-        eventType,
-        statusCode: 200,
-        message: `Event acknowledged (no handler): ${eventType}`,
-    };
-}
-// ---------------------------------------------------------------------------
-// Dispatcher
-// ---------------------------------------------------------------------------
-const HANDLERS = {
-    subscription_cancelled: handleSubscriptionCancelled,
-    subscription_updated: handleSubscriptionUpdated,
-    license_key_created: handleLicenseKeyCreated,
-};
-/**
- * Dispatches a parsed webhook payload to the appropriate event handler.
- * Unhandled but valid events are acknowledged with a 200 response.
- */
-export function dispatchWebhookEvent(payload) {
-    const eventType = payload.meta.event_name;
-    const handler = HANDLERS[eventType];
-    if (handler) {
-        return handler(payload);
-    }
-    return handleUnknownEvent(eventType);
-}
-//# sourceMappingURL=event-handlers.js.map

package/dist/engine/webhook/index.d.ts

@@ -1,4 +0,0 @@
-export { startWebhookServer, stopWebhookServer, getWebhookState, setWebhookSecret, } from './server.js';
-export { validateSignature, extractSignatureHeader } from './signature.js';
-export { dispatchWebhookEvent, handleSubscriptionCancelled, handleSubscriptionUpdated, handleLicenseKeyCreated, handleUnknownEvent, } from './event-handlers.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/engine/webhook/index.js

@@ -1,5 +0,0 @@
-// engine/webhook/index.ts — Barrel re-export for the webhook engine module.
-export { startWebhookServer, stopWebhookServer, getWebhookState, setWebhookSecret, } from './server.js';
-export { validateSignature, extractSignatureHeader } from './signature.js';
-export { dispatchWebhookEvent, handleSubscriptionCancelled, handleSubscriptionUpdated, handleLicenseKeyCreated, handleUnknownEvent, } from './event-handlers.js';
-//# sourceMappingURL=index.js.map

package/dist/engine/webhook/server.d.ts

@@ -1,12 +0,0 @@
-import type { WebhookServerState } from '../../types/index.js';
-/** Returns the current webhook server state (immutable snapshot). */
-export declare function getWebhookState(): WebhookServerState;
-/** Replaces the webhook secret used for HMAC-SHA256 validation. */
-export declare function setWebhookSecret(secret: string): void;
-/** Starts the HTTP webhook server on the given port. Idempotent. */
-export declare function startWebhookServer(port?: number): Promise<WebhookServerState>;
-/** Stops the running webhook server gracefully. Idempotent. */
-export declare function stopWebhookServer(): Promise<WebhookServerState>;
-/** Reset replay protection state (for testing only). */
-export declare function _resetReplayState(): void;
-//# sourceMappingURL=server.d.ts.map

package/dist/engine/webhook/server.js

@@ -1,249 +0,0 @@
-// engine/webhook/server.ts — Lightweight HTTP webhook receiver using node:http.
-// No framework dependencies — only built-in Node.js modules.
-import { createServer } from 'node:http';
-import { randomUUID, createHash } from 'node:crypto';
-import { validateSignature, extractSignatureHeader } from './signature.js';
-import { dispatchWebhookEvent } from './event-handlers.js';
-// Constants
-const DEFAULT_PORT = 2358;
-const MAX_RECENT_EVENTS = 20;
-const MAX_BODY_SIZE = 1024 * 1024; // 1 MB
-const NONCE_CACHE_SIZE = 1000;
-const MAX_TIMESTAMP_AGE_MS = 5 * 60 * 1000; // 5 minutes
-const RATE_LIMIT_WINDOW_MS = 60 * 1000;
-const RATE_LIMIT_MAX = 10;
-// Module state
-let activeServer = null;
-let serverState = makeIdleState();
-let webhookSecret = '';
-const recentNonces = new Set();
-const nonceQueue = [];
-const rateLimitMap = new Map();
-// Public API
-/** Returns the current webhook server state (immutable snapshot). */
-export function getWebhookState() {
-    return serverState;
-}
-/** Replaces the webhook secret used for HMAC-SHA256 validation. */
-export function setWebhookSecret(secret) {
-    webhookSecret = secret;
-}
-/** Starts the HTTP webhook server on the given port. Idempotent. */
-export async function startWebhookServer(port = DEFAULT_PORT) {
-    if (activeServer !== null) {
-        return serverState;
-    }
-    return new Promise((resolve, reject) => {
-        const server = createServer(handleRequest);
-        server.on('error', (err) => {
-            reject(err);
-        });
-        server.listen(port, () => {
-            activeServer = server;
-            serverState = {
-                running: true,
-                port,
-                startedAt: new Date().toISOString(),
-                eventsProcessed: 0,
-                recentEvents: [],
-            };
-            if (!webhookSecret) {
-                console.warn('[Planu] Warning: Webhook server started without a secret. All incoming requests will be accepted without signature verification. Set a secret via configure_webhook.');
-            }
-            resolve(serverState);
-        });
-    });
-}
-/** Stops the running webhook server gracefully. Idempotent. */
-export async function stopWebhookServer() {
-    if (activeServer === null) {
-        serverState = makeIdleState();
-        return serverState;
-    }
-    const server = activeServer;
-    return new Promise((resolve, reject) => {
-        server.close((err) => {
-            /* v8 ignore start */
-            if (err) {
-                reject(err);
-                return;
-            }
-            /* v8 ignore stop */
-            activeServer = null;
-            serverState = makeIdleState();
-            resolve(serverState);
-        });
-    });
-}
-// HTTP request handler
-function handleRequest(req, res) {
-    if (req.method !== 'POST') {
-        res.writeHead(405, { 'Content-Type': 'text/plain' });
-        res.end('Method Not Allowed');
-        return;
-    }
-    collectBody(req)
-        .then((rawBody) => {
-        processWebhookRequest(rawBody, req.headers, res);
-    })
-        .catch(() => {
-        res.writeHead(400, { 'Content-Type': 'text/plain' });
-        res.end('Bad Request');
-    });
-}
-function collectBody(req) {
-    return new Promise((resolve, reject) => {
-        const chunks = [];
-        let totalSize = 0;
-        req.on('data', (chunk) => {
-            totalSize += chunk.length;
-            if (totalSize > MAX_BODY_SIZE) {
-                reject(new Error('Payload too large'));
-                return;
-            }
-            chunks.push(chunk);
-        });
-        req.on('end', () => {
-            resolve(Buffer.concat(chunks));
-        });
-        req.on('error', reject);
-    });
-}
-// Replay & rate-limit protection (SPEC-094 AC-7)
-function isReplayAttack(headers, bodyStr) {
-    const tsHeader = headers['x-webhook-timestamp'] ?? headers['X-Webhook-Timestamp'];
-    const timestamp = typeof tsHeader === 'string' ? tsHeader : undefined;
-    if (timestamp) {
-        const age = Date.now() - new Date(timestamp).getTime();
-        if (age > MAX_TIMESTAMP_AGE_MS || age < -MAX_TIMESTAMP_AGE_MS) {
-            return 'Webhook timestamp too old or in the future';
-        }
-    }
-    const nonce = extractNonce(headers, bodyStr);
-    if (nonce && recentNonces.has(nonce)) {
-        return 'Duplicate webhook (replay detected)';
-    }
-    if (nonce) {
-        trackNonce(nonce);
-    }
-    return null;
-}
-function extractNonce(headers, bodyStr) {
-    const idHeader = headers['x-webhook-id'] ?? headers['X-Webhook-Id'];
-    if (typeof idHeader === 'string') {
-        return idHeader;
-    }
-    return createHash('sha256').update(bodyStr).digest('hex').slice(0, 32);
-}
-function trackNonce(nonce) {
-    recentNonces.add(nonce);
-    nonceQueue.push(nonce);
-    while (nonceQueue.length > NONCE_CACHE_SIZE) {
-        const old = nonceQueue.shift();
-        if (old) {
-            recentNonces.delete(old);
-        }
-    }
-}
-function isRateLimited(source) {
-    const now = Date.now();
-    const entry = rateLimitMap.get(source);
-    if (!entry || now - entry.windowStart > RATE_LIMIT_WINDOW_MS) {
-        rateLimitMap.set(source, { count: 1, windowStart: now });
-        return false;
-    }
-    entry.count++;
-    return entry.count > RATE_LIMIT_MAX;
-}
-/** Reset replay protection state (for testing only). */
-export function _resetReplayState() {
-    recentNonces.clear();
-    nonceQueue.length = 0;
-    rateLimitMap.clear();
-}
-function processWebhookRequest(rawBody, headers, res) {
-    // Rate limiting
-    const source = String(headers['x-forwarded-for'] ?? headers['x-real-ip'] ?? 'unknown');
-    if (isRateLimited(source)) {
-        res.writeHead(429, { 'Content-Type': 'text/plain' });
-        res.end('Too Many Requests');
-        return;
-    }
-    // Replay protection
-    const replayReason = isReplayAttack(headers, rawBody.toString('utf8'));
-    if (replayReason) {
-        recordEvent('replay_rejected', false, replayReason, '');
-        res.writeHead(409, { 'Content-Type': 'text/plain' });
-        res.end(replayReason);
-        return;
-    }
-    // Signature validation (only if a secret is configured)
-    if (webhookSecret) {
-        const sig = extractSignatureHeader(headers);
-        if (!validateSignature(rawBody, sig, webhookSecret)) {
-            recordEvent('signature_invalid', false, 'Signature validation failed', '');
-            res.writeHead(401, { 'Content-Type': 'text/plain' });
-            res.end('Unauthorized');
-            return;
-        }
-    }
-    // Parse JSON body
-    let payload;
-    try {
-        payload = JSON.parse(rawBody.toString('utf8'));
-    }
-    catch {
-        res.writeHead(400, { 'Content-Type': 'text/plain' });
-        res.end('Invalid JSON');
-        return;
-    }
-    if (!payload.meta?.event_name) {
-        res.writeHead(400, { 'Content-Type': 'text/plain' });
-        res.end('Invalid payload: missing meta.event_name');
-        return;
-    }
-    // Dispatch event
-    const eventType = payload.meta.event_name;
-    try {
-        const result = dispatchWebhookEvent(payload);
-        recordEvent(eventType, result.success, result.message, result.eventType);
-        res.writeHead(result.statusCode, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ ok: true, message: result.message }));
-        /* v8 ignore start */
-    }
-    catch (err) {
-        const errMsg = err instanceof Error ? err.message : 'Unknown error';
-        recordEvent(eventType, false, errMsg, eventType);
-        res.writeHead(500, { 'Content-Type': 'text/plain' });
-        res.end('Internal Server Error');
-    }
-    /* v8 ignore stop */
-}
-// Event recording
-function recordEvent(_eventType, processed, summary, resolvedType) {
-    const record = {
-        id: randomUUID(),
-        eventType: resolvedType,
-        receivedAt: new Date().toISOString(),
-        processed,
-        summary,
-        ...(processed ? {} : { error: summary }),
-    };
-    const recentEvents = [record, ...serverState.recentEvents].slice(0, MAX_RECENT_EVENTS);
-    serverState = {
-        ...serverState,
-        eventsProcessed: serverState.eventsProcessed + 1,
-        recentEvents,
-    };
-}
-// Helpers
-function makeIdleState() {
-    return {
-        running: false,
-        port: DEFAULT_PORT,
-        startedAt: null,
-        eventsProcessed: 0,
-        recentEvents: [],
-    };
-}
-//# sourceMappingURL=server.js.map

package/dist/engine/webhook/signature.d.ts

@@ -1,16 +0,0 @@
-/**
- * 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 declare function validateSignature(rawBody: Buffer, signatureHeader: string, secret: string): boolean;
-/**
- * Extracts the signature header value from a map of HTTP headers.
- * Header names are case-insensitive in HTTP/1.1.
- */
-export declare function extractSignatureHeader(headers: Record<string, string | string[] | undefined>): string;
-//# sourceMappingURL=signature.d.ts.map

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