@jshookmcp/jshook 0.1.9 → 0.2.1

package/dist/tests/server/domains/workflow/workflow-base.test.js

@@ -0,0 +1,483 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const { mockIsSsrfTarget, mockIsPrivateHost, mockIsLoopbackHost, mockLookup, } = vi.hoisted(() => ({
+    mockIsSsrfTarget: vi.fn(async () => false),
+    mockIsPrivateHost: vi.fn(() => false),
+    mockIsLoopbackHost: vi.fn(() => false),
+    mockLookup: vi.fn(),
+}));
+vi.mock('@src/server/domains/network/replay', () => ({
+    isSsrfTarget: mockIsSsrfTarget,
+    isPrivateHost: mockIsPrivateHost,
+    isLoopbackHost: mockIsLoopbackHost,
+}));
+vi.mock('node:dns/promises', () => ({
+    lookup: mockLookup,
+}));
+vi.mock('node:fs/promises', () => ({
+    mkdir: vi.fn(async () => undefined),
+    writeFile: vi.fn(async () => undefined),
+    realpath: vi.fn(async (p) => p),
+}));
+vi.mock('@utils/outputPaths', () => ({
+    getProjectRoot: vi.fn(() => '/project'),
+}));
+vi.mock('@server/workflows/WorkflowEngine', () => ({
+    executeExtensionWorkflow: vi.fn(),
+}));
+import { WorkflowHandlersBase } from '../../../../src/server/domains/workflow/handlers.impl.workflow-base.js';
+function parseJson(response) {
+    return JSON.parse(response.content[0].text);
+}
+function createDeps() {
+    return {
+        browserHandlers: {
+            handlePageEvaluate: vi.fn(),
+            handlePageNavigate: vi.fn(),
+            handlePageType: vi.fn(),
+            handlePageClick: vi.fn(),
+            handleTabWorkflow: vi.fn(),
+        },
+        advancedHandlers: {
+            handleNetworkEnable: vi.fn(),
+            handleConsoleInjectFetchInterceptor: vi.fn(),
+            handleConsoleInjectXhrInterceptor: vi.fn(),
+            handleNetworkGetStats: vi.fn(),
+            handleNetworkGetRequests: vi.fn(),
+            handleNetworkExtractAuth: vi.fn(),
+            handleNetworkExportHar: vi.fn(),
+        },
+        serverContext: {
+            extensionWorkflowsById: new Map(),
+            extensionWorkflowRuntimeById: new Map(),
+        },
+    };
+}
+describe('WorkflowHandlersBase', () => {
+    let deps;
+    let handlers;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        deps = createDeps();
+        handlers = new WorkflowHandlersBase(deps);
+    });
+    describe('initBuiltinScripts', () => {
+        it('registers built-in scripts on construction', () => {
+            const registry = handlers.scriptRegistry;
+            expect(registry.has('auth_extract')).toBe(true);
+            expect(registry.has('bundle_search')).toBe(true);
+            expect(registry.has('react_fill_form')).toBe(true);
+            expect(registry.has('dom_find_upgrade_buttons')).toBe(true);
+        });
+        it('has description for each built-in script', () => {
+            const registry = handlers.scriptRegistry;
+            for (const [, entry] of registry) {
+                expect(entry.description).toBeDefined();
+                expect(entry.description.length).toBeGreaterThan(0);
+            }
+        });
+        it('has code for each built-in script', () => {
+            const registry = handlers.scriptRegistry;
+            for (const [, entry] of registry) {
+                expect(entry.code).toBeDefined();
+                expect(entry.code.length).toBeGreaterThan(0);
+            }
+        });
+    });
+    describe('handlePageScriptRegister', () => {
+        it('fails when name is empty', async () => {
+            const body = parseJson(await handlers.handlePageScriptRegister({ name: '', code: 'x' }));
+            expect(body.success).toBe(false);
+            expect(body.error).toContain('name and code are required');
+        });
+        it('fails when code is empty', async () => {
+            const body = parseJson(await handlers.handlePageScriptRegister({ name: 'test', code: '' }));
+            expect(body.success).toBe(false);
+        });
+        it('fails when both name and code are missing', async () => {
+            const body = parseJson(await handlers.handlePageScriptRegister({}));
+            expect(body.success).toBe(false);
+        });
+        it('registers a new script', async () => {
+            const body = parseJson(await handlers.handlePageScriptRegister({
+                name: 'my_script',
+                code: '(() => 42)()',
+                description: 'A test script',
+            }));
+            expect(body.success).toBe(true);
+            expect(body.action).toBe('registered');
+            expect(body.name).toBe('my_script');
+            expect(body.description).toBe('A test script');
+            expect(body.available).toContain('my_script');
+        });
+        it('updates an existing script', async () => {
+            await handlers.handlePageScriptRegister({
+                name: 'my_script',
+                code: 'original()',
+            });
+            const body = parseJson(await handlers.handlePageScriptRegister({
+                name: 'my_script',
+                code: 'updated()',
+                description: 'Updated',
+            }));
+            expect(body.success).toBe(true);
+            expect(body.action).toBe('updated');
+        });
+        it('evicts oldest non-builtin when at max capacity', async () => {
+            const MAX = WorkflowHandlersBase.MAX_SCRIPTS;
+            for (let i = 0; i < MAX; i++) {
+                await handlers.handlePageScriptRegister({
+                    name: `custom_${i}`,
+                    code: `(() => ${i})()`,
+                });
+            }
+            const body = parseJson(await handlers.handlePageScriptRegister({
+                name: 'overflow_script',
+                code: '(() => "overflow")()',
+            }));
+            expect(body.success).toBe(true);
+            const registry = handlers.scriptRegistry;
+            expect(registry.has('overflow_script')).toBe(true);
+            expect(registry.has('auth_extract')).toBe(true);
+        });
+        it('uses empty string as default description', async () => {
+            const body = parseJson(await handlers.handlePageScriptRegister({
+                name: 'no_desc',
+                code: '1',
+            }));
+            expect(body.success).toBe(true);
+            expect(body.description).toBe('');
+        });
+    });
+    describe('handlePageScriptRun', () => {
+        it('fails when script name not found', async () => {
+            const body = parseJson(await handlers.handlePageScriptRun({ name: 'nonexistent' }));
+            expect(body.success).toBe(false);
+            expect(body.error).toContain('not found');
+            expect(Array.isArray(body.available)).toBe(true);
+        });
+        it('runs script without params', async () => {
+            deps.browserHandlers.handlePageEvaluate.mockResolvedValue({
+                content: [{ type: 'text', text: JSON.stringify({ value: 'ok' }) }],
+            });
+            await handlers.handlePageScriptRegister({
+                name: 'simple',
+                code: '(() => "result")()',
+            });
+            const response = await handlers.handlePageScriptRun({ name: 'simple' });
+            expect(deps.browserHandlers.handlePageEvaluate).toHaveBeenCalledOnce();
+            expect(response.content[0].type).toBe('text');
+        });
+        it('injects params when provided', async () => {
+            deps.browserHandlers.handlePageEvaluate.mockResolvedValue({
+                content: [{ type: 'text', text: JSON.stringify({ value: 'ok' }) }],
+            });
+            await handlers.handlePageScriptRegister({
+                name: 'parameterized',
+                code: '(function(){ return __params__; })()',
+            });
+            await handlers.handlePageScriptRun({
+                name: 'parameterized',
+                params: { key: 'value' },
+            });
+            const call = deps.browserHandlers.handlePageEvaluate.mock.calls[0][0];
+            expect(call.code).toContain('__params__');
+            expect(call.code).toContain('JSON.parse');
+        });
+        it('returns error when script execution throws', async () => {
+            deps.browserHandlers.handlePageEvaluate.mockRejectedValue(new Error('Eval failed'));
+            await handlers.handlePageScriptRegister({
+                name: 'failing',
+                code: 'throw new Error("boom")',
+            });
+            const body = parseJson(await handlers.handlePageScriptRun({ name: 'failing' }));
+            expect(body.success).toBe(false);
+            expect(body.error).toContain('Eval failed');
+            expect(body.script).toBe('failing');
+        });
+        it('runs built-in auth_extract script', async () => {
+            deps.browserHandlers.handlePageEvaluate.mockResolvedValue({
+                content: [{ type: 'text', text: JSON.stringify({ token: 'abc' }) }],
+            });
+            const response = await handlers.handlePageScriptRun({ name: 'auth_extract' });
+            expect(deps.browserHandlers.handlePageEvaluate).toHaveBeenCalledOnce();
+            expect(response.content).toBeDefined();
+        });
+    });
+    describe('normalizeOutputPath', () => {
+        it('returns default path when input is undefined', () => {
+            const result = handlers.normalizeOutputPath(undefined, 'default/path', 'dir');
+            expect(result).toBe('default/path');
+        });
+        it('returns default path when input is empty string', () => {
+            const result = handlers.normalizeOutputPath('', 'default/path', 'dir');
+            expect(result).toBe('default/path');
+        });
+        it('returns default path when input is whitespace only', () => {
+            const result = handlers.normalizeOutputPath('   ', 'default/path', 'dir');
+            expect(result).toBe('default/path');
+        });
+        it('returns default path for absolute paths', () => {
+            const result = handlers.normalizeOutputPath('/etc/passwd', 'default/path', 'dir');
+            expect(result).toBe('default/path');
+        });
+        it('returns default path for Windows absolute paths', () => {
+            const result = handlers.normalizeOutputPath('C:\\data\\file.txt', 'default/path', 'dir');
+            expect(result).toBe('default/path');
+        });
+        it('returns default path for path traversal attempts', () => {
+            const result = handlers.normalizeOutputPath('../../../etc/passwd', 'default/path', 'dir');
+            expect(result).toBe('default/path');
+        });
+        it('prepends preferred directory for filename-only input', () => {
+            const result = handlers.normalizeOutputPath('output.har', 'default/path', 'artifacts/har');
+            expect(result).toBe('artifacts/har/output.har');
+        });
+        it('returns path as-is for relative paths with directories', () => {
+            const result = handlers.normalizeOutputPath('reports/output.md', 'default/path', 'dir');
+            expect(result).toBe('reports/output.md');
+        });
+    });
+    describe('escapeInlineScriptLiteral', () => {
+        it('escapes < character', () => {
+            const result = handlers.escapeInlineScriptLiteral('<script>');
+            expect(result).toContain('\\u003C');
+            expect(result).toContain('\\u003E');
+        });
+        it('escapes / character', () => {
+            const result = handlers.escapeInlineScriptLiteral('a/b');
+            expect(result).toContain('\\u002F');
+        });
+        it('escapes line separator and paragraph separator', () => {
+            const result = handlers.escapeInlineScriptLiteral('a\u2028b\u2029c');
+            expect(result).toContain('\\u2028');
+            expect(result).toContain('\\u2029');
+        });
+        it('returns string unchanged if no special chars', () => {
+            const result = handlers.escapeInlineScriptLiteral('hello world');
+            expect(result).toBe('hello world');
+        });
+    });
+    describe('evictBundleCache', () => {
+        it('removes expired entries', () => {
+            const cache = handlers.bundleCache;
+            const ttl = WorkflowHandlersBase.BUNDLE_CACHE_TTL_MS;
+            cache.set('old', { text: 'data', cachedAt: Date.now() - ttl - 1000 });
+            handlers.bundleCacheBytes = 4;
+            handlers.evictBundleCache();
+            expect(cache.size).toBe(0);
+            expect(handlers.bundleCacheBytes).toBe(0);
+        });
+        it('keeps unexpired entries', () => {
+            const cache = handlers.bundleCache;
+            cache.set('recent', { text: 'data', cachedAt: Date.now() });
+            handlers.bundleCacheBytes = 4;
+            handlers.evictBundleCache();
+            expect(cache.has('recent')).toBe(true);
+        });
+        it('evicts oldest when over entry limit', () => {
+            const cache = handlers.bundleCache;
+            const maxEntries = WorkflowHandlersBase.MAX_BUNDLE_CACHE;
+            for (let i = 0; i < maxEntries + 5; i++) {
+                const text = `data_${i}`;
+                cache.set(`key_${i}`, { text, cachedAt: Date.now() });
+                handlers.bundleCacheBytes += text.length;
+            }
+            handlers.evictBundleCache();
+            expect(cache.size).toBeLessThanOrEqual(maxEntries);
+        });
+    });
+    describe('buildWebApiCaptureReportMarkdown', () => {
+        it('builds complete markdown report with all sections', () => {
+            const report = handlers.buildWebApiCaptureReportMarkdown({
+                generatedAt: '2026-03-15T12:00:00Z',
+                url: 'https://api.example.com',
+                waitUntil: 'networkidle0',
+                waitAfterActionsMs: 2000,
+                steps: ['network_enable', 'page_navigate(https://api.example.com)'],
+                warnings: ['Action click failed: element not found'],
+                totalCaptured: 42,
+                authFindings: [
+                    { type: 'bearer', location: 'header', confidence: 0.95, maskedValue: 'ey***' },
+                ],
+                harExported: true,
+                harOutputPath: 'artifacts/har/capture.har',
+            });
+            expect(report).toContain('# Web API Capture Report');
+            expect(report).toContain('URL: https://api.example.com');
+            expect(report).toContain('Wait Until: networkidle0');
+            expect(report).toContain('Wait After Actions (ms): 2000');
+            expect(report).toContain('Captured Requests: 42');
+            expect(report).toContain('HAR Exported: yes');
+            expect(report).toContain('## Steps');
+            expect(report).toContain('- network_enable');
+            expect(report).toContain('## Auth Findings');
+            expect(report).toContain('type=bearer');
+            expect(report).toContain('confidence=0.95');
+            expect(report).toContain('## Warnings');
+            expect(report).toContain('Action click failed');
+        });
+        it('reports "(none)" for empty steps', () => {
+            const report = handlers.buildWebApiCaptureReportMarkdown({
+                generatedAt: '2026-03-15T12:00:00Z',
+                url: 'https://api.example.com',
+                waitUntil: 'load',
+                waitAfterActionsMs: 0,
+                steps: [],
+                warnings: [],
+                totalCaptured: 0,
+                authFindings: [],
+                harExported: false,
+            });
+            expect(report).toContain('## Steps\n- (none)');
+            expect(report).toContain('## Auth Findings\n- (none)');
+            expect(report).toContain('## Warnings\n- (none)');
+        });
+        it('handles auth finding with masked field fallback chain', () => {
+            const report = handlers.buildWebApiCaptureReportMarkdown({
+                generatedAt: '2026-03-15T12:00:00Z',
+                url: 'https://example.com',
+                waitUntil: 'load',
+                waitAfterActionsMs: 0,
+                steps: [],
+                warnings: [],
+                totalCaptured: 0,
+                authFindings: [
+                    { type: 'cookie', location: 'response', value: 'session=abc123' },
+                ],
+                harExported: false,
+            });
+            expect(report).toContain('type=cookie');
+            expect(report).toContain('value=session=abc123');
+        });
+        it('handles HAR path n/a when not provided', () => {
+            const report = handlers.buildWebApiCaptureReportMarkdown({
+                generatedAt: '2026-03-15T12:00:00Z',
+                url: 'https://example.com',
+                waitUntil: 'load',
+                waitAfterActionsMs: 0,
+                steps: [],
+                warnings: [],
+                totalCaptured: 0,
+                authFindings: [],
+                harExported: false,
+            });
+            expect(report).toContain('HAR Path: n/a');
+        });
+    });
+    describe('getOptionalString', () => {
+        it('returns string value', () => {
+            expect(handlers.getOptionalString('hello')).toBe('hello');
+        });
+        it('returns undefined for non-string', () => {
+            expect(handlers.getOptionalString(123)).toBeUndefined();
+            expect(handlers.getOptionalString(null)).toBeUndefined();
+            expect(handlers.getOptionalString(undefined)).toBeUndefined();
+        });
+    });
+    describe('getOptionalRecord', () => {
+        it('returns object value', () => {
+            const obj = { key: 'val' };
+            expect(handlers.getOptionalRecord(obj)).toBe(obj);
+        });
+        it('returns undefined for null', () => {
+            expect(handlers.getOptionalRecord(null)).toBeUndefined();
+        });
+        it('returns undefined for arrays', () => {
+            expect(handlers.getOptionalRecord([1, 2])).toBeUndefined();
+        });
+        it('returns undefined for primitives', () => {
+            expect(handlers.getOptionalRecord('str')).toBeUndefined();
+            expect(handlers.getOptionalRecord(42)).toBeUndefined();
+        });
+    });
+    describe('jsonTextResult', () => {
+        it('wraps payload in standard tool response format', () => {
+            const result = handlers.jsonTextResult({ success: true, data: 'test' });
+            expect(result.content).toHaveLength(1);
+            expect(result.content[0].type).toBe('text');
+            const parsed = JSON.parse(result.content[0].text);
+            expect(parsed.success).toBe(true);
+            expect(parsed.data).toBe('test');
+        });
+    });
+    describe('handleListExtensionWorkflows', () => {
+        it('returns error when serverContext is unavailable', async () => {
+            const noDeps = createDeps();
+            noDeps.serverContext = undefined;
+            const h = new WorkflowHandlersBase(noDeps);
+            const body = parseJson(await h.handleListExtensionWorkflows());
+            expect(body.success).toBe(false);
+            expect(body.error).toContain('unavailable');
+        });
+        it('returns empty list when no workflows loaded', async () => {
+            const body = parseJson(await handlers.handleListExtensionWorkflows());
+            expect(body.success).toBe(true);
+            expect(body.count).toBe(0);
+            expect(body.workflows).toEqual([]);
+        });
+        it('returns sorted list of loaded workflows', async () => {
+            const ctx = deps.serverContext;
+            ctx.extensionWorkflowsById.set('z-workflow', {
+                id: 'z-workflow',
+                displayName: 'Z Workflow',
+                description: 'last',
+                tags: [],
+                timeoutMs: 10000,
+                defaultMaxConcurrency: 1,
+                source: 'z.ts',
+            });
+            ctx.extensionWorkflowsById.set('a-workflow', {
+                id: 'a-workflow',
+                displayName: 'A Workflow',
+                description: 'first',
+                tags: ['demo'],
+                timeoutMs: 5000,
+                defaultMaxConcurrency: 2,
+                source: 'a.ts',
+            });
+            const body = parseJson(await handlers.handleListExtensionWorkflows());
+            expect(body.success).toBe(true);
+            expect(body.count).toBe(2);
+            expect(body.workflows[0].id).toBe('a-workflow');
+            expect(body.workflows[1].id).toBe('z-workflow');
+        });
+    });
+    describe('handleRunExtensionWorkflow', () => {
+        it('returns error when serverContext is unavailable', async () => {
+            const noDeps = createDeps();
+            noDeps.serverContext = undefined;
+            const h = new WorkflowHandlersBase(noDeps);
+            const body = parseJson(await h.handleRunExtensionWorkflow({ workflowId: 'test' }));
+            expect(body.success).toBe(false);
+            expect(body.error).toContain('unavailable');
+        });
+        it('returns error when workflowId is missing', async () => {
+            const body = parseJson(await handlers.handleRunExtensionWorkflow({}));
+            expect(body.success).toBe(false);
+            expect(body.error).toContain('workflowId is required');
+        });
+        it('returns error when workflow not found', async () => {
+            const body = parseJson(await handlers.handleRunExtensionWorkflow({ workflowId: 'nonexistent' }));
+            expect(body.success).toBe(false);
+            expect(body.error).toContain('not found');
+            expect(Array.isArray(body.available)).toBe(true);
+        });
+        it('accepts id as alias for workflowId', async () => {
+            const body = parseJson(await handlers.handleRunExtensionWorkflow({ id: 'nonexistent' }));
+            expect(body.success).toBe(false);
+            expect(body.error).toContain('nonexistent');
+        });
+        it('handles workflow execution failure', async () => {
+            const ctx = deps.serverContext;
+            ctx.extensionWorkflowRuntimeById.set('failing', {
+                workflow: {},
+                source: 'fail.ts',
+            });
+            const { executeExtensionWorkflow } = await import('../../../../src/server/workflows/WorkflowEngine.js');
+            executeExtensionWorkflow.mockRejectedValue(new Error('Workflow execution timeout'));
+            const body = parseJson(await handlers.handleRunExtensionWorkflow({ workflowId: 'failing' }));
+            expect(body.success).toBe(false);
+            expect(body.error).toContain('Workflow execution timeout');
+        });
+    });
+});

