@appspacer/cli 1.0.0

package/dist/commands/vault.js

@@ -0,0 +1,292 @@
+import fs from "fs";
+import path from "path";
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import dotenv from "dotenv";
+import { select, confirm } from "@inquirer/prompts";
+import { apiRequest } from "../api.js";
+const VAULT_CONF = path.join(process.cwd(), ".vault.json");
+const LOCAL_ENV = path.join(process.cwd(), ".env");
+function loadVaultConfig() {
+    if (!fs.existsSync(VAULT_CONF)) {
+        throw new Error(`Vault not initialized. Run ${chalk.cyan("appspacer vault init")} first.`);
+    }
+    return JSON.parse(fs.readFileSync(VAULT_CONF, "utf-8"));
+}
+function saveVaultConfig(config) {
+    fs.writeFileSync(VAULT_CONF, JSON.stringify(config, null, 2));
+}
+// ── INIT ────────────────────────────────────────────────────────
+const init = async () => {
+    const spinner = ora("Fetching vault projects...").start();
+    try {
+        const projects = await apiRequest("/cli/vault/projects");
+        spinner.stop();
+        if (!projects || projects.length === 0) {
+            console.log(chalk.red("✖ No Vault projects found. Create one in the AppSpacer dashboard first."));
+            return;
+        }
+        const projectId = await select({
+            message: "Select a vault project:",
+            choices: projects.map(p => ({ name: p.name, value: p.id }))
+        });
+        spinner.start("Fetching environments...");
+        const envs = await apiRequest(`/cli/vault/environments/${projectId}`);
+        spinner.stop();
+        if (!envs || envs.length === 0) {
+            console.log(chalk.red("✖ No environments found for this project."));
+            return;
+        }
+        const envId = await select({
+            message: "Select an environment:",
+            choices: envs.map(e => ({ name: e.name, value: e.id }))
+        });
+        const selectedEnv = envs.find(e => e.id === envId);
+        saveVaultConfig({ projectId, envId, envName: selectedEnv.name });
+        // Ensure .env is ignored
+        const gitignorePath = path.join(process.cwd(), ".gitignore");
+        if (fs.existsSync(gitignorePath)) {
+            const content = fs.readFileSync(gitignorePath, "utf-8");
+            if (!content.includes(".env")) {
+                const prefix = content.endsWith("\n") ? "" : "\n";
+                fs.appendFileSync(gitignorePath, `${prefix}\n# AppSpacer Vault\n.env\n`);
+                console.log(chalk.gray(`  Added .env to .gitignore`));
+            }
+        }
+        else {
+            fs.writeFileSync(gitignorePath, "# AppSpacer Vault\n.env\n");
+            console.log(chalk.gray(`  Created .gitignore with .env`));
+        }
+        console.log(chalk.green(`✔ Vault initialised!`));
+        console.log(`  Project: ${projects.find(p => p.id === projectId)?.name}`);
+        console.log(`  Environment: ${selectedEnv.name}`);
+        console.log(`  Target: .env\n`);
+        console.log(`Run ${chalk.cyan("appspacer vault pull")} to download variables.`);
+    }
+    catch (err) {
+        spinner.fail(err instanceof Error ? err.message : "Init failed");
+    }
+};
+// ── PUSH ────────────────────────────────────────────────────────
+const push = async () => {
+    try {
+        const conf = loadVaultConfig();
+        if (!fs.existsSync(LOCAL_ENV)) {
+            console.log(chalk.yellow(`⚠ No .env file found in ${process.cwd()}`));
+            return;
+        }
+        const envString = fs.readFileSync(LOCAL_ENV, "utf-8");
+        const parsedCount = Object.keys(dotenv.parse(Buffer.from(envString))).length;
+        if (parsedCount === 0) {
+            console.log(chalk.yellow("⚠ Local .env is empty. Nothing to push."));
+            return;
+        }
+        const spinner = ora(`Pushing ${parsedCount} variables to vault ${chalk.bold(conf.envName)}...`).start();
+        const res = await apiRequest("/cli/vault/variable/import", {
+            method: "POST",
+            body: JSON.stringify({ environment_id: conf.envId, envString })
+        });
+        spinner.succeed(chalk.green(`${res.count} secrets pushed successfully!`));
+    }
+    catch (err) {
+        console.log(chalk.red("✖ " + (err instanceof Error ? err.message : "Failed to push secrets")));
+    }
+};
+// ── PULL ────────────────────────────────────────────────────────
+const pull = async () => {
+    try {
+        if (fs.existsSync(LOCAL_ENV)) {
+            const ok = await confirm({
+                message: "A .env file already exists. Overwrite it with vault secrets?",
+                default: false
+            });
+            if (!ok) {
+                console.log(chalk.gray("Aborted."));
+                return;
+            }
+        }
+        const conf = loadVaultConfig();
+        const spinner = ora(`Pulling secrets from ${chalk.bold(conf.envName)}...`).start();
+        const vars = await apiRequest(`/cli/vault/variables/${conf.envId}?decrypt=true`);
+        if (vars.length === 0) {
+            spinner.info(chalk.yellow("No variables found in this environment."));
+            return;
+        }
+        const lines = vars.map(v => `${v.key}=${v.value}`);
+        const outString = lines.join("\n") + "\n";
+        // Atomic write — prevent a partial file if the process is interrupted
+        const tmpPath = LOCAL_ENV + ".tmp";
+        fs.writeFileSync(tmpPath, outString);
+        fs.renameSync(tmpPath, LOCAL_ENV);
+        spinner.succeed(chalk.green(`${vars.length} secrets pulled to .env`));
+    }
+    catch (err) {
+        console.log(chalk.red("✖ " + (err instanceof Error ? err.message : "Failed to pull secrets")));
+    }
+};
+// ── ENV COMMANDS ────────────────────────────────────────────────
+const envCommand = new Command("env").description("Manage synced environments");
+envCommand.command("list")
+    .description("List all environments in the current project")
+    .action(async () => {
+    try {
+        const conf = loadVaultConfig();
+        const spinner = ora("Fetching environments...").start();
+        const envs = await apiRequest(`/cli/vault/environments/${conf.projectId}`);
+        spinner.stop();
+        console.log(chalk.bold("\nEnvironments:"));
+        envs.forEach(e => {
+            const mark = e.id === conf.envId ? chalk.green("●") : "○";
+            console.log(`  ${mark} ${e.id === conf.envId ? chalk.green(e.name) : e.name}`);
+        });
+        console.log();
+    }
+    catch (err) {
+        console.log(chalk.red("✖ " + (err instanceof Error ? err.message : "Failed")));
+    }
+});
+envCommand.command("use")
+    .description("Switch the active environment")
+    .argument("<env_name>", "Name of the environment to switch to")
+    .action(async (envName) => {
+    try {
+        const conf = loadVaultConfig();
+        const spinner = ora(`Finding environment '${envName}'...`).start();
+        const envs = await apiRequest(`/cli/vault/environments/${conf.projectId}`);
+        const target = envs.find(e => e.name.toLowerCase() === envName.toLowerCase());
+        if (!target) {
+            spinner.fail(`Environment '${envName}' not found in this project.`);
+            return;
+        }
+        saveVaultConfig({ ...conf, envId: target.id, envName: target.name });
+        spinner.succeed(`Switched to ${chalk.bold(target.name)}`);
+        await pull();
+    }
+    catch (err) {
+        console.log(chalk.red("✖ " + (err instanceof Error ? err.message : "Failed")));
+    }
+});
+// ── SECRETS COMMANDS ────────────────────────────────────────────
+const secretsCommand = new Command("secrets").description("Inspect and edit individual secrets");
+secretsCommand.command("ls")
+    .description("List all remote secrets (values masked)")
+    .action(async () => {
+    try {
+        const conf = loadVaultConfig();
+        const spinner = ora(`Fetching secrets from ${conf.envName}...`).start();
+        const vars = await apiRequest(`/cli/vault/variables/${conf.envId}`);
+        spinner.stop();
+        console.log(chalk.bold(`\nSecrets for ${conf.envName}:`));
+        if (vars.length === 0) {
+            console.log(chalk.gray("  (No secrets found)"));
+        }
+        else {
+            vars.forEach(v => {
+                console.log(`  ${chalk.cyan(v.key)} = ${chalk.gray("••••••••")}`);
+            });
+        }
+        console.log();
+    }
+    catch (err) {
+        console.log(chalk.red("✖ " + (err instanceof Error ? err.message : "Failed")));
+    }
+});
+secretsCommand.command("set")
+    .description("Set a single remote variable (e.g. KEY=VALUE)")
+    .argument("<keyval>", "Format: KEY=VALUE")
+    .action(async (keyval) => {
+    const parts = keyval.split("=");
+    if (parts.length < 2) {
+        console.log(chalk.red("✖ Invalid format. Usage: appspacer vault secrets set KEY=VALUE"));
+        return;
+    }
+    const key = parts[0].trim();
+    const value = parts.slice(1).join("=").trim(); // in case value has =
+    try {
+        const conf = loadVaultConfig();
+        const spinner = ora(`Setting ${key}...`).start();
+        await apiRequest("/cli/vault/variable/create", {
+            method: "POST",
+            body: JSON.stringify({ environment_id: conf.envId, key, value })
+        });
+        spinner.succeed(`Set ${chalk.cyan(key)} in ${chalk.bold(conf.envName)}`);
+    }
+    catch (err) {
+        console.log(chalk.red("✖ " + (err instanceof Error ? err.message : "Failed")));
+    }
+});
+// ── AUDIT ───────────────────────────────────────────────────────
+const audit = async () => {
+    try {
+        const conf = loadVaultConfig();
+        const spinner = ora(`Fetching audit logs...`).start();
+        const logs = await apiRequest(`/cli/vault/audit/${conf.envId}`);
+        spinner.stop();
+        console.log(chalk.bold(`\nAudit Logs - ${conf.envName}`));
+        if (logs.length === 0) {
+            console.log(chalk.gray("  No audit history found."));
+            return;
+        }
+        logs.forEach(log => {
+            const userStr = log.users
+                ? `${log.users.first_name} ${log.users.last_name}`.trim() || log.users.email
+                : "System";
+            const dateStr = new Date(log.created_at).toLocaleString();
+            let actionStr = chalk.bold(log.action);
+            if (log.action === "PULL")
+                actionStr = chalk.cyan(actionStr);
+            else if (log.action === "PUSH")
+                actionStr = chalk.yellow(actionStr);
+            else if (log.action === "SET_VAR")
+                actionStr = chalk.green(actionStr);
+            // Format metadata as readable key=value pairs instead of raw JSON
+            const meta = log.metadata;
+            const metaStr = meta
+                ? Object.entries(meta)
+                    .map(([k, v]) => `${chalk.dim(k + "=")}${v}`)
+                    .join("  ")
+                : "";
+            const line = metaStr
+                ? `${chalk.gray(dateStr)}  ${actionStr.padEnd(10)}  ${userStr}  ${chalk.dim(metaStr)}`
+                : `${chalk.gray(dateStr)}  ${actionStr.padEnd(10)}  ${userStr}`;
+            console.log(line);
+        });
+        console.log();
+    }
+    catch (err) {
+        console.log(chalk.red("✖ " + (err instanceof Error ? err.message : "Failed")));
+    }
+};
+// ── ROLLBACK ────────────────────────────────────────────────────
+const rollback = async () => {
+    try {
+        const conf = loadVaultConfig();
+        const ok = await confirm({
+            message: `Are you sure you want to revert the last change in ${chalk.bold(conf.envName)}?`,
+            default: false
+        });
+        if (!ok) {
+            console.log(chalk.gray("Aborted."));
+            return;
+        }
+        const spinner = ora(`Rolling back last change in ${conf.envName}...`).start();
+        const res = await apiRequest(`/cli/vault/rollback/${conf.envId}`, {
+            method: "POST"
+        });
+        spinner.succeed(chalk.green(res.message));
+        console.log(`Run ${chalk.cyan("appspacer vault pull")} to update your local .env file.`);
+    }
+    catch (err) {
+        console.log(chalk.red("✖ " + (err instanceof Error ? err.message : "Failed to rollback")));
+    }
+};
+export const vaultCommand = new Command("vault")
+    .description("Manage and sync environment variables via AppSpacer Vault");
+vaultCommand.command("init").description("Initialize vault in the current directory").action(init);
+vaultCommand.command("push").description("Push local .env to remote vault").action(push);
+vaultCommand.command("pull").description("Pull variables from remote vault into local .env").action(pull);
+vaultCommand.command("rollback").description("Revert the most recent change in the synced environment").action(rollback);
+vaultCommand.command("audit").description("View recent audit history for the synced environment").action(audit);
+vaultCommand.addCommand(envCommand);
+vaultCommand.addCommand(secretsCommand);

