@revstackhq/cli 0.0.0-dev-20260226054033

package/tests/integration/pull.test.ts

@@ -0,0 +1,216 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { Command } from "commander";
+
+// ── Mock auth ────────────────────────────────────────────────
+vi.mock("../../src/utils/auth", () => ({
+  getApiKey: vi.fn(),
+}));
+
+// ── Mock prompts ─────────────────────────────────────────────
+vi.mock("prompts", () => ({
+  default: vi.fn(),
+}));
+
+// ── Mock ora ─────────────────────────────────────────────────
+const mockSpinner = {
+  start: vi.fn().mockReturnThis(),
+  succeed: vi.fn().mockReturnThis(),
+  fail: vi.fn().mockReturnThis(),
+};
+
+vi.mock("ora", () => ({
+  default: vi.fn(() => mockSpinner),
+}));
+
+// ── 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) };
+});
+
+// ── Mock node:fs ─────────────────────────────────────────────
+vi.mock("node:fs", () => ({
+  default: {
+    existsSync: vi.fn(),
+    writeFileSync: vi.fn(),
+  },
+  existsSync: vi.fn(),
+  writeFileSync: vi.fn(),
+}));
+
+// ── Imports (after mocks) ────────────────────────────────────
+import { getApiKey } from "../../src/utils/auth";
+import prompts from "prompts";
+import fs from "node:fs";
+import { pullCommand } from "../../src/commands/pull";
+
+const mockGetApiKey = vi.mocked(getApiKey);
+const mockPrompts = vi.mocked(prompts);
+const mockFs = vi.mocked(fs);
+
+// ── Helpers ──────────────────────────────────────────────────
+
+const REMOTE_CONFIG = {
+  features: {
+    seats: { name: "Seats", type: "static", unit_type: "count" },
+  },
+  plans: {
+    default: {
+      name: "Default",
+      is_default: true,
+      is_public: false,
+      type: "free",
+      features: {},
+    },
+  },
+};
+
+function createFetchResponse(body: unknown, ok = true, status = 200): Response {
+  return {
+    ok,
+    status,
+    statusText: ok ? "OK" : "Bad Request",
+    json: () => Promise.resolve(body),
+    headers: new Headers(),
+    redirected: false,
+    type: "basic" as ResponseType,
+    url: "",
+    clone: () => createFetchResponse(body, ok, status),
+    body: null,
+    bodyUsed: false,
+    arrayBuffer: () => Promise.resolve(new ArrayBuffer(0)),
+    blob: () => Promise.resolve(new Blob()),
+    formData: () => Promise.resolve(new FormData()),
+    text: () => Promise.resolve(JSON.stringify(body)),
+    bytes: () => Promise.resolve(new Uint8Array()),
+  };
+}
+
+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(pullCommand);
+  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();
+  vi.unstubAllGlobals();
+});
+
+// ── Tests ────────────────────────────────────────────────────
+
+describe("pull command", () => {
+  it("exits if the user is not authenticated", async () => {
+    mockGetApiKey.mockReturnValue(null);
+
+    const program = createTestProgram();
+
+    await expect(
+      program.parseAsync(["node", "revstack", "pull"], { from: "node" })
+    ).rejects.toThrow(ProcessExitError);
+
+    expect(exitSpy).toHaveBeenCalledWith(1);
+  });
+
+  it("exits when the API returns an error", async () => {
+    mockGetApiKey.mockReturnValue("sk_test_valid123");
+
+    const mockFetch = vi
+      .fn()
+      .mockResolvedValueOnce(createFetchResponse({}, false, 500));
+
+    vi.stubGlobal("fetch", mockFetch);
+
+    const program = createTestProgram();
+
+    await expect(
+      program.parseAsync(["node", "revstack", "pull"], { from: "node" })
+    ).rejects.toThrow(ProcessExitError);
+
+    expect(exitSpy).toHaveBeenCalledWith(1);
+    expect(mockSpinner.fail).toHaveBeenCalled();
+  });
+
+  it("pulls config and writes file after user confirmation", async () => {
+    mockGetApiKey.mockReturnValue("sk_test_valid123");
+    mockFs.existsSync.mockReturnValue(true); // config file exists
+
+    const mockFetch = vi
+      .fn()
+      .mockResolvedValueOnce(createFetchResponse(REMOTE_CONFIG));
+
+    vi.stubGlobal("fetch", mockFetch);
+    mockPrompts.mockResolvedValue({ confirm: true });
+
+    const program = createTestProgram();
+    await program.parseAsync(["node", "revstack", "pull"], { from: "node" });
+
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    expect(mockFetch.mock.calls[0][0]).toContain("/api/v1/cli/pull");
+    expect(mockFs.writeFileSync).toHaveBeenCalledWith(
+      expect.stringContaining("revstack.config.ts"),
+      expect.stringContaining("defineConfig"),
+      "utf-8"
+    );
+  });
+
+  it("cancels without writing when user declines", async () => {
+    mockGetApiKey.mockReturnValue("sk_test_valid123");
+    mockFs.existsSync.mockReturnValue(true);
+
+    const mockFetch = vi
+      .fn()
+      .mockResolvedValueOnce(createFetchResponse(REMOTE_CONFIG));
+
+    vi.stubGlobal("fetch", mockFetch);
+    mockPrompts.mockResolvedValue({ confirm: false });
+
+    const program = createTestProgram();
+    await program.parseAsync(["node", "revstack", "pull"], { from: "node" });
+
+    expect(mockFs.writeFileSync).not.toHaveBeenCalled();
+  });
+
+  it("skips confirmation when config file does not exist", async () => {
+    mockGetApiKey.mockReturnValue("sk_test_valid123");
+    mockFs.existsSync.mockReturnValue(false); // no existing config
+
+    const mockFetch = vi
+      .fn()
+      .mockResolvedValueOnce(createFetchResponse(REMOTE_CONFIG));
+
+    vi.stubGlobal("fetch", mockFetch);
+
+    const program = createTestProgram();
+    await program.parseAsync(["node", "revstack", "pull"], { from: "node" });
+
+    // Prompts never called since file doesn't exist
+    expect(mockPrompts).not.toHaveBeenCalled();
+    // File was written directly
+    expect(mockFs.writeFileSync).toHaveBeenCalled();
+  });
+});

