@taskforcehq/taskforce 0.3.303 → 0.3.305

package/dist/mcp/adminWorkspaceRegistrar.d.ts

@@ -0,0 +1,2 @@
+import type { DomainToolExecutor, RegisterMcpTool } from './toolCatalog.js';
+export declare function registerAdminWorkspaceTools(registerTool: RegisterMcpTool, executeTool: DomainToolExecutor): void;

package/dist/mcp/adminWorkspaceRegistrar.js

@@ -0,0 +1,154 @@
+import { bindDomainTool } from './toolCatalog.js';
+function stringProperty(description, enumValues) {
+    return enumValues ? { type: 'string', description, enum: enumValues } : { type: 'string', description };
+}
+function numberProperty(description) {
+    return { type: 'number', description };
+}
+function booleanProperty(description) {
+    return { type: 'boolean', description };
+}
+function arrayProperty(description, items) {
+    return { type: 'array', description, items };
+}
+export function registerAdminWorkspaceTools(registerTool, executeTool) {
+    const register = (name, buildDescriptor) => {
+        registerTool({
+            name,
+            buildDescriptor: (context) => {
+                const descriptor = buildDescriptor(context);
+                return {
+                    name,
+                    description: descriptor.description,
+                    inputSchema: {
+                        type: 'object',
+                        properties: descriptor.inputSchema.properties,
+                        ...(descriptor.inputSchema.required ? { required: descriptor.inputSchema.required } : {}),
+                    },
+                };
+            },
+            handler: bindDomainTool(executeTool, name),
+        });
+    };
+    register('get_config', (context) => ({
+        description: context.describeTool('Get the active workspace taxonomy and planning configuration. Call this at the start of a session or before create_task/update_task when you need valid category, type, priority, approach, status, or complexity values.'),
+        inputSchema: { properties: {} },
+    }));
+    register('update_categories', (context) => ({
+        description: context.describeTool('Replace the workspace category taxonomy. This is session-only and updates the active categories used by task fields and validation.'),
+        inputSchema: {
+            properties: {
+                categories: arrayProperty('Ordered category definitions to save.', {
+                    type: 'object',
+                    properties: {
+                        value: { type: 'string' },
+                        label: { type: 'string' },
+                        aliases: { type: 'array', items: { type: 'string' } },
+                    },
+                }),
+            },
+            required: ['categories'],
+        },
+    }));
+    register('update_types', (context) => ({
+        description: context.describeTool('Replace the workspace task type taxonomy. This is session-only and updates the active task type definitions used by validation and task editing flows.'),
+        inputSchema: {
+            properties: {
+                types: arrayProperty('Ordered task type definitions to save.', {
+                    type: 'object',
+                    properties: {
+                        value: { type: 'string' },
+                        label: { type: 'string' },
+                        aliases: { type: 'array', items: { type: 'string' } },
+                    },
+                }),
+            },
+            required: ['types'],
+        },
+    }));
+    register('bulk_update_type', (context) => ({
+        description: context.describeTool('Bulk-update tasks from one task type to another. Use get_config first to confirm the current valid type values.'),
+        inputSchema: {
+            properties: {
+                fromType: stringProperty('Current task type value to replace.', context.typeEnum),
+                toType: stringProperty('Replacement task type value.', context.typeEnum),
+            },
+            required: ['fromType', 'toType'],
+        },
+    }));
+    register('bulk_update_fields', (context) => ({
+        description: context.describeTool('Apply field updates to multiple tasks in one request. Use get_config first to confirm valid taxonomy values before calling this tool.'),
+        inputSchema: {
+            properties: {
+                updates: arrayProperty('List of per-task field updates.', {
+                    type: 'object',
+                    properties: {
+                        id: { type: 'string', description: 'Task ID or task reference such as T-123.' },
+                        title: { type: 'string' },
+                        description: { type: 'string' },
+                        category: { type: 'string' },
+                        type: { type: 'string' },
+                        priority: { type: 'number', description: context.priorityDesc },
+                        approach: { type: 'string', enum: context.approachEnum },
+                        assignee: { type: 'string', description: `${context.assigneeHint} Call list_assignees to inspect the current eligible IDs.` },
+                        owner: { type: 'string', description: `${context.assigneeHint} Alias for assignee.` },
+                        status: { type: 'string', enum: ['task', 'on-hold', 'in-progress', 'review', 'done', 'cancelled'] },
+                        complexity: { type: 'number', description: context.complexityDesc },
+                    },
+                    required: ['id'],
+                }),
+            },
+            required: ['updates'],
+        },
+    }));
+    register('export_resources', (context) => ({
+        description: context.describeTool('Export Taskforce resources to files on disk. Local-only utility for generating external artifacts from workspace data.'),
+        inputSchema: {
+            properties: {
+                type: stringProperty('Resource export type.'),
+                path: stringProperty('Destination path for the export output.'),
+                variables: { type: 'object', description: 'Optional template variables for the export job.' },
+                environment: stringProperty('Optional environment name to include in the export context.'),
+            },
+            required: ['type', 'path'],
+        },
+    }));
+    register('get_paths', (context) => ({
+        description: context.describeTool('Get project and Taskforce storage paths. Local-only utility for discovering the project root, Taskforce data root, and related filesystem locations.'),
+        inputSchema: { properties: {} },
+    }));
+    register('update_priorities', (context) => ({
+        description: context.describeTool('Replace the workspace priority options. This is session-only and updates the valid priority taxonomy used by task editing flows.'),
+        inputSchema: {
+            properties: {
+                priorities: arrayProperty('Ordered priority definitions to save.', {
+                    type: 'object',
+                    properties: {
+                        value: { type: 'number' },
+                        label: { type: 'string' },
+                    },
+                }),
+            },
+            required: ['priorities'],
+        },
+    }));
+    register('update_approaches', (context) => ({
+        description: context.describeTool('Replace the active approach options. This is session-only and updates the valid approach taxonomy used by task editing flows.'),
+        inputSchema: {
+            properties: {
+                approaches: arrayProperty('Ordered approach definitions to save.', {
+                    type: 'object',
+                    properties: {
+                        value: { type: 'string' },
+                        label: { type: 'string' },
+                    },
+                }),
+            },
+            required: ['approaches'],
+        },
+    }));
+    register('get_stats', (context) => ({
+        description: context.describeTool('Get task counts by status and priority for situational awareness. Call this at the start of a session to understand the current workload before listing or modifying tasks. Returns active totals (by status and priority) and archived totals.'),
+        inputSchema: { properties: {} },
+    }));
+}

