@tapicker/bridge 1.0.0 → 1.1.0

package/dist/server.js

@@ -7,13 +7,14 @@ import { join, resolve } from 'node:path';
 import { WebSocketServer } from 'ws';
 import { createMcpHandler } from '@modelcontextprotocol/server';
 import { localhostHostValidation, toNodeHandler } from '@modelcontextprotocol/node';
-import { DEFAULT_HOST, DEFAULT_MCP_PATH, DEFAULT_PORT, DEFAULT_PORT_MAX, DEFAULT_WS_PATH, DEFAULT_WORKFLOW_WATCH_WS_PATH, PROTOCOL_VERSION, VERSION, } from './constants.js';
+import { DEFAULT_HOST, DEFAULT_MCP_PATH, DEFAULT_PORT, DEFAULT_PORT_MAX, DEFAULT_WS_PATH, DEFAULT_WORKFLOW_STATUS_WATCH_WS_PATH, PROTOCOL_VERSION, VERSION, } from './constants.js';
 import { BridgeService } from './bridge/bridge-service.js';
-import { PairingStateFile } from './bridge/pairing-state.js';
+import { getDefaultBridgeDataDir, PairingStateFile } from './bridge/pairing-state.js';
+import { ExportStore } from './bridge/export-store.js';
 import { getCommandCapabilities, dispatchCommand } from './commands.js';
 import { BridgeError, safeError, safeSuccess, toBridgeError } from './errors.js';
 import { createBridgeMcpApi, createTapickerMcpServer } from './mcp.js';
-import { WorkflowWatchRequestSchema, createEnvelope, parseEnvelope } from './protocol/schema.js';
+import { WorkflowStatusWatchRequestSchema, createEnvelope, parseEnvelope } from './protocol/schema.js';
 const DEFAULT_CORS_ORIGINS = ['*'];
 const CORS_ALLOWED_METHODS = 'GET, POST, DELETE, OPTIONS';
 const CORS_ALLOWED_HEADERS = 'Accept, Authorization, Content-Type, Last-Event-ID, MCP-Protocol-Version, Mcp-Session-Id';
