@taskforcehq/taskforce 0.3.168

package/dist/core/SetupState.test.js

@@ -0,0 +1,113 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { TaskforceCore } from './Taskforce';
+const createdRoots = [];
+const originalHome = process.env.HOME;
+function createProjectRoot(prefix = 'taskforce-setup-state-', packageName) {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+    process.env.HOME = root;
+    if (packageName) {
+        fs.writeFileSync(path.join(root, 'package.json'), JSON.stringify({ name: packageName }), 'utf-8');
+    }
+    createdRoots.push(root);
+    return root;
+}
+afterEach(() => {
+    process.env.HOME = originalHome;
+    while (createdRoots.length > 0) {
+        const root = createdRoots.pop();
+        if (root && fs.existsSync(root)) {
+            fs.rmSync(root, { recursive: true, force: true });
+        }
+    }
+});
+describe('TaskforceCore - setup state and local name resolution', () => {
+    it('uses nearest package.json name as local suggested workspace name', () => {
+        const projectRoot = createProjectRoot('taskforce-setup-pkg-', 'alpha-local');
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        const setup = core.getSetupState('default', 'local');
+        expect(setup.suggestedWorkspaceName).toBe('alpha-local');
+        expect(core.getPaths().projectName).toBe('alpha-local');
+    });
+    it('falls back to folder name when package.json name is missing', () => {
+        const projectRoot = createProjectRoot('taskforce-setup-folder-');
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        const expectedFolder = path.basename(projectRoot);
+        const setup = core.getSetupState('default', 'local');
+        expect(setup.suggestedWorkspaceName).toBe(expectedFolder);
+        expect(core.getPaths().projectName).toBe(expectedFolder);
+    });
+    it('marks cloud workspace setup as missing when workspace name is placeholder', () => {
+        const projectRoot = createProjectRoot('taskforce-setup-cloud-', 'cloud-test');
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        const setup = core.getSetupState('default', 'cloud');
+        expect(setup.workspaceSetupState).toBe('missing');
+    });
+    it('marks local workspace setup as missing when workspace name is placeholder', () => {
+        const projectRoot = createProjectRoot('taskforce-setup-local-', 'local-test');
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        const setup = core.getSetupState('default', 'local');
+        expect(setup.workspaceSetupState).toBe('missing');
+    });
+    it('marks cloud workspace setup as present when workspace has user-defined display name', () => {
+        const projectRoot = createProjectRoot('taskforce-setup-cloud-present-', 'cloud-test');
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        const db = core.db;
+        const now = new Date().toISOString();
+        db.prepare(`
+            INSERT INTO workspaces (id, tenant_id, slug, name, description, created_at, updated_at)
+            VALUES (?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT (id) DO UPDATE SET
+                name = excluded.name,
+                updated_at = excluded.updated_at
+        `).run('workspace-1', 'default', 'workspace-1', 'Acme Project', 'Test workspace', now, now);
+        const setup = core.getSetupState('workspace-1', 'cloud');
+        expect(setup.workspaceSetupState).toBe('present');
+        expect(setup.workspace?.name).toBe('Acme Project');
+    });
+    it('marks global setup as present in cloud when global setup mode is configured', () => {
+        const projectRoot = createProjectRoot('taskforce-setup-mode-', 'mode-test');
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        core.updateGlobalSettings({ setup: { mode: 'operations', forceSetup: true } });
+        const setup = core.getSetupState('default', 'cloud');
+        expect(setup.globalSetupState).toBe('present');
+        expect(setup.mode).toBe('operations');
+        expect(setup.forceSetup).toBe(true);
+    });
+    it('marks local global setup as present when user-level global settings row exists', () => {
+        const projectRoot = createProjectRoot('taskforce-setup-local-global-db-', 'db-test');
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        core.updateGlobalSettings({ setup: { mode: 'core' } });
+        const setup = core.getSetupState('default', 'local');
+        expect(setup.globalSetupState).toBe('present');
+    });
+    it('updates workspace profile with user-defined name and description', () => {
+        const projectRoot = createProjectRoot('taskforce-setup-update-', 'update-test');
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        const db = core.db;
+        const now = new Date().toISOString();
+        db.prepare('INSERT OR IGNORE INTO workspaces (id, tenant_id, slug, name, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)').run('default', 'default', 'default', 'Default Workspace', now, now);
+        const workspace = core.updateWorkspaceProfile('default', {
+            name: 'Delta Mission',
+            description: 'Main rollout workspace'
+        });
+        expect(workspace.name).toBe('Delta Mission');
+        expect(workspace.description).toBe('Main rollout workspace');
+        const setup = core.getSetupState('default', 'cloud');
+        expect(setup.workspaceSetupState).toBe('present');
+    });
+    it('treats user-saved "Default Workspace" without system placeholder description as configured', () => {
+        const projectRoot = createProjectRoot('taskforce-setup-default-name-', 'default-name-test');
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        const db = core.db;
+        const now = new Date().toISOString();
+        db.prepare('INSERT OR IGNORE INTO workspaces (id, tenant_id, slug, name, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)').run('default', 'default', 'default', 'Default Workspace', now, now);
+        core.updateWorkspaceProfile('default', {
+            name: 'Default Workspace'
+        });
+        const setup = core.getSetupState('default', 'cloud');
+        expect(setup.workspaceSetupState).toBe('present');
+    });
+});

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

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

