@tyndall/cli 0.0.1

package/README.md

@@ -0,0 +1,30 @@
+# @tyndall/cli
+
+## Overview
+Command-line interface package that dispatches framework commands and normalizes execution flags.
+
+## Responsibilities
+- Parse and dispatch CLI commands
+- Bridge user flags into build, dev, and runtime options
+- Standardize CLI logging and error formatting
+- Expose the `cloud-front` executable for app/package scripts
+- Run the published `cloud-front` executable with Bun for dev command compatibility with TS/TSX route loading
+
+## Public API Highlights
+- runCli
+- parseArgs
+- formatUsage
+
+## Development
+- Build: bun run --filter @tyndall/cli build
+- Test (from workspace root): bun test
+
+## Documentation
+- Package specification: [spec.md](./spec.md)
+- Package architecture: [architecture.md](./architecture.md)
+- Package changes: [CHANGELOG.md](./CHANGELOG.md)
+
+## Maintenance Rules
+- Keep this document aligned with implemented package behavior.
+- Update spec.md and architecture.md whenever package contracts or design boundaries change.
+- Record user-visible package changes in CHANGELOG.md.

package/bin/cloud-front.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env bun
+import { runCli } from "../dist/dispatcher.js";
+
+const exitCode = await runCli(process.argv.slice(2));
+if (exitCode !== 0) {
+  process.exitCode = exitCode;
+}

package/dist/adapter-registry.d.ts

@@ -0,0 +1,9 @@
+import type { UIAdapterRegistry } from "@tyndall/core";
+export interface ResolveAdapterRegistryOptions {
+    explicitRegistry?: UIAdapterRegistry;
+    reactRegistryLoader?: () => Promise<UIAdapterRegistry | undefined>;
+    webComponentsRegistryLoader?: () => Promise<UIAdapterRegistry | undefined>;
+    wasmRegistryLoader?: () => Promise<UIAdapterRegistry | undefined>;
+}
+export declare const resolveAdapterRegistry: (options?: ResolveAdapterRegistryOptions) => Promise<UIAdapterRegistry | undefined>;
+//# sourceMappingURL=adapter-registry.d.ts.map

package/dist/adapter-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter-registry.d.ts","sourceRoot":"","sources":["../src/adapter-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAcvD,MAAM,WAAW,6BAA6B;IAC5C,gBAAgB,CAAC,EAAE,iBAAiB,CAAC;IACrC,mBAAmB,CAAC,EAAE,MAAM,OAAO,CAAC,iBAAiB,GAAG,SAAS,CAAC,CAAC;IACnE,2BAA2B,CAAC,EAAE,MAAM,OAAO,CAAC,iBAAiB,GAAG,SAAS,CAAC,CAAC;IAC3E,kBAAkB,CAAC,EAAE,MAAM,OAAO,CAAC,iBAAiB,GAAG,SAAS,CAAC,CAAC;CACnE;AA6CD,eAAO,MAAM,sBAAsB,GACjC,UAAS,6BAAkC,KAC1C,OAAO,CAAC,iBAAiB,GAAG,SAAS,CAmBvC,CAAC"}

package/dist/adapter-registry.js

