superacli 1.1.5 → 1.1.6

package/temp_resend_cli/repo/tests/lib/update-check.test.ts

@@ -0,0 +1,179 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  type MockInstance,
+  test,
+  vi,
+} from 'vitest';
+import { checkForUpdates } from '../../src/lib/update-check';
+import { VERSION } from '../../src/lib/version';
+import { captureTestEnv } from '../helpers';
+
+// Use a version guaranteed to be "newer" than whatever VERSION is
+const NEWER_VERSION = '99.0.0';
+
+const testConfigDir = join(tmpdir(), `resend-update-check-test-${process.pid}`);
+const testResendDir = join(testConfigDir, 'resend');
+const statePath = join(testResendDir, 'update-state.json');
+
+describe('checkForUpdates', () => {
+  const restoreEnv = captureTestEnv();
+  let stderrOutput: string;
+  let stderrSpy: MockInstance;
+  let fetchSpy: MockInstance;
+
+  beforeEach(() => {
+    mkdirSync(testResendDir, { recursive: true });
+    stderrOutput = '';
+    stderrSpy = vi
+      .spyOn(process.stderr, 'write')
+      .mockImplementation((chunk) => {
+        stderrOutput += String(chunk);
+        return true;
+      });
+
+    // Point getConfigDir() at our temp dir via XDG_CONFIG_HOME
+    process.env.XDG_CONFIG_HOME = testConfigDir;
+
+    // Ensure TTY and no CI
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: true,
+      writable: true,
+    });
+    delete process.env.CI;
+    delete process.env.GITHUB_ACTIONS;
+    delete process.env.RESEND_NO_UPDATE_NOTIFIER;
+  });
+
+  afterEach(() => {
+    stderrSpy.mockRestore();
+    if (fetchSpy) {
+      fetchSpy.mockRestore();
+    }
+    restoreEnv();
+    if (existsSync(testConfigDir)) {
+      rmSync(testConfigDir, { recursive: true, force: true });
+    }
+  });
+
+  function mockFetch(tagName: string, extra: Record<string, unknown> = {}) {
+    fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValue({
+      ok: true,
+      json: async () => ({ tag_name: tagName, ...extra }),
+    } as Response);
+  }
+
+  function mockFetchFailure() {
+    fetchSpy = vi
+      .spyOn(globalThis, 'fetch')
+      .mockRejectedValue(new Error('network error'));
+  }
+
+  test('skips check when RESEND_NO_UPDATE_NOTIFIER=1', async () => {
+    process.env.RESEND_NO_UPDATE_NOTIFIER = '1';
+    await checkForUpdates();
+    expect(stderrOutput).toBe('');
+  });
+
+  test('skips check when CI=true', async () => {
+    process.env.CI = 'true';
+    await checkForUpdates();
+    expect(stderrOutput).toBe('');
+  });
+
+  test('skips check when not a TTY', async () => {
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: undefined,
+      writable: true,
+    });
+    await checkForUpdates();
+    expect(stderrOutput).toBe('');
+  });
+
+  test('prints notice when newer version available from fresh fetch', async () => {
+    mockFetch(`v${NEWER_VERSION}`);
+    await checkForUpdates();
+
+    expect(stderrOutput).toContain('Update available');
+    expect(stderrOutput).toContain(`v${VERSION}`);
+    expect(stderrOutput).toContain(`v${NEWER_VERSION}`);
+  });
+
+  test('prints nothing when already on latest', async () => {
+    mockFetch(`v${VERSION}`);
+    await checkForUpdates();
+    expect(stderrOutput).toBe('');
+  });
+
+  test('uses cached state when fresh (no fetch)', async () => {
+    writeFileSync(
+      statePath,
+      JSON.stringify({ lastChecked: Date.now(), latestVersion: NEWER_VERSION }),
+    );
+
+    mockFetch(`v${NEWER_VERSION}`);
+    await checkForUpdates();
+
+    expect(fetchSpy).not.toHaveBeenCalled();
+    expect(stderrOutput).toContain(`v${NEWER_VERSION}`);
+  });
+
+  test('refetches when cache is stale', async () => {
+    const staleTime = Date.now() - 25 * 60 * 60 * 1000; // 25 hours ago
+    writeFileSync(
+      statePath,
+      JSON.stringify({ lastChecked: staleTime, latestVersion: VERSION }),
+    );
+
+    mockFetch(`v${NEWER_VERSION}`);
+    await checkForUpdates();
+
+    expect(fetchSpy).toHaveBeenCalled();
+    expect(stderrOutput).toContain(`v${NEWER_VERSION}`);
+    // Verify cache was updated
+    const state = JSON.parse(readFileSync(statePath, 'utf-8'));
+    expect(state.latestVersion).toBe(NEWER_VERSION);
+  });
+
+  test('handles fetch failure gracefully', async () => {
+    mockFetchFailure();
+    await checkForUpdates();
+    expect(stderrOutput).toBe('');
+  });
+
+  test('writes state file after successful fetch', async () => {
+    mockFetch(`v${VERSION}`);
+    await checkForUpdates();
+
+    expect(existsSync(statePath)).toBe(true);
+    const state = JSON.parse(readFileSync(statePath, 'utf-8'));
+    expect(state.latestVersion).toBe(VERSION);
+  });
+
+  test('ignores prerelease versions', async () => {
+    fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValue({
+      ok: true,
+      json: async () => ({ tag_name: 'v99.0.0', prerelease: true }),
+    } as Response);
+
+    await checkForUpdates();
+    expect(stderrOutput).toBe('');
+  });
+
+  test('ignores non-semver tag names', async () => {
+    mockFetch('canary-20260311');
+    await checkForUpdates();
+    expect(stderrOutput).toBe('');
+  });
+});

package/temp_resend_cli/repo/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"]
+}

package/temp_resend_cli/repo/vitest.config.e2e.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    include: ['tests/e2e/**/*.test.ts'],
+    testTimeout: 60_000,
+  },
+});

package/temp_resend_cli/repo/vitest.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    include: ['tests/**/*.test.ts'],
+    exclude: ['tests/e2e/**'],
+    clearMocks: true,
+    restoreMocks: true,
+  },
+});

package/tests/test-resend-smoke.sh

@@ -10,19 +10,23 @@ echo "Running resend smoke test..."
 export SUPERCLI_HOME=$(mktemp -d)
 trap "rm -rf $SUPERCLI_HOME" EXIT
 
+# Find node
+NODE_DIR=$(dirname $(which node))
+
 # 1. Install plugin
 node cli/supercli.js plugins install ./plugins/resend --on-conflict replace --json
 
-# 2. Check doctor
+# 2. Check doctor (node/npm checks should pass)
 node cli/supercli.js plugins doctor resend --json | grep -q '"ok":true'
 
 # 3. Check skills
 node cli/supercli.js skills list --catalog --provider resend --json | grep -q "resend:root.readme"
 
-# 4. Check doctor (expect dependency error but valid JSON)
+# 4. Check doctor (expect dependency error when resend is hidden)
 # We expect exit 1 because dep is missing
 set +e
-OUT=$(node cli/supercli.js resend cli doctor --json 2>&1)
+# Use a restricted PATH that includes node but NOT the global resend
+OUT=$(PATH="$NODE_DIR" node cli/supercli.js resend cli doctor --json 2>&1)
 EXIT_CODE=$?
 set -e