@taskforcehq/taskforce 0.3.302 → 0.3.304

package/dist/server/routes/shared.d.ts

@@ -7,8 +7,38 @@
  */
 import { IncomingMessage, ServerResponse } from 'http';
 import { TaskforceCore } from '../../core/Taskforce.js';
+import type { McpAccessTokenAuthResult, McpOAuthAccessTokenAuthResult, McpAccessTokenScope } from '../../core/Taskforce.js';
 import type { RouteContext } from '../routes.js';
+import type { AiProfileBootstrapConfig } from '../../mcp/aiProfileBootstrap.js';
 export declare function resolveErrorStatusCode(error: unknown, fallback?: number): number;
+export declare function buildCloudMcpRuntimeAuth(input: {
+    req: IncomingMessage;
+    auth: {
+        authenticatedViaToken: McpAccessTokenAuthResult | null;
+        authenticatedViaOAuth: McpOAuthAccessTokenAuthResult | null;
+        userId: string | null;
+    } & Required<AiProfileBootstrapConfig>;
+    requestHeader: (req: IncomingMessage, name: string, fallback?: string) => string;
+    requestId?: string | null;
+    authScopes?: McpAccessTokenScope[] | null;
+}): {
+    scopes?: McpAccessTokenScope[] | null;
+    userId?: string | null;
+    tokenId?: string | null;
+    aiProfileToken?: AiProfileBootstrapConfig['aiProfileToken'];
+    aiProfileName?: AiProfileBootstrapConfig['aiProfileName'];
+    aiProfileIcon?: AiProfileBootstrapConfig['aiProfileIcon'];
+    aiProfileColor?: AiProfileBootstrapConfig['aiProfileColor'];
+    aiProfileDescription?: AiProfileBootstrapConfig['aiProfileDescription'];
+    aiProfileRole?: AiProfileBootstrapConfig['aiProfileRole'];
+    aiProfileProvider?: AiProfileBootstrapConfig['aiProfileProvider'];
+    aiProfileModel?: AiProfileBootstrapConfig['aiProfileModel'];
+    aiProfileSurfaceType?: AiProfileBootstrapConfig['aiProfileSurfaceType'];
+    actorType?: 'local' | 'user' | 'token' | 'oauth';
+    requestId?: string | null;
+    ip?: string | null;
+    userAgent?: string | null;
+};
 export declare function requestHeader(req: IncomingMessage, name: string, fallback?: string): string;
 export declare function requestWorkspaceHeader(req: IncomingMessage): string;
 export declare function requestAuthoritativeWorkspaceId(req: IncomingMessage): string;

package/dist/server/routes/shared.js

@@ -17,6 +17,32 @@ export function resolveErrorStatusCode(error, fallback = 400) {
     }
     return fallback;
 }
