@taskforcehq/taskforce 0.3.311 → 0.3.313

package/dist/core/SignupMonetizationSettings.test.js

@@ -1,515 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { TaskforceCore } from './Taskforce';
-function makeProjectRoot() {
-    return fs.mkdtempSync(path.join(os.tmpdir(), 'taskforce-onboarding-policy-'));
-}
-function insertFreePriceMapping(core, planVersionId) {
-    const db = core.db;
-    const tenantId = core.getTenantId();
-    const now = new Date().toISOString();
-    db.prepare(`
-        INSERT OR IGNORE INTO billing_price_mappings (
-            tenant_id, plan_version_id, billing_interval, stripe_price_id, pricing_type, active, unit_amount, currency, created_at, updated_at
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(tenantId, planVersionId, 'month', `free:${planVersionId}:month`, 'free', 1, 0, null, now, now);
-}
-function openCore(projectRoot) {
-    const core = new TaskforceCore({
-        projectRoot,
-        storagePath: path.join(projectRoot, '.taskforce'),
-        tenantId: path.basename(projectRoot)
-    });
-    core.upsertPlanCatalog({ planId: 'free', displayName: 'Free', status: 'active' });
-    core.updatePlanVersion({
-        planId: 'free',
-        versionNumber: 1,
-        seatLimit: 1
-    });
-    core.updatePlanVersionFeatures({
-        planVersionId: 'free-v1',
-        features: [
-            { featureKey: 'workspace.workspaces', access: 'enabled' }
-        ]
-    });
-    insertFreePriceMapping(core, 'free-v1');
-    return core;
-}
-describe('TaskforceCore onboarding policy', () => {
-    it('fails closed to require_plan_selection when no explicit onboarding policy is configured', () => {
-        const projectRoot = makeProjectRoot();
-        const core = openCore(projectRoot);
-        try {
-            expect(core.getOnboardingPolicy()).toEqual({
-                mode: 'require_plan_selection',
-                planId: null
-            });
-        }
-        finally {
-            core.close();
-            fs.rmSync(projectRoot, { recursive: true, force: true });
-        }
-    });
-    it('falls back to require_plan_selection when no free onboarding plan is available', () => {
-        const projectRoot = makeProjectRoot();
-        const core = new TaskforceCore({
-            projectRoot,
-            storagePath: path.join(projectRoot, '.taskforce'),
-            tenantId: path.basename(projectRoot)
-        });
-        core.upsertPlanCatalog({ planId: 'free', displayName: 'Free', status: 'active' });
-        core.updatePlanVersion({
-            planId: 'free',
-            versionNumber: 1,
-            seatLimit: 1
-        });
-        core.updatePlanVersionFeatures({
-            planVersionId: 'free-v1',
-            features: [
-                { featureKey: 'workspace.workspaces', access: 'enabled' }
-            ]
-        });
-        try {
-            expect(core.getOnboardingPolicy()).toEqual({
-                mode: 'require_plan_selection',
-                planId: null
-            });
-        }
-        finally {
-            core.close();
-            fs.rmSync(projectRoot, { recursive: true, force: true });
-        }
-    });
-    it('fails validation for auto_grant_free without a plan id', () => {
-        const projectRoot = makeProjectRoot();
-        const core = openCore(projectRoot);
-        try {
-            expect(core.validateOnboardingPolicy({
-                mode: 'auto_grant_free',
-                planId: null
-            })).toEqual(expect.objectContaining({
-                valid: false,
-                code: 'ONBOARDING_PLAN_REQUIRED'
-            }));
-        }
-        finally {
-            core.close();
-            fs.rmSync(projectRoot, { recursive: true, force: true });
-        }
-    });
-    it('fails validation when the configured plan does not exist', () => {
-        const projectRoot = makeProjectRoot();
-        const core = openCore(projectRoot);
-        try {
-            expect(core.validateOnboardingPolicy({
-                mode: 'auto_grant_free',
-                planId: 'missing'
-            })).toEqual(expect.objectContaining({
-                valid: false,
-                code: 'ONBOARDING_PLAN_NOT_FOUND'
-            }));
-        }
-        finally {
-            core.close();
-            fs.rmSync(projectRoot, { recursive: true, force: true });
-        }
-    });
-    it('fails validation when the configured plan is disabled', () => {
-        const projectRoot = makeProjectRoot();
-        const core = openCore(projectRoot);
-        try {
-            core.upsertPlanCatalog({ planId: 'free', displayName: 'Free', status: 'archived' });
-            expect(core.validateOnboardingPolicy({
-                mode: 'auto_grant_free',
-                planId: 'free'
-            })).toEqual(expect.objectContaining({
-                valid: false,
-                code: 'ONBOARDING_PLAN_NOT_ENABLED'
-            }));
-        }
-        finally {
-            core.close();
-            fs.rmSync(projectRoot, { recursive: true, force: true });
-        }
-    });
-    it('fails validation when auto_grant_free points at a plan whose default version lacks free pricing', () => {
-        const projectRoot = makeProjectRoot();
-        const core = openCore(projectRoot);
-        try {
-            core.upsertPlanCatalog({ planId: 'team-5', displayName: 'Team 5', status: 'active' });
-            expect(core.validateOnboardingPolicy({
-                mode: 'auto_grant_free',
-                planId: 'team-5'
-            })).toEqual(expect.objectContaining({
-                valid: false,
-                code: 'ONBOARDING_PLAN_MUST_BE_FREE'
-            }));
-        }
-        finally {
-            core.close();
-            fs.rmSync(projectRoot, { recursive: true, force: true });
-        }
-    });
-    it('passes validation for require_plan_selection without a plan id', () => {
-        const projectRoot = makeProjectRoot();
-        const core = openCore(projectRoot);
-        try {
-            expect(core.validateOnboardingPolicy({
-                mode: 'require_plan_selection',
-                planId: null
-            })).toEqual({ valid: true });
-        }
-        finally {
-            core.close();
-            fs.rmSync(projectRoot, { recursive: true, force: true });
-        }
-    });
-    it('requires plan selection during registration when no explicit onboarding policy is configured', () => {
-        const projectRoot = makeProjectRoot();
-        const core = openCore(projectRoot);
-        try {
-            const created = core.registerPasswordUser({
-                email: 'implicit-onboarding@example.com',
-                password: 'ValidPassphrase123!'
-            });
-            expect(created.planSelectionRequired).toBe(true);
-            expect(created.checkoutPending).toBe(false);
-            expect(core.getAccountEntitlement(created.userId)).toEqual(expect.objectContaining({
-                state: 'pending_plan_selection'
-            }));
-            expect(core.getAccountAccessStatus(created.userId)).toEqual(expect.objectContaining({
-                gate: 'plan_selection_required',
-                canAccessApp: false,
-                canAccessPlans: true,
-                planSelectionRequired: true
-            }));
-        }
-        finally {
-            core.close();
-            fs.rmSync(projectRoot, { recursive: true, force: true });
-        }
-    });
-    it('allows backfill transitions to create pending plan selection entitlements', () => {
-        const projectRoot = makeProjectRoot();
-        const tenantId = path.basename(projectRoot);
-        const core = openCore(projectRoot);
-        try {
-            const now = new Date().toISOString();
-            core.updateGlobalSettings({
-                billing: {
-                    onboardingPolicy: {
-                        mode: 'require_plan_selection',
-                        planId: null
-                    }
-                }
-            });
-            const db = core.getDatabaseAdapter();
-            db.prepare(`
-                INSERT INTO users (id, tenant_id, email, display_name, is_disabled, created_at, updated_at)
-                VALUES (?, ?, ?, ?, 0, ?, ?)
-            `).run('pending-u1', tenantId, 'pending@example.com', 'Pending', now, now);
-            db.prepare(`
-                INSERT INTO user_billing (user_id, tenant_id, entitlement_state, created_at, updated_at)
-                VALUES (?, ?, ?, ?, ?)
-            `).run('pending-u1', tenantId, 'pending_plan_selection', now, now);
-            core.transitionCanonicalCommercialState({
-                accountId: 'pending-u1',
-                planVersionId: 'free-v1',
-                state: 'pending_plan_selection',
-                source: 'backfill',
-                updatedBy: 'backfill',
-                billingMirrorPlanId: null,
-                effectiveAt: now,
-                createdAt: now,
-                updatedAt: now
-            });
-            expect(core.hasAccountEntitlement('pending-u1')).toBe(true);
-            expect(core.getAccountAccessStatus('pending-u1')).toEqual(expect.objectContaining({
-                gate: 'plan_selection_required',
-                canAccessApp: false,
-                canAccessPlans: true,
-                planSelectionRequired: true
-            }));
-        }
-        finally {
-            core.close();
-            fs.rmSync(projectRoot, { recursive: true, force: true });
-        }
-    });
-    it('treats a live checkout_pending entitlement as checkout recovery state', () => {
-        const projectRoot = makeProjectRoot();
-        const tenantId = path.basename(projectRoot);
-        const core = openCore(projectRoot);
-        try {
-            const now = new Date().toISOString();
-            const checkoutExpiresAt = new Date(Date.now() + (60 * 60 * 1000)).toISOString();
-            core.upsertPlanCatalog({ planId: 'basic', displayName: 'Basic', status: 'active' });
-            const db = core.getDatabaseAdapter();
-            db.prepare(`
-                INSERT INTO users (id, tenant_id, email, display_name, is_disabled, created_at, updated_at)
-                VALUES (?, ?, ?, ?, 0, ?, ?)
-            `).run('checkout-u1', tenantId, 'checkout@example.com', 'Checkout', now, now);
-            core.transitionCanonicalCommercialState({
-                accountId: 'checkout-u1',
-                planVersionId: 'basic-v1',
-                state: 'checkout_pending',
-                source: 'checkout-start',
-                updatedBy: 'checkout-start',
-                billingMirrorPlanId: 'basic',
-                effectiveAt: now,
-                effectiveUntil: checkoutExpiresAt,
-                createdAt: now,
-                updatedAt: now
-            });
-            expect(core.getAccountAccessStatus('checkout-u1')).toEqual(expect.objectContaining({
-                gate: 'checkout_pending',
-                canAccessApp: false,
-                canAccessPlans: true,
-                planSelectionRequired: false,
-                message: 'Complete checkout to continue.'
-            }));
-        }
-        finally {
-            core.close();
-            fs.rmSync(projectRoot, { recursive: true, force: true });
-        }
-    });
-    it('treats an expired checkout_pending entitlement as requiring plan reselection', () => {
-        const projectRoot = makeProjectRoot();
-        const tenantId = path.basename(projectRoot);
-        const core = openCore(projectRoot);
-        try {
-            const now = new Date().toISOString();
-            const expiredAt = new Date(Date.now() - (60 * 1000)).toISOString();
-            core.upsertPlanCatalog({ planId: 'basic', displayName: 'Basic', status: 'active' });
-            const db = core.getDatabaseAdapter();
-            db.prepare(`
-                INSERT INTO users (id, tenant_id, email, display_name, is_disabled, created_at, updated_at)
-                VALUES (?, ?, ?, ?, 0, ?, ?)
-            `).run('expired-checkout-u1', tenantId, 'expired@example.com', 'Expired Checkout', now, now);
-            core.transitionCanonicalCommercialState({
-                accountId: 'expired-checkout-u1',
-                planVersionId: 'basic-v1',
-                state: 'checkout_pending',
-                source: 'checkout-start',
-                updatedBy: 'checkout-start',
-                billingMirrorPlanId: 'basic',
-                effectiveAt: now,
-                effectiveUntil: expiredAt,
-                createdAt: now,
-                updatedAt: now
-            });
-            expect(core.getAccountAccessStatus('expired-checkout-u1')).toEqual(expect.objectContaining({
-                gate: 'plan_selection_required',
-                canAccessApp: false,
-                canAccessPlans: true,
-                planSelectionRequired: true,
-                message: 'Choose a plan to continue.'
-            }));
-            expect(core.getAccountEntitlement('expired-checkout-u1')).toEqual(expect.objectContaining({
-                state: 'pending_plan_selection',
-                effectiveUntil: null
-            }));
-            const entitlementRow = db.prepare(`
-                SELECT entitlement_state, effective_until, updated_by
-                FROM account_entitlements
-                WHERE tenant_id = ? AND account_id = ?
-                LIMIT 1
-            `).get(tenantId, 'expired-checkout-u1');
-            expect(entitlementRow).toEqual(expect.objectContaining({
-                entitlement_state: 'pending_plan_selection',
-                effective_until: null,
-                updated_by: 'checkout-expired'
-            }));
-            const billingRow = db.prepare(`
-                SELECT entitlement_state, tier, effective_until
-                FROM user_billing
-                WHERE tenant_id = ? AND user_id = ?
-                LIMIT 1
-            `).get(tenantId, 'expired-checkout-u1');
-            expect(billingRow).toEqual(expect.objectContaining({
-                entitlement_state: 'pending_plan_selection',
-                tier: '',
-                effective_until: null
-            }));
-        }
-        finally {
-            core.close();
-            fs.rmSync(projectRoot, { recursive: true, force: true });
-        }
-    });
-    it('treats an expired trialing entitlement as requiring plan reselection', () => {
-        const projectRoot = makeProjectRoot();
-        const tenantId = path.basename(projectRoot);
-        const core = openCore(projectRoot);
-        try {
-            const now = new Date().toISOString();
-            const expiredAt = new Date(Date.now() - (60 * 1000)).toISOString();
-            core.upsertPlanCatalog({ planId: 'basic', displayName: 'Basic', status: 'active' });
-            const db = core.getDatabaseAdapter();
-            db.prepare(`
-                INSERT INTO users (id, tenant_id, email, display_name, is_disabled, created_at, updated_at)
-                VALUES (?, ?, ?, ?, 0, ?, ?)
-            `).run('expired-trial-u1', tenantId, 'expired-trial@example.com', 'Expired Trial', now, now);
-            core.transitionCanonicalCommercialState({
-                accountId: 'expired-trial-u1',
-                planVersionId: 'basic-v1',
-                state: 'trialing',
-                source: 'system',
-                updatedBy: 'trial-start',
-                billingMirrorPlanId: 'basic',
-                effectiveAt: now,
-                effectiveUntil: expiredAt,
-                createdAt: now,
-                updatedAt: now
-            });
-            expect(core.getAccountAccessStatus('expired-trial-u1')).toEqual(expect.objectContaining({
-                gate: 'plan_selection_required',
-                canAccessApp: false,
-                canAccessPlans: true,
-                planSelectionRequired: true,
-                message: 'Choose a plan to continue.'
-            }));
-            expect(core.getAccountEntitlement('expired-trial-u1')).toEqual(expect.objectContaining({
-                state: 'pending_plan_selection',
-                effectiveUntil: null
-            }));
-            const entitlementRow = db.prepare(`
-                SELECT entitlement_state, effective_until, updated_by
-                FROM account_entitlements
-                WHERE tenant_id = ? AND account_id = ?
-                LIMIT 1
-            `).get(tenantId, 'expired-trial-u1');
-            expect(entitlementRow).toEqual(expect.objectContaining({
-                entitlement_state: 'pending_plan_selection',
-                effective_until: null,
-                updated_by: 'trial-expired'
-            }));
-            const billingRow = db.prepare(`
-                SELECT entitlement_state, tier, effective_until
-                FROM user_billing
-                WHERE tenant_id = ? AND user_id = ?
-                LIMIT 1
-            `).get(tenantId, 'expired-trial-u1');
-            expect(billingRow).toEqual(expect.objectContaining({
-                entitlement_state: 'pending_plan_selection',
-                tier: '',
-                effective_until: null
-            }));
-        }
-        finally {
-            core.close();
-            fs.rmSync(projectRoot, { recursive: true, force: true });
-        }
-    });
-    it('auto-heals a pending-plan-selection entitlement from an active Stripe billing mirror', () => {
-        const projectRoot = makeProjectRoot();
-        const tenantId = path.basename(projectRoot);
-        const core = openCore(projectRoot);
-        try {
-            const now = new Date().toISOString();
-            const nextRenewal = new Date(Date.now() + (24 * 60 * 60 * 1000)).toISOString();
-            core.upsertPlanCatalog({ planId: 'team-5', displayName: 'Team 5', status: 'active' });
-            const db = core.getDatabaseAdapter();
-            db.prepare(`
-                INSERT INTO users (id, tenant_id, email, display_name, is_disabled, created_at, updated_at)
-                VALUES (?, ?, ?, ?, 0, ?, ?)
-            `).run('mirror-heal-u1', tenantId, 'mirror-heal@example.com', 'Mirror Heal', now, now);
-            core.transitionCanonicalCommercialState({
-                accountId: 'mirror-heal-u1',
-                planVersionId: 'free-v1',
-                state: 'pending_plan_selection',
-                source: 'backfill',
-                updatedBy: 'backfill',
-                billingMirrorPlanId: null,
-                effectiveAt: now,
-                createdAt: now,
-                updatedAt: now
-            });
-            db.prepare(`
-                UPDATE user_billing
-                SET stripe_customer_id = ?, stripe_subscription_id = ?, entitlement_state = ?, tier = ?, effective_until = ?, updated_at = ?
-                WHERE tenant_id = ? AND user_id = ?
-            `).run('cus_heal', 'sub_heal', 'active', 'team-5', nextRenewal, now, tenantId, 'mirror-heal-u1');
-            expect(core.getAccountAccessStatus('mirror-heal-u1')).toEqual(expect.objectContaining({
-                gate: 'ok',
-                canAccessApp: true,
-                planSelectionRequired: false
-            }));
-            expect(core.getAccountEntitlement('mirror-heal-u1')).toEqual(expect.objectContaining({
-                state: 'active',
-                planId: 'team-5',
-                planVersionId: 'team-5-v1',
-                effectiveUntil: nextRenewal
-            }));
-            const entitlementRow = db.prepare(`
-                SELECT entitlement_state, plan_version_id, effective_until, updated_by
-                FROM account_entitlements
-                WHERE tenant_id = ? AND account_id = ?
-                LIMIT 1
-            `).get(tenantId, 'mirror-heal-u1');
-            expect(entitlementRow).toEqual(expect.objectContaining({
-                entitlement_state: 'active',
-                plan_version_id: 'team-5-v1',
-                effective_until: nextRenewal,
-                updated_by: 'billing-mirror-auto-heal'
-            }));
-        }
-        finally {
-            core.close();
-            fs.rmSync(projectRoot, { recursive: true, force: true });
-        }
-    });
-    it('auto-heals a pending-plan-selection entitlement from Stripe status and price mapping when mirror state is stale', () => {
-        const projectRoot = makeProjectRoot();
-        const tenantId = path.basename(projectRoot);
-        const core = openCore(projectRoot);
-        try {
-            const now = new Date().toISOString();
-            const nextRenewal = new Date(Date.now() + (24 * 60 * 60 * 1000)).toISOString();
-            core.upsertPlanCatalog({ planId: 'team-5', displayName: 'Team 5', status: 'active' });
-            const db = core.getDatabaseAdapter();
-            db.prepare(`
-                INSERT INTO users (id, tenant_id, email, display_name, is_disabled, created_at, updated_at)
-                VALUES (?, ?, ?, ?, 0, ?, ?)
-            `).run('mirror-price-heal-u1', tenantId, 'mirror-price-heal@example.com', 'Mirror Price Heal', now, now);
-            core.transitionCanonicalCommercialState({
-                accountId: 'mirror-price-heal-u1',
-                planVersionId: 'free-v1',
-                state: 'pending_plan_selection',
-                source: 'backfill',
-                updatedBy: 'checkout-expired',
-                billingMirrorPlanId: null,
-                effectiveAt: now,
-                createdAt: now,
-                updatedAt: now
-            });
-            db.prepare(`
-                UPDATE user_billing
-                SET stripe_customer_id = ?, stripe_subscription_id = ?, stripe_price_id = ?, stripe_status = ?, entitlement_state = ?, tier = ?, effective_until = ?, updated_at = ?
-                WHERE tenant_id = ? AND user_id = ?
-            `).run('cus_heal_2', 'sub_heal_2', 'price_team_5_month', 'active', 'pending_plan_selection', 'team-5', nextRenewal, now, tenantId, 'mirror-price-heal-u1');
-            db.prepare(`
-                INSERT INTO billing_price_mappings (tenant_id, plan_version_id, billing_interval, stripe_price_id, active, created_at, updated_at)
-                VALUES (?, ?, ?, ?, 1, ?, ?)
-            `).run(tenantId, 'team-5-v1', 'month', 'price_team_5_month', now, now);
-            expect(core.getAccountAccessStatus('mirror-price-heal-u1')).toEqual(expect.objectContaining({
-                gate: 'ok',
-                canAccessApp: true,
-                planSelectionRequired: false
-            }));
-            expect(core.getAccountEntitlement('mirror-price-heal-u1')).toEqual(expect.objectContaining({
-                state: 'active',
-                planId: 'team-5',
-                planVersionId: 'team-5-v1',
-                effectiveUntil: nextRenewal
-            }));
-        }
-        finally {
-            core.close();
-            fs.rmSync(projectRoot, { recursive: true, force: true });
-        }
-    });
-});

package/dist/core/Stats.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/core/Stats.test.js

@@ -1,36 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, describe, expect, it } from 'vitest';
-import { TaskforceCore } from './Taskforce';
-const roots = [];
-function createCore() {
-    const projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'taskforce-stats-'));
-    roots.push(projectRoot);
-    fs.writeFileSync(path.join(projectRoot, 'package.json'), JSON.stringify({ name: 'stats-test' }), 'utf-8');
-    return new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-}
-afterEach(() => {
-    while (roots.length > 0) {
-        const root = roots.pop();
-        if (root)
-            fs.rmSync(root, { recursive: true, force: true });
-    }
-});
-describe('TaskforceCore stats typing', () => {
-    it('returns archived aggregate counts as numbers', () => {
-        const core = createCore();
-        const doneTask = core.createTask({ title: 'Done task', status: 'task' });
-        const cancelledTask = core.createTask({ title: 'Cancelled task', status: 'task' });
-        core.archiveTask(doneTask.id, false);
-        core.archiveTask(cancelledTask.id, true, 'No longer needed');
-        const stats = core.getStats();
-        expect(stats.archived.total).toBe(2);
-        expect(stats.archived.doneCount).toBe(1);
-        expect(stats.archived.cancelledCount).toBe(1);
-        expect(typeof stats.archived.total).toBe('number');
-        expect(typeof stats.archived.doneCount).toBe('number');
-        expect(typeof stats.archived.cancelledCount).toBe('number');
-        core.close();
-    });
-});

package/dist/core/SystemAdmin.test.d.ts

@@ -1 +0,0 @@
-export {};