@taskforcehq/taskforce 0.3.170 → 0.3.300

package/scripts/bootstrap-playwright-auth.mjs

@@ -0,0 +1,155 @@
+import { chromium } from '@playwright/test';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+function asNonEmpty(value) {
+    return String(value || '').trim();
+}
+
+function resolveBaseUrl() {
+    const raw = asNonEmpty(process.env.TASKFORCE_PLAYWRIGHT_CLOUD_BASE_URL)
+        || asNonEmpty(process.env.SYNC_SOAK_CLOUD_BASE_URL)
+        || 'https://app.taskforcehq.ai';
+    return raw.replace(/\/+$/, '');
+}
+
+function resolveStorageStatePath() {
+    return asNonEmpty(process.env.TASKFORCE_PLAYWRIGHT_STORAGE_STATE)
+        || path.join(os.homedir(), '.codex', 'playwright', 'taskforce-cloud-auth.json');
+}
+
+function resolveCredentials() {
+    const email = asNonEmpty(process.env.TASKFORCE_E2E_EMAIL) || asNonEmpty(process.env.SYNC_SOAK_EMAIL);
+    const password = asNonEmpty(process.env.TASKFORCE_E2E_PASSWORD) || asNonEmpty(process.env.SYNC_SOAK_PASSWORD);
+    if (!email || !password) {
+        throw new Error(
+            'Missing credentials. Set TASKFORCE_E2E_EMAIL/TASKFORCE_E2E_PASSWORD or SYNC_SOAK_EMAIL/SYNC_SOAK_PASSWORD.'
+        );
+    }
+    return { email, password };
+}
+
+async function ensureParentDir(filePath) {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+}
+
+async function readSessionAuthenticated(page, baseUrl) {
+    return await page.evaluate(async (origin) => {
+        const candidates = [
+            `${origin}/api/taskforce/auth/session`,
+            `${origin}/taskforce/api/taskforce/auth/session`
+        ];
+        for (const url of candidates) {
+            try {
+                const response = await fetch(url, {
+                    method: 'GET',
+                    credentials: 'include',
+                    headers: { Accept: 'application/json' }
+                });
+                if (!response.ok) continue;
+                const payload = await response.json().catch(() => ({}));
+                if (payload && typeof payload === 'object' && 'authenticated' in payload) {
+                    return Boolean(payload.authenticated);
+                }
+            } catch {
+                // ignore endpoint miss or cross-origin fetch issues
+            }
+        }
+        return false;
+    }, baseUrl);
+}
+
+async function sessionLooksValid(context, baseUrl) {
+    const page = await context.newPage();
+    try {
+        await page.goto(`${baseUrl}/taskforce/`, { waitUntil: 'domcontentloaded', timeout: 60000 });
+        await page.waitForTimeout(500);
+        if (!/(?:\/taskforce)?\/login(?:\?|$)/i.test(page.url())) {
+            return true;
+        }
+        return await readSessionAuthenticated(page, baseUrl);
+    } catch {
+        return false;
+    } finally {
+        await page.close().catch(() => undefined);
+    }
+}
+
+async function performLogin(context, baseUrl, email, password) {
+    const page = await context.newPage();
+    await page.goto(`${baseUrl}/login?mode=login&next=${encodeURIComponent('/taskforce/')}`, {
+        waitUntil: 'domcontentloaded',
+        timeout: 60000
+    });
+
+    const emailField = page.locator('input[type="email"]').first();
+    const passwordField = page.locator('input[type="password"]').first();
+    const signInButton = page.getByRole('button', { name: /^sign in$/i }).first();
+
+    await emailField.waitFor({ state: 'visible', timeout: 20000 });
+    await passwordField.waitFor({ state: 'visible', timeout: 20000 });
+
+    await emailField.fill(email);
+    await passwordField.fill(password);
+
+    await Promise.all([
+        signInButton.click(),
+        page.waitForLoadState('domcontentloaded').catch(() => undefined)
+    ]);
+
+    await page.waitForFunction(
+        () => !/(?:\/taskforce)?\/login(?:\?|$)/i.test(window.location.pathname + window.location.search),
+        undefined,
+        { timeout: 30000 }
+    ).catch(() => undefined);
+
+    const authenticated = await readSessionAuthenticated(page, baseUrl);
+    if (!authenticated) {
+        const feedback = await page.locator('[class*="loginError"], [data-testid*="login-error"]').first().textContent().catch(() => '');
+        throw new Error(`Login did not produce an authenticated session. url=${page.url()} feedback=${String(feedback || '').trim()}`);
+    }
+
+    await page.goto(`${baseUrl}/taskforce/`, { waitUntil: 'domcontentloaded', timeout: 60000 });
+    await page.close();
+}
+
+async function main() {
+    const baseUrl = resolveBaseUrl();
+    const storageStatePath = resolveStorageStatePath();
+    const { email, password } = resolveCredentials();
+    const forceLogin = /^(1|true|yes)$/i.test(asNonEmpty(process.env.TASKFORCE_PLAYWRIGHT_FORCE_LOGIN));
+
+    await ensureParentDir(storageStatePath);
+
+    const browser = await chromium.launch({ headless: true });
+    try {
+        if (!forceLogin) {
+            try {
+                await fs.access(storageStatePath);
+                const existingContext = await browser.newContext({ storageState: storageStatePath });
+                const existingSessionValid = await sessionLooksValid(existingContext, baseUrl);
+                await existingContext.close();
+                if (existingSessionValid) {
+                    console.log(`Playwright auth session already valid at ${storageStatePath}`);
+                    return;
+                }
+            } catch {
+                // Missing or stale session file; refresh below.
+            }
+        }
+
+        const freshContext = await browser.newContext();
+        await performLogin(freshContext, baseUrl, email, password);
+        await freshContext.storageState({ path: storageStatePath });
+        await freshContext.close();
+        console.log(`Saved Playwright auth session to ${storageStatePath}`);
+    } finally {
+        await browser.close();
+    }
+}
+
+main().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+});

