@taskforcehq/taskforce 0.3.329 → 0.3.332

package/dist/server/routes/modelConnections.js

@@ -0,0 +1,205 @@
+import { INTERNAL_SUBSCRIPTION_MODEL_FEATURE_KEY } from '../../shared/userFeatureGrants.js';
+import { ModelProviderConnectionError, ModelProviderConnectionStore, } from '../../storage/modelProviderConnectionStore.js';
+import { ModelProviderCredentialHomeManager } from '../../services/modelProviderCredentialHome.js';
+import { ModelProviderConnectionService, } from '../../services/modelProviderConnectionService.js';
+import { CodexDeviceCodeLoginManager, } from '../../services/codexDeviceCodeLoginManager.js';
+import { createCodexModelProviderConnectionLifecycleHandlers } from '../../services/codexModelProviderConnectionLifecycle.js';
+import { parseJsonBody } from './primitives.js';
+function writeJson(res, statusCode, payload) {
+    res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(payload));
+}
+function writeError(res, error) {
+    const knownError = error instanceof ModelProviderConnectionError;
+    const statusCode = Number(error?.statusCode);
+    const safeStatusCode = Number.isInteger(statusCode) && statusCode >= 400 && statusCode <= 599
+        ? statusCode
+        : 500;
+    const code = knownError && typeof error?.code === 'string'
+        ? String(error.code)
+        : 'MODEL_CONNECTION_REQUEST_FAILED';
+    const message = knownError
+        ? String(error?.message || 'Model connection request failed.')
+        : 'Model connection request failed.';
+    writeJson(res, safeStatusCode, { success: false, error: message, code });
+}
+export function registerModelConnectionsRoutes(deps) {
+    const { addRoute, ensureAppAccess, resolveAuthenticatedUserId, resolveRuntimeMode, core, } = deps;
+    let resolvedService = deps.service;
+    let resolvedLoginManager = deps.loginManager;
+    let resolvedStore = null;
+    const store = () => {
+        if (resolvedStore)
+            return resolvedStore;
+        if (!core)
+            throw new Error('Model connection store is unavailable.');
+        resolvedStore = new ModelProviderConnectionStore(core.getDatabaseAdapter(), core.getTenantId());
+        return resolvedStore;
+    };
+    const service = () => {
+        if (resolvedService)
+            return resolvedService;
+        if (!core)
+            throw new Error('Model connection service is unavailable.');
+        const lifecycleHandlers = deps.lifecycleHandlers || [{
+                providerKey: 'openai',
+                authenticationType: 'chatgpt_device_code',
+                lifecycle: createCodexModelProviderConnectionLifecycleHandlers(),
+            }];
+        resolvedService = new ModelProviderConnectionService(store(), new ModelProviderCredentialHomeManager(deps.credentialStoragePath), (userId) => core.hasUserFeatureGrant(userId, INTERNAL_SUBSCRIPTION_MODEL_FEATURE_KEY), lifecycleHandlers);
+        return resolvedService;
+    };
+    const loginManager = () => {
+        if (resolvedLoginManager)
+            return resolvedLoginManager;
+        const connectionService = service();
+        if (!(connectionService instanceof ModelProviderConnectionService)) {
+            throw new Error('Model connection login manager is unavailable.');
+        }
+        resolvedLoginManager = new CodexDeviceCodeLoginManager(connectionService, store());
+        return resolvedLoginManager;
+    };
+    const authorize = (req, res) => {
+        if (!ensureAppAccess(req, res))
+            return null;
+        if (resolveRuntimeMode(req) !== 'cloud') {
+            writeJson(res, 404, {
+                success: false,
+                error: 'Model connections are unavailable in this runtime.',
+                code: 'MODEL_CONNECTIONS_CLOUD_ONLY',
+            });
+            return null;
+        }
+        const userId = String(resolveAuthenticatedUserId(req) || '').trim();
+        if (!userId) {
+            writeJson(res, 401, {
+                success: false,
+                error: 'Authentication is required.',
+                code: 'AUTH_REQUIRED',
+            });
+            return null;
+        }
+        return userId;
+    };
+    addRoute('GET', '/api/taskforce/model-connections', async (req, res) => {
+        const ownerUserId = authorize(req, res);
+        if (!ownerUserId)
+            return;
+        try {
+            writeJson(res, 200, {
+                success: true,
+                eligible: core ? core.hasUserFeatureGrant(ownerUserId, INTERNAL_SUBSCRIPTION_MODEL_FEATURE_KEY) : true,
+                connections: service().list(ownerUserId),
+            });
+        }
+        catch (error) {
+            writeError(res, error);
+        }
+    });
+    addRoute('POST', '/api/taskforce/model-connections', async (req, res) => {
+        const ownerUserId = authorize(req, res);
+        if (!ownerUserId)
+            return;
+        try {
+            const body = await parseJsonBody(req, 16 * 1024);
+            const connection = service().create({
+                ownerUserId,
+                providerKey: String(body?.providerKey || ''),
+                authenticationType: String(body?.authenticationType || ''),
+            });
+            writeJson(res, 201, { success: true, connection });
+        }
+        catch (error) {
+            writeError(res, error);
+        }
+    });
+    addRoute('GET', '/api/taskforce/model-connections/:connectionId', async (req, res, params) => {
+        const ownerUserId = authorize(req, res);
+        if (!ownerUserId)
+            return;
+        try {
+            writeJson(res, 200, {
+                success: true,
+                connection: service().get(ownerUserId, params.connectionId),
+            });
+        }
+        catch (error) {
+            writeError(res, error);
+        }
+    });
+    addRoute('PATCH', '/api/taskforce/model-connections/:connectionId', async (req, res, params) => {
+        const ownerUserId = authorize(req, res);
+        if (!ownerUserId)
+            return;
+        try {
+            const body = await parseJsonBody(req, 16 * 1024);
+            const connection = service().rename(ownerUserId, params.connectionId, body?.displayName);
+            writeJson(res, 200, { success: true, connection });
+        }
+        catch (error) {
+            writeError(res, error);
+        }
+    });
+    addRoute('POST', '/api/taskforce/model-connections/:connectionId/login', async (req, res, params) => {
+        const ownerUserId = authorize(req, res);
+        if (!ownerUserId)
+            return;
+        try {
+            const login = await loginManager().start(ownerUserId, params.connectionId);
+            writeJson(res, 202, { success: true, login });
+        }
+        catch (error) {
+            writeError(res, error);
+        }
+    });
+    addRoute('GET', '/api/taskforce/model-connections/:connectionId/login/:sessionId', async (req, res, params) => {
+        const ownerUserId = authorize(req, res);
+        if (!ownerUserId)
+            return;
+        try {
+            const login = loginManager().get(ownerUserId, params.connectionId, params.sessionId);
+            writeJson(res, 200, { success: true, login });
+        }
+        catch (error) {
+            writeError(res, error);
+        }
+    });
+    addRoute('POST', '/api/taskforce/model-connections/:connectionId/login/:sessionId/cancel', async (req, res, params) => {
+        const ownerUserId = authorize(req, res);
+        if (!ownerUserId)
+            return;
+        try {
+            const login = await loginManager().cancel(ownerUserId, params.connectionId, params.sessionId);
+            writeJson(res, 200, { success: true, login });
+        }
+        catch (error) {
+            writeError(res, error);
+        }
+    });
+    for (const operation of ['verify', 'refresh', 'disconnect']) {
+        addRoute('POST', `/api/taskforce/model-connections/:connectionId/${operation}`, async (req, res, params) => {
+            const ownerUserId = authorize(req, res);
+            if (!ownerUserId)
+                return;
+            try {
+                const connection = await service()[operation](ownerUserId, params.connectionId);
+                writeJson(res, 200, { success: true, connection });
+            }
+            catch (error) {
+                writeError(res, error);
+            }
+        });
+    }
+    addRoute('DELETE', '/api/taskforce/model-connections/:connectionId', async (req, res, params) => {
+        const ownerUserId = authorize(req, res);
+        if (!ownerUserId)
+            return;
+        try {
+            const result = await service().cleanup(ownerUserId, params.connectionId);
+            writeJson(res, 200, { success: true, ...result });
+        }
+        catch (error) {
+            writeError(res, error);
+        }
+    });
+}

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

