@taskforcehq/taskforce 0.3.170 → 0.3.301

package/dist/mcp/clientIntegrations.test.js

@@ -0,0 +1,110 @@
+import { describe, expect, it } from 'vitest';
+import { MCP_CLIENT_OPTIONS, buildCloudMcpClientIntegration, buildCloudMcpServerId, } from './clientIntegrations';
+describe('clientIntegrations', () => {
+    it('builds a readable cloud MCP server id from workspace name', () => {
+        expect(buildCloudMcpServerId('Workspace Alpha', null)).toBe('taskforce-workspace-alpha');
+        expect(buildCloudMcpServerId('A Workspace Name That Is Way Too Long For Comfort', null)).toBe('taskforce-a-workspace-name-that-is');
+    });
+    it('keeps enabled connector clients available in the selector', () => {
+        expect(MCP_CLIENT_OPTIONS.map((option) => option.id)).toEqual(expect.arrayContaining(['openclaw', 'codex', 'gemini-cli']));
+        expect(MCP_CLIENT_OPTIONS.map((option) => option.id)).not.toEqual(expect.arrayContaining(['chatgpt-desktop', 'claude-desktop']));
+    });
+    it('builds JSON config for VS Code using the servers root', () => {
+        const integration = buildCloudMcpClientIntegration({
+            clientId: 'vscode',
+            endpoint: 'https://performance-app.taskforcehq.ai/mcp',
+            tokenValue: '<<GENERATE_TOKEN>>',
+            serverId: 'taskforce-workspace-alpha',
+        });
+        expect(integration.kind).toBe('json');
+        expect(integration.rootKey).toBe('servers');
+        expect(integration.serverConfig).toEqual({
+            type: 'http',
+            url: 'https://performance-app.taskforcehq.ai/mcp',
+            headers: {
+                Authorization: 'Bearer <<GENERATE_TOKEN>>'
+            }
+        });
+    });
+    it('builds text config for Codex using http_headers', () => {
+        const integration = buildCloudMcpClientIntegration({
+            clientId: 'codex',
+            endpoint: 'https://performance-app.taskforcehq.ai/mcp',
+            tokenValue: '<<GENERATE_TOKEN>>',
+            serverId: 'taskforce-workspace-alpha',
+        });
+        expect(integration.kind).toBe('text');
+        expect(integration.renderedText).toContain('[mcp_servers.taskforce-workspace-alpha]');
+        expect(integration.renderedText).toContain('http_headers = { Authorization = "Bearer <<GENERATE_TOKEN>>" }');
+    });
+    it('includes optional AI identity headers in generated config snippets for automation-friendly clients', () => {
+        const codex = buildCloudMcpClientIntegration({
+            clientId: 'codex',
+            endpoint: 'https://performance-app.taskforcehq.ai/mcp',
+            tokenValue: '<<GENERATE_TOKEN>>',
+            serverId: 'taskforce-workspace-alpha',
+            aiProfileName: 'Automation Codex',
+            aiProfileToken: 'tfp_automation_codex',
+            aiProfileDescription: 'OpenAI Codex coding agent connected through MCP.',
+            aiProfileRole: 'Coding Agent',
+            aiProfileProvider: 'OpenAI',
+            aiProfileModel: 'Codex',
+            aiProfileSurfaceType: 'coding_tool',
+        });
+        const vscode = buildCloudMcpClientIntegration({
+            clientId: 'vscode',
+            endpoint: 'https://performance-app.taskforcehq.ai/mcp',
+            tokenValue: '<<GENERATE_TOKEN>>',
+            serverId: 'taskforce-workspace-alpha',
+            aiProfileName: 'Automation Codex',
+            aiProfileRole: 'Coding Agent',
+        });
+        expect(codex.renderedText).toContain('X-Taskforce-AI-Name = "Automation Codex"');
+        expect(codex.renderedText).toContain('X-Taskforce-AI-Profile-Token = "tfp_automation_codex"');
+        expect(codex.renderedText).toContain('X-Taskforce-AI-Description = "OpenAI Codex coding agent connected through MCP."');
+        expect(codex.renderedText).toContain('X-Taskforce-AI-Role = "Coding Agent"');
+        expect(codex.renderedText).toContain('X-Taskforce-AI-Provider = "OpenAI"');
+        expect(codex.renderedText).toContain('X-Taskforce-AI-Model = "Codex"');
+        expect(codex.renderedText).toContain('X-Taskforce-AI-Surface-Type = "coding_tool"');
+        expect(codex.instructionText).toContain('automated AI workers');
+        expect(vscode.serverConfig).toEqual({
+            type: 'http',
+            url: 'https://performance-app.taskforcehq.ai/mcp',
+            headers: {
+                Authorization: 'Bearer <<GENERATE_TOKEN>>',
+                'X-Taskforce-AI-Name': 'Automation Codex',
+                'X-Taskforce-AI-Role': 'Coding Agent',
+            }
+        });
+        expect(vscode.instructionText).toContain('automated AI workers');
+    });
+    it('builds JSON text config for OpenClaw using mcp.servers', () => {
+        const integration = buildCloudMcpClientIntegration({
+            clientId: 'openclaw',
+            endpoint: 'https://performance-app.taskforcehq.ai/mcp',
+            tokenValue: '<<GENERATE_TOKEN>>',
+            serverId: 'taskforce-workspace-alpha',
+        });
+        expect(integration.kind).toBe('json');
+        expect(integration.rootKey).toBe('servers');
+        expect(integration.wrapperKeys).toEqual(['mcp']);
+        expect(integration.serverConfig).toEqual({
+            transport: 'streamable-http',
+            url: 'https://performance-app.taskforcehq.ai/mcp',
+            headers: {
+                Authorization: 'Bearer <<GENERATE_TOKEN>>'
+            }
+        });
+        expect(integration.instructionText).toContain('~/.openclaw/openclaw.json');
+    });
+    it('builds command config for Gemini CLI using http transport', () => {
+        const integration = buildCloudMcpClientIntegration({
+            clientId: 'gemini-cli',
+            endpoint: 'https://performance-app.taskforcehq.ai/mcp',
+            tokenValue: '<<GENERATE_TOKEN>>',
+            serverId: 'taskforce-workspace-alpha',
+        });
+        expect(integration.kind).toBe('text');
+        expect(integration.renderedText).toBe('gemini mcp add taskforce-workspace-alpha https://performance-app.taskforcehq.ai/mcp --transport http --header "Authorization: Bearer <<GENERATE_TOKEN>>"');
+    });
+});

