@taskforcehq/taskforce 0.3.168

package/dist/server/realtimeSyncWs.d.ts

@@ -0,0 +1,30 @@
+import type { IncomingMessage } from 'http';
+import type { TaskforceAuthConfig, TaskforceRole } from './auth.js';
+import type { RealtimeMutationEvent } from '../core/Taskforce.js';
+interface RealtimeSyncCoreAccess {
+    resolveUserAccess(userId: string, workspaceId: string, fallbackRole: TaskforceRole): {
+        workspaceId: string;
+    } | null;
+}
+export interface RealtimeWsLike {
+    readyState: number;
+    bufferedAmount?: number;
+    send(data: string): void;
+    close(code?: number, reason?: string): void;
+    on(event: 'message', listener: (data: unknown) => void): unknown;
+    on(event: 'close', listener: () => void): unknown;
+    on(event: 'error', listener: (error: unknown) => void): unknown;
+}
+type Logger = Pick<Console, 'log' | 'warn'>;
+interface RealtimeSyncWsOptions {
+    replayMaxEvents: number;
+    replayTtlMs: number;
+    replayPerMessageLimit: number;
+    maxBufferedBytes: number;
+}
+export declare function createRealtimeSyncWsManager(core: RealtimeSyncCoreAccess, authConfig: TaskforceAuthConfig, logger?: Logger, customOptions?: Partial<RealtimeSyncWsOptions>): {
+    handleConnection: (ws: RealtimeWsLike, req: IncomingMessage) => void;
+    broadcastTaskforceUpdate: (workspaceId?: string) => void;
+    broadcastMutation: (event: RealtimeMutationEvent) => void;
+};
+export {};

package/dist/server/realtimeSyncWs.js

