superacli 1.1.5 → 1.1.6

package/temp_resend_cli/repo/tests/lib/output.test.ts

@@ -0,0 +1,136 @@
+import {
+  afterEach,
+  describe,
+  expect,
+  type MockInstance,
+  test,
+  vi,
+} from 'vitest';
+import { outputError, outputResult } from '../../src/lib/output';
+
+describe('outputResult', () => {
+  let logSpy: MockInstance;
+  const originalIsTTY = process.stdout.isTTY;
+
+  afterEach(() => {
+    logSpy?.mockRestore();
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: originalIsTTY,
+      writable: true,
+    });
+  });
+
+  test('outputs JSON when json option is true', () => {
+    logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    outputResult({ id: '123' }, { json: true });
+    expect(logSpy).toHaveBeenCalledWith(JSON.stringify({ id: '123' }, null, 2));
+  });
+
+  test('outputs JSON when stdout is not TTY', () => {
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: undefined,
+      writable: true,
+    });
+    logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    outputResult({ id: '123' });
+    expect(logSpy).toHaveBeenCalledWith(JSON.stringify({ id: '123' }, null, 2));
+  });
+
+  test('outputs string directly for human-readable mode', () => {
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: true,
+      writable: true,
+    });
+    logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    outputResult('Email sent successfully');
+    expect(logSpy).toHaveBeenCalledWith('Email sent successfully');
+  });
+
+  test('outputs JSON for objects in human mode (fallback)', () => {
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: true,
+      writable: true,
+    });
+    logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    outputResult({ id: '123' });
+    expect(logSpy).toHaveBeenCalledWith(JSON.stringify({ id: '123' }, null, 2));
+  });
+});
+
+describe('outputError', () => {
+  let errorSpy: MockInstance;
+  let exitSpy: MockInstance;
+  const originalIsTTY = process.stdout.isTTY;
+
+  afterEach(() => {
+    errorSpy?.mockRestore();
+    exitSpy?.mockRestore();
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: originalIsTTY,
+      writable: true,
+    });
+  });
+
+  test('outputs JSON error when json is true', () => {
+    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = vi
+      .spyOn(process, 'exit')
+      .mockImplementation(() => undefined as never);
+
+    outputError({ message: 'not found', code: 'not_found' }, { json: true });
+
+    const expected = JSON.stringify(
+      { error: { message: 'not found', code: 'not_found' } },
+      null,
+      2,
+    );
+    expect(errorSpy).toHaveBeenCalledWith(expected);
+    expect(exitSpy).toHaveBeenCalledWith(1);
+  });
+
+  test('outputs text error when TTY and no json flag', () => {
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: true,
+      writable: true,
+    });
+    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = vi
+      .spyOn(process, 'exit')
+      .mockImplementation(() => undefined as never);
+
+    outputError({ message: 'something broke' });
+
+    expect(errorSpy).toHaveBeenCalledWith(
+      expect.stringContaining('something broke'),
+    );
+    expect(exitSpy).toHaveBeenCalledWith(1);
+  });
+
+  test('uses custom exit code', () => {
+    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = vi
+      .spyOn(process, 'exit')
+      .mockImplementation(() => undefined as never);
+
+    outputError({ message: 'error' }, { exitCode: 2, json: true });
+
+    expect(exitSpy).toHaveBeenCalledWith(2);
+  });
+
+  test('defaults error code to "unknown" when not provided', () => {
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: undefined,
+      writable: true,
+    });
+    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = vi
+      .spyOn(process, 'exit')
+      .mockImplementation(() => undefined as never);
+
+    outputError({ message: 'oops' });
+
+    const output = errorSpy.mock.calls[0][0] as string;
+    const parsed = JSON.parse(output);
+    expect(parsed.error.code).toBe('unknown');
+  });
+});

package/temp_resend_cli/repo/tests/lib/prompts.test.ts

