@taskforcehq/taskforce 0.3.326 → 0.3.328

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

@@ -0,0 +1,167 @@
+import type { IncomingMessage } from 'http';
+import type { TaskforceCore } from '../../core/Taskforce.js';
+import type { RouteContext } from './primitives.js';
+export declare function createTaskHttpDurableRouters(input: {
+    core: TaskforceCore;
+    context: RouteContext;
+    req: IncomingMessage;
+    workspaceId: string;
+}): {
+    actorRef: string;
+    root: {
+        enabled: boolean;
+        create(candidate: unknown): import("../../core/Taskforce.js").TaskItem;
+        update(taskIdInput: string, candidate: unknown, saveSource: "manual" | "autosave", activityAction?: "task-updated" | "task-schedule-changed"): import("../../core/Taskforce.js").TaskItem;
+        runBatch<T>(routeInput: string, request: unknown, apply: (context: {
+            runChild<R>(mutation: () => R): R;
+            deferPostCommitNotification(notify: () => void): void;
+        }) => T, options?: {
+            atomicRecovery?: boolean;
+            allowIndependentNestedOwnership?: boolean;
+        }): T;
+        archive(taskId: string, cancellation: boolean, reason: string | null): import("../../core/Taskforce.js").TaskItem;
+        unarchive(taskId: string): import("../../core/Taskforce.js").TaskItem;
+        restore(deletedRecordIdInput: string, restoreDestination?: import("../../shared/taskRestoreDestination.js").TaskRestoreDestination): import("../../core/Taskforce.js").TaskItem;
+        delete(taskIdInput: string): import("../../core/Taskforce.js").DeletedTaskRecord;
+    };
+    comments: {
+        enabled: boolean;
+        append(args: {
+            taskId: string;
+            comment: import("../../core/Taskforce.js").Comment;
+        }): {
+            state: "pending" | "committed";
+            route: "local-outbox" | "cloud-acceptance";
+            operationId: string;
+            task: import("../../core/Taskforce.js").TaskItem;
+        };
+    };
+    checklist: {
+        enabled: boolean;
+        replace(args: {
+            taskId: string;
+            items: readonly Partial<import("../../core/Taskforce.js").ChecklistItem>[];
+        }): {
+            state: "pending" | "committed";
+            route: "local-outbox" | "cloud-acceptance";
+            operationId: string;
+            task: import("../../core/Taskforce.js").TaskItem;
+        };
+    };
+    attachmentLinks: {
+        enabled: boolean;
+        replace(args: {
+            taskId: string;
+            links: readonly import("../../sync/v3/workspaceSyncV3NestedTaskCodecs.js").WorkspaceSyncV3TaskAttachmentLink[];
+            cardCoverAssetId?: string | null;
+        }): {
+            state: "pending" | "committed";
+            route: "local-outbox" | "cloud-acceptance";
+            operationId: string;
+            task: import("../../core/Taskforce.js").TaskItem;
+        };
+    };
+    createChecklistRouter: (operationId?: string) => {
+        enabled: boolean;
+        replace(args: {
+            taskId: string;
+            items: readonly Partial<import("../../core/Taskforce.js").ChecklistItem>[];
+        }): {
+            state: "pending" | "committed";
+            route: "local-outbox" | "cloud-acceptance";
+            operationId: string;
+            task: import("../../core/Taskforce.js").TaskItem;
+        };
+    };
+    createAttachmentLinksRouter: (operationId?: string, deferPostCommitNotification?: (notify: () => void) => void) => {
+        enabled: boolean;
+        replace(args: {
+            taskId: string;
+            links: readonly import("../../sync/v3/workspaceSyncV3NestedTaskCodecs.js").WorkspaceSyncV3TaskAttachmentLink[];
+            cardCoverAssetId?: string | null;
+        }): {
+            state: "pending" | "committed";
+            route: "local-outbox" | "cloud-acceptance";
+            operationId: string;
+            task: import("../../core/Taskforce.js").TaskItem;
+        };
+    };
+    bulk: {
+        create(tasks: Array<Record<string, unknown>>, atomic: boolean, route?: string): {
+            created: import("../../core/Taskforce.js").TaskItem[];
+            errors: {
+                index: number;
+                id?: string;
+                message: string;
+                statusCode: number;
+                code?: string;
+                details?: unknown;
+            }[];
+            total: number;
+            atomic: boolean;
+            validateOnly: boolean;
+        };
+        archive(ids: unknown[], status: unknown): {
+            archived: import("../../core/Taskforce.js").TaskItem[];
+            errors: {
+                index: number;
+                id?: string;
+                message: string;
+                statusCode: number;
+                code?: string;
+                details?: unknown;
+            }[];
+        };
+        restoreDeleted(ids: string[], restoreDestination?: import("../../shared/taskRestoreDestination.js").TaskRestoreDestination): {
+            restored: {
+                deletedRecordId: string;
+                taskId: string;
+                task: import("../../core/Taskforce.js").TaskItem;
+                restoredTo: "archived" | "active";
+            }[];
+            errors: {
+                index: number;
+                id?: string;
+                message: string;
+                statusCode: number;
+                code?: string;
+                details?: unknown;
+            }[];
+        };
+        updateFields(updates: Array<{
+            id: string;
+            [key: string]: unknown;
+        }>, options?: {
+            saveSource?: "manual" | "autosave";
+            atomicItemFailures?: boolean;
+        }): {
+            preview: import("../../core/Taskforce.js").BulkUpdateFieldsPreview;
+            results: import("../../core/Taskforce.js").TaskItem[];
+            errors: {
+                index: number;
+                id?: string;
+                message: string;
+                statusCode: number;
+                code?: string;
+                details?: unknown;
+            }[];
+        };
+    };
+    createRootRouter: (operationId?: string, deferPostCommitNotification?: (notify: () => void) => void) => {
+        enabled: boolean;
+        create(candidate: unknown): import("../../core/Taskforce.js").TaskItem;
+        update(taskIdInput: string, candidate: unknown, saveSource: "manual" | "autosave", activityAction?: "task-updated" | "task-schedule-changed"): import("../../core/Taskforce.js").TaskItem;
+        runBatch<T>(routeInput: string, request: unknown, apply: (context: {
+            runChild<R>(mutation: () => R): R;
+            deferPostCommitNotification(notify: () => void): void;
+        }) => T, options?: {
+            atomicRecovery?: boolean;
+            allowIndependentNestedOwnership?: boolean;
+        }): T;
+        archive(taskId: string, cancellation: boolean, reason: string | null): import("../../core/Taskforce.js").TaskItem;
+        unarchive(taskId: string): import("../../core/Taskforce.js").TaskItem;
+        restore(deletedRecordIdInput: string, restoreDestination?: import("../../shared/taskRestoreDestination.js").TaskRestoreDestination): import("../../core/Taskforce.js").TaskItem;
+        delete(taskIdInput: string): import("../../core/Taskforce.js").DeletedTaskRecord;
+    };
+    deriveChildOperationId: (route: string, index: number, taskId: string) => string;
+};

