@atmyapp/cli 0.0.7 → 0.0.9

package/README.md

@@ -19,6 +19,8 @@
   - [Content Definitions](#content-definitions)
   - [Event Definitions](#event-definitions)
   - [Image & File Definitions](#image--file-definitions)
+  - [Icon Definitions](#icon-definitions)
+  - [MDX Fields](#mdx-fields)
 - [💡 Examples](#-examples)
 - [🔧 Configuration](#-configuration)
 - [🏗️ Architecture](#-architecture)
@@ -290,6 +292,38 @@ export type UserIcon = AmaIconDef<"/icons/user">;
 export type ATMYAPP = [MenuIcon, SearchIcon, UserIcon];
 ```
 
+### MDX Fields
+
+Define MDX (Markdown with JSX) fields with component configurations using `AmaMdxFieldDef`, `AmaMdxConfigDef`, and `AmaComponentDef`:
+
+```typescript
+import {
+  AmaMdxFieldDef,
+  AmaMdxConfigDef,
+  AmaComponentDef,
+} from "@atmyapp/core";
+
+// 1. Define MDX components and their props
+type Callout = AmaComponentDef<"Callout", {
+  title: string;
+  type: "info" | "warning" | "error";
+}>;
+
+// 2. Create an MDX configuration
+type BlogMdxConfig = AmaMdxConfigDef<"blogComponents", [Callout]>;
+
+// 3. Use the config in your content definition
+interface BlogPost {
+  title: string;
+  content: AmaMdxFieldDef<BlogMdxConfig>;
+}
+
+export type BlogPostContent = AmaContentDef<"/blog/posts", BlogPost>;
+
+// 4. Export the configuration and definitions
+export type ATMYAPP = [BlogMdxConfig, BlogPostContent];
+```
+
 ## 💡 Examples
 
 ### 🏪 E-commerce Setup
@@ -364,13 +398,24 @@ import {
   AmaCustomEventDef,
   AmaImageDef,
   AmaIconDef,
+  AmaMdxFieldDef,
+  AmaMdxConfigDef,
+  AmaComponentDef,
 } from "@atmyapp/core";
 
+// MDX Components for blog
+type Callout = AmaComponentDef<"Callout", {
+  title: string;
+  type: "info" | "warning" | "error";
+}>;
+
+type BlogMdxConfig = AmaMdxConfigDef<"blogComponents", [Callout]>;
+
 // Blog content types
 interface BlogPost {
   title: string;
   slug: string;
-  content: string;
+  content: AmaMdxFieldDef<BlogMdxConfig>;
   excerpt: string;
   publishedAt: string;
   author: {
@@ -428,6 +473,7 @@ export type ATMYAPP = [
   BlogPosts,
   FeaturedPost,
   Categories,
+  BlogMdxConfig,
   BlogHeroImage,
   ShareIcon,
   LikeIcon,

package/dist/cli/commands/generate.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function generateCommand(): Command;

package/dist/cli/commands/generate.js

@@ -0,0 +1,119 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCommand = generateCommand;
+const commander_1 = require("commander");
+const path_1 = __importDefault(require("path"));
+const fs_1 = require("fs");
+const logger_1 = require("../logger");
+const http_1 = require("../utils/http");
+const DEFAULT_BRANCH = "main";
+function generateCommand() {
+    return new commander_1.Command("generate")
+        .description("Generate a placeholder file in project storage")
+        .requiredOption("--path <path>", "POSIX project-relative path to generate")
+        .option("-t, --token <token>", "Authentication token override")
+        .option("-u, --url <url>", "Project base URL override")
+        .option("-p, --project-id <id>", "Project identifier override")
+        .option("--branch <name>", "Branch to target", DEFAULT_BRANCH)
+        .option("--save <file>", "Save generated content to a local file path")
+        .option("--json", "Print raw JSON response")
+        .option("--warnings-as-error", "Treat validation warnings as errors")
+        .option("--verbose", "Enable verbose logging")
+        .action((options) => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const logger = new logger_1.Logger(Boolean(options.verbose));
+        try {
+            const session = (0, http_1.resolveSession)({
+                token: options.token,
+                projectId: options.projectId,
+                url: options.url,
+            });
+            const targetPath = normalizePlaceholderPath(options.path);
+            const endpoint = buildGenerateEndpoint(session);
+            const url = (0, http_1.projectUrl)(session, endpoint, {
+                branch: (_a = options.branch) !== null && _a !== void 0 ? _a : DEFAULT_BRANCH,
+            });
+            const fetcher = (0, http_1.createAmaFetch)(session);
+            const { data, error } = yield fetcher(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({ path: targetPath }),
+            });
+            if (error) {
+                const errorMessage = typeof error === "string"
+                    ? error
+                    : error instanceof Error
+                        ? error.message
+                        : (_b = error.message) !== null && _b !== void 0 ? _b : (error.status
+                            ? `HTTP ${error.status}`
+                            : "Unknown error");
+                throw new Error(`Request failed: ${errorMessage}`);
+            }
+            if (!data) {
+                throw new Error("No response received from the server.");
+            }
+            if (!data.success || !data.data) {
+                throw new Error(data.error || "Placeholder generation failed.");
+            }
+            const result = data.data;
+            if (options.json) {
+                console.log(JSON.stringify(data, null, 2));
+            }
+            else {
+                logger.success(`Generated placeholder for ${result.path}.`);
+                if (result.warnings && result.warnings.length > 0) {
+                    logger.warn(`Warnings (${result.warnings.length}):\n${result.warnings
+                        .map((warning) => `  • ${warning}`)
+                        .join("\n")}`);
+                }
+            }
+            if (options.save) {
+                yield persistContent(options.save, result.content, logger);
+            }
+            if (options.warningsAsError &&
+                result.warnings &&
+                result.warnings.length > 0) {
+                throw new Error("Generation returned warnings treated as errors.");
+            }
+            logger.success("Placeholder generation completed.");
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            logger.error(`Generation failed: ${message}`);
+            process.exit(1);
+        }
+    }));
+}
+function normalizePlaceholderPath(input) {
+    const trimmed = input.trim();
+    if (!trimmed) {
+        throw new Error("Path is required and cannot be empty.");
+    }
+    return trimmed.replace(/\\/g, "/");
+}
+function buildGenerateEndpoint(session) {
+    return `v0/projects/${encodeURIComponent(session.projectId)}/storage/ghost/placeholders`;
+}
+function persistContent(destination, content, logger) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const absolutePath = path_1.default.resolve(process.cwd(), destination);
+        const directory = path_1.default.dirname(absolutePath);
+        yield fs_1.promises.mkdir(directory, { recursive: true });
+        yield fs_1.promises.writeFile(absolutePath, content, "utf8");
+        logger.success(`Saved generated content to ${absolutePath}.`);
+    });
+}

package/dist/cli/commands/migrate.js

@@ -31,16 +31,16 @@ function migrateCommand() {
         const startTime = Date.now();
         const logger = new utils_1.Logger(options.verbose);
         try {
-            logger.info("🚀 Starting migration process");
+            logger.info("Starting migration process.");
             logger.verbose_log(`Options: ${JSON.stringify(options)}`);
             if (options.parallel) {
-                logger.info("⚡ Parallel processing enabled");
+                logger.info("Parallel processing enabled.");
                 if (options.maxWorkers) {
-                    logger.info(`👥 Using ${options.maxWorkers} worker threads`);
+                    logger.info(`Using ${options.maxWorkers} worker threads.`);
                 }
             }
             else {
-                logger.info("🔄 Using sequential processing");
+                logger.info("Using sequential processing.");
             }
             const config = (0, utils_1.getConfig)();
             const patterns = config.include || ["**/*.ts", "**/*.tsx"];
@@ -49,23 +49,23 @@ function migrateCommand() {
             let processingResult;
             if (options.parallel !== false) {
                 // Use optimized parallel processing pipeline
-                logger.info("🚀 Using optimized parallel processing pipeline");
+                logger.info("Using optimized parallel processing pipeline.");
                 processingResult = yield (0, parallel_schema_processor_1.optimizedMigrationPipeline)(patterns, options.tsconfig, options.continueOnError, logger, options.maxWorkers);
             }
             else {
                 // Fallback to original sequential processing
-                logger.info("🔄 Using original sequential processing");
+                logger.info("Using original sequential processing.");
                 const files = yield (0, utils_1.scanFiles)(patterns, logger);
-                logger.info(`📚 Found ${files.length} files to process`);
+                logger.info(`Found ${files.length} files to process.`);
                 const project = (0, utils_1.createProject)(files, options.tsconfig, logger);
                 processingResult = (0, utils_1.processFiles)(project.getSourceFiles(), options.tsconfig, options.continueOnError, logger);
             }
             const { contents, errors, successCount, failureCount } = processingResult;
             // Report processing results
             const processingTime = ((Date.now() - startTime) / 1000).toFixed(2);
-            logger.success(`✅ Successfully processed ${successCount} AMA contents in ${processingTime}s`);
+            logger.success(`Successfully processed ${successCount} AMA contents in ${processingTime}s.`);
             if (failureCount > 0) {
-                logger.warn(`⚠️ Failed to process ${failureCount} items`);
+                logger.warn(`Failed to process ${failureCount} items.`);
                 if (options.verbose && errors.length > 0) {
                     logger.info("Errors encountered:");
                     errors.forEach((err) => logger.error(`  ${err}`));
@@ -77,14 +77,14 @@ function migrateCommand() {
             }
             // Generate and save output
             const outputStartTime = Date.now();
-            logger.info("🔧 Generating output definitions...");
+            logger.info("Generating output definitions...");
             const output = (0, utils_1.generateOutput)(contents, config, logger);
             const outputTime = ((Date.now() - outputStartTime) / 1000).toFixed(2);
             logger.verbose_log(`Output generation took ${outputTime}s`);
             (0, utils_1.saveOutputToFile)(output, logger);
             // Upload definitions unless dry-run is enabled
             if (!options.dryRun) {
-                logger.info("📤 Uploading definitions to AtMyApp platform");
+                logger.info("Uploading definitions to AtMyApp platform.");
                 const uploadStartTime = Date.now();
                 const uploadSuccess = yield (0, utils_1.uploadDefinitions)(output, config, logger);
                 const uploadTime = ((Date.now() - uploadStartTime) / 1000).toFixed(2);
@@ -95,13 +95,13 @@ function migrateCommand() {
                 }
             }
             else {
-                logger.info("🏁 Dry run mode enabled. Skipping upload to server.");
+                logger.info("Dry run mode enabled. Skipping upload to server.");
             }
             const totalTime = ((Date.now() - startTime) / 1000).toFixed(2);
-            logger.success(`🎉 Migration completed successfully in ${totalTime}s`);
+            logger.success(`Migration completed successfully in ${totalTime}s.`);
             // Performance summary
             if (options.verbose) {
-                logger.info("📊 Performance Summary:");
+                logger.info("Performance summary:");
                 logger.info(`  Total time: ${totalTime}s`);
                 logger.info(`  Processing time: ${processingTime}s`);
                 logger.info(`  Files processed: ${successCount}`);
@@ -114,7 +114,7 @@ function migrateCommand() {
         catch (error) {
             const totalTime = ((Date.now() - startTime) / 1000).toFixed(2);
             const message = error instanceof Error ? error.message : "Unknown error";
-            logger.error(`💥 Fatal error after ${totalTime}s: ${message}`, error);
+            logger.error(`Fatal error after ${totalTime}s: ${message}`, error);
             process.exit(1);
         }
     }));

package/dist/cli/commands/snapshot.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function snapshotCommand(): Command;

package/dist/cli/commands/snapshot.js

@@ -0,0 +1,287 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.snapshotCommand = snapshotCommand;
+const commander_1 = require("commander");
+const logger_1 = require("../logger");
+const http_1 = require("../utils/http");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const DEFAULT_OUTPUT_PATH = ".ama/local";
+const API_BASE = "https://ama-core.maciekgamro.workers.dev";
+/**
+ * Get the work-container API URL for snapshot operations
+ */
+function getSnapshotApiUrl(projectId, endpoint) {
+    return `${API_BASE}/v0/work-container/projects/${projectId}/${endpoint}`;
+}
+/**
+ * Create a new snapshot
+ */
+function createSnapshot(session, options, logger) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const url = getSnapshotApiUrl(session.projectId, "snapshot");
+        logger.info(`Creating snapshot for project ${session.projectId}...`);
+        logger.verbose_log(`POST ${url}`);
+        const response = yield fetch(url, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${session.token}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                branch: (_a = options.branch) !== null && _a !== void 0 ? _a : "main",
+                forceFullSync: (_b = options.forceSync) !== null && _b !== void 0 ? _b : false,
+            }),
+        });
+        if (!response.ok) {
+            const errorText = yield response.text();
+            throw new Error(`Failed to create snapshot: ${response.status} - ${errorText}`);
+        }
+        return response.json();
+    });
+}
+/**
+ * Get the latest snapshot info
+ */
+function getLatestSnapshot(session, options, logger) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const branch = (_a = options.branch) !== null && _a !== void 0 ? _a : "main";
+        const url = `${getSnapshotApiUrl(session.projectId, "latest-snapshot")}?branch=${branch}`;
+        logger.verbose_log(`GET ${url}`);
+        const response = yield fetch(url, {
+            method: "GET",
+            headers: {
+                Authorization: `Bearer ${session.token}`,
+            },
+        });
+        if (!response.ok) {
+            const errorText = yield response.text();
+            throw new Error(`Failed to get latest snapshot: ${response.status} - ${errorText}`);
+        }
+        return response.json();
+    });
+}
+/**
+ * Download a snapshot from the given URL
+ */
+function downloadSnapshotFile(downloadUrl, token, outputPath, logger) {
+    return __awaiter(this, void 0, void 0, function* () {
+        logger.info("Downloading snapshot...");
+        logger.verbose_log(`GET ${downloadUrl}`);
+        const response = yield fetch(downloadUrl, {
+            headers: {
+                Authorization: `Bearer ${token}`,
+            },
+        });
+        if (!response.ok) {
+            const errorText = yield response.text();
+            throw new Error(`Failed to download snapshot: ${response.status} - ${errorText}`);
+        }
+        // Ensure output directory exists
+        const outputDir = path.dirname(outputPath);
+        if (!fs.existsSync(outputDir)) {
+            fs.mkdirSync(outputDir, { recursive: true });
+        }
+        // Write the ZIP file
+        const arrayBuffer = yield response.arrayBuffer();
+        const buffer = Buffer.from(arrayBuffer);
+        fs.writeFileSync(outputPath, buffer);
+        return outputPath;
+    });
+}
+/**
+ * Extract a ZIP file to a directory
+ */
+function extractZip(zipPath, extractDir, logger) {
+    logger.info("Extracting snapshot...");
+    // Ensure extract directory exists and is empty
+    if (fs.existsSync(extractDir)) {
+        // Remove existing contents
+        fs.rmSync(extractDir, { recursive: true, force: true });
+    }
+    fs.mkdirSync(extractDir, { recursive: true });
+    // Use tar on Unix or PowerShell on Windows
+    const isWindows = process.platform === "win32";
+    try {
+        if (isWindows) {
+            // Use PowerShell's Expand-Archive
+            (0, child_process_1.execSync)(`powershell -Command "Expand-Archive -Path '${zipPath}' -DestinationPath '${extractDir}' -Force"`, { stdio: "pipe" });
+        }
+        else {
+            // Use unzip on Unix
+            (0, child_process_1.execSync)(`unzip -o "${zipPath}" -d "${extractDir}"`, { stdio: "pipe" });
+        }
+    }
+    catch (error) {
+        throw new Error(`Failed to extract snapshot: ${error instanceof Error ? error.message : error}`);
+    }
+}
+/**
+ * Format bytes to human readable string
+ */
+function formatBytes(bytes) {
+    if (bytes === 0)
+        return "0 Bytes";
+    const k = 1024;
+    const sizes = ["Bytes", "KB", "MB", "GB"];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + sizes[i];
+}
+function snapshotCommand() {
+    const command = new commander_1.Command("snapshot").description("Manage storage snapshots for local fallback");
+    // Subcommand: create
+    command
+        .command("create")
+        .description("Create a new storage snapshot (may take a few minutes)")
+        .option("-t, --token <token>", "Authentication token")
+        .option("-u, --url <url>", "Project base URL")
+        .option("-p, --project-id <id>", "Project identifier")
+        .option("-b, --branch <branch>", "Branch name", "main")
+        .option("--force-sync", "Force full sync instead of incremental")
+        .option("--verbose", "Enable verbose logging")
+        .action((options) => __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const logger = new logger_1.Logger(Boolean(options.verbose));
+        try {
+            const session = (0, http_1.resolveSession)({
+                token: options.token,
+                projectId: options.projectId,
+                url: options.url,
+            });
+            const result = yield createSnapshot(session, options, logger);
+            if (!result.success || !result.data) {
+                throw new Error((_a = result.error) !== null && _a !== void 0 ? _a : "Failed to create snapshot");
+            }
+            const { data } = result;
+            logger.success("Snapshot created successfully!");
+            logger.info(`  Project: ${data.projectId}`);
+            logger.info(`  Branch: ${data.branch}`);
+            logger.info(`  Collections: ${data.stats.collectionsProcessed}`);
+            logger.info(`  Entries: ${data.stats.entriesIncluded}`);
+            logger.info(`  Blobs: ${data.stats.blobsIncluded}`);
+            logger.info(`  Files: ${data.stats.filesIncluded}`);
+            logger.info(`  Size: ${formatBytes(data.stats.totalSizeBytes)}`);
+            logger.info(`  Duration: ${data.duration}ms`);
+            logger.info(`  Download URL expires: ${data.expiresAt}`);
+            logger.info("");
+            logger.info("To download this snapshot, run:");
+            logger.info("  ama snapshot download");
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "Unknown error";
+            logger.error(`Snapshot creation failed: ${message}`, error);
+            process.exit(1);
+        }
+    }));
+    // Subcommand: download
+    command
+        .command("download")
+        .description("Download the latest snapshot to local storage")
+        .option("-t, --token <token>", "Authentication token")
+        .option("-u, --url <url>", "Project base URL")
+        .option("-p, --project-id <id>", "Project identifier")
+        .option("-b, --branch <branch>", "Branch name", "main")
+        .option("-o, --output <path>", "Output directory", DEFAULT_OUTPUT_PATH)
+        .option("--verbose", "Enable verbose logging")
+        .action((options) => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c;
+        const logger = new logger_1.Logger(Boolean(options.verbose));
+        try {
+            const session = (0, http_1.resolveSession)({
+                token: options.token,
+                projectId: options.projectId,
+                url: options.url,
+            });
+            // Get the latest snapshot info
+            logger.info("Checking for latest snapshot...");
+            const latestResult = yield getLatestSnapshot(session, options, logger);
+            let downloadUrl;
+            if (latestResult.data && !latestResult.data.isExpired) {
+                // Use existing snapshot
+                logger.info(`Found existing snapshot from: ${latestResult.data.createdAt}`);
+                downloadUrl = latestResult.data.downloadUrl;
+            }
+            else {
+                // Need to create a new snapshot first
+                if ((_a = latestResult.data) === null || _a === void 0 ? void 0 : _a.isExpired) {
+                    logger.warn("Latest snapshot has expired, creating a new one...");
+                }
+                else {
+                    logger.info("No existing snapshot found, creating a new one...");
+                }
+                const createResult = yield createSnapshot(session, options, logger);
+                if (!createResult.success || !createResult.data) {
+                    throw new Error((_b = createResult.error) !== null && _b !== void 0 ? _b : "Failed to create snapshot");
+                }
+                downloadUrl = createResult.data.downloadUrl;
+                logger.info(`Snapshot created (${formatBytes(createResult.data.stats.totalSizeBytes)})`);
+            }
+            // Download the snapshot
+            const outputDir = path.resolve(process.cwd(), (_c = options.output) !== null && _c !== void 0 ? _c : DEFAULT_OUTPUT_PATH);
+            const zipPath = path.join(outputDir, "snapshot.zip");
+            yield downloadSnapshotFile(downloadUrl, session.token, zipPath, logger);
+            logger.success(`Downloaded to: ${zipPath}`);
+            // Extract the snapshot
+            extractZip(zipPath, outputDir, logger);
+            // Remove the ZIP file after extraction
+            fs.unlinkSync(zipPath);
+            logger.success(`Snapshot extracted to: ${outputDir}`);
+            logger.info("");
+            logger.info("Your local storage is now ready. Configure your client with:");
+            logger.info('  clientMode: "local"');
+            logger.info("  or");
+            logger.info('  clientMode: "with-fallback"');
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "Unknown error";
+            logger.error(`Snapshot download failed: ${message}`, error);
+            process.exit(1);
+        }
+    }));
+    return command;
+}

package/dist/cli/commands/upload.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function uploadCommand(): Command;