@jshookmcp/jshook 0.2.5 → 0.2.6

package/dist/src/server/http/SseStream.d.ts

@@ -0,0 +1,21 @@
+import type { ServerResponse, IncomingMessage } from 'node:http';
+import type { EventBus, ServerEventMap } from '../EventBus.js';
+export interface SseStreamOptions {
+    sessionId?: string;
+    heartbeatMs?: number;
+}
+export declare class SseStream {
+    private readonly eventBus;
+    private readonly options;
+    private res;
+    private heartbeatTimer;
+    private unsubscribe;
+    private closed;
+    constructor(eventBus: EventBus<ServerEventMap>, options?: SseStreamOptions);
+    start(res: ServerResponse): void;
+    sendEvent(event: string, data: unknown): void;
+    sendRaw(message: string): void;
+    close(): void;
+    private startHeartbeat;
+}
+export declare function createProgressHandler(eventBus: EventBus<ServerEventMap>): (req: IncomingMessage, res: ServerResponse, sessionId?: string) => void;

package/dist/src/server/http/SseStream.js

@@ -0,0 +1,129 @@
+import { logger } from '../../utils/logger.js';
+export class SseStream {
+    eventBus;
+    options;
+    res = null;
+    heartbeatTimer = null;
+    unsubscribe = null;
+    closed = false;
+    constructor(eventBus, options = {}) {
+        this.eventBus = eventBus;
+        this.options = {
+            heartbeatMs: options.heartbeatMs ?? 30_000,
+            sessionId: options.sessionId,
+        };
+    }
+    start(res) {
+        if (this.res) {
+            logger.warn('SseStream already started');
+            return;
+        }
+        this.res = res;
+        this.closed = false;
+        res.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            Connection: 'keep-alive',
+            'X-Accel-Buffering': 'no',
+        });
+        this.sendEvent('connected', {
+            timestamp: new Date().toISOString(),
+            sessionId: this.options.sessionId,
+        });
+        this.unsubscribe = this.eventBus.on('task:update', (payload) => {
+            const p = payload;
+            if (this.options.sessionId && p.sessionId !== this.options.sessionId) {
+                return;
+            }
+            this.sendEvent('task:update', payload);
+        });
+        this.startHeartbeat();
+        res.on('close', () => {
+            this.close();
+        });
+        res.on('error', (err) => {
+            logger.warn('SSE stream error:', err);
+            this.close();
+        });
+    }
+    sendEvent(event, data) {
+        if (!this.res || this.closed) {
+            return;
+        }
+        const eventData = JSON.stringify(data);
+        const lines = `event: ${event}\ndata: ${eventData}\n\n`;
+        try {
+            this.res.write(lines);
+        }
+        catch (err) {
+            logger.warn('Failed to write SSE event:', err);
+            this.close();
+        }
+    }
+    sendRaw(message) {
+        if (!this.res || this.closed) {
+            return;
+        }
+        try {
+            this.res.write(`${message}\n\n`);
+        }
+        catch (err) {
+            logger.warn('Failed to write SSE message:', err);
+            this.close();
+        }
+    }
+    close() {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+        if (this.unsubscribe) {
+            this.unsubscribe();
+            this.unsubscribe = null;
+        }
+        if (this.res && !this.res.writableEnded) {
+            try {
+                this.res.end();
+            }
+            catch {
+            }
+        }
+        this.res = null;
+        logger.debug('SSE stream closed');
+    }
+    startHeartbeat() {
+        this.heartbeatTimer = setInterval(() => {
+            if (!this.closed && this.res) {
+                try {
+                    this.res.write(`: heartbeat\n\n`);
+                }
+                catch {
+                    this.close();
+                }
+            }
+        }, this.options.heartbeatMs);
+    }
+}
+export function createProgressHandler(eventBus) {
+    return (req, res, sessionId) => {
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+        if (req.method === 'OPTIONS') {
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+        if (req.method !== 'GET') {
+            res.writeHead(405, { 'Content-Type': 'text/plain' });
+            res.end('Method Not Allowed');
+            return;
+        }
+        const stream = new SseStream(eventBus, { sessionId });
+        stream.start(res);
+    };
+}

package/dist/src/server/teams/TeamManager.d.ts

@@ -0,0 +1,43 @@
+import { EventEmitter } from 'node:events';
+export interface TeamSession {
+    id: string;
+    name: string;
+    createdAt: number;
+    lastActivityAt: number;
+    status: 'active' | 'closing' | 'closed';
+    sessionIds: string[];
+}
+export interface ForceDeleteOptions {
+    timeoutMs?: number;
+    skipSessionCleanup?: boolean;
+}
+export interface ForceDeleteResult {
+    success: boolean;
+    teamName: string;
+    sessionsClosed: number;
+    error?: string;
+}
+export declare class TeamManager extends EventEmitter {
+    private readonly teams;
+    private readonly cleanupTimeouts;
+    registerTeam(name: string, sessionId?: string): TeamSession;
+    addSessionToTeam(teamName: string, sessionId: string): void;
+    removeSessionFromTeam(teamName: string, sessionId: string): void;
+    getTeam(teamName: string): TeamSession | undefined;
+    listTeams(): TeamSession[];
+    getStats(): {
+        totalTeams: number;
+        activeTeams: number;
+        totalSessions: number;
+    };
+    forceDeleteTeam(teamName: string, options?: ForceDeleteOptions): Promise<ForceDeleteResult>;
+    private closeSession;
+    scheduleAutoCleanup(teamName: string, delayMs?: number): void;
+    cancelScheduledCleanup(teamName: string): void;
+    shutdown(timeoutMs?: number): Promise<{
+        closed: number;
+        failed: number;
+    }>;
+}
+export declare function getTeamManager(): TeamManager;
+export declare function resetTeamManager(): void;

package/dist/src/server/teams/TeamManager.js

@@ -0,0 +1,238 @@
+import { spawn } from 'node:child_process';
+import { EventEmitter } from 'node:events';
+const DEFAULT_TIMEOUT_MS = 30_000;
+function validateTeamName(name) {
+    if (!name || typeof name !== 'string') {
+        return { valid: false, error: 'Team name must be a non-empty string' };
+    }
+    if (name.length > 64) {
+        return { valid: false, error: 'Team name must not exceed 64 characters' };
+    }
+    const safePattern = /^[a-zA-Z0-9._-]+$/;
+    if (!safePattern.test(name)) {
+        return {
+            valid: false,
+            error: 'Team name can only contain letters, numbers, dots, underscores, and dashes',
+        };
+    }
+    if (name.includes('..') || name.includes('/') || name.includes('\\')) {
+        return { valid: false, error: 'Path traversal detected in team name' };
+    }
+    return { valid: true };
+}
+async function execCodexCommand(args, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    return new Promise((resolve, reject) => {
+        const child = spawn('codex', args, {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            shell: true,
+        });
+        let stdout = '';
+        let stderr = '';
+        let timedOut = false;
+        const timeoutId = setTimeout(() => {
+            timedOut = true;
+            child.kill('SIGKILL');
+            reject(new Error(`Codex command timed out after ${timeoutMs}ms: codex ${args.join(' ')}`));
+        }, timeoutMs);
+        child.stdout.on('data', (data) => {
+            stdout += data.toString();
+        });
+        child.stderr.on('data', (data) => {
+            stderr += data.toString();
+        });
+        child.on('close', (code) => {
+            if (!timedOut) {
+                clearTimeout(timeoutId);
+                resolve({ stdout, stderr, code: code ?? 1 });
+            }
+        });
+        child.on('error', (err) => {
+            if (!timedOut) {
+                clearTimeout(timeoutId);
+                reject(err);
+            }
+        });
+    });
+}
+export class TeamManager extends EventEmitter {
+    teams = new Map();
+    cleanupTimeouts = new Map();
+    registerTeam(name, sessionId) {
+        const validation = validateTeamName(name);
+        if (!validation.valid) {
+            throw new Error(`Invalid team name: ${validation.error}`);
+        }
+        const existing = this.teams.get(name);
+        if (existing) {
+            return existing;
+        }
+        const team = {
+            id: name,
+            name,
+            createdAt: Date.now(),
+            lastActivityAt: Date.now(),
+            status: 'active',
+            sessionIds: sessionId ? [sessionId] : [],
+        };
+        this.teams.set(name, team);
+        this.emit('team:registered', { name, sessionId });
+        return team;
+    }
+    addSessionToTeam(teamName, sessionId) {
+        const team = this.teams.get(teamName);
+        if (!team) {
+            throw new Error(`Team "${teamName}" not found`);
+        }
+        if (!team.sessionIds.includes(sessionId)) {
+            team.sessionIds.push(sessionId);
+            team.lastActivityAt = Date.now();
+            this.emit('session:added', { teamName, sessionId });
+        }
+    }
+    removeSessionFromTeam(teamName, sessionId) {
+        const team = this.teams.get(teamName);
+        if (!team) {
+            return;
+        }
+        const index = team.sessionIds.indexOf(sessionId);
+        if (index !== -1) {
+            team.sessionIds.splice(index, 1);
+            team.lastActivityAt = Date.now();
+            this.emit('session:removed', { teamName, sessionId });
+        }
+    }
+    getTeam(teamName) {
+        return this.teams.get(teamName);
+    }
+    listTeams() {
+        return [...this.teams.values()].filter((t) => t.status === 'active');
+    }
+    getStats() {
+        const values = [...this.teams.values()];
+        return {
+            totalTeams: values.length,
+            activeTeams: values.filter((t) => t.status === 'active').length,
+            totalSessions: values.reduce((sum, t) => sum + t.sessionIds.length, 0),
+        };
+    }
+    async forceDeleteTeam(teamName, options = {}) {
+        const { timeoutMs = DEFAULT_TIMEOUT_MS, skipSessionCleanup = false } = options;
+        const validation = validateTeamName(teamName);
+        if (!validation.valid) {
+            return {
+                success: false,
+                teamName,
+                sessionsClosed: 0,
+                error: `Invalid team name: ${validation.error}`,
+            };
+        }
+        const team = this.teams.get(teamName);
+        if (!team) {
+            return {
+                success: false,
+                teamName,
+                sessionsClosed: 0,
+                error: `Team "${teamName}" not found`,
+            };
+        }
+        team.status = 'closing';
+        this.emit('team:closing', { teamName });
+        const pendingTimeout = this.cleanupTimeouts.get(teamName);
+        if (pendingTimeout) {
+            clearTimeout(pendingTimeout);
+            this.cleanupTimeouts.delete(teamName);
+        }
+        let sessionsClosed = 0;
+        let error;
+        try {
+            if (!skipSessionCleanup && team.sessionIds.length > 0) {
+                const closePromises = team.sessionIds.map((sessionId) => this.closeSession(sessionId, timeoutMs));
+                const results = await Promise.allSettled(closePromises);
+                sessionsClosed = results.filter((r) => r.status === 'fulfilled').length;
+                const failures = results
+                    .filter((r) => r.status === 'rejected')
+                    .map((r) => r.reason)
+                    .filter((e) => e instanceof Error)
+                    .map((e) => e.message);
+                if (failures.length > 0) {
+                    error = `Failed to close ${failures.length} session(s): ${failures.join('; ')}`;
+                }
+            }
+            this.teams.delete(teamName);
+            team.status = 'closed';
+            this.emit('team:deleted', { teamName, sessionsClosed });
+            return {
+                success: !error,
+                teamName,
+                sessionsClosed,
+                error,
+            };
+        }
+        catch (e) {
+            const errorMessage = e instanceof Error ? e.message : String(e);
+            return {
+                success: false,
+                teamName,
+                sessionsClosed,
+                error: errorMessage,
+            };
+        }
+    }
+    async closeSession(sessionId, timeoutMs) {
+        try {
+            await execCodexCommand(['cancel-session', sessionId], timeoutMs);
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            throw new Error(`Failed to close session ${sessionId}: ${msg}`, { cause: e });
+        }
+    }
+    scheduleAutoCleanup(teamName, delayMs = 300_000) {
+        const existing = this.cleanupTimeouts.get(teamName);
+        if (existing) {
+            clearTimeout(existing);
+        }
+        const timeoutId = setTimeout(() => {
+            this.forceDeleteTeam(teamName).catch(() => {
+            });
+            this.cleanupTimeouts.delete(teamName);
+        }, delayMs);
+        this.cleanupTimeouts.set(teamName, timeoutId);
+    }
+    cancelScheduledCleanup(teamName) {
+        const timeout = this.cleanupTimeouts.get(teamName);
+        if (timeout) {
+            clearTimeout(timeout);
+            this.cleanupTimeouts.delete(teamName);
+        }
+    }
+    async shutdown(timeoutMs = DEFAULT_TIMEOUT_MS) {
+        const teams = [...this.teams.keys()];
+        let closed = 0;
+        let failed = 0;
+        const results = await Promise.allSettled(teams.map((name) => this.forceDeleteTeam(name, { timeoutMs })));
+        for (const result of results) {
+            if (result.status === 'fulfilled' && result.value.success) {
+                closed++;
+            }
+            else {
+                failed++;
+            }
+        }
+        for (const [name, timeout] of this.cleanupTimeouts.entries()) {
+            clearTimeout(timeout);
+            this.cleanupTimeouts.delete(name);
+        }
+        return { closed, failed };
+    }
+}
+let globalTeamManager;
+export function getTeamManager() {
+    if (!globalTeamManager) {
+        globalTeamManager = new TeamManager();
+    }
+    return globalTeamManager;
+}
+export function resetTeamManager() {
+    globalTeamManager = undefined;
+}

package/dist/src/server/teams/index.d.ts

@@ -0,0 +1 @@
+export * from './TeamManager.js';

package/dist/src/server/teams/index.js

@@ -0,0 +1 @@
+export * from './TeamManager.js';

package/dist/src/server/workflows/WorkflowContract.d.ts

@@ -3,12 +3,13 @@ export interface RetryPolicy {
     backoffMs: number;
     multiplier?: number;
 }
-export type WorkflowNodeType = 'tool' | 'sequence' | 'parallel' | 'branch';
+export type ToolNodeInput = string | number | boolean | null | undefined | Record<string, unknown> | unknown[];
+export type WorkflowNodeType = 'tool' | 'sequence' | 'parallel' | 'branch' | 'fallback';
 export interface ToolNode {
     readonly kind: 'tool';
     readonly id: string;
     readonly toolName: string;
-    readonly input?: Record<string, unknown>;
+    readonly input?: Record<string, ToolNodeInput>;
     readonly inputFrom?: Record<string, string>;
     readonly timeoutMs?: number;
     readonly retry?: RetryPolicy;
@@ -33,7 +34,13 @@ export interface BranchNode {
     readonly whenTrue: WorkflowNode;
     readonly whenFalse?: WorkflowNode;
 }
-export type WorkflowNode = ToolNode | SequenceNode | ParallelNode | BranchNode;
+export interface FallbackNode {
+    readonly kind: 'fallback';
+    readonly id: string;
+    readonly primary: WorkflowNode;
+    readonly fallback: WorkflowNode;
+}
+export type WorkflowNode = ToolNode | SequenceNode | ParallelNode | BranchNode | FallbackNode;
 export interface WorkflowExecutionContext {
     readonly workflowRunId: string;
     readonly profile: string;
@@ -93,7 +100,7 @@ export declare class ToolNodeBuilder extends WorkflowNodeBuilder<ToolNode> {
     private _retry?;
     private _timeoutMs?;
     constructor(id: string, toolName: string);
-    input(input: Record<string, unknown>): this;
+    input(input: Record<string, ToolNodeInput>): this;
     inputFrom(mapping: Record<string, string>): this;
     retry(policy: RetryPolicy): this;
     timeout(ms: number): this;
@@ -106,6 +113,7 @@ export declare class SequenceNodeBuilder extends WorkflowNodeBuilder<SequenceNod
     sequence(id: string, config?: (b: SequenceNodeBuilder) => void): this;
     parallel(id: string, config?: (b: ParallelNodeBuilder) => void): this;
     branch(id: string, predicateId: string, config?: (b: BranchNodeBuilder) => void): this;
+    fallback(id: string, config?: (b: FallbackNodeBuilder) => void): this;
     build(): SequenceNode;
 }
 export declare class ParallelNodeBuilder extends WorkflowNodeBuilder<ParallelNode> {
@@ -117,6 +125,7 @@ export declare class ParallelNodeBuilder extends WorkflowNodeBuilder<ParallelNod
     sequence(id: string, config?: (b: SequenceNodeBuilder) => void): this;
     parallel(id: string, config?: (b: ParallelNodeBuilder) => void): this;
     branch(id: string, predicateId: string, config?: (b: BranchNodeBuilder) => void): this;
+    fallback(id: string, config?: (b: FallbackNodeBuilder) => void): this;
     maxConcurrency(concurrency: number): this;
     failFast(ff: boolean): this;
     build(): ParallelNode;
@@ -132,6 +141,13 @@ export declare class BranchNodeBuilder extends WorkflowNodeBuilder<BranchNode> {
     whenFalse(nodeBuilder: AnyWorkflowNodeBuilder): this;
     build(): BranchNode;
 }
+export declare class FallbackNodeBuilder extends WorkflowNodeBuilder<FallbackNode> {
+    private _primary?;
+    private _fallback?;
+    primary(nodeBuilder: AnyWorkflowNodeBuilder): this;
+    fallback(nodeBuilder: AnyWorkflowNodeBuilder): this;
+    build(): FallbackNode;
+}
 export declare class WorkflowBuilder {
     private _id;
     private _displayName;

package/dist/src/server/workflows/WorkflowContract.js

@@ -76,6 +76,13 @@ export class SequenceNodeBuilder extends WorkflowNodeBuilder {
         this._steps.push(builder);
         return this;
     }
+    fallback(id, config) {
+        const builder = new FallbackNodeBuilder(id);
+        if (config)
+            config(builder);
+        this._steps.push(builder);
+        return this;
+    }
     build() {
         return {
             kind: 'sequence',
@@ -120,6 +127,13 @@ export class ParallelNodeBuilder extends WorkflowNodeBuilder {
         this._steps.push(builder);
         return this;
     }
+    fallback(id, config) {
+        const builder = new FallbackNodeBuilder(id);
+        if (config)
+            config(builder);
+        this._steps.push(builder);
+        return this;
+    }
     maxConcurrency(concurrency) {
         this._maxConcurrency = concurrency;
         return this;
@@ -173,6 +187,32 @@ export class BranchNodeBuilder extends WorkflowNodeBuilder {
         };
     }
 }
+export class FallbackNodeBuilder extends WorkflowNodeBuilder {
+    _primary;
+    _fallback;
+    primary(nodeBuilder) {
+        this._primary = nodeBuilder;
+        return this;
+    }
+    fallback(nodeBuilder) {
+        this._fallback = nodeBuilder;
+        return this;
+    }
+    build() {
+        if (!this._primary) {
+            throw new Error(`FallbackNode '${this.id}' requires a primary step`);
+        }
+        if (!this._fallback) {
+            throw new Error(`FallbackNode '${this.id}' requires a fallback step`);
+        }
+        return {
+            kind: 'fallback',
+            id: this.id,
+            primary: this._primary.build(),
+            fallback: this._fallback.build(),
+        };
+    }
+}
 export class WorkflowBuilder {
     _id;
     _displayName;