package/tests/integration/push.test.ts

@@ -0,0 +1,204 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { Command } from "commander";
+
+// ── Mock auth (using @/ alias to match push.ts imports) ──────
+vi.mock("../../src/utils/auth", () => ({
+  getApiKey: vi.fn(),
+}));
+
+// ── Mock config-loader ───────────────────────────────────────
+vi.mock("../../src/utils/config-loader", () => ({
+  loadLocalConfig: vi.fn(),
+}));
+
+// ── Mock prompts ─────────────────────────────────────────────
+vi.mock("prompts", () => ({
+  default: vi.fn(),
+}));
+
+// ── Mock ora ─────────────────────────────────────────────────
+const mockSpinner = {
+  start: vi.fn().mockReturnThis(),
+  succeed: vi.fn().mockReturnThis(),
+  fail: vi.fn().mockReturnThis(),
+};
+
+vi.mock("ora", () => ({
+  default: vi.fn(() => mockSpinner),
+}));
+
+// ── 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 } from "../../src/utils/auth";
+import { loadLocalConfig } from "../../src/utils/config-loader";
+import { pushCommand } from "../../src/commands/push";
+import prompts from "prompts";
+
+const mockGetApiKey = vi.mocked(getApiKey);
+const mockLoadLocalConfig = vi.mocked(loadLocalConfig);
+const mockPrompts = vi.mocked(prompts);
+
+// ── Helpers ──────────────────────────────────────────────────
+
+const SAMPLE_CONFIG = {
+  features: { seats: { name: "Seats", type: "static", unit_type: "count" } },
+  plans: {
+    default: {
+      name: "Default",
+      is_default: true,
+      is_public: false,
+      type: "free",
+      features: {},
+    },
+  },
+};
+
+function createFetchResponse(body: unknown, ok = true, status = 200): Response {
+  return {
+    ok,
+    status,
+    statusText: ok ? "OK" : "Bad Request",
+    json: () => Promise.resolve(body),
+    headers: new Headers(),
+    redirected: false,
+    type: "basic" as ResponseType,
+    url: "",
+    clone: () => createFetchResponse(body, ok, status),
+    body: null,
+    bodyUsed: false,
+    arrayBuffer: () => Promise.resolve(new ArrayBuffer(0)),
+    blob: () => Promise.resolve(new Blob()),
+    formData: () => Promise.resolve(new FormData()),
+    text: () => Promise.resolve(JSON.stringify(body)),
+    bytes: () => Promise.resolve(new Uint8Array()),
+  };
+}
+
+// ── Capture process.exit via a thrown sentinel ────────────────
+
+class ProcessExitError extends Error {
+  code: number;
+  constructor(code: number) {
+    super(`process.exit(${code})`);
+    this.code = code;
+  }
+}
+
+/**
+ * Creates a fresh commander wrapper around pushCommand's action
+ * to avoid state leakage between tests.
+ */
+function createTestProgram(): Command {
+  const program = new Command();
+  program.exitOverride(); // Throw instead of calling process.exit
+  program.addCommand(pushCommand);
+  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();
+  vi.unstubAllGlobals();
+});
+
+// ── Tests ────────────────────────────────────────────────────
+
+describe("push command", () => {
+  it("exits if the user is not authenticated", async () => {
+    mockGetApiKey.mockReturnValue(null);
+
+    const program = createTestProgram();
+
+    await expect(
+      program.parseAsync(["node", "revstack", "push"], { from: "node" })
+    ).rejects.toThrow(ProcessExitError);
+
+    expect(exitSpy).toHaveBeenCalledWith(1);
+    expect(mockLoadLocalConfig).not.toHaveBeenCalled();
+  });
+
+  it("diffs, confirms, and pushes successfully", async () => {
+    mockGetApiKey.mockReturnValue("sk_test_valid123");
+    mockLoadLocalConfig.mockResolvedValue(
+      SAMPLE_CONFIG as Record<string, unknown>
+    );
+
+    const diffResponse = {
+      diff: [
+        { action: "added", entity: "plan", id: "pro", message: "New plan" },
+      ],
+      canPush: true,
+    };
+
+    const mockFetch = vi
+      .fn()
+      .mockResolvedValueOnce(createFetchResponse(diffResponse))
+      .mockResolvedValueOnce(createFetchResponse({ success: true }));
+
+    vi.stubGlobal("fetch", mockFetch);
+    mockPrompts.mockResolvedValue({ confirm: true });
+
+    const program = createTestProgram();
+    await program.parseAsync(["node", "revstack", "push"], { from: "node" });
+
+    // Verify both diff and push endpoints were called
+    expect(mockFetch).toHaveBeenCalledTimes(2);
+    expect(mockFetch.mock.calls[0][0]).toContain("/api/v1/cli/diff");
+    expect(mockFetch.mock.calls[1][0]).toContain("/api/v1/cli/push");
+  });
+
+  it("exits early when push is blocked (canPush: false)", async () => {
+    mockGetApiKey.mockReturnValue("sk_test_valid123");
+    mockLoadLocalConfig.mockResolvedValue(
+      SAMPLE_CONFIG as Record<string, unknown>
+    );
+
+    const diffResponse = {
+      diff: [
+        {
+          action: "removed",
+          entity: "plan",
+          id: "default",
+          message: "Cannot remove default plan",
+        },
+      ],
+      canPush: false,
+      blockedReason: "Cannot delete the default plan.",
+    };
+
+    const mockFetch = vi
+      .fn()
+      .mockResolvedValueOnce(createFetchResponse(diffResponse));
+
+    vi.stubGlobal("fetch", mockFetch);
+
+    const program = createTestProgram();
+
+    await expect(
+      program.parseAsync(["node", "revstack", "push"], { from: "node" })
+    ).rejects.toThrow(ProcessExitError);
+
+    // Only diff called, push never reached
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    expect(exitSpy).toHaveBeenCalledWith(1);
+  });
+});

