@revstackhq/cli 0.0.0-dev-20260226054033

package/src/commands/push.ts

@@ -0,0 +1,206 @@
+/**
+ * @file commands/push.ts
+ * @description The core deployment command. Loads the local config, sends it
+ * to Revstack Cloud for diffing, presents the changes, and (upon confirmation)
+ * pushes the config to production.
+ */
+
+import { Command } from "commander";
+import chalk from "chalk";
+import prompts from "prompts";
+import ora from "ora";
+import { getApiKey } from "@/utils/auth";
+import { loadLocalConfig } from "@/utils/config-loader";
+
+// ─── Types ───────────────────────────────────────────────────
+
+interface DiffEntry {
+  action: "added" | "removed" | "updated";
+  entity: string;
+  id: string;
+  message: string;
+}
+
+interface DiffResponse {
+  diff: DiffEntry[];
+  canPush: boolean;
+  blockedReason?: string;
+}
+
+// ─── Helpers ─────────────────────────────────────────────────
+
+const API_BASE = "https://app.revstack.dev";
+
+const DIFF_ICONS: Record<DiffEntry["action"], string> = {
+  added: chalk.green("  + "),
+  removed: chalk.red("  − "),
+  updated: chalk.yellow("  ~ "),
+};
+
+const DIFF_COLORS: Record<DiffEntry["action"], (text: string) => string> = {
+  added: chalk.green,
+  removed: chalk.red,
+  updated: chalk.yellow,
+};
+
+function printDiff(diff: DiffEntry[]): void {
+  if (diff.length === 0) {
+    console.log(
+      chalk.dim("\n  No changes detected. Your config is up to date.\n")
+    );
+    return;
+  }
+
+  console.log(chalk.bold("\n  Changes:\n"));
+
+  for (const entry of diff) {
+    const icon = DIFF_ICONS[entry.action];
+    const color = DIFF_COLORS[entry.action];
+    const label = chalk.dim(`[${entry.entity}]`);
+    console.log(
+      `${icon}${color(entry.id)} ${label} ${chalk.white(entry.message)}`
+    );
+  }
+
+  console.log();
+}
+
+function requireAuth(): string {
+  const apiKey = getApiKey();
+
+  if (!apiKey) {
+    console.error(
+      "\n" +
+        chalk.red("  ✖ Not authenticated.\n") +
+        chalk.dim("    Run ") +
+        chalk.bold("revstack login") +
+        chalk.dim(" first.\n")
+    );
+    process.exit(1);
+  }
+
+  return apiKey;
+}
+
+// ─── Command ─────────────────────────────────────────────────
+
+export const pushCommand = new Command("push")
+  .description("Push your local billing config to Revstack Cloud")
+  .option("-e, --env <environment>", "Target environment", "test")
+  .action(async (options: { env: string }) => {
+    const apiKey = requireAuth();
+    const config = await loadLocalConfig(process.cwd());
+
+    // ── Step 1: Compute diff ──────────────────────────────────
+
+    const spinner = ora({
+      text: "Calculating diff...",
+      prefixText: " ",
+    }).start();
+
+    let diffResponse: DiffResponse;
+
+    try {
+      const res = await fetch(`${API_BASE}/api/v1/cli/diff`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey}`,
+        },
+        body: JSON.stringify({ env: options.env, config }),
+      });
+
+      if (!res.ok) {
+        spinner.fail("Failed to calculate diff");
+        console.error(
+          chalk.red(`\n  API returned ${res.status}: ${res.statusText}\n`)
+        );
+        process.exit(1);
+      }
+
+      diffResponse = (await res.json()) as DiffResponse;
+      spinner.succeed("Diff calculated");
+    } catch (error: unknown) {
+      spinner.fail("Failed to reach Revstack Cloud");
+      console.error(chalk.red(`\n  ${(error as Error).message}\n`));
+      process.exit(1);
+    }
+
+    // ── Step 2: Present diff ──────────────────────────────────
+
+    printDiff(diffResponse.diff);
+
+    if (diffResponse.diff.length === 0) {
+      return;
+    }
+
+    // ── Step 3: Check if push is allowed ──────────────────────
+
+    if (!diffResponse.canPush) {
+      console.log(
+        chalk.red("  ✖ Push is blocked.\n") +
+          chalk.dim(
+            `    ${diffResponse.blockedReason ?? "The server rejected this configuration."}\n`
+          )
+      );
+      process.exit(1);
+    }
+
+    // ── Step 4: Confirm ───────────────────────────────────────
+
+    const envLabel =
+      options.env === "production"
+        ? chalk.red.bold(options.env)
+        : chalk.cyan.bold(options.env);
+
+    const { confirm } = await prompts({
+      type: "confirm",
+      name: "confirm",
+      message: `Apply these changes to ${envLabel}?`,
+      initial: false,
+    });
+
+    if (!confirm) {
+      console.log(chalk.dim("\n  Push cancelled.\n"));
+      return;
+    }
+
+    // ── Step 5: Push ──────────────────────────────────────────
+
+    const pushSpinner = ora({
+      text: `Pushing to ${options.env}...`,
+      prefixText: " ",
+    }).start();
+
+    try {
+      const res = await fetch(`${API_BASE}/api/v1/cli/push`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey}`,
+        },
+        body: JSON.stringify({ env: options.env, config }),
+      });
+
+      if (!res.ok) {
+        pushSpinner.fail("Push failed");
+        console.error(
+          chalk.red(`\n  API returned ${res.status}: ${res.statusText}\n`)
+        );
+        process.exit(1);
+      }
+
+      pushSpinner.succeed("Pushed successfully");
+      console.log(
+        "\n" +
+          chalk.green("  ✔ Config deployed to ") +
+          envLabel +
+          "\n" +
+          chalk.dim("    Changes are now live.\n")
+      );
+    } catch (error: unknown) {
+      pushSpinner.fail("Push failed");
+      console.error(chalk.red(`\n  ${(error as Error).message}\n`));
+      process.exit(1);
+    }
+  });