package/dist/mcp/canonicalAssetHelpers.d.ts

@@ -0,0 +1,70 @@
+import type { WorkspaceAssetEntry, WorkspaceAssetKind, WorkspaceAssetLinkRole, WorkspaceAssetScanStatus, WorkspaceAssetStore } from '../storage/workspaceAssetStore.js';
+import type { McpTaskAttachmentDescriptor, TaskAttachmentRecord } from './taskAttachmentTypes.js';
+export interface CanonicalAssetHelpersDeps {
+    activeWorkspaceId: string;
+    projectRoot: string;
+    basePath: string;
+    workspaceAssetStore: WorkspaceAssetStore | null;
+    objectStorageClient: {
+        getObject(storageKey: string): Promise<{
+            body: Buffer;
+        } | null>;
+    } | null;
+    sanitizeFilenameForPath: (filenameRaw: unknown, fallback?: string) => string;
+    sanitizeDisplayName: (valueRaw: unknown, fallback: string) => string;
+    toPosixPath: (filePath: string) => string;
+    inferMimeTypeFromPath: (filePath: string) => string;
+    inferAssetKind: (filePath: string, mimeType: string) => WorkspaceAssetKind;
+    buildCanonicalWorkspaceAssetRelativePath: (params: {
+        workspaceIdRaw: unknown;
+        kind: WorkspaceAssetKind;
+        filename: string;
+        now?: Date;
+    }) => {
+        relativePath: string;
+        assetId: string;
+    };
+}
+export declare function createCanonicalAssetHelpers(deps: CanonicalAssetHelpersDeps): {
+    normalizeAttachmentStorageKey: (pathValue: unknown, fsPathValue: unknown) => string | null;
+    buildSyntheticAttachmentId: (taskId: string, attachment: TaskAttachmentRecord) => string;
+    getAttachmentAssetRecord: (attachment: TaskAttachmentRecord) => WorkspaceAssetEntry | null;
+    buildAttachmentDownloadUrl: (attachment: McpTaskAttachmentDescriptor) => string;
+    buildDocumentDownloadUrl: (asset: WorkspaceAssetEntry) => string;
+    readCanonicalAttachmentBuffer: (taskId: string, attachment: McpTaskAttachmentDescriptor) => Promise<Buffer>;
+    readCanonicalDocumentBuffer: (asset: WorkspaceAssetEntry) => Promise<Buffer>;
+    toTaskAttachmentRecord: (attachment: string | TaskAttachmentRecord) => TaskAttachmentRecord;
+    resolveAttachmentLogicalFilename: (attachmentInput: string | TaskAttachmentRecord, assetOverride?: ReturnType<(attachment: TaskAttachmentRecord) => WorkspaceAssetEntry | null> | null) => string;
+    resolveCanonicalOverwriteTarget: (task: {
+        id: string;
+        attachments?: Array<string | TaskAttachmentRecord> | null;
+    }, filenameRaw: unknown, describeTaskAttachment: (taskId: string, attachmentInput: string | TaskAttachmentRecord) => McpTaskAttachmentDescriptor) => null | {
+        index: number;
+        attachment: TaskAttachmentRecord;
+        asset: NonNullable<ReturnType<(attachment: TaskAttachmentRecord) => WorkspaceAssetEntry | null>>;
+        descriptor: McpTaskAttachmentDescriptor;
+        relativePath: string;
+        absolutePath: string;
+        logicalFilename: string;
+    };
+    ensureCanonicalTaskAttachment: (relativePathRaw: string, taskIdRaw: string, captionRaw: string | undefined, timestampRaw: string | undefined, role: WorkspaceAssetLinkRole, options?: {
+        originalFilename?: string;
+        logicalName?: string;
+        assetId?: string;
+        documentId?: string | null;
+        createdAt?: string;
+        createdByUserId?: string | null;
+        scanStatus?: WorkspaceAssetScanStatus;
+        scanEngine?: string | null;
+        scanDetails?: string | null;
+    }) => WorkspaceAssetEntry | null;
+    buildCanonicalWorkspaceAssetRelativePath: (params: {
+        workspaceIdRaw: unknown;
+        kind: WorkspaceAssetKind;
+        filename: string;
+        now?: Date;
+    }) => {
+        relativePath: string;
+        assetId: string;
+    };
+};