package/tests/unit/auth.test.ts

@@ -0,0 +1,112 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+// ── Mock node:fs before importing auth ────────────────────────
+vi.mock("node:fs", () => ({
+  default: {
+    existsSync: vi.fn(),
+    mkdirSync: vi.fn(),
+    writeFileSync: vi.fn(),
+    readFileSync: vi.fn(),
+    unlinkSync: vi.fn(),
+  },
+  existsSync: vi.fn(),
+  mkdirSync: vi.fn(),
+  writeFileSync: vi.fn(),
+  readFileSync: vi.fn(),
+  unlinkSync: vi.fn(),
+}));
+
+import fs from "node:fs";
+import { setApiKey, getApiKey, clearApiKey } from "../../src/utils/auth.js";
+
+const mockFs = vi.mocked(fs);
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+describe("auth", () => {
+  describe("setApiKey", () => {
+    it("creates the .revstack directory if it does not exist", () => {
+      mockFs.existsSync.mockReturnValue(false);
+
+      setApiKey("sk_test_abc123");
+
+      expect(mockFs.mkdirSync).toHaveBeenCalledWith(
+        expect.stringContaining(".revstack"),
+        { recursive: true }
+      );
+    });
+
+    it("writes credentials.json with the API key", () => {
+      mockFs.existsSync.mockReturnValue(true);
+
+      setApiKey("sk_test_abc123");
+
+      expect(mockFs.writeFileSync).toHaveBeenCalledWith(
+        expect.stringContaining("credentials.json"),
+        JSON.stringify({ apiKey: "sk_test_abc123" }, null, 2),
+        "utf-8"
+      );
+    });
+
+    it("skips mkdir if directory already exists", () => {
+      mockFs.existsSync.mockReturnValue(true);
+
+      setApiKey("sk_live_xyz");
+
+      expect(mockFs.mkdirSync).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("getApiKey", () => {
+    it("returns the stored API key", () => {
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.readFileSync.mockReturnValue(
+        JSON.stringify({ apiKey: "sk_test_stored" })
+      );
+
+      const key = getApiKey();
+
+      expect(key).toBe("sk_test_stored");
+    });
+
+    it("returns null if credentials file does not exist", () => {
+      mockFs.existsSync.mockReturnValue(false);
+
+      const key = getApiKey();
+
+      expect(key).toBeNull();
+      expect(mockFs.readFileSync).not.toHaveBeenCalled();
+    });
+
+    it("returns null if the file contains invalid JSON", () => {
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.readFileSync.mockReturnValue("not valid json");
+
+      const key = getApiKey();
+
+      expect(key).toBeNull();
+    });
+  });
+
+  describe("clearApiKey", () => {
+    it("deletes the credentials file if it exists", () => {
+      mockFs.existsSync.mockReturnValue(true);
+
+      clearApiKey();
+
+      expect(mockFs.unlinkSync).toHaveBeenCalledWith(
+        expect.stringContaining("credentials.json")
+      );
+    });
+
+    it("does nothing if credentials file does not exist", () => {
+      mockFs.existsSync.mockReturnValue(false);
+
+      clearApiKey();
+
+      expect(mockFs.unlinkSync).not.toHaveBeenCalled();
+    });
+  });
+});

package/tests/unit/config-loader.test.ts

@@ -0,0 +1,94 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+// ── Mock jiti ─────────────────────────────────────────────────
+const mockImport = vi.fn();
+
+vi.mock("jiti", () => ({
+  createJiti: vi.fn(() => ({
+    import: mockImport,
+  })),
+}));
+
+// ── Mock chalk to avoid ANSI in test output ───────────────────
+vi.mock("chalk", () => ({
+  default: {
+    red: (s: string) => s,
+    dim: (s: string) => s,
+    bold: (s: string) => s,
+  },
+}));
+
+// ── Mock process.exit ────────────────────────────────────────
+const mockExit = vi
+  .spyOn(process, "exit")
+  .mockImplementation(() => undefined as never);
+
+import { loadLocalConfig } from "../../src/utils/config-loader.js";
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+describe("config-loader", () => {
+  describe("loadLocalConfig", () => {
+    it("extracts the default export from the module", async () => {
+      const sampleConfig = {
+        features: {
+          seats: { name: "Seats", type: "static", unit_type: "count" },
+        },
+        plans: {},
+      };
+
+      mockImport.mockResolvedValue({ default: sampleConfig });
+
+      const result = await loadLocalConfig("/fake/project");
+
+      expect(result).toEqual(sampleConfig);
+    });
+
+    it("falls back to the module itself if no default export", async () => {
+      const sampleConfig = { features: {}, plans: {} };
+
+      mockImport.mockResolvedValue(sampleConfig);
+
+      const result = await loadLocalConfig("/fake/project");
+
+      expect(result).toEqual(sampleConfig);
+    });
+
+    it("sanitizes non-serializable values (functions stripped)", async () => {
+      const configWithFn = {
+        default: {
+          features: {},
+          plans: {},
+          helper: () => "should be stripped",
+        },
+      };
+
+      mockImport.mockResolvedValue(configWithFn);
+
+      const result = await loadLocalConfig("/fake/project");
+
+      expect(result).not.toHaveProperty("helper");
+      expect(result).toEqual({ features: {}, plans: {} });
+    });
+
+    it("calls process.exit(1) if the config file is not found", async () => {
+      const error: NodeJS.ErrnoException = new Error("Cannot find module");
+      error.code = "MODULE_NOT_FOUND";
+      mockImport.mockRejectedValue(error);
+
+      await loadLocalConfig("/fake/project");
+
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+
+    it("calls process.exit(1) on syntax errors", async () => {
+      mockImport.mockRejectedValue(new SyntaxError("Unexpected token"));
+
+      await loadLocalConfig("/fake/project");
+
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/tsconfig.test.json

@@ -0,0 +1,12 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["./src/*"]
+    },
+    "noEmit": true,
+    "types": ["node", "vitest/globals"]
+  },
+  "include": ["src", "tests"]
+}

package/tsup.config.ts

@@ -0,0 +1,16 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+  entry: ["src/cli.ts"],
+  format: ["esm"],
+  dts: false,
+  splitting: false,
+  sourcemap: true,
+  clean: true,
+  target: "node18",
+  outDir: "dist",
+  skipNodeModulesBundle: true,
+  banner: {
+    js: "#!/usr/bin/env node",
+  },
+});

package/vitest.config.ts

@@ -0,0 +1,15 @@
+import { defineConfig } from "vitest/config";
+import path from "node:path";
+
+export default defineConfig({
+  resolve: {
+    alias: {
+      "@": path.resolve(__dirname, "src"),
+    },
+  },
+  test: {
+    globals: true,
+    environment: "node",
+    include: ["tests/**/*.test.ts"],
+  },
+});