@velajs/cli 0.2.0

package/README.md

@@ -0,0 +1,57 @@
+# @velajs/cli
+
+Node-side command-line tools for [Vela](https://github.com/velajs/vela) apps. Runs
+outside the edge Worker (it uses `node:*` / `process`), so it stays out of your
+Worker bundle.
+
+## Install
+
+```bash
+pnpm add -D @velajs/cli
+```
+
+## Commands
+
+| Command | What it does |
+| --- | --- |
+| `vela db seed` | Build the app and run all `@Seeder()` classes in order. |
+| `vela route list` | HTTP route table: framework-composed controller routes (`Controller#handler`, full paths incl. prefix/version) plus `(mounted)` extras (CRUD/contributed, doc UIs). |
+| `vela module graph` | Module graph: imports tree with `global`/`lazy` flags and provider counts (`--json` for the raw graph). |
+| `vela entrypoint list` | Declared entrypoint kinds (websocket, queue, cron, …) and their entries — lazy modules stay unmaterialized. |
+| `vela openapi dump` | Emit the OpenAPI document (needs `rootModule` in the config; `--out`, `--title`, `--api-version`, `--global-prefix`). |
+
+All introspection commands take `--config <path>` and `--json`.
+
+## Configure
+
+Create a `vela.config.{js,mjs,ts}` at your project root that builds your app.
+Wire your runtime bindings here (e.g. via miniflare for Cloudflare, or a Node
+adapter):
+
+```ts
+// vela.config.ts
+import { defineVelaConfig } from '@velajs/cli/config';
+import { AppModule } from './src/app.module';
+
+export default defineVelaConfig({
+  rootModule: AppModule, // optional — needed by `vela openapi dump`
+  async createApp() {
+    const { createCloudflareApp } = await import('@velajs/cloudflare');
+    return createCloudflareApp(AppModule);
+  },
+});
+```
+
+> `.ts` configs require a runtime that strips types (Node 22+
+> `--experimental-strip-types`, or `tsx`). `.js`/`.mjs` load directly.
+
+## Commands
+
+```bash
+# Run all @Seeder() classes (see @velajs/vela/seeder), in order:
+vela db seed
+vela db seed --config ./config/vela.config.js
+vela db seed --continue-on-error
+```
+
+Exit code is `0` when all seeders run and `1` if any fail.

package/dist/commands/introspect.commands.d.ts

@@ -0,0 +1,40 @@
+import type { VelaApplication } from '@velajs/vela';
+import { Command } from 'clipanion';
+/** Shared shell: load config → createApp → run → best-effort dispose. */
+declare abstract class AppCommand extends Command {
+    config: string | undefined;
+    json: boolean;
+    protected abstract run(app: VelaApplication): Promise<number>;
+    execute(): Promise<number>;
+    protected print(text: string): void;
+}
+/** `vela route list` — the app's HTTP route table. */
+export declare class RouteListCommand extends AppCommand {
+    static paths: string[][];
+    static usage: import("clipanion").Usage;
+    protected run(app: VelaApplication): Promise<number>;
+}
+/** `vela module graph` — the loaded module graph. */
+export declare class ModuleGraphCommand extends AppCommand {
+    static paths: string[][];
+    static usage: import("clipanion").Usage;
+    protected run(app: VelaApplication): Promise<number>;
+}
+/** `vela entrypoint list` — declared entrypoint kinds and their entries. */
+export declare class EntrypointListCommand extends AppCommand {
+    static paths: string[][];
+    static usage: import("clipanion").Usage;
+    protected run(app: VelaApplication): Promise<number>;
+}
+/** `vela openapi dump` — emit the OpenAPI document. */
+export declare class OpenApiDumpCommand extends Command {
+    static paths: string[][];
+    static usage: import("clipanion").Usage;
+    config: string | undefined;
+    out: string | undefined;
+    title: string | undefined;
+    apiVersion: string | undefined;
+    globalPrefix: string | undefined;
+    execute(): Promise<number>;
+}
+export {};

package/dist/commands/introspect.commands.js

@@ -0,0 +1,165 @@
+import { writeFile } from 'node:fs/promises';
+import { createOpenApiDocument } from '@velajs/vela';
+import { Command, Option } from 'clipanion';
+import { loadConfig } from '../config.js';
+import { renderTable } from '../format.js';
+import { collectEntrypoints, collectModules, collectRoutes, renderModuleTree } from '../introspect.js';
+/** Shared shell: load config → createApp → run → best-effort dispose. */
+class AppCommand extends Command {
+    config = Option.String('--config', { description: 'Path to the vela config file.' });
+    json = Option.Boolean('--json', false, { description: 'Emit machine-readable JSON.' });
+    async execute() {
+        const velaConfig = await loadConfig(process.cwd(), this.config);
+        const app = await velaConfig.createApp();
+        try {
+            return await this.run(app);
+        }
+        finally {
+            const dispose = app.dispose;
+            if (typeof dispose === 'function') {
+                try {
+                    await dispose.call(app);
+                }
+                catch (error) {
+                    this.context.stderr.write(`Warning: teardown failed: ${String(error)}\n`);
+                }
+            }
+        }
+    }
+    print(text) {
+        this.context.stdout.write(`${text}\n`);
+    }
+}
+/** `vela route list` — the app's HTTP route table. */
+export class RouteListCommand extends AppCommand {
+    static paths = [['route', 'list']];
+    static usage = Command.Usage({
+        category: 'Introspection',
+        description: 'List the HTTP routes of the Vela app.',
+        details: 'Framework-composed controller routes (method, full path, controller#handler) plus ' +
+            'everything else mounted on the router (CRUD/contributed routes, doc UIs) labeled (mounted).',
+        examples: [['List routes', 'vela route list'], ['As JSON', 'vela route list --json']],
+    });
+    async run(app) {
+        const rows = collectRoutes(app);
+        if (rows === null) {
+            this.print('This app builds no HTTP routes — nothing to list.');
+            return 0;
+        }
+        if (this.json) {
+            this.print(JSON.stringify(rows, null, 2));
+            return 0;
+        }
+        for (const line of renderTable(['METHOD', 'PATH', 'HANDLER'], rows.map((r) => [r.method, r.path, r.handler]))) {
+            this.print(line);
+        }
+        return 0;
+    }
+}
+/** `vela module graph` — the loaded module graph. */
+export class ModuleGraphCommand extends AppCommand {
+    static paths = [['module', 'graph']];
+    static usage = Command.Usage({
+        category: 'Introspection',
+        description: 'Print the module graph of the Vela app.',
+        details: 'Module instances with their imports (indented tree), global/lazy flags, and provider ' +
+            'counts. --json emits the raw descriptions (providers, exports, imports per module).',
+        examples: [['Print the graph', 'vela module graph'], ['As JSON', 'vela module graph --json']],
+    });
+    async run(app) {
+        const modules = collectModules(app);
+        if (this.json) {
+            this.print(JSON.stringify(modules, null, 2));
+            return 0;
+        }
+        for (const line of renderModuleTree(modules))
+            this.print(line);
+        return 0;
+    }
+}
+/** `vela entrypoint list` — declared entrypoint kinds and their entries. */
+export class EntrypointListCommand extends AppCommand {
+    static paths = [['entrypoint', 'list']];
+    static usage = Command.Usage({
+        category: 'Introspection',
+        description: 'List entrypoint kinds and entries (websocket, queue, cron, …).',
+        details: 'Every declared kind — including kinds with zero entries — with the contributing ' +
+            'class (and method for method-level kinds) and its metadata.',
+        examples: [['List entrypoints', 'vela entrypoint list']],
+    });
+    async run(app) {
+        const rows = collectEntrypoints(app);
+        if (this.json) {
+            this.print(JSON.stringify(rows, null, 2));
+            return 0;
+        }
+        for (const line of renderTable(['KIND', 'TARGET', 'META'], rows.map((r) => [r.kind, r.target, r.meta]))) {
+            this.print(line);
+        }
+        return 0;
+    }
+}
+/** `vela openapi dump` — emit the OpenAPI document. */
+export class OpenApiDumpCommand extends Command {
+    static paths = [['openapi', 'dump']];
+    static usage = Command.Usage({
+        category: 'Introspection',
+        description: 'Emit the OpenAPI document for the Vela app.',
+        details: "Requires `rootModule` in vela.config (createOpenApiDocument works from the module " +
+            "class). The app's global prefix is applied automatically; --global-prefix overrides.",
+        examples: [
+            ['Print to stdout', 'vela openapi dump'],
+            ['Write to a file', 'vela openapi dump --out openapi.json'],
+        ],
+    });
+    config = Option.String('--config', { description: 'Path to the vela config file.' });
+    out = Option.String('--out', { description: 'Write the document to this file instead of stdout.' });
+    title = Option.String('--title', { description: 'info.title override.' });
+    apiVersion = Option.String('--api-version', { description: 'info.version override.' });
+    globalPrefix = Option.String('--global-prefix', {
+        description: "Path prefix override (defaults to the app's global prefix).",
+    });
+    async execute() {
+        const velaConfig = await loadConfig(process.cwd(), this.config);
+        if (!velaConfig.rootModule) {
+            this.context.stderr.write("openapi dump needs the root module. Add it to your vela.config:\n\n" +
+                '  export default defineVelaConfig({\n' +
+                '    rootModule: AppModule,\n' +
+                '    async createApp() { ... },\n' +
+                '  });\n');
+            return 1;
+        }
+        const app = await velaConfig.createApp();
+        try {
+            const info = {};
+            if (this.title)
+                info.title = this.title;
+            if (this.apiVersion)
+                info.version = this.apiVersion;
+            const document = createOpenApiDocument(velaConfig.rootModule, {
+                globalPrefix: this.globalPrefix ?? app.getGlobalPrefix(),
+                ...(Object.keys(info).length > 0 ? { info } : {}),
+            });
+            const text = JSON.stringify(document, null, 2);
+            if (this.out) {
+                await writeFile(this.out, `${text}\n`, 'utf8');
+                this.context.stdout.write(`Wrote ${this.out}\n`);
+            }
+            else {
+                this.context.stdout.write(`${text}\n`);
+            }
+            return 0;
+        }
+        finally {
+            const dispose = app.dispose;
+            if (typeof dispose === 'function') {
+                try {
+                    await dispose.call(app);
+                }
+                catch (error) {
+                    this.context.stderr.write(`Warning: teardown failed: ${String(error)}\n`);
+                }
+            }
+        }
+    }
+}

package/dist/commands/seed.command.d.ts

@@ -0,0 +1,9 @@
+import { Command } from 'clipanion';
+/** `vela db seed` — build the app from vela.config and run its seeders. */
+export declare class SeedCommand extends Command {
+    static paths: string[][];
+    static usage: import("clipanion").Usage;
+    config: string | undefined;
+    continueOnError: boolean;
+    execute(): Promise<number>;
+}

package/dist/commands/seed.command.js

@@ -0,0 +1,40 @@
+import { runSeeders } from '@velajs/vela/seeder';
+import { Command, Option } from 'clipanion';
+import { loadConfig } from '../config.js';
+import { formatSeedResults } from '../format.js';
+/** `vela db seed` — build the app from vela.config and run its seeders. */
+export class SeedCommand extends Command {
+    static paths = [['db', 'seed']];
+    static usage = Command.Usage({
+        category: 'Database',
+        description: 'Run database seeders for the Vela app.',
+        details: 'Loads vela.config.{js,mjs,ts}, builds the app, and runs all @Seeder() classes in order.',
+        examples: [
+            ['Run all seeders', 'vela db seed'],
+            ['Use a specific config', 'vela db seed --config ./config/vela.config.js'],
+        ],
+    });
+    config = Option.String('--config', { description: 'Path to the vela config file.' });
+    continueOnError = Option.Boolean('--continue-on-error', false, {
+        description: 'Run all seeders even if one fails.',
+    });
+    async execute() {
+        const { createApp } = await loadConfig(process.cwd(), this.config);
+        const app = await createApp();
+        this.context.stdout.write('Running seeders…\n');
+        const results = await runSeeders(app, { stopOnError: !this.continueOnError });
+        const code = formatSeedResults(results, (message) => this.context.stdout.write(`${message}\n`));
+        // Best-effort teardown (VelaApplication.dispose exists on recent versions).
+        // Must not clobber the computed exit code if a shutdown hook throws.
+        const dispose = app.dispose;
+        if (typeof dispose === 'function') {
+            try {
+                await dispose.call(app);
+            }
+            catch (error) {
+                this.context.stderr.write(`Warning: teardown failed after seeding: ${String(error)}\n`);
+            }
+        }
+        return code;
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,33 @@
+import type { Type, VelaApplication } from '@velajs/vela';
+/**
+ * A `vela.config.{js,mjs,ts}` default-exports (or exports `config`) this shape.
+ * You wire your runtime bindings inside `createApp` — e.g. via miniflare for a
+ * Cloudflare Worker, or a plain Node adapter — and return a built app.
+ *
+ * ```ts
+ * // vela.config.ts
+ * import { defineVelaConfig } from '@velajs/cli/config';
+ * export default defineVelaConfig({
+ *   async createApp() {
+ *     const { createCloudflareApp } = await import('@velajs/cloudflare');
+ *     return createCloudflareApp(AppModule);
+ *   },
+ * });
+ * ```
+ */
+export interface VelaConfig {
+    createApp(): Promise<VelaApplication> | VelaApplication;
+    /**
+     * The app's root module class — needed only by commands that work from
+     * module metadata rather than the built app (`vela openapi dump`).
+     */
+    rootModule?: Type;
+}
+/** Identity helper for type-safe config files. */
+export declare function defineVelaConfig(config: VelaConfig): VelaConfig;
+/**
+ * Locate + import the vela config. `.ts` requires a runtime that strips types
+ * (Node 22+ `--experimental-strip-types`, or tsx/ts-node); `.js`/`.mjs` load
+ * directly.
+ */
+export declare function loadConfig(cwd?: string, explicitPath?: string): Promise<VelaConfig>;

package/dist/config.js

@@ -0,0 +1,42 @@
+import { access } from 'node:fs/promises';
+import { isAbsolute, join, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+/** Identity helper for type-safe config files. */
+export function defineVelaConfig(config) {
+    return config;
+}
+const CANDIDATES = ['vela.config.js', 'vela.config.mjs', 'vela.config.ts'];
+/**
+ * Locate + import the vela config. `.ts` requires a runtime that strips types
+ * (Node 22+ `--experimental-strip-types`, or tsx/ts-node); `.js`/`.mjs` load
+ * directly.
+ */
+export async function loadConfig(cwd = process.cwd(), explicitPath) {
+    const path = explicitPath
+        ? isAbsolute(explicitPath)
+            ? explicitPath
+            : resolve(cwd, explicitPath)
+        : await findConfig(cwd);
+    if (!path) {
+        throw new Error(`No vela config found. Create one of: ${CANDIDATES.join(', ')} (or pass --config <path>).`);
+    }
+    const mod = (await import(pathToFileURL(path).href));
+    const config = mod.default ?? mod.config;
+    if (!config || typeof config.createApp !== 'function') {
+        throw new Error(`Config at ${path} must export { createApp(): Promise<VelaApplication> } (default export or a named 'config').`);
+    }
+    return config;
+}
+async function findConfig(cwd) {
+    for (const name of CANDIDATES) {
+        const candidate = join(cwd, name);
+        try {
+            await access(candidate);
+            return candidate;
+        }
+        catch {
+            // try next
+        }
+    }
+    return undefined;
+}

package/dist/format.d.ts

@@ -0,0 +1,8 @@
+import type { SeederResult } from '@velajs/vela/seeder';
+/**
+ * Render seeder results to a logger and return a process exit code
+ * (0 = all ran, 1 = at least one failed). Pure — no I/O beyond the logger.
+ */
+export declare function formatSeedResults(results: SeederResult[], log?: (message: string) => void): number;
+/** Aligned plain-text table. Pure; returns lines. */
+export declare function renderTable(headers: string[], rows: string[][]): string[];

package/dist/format.js

@@ -0,0 +1,32 @@
+/**
+ * Render seeder results to a logger and return a process exit code
+ * (0 = all ran, 1 = at least one failed). Pure — no I/O beyond the logger.
+ */
+export function formatSeedResults(results, log = (m) => console.log(m)) {
+    if (results.length === 0) {
+        log('No seeders found.');
+        return 0;
+    }
+    let failed = 0;
+    for (const result of results) {
+        if (result.ok) {
+            log(`  ✓ ${result.name}`);
+        }
+        else {
+            failed++;
+            log(`  ✗ ${result.name}${result.error ? `: ${errorMessage(result.error)}` : ''}`);
+        }
+    }
+    const total = results.length;
+    log(`\n${total - failed}/${total} seeders ran successfully.`);
+    return failed > 0 ? 1 : 0;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/** Aligned plain-text table. Pure; returns lines. */
+export function renderTable(headers, rows) {
+    const widths = headers.map((h, i) => Math.max(h.length, ...rows.map((r) => (r[i] ?? '').length)));
+    const line = (cells) => cells.map((c, i) => (c ?? '').padEnd(widths[i])).join('  ').trimEnd();
+    return [line(headers), line(widths.map((w) => '-'.repeat(w))), ...rows.map(line)];
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+export { SeedCommand } from './commands/seed.command.js';
+export { EntrypointListCommand, ModuleGraphCommand, OpenApiDumpCommand, RouteListCommand, } from './commands/introspect.commands.js';
+export { collectRoutes, collectModules, collectEntrypoints, renderModuleTree } from './introspect.js';
+export type { RouteRow, EntrypointRow } from './introspect.js';
+export { renderTable } from './format.js';
+export { loadConfig, defineVelaConfig } from './config.js';
+export type { VelaConfig } from './config.js';
+export { formatSeedResults } from './format.js';

package/dist/index.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+import { Builtins, Cli } from 'clipanion';
+import { EntrypointListCommand, ModuleGraphCommand, OpenApiDumpCommand, RouteListCommand, } from './commands/introspect.commands.js';
+import { SeedCommand } from './commands/seed.command.js';
+const cli = new Cli({
+    binaryName: 'vela',
+    binaryLabel: 'Vela CLI',
+    binaryVersion: '0.2.0',
+});
+cli.register(Builtins.HelpCommand);
+cli.register(Builtins.VersionCommand);
+cli.register(SeedCommand);
+cli.register(RouteListCommand);
+cli.register(ModuleGraphCommand);
+cli.register(EntrypointListCommand);
+cli.register(OpenApiDumpCommand);
+void cli.runExit(process.argv.slice(2));
+export { SeedCommand } from './commands/seed.command.js';
+export { EntrypointListCommand, ModuleGraphCommand, OpenApiDumpCommand, RouteListCommand, } from './commands/introspect.commands.js';
+export { collectRoutes, collectModules, collectEntrypoints, renderModuleTree } from './introspect.js';
+export { renderTable } from './format.js';
+export { loadConfig, defineVelaConfig } from './config.js';
+export { formatSeedResults } from './format.js';

package/dist/introspect.d.ts

@@ -0,0 +1,32 @@
+import type { VelaApplication } from '@velajs/vela';
+import type { ModuleDescription } from '@velajs/vela';
+/** One row of `vela route list`. */
+export interface RouteRow {
+    method: string;
+    path: string;
+    /** `Controller#handler`, or `(mounted)` for routes vela did not compose
+     * itself (RouteContributor/CRUD, OpenAPI UI mounts, manual Hono routes). */
+    handler: string;
+    source: 'controller' | 'mounted';
+}
+/**
+ * The app's route table: `describeRoutes()` rows (framework-composed truth)
+ * plus everything else present on the Hono router, deduped and labeled
+ * `(mounted)`. Returns null when the app never built HTTP routes.
+ */
+export declare function collectRoutes(app: VelaApplication): RouteRow[] | null;
+/** `vela module graph` tree lines (or raw descriptions for --json). */
+export declare function collectModules(app: VelaApplication): ModuleDescription[];
+export declare function renderModuleTree(modules: ModuleDescription[]): string[];
+/** One row of `vela entrypoint list`. */
+export interface EntrypointRow {
+    kind: string;
+    target: string;
+    meta: string;
+}
+/**
+ * Every DECLARED entrypoint kind (from the global kind store — includes kinds
+ * with zero entries) joined with the app's entries. Metadata-only entries of
+ * lazy modules list fine; nothing materializes.
+ */
+export declare function collectEntrypoints(app: VelaApplication): EntrypointRow[];

package/dist/introspect.js

@@ -0,0 +1,103 @@
+import { describeToken, getEntrypointKinds } from '@velajs/vela';
+/**
+ * The app's route table: `describeRoutes()` rows (framework-composed truth)
+ * plus everything else present on the Hono router, deduped and labeled
+ * `(mounted)`. Returns null when the app never built HTTP routes.
+ */
+export function collectRoutes(app) {
+    let described;
+    try {
+        described = app.describeRoutes();
+    }
+    catch {
+        return null; // no HTTP routes built (slim/non-HTTP app)
+    }
+    const rows = described.map((r) => ({
+        method: r.method,
+        path: r.path,
+        handler: `${r.controller}#${r.handler}`,
+        source: 'controller',
+    }));
+    const covered = new Set(described.map((r) => `${r.method} ${r.path}`));
+    for (const r of described) {
+        // @Head handlers are served by Hono under GET — claim that row too so it
+        // doesn't reappear as a mounted duplicate.
+        if (r.method === 'HEAD')
+            covered.add(`GET ${r.path}`);
+    }
+    const seenMounted = new Set();
+    for (const honoRoute of app.getHonoApp().routes) {
+        // 'ALL' entries are middleware mounts (framework-internal disposal/context
+        // wrappers, global + scoped middleware) — not endpoints.
+        if (honoRoute.method === 'ALL')
+            continue;
+        const key = `${honoRoute.method} ${honoRoute.path}`;
+        if (covered.has(key) || seenMounted.has(key))
+            continue;
+        seenMounted.add(key);
+        rows.push({ method: honoRoute.method, path: honoRoute.path, handler: '(mounted)', source: 'mounted' });
+    }
+    return rows.sort((a, b) => a.path.localeCompare(b.path) || a.method.localeCompare(b.method));
+}
+/** `vela module graph` tree lines (or raw descriptions for --json). */
+export function collectModules(app) {
+    return app.getContainer().getModuleDescriptions();
+}
+export function renderModuleTree(modules) {
+    const byId = new Map(modules.map((m) => [m.moduleId, m]));
+    const imported = new Set(modules.flatMap((m) => m.imports));
+    const roots = modules.filter((m) => !imported.has(m.moduleId));
+    const lines = [];
+    const render = (id, depth, trail) => {
+        const mod = byId.get(id);
+        const flags = mod
+            ? [mod.isGlobal ? 'global' : null, mod.lazy ? 'lazy' : null].filter(Boolean)
+            : [];
+        const suffix = flags.length > 0 ? ` (${flags.join(', ')})` : '';
+        const providers = mod ? ` — ${mod.providers.length} provider${mod.providers.length === 1 ? '' : 's'}` : '';
+        lines.push(`${'  '.repeat(depth)}${id}${suffix}${providers}`);
+        if (!mod || trail.has(id))
+            return;
+        const nextTrail = new Set(trail).add(id);
+        for (const child of mod.imports)
+            render(child, depth + 1, nextTrail);
+    };
+    for (const root of roots)
+        render(root.moduleId, 0, new Set());
+    return lines;
+}
+function safeMeta(meta) {
+    try {
+        return JSON.stringify(meta, (_key, value) => typeof value === 'function'
+            ? '[function]'
+            : typeof value === 'object' && value !== null && value.constructor !== Object && !Array.isArray(value)
+                ? `[${value.constructor.name}]`
+                : value) ?? 'undefined';
+    }
+    catch {
+        return '[unserializable]';
+    }
+}
+/**
+ * Every DECLARED entrypoint kind (from the global kind store — includes kinds
+ * with zero entries) joined with the app's entries. Metadata-only entries of
+ * lazy modules list fine; nothing materializes.
+ */
+export function collectEntrypoints(app) {
+    const rows = [];
+    const declared = getEntrypointKinds().map((k) => k.kind);
+    const populated = app.entrypoints.kinds();
+    const kinds = [...new Set([...declared, ...populated])];
+    for (const kind of kinds) {
+        const entries = app.entrypoints.ofKind(kind);
+        if (entries.length === 0) {
+            rows.push({ kind, target: '(no entrypoints)', meta: '' });
+            continue;
+        }
+        for (const ep of entries) {
+            const method = ep.methodName !== undefined ? `#${String(ep.methodName)}` : '';
+            rows.push({ kind, target: `${describeToken(ep.token)}${method}`, meta: safeMeta(ep.meta) });
+        }
+    }
+    return rows;
+}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@velajs/cli",
+  "version": "0.2.0",
+  "description": "CLI for Vela apps — seeding and project tasks (Node-side; not bundled into the edge Worker)",
+  "type": "module",
+  "bin": {
+    "vela": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./config": {
+      "types": "./dist/config.d.ts",
+      "import": "./dist/config.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "clipanion": "^4.0.0-rc.4"
+  },
+  "peerDependencies": {
+    "@velajs/vela": ">=1.15.0"
+  },
+  "devDependencies": {
+    "@swc/core": "^1.15.43",
+    "@types/node": "^22.0.0",
+    "@velajs/vela": "^1.15.0",
+    "typescript": "^6.0.3",
+    "unplugin-swc": "^1.5.9",
+    "vitest": "^4.1.9"
+  },
+  "keywords": [
+    "vela",
+    "cli",
+    "seeder",
+    "edge",
+    "cloudflare-workers"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "build": "rm -rf dist && tsc",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  }
+}