@appspacer/cli 1.0.0

package/dist/__tests__/setup-injections.test.js

@@ -0,0 +1,238 @@
+import { describe, it, expect } from "vitest";
+import { detectArchitecture, hasExistingInjection, removeExistingInjection, injectTraditionalAndroid, injectNewArchAndroid, injectIosSetup, } from "../commands/setup.js";
+// ─── detectArchitecture ──────────────────────────────────────────────────────
+describe("detectArchitecture", () => {
+    it("returns 'new' for ReactHostDelegate pattern", () => {
+        expect(detectArchitecture("class Foo : ReactHostDelegate {}")).toBe("new");
+    });
+    it("returns 'new' for ReactHostImpl pattern", () => {
+        expect(detectArchitecture("val host = ReactHostImpl(ctx, delegate)")).toBe("new");
+    });
+    it("returns 'new' for DefaultNewArchitectureEntryPoint", () => {
+        expect(detectArchitecture("DefaultNewArchitectureEntryPoint.load()")).toBe("new");
+    });
+    it("returns 'traditional' for ReactNativeHost pattern", () => {
+        expect(detectArchitecture("object : ReactNativeHost(this) {}")).toBe("traditional");
+    });
+    it("returns 'traditional' for getJSBundleFile pattern", () => {
+        expect(detectArchitecture("override fun getJSBundleFile(): String? = null")).toBe("traditional");
+    });
+    it("defaults to 'traditional' when no known patterns present", () => {
+        expect(detectArchitecture("class MainApplication : Application() {}")).toBe("traditional");
+    });
+});
+// ─── hasExistingInjection ────────────────────────────────────────────────────
+describe("hasExistingInjection", () => {
+    it("returns true when both markers are present", () => {
+        const content = `before\n// APPSPACER_START\ncode\n// APPSPACER_END\nafter`;
+        expect(hasExistingInjection(content)).toBe(true);
+    });
+    it("returns false when only START marker is present", () => {
+        expect(hasExistingInjection("// APPSPACER_START\ncode")).toBe(false);
+    });
+    it("returns false when only END marker is present", () => {
+        expect(hasExistingInjection("code\n// APPSPACER_END")).toBe(false);
+    });
+    it("returns false when no markers present", () => {
+        expect(hasExistingInjection("class MainApplication {}")).toBe(false);
+    });
+});
+// ─── removeExistingInjection ─────────────────────────────────────────────────
+describe("removeExistingInjection", () => {
+    it("removes the injected block including markers", () => {
+        const content = [
+            "class MainApplication {",
+            "    // APPSPACER_START",
+            "    // injected code",
+            "    // APPSPACER_END",
+            "}",
+        ].join("\n");
+        const result = removeExistingInjection(content);
+        expect(result).not.toContain("APPSPACER_START");
+        expect(result).not.toContain("APPSPACER_END");
+        expect(result).not.toContain("injected code");
+        expect(result).toContain("class MainApplication {");
+        expect(result).toContain("}");
+    });
+    it("returns content unchanged when no injection present", () => {
+        const content = "class MainApplication {}";
+        expect(removeExistingInjection(content)).toBe(content);
+    });
+    it("does not leave excessive blank lines after removal", () => {
+        const content = [
+            "line1",
+            "    // APPSPACER_START",
+            "    code",
+            "    // APPSPACER_END",
+            "line2",
+        ].join("\n");
+        const result = removeExistingInjection(content);
+        expect(result).not.toMatch(/\n{3,}/);
+    });
+});
+// ─── injectTraditionalAndroid ────────────────────────────────────────────────
+describe("injectTraditionalAndroid", () => {
+    it("injects inside ReactNativeHost block", () => {
+        const content = `
+class MainApplication : Application(), ReactApplication {
+    override val reactNativeHost: ReactNativeHost =
+        object : DefaultReactNativeHost(this) {
+        }
+}`;
+        const { result, method } = injectTraditionalAndroid(content);
+        expect(result).toContain("getJSBundleFile");
+        expect(result).toContain("APPSPACER_START");
+        expect(result).toContain("APPSPACER_END");
+        expect(method).toMatch(/ReactNativeHost/i);
+    });
+    it("falls back to class body when no ReactNativeHost block found", () => {
+        const content = `
+class MainApplication : Application() {
+    fun onCreate() {}
+}`;
+        const { result, method } = injectTraditionalAndroid(content);
+        expect(result).toContain("APPSPACER_START");
+        expect(result).toContain("getJSBundleFile");
+        expect(method).toContain("fallback");
+    });
+    it("injected result passes hasExistingInjection check", () => {
+        const content = `class MainApplication : Application() {}`;
+        const { result } = injectTraditionalAndroid(content);
+        expect(hasExistingInjection(result)).toBe(true);
+    });
+});
+// ─── injectNewArchAndroid ────────────────────────────────────────────────────
+describe("injectNewArchAndroid", () => {
+    it("injects inside ReactHostDelegate block", () => {
+        const content = `
+class MainApplication : Application() {
+    val delegate = object : ReactHostDelegate {
+    }
+}`;
+        const { result, method } = injectNewArchAndroid(content);
+        expect(result).toContain("getJsBundleFilePath");
+        expect(result).toContain("APPSPACER_START");
+        expect(method).toMatch(/ReactHostDelegate/i);
+    });
+    it("adds instruction comment for DefaultReactHost pattern", () => {
+        const content = `
+class MainApplication : Application() {
+    val host = DefaultReactHost.getDefaultReactHost(applicationContext, packages)
+}`;
+        const { result, warn } = injectNewArchAndroid(content);
+        expect(result).toContain("APPSPACER_START");
+        expect(result).toContain("ACTION REQUIRED");
+        expect(warn).toContain("manual action required");
+    });
+    it("injected result passes hasExistingInjection check", () => {
+        const content = `
+class MainApplication : Application() {
+    val delegate = object : ReactHostDelegate {}
+}`;
+        const { result } = injectNewArchAndroid(content);
+        expect(hasExistingInjection(result)).toBe(true);
+    });
+});
+// ─── injectIosSetup (Obj-C) ──────────────────────────────────────────────────
+describe("injectIosSetup — Obj-C (.mm)", () => {
+    const filePath = "AppDelegate.mm";
+    it("replaces bundleURL method body", () => {
+        const content = `
+#import "AppDelegate.h"
+
+@implementation AppDelegate
+
+- (NSURL *)bundleURL {
+  return [[RCTBundleURLProvider sharedSettings] jsBundleURLForBundleRoot:@"index"];
+}
+
+@end`;
+        const { result } = injectIosSetup(content, filePath);
+        expect(result).toContain("[AppSpacerModule bundleURL]");
+        expect(result).toContain("APPSPACER_START");
+    });
+    it("adds AppSpacerModule.h import if missing", () => {
+        const content = `
+#import "AppDelegate.h"
+
+@implementation AppDelegate
+
+- (NSURL *)bundleURL {
+  return nil;
+}
+@end`;
+        const { result } = injectIosSetup(content, filePath);
+        expect(result).toContain("#import <AppSpacerModule.h>");
+    });
+    it("does not add duplicate import if already present", () => {
+        const content = `
+#import "AppDelegate.h"
+#import <AppSpacerModule.h>
+
+@implementation AppDelegate
+- (NSURL *)bundleURL { return nil; }
+@end`;
+        const { result } = injectIosSetup(content, filePath);
+        const count = (result.match(/#import <AppSpacerModule\.h>/g) || []).length;
+        expect(count).toBe(1);
+    });
+    it("injects bundleURL method before @end as fallback", () => {
+        const content = `
+#import "AppDelegate.h"
+@implementation AppDelegate
+@end`;
+        const { result } = injectIosSetup(content, filePath);
+        expect(result).toContain("[AppSpacerModule bundleURL]");
+        expect(result).toContain("APPSPACER_START");
+    });
+    it("re-applies cleanly (idempotent via remove + re-inject)", () => {
+        const content = `
+#import "AppDelegate.h"
+@implementation AppDelegate
+- (NSURL *)bundleURL { return nil; }
+@end`;
+        const { result: first } = injectIosSetup(content, filePath);
+        const { result: second } = injectIosSetup(first, filePath);
+        const startCount = (second.match(/APPSPACER_START/g) || []).length;
+        expect(startCount).toBe(1);
+    });
+});
+// ─── injectIosSetup (Swift) ──────────────────────────────────────────────────
+describe("injectIosSetup — Swift (.swift)", () => {
+    const filePath = "AppDelegate.swift";
+    it("replaces bundleURL() override body", () => {
+        const content = `
+import UIKit
+
+@UIApplicationMain
+class AppDelegate: UIResponder, UIApplicationDelegate {
+  override func bundleURL() -> URL? {
+    return RCTBundleURLProvider.sharedSettings().jsBundleURL(forBundleRoot: "index")
+  }
+}`;
+        const { result } = injectIosSetup(content, filePath);
+        expect(result).toContain("AppSpacerModule.bundleURL()");
+        expect(result).toContain("APPSPACER_START");
+    });
+    it("injects bundleURL override before class end as fallback", () => {
+        const content = `
+import UIKit
+class AppDelegate: UIResponder {
+  func application(_ application: UIApplication) -> Bool { return true }
+}`;
+        const { result } = injectIosSetup(content, filePath);
+        expect(result).toContain("AppSpacerModule.bundleURL()");
+        expect(result).toContain("APPSPACER_START");
+    });
+    it("re-applies cleanly (idempotent)", () => {
+        const content = `
+import UIKit
+class AppDelegate: UIResponder {
+  override func bundleURL() -> URL? { return nil }
+}`;
+        const { result: first } = injectIosSetup(content, filePath);
+        const { result: second } = injectIosSetup(first, filePath);
+        const startCount = (second.match(/APPSPACER_START/g) || []).length;
+        expect(startCount).toBe(1);
+    });
+});

package/dist/__tests__/zip.test.d.ts

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

package/dist/__tests__/zip.test.js

@@ -0,0 +1,62 @@
+import { describe, it, expect, afterAll } from "vitest";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { createZip } from "../utils/zip.js";
+const TMP_DIR = path.join(os.tmpdir(), "appspacer-zip-tests");
+function setup() {
+    const sourceDir = path.join(TMP_DIR, "source");
+    const zipPath = path.join(TMP_DIR, "out.zip");
+    fs.mkdirSync(sourceDir, { recursive: true });
+    return { sourceDir, zipPath };
+}
+afterAll(() => {
+    if (fs.existsSync(TMP_DIR))
+        fs.rmSync(TMP_DIR, { recursive: true, force: true });
+});
+describe("createZip", () => {
+    it("creates a zip file at the given output path", async () => {
+        const { sourceDir, zipPath } = setup();
+        fs.writeFileSync(path.join(sourceDir, "bundle.js"), "console.log('hello');");
+        await createZip(sourceDir, zipPath);
+        expect(fs.existsSync(zipPath)).toBe(true);
+        expect(fs.statSync(zipPath).size).toBeGreaterThan(0);
+    });
+    it("zip file starts with PK magic bytes (valid ZIP header)", async () => {
+        const { sourceDir, zipPath } = setup();
+        fs.writeFileSync(path.join(sourceDir, "index.js"), "export default 42;");
+        await createZip(sourceDir, zipPath);
+        const buf = Buffer.alloc(4);
+        const fd = fs.openSync(zipPath, "r");
+        fs.readSync(fd, buf, 0, 4, 0);
+        fs.closeSync(fd);
+        // ZIP local file header signature: PK (0x50 0x4B 0x03 0x04)
+        expect(buf[0]).toBe(0x50);
+        expect(buf[1]).toBe(0x4b);
+    });
+    it("produces a larger zip when more files are added", async () => {
+        const { sourceDir, zipPath: zipA } = setup();
+        fs.writeFileSync(path.join(sourceDir, "a.js"), "a");
+        await createZip(sourceDir, zipA);
+        const sizeA = fs.statSync(zipA).size;
+        fs.writeFileSync(path.join(sourceDir, "b.js"), "b".repeat(1000));
+        const zipB = path.join(TMP_DIR, "out2.zip");
+        await createZip(sourceDir, zipB);
+        const sizeB = fs.statSync(zipB).size;
+        expect(sizeB).toBeGreaterThan(sizeA);
+    });
+    it("works with an empty directory", async () => {
+        const { sourceDir, zipPath } = setup();
+        // sourceDir exists but is empty
+        await expect(createZip(sourceDir, zipPath)).resolves.toBeUndefined();
+    });
+    it("packages nested files correctly (no throw)", async () => {
+        const { sourceDir, zipPath } = setup();
+        const sub = path.join(sourceDir, "assets", "images");
+        fs.mkdirSync(sub, { recursive: true });
+        fs.writeFileSync(path.join(sub, "logo.png"), "fake-png-data");
+        fs.writeFileSync(path.join(sourceDir, "index.js"), "console.log('hi')");
+        await expect(createZip(sourceDir, zipPath)).resolves.toBeUndefined();
+        expect(fs.statSync(zipPath).size).toBeGreaterThan(0);
+    });
+});

package/dist/api.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Make an authenticated request to the AppSpacer API.
+ * - Aborts automatically after 30 seconds.
+ * - Retries up to 3 times on HTTP 429, honouring the Retry-After header.
+ */
+export declare function apiRequest<T>(endpoint: string, options?: RequestInit): Promise<T>;

package/dist/api.js

@@ -0,0 +1,52 @@
+import { getApiUrl, getToken } from "./config.js";
+const REQUEST_TIMEOUT_MS = 30_000;
+const MAX_RETRIES = 3;
+const RETRY_DELAY_MS = 5_000;
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Make an authenticated request to the AppSpacer API.
+ * - Aborts automatically after 30 seconds.
+ * - Retries up to 3 times on HTTP 429, honouring the Retry-After header.
+ */
+export async function apiRequest(endpoint, options = {}) {
+    const url = `${getApiUrl()}${endpoint}`;
+    const token = getToken();
+    const headers = {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json",
+        ...(options.headers || {}),
+    };
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+        let response;
+        try {
+            response = await fetch(url, { ...options, headers, signal: controller.signal });
+        }
+        catch (err) {
+            clearTimeout(timer);
+            if (err.name === "AbortError") {
+                throw new Error(`Request timed out after ${REQUEST_TIMEOUT_MS / 1000}s (${endpoint})`);
+            }
+            throw err;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+        // Rate-limited — wait then retry
+        if (response.status === 429 && attempt < MAX_RETRIES) {
+            const retryAfter = parseInt(response.headers.get("Retry-After") ?? String(RETRY_DELAY_MS / 1000), 10);
+            await sleep(retryAfter * 1000);
+            continue;
+        }
+        const body = await response.json();
+        if (!response.ok || !body.success) {
+            const msg = body.error?.message ?? `Request failed with status ${response.status}`;
+            throw new Error(msg);
+        }
+        return body.data;
+    }
+    throw new Error(`Request failed after ${MAX_RETRIES} retries (${endpoint})`);
+}

package/dist/commands/deployments.d.ts

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

package/dist/commands/deployments.js

@@ -0,0 +1,39 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { apiRequest } from "../api.js";
+const KEY_PREVIEW_LEN = 24;
+export const deploymentsCommand = new Command("deployments")
+    .description("List CodePush deployments for an app")
+    .requiredOption("-a, --app <appIdOrName>", "App ID or Name")
+    .addHelpText("after", `
+Examples:
+  $ appspacer deployments -a my-app
+  $ appspacer deployments -a abc123`)
+    .action(async (opts) => {
+    const spinner = ora("Fetching deployments...").start();
+    try {
+        const deployments = await apiRequest(`/codepush/deployments?app_id=${opts.app}`);
+        spinner.stop();
+        if (!deployments || deployments.length === 0) {
+            console.log(chalk.yellow("\n  No deployments found for this app.\n"));
+            return;
+        }
+        const nameWidth = Math.max(4, ...deployments.map((d) => d.name.length));
+        console.log("");
+        console.log(`  ${chalk.bold("NAME".padEnd(nameWidth))}   ${chalk.bold("DEPLOYMENT KEY")}`);
+        console.log(chalk.dim("  " + "─".repeat(nameWidth + 3 + KEY_PREVIEW_LEN + 1)));
+        for (const d of deployments) {
+            const keyPreview = d.key.length > KEY_PREVIEW_LEN
+                ? d.key.slice(0, KEY_PREVIEW_LEN) + "…"
+                : d.key;
+            console.log(`  ${chalk.cyan(d.name.padEnd(nameWidth))}   ${chalk.dim(keyPreview)}`);
+        }
+        console.log(chalk.dim(`\n  ${deployments.length} deployment${deployments.length !== 1 ? "s" : ""} found\n`));
+    }
+    catch (err) {
+        spinner.fail("Failed to fetch deployments");
+        console.error(chalk.red(`  ✗ ${err.message}`));
+        process.exit(1);
+    }
+});

package/dist/commands/envsync.d.ts

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

package/dist/commands/envsync.js

@@ -0,0 +1,230 @@
+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 } from "@inquirer/prompts";
+import { apiRequest } from "../api.js";
+const ENVSYNC_CONF = path.join(process.cwd(), ".envsync.json");
+const LOCAL_ENV = path.join(process.cwd(), ".env");
+function loadEnvsyncConfig() {
+    if (!fs.existsSync(ENVSYNC_CONF)) {
+        throw new Error(`Vault not initialized. Run ${chalk.cyan("appspacer envsync init")} first.`);
+    }
+    return JSON.parse(fs.readFileSync(ENVSYNC_CONF, "utf-8"));
+}
+function saveEnvsyncConfig(config) {
+    fs.writeFileSync(ENVSYNC_CONF, JSON.stringify(config, null, 2));
+}
+// ── INIT ────────────────────────────────────────────────────────
+const init = async () => {
+    const spinner = ora("Fetching vault projects...").start();
+    try {
+        const projects = await apiRequest("/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(`/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);
+        saveEnvsyncConfig({ projectId, envId, envName: selectedEnv.name });
+        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 envsync pull")} to download variables.`);
+    }
+    catch (err) {
+        spinner.fail(err.message || "Init failed");
+    }
+};
+// ── PUSH ────────────────────────────────────────────────────────
+const push = async () => {
+    try {
+        const conf = loadEnvsyncConfig();
+        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("/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.message || "Failed to push secrets")));
+    }
+};
+// ── PULL ────────────────────────────────────────────────────────
+const pull = async () => {
+    try {
+        const conf = loadEnvsyncConfig();
+        const spinner = ora(`Pulling secrets from ${chalk.bold(conf.envName)}...`).start();
+        const vars = await apiRequest(`/vault/variables/${conf.envId}?decrypt=true`);
+        if (vars.length === 0) {
+            spinner.info(chalk.yellow("No variables found in this environment."));
+            return;
+        }
+        // Build .env string
+        const lines = vars.map(v => `${v.key}=${v.value}`);
+        const outString = lines.join("\n") + "\n";
+        fs.writeFileSync(LOCAL_ENV, outString);
+        spinner.succeed(chalk.green(`${vars.length} secrets pulled to .env`));
+    }
+    catch (err) {
+        console.log(chalk.red("✖ " + (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 = loadEnvsyncConfig();
+        const spinner = ora("Fetching environments...").start();
+        const envs = await apiRequest(`/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.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 = loadEnvsyncConfig();
+        const spinner = ora(`Finding environment '${envName}'...`).start();
+        const envs = await apiRequest(`/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;
+        }
+        saveEnvsyncConfig({ ...conf, envId: target.id, envName: target.name });
+        spinner.succeed(`Switched to ${chalk.bold(target.name)}`);
+        await pull();
+    }
+    catch (err) {
+        console.log(chalk.red("✖ " + (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 = loadEnvsyncConfig();
+        const spinner = ora(`Fetching secrets from ${conf.envName}...`).start();
+        const vars = await apiRequest(`/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(v.value)}`);
+            });
+        }
+        console.log();
+    }
+    catch (err) {
+        console.log(chalk.red("✖ " + (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 envsync secrets set KEY=VALUE"));
+        return;
+    }
+    const key = parts[0].trim();
+    const value = parts.slice(1).join("=").trim(); // in case value has =
+    try {
+        const conf = loadEnvsyncConfig();
+        const spinner = ora(`Setting ${key}...`).start();
+        await apiRequest("/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.message || "Failed")));
+    }
+});
+// ── AUDIT ───────────────────────────────────────────────────────
+const audit = async () => {
+    try {
+        const conf = loadEnvsyncConfig();
+        const spinner = ora(`Fetching audit logs...`).start();
+        const logs = await apiRequest(`/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}` : "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);
+            console.log(`${chalk.gray(dateStr)} | ${userStr} | ${actionStr} | ${chalk.gray(JSON.stringify(log.metadata))}`);
+        });
+        console.log();
+    }
+    catch (err) {
+        console.log(chalk.red("✖ " + (err.message || "Failed")));
+    }
+};
+export const envsyncCommand = new Command("envsync")
+    .description("Manage and sync environment variables via AppSpacer Vault");
+envsyncCommand.command("init").description("Initialize an envsync vault in the current directory").action(init);
+envsyncCommand.command("push").description("Push local .env to remote vault").action(push);
+envsyncCommand.command("pull").description("Pull variables from remote vault into local .env").action(pull);
+envsyncCommand.command("audit").description("View recent audit history for the synced environment").action(audit);
+envsyncCommand.addCommand(envCommand);
+envsyncCommand.addCommand(secretsCommand);

package/dist/commands/login.d.ts

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