package/src/utils/auth.ts

@@ -0,0 +1,59 @@
+/**
+ * @file utils/auth.ts
+ * @description Manages global Revstack credentials stored at ~/.revstack/credentials.json.
+ * Provides simple get/set helpers for the API key used by all authenticated commands.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+const CREDENTIALS_DIR = path.join(os.homedir(), ".revstack");
+const CREDENTIALS_FILE = path.join(CREDENTIALS_DIR, "credentials.json");
+
+interface Credentials {
+  apiKey: string;
+}
+
+/**
+ * Persist an API key to the global credentials file.
+ * Creates `~/.revstack/` if it doesn't exist.
+ */
+export function setApiKey(key: string): void {
+  if (!fs.existsSync(CREDENTIALS_DIR)) {
+    fs.mkdirSync(CREDENTIALS_DIR, { recursive: true });
+  }
+
+  const credentials: Credentials = { apiKey: key };
+  fs.writeFileSync(
+    CREDENTIALS_FILE,
+    JSON.stringify(credentials, null, 2),
+    "utf-8"
+  );
+}
+
+/**
+ * Read the stored API key, or return `null` if none is configured.
+ */
+export function getApiKey(): string | null {
+  if (!fs.existsSync(CREDENTIALS_FILE)) {
+    return null;
+  }
+
+  try {
+    const raw = fs.readFileSync(CREDENTIALS_FILE, "utf-8");
+    const credentials: Credentials = JSON.parse(raw);
+    return credentials.apiKey ?? null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Remove stored credentials. Used by `revstack logout`.
+ */
+export function clearApiKey(): void {
+  if (fs.existsSync(CREDENTIALS_FILE)) {
+    fs.unlinkSync(CREDENTIALS_FILE);
+  }
+}

package/src/utils/config-loader.ts

@@ -0,0 +1,57 @@
+/**
+ * @file utils/config-loader.ts
+ * @description Loads and evaluates the user's `revstack.config.ts` at runtime
+ * using jiti (just-in-time TypeScript compilation). Returns a sanitized,
+ * JSON-safe representation of the config for network transmission.
+ */
+
+import { createJiti } from "jiti";
+import path from "node:path";
+import chalk from "chalk";
+
+/**
+ * Load the `revstack.config.ts` from the given directory.
+ *
+ * @param cwd - The directory to search for `revstack.config.ts`.
+ * @returns The parsed and sanitized configuration object.
+ */
+export async function loadLocalConfig(
+  cwd: string
+): Promise<Record<string, unknown>> {
+  const configPath = path.resolve(cwd, "revstack.config.ts");
+
+  try {
+    const jiti = createJiti(cwd);
+    const module = (await jiti.import(configPath)) as Record<string, unknown>;
+    const config = (module.default ?? module) as Record<string, unknown>;
+
+    // Sanitize: strip functions, class instances, and non-serializable data.
+    // This ensures we only send plain JSON to the Revstack Cloud API.
+    return JSON.parse(JSON.stringify(config));
+  } catch (error: unknown) {
+    const err = error as NodeJS.ErrnoException;
+
+    if (
+      err.code === "ERR_MODULE_NOT_FOUND" ||
+      err.code === "ENOENT" ||
+      err.code === "MODULE_NOT_FOUND"
+    ) {
+      console.error(
+        chalk.red(
+          "\n  ✖ Could not find revstack.config.ts in the current directory.\n"
+        ) +
+          chalk.dim("    Run ") +
+          chalk.bold("revstack init") +
+          chalk.dim(" to create one.\n")
+      );
+    } else {
+      console.error(
+        chalk.red("\n  ✖ Failed to parse revstack.config.ts\n") +
+          chalk.dim("    " + (err.message ?? String(error))) +
+          "\n"
+      );
+    }
+
+    process.exit(1);
+  }
+}

package/tests/integration/init.test.ts

@@ -0,0 +1,97 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { Command } from "commander";
+
+// ── Mock node:fs ─────────────────────────────────────────────
+vi.mock("node:fs", () => ({
+  default: {
+    existsSync: vi.fn(),
+    writeFileSync: vi.fn(),
+  },
+  existsSync: vi.fn(),
+  writeFileSync: vi.fn(),
+}));
+
+// ── Mock chalk (no-op proxy) ─────────────────────────────────
+vi.mock("chalk", () => {
+  const passthrough = (s: string) => s;
+  const handler: ProxyHandler<typeof passthrough> = {
+    get: () => new Proxy(passthrough, handler),
+    apply: (_t, _ctx, args: string[]) => args[0],
+  };
+  return { default: new Proxy(passthrough, handler) };
+});
+
+// ── Imports (after mocks) ────────────────────────────────────
+import fs from "node:fs";
+import { initCommand } from "../../src/commands/init";
+
+const mockFs = vi.mocked(fs);
+
+class ProcessExitError extends Error {
+  code: number;
+  constructor(code: number) {
+    super(`process.exit(${code})`);
+    this.code = code;
+  }
+}
+
+function createTestProgram(): Command {
+  const program = new Command();
+  program.exitOverride();
+  program.addCommand(initCommand);
+  return program;
+}
+
+let exitSpy: ReturnType<typeof vi.spyOn>;
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  exitSpy = vi
+    .spyOn(process, "exit")
+    .mockImplementation((code?: string | number | null | undefined) => {
+      throw new ProcessExitError(Number(code ?? 0));
+    });
+});
+
+afterEach(() => {
+  exitSpy.mockRestore();
+});
+
+// ── Tests ────────────────────────────────────────────────────
+
+describe("init command", () => {
+  it("creates revstack.config.ts when it does not exist", async () => {
+    mockFs.existsSync.mockReturnValue(false);
+    const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+
+    const program = createTestProgram();
+    await program.parseAsync(["node", "revstack", "init"], { from: "node" });
+
+    expect(mockFs.writeFileSync).toHaveBeenCalledWith(
+      expect.stringContaining("revstack.config.ts"),
+      expect.stringContaining("defineConfig"),
+      "utf-8"
+    );
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining("Created revstack.config.ts")
+    );
+
+    consoleSpy.mockRestore();
+  });
+
+  it("exits with code 1 when revstack.config.ts already exists", async () => {
+    mockFs.existsSync.mockReturnValue(true);
+    const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+
+    const program = createTestProgram();
+
+    await expect(
+      program.parseAsync(["node", "revstack", "init"], { from: "node" })
+    ).rejects.toThrow(ProcessExitError);
+
+    expect(exitSpy).toHaveBeenCalledWith(1);
+    expect(mockFs.writeFileSync).not.toHaveBeenCalled();
+
+    consoleSpy.mockRestore();
+  });
+});

