@taskforcehq/taskforce 0.3.326 → 0.3.328

package/dist/server/routes/shared.js

@@ -5,8 +5,21 @@
  * `*RouteDependencies` interface so that no module needs to reach back into
  * routes.ts at runtime.
  */
+import { randomUUID } from 'crypto';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
 import { TaskforceRuleError } from '../../core/Taskforce.js';
 import { resolveRequestAccess, } from '../auth.js';
+import { parseJsonBody } from './primitives.js';
+import { createTaskforceMcpServer, isMcpWriteToolName } from '../../mcp/runtime.js';
+import { MCP_CLOUD_TOOL_SCOPE_REQUIREMENTS } from '../../mcp/toolRegistry.js';
+import { resolveCanonicalMcpToolName } from '../../mcp/toolCallCompatibility.js';
+import { applyPrefixedRateLimitHeaders } from '../rateLimit.js';
+import { parseAiProfileBootstrapHeaders } from '../../mcp/aiProfileBootstrap.js';
+import { parseMcpClientId } from '../../mcp/clientRegistry.js';
+import { resolveAppAccessDeniedResponse } from '../appAccess.js';
+import { resolveCloudApplicationBaseUrl } from '../../config/applicationBaseUrl.js';
+import { getRequestPerformanceDiagnostics, runWithRequestPerformanceDiagnostics, } from '../../storage/postgresRequestDiagnostics.js';
 // === SECTION: Error helpers ===
 export function resolveErrorStatusCode(error, fallback = 400) {
     if (error instanceof TaskforceRuleError)
@@ -17,9 +30,18 @@ export function resolveErrorStatusCode(error, fallback = 400) {
     }
     return fallback;
 }
+export function buildCloudMcpProfileConnectionId(input) {
+    if (input.oauth) {
+        return `oauth-client:${input.oauth.clientId}:${input.oauth.userId}:${input.oauth.workspaceId}`;
+    }
+    return input.token?.tokenId
+        ? `token:${input.token.tokenId}:${input.mcpClientId || 'general'}`
+        : null;
+}
 // === SECTION: Route timing helpers ===
 export const BOOTSTRAP_ROUTE_SLOW_THRESHOLD_MS = 1500;
 export const BOOTSTRAP_ROUTE_SEVERE_THRESHOLD_MS = 5000;
+export const TASKFORCE_PERFORMANCE_TRACE_HEADER = 'x-taskforce-performance-trace';
 function sanitizeServerTimingMetricName(name) {
     return String(name || 'taskforce-route')
         .trim()
@@ -49,6 +71,55 @@ export function serializeJsonWithTiming(payload, startedAt = getRouteTimingNow()
         durationMs: Math.max(0, getRouteTimingNow() - startedAt),
     };
 }
+export function runWithPerformanceTrace(req, callback) {
+    const enabled = requestHeader(req, TASKFORCE_PERFORMANCE_TRACE_HEADER, '').trim() === '1';
+    return runWithRequestPerformanceDiagnostics(enabled, callback);
+}
+export function currentPerformanceTraceDiagnostics() {
+    return getRequestPerformanceDiagnostics();
+}
+export function performanceTraceServerTimingMetrics(diagnostics) {
+    return diagnostics ? [{ name: 'postgres-worker-wait', durationMs: diagnostics.postgresWorkerWaitMs }] : [];
+}
+export function setPerformanceTraceHeaders(res, diagnostics, responseBytes) {
+    if (!diagnostics)
+        return;
+    res.setHeader('X-Taskforce-Postgres-Query-Count', String(diagnostics.postgresQueryCount));
+    res.setHeader('X-Taskforce-Postgres-Worker-Call-Count', String(diagnostics.postgresWorkerCallCount));
+    res.setHeader('X-Taskforce-Response-Bytes', String(responseBytes));
+}
+export function respondWithPerformanceTraceJson(input) {
+    runWithPerformanceTrace(input.req, () => {
+        const startedAt = getRouteTimingNow();
+        const data = input.load();
+        const loadCompletedAt = getRouteTimingNow();
+        const serialized = serializeJsonWithTiming(data);
+        const diagnostics = getRequestPerformanceDiagnostics();
+        const totalDurationMs = Math.max(0, getRouteTimingNow() - startedAt);
+        setServerTimingHeader(input.res, [
+            { name: 'route-total', durationMs: totalDurationMs },
+            { name: 'route-load', durationMs: loadCompletedAt - startedAt },
+            { name: 'route-json', durationMs: serialized.durationMs },
+            ...performanceTraceServerTimingMetrics(diagnostics),
+        ]);
+        setPerformanceTraceHeaders(input.res, diagnostics, serialized.byteLength);
+        logSlowBootstrapRoute({
+            route: input.route,
+            workspaceId: input.workspaceId,
+            traceId: requestBootstrapTraceId(input.req),
+            durationMs: totalDurationMs,
+            details: diagnostics ? {
+                responseBytes: serialized.byteLength,
+                postgresQueryCount: diagnostics.postgresQueryCount,
+                postgresWorkerCallCount: diagnostics.postgresWorkerCallCount,
+                postgresWorkerWaitMs: Math.round(diagnostics.postgresWorkerWaitMs),
+                jsonSerializeMs: serialized.durationMs,
+            } : { responseBytes: serialized.byteLength },
+        });
+        input.res.writeHead(200, { 'Content-Type': 'application/json' });
+        input.res.end(serialized.body);
+    });
+}
 export function requestBootstrapTraceId(req) {
     return requestHeader(req, 'x-taskforce-bootstrap-trace-id', '').trim();
 }