package/dist/commands/whoami.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const whoamiCommand: Command;

package/dist/commands/whoami.js

@@ -0,0 +1,16 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import { apiRequest } from "../api.js";
+export const whoamiCommand = new Command("whoami")
+    .description("Show the currently authenticated user")
+    .action(async () => {
+    try {
+        const user = await apiRequest("/profile");
+        const displayName = `${user.first_name || ""} ${user.last_name || ""}`.trim() || user.email;
+        console.log(chalk.green(`✓ Logged in as ${chalk.bold(displayName)} (${user.email})`));
+    }
+    catch (err) {
+        console.error(chalk.red(`✗ ${err.message}`));
+        process.exit(1);
+    }
+});

package/dist/config.d.ts

@@ -0,0 +1,8 @@
+export interface AppSpacerConfig {
+    apiUrl: string;
+    accessToken: string | null;
+}
+export declare function loadConfig(): AppSpacerConfig;
+export declare function saveConfig(config: Partial<AppSpacerConfig>): void;
+export declare function getToken(): string;
+export declare function getApiUrl(): string;

package/dist/config.js

@@ -0,0 +1,45 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+const CONFIG_DIR = path.join(os.homedir(), ".appspacer");
+const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+const DEFAULT_CONFIG = {
+    apiUrl: "https://api.appspacer.com/api",
+    accessToken: null,
+};
+export function loadConfig() {
+    try {
+        if (fs.existsSync(CONFIG_FILE)) {
+            const raw = fs.readFileSync(CONFIG_FILE, "utf-8");
+            return { ...DEFAULT_CONFIG, ...JSON.parse(raw) };
+        }
+    }
+    catch {
+        // Corrupt or unreadable config — reset to defaults
+    }
+    return { ...DEFAULT_CONFIG };
+}
+export function saveConfig(config) {
+    const current = loadConfig();
+    const merged = { ...current, ...config };
+    if (!fs.existsSync(CONFIG_DIR)) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    // Atomic write: write to a temp file then rename so a concurrent read
+    // never sees a partially-written file.
+    const tmpFile = CONFIG_FILE + ".tmp";
+    fs.writeFileSync(tmpFile, JSON.stringify(merged, null, 2), {
+        mode: 0o600, // owner read/write only — protects the access token on Unix
+    });
+    fs.renameSync(tmpFile, CONFIG_FILE);
+}
+export function getToken() {
+    const config = loadConfig();
+    if (!config.accessToken) {
+        throw new Error("Not logged in. Run `appspacer login` first.");
+    }
+    return config.accessToken;
+}
+export function getApiUrl() {
+    return loadConfig().apiUrl;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { loginCommand } from "./commands/login.js";
+import { releaseCommand } from "./commands/release.js";
+import { deploymentsCommand } from "./commands/deployments.js";
+import { whoamiCommand } from "./commands/whoami.js";
+import { releaseReactNativeCommand } from "./commands/release-react-native.js";
+import { rollbackCommand } from "./commands/rollback.js";
+import { setupCommand, undoCommand } from "./commands/setup.js";
+import { vaultCommand } from "./commands/vault.js";
+const program = new Command();
+program
+    .name("appspacer")
+    .description("AppSpacer CLI — push OTA updates to React Native apps")
+    .version("1.0.0");
+program.addCommand(loginCommand);
+program.addCommand(releaseCommand);
+program.addCommand(deploymentsCommand);
+program.addCommand(whoamiCommand);
+program.addCommand(releaseReactNativeCommand);
+program.addCommand(rollbackCommand);
+program.addCommand(setupCommand);
+program.addCommand(undoCommand);
+program.addCommand(vaultCommand);
+program.parse();

package/dist/utils/bundle.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Run the React Native bundler for the given platform.
+ * Output goes into `outputDir`.
+ *
+ * When `includeAssets` is false (default), only the JS bundle is produced.
+ * This keeps OTA updates small since assets are already in the native binary.
+ */
+export declare function runReactNativeBundle(platform: "android" | "ios", outputDir: string, includeAssets?: boolean): void;

package/dist/utils/bundle.js

@@ -0,0 +1,59 @@
+import { execSync } from "child_process";
+import fs from "fs";
+import path from "path";
+import chalk from "chalk";
+/**
+ * Run the React Native bundler for the given platform.
+ * Output goes into `outputDir`.
+ *
+ * When `includeAssets` is false (default), only the JS bundle is produced.
+ * This keeps OTA updates small since assets are already in the native binary.
+ */
+export function runReactNativeBundle(platform, outputDir, includeAssets = false) {
+    // ── Validation ──────────────────────────────────────────
+    const packageJsonPath = path.resolve("package.json");
+    if (!fs.existsSync(packageJsonPath)) {
+        console.error(chalk.red("✗ Error: No package.json found. Run this command in your React Native project root."));
+        process.exit(1);
+    }
+    const pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+    const isReactNative = pkg.dependencies?.["react-native"] || pkg.devDependencies?.["react-native"];
+    if (!isReactNative) {
+        console.error(chalk.red("✗ Error: This is not a React Native project (missing 'react-native' dependency)."));
+        process.exit(1);
+    }
+    const entryFile = "index.js";
+    if (!fs.existsSync(path.resolve(entryFile))) {
+        console.error(chalk.red(`✗ Error: Entry file "${entryFile}" not found.`));
+        process.exit(1);
+    }
+    // Ensure output directory exists
+    if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+    }
+    const bundleOutput = platform === "android"
+        ? path.join(outputDir, "index.android.bundle")
+        : path.join(outputDir, "main.jsbundle");
+    const parts = [
+        "npx --no-install react-native bundle",
+        `--platform ${platform}`,
+        "--dev false",
+        "--reset-cache",
+        `--entry-file ${entryFile}`,
+        `--bundle-output ${bundleOutput}`,
+    ];
+    if (includeAssets) {
+        // Put assets in a subdirectory to keep things organized
+        const assetsDir = path.join(outputDir, "assets");
+        if (!fs.existsSync(assetsDir)) {
+            fs.mkdirSync(assetsDir, { recursive: true });
+        }
+        parts.push(`--assets-dest ${assetsDir}`);
+    }
+    try {
+        execSync(parts.join(" "), { stdio: "inherit" });
+    }
+    catch (err) {
+        throw new Error("React Native bundling failed. See above for details.");
+    }
+}

