badgr-cli 1.0.48 → 1.1.0

package/tests/onboarding.test.js

@@ -0,0 +1,134 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+const mockCallApi = vi.fn();
+const mockOpenBrowser = vi.fn();
+const mockSaveConfig = vi.fn(updates => ({ apiKey: 'test-key', baseUrl: 'https://example.test/v1', ...updates }));
+
+vi.mock('../src/api.js', () => ({ callApi: (...args) => mockCallApi(...args) }));
+vi.mock('../src/browser.js', () => ({ openBrowser: (...args) => mockOpenBrowser(...args) }));
+vi.mock('../src/config.js', async () => {
+  const actual = await vi.importActual('../src/config.js');
+  return { ...actual, saveConfig: (...args) => mockSaveConfig(...args) };
+});
+
+const { ensureBadgrReady } = await import('../src/onboarding.js');
+
+const chalk = { red: s => s, dim: s => s, green: s => s, bold: s => s, yellow: s => s, cyan: s => s };
+
+describe('ensureBadgrReady', () => {
+  let originalStdinTTY;
+  let originalStdoutTTY;
+
+  beforeEach(() => {
+    mockCallApi.mockReset();
+    mockOpenBrowser.mockReset();
+    mockSaveConfig.mockClear();
+    process.exitCode = undefined;
+    vi.spyOn(console, 'log').mockImplementation(() => {});
+    vi.spyOn(console, 'error').mockImplementation(() => {});
+    originalStdinTTY = process.stdin.isTTY;
+    originalStdoutTTY = process.stdout.isTTY;
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    vi.useRealTimers();
+    process.stdin.isTTY = originalStdinTTY;
+    process.stdout.isTTY = originalStdoutTTY;
+    process.exitCode = undefined;
+  });
+
+  describe('non-interactive (no TTY)', () => {
+    beforeEach(() => {
+      process.stdin.isTTY = false;
+      process.stdout.isTTY = false;
+    });
+
+    it('returns the config unchanged when an API key is already stored, without any network calls', async () => {
+      const config = { apiKey: 'existing-key', baseUrl: 'https://example.test/v1' };
+      const result = await ensureBadgrReady(config, chalk);
+      expect(result).toBe(config);
+      expect(mockCallApi).not.toHaveBeenCalled();
+      expect(mockOpenBrowser).not.toHaveBeenCalled();
+    });
+
+    it('throws the standard "Run: badgr login" error instead of opening a browser', async () => {
+      const config = { apiKey: undefined, baseUrl: 'https://example.test/v1' };
+      await expect(ensureBadgrReady(config, chalk)).rejects.toThrow(/badgr login/);
+      expect(mockOpenBrowser).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('interactive (TTY present)', () => {
+    beforeEach(() => {
+      process.stdin.isTTY = true;
+      process.stdout.isTTY = true;
+    });
+
+    it('skips the login/billing flow entirely when already logged in with a positive balance', async () => {
+      const config = { apiKey: 'existing-key', baseUrl: 'https://example.test/v1' };
+      mockCallApi.mockResolvedValueOnce({ credits: 10 }); // /api/me
+      const result = await ensureBadgrReady(config, chalk);
+      expect(result.apiKey).toBe('existing-key');
+      expect(mockOpenBrowser).not.toHaveBeenCalled();
+    });
+
+    it('opens the login URL, polls until complete, and stores the returned API key', async () => {
+      vi.useFakeTimers();
+      const config = { apiKey: undefined, baseUrl: 'https://example.test/v1' };
+
+      mockCallApi
+        .mockResolvedValueOnce({ session_id: 'sess-1', login_url: 'https://aibadgr.com/login?cli_session=sess-1' }) // POST /cli/session
+        .mockResolvedValueOnce({ status: 'pending' }) // first poll
+        .mockResolvedValueOnce({ status: 'complete', api_key: 'new-key-from-browser', credits: 10 }) // second poll
+        .mockResolvedValueOnce({ credits: 10 }); // /api/me funded check afterward
+
+      const promise = ensureBadgrReady(config, chalk);
+      await vi.advanceTimersByTimeAsync(2000);
+      await vi.advanceTimersByTimeAsync(2000);
+      const result = await promise;
+
+      expect(mockOpenBrowser).toHaveBeenCalledWith('https://aibadgr.com/login?cli_session=sess-1');
+      expect(mockSaveConfig).toHaveBeenCalledWith({ apiKey: 'new-key-from-browser' });
+      expect(result.apiKey).toBe('new-key-from-browser');
+    });
+
+    it('throws if the login session expires before completion', async () => {
+      vi.useFakeTimers();
+      const config = { apiKey: undefined, baseUrl: 'https://example.test/v1' };
+      mockCallApi
+        .mockResolvedValueOnce({ session_id: 'sess-1', login_url: 'https://aibadgr.com/login?cli_session=sess-1' })
+        .mockResolvedValueOnce({ status: 'expired' });
+
+      const promise = ensureBadgrReady(config, chalk);
+      const assertion = expect(promise).rejects.toThrow(/expired/);
+      await vi.advanceTimersByTimeAsync(2000);
+      await assertion;
+    });
+
+    it('opens billing checkout and polls until funded when balance is $0', async () => {
+      vi.useFakeTimers();
+      const config = { apiKey: 'existing-key', baseUrl: 'https://example.test/v1' };
+
+      mockCallApi
+        .mockResolvedValueOnce({ credits: 0 }) // initial /api/me
+        .mockResolvedValueOnce({ credits: 0 }) // first poll
+        .mockResolvedValueOnce({ credits: 10 }); // second poll — funded
+
+      const promise = ensureBadgrReady(config, chalk);
+      await vi.advanceTimersByTimeAsync(2000);
+      await vi.advanceTimersByTimeAsync(2000);
+      await promise;
+
+      expect(mockOpenBrowser).toHaveBeenCalledWith('https://aibadgr.com/dashboard#billing');
+    });
+
+    it('does not block the launch if the balance check itself fails to reach the API', async () => {
+      const config = { apiKey: 'existing-key', baseUrl: 'https://example.test/v1' };
+      mockCallApi.mockRejectedValueOnce(new Error('network down'));
+      const result = await ensureBadgrReady(config, chalk);
+      expect(result.apiKey).toBe('existing-key');
+      expect(mockOpenBrowser).not.toHaveBeenCalled();
+    });
+  });
+});

package/tests/pull.test.js

@@ -0,0 +1,266 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import { changedFilesFromPatch, intersectFiles, parsePullArgs, localChangedFiles } from '../src/commands/pull.js';
+
+describe('localChangedFiles', () => {
+  function fakeGit(stdout) {
+    return () => ({ status: 0, stdout, stderr: '' });
+  }
+
+  it('parses an unstaged modification (leading-space status code)', () => {
+    // Regression: a naive .trim() on the line eats this leading status
+    // space and shifts the fixed-width slice, corrupting the filename.
+    expect(localChangedFiles(fakeGit(' M src/checkout.ts\n'))).toEqual(['src/checkout.ts']);
+  });
+
+  it('parses a staged modification (trailing-space status code)', () => {
+    expect(localChangedFiles(fakeGit('M  src/checkout.ts\n'))).toEqual(['src/checkout.ts']);
+  });
+
+  it('parses an untracked file', () => {
+    expect(localChangedFiles(fakeGit('?? new-file.txt\n'))).toEqual(['new-file.txt']);
+  });
+
+  it('parses a rename, keeping only the destination path', () => {
+    expect(localChangedFiles(fakeGit('R  old-name.txt -> new-name.txt\n'))).toEqual(['new-name.txt']);
+  });
+
+  it('parses multiple changed files, sorted', () => {
+    expect(localChangedFiles(fakeGit(' M b.txt\n?? a.txt\n'))).toEqual(['a.txt', 'b.txt']);
+  });
+
+  it('returns an empty array for a clean worktree', () => {
+    expect(localChangedFiles(fakeGit(''))).toEqual([]);
+  });
+
+  it('throws when git status fails', () => {
+    const failing = () => ({ status: 1, stdout: '', stderr: 'not a git repository' });
+    expect(() => localChangedFiles(failing)).toThrow('not a git repository');
+  });
+});
+
+describe('badgr pull helpers', () => {
+  it('parses deployment id and safety flags', () => {
+    expect(parsePullArgs(['dep-123', '--branch'])).toEqual({ deploymentId: 'dep-123', flags: { branch: true, diffOnly: false, yes: false } });
+    expect(parsePullArgs(['dep-123', '--diff-only'])).toEqual({ deploymentId: 'dep-123', flags: { branch: false, diffOnly: true, yes: false } });
+  });
+
+  it('parses --yes and -y as the same flag', () => {
+    expect(parsePullArgs(['dep-123', '--yes']).flags.yes).toBe(true);
+    expect(parsePullArgs(['dep-123', '-y']).flags.yes).toBe(true);
+  });
+
+  it('defaults all safety flags to false when only the id is given', () => {
+    expect(parsePullArgs(['dep-123'])).toEqual({ deploymentId: 'dep-123', flags: { branch: false, diffOnly: false, yes: false } });
+  });
+
+  it('returns undefined deploymentId when no positional arg is given', () => {
+    expect(parsePullArgs(['--branch']).deploymentId).toBeUndefined();
+  });
+
+  it('extracts changed files from a git patch and detects conflicts', () => {
+    const patch = ['diff --git a/src/a.js b/src/a.js', '--- a/src/a.js', '+++ b/src/a.js', 'diff --git a/new.txt b/new.txt', '--- /dev/null', '+++ b/new.txt'].join('\n');
+    expect(changedFilesFromPatch(patch)).toEqual(['new.txt', 'src/a.js']);
+    expect(intersectFiles(['new.txt', 'src/a.js'], ['src/a.js', 'README.md'])).toEqual(['src/a.js']);
+  });
+
+  it('extracts changed files from a patch that only adds new files', () => {
+    const patch = ['diff --git a/new.txt b/new.txt', '--- /dev/null', '+++ b/new.txt'].join('\n');
+    expect(changedFilesFromPatch(patch)).toEqual(['new.txt']);
+  });
+
+  it('returns an empty conflict list when nothing overlaps', () => {
+    expect(intersectFiles(['a.js', 'b.js'], ['c.js'])).toEqual([]);
+  });
+});
+
+// Configurable per-test behavior — set inside each test before calling
+// pullCommand, since vi.mock factories are hoisted and evaluated once.
+let gitBehavior = {};
+let tarWriteBehavior = () => {};
+
+function resetGitBehavior() {
+  gitBehavior = {
+    revParse: () => ({ status: 0, stdout: 'true\n', stderr: '' }),
+    status: () => ({ status: 0, stdout: '', stderr: '' }),
+    checkout: () => ({ status: 0, stdout: '', stderr: '' }),
+    applyCheck: () => ({ status: 0, stdout: '', stderr: '' }),
+    apply: () => ({ status: 0, stdout: '', stderr: '' }),
+  };
+}
+
+vi.mock('child_process', () => ({
+  spawnSync: vi.fn((cmd, args) => {
+    if (args[0] === 'rev-parse') return gitBehavior.revParse();
+    if (args[0] === 'status') return gitBehavior.status();
+    if (args[0] === 'checkout') return gitBehavior.checkout(args);
+    if (args[0] === 'apply' && args[1] === '--check') return gitBehavior.applyCheck(args);
+    if (args[0] === 'apply') return gitBehavior.apply(args);
+    return { status: 0, stdout: '', stderr: '' };
+  }),
+}));
+
+vi.mock('tar', () => {
+  const x = vi.fn(async opts => tarWriteBehavior(opts));
+  return { default: { x }, x };
+});
+
+function writeNonPatchArtifact({ cwd }) {
+  fs.mkdirSync(`${cwd}/test-results`, { recursive: true });
+  fs.writeFileSync(`${cwd}/test-results/output.txt`, 'ok');
+}
+
+function writePatchArtifact(patchText) {
+  return ({ cwd }) => {
+    fs.writeFileSync(`${cwd}/badgr-agent.patch`, patchText);
+  };
+}
+
+const CLEAN_PATCH = [
+  'diff --git a/src/checkout.ts b/src/checkout.ts',
+  '--- a/src/checkout.ts',
+  '+++ b/src/checkout.ts',
+  '@@ -1 +1 @@',
+  '-old',
+  '+new',
+].join('\n');
+
+describe('pullCommand', () => {
+  const config = { apiKey: 'test-key', baseUrl: 'https://example.test/v1' };
+  const chalk = { red: s => s, dim: s => s, green: s => s, yellow: s => s };
+
+  beforeEach(() => {
+    process.exitCode = undefined;
+    resetGitBehavior();
+    tarWriteBehavior = writeNonPatchArtifact;
+    vi.spyOn(console, 'log').mockImplementation(() => {});
+    vi.spyOn(console, 'error').mockImplementation(() => {});
+    vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+    global.fetch = vi.fn().mockResolvedValue({
+      ok: true,
+      arrayBuffer: async () => new ArrayBuffer(8),
+    });
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    process.exitCode = undefined;
+    delete global.fetch;
+  });
+
+  it('prints a usage error and exits 1 when no deployment id is given', async () => {
+    const { pullCommand } = await import('../src/commands/pull.js');
+    await pullCommand(config, [], chalk);
+    expect(process.exitCode).toBe(1);
+    expect(console.error).toHaveBeenCalled();
+  });
+
+  it('errors when not run inside a git worktree', async () => {
+    gitBehavior.revParse = () => ({ status: 0, stdout: 'false\n', stderr: '' });
+    const { pullCommand } = await import('../src/commands/pull.js');
+    await pullCommand(config, ['dep-abc'], chalk);
+    expect(process.exitCode).toBe(1);
+    const logged = console.error.mock.calls.map(c => c.join(' ')).join('\n');
+    expect(logged).toContain('git worktree');
+  });
+
+  it('reports a download failure clearly', async () => {
+    global.fetch = vi.fn().mockResolvedValue({ ok: false, status: 404, statusText: 'Not Found', text: async () => '' });
+    const { pullCommand } = await import('../src/commands/pull.js');
+    await pullCommand(config, ['dep-missing'], chalk);
+    expect(process.exitCode).toBe(1);
+    const logged = console.error.mock.calls.map(c => c.join(' ')).join('\n');
+    expect(logged).toContain('Could not pull dep-missing');
+  });
+
+  it('points to `badgr artifacts <id>` instead of erroring when there is no code patch', async () => {
+    const { pullCommand } = await import('../src/commands/pull.js');
+    await pullCommand(config, ['dep-test-001'], chalk);
+
+    expect(process.exitCode).toBeUndefined();
+    const logged = console.log.mock.calls.map(c => c.join(' ')).join('\n');
+    expect(logged).toContain('badgr artifacts dep-test-001');
+    expect(logged).toContain('nothing to apply');
+  });
+
+  it('applies cleanly when there are no local conflicts', async () => {
+    tarWriteBehavior = writePatchArtifact(CLEAN_PATCH);
+    gitBehavior.status = () => ({ status: 0, stdout: '', stderr: '' }); // no local changes at all
+
+    const { pullCommand } = await import('../src/commands/pull.js');
+    await pullCommand(config, ['dep-clean-001'], chalk);
+
+    expect(process.exitCode).toBeUndefined();
+    const logged = console.log.mock.calls.map(c => c.join(' ')).join('\n');
+    expect(logged).toContain('Applied cloud changes from dep-clean-001');
+    expect(logged).toContain('src/checkout.ts');
+  });
+
+  it('refuses to overwrite when local edits conflict, without --branch', async () => {
+    tarWriteBehavior = writePatchArtifact(CLEAN_PATCH);
+    gitBehavior.status = () => ({ status: 0, stdout: ' M src/checkout.ts\n', stderr: '' });
+
+    const { pullCommand } = await import('../src/commands/pull.js');
+    await pullCommand(config, ['dep-conflict-001'], chalk);
+
+    expect(process.exitCode).toBe(1);
+    const logged = console.error.mock.calls.map(c => c.join(' ')).join('\n');
+    expect(logged).toContain('conflict with local edits');
+    expect(logged).toContain('src/checkout.ts');
+    expect(logged).toContain('--branch');
+  });
+
+  it('applies on a new branch when --branch is passed despite conflicts', async () => {
+    tarWriteBehavior = writePatchArtifact(CLEAN_PATCH);
+    gitBehavior.status = () => ({ status: 0, stdout: ' M src/checkout.ts\n', stderr: '' });
+    const checkoutSpy = vi.fn(() => ({ status: 0, stdout: '', stderr: '' }));
+    gitBehavior.checkout = checkoutSpy;
+
+    const { pullCommand } = await import('../src/commands/pull.js');
+    await pullCommand(config, ['dep-conflict-002', '--branch'], chalk);
+
+    expect(process.exitCode).toBeUndefined();
+    expect(checkoutSpy).toHaveBeenCalledWith(['checkout', '-b', 'badgr/dep-conflict-002']);
+    const logged = console.log.mock.calls.map(c => c.join(' ')).join('\n');
+    expect(logged).toContain('Created branch badgr/dep-conflict-002');
+    expect(logged).toContain('Applied cloud changes from dep-conflict-002');
+  });
+
+  it('--diff-only prints the raw patch and does not apply anything', async () => {
+    tarWriteBehavior = writePatchArtifact(CLEAN_PATCH);
+    gitBehavior.status = () => ({ status: 0, stdout: ' M src/checkout.ts\n', stderr: '' });
+
+    const { pullCommand } = await import('../src/commands/pull.js');
+    await pullCommand(config, ['dep-diff-001', '--diff-only'], chalk);
+
+    expect(process.exitCode).toBeUndefined();
+    expect(process.stdout.write).toHaveBeenCalledWith(CLEAN_PATCH);
+    const logged = console.log.mock.calls.map(c => c.join(' ')).join('\n');
+    expect(logged).not.toContain('Applied cloud changes');
+  });
+
+  it('surfaces a clear error when the patch does not apply cleanly', async () => {
+    tarWriteBehavior = writePatchArtifact(CLEAN_PATCH);
+    gitBehavior.status = () => ({ status: 0, stdout: '', stderr: '' });
+    gitBehavior.applyCheck = () => ({ status: 1, stdout: '', stderr: 'patch does not apply' });
+
+    const { pullCommand } = await import('../src/commands/pull.js');
+    await pullCommand(config, ['dep-bad-patch'], chalk);
+
+    expect(process.exitCode).toBe(1);
+    const logged = console.error.mock.calls.map(c => c.join(' ')).join('\n');
+    expect(logged).toContain('patch does not apply');
+  });
+
+  it('accepts --yes alongside --branch without changing the outcome', async () => {
+    tarWriteBehavior = writePatchArtifact(CLEAN_PATCH);
+    gitBehavior.status = () => ({ status: 0, stdout: ' M src/checkout.ts\n', stderr: '' });
+
+    const { pullCommand } = await import('../src/commands/pull.js');
+    await pullCommand(config, ['dep-conflict-003', '--branch', '--yes'], chalk);
+
+    expect(process.exitCode).toBeUndefined();
+    const logged = console.log.mock.calls.map(c => c.join(' ')).join('\n');
+    expect(logged).toContain('Applied cloud changes from dep-conflict-003');
+  });
+});