package/scripts/check-compat-boundaries.mjs

@@ -0,0 +1,41 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+const projectRoot = process.cwd();
+const sourceRoot = path.join(projectRoot, 'src');
+const allowedExtensions = new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.md']);
+const compatMarkers = ['COMPAT_TRACK:', 'COMPAT_REMOVE_AFTER:'];
+const allowedPrefixes = [
+    path.join(projectRoot, 'src', 'compat'),
+    path.join(projectRoot, 'src', 'migrations')
+];
+const violations = [];
+
+function walk(dir) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            walk(fullPath);
+            continue;
+        }
+        if (!allowedExtensions.has(path.extname(entry.name))) continue;
+        const content = fs.readFileSync(fullPath, 'utf8');
+        if (!compatMarkers.some((marker) => content.includes(marker))) continue;
+        const normalized = path.normalize(fullPath);
+        if (allowedPrefixes.some((prefix) => normalized.startsWith(prefix))) continue;
+        violations.push(path.relative(projectRoot, fullPath));
+    }
+}
+
+walk(sourceRoot);
+
+if (violations.length > 0) {
+    console.error('[compat-boundaries] Compat markers found outside src/compat or src/migrations:');
+    for (const violation of violations) {
+        console.error(`- ${violation}`);
+    }
+    process.exit(1);
+}
+
+console.log('[compat-boundaries] OK');

package/scripts/check-env.ts