@@ -0,0 +1,257 @@
+import { resolveRequestAccess } from './auth.js';
+const DEFAULT_OPTIONS = {
+    replayMaxEvents: 1000,
+    replayTtlMs: 10 * 60_000,
+    replayPerMessageLimit: 200,
+    maxBufferedBytes: 1_000_000
+};
+function parseWorkspaceId(raw) {
+    const value = typeof raw === 'string' ? raw.trim() : '';
+    if (!value || value.length > 120 || /\s/.test(value))
+        return '';
+    if (value === '*')
+        return '*';
+    return value;
+}
+function parseReplayCursor(raw) {
+    const cursor = typeof raw === 'string' ? raw.trim() : '';
+    if (!cursor)
+        return null;
+    const split = cursor.lastIndexOf(':');
+    if (split <= 0)
+        return null;
+    const serverEpoch = cursor.slice(0, split).trim();
+    const seqRaw = cursor.slice(split + 1).trim();
+    const seq = Number.parseInt(seqRaw, 10);
+    if (!serverEpoch || !Number.isFinite(seq) || seq < 0)
+        return null;
+    return { serverEpoch, seq };
+}
+function parseJson(raw) {
+    try {
+        const text = Buffer.isBuffer(raw) ? raw.toString('utf8') : String(raw);
+        const parsed = JSON.parse(text);
+        return parsed && typeof parsed === 'object' ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function createRealtimeSyncWsManager(core, authConfig, logger = console, customOptions) {
+    const options = {
+        ...DEFAULT_OPTIONS,
+        ...(customOptions || {})
+    };
+    const connections = new Map();
+    const replayBufferByWorkspace = new Map();
+    const send = (ws, payload) => {
+        if (ws.readyState !== 1)
+            return;
+        if (typeof ws.bufferedAmount === 'number' && ws.bufferedAmount > options.maxBufferedBytes) {
+            logger.warn(`[Taskforce] WebSocket slow-consumer close bufferedAmount=${ws.bufferedAmount}`);
+            ws.close(1013, 'slow-consumer');
+            removeConnection(ws);
+            return;
+        }
+        try {
+            ws.send(JSON.stringify(payload));
+        }
+        catch {
+            ws.close(1011, 'send-failed');
+            removeConnection(ws);
+        }
+    };
+    const removeConnection = (ws) => {
+        const existing = connections.get(ws);
+        if (existing) {
+            logger.log(`[Taskforce] WebSocket client disconnected user=${existing.userId}`);
+        }
+        connections.delete(ws);
+    };
+    const canSubscribe = (state, workspaceId) => {
+        if (!workspaceId)
+            return false;
+        if (!authConfig.enabled || !authConfig.requiredForApi)
+            return true;
+        if (!state.authenticated || !state.userId || state.userId === 'anonymous')
+            return false;
+        const resolved = core.resolveUserAccess(state.userId, workspaceId, state.role);
+        return Boolean(resolved?.workspaceId === workspaceId);
+    };
+    const closeUnauthorized = (ws, reason) => {
+        logger.warn(`[Taskforce] WebSocket rejected: ${reason}`);
+        ws.close(1008, reason);
+    };
+    const subscribeWorkspace = (ws, state, workspaceId) => {
+        if (!canSubscribe(state, workspaceId)) {
+            send(ws, { type: 'taskforce:subscription-error', workspaceId, reason: 'forbidden' });
+            return;
+        }
+        state.workspaceIds.add(workspaceId);
+        send(ws, { type: 'taskforce:subscribed', workspaceId });
+        logger.log(`[Taskforce] WebSocket subscribed user=${state.userId} workspace=${workspaceId}`);
+    };
+    const unsubscribeWorkspace = (ws, state, workspaceId) => {
+        if (!workspaceId)
+            return;
+        state.workspaceIds.delete(workspaceId);
+        send(ws, { type: 'taskforce:unsubscribed', workspaceId });
+        logger.log(`[Taskforce] WebSocket unsubscribed user=${state.userId} workspace=${workspaceId}`);
+    };
+    const pruneWorkspaceBuffer = (workspaceId) => {
+        const current = replayBufferByWorkspace.get(workspaceId);
+        if (!current || current.length === 0)
+            return;
+        const now = Date.now();
+        const cutoff = now - options.replayTtlMs;
+        const ttlFiltered = current.filter((event) => Date.parse(event.serverTs) >= cutoff);
+        const bounded = ttlFiltered.slice(Math.max(0, ttlFiltered.length - options.replayMaxEvents));
+        replayBufferByWorkspace.set(workspaceId, bounded);
+    };
+    const appendReplayEvent = (event) => {
+        const workspaceId = parseWorkspaceId(event.workspaceId);
+        if (!workspaceId)
+            return;
+        const current = replayBufferByWorkspace.get(workspaceId) || [];
+        current.push(event);
+        replayBufferByWorkspace.set(workspaceId, current);
+        pruneWorkspaceBuffer(workspaceId);
+    };
+    const getWorkspaceReplayEvents = (workspaceId) => {
+        pruneWorkspaceBuffer(workspaceId);
+        const direct = replayBufferByWorkspace.get(workspaceId) || [];
+        const shared = replayBufferByWorkspace.get('*') || [];
+        const merged = workspaceId === '*'
+            ? direct
+            : [...direct, ...shared];
+        return merged.sort((a, b) => a.seq - b.seq);
+    };
+    const handleReplay = (ws, state, requestedWorkspaceId, cursorRaw, limitRaw) => {
+        const workspaceId = parseWorkspaceId(requestedWorkspaceId);
+        if (!workspaceId || workspaceId === '*') {
+            send(ws, { type: 'taskforce:replay-error', reason: 'workspace-required' });
+            return;
+        }
+        if (!canSubscribe(state, workspaceId)) {
+            send(ws, { type: 'taskforce:replay-error', workspaceId, reason: 'forbidden' });
+            return;
+        }
+        state.workspaceIds.add(workspaceId);
+        const cursor = parseReplayCursor(cursorRaw);
+        const events = getWorkspaceReplayEvents(workspaceId);
+        const latest = events.length > 0 ? events[events.length - 1] : null;
+        const maxReplay = Number.isFinite(Number(limitRaw))
+            ? Math.max(1, Math.min(options.replayPerMessageLimit, Math.floor(Number(limitRaw))))
+            : options.replayPerMessageLimit;
+        if (cursor && latest && cursor.serverEpoch !== latest.serverEpoch) {
+            send(ws, {
+                type: 'taskforce:replay-reset',
+                workspaceId,
+                reason: 'server-epoch-mismatch',
+                serverEpoch: latest.serverEpoch
+            });
+            return;
+        }
+        if (cursor && events.length > 0) {
+            const earliestSeq = events[0].seq;
+            if (earliestSeq > (cursor.seq + 1)) {
+                send(ws, {
+                    type: 'taskforce:replay-gap',
+                    workspaceId,
+                    reason: 'cursor-evicted',
+                    earliestSeq,
+                    cursorSeq: cursor.seq
+                });
+                return;
+            }
+        }
+        const replayable = cursor
+            ? events.filter((event) => event.seq > cursor.seq)
+            : events;
+        const replayEvents = replayable.slice(0, maxReplay);
+        send(ws, {
+            type: 'taskforce:replay',
+            workspaceId,
+            events: replayEvents,
+            truncated: replayable.length > replayEvents.length
+        });
+    };
+    const handleConnection = (ws, req) => {
+        const access = resolveRequestAccess(req, authConfig);
+        if (authConfig.enabled && authConfig.requiredForApi && (!access.authenticated || !access.userId || access.userId === 'anonymous')) {
+            closeUnauthorized(ws, 'unauthorized');
+            return;
+        }
+        const state = {
+            authenticated: access.authenticated,
+            userId: access.userId || 'anonymous',
+            role: access.role,
+            workspaceIds: new Set()
+        };
+        connections.set(ws, state);
+        logger.log(`[Taskforce] WebSocket client connected user=${state.userId}`);
+        const initialWorkspaceId = parseWorkspaceId(access.workspaceId);
+        if (initialWorkspaceId && canSubscribe(state, initialWorkspaceId)) {
+            state.workspaceIds.add(initialWorkspaceId);
+        }
+        ws.on('message', (rawData) => {
+            const payload = parseJson(rawData);
+            if (!payload) {
+                send(ws, { type: 'taskforce:error', reason: 'invalid-json' });
+                return;
+            }
+            const messageType = String(payload.type || '').trim();
+            if (messageType === 'taskforce:subscribe') {
+                subscribeWorkspace(ws, state, parseWorkspaceId(payload.workspaceId));
+                return;
+            }
+            if (messageType === 'taskforce:unsubscribe') {
+                unsubscribeWorkspace(ws, state, parseWorkspaceId(payload.workspaceId));
+                return;
+            }
+            if (messageType === 'taskforce:replay') {
+                handleReplay(ws, state, parseWorkspaceId(payload.workspaceId), payload.cursor, payload.limit);
+                return;
+            }
+            send(ws, { type: 'taskforce:error', reason: 'unsupported-message' });
+        });
+        ws.on('close', () => removeConnection(ws));
+        ws.on('error', () => removeConnection(ws));
+    };
+    const broadcastTaskforceUpdate = (workspaceId) => {
+        const normalizedWorkspaceId = parseWorkspaceId(workspaceId);
+        const payload = {
+            type: 'taskforce:update',
+            ...(normalizedWorkspaceId ? { workspaceId: normalizedWorkspaceId } : {})
+        };
+        for (const [ws, state] of connections.entries()) {
+            if (normalizedWorkspaceId && !state.workspaceIds.has(normalizedWorkspaceId))
+                continue;
+            send(ws, payload);
+        }
+    };
+    const broadcastMutation = (event) => {
+        const workspaceId = parseWorkspaceId(event.workspaceId);
+        appendReplayEvent(event);
+        const broadcastToAll = workspaceId === '*';
+        const updatePayload = {
+            type: 'taskforce:update',
+            ...(workspaceId && !broadcastToAll ? { workspaceId } : {})
+        };
+        const mutationPayload = {
+            type: 'taskforce:mutation',
+            ...event
+        };
+        for (const [ws, state] of connections.entries()) {
+            if (!broadcastToAll && workspaceId && !state.workspaceIds.has(workspaceId))
+                continue;
+            send(ws, mutationPayload);
+            send(ws, updatePayload);
+        }
+    };
+    return {
+        handleConnection,
+        broadcastTaskforceUpdate,
+        broadcastMutation
+    };
+}

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

@@ -0,0 +1,15 @@
+import type { IncomingMessage } from 'http';
+import type { TaskforceCore } from '../core/Taskforce.js';
+import type { RouteHandler, RouteContext } from './routes.js';
+export type BillingInterval = 'month' | 'year';
+export interface BillingRouteDependencies {
+    addRoute: (method: string, path: string, handler: RouteHandler) => void;
+    core: TaskforceCore;
+    context: RouteContext;
+    ensureAuthenticatedUser: (req: IncomingMessage) => boolean;
+    ensureAdminRole: (req: IncomingMessage) => boolean;
+    requestUserId: (req: IncomingMessage) => string;
+    resolveErrorStatusCode: (error: unknown, fallback?: number) => number;
+    auditAdminAction: (req: IncomingMessage, action: string, details: Record<string, unknown>) => void;
+}
+export declare function registerBillingRoutes(deps: BillingRouteDependencies): void;