@workflow/builders 5.0.1 → 5.0.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,2 @@
1
+ export {};
2
+ //# sourceMappingURL=flow-bundle-safety.build.test.d.ts.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"flow-bundle-safety.build.test.d.ts","sourceRoot":"","sources":["../src/flow-bundle-safety.build.test.ts"],"names":[],"mappings":""}
@@ -0,0 +1,239 @@
1
+ import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
2
+ import { dirname, join, resolve } from 'node:path';
3
+ import { createContext, runInContext } from 'node:vm';
4
+ import { afterEach, describe, expect, it } from 'vitest';
5
+ import { BaseBuilder } from './base-builder.js';
6
+ import { ALLOW_UNSAFE_FLOW_BUNDLE_ENV } from './flow-bundle-safety.js';
7
+ /**
8
+ * End-to-end coverage for the sandbox-safety check: these build a real
9
+ * workflow bundle so the assertions run against esbuild's actual CJS output
10
+ * and metafile, not a hand-written approximation of them.
11
+ */
12
+ class TestBuilder extends BaseBuilder {
13
+ async build() { }
14
+ createWorkflowBundle(inputFile, outfile, discoveredEntries) {
15
+ return this.createWorkflowsBundle({
16
+ inputFiles: [inputFile],
17
+ outfile,
18
+ bundleFinalOutput: false,
19
+ discoveredEntries,
20
+ });
21
+ }
22
+ }
23
+ describe('flow bundle sandbox safety (esbuild)', () => {
24
+ const repoRoot = resolve(import.meta.dirname, '../../..');
25
+ const outputDirs = [];
26
+ afterEach(() => {
27
+ for (const outputDir of outputDirs) {
28
+ rmSync(outputDir, { recursive: true, force: true });
29
+ }
30
+ outputDirs.length = 0;
31
+ delete process.env[ALLOW_UNSAFE_FLOW_BUNDLE_ENV];
32
+ });
33
+ /**
34
+ * Keep fixtures beneath this package so their workspace dependencies resolve
35
+ * exactly as they do for a real consumer workflow.
36
+ */
37
+ function createFixture(files) {
38
+ const outputDir = mkdtempSync(join(import.meta.dirname, '.flow-safety-'));
39
+ outputDirs.push(outputDir);
40
+ for (const [relativePath, contents] of Object.entries(files)) {
41
+ const absolutePath = join(outputDir, relativePath);
42
+ mkdirSync(dirname(absolutePath), { recursive: true });
43
+ writeFileSync(absolutePath, contents, 'utf8');
44
+ }
45
+ return outputDir;
46
+ }
47
+ function buildWorkflow(outputDir) {
48
+ const inputFile = join(outputDir, 'workflow.ts');
49
+ const config = {
50
+ buildTarget: 'standalone',
51
+ workingDir: outputDir,
52
+ projectRoot: repoRoot,
53
+ moduleSpecifierRoot: repoRoot,
54
+ dirs: ['.'],
55
+ stepsBundlePath: join(outputDir, 'steps.js'),
56
+ workflowsBundlePath: join(outputDir, 'workflow.js'),
57
+ webhookBundlePath: join(outputDir, 'webhook.js'),
58
+ sourcemap: false,
59
+ suppressCreateWorkflowsBundleLogs: true,
60
+ suppressCreateWorkflowsBundleWarnings: true,
61
+ };
62
+ const discoveredEntries = {
63
+ discoveredSteps: new Set(),
64
+ discoveredWorkflows: new Set([inputFile]),
65
+ discoveredSerdeFiles: new Set(),
66
+ };
67
+ return new TestBuilder(config).createWorkflowBundle(inputFile, config.workflowsBundlePath, discoveredEntries);
68
+ }
69
+ function packageFiles(name, contents) {
70
+ return {
71
+ [`node_modules/${name}/package.json`]: JSON.stringify({
72
+ name,
73
+ version: '1.0.0',
74
+ main: 'index.js',
75
+ }),
76
+ [`node_modules/${name}/index.js`]: contents,
77
+ };
78
+ }
79
+ it('builds a workflow whose dependency only uses bundled CommonJS', async () => {
80
+ const outputDir = createFixture({
81
+ ...packageFiles('safe-pkg', [
82
+ "const inner = require('./inner.js');",
83
+ "const isNode = typeof require === 'function';",
84
+ 'module.exports.greet = () => `${inner.name}:${isNode}`;',
85
+ ].join('\n')),
86
+ 'node_modules/safe-pkg/inner.js': "module.exports = { name: 'inner' };",
87
+ 'workflow.ts': [
88
+ "import { greet } from 'safe-pkg';",
89
+ 'export async function wf() { "use workflow"; return greet(); }',
90
+ ].join('\n'),
91
+ });
92
+ const { interimBundleText } = await buildWorkflow(outputDir);
93
+ // `require('./inner.js')` is rewritten to esbuild's `require_inner()`
94
+ // wrapper and `typeof require` never throws, so neither is a violation.
95
+ expect(interimBundleText).toContain('require_inner');
96
+ expect(interimBundleText).toContain('typeof require');
97
+ });
98
+ it('builds a workflow that reaches a guarded optional-dependency probe', async () => {
99
+ // The shape framer-motion ships: `require` is expected to be missing and
100
+ // the resulting ReferenceError is caught, so the bundle still loads.
101
+ const outputDir = createFixture({
102
+ 'optional-probe.ts': [
103
+ 'export let isValidProp: ((key: string) => boolean) | undefined;',
104
+ 'try {',
105
+ ' isValidProp = require("@emotion/is-prop-valid").default;',
106
+ '} catch {',
107
+ ' // optional dependency, fall back to the default',
108
+ '}',
109
+ ].join('\n'),
110
+ 'workflow.ts': [
111
+ "import { isValidProp } from './optional-probe.js';",
112
+ 'export async function wf() { "use workflow"; return Boolean(isValidProp); }',
113
+ ].join('\n'),
114
+ });
115
+ const { interimBundleText } = await buildWorkflow(outputDir);
116
+ expect(interimBundleText).toContain('@emotion/is-prop-valid');
117
+ });
118
+ it('builds a workflow whose dependency only requires a builtin behind a typeof check', async () => {
119
+ // tweetnacl's shape: `require("crypto")` is external in the bundle, but it
120
+ // only runs when `require` exists, which it never does in the sandbox.
121
+ const outputDir = createFixture({
122
+ ...packageFiles('guarded-pkg', [
123
+ 'var crypto;',
124
+ "if (typeof self !== 'undefined' && self.crypto) {",
125
+ ' crypto = self.crypto;',
126
+ "} else if (typeof require !== 'undefined') {",
127
+ " crypto = require('crypto');",
128
+ '}',
129
+ 'module.exports.hasCrypto = () => Boolean(crypto);',
130
+ ].join('\n')),
131
+ ...packageFiles('wrapper-pkg', "module.exports = require('guarded-pkg');"),
132
+ 'workflow.ts': [
133
+ "import { hasCrypto } from 'wrapper-pkg';",
134
+ 'export async function wf() { "use workflow"; return hasCrypto(); }',
135
+ ].join('\n'),
136
+ });
137
+ const { interimBundleText } = await buildWorkflow(outputDir);
138
+ expect(interimBundleText).toContain('require("crypto")');
139
+ const context = createContext({ module: { exports: {} }, exports: {} });
140
+ expect(() => runInContext(interimBundleText, context)).not.toThrow();
141
+ });
142
+ it('fails when a transitive dependency pulls in a Node.js builtin', async () => {
143
+ const outputDir = createFixture({
144
+ ...packageFiles('leaky-pkg', [
145
+ "const fs = require('node:fs');",
146
+ "module.exports.readIt = () => fs.readFileSync('x');",
147
+ ].join('\n')),
148
+ ...packageFiles('wrapper-pkg', [
149
+ "const leaky = require('leaky-pkg');",
150
+ 'module.exports.go = () => leaky.readIt();',
151
+ ].join('\n')),
152
+ 'workflow.ts': [
153
+ "import { go } from 'wrapper-pkg';",
154
+ 'export async function wf() { "use workflow"; return go(); }',
155
+ ].join('\n'),
156
+ });
157
+ const error = await buildWorkflow(outputDir).catch((e) => e);
158
+ expect(error).toBeInstanceOf(Error);
159
+ const message = error.message;
160
+ expect(message).toContain('node:fs');
161
+ expect(message).toContain('node_modules/leaky-pkg/index.js');
162
+ // The chain names the user file that started it.
163
+ expect(message).toContain('workflow.ts');
164
+ expect(message).toContain('node_modules/wrapper-pkg/index.js');
165
+ expect(message).toContain('use step');
166
+ });
167
+ it('fails when a builtin arrives through a re-export', async () => {
168
+ const outputDir = createFixture({
169
+ ...packageFiles('reexported-pkg', [
170
+ "const os = require('node:os');",
171
+ 'module.exports.platform = () => os.platform();',
172
+ ].join('\n')),
173
+ 'reexport.ts': "export * from 'reexported-pkg';",
174
+ 'workflow.ts': [
175
+ "import { platform } from './reexport.js';",
176
+ 'export async function wf() { "use workflow"; return platform(); }',
177
+ ].join('\n'),
178
+ });
179
+ const error = await buildWorkflow(outputDir).catch((e) => e);
180
+ expect(error).toBeInstanceOf(Error);
181
+ expect(error.message).toContain('node:os');
182
+ expect(error.message).toContain('reexport.ts');
183
+ });
184
+ it('fails on a user-written dynamic require in workflow code', async () => {
185
+ const outputDir = createFixture({
186
+ 'workflow.ts': [
187
+ 'export async function wf(name: string) {',
188
+ ' "use workflow";',
189
+ ' return require(name).value;',
190
+ '}',
191
+ ].join('\n'),
192
+ });
193
+ const error = await buildWorkflow(outputDir).catch((e) => e);
194
+ expect(error).toBeInstanceOf(Error);
195
+ const message = error.message;
196
+ expect(message).toContain('Unresolved require() calls');
197
+ expect(message).toContain('require(name)');
198
+ });
199
+ it('fails on a dynamic require inside a bundled dependency', async () => {
200
+ const outputDir = createFixture({
201
+ ...packageFiles('lazy-pkg', [
202
+ 'module.exports.load = (name) => require(name);',
203
+ "module.exports.ok = () => 'ok';",
204
+ ].join('\n')),
205
+ 'workflow.ts': [
206
+ "import { load } from 'lazy-pkg';",
207
+ 'export async function wf() { "use workflow"; return load("x"); }',
208
+ ].join('\n'),
209
+ });
210
+ const error = await buildWorkflow(outputDir).catch((e) => e);
211
+ expect(error).toBeInstanceOf(Error);
212
+ expect(error.message).toContain('node_modules/lazy-pkg/index.js');
213
+ });
214
+ it('downgrades to a warning behind the escape hatch', async () => {
215
+ process.env[ALLOW_UNSAFE_FLOW_BUNDLE_ENV] = '1';
216
+ const outputDir = createFixture({
217
+ ...packageFiles('leaky-pkg', [
218
+ "const fs = require('node:fs');",
219
+ "module.exports.readIt = () => fs.readFileSync('x');",
220
+ ].join('\n')),
221
+ ...packageFiles('wrapper-pkg', [
222
+ "const leaky = require('leaky-pkg');",
223
+ 'module.exports.go = () => leaky.readIt();',
224
+ ].join('\n')),
225
+ 'workflow.ts': [
226
+ "import { go } from 'wrapper-pkg';",
227
+ 'export async function wf() { "use workflow"; return go(); }',
228
+ ].join('\n'),
229
+ });
230
+ const { interimBundleText } = await buildWorkflow(outputDir);
231
+ expect(interimBundleText).toContain('require("node:fs")');
232
+ // ...and that bundle is exactly what the check exists to stop: evaluating
233
+ // it the way the runtime does throws before any workflow can start.
234
+ // Mirrors the workflow sandbox: `module`/`exports` shims, no `require`.
235
+ const context = createContext({ module: { exports: {} }, exports: {} });
236
+ expect(() => runInContext(interimBundleText, context)).toThrow(/require is not defined/);
237
+ });
238
+ });
239
+ //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flow-bundle-safety.build.test.js","sourceRoot":"","sources":["../src/flow-bundle-safety.build.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';\nimport { dirname, join, resolve } from 'node:path';\nimport { createContext, runInContext } from 'node:vm';\nimport { afterEach, describe, expect, it } from 'vitest';\nimport { BaseBuilder, type DiscoveredEntries } from './base-builder.js';\nimport { ALLOW_UNSAFE_FLOW_BUNDLE_ENV } from './flow-bundle-safety.js';\nimport type { StandaloneConfig } from './types.js';\n\n/**\n * End-to-end coverage for the sandbox-safety check: these build a real\n * workflow bundle so the assertions run against esbuild's actual CJS output\n * and metafile, not a hand-written approximation of them.\n */\n\nclass TestBuilder extends BaseBuilder {\n  async build(): Promise<void> {}\n\n  createWorkflowBundle(\n    inputFile: string,\n    outfile: string,\n    discoveredEntries: DiscoveredEntries\n  ) {\n    return this.createWorkflowsBundle({\n      inputFiles: [inputFile],\n      outfile,\n      bundleFinalOutput: false,\n      discoveredEntries,\n    });\n  }\n}\n\ndescribe('flow bundle sandbox safety (esbuild)', () => {\n  const repoRoot = resolve(import.meta.dirname, '../../..');\n  const outputDirs: string[] = [];\n\n  afterEach(() => {\n    for (const outputDir of outputDirs) {\n      rmSync(outputDir, { recursive: true, force: true });\n    }\n    outputDirs.length = 0;\n    delete process.env[ALLOW_UNSAFE_FLOW_BUNDLE_ENV];\n  });\n\n  /**\n   * Keep fixtures beneath this package so their workspace dependencies resolve\n   * exactly as they do for a real consumer workflow.\n   */\n  function createFixture(files: Record<string, string>): string {\n    const outputDir = mkdtempSync(join(import.meta.dirname, '.flow-safety-'));\n    outputDirs.push(outputDir);\n    for (const [relativePath, contents] of Object.entries(files)) {\n      const absolutePath = join(outputDir, relativePath);\n      mkdirSync(dirname(absolutePath), { recursive: true });\n      writeFileSync(absolutePath, contents, 'utf8');\n    }\n    return outputDir;\n  }\n\n  function buildWorkflow(outputDir: string) {\n    const inputFile = join(outputDir, 'workflow.ts');\n    const config: StandaloneConfig = {\n      buildTarget: 'standalone',\n      workingDir: outputDir,\n      projectRoot: repoRoot,\n      moduleSpecifierRoot: repoRoot,\n      dirs: ['.'],\n      stepsBundlePath: join(outputDir, 'steps.js'),\n      workflowsBundlePath: join(outputDir, 'workflow.js'),\n      webhookBundlePath: join(outputDir, 'webhook.js'),\n      sourcemap: false,\n      suppressCreateWorkflowsBundleLogs: true,\n      suppressCreateWorkflowsBundleWarnings: true,\n    };\n    const discoveredEntries: DiscoveredEntries = {\n      discoveredSteps: new Set(),\n      discoveredWorkflows: new Set([inputFile]),\n      discoveredSerdeFiles: new Set(),\n    };\n    return new TestBuilder(config).createWorkflowBundle(\n      inputFile,\n      config.workflowsBundlePath,\n      discoveredEntries\n    );\n  }\n\n  function packageFiles(\n    name: string,\n    contents: string\n  ): Record<string, string> {\n    return {\n      [`node_modules/${name}/package.json`]: JSON.stringify({\n        name,\n        version: '1.0.0',\n        main: 'index.js',\n      }),\n      [`node_modules/${name}/index.js`]: contents,\n    };\n  }\n\n  it('builds a workflow whose dependency only uses bundled CommonJS', async () => {\n    const outputDir = createFixture({\n      ...packageFiles(\n        'safe-pkg',\n        [\n          \"const inner = require('./inner.js');\",\n          \"const isNode = typeof require === 'function';\",\n          'module.exports.greet = () => `${inner.name}:${isNode}`;',\n        ].join('\\n')\n      ),\n      'node_modules/safe-pkg/inner.js': \"module.exports = { name: 'inner' };\",\n      'workflow.ts': [\n        \"import { greet } from 'safe-pkg';\",\n        'export async function wf() { \"use workflow\"; return greet(); }',\n      ].join('\\n'),\n    });\n\n    const { interimBundleText } = await buildWorkflow(outputDir);\n\n    // `require('./inner.js')` is rewritten to esbuild's `require_inner()`\n    // wrapper and `typeof require` never throws, so neither is a violation.\n    expect(interimBundleText).toContain('require_inner');\n    expect(interimBundleText).toContain('typeof require');\n  });\n\n  it('builds a workflow that reaches a guarded optional-dependency probe', async () => {\n    // The shape framer-motion ships: `require` is expected to be missing and\n    // the resulting ReferenceError is caught, so the bundle still loads.\n    const outputDir = createFixture({\n      'optional-probe.ts': [\n        'export let isValidProp: ((key: string) => boolean) | undefined;',\n        'try {',\n        '  isValidProp = require(\"@emotion/is-prop-valid\").default;',\n        '} catch {',\n        '  // optional dependency, fall back to the default',\n        '}',\n      ].join('\\n'),\n      'workflow.ts': [\n        \"import { isValidProp } from './optional-probe.js';\",\n        'export async function wf() { \"use workflow\"; return Boolean(isValidProp); }',\n      ].join('\\n'),\n    });\n\n    const { interimBundleText } = await buildWorkflow(outputDir);\n\n    expect(interimBundleText).toContain('@emotion/is-prop-valid');\n  });\n\n  it('builds a workflow whose dependency only requires a builtin behind a typeof check', async () => {\n    // tweetnacl's shape: `require(\"crypto\")` is external in the bundle, but it\n    // only runs when `require` exists, which it never does in the sandbox.\n    const outputDir = createFixture({\n      ...packageFiles(\n        'guarded-pkg',\n        [\n          'var crypto;',\n          \"if (typeof self !== 'undefined' && self.crypto) {\",\n          '  crypto = self.crypto;',\n          \"} else if (typeof require !== 'undefined') {\",\n          \"  crypto = require('crypto');\",\n          '}',\n          'module.exports.hasCrypto = () => Boolean(crypto);',\n        ].join('\\n')\n      ),\n      ...packageFiles(\n        'wrapper-pkg',\n        \"module.exports = require('guarded-pkg');\"\n      ),\n      'workflow.ts': [\n        \"import { hasCrypto } from 'wrapper-pkg';\",\n        'export async function wf() { \"use workflow\"; return hasCrypto(); }',\n      ].join('\\n'),\n    });\n\n    const { interimBundleText } = await buildWorkflow(outputDir);\n\n    expect(interimBundleText).toContain('require(\"crypto\")');\n    const context = createContext({ module: { exports: {} }, exports: {} });\n    expect(() =>\n      runInContext(interimBundleText as string, context)\n    ).not.toThrow();\n  });\n\n  it('fails when a transitive dependency pulls in a Node.js builtin', async () => {\n    const outputDir = createFixture({\n      ...packageFiles(\n        'leaky-pkg',\n        [\n          \"const fs = require('node:fs');\",\n          \"module.exports.readIt = () => fs.readFileSync('x');\",\n        ].join('\\n')\n      ),\n      ...packageFiles(\n        'wrapper-pkg',\n        [\n          \"const leaky = require('leaky-pkg');\",\n          'module.exports.go = () => leaky.readIt();',\n        ].join('\\n')\n      ),\n      'workflow.ts': [\n        \"import { go } from 'wrapper-pkg';\",\n        'export async function wf() { \"use workflow\"; return go(); }',\n      ].join('\\n'),\n    });\n\n    const error = await buildWorkflow(outputDir).catch((e: Error) => e);\n\n    expect(error).toBeInstanceOf(Error);\n    const message = (error as Error).message;\n    expect(message).toContain('node:fs');\n    expect(message).toContain('node_modules/leaky-pkg/index.js');\n    // The chain names the user file that started it.\n    expect(message).toContain('workflow.ts');\n    expect(message).toContain('node_modules/wrapper-pkg/index.js');\n    expect(message).toContain('use step');\n  });\n\n  it('fails when a builtin arrives through a re-export', async () => {\n    const outputDir = createFixture({\n      ...packageFiles(\n        'reexported-pkg',\n        [\n          \"const os = require('node:os');\",\n          'module.exports.platform = () => os.platform();',\n        ].join('\\n')\n      ),\n      'reexport.ts': \"export * from 'reexported-pkg';\",\n      'workflow.ts': [\n        \"import { platform } from './reexport.js';\",\n        'export async function wf() { \"use workflow\"; return platform(); }',\n      ].join('\\n'),\n    });\n\n    const error = await buildWorkflow(outputDir).catch((e: Error) => e);\n\n    expect(error).toBeInstanceOf(Error);\n    expect((error as Error).message).toContain('node:os');\n    expect((error as Error).message).toContain('reexport.ts');\n  });\n\n  it('fails on a user-written dynamic require in workflow code', async () => {\n    const outputDir = createFixture({\n      'workflow.ts': [\n        'export async function wf(name: string) {',\n        '  \"use workflow\";',\n        '  return require(name).value;',\n        '}',\n      ].join('\\n'),\n    });\n\n    const error = await buildWorkflow(outputDir).catch((e: Error) => e);\n\n    expect(error).toBeInstanceOf(Error);\n    const message = (error as Error).message;\n    expect(message).toContain('Unresolved require() calls');\n    expect(message).toContain('require(name)');\n  });\n\n  it('fails on a dynamic require inside a bundled dependency', async () => {\n    const outputDir = createFixture({\n      ...packageFiles(\n        'lazy-pkg',\n        [\n          'module.exports.load = (name) => require(name);',\n          \"module.exports.ok = () => 'ok';\",\n        ].join('\\n')\n      ),\n      'workflow.ts': [\n        \"import { load } from 'lazy-pkg';\",\n        'export async function wf() { \"use workflow\"; return load(\"x\"); }',\n      ].join('\\n'),\n    });\n\n    const error = await buildWorkflow(outputDir).catch((e: Error) => e);\n\n    expect(error).toBeInstanceOf(Error);\n    expect((error as Error).message).toContain(\n      'node_modules/lazy-pkg/index.js'\n    );\n  });\n\n  it('downgrades to a warning behind the escape hatch', async () => {\n    process.env[ALLOW_UNSAFE_FLOW_BUNDLE_ENV] = '1';\n    const outputDir = createFixture({\n      ...packageFiles(\n        'leaky-pkg',\n        [\n          \"const fs = require('node:fs');\",\n          \"module.exports.readIt = () => fs.readFileSync('x');\",\n        ].join('\\n')\n      ),\n      ...packageFiles(\n        'wrapper-pkg',\n        [\n          \"const leaky = require('leaky-pkg');\",\n          'module.exports.go = () => leaky.readIt();',\n        ].join('\\n')\n      ),\n      'workflow.ts': [\n        \"import { go } from 'wrapper-pkg';\",\n        'export async function wf() { \"use workflow\"; return go(); }',\n      ].join('\\n'),\n    });\n\n    const { interimBundleText } = await buildWorkflow(outputDir);\n\n    expect(interimBundleText).toContain('require(\"node:fs\")');\n\n    // ...and that bundle is exactly what the check exists to stop: evaluating\n    // it the way the runtime does throws before any workflow can start.\n    // Mirrors the workflow sandbox: `module`/`exports` shims, no `require`.\n    const context = createContext({ module: { exports: {} }, exports: {} });\n    expect(() => runInContext(interimBundleText as string, context)).toThrow(\n      /require is not defined/\n    );\n  });\n});\n"]}
@@ -0,0 +1,149 @@
1
+ /**
2
+ * Sandbox-safety checks for the workflow ("flow") bundle.
3
+ *
4
+ * The flow bundle is evaluated with `vm.runInContext()` inside a sandbox that
5
+ * deliberately has no `require`: `createContext()` in
6
+ * `packages/core/src/vm/index.ts` only shims `module` and `exports`. esbuild
7
+ * emits the flow bundle as CJS, which means:
8
+ *
9
+ * - every import that stays **external** turns into a literal
10
+ * `require("<specifier>")` call, and
11
+ * - every `require(...)` esbuild could not statically resolve is copied into
12
+ * the output verbatim.
13
+ *
14
+ * Both throw `ReferenceError: require is not defined` as soon as they are
15
+ * evaluated. External imports are the worst case: esbuild hoists them to the
16
+ * top level of the bundle, so the whole bundle fails to load and *every*
17
+ * workflow in the deployment breaks, not just the code path that needed the
18
+ * module.
19
+ *
20
+ * The exception is a `require()` inside a `try` block. That is how packages
21
+ * probe for an optional dependency (framer-motion ships one, and esbuild
22
+ * externalizes an unresolvable `require()` precisely when it is wrapped that
23
+ * way), and the sandbox's `ReferenceError` lands in the `catch`, so the bundle
24
+ * still loads. Those are left alone, as are calls behind a `typeof require`
25
+ * check (`if (typeof require !== "undefined") …`, esbuild's own ESM
26
+ * `__require` shim), which never run in the sandbox. Both are decided on the
27
+ * parsed syntax tree: a check only excuses the branches it provably skips.
28
+ *
29
+ * Those failures used to be silent at build time.
30
+ * `createNodeModuleErrorPlugin()` marks Node.js/Bun builtins as external and
31
+ * only reports the ones it can trace back to an `import … from "pkg"`
32
+ * statement inside user code, so transitively imported builtins (and
33
+ * re-exported ones, and side-effect-only imports) shipped a bundle that could
34
+ * never run. This module is the backstop that turns those into build errors.
35
+ */
36
+ import * as esbuild from 'esbuild';
37
+ /**
38
+ * Set to `1` to downgrade flow bundle safety failures to warnings.
39
+ *
40
+ * The bundle still crashes at runtime if the offending code is reached; this
41
+ * only exists as an escape hatch for the rare case where the detection is
42
+ * wrong (for example a `require()` that is provably unreachable, or guarded in
43
+ * a way the `try`/`catch` and `typeof require` checks do not see).
44
+ */
45
+ export declare const ALLOW_UNSAFE_FLOW_BUNDLE_ENV = "WORKFLOW_ALLOW_UNSAFE_FLOW_BUNDLE";
46
+ /** An import esbuild left external, which becomes a top-level `require()`. */
47
+ export interface ExternalImportViolation {
48
+ /** The externalized specifier, e.g. `node:fs`. */
49
+ specifier: string;
50
+ /** Bundle inputs that imported it, as metafile keys. */
51
+ importers: string[];
52
+ /**
53
+ * Import chain from the bundle entry down to the first importer, with the
54
+ * synthetic virtual entry removed. Empty when it cannot be reconstructed.
55
+ */
56
+ importChain: string[];
57
+ /** Whether the specifier names a Node.js or Bun built-in module. */
58
+ isRuntimeBuiltin: boolean;
59
+ }
60
+ /** A `require(...)` call left in the bundle that resolves to the global. */
61
+ export interface DynamicRequireViolation {
62
+ /** Bundle module the call belongs to, when esbuild labelled the section. */
63
+ module?: string;
64
+ /** 1-based line within the flow bundle. */
65
+ line: number;
66
+ /** 1-based column within the flow bundle. */
67
+ column: number;
68
+ /** The requested specifier when the call site passes a string literal. */
69
+ specifier?: string;
70
+ /** Trimmed source line, for context. */
71
+ snippet: string;
72
+ }
73
+ export interface FlowBundleSafetyReport {
74
+ externalImports: ExternalImportViolation[];
75
+ dynamicRequires: DynamicRequireViolation[];
76
+ }
77
+ export declare function isFlowBundleSafetyReportEmpty(report: FlowBundleSafetyReport): boolean;
78
+ /** A `//` comment that starts at column 0 — esbuild's module section marker. */
79
+ export interface BannerComment {
80
+ /** Offset of the `//`. */
81
+ index: number;
82
+ /** Comment text with the leading `// ` removed. */
83
+ text: string;
84
+ }
85
+ export interface MaskResult {
86
+ /**
87
+ * `code` with every comment, string literal, template literal chunk and
88
+ * regex literal replaced by spaces. Offsets and line breaks are preserved,
89
+ * so positions map 1:1 back onto the original text. Template *substitutions*
90
+ * (`${…}`) are left intact because they contain real code.
91
+ */
92
+ masked: string;
93
+ /** Column-0 line comments, in source order. */
94
+ banners: BannerComment[];
95
+ }
96
+ /**
97
+ * Blanks out every non-code region of `code` so the result can be scanned with
98
+ * plain string matching without tripping over `require` inside comments,
99
+ * strings or regexes.
100
+ */
101
+ export declare function maskNonCodeRegions(code: string): MaskResult;
102
+ /** A `require` reference found in the bundle text. */
103
+ export interface RequireSite extends DynamicRequireViolation {
104
+ /**
105
+ * The reference sits inside a `try { … } catch` block, so the sandbox's
106
+ * `ReferenceError` is caught, or behind a `typeof require` check, so it never
107
+ * runs. Either way the bundle still loads.
108
+ */
109
+ guarded: boolean;
110
+ }
111
+ /**
112
+ * Finds every `require` reference in `bundleText` that will be evaluated at
113
+ * runtime, flagging the ones a `try` block protects.
114
+ *
115
+ * This is a cheap pre-filter: it runs on every build, so it must be fast and
116
+ * must not flag the patterns that show up in ordinary bundled output
117
+ * (`typeof require`, `__require`, `require_pkg()`, `obj.require`). Anything it
118
+ * does flag is confirmed with esbuild's own scope analysis before it fails a
119
+ * build — see {@link probeFreeRequireReferences}.
120
+ */
121
+ export declare function findRequireSites(bundleText: string, knownModules?: Set<string>): RequireSite[];
122
+ /** The unguarded subset of {@link findRequireSites}. */
123
+ export declare function findDynamicRequireCandidates(bundleText: string, knownModules?: Set<string>): DynamicRequireViolation[];
124
+ /**
125
+ * Collects the imports esbuild left external. In a CJS bundle each of these is
126
+ * emitted as a top-level `require("…")`.
127
+ */
128
+ export declare function collectExternalImports(metafile: esbuild.Metafile): ExternalImportViolation[];
129
+ /**
130
+ * Inspects a finished flow bundle for constructs the workflow sandbox cannot
131
+ * evaluate.
132
+ */
133
+ export declare function analyzeFlowBundleSafety({ bundleText, metafile, }: {
134
+ bundleText: string;
135
+ metafile?: esbuild.Metafile;
136
+ }): Promise<FlowBundleSafetyReport>;
137
+ export declare function formatFlowBundleSafetyReport(report: FlowBundleSafetyReport): string;
138
+ /**
139
+ * Fails the build when the flow bundle contains anything the workflow sandbox
140
+ * cannot evaluate.
141
+ *
142
+ * @param warn - Sink for the downgraded message when the escape hatch is set.
143
+ */
144
+ export declare function assertFlowBundleIsSandboxSafe({ bundleText, metafile, warn, }: {
145
+ bundleText: string;
146
+ metafile?: esbuild.Metafile;
147
+ warn?: (message: string) => void;
148
+ }): Promise<FlowBundleSafetyReport>;
149
+ //# sourceMappingURL=flow-bundle-safety.d.ts.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"flow-bundle-safety.d.ts","sourceRoot":"","sources":["../src/flow-bundle-safety.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAIH,OAAO,KAAK,OAAO,MAAM,SAAS,CAAC;AAGnC;;;;;;;GAOG;AACH,eAAO,MAAM,4BAA4B,sCAAsC,CAAC;AAUhF,8EAA8E;AAC9E,MAAM,WAAW,uBAAuB;IACtC,kDAAkD;IAClD,SAAS,EAAE,MAAM,CAAC;IAClB,wDAAwD;IACxD,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB;;;OAGG;IACH,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,oEAAoE;IACpE,gBAAgB,EAAE,OAAO,CAAC;CAC3B;AAED,4EAA4E;AAC5E,MAAM,WAAW,uBAAuB;IACtC,4EAA4E;IAC5E,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,2CAA2C;IAC3C,IAAI,EAAE,MAAM,CAAC;IACb,6CAA6C;IAC7C,MAAM,EAAE,MAAM,CAAC;IACf,0EAA0E;IAC1E,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,wCAAwC;IACxC,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,sBAAsB;IACrC,eAAe,EAAE,uBAAuB,EAAE,CAAC;IAC3C,eAAe,EAAE,uBAAuB,EAAE,CAAC;CAC5C;AAED,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,sBAAsB,GAC7B,OAAO,CAIT;AAMD,gFAAgF;AAChF,MAAM,WAAW,aAAa;IAC5B,0BAA0B;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,mDAAmD;IACnD,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,UAAU;IACzB;;;;;OAKG;IACH,MAAM,EAAE,MAAM,CAAC;IACf,+CAA+C;IAC/C,OAAO,EAAE,aAAa,EAAE,CAAC;CAC1B;AAgPD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAuF3D;AA2UD,sDAAsD;AACtD,MAAM,WAAW,WAAY,SAAQ,uBAAuB;IAC1D;;;;OAIG;IACH,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,MAAM,EAClB,YAAY,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,GACzB,WAAW,EAAE,CAqDf;AAED,wDAAwD;AACxD,wBAAgB,4BAA4B,CAC1C,UAAU,EAAE,MAAM,EAClB,YAAY,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,GACzB,uBAAuB,EAAE,CAI3B;AAwLD;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,OAAO,CAAC,QAAQ,GACzB,uBAAuB,EAAE,CAe3B;AAUD;;;GAGG;AACH,wBAAsB,uBAAuB,CAAC,EAC5C,UAAU,EACV,QAAQ,GACT,EAAE;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAC;CAC7B,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAsClC;AASD,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,sBAAsB,GAC7B,MAAM,CAoDR;AAsBD;;;;;GAKG;AACH,wBAAsB,6BAA6B,CAAC,EAClD,UAAU,EACV,QAAQ,EACR,IAAiD,GAClD,EAAE;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAC;IAC5B,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CAClC,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAalC"}