@@ -1,4 +1,4 @@
-import { assertEnvironment, type EnvValidationTarget } from '../src/config/envSchema.js';
+import { type EnvValidationTarget, validateEnvironment } from '../src/config/envSchema.js';
 
 function readArg(name: string): string | null {
     const prefix = `${name}=`;
@@ -15,7 +15,14 @@ const target: EnvValidationTarget = (targetRaw === 'server' || targetRaw === 'so
 const strictUnknown = ['1', 'true', 'yes', 'on'].includes(strictRaw);
 
 try {
-    assertEnvironment(process.env, { target, strictUnknown });
+    const result = validateEnvironment(process.env, { target, strictUnknown });
+    if (!result.ok) {
+        const details = result.errors.map((entry) => `- ${entry}`).join('\n');
+        throw new Error(`Environment validation failed:\n${details}`);
+    }
+    for (const warning of result.warnings) {
+        console.warn(`[env] warning: ${warning}`);
+    }
     console.log(`[env] validation passed (target=${target}, strictUnknown=${strictUnknown})`);
 } catch (error) {
     const message = String((error as Error)?.message || error);

package/scripts/debug-login.mjs

@@ -0,0 +1,32 @@
+// One-off Playwright script to inspect login form inputs on the production app.
+// Run with: node scripts/debug-login.mjs
+import { chromium } from 'playwright';
+
+(async () => {
+    const browser = await chromium.launch();
+    const context = await browser.newContext();
+    const page = await context.newPage();
+    try {
+        await page.goto('https://app.taskforcehq.ai/taskforce/login', { timeout: 15000 });
+        console.log("Navigated to /taskforce/login");
+        await page.waitForTimeout(2000);
+        const inputs = await page.locator('input').evaluateAll(els => els.map(e => ({ type: e.type, placeholder: e.placeholder, name: e.name })));
+        console.log("Inputs on /taskforce/login:", inputs);
+
+        await page.goto('https://app.taskforcehq.ai/taskforce/', { timeout: 15000 });
+        console.log("Navigated to /taskforce/");
+        await page.waitForTimeout(2000);
+        const inputs2 = await page.locator('input').evaluateAll(els => els.map(e => ({ type: e.type, placeholder: e.placeholder, name: e.name })));
+        console.log("Inputs on /taskforce/:", inputs2);
+
+        await page.goto('https://app.taskforcehq.ai/taskforce/', { timeout: 15000 });
+        console.log("Navigated to /taskforce/");
+        await page.waitForTimeout(2000);
+        const inputs3 = await page.locator('input').evaluateAll(els => els.map(e => ({ type: e.type, placeholder: e.placeholder, name: e.name })));
+        console.log("Inputs on /taskforce/:", inputs3);
+    } catch (e) {
+        console.error(e);
+    } finally {
+        await browser.close();
+    }
+})();

package/scripts/migrate-planning-model.ts

@@ -0,0 +1,233 @@
+import { TaskforceCore } from '../src/core/Taskforce.js';
+import type { ChecklistItem, TaskItem } from '../src/types.js';
+import { collectSubtreeTaskIds } from '../src/utils/taskHierarchy.js';
+
+type MigrationOptions = {
+    workspaceId: string | null;
+    all: boolean;
+    dryRun: boolean;
+};
+
+type WorkspaceMigrationSummary = {
+    workspaceId: string;
+    rootParentCount: number;
+    descendantTaskCount: number;
+    createdWorkstreams: number;
+    deletedRootTasks: number;
+    updatedTasks: number;
+};
+
+type LegacyTaskRow = TaskItem & { isArchived?: boolean };
+
+function readFlag(name: string): string | null {
+    const prefix = `${name}=`;
+    const match = process.argv.find((arg) => arg.startsWith(prefix));
+    return match ? match.slice(prefix.length) : null;
+}
+
+function parseArgs(): MigrationOptions {
+    const workspaceId = (readFlag('--workspace') || '').trim() || null;
+    const all = process.argv.includes('--all');
+    const dryRun = process.argv.includes('--dry-run');
+    if (workspaceId && all) {
+        throw new Error('Use either --workspace=<id> or --all, not both.');
+    }
+    return { workspaceId, all, dryRun };
+}
+
+function normalizeOwnerId(task: TaskItem): string | null {
+    const raw = String(task.assignee || '').trim();
+    if (!raw || raw === 'unassigned') return null;
+    return raw;
+}
+
+function checklistItemsToDescription(checklistItems: ChecklistItem[] | undefined, baseDescription: string | null | undefined): string | null {
+    const items = Array.isArray(checklistItems) ? checklistItems : [];
+    if (items.length === 0) return typeof baseDescription === 'string' && baseDescription.trim() ? baseDescription : null;
+    const checklistText = items
+        .sort((left, right) => Number(left.order || 0) - Number(right.order || 0))
+        .map((item) => `- [${item.isCompleted ? 'x' : ' '}] ${item.title}`)
+        .join('\n');
+    const trimmedBase = String(baseDescription || '').trim();
+    return [trimmedBase, 'Former checklist', checklistText].filter(Boolean).join('\n\n');
+}
+
+function listWorkspaceIds(core: TaskforceCore): string[] {
+    const preferred = core.resolvePreferredWorkspaceId({ allowDefault: true });
+    const db = (core as any).db;
+    const tenantId = core.getPaths().tenantId;
+    const rows = db.prepare(`
+        SELECT id
+        FROM workspaces
+        WHERE tenant_id = ?
+        ORDER BY created_at ASC
+    `).all(tenantId) as Array<{ id?: string }>;
+    const ids = rows
+        .map((row) => String(row.id || '').trim())
+        .filter(Boolean);
+    if (ids.length > 0) return ids;
+    return [preferred || 'default'];
+}
+
+function listAllTasksForWorkspace(core: TaskforceCore, workspaceId: string): LegacyTaskRow[] {
+    const active = core.listTasks(workspaceId).tasks;
+    const archived = core.listArchive(workspaceId).archived;
+    return [...active, ...archived];
+}
+
+function migrateWorkspace(core: TaskforceCore, workspaceId: string, dryRun: boolean): WorkspaceMigrationSummary {
+    const existingInitiatives = core.listInitiatives(workspaceId);
+    const existingWorkstreams = core.listWorkstreams(workspaceId);
+    if (existingInitiatives.length > 0 || existingWorkstreams.length > 0) {
+        throw new Error(
+            `Workspace ${workspaceId} already has planning entities (${existingInitiatives.length} initiatives, ${existingWorkstreams.length} workstreams). Aborting.`
+        );
+    }
+
+    const allTasks = listAllTasksForWorkspace(core, workspaceId);
+    const childrenByParent = new Map<string, LegacyTaskRow[]>();
+    const tasksById = new Map<string, LegacyTaskRow>();
+    for (const task of allTasks) {
+        tasksById.set(task.id, task);
+        const parentId = String(task.parentTaskId || '').trim();
+        if (!parentId) continue;
+        const list = childrenByParent.get(parentId) || [];
+        list.push(task);
+        childrenByParent.set(parentId, list);
+    }
+
+    const rootParents = allTasks.filter((task) => {
+        if (!childrenByParent.has(task.id)) return false;
+        const parentId = String(task.parentTaskId || '').trim();
+        return !parentId || !tasksById.has(parentId);
+    });
+
+    const summary: WorkspaceMigrationSummary = {
+        workspaceId,
+        rootParentCount: rootParents.length,
+        descendantTaskCount: 0,
+        createdWorkstreams: 0,
+        deletedRootTasks: 0,
+        updatedTasks: 0,
+    };
+
+    if (rootParents.length === 0) {
+        return summary;
+    }
+
+    const db = (core as any).db;
+    const tenantId = core.getPaths().tenantId;
+    const descendantsByRoot = new Map<string, LegacyTaskRow[]>();
+
+    for (const root of rootParents) {
+        const descendantIds = [...collectSubtreeTaskIds(allTasks, root.id)].filter((id) => id !== root.id);
+        const descendants = descendantIds
+            .map((id) => tasksById.get(id))
+            .filter((task): task is LegacyTaskRow => Boolean(task));
+        descendantsByRoot.set(root.id, descendants);
+        summary.descendantTaskCount += descendants.length;
+    }
+
+    summary.createdWorkstreams = rootParents.length;
+    summary.updatedTasks = summary.descendantTaskCount;
+    summary.deletedRootTasks = rootParents.length;
+
+    const mutate = () => {
+        for (const root of rootParents) {
+            const descendants = descendantsByRoot.get(root.id) || [];
+
+            const workstream = core.createWorkstream({
+                title: root.title,
+                description: checklistItemsToDescription(root.checklistItems, root.description),
+                ownerId: normalizeOwnerId(root),
+                referenceNumber: root.referenceNumber ?? undefined,
+                createdAt: root.createdAt,
+                updatedAt: root.updatedAt,
+                isArchived: Boolean(root.isArchived),
+                comments: root.comments || [],
+                attachments: root.attachments || [],
+            }, workspaceId);
+
+            for (const descendant of descendants) {
+                const nextUpdatedAt = new Date().toISOString();
+                db.prepare(`
+                    UPDATE tasks
+                    SET parent_task_id = NULL,
+                        child_display_order = NULL,
+                        workstream_id = @workstreamId,
+                        updated_at = @updatedAt
+                    WHERE tenant_id = @tenantId
+                      AND workspace_id = @workspaceId
+                      AND id = @id
+                `).run({
+                    id: descendant.id,
+                    tenantId,
+                    workspaceId,
+                    workstreamId: workstream.id,
+                    updatedAt: nextUpdatedAt,
+                });
+            }
+
+            // Clear canonical attachment links tied to the legacy parent task before deleting it.
+            (core as any).syncCanonicalTaskAttachmentLinks(root.id, workspaceId, []);
+
+            db.prepare(`
+                DELETE FROM tasks
+                WHERE tenant_id = @tenantId
+                  AND workspace_id = @workspaceId
+                  AND id = @id
+            `).run({
+                id: root.id,
+                tenantId,
+                workspaceId,
+            });
+        }
+
+        (core as any).persistBackup?.();
+    };
+
+    if (!dryRun) {
+        db.transaction(mutate)();
+    }
+
+    return summary;
+}
+
+function printSummary(summary: WorkspaceMigrationSummary): void {
+    console.log([
+        `workspace=${summary.workspaceId}`,
+        `rootParents=${summary.rootParentCount}`,
+        `descendants=${summary.descendantTaskCount}`,
+        `workstreamsCreated=${summary.createdWorkstreams}`,
+        `tasksUpdated=${summary.updatedTasks}`,
+        `rootTasksDeleted=${summary.deletedRootTasks}`,
+    ].join(' '));
+}
+
+async function main() {
+    const options = parseArgs();
+    const core = new TaskforceCore({
+        projectRoot: process.cwd(),
+        runtimeMode: 'local',
+        storagePath: '.taskforce',
+    });
+
+    try {
+        const workspaceIds = options.all
+            ? listWorkspaceIds(core)
+            : [options.workspaceId || core.resolvePreferredWorkspaceId({ allowDefault: true }) || 'default'];
+
+        console.log(`[planning-migration] mode=${options.dryRun ? 'dry-run' : 'apply'} workspaces=${workspaceIds.join(',')}`);
+        for (const workspaceId of workspaceIds) {
+            const summary = migrateWorkspace(core, workspaceId, options.dryRun);
+            printSummary(summary);
+        }
+    } finally {
+        core.close();
+    }
+}
+
+main().catch((error) => {
+    console.error(`[planning-migration] ${String((error as Error)?.message || error)}`);
+    process.exit(1);
+});