@@ -0,0 +1,185 @@
+import {
+  afterEach,
+  describe,
+  expect,
+  type MockInstance,
+  test,
+  vi,
+} from 'vitest';
+import { expectExit1, mockExitThrow } from '../helpers';
+
+describe('promptForMissing', () => {
+  const originalStdinIsTTY = process.stdin.isTTY;
+  const originalStdoutIsTTY = process.stdout.isTTY;
+  let errorSpy: MockInstance | undefined;
+  let exitSpy: MockInstance | undefined;
+
+  afterEach(() => {
+    errorSpy?.mockRestore();
+    exitSpy?.mockRestore();
+    errorSpy = undefined;
+    exitSpy = undefined;
+    Object.defineProperty(process.stdin, 'isTTY', {
+      value: originalStdinIsTTY,
+      writable: true,
+    });
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: originalStdoutIsTTY,
+      writable: true,
+    });
+  });
+
+  test('returns options unchanged when nothing is missing', async () => {
+    const { promptForMissing } = await import('../../src/lib/prompts');
+    const opts = { from: 'a@b.com', to: 'c@d.com', subject: 'Hi' };
+    const result = await promptForMissing(
+      opts,
+      [
+        { flag: 'from', message: 'From' },
+        { flag: 'to', message: 'To' },
+        { flag: 'subject', message: 'Subject' },
+      ],
+      {},
+    );
+    expect(result).toEqual(opts);
+  });
+
+  test('exits with missing_flags error in non-interactive mode', async () => {
+    Object.defineProperty(process.stdin, 'isTTY', {
+      value: undefined,
+      writable: true,
+    });
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: undefined,
+      writable: true,
+    });
+    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { promptForMissing } = await import('../../src/lib/prompts');
+
+    await expectExit1(() =>
+      promptForMissing(
+        { from: undefined, to: 'c@d.com', subject: undefined },
+        [
+          { flag: 'from', message: 'From' },
+          { flag: 'to', message: 'To' },
+          { flag: 'subject', message: 'Subject' },
+        ],
+        {},
+      ),
+    );
+
+    const allErrors = errorSpy?.mock.calls.map((c) => c[0]).join(' ');
+    expect(allErrors).toContain('--from');
+    expect(allErrors).toContain('--subject');
+    // --to should NOT be listed since it has a value
+    expect(allErrors).not.toContain('--to,');
+  });
+
+  test('errors output includes missing_flags code', async () => {
+    Object.defineProperty(process.stdin, 'isTTY', {
+      value: undefined,
+      writable: true,
+    });
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: undefined,
+      writable: true,
+    });
+    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { promptForMissing } = await import('../../src/lib/prompts');
+
+    await expectExit1(() =>
+      promptForMissing(
+        { from: undefined },
+        [{ flag: 'from', message: 'From' }],
+        {},
+      ),
+    );
+
+    const allErrors = errorSpy?.mock.calls.map((c) => c[0]).join(' ');
+    expect(allErrors).toContain('missing_flags');
+  });
+
+  test('skips fields marked as required=false', async () => {
+    const { promptForMissing } = await import('../../src/lib/prompts');
+    const opts = { from: 'a@b.com', to: undefined };
+    const result = await promptForMissing(
+      opts,
+      [
+        { flag: 'from', message: 'From' },
+        { flag: 'to', message: 'To', required: false },
+      ],
+      {},
+    );
+    expect(result).toEqual(opts);
+  });
+});
+
+describe('confirmDelete', () => {
+  const originalStdinIsTTY = process.stdin.isTTY;
+  const originalStdoutIsTTY = process.stdout.isTTY;
+  let errorSpy: MockInstance | undefined;
+  let exitSpy: MockInstance | undefined;
+
+  afterEach(() => {
+    errorSpy?.mockRestore();
+    exitSpy?.mockRestore();
+    errorSpy = undefined;
+    exitSpy = undefined;
+    Object.defineProperty(process.stdin, 'isTTY', {
+      value: originalStdinIsTTY,
+      writable: true,
+    });
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: originalStdoutIsTTY,
+      writable: true,
+    });
+  });
+
+  test('exits with confirmation_required when non-interactive', async () => {
+    Object.defineProperty(process.stdin, 'isTTY', {
+      value: undefined,
+      writable: true,
+    });
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: undefined,
+      writable: true,
+    });
+    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { confirmDelete } = await import('../../src/lib/prompts');
+
+    await expectExit1(() =>
+      confirmDelete('res_123', 'Delete resource res_123?', { json: false }),
+    );
+
+    const output = errorSpy?.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('confirmation_required');
+  });
+
+  test('outputs JSON confirmation_required error when json option is true', async () => {
+    Object.defineProperty(process.stdin, 'isTTY', {
+      value: undefined,
+      writable: true,
+    });
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: undefined,
+      writable: true,
+    });
+    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { confirmDelete } = await import('../../src/lib/prompts');
+    await expectExit1(() =>
+      confirmDelete('res_123', 'Delete?', { json: true }),
+    );
+
+    const raw = errorSpy?.mock.calls.map((c) => c[0]).join(' ');
+    const parsed = JSON.parse(raw);
+    expect(parsed.error.code).toBe('confirmation_required');
+  });
+});

package/temp_resend_cli/repo/tests/lib/spinner.test.ts

