@vwork/function-bundler 0.1.0

package/dist/bundle.d.ts

@@ -0,0 +1,22 @@
+import type { FunctionProjectSnapshot } from "./project.js";
+export interface BundleFunctionProjectInput {
+    readonly snapshot: FunctionProjectSnapshot;
+    readonly workspaceRoot: string;
+    readonly installDependencies?: boolean;
+    readonly maxBundleBytes?: number;
+    readonly installTimeoutMs?: number;
+}
+export interface BundleFunctionProjectResult {
+    readonly code: string;
+    readonly codeHash: string;
+    readonly codeSize: number;
+    readonly manifest: {
+        readonly entrypoint: string;
+        readonly source_tree_hash: string;
+        readonly source_file_count: number;
+        readonly source_size_bytes: number;
+        readonly builder: "vwork-esbuild";
+    };
+    readonly log: string;
+}
+export declare function bundleFunctionProject(input: BundleFunctionProjectInput): Promise<BundleFunctionProjectResult>;

package/dist/bundle.js

@@ -0,0 +1,119 @@
+import { createHash } from "node:crypto";
+import { execFile } from "node:child_process";
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { createRequire } from "node:module";
+import { promisify } from "node:util";
+import { build } from "esbuild";
+import { FUNCTION_PROJECT_LIMITS } from "./project.js";
+const execFileAsync = promisify(execFile);
+const require = createRequire(import.meta.url);
+export async function bundleFunctionProject(input) {
+    await writeSnapshot(input.workspaceRoot, input.snapshot);
+    let log = "";
+    if (input.installDependencies && hasPackageJson(input.snapshot)) {
+        log += await installSnapshotDependencies(input.workspaceRoot, input.installTimeoutMs);
+    }
+    const output = await build({
+        entryPoints: [join(input.workspaceRoot, input.snapshot.entrypoint)],
+        bundle: true,
+        write: false,
+        format: "esm",
+        platform: "browser",
+        target: "es2022",
+        mainFields: ["browser", "module", "main"],
+        conditions: ["worker", "browser", "import", "default"],
+        logLevel: "silent"
+    }).catch((error) => {
+        throw new Error(`BUNDLE_FAILED: ${error instanceof Error ? error.message : String(error)}`);
+    });
+    const code = normalizeDefaultExport(output.outputFiles[0]?.text ?? "");
+    validateWorkerOutput(code);
+    const codeSize = Buffer.byteLength(code, "utf8");
+    const maxBundleBytes = input.maxBundleBytes ?? FUNCTION_PROJECT_LIMITS.maxBundleBytes;
+    if (codeSize > maxBundleBytes) {
+        throw new Error(`BUNDLE_TOO_LARGE: ${codeSize}`);
+    }
+    return {
+        code,
+        codeHash: `sha256:${createHash("sha256").update(code).digest("hex")}`,
+        codeSize,
+        manifest: {
+            entrypoint: input.snapshot.entrypoint,
+            source_tree_hash: input.snapshot.treeHash,
+            source_file_count: input.snapshot.sourceFileCount,
+            source_size_bytes: input.snapshot.sourceSizeBytes,
+            builder: "vwork-esbuild"
+        },
+        log: `${log}Bundled ${input.snapshot.entrypoint} into dist/index.js (${codeSize} bytes)\n`
+    };
+}
+async function writeSnapshot(root, snapshot) {
+    for (const file of snapshot.files) {
+        const target = join(root, file.path);
+        await mkdir(dirname(target), { recursive: true });
+        await writeFile(target, file.content, "utf8");
+    }
+}
+function validateWorkerOutput(code) {
+    if (!/\bexport\s+default\b/.test(code) && !/\bexport\s*\{[^}]*\bdefault\b[^}]*\}/.test(code)) {
+        throw new Error("INVALID_WORKER_OUTPUT: missing default export");
+    }
+    if (!/\bfetch\s*\(/.test(code)) {
+        throw new Error("INVALID_WORKER_OUTPUT: missing fetch handler");
+    }
+    const executableCode = stripComments(code);
+    if (/\beval\s*\(|new\s+Function\s*\(/.test(executableCode)) {
+        throw new Error("INVALID_WORKER_OUTPUT: dynamic execution API found");
+    }
+    if (/\brequire\s*\(/.test(executableCode)) {
+        throw new Error("INVALID_WORKER_OUTPUT: CommonJS require call found");
+    }
+}
+function stripComments(code) {
+    return code
+        .replace(/\/\*[\s\S]*?\*\//g, "")
+        .replace(/(^|[^:])\/\/.*$/gm, "$1");
+}
+function normalizeDefaultExport(code) {
+    return code.replace(/export\s*\{\s*([A-Za-z_$][\w$]*)\s+as\s+default\s*\};?\s*$/m, "export default $1;\n");
+}
+function hasPackageJson(snapshot) {
+    return snapshot.files.some((file) => file.path === "package.json");
+}
+async function installSnapshotDependencies(workspaceRoot, timeoutMs) {
+    const pnpmBin = join(dirname(require.resolve("pnpm")), "bin", "pnpm.cjs");
+    try {
+        const { stdout, stderr } = await execFileAsync(process.execPath, [pnpmBin, "install", "--ignore-scripts"], {
+            cwd: workspaceRoot,
+            maxBuffer: 10 * 1024 * 1024,
+            ...(timeoutMs ? { timeout: timeoutMs } : {})
+        });
+        const output = summarizeInstallOutput(stdout, stderr);
+        return output
+            ? `Ran pnpm install --ignore-scripts in snapshot workspace\n${output}\n`
+            : "Ran pnpm install --ignore-scripts in snapshot workspace\n";
+    }
+    catch (error) {
+        const output = summarizeInstallError(error);
+        const detail = output ? ` ${output}` : "";
+        throw new Error(`DEPENDENCY_INSTALL_FAILED:${detail}`);
+    }
+}
+function summarizeInstallOutput(stdout, stderr) {
+    const output = `${stdout}\n${stderr}`.trim();
+    if (!output) {
+        return "";
+    }
+    return output.split(/\r?\n/).slice(-10).join("\n");
+}
+function summarizeInstallError(error) {
+    if (!error || typeof error !== "object") {
+        return String(error);
+    }
+    const stdout = "stdout" in error && typeof error.stdout === "string" ? error.stdout : "";
+    const stderr = "stderr" in error && typeof error.stderr === "string" ? error.stderr : "";
+    const message = "message" in error && typeof error.message === "string" ? error.message : "";
+    const output = summarizeInstallOutput(stdout, stderr);
+    return output || message;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./project.js";
+export * from "./bundle.js";

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from "./project.js";
+export * from "./bundle.js";

package/dist/project.d.ts

@@ -0,0 +1,28 @@
+export interface FunctionProjectFile {
+    readonly path: string;
+    readonly language: string;
+    readonly content: string;
+    readonly sizeBytes: number;
+}
+export interface FunctionProjectSnapshot {
+    readonly files: readonly FunctionProjectFile[];
+    readonly entrypoint: "src/index.ts" | "src/index.js";
+    readonly sourceFileCount: number;
+    readonly sourceSizeBytes: number;
+    readonly treeHash: string;
+}
+export interface FunctionProjectLimits {
+    readonly maxFiles: number;
+    readonly maxFileBytes: number;
+    readonly maxTotalBytes: number;
+    readonly maxBundleBytes: number;
+    readonly maxDependencies: number;
+}
+export interface CollectFunctionProjectOptions {
+    readonly include?: readonly string[];
+    readonly limits?: Partial<FunctionProjectLimits>;
+}
+export declare const FUNCTION_PROJECT_LIMITS: FunctionProjectLimits;
+export declare function validateSourcePath(path: string): string;
+export declare function collectFunctionProject(root: string, options?: CollectFunctionProjectOptions): Promise<FunctionProjectSnapshot>;
+export declare function resolveEntrypoint(files: readonly FunctionProjectFile[]): "src/index.ts" | "src/index.js";

package/dist/project.js

@@ -0,0 +1,172 @@
+import { createHash } from "node:crypto";
+import { readdir, readFile, stat } from "node:fs/promises";
+import { join, relative, sep } from "node:path";
+export const FUNCTION_PROJECT_LIMITS = {
+    maxFiles: 100,
+    maxFileBytes: 256 * 1024,
+    maxTotalBytes: 2 * 1024 * 1024,
+    maxBundleBytes: 5 * 1024 * 1024,
+    maxDependencies: 50
+};
+const defaultRootFiles = new Set(["package.json", "pnpm-lock.yaml", "tsconfig.json", "README.md"]);
+const excludedPrefixes = ["node_modules/", "dist/", ".git/", "coverage/", ".tmp/", ".cache/"];
+const dependencySections = ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"];
+export function validateSourcePath(path) {
+    const normalized = normalizeSourcePath(path);
+    if (isUnsafePath(normalized, path)) {
+        throw new Error(`INVALID_SOURCE_PATH: ${path}`);
+    }
+    if (isAlwaysExcludedPath(normalized) || isHiddenPath(normalized)) {
+        throw new Error(`INVALID_SOURCE_PATH: ${normalized}`);
+    }
+    return normalized;
+}
+export async function collectFunctionProject(root, options = {}) {
+    const limits = { ...FUNCTION_PROJECT_LIMITS, ...options.limits };
+    const files = [];
+    await walk(root, root, files, options.include ?? []);
+    files.sort((a, b) => a.path.localeCompare(b.path));
+    if (files.length > limits.maxFiles) {
+        throw new Error(`SOURCE_FILE_COUNT_EXCEEDED: ${files.length}`);
+    }
+    const total = files.reduce((sum, file) => sum + file.sizeBytes, 0);
+    if (total > limits.maxTotalBytes) {
+        throw new Error(`SOURCE_TOO_LARGE: ${total}`);
+    }
+    for (const file of files) {
+        if (file.sizeBytes > limits.maxFileBytes) {
+            throw new Error(`SOURCE_FILE_TOO_LARGE: ${file.path}`);
+        }
+    }
+    const dependencyCount = countProjectDependencies(files);
+    if (dependencyCount > limits.maxDependencies) {
+        throw new Error(`DEPENDENCY_COUNT_EXCEEDED: ${dependencyCount}`);
+    }
+    return {
+        files,
+        entrypoint: resolveEntrypoint(files),
+        sourceFileCount: files.length,
+        sourceSizeBytes: total,
+        treeHash: hashFiles(files)
+    };
+}
+export function resolveEntrypoint(files) {
+    const paths = new Set(files.map((file) => file.path));
+    if (paths.has("src/index.ts")) {
+        return "src/index.ts";
+    }
+    if (paths.has("src/index.js")) {
+        return "src/index.js";
+    }
+    throw new Error("MISSING_FUNCTION_ENTRYPOINT: expected src/index.ts or src/index.js");
+}
+async function walk(root, directory, output, include) {
+    for (const entry of await readdir(directory, { withFileTypes: true })) {
+        const absolute = join(directory, entry.name);
+        const relativePath = normalizeSourcePath(relative(root, absolute).split(sep).join("/"));
+        if (isUnsafePath(relativePath, relativePath) || isAlwaysExcludedPath(relativePath)) {
+            continue;
+        }
+        const explicitlyIncluded = include.some((pattern) => simpleGlobMatch(pattern, relativePath));
+        if (isHiddenPath(relativePath) && !explicitlyIncluded) {
+            continue;
+        }
+        if (entry.isDirectory()) {
+            if (shouldIncludeDirectory(relativePath, include)) {
+                await walk(root, absolute, output, include);
+            }
+            continue;
+        }
+        if (!entry.isFile() || !shouldIncludeFile(relativePath, include)) {
+            continue;
+        }
+        const content = await readFile(absolute, "utf8");
+        const sizeBytes = (await stat(absolute)).size;
+        output.push({ path: relativePath, language: languageForPath(relativePath), content, sizeBytes });
+    }
+}
+function normalizeSourcePath(path) {
+    return path.replaceAll("\\", "/").replace(/^\/+/, "");
+}
+function isUnsafePath(normalized, originalPath) {
+    return (!normalized ||
+        normalized.includes("\0") ||
+        normalized.startsWith("../") ||
+        normalized.includes("/../") ||
+        normalized === ".." ||
+        /^[a-zA-Z]:/.test(originalPath));
+}
+function isAlwaysExcludedPath(path) {
+    return path === ".env" || path.startsWith(".env.") || path.endsWith(".log") || excludedPrefixes.some((prefix) => path.startsWith(prefix));
+}
+function isHiddenPath(path) {
+    return path.split("/").some((part) => part.startsWith(".") && part !== ".");
+}
+function shouldIncludeDirectory(path, include) {
+    return (path === "src" ||
+        path.startsWith("src/") ||
+        include.some((pattern) => {
+            const prefix = globPrefix(pattern);
+            return prefix !== "" && (path === prefix || path.startsWith(`${prefix}/`));
+        }));
+}
+function shouldIncludeFile(path, include) {
+    return path.startsWith("src/") || defaultRootFiles.has(path) || include.some((pattern) => simpleGlobMatch(pattern, path));
+}
+function globPrefix(pattern) {
+    const index = pattern.indexOf("*");
+    const prefix = index >= 0 ? pattern.slice(0, index) : pattern;
+    return prefix.replace(/\/+$/, "");
+}
+function simpleGlobMatch(pattern, path) {
+    if (pattern.endsWith("/**")) {
+        return path.startsWith(pattern.slice(0, -3));
+    }
+    if (pattern.includes("*")) {
+        const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replaceAll("*", "[^/]*");
+        return new RegExp(`^${escaped}$`).test(path);
+    }
+    return pattern === path;
+}
+function languageForPath(path) {
+    if (path.endsWith(".ts")) {
+        return "typescript";
+    }
+    if (path.endsWith(".js")) {
+        return "javascript";
+    }
+    if (path.endsWith(".json")) {
+        return "json";
+    }
+    if (path.endsWith(".md")) {
+        return "markdown";
+    }
+    if (path.endsWith(".yaml") || path.endsWith(".yml")) {
+        return "yaml";
+    }
+    return "text";
+}
+function countProjectDependencies(files) {
+    const packageJsonFile = files.find((file) => file.path === "package.json");
+    if (!packageJsonFile) {
+        return 0;
+    }
+    const packageJson = JSON.parse(packageJsonFile.content);
+    return dependencySections.reduce((count, section) => {
+        const value = packageJson[section];
+        if (!value || typeof value !== "object" || Array.isArray(value)) {
+            return count;
+        }
+        return count + Object.keys(value).length;
+    }, 0);
+}
+function hashFiles(files) {
+    const hash = createHash("sha256");
+    for (const file of files) {
+        hash.update(file.path);
+        hash.update("\0");
+        hash.update(file.content);
+        hash.update("\0");
+    }
+    return `sha256:${hash.digest("hex")}`;
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@vwork/function-bundler",
+  "version": "0.1.0",
+  "type": "module",
+  "files": [
+    "dist/*.js",
+    "dist/*.d.ts",
+    "package.json"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "dependencies": {
+    "esbuild": "^0.25.5",
+    "pnpm": "10.18.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "tsx": "^4.19.2",
+    "typescript": "^5.9.3"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "tsx --test src/test/*.test.ts",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  }
+}