@@ -0,0 +1,61 @@
+const loadReactAdapterRegistry = async () => {
+    try {
+        const module = (await import("@tyndall/react"));
+        const createRegistry = module.createReactAdapterRegistry;
+        return typeof createRegistry === "function" ? createRegistry() : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+const loadWebComponentsAdapterRegistry = async () => {
+    try {
+        const module = (await import("@tyndall/webcomponents"));
+        const createRegistry = module.createWebComponentsAdapterRegistry;
+        return typeof createRegistry === "function" ? createRegistry() : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+const loadWasmAdapterRegistry = async () => {
+    try {
+        const module = (await import("@tyndall/wasm"));
+        const createRegistry = module.createWasmAdapterRegistry;
+        return typeof createRegistry === "function" ? createRegistry() : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+const mergeRegistries = (registries) => {
+    const merged = {};
+    for (const registry of registries) {
+        if (!registry) {
+            continue;
+        }
+        Object.assign(merged, registry);
+    }
+    return Object.keys(merged).length > 0 ? merged : undefined;
+};
+export const resolveAdapterRegistry = async (options = {}) => {
+    if (options.explicitRegistry) {
+        return options.explicitRegistry;
+    }
+    const loaders = [
+        options.reactRegistryLoader ?? loadReactAdapterRegistry,
+        options.webComponentsRegistryLoader ?? loadWebComponentsAdapterRegistry,
+        options.wasmRegistryLoader ?? loadWasmAdapterRegistry,
+    ];
+    const registries = [];
+    for (const load of loaders) {
+        // Keep optional UI runtime loading non-fatal so factory adapters still work.
+        try {
+            registries.push(await load());
+        }
+        catch {
+            registries.push(undefined);
+        }
+    }
+    return mergeRegistries(registries);
+};

package/dist/args.d.ts

@@ -0,0 +1,3 @@
+import type { ParsedArgs } from "./types.js";
+export declare const parseArgs: (argv: string[]) => ParsedArgs;
+//# sourceMappingURL=args.d.ts.map

package/dist/args.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"args.d.ts","sourceRoot":"","sources":["../src/args.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAsB,UAAU,EAAE,MAAM,YAAY,CAAC;AA4BjE,eAAO,MAAM,SAAS,GAAI,MAAM,MAAM,EAAE,KAAG,UA4D1C,CAAC"}

package/dist/args.js

@@ -0,0 +1,85 @@
+const NUMBER_PATTERN = /^-?\d+(?:\.\d+)?$/;
+const coerceValue = (raw) => {
+    if (raw === "true") {
+        return true;
+    }
+    if (raw === "false") {
+        return false;
+    }
+    if (NUMBER_PATTERN.test(raw)) {
+        return Number(raw);
+    }
+    return raw;
+};
+const applyFlag = (flags, name, value) => {
+    flags[name] = value;
+    if (name.startsWith("no-") && value === true) {
+        // Keep --no-<flag> normalized to a single false entry for downstream handlers.
+        const positive = name.slice(3);
+        if (positive.length > 0) {
+            flags[positive] = false;
+        }
+    }
+};
+export const parseArgs = (argv) => {
+    const flags = {};
+    const positionals = [];
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token === "--") {
+            positionals.push(...argv.slice(index + 1));
+            break;
+        }
+        if (token.startsWith("--") && token.length > 2) {
+            const raw = token.slice(2);
+            const equalsIndex = raw.indexOf("=");
+            if (equalsIndex >= 0) {
+                const name = raw.slice(0, equalsIndex);
+                const rawValue = raw.slice(equalsIndex + 1);
+                applyFlag(flags, name, coerceValue(rawValue));
+            }
+            else {
+                const next = argv[index + 1];
+                if (next && !next.startsWith("-")) {
+                    applyFlag(flags, raw, coerceValue(next));
+                    index += 1;
+                }
+                else {
+                    applyFlag(flags, raw, true);
+                }
+            }
+            continue;
+        }
+        if (token.startsWith("-") && token.length > 1) {
+            if (token === "-h") {
+                applyFlag(flags, "help", true);
+            }
+            else if (token === "-v") {
+                applyFlag(flags, "version", true);
+            }
+            else {
+                for (const char of token.slice(1)) {
+                    if (char === "h") {
+                        applyFlag(flags, "help", true);
+                    }
+                    else if (char === "v") {
+                        applyFlag(flags, "version", true);
+                    }
+                    else {
+                        applyFlag(flags, char, true);
+                    }
+                }
+            }
+            continue;
+        }
+        positionals.push(token);
+    }
+    const command = positionals.shift() ?? null;
+    return {
+        command,
+        args: positionals,
+        flags,
+        help: Boolean(flags.help),
+        version: Boolean(flags.version),
+    };
+};

package/dist/commands/build.d.ts

@@ -0,0 +1,24 @@
+import type { CommandHandler } from "../types.js";
+export interface BuildCommandOptions {
+    rootDir: string;
+    mode: "ssg" | "ssr";
+    outDir?: string;
+    cache: {
+        enabled: boolean;
+        dir?: string;
+        maxSizeMB?: number;
+        maxAgeDays?: number;
+    };
+}
+export interface BuildCommandDeps {
+    build: (options: BuildCommandOptions & {
+        adapterRegistry?: unknown;
+    }) => Promise<{
+        outDir: string;
+    }>;
+    cwd?: () => string;
+    resolveAdapterRegistry?: () => Promise<unknown>;
+}
+export declare const createBuildCommand: (deps: BuildCommandDeps) => CommandHandler;
+export declare const runBuildCommand: CommandHandler;
+//# sourceMappingURL=build.d.ts.map

package/dist/commands/build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../src/commands/build.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAW,MAAM,aAAa,CAAC;AAE3D,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,KAAK,GAAG,KAAK,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE;QACL,OAAO,EAAE,OAAO,CAAC;QACjB,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,CAAC;CACH;AAED,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,CAAC,OAAO,EAAE,mBAAmB,GAAG;QAAE,eAAe,CAAC,EAAE,OAAO,CAAA;KAAE,KAAK,OAAO,CAAC;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACrG,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IACnB,sBAAsB,CAAC,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;CACjD;AAsCD,eAAO,MAAM,kBAAkB,GAAI,MAAM,gBAAgB,KAAG,cAc3D,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,cAc7B,CAAC"}

package/dist/commands/build.js

@@ -0,0 +1,59 @@
+const readNumber = (value) => {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === "string") {
+        const parsed = Number(value);
+        return Number.isFinite(parsed) ? parsed : undefined;
+    }
+    return undefined;
+};
+const resolveBuildOptions = (flags, cwd) => {
+    const mode = flags.mode === "ssr" ? "ssr" : "ssg";
+    const outDir = typeof flags.outDir === "string"
+        ? flags.outDir
+        : typeof flags["out-dir"] === "string"
+            ? flags["out-dir"]
+            : undefined;
+    const cacheEnabled = flags.cache !== false;
+    const cacheDir = typeof flags["cache-dir"] === "string" ? flags["cache-dir"] : undefined;
+    return {
+        rootDir: cwd,
+        mode,
+        outDir,
+        cache: {
+            enabled: cacheEnabled,
+            dir: cacheDir,
+            maxSizeMB: readNumber(flags["cache-max-size-mb"]),
+            maxAgeDays: readNumber(flags["cache-max-age-days"]),
+        },
+    };
+};
+export const createBuildCommand = (deps) => {
+    return async ({ flags, io }) => {
+        const cwd = deps.cwd ? deps.cwd() : process.cwd();
+        const options = resolveBuildOptions(flags, cwd);
+        io.stdout.write(`Build started in ${options.rootDir}\n`);
+        if (!options.cache.enabled) {
+            io.stdout.write("Build cache disabled.\n");
+        }
+        const result = await deps.build(options);
+        io.stdout.write(`Build completed: ${result.outDir}\n`);
+        return 0;
+    };
+};
+export const runBuildCommand = async (context) => {
+    const { build } = await import("@tyndall/build");
+    const { resolveAdapterRegistry } = await import("../adapter-registry.js");
+    const command = createBuildCommand({
+        resolveAdapterRegistry,
+        build: async (options) => {
+            const adapterRegistry = await resolveAdapterRegistry();
+            return build({
+                ...options,
+                adapterRegistry,
+            });
+        },
+    });
+    return command(context);
+};

package/dist/commands/dev.d.ts

@@ -0,0 +1,25 @@
+import type { CommandHandler } from "../types.js";
+import type { UIAdapterRegistry } from "@tyndall/core";
+export interface DevCommandOptions {
+    port: number;
+    host: string;
+    open: boolean;
+    ssr: boolean;
+    adapterRegistry?: UIAdapterRegistry;
+}
+export interface DevCommandDeps {
+    startDevServer: (options: DevCommandOptions) => Promise<{
+        url: string;
+        close: () => Promise<void> | void;
+    }>;
+    openUrl?: (url: string) => Promise<void> | void;
+}
+export declare const createDevCommand: (deps: DevCommandDeps) => CommandHandler;
+export declare const isBunRuntime: (runtime?: unknown) => boolean;
+export declare const ensureDevRuntimeSupported: (io: {
+    stderr: {
+        write: (text: string) => void;
+    };
+}, runtime?: unknown) => boolean;
+export declare const runDevCommand: CommandHandler;
+//# sourceMappingURL=dev.d.ts.map

package/dist/commands/dev.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../../src/commands/dev.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAW,MAAM,aAAa,CAAC;AAC3D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAGvD,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,OAAO,CAAC;IACd,GAAG,EAAE,OAAO,CAAC;IACb,eAAe,CAAC,EAAE,iBAAiB,CAAC;CACrC;AAED,MAAM,WAAW,cAAc;IAC7B,cAAc,EAAE,CAAC,OAAO,EAAE,iBAAiB,KAAK,OAAO,CAAC;QACtD,GAAG,EAAE,MAAM,CAAC;QACZ,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;KACnC,CAAC,CAAC;IACH,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CACjD;AA2CD,eAAO,MAAM,gBAAgB,GAAI,MAAM,cAAc,KAAG,cAoBvD,CAAC;AAEF,eAAO,MAAM,YAAY,GAAI,UAAS,OAAiB,YACd,CAAC;AAE1C,eAAO,MAAM,yBAAyB,GACpC,IAAI;IACF,MAAM,EAAE;QAAE,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;KAAE,CAAC;CAC3C,EACD,UAAS,OAAiB,YAa3B,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,cAgB3B,CAAC"}

package/dist/commands/dev.js

@@ -0,0 +1,85 @@
+import { resolveAdapterRegistry } from "../adapter-registry.js";
+const DEFAULT_PORT = 3000;
+const DEFAULT_HOST = "localhost";
+const readRuntimeBunVersion = (runtime) => {
+    if (!runtime || typeof runtime !== "object") {
+        return null;
+    }
+    const versions = runtime.versions;
+    if (!versions || typeof versions !== "object") {
+        return null;
+    }
+    const bunVersion = versions.bun;
+    return typeof bunVersion === "string" && bunVersion.length > 0
+        ? bunVersion
+        : null;
+};
+const normalizePort = (flags) => {
+    const raw = flags.port ?? flags.p;
+    if (typeof raw === "number" && Number.isFinite(raw)) {
+        return raw;
+    }
+    if (typeof raw === "string") {
+        const parsed = Number(raw);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    return DEFAULT_PORT;
+};
+const resolveDevOptions = (flags) => {
+    const host = typeof flags.host === "string" ? flags.host : DEFAULT_HOST;
+    return {
+        port: normalizePort(flags),
+        host,
+        open: Boolean(flags.open),
+        ssr: Boolean(flags.ssr),
+    };
+};
+export const createDevCommand = (deps) => {
+    return async ({ flags, io }) => {
+        const options = resolveDevOptions(flags);
+        const server = await deps.startDevServer(options);
+        io.stdout.write(`Dev server running at ${server.url}\n`);
+        if (options.ssr) {
+            io.stdout.write("SSR preview enabled.\n");
+        }
+        if (options.open) {
+            if (deps.openUrl) {
+                await deps.openUrl(server.url);
+            }
+            else {
+                io.stdout.write("Open flag requested; auto-open is not configured.\n");
+            }
+        }
+        return 0;
+    };
+};
+export const isBunRuntime = (runtime = process) => readRuntimeBunVersion(runtime) !== null;
+export const ensureDevRuntimeSupported = (io, runtime = process) => {
+    if (isBunRuntime(runtime)) {
+        return true;
+    }
+    io.stderr.write([
+        "cloud-front dev requires Bun runtime because dev route loading imports TS/TSX modules directly.",
+        "Run the command with Bun (for example: `bun run dev` or `bun run scripts/cloud-front.ts dev`).",
+    ].join(" "));
+    io.stderr.write("\n");
+    return false;
+};
+export const runDevCommand = async (context) => {
+    if (!ensureDevRuntimeSupported(context.io)) {
+        return 1;
+    }
+    const { startDevServer } = await import("@tyndall/dev");
+    const { openUrl } = await import("../open.js");
+    const adapterRegistry = await resolveAdapterRegistry();
+    const command = createDevCommand({
+        startDevServer: (options) => startDevServer({
+            ...options,
+            adapterRegistry,
+        }),
+        openUrl,
+    });
+    return command(context);
+};

package/dist/commands/format.d.ts

@@ -0,0 +1,15 @@
+import type { CommandHandler } from "../types.js";
+export interface FormatCommandOptions {
+    cwd: string;
+    write: boolean;
+    files: string[];
+}
+export interface FormatCommandDeps {
+    runFormat: (options: FormatCommandOptions) => Promise<{
+        code: number;
+    }>;
+    cwd?: () => string;
+}
+export declare const createFormatCommand: (deps: FormatCommandDeps) => CommandHandler;
+export declare const runFormatCommand: CommandHandler;
+//# sourceMappingURL=format.d.ts.map

package/dist/commands/format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../src/commands/format.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAW,MAAM,aAAa,CAAC;AAE3D,MAAM,WAAW,oBAAoB;IACnC,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,CAAC,OAAO,EAAE,oBAAoB,KAAK,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACxE,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACpB;AAWD,eAAO,MAAM,mBAAmB,GAAI,MAAM,iBAAiB,KAAG,cAc7D,CAAC;AAEF,eAAO,MAAM,gBAAgB,EAAE,cAI9B,CAAC"}

package/dist/commands/format.js

@@ -0,0 +1,26 @@
+const resolveFormatOptions = (flags, args, cwd) => {
+    const write = Boolean(flags.write);
+    return {
+        cwd,
+        write,
+        files: args,
+    };
+};
+export const createFormatCommand = (deps) => {
+    return async ({ flags, args, io }) => {
+        const cwd = deps.cwd ? deps.cwd() : process.cwd();
+        const options = resolveFormatOptions(flags, args, cwd);
+        const result = await deps.runFormat(options);
+        if (result.code !== 0) {
+            io.stderr.write(`Format failed with code ${result.code}.\n`);
+            return result.code;
+        }
+        io.stdout.write("Format completed.\n");
+        return 0;
+    };
+};
+export const runFormatCommand = async (context) => {
+    const { runFormat } = await import("@tyndall/lint");
+    const command = createFormatCommand({ runFormat });
+    return command(context);
+};

package/dist/commands/lint.d.ts

@@ -0,0 +1,15 @@
+import type { CommandHandler } from "../types.js";
+export interface LintCommandOptions {
+    cwd: string;
+    fix: boolean;
+    files: string[];
+}
+export interface LintCommandDeps {
+    runLint: (options: LintCommandOptions) => Promise<{
+        code: number;
+    }>;
+    cwd?: () => string;
+}
+export declare const createLintCommand: (deps: LintCommandDeps) => CommandHandler;
+export declare const runLintCommand: CommandHandler;
+//# sourceMappingURL=lint.d.ts.map

package/dist/commands/lint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lint.d.ts","sourceRoot":"","sources":["../../src/commands/lint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAW,MAAM,aAAa,CAAC;AAE3D,MAAM,WAAW,kBAAkB;IACjC,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,OAAO,CAAC;IACb,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,CAAC,OAAO,EAAE,kBAAkB,KAAK,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACpE,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACpB;AAWD,eAAO,MAAM,iBAAiB,GAAI,MAAM,eAAe,KAAG,cAczD,CAAC;AAEF,eAAO,MAAM,cAAc,EAAE,cAI5B,CAAC"}

package/dist/commands/lint.js

@@ -0,0 +1,26 @@
+const resolveLintOptions = (flags, args, cwd) => {
+    const fix = Boolean(flags.fix);
+    return {
+        cwd,
+        fix,
+        files: args,
+    };
+};
+export const createLintCommand = (deps) => {
+    return async ({ flags, args, io }) => {
+        const cwd = deps.cwd ? deps.cwd() : process.cwd();
+        const options = resolveLintOptions(flags, args, cwd);
+        const result = await deps.runLint(options);
+        if (result.code !== 0) {
+            io.stderr.write(`Lint failed with code ${result.code}.\n`);
+            return result.code;
+        }
+        io.stdout.write("Lint completed.\n");
+        return 0;
+    };
+};
+export const runLintCommand = async (context) => {
+    const { runLint } = await import("@tyndall/lint");
+    const command = createLintCommand({ runLint });
+    return command(context);
+};

package/dist/commands/preview.d.ts

@@ -0,0 +1,14 @@
+import type { CommandHandler } from "../types.js";
+import { type PreviewServer } from "../preview-server.js";
+export interface PreviewCommandOptions {
+    outDir: string;
+    port: number;
+    host: string;
+}
+export interface PreviewCommandDeps {
+    startPreviewServer: (options: PreviewCommandOptions) => Promise<PreviewServer>;
+    cwd?: () => string;
+}
+export declare const createPreviewCommand: (deps: PreviewCommandDeps) => CommandHandler;
+export declare const runPreviewCommand: CommandHandler;
+//# sourceMappingURL=preview.d.ts.map

package/dist/commands/preview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preview.d.ts","sourceRoot":"","sources":["../../src/commands/preview.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAW,MAAM,aAAa,CAAC;AAC3D,OAAO,EAAsB,KAAK,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAE9E,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,kBAAkB;IACjC,kBAAkB,EAAE,CAAC,OAAO,EAAE,qBAAqB,KAAK,OAAO,CAAC,aAAa,CAAC,CAAC;IAC/E,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACpB;AA4BD,eAAO,MAAM,oBAAoB,GAAI,MAAM,kBAAkB,KAAG,cAQ/D,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,cAG/B,CAAC"}

package/dist/commands/preview.js

@@ -0,0 +1,35 @@
+import { startPreviewServer } from "../preview-server.js";
+const DEFAULT_PORT = 4173;
+const DEFAULT_HOST = "localhost";
+const resolvePreviewOptions = (flags, cwd) => {
+    const portFlag = flags.port ?? flags.p;
+    const port = typeof portFlag === "number"
+        ? portFlag
+        : typeof portFlag === "string"
+            ? Number(portFlag)
+            : DEFAULT_PORT;
+    const host = typeof flags.host === "string" ? flags.host : DEFAULT_HOST;
+    const outDir = typeof flags.outDir === "string"
+        ? flags.outDir
+        : typeof flags["out-dir"] === "string"
+            ? flags["out-dir"]
+            : "dist";
+    return {
+        port: Number.isFinite(port) ? port : DEFAULT_PORT,
+        host,
+        outDir: outDir.startsWith("/") ? outDir : `${cwd}/${outDir}`,
+    };
+};
+export const createPreviewCommand = (deps) => {
+    return async ({ flags, io }) => {
+        const cwd = deps.cwd ? deps.cwd() : process.cwd();
+        const options = resolvePreviewOptions(flags, cwd);
+        const server = await deps.startPreviewServer(options);
+        io.stdout.write(`Preview server running at ${server.url}\n`);
+        return 0;
+    };
+};
+export const runPreviewCommand = async (context) => {
+    const command = createPreviewCommand({ startPreviewServer });
+    return command(context);
+};

package/dist/commands/registry.d.ts

@@ -0,0 +1,5 @@
+import type { CommandDefinition, CommandName } from "../types.js";
+export declare const COMMANDS: CommandDefinition[];
+export declare const COMMAND_LOOKUP: Map<CommandName, CommandDefinition>;
+export declare const isCommandName: (value: string) => value is CommandName;
+//# sourceMappingURL=registry.d.ts.map

package/dist/commands/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/commands/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAkB,WAAW,EAAE,MAAM,aAAa,CAAC;AAgBlF,eAAO,MAAM,QAAQ,EAAE,iBAAiB,EAsCvC,CAAC;AAEF,eAAO,MAAM,cAAc,qCAE1B,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,OAAO,MAAM,KAAG,KAAK,IAAI,WAEtD,CAAC"}

package/dist/commands/registry.js

@@ -0,0 +1,55 @@
+import { runBuildCommand } from "./build.js";
+import { runDevCommand } from "./dev.js";
+import { runFormatCommand } from "./format.js";
+import { runPreviewCommand } from "./preview.js";
+import { runStartCommand } from "./start.js";
+import { runLintCommand } from "./lint.js";
+const notImplemented = (name) => {
+    return ({ io }) => {
+        // Explicitly fail until each command is implemented in later milestones.
+        io.stderr.write(`Command "${name}" is not implemented yet.\n`);
+        return 1;
+    };
+};
+export const COMMANDS = [
+    {
+        name: "dev",
+        summary: "Start dev server with HMR",
+        usage: "cloud-front dev [--port <number>] [--host <host>] [--open] [--ssr]",
+        run: runDevCommand,
+    },
+    {
+        name: "build",
+        summary: "Build for production (SSG + assets)",
+        usage: "cloud-front build [--mode <ssg|ssr>] [--outDir <dir>] [--no-cache] [--cache-dir <dir>]",
+        run: runBuildCommand,
+    },
+    {
+        name: "start",
+        summary: "Start production server (SSR only)",
+        usage: "cloud-front start [--port <number>] [--adapter <node|express|fastify>]",
+        run: runStartCommand,
+    },
+    {
+        name: "preview",
+        summary: "Serve built static output locally",
+        usage: "cloud-front preview [--port <number>]",
+        run: runPreviewCommand,
+    },
+    {
+        name: "lint",
+        summary: "Run lint",
+        usage: "cloud-front lint [--fix]",
+        run: runLintCommand,
+    },
+    {
+        name: "format",
+        summary: "Run formatter",
+        usage: "cloud-front format [--write]",
+        run: runFormatCommand,
+    },
+];
+export const COMMAND_LOOKUP = new Map(COMMANDS.map((command) => [command.name, command]));
+export const isCommandName = (value) => {
+    return COMMAND_LOOKUP.has(value);
+};

package/dist/commands/start.d.ts

@@ -0,0 +1,33 @@
+import type { CommandHandler } from "../types.js";
+import type { UIAdapterFactory, UIAdapterRegistry } from "@tyndall/core";
+export interface StartCommandOptions {
+    port: number;
+    host: string;
+    adapter: "node" | "express" | "fastify";
+    distDir: string;
+}
+export interface StartCommandRuntimeConfig {
+    adapterRegistry?: UIAdapterRegistry;
+    uiAdapter?: string | UIAdapterFactory;
+    uiOptions?: Record<string, unknown>;
+    appMode?: "ssg" | "ssr";
+}
+export interface StartCommandDeps {
+    createServer: (options: {
+        port?: number;
+        host?: string;
+        distDir?: string;
+        adapterRegistry?: UIAdapterRegistry;
+        uiAdapter?: string | UIAdapterFactory;
+        uiOptions?: Record<string, unknown>;
+        appMode?: "ssg" | "ssr";
+    }) => Promise<{
+        url: string;
+        close: () => Promise<void> | void;
+    }>;
+    cwd?: () => string;
+    loadRuntimeConfig?: (cwd: string) => Promise<StartCommandRuntimeConfig | undefined>;
+}
+export declare const createStartCommand: (deps: StartCommandDeps) => CommandHandler;
+export declare const runStartCommand: CommandHandler;
+//# sourceMappingURL=start.d.ts.map

package/dist/commands/start.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"start.d.ts","sourceRoot":"","sources":["../../src/commands/start.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAW,MAAM,aAAa,CAAC;AAC3D,OAAO,KAAK,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAGzE,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAAC;IACxC,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,yBAAyB;IACxC,eAAe,CAAC,EAAE,iBAAiB,CAAC;IACpC,SAAS,CAAC,EAAE,MAAM,GAAG,gBAAgB,CAAC;IACtC,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACpC,OAAO,CAAC,EAAE,KAAK,GAAG,KAAK,CAAC;CACzB;AAED,MAAM,WAAW,gBAAgB;IAC/B,YAAY,EAAE,CAAC,OAAO,EAAE;QACtB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,eAAe,CAAC,EAAE,iBAAiB,CAAC;QACpC,SAAS,CAAC,EAAE,MAAM,GAAG,gBAAgB,CAAC;QACtC,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACpC,OAAO,CAAC,EAAE,KAAK,GAAG,KAAK,CAAC;KACzB,KAAK,OAAO,CAAC;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;KAAE,CAAC,CAAC;IAClE,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IACnB,iBAAiB,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,yBAAyB,GAAG,SAAS,CAAC,CAAC;CACrF;AA+BD,eAAO,MAAM,kBAAkB,GAAI,MAAM,gBAAgB,KAAG,cA0B3D,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,cA4B7B,CAAC"}

package/dist/commands/start.js

@@ -0,0 +1,78 @@
+import { resolveAdapterRegistry } from "../adapter-registry.js";
+const DEFAULT_PORT = 3000;
+const DEFAULT_HOST = "localhost";
+const resolveStartOptions = (flags, cwd) => {
+    const portFlag = flags.port ?? flags.p;
+    const port = typeof portFlag === "number"
+        ? portFlag
+        : typeof portFlag === "string"
+            ? Number(portFlag)
+            : DEFAULT_PORT;
+    const host = typeof flags.host === "string" ? flags.host : DEFAULT_HOST;
+    const adapter = flags.adapter === "express" || flags.adapter === "fastify" ? flags.adapter : "node";
+    const distDir = typeof flags.distDir === "string"
+        ? flags.distDir
+        : typeof flags["dist-dir"] === "string"
+            ? flags["dist-dir"]
+            : "dist";
+    return {
+        port: Number.isFinite(port) ? port : DEFAULT_PORT,
+        host,
+        adapter,
+        distDir: distDir.startsWith("/") ? distDir : `${cwd}/${distDir}`,
+    };
+};
+export const createStartCommand = (deps) => {
+    return async ({ flags, io }) => {
+        const cwd = deps.cwd ? deps.cwd() : process.cwd();
+        const options = resolveStartOptions(flags, cwd);
+        const runtimeConfig = deps.loadRuntimeConfig
+            ? await deps.loadRuntimeConfig(cwd)
+            : undefined;
+        if (options.adapter !== "node") {
+            io.stderr.write(`Adapter ${options.adapter} is not implemented yet.\n`);
+            return 1;
+        }
+        const server = await deps.createServer({
+            port: options.port,
+            host: options.host,
+            distDir: options.distDir,
+            adapterRegistry: runtimeConfig?.adapterRegistry,
+            uiAdapter: runtimeConfig?.uiAdapter,
+            uiOptions: runtimeConfig?.uiOptions,
+            appMode: runtimeConfig?.appMode,
+        });
+        io.stdout.write(`Runtime server running at ${server.url}\n`);
+        return 0;
+    };
+};
+export const runStartCommand = async (context) => {
+    const { createServer } = await import("@tyndall/runtime");
+    const { loadConfig } = await import("@tyndall/core");
+    const adapterRegistry = await resolveAdapterRegistry();
+    const command = createStartCommand({
+        createServer,
+        loadRuntimeConfig: async (cwd) => {
+            try {
+                const config = await loadConfig(cwd);
+                return {
+                    adapterRegistry,
+                    uiAdapter: config.ui.adapter,
+                    uiOptions: {
+                        ...config.ui.options,
+                        navigationMode: config.routing.navigation,
+                        clientRenderMode: config.routing.clientRender,
+                    },
+                    appMode: config.mode,
+                };
+            }
+            catch {
+                // Keep runtime startup resilient when config is unavailable and rely on dist defaults.
+                return {
+                    adapterRegistry,
+                };
+            }
+        },
+    });
+    return command(context);
+};

package/dist/dispatcher.d.ts

@@ -0,0 +1,3 @@
+import type { CliIO } from "./types.js";
+export declare const runCli: (argv: string[], io?: CliIO) => Promise<number>;
+//# sourceMappingURL=dispatcher.d.ts.map

package/dist/dispatcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatcher.d.ts","sourceRoot":"","sources":["../src/dispatcher.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AASxC,eAAO,MAAM,MAAM,GACjB,MAAM,MAAM,EAAE,EACd,KAAI,KAAiB,KACpB,OAAO,CAAC,MAAM,CA8ChB,CAAC"}

package/dist/dispatcher.js

@@ -0,0 +1,53 @@
+import { parseArgs } from "./args.js";
+import { COMMAND_LOOKUP, isCommandName } from "./commands/registry.js";
+import { formatCliError } from "./errors.js";
+import { createCliLogger } from "./logging.js";
+import { formatUsage } from "./usage.js";
+const CLI_VERSION = "0.0.1";
+const defaultIO = {
+    stdout: process.stdout,
+    stderr: process.stderr,
+};
+export const runCli = async (argv, io = defaultIO) => {
+    const parsed = parseArgs(argv);
+    const logger = createCliLogger({
+        ci: Boolean(process.env.CI),
+        stdout: io.stdout,
+        stderr: io.stderr,
+    });
+    if (parsed.version) {
+        io.stdout.write(`cloud-front ${CLI_VERSION}\n`);
+        return 0;
+    }
+    if (parsed.help || !parsed.command || parsed.command === "help") {
+        io.stdout.write(formatUsage());
+        return 0;
+    }
+    if (!isCommandName(parsed.command)) {
+        logger.error(`Unknown command: ${parsed.command}`);
+        io.stderr.write(formatUsage());
+        return 1;
+    }
+    const command = COMMAND_LOOKUP.get(parsed.command);
+    if (!command) {
+        logger.error(`Unknown command: ${parsed.command}`);
+        io.stderr.write(formatUsage());
+        return 1;
+    }
+    try {
+        const result = await command.run({
+            args: parsed.args,
+            flags: parsed.flags,
+            io,
+        });
+        return Number.isInteger(result) ? result : 0;
+    }
+    catch (error) {
+        logger.error(`Command failed: ${parsed.command}`);
+        const detail = formatCliError(error);
+        if (detail.length > 0) {
+            logger.error(detail);
+        }
+        return 1;
+    }
+};

package/dist/errors.d.ts

@@ -0,0 +1,2 @@
+export declare const formatCliError: (error: unknown) => string;
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,cAAc,GAAI,OAAO,OAAO,KAAG,MAW/C,CAAC"}

package/dist/errors.js

@@ -0,0 +1,20 @@
+import { formatHyperError, HyperError, isHyperError } from "@tyndall/core";
+const isHyperErrorShape = (error) => {
+    if (!error || typeof error !== "object") {
+        return false;
+    }
+    const candidate = error;
+    return typeof candidate.code === "string" && typeof candidate.message === "string";
+};
+export const formatCliError = (error) => {
+    if (isHyperError(error)) {
+        return formatHyperError(error);
+    }
+    if (isHyperErrorShape(error)) {
+        return formatHyperError(new HyperError(error.code, error.message, error.details));
+    }
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+};

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { parseArgs } from "./args.js";
+export { runCli } from "./dispatcher.js";
+export { formatUsage } from "./usage.js";
+export { COMMANDS } from "./commands/registry.js";
+export type { CliIO, CommandContext, CommandDefinition, CommandHandler, CommandName, FlagMap, FlagValue, ParsedArgs, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AACtC,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACzC,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAClD,YAAY,EACV,KAAK,EACL,cAAc,EACd,iBAAiB,EACjB,cAAc,EACd,WAAW,EACX,OAAO,EACP,SAAS,EACT,UAAU,GACX,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export { parseArgs } from "./args.js";
+export { runCli } from "./dispatcher.js";
+export { formatUsage } from "./usage.js";
+export { COMMANDS } from "./commands/registry.js";

package/dist/logging.d.ts

@@ -0,0 +1,20 @@
+export interface LoggerOptions {
+    ci?: boolean;
+    stdout?: {
+        write: (text: string) => void;
+    };
+    stderr?: {
+        write: (text: string) => void;
+    };
+    now?: () => number;
+}
+export interface CliLogger {
+    info: (message: string) => void;
+    warn: (message: string) => void;
+    error: (message: string) => void;
+    success: (message: string) => void;
+    time: (label: string) => () => number;
+}
+export declare const formatDuration: (durationMs: number) => string;
+export declare const createCliLogger: (options?: LoggerOptions) => CliLogger;
+//# sourceMappingURL=logging.d.ts.map

package/dist/logging.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logging.d.ts","sourceRoot":"","sources":["../src/logging.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,aAAa;IAC5B,EAAE,CAAC,EAAE,OAAO,CAAC;IACb,MAAM,CAAC,EAAE;QAAE,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;KAAE,CAAC;IAC3C,MAAM,CAAC,EAAE;QAAE,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;KAAE,CAAC;IAC3C,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IAChC,IAAI,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IAChC,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACjC,OAAO,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,MAAM,CAAC;CACvC;AAaD,eAAO,MAAM,cAAc,GAAI,YAAY,MAAM,WAKhD,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,UAAS,aAAkB,KAAG,SA2B7D,CAAC"}

package/dist/logging.js

@@ -0,0 +1,39 @@
+const COLORS = {
+    reset: "\u001b[0m",
+    red: "\u001b[31m",
+    green: "\u001b[32m",
+    yellow: "\u001b[33m",
+    cyan: "\u001b[36m",
+};
+const colorize = (text, color, enabled) => enabled ? `${color}${text}${COLORS.reset}` : text;
+export const formatDuration = (durationMs) => {
+    if (durationMs >= 1000) {
+        return `${(durationMs / 1000).toFixed(2)}s`;
+    }
+    return `${durationMs}ms`;
+};
+export const createCliLogger = (options = {}) => {
+    const stdout = options.stdout ?? process.stdout;
+    const stderr = options.stderr ?? process.stderr;
+    const now = options.now ?? Date.now;
+    const useColor = !options.ci &&
+        !process.env.NO_COLOR &&
+        Boolean(process.stdout.isTTY);
+    const writeLine = (stream, message) => {
+        stream.write(`${message}\n`);
+    };
+    return {
+        info: (message) => writeLine(stdout, colorize(message, COLORS.cyan, useColor)),
+        warn: (message) => writeLine(stderr, colorize(message, COLORS.yellow, useColor)),
+        error: (message) => writeLine(stderr, colorize(message, COLORS.red, useColor)),
+        success: (message) => writeLine(stdout, colorize(message, COLORS.green, useColor)),
+        time: (label) => {
+            const startedAt = now();
+            return () => {
+                const duration = now() - startedAt;
+                writeLine(stdout, `${label} ${formatDuration(duration)}`);
+                return duration;
+            };
+        },
+    };
+};

package/dist/open.d.ts

@@ -0,0 +1,8 @@
+export interface OpenCommand {
+    command: string;
+    args: string[];
+}
+export declare const shouldAutoOpen: (env: NodeJS.ProcessEnv, platform: NodeJS.Platform) => boolean;
+export declare const resolveOpenCommand: (platform: NodeJS.Platform, url: string) => OpenCommand;
+export declare const openUrl: (url: string, env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform) => Promise<void>;
+//# sourceMappingURL=open.d.ts.map

package/dist/open.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"open.d.ts","sourceRoot":"","sources":["../src/open.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB;AAID,eAAO,MAAM,cAAc,GACzB,KAAK,MAAM,CAAC,UAAU,EACtB,UAAU,MAAM,CAAC,QAAQ,KACxB,OASF,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAI,UAAU,MAAM,CAAC,QAAQ,EAAE,KAAK,MAAM,KAAG,WAQ3E,CAAC;AAEF,eAAO,MAAM,OAAO,GAClB,KAAK,MAAM,EACX,MAAK,MAAM,CAAC,UAAwB,EACpC,WAAU,MAAM,CAAC,QAA2B,KAC3C,OAAO,CAAC,IAAI,CAcd,CAAC"}

package/dist/open.js

@@ -0,0 +1,35 @@
+import { spawn } from "node:child_process";
+const isTruthy = (value) => value !== undefined && value !== "0" && value.toLowerCase() !== "false";
+export const shouldAutoOpen = (env, platform) => {
+    // Avoid spawning openers in CI/headless environments where it will fail or hang.
+    if (isTruthy(env.CI)) {
+        return false;
+    }
+    if (platform === "linux" && !env.DISPLAY && !env.WAYLAND_DISPLAY) {
+        return false;
+    }
+    return true;
+};
+export const resolveOpenCommand = (platform, url) => {
+    if (platform === "darwin") {
+        return { command: "open", args: [url] };
+    }
+    if (platform === "win32") {
+        return { command: "cmd", args: ["/c", "start", "", url] };
+    }
+    return { command: "xdg-open", args: [url] };
+};
+export const openUrl = async (url, env = process.env, platform = process.platform) => {
+    if (!shouldAutoOpen(env, platform)) {
+        return;
+    }
+    const { command, args } = resolveOpenCommand(platform, url);
+    try {
+        const child = spawn(command, args, { stdio: "ignore", detached: true });
+        child.on("error", () => undefined);
+        child.unref();
+    }
+    catch {
+        return;
+    }
+};

package/dist/preview-server.d.ts

@@ -0,0 +1,13 @@
+export interface PreviewServerOptions {
+    outDir: string;
+    port?: number;
+    host?: string;
+}
+export interface PreviewServer {
+    host: string;
+    port: number;
+    url: string;
+    close: () => Promise<void>;
+}
+export declare const startPreviewServer: (options: PreviewServerOptions) => Promise<PreviewServer>;
+//# sourceMappingURL=preview-server.d.ts.map

package/dist/preview-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preview-server.d.ts","sourceRoot":"","sources":["../src/preview-server.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5B;AAqBD,eAAO,MAAM,kBAAkB,GAC7B,SAAS,oBAAoB,KAC5B,OAAO,CAAC,aAAa,CAuDvB,CAAC"}

package/dist/preview-server.js

@@ -0,0 +1,70 @@
+import { createServer as createHttpServer } from "node:http";
+import { readFile, stat } from "node:fs/promises";
+import { extname, join, resolve } from "node:path";
+const CONTENT_TYPES = {
+    ".html": "text/html; charset=utf-8",
+    ".js": "text/javascript; charset=utf-8",
+    ".css": "text/css; charset=utf-8",
+    ".json": "application/json; charset=utf-8",
+    ".txt": "text/plain; charset=utf-8",
+};
+const resolveFilePath = (root, urlPath) => {
+    const sanitized = urlPath.split("?")[0].split("#")[0];
+    const withIndex = sanitized.endsWith("/") || sanitized === "" ? `${sanitized}index.html` : sanitized;
+    const fullPath = resolve(root, `.${withIndex}`);
+    // Important: block path traversal outside the output directory.
+    if (!fullPath.startsWith(resolve(root))) {
+        return null;
+    }
+    return fullPath;
+};
+export const startPreviewServer = async (options) => {
+    const host = options.host ?? "localhost";
+    const port = options.port ?? 4173;
+    const outDir = resolve(options.outDir ?? join(process.cwd(), "dist"));
+    const server = createHttpServer(async (request, response) => {
+        const urlPath = request.url ?? "/";
+        const filePath = resolveFilePath(outDir, urlPath);
+        if (filePath) {
+            try {
+                const fileStat = await stat(filePath);
+                if (fileStat.isFile()) {
+                    const data = await readFile(filePath);
+                    const ext = extname(filePath);
+                    response.statusCode = 200;
+                    response.setHeader("content-type", CONTENT_TYPES[ext] ?? "application/octet-stream");
+                    response.end(data);
+                    return;
+                }
+            }
+            catch {
+                // File not found, fall through to 404.
+            }
+        }
+        response.statusCode = 404;
+        response.setHeader("content-type", "text/plain; charset=utf-8");
+        response.end("Not Found");
+    });
+    await new Promise((resolvePromise, reject) => {
+        server.once("error", reject);
+        server.listen(port, host, () => resolvePromise());
+    });
+    const address = server.address();
+    if (!address || typeof address === "string") {
+        throw new Error("Preview server did not return a TCP address.");
+    }
+    return {
+        host: address.address,
+        port: address.port,
+        url: `http://${address.address}:${address.port}`,
+        close: () => new Promise((resolvePromise, reject) => {
+            server.close((error) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolvePromise();
+            });
+        }),
+    };
+};

package/dist/types.d.ts

@@ -0,0 +1,31 @@
+export type FlagValue = string | number | boolean;
+export type FlagMap = Record<string, FlagValue>;
+export interface ParsedArgs {
+    command: string | null;
+    args: string[];
+    flags: FlagMap;
+    help: boolean;
+    version: boolean;
+}
+export interface CliIO {
+    stdout: {
+        write: (text: string) => void;
+    };
+    stderr: {
+        write: (text: string) => void;
+    };
+}
+export interface CommandContext {
+    args: string[];
+    flags: FlagMap;
+    io: CliIO;
+}
+export type CommandHandler = (ctx: CommandContext) => Promise<number> | number;
+export type CommandName = "dev" | "build" | "start" | "preview" | "lint" | "format";
+export interface CommandDefinition {
+    name: CommandName;
+    summary: string;
+    usage: string;
+    run: CommandHandler;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAClD,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;AAEhD,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,KAAK,EAAE,OAAO,CAAC;IACf,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,KAAK;IACpB,MAAM,EAAE;QAAE,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;KAAE,CAAC;IAC1C,MAAM,EAAE;QAAE,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;KAAE,CAAC;CAC3C;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,KAAK,EAAE,OAAO,CAAC;IACf,EAAE,EAAE,KAAK,CAAC;CACX;AAED,MAAM,MAAM,cAAc,GAAG,CAAC,GAAG,EAAE,cAAc,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;AAE/E,MAAM,MAAM,WAAW,GAAG,KAAK,GAAG,OAAO,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM,GAAG,QAAQ,CAAC;AAEpF,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,WAAW,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,cAAc,CAAC;CACrB"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/usage.d.ts

@@ -0,0 +1,2 @@
+export declare const formatUsage: () => string;
+//# sourceMappingURL=usage.d.ts.map

package/dist/usage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usage.d.ts","sourceRoot":"","sources":["../src/usage.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW,QAAO,MA0B9B,CAAC"}

package/dist/usage.js

@@ -0,0 +1,18 @@
+import { COMMANDS } from "./commands/registry.js";
+export const formatUsage = () => {
+    const lines = [
+        "Cloud Front CLI",
+        "",
+        "Usage:",
+        "  cloud-front <command> [flags]",
+        "",
+        "Commands:",
+    ];
+    // Keep this list deterministic for snapshot testing and docs alignment.
+    for (const command of COMMANDS) {
+        const padded = command.name.padEnd(8, " ");
+        lines.push(`  ${padded} ${command.summary}`);
+    }
+    lines.push("", "Global Flags:", "  -h, --help     Show help", "  -v, --version  Show version", "", "Run `cloud-front <command> --help` for command-specific flags.");
+    return `${lines.join("\n")}\n`;
+};

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@tyndall/cli",
+  "version": "0.0.1",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "bin": {
+    "cloud-front": "./bin/cloud-front.js"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "bun": "./src/index.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "bin"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json"
+  },
+  "dependencies": {
+    "@tyndall/core": "workspace:*",
+    "@tyndall/dev": "workspace:*",
+    "@tyndall/build": "workspace:*",
+    "@tyndall/runtime": "workspace:*",
+    "@tyndall/shared": "workspace:*",
+    "@tyndall/lint": "workspace:*",
+    "@tyndall/webcomponents": "workspace:*",
+    "@tyndall/wasm": "workspace:*"
+  }
+}