package/dist/tests/server/extensions/ExtensionManager.discovery.test.d.ts

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

package/dist/tests/server/extensions/ExtensionManager.discovery.test.js

@@ -0,0 +1,60 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const state = vi.hoisted(() => ({
+    glob: vi.fn(),
+}));
+vi.mock('tinyglobby', () => ({
+    glob: state.glob,
+}));
+describe('ExtensionManager.discovery', () => {
+    beforeEach(() => {
+        vi.resetModules();
+        state.glob.mockReset();
+    });
+    it('discovers plugin manifests and prefers js over ts in duplicate dist candidates', async () => {
+        state.glob.mockImplementation(async (_pattern, options) => {
+            if (options.cwd === '/plugins') {
+                return [
+                    '/plugins/alpha/manifest.ts',
+                    '/plugins/alpha/dist/manifest.js',
+                    '/plugins/beta/manifest.js',
+                    '/plugins/ignore/readme.md',
+                ];
+            }
+            return [];
+        });
+        const { discoverPluginFiles } = await import('../../../src/server/extensions/ExtensionManager.discovery.js');
+        await expect(discoverPluginFiles(['/plugins'])).resolves.toEqual([
+            '/plugins/alpha/dist/manifest.js',
+            '/plugins/beta/manifest.js',
+        ]);
+    });
+    it('discovers workflow manifests in both workflow.* and *.workflow.* forms', async () => {
+        state.glob.mockImplementation(async (_pattern, options) => {
+            if (options.cwd === '/workflows') {
+                return [
+                    '/workflows/a/workflow.ts',
+                    '/workflows/b/build.workflow.js',
+                    '/workflows/c/workflow.md',
+                ];
+            }
+            return [];
+        });
+        const { discoverWorkflowFiles } = await import('../../../src/server/extensions/ExtensionManager.discovery.js');
+        await expect(discoverWorkflowFiles(['/workflows'])).resolves.toEqual([
+            '/workflows/a/workflow.ts',
+            '/workflows/b/build.workflow.js',
+        ]);
+    });
+    it('skips roots whose glob scan fails', async () => {
+        state.glob.mockImplementation(async (_pattern, options) => {
+            if (options.cwd === '/broken') {
+                throw new Error('scan failed');
+            }
+            return ['/ok/plugin/manifest.ts'];
+        });
+        const { discoverPluginFiles } = await import('../../../src/server/extensions/ExtensionManager.discovery.js');
+        await expect(discoverPluginFiles(['/broken', '/ok'])).resolves.toEqual([
+            '/ok/plugin/manifest.ts',
+        ]);
+    });
+});