package/dist/core/SystemAdmin.test.js

@@ -0,0 +1,295 @@
+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-system-admin-'));
+}
+function openCore(projectRoot) {
+    return new TaskforceCore({
+        projectRoot,
+        storagePath: path.join(projectRoot, '.taskforce')
+    });
+}
+describe('TaskforceCore system admin model', () => {
+    it('creates billing row for registration without workspace', () => {
+        const projectRoot = makeProjectRoot();
+        const core = openCore(projectRoot);
+        try {
+            const created = core.registerPasswordUser({
+                email: 'billing-noworkspace@example.com',
+                password: 'password123'
+            });
+            const db = core.db;
+            const row = db.prepare(`
+                SELECT user_id, tier, entitlement_state
+                FROM user_billing
+                WHERE tenant_id = ? AND user_id = ?
+                LIMIT 1
+            `).get('default', created.userId);
+            expect(row?.user_id).toBe(created.userId);
+            expect(row?.tier).toBe('free');
+            expect(row?.entitlement_state).toBe('free');
+        }
+        finally {
+            core.close();
+            fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+    });
+    it('creates billing row for registration with workspace', () => {
+        const projectRoot = makeProjectRoot();
+        const core = openCore(projectRoot);
+        try {
+            core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
+            const created = core.registerPasswordUser({
+                email: 'billing-workspace@example.com',
+                password: 'password123',
+                workspaceId: 'workspace-1',
+                role: 'member'
+            });
+            const db = core.db;
+            const row = db.prepare(`
+                SELECT user_id, tier, entitlement_state
+                FROM user_billing
+                WHERE tenant_id = ? AND user_id = ?
+                LIMIT 1
+            `).get('default', created.userId);
+            expect(row?.user_id).toBe(created.userId);
+            expect(row?.tier).toBe('free');
+            expect(row?.entitlement_state).toBe('free');
+        }
+        finally {
+            core.close();
+            fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+    });
+    it('assigns first registered user as system_admin and later users as user', () => {
+        const projectRoot = makeProjectRoot();
+        const core = openCore(projectRoot);
+        try {
+            const first = core.registerPasswordUser({
+                email: 'first@example.com',
+                password: 'password123'
+            });
+            const second = core.registerPasswordUser({
+                email: 'second@example.com',
+                password: 'password123'
+            });
+            expect(core.getSystemRole(first.userId)).toBe('system_admin');
+            expect(core.getSystemRole(second.userId)).toBe('user');
+            expect(core.countSystemAdmins()).toBe(1);
+        }
+        finally {
+            core.close();
+            fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+    });
+    it('applies registration betaAccess at user level', () => {
+        const projectRoot = makeProjectRoot();
+        const core = openCore(projectRoot);
+        try {
+            core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
+            core.registerPasswordUser({
+                email: 'bootstrap-admin@example.com',
+                password: 'password123'
+            });
+            const user = core.registerPasswordUser({
+                email: 'beta-off@example.com',
+                password: 'password123',
+                workspaceId: 'workspace-1',
+                role: 'owner',
+                betaAccess: false
+            });
+            expect(core.getUserBetaAccess(user.userId)).toBe(false);
+            expect(core.setUserBetaAccessGlobal(user.userId, true)).toBe(true);
+            expect(core.getUserBetaAccess(user.userId)).toBe(true);
+        }
+        finally {
+            core.close();
+            fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+    });
+    it('enforces last-system-admin guard on demote and disable', () => {
+        const projectRoot = makeProjectRoot();
+        const core = openCore(projectRoot);
+        try {
+            const first = core.registerPasswordUser({
+                email: 'first@example.com',
+                password: 'password123'
+            });
+            expect(() => core.setSystemRole(first.userId, 'user')).toThrowError(/last system admin/i);
+            expect(() => core.setUserDisabledGlobal(first.userId, true)).toThrowError(/last system admin/i);
+        }
+        finally {
+            core.close();
+            fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+    });
+    it('does not auto-promote system role from workspace role changes post-migration', () => {
+        const projectRoot = makeProjectRoot();
+        const core = openCore(projectRoot);
+        try {
+            const first = core.registerPasswordUser({
+                email: 'first@example.com',
+                password: 'password123'
+            });
+            const second = core.registerPasswordUser({
+                email: 'second@example.com',
+                password: 'password123'
+            });
+            core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
+            core.ensureBootstrapUserAccess({
+                userId: second.userId,
+                workspaceId: 'workspace-1',
+                role: 'member',
+                email: 'second@example.com'
+            });
+            expect(core.updateWorkspaceUserRole(second.userId, 'workspace-1', 'admin')).toBe(true);
+            expect(core.getSystemRole(second.userId)).toBe('user');
+            expect(core.getSystemRole(first.userId)).toBe('system_admin');
+        }
+        finally {
+            core.close();
+            fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+    });
+    it('backfills owner/admin memberships once and does not rerun after completion', () => {
+        const projectRoot = makeProjectRoot();
+        const initial = openCore(projectRoot);
+        try {
+            initial.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
+            initial.ensureBootstrapUserAccess({
+                userId: 'owner-1',
+                workspaceId: 'workspace-1',
+                role: 'owner',
+                email: 'owner@example.com'
+            });
+            initial.ensureBootstrapUserAccess({
+                userId: 'admin-1',
+                workspaceId: 'workspace-1',
+                role: 'admin',
+                email: 'admin@example.com'
+            });
+            initial.ensureBootstrapUserAccess({
+                userId: 'member-1',
+                workspaceId: 'workspace-1',
+                role: 'member',
+                email: 'member@example.com'
+            });
+            const db = initial.db;
+            db.prepare(`UPDATE users SET system_role = 'user' WHERE tenant_id = ?`).run('default');
+            db.prepare(`DELETE FROM system_settings WHERE tenant_id = ? AND settings_key = ?`).run('default', 'migration.system_role.backfill.v1');
+        }
+        finally {
+            initial.close();
+        }
+        const reopened = openCore(projectRoot);
+        try {
+            expect(reopened.getSystemRole('owner-1')).toBe('system_admin');
+            expect(reopened.getSystemRole('admin-1')).toBe('system_admin');
+            expect(reopened.getSystemRole('member-1')).toBe('user');
+            expect(reopened.countSystemAdmins()).toBe(2);
+            expect(reopened.setSystemRole('owner-1', 'user')).toBe(true);
+        }
+        finally {
+            reopened.close();
+        }
+        const reopenedAgain = openCore(projectRoot);
+        try {
+            expect(reopenedAgain.getSystemRole('owner-1')).toBe('user');
+            expect(reopenedAgain.getSystemRole('admin-1')).toBe('system_admin');
+            expect(reopenedAgain.countSystemAdmins()).toBe(1);
+        }
+        finally {
+            reopenedAgain.close();
+            fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+    });
+    it('backfills user beta access from membership beta flags once', () => {
+        const projectRoot = makeProjectRoot();
+        const initial = openCore(projectRoot);
+        try {
+            initial.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
+            initial.ensureBootstrapUserAccess({
+                userId: 'beta-on',
+                workspaceId: 'workspace-1',
+                role: 'member',
+                email: 'beta-on@example.com'
+            });
+            initial.ensureBootstrapUserAccess({
+                userId: 'beta-off',
+                workspaceId: 'workspace-1',
+                role: 'member',
+                email: 'beta-off@example.com'
+            });
+            initial.setWorkspaceUserBetaAccess('beta-off', 'workspace-1', false);
+            const db = initial.db;
+            db.prepare(`UPDATE users SET beta_access = 1 WHERE tenant_id = ?`).run('default');
+            db.prepare(`DELETE FROM system_settings WHERE tenant_id = ? AND settings_key = ?`).run('default', 'migration.user_beta_access.backfill.v1');
+        }
+        finally {
+            initial.close();
+        }
+        const reopened = openCore(projectRoot);
+        try {
+            expect(reopened.getUserBetaAccess('beta-on')).toBe(true);
+            expect(reopened.getUserBetaAccess('beta-off')).toBe(false);
+            expect(reopened.setUserBetaAccessGlobal('beta-off', true)).toBe(true);
+        }
+        finally {
+            reopened.close();
+        }
+        const reopenedAgain = openCore(projectRoot);
+        try {
+            expect(reopenedAgain.getUserBetaAccess('beta-off')).toBe(true);
+        }
+        finally {
+            reopenedAgain.close();
+            fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+    });
+    it('resolvePreferredUserWorkspaceId prefers explicit and persisted ids before fallback', () => {
+        const projectRoot = makeProjectRoot();
+        const core = openCore(projectRoot);
+        try {
+            core.createWorkspace({ workspaceId: 'workspace-a', name: 'Workspace A' });
+            core.createWorkspace({ workspaceId: 'workspace-b', name: 'Workspace B' });
+            core.ensureBootstrapUserAccess({
+                userId: 'member-1',
+                workspaceId: 'workspace-a',
+                role: 'member',
+                email: 'member-1@example.com'
+            });
+            core.ensureBootstrapUserAccess({
+                userId: 'member-1',
+                workspaceId: 'workspace-b',
+                role: 'member',
+                email: 'member-1@example.com'
+            });
+            expect(core.resolvePreferredUserWorkspaceId('member-1', { preferredWorkspaceId: 'workspace-b' })).toBe('workspace-b');
+            expect(core.resolvePreferredUserWorkspaceId('member-1', { persistedWorkspaceId: 'workspace-a' })).toBe('workspace-a');
+            expect(core.resolvePreferredUserWorkspaceId('member-1', { preferredWorkspaceId: 'workspace-missing', persistedWorkspaceId: 'workspace-b' })).toBe('workspace-b');
+            expect(core.resolvePreferredUserWorkspaceId('member-1')).toBeTruthy();
+        }
+        finally {
+            core.close();
+            fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+    });
+    it('resolvePreferredUserWorkspaceId returns null for users with no active memberships', () => {
+        const projectRoot = makeProjectRoot();
+        const core = openCore(projectRoot);
+        try {
+            const created = core.registerPasswordUser({
+                email: 'nomembership@example.com',
+                password: 'password123'
+            });
+            expect(core.resolvePreferredUserWorkspaceId(created.userId)).toBeNull();
+        }
+        finally {
+            core.close();
+            fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+    });
+});

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

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

package/dist/core/TaskTaxonomyValidation.test.js

@@ -0,0 +1,64 @@
+import { describe, it, expect } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { TaskforceCore } from './Taskforce';
+function makeTempProjectRoot() {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'taskforce-taxonomy-'));
+    fs.mkdirSync(root, { recursive: true });
+    return root;
+}
+describe('TaskforceCore taxonomy validation', () => {
+    it('falls back unresolved category and approach to default', () => {
+        const projectRoot = makeTempProjectRoot();
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        const task = core.createTask({
+            title: 'Taxonomy Fallback',
+            category: 'security',
+            approach: 'unknown-approach'
+        });
+        expect(task.category).toBe('default');
+        expect(task.approach).toBe('default');
+        core.close();
+        fs.rmSync(projectRoot, { recursive: true, force: true });
+    });
+    it('normalizes exact taxonomy aliases by token match', () => {
+        const projectRoot = makeTempProjectRoot();
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        core.updateCategories([{ value: 'ui/ux', label: 'UI/UX' }]);
+        core.updateTypes([{ value: 'feature', label: 'Feature' }]);
+        const task = core.createTask({
+            title: 'Alias Match',
+            category: 'UI UX',
+            type: 'FEATURE'
+        });
+        expect(task.category).toBe('ui/ux');
+        expect(task.type).toBe('feature');
+        core.close();
+        fs.rmSync(projectRoot, { recursive: true, force: true });
+    });
+    it('auto-reassigns removed categories and approaches to default', () => {
+        const projectRoot = makeTempProjectRoot();
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        core.updateCategories([
+            { value: 'general', label: 'General' },
+            { value: 'custom', label: 'Custom' }
+        ]);
+        core.updateApproaches([
+            { value: 'evaluate', label: 'Evaluate' },
+            { value: 'custom-approach', label: 'Custom Approach' }
+        ]);
+        const task = core.createTask({
+            title: 'Reassign Test',
+            category: 'custom',
+            approach: 'custom-approach'
+        });
+        core.updateCategories([{ value: 'general', label: 'General' }]);
+        core.updateApproaches([{ value: 'evaluate', label: 'Evaluate' }]);
+        const reloaded = core.getTask(task.id);
+        expect(reloaded?.category).toBe('default');
+        expect(reloaded?.approach).toBe('default');
+        core.close();
+        fs.rmSync(projectRoot, { recursive: true, force: true });
+    });
+});