@notionhq/custom-blocks-dev-shell 0.1.33 → 0.1.34

package/bin/cli.js

@@ -1,6 +1,11 @@
 #!/usr/bin/env node
+/**
+ * Executable wrapper for the published dev shell package.
+ *
+ * The package exposes this file as its CLI entry point. Keep the wrapper dependency-free.
+ */
 try {
-	await import(new URL("../dist-cli/main.js", import.meta.url))
+	await import(new URL("../dist-cli/published-cli.js", import.meta.url))
 } catch (error) {
 	if (
 		error?.code === "ERR_MODULE_NOT_FOUND" &&

package/dist-cli/block-server.js

@@ -1,13 +1,10 @@
 /**
- * Per-block Vite server plumbing shared by the repo dev script
- * (`scripts/dev.ts`) and the published dev shell CLI (`cli/main.ts`).
+ * Provides shared Vite server setup for both dev shell launchers. It builds the block registry,
+ * generates a Vite config for each block, and formats Vite change logs.
  */
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { relative, resolve } from "node:path";
-/** First port handed to per-block Vite servers; blocks count up from here. */
-export const BLOCK_BASE_PORT = 9876;
-/** Port the dev shell UI is served on. */
-export const SHELL_PORT = 9873;
+import { BLOCK_BASE_PORT } from "./ports.js";
 /** The registry for a worker's blocks, assuming sequential port assignment. */
 export function buildBlockRegistry(blocks, basePort = BLOCK_BASE_PORT) {
     return blocks.map((capability, index) => ({

package/dist-cli/convert.js

@@ -9,7 +9,7 @@ import { readFileSync } from "node:fs";
 import * as v from "valibot";
 import { convertPublicApiPropertyValue, isDataSourceValue, matchesPropertyType, } from "./convert-values.js";
 import { NOTION_PROPERTY_TYPES, sourceFileSchema } from "./data-sources.js";
-import { claimUniqueKey, slugify } from "./utils.js";
+import { claimUniqueKey, parseLongOptions, slugify } from "./utils.js";
 const SUPPORTED_TYPES = new Set(NOTION_PROPERTY_TYPES);
 /** The spelling of "text" in the local file format. */
 const UNSUPPORTED_TYPE_FALLBACK = "rich_text";
@@ -19,37 +19,19 @@ export function parseConvertArgs(argv) {
         key: undefined,
         name: undefined,
     };
-    const takeValue = (name, index) => {
-        const value = argv[index];
-        if (value === undefined || value.startsWith("--")) {
-            throw new Error(`${name} requires a value.`);
-        }
-        return value;
-    };
-    for (let index = 0; index < argv.length; index++) {
-        const arg = argv[index];
-        if (arg === "--in") {
-            args.input = takeValue("--in", ++index);
-        }
-        else if (arg.startsWith("--in=")) {
-            args.input = arg.slice("--in=".length);
-        }
-        else if (arg === "--key") {
-            args.key = takeValue("--key", ++index);
-        }
-        else if (arg.startsWith("--key=")) {
-            args.key = arg.slice("--key=".length);
-        }
-        else if (arg === "--name") {
-            args.name = takeValue("--name", ++index);
-        }
-        else if (arg.startsWith("--name=")) {
-            args.name = arg.slice("--name=".length);
-        }
-        else {
-            throw new Error(`Unknown convert option "${arg}". Supported: --in <file>, --key <key>, --name <name>.`);
-        }
-    }
+    parseLongOptions(argv, {
+        "--in": value => {
+            args.input = value;
+        },
+        "--key": value => {
+            args.key = value;
+        },
+        "--name": value => {
+            args.name = value;
+        },
+    }, arg => {
+        throw new Error(`Unknown convert option "${arg}". Supported: --in <file>, --key <key>, --name <name>.`);
+    });
     return args;
 }
 const sampleInputSchema = v.pipe(v.looseObject({

package/dist-cli/dev-shell-launcher.js

@@ -0,0 +1,195 @@
+/**
+ * Shared orchestration for the repository and published dev shell launchers.
+ *
+ * It builds the worker and reads its manifest, starts one Vite server per
+ * custom block, and owns process and resource cleanup. Each launcher entry point
+ * supplies a small shell adapter, but otherwise delegates to this module.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { basename, dirname, join, resolve } from "node:path";
+import { buildBlockRegistry, writeBlockViteConfig, } from "./block-server.js";
+import { readDataSources } from "./data-sources.js";
+import { materializeWorkerSchemaDataSources } from "./materialize.js";
+import { BLOCK_BASE_PORT, parsePort, SHELL_PORT, validateBlockPortRange, validateShellPort, } from "./ports.js";
+import { installProcessSignalHandlers, ProcessSupervisor, } from "./process-supervisor.js";
+import { parseLongOptions } from "./utils.js";
+import { blockCapabilities, findWorkerDir, generateWorkerManifest, } from "./worker-manifest.js";
+const dim = "\x1b[2m";
+const bold = "\x1b[1m";
+const cyan = "\x1b[36m";
+const reset = "\x1b[0m";
+const label = (name) => `${cyan}[${name}]${reset}`;
+export async function prepareWorkerLaunchPlan(workerDir, options = {}) {
+    const root = resolve(workerDir);
+    if (!existsSync(resolve(root, "node_modules"))) {
+        throw new Error(`No node_modules in ${root}. Install the worker's dependencies first ` +
+            `(e.g. \`npm install\`), then rerun.`);
+    }
+    const { manifest, manifestPath } = await generateWorkerManifest(root, {
+        build: options.build,
+    });
+    const capabilities = blockCapabilities(manifest);
+    const blockBasePort = options.blockBasePort ?? BLOCK_BASE_PORT;
+    validateBlockPortRange(blockBasePort, capabilities.length);
+    const blocks = capabilities.map((capability, index) => {
+        const blockDir = resolve(root, capability.config.source.path);
+        return {
+            capability,
+            blockDir,
+            configFile: writeBlockViteConfig(root, blockDir, capability),
+            port: blockBasePort + index,
+        };
+    });
+    const dataDir = resolve(root, "src/data");
+    materializeWorkerSchemaDataSources(manifest, dataDir);
+    return {
+        workerDir: root,
+        dataDir,
+        manifestPath,
+        blocks,
+        registry: buildBlockRegistry(capabilities, blockBasePort),
+        dataSources: readDataSources(dataDir),
+    };
+}
+export function parseWorkerLaunchArgs(argv) {
+    const args = {
+        worker: undefined,
+        shellPort: SHELL_PORT,
+        blockBasePort: BLOCK_BASE_PORT,
+    };
+    parseLongOptions(argv, {
+        "--worker": value => {
+            if (value.length === 0) {
+                throw new Error("--worker requires a path to a worker directory.");
+            }
+            args.worker = value;
+        },
+        "--port": value => {
+            args.shellPort = parsePort("--port", value);
+        },
+        "--block-base-port": value => {
+            args.blockBasePort = parsePort("--block-base-port", value);
+        },
+    });
+    return args;
+}
+function resolveWorkerViteBin(workerDir) {
+    let vitePkgPath;
+    try {
+        const workerRequire = createRequire(join(workerDir, "package.json"));
+        vitePkgPath = workerRequire.resolve("vite/package.json");
+    }
+    catch {
+        throw new Error(`Could not resolve "vite" from ${workerDir}. Add vite to the worker's ` +
+            `devDependencies and reinstall.`);
+    }
+    const vitePkg = JSON.parse(readFileSync(vitePkgPath, "utf-8"));
+    const bin = typeof vitePkg.bin === "string" ? vitePkg.bin : vitePkg.bin?.vite;
+    if (bin === undefined) {
+        throw new Error(`The vite package at ${vitePkgPath} exposes no bin.`);
+    }
+    return resolve(dirname(vitePkgPath), bin);
+}
+function createBlockProcesses(plan) {
+    if (plan.blocks.length === 0) {
+        return [];
+    }
+    const viteBin = resolveWorkerViteBin(plan.workerDir);
+    return plan.blocks.map(block => ({
+        name: block.capability.key,
+        command: process.execPath,
+        args: [
+            viteBin,
+            "--config",
+            block.configFile,
+            "--port",
+            String(block.port),
+            "--strictPort",
+        ],
+        cwd: plan.workerDir,
+        detached: process.platform !== "win32",
+    }));
+}
+function logNamed(name, message) {
+    console.log(`${label(name)} ${message}`);
+}
+function printSummary(args, registry) {
+    console.log("");
+    console.log(`${bold}Dev shell${reset}`);
+    console.log(`  ${label("dev-shell")} ${dim}http://localhost:${args.shellPort}${reset}`);
+    if (registry.length > 0) {
+        console.log("");
+        console.log(`${bold}Blocks${reset}`);
+        for (const entry of registry) {
+            console.log(`  ${label(entry.key)} ${dim}${entry.url}${reset}`);
+        }
+    }
+    console.log("");
+}
+function resolveWorkerLaunch(options) {
+    const args = parseWorkerLaunchArgs(options.argv);
+    const workerDir = args.worker === undefined
+        ? findWorkerDir(options.detectFromDir)
+        : resolve(options.workerBaseDir, args.worker);
+    if (workerDir === undefined) {
+        throw new Error("No worker found: run from inside a worker directory, or pass --worker <dir>.");
+    }
+    if (args.worker === undefined) {
+        console.log(`Detected a worker at ${workerDir}.`);
+    }
+    return { args, workerDir };
+}
+function logWorkerPlan(workerName, plan) {
+    logNamed(workerName, `Wrote ${plan.manifestPath}`);
+    if (plan.blocks.length === 0) {
+        logNamed(workerName, "Worker declares no custom blocks.");
+    }
+    logNamed(workerName, plan.dataSources.length > 0
+        ? `Data sources from src/data: ${plan.dataSources
+            .map(source => source.name)
+            .join(", ")}`
+        : "No data sources — create src/data/<key>.json files " +
+            "(format: node_modules/@notionhq/custom-blocks-dev-shell/docs/data-sources.md).");
+}
+async function prepareWorkerLaunch(options) {
+    const { args, workerDir } = resolveWorkerLaunch(options);
+    const workerName = basename(workerDir);
+    logNamed(workerName, "Extracting worker manifest...");
+    const plan = await prepareWorkerLaunchPlan(workerDir, {
+        blockBasePort: args.blockBasePort,
+    });
+    logWorkerPlan(workerName, plan);
+    validateShellPort(args.shellPort, args.blockBasePort, plan.blocks.length);
+    const shell = await options.createShellLaunch({
+        args,
+        plan,
+        log: logNamed,
+    });
+    return { args, plan, shell };
+}
+export async function launchDevShell(options) {
+    const { installSignalHandlers = true } = options;
+    const callbacks = {
+        onChange: logNamed,
+        onUnexpectedExit: (name, code) => console.error(`${label(name)} dev server exited with code ${code}`),
+        onProcessError: (name, error) => console.error(`${label(name)} dev server failed: ${error.message}`),
+    };
+    const run = options.createRun?.() ?? new ProcessSupervisor(callbacks);
+    if (installSignalHandlers) {
+        installProcessSignalHandlers(run);
+    }
+    try {
+        const { args, plan, shell } = await prepareWorkerLaunch(options);
+        for (const resource of shell.resources) {
+            run.addResource(resource);
+        }
+        run.start([...shell.processes, ...createBlockProcesses(plan)]);
+        printSummary(args, plan.registry);
+    }
+    catch (error) {
+        console.error(`Failed to start dev shell: ${error instanceof Error ? error.message : error}`);
+        process.exitCode = 1;
+        run.shutdown("SIGTERM");
+    }
+}

package/dist-cli/ports.js

@@ -0,0 +1,36 @@
+/**
+ * Port defaults and validation shared by the repository and published launchers.
+ */
+/** First port handed to per-block Vite servers; blocks count up from here. */
+export const BLOCK_BASE_PORT = 9876;
+/** Port the dev shell UI is served on. */
+export const SHELL_PORT = 9873;
+/** Highest valid TCP port. */
+const MAX_PORT = 65535;
+/** Parse and validate a named CLI port option. */
+export function parsePort(name, raw) {
+    const port = Number(raw);
+    if (!Number.isInteger(port) || port <= 0 || port > MAX_PORT) {
+        throw new Error(`${name} requires a port number, got "${raw}".`);
+    }
+    return port;
+}
+/** Reject a sequential block-port range that would exceed the TCP port limit. */
+export function validateBlockPortRange(blockBasePort, blockCount) {
+    const lastPort = blockBasePort + blockCount - 1;
+    if (blockCount > 0 && lastPort > MAX_PORT) {
+        throw new Error(`--block-base-port ${blockBasePort} is too high for ${blockCount} ` +
+            `block servers; the last block port would be ${lastPort}, but ports ` +
+            `cannot exceed ${MAX_PORT}.`);
+    }
+}
+/** Reject a shell port that overlaps the sequential block-port range. */
+export function validateShellPort(shellPort, blockBasePort, blockCount) {
+    if (blockCount > 0 &&
+        shellPort >= blockBasePort &&
+        shellPort < blockBasePort + blockCount) {
+        throw new Error(`--port ${shellPort} collides with the block server ports ` +
+            `(${blockBasePort}–${blockBasePort + blockCount - 1}); ` +
+            `pick a port outside that range or move --block-base-port.`);
+    }
+}

package/dist-cli/process-supervisor.js

@@ -0,0 +1,119 @@
+/**
+ * Own child processes and non-child resources for one dev shell run.
+ */
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+import { makeChangeLogger } from "./block-server.js";
+const SHUTDOWN_GRACE_MS = 1500;
+const dim = "\x1b[2m";
+const reset = "\x1b[0m";
+export class ProcessSupervisor {
+    callbacks;
+    processes = new Map();
+    resources = [];
+    shuttingDown = false;
+    constructor(callbacks) {
+        this.callbacks = callbacks;
+    }
+    addResource(resource) {
+        if (this.shuttingDown) {
+            closeResource(resource);
+            return;
+        }
+        this.resources.push(resource);
+    }
+    start(specs) {
+        for (const spec of specs) {
+            if (this.shuttingDown) {
+                return;
+            }
+            const detached = spec.detached ?? process.platform !== "win32";
+            const proc = spawn(spec.command, [...spec.args], {
+                cwd: spec.cwd,
+                stdio: ["ignore", "pipe", "inherit"],
+                detached,
+                env: spec.env === undefined
+                    ? process.env
+                    : { ...process.env, ...spec.env },
+            });
+            this.processes.set(proc, detached);
+            if (proc.stdout !== null) {
+                createInterface({ input: proc.stdout }).on("line", makeChangeLogger(message => this.callbacks.onChange(spec.name, message)));
+            }
+            proc.on("error", error => {
+                if (this.shuttingDown) {
+                    return;
+                }
+                this.callbacks.onProcessError(spec.name, error);
+                process.exitCode = 1;
+                this.shutdown("SIGTERM");
+            });
+            proc.on("exit", code => {
+                this.processes.delete(proc);
+                if (this.shuttingDown || code === 0 || code === null) {
+                    return;
+                }
+                this.callbacks.onUnexpectedExit(spec.name, code);
+                process.exitCode = code;
+                this.shutdown("SIGTERM");
+            });
+        }
+    }
+    shutdown(signal) {
+        if (this.shuttingDown) {
+            return;
+        }
+        this.shuttingDown = true;
+        if (signal !== "exit" &&
+            (this.processes.size > 0 || this.resources.length > 0)) {
+            console.log(`\n${dim}Shutting down...${reset}`);
+        }
+        for (const resource of this.resources) {
+            closeResource(resource);
+        }
+        for (const [proc, detached] of this.processes) {
+            killProcess(proc, detached, "SIGTERM");
+        }
+        if (signal === "exit") {
+            return;
+        }
+        const timer = setTimeout(() => {
+            for (const [proc, detached] of this.processes) {
+                killProcess(proc, detached, "SIGKILL");
+            }
+            process.exit(process.exitCode ?? 0);
+        }, SHUTDOWN_GRACE_MS);
+        timer.unref();
+    }
+}
+function closeResource(resource) {
+    try {
+        resource();
+    }
+    catch { }
+}
+function killProcess(proc, detached, signal) {
+    if (proc.pid === undefined || proc.killed) {
+        return;
+    }
+    try {
+        if (detached && process.platform !== "win32") {
+            process.kill(-proc.pid, signal);
+        }
+        else {
+            proc.kill(signal);
+        }
+    }
+    catch { }
+}
+export function installProcessSignalHandlers(run) {
+    for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) {
+        process.on(signal, () => run.shutdown(signal));
+    }
+    process.on("exit", () => run.shutdown("exit"));
+    process.on("uncaughtException", error => {
+        console.error(error);
+        process.exitCode = 1;
+        run.shutdown("SIGTERM");
+    });
+}

package/dist-cli/published-cli.js

@@ -0,0 +1,73 @@
+/**
+ * Published launcher entry point for custom block authors. This file is the
+ * entry point for `ntn customblocks dev` and `npx @notionhq/custom-blocks-dev-shell`.
+ *
+ * The shared launcher orchestrates building the worker, reading its manifest,
+ * starting one Vite server per custom block, and owning the ports, output, and
+ * lifecycle. This entry point starts the dev shell and supplies the package's
+ * prebuilt shell adapter with the block registry and data sources.
+ *
+ * Other subcommands like `convert` exit before any dev shell machinery starts.
+ */
+import { existsSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { runConvert } from "./convert.js";
+import { readDataSources } from "./data-sources.js";
+import { launchDevShell } from "./dev-shell-launcher.js";
+import { copyPrebuiltDataSources } from "./prebuilt.js";
+import { serveUi } from "./serve-ui.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const createShellLaunch = async ({ args, plan, log }) => {
+    const distDir = resolve(__dirname, "..", "dist");
+    if (!existsSync(join(distDir, "index.html"))) {
+        throw new Error(`No prebuilt UI found at ${distDir}. This package was not assembled ` +
+            `correctly; reinstall it.`);
+    }
+    const prebuiltDir = resolve(__dirname, "..", "data");
+    let server;
+    try {
+        server = await serveUi(distDir, args.shellPort, {
+            blocks: plan.registry,
+            dataSources: plan.dataSources,
+            prebuiltFilenames: readDataSources(prebuiltDir).map(source => source.filename),
+        }, () => {
+            const written = copyPrebuiltDataSources(prebuiltDir, plan.dataDir);
+            if (written.length > 0) {
+                log(basename(plan.workerDir), `Added pre-built data sources: ${written.join(", ")}`);
+            }
+            return readDataSources(plan.dataDir);
+        });
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "EADDRINUSE") {
+            throw new Error(`Port ${args.shellPort} is already in use. Stop whatever holds it ` +
+                `or rerun with --port <port> (and --block-base-port <port> for the ` +
+                `block servers).`);
+        }
+        throw error;
+    }
+    return {
+        processes: [],
+        resources: [() => server.close()],
+    };
+};
+async function main() {
+    const argv = process.argv.slice(2);
+    // One-shot subcommands return before any dev shell machinery starts.
+    if (argv[0] === "convert") {
+        await runConvert(argv.slice(1));
+        return;
+    }
+    await launchDevShell({
+        argv,
+        workerBaseDir: process.cwd(),
+        detectFromDir: process.cwd(),
+        createShellLaunch,
+    });
+}
+main().catch(error => {
+    console.error(error instanceof Error ? error.message : error);
+    process.exitCode = 1;
+});

package/dist-cli/utils.js

@@ -24,3 +24,28 @@ export function claimUniqueKey(base, used) {
     used.add(key);
     return key;
 }
+/**
+ * Parse long options in both `--name value` and `--name=value` forms.
+ * Unknown options are passed to `onUnknown`. Callers can ignore or reject them.
+ */
+export function parseLongOptions(argv, handlers, onUnknown = () => { }) {
+    const takeValue = (name, index) => {
+        const value = argv[index];
+        if (value === undefined || value.startsWith("--")) {
+            throw new Error(`${name} requires a value.`);
+        }
+        return value;
+    };
+    for (let index = 0; index < argv.length; index++) {
+        const arg = argv[index];
+        const separator = arg.indexOf("=");
+        const name = separator === -1 ? arg : arg.slice(0, separator);
+        const handler = handlers[name];
+        if (handler === undefined) {
+            onUnknown(arg);
+            continue;
+        }
+        const value = separator === -1 ? takeValue(name, ++index) : arg.slice(separator + 1);
+        handler(value);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@notionhq/custom-blocks-dev-shell",
-  "version": "0.1.33",
+  "version": "0.1.34",
   "description": "Local preview shell for Notion custom block workers.",
   "license": "MIT",
   "repository": {

package/dist-cli/main.js

@@ -1,271 +0,0 @@
-/**
- * Entry point for the published dev shell CLI (`npx`-run from a worker
- * project). Mirrors the repo's `scripts/dev.ts`: build the
- * worker, extract its manifest, serve one Vite dev server per custom block
- * (using the worker's own Vite install), and serve the prebuilt dev shell UI
- * with the block registry injected at runtime.
- */
-import { spawn } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
-import { createRequire } from "node:module";
-import { basename, dirname, join, resolve } from "node:path";
-import { createInterface } from "node:readline";
-import { fileURLToPath } from "node:url";
-import { BLOCK_BASE_PORT, buildBlockRegistry, makeChangeLogger, SHELL_PORT, writeBlockViteConfig, } from "./block-server.js";
-import { runConvert } from "./convert.js";
-import { readDataSources } from "./data-sources.js";
-import { materializeWorkerSchemaDataSources } from "./materialize.js";
-import { copyPrebuiltDataSources } from "./prebuilt.js";
-import { serveUi } from "./serve-ui.js";
-import { blockCapabilities, findWorkerDir, generateWorkerManifest, } from "./worker-manifest.js";
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const dim = "\x1b[2m";
-const bold = "\x1b[1m";
-const cyan = "\x1b[36m";
-const reset = "\x1b[0m";
-const label = (name) => `${cyan}[${name}]${reset}`;
-function parseCliArgs(argv) {
-    const args = {
-        worker: undefined,
-        shellPort: SHELL_PORT,
-        blockBasePort: BLOCK_BASE_PORT,
-    };
-    const takeValue = (name, index) => {
-        const value = argv[index];
-        if (value === undefined || value.startsWith("--")) {
-            throw new Error(`${name} requires a value.`);
-        }
-        return value;
-    };
-    const takePort = (name, raw) => {
-        const port = Number(raw);
-        if (!Number.isInteger(port) || port <= 0 || port > 65535) {
-            throw new Error(`${name} requires a port number, got "${raw}".`);
-        }
-        return port;
-    };
-    for (let index = 0; index < argv.length; index++) {
-        const arg = argv[index];
-        if (arg === "--worker") {
-            args.worker = takeValue("--worker", ++index);
-        }
-        else if (arg.startsWith("--worker=")) {
-            args.worker = arg.slice("--worker=".length);
-            if (args.worker.length === 0) {
-                throw new Error("--worker requires a path to a worker directory.");
-            }
-        }
-        else if (arg === "--port") {
-            args.shellPort = takePort("--port", takeValue("--port", ++index));
-        }
-        else if (arg.startsWith("--port=")) {
-            args.shellPort = takePort("--port", arg.slice("--port=".length));
-        }
-        else if (arg === "--block-base-port") {
-            args.blockBasePort = takePort("--block-base-port", takeValue("--block-base-port", ++index));
-        }
-        else if (arg.startsWith("--block-base-port=")) {
-            args.blockBasePort = takePort("--block-base-port", arg.slice("--block-base-port=".length));
-        }
-    }
-    return args;
-}
-function resolveWorkerDir(workerArg) {
-    if (workerArg !== undefined) {
-        return resolve(process.cwd(), workerArg);
-    }
-    const detected = findWorkerDir(process.cwd());
-    if (detected !== undefined) {
-        console.log(`Detected a worker at ${detected}.`);
-        return detected;
-    }
-    throw new Error("No worker found: run from inside a worker directory, or pass --worker <dir>.");
-}
-/**
- * The worker's own Vite binary. Blocks are served with the worker's Vite (and
- * plugins) rather than anything bundled here, matching how the block builds in
- * production.
- */
-function resolveViteBin(workerDir) {
-    let vitePkgPath;
-    try {
-        const workerRequire = createRequire(join(workerDir, "package.json"));
-        vitePkgPath = workerRequire.resolve("vite/package.json");
-    }
-    catch {
-        throw new Error(`Could not resolve "vite" from ${workerDir}. Add vite to the worker's ` +
-            `devDependencies and reinstall.`);
-    }
-    const vitePkg = JSON.parse(readFileSync(vitePkgPath, "utf-8"));
-    const bin = typeof vitePkg.bin === "string" ? vitePkg.bin : vitePkg.bin?.vite;
-    if (bin === undefined) {
-        throw new Error(`The vite package at ${vitePkgPath} exposes no bin.`);
-    }
-    return resolve(dirname(vitePkgPath), bin);
-}
-const procs = [];
-async function main() {
-    const argv = process.argv.slice(2);
-    // One-shot subcommands return before any dev-server machinery starts;
-    // with no subcommand the CLI is the dev shell, as it always was.
-    if (argv[0] === "convert") {
-        await runConvert(argv.slice(1));
-        return;
-    }
-    const cliArgs = parseCliArgs(argv);
-    const workerDir = resolveWorkerDir(cliArgs.worker);
-    if (!existsSync(resolve(workerDir, "node_modules"))) {
-        throw new Error(`No node_modules in ${workerDir}. Install the worker's dependencies first ` +
-            `(e.g. \`npm install\`), then rerun.`);
-    }
-    console.log(`${label(basename(workerDir))} Extracting worker manifest...`);
-    const { manifest, manifestPath } = await generateWorkerManifest(workerDir);
-    console.log(`${label(basename(workerDir))} Wrote ${manifestPath}`);
-    const blocks = blockCapabilities(manifest);
-    if (blocks.length === 0) {
-        // Not an error — start the shell anyway; it shows "None" under Blocks.
-        console.log(`${label(basename(workerDir))} Worker declares no custom blocks.`);
-    }
-    // Materialize schema-only files for the worker's declared sources, then
-    // load the directory. Files are validated before injection; a malformed
-    // file fails spin-up with the problem named.
-    const dataDir = resolve(workerDir, "src/data");
-    materializeWorkerSchemaDataSources(manifest, dataDir);
-    const dataSources = readDataSources(dataDir);
-    console.log(dataSources.length > 0
-        ? `${label(basename(workerDir))} Data sources from src/data: ${dataSources
-            .map(source => source.name)
-            .join(", ")}`
-        : `${label(basename(workerDir))} No data sources — create src/data/<key>.json files ` +
-            `(format: node_modules/@notionhq/custom-blocks-dev-shell/docs/data-sources.md).`);
-    if (blocks.length > 0 &&
-        cliArgs.shellPort >= cliArgs.blockBasePort &&
-        cliArgs.shellPort < cliArgs.blockBasePort + blocks.length) {
-        throw new Error(`--port ${cliArgs.shellPort} collides with the block server ports ` +
-            `(${cliArgs.blockBasePort}–${cliArgs.blockBasePort + blocks.length - 1}); ` +
-            `pick a port outside that range or move --block-base-port.`);
-    }
-    const viteBin = blocks.length > 0 ? resolveViteBin(workerDir) : undefined;
-    const registry = buildBlockRegistry(blocks, cliArgs.blockBasePort);
-    for (const [index, capability] of blocks.entries()) {
-        const blockDir = resolve(workerDir, capability.config.source.path);
-        const configFile = writeBlockViteConfig(workerDir, blockDir, capability);
-        const port = cliArgs.blockBasePort + index;
-        const proc = spawn(process.execPath, [
-            viteBin,
-            "--config",
-            configFile,
-            "--port",
-            String(port),
-            "--strictPort",
-        ], {
-            cwd: workerDir,
-            stdio: ["ignore", "pipe", "inherit"],
-            // Process groups (and negative-PID kills) are POSIX-only; on
-            // Windows children are killed individually in shutdown().
-            detached: process.platform !== "win32",
-        });
-        if (proc.stdout !== null) {
-            createInterface({ input: proc.stdout }).on("line", makeChangeLogger(message => console.log(`${label(capability.key)} ${message}`)));
-        }
-        proc.on("exit", code => {
-            if (shuttingDown || code === 0 || code === null) {
-                return;
-            }
-            console.error(`${label(capability.key)} dev server exited with code ${code}`);
-            process.exitCode = code;
-            shutdown("SIGTERM");
-        });
-        procs.push(proc);
-    }
-    // The published layout is dist/ next to cli/; index.html must be prebuilt.
-    const distDir = resolve(__dirname, "..", "dist");
-    if (!existsSync(join(distDir, "index.html"))) {
-        throw new Error(`No prebuilt UI found at ${distDir}. This package was not assembled ` +
-            `correctly; reinstall it.`);
-    }
-    const prebuiltDir = resolve(__dirname, "..", "data");
-    try {
-        await serveUi(distDir, cliArgs.shellPort, {
-            blocks: registry,
-            dataSources,
-            prebuiltFilenames: readDataSources(prebuiltDir).map(source => source.filename),
-        }, () => {
-            const written = copyPrebuiltDataSources(prebuiltDir, dataDir);
-            if (written.length > 0) {
-                console.log(`${label(basename(workerDir))} Added pre-built data sources: ` +
-                    written.join(", "));
-            }
-            return readDataSources(dataDir);
-        });
-    }
-    catch (error) {
-        const code = error.code;
-        if (code === "EADDRINUSE") {
-            throw new Error(`Port ${cliArgs.shellPort} is already in use. Stop whatever holds it ` +
-                `or rerun with --port <port> (and --block-base-port <port> for the ` +
-                `block servers).`);
-        }
-        throw error;
-    }
-    console.log("");
-    console.log(`${bold}Dev shell${reset}`);
-    console.log(`  ${label("dev-shell")} ${dim}http://localhost:${cliArgs.shellPort}${reset}`);
-    if (blocks.length > 0) {
-        console.log("");
-        console.log(`${bold}Blocks${reset}`);
-        for (const [index, entry] of registry.entries()) {
-            console.log(`  ${label(entry.key)} ${dim}http://localhost:${cliArgs.blockBasePort + index}${reset}`);
-        }
-    }
-    console.log("");
-}
-function killProc(p, signal) {
-    if (p.pid === undefined || p.killed) {
-        return;
-    }
-    try {
-        if (process.platform === "win32") {
-            p.kill(signal);
-        }
-        else {
-            process.kill(-p.pid, signal);
-        }
-    }
-    catch { }
-}
-let shuttingDown = false;
-function shutdown(signal) {
-    if (shuttingDown) {
-        return;
-    }
-    shuttingDown = true;
-    if (signal !== "exit" && procs.length > 0) {
-        console.log(`\n${dim}Shutting down...${reset}`);
-    }
-    for (const p of procs) {
-        killProc(p, "SIGTERM");
-    }
-    setTimeout(() => {
-        for (const p of procs) {
-            killProc(p, "SIGKILL");
-        }
-        // Preserve a failure exit code set before shutdown (startup errors,
-        // crashed block servers); plain signal shutdowns still exit 0.
-        process.exit(process.exitCode ?? 0);
-    }, 1500).unref();
-}
-for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) {
-    process.on(signal, () => shutdown(signal));
-}
-process.on("exit", () => shutdown("exit"));
-process.on("uncaughtException", err => {
-    console.error(err);
-    process.exitCode = 1;
-    shutdown("SIGTERM");
-});
-main().catch(err => {
-    console.error(err instanceof Error ? err.message : err);
-    process.exitCode = 1;
-    shutdown("SIGTERM");
-});