create-nodejs-fn 0.0.1

package/README.md

@@ -0,0 +1,289 @@
+# Create NodeJS Fn
+
+
+> **⚡ A crazy Vite plugin that lets you transparently call Node.js native code from Cloudflare Workers**
+
+**🚨 WARNING: This project uses INSANE black magic! DO NOT use in production!! 🚨**
+
+
+## 🤯 What is this?
+
+Cloudflare Workers are amazing, but they run on the V8 JavaScript engine—**not Node.js**. This means native modules (binary addons compiled with node-gyp) simply don't work. Want to use `@napi-rs/canvas` for image generation, `sharp` for image processing, or `pdfjs-dist` with canvas rendering? You're out of luck...
+
+**...or are you?** 🔥
+
+`create-nodejs-fn` bridges this gap by leveraging **Cloudflare Containers** (currently in beta). Here's how it works:
+
+1. **You write functions in `*.container.ts` files** using any Node.js native modules you want
+2. **The Vite plugin analyzes your code** using `ts-morph` (TypeScript AST manipulation)
+3. **It auto-generates type-safe proxy functions** that look identical to your original exports
+4. **Your container code is bundled with esbuild** and packaged into a Docker image
+5. **At runtime, the proxy transparently routes calls** via Cap'n Proto RPC to the container
+6. **Cloudflare Durable Objects manage container lifecycle** and connection state
+
+The result? You `import { myFunction } from "./native.container"` and call it like any normal function—but it actually executes inside a Docker container running full Node.js with native module support!
+
+![alt](./assets/black-magic.jpg)
+
+## 🎮 Live Demo
+
+**Try it now!** This example uses `@napi-rs/canvas` + `pdfjs-dist` to render PDF pages as images:
+
+👉 **[Render Bitcoin Whitepaper (Page 1)](https://example-create-nodejs-fn.inaridiy.workers.dev/renderPdf?url=https://bitcoin.org/bitcoin.pdf&pageNum=1&scale=3)**
+
+```
+https://example-create-nodejs-fn.inaridiy.workers.dev/renderPdf?url=https://bitcoin.org/bitcoin.pdf&pageNum=1&scale=3
+```
+
+Yes, this is running on Cloudflare Workers. Yes, it's using native Node.js modules. Yes, it's black magic. 
+
+## 🚀 Quick Start
+
+### Prerequisites
+
+You need a **Cloudflare Workers + Vite** project. Create one with:
+
+```bash
+# Using Hono (recommended)
+pnpm create hono@latest my-app --template cloudflare-workers+vite
+
+# Then cd into it
+cd my-app
+```
+
+### 1. Install dependencies
+
+```bash
+pnpm add create-nodejs-fn @cloudflare/containers capnweb@0.2.0 @napi-rs/canvas
+```
+
+### 2. Initialize config
+
+```bash
+pnpm create-nodejs-fn init
+```
+
+This configures:
+- Adds Containers & Durable Objects config to `wrangler.jsonc`
+- Generates `.create-nodejs-fn/Dockerfile`
+- Creates `src/__generated__/` directory
+- Adds DO export to entry file
+
+### 3. Configure Vite plugin
+
+```typescript
+// vite.config.ts
+import { cloudflare } from "@cloudflare/vite-plugin";
+import { defineConfig } from "vite";
+import { createNodejsFnPlugin } from "create-nodejs-fn";
+
+export default defineConfig({
+  plugins: [
+    createNodejsFnPlugin({
+      // Native dependencies to install in the container
+      external: ["@napi-rs/canvas"],
+      // Docker config with fonts for text rendering
+      docker: {
+        baseImage: "node:20-bookworm-slim",
+        systemPackages: [
+          "fontconfig",
+          "fonts-noto-core",
+          "fonts-noto-cjk",
+          "fonts-noto-color-emoji",
+        ],
+      },
+    }),
+    cloudflare(),
+  ],
+});
+```
+
+### 4. Write a container function
+
+```typescript
+// src/clock.container.ts
+import { createCanvas } from "@napi-rs/canvas";
+import { nodejsFn } from "./__generated__/create-nodejs-fn.runtime";
+
+export const renderClock = nodejsFn(async () => {
+  // 🎨 Create an image with current time using @napi-rs/canvas!
+  const canvas = createCanvas(600, 200);
+  const ctx = canvas.getContext("2d");
+
+  // Background
+  ctx.fillStyle = "#1a1a2e";
+  ctx.fillRect(0, 0, 600, 200);
+
+  // Text with Noto font (installed via systemPackages)
+  ctx.font = "bold 36px 'Noto Sans CJK JP', 'Noto Color Emoji', sans-serif";
+  ctx.fillStyle = "#eee";
+  ctx.textAlign = "center";
+  ctx.textBaseline = "middle";
+
+  const now = new Date().toISOString();
+  ctx.fillText(`🕐 ${now}`, 300, 100);
+
+  // Return as PNG data URL
+  return await canvas.toDataURLAsync("image/webp");
+});
+```
+
+### 5. Call it from your Worker like any normal function
+
+```typescript
+// src/index.ts
+import { Hono } from "hono";
+import { renderClock } from "./clock.container";
+
+const app = new Hono();
+
+app.get("/clock", async (c) => {
+  // 😱 Looks like a normal function call!
+  // But behind the scenes, RPC flies to the container!
+  const pngDataUrl = await renderClock();
+
+  // Convert data URL to response
+  return fetch(pngDataUrl);
+});
+
+// Don't forget to export the DO
+export { NodejsFnContainer } from "./__generated__/create-nodejs-fn.do";
+export default { fetch: app.fetch };
+```
+
+### 6. Launch!
+
+```bash
+pnpm dev
+```
+
+Visit `http://localhost:5173/clock` to see a dynamically generated image with the current timestamp! 🎉
+
+
+## 🪄 The Black Magic Revealed
+
+### 1️⃣ Transparent Proxy Generation via AST Transformation
+
+Uses `ts-morph` to **statically analyze** `*.container.ts` files.
+Detects exported functions and **auto-generates proxy functions with identical type signatures**.
+
+```typescript
+// Your code (clock.container.ts)
+export const renderClock = nodejsFn(async () => {
+  // Node.js native processing...
+  return pngDataUrl;
+});
+
+// 🧙 The plugin auto-generates a proxy
+// → Types fully preserved! IDE autocomplete works!
+// → Calls are routed to the container via RPC!
+```
+
+### 2️⃣ Container Management via Durable Objects
+
+Uses Cloudflare **Durable Objects** to manage container connections.
+Stateful, with multi-instance routing support!
+
+```typescript
+// Route to specific instances with containerKey
+export const renderClock = nodejsFn(
+  async () => { /* ... */ },
+  containerKey(({ args }) => {
+    // Route to containers based on arguments! Load balancing!
+    return `instance-${Math.floor(Math.random() * 3)}`;
+  })
+);
+```
+
+### 3️⃣ Fully Automated Build with esbuild + Docker
+
+- Bundles container server code with **esbuild**
+- **Auto-generates Dockerfile**
+- Native deps specified in `external` are auto-extracted to `package.json`
+
+
+## ⚙️ Plugin Options
+
+```typescript
+createNodejsFnPlugin({
+  // File patterns for container functions (default: ["src/**/*.container.ts"])
+  files: ["src/**/*.container.ts"],
+  
+  // Output directory for generated files (default: "src/__generated__")
+  generatedDir: "src/__generated__",
+  
+  // Durable Object binding name (default: "NODEJS_FN")
+  binding: "NODEJS_FN",
+  
+  // Container class name (default: "NodejsFnContainer")
+  className: "NodejsFnContainer",
+  
+  // Container port (default: 8080)
+  containerPort: 8080,
+  
+  // External dependencies to install in container
+  external: ["@napi-rs/canvas", "sharp"],
+  
+  // Docker image settings
+  docker: {
+    baseImage: "node:20-bookworm-slim",
+    systemPackages: [
+      "fontconfig",
+      "fonts-noto-core",
+      "fonts-noto-cjk",
+      "fonts-noto-color-emoji",
+    ],
+    preInstallCommands: [],
+    postInstallCommands: [],
+    env: { MY_VAR: "value" },
+  },
+  
+  // Environment variables to pass from Worker to Container
+  workerEnvVars: ["API_KEY", "SECRET"],
+  
+  // Auto-rebuild on file changes (default: true)
+  autoRebuildContainers: true,
+  
+  // Rebuild debounce time (default: 600ms)
+  rebuildDebounceMs: 600,
+});
+```
+
+---
+
+## 🏗️ Internal Architecture
+
+```
+project/
+├── src/
+│   ├── clock.container.ts        # Your code
+│   ├── index.ts                  # Worker entry
+│   └── __generated__/            # 🧙 Auto-generated magic
+│       ├── create-nodejs-fn.ts         # RPC client & type definitions
+│       ├── create-nodejs-fn.do.ts      # Durable Object class
+│       ├── create-nodejs-fn.context.ts # Container key resolution
+│       ├── create-nodejs-fn.runtime.ts # nodejsFn / containerKey helpers
+│       └── proxy.src__clock.container.ts # Proxy functions
+│
+└── .create-nodejs-fn/            # 🐳 Container build artifacts
+    ├── Dockerfile                # Auto-generated
+    ├── container.entry.ts        # Server entry (generated)
+    ├── server.mjs                # Bundled with esbuild
+    └── package.json              # Only external deps extracted
+```
+
+---
+
+## ⚠️ Limitations & Caveats
+
+- **Not for production**: This is an experimental project
+- Requires **Cloudflare Containers** (currently in beta)
+- Function arguments and return values must be **serializable**
+- Container cold starts exist (adjust with `sleepAfter`)
+- Debugging is hard (check your logs if something breaks)
+
+---
+
+## 📝 License
+
+MIT

package/dist/chunk-XP4XDEWF.mjs

@@ -0,0 +1,17 @@
+// src/fs-utils.ts
+import fs from "fs";
+import path from "path";
+function ensureDir(p) {
+  fs.mkdirSync(p, { recursive: true });
+}
+function writeFileIfChanged(filePath, content) {
+  ensureDir(path.dirname(filePath));
+  const current = fs.existsSync(filePath) ? fs.readFileSync(filePath, "utf8") : null;
+  if (current === content) return;
+  fs.writeFileSync(filePath, content);
+}
+
+export {
+  ensureDir,
+  writeFileIfChanged
+};

package/dist/cli.d.mts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,356 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli.ts
+var import_node_fs2 = __toESM(require("fs"));
+var import_node_path2 = __toESM(require("path"));
+var import_node_url = require("url");
+var import_promises = __toESM(require("readline/promises"));
+var import_gunshi = require("gunshi");
+
+// src/fs-utils.ts
+var import_node_fs = __toESM(require("fs"));
+var import_node_path = __toESM(require("path"));
+function ensureDir(p) {
+  import_node_fs.default.mkdirSync(p, { recursive: true });
+}
+function writeFileIfChanged(filePath, content) {
+  ensureDir(import_node_path.default.dirname(filePath));
+  const current = import_node_fs.default.existsSync(filePath) ? import_node_fs.default.readFileSync(filePath, "utf8") : null;
+  if (current === content) return;
+  import_node_fs.default.writeFileSync(filePath, content);
+}
+
+// src/cli.ts
+var import_meta = {};
+var moduleDir = typeof __dirname === "string" ? __dirname : import_node_path2.default.dirname((0, import_node_url.fileURLToPath)(import_meta.url));
+var pkgJsonPath = import_node_path2.default.resolve(moduleDir, "../package.json");
+var pkg = import_node_fs2.default.existsSync(pkgJsonPath) ? JSON.parse(import_node_fs2.default.readFileSync(pkgJsonPath, "utf8")) : { version: "0.0.0" };
+var VERSION = pkg.version ?? "0.0.0";
+var initCommand = (0, import_gunshi.define)({
+  name: "init",
+  description: "Interactively scaffold create-nodejs-fn files",
+  args: {
+    yes: {
+      type: "boolean",
+      short: "y",
+      description: "Use defaults and skip prompts"
+    },
+    force: {
+      type: "boolean",
+      short: "f",
+      description: "Overwrite existing files without asking"
+    }
+  },
+  run: async (ctx) => {
+    const yes = Boolean(ctx.values.yes);
+    const force = Boolean(ctx.values.force);
+    await runInit({ yes, force });
+  }
+});
+async function runInit(opts) {
+  const cwd = process.cwd();
+  const defaults = await gatherDefaults(cwd);
+  const prompter = createPrompter(opts.yes);
+  const answers = {
+    name: await prompter.text("Worker name", defaults.name),
+    main: normalizeEntry(await prompter.text("Entry file", defaults.main)),
+    className: await prompter.text("Container class name", defaults.className),
+    binding: await prompter.text("Durable Object binding", defaults.binding),
+    image: await prompter.text("Container image path", defaults.image),
+    compatibilityDate: await prompter.text("Compatibility date", defaults.compatibilityDate),
+    maxInstances: await prompter.number("Max container instances", defaults.maxInstances)
+  };
+  const results = [];
+  if (await ensureDockerfile(cwd, opts, prompter)) {
+    results.push(".create-nodejs-fn/Dockerfile");
+  }
+  if (updateGitignore(cwd)) {
+    results.push(".gitignore");
+  }
+  if (ensureGeneratedDir(cwd)) {
+    results.push("src/__generated__/");
+  }
+  const wranglerResult = await writeWranglerJsonc(cwd, answers, opts, prompter);
+  if (wranglerResult) {
+    results.push("wrangler.jsonc");
+  }
+  if (ensureEntryExportsDo(cwd, answers, opts)) {
+    results.push(answers.main);
+  }
+  prompter.close();
+  if (results.length === 0) {
+    console.log("All files already up to date. Nothing to do.");
+    return;
+  }
+  console.log("Updated:");
+  for (const r of results) {
+    console.log(`  - ${r}`);
+  }
+}
+async function ensureDockerfile(cwd, opts, prompter) {
+  const dockerfilePath = import_node_path2.default.join(cwd, ".create-nodejs-fn", "Dockerfile");
+  const dockerDir = import_node_path2.default.dirname(dockerfilePath);
+  ensureDir(dockerDir);
+  if (import_node_fs2.default.existsSync(dockerfilePath) && !opts.force) {
+    const overwrite = await prompter.confirm(
+      "Dockerfile already exists. Overwrite it?",
+      false
+    );
+    if (!overwrite) return false;
+  }
+  const content = [
+    "# create-nodejs-fn container image",
+    "# Generated by `create-nodejs-fn init`. The build step will refresh this file.",
+    "FROM node:20-slim",
+    "WORKDIR /app",
+    "RUN corepack enable",
+    "# Dependencies are injected via the generated package.json during build.",
+    "COPY package.json ./",
+    "RUN pnpm install --prod --no-frozen-lockfile",
+    "# The server bundle is generated at build time.",
+    "COPY ./server.mjs ./server.mjs",
+    "ENV NODE_ENV=production",
+    "EXPOSE 8080",
+    'CMD ["node", "./server.mjs"]',
+    ""
+  ].join("\n");
+  writeFileIfChanged(dockerfilePath, content);
+  return true;
+}
+function updateGitignore(cwd) {
+  const target = import_node_path2.default.join(cwd, ".gitignore");
+  const existing = import_node_fs2.default.existsSync(target) ? import_node_fs2.default.readFileSync(target, "utf8").split(/\r?\n/) : [];
+  const block = [
+    "# create-nodejs-fn",
+    ".create-nodejs-fn/*",
+    "!.create-nodejs-fn/Dockerfile",
+    "src/__generated__"
+  ];
+  const lines = [...existing];
+  const present = new Set(lines);
+  const missing = block.filter((line) => !present.has(line));
+  const changed = missing.length > 0;
+  if (changed) {
+    if (lines.length && lines[lines.length - 1] !== "") {
+      lines.push("");
+    }
+    for (const line of block) {
+      if (!present.has(line)) {
+        lines.push(line);
+      }
+    }
+  }
+  if (changed) {
+    const cleaned = trimBlankDuplicates(lines).join("\n");
+    import_node_fs2.default.writeFileSync(target, cleaned.endsWith("\n") ? cleaned : `${cleaned}
+`);
+  }
+  return changed;
+}
+function ensureGeneratedDir(cwd) {
+  const dir = import_node_path2.default.join(cwd, "src", "__generated__");
+  if (import_node_fs2.default.existsSync(dir)) return false;
+  ensureDir(dir);
+  return true;
+}
+async function writeWranglerJsonc(cwd, answers, opts, prompter) {
+  const target = import_node_path2.default.join(cwd, "wrangler.jsonc");
+  const exists = import_node_fs2.default.existsSync(target);
+  if (exists && !opts.force) {
+    const proceed = await prompter.confirm("wrangler.jsonc already exists. Merge updates?", true);
+    if (!proceed) return false;
+  }
+  const existing = exists ? readJsonc(target) : {};
+  const merged = mergeWranglerConfig(existing, answers);
+  writeFileIfChanged(target, `${JSON.stringify(merged, null, 2)}
+`);
+  return true;
+}
+function readJsonc(filePath) {
+  try {
+    const raw = import_node_fs2.default.readFileSync(filePath, "utf8");
+    const withoutBlock = raw.replace(/\/\*[\s\S]*?\*\//g, "");
+    const withoutLine = withoutBlock.replace(/(^|[^:])\/\/.*$/gm, "$1");
+    return JSON.parse(withoutLine);
+  } catch {
+    return {};
+  }
+}
+function mergeWranglerConfig(base, answers) {
+  const out = { ...base };
+  out.$schema = out.$schema ?? "node_modules/wrangler/config-schema.json";
+  out.name = out.name ?? answers.name;
+  out.main = out.main ?? (answers.main.startsWith("./") ? answers.main : `./${answers.main}`);
+  out.compatibility_date = out.compatibility_date ?? answers.compatibilityDate;
+  const flags = Array.isArray(out.compatibility_flags) ? out.compatibility_flags : [];
+  if (!flags.includes("nodejs_compat")) flags.push("nodejs_compat");
+  out.compatibility_flags = flags;
+  const containers = Array.isArray(out.containers) ? [...out.containers] : [];
+  const containerIdx = containers.findIndex((c) => c?.class_name === answers.className);
+  const containerEntry = {
+    class_name: answers.className,
+    image: answers.image,
+    max_instances: answers.maxInstances
+  };
+  if (containerIdx >= 0) {
+    containers[containerIdx] = { ...containers[containerIdx], ...containerEntry };
+  } else {
+    containers.push(containerEntry);
+  }
+  out.containers = containers;
+  const durable = typeof out.durable_objects === "object" && out.durable_objects !== null ? { ...out.durable_objects } : {};
+  const bindings = Array.isArray(durable.bindings) ? [...durable.bindings] : [];
+  const bindingIdx = bindings.findIndex((b) => b?.name === answers.binding);
+  const bindingEntry = { name: answers.binding, class_name: answers.className };
+  if (bindingIdx >= 0) {
+    bindings[bindingIdx] = { ...bindings[bindingIdx], ...bindingEntry };
+  } else {
+    bindings.push(bindingEntry);
+  }
+  durable.bindings = bindings;
+  out.durable_objects = durable;
+  const migrations = Array.isArray(out.migrations) ? [...out.migrations] : [];
+  const migIdx = migrations.findIndex((m) => m?.tag === "v1");
+  const ensureNewSqlite = (entry) => {
+    const classes = Array.isArray(entry.new_sqlite_classes) ? [...entry.new_sqlite_classes] : [];
+    if (!classes.includes(answers.className)) classes.push(answers.className);
+    entry.new_sqlite_classes = classes;
+    return entry;
+  };
+  if (migIdx >= 0) {
+    migrations[migIdx] = ensureNewSqlite({ ...migrations[migIdx], tag: migrations[migIdx].tag ?? "v1" });
+  } else {
+    migrations.push(ensureNewSqlite({ tag: "v1" }));
+  }
+  out.migrations = migrations;
+  return out;
+}
+function ensureEntryExportsDo(cwd, answers, opts) {
+  const entryRel = answers.main.startsWith("./") ? answers.main.slice(2) : answers.main;
+  const entryAbs = import_node_path2.default.join(cwd, entryRel);
+  ensureDir(import_node_path2.default.dirname(entryAbs));
+  const doAbs = import_node_path2.default.join(cwd, "src", "__generated__", "create-nodejs-fn.do.ts");
+  const doRel = import_node_path2.default.relative(import_node_path2.default.dirname(entryAbs), doAbs).replace(/\\/g, "/").replace(/\.ts$/, "");
+  const exportLine = `export { ${answers.className} } from "${doRel.startsWith(".") ? doRel : `./${doRel}`}";`;
+  if (import_node_fs2.default.existsSync(entryAbs)) {
+    const content = import_node_fs2.default.readFileSync(entryAbs, "utf8");
+    if (content.includes(exportLine) || content.match(new RegExp(`export\\s+\\{\\s*${answers.className}\\s*\\}.*create-nodejs-fn\\.do`))) {
+      return false;
+    }
+    const next = content.endsWith("\n") ? `${content}${exportLine}
+` : `${content}
+${exportLine}
+`;
+    writeFileIfChanged(entryAbs, next);
+    return true;
+  }
+  const template = `${exportLine}
+`;
+  writeFileIfChanged(entryAbs, template);
+  return true;
+}
+async function gatherDefaults(cwd) {
+  const pkgPath = import_node_path2.default.join(cwd, "package.json");
+  const pkgJson = import_node_fs2.default.existsSync(pkgPath) ? JSON.parse(import_node_fs2.default.readFileSync(pkgPath, "utf8")) : {};
+  return {
+    name: pkgJson.name ?? import_node_path2.default.basename(cwd),
+    main: "src/index.ts",
+    className: "NodejsFnContainer",
+    binding: "NODEJS_FN",
+    image: "./.create-nodejs-fn/Dockerfile",
+    compatibilityDate: defaultCompatibilityDate(),
+    maxInstances: 10
+  };
+}
+function defaultCompatibilityDate() {
+  const d = /* @__PURE__ */ new Date();
+  const yyyy = d.getUTCFullYear();
+  const mm = `${d.getUTCMonth() + 1}`.padStart(2, "0");
+  const dd = `${d.getUTCDate()}`.padStart(2, "0");
+  return `${yyyy}-${mm}-${dd}`;
+}
+function normalizeEntry(input) {
+  if (!input) return "src/index.ts";
+  const withSlash = input.startsWith("./") ? input : `./${input}`;
+  return withSlash.replace(/\\/g, "/");
+}
+function createPrompter(skip) {
+  if (skip || !process.stdin.isTTY) {
+    return {
+      text: async (_message, defaultValue) => defaultValue,
+      number: async (_message, defaultValue) => defaultValue,
+      confirm: async (_message, defaultValue = false) => defaultValue,
+      close: () => {
+      }
+    };
+  }
+  const rl = import_promises.default.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return {
+    async text(message, defaultValue) {
+      const answer = await rl.question(formatPrompt(message, defaultValue));
+      return answer.trim() || defaultValue;
+    },
+    async number(message, defaultValue) {
+      const answer = await rl.question(formatPrompt(message, String(defaultValue)));
+      const parsed = Number.parseInt(answer.trim(), 10);
+      return Number.isFinite(parsed) ? parsed : defaultValue;
+    },
+    async confirm(message, defaultValue = false) {
+      const suffix = defaultValue ? " [Y/n] " : " [y/N] ";
+      const answer = (await rl.question(`${message}${suffix}`)).trim().toLowerCase();
+      if (!answer) return defaultValue;
+      return answer.startsWith("y");
+    },
+    close() {
+      rl.close();
+    }
+  };
+}
+function formatPrompt(message, defaultValue) {
+  const suffix = defaultValue !== void 0 && defaultValue !== null ? ` (${defaultValue})` : "";
+  return `${message}${suffix}: `;
+}
+function trimBlankDuplicates(lines) {
+  const out = [];
+  for (const line of lines) {
+    if (line === "" && out.length > 0 && out[out.length - 1] === "") continue;
+    out.push(line);
+  }
+  return out;
+}
+async function main() {
+  await (0, import_gunshi.cli)(process.argv.slice(2), initCommand, {
+    name: "create-nodejs-fn",
+    version: VERSION
+  });
+}
+main().catch((err) => {
+  console.error(err);
+  process.exitCode = 1;
+});