+export function buildCloudMcpRuntimeAuth(input) {
+    const { req, auth, requestHeader, requestId, authScopes } = input;
+    const actorType = auth.authenticatedViaToken
+        ? 'token'
+        : auth.authenticatedViaOAuth
+            ? 'oauth'
+            : 'user';
+    return {
+        scopes: authScopes || auth.authenticatedViaToken?.scopes || auth.authenticatedViaOAuth?.scopes || [],
+        userId: auth.authenticatedViaToken?.userId || auth.authenticatedViaOAuth?.userId || auth.userId || null,
+        tokenId: auth.authenticatedViaToken?.tokenId || auth.authenticatedViaOAuth?.grantId || null,
+        aiProfileToken: auth.aiProfileToken,
+        aiProfileName: auth.aiProfileName,
+        aiProfileIcon: auth.aiProfileIcon,
+        aiProfileColor: auth.aiProfileColor,
+        aiProfileDescription: auth.aiProfileDescription,
+        aiProfileRole: auth.aiProfileRole,
+        aiProfileProvider: auth.aiProfileProvider,
+        aiProfileModel: auth.aiProfileModel,
+        aiProfileSurfaceType: auth.aiProfileSurfaceType,
+        actorType,
+        requestId: String(requestId || req.headers['x-request-id'] || req.headers['x-railway-request-id'] || '').trim() || undefined,
+        ip: req.socket?.remoteAddress || null,
+        userAgent: requestHeader(req, 'user-agent', '') || null,
+    };
+}
 // === SECTION: Request header helpers ===
 export function requestHeader(req, name, fallback = '') {
     const value = req.headers?.[name.toLowerCase()];
@@ -167,9 +193,11 @@ export function makeEnsureAppAccess(core, context) {
             return true;
         const code = accountAccess.gate === 'plan_selection_required'
             ? 'PLAN_SELECTION_REQUIRED'
-            : accountAccess.gate === 'misconfigured'
-                ? 'ACCOUNT_ACCESS_MISCONFIGURED'
-                : 'ACCOUNT_ENTITLEMENT_REQUIRED';
+            : accountAccess.gate === 'checkout_pending'
+                ? 'CHECKOUT_PENDING'
+                : accountAccess.gate === 'misconfigured'
+                    ? 'ACCOUNT_ACCESS_MISCONFIGURED'
+                    : 'ACCOUNT_ENTITLEMENT_REQUIRED';
         res.writeHead(403, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify({
             error: accountAccess.message || 'This account cannot access the app.',

package/dist/server/routes/sync.integration.test.js

@@ -344,6 +344,10 @@ describe('Server Routes Workspace Sync Integration', () => {
                         username: 'codex',
                         icon: 'Bot',
                         color: '#0ea5e9',
+                        description: 'Terminal-first coding agent',
+                        role: 'Implementer',
+                        provider: 'OpenAI',
+                        model: 'gpt-5.4',
                         surfaceType: 'coding_tool',
                         createdAt: '2026-03-22T10:00:00.000Z',
                         updatedAt: '2026-03-22T10:05:00.000Z',
@@ -361,6 +365,10 @@ describe('Server Routes Workspace Sync Integration', () => {
                 id: 'ai-profile-codex',
                 name: 'Codex',
                 username: 'codex',
+                description: 'Terminal-first coding agent',
+                role: 'Implementer',
+                provider: 'OpenAI',
+                model: 'gpt-5.4',
                 surfaceType: 'coding_tool'
             })
         ]);
@@ -1311,6 +1319,166 @@ describe('Server Routes Workspace Sync Integration', () => {
             })
         ]);
     });
+    it('lets the cloud document ref win during normal sync apply and records a diagnostic', async () => {
+        const projectRoot = createIsolatedProjectRoot('taskforce-sync-apply-doc-ref-drift-');
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        core.createWorkspace({ workspaceId, name: 'Local Active Workspace' });
+        core.createTask({
+            id: 'task-doc-ref-drift-1',
+            title: 'Task with drifting synced markdown asset',
+            status: 'task'
+        }, {
+            workspaceId,
+            allowClientProvidedId: true
+        });
+        const seededStore = new WorkspaceAssetStore(core.getDatabaseAdapter(), core.getTenantId());
+        seededStore.upsertAsset({
+            assetId: 'asset-doc-ref-drift-1',
+            workspaceId,
+            kind: 'document',
+            originalFilename: 'phase1-ref-drift.md',
+            mimeType: 'text/markdown',
+            storageProvider: 'local',
+            storageKey: 'docs/phase1-ref-drift.md',
+            contentSha256: 'sha-doc-ref-drift-local',
+            sizeBytes: 10,
+            documentId: 'doc-ref-drift-1',
+            referenceNumber: 12,
+            createdAt: '2026-03-17T11:55:00.000Z',
+            updatedAt: '2026-03-17T11:55:00.000Z'
+        });
+        seededStore.upsertLink({
+            workspaceId,
+            assetId: 'asset-doc-ref-drift-1',
+            taskId: 'task-doc-ref-drift-1',
+            role: 'attachment',
+            updatedAt: '2026-03-17T11:55:00.000Z',
+            deletedAt: null
+        });
+        const routes = createRoutes(core, { authConfig: { runtimeMode: 'local', enabled: false } });
+        const match = matchRoute('POST', '/api/taskforce/sync/workspace/apply-local', routes);
+        expect(match).toBeTruthy();
+        const req = createMockReq('POST', '/api/taskforce/sync/workspace/apply-local', {
+            changes: [
+                {
+                    op: 'document-upsert',
+                    path: 'docs/phase1-ref-drift.md',
+                    updatedAt: '2026-03-17T12:00:00.000Z',
+                    content: '# cloud canonical markdown\n',
+                    assetId: 'asset-doc-ref-drift-1',
+                    documentId: 'doc-ref-drift-1',
+                    referenceNumber: 18,
+                    version: 2,
+                    taskId: 'task-doc-ref-drift-1',
+                    originalFilename: 'phase1-ref-drift.md',
+                    linkRole: 'attachment'
+                }
+            ]
+        }, { 'x-taskforce-workspace-id': workspaceId });
+        const res = createMockRes();
+        await match?.handler(req, res, {});
+        expect(res.writeHead).toHaveBeenCalledWith(200, expect.any(Object));
+        const reloadedCore = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        const store = new WorkspaceAssetStore(reloadedCore.getDatabaseAdapter(), reloadedCore.getTenantId());
+        const asset = store.get('asset-doc-ref-drift-1', workspaceId);
+        const syncEvents = reloadedCore.listSyncEvents(workspaceId, 20);
+        expect(asset).toEqual(expect.objectContaining({
+            assetId: 'asset-doc-ref-drift-1',
+            referenceNumber: 18,
+            version: 2
+        }));
+        expect(syncEvents).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                eventType: 'apply',
+                status: 'error',
+                errorMessage: 'Detected document reference number mismatch during normal sync.',
+                details: expect.objectContaining({
+                    assetId: 'asset-doc-ref-drift-1',
+                    existingReferenceNumber: 12,
+                    incomingReferenceNumber: 18
+                })
+            })
+        ]));
+    });
+    it('lets the cloud image ref win during normal sync apply and records a diagnostic', async () => {
+        const projectRoot = createIsolatedProjectRoot('taskforce-sync-apply-image-ref-drift-');
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        core.createWorkspace({ workspaceId, name: 'Local Active Workspace' });
+        core.createTask({
+            id: 'task-image-ref-drift-1',
+            title: 'Task with drifting synced image asset',
+            status: 'task'
+        }, {
+            workspaceId,
+            allowClientProvidedId: true
+        });
+        const seededStore = new WorkspaceAssetStore(core.getDatabaseAdapter(), core.getTenantId());
+        seededStore.upsertAsset({
+            assetId: 'asset-image-ref-drift-1',
+            workspaceId,
+            kind: 'image',
+            originalFilename: 'hero.png',
+            mimeType: 'image/png',
+            storageProvider: 'local',
+            storageKey: 'workspaces/workspace-local-active/assets/images/hero.png',
+            contentSha256: 'sha-image-ref-drift-local',
+            sizeBytes: 10,
+            referenceNumber: 12,
+            createdAt: '2026-03-17T11:55:00.000Z',
+            updatedAt: '2026-03-17T11:55:00.000Z'
+        });
+        seededStore.upsertLink({
+            workspaceId,
+            assetId: 'asset-image-ref-drift-1',
+            taskId: 'task-image-ref-drift-1',
+            role: 'image',
+            updatedAt: '2026-03-17T11:55:00.000Z',
+            deletedAt: null
+        });
+        const routes = createRoutes(core, { authConfig: { runtimeMode: 'local', enabled: false } });
+        const match = matchRoute('POST', '/api/taskforce/sync/workspace/apply-local', routes);
+        expect(match).toBeTruthy();
+        const req = createMockReq('POST', '/api/taskforce/sync/workspace/apply-local', {
+            changes: [
+                {
+                    op: 'asset-upsert',
+                    path: 'workspaces/workspace-local-active/assets/images/hero.png',
+                    updatedAt: '2026-03-17T12:05:00.000Z',
+                    contentBase64: Buffer.from('cloud-hero').toString('base64'),
+                    assetId: 'asset-image-ref-drift-1',
+                    kind: 'image',
+                    mimeType: 'image/png',
+                    referenceNumber: 18,
+                    taskId: 'task-image-ref-drift-1',
+                    originalFilename: 'hero.png',
+                    linkRole: 'image'
+                }
+            ]
+        }, { 'x-taskforce-workspace-id': workspaceId });
+        const res = createMockRes();
+        await match?.handler(req, res, {});
+        expect(res.writeHead).toHaveBeenCalledWith(200, expect.any(Object));
+        const reloadedCore = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        const store = new WorkspaceAssetStore(reloadedCore.getDatabaseAdapter(), reloadedCore.getTenantId());
+        const asset = store.get('asset-image-ref-drift-1', workspaceId);
+        const syncEvents = reloadedCore.listSyncEvents(workspaceId, 20);
+        expect(asset).toEqual(expect.objectContaining({
+            assetId: 'asset-image-ref-drift-1',
+            referenceNumber: 18
+        }));
+        expect(syncEvents).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                eventType: 'apply',
+                status: 'error',
+                errorMessage: 'Detected asset reference number mismatch during normal sync.',
+                details: expect.objectContaining({
+                    assetId: 'asset-image-ref-drift-1',
+                    existingReferenceNumber: 12,
+                    incomingReferenceNumber: 18
+                })
+            })
+        ]));
+    });
     it('round-trips cloud attachment links for canonical markdown and file assets into local apply', async () => {
         const cloudProjectRoot = createIsolatedProjectRoot('taskforce-sync-cloud-link-roundtrip-cloud-');
         const localProjectRoot = createIsolatedProjectRoot('taskforce-sync-cloud-link-roundtrip-local-');
@@ -1597,6 +1765,18 @@ describe('Server Routes Workspace Sync Integration', () => {
         const pushRes = createMockRes();
         await pushMatch?.handler(pushReq, pushRes, {});
         expect(pushRes.writeHead).toHaveBeenCalledWith(200, expect.any(Object));
+        const pushBody = readJsonBody(pushRes);
+        expect(Array.isArray(pushBody?.appliedTaskUpserts)).toBe(true);
+        expect(pushBody?.appliedTaskUpserts).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                archived: false,
+                task: expect.objectContaining({
+                    id: taskId,
+                    title: 'Offline provisional task',
+                    referenceNumber: 1
+                })
+            })
+        ]));
         const persisted = core.getTask(taskId, workspaceId);
         expect(persisted?.referenceNumber).toBe(1);
         expect(Date.parse(String(persisted?.updatedAt || ''))).toBeGreaterThan(Date.parse(staleUpdatedAt));