@jshookmcp/jshook 0.2.6 → 0.2.8

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

@@ -1,238 +0,0 @@
-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

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

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

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

package/dist/src/server/types.d.ts

@@ -1,4 +0,0 @@
-import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
-export type ToolArgs = Record<string, unknown>;
-export type ToolResponse = CallToolResult;
-export type ToolHandler = (args: ToolArgs) => Promise<ToolResponse>;

package/dist/src/server/types.js

@@ -1 +0,0 @@
-export {};

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

@@ -1,176 +0,0 @@
-export interface RetryPolicy {
-    maxAttempts: number;
-    backoffMs: number;
-    multiplier?: number;
-}
-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, ToolNodeInput>;
-    readonly inputFrom?: Record<string, string>;
-    readonly timeoutMs?: number;
-    readonly retry?: RetryPolicy;
-}
-export interface SequenceNode {
-    readonly kind: 'sequence';
-    readonly id: string;
-    readonly steps: WorkflowNode[];
-}
-export interface ParallelNode {
-    readonly kind: 'parallel';
-    readonly id: string;
-    readonly steps: WorkflowNode[];
-    readonly maxConcurrency?: number;
-    readonly failFast?: boolean;
-}
-export interface BranchNode {
-    readonly kind: 'branch';
-    readonly id: string;
-    readonly predicateId: string;
-    readonly predicateFn?: (ctx: WorkflowExecutionContext) => boolean | Promise<boolean>;
-    readonly whenTrue: WorkflowNode;
-    readonly whenFalse?: WorkflowNode;
-}
-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;
-    readonly stepResults: ReadonlyMap<string, unknown>;
-    invokeTool(toolName: string, args: Record<string, unknown>): Promise<unknown>;
-    emitSpan(name: string, attrs?: Record<string, unknown>): void;
-    emitMetric(name: string, value: number, type: 'counter' | 'gauge' | 'histogram', attrs?: Record<string, unknown>): void;
-    getConfig<T = unknown>(path: string, fallback?: T): T;
-}
-export interface WorkflowRouteStep {
-    readonly id: string;
-    readonly toolName: string;
-    readonly description: string;
-    readonly prerequisites: string[];
-    readonly parallel?: boolean;
-    readonly expectedInputs?: Record<string, string>;
-    readonly evidenceNodeType?: string;
-}
-export type WorkflowRouteKind = 'preset' | 'workflow';
-export interface WorkflowRouteMetadata {
-    readonly kind: WorkflowRouteKind;
-    readonly triggerPatterns: RegExp[];
-    readonly steps: WorkflowRouteStep[];
-    readonly requiredDomains: string[];
-    readonly priority: number;
-}
-export interface WorkflowContract {
-    readonly kind: 'workflow-contract';
-    readonly version: 1;
-    readonly id: string;
-    readonly displayName: string;
-    readonly description?: string;
-    readonly tags?: string[];
-    readonly timeoutMs?: number;
-    readonly defaultMaxConcurrency?: number;
-    readonly route?: WorkflowRouteMetadata;
-    build(ctx: WorkflowExecutionContext): WorkflowNode;
-    onStart?(ctx: WorkflowExecutionContext): Promise<void> | void;
-    onFinish?(ctx: WorkflowExecutionContext, result: unknown): Promise<void> | void;
-    onError?(ctx: WorkflowExecutionContext, error: Error): Promise<void> | void;
-}
-export interface ToolNodeOptions {
-    input?: Record<string, unknown>;
-    retry?: RetryPolicy;
-    timeoutMs?: number;
-}
-export declare abstract class WorkflowNodeBuilder<T extends WorkflowNode> {
-    protected id: string;
-    constructor(id: string);
-    abstract build(): T;
-}
-type AnyWorkflowNodeBuilder = WorkflowNodeBuilder<WorkflowNode>;
-export declare class ToolNodeBuilder extends WorkflowNodeBuilder<ToolNode> {
-    private toolName;
-    private _input?;
-    private _inputFrom?;
-    private _retry?;
-    private _timeoutMs?;
-    constructor(id: string, toolName: string);
-    input(input: Record<string, ToolNodeInput>): this;
-    inputFrom(mapping: Record<string, string>): this;
-    retry(policy: RetryPolicy): this;
-    timeout(ms: number): this;
-    build(): ToolNode;
-}
-export declare class SequenceNodeBuilder extends WorkflowNodeBuilder<SequenceNode> {
-    private _steps;
-    step(nodeBuilder: AnyWorkflowNodeBuilder): this;
-    tool(id: string, toolName: string, config?: (b: ToolNodeBuilder) => void): this;
-    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> {
-    private _steps;
-    private _maxConcurrency?;
-    private _failFast?;
-    step(nodeBuilder: AnyWorkflowNodeBuilder): this;
-    tool(id: string, toolName: string, config?: (b: ToolNodeBuilder) => void): this;
-    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;
-}
-export declare class BranchNodeBuilder extends WorkflowNodeBuilder<BranchNode> {
-    private predicateId;
-    private _predicateFn?;
-    private _whenTrue?;
-    private _whenFalse?;
-    constructor(id: string, predicateId: string);
-    predicateFn(fn: (ctx: WorkflowExecutionContext) => boolean | Promise<boolean>): this;
-    whenTrue(nodeBuilder: AnyWorkflowNodeBuilder): this;
-    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;
-    private _description?;
-    private _tags?;
-    private _timeoutMs?;
-    private _defaultMaxConcurrency?;
-    private _route?;
-    private _buildFn;
-    private _onStart?;
-    private _onFinish?;
-    private _onError?;
-    constructor(id: string, displayName: string);
-    description(desc: string): this;
-    tags(tags: string[]): this;
-    timeoutMs(timeout: number): this;
-    defaultMaxConcurrency(max: number): this;
-    route(route: WorkflowRouteMetadata): this;
-    buildGraph(fn: (ctx: WorkflowExecutionContext) => AnyWorkflowNodeBuilder): this;
-    onStart(fn: (ctx: WorkflowExecutionContext) => Promise<void> | void): this;
-    onFinish(fn: (ctx: WorkflowExecutionContext, result: unknown) => Promise<void> | void): this;
-    onError(fn: (ctx: WorkflowExecutionContext, error: Error) => Promise<void> | void): this;
-    build(): WorkflowContract;
-}
-export declare function createWorkflow(id: string, displayName: string): WorkflowBuilder;
-export {};