package/dist/mcp/canonicalAssetHelpers.js

@@ -0,0 +1,259 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { createHash, randomUUID } from 'node:crypto';
+export function createCanonicalAssetHelpers(deps) {
+    const normalizeAttachmentStorageKey = (pathValue, fsPathValue) => {
+        const fsPathRaw = String(fsPathValue || '').trim().replace(/\\/g, '/');
+        if (fsPathRaw) {
+            return fsPathRaw.replace(/^\.taskforce\//, '').trim() || null;
+        }
+        const pathRaw = String(pathValue || '').trim();
+        if (!pathRaw)
+            return null;
+        if (/^https?:\/\//i.test(pathRaw))
+            return pathRaw;
+        if (pathRaw.startsWith('/api/taskforce/context/')) {
+            return decodeURIComponent(pathRaw.slice('/api/taskforce/context/'.length)).trim() || null;
+        }
+        return null;
+    };
+    const buildSyntheticAttachmentId = (taskId, attachment) => {
+        const stableSource = [
+            taskId,
+            String(attachment.path || '').trim(),
+            String(attachment.fsPath || '').trim(),
+            String(attachment.caption || '').trim(),
+        ].join('::');
+        return `attachment-${createHash('sha256').update(stableSource).digest('hex').slice(0, 24)}`;
+    };
+    const getAttachmentAssetRecord = (attachment) => {
+        if (!deps.workspaceAssetStore)
+            return null;
+        const assetId = String(attachment.assetId || '').trim();
+        if (assetId) {
+            const byId = deps.workspaceAssetStore.get(assetId, deps.activeWorkspaceId);
+            if (byId && !byId.deletedAt)
+                return byId;
+        }
+        const storageKey = normalizeAttachmentStorageKey(attachment.path, attachment.fsPath);
+        if (!storageKey || /^https?:\/\//i.test(storageKey))
+            return null;
+        const byStorageKey = deps.workspaceAssetStore.getByStorageKey(storageKey, deps.activeWorkspaceId);
+        if (byStorageKey && !byStorageKey.deletedAt)
+            return byStorageKey;
+        return null;
+    };
+    const buildAttachmentDownloadUrl = (attachment) => {
+        if (attachment.source === 'external')
+            return attachment.path;
+        const safeName = encodeURIComponent(String(attachment.caption || attachment.displayName || attachment.originalFilename || path.basename(attachment.fsPath || attachment.path) || 'download').trim());
+        const joiner = attachment.path.includes('?') ? '&' : '?';
+        return `${attachment.path}${joiner}download=1&filename=${safeName}`;
+    };
+    const buildDocumentDownloadUrl = (asset) => {
+        const safeName = deps.sanitizeFilenameForPath(asset.originalFilename
+            || asset.logicalName
+            || path.basename(String(asset.storageKey || '').trim())
+            || 'document.txt', 'document.txt');
+        return `/api/taskforce/documents/${encodeURIComponent(String(asset.assetId || '').trim())}/content?download=1&filename=${encodeURIComponent(safeName)}`;
+    };
+    const describeAttachmentStorageContext = (attachment, storageKey) => {
+        const parts = [
+            `attachmentId=${attachment.attachmentId}`,
+            `assetId=${String(attachment.assetId || 'unknown')}`,
+            `storageKey=${storageKey || 'unknown'}`
+        ];
+        return parts.join(', ');
+    };
+    const readCanonicalAttachmentBuffer = async (taskId, attachment) => {
+        const assetId = String(attachment.assetId || '').trim();
+        const asset = assetId && deps.workspaceAssetStore
+            ? deps.workspaceAssetStore.get(assetId, deps.activeWorkspaceId)
+            : null;
+        if (!asset || asset.deletedAt) {
+            throw new Error(`Attachment ${attachment.attachmentId} not found on task ${taskId}`);
+        }
+        if (asset.scanStatus === 'infected') {
+            throw new Error('Attachment is quarantined');
+        }
+        if (asset.scanStatus === 'pending') {
+            throw new Error('Attachment scan pending');
+        }
+        if (asset.storageProvider === 'r2') {
+            const attachmentContext = describeAttachmentStorageContext(attachment, asset.storageKey);
+            if (!deps.objectStorageClient) {
+                throw new Error(`Attachment read failed from R2 because object storage is not configured in this MCP runtime (${attachmentContext})`);
+            }
+            let object;
+            try {
+                object = await deps.objectStorageClient.getObject(asset.storageKey);
+            }
+            catch (error) {
+                const message = error instanceof Error ? String(error.message || '').trim() : String(error || '').trim();
+                throw new Error(`Attachment read failed from R2 (${attachmentContext}): ${message || 'Unknown object storage error'}`);
+            }
+            if (!object) {
+                throw new Error(`Attachment ${attachment.attachmentId} not found on task ${taskId}`);
+            }
+            return object.body;
+        }
+        const resolvedPath = path.resolve(deps.basePath, asset.storageKey);
+        if (!resolvedPath.startsWith(path.resolve(deps.basePath))) {
+            throw new Error(`Attachment ${attachment.attachmentId} not found on task ${taskId}`);
+        }
+        if (!fs.existsSync(resolvedPath) || !fs.statSync(resolvedPath).isFile()) {
+            throw new Error(`Attachment ${attachment.attachmentId} not found on task ${taskId}`);
+        }
+        return fs.readFileSync(resolvedPath);
+    };
+    const readCanonicalDocumentBuffer = async (asset) => {
+        if (asset.deletedAt || asset.kind !== 'document') {
+            throw new Error(`Document ${asset.assetId} not found in workspace ${deps.activeWorkspaceId}.`);
+        }
+        if (asset.scanStatus === 'infected') {
+            throw new Error('Document is quarantined');
+        }
+        if (asset.scanStatus === 'pending') {
+            throw new Error('Document scan pending');
+        }
+        if (asset.storageProvider === 'r2') {
+            if (!deps.objectStorageClient) {
+                throw new Error(`Document read failed from R2 because object storage is not configured in this MCP runtime (assetId=${asset.assetId}, storageKey=${asset.storageKey || 'unknown'})`);
+            }
+            let object;
+            try {
+                object = await deps.objectStorageClient.getObject(asset.storageKey);
+            }
+            catch (error) {
+                const message = error instanceof Error ? String(error.message || '').trim() : String(error || '').trim();
+                throw new Error(`Document read failed from R2 (assetId=${asset.assetId}, storageKey=${asset.storageKey || 'unknown'}): ${message || 'Unknown object storage error'}`);
+            }
+            if (!object) {
+                throw new Error(`Document ${asset.assetId} not found in workspace ${deps.activeWorkspaceId}.`);
+            }
+            return object.body;
+        }
+        const resolvedPath = path.resolve(deps.basePath, asset.storageKey);
+        if (!resolvedPath.startsWith(path.resolve(deps.basePath))) {
+            throw new Error(`Document ${asset.assetId} not found in workspace ${deps.activeWorkspaceId}.`);
+        }
+        if (!fs.existsSync(resolvedPath) || !fs.statSync(resolvedPath).isFile()) {
+            throw new Error(`Document ${asset.assetId} not found in workspace ${deps.activeWorkspaceId}.`);
+        }
+        return fs.readFileSync(resolvedPath);
+    };
+    const toTaskAttachmentRecord = (attachment) => {
+        if (typeof attachment === 'string') {
+            return { path: attachment };
+        }
+        return attachment;
+    };
+    const resolveAttachmentLogicalFilename = (attachmentInput, assetOverride) => {
+        const attachment = toTaskAttachmentRecord(attachmentInput);
+        const asset = assetOverride ?? getAttachmentAssetRecord(attachment);
+        const candidate = String(attachment.originalFilename
+            || asset?.originalFilename
+            || attachment.displayName
+            || asset?.logicalName
+            || '').trim();
+        if (candidate) {
+            return deps.sanitizeFilenameForPath(candidate);
+        }
+        const storageKey = normalizeAttachmentStorageKey(attachment.path, attachment.fsPath);
+        return deps.sanitizeFilenameForPath(storageKey ? path.basename(storageKey) : '', 'attachment.txt');
+    };
+    const resolveCanonicalOverwriteTarget = (task, filenameRaw, describeTaskAttachment) => {
+        const requestedFilename = deps.sanitizeFilenameForPath(filenameRaw);
+        const existingAttachments = Array.isArray(task.attachments) ? task.attachments : [];
+        for (let index = 0; index < existingAttachments.length; index++) {
+            const attachment = toTaskAttachmentRecord(existingAttachments[index]);
+            const asset = getAttachmentAssetRecord(attachment);
+            if (!asset || asset.deletedAt || asset.storageProvider === 'external')
+                continue;
+            const descriptor = describeTaskAttachment(task.id, attachment);
+            if (descriptor.source !== 'canonical')
+                continue;
+            const logicalFilename = resolveAttachmentLogicalFilename(attachment, asset);
+            if (logicalFilename !== requestedFilename)
+                continue;
+            const relativePath = deps.toPosixPath(path.relative(deps.projectRoot, path.resolve(deps.basePath, asset.storageKey)));
+            return {
+                index,
+                attachment,
+                asset,
+                descriptor,
+                relativePath,
+                absolutePath: path.resolve(deps.basePath, asset.storageKey),
+                logicalFilename,
+            };
+        }
+        return null;
+    };
+    const ensureCanonicalTaskAttachment = (relativePathRaw, taskIdRaw, captionRaw, timestampRaw, role, options) => {
+        if (!deps.workspaceAssetStore)
+            return null;
+        const relativePath = String(relativePathRaw || '').trim();
+        const taskId = String(taskIdRaw || '').trim();
+        if (!relativePath || !taskId)
+            return null;
+        const absolutePath = path.resolve(deps.projectRoot, relativePath);
+        if (!fs.existsSync(absolutePath) || !fs.statSync(absolutePath).isFile())
+            return null;
+        const storageKey = relativePath.replace(/^\.taskforce\//, '').trim() || relativePath;
+        const buffer = fs.readFileSync(absolutePath);
+        const stats = fs.statSync(absolutePath);
+        const mimeType = deps.inferMimeTypeFromPath(relativePath);
+        const kind = deps.inferAssetKind(relativePath, mimeType);
+        const timestamp = String(timestampRaw || new Date().toISOString()).trim() || new Date().toISOString();
+        const existing = deps.workspaceAssetStore.getByStorageKey(storageKey, deps.activeWorkspaceId);
+        const originalFilename = deps.sanitizeFilenameForPath(options?.originalFilename || existing?.originalFilename || path.basename(relativePath));
+        const logicalName = deps.sanitizeDisplayName(options?.logicalName || existing?.logicalName || originalFilename, originalFilename);
+        const asset = deps.workspaceAssetStore.upsertAsset({
+            assetId: options?.assetId || existing?.assetId || `asset-${randomUUID().replace(/-/g, '')}`,
+            workspaceId: deps.activeWorkspaceId,
+            kind,
+            logicalName,
+            originalFilename,
+            mimeType,
+            storageProvider: 'local',
+            storageKey,
+            contentSha256: createHash('sha256').update(buffer).digest('hex'),
+            sizeBytes: stats.size,
+            documentId: kind === 'document' ? (options?.documentId || existing?.documentId || `doc-${randomUUID().replace(/-/g, '')}`) : null,
+            version: kind === 'document' ? Math.max(1, Number(existing?.version || 0) + 1) : null,
+            isLatest: true,
+            scanStatus: options?.scanStatus || existing?.scanStatus || 'clean',
+            scanEngine: options?.scanEngine !== undefined ? options.scanEngine : (existing?.scanEngine || null),
+            scanDetails: options?.scanDetails !== undefined ? options.scanDetails : (existing?.scanDetails || null),
+            createdByUserId: options?.createdByUserId !== undefined ? options.createdByUserId : (existing?.createdByUserId || null),
+            createdAt: options?.createdAt || existing?.createdAt || timestamp,
+            updatedAt: timestamp,
+            deletedAt: null,
+            purgeAfter: null
+        });
+        deps.workspaceAssetStore.upsertLink({
+            workspaceId: deps.activeWorkspaceId,
+            assetId: asset.assetId,
+            taskId,
+            role,
+            displayName: kind === 'document' ? null : (captionRaw || null),
+            updatedAt: timestamp,
+            deletedAt: null
+        });
+        return asset;
+    };
+    return {
+        normalizeAttachmentStorageKey,
+        buildSyntheticAttachmentId,
+        getAttachmentAssetRecord,
+        buildAttachmentDownloadUrl,
+        buildDocumentDownloadUrl,
+        readCanonicalAttachmentBuffer,
+        readCanonicalDocumentBuffer,
+        toTaskAttachmentRecord,
+        resolveAttachmentLogicalFilename,
+        resolveCanonicalOverwriteTarget,
+        ensureCanonicalTaskAttachment,
+        buildCanonicalWorkspaceAssetRelativePath: deps.buildCanonicalWorkspaceAssetRelativePath,
+    };
+}

package/dist/mcp/clientIntegrations.d.ts

@@ -1,5 +1,5 @@
 import { type AiProfileBootstrapConfig } from './aiProfileBootstrap.js';
-export type McpClientId = 'cursor' | 'cline' | 'vscode' | 'windsurf' | 'antigravity' | 'openclaw' | 'codex' | 'claude-code' | 'gemini-cli' | 'claude-desktop' | 'chatgpt-desktop';
+export type McpClientId = 'general' | 'cursor' | 'cline' | 'vscode' | 'windsurf' | 'antigravity' | 'openclaw' | 'codex' | 'claude-code' | 'gemini-cli' | 'claude-desktop' | 'chatgpt-desktop';
 export interface McpClientOption {
     id: McpClientId;
     label: string;
@@ -11,6 +11,16 @@ export interface BuildCloudMcpClientConfigInput extends AiProfileBootstrapConfig
     tokenValue: string;
     serverId: string;
 }
+export interface LocalMcpServerConfig {
+    command: string;
+    args: string[];
+    env?: Record<string, string>;
+}
+export interface BuildLocalMcpClientConfigInput {
+    clientId: McpClientId;
+    serverId: string;
+    serverConfig: LocalMcpServerConfig;
+}
 export interface CloudMcpClientIntegration {
     clientId: McpClientId;
     kind: 'json' | 'text';
@@ -25,3 +35,4 @@ export declare const MCP_CLIENT_OPTIONS: McpClientOption[];
 export declare function sanitizeMcpId(value: string, fallback: string): string;
 export declare function buildCloudMcpServerId(workspaceName?: string | null, projectName?: string | null): string;
 export declare function buildCloudMcpClientIntegration(input: BuildCloudMcpClientConfigInput): CloudMcpClientIntegration;
+export declare function buildLocalMcpClientIntegration(input: BuildLocalMcpClientConfigInput): CloudMcpClientIntegration;