@@ -80,6 +151,8 @@ export function buildCloudMcpRuntimeAuth(input) {
         userId: auth.authenticatedViaToken?.userId || auth.authenticatedViaOAuth?.userId || auth.userId || null,
         tokenId: auth.authenticatedViaToken?.tokenId || auth.authenticatedViaOAuth?.grantId || null,
         aiProfileToken: auth.aiProfileToken,
+        aiProfileId: auth.authenticatedViaOAuth?.aiProfileId || null,
+        aiProfileIdentityAsserted: auth.aiProfileIdentityAsserted === true,
         aiProfileName: auth.aiProfileName,
         aiProfileIcon: auth.aiProfileIcon,
         aiProfileColor: auth.aiProfileColor,
@@ -88,6 +161,12 @@ export function buildCloudMcpRuntimeAuth(input) {
         aiProfileProvider: auth.aiProfileProvider,
         aiProfileModel: auth.aiProfileModel,
         aiProfileSurfaceType: auth.aiProfileSurfaceType,
+        mcpClientId: auth.mcpClientId,
+        mcpConnectionId: buildCloudMcpProfileConnectionId({
+            oauth: auth.authenticatedViaOAuth,
+            token: auth.authenticatedViaToken,
+            mcpClientId: auth.mcpClientId,
+        }),
         aiProfileSeatScope: 'cloud_metered',
         actorType,
         requestId: String(requestId || req.headers['x-request-id'] || req.headers['x-railway-request-id'] || '').trim() || undefined,
@@ -95,6 +174,418 @@ export function buildCloudMcpRuntimeAuth(input) {
         userAgent: requestHeader(req, 'user-agent', '') || null,
     };
 }
+export function makeAuthenticateCloudMcpRequest(core, deps) {
+    const { resolveAuthenticatedUserId, writeMcpHttpError } = deps;
+    return function authenticateCloudMcpRequest(req, res) {
+        const authorization = requestHeader(req, 'authorization', '').trim();
+        const bearerToken = authorization.toLowerCase().startsWith('bearer ')
+            ? authorization.slice(7).trim()
+            : '';
+        const requestedWorkspaceId = requestHeader(req, 'x-taskforce-workspace-id', '').trim();
+        const bootstrap = parseAiProfileBootstrapHeaders(req.headers);
+        const rawMcpClientId = requestHeader(req, 'x-taskforce-mcp-client-id', '').trim();
+        if (rawMcpClientId && !bootstrap.mcpClientId) {
+            console.warn('[Taskforce MCP] Ignoring unknown MCP client id.', { code: 'unknown_mcp_client_id' });
+        }
+        if (bearerToken) {
+            const tokenAuth = core.authenticateMcpAccessToken(bearerToken);
+            const oauthAuth = tokenAuth ? null : core.authenticateMcpOAuthAccessToken(bearerToken);
+            if ((!tokenAuth || tokenAuth.status !== 'active') && (!oauthAuth || oauthAuth.status !== 'active')) {
+                core.addMcpAuditLog({
+                    workspaceId: requestedWorkspaceId || 'default',
+                    actorType: 'token',
+                    actorUserId: 'anonymous',
+                    toolName: 'auth',
+                    details: {
+                        requestId: String(req.headers['x-request-id'] || req.headers['x-railway-request-id'] || '').trim() || randomUUID(),
+                        ip: req.socket?.remoteAddress || null,
+                        userAgent: requestHeader(req, 'user-agent', '') || null,
+                        outcome: 'deny',
+                        reasonCode: 'invalid_credential',
+                        workspaceIdHint: requestedWorkspaceId || null
+                    }
+                });
+                writeMcpHttpError(res, 401, 'Unauthorized.');
+                return null;
+            }
+            const resolvedWorkspaceId = tokenAuth?.workspaceId || oauthAuth?.workspaceId || '';
+            if (requestedWorkspaceId && requestedWorkspaceId !== resolvedWorkspaceId) {
+                core.addMcpAuditLog({
+                    workspaceId: resolvedWorkspaceId || requestedWorkspaceId || 'default',
+                    actorType: tokenAuth ? 'token' : 'oauth',
+                    actorUserId: tokenAuth?.userId || oauthAuth?.userId || 'anonymous',
+                    tokenId: tokenAuth?.tokenId || oauthAuth?.grantId || null,
+                    toolName: 'auth',
+                    details: {
+                        requestId: String(req.headers['x-request-id'] || req.headers['x-railway-request-id'] || '').trim() || randomUUID(),
+                        ip: req.socket?.remoteAddress || null,
+                        userAgent: requestHeader(req, 'user-agent', '') || null,
+                        outcome: 'deny',
+                        reasonCode: 'workspace_mismatch',
+                        requestedWorkspaceId,
+                        credentialWorkspaceId: resolvedWorkspaceId
+                    }
+                });
+                writeMcpHttpError(res, 403, 'Forbidden.');
+                return null;
+            }
+            return {
+                workspaceId: resolvedWorkspaceId,
+                authenticatedViaToken: tokenAuth || null,
+                authenticatedViaOAuth: oauthAuth || null,
+                userId: null,
+                ...bootstrap,
+                aiProfileId: oauthAuth?.aiProfileId || null,
+                aiProfileIdentityAsserted: Boolean(bootstrap.aiProfileName || bootstrap.aiProfileProvider),
+                aiProfileToken: bootstrap.aiProfileToken || oauthAuth?.aiProfileToken || null,
+                aiProfileName: bootstrap.aiProfileName || oauthAuth?.aiProfileName || null,
+                mcpClientId: oauthAuth
+                    ? parseMcpClientId(oauthAuth.productClientId)
+                    : bootstrap.mcpClientId,
+            };
+        }
+        core.addMcpAuditLog({
+            workspaceId: requestedWorkspaceId || 'default',
+            actorType: 'user',
+            actorUserId: resolveAuthenticatedUserId(req) || 'anonymous',
+            toolName: 'auth',
+            details: {
+                requestId: String(req.headers['x-request-id'] || req.headers['x-railway-request-id'] || '').trim() || randomUUID(),
+                ip: req.socket?.remoteAddress || null,
+                userAgent: requestHeader(req, 'user-agent', '') || null,
+                outcome: 'deny',
+                reasonCode: 'missing_bearer'
+            }
+        });
+        writeMcpHttpError(res, 401, 'Unauthorized.');
+        return null;
+    };
+}
+function writeMcpHttpError(res, statusCode, message, data) {
+    res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({
+        jsonrpc: '2.0',
+        error: {
+            code: -32000,
+            message,
+            ...(data ? { data } : {}),
+        },
+        id: null,
+    }));
+}
+function extractMcpWriteToolNames(body) {
+    const messages = Array.isArray(body) ? body : [body];
+    const names = messages.flatMap((message) => {
+        if (!message || typeof message !== 'object')
+            return [];
+        const method = String(message.method || '').trim();
+        if (method !== 'tools/call')
+            return [];
+        const toolName = String(message?.params?.name || '').trim();
+        return toolName && isMcpWriteToolName(toolName) ? [toolName] : [];
+    });
+    return Array.from(new Set(names));
+}
+function extractFirstMcpToolName(body) {
+    const messages = Array.isArray(body) ? body : [body];
+    for (const message of messages) {
+        if (!message || typeof message !== 'object')
+            continue;
+        if (String(message.method || '').trim() !== 'tools/call')
+            continue;
+        const toolName = String(message?.params?.name || '').trim();
+        if (toolName)
+            return toolName;
+    }
+    return null;
+}
+function findDeniedCloudMcpToolName(body, scopes) {
+    const messages = Array.isArray(body) ? body : [body];
+    for (const message of messages) {
+        if (!message || typeof message !== 'object')
+            continue;
+        if (String(message.method || '').trim() !== 'tools/call')
+            continue;
+        const requestedToolName = String(message?.params?.name || '').trim();
+        if (!requestedToolName)
+            continue;
+        const toolName = resolveCanonicalMcpToolName(requestedToolName);
+        const requiredScope = MCP_CLOUD_TOOL_SCOPE_REQUIREMENTS[toolName];
+        if (!requiredScope || !scopes.includes(requiredScope))
+            return requestedToolName;
+    }
+    return null;
+}
+export function makeHandleCloudMcpRequest(core, deps) {
+    const { ensureAppAccess, resolveAuthenticatedUserId, writeRateLimit } = deps;
+    const authenticateCloudMcpRequest = makeAuthenticateCloudMcpRequest(core, {
+        resolveAuthenticatedUserId,
+        writeMcpHttpError,
+    });
+    const recordCloudMcpCredentialUsage = (req, tokenAuth, oauthAuth) => {
+        if (tokenAuth) {
+            core.recordMcpAccessTokenUsage({
+                tokenId: tokenAuth.tokenId,
+                workspaceId: tokenAuth.workspaceId,
+                ip: req.socket?.remoteAddress || null,
+                userAgent: requestHeader(req, 'user-agent', '') || null,
+            });
+            return;
+        }
+        if (oauthAuth) {
+            core.recordMcpOAuthConnectorGrantUsage({
+                grantId: oauthAuth.grantId,
+                workspaceId: oauthAuth.workspaceId,
+            });
+        }
+    };
+    const applyCloudMcpWriteRateLimit = (req, res, auth, body) => {
+        if (!writeRateLimit.enabled)
+            return true;
+        const writeTools = extractMcpWriteToolNames(body);
+        if (writeTools.length === 0)
+            return true;
+        const actorKey = auth.authenticatedViaToken?.tokenId
+            ? `token:${auth.authenticatedViaToken.tokenId}`
+            : auth.authenticatedViaOAuth?.grantId
+                ? `oauth:${auth.authenticatedViaOAuth.grantId}`
+                : auth.userId
+                    ? `user:${auth.userId}`
+                    : `workspace:${auth.workspaceId}`;
+        const actorResult = core.checkMcpRateLimit({
+            scope: 'actor',
+            key: actorKey,
+            limit: writeRateLimit.actorMaxRequests,
+            windowMs: writeRateLimit.windowMs
+        });
+        const workspaceResult = core.checkMcpRateLimit({
+            scope: 'workspace',
+            key: auth.workspaceId,
+            limit: writeRateLimit.workspaceMaxRequests,
+            windowMs: writeRateLimit.windowMs
+        });
+        applyPrefixedRateLimitHeaders(res, actorResult, 'X-MCP-Write-RateLimit');
+        applyPrefixedRateLimitHeaders(res, workspaceResult, 'X-MCP-Write-Workspace-RateLimit');
+        if (actorResult.allowed && workspaceResult.allowed)
+            return true;
+        const retryAfterSeconds = Math.max(actorResult.retryAfterSeconds, workspaceResult.retryAfterSeconds);
+        res.setHeader('Retry-After', String(retryAfterSeconds));
+        core.addMcpAuditLog({
+            workspaceId: auth.workspaceId,
+            actorType: auth.authenticatedViaToken ? 'token' : auth.authenticatedViaOAuth ? 'oauth' : 'user',
+            actorUserId: auth.authenticatedViaToken?.userId || auth.authenticatedViaOAuth?.userId || auth.userId || 'anonymous',
+            tokenId: auth.authenticatedViaToken?.tokenId || auth.authenticatedViaOAuth?.grantId || null,
+            toolName: extractFirstMcpToolName(body) || 'rate_limit',
+            details: {
+                requestId: String(req.headers['x-request-id'] || req.headers['x-railway-request-id'] || '').trim() || randomUUID(),
+                ip: req.socket?.remoteAddress || null,
+                userAgent: requestHeader(req, 'user-agent', '') || null,
+                outcome: 'deny',
+                reasonCode: actorResult.allowed ? 'workspace_write_rate_limited' : 'actor_write_rate_limited',
+                actorLimit: actorResult.limit,
+                workspaceLimit: workspaceResult.limit
+            }
+        });
+        writeMcpHttpError(res, 429, 'Write rate limit exceeded. Retry later.');
+        return false;
+    };
+    return async function handleCloudMcpRequest(req, res) {
+        const requestStartedAtMs = Date.now();
+        let authMs = 0;
+        let bodyParseMs = 0;
+        let rateLimitMs = 0;
+        if (requestRuntimeMode(req) !== 'cloud') {
+            writeMcpHttpError(res, 400, 'The /mcp HTTP endpoint is only available in cloud runtime. In local runtime, use the local stdio MCP server (for example: `taskforce mcp <project-path>`).');
+            return;
+        }
+        if (!ensureAppAccess(req, res))
+            return;
+        if (req.method !== 'POST' && req.method !== 'GET' && req.method !== 'DELETE') {
+            writeMcpHttpError(res, 405, 'Method not allowed.');
+            return;
+        }
+        const authStartedAtMs = Date.now();
+        const auth = authenticateCloudMcpRequest(req, res);
+        authMs = Date.now() - authStartedAtMs;
+        if (!auth)
+            return;
+        if (req.method !== 'POST') {
+            writeMcpHttpError(res, 405, 'Method not allowed.');
+            return;
+        }
+        let body = undefined;
+        try {
+            const bodyParseStartedAtMs = Date.now();
+            body = await parseJsonBody(req);
+            bodyParseMs = Date.now() - bodyParseStartedAtMs;
+        }
+        catch (error) {
+            writeMcpHttpError(res, resolveErrorStatusCode(error, 400), 'Invalid JSON body.');
+            return;
+        }
+        const authScopes = auth.authenticatedViaToken?.scopes || auth.authenticatedViaOAuth?.scopes || [];
+        const requestId = String(req.headers['x-request-id'] || req.headers['x-railway-request-id'] || '').trim() || randomUUID();
+        res.setHeader('X-Request-ID', requestId);
+        const mcpMethod = !Array.isArray(body) && body !== null && typeof body === 'object'
+            ? String(body.method || '')
+            : '';
+        const initializeRequest = isInitializeRequest(body)
+            || mcpMethod === 'initialize';
+        const deniedToolName = findDeniedCloudMcpToolName(body, authScopes);
+        if (deniedToolName) {
+            core.addMcpAuditLog({
+                workspaceId: auth.workspaceId,
+                actorType: auth.authenticatedViaToken ? 'token' : auth.authenticatedViaOAuth ? 'oauth' : 'user',
+                actorUserId: auth.authenticatedViaToken?.userId || auth.authenticatedViaOAuth?.userId || auth.userId || 'anonymous',
+                tokenId: auth.authenticatedViaToken?.tokenId || auth.authenticatedViaOAuth?.grantId || null,
+                toolName: deniedToolName,
+                details: {
+                    requestId,
+                    ip: req.socket?.remoteAddress || null,
+                    userAgent: requestHeader(req, 'user-agent', '') || null,
+                    outcome: 'deny',
+                    reasonCode: 'scope_denied',
+                    scopes: authScopes
+                }
+            });
+            writeMcpHttpError(res, 403, 'Forbidden.');
+            return;
+        }
+        const writeToolNames = extractMcpWriteToolNames(body);
+        const rateLimitStartedAtMs = Date.now();
+        const rateLimitAllowed = applyCloudMcpWriteRateLimit(req, res, auth, body);
+        rateLimitMs = Date.now() - rateLimitStartedAtMs;
+        if (!rateLimitAllowed)
+            return;
+        let runtime = null;
+        let runtimeConstructionMs = 0;
+        let transportConnectMs = 0;
+        let requestHandlingMs = 0;
+        let cleanupMs = 0;
+        let outcome = 'success';
+        const toolTimingState = { value: null };
+        try {
+            const runtimeStartedAtMs = Date.now();
+            // Intentionally isolate the MCP runtime per HTTP request. The runtime closes over
+            // workspace auth, AI identity, permissions, subscriptions, and mutable helper state;
+            // sharing it could leak state across tenants or callers. Keep the transport stateless
+            // too. The timing event below measures construction cost so caching is only revisited
+            // with evidence and must preserve these boundaries (including dynamic tool schemas).
+            runtime = createTaskforceMcpServer({
+                projectRoot: core.getPaths().projectRoot,
+                tenantId: core.getTenantId(),
+                workspaceId: auth.workspaceId,
+                core,
+                serverName: 'taskforce-cloud',
+                logStartup: false,
+                runtimeMode: 'cloud',
+                applicationBaseUrl: resolveCloudApplicationBaseUrl(),
+                auth: buildCloudMcpRuntimeAuth({
+                    req,
+                    auth,
+                    requestHeader,
+                    requestId,
+                    authScopes,
+                }),
+                onToolCallTiming: (timing) => {
+                    toolTimingState.value = timing;
+                    if (!res.headersSent) {
+                        setServerTimingHeader(res, [
+                            { name: 'auth', durationMs: authMs },
+                            { name: 'body-parse', durationMs: bodyParseMs },
+                            { name: 'rate-limit', durationMs: rateLimitMs },
+                            { name: 'runtime', durationMs: runtimeConstructionMs },
+                            { name: 'transport-connect', durationMs: transportConnectMs },
+                            { name: 'tool-envelope-prepare', durationMs: timing.preparationMs },
+                            { name: 'tool-envelope-validate', durationMs: timing.validationMs },
+                            { name: 'tool-handler', durationMs: timing.handlerMs },
+                            ...Object.entries(timing.subphases).map(([phase, durationMs]) => ({
+                                name: `tool-${phase}`,
+                                durationMs,
+                            })),
+                        ]);
+                    }
+                },
+            });
+            runtimeConstructionMs = Date.now() - runtimeStartedAtMs;
+            const transport = new StreamableHTTPServerTransport({
+                sessionIdGenerator: undefined,
+                enableJsonResponse: true,
+            });
+            const transportStartedAtMs = Date.now();
+            await runtime.server.connect(transport);
+            transportConnectMs = Date.now() - transportStartedAtMs;
+            if (!initializeRequest) {
+                // Stateless cloud sessions still require a valid MCP JSON-RPC request;
+                // let the SDK validate and respond rather than trying to track sessions server-side.
+            }
+            const requestHandlingStartedAtMs = Date.now();
+            await transport.handleRequest(req, res, body);
+            requestHandlingMs = Date.now() - requestHandlingStartedAtMs;
+            recordCloudMcpCredentialUsage(req, auth.authenticatedViaToken, auth.authenticatedViaOAuth);
+        }
+        catch (error) {
+            outcome = 'failure';
+            console.error('[Taskforce MCP] Cloud transport request failed:', {
+                requestId,
+                kind: 'tool_transport_failure',
+                message: error instanceof Error ? error.message : String(error),
+            });
+            if (!res.headersSent) {
+                writeMcpHttpError(res, 500, 'MCP transport failure.', {
+                    kind: 'tool_transport_failure',
+                    retryable: true,
+                    requestId,
+                });
+            }
+        }
+        finally {
+            if (runtime) {
+                const cleanupStartedAtMs = Date.now();
+                try {
+                    await runtime.server.close();
+                }
+                catch (closeError) {
+                    console.warn('[Taskforce MCP] Cloud transport cleanup failed:', closeError);
+                }
+                cleanupMs = Date.now() - cleanupStartedAtMs;
+            }
+            const totalDurationMs = Date.now() - requestStartedAtMs;
+            if (initializeRequest || mcpMethod === 'tools/list' || writeToolNames.length > 0 || totalDurationMs >= 250) {
+                const timingSnapshot = toolTimingState.value;
+                console.info(`[Taskforce MCP] ${JSON.stringify({
+                    event: 'cloud_request_timing',
+                    requestId,
+                    requestKind: initializeRequest
+                        ? 'initialize'
+                        : mcpMethod === 'tools/list'
+                            ? 'tools_list'
+                            : (extractFirstMcpToolName(body) ? 'tool_call' : 'other'),
+                    method: mcpMethod || null,
+                    toolName: extractFirstMcpToolName(body),
+                    workspaceId: auth.workspaceId,
+                    databaseProvider: core.getDatabaseProvider(),
+                    authMode: auth.authenticatedViaToken ? 'token' : auth.authenticatedViaOAuth ? 'oauth' : 'user',
+                    batchSize: Array.isArray(body) ? body.length : 1,
+                    isWrite: writeToolNames.length > 0,
+                    outcome,
+                    httpStatus: res.statusCode,
+                    responseBytes: timingSnapshot?.responseBytes ?? null,
+                    totalDurationMs,
+                    preRuntimeMs: Math.max(0, totalDurationMs - runtimeConstructionMs - transportConnectMs - requestHandlingMs - cleanupMs),
+                    authMs,
+                    bodyParseMs,
+                    rateLimitMs,
+                    runtimeConstructionMs,
+                    transportConnectMs,
+                    requestHandlingMs,
+                    cleanupMs,
+                    toolTiming: timingSnapshot,
+                })}`);
+            }
+        }
+    };
+}
 // === SECTION: Request header helpers ===
 export function requestHeader(req, name, fallback = '') {
     const value = req.headers?.[name.toLowerCase()];
@@ -127,6 +618,17 @@ export function requestSystemRole(req) {
 export function requestUserId(req) {
     return requestHeader(req, 'x-taskforce-user-id', 'anonymous') || 'anonymous';
 }
+/**
+ * Resolve the human actor recorded by ordinary HTTP mutations. The standalone
+ * server has already replaced this header with authenticated cloud identity
+ * when available; local signed-in clients provide the same account id through
+ * the request-scoped mutation header. Anonymous sessions retain the legacy
+ * generic actor for compatibility.
+ */
+export function requestHumanActorRef(req) {
+    const userId = String(requestUserId(req) || '').trim();
+    return userId && userId !== 'anonymous' ? userId : 'user';
+}
 // === SECTION: Workspace ID resolution ===
 export function makeRequestWorkspaceId(core, context) {
     return function requestWorkspaceId(req) {
@@ -231,23 +733,11 @@ export function makeEnsureAppAccess(core, context) {
         if (!access.authenticated || !access.userId || access.userId === 'anonymous')
             return true;
         const accountAccess = core.getAccountAccessStatus(access.userId);
-        if (accountAccess.canAccessApp)
+        const denied = resolveAppAccessDeniedResponse(accountAccess);
+        if (!denied)
             return true;
-        const code = accountAccess.gate === 'plan_selection_required'
-            ? 'PLAN_SELECTION_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.',
-            code,
-            gate: accountAccess.gate,
-            canAccessPlans: accountAccess.canAccessPlans,
-            planSelectionRequired: accountAccess.planSelectionRequired
-        }));
+        res.writeHead(denied.statusCode, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(denied.body));
         return false;
     };
 }

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

@@ -3,6 +3,7 @@ import { TaskforceCore, TaskforceSyncCapable } from '../../core/Taskforce.js';
 import { type RouteContext, type RouteHandler } from './primitives.js';
 import { resolveRequestAccess, createSessionTokenCookie } from '../auth.js';
 import { isReservedWorkspaceId } from '../../utils/workspaceIdentity.js';
+import { type WorkspaceSyncServerDataServices } from '../../sync/engine/workspaceSyncServerDataServices.js';
 export interface SyncRouteDependencies {
     addRoute: (method: string, path: string, handler: RouteHandler) => void;
     core: TaskforceCore & TaskforceSyncCapable;
@@ -13,5 +14,6 @@ export interface SyncRouteDependencies {
     resolveRequestAccess: typeof resolveRequestAccess;
     isReservedWorkspaceId: typeof isReservedWorkspaceId;
     createSessionTokenCookie: typeof createSessionTokenCookie;
+    serverDataServices?: WorkspaceSyncServerDataServices;
 }
 export declare function registerSyncRoutes(deps: SyncRouteDependencies): void;