package/dist/utils/hash.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Compute a SHA-256 hex digest for the file at `filePath`.
+ */
+export declare function computeFileHash(filePath: string): string;

package/dist/utils/hash.js

@@ -0,0 +1,9 @@
+import crypto from "crypto";
+import fs from "fs";
+/**
+ * Compute a SHA-256 hex digest for the file at `filePath`.
+ */
+export function computeFileHash(filePath) {
+    const fileBuffer = fs.readFileSync(filePath);
+    return crypto.createHash("sha256").update(fileBuffer).digest("hex");
+}

package/dist/utils/ui.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Returns a formatted step label for use with ora spinners.
+ * e.g. [1/4] Bundling React Native app...
+ */
+export declare function stepLabel(n: number, total: number, text: string): string;
+/**
+ * Prints a branded header box for major commands.
+ */
+export declare function printHeader(title: string): void;
+/**
+ * Prints a formatted success summary section after a command completes.
+ * @param title  - headline text shown next to the green ✓
+ * @param rows   - array of [label, value] pairs displayed below
+ */
+export declare function printSummary(title: string, rows: Array<[string, string]>): void;
+/**
+ * Prints a key/value info line — used for lightweight status messages.
+ */
+export declare function infoLine(label: string, value: string): void;

package/dist/utils/ui.js