@@ -25,6 +26,8 @@ export class BridgeServer {
     requestedPort;
     portMax;
     token;
+    exports;
+    exportCleanupTimer;
     corsOrigins;
     tls;
     mcpHandler;
@@ -41,28 +44,41 @@ export class BridgeServer {
         this.token = options.token;
         this.corsOrigins = normalizeCorsOrigins(options.corsOrigins ?? DEFAULT_CORS_ORIGINS);
         this.tls = options.tls;
+        this.exports = new ExportStore(join(resolve(options.dataDir ?? getDefaultBridgeDataDir()), 'exports'));
         const pairingState = options.dataDir
             ? new PairingStateFile(join(resolve(options.dataDir), 'paired-clients.json'))
             : undefined;
         this.bridge = new BridgeService({
             pairingCode: options.pairingCode ?? String(randomInt(0, 10_000)).padStart(4, '0'),
             capabilities: [
+                'workflow.guide',
+                'workflow.schema',
+                'workflow.validate',
+                'workflow.list',
+                'workflow.get',
+                'workflow.create',
+                'workflow.update',
                 'workflow.start',
                 'workflow.pause',
                 'workflow.resume',
                 'workflow.stop',
                 'workflow.status',
-                'workflow.status.get',
+                'workflow.logs',
+                'workflow.log',
+                'data.list',
+                'data.preview',
                 'data.get',
+                'data.export',
                 'data.delete',
+                'user.me',
             ],
             pairingState,
         });
-        this.mcpHandler = createMcpHandler(() => createTapickerMcpServer(createBridgeMcpApi(this.bridge)));
+        this.mcpHandler = createMcpHandler(() => createTapickerMcpServer(createBridgeMcpApi(this.bridge, this.exports)));
         this.mcpNodeHandler = toNodeHandler(this.mcpHandler, {
             onerror: (error) => console.error('Tapicker Bridge MCP request failed:', error),
         });
-        this.bridge.on('workflow.status', (event) => this.publishWorkflowStatus(event));
+        this.bridge.on('workflow.status.changed', (event) => this.publishWorkflowStatus(event));
     }
     getPairingCode() {
         return this.bridge.getPairingCode();
@@ -84,6 +100,9 @@ export class BridgeServer {
                 this.server = runtime.server;
                 this.webSocketServer = runtime.webSocketServer;
                 this.port = actualPort;
+                this.cleanExports();
+                this.exportCleanupTimer = setInterval(() => this.cleanExports(), 60_000);
+                this.exportCleanupTimer.unref();
                 return this.getAddress();
             }
             catch (error) {
@@ -99,6 +118,7 @@ export class BridgeServer {
         throw toBridgeError(lastError, 'PortUnavailable', 503);
     }
     async close() {
+        clearInterval(this.exportCleanupTimer);
         this.bridge.close();
         this.workflowSubscriptions.clear();
         await this.mcpHandler.close();
@@ -122,7 +142,7 @@ export class BridgeServer {
             port: this.port,
             httpUrl: `${protocol}://${displayHost}:${this.port}`,
             wsUrl: `${webSocketProtocol}://${displayHost}:${this.port}${DEFAULT_WS_PATH}`,
-            workflowWatchWsUrl: `${webSocketProtocol}://${displayHost}:${this.port}${DEFAULT_WORKFLOW_WATCH_WS_PATH}`,
+            workflowStatusWatchWsUrl: `${webSocketProtocol}://${displayHost}:${this.port}${DEFAULT_WORKFLOW_STATUS_WATCH_WS_PATH}`,
             mcpUrl: `${protocol}://${displayHost}:${this.port}${DEFAULT_MCP_PATH}`,
         };
     }
@@ -134,7 +154,7 @@ export class BridgeServer {
     }
     createRuntime() {
         const requestHandler = (request, response) => {
-            void this.handleRequest(request, response);
+            this.handleRequest(request, response);
         };
         const server = this.tls
             ? createHttpsServer({
@@ -145,7 +165,7 @@ export class BridgeServer {
         const webSocketServer = new WebSocketServer({ noServer: true });
         server.on('upgrade', (request, socket, head) => {
             const requestUrl = new URL(request.url || '/', this.getOrigin(request));
-            if (requestUrl.pathname === DEFAULT_WORKFLOW_WATCH_WS_PATH) {
+            if (requestUrl.pathname === DEFAULT_WORKFLOW_STATUS_WATCH_WS_PATH) {
                 try {
                     this.assertAuthorized(request);
                 }
@@ -153,7 +173,7 @@ export class BridgeServer {
                     rejectUpgrade(socket, toBridgeError(error));
                     return;
                 }
-                webSocketServer.handleUpgrade(request, socket, head, (client) => this.attachWorkflowWatcher(client));
+                webSocketServer.handleUpgrade(request, socket, head, (client) => this.attachWorkflowStatusWatcher(client));
                 return;
             }
             if (requestUrl.pathname !== DEFAULT_WS_PATH) {
@@ -166,10 +186,21 @@ export class BridgeServer {
         });
         return { server, webSocketServer };
     }
+    cleanExports() {
+        this.exports.cleanup().catch((error) => console.warn('Failed to clean expired exports:', error));
+    }
     async handleRequest(request, response) {
         try {
             const requestUrl = new URL(request.url || '/', this.getOrigin(request));
             const method = request.method || 'GET';
+            const exportRoute = /^\/v1\/exports\/([0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12})(\/upload)?$/.exec(requestUrl.pathname);
+            // 上传由当前导出的一次性凭证授权，与浏览器页面的 CORS 配置独立。
+            if (method === 'POST' && exportRoute?.[2]) {
+                await this.exports.upload(exportRoute[1], request);
+                response.statusCode = 204;
+                response.end();
+                return;
+            }
             if (!this.applyCors(request, response)) {
                 this.sendJson(response, 403, safeError(new BridgeError('CorsOriginNotAllowed', 'Cross-origin requests from this Origin are not allowed', {
                     status: 403,
@@ -189,6 +220,11 @@ export class BridgeServer {
                 await this.mcpNodeHandler(request, response);
                 return;
             }
+            if (method === 'GET' && exportRoute && !exportRoute[2]) {
+                this.assertAuthorized(request);
+                await this.exports.download(exportRoute[1], response);
+                return;
+            }
             if (method === 'GET' && requestUrl.pathname === '/v1/health') {
                 this.sendJson(response, 200, {
                     ok: true,
@@ -206,7 +242,7 @@ export class BridgeServer {
                     protocolVersion: PROTOCOL_VERSION,
                     bridgeId: this.bridgeId,
                     wsPath: DEFAULT_WS_PATH,
-                    workflowWatchPath: DEFAULT_WORKFLOW_WATCH_WS_PATH,
+                    workflowStatusWatchPath: DEFAULT_WORKFLOW_STATUS_WATCH_WS_PATH,
                     requiresAuthentication: Boolean(this.token),
                 });
                 return;
@@ -225,22 +261,30 @@ export class BridgeServer {
                 });
                 return;
             }
-            if (requestUrl.pathname === DEFAULT_WORKFLOW_WATCH_WS_PATH) {
+            if (requestUrl.pathname === DEFAULT_WORKFLOW_STATUS_WATCH_WS_PATH) {
                 this.assertAuthorized(request);
-                this.sendJson(response, 405, safeError(new BridgeError('WebSocketRequired', 'workflow.watch requires a WebSocket connection', { status: 405 })));
+                this.sendJson(response, 405, safeError(new BridgeError('WebSocketRequired', 'workflow.status.watch requires a WebSocket connection', {
+                    status: 405,
+                })));
                 return;
             }
             if (method === 'POST' && requestUrl.pathname.startsWith('/v1/commands/')) {
                 this.assertAuthorized(request);
                 const commandName = decodeURIComponent(requestUrl.pathname.slice('/v1/commands/'.length));
                 const body = await readJson(request);
-                const data = await dispatchCommand(commandName, body, { bridge: this.bridge });
+                const data = await dispatchCommand(commandName, body, { bridge: this.bridge, exports: this.exports });
                 this.sendJson(response, 200, safeSuccess(data));
                 return;
             }
             this.sendJson(response, 404, safeError(new BridgeError('NotFound', 'Route not found', { status: 404 })));
         }
         catch (error) {
+            if (response.destroyed)
+                return;
+            if (response.headersSent) {
+                response.destroy();
+                return;
+            }
             const bridgeError = toBridgeError(error);
             this.sendJson(response, bridgeError.status, safeError(bridgeError));
         }
@@ -255,33 +299,33 @@ export class BridgeServer {
             throw new BridgeError('Unauthorized', 'Bridge authentication is required', { status: 401 });
         }
     }
-    attachWorkflowWatcher(socket) {
+    attachWorkflowStatusWatcher(socket) {
         const remove = () => this.workflowSubscriptions.delete(socket);
         socket.on('close', remove);
         socket.on('error', remove);
         socket.on('message', (raw) => {
             const parsedEnvelope = parseEnvelope(raw);
             if (!parsedEnvelope.success) {
-                socket.close(1007, 'Invalid Workflow watch message');
+                socket.close(1007, 'Invalid Workflow status watch message');
                 return;
             }
             const request = parsedEnvelope.data;
-            if (request.type !== 'workflow.watch') {
-                this.sendWorkflowWatchResult(socket, request.id, safeError(new BridgeError('UnsupportedMessage', 'Only workflow.watch is supported on this socket', {
+            if (request.type !== 'workflow.status.watch') {
+                this.sendWorkflowStatusWatchResult(socket, request.id, safeError(new BridgeError('UnsupportedMessage', 'Only workflow.status.watch is supported on this socket', {
                     status: 400,
                 })));
                 return;
             }
-            const parsedRequest = WorkflowWatchRequestSchema.safeParse(request.data);
+            const parsedRequest = WorkflowStatusWatchRequestSchema.safeParse(request.data);
             if (!parsedRequest.success) {
-                this.sendWorkflowWatchResult(socket, request.id, safeError(new BridgeError('InvalidArguments', 'Invalid Workflow watch arguments', {
+                this.sendWorkflowStatusWatchResult(socket, request.id, safeError(new BridgeError('InvalidArguments', 'Invalid Workflow status watch arguments', {
                     status: 400,
                     details: parsedRequest.error.issues,
                 })));
                 return;
             }
             if (this.workflowSubscriptions.has(socket)) {
-                this.sendWorkflowWatchResult(socket, request.id, safeError(new BridgeError('WorkflowWatchAlreadyStarted', 'This socket is already watching a Workflow', {
+                this.sendWorkflowStatusWatchResult(socket, request.id, safeError(new BridgeError('WorkflowStatusWatchAlreadyStarted', 'This socket is already watching a Workflow', {
                     status: 409,
                 })));
                 return;
@@ -291,17 +335,17 @@ export class BridgeServer {
                 const clientId = this.bridge.resolveCommandClientId('workflow.status', watchRequest.clientId);
                 const subscription = { clientId, workflowId: watchRequest.input.workflowId };
                 this.workflowSubscriptions.set(socket, subscription);
-                this.sendWorkflowWatchResult(socket, request.id, safeSuccess(subscription));
+                this.sendWorkflowStatusWatchResult(socket, request.id, safeSuccess(subscription));
             }
             catch (error) {
-                this.sendWorkflowWatchResult(socket, request.id, safeError(error));
+                this.sendWorkflowStatusWatchResult(socket, request.id, safeError(error));
             }
         });
     }
-    sendWorkflowWatchResult(socket, id, data) {
+    sendWorkflowStatusWatchResult(socket, id, data) {
         if (socket.readyState === socket.OPEN) {
             try {
-                socket.send(JSON.stringify(createEnvelope('workflow.watch:res', data, { id, callback: false })));
+                socket.send(JSON.stringify(createEnvelope('workflow.status.watch:res', data, { id, callback: false })));
             }
             catch {
                 this.workflowSubscriptions.delete(socket);
@@ -309,7 +353,7 @@ export class BridgeServer {
         }
     }
     publishWorkflowStatus(event) {
-        const envelope = JSON.stringify(createEnvelope('workflow.status', event, { callback: false }));
+        const envelope = JSON.stringify(createEnvelope('workflow.status.changed', event, { callback: false }));
         for (const [socket, subscription] of this.workflowSubscriptions) {
             if (socket.readyState === socket.OPEN && subscriptionKey(subscription) === subscriptionKey(event)) {
                 try {

package/dist/update-notifier-worker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=update-notifier-worker.d.ts.map

package/dist/update-notifier-worker.js

@@ -0,0 +1,3 @@
+import { refreshUpdateCache } from './update-notifier.js';
+await refreshUpdateCache(process.argv[2]).catch(() => undefined);
+//# sourceMappingURL=update-notifier-worker.js.map

package/dist/update-notifier.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 从缓存显示提醒，然后按需启动独立的检查进程。
+ */
+export declare function showCachedUpdate(directory?: string): Promise<void>;
+/**
+ * 在后台进程中刷新 npm 缓存。失败也记录检查时间，避免离线时反复请求。
+ */
+export declare function refreshUpdateCache(directory?: string): Promise<void>;
+//# sourceMappingURL=update-notifier.d.ts.map

package/dist/update-notifier.js

@@ -0,0 +1,178 @@
+import { exec, spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { mkdir, readFile, rename, rmdir, stat, unlink, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { promisify } from 'node:util';
+import { z } from 'zod';
+import { getDefaultBridgeDataDir } from './bridge/pairing-state.js';
+import { VERSION } from './constants.js';
+const UPDATE_INTERVAL = 24 * 60 * 60 * 1000;
+const REQUEST_TIMEOUT = 5000;
+const LOCK_TIMEOUT = 60_000;
+const DEFAULT_REGISTRY = 'https://registry.npmjs.org/';
+const execAsync = promisify(exec);
+const CacheSchema = z.object({
+    checkedAt: z.number().optional(),
+    latestVersion: z.string().optional(),
+    notifiedAt: z.number().optional(),
+});
+const RegistrySchema = z.object({ 'dist-tags': z.object({ latest: z.string() }) });
+const numericVersion = /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)$/;
+/**
+ * 仅比较发布流程使用的三段数字版本。
+ */
+function isNewerVersion(latest, current) {
+    if (!numericVersion.test(latest) || !numericVersion.test(current))
+        return false;
+    const latestParts = latest.split('.').map(BigInt);
+    const currentParts = current.split('.').map(BigInt);
+    const difference = latestParts.findIndex((part, index) => part !== currentParts[index]);
+    return difference !== -1 && latestParts[difference] > currentParts[difference];
+}
+function isRecent(timestamp) {
+    return timestamp !== undefined && Date.now() - timestamp < UPDATE_INTERVAL;
+}
+/**
+ * 使用与全局升级命令相同的 npm 配置，并保留镜像地址的路径前缀。
+ */
+async function getRegistryPackageUrl() {
+    const config = await execAsync('npm config get @tapicker:registry registry --global', {
+        timeout: 2000,
+        windowsHide: true,
+    }).catch(() => undefined);
+    const settings = config?.stdout.trim().split(/\r?\n/) ?? [];
+    const registry = ['@tapicker:registry', 'registry']
+        .map((key) => settings
+        .find((line) => line.startsWith(`${key}=`))
+        ?.slice(key.length + 1)
+        .trim())
+        .find((value) => value && value !== 'undefined' && value !== 'null');
+    const url = new URL(registry ?? DEFAULT_REGISTRY);
+    if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+        throw new Error('Unsupported npm registry protocol');
+    }
+    url.pathname = `${url.pathname.replace(/\/+$/, '')}/@tapicker%2Fbridge`;
+    return url;
+}
+async function readCache(path) {
+    try {
+        return CacheSchema.safeParse(JSON.parse(await readFile(path, 'utf8'))).data ?? {};
+    }
+    catch (error) {
+        if (error instanceof SyntaxError || error.code === 'ENOENT')
+            return {};
+        throw error;
+    }
+}
+async function writeCache(path, cache) {
+    const temporaryPath = `${path}.${randomUUID()}.tmp`;
+    try {
+        await writeFile(temporaryPath, JSON.stringify(cache), { flag: 'wx', mode: 0o600 });
+        await rename(temporaryPath, path);
+    }
+    finally {
+        await unlink(temporaryPath).catch(() => undefined);
+    }
+}
+/**
+ * 尝试获取短期文件锁。已有进程持锁时直接跳过，避免 CLI 等待网络请求。
+ */
+async function withCacheLock(directory, action) {
+    const path = join(directory, 'update-notifier.json');
+    const lockPath = `${path}.lock`;
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    try {
+        await mkdir(lockPath);
+    }
+    catch (error) {
+        if (error.code !== 'EEXIST')
+            throw error;
+        const lock = await stat(lockPath).catch(() => undefined);
+        if (!lock || Date.now() - lock.mtimeMs < LOCK_TIMEOUT)
+            return;
+        await rmdir(lockPath);
+        await mkdir(lockPath);
+    }
+    try {
+        await action(path);
+    }
+    finally {
+        await rmdir(lockPath);
+    }
+}
+function printUpdate(latest) {
+    const useColor = !('NO_COLOR' in process.env) && process.stderr.hasColors?.();
+    const title = `Update Available: ${VERSION} → `;
+    const lines = [`${title}${latest}`, 'npm i -g @tapicker/bridge@latest', 'Restart Bridge to Apply if Running'];
+    const width = Math.max(...lines.map((line) => line.length));
+    const border = '─'.repeat(width + 4);
+    const rows = lines.map((line, index) => {
+        const padding = width - line.length;
+        const left = Math.floor(padding / 2);
+        const right = padding - left;
+        const label = index === 0 && useColor ? `${title}\x1b[36m${latest}\x1b[0m` : line;
+        return `│${' '.repeat(left + 2)}${label}${' '.repeat(right + 2)}│`;
+    });
+    console.error([`╭${border}╮`, ...rows, `╰${border}╯`].join('\n'));
+}
+/**
+ * 从缓存显示提醒，然后按需启动独立的检查进程。
+ */
+export async function showCachedUpdate(directory = getDefaultBridgeDataDir()) {
+    try {
+        const cache = await readCache(join(directory, 'update-notifier.json'));
+        const latestVersion = cache.latestVersion;
+        if (latestVersion && isNewerVersion(latestVersion, VERSION) && !isRecent(cache.notifiedAt)) {
+            await withCacheLock(directory, async (path) => {
+                const current = await readCache(path);
+                if (current.latestVersion !== latestVersion || isRecent(current.notifiedAt))
+                    return;
+                await writeCache(path, { ...current, notifiedAt: Date.now() });
+                printUpdate(latestVersion);
+            });
+        }
+        if (!isRecent(cache.checkedAt)) {
+            const worker = fileURLToPath(new URL('./update-notifier-worker.js', import.meta.url));
+            const child = spawn(process.execPath, [worker, directory], {
+                detached: true,
+                stdio: 'ignore',
+                windowsHide: true,
+            });
+            child.on('error', () => undefined);
+            child.unref();
+        }
+    }
+    catch {
+        // 缓存或进程创建失败时，继续执行 CLI 命令。
+    }
+}
+/**
+ * 在后台进程中刷新 npm 缓存。失败也记录检查时间，避免离线时反复请求。
+ */
+export async function refreshUpdateCache(directory = getDefaultBridgeDataDir()) {
+    await withCacheLock(directory, async (path) => {
+        const cache = await readCache(path);
+        if (isRecent(cache.checkedAt))
+            return;
+        const checkedAt = Date.now();
+        let latestVersion;
+        try {
+            const response = await fetch(await getRegistryPackageUrl(), {
+                headers: { Accept: 'application/vnd.npm.install-v1+json' },
+                signal: AbortSignal.timeout(REQUEST_TIMEOUT),
+            });
+            if (response.ok) {
+                const result = RegistrySchema.safeParse(await response.json());
+                const version = result.data?.['dist-tags'].latest;
+                if (version && numericVersion.test(version))
+                    latestVersion = version;
+            }
+        }
+        catch {
+            // 网络错误与超时都不需要提示。
+        }
+        await writeCache(path, { ...cache, checkedAt, latestVersion });
+    });
+}
+//# sourceMappingURL=update-notifier.js.map

package/dist/workflow-watch.d.ts

@@ -1,14 +1,14 @@
 import { BridgeError } from './errors.js';
 import type { WorkflowStatusEvent } from './protocol/schema.js';
-export type WorkflowWatchInput = {
+export type WorkflowStatusWatchInput = {
     clientId?: string;
     workflowId: string;
     timeoutMs?: number;
 };
-export type WorkflowWatchResult = WorkflowStatusEvent & {
-    timedOut: boolean;
+export type WorkflowStatusWatchResult = WorkflowStatusEvent & {
+    isTimedOut: boolean;
 };
-export type WorkflowWatchConnection = {
+export type WorkflowStatusWatchConnection = {
     clientId: string;
     workflowId: string;
     onStatus: (listener: (event: WorkflowStatusEvent) => void) => () => void;
@@ -18,14 +18,15 @@ export type WorkflowWatchConnection = {
 type WaitForWorkflowStatusOptions = {
     clientId: string;
     workflowId: string;
+    runAt?: string;
     subscribe: (onStatus: (event: WorkflowStatusEvent) => void, onClose: (error: BridgeError) => void) => () => void;
     readStatus: () => Promise<WorkflowStatusEvent>;
     onStatus?: (event: WorkflowStatusEvent) => void;
     timeoutMs?: number;
     signal?: AbortSignal;
 };
-export declare function workflowWatchWebSocketUrl(bridgeUrl: URL): URL;
-export declare function connectWorkflowWatch(url: string | URL, input: Omit<WorkflowWatchInput, 'timeoutMs'>, token?: string, signal?: AbortSignal): Promise<WorkflowWatchConnection>;
-export declare function waitForWorkflowStatus(options: WaitForWorkflowStatusOptions): Promise<WorkflowWatchResult>;
+export declare function workflowStatusWatchWebSocketUrl(bridgeUrl: URL): import("url").URL;
+export declare function connectWorkflowStatusWatch(url: string | URL, input: Omit<WorkflowStatusWatchInput, 'timeoutMs'>, token?: string, signal?: AbortSignal): Promise<WorkflowStatusWatchConnection>;
+export declare function waitForWorkflowStatus(options: WaitForWorkflowStatusOptions): Promise<WorkflowStatusWatchResult>;
 export {};
 //# sourceMappingURL=workflow-watch.d.ts.map