package/dist/server/routes/durableTaskHttpRouters.js

@@ -0,0 +1,89 @@
+import { createHash } from 'crypto';
+import { createDurableTaskHttpBulkMutationRouter } from '../../sync/v3/durableTaskHttpBulkMutationRouter.js';
+import { createDurableTaskHttpRootMutationRouter } from '../../sync/v3/durableTaskHttpRootMutationRouter.js';
+import { createDurableTaskCommentMutationRouter } from '../../sync/v3/durableTaskCommentMutationRouter.js';
+import { createDurableTaskChecklistMutationRouter } from '../../sync/v3/durableTaskChecklistMutationRouter.js';
+import { createDurableTaskAttachmentLinksMutationRouter } from '../../sync/v3/durableTaskAttachmentLinksMutationRouter.js';
+import { requestHeader, requestHumanActorRef, requestRuntimeMode } from './shared.js';
+export function createTaskHttpDurableRouters(input) {
+    const { core, context, req, workspaceId } = input;
+    const runtimeMode = context.authConfig?.runtimeMode === 'cloud' ? 'cloud' : requestRuntimeMode(req);
+    const parentOperationId = requestHeader(req, 'x-taskforce-operation-id', '').trim();
+    const actorRef = requestHumanActorRef(req);
+    const createRootRouter = (operationId = parentOperationId, deferPostCommitNotification) => createDurableTaskHttpRootMutationRouter({
+        core,
+        runtimeMode,
+        tenantId: core.getTenantId(),
+        workspaceId,
+        operationId,
+        actorRef,
+        deferPostCommitNotification,
+    });
+    const deriveId = (kind, route, index, taskId) => {
+        if (!parentOperationId)
+            return '';
+        const digest = createHash('sha256').update(JSON.stringify({
+            parentOperationId,
+            route,
+            index,
+            ...(kind === 'operation' ? { taskId: String(taskId || '') } : { participant: 'task' }),
+        })).digest('hex');
+        return `${kind}-${digest}`;
+    };
+    const root = createRootRouter();
+    const comments = createDurableTaskCommentMutationRouter({
+        core,
+        runtimeMode,
+        surface: 'http',
+        tenantId: core.getTenantId(),
+        workspaceId,
+        actorRef,
+        operationId: parentOperationId,
+        cloudClientId: 'http-cloud',
+    });
+    const createChecklistRouter = (operationId = parentOperationId) => createDurableTaskChecklistMutationRouter({
+        core,
+        runtimeMode,
+        surface: 'http',
+        tenantId: core.getTenantId(),
+        workspaceId,
+        actorRef,
+        operationId,
+        cloudClientId: 'http-cloud',
+    });
+    const checklist = createChecklistRouter();
+    const createAttachmentLinksRouter = (operationId = parentOperationId, deferPostCommitNotification) => createDurableTaskAttachmentLinksMutationRouter({
+        core,
+        runtimeMode,
+        surface: 'http',
+        tenantId: core.getTenantId(),
+        workspaceId,
+        actorRef,
+        operationId,
+        cloudClientId: 'http-cloud',
+        deferPostCommitNotification,
+    });
+    const attachmentLinks = createAttachmentLinksRouter();
+    const bulk = createDurableTaskHttpBulkMutationRouter({
+        core,
+        workspaceId,
+        rootRouter: root,
+        createChildRouter: (operationId, deferPostCommitNotification) => createRootRouter(operationId, deferPostCommitNotification),
+        createChecklistRouter,
+        createAttachmentLinksRouter,
+        deriveChildOperationId: (route, index, taskId) => deriveId('operation', route, index, taskId),
+        deriveCreateTaskId: (route, index) => deriveId('task', route, index),
+    });
+    return {
+        actorRef,
+        root,
+        comments,
+        checklist,
+        attachmentLinks,
+        createChecklistRouter,
+        createAttachmentLinksRouter,
+        bulk,
+        createRootRouter,
+        deriveChildOperationId: (route, index, taskId) => (deriveId('operation', route, index, taskId)),
+    };
+}

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