package/tests/integration/login.test.ts

@@ -0,0 +1,95 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { Command } from "commander";
+
+// ── Mock auth ────────────────────────────────────────────────
+vi.mock("../../src/utils/auth", () => ({
+  setApiKey: vi.fn(),
+}));
+
+// ── Mock prompts ─────────────────────────────────────────────
+vi.mock("prompts", () => ({
+  default: vi.fn(),
+}));
+
+// ── Mock chalk (no-op proxy) ─────────────────────────────────
+vi.mock("chalk", () => {
+  const passthrough = (s: string) => s;
+  const handler: ProxyHandler<typeof passthrough> = {
+    get: () => new Proxy(passthrough, handler),
+    apply: (_t, _ctx, args: string[]) => args[0],
+  };
+  return { default: new Proxy(passthrough, handler) };
+});
+
+// ── Imports (after mocks) ────────────────────────────────────
+import { setApiKey } from "../../src/utils/auth";
+import prompts from "prompts";
+import { loginCommand } from "../../src/commands/login";
+
+const mockSetApiKey = vi.mocked(setApiKey);
+const mockPrompts = vi.mocked(prompts);
+
+class ProcessExitError extends Error {
+  code: number;
+  constructor(code: number) {
+    super(`process.exit(${code})`);
+    this.code = code;
+  }
+}
+
+function createTestProgram(): Command {
+  const program = new Command();
+  program.exitOverride();
+  program.addCommand(loginCommand);
+  return program;
+}
+
+let exitSpy: ReturnType<typeof vi.spyOn>;
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  exitSpy = vi
+    .spyOn(process, "exit")
+    .mockImplementation((code?: string | number | null | undefined) => {
+      throw new ProcessExitError(Number(code ?? 0));
+    });
+});
+
+afterEach(() => {
+  exitSpy.mockRestore();
+});
+
+// ── Tests ────────────────────────────────────────────────────
+
+describe("login command", () => {
+  it("stores the API key when user provides a valid key", async () => {
+    mockPrompts.mockResolvedValue({ secretKey: "sk_test_mykey123" });
+    const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+
+    const program = createTestProgram();
+    await program.parseAsync(["node", "revstack", "login"], { from: "node" });
+
+    expect(mockSetApiKey).toHaveBeenCalledWith("sk_test_mykey123");
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining("Authenticated successfully")
+    );
+
+    consoleSpy.mockRestore();
+  });
+
+  it("exits when user cancels the prompt", async () => {
+    mockPrompts.mockResolvedValue({}); // empty → no secretKey
+    const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+
+    const program = createTestProgram();
+
+    await expect(
+      program.parseAsync(["node", "revstack", "login"], { from: "node" })
+    ).rejects.toThrow(ProcessExitError);
+
+    expect(exitSpy).toHaveBeenCalledWith(0);
+    expect(mockSetApiKey).not.toHaveBeenCalled();
+
+    consoleSpy.mockRestore();
+  });
+});