@@ -0,0 +1,43 @@
+import chalk from "chalk";
+const BRAND = "#7C3AED";
+/**
+ * Returns a formatted step label for use with ora spinners.
+ * e.g. [1/4] Bundling React Native app...
+ */
+export function stepLabel(n, total, text) {
+    return `${chalk.bold.dim(`[${n}/${total}]`)} ${text}`;
+}
+/**
+ * Prints a branded header box for major commands.
+ */
+export function printHeader(title) {
+    const WIDTH = 38;
+    const inner = ` ${title} `;
+    const padded = inner.padStart(Math.floor((WIDTH + inner.length) / 2)).padEnd(WIDTH);
+    console.log("");
+    console.log(chalk.bold.hex(BRAND)("  ╔" + "═".repeat(WIDTH) + "╗"));
+    console.log(chalk.bold.hex(BRAND)("  ║") + chalk.bold.white(padded) + chalk.bold.hex(BRAND)("║"));
+    console.log(chalk.bold.hex(BRAND)("  ╚" + "═".repeat(WIDTH) + "╝"));
+    console.log("");
+}
+/**
+ * Prints a formatted success summary section after a command completes.
+ * @param title  - headline text shown next to the green ✓
+ * @param rows   - array of [label, value] pairs displayed below
+ */
+export function printSummary(title, rows) {
+    const labelWidth = Math.max(...rows.map(([l]) => l.length));
+    console.log("");
+    console.log(chalk.green("  ✓ ") + chalk.bold.green(title));
+    console.log(chalk.dim("  " + "─".repeat(46)));
+    for (const [label, value] of rows) {
+        console.log(`  ${chalk.dim((label + ":").padEnd(labelWidth + 1))}  ${chalk.white(value)}`);
+    }
+    console.log("");
+}
+/**
+ * Prints a key/value info line — used for lightweight status messages.
+ */
+export function infoLine(label, value) {
+    console.log(`  ${chalk.dim(label + ":")}  ${chalk.white(value)}`);
+}