@@ -0,0 +1,166 @@
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  type MockInstance,
+  test,
+  vi,
+} from 'vitest';
+
+describe('createSpinner', () => {
+  const originalStdinIsTTY = process.stdin.isTTY;
+  const originalStdoutIsTTY = process.stdout.isTTY;
+  let stderrSpy: MockInstance;
+
+  beforeEach(() => {
+    vi.resetModules();
+  });
+
+  afterEach(() => {
+    stderrSpy?.mockRestore();
+    Object.defineProperty(process.stdin, 'isTTY', {
+      value: originalStdinIsTTY,
+      writable: true,
+    });
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: originalStdoutIsTTY,
+      writable: true,
+    });
+    delete process.env.CI;
+  });
+
+  test('returns no-op spinner in non-interactive mode', async () => {
+    Object.defineProperty(process.stdin, 'isTTY', {
+      value: undefined,
+      writable: true,
+    });
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: undefined,
+      writable: true,
+    });
+
+    const { createSpinner } = await import('../../src/lib/spinner');
+    const spinner = createSpinner('test message');
+
+    // Should not throw when calling any method
+    expect(() => spinner.stop('done')).not.toThrow();
+    expect(() => spinner.fail('error')).not.toThrow();
+    expect(() => spinner.warn('warning')).not.toThrow();
+    expect(() => spinner.update('updating')).not.toThrow();
+  });
+
+  test('returns functional spinner in interactive mode', async () => {
+    Object.defineProperty(process.stdin, 'isTTY', {
+      value: true,
+      writable: true,
+    });
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: true,
+      writable: true,
+    });
+    delete process.env.CI;
+    delete process.env.GITHUB_ACTIONS;
+    delete process.env.TERM;
+
+    stderrSpy = vi
+      .spyOn(process.stderr, 'write')
+      .mockImplementation(() => true);
+
+    const { createSpinner } = await import('../../src/lib/spinner');
+    const spinner = createSpinner('loading...');
+
+    expect(spinner).toHaveProperty('stop');
+    expect(spinner).toHaveProperty('fail');
+    expect(spinner).toHaveProperty('warn');
+    expect(spinner).toHaveProperty('update');
+
+    // Stop to clean up the interval
+    spinner.stop('done');
+    expect(stderrSpy).toHaveBeenCalled();
+  });
+
+  test('stop writes checkmark to stderr', async () => {
+    Object.defineProperty(process.stdin, 'isTTY', {
+      value: true,
+      writable: true,
+    });
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: true,
+      writable: true,
+    });
+    delete process.env.CI;
+    delete process.env.GITHUB_ACTIONS;
+    delete process.env.TERM;
+
+    stderrSpy = vi
+      .spyOn(process.stderr, 'write')
+      .mockImplementation(() => true);
+
+    const { createSpinner } = await import('../../src/lib/spinner');
+    const spinner = createSpinner('loading...');
+    spinner.stop('completed');
+
+    const lastCall = stderrSpy.mock.calls[
+      stderrSpy.mock.calls.length - 1
+    ][0] as string;
+    expect(lastCall).toContain('✔');
+    expect(lastCall).toContain('completed');
+  });
+
+  test('fail writes cross mark to stderr', async () => {
+    Object.defineProperty(process.stdin, 'isTTY', {
+      value: true,
+      writable: true,
+    });
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: true,
+      writable: true,
+    });
+    delete process.env.CI;
+    delete process.env.GITHUB_ACTIONS;
+    delete process.env.TERM;
+
+    stderrSpy = vi
+      .spyOn(process.stderr, 'write')
+      .mockImplementation(() => true);
+
+    const { createSpinner } = await import('../../src/lib/spinner');
+    const spinner = createSpinner('loading...');
+    spinner.fail('error occurred');
+
+    const lastCall = stderrSpy.mock.calls[
+      stderrSpy.mock.calls.length - 1
+    ][0] as string;
+    expect(lastCall).toContain('✗');
+    expect(lastCall).toContain('error occurred');
+  });
+
+  test('warn writes warning icon to stderr', async () => {
+    Object.defineProperty(process.stdin, 'isTTY', {
+      value: true,
+      writable: true,
+    });
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: true,
+      writable: true,
+    });
+    delete process.env.CI;
+    delete process.env.GITHUB_ACTIONS;
+    delete process.env.TERM;
+
+    stderrSpy = vi
+      .spyOn(process.stderr, 'write')
+      .mockImplementation(() => true);
+
+    const { createSpinner } = await import('../../src/lib/spinner');
+    const spinner = createSpinner('loading...');
+    spinner.warn('watch out');
+
+    const lastCall = stderrSpy.mock.calls[
+      stderrSpy.mock.calls.length - 1
+    ][0] as string;
+    expect(lastCall).toContain('⚠');
+    expect(lastCall).toContain('watch out');
+  });
+});