@@ -0,0 +1,11 @@
+import type { TaskforceCore } from '../../core/Taskforce.js';
+import { probeGlobalTaskforceCli, type LocalCliHealthResult } from '../../mcp/localCliHealth.js';
+import type { RouteContext, RouteHandler } from './primitives.js';
+export interface LocalMcpHealthRouteDependencies {
+    addRoute: (method: string, path: string, handler: RouteHandler) => void;
+    core: TaskforceCore;
+    context: RouteContext;
+    probeCli?: typeof probeGlobalTaskforceCli;
+}
+export declare function registerLocalMcpHealthRoutes(deps: LocalMcpHealthRouteDependencies): void;
+export type { LocalCliHealthResult };

package/dist/server/routes/localMcpHealth.js

@@ -0,0 +1,29 @@
+import { getTaskforceRuntimeVersion, probeGlobalTaskforceCli } from '../../mcp/localCliHealth.js';
+export function registerLocalMcpHealthRoutes(deps) {
+    const { addRoute, core, context, probeCli = probeGlobalTaskforceCli } = deps;
+    addRoute('POST', '/api/taskforce/mcp/global-cli-health', async (req, res) => {
+        if (context.authConfig?.runtimeMode === 'cloud') {
+            res.writeHead(404, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: false, code: 'LOCAL_MCP_HEALTH_UNAVAILABLE', error: 'Local MCP CLI health is available only in local runtime.' }));
+            return;
+        }
+        const requestedWorkspaceId = String(req.headers['x-taskforce-workspace-id'] || '').trim();
+        const workspaceId = requestedWorkspaceId && core.workspaceExists(requestedWorkspaceId)
+            ? requestedWorkspaceId
+            : core.resolvePreferredWorkspaceId({ allowDefault: false });
+        if (!workspaceId) {
+            res.writeHead(409, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: false, code: 'WORKSPACE_REQUIRED', error: 'A non-default workspace is required to validate Local MCP.' }));
+            return;
+        }
+        const paths = core.getPaths();
+        const result = await probeCli({
+            projectRoot: paths.projectRoot,
+            tenantId: core.getTenantId(),
+            workspaceId,
+            appVersion: getTaskforceRuntimeVersion(),
+        });
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ success: result.state !== 'unusable', result }));
+    });
+}

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

@@ -0,0 +1,13 @@
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import type { TaskforceCore } from '../../core/Taskforce.js';
+import { createTaskforceMcpServer } from '../../mcp/runtime.js';
+import { type LocalServiceRouteContext, type RouteHandler } from './primitives.js';
+interface LocalServiceRouteDependencies {
+    addRoute: (method: string, path: string, handler: RouteHandler) => void;
+    core: TaskforceCore;
+    context: LocalServiceRouteContext | undefined;
+    createMcpServer?: typeof createTaskforceMcpServer;
+    createMcpTransport?: () => StreamableHTTPServerTransport;
+}
+export declare function registerLocalServiceRoutes(deps: LocalServiceRouteDependencies): void;
+export {};