@@ -6,12 +6,15 @@
  * routes.ts at runtime.
  */
 import { IncomingMessage, ServerResponse } from 'http';
+import { NodeStreamableHTTPServerTransport } from '@modelcontextprotocol/node';
 import { TaskforceCore } from '../../core/Taskforce.js';
 import type { McpAccessTokenAuthResult, McpOAuthAccessTokenAuthResult, McpAccessTokenScope } from '../../core/Taskforce.js';
 import { type RouteContext } from './primitives.js';
+import { type McpRuntimeFactory, type TaskforceMcpServerOptions } from '../../mcp/runtime.js';
 import { type AiProfileBootstrapConfig } from '../../mcp/aiProfileBootstrap.js';
 import type { AiProfileSeatScope } from '../../shared/aiProfileSeatScope.js';
 import { type RequestPerformanceDiagnostics } from '../../storage/postgresRequestDiagnostics.js';
+import { beginCloudMcpCapacityRequest } from '../cloudMcpCapacityTelemetry.js';
 export declare function resolveErrorStatusCode(error: unknown, fallback?: number): number;
 export declare function buildCloudMcpProfileConnectionId(input: {
     oauth?: McpOAuthAccessTokenAuthResult | null;
@@ -100,6 +103,20 @@ export declare function makeAuthenticateCloudMcpRequest(core: TaskforceCore, dep
     resolveAuthenticatedUserId: (req: IncomingMessage) => string;
     writeMcpHttpError: (res: ServerResponse, statusCode: number, message: string, data?: Record<string, unknown>) => void;
 }): (req: IncomingMessage, res: ServerResponse) => CloudMcpRequestAuth | null;
+export type CloudMcpToolPolicy = {
+    requiredScope: McpAccessTokenScope | null;
+    isWrite: boolean;
+};
+export type CloudMcpToolPolicyResolver = (toolName: string) => CloudMcpToolPolicy;
+export interface CloudMcpRuntimeLease {
+    runtime: ReturnType<McpRuntimeFactory>;
+    transport: NodeStreamableHTTPServerTransport;
+    release(): Promise<void>;
+}
+export type AcquireCloudMcpRuntime = (input: {
+    req: IncomingMessage;
+    options: TaskforceMcpServerOptions;
+}) => Promise<CloudMcpRuntimeLease>;
 export declare function makeHandleCloudMcpRequest(core: TaskforceCore, deps: {
     ensureAppAccess: (req: IncomingMessage, res: ServerResponse) => boolean;
     resolveAuthenticatedUserId: (req: IncomingMessage) => string;
@@ -109,6 +126,11 @@ export declare function makeHandleCloudMcpRequest(core: TaskforceCore, deps: {
         workspaceMaxRequests: number;
         windowMs: number;
     };
+    createMcpServer?: McpRuntimeFactory;
+    resolveMcpToolPolicy?: CloudMcpToolPolicyResolver;
+    acquireMcpRuntime?: AcquireCloudMcpRuntime;
+    capacityTelemetryEnabled?: () => boolean;
+    beginCapacityRequest?: typeof beginCloudMcpCapacityRequest;
 }): (req: IncomingMessage, res: ServerResponse) => Promise<void>;
 export declare function requestHeader(req: IncomingMessage, name: string, fallback?: string): string;
 export declare function requestWorkspaceHeader(req: IncomingMessage): string;