package/temp_resend_cli/repo/tests/lib/table.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, test } from 'vitest';
+import { renderTable } from '../../src/lib/table';
+
+describe('renderTable', () => {
+  test('renders a table with correct border characters', () => {
+    const output = renderTable(['Name', 'ID'], [['Alice', 'abc-123']]);
+    expect(output).toContain('┌');
+    expect(output).toContain('┐');
+    expect(output).toContain('└');
+    expect(output).toContain('┘');
+    expect(output).toContain('│');
+  });
+
+  test('includes headers in output', () => {
+    const output = renderTable(
+      ['Name', 'Status'],
+      [['my-domain.com', 'verified']],
+    );
+    expect(output).toContain('Name');
+    expect(output).toContain('Status');
+  });
+
+  test('includes row data in output', () => {
+    const output = renderTable(
+      ['Name', 'Status'],
+      [['my-domain.com', 'verified']],
+    );
+    expect(output).toContain('my-domain.com');
+    expect(output).toContain('verified');
+  });
+
+  test('pads columns to the widest cell in each column', () => {
+    const output = renderTable(
+      ['Key', 'Value'],
+      [
+        ['short', 'a very long value here'],
+        ['much longer key', 'v'],
+      ],
+    );
+    // All rows should have the same line length
+    const lines = output.split('\n');
+    const lengths = lines.map((l) => l.length);
+    expect(new Set(lengths).size).toBe(1);
+  });
+
+  test('renders multiple rows', () => {
+    const output = renderTable(
+      ['A', 'B'],
+      [
+        ['row1a', 'row1b'],
+        ['row2a', 'row2b'],
+      ],
+    );
+    expect(output).toContain('row1a');
+    expect(output).toContain('row2a');
+  });
+
+  test('contains a separator row between header and data', () => {
+    const output = renderTable(['Col'], [['val']]);
+    expect(output).toContain('├');
+    expect(output).toContain('┤');
+  });
+});

package/temp_resend_cli/repo/tests/lib/tty.test.ts

@@ -0,0 +1,89 @@
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
+import { captureTestEnv } from '../helpers';
+
+// We need to import the module fresh per test to pick up env changes,
+// so we use dynamic imports.
+
+describe('isInteractive', () => {
+  const restoreEnv = captureTestEnv();
+
+  beforeEach(() => {
+    vi.resetModules();
+  });
+
+  afterEach(() => {
+    restoreEnv();
+  });
+
+  function setTTY(stdin: boolean, stdout: boolean) {
+    Object.defineProperty(process.stdin, 'isTTY', {
+      value: stdin ? true : undefined,
+      writable: true,
+    });
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: stdout ? true : undefined,
+      writable: true,
+    });
+  }
+
+  test('returns true when stdin and stdout are TTY and no CI env', async () => {
+    setTTY(true, true);
+    delete process.env.CI;
+    delete process.env.GITHUB_ACTIONS;
+    delete process.env.TERM;
+
+    const { isInteractive } = await import('../../src/lib/tty');
+    expect(isInteractive()).toBe(true);
+  });
+
+  test('returns false when stdin is not TTY', async () => {
+    setTTY(false, true);
+    delete process.env.CI;
+
+    const { isInteractive } = await import('../../src/lib/tty');
+    expect(isInteractive()).toBe(false);
+  });
+
+  test('returns false when stdout is not TTY', async () => {
+    setTTY(true, false);
+    delete process.env.CI;
+
+    const { isInteractive } = await import('../../src/lib/tty');
+    expect(isInteractive()).toBe(false);
+  });
+
+  test('returns false when CI=true', async () => {
+    setTTY(true, true);
+    process.env.CI = 'true';
+
+    const { isInteractive } = await import('../../src/lib/tty');
+    expect(isInteractive()).toBe(false);
+  });
+
+  test('returns false when CI=1', async () => {
+    setTTY(true, true);
+    process.env.CI = '1';
+
+    const { isInteractive } = await import('../../src/lib/tty');
+    expect(isInteractive()).toBe(false);
+  });
+
+  test('returns false when GITHUB_ACTIONS is set', async () => {
+    setTTY(true, true);
+    delete process.env.CI;
+    process.env.GITHUB_ACTIONS = 'true';
+
+    const { isInteractive } = await import('../../src/lib/tty');
+    expect(isInteractive()).toBe(false);
+  });
+
+  test('returns false when TERM=dumb', async () => {
+    setTTY(true, true);
+    delete process.env.CI;
+    delete process.env.GITHUB_ACTIONS;
+    process.env.TERM = 'dumb';
+
+    const { isInteractive } = await import('../../src/lib/tty');
+    expect(isInteractive()).toBe(false);
+  });
+});