package/dist/tests/server/extensions/ExtensionManager.guards.test.d.ts

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

package/dist/tests/server/extensions/ExtensionManager.guards.test.js

@@ -0,0 +1,51 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { isExtensionBuilder, isWorkflowContract, } from '../../../src/server/extensions/ExtensionManager.guards.js';
+describe('ExtensionManager.guards', () => {
+    beforeEach(() => {
+    });
+    it('recognizes a valid extension builder shape', () => {
+        expect(isExtensionBuilder({
+            id: 'plugin-id',
+            version: '1.0.0',
+            tools: [],
+        })).toBe(true);
+    });
+    it('rejects invalid extension builder values', () => {
+        expect(isExtensionBuilder(null)).toBe(false);
+        expect(isExtensionBuilder('plugin')).toBe(false);
+        expect(isExtensionBuilder({
+            id: 'plugin-id',
+            version: '1.0.0',
+            tools: 'not-an-array',
+        })).toBe(false);
+        expect(isExtensionBuilder({
+            id: 'plugin-id',
+            tools: [],
+        })).toBe(false);
+    });
+    it('recognizes a valid workflow contract shape', () => {
+        expect(isWorkflowContract({
+            kind: 'workflow-contract',
+            version: 1,
+            id: 'workflow-id',
+            displayName: 'Workflow',
+            build: () => ({ kind: 'sequence', id: 'root', steps: [] }),
+        })).toBe(true);
+    });
+    it('rejects invalid workflow contract values', () => {
+        expect(isWorkflowContract(undefined)).toBe(false);
+        expect(isWorkflowContract({
+            kind: 'workflow-contract',
+            version: 2,
+            id: 'workflow-id',
+            displayName: 'Workflow',
+            build: () => ({ kind: 'sequence', id: 'root', steps: [] }),
+        })).toBe(false);
+        expect(isWorkflowContract({
+            kind: 'workflow-contract',
+            version: 1,
+            id: 'workflow-id',
+            displayName: 'Workflow',
+        })).toBe(false);
+    });
+});

package/dist/tests/server/extensions/ExtensionManager.integrity.test.d.ts

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