package/dist/utils/validators.d.ts

@@ -0,0 +1,25 @@
+declare const VALID_PLATFORMS: readonly ["android", "ios"];
+export type Platform = typeof VALID_PLATFORMS[number];
+/**
+ * Validates the platform argument and exits with a clear message if invalid.
+ */
+export declare function requireValidPlatform(platform: string): asserts platform is Platform;
+/**
+ * Validates that a deployment name contains only safe characters,
+ * preventing malformed API requests from confusing error responses.
+ */
+export declare function requireValidDeployment(name: string): void;
+/**
+ * Validates that a semver or semver-range string is plausibly well-formed
+ * before sending it to the server.
+ */
+export declare function requireValidVersion(version: string, flag?: string): void;
+/**
+ * Exits with a clear error if a required string option is empty.
+ */
+export declare function requireNonEmpty(value: string, label: string): void;
+/**
+ * Validates that rollout is an integer between 0 and 100.
+ */
+export declare function requireValidRollout(value: string): number;
+export {};

package/dist/utils/validators.js

@@ -0,0 +1,65 @@
+import chalk from "chalk";
+const VALID_PLATFORMS = ["android", "ios"];
+/**
+ * Validates the platform argument and exits with a clear message if invalid.
+ */
+export function requireValidPlatform(platform) {
+    if (!VALID_PLATFORMS.includes(platform)) {
+        console.error(chalk.red(`  ✗ Invalid platform "${platform}".`) +
+            chalk.dim(` Expected: ${VALID_PLATFORMS.join(" | ")}`));
+        process.exit(1);
+    }
+}
+/**
+ * Validates that a deployment name contains only safe characters,
+ * preventing malformed API requests from confusing error responses.
+ */
+export function requireValidDeployment(name) {
+    if (!name || name.trim().length === 0) {
+        console.error(chalk.red("  ✗ Deployment name cannot be empty."));
+        process.exit(1);
+    }
+    if (!/^[a-zA-Z0-9_\- ]+$/.test(name)) {
+        console.error(chalk.red(`  ✗ Invalid deployment name "${name}".`) +
+            chalk.dim(" Only letters, numbers, spaces, hyphens, and underscores are allowed."));
+        process.exit(1);
+    }
+}
+/**
+ * Validates that a semver or semver-range string is plausibly well-formed
+ * before sending it to the server.
+ */
+export function requireValidVersion(version, flag = "-t") {
+    if (!version || version.trim().length === 0) {
+        console.error(chalk.red(`  ✗ Target version (${flag}) cannot be empty.`));
+        process.exit(1);
+    }
+    // Accept: 1.0.0 / ^1.0.0 / ~1.0 / >=1.0.0 <2.0.0 / *
+    const semverLike = /^[\^~><=*\s\d.]+$/;
+    if (!semverLike.test(version)) {
+        console.error(chalk.red(`  ✗ Invalid version "${version}".`) +
+            chalk.dim(` Expected a semver string like 1.0.0 or ^1.2.0 (${flag})`));
+        process.exit(1);
+    }
+}
+/**
+ * Exits with a clear error if a required string option is empty.
+ */
+export function requireNonEmpty(value, label) {
+    if (!value || value.trim().length === 0) {
+        console.error(chalk.red(`  ✗ ${label} cannot be empty.`));
+        process.exit(1);
+    }
+}
+/**
+ * Validates that rollout is an integer between 0 and 100.
+ */
+export function requireValidRollout(value) {
+    const n = parseInt(value, 10);
+    if (isNaN(n) || n < 0 || n > 100) {
+        console.error(chalk.red(`  ✗ Invalid rollout "${value}".`) +
+            chalk.dim(" Expected an integer between 0 and 100."));
+        process.exit(1);
+    }
+    return n;
+}

package/dist/utils/zip.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Zip the contents of `sourceDir` into `outputPath`.
+ * Returns a promise that resolves when the archive is finalized.
+ */
+export declare function createZip(sourceDir: string, outputPath: string): Promise<void>;

package/dist/utils/zip.js

@@ -0,0 +1,17 @@
+import archiver from "archiver";
+import fs from "fs";
+/**
+ * Zip the contents of `sourceDir` into `outputPath`.
+ * Returns a promise that resolves when the archive is finalized.
+ */
+export function createZip(sourceDir, outputPath) {
+    return new Promise((resolve, reject) => {
+        const output = fs.createWriteStream(outputPath);
+        const archive = archiver("zip", { zlib: { level: 9 } });
+        output.on("close", () => resolve());
+        archive.on("error", (err) => reject(err));
+        archive.pipe(output);
+        archive.directory(sourceDir, false);
+        archive.finalize();
+    });
+}