package/dist/mcp/index.d.ts

@@ -0,0 +1,2 @@
+export { createTaskforceMcpServer, startTaskforceMcpStdioServer } from './runtime.js';
+export type { TaskforceMcpServerOptions } from './runtime.js';

package/dist/mcp/index.js

@@ -0,0 +1,2 @@
+// Public API for the MCP module
+export { createTaskforceMcpServer, startTaskforceMcpStdioServer } from './runtime.js';

package/dist/mcp/optionResolution.test.js

@@ -2,11 +2,11 @@ import { describe, expect, it } from 'vitest';
 import { COMPLEXITY_OPTIONS, resolveNumberOption, resolveStringOption, STATUS_OPTIONS } from './optionResolution';
 describe('mcp option resolution', () => {
     const categoryOptions = [
-        { value: 'ui/ux', label: 'UI/UX' },
+        { value: 'ui/ux', label: 'UI/UX', aliases: ['design'] },
         { value: 'general', label: 'General' }
     ];
     const typeOptions = [
-        { value: 'feature', label: 'Feature' },
+        { value: 'feature', label: 'Feature', aliases: ['capability'] },
         { value: 'bug', label: 'Bug' }
     ];
     const priorityOptions = [
@@ -20,6 +20,10 @@ describe('mcp option resolution', () => {
         expect(resolveStringOption('category', 'UI UX', categoryOptions)).toBe('ui/ux');
         expect(resolveStringOption('type', 'Feature', typeOptions)).toBe('feature');
     });
+    it('resolves configured taxonomy aliases', () => {
+        expect(resolveStringOption('category', 'design', categoryOptions)).toBe('ui/ux');
+        expect(resolveStringOption('type', 'capability', typeOptions)).toBe('feature');
+    });
     it('resolves status aliases', () => {
         expect(resolveStringOption('status', 'in progress', STATUS_OPTIONS)).toBe('in-progress');
         expect(resolveStringOption('status', 'completed', STATUS_OPTIONS)).toBe('done');

package/dist/mcp/runtime.d.ts

@@ -0,0 +1,120 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { McpAccessTokenScope, TaskforceCore } from '../core/Taskforce.js';
+export interface TaskforceMcpServerOptions {
+    projectRoot?: string;
+    tenantId?: string;
+    workspaceId?: string;
+    serverName?: string;
+    version?: string;
+    logStartup?: boolean;
+    runtimeMode?: 'local' | 'cloud';
+    auth?: {
+        scopes?: McpAccessTokenScope[] | null;
+        userId?: string | null;
+        tokenId?: string | null;
+        aiProfileToken?: string | null;
+        aiProfileName?: string | null;
+        aiProfileDescription?: string | null;
+        aiProfileRole?: string | null;
+        aiProfileProvider?: string | null;
+        aiProfileModel?: string | null;
+        aiProfileSurfaceType?: string | null;
+        actorType?: 'local' | 'user' | 'token' | 'oauth';
+        requestId?: string | null;
+        ip?: string | null;
+        userAgent?: string | null;
+    };
+}
+export declare function isMcpWriteToolName(name: string): boolean;
+export declare function buildRecoverableToolErrorResult(error: unknown, requestId?: string | null): {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+} | null;
+export declare function createTaskforceMcpServer(options?: TaskforceMcpServerOptions): {
+    server: Server<{
+        method: string;
+        params?: {
+            [x: string]: unknown;
+            _meta?: {
+                [x: string]: unknown;
+                progressToken?: string | number | undefined;
+                "io.modelcontextprotocol/related-task"?: {
+                    taskId: string;
+                } | undefined;
+            } | undefined;
+        } | undefined;
+    }, {
+        method: string;
+        params?: {
+            [x: string]: unknown;
+            _meta?: {
+                [x: string]: unknown;
+                progressToken?: string | number | undefined;
+                "io.modelcontextprotocol/related-task"?: {
+                    taskId: string;
+                } | undefined;
+            } | undefined;
+        } | undefined;
+    }, {
+        [x: string]: unknown;
+        _meta?: {
+            [x: string]: unknown;
+            progressToken?: string | number | undefined;
+            "io.modelcontextprotocol/related-task"?: {
+                taskId: string;
+            } | undefined;
+        } | undefined;
+    }>;
+    core: TaskforceCore;
+    projectRoot: string;
+    projectName: string;
+    workspaceId: string;
+    tenantId: string;
+    version: string;
+};
+export declare function startTaskforceMcpStdioServer(options?: TaskforceMcpServerOptions): Promise<{
+    transport: StdioServerTransport;
+    server: Server<{
+        method: string;
+        params?: {
+            [x: string]: unknown;
+            _meta?: {
+                [x: string]: unknown;
+                progressToken?: string | number | undefined;
+                "io.modelcontextprotocol/related-task"?: {
+                    taskId: string;
+                } | undefined;
+            } | undefined;
+        } | undefined;
+    }, {
+        method: string;
+        params?: {
+            [x: string]: unknown;
+            _meta?: {
+                [x: string]: unknown;
+                progressToken?: string | number | undefined;
+                "io.modelcontextprotocol/related-task"?: {
+                    taskId: string;
+                } | undefined;
+            } | undefined;
+        } | undefined;
+    }, {
+        [x: string]: unknown;
+        _meta?: {
+            [x: string]: unknown;
+            progressToken?: string | number | undefined;
+            "io.modelcontextprotocol/related-task"?: {
+                taskId: string;
+            } | undefined;
+        } | undefined;
+    }>;
+    core: TaskforceCore;
+    projectRoot: string;
+    projectName: string;
+    workspaceId: string;
+    tenantId: string;
+    version: string;
+}>;