package/tests/integration/logout.test.ts

@@ -0,0 +1,70 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { Command } from "commander";
+
+// ── Mock auth ────────────────────────────────────────────────
+vi.mock("../../src/utils/auth", () => ({
+  getApiKey: vi.fn(),
+  clearApiKey: vi.fn(),
+}));
+
+// ── Mock chalk (no-op proxy) ─────────────────────────────────
+vi.mock("chalk", () => {
+  const passthrough = (s: string) => s;
+  const handler: ProxyHandler<typeof passthrough> = {
+    get: () => new Proxy(passthrough, handler),
+    apply: (_t, _ctx, args: string[]) => args[0],
+  };
+  return { default: new Proxy(passthrough, handler) };
+});
+
+// ── Imports (after mocks) ────────────────────────────────────
+import { getApiKey, clearApiKey } from "../../src/utils/auth";
+import { logoutCommand } from "../../src/commands/logout";
+
+const mockGetApiKey = vi.mocked(getApiKey);
+const mockClearApiKey = vi.mocked(clearApiKey);
+
+function createTestProgram(): Command {
+  const program = new Command();
+  program.exitOverride();
+  program.addCommand(logoutCommand);
+  return program;
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+// ── Tests ────────────────────────────────────────────────────
+
+describe("logout command", () => {
+  it("prints 'not logged in' when no credentials exist", async () => {
+    mockGetApiKey.mockReturnValue(null);
+    const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+
+    const program = createTestProgram();
+    await program.parseAsync(["node", "revstack", "logout"], { from: "node" });
+
+    expect(mockClearApiKey).not.toHaveBeenCalled();
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining("Not currently logged in")
+    );
+
+    consoleSpy.mockRestore();
+  });
+
+  it("clears credentials and prints success when logged in", async () => {
+    mockGetApiKey.mockReturnValue("sk_test_valid123");
+    const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+
+    const program = createTestProgram();
+    await program.parseAsync(["node", "revstack", "logout"], { from: "node" });
+
+    expect(mockClearApiKey).toHaveBeenCalledOnce();
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining("Successfully logged out")
+    );
+
+    consoleSpy.mockRestore();
+  });
+});