ts-workflow-engine-lite 2.1.0

package/dist/src/storage/StorageProvider.d.ts

@@ -0,0 +1,223 @@
+import type { WorkflowInstance } from "../model/Instance.js";
+import type { WorkflowDefinition } from "../model/Workflow.js";
+export type StorageClient = any;
+export interface EventWaitingState {
+    instanceId: string;
+    nodeId: string;
+    eventType: string;
+    condition?: string;
+    requireInstanceIdMatch?: boolean;
+    timeoutMs?: number;
+    deadline?: number;
+    createdAt: number;
+}
+export type ReleasePolicy = {
+    type: "stable";
+} | {
+    type: "canary";
+    baselineVersion: number;
+    canaryVersion: number;
+    canaryPercent: number;
+};
+export interface PromotionRules {
+    autoPromote: boolean;
+    minInstances?: number;
+    maxErrorRate?: number;
+    evaluationWindowMs?: number;
+}
+export interface CanaryMetrics {
+    totalInstances: number;
+    errorRate: number;
+    avgDurationMs: number;
+}
+export interface StoredWorkflow {
+    id: string;
+    name: string;
+    description?: string;
+    definition: WorkflowDefinition;
+    version: number;
+    createdAt: number;
+    updatedAt: number;
+    tags?: string[];
+    metadata?: Record<string, any>;
+    publishedVersion?: number;
+    lockedVersion?: number;
+    releasePolicy?: ReleasePolicy;
+    canaryVersion?: number;
+    canaryPercent?: number;
+    promotionRules?: PromotionRules;
+    canaryStartedAt?: number;
+}
+export interface StoredWorkflowVersion {
+    id: string;
+    name: string;
+    description?: string;
+    definition: WorkflowDefinition;
+    version: number;
+    createdAt: number;
+    tags?: string[];
+    metadata?: Record<string, unknown>;
+}
+export interface NodeMetrics {
+    nodeId: string;
+    nodeType?: string;
+    startTime?: number;
+    endTime?: number;
+    duration?: number;
+    retryCount: number;
+    retryTimestamps?: number[];
+    error?: {
+        message: string;
+        stack?: string;
+        timestamp: number;
+    };
+    status?: "pending" | "running" | "completed" | "failed" | "skipped";
+}
+export interface InstanceMetrics {
+    instanceId: string;
+    workflowId: string;
+    nodeMetrics: Record<string, NodeMetrics>;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface EventRecord {
+    id: string;
+    instanceId: string;
+    workflowId: string;
+    eventType: string;
+    payload: unknown;
+    timestamp: number;
+    metadata?: Record<string, unknown>;
+}
+export interface HeartbeatState {
+    instanceId: string;
+    nodeId: string;
+    heartbeatKey: string;
+    workerId?: string;
+    lastBeat: number;
+    timeoutMs: number;
+    deadline: number;
+    createdAt: number;
+}
+export interface EventQueryParams {
+    instanceId?: string;
+    eventType?: string;
+    startTime?: number;
+    endTime?: number;
+    page?: number;
+    pageSize?: number;
+}
+export type InstanceSortField = "createdAt" | "updatedAt" | "status";
+export type InstanceSortOrder = "asc" | "desc";
+export interface InstanceQueryParams {
+    workflowId?: string;
+    status?: string;
+    startTime?: number;
+    endTime?: number;
+    page?: number;
+    pageSize?: number;
+    parentInstanceId?: string;
+    sortBy?: InstanceSortField;
+    sortOrder?: InstanceSortOrder;
+}
+export interface StorageCore {
+    connect(): Promise<void>;
+    close(): Promise<void>;
+    saveInstance(instance: WorkflowInstance): Promise<void>;
+    casUpdateInstance(instance: WorkflowInstance): Promise<boolean>;
+    loadInstance(instanceId: string): Promise<WorkflowInstance | null>;
+    deleteInstance(instanceId: string): Promise<void>;
+    listInstances(): Promise<string[]>;
+    queryInstances(params: InstanceQueryParams): Promise<{
+        instances: WorkflowInstance[];
+        total: number;
+    }>;
+    saveWorkflow(workflow: WorkflowDefinition): Promise<void>;
+    loadWorkflow(workflowId: string): Promise<WorkflowDefinition | null>;
+    deleteWorkflow(workflowId: string): Promise<void>;
+    listWorkflows(): Promise<string[]>;
+    saveEventWaitingState(state: EventWaitingState): Promise<void>;
+    loadEventWaitingState(instanceId: string, nodeId: string): Promise<EventWaitingState | null>;
+    loadAllEventWaitingStates(): Promise<EventWaitingState[]>;
+    deleteEventWaitingState(instanceId: string, nodeId: string): Promise<void>;
+}
+export interface MetricsStorage {
+    saveInstanceMetrics(metrics: InstanceMetrics): Promise<void>;
+    loadInstanceMetrics(instanceId: string): Promise<InstanceMetrics | null>;
+    updateNodeMetrics(instanceId: string, nodeId: string, metrics: NodeMetrics): Promise<void>;
+}
+export interface EventHistoryStorage {
+    saveEvent(event: EventRecord): Promise<void>;
+    loadEvent(eventId: string): Promise<EventRecord | null>;
+    queryEvents(params: EventQueryParams): Promise<{
+        events: EventRecord[];
+        total: number;
+    }>;
+    deleteEvent(eventId: string): Promise<void>;
+}
+export interface WorkflowMetadataStorage {
+    saveWorkflowWithMetadata(workflow: StoredWorkflow): Promise<void>;
+    loadWorkflowWithMetadata(workflowId: string): Promise<StoredWorkflow | null>;
+    listWorkflowsWithMetadata(): Promise<StoredWorkflow[]>;
+    saveWorkflowVersion(version: StoredWorkflowVersion): Promise<void>;
+    loadWorkflowVersion(workflowId: string, version: number): Promise<StoredWorkflowVersion | null>;
+    listWorkflowVersions(workflowId: string): Promise<number[]>;
+}
+export interface HeartbeatStorage {
+    saveHeartbeat?(state: HeartbeatState): Promise<void>;
+    loadAllHeartbeats?(): Promise<HeartbeatState[]>;
+    deleteHeartbeat?(instanceId: string, nodeId: string): Promise<void>;
+}
+export interface CleanupStorage {
+    cleanupStaleEvents?(retentionDays: number): Promise<number>;
+    cleanupExpiredHeartbeats?(): Promise<number>;
+    cleanupStaleInstances?(maxAgeMs: number): number | Promise<number>;
+}
+export interface DlqStorage {
+    saveDeadLetterEntry?(entry: unknown): Promise<void>;
+    loadAllDeadLetterEntries?(): Promise<unknown[]>;
+    deleteDeadLetterEntry?(id: string): Promise<void>;
+}
+export interface WebhookStorage {
+    saveWebhookEntry?(entry: unknown): Promise<void>;
+    loadAllWebhookEntries?(): Promise<unknown[]>;
+    deleteWebhookEntry?(id: string): Promise<void>;
+    saveWebhookDeliveryEntry?(entry: unknown): Promise<void>;
+    loadAllWebhookDeliveryEntries?(): Promise<unknown[]>;
+    deleteWebhookDeliveryEntry?(id: string): Promise<void>;
+}
+export type FullStorageProvider = StorageCore | MetricsStorage | EventHistoryStorage | WorkflowMetadataStorage | HeartbeatStorage | CleanupStorage | DlqStorage | WebhookStorage;
+export interface StorageProvider extends StorageCore {
+    getClient?(): StorageClient;
+    saveWorkflowWithMetadata(workflow: StoredWorkflow): Promise<void>;
+    loadWorkflowWithMetadata(workflowId: string): Promise<StoredWorkflow | null>;
+    listWorkflowsWithMetadata(): Promise<StoredWorkflow[]>;
+    saveWorkflowVersion(version: StoredWorkflowVersion): Promise<void>;
+    loadWorkflowVersion(workflowId: string, version: number): Promise<StoredWorkflowVersion | null>;
+    listWorkflowVersions(workflowId: string): Promise<number[]>;
+    saveInstanceMetrics(metrics: InstanceMetrics): Promise<void>;
+    loadInstanceMetrics(instanceId: string): Promise<InstanceMetrics | null>;
+    updateNodeMetrics(instanceId: string, nodeId: string, metrics: NodeMetrics): Promise<void>;
+    saveEvent(event: EventRecord): Promise<void>;
+    loadEvent(eventId: string): Promise<EventRecord | null>;
+    queryEvents(params: EventQueryParams): Promise<{
+        events: EventRecord[];
+        total: number;
+    }>;
+    deleteEvent(eventId: string): Promise<void>;
+    saveHeartbeat?(state: HeartbeatState): Promise<void>;
+    loadAllHeartbeats?(): Promise<HeartbeatState[]>;
+    deleteHeartbeat?(instanceId: string, nodeId: string): Promise<void>;
+    cleanupStaleEvents?(retentionDays: number): Promise<number>;
+    cleanupExpiredHeartbeats?(): Promise<number>;
+    cleanupStaleInstances?(maxAgeMs: number): number | Promise<number>;
+    saveDeadLetterEntry?(entry: unknown): Promise<void>;
+    loadAllDeadLetterEntries?(): Promise<unknown[]>;
+    deleteDeadLetterEntry?(id: string): Promise<void>;
+    saveWebhookEntry?(entry: unknown): Promise<void>;
+    loadAllWebhookEntries?(): Promise<unknown[]>;
+    deleteWebhookEntry?(id: string): Promise<void>;
+    saveWebhookDeliveryEntry?(entry: unknown): Promise<void>;
+    loadAllWebhookDeliveryEntries?(): Promise<unknown[]>;
+    deleteWebhookDeliveryEntry?(id: string): Promise<void>;
+}

package/dist/src/storage/StorageProvider.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=StorageProvider.js.map

package/dist/src/storage/StorageProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StorageProvider.js","sourceRoot":"","sources":["../../../src/storage/StorageProvider.ts"],"names":[],"mappings":""}

package/dist/src/storage/builtin-adapters.d.ts

@@ -0,0 +1 @@
+export declare function registerBuiltinStorageAdapters(): void;

package/dist/src/storage/builtin-adapters.js

@@ -0,0 +1,20 @@
+import { registerStorageAdapter } from "./registry.js";
+import { MemoryStorage } from "./MemoryStorage.js";
+import { LocalFileStorage } from "./LocalFileStorage.js";
+export function registerBuiltinStorageAdapters() {
+    registerStorageAdapter("memory", async () => {
+        const storage = new MemoryStorage();
+        await storage.connect();
+        return storage;
+    });
+    registerStorageAdapter("local-file", async (config) => {
+        const directory = config.directory ??
+            process.env.STORAGE_DIR ??
+            ".ts-workflow-engine-data";
+        const fsyncOnWrite = config.fsyncOnWrite ?? process.env.FSYNC_ON_WRITE === "true";
+        const storage = new LocalFileStorage({ directory, fsyncOnWrite });
+        await storage.connect();
+        return storage;
+    });
+}
+//# sourceMappingURL=builtin-adapters.js.map

package/dist/src/storage/builtin-adapters.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"builtin-adapters.js","sourceRoot":"","sources":["../../../src/storage/builtin-adapters.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAMtD,MAAM,UAAU,8BAA8B;IAC5C,sBAAsB,CAAC,QAAQ,EAAE,KAAK,IAAI,EAAE;QAC1C,MAAM,OAAO,GAAG,IAAI,aAAa,EAAE,CAAC;QACpC,MAAM,OAAO,CAAC,OAAO,EAAE,CAAC;QACxB,OAAO,OAAO,CAAC;IACjB,CAAC,CAAC,CAAC;IAEH,sBAAsB,CAAC,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE;QACpD,MAAM,SAAS,GACZ,MAAM,CAAC,SAAoB;YAC5B,OAAO,CAAC,GAAG,CAAC,WAAW;YACvB,0BAA0B,CAAC;QAC7B,MAAM,YAAY,GACf,MAAM,CAAC,YAAwB,IAAI,OAAO,CAAC,GAAG,CAAC,cAAc,KAAK,MAAM,CAAC;QAC5E,MAAM,OAAO,GAAG,IAAI,gBAAgB,CAAC,EAAE,SAAS,EAAE,YAAY,EAAE,CAAC,CAAC;QAClE,MAAM,OAAO,CAAC,OAAO,EAAE,CAAC;QACxB,OAAO,OAAO,CAAC;IACjB,CAAC,CAAC,CAAC;AACL,CAAC"}

package/dist/src/storage/index.d.ts

@@ -0,0 +1,17 @@
+export { MemoryStorage } from "./MemoryStorage.js";
+export { LocalFileStorage, type LocalFileStorageOptions, } from "./LocalFileStorage.js";
+export type { CleanupStorage, EventHistoryStorage, EventQueryParams, EventRecord, EventWaitingState, FullStorageProvider, HeartbeatStorage, InstanceMetrics, InstanceQueryParams, MetricsStorage, NodeMetrics, StorageCore, StorageProvider, StoredWorkflow, StoredWorkflowVersion, WebhookStorage, WorkflowMetadataStorage, } from "./StorageProvider.js";
+export type { DlqStorage } from "./StorageProvider.js";
+export { createStorageFromRegistry, listStorageAdapters, registerStorageAdapter, type StorageFactory, unregisterStorageAdapter, } from "./registry.js";
+export { registerBuiltinStorageAdapters } from "./builtin-adapters.js";
+import type { StorageProvider } from "./StorageProvider.js";
+export declare function createStorage(options?: {
+    type?: "memory" | "file";
+    directory?: string;
+    fsyncOnWrite?: boolean;
+}): Promise<StorageProvider>;
+export declare enum StorageType {
+    MEMORY = "memory",
+    FILE = "file"
+}
+export declare function getStorageType(storage: StorageProvider): StorageType;

package/dist/src/storage/index.js

@@ -0,0 +1,52 @@
+import { Logger } from "../utils/Logger.js";
+export { MemoryStorage } from "./MemoryStorage.js";
+export { LocalFileStorage, } from "./LocalFileStorage.js";
+export { createStorageFromRegistry, listStorageAdapters, registerStorageAdapter, unregisterStorageAdapter, } from "./registry.js";
+export { registerBuiltinStorageAdapters } from "./builtin-adapters.js";
+import { MemoryStorage } from "./MemoryStorage.js";
+import { LocalFileStorage } from "./LocalFileStorage.js";
+const LEGACY_DEFAULT_DIR = ".ts-runit-data";
+const DEFAULT_DIR = ".ts-workflow-engine-data";
+export async function createStorage(options) {
+    const type = options?.type ??
+        process.env.STORAGE_TYPE ??
+        (process.env.NODE_ENV === "test" ? "memory" : "file");
+    if (type === "file") {
+        let directory = options?.directory ?? process.env.STORAGE_DIR ?? DEFAULT_DIR;
+        if (directory === DEFAULT_DIR &&
+            !options?.directory &&
+            !process.env.STORAGE_DIR) {
+            try {
+                const fs = await import("node:fs");
+                if (fs.existsSync(LEGACY_DEFAULT_DIR) && !fs.existsSync(DEFAULT_DIR)) {
+                    Logger.warn("system", "storage", `Legacy storage directory "${LEGACY_DEFAULT_DIR}" detected. ` +
+                        `Rename it to "${DEFAULT_DIR}" or set STORAGE_DIR. ` +
+                        `Run: npx tsx scripts/migrate-storage-dir.ts`);
+                    directory = LEGACY_DEFAULT_DIR;
+                }
+            }
+            catch {
+            }
+        }
+        const fsyncOnWrite = options?.fsyncOnWrite ?? process.env.FSYNC_ON_WRITE === "true";
+        Logger.info("system", "storage", `Using local file storage: ${directory}${fsyncOnWrite ? " (fsync on write)" : ""}`);
+        const storage = new LocalFileStorage({ directory, fsyncOnWrite });
+        await storage.connect();
+        return storage;
+    }
+    Logger.info("system", "storage", "Using memory storage");
+    const storage = new MemoryStorage();
+    await storage.connect();
+    return storage;
+}
+export var StorageType;
+(function (StorageType) {
+    StorageType["MEMORY"] = "memory";
+    StorageType["FILE"] = "file";
+})(StorageType || (StorageType = {}));
+export function getStorageType(storage) {
+    return storage instanceof LocalFileStorage
+        ? StorageType.FILE
+        : StorageType.MEMORY;
+}
+//# sourceMappingURL=index.js.map

package/dist/src/storage/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/storage/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAEzC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EACL,gBAAgB,GAEjB,MAAM,oBAAoB,CAAC;AAqB5B,OAAO,EACL,yBAAyB,EACzB,mBAAmB,EACnB,sBAAsB,EAEtB,wBAAwB,GACzB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,8BAA8B,EAAE,MAAM,oBAAoB,CAAC;AAEpE,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAItD,MAAM,kBAAkB,GAAG,gBAAgB,CAAC;AAC5C,MAAM,WAAW,GAAG,0BAA0B,CAAC;AAO/C,MAAM,CAAC,KAAK,UAAU,aAAa,CAAC,OAInC;IACC,MAAM,IAAI,GACR,OAAO,EAAE,IAAI;QACZ,OAAO,CAAC,GAAG,CAAC,YAA8C;QAC3D,CAAC,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,MAAM,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;IAExD,IAAI,IAAI,KAAK,MAAM,EAAE,CAAC;QACpB,IAAI,SAAS,GACX,OAAO,EAAE,SAAS,IAAI,OAAO,CAAC,GAAG,CAAC,WAAW,IAAI,WAAW,CAAC;QAG/D,IACE,SAAS,KAAK,WAAW;YACzB,CAAC,OAAO,EAAE,SAAS;YACnB,CAAC,OAAO,CAAC,GAAG,CAAC,WAAW,EACxB,CAAC;YACD,IAAI,CAAC;gBACH,MAAM,EAAE,GAAG,MAAM,MAAM,CAAC,SAAS,CAAC,CAAC;gBACnC,IAAI,EAAE,CAAC,UAAU,CAAC,kBAAkB,CAAC,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,WAAW,CAAC,EAAE,CAAC;oBACrE,MAAM,CAAC,IAAI,CACT,QAAQ,EACR,SAAS,EACT,6BAA6B,kBAAkB,cAAc;wBAC3D,iBAAiB,WAAW,wBAAwB;wBACpD,6CAA6C,CAChD,CAAC;oBACF,SAAS,GAAG,kBAAkB,CAAC;gBACjC,CAAC;YACH,CAAC;YAAC,MAAM,CAAC;YAET,CAAC;QACH,CAAC;QAED,MAAM,YAAY,GAChB,OAAO,EAAE,YAAY,IAAI,OAAO,CAAC,GAAG,CAAC,cAAc,KAAK,MAAM,CAAC;QACjE,MAAM,CAAC,IAAI,CACT,QAAQ,EACR,SAAS,EACT,6BAA6B,SAAS,GAAG,YAAY,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC,CAAC,EAAE,EAAE,CACnF,CAAC;QACF,MAAM,OAAO,GAAG,IAAI,gBAAgB,CAAC,EAAE,SAAS,EAAE,YAAY,EAAE,CAAC,CAAC;QAClE,MAAM,OAAO,CAAC,OAAO,EAAE,CAAC;QACxB,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,SAAS,EAAE,sBAAsB,CAAC,CAAC;IACzD,MAAM,OAAO,GAAG,IAAI,aAAa,EAAE,CAAC;IACpC,MAAM,OAAO,CAAC,OAAO,EAAE,CAAC;IACxB,OAAO,OAAO,CAAC;AACjB,CAAC;AAKD,MAAM,CAAN,IAAY,WAGX;AAHD,WAAY,WAAW;IACrB,gCAAiB,CAAA;IACjB,4BAAa,CAAA;AACf,CAAC,EAHW,WAAW,KAAX,WAAW,QAGtB;AAKD,MAAM,UAAU,cAAc,CAAC,OAAwB;IACrD,OAAO,OAAO,YAAY,gBAAgB;QACxC,CAAC,CAAC,WAAW,CAAC,IAAI;QAClB,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC;AACzB,CAAC"}

package/dist/src/storage/registry.d.ts

@@ -0,0 +1,6 @@
+import type { StorageProvider } from "./StorageProvider.js";
+export type StorageFactory = (config: Record<string, unknown>) => Promise<StorageProvider>;
+export declare function registerStorageAdapter(name: string, factory: StorageFactory): void;
+export declare function unregisterStorageAdapter(name: string): boolean;
+export declare function listStorageAdapters(): string[];
+export declare function createStorageFromRegistry(name?: string, config?: Record<string, unknown>): Promise<StorageProvider>;

package/dist/src/storage/registry.js

@@ -0,0 +1,23 @@
+import { Logger } from "../utils/Logger.js";
+const registry = new Map();
+export function registerStorageAdapter(name, factory) {
+    registry.set(name, factory);
+    Logger.info("system", "storage", `Storage adapter registered: ${name}`);
+}
+export function unregisterStorageAdapter(name) {
+    return registry.delete(name);
+}
+export function listStorageAdapters() {
+    return [...registry.keys()];
+}
+export async function createStorageFromRegistry(name, config) {
+    const adapterName = name ?? process.env.STORAGE_ADAPTER ?? "local-file";
+    const factory = registry.get(adapterName);
+    if (!factory) {
+        const available = [...registry.keys()].join(", ");
+        throw new Error(`Unknown storage adapter: "${adapterName}". Registered adapters: ${available}`);
+    }
+    Logger.info("system", "storage", `Creating storage with adapter: ${adapterName}`);
+    return factory(config ?? {});
+}
+//# sourceMappingURL=registry.js.map

package/dist/src/storage/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../../src/storage/registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAUzC,MAAM,QAAQ,GAAG,IAAI,GAAG,EAA0B,CAAC;AAYnD,MAAM,UAAU,sBAAsB,CACpC,IAAY,EACZ,OAAuB;IAEvB,QAAQ,CAAC,GAAG,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IAC5B,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,SAAS,EAAE,+BAA+B,IAAI,EAAE,CAAC,CAAC;AAC1E,CAAC;AAMD,MAAM,UAAU,wBAAwB,CAAC,IAAY;IACnD,OAAO,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;AAC/B,CAAC;AAKD,MAAM,UAAU,mBAAmB;IACjC,OAAO,CAAC,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;AAC9B,CAAC;AAYD,MAAM,CAAC,KAAK,UAAU,yBAAyB,CAC7C,IAAa,EACb,MAAgC;IAEhC,MAAM,WAAW,GAAG,IAAI,IAAI,OAAO,CAAC,GAAG,CAAC,eAAe,IAAI,YAAY,CAAC;IACxE,MAAM,OAAO,GAAG,QAAQ,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;IAC1C,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,MAAM,SAAS,GAAG,CAAC,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAClD,MAAM,IAAI,KAAK,CACb,6BAA6B,WAAW,2BAA2B,SAAS,EAAE,CAC/E,CAAC;IACJ,CAAC;IACD,MAAM,CAAC,IAAI,CACT,QAAQ,EACR,SAAS,EACT,kCAAkC,WAAW,EAAE,CAChD,CAAC;IACF,OAAO,OAAO,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC;AAC/B,CAAC"}

package/dist/src/telemetry/index.d.ts

@@ -0,0 +1,53 @@
+export declare enum SpanStatusCode {
+    UNSET = 0,
+    OK = 1,
+    ERROR = 2
+}
+export declare enum SpanKind {
+    INTERNAL = 0,
+    SERVER = 1,
+    CLIENT = 2,
+    PRODUCER = 3,
+    CONSUMER = 4
+}
+export interface Span {
+    setAttributes(attrs: Record<string, unknown>): Span;
+    setStatus(status: {
+        code: SpanStatusCode;
+        message?: string;
+    }): Span;
+    recordException(error: Error): void;
+    end(): void;
+    spanContext(): {
+        traceId: string;
+        spanId: string;
+    };
+}
+export interface Context {
+    with<T>(fn: () => T): T;
+}
+export interface SpanOptions {
+    kind?: SpanKind;
+    attributes?: Record<string, unknown>;
+}
+export interface StartedSpan {
+    span: Span;
+    context: Context;
+}
+export declare function initTelemetry(): Promise<boolean>;
+export declare function shutdownTelemetry(): Promise<void>;
+export declare function startSpan(_name: string, _attrs?: Record<string, string | number | boolean | undefined>, parent?: Context, _options?: SpanOptions): StartedSpan;
+export declare function startServerSpan(name: string, attrs?: Record<string, string | number | boolean | undefined>): StartedSpan;
+export declare function otelTraceId(_span: Span): string | undefined;
+export declare function recordSpanError(span: Span, error: unknown): void;
+export declare function getTracer(): {
+    startSpan: () => Span;
+};
+export declare const context: {
+    active: () => Context;
+    with<T>(ctx: Context, fn: () => T): T;
+};
+export declare const trace: {
+    getActiveSpan: () => Span | undefined;
+    setSpan: (ctx: Context, _span: Span) => Context;
+};

package/dist/src/telemetry/index.js

@@ -0,0 +1,73 @@
+import { Logger } from "../utils/Logger.js";
+export var SpanStatusCode;
+(function (SpanStatusCode) {
+    SpanStatusCode[SpanStatusCode["UNSET"] = 0] = "UNSET";
+    SpanStatusCode[SpanStatusCode["OK"] = 1] = "OK";
+    SpanStatusCode[SpanStatusCode["ERROR"] = 2] = "ERROR";
+})(SpanStatusCode || (SpanStatusCode = {}));
+export var SpanKind;
+(function (SpanKind) {
+    SpanKind[SpanKind["INTERNAL"] = 0] = "INTERNAL";
+    SpanKind[SpanKind["SERVER"] = 1] = "SERVER";
+    SpanKind[SpanKind["CLIENT"] = 2] = "CLIENT";
+    SpanKind[SpanKind["PRODUCER"] = 3] = "PRODUCER";
+    SpanKind[SpanKind["CONSUMER"] = 4] = "CONSUMER";
+})(SpanKind || (SpanKind = {}));
+const NOOP_TRACE_ID = "0".repeat(32);
+const NOOP_SPAN_ID = "0".repeat(16);
+function createNoopSpan() {
+    const span = {
+        setAttributes: () => span,
+        setStatus: () => span,
+        recordException: () => { },
+        end: () => { },
+        spanContext: () => ({ traceId: NOOP_TRACE_ID, spanId: NOOP_SPAN_ID }),
+    };
+    return span;
+}
+function createNoopContext() {
+    return {
+        with(fn) {
+            return fn();
+        },
+    };
+}
+export async function initTelemetry() {
+    return false;
+}
+export async function shutdownTelemetry() {
+    Logger.debug("system", "telemetry", "No-op telemetry shutdown");
+}
+export function startSpan(_name, _attrs = {}, parent, _options = {}) {
+    return {
+        span: createNoopSpan(),
+        context: parent ?? createNoopContext(),
+    };
+}
+export function startServerSpan(name, attrs = {}) {
+    return startSpan(name, attrs, undefined, { kind: SpanKind.SERVER });
+}
+export function otelTraceId(_span) {
+    return undefined;
+}
+export function recordSpanError(span, error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    span.recordException(err);
+    span.setStatus({ code: SpanStatusCode.ERROR, message: err.message });
+}
+export function getTracer() {
+    return {
+        startSpan: () => createNoopSpan(),
+    };
+}
+export const context = {
+    active: () => createNoopContext(),
+    with(ctx, fn) {
+        return ctx.with(fn);
+    },
+};
+export const trace = {
+    getActiveSpan: () => undefined,
+    setSpan: (ctx, _span) => ctx,
+};
+//# sourceMappingURL=index.js.map

package/dist/src/telemetry/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/telemetry/index.ts"],"names":[],"mappings":"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"}

package/dist/src/telemetry/spanRegistry.d.ts

@@ -0,0 +1,9 @@
+import type { Context, Span } from "./index.js";
+export interface RegisteredWorkflowSpan {
+    span: Span;
+    context: Context;
+}
+export declare function registerWorkflowSpan(instanceId: string, span: Span, context: Context): void;
+export declare function getWorkflowSpan(instanceId: string): RegisteredWorkflowSpan | undefined;
+export declare function unregisterWorkflowSpan(instanceId: string): void;
+export declare function clearWorkflowSpansForTest(): void;

package/dist/src/telemetry/spanRegistry.js

@@ -0,0 +1,14 @@
+const workflowSpans = new Map();
+export function registerWorkflowSpan(instanceId, span, context) {
+    workflowSpans.set(instanceId, { span, context });
+}
+export function getWorkflowSpan(instanceId) {
+    return workflowSpans.get(instanceId);
+}
+export function unregisterWorkflowSpan(instanceId) {
+    workflowSpans.delete(instanceId);
+}
+export function clearWorkflowSpansForTest() {
+    workflowSpans.clear();
+}
+//# sourceMappingURL=spanRegistry.js.map

package/dist/src/telemetry/spanRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spanRegistry.js","sourceRoot":"","sources":["../../../src/telemetry/spanRegistry.ts"],"names":[],"mappings":"AAOA,MAAM,aAAa,GAAG,IAAI,GAAG,EAAkC,CAAC;AAEhE,MAAM,UAAU,oBAAoB,CAClC,UAAkB,EAClB,IAAU,EACV,OAAgB;IAEhB,aAAa,CAAC,GAAG,CAAC,UAAU,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC;AACnD,CAAC;AAED,MAAM,UAAU,eAAe,CAC7B,UAAkB;IAElB,OAAO,aAAa,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;AACvC,CAAC;AAED,MAAM,UAAU,sBAAsB,CAAC,UAAkB;IACvD,aAAa,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;AACnC,CAAC;AAED,MAAM,UAAU,yBAAyB;IACvC,aAAa,CAAC,KAAK,EAAE,CAAC;AACxB,CAAC"}

package/dist/src/templates/AutoExtract.d.ts

@@ -0,0 +1,2 @@
+import type { WorkflowTemplate } from "./TemplateGallery.js";
+export declare function extractTemplatesFromDemos(demoDir: string): WorkflowTemplate[];

package/dist/src/templates/AutoExtract.js

@@ -0,0 +1,124 @@
+import { readdirSync, readFileSync } from "node:fs";
+import { basename, join } from "node:path";
+import { Logger } from "../utils/Logger.js";
+export function extractTemplatesFromDemos(demoDir) {
+    const templates = [];
+    try {
+        const files = readdirSync(demoDir).filter((f) => f.endsWith(".ts"));
+        for (const file of files) {
+            try {
+                const filePath = join(demoDir, file);
+                const content = readFileSync(filePath, "utf-8");
+                const template = extractTemplateFromFile(file, content);
+                if (template) {
+                    templates.push(template);
+                }
+            }
+            catch (err) {
+                Logger.warn("system", "template-extract", `Failed to extract from ${file}`, {
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }
+        Logger.info("system", "template-extract", "Templates extracted", {
+            totalFiles: files.length,
+            extracted: templates.length,
+        });
+    }
+    catch (err) {
+        Logger.error("system", "template-extract", "Failed to read demo directory", err instanceof Error ? err.message : String(err));
+    }
+    return templates;
+}
+function extractTemplateFromFile(fileName, content) {
+    const workflowMatch = content.match(/(?:const|let|var)\s+\w+\s*[:=]\s*({[\s\S]*?id:\s*["'][^"']+["'][\s\S]*?})/);
+    if (!workflowMatch) {
+        return null;
+    }
+    const nameMatch = content.match(/@name\s+(.+)/);
+    const descMatch = content.match(/@description\s+(.+)/);
+    const categoryMatch = content.match(/@category\s+(.+)/);
+    const tagsMatch = content.match(/@tags\s+(.+)/);
+    const difficultyMatch = content.match(/@difficulty\s+(.+)/);
+    const id = basename(fileName, ".ts")
+        .replace(/-demo$/, "")
+        .replace(/[^a-z0-9-]/gi, "-")
+        .toLowerCase();
+    const tags = tagsMatch
+        ? tagsMatch[1].split(",").map((t) => t.trim())
+        : [id.split("-")[0]];
+    const category = categoryMatch
+        ? categoryMatch[1].trim()
+        : guessCategory(content);
+    const difficulty = difficultyMatch
+        ? difficultyMatch[1].trim()
+        : guessDifficulty(content);
+    return {
+        id,
+        name: nameMatch?.[1]?.trim() || formatName(id),
+        description: descMatch?.[1]?.trim() || `Workflow template extracted from ${fileName}`,
+        category,
+        tags,
+        difficulty,
+        definition: {
+            id,
+            name: nameMatch?.[1]?.trim() || formatName(id),
+            nodes: {},
+            startNode: "",
+        },
+        parameters: [],
+        examples: [],
+        author: "ts-runit",
+        version: "1.0.0",
+        downloads: 0,
+        rating: 0,
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+    };
+}
+function guessCategory(content) {
+    const contentLower = content.toLowerCase();
+    if (contentLower.includes("approval"))
+        return "approval";
+    if (contentLower.includes("notification"))
+        return "notification";
+    if (contentLower.includes("http"))
+        return "integration";
+    if (contentLower.includes("llm") || contentLower.includes("ai"))
+        return "ai";
+    if (contentLower.includes("loop"))
+        return "automation";
+    if (contentLower.includes("condition"))
+        return "routing";
+    return "general";
+}
+function guessDifficulty(content) {
+    const contentLower = content.toLowerCase();
+    let complexity = 0;
+    if (contentLower.includes("subworkflow"))
+        complexity += 2;
+    if (contentLower.includes("parallel"))
+        complexity += 1;
+    if (contentLower.includes("loop"))
+        complexity += 1;
+    if (contentLower.includes("condition"))
+        complexity += 1;
+    if (contentLower.includes("approval"))
+        complexity += 1;
+    if (contentLower.includes("saga"))
+        complexity += 2;
+    if (contentLower.includes("fanout"))
+        complexity += 2;
+    if (complexity >= 4)
+        return "advanced";
+    if (complexity >= 2)
+        return "intermediate";
+    return "beginner";
+}
+function formatName(id) {
+    return id
+        .split("-")
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join(" ");
+}
+//# sourceMappingURL=AutoExtract.js.map