@mondaydotcomorg/z2h-cli 0.13.1 → 0.14.0

package/src/commands/__tests__/doctor.test.ts

@@ -0,0 +1,411 @@
+import { readFile } from 'node:fs/promises';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { execa } from 'execa';
+import { pathExists, readJson } from 'fs-extra';
+import { tryReadAuthTokenSync } from '../../util/auth/auth-store';
+import { doctorCommand } from '../doctor';
+
+vi.mock('execa', () => ({ execa: vi.fn() }));
+
+vi.mock('fs-extra', async importOriginal => {
+  const actual = await importOriginal<typeof import('fs-extra')>();
+  return { ...actual, pathExists: vi.fn(), readJson: vi.fn() };
+});
+
+vi.mock('node:fs/promises', async importOriginal => {
+  const actual = await importOriginal<typeof import('node:fs/promises')>();
+  return { ...actual, readFile: vi.fn() };
+});
+
+// Return null so checkZ2hCli skips the broker fetch entirely
+vi.mock('../../util/auth/auth-store', async importOriginal => {
+  const actual = await importOriginal<typeof import('../../util/auth/auth-store')>();
+  return { ...actual, tryReadAuthTokenSync: vi.fn().mockReturnValue(null) };
+});
+
+const mockExeca = vi.mocked(execa);
+const mockPathExists = vi.mocked(pathExists);
+const mockReadJson = vi.mocked(readJson);
+const mockReadFile = vi.mocked(readFile);
+const mockTryReadAuthTokenSync = vi.mocked(tryReadAuthTokenSync);
+
+// Capture stdout written during doctorCommand
+async function captureStdout(fn: () => Promise<void>): Promise<string> {
+  let out = '';
+  const spy = vi.spyOn(process.stdout, 'write').mockImplementation((chunk: unknown) => {
+    out += String(chunk);
+    return true;
+  });
+  try {
+    await fn();
+  } finally {
+    spy.mockRestore();
+  }
+  return out;
+}
+
+describe('doctorCommand', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    mockPathExists.mockResolvedValue(true as never);
+
+    mockReadJson.mockImplementation(async (p: unknown) => {
+      const filePath = String(p);
+      if (filePath.endsWith('auth.json')) {
+        return { token: 'fake.jwt.token' };
+      }
+      if (filePath.endsWith('installed_plugins.json')) {
+        return {
+          plugins: {
+            'z2h@bigbrain-z2h': [{ installPath: '/dev/z2h' }],
+            'cf-external-claude-plugin@client-foundations-ai-tools': [{ installPath: '/dev/cf' }],
+            'pr-guardrails@agentic-builders-hub': [{ installPath: '/dev/pr' }],
+          },
+        };
+      }
+      if (filePath.endsWith('package.json')) {
+        return { z2hWorkspace: true, dependencies: { react: '^18.3.1' } };
+      }
+      return {};
+    });
+
+    // readFile: return profile content with token for shell profiles, throw for everything else
+    mockReadFile.mockImplementation(((p: unknown) => {
+      const filePath = String(p);
+      if (filePath.endsWith('.zshrc') || filePath.endsWith('.bash_profile')) {
+        return Promise.resolve('export Z2H_NPM_TOKEN="fake-token"\n');
+      }
+      return Promise.reject(Object.assign(new Error('ENOENT'), { code: 'ENOENT' }));
+    }) as never);
+
+    mockExeca.mockImplementation(((cmd: unknown, args?: unknown) => {
+      const command = String(cmd);
+      const argv = (args as string[]) ?? [];
+      if (command === 'node' && argv[0] === '--version') {
+        return Promise.resolve({ stdout: 'v24.13.1' });
+      }
+      if (command === 'yarn' && argv[0] === '--version') {
+        return Promise.resolve({ stdout: '4.5.1' });
+      }
+      if (command === 'aws' && argv[0] === '--version') {
+        return Promise.resolve({ stdout: 'aws-cli/2.22.0 Python/3.13' });
+      }
+      if (command === 'bash') {
+        return Promise.resolve({ stdout: '0.39.7' });
+      } // nvm --version
+      if (command === 'pipx') {
+        return Promise.resolve({ stdout: 'Name: git-remote-s3\nVersion: 0.2.3\n' });
+      }
+      if (command === 'which') {
+        return Promise.resolve({ stdout: '/usr/local/bin/' + String(argv[0]) });
+      }
+      return Promise.reject(new Error(`unexpected: ${command}`));
+    }) as never);
+
+    vi.stubEnv('Z2H_WORKSPACE_HOME', '/fake/zth-projects');
+  });
+
+  afterEach(() => {
+    vi.unstubAllEnvs();
+    vi.unstubAllGlobals();
+  });
+
+  // ── happy path ────────────────────────────────────────────────────────────
+
+  it('prints no-issues when everything is healthy', async () => {
+    const out = await captureStdout(() => doctorCommand());
+    expect(out).toContain('No issues detected');
+    expect(out).not.toContain('❌');
+    expect(out).not.toContain('⚠️');
+  });
+
+  // ── System tools ──────────────────────────────────────────────────────────
+
+  it('shows warn for nvm when nvm is not available', async () => {
+    mockExeca.mockImplementation(((cmd: unknown) => {
+      if (String(cmd) === 'bash') {
+        return Promise.reject(new Error('not found'));
+      }
+      return Promise.resolve({ stdout: '' });
+    }) as never);
+    const out = await captureStdout(() => doctorCommand());
+    expect(out).toContain('nvm');
+    expect(out).toContain('⚠️');
+  });
+
+  it('shows fail for node when command not found', async () => {
+    mockExeca.mockImplementation(((cmd: unknown) => {
+      if (String(cmd) === 'node') {
+        return Promise.reject(new Error('not found'));
+      }
+      return Promise.resolve({ stdout: '' });
+    }) as never);
+    const out = await captureStdout(() => doctorCommand());
+    expect(out).toContain('node');
+    expect(out).toContain('❌');
+  });
+
+  it('shows fail for node when version mismatches .nvmrc', async () => {
+    mockExeca.mockImplementation(((cmd: unknown, args?: unknown) => {
+      const argv = (args as string[]) ?? [];
+      if (String(cmd) === 'node' && argv[0] === '--version') {
+        return Promise.resolve({ stdout: 'v22.0.0' });
+      }
+      return Promise.resolve({ stdout: '' });
+    }) as never);
+    // make readFile return a valid .nvmrc so version comparison runs
+    mockReadFile.mockImplementation(((p: unknown) => {
+      if (String(p).includes('.nvmrc')) {
+        return Promise.resolve('v24.13');
+      }
+      return Promise.resolve('export Z2H_NPM_TOKEN="x"\n');
+    }) as never);
+    const out = await captureStdout(() => doctorCommand());
+    expect(out).toContain('expected');
+  });
+
+  it('shows fail for yarn when command not found', async () => {
+    mockExeca.mockImplementation(((cmd: unknown) => {
+      if (String(cmd) === 'yarn') {
+        return Promise.reject(new Error('not found'));
+      }
+      return Promise.resolve({ stdout: '' });
+    }) as never);
+    const out = await captureStdout(() => doctorCommand());
+    expect(out).toContain('yarn');
+    expect(out).toContain('❌');
+  });
+
+  it('shows fail for aws when command not found', async () => {
+    mockExeca.mockImplementation(((cmd: unknown) => {
+      if (String(cmd) === 'aws') {
+        return Promise.reject(new Error('not found'));
+      }
+      return Promise.resolve({ stdout: '' });
+    }) as never);
+    const out = await captureStdout(() => doctorCommand());
+    expect(out).toContain('aws');
+    expect(out).toContain('❌');
+  });
+
+  it('shows fail for git-remote-s3 when not on PATH', async () => {
+    mockExeca.mockImplementation(((cmd: unknown, args?: unknown) => {
+      const argv = (args as string[]) ?? [];
+      if (String(cmd) === 'which' && argv[0] === 'git-remote-s3') {
+        return Promise.reject(new Error('not found'));
+      }
+      return Promise.resolve({ stdout: '' });
+    }) as never);
+    const out = await captureStdout(() => doctorCommand());
+    expect(out).toContain('git-remote-s3');
+    expect(out).toContain('❌');
+  });
+
+  // ── CLI & auth ────────────────────────────────────────────────────────────
+
+  it('shows warn for z2h-cli when a newer version is available', async () => {
+    mockTryReadAuthTokenSync.mockReturnValueOnce('fake.jwt.token');
+    vi.stubGlobal(
+      'fetch',
+      vi.fn().mockResolvedValue({
+        ok: true,
+        json: async () => ({ 'dist-tags': { latest: '999.0.0' } }),
+      })
+    );
+    const out = await captureStdout(() => doctorCommand());
+    expect(out).toContain('z2h-cli');
+    expect(out).toContain('⚠️');
+    expect(out).toContain('latest: 999.0.0');
+  });
+
+  it('shows fail for auth token when auth.json is missing', async () => {
+    mockReadJson.mockImplementation(async (p: unknown) => {
+      if (String(p).endsWith('auth.json')) {
+        const err = new Error('ENOENT: no such file or directory') as NodeJS.ErrnoException;
+        err.code = 'ENOENT';
+        throw err;
+      }
+      return {};
+    });
+    const out = await captureStdout(() => doctorCommand());
+    expect(out).toContain('auth token');
+    expect(out).toContain('❌');
+    expect(out).toContain('not found');
+    expect(out).toContain('generate-z2h-token');
+  });
+
+  it('shows fail for auth token when auth.json contains invalid JSON', async () => {
+    mockReadJson.mockImplementation(async (p: unknown) => {
+      if (String(p).endsWith('auth.json')) {
+        throw new SyntaxError('Unexpected token in JSON');
+      }
+      return {};
+    });
+    const out = await captureStdout(() => doctorCommand());
+    expect(out).toContain('auth token');
+    expect(out).toContain('❌');
+    expect(out).toContain('could not be parsed');
+    expect(out).toContain('generate-z2h-token');
+  });
+
+  it('shows fail for auth token when token field is missing', async () => {
+    mockReadJson.mockImplementation(async (p: unknown) => {
+      if (String(p).endsWith('auth.json')) {
+        return {};
+      }
+      return {};
+    });
+    const out = await captureStdout(() => doctorCommand());
+    expect(out).toContain('auth token');
+    expect(out).toContain('❌');
+    expect(out).toContain('missing token field');
+    expect(out).toContain('generate-z2h-token');
+  });
+
+  it('shows fail for npm token when not found in any profile', async () => {
+    mockReadFile.mockResolvedValue('# no z2h token here\n' as never);
+    const out = await captureStdout(() => doctorCommand());
+    expect(out).toContain('npm token in profile');
+    expect(out).toContain('❌');
+  });
+
+  // ── Workspace ─────────────────────────────────────────────────────────────
+
+  it('shows fail for workspace when not initialized', async () => {
+    mockReadJson.mockImplementation(async (p: unknown) => {
+      if (String(p).endsWith('package.json')) {
+        return {};
+      }
+      if (String(p).endsWith('auth.json')) {
+        return { token: 'fake.jwt.token' };
+      }
+      if (String(p).endsWith('installed_plugins.json')) {
+        return {
+          plugins: {
+            'z2h@bigbrain-z2h': [{ installPath: '/dev/z2h' }],
+            'cf-external-claude-plugin@client-foundations-ai-tools': [{ installPath: '/dev/cf' }],
+            'pr-guardrails@agentic-builders-hub': [{ installPath: '/dev/pr' }],
+          },
+        };
+      }
+      return {};
+    });
+    const out = await captureStdout(() => doctorCommand());
+    expect(out).toContain('workspace');
+    expect(out).toContain('❌');
+    expect(out).toContain('create-workspace');
+  });
+
+  it('shows fail for react version when workspace has react 19', async () => {
+    mockReadJson.mockImplementation(async (p: unknown) => {
+      if (String(p).endsWith('package.json')) {
+        return { z2hWorkspace: true, dependencies: { react: '^19.0.0' } };
+      }
+      if (String(p).endsWith('auth.json')) {
+        return { token: 'fake.jwt.token' };
+      }
+      if (String(p).endsWith('installed_plugins.json')) {
+        return {
+          plugins: {
+            'z2h@bigbrain-z2h': [{ installPath: '/dev/z2h' }],
+            'cf-external-claude-plugin@client-foundations-ai-tools': [{ installPath: '/dev/cf' }],
+            'pr-guardrails@agentic-builders-hub': [{ installPath: '/dev/pr' }],
+          },
+        };
+      }
+      return {};
+    });
+    const out = await captureStdout(() => doctorCommand());
+    expect(out).toContain('react version');
+    expect(out).toContain('❌');
+    expect(out).toContain('expected 18.x');
+  });
+
+  it('shows warn for react version when react is not in dependencies', async () => {
+    mockReadJson.mockImplementation(async (p: unknown) => {
+      if (String(p).endsWith('package.json')) {
+        return { z2hWorkspace: true, dependencies: {} };
+      }
+      if (String(p).endsWith('auth.json')) {
+        return { token: 'fake.jwt.token' };
+      }
+      if (String(p).endsWith('installed_plugins.json')) {
+        return {
+          plugins: {
+            'z2h@bigbrain-z2h': [{ installPath: '/dev/z2h' }],
+            'cf-external-claude-plugin@client-foundations-ai-tools': [{ installPath: '/dev/cf' }],
+            'pr-guardrails@agentic-builders-hub': [{ installPath: '/dev/pr' }],
+          },
+        };
+      }
+      return {};
+    });
+    const out = await captureStdout(() => doctorCommand());
+    expect(out).toContain('react version');
+    expect(out).toContain('❌');
+  });
+
+  it('shows warn for SSL cert when not found', async () => {
+    mockPathExists.mockImplementation(async (p: unknown) => {
+      if (String(p).includes('devcert')) {
+        return false as never;
+      }
+      return true as never;
+    });
+    const out = await captureStdout(() => doctorCommand());
+    expect(out).toContain('SSL cert');
+    expect(out).toContain('⚠️');
+  });
+
+  // ── Plugins ───────────────────────────────────────────────────────────────
+
+  it('shows fail for z2h plugin (mandatory) when installPath dir is missing', async () => {
+    mockPathExists.mockImplementation(async (p: unknown) => {
+      if (String(p) === '/dev/z2h') {
+        return false as never;
+      }
+      return true as never;
+    });
+    const out = await captureStdout(() => doctorCommand());
+    expect(out).toContain('z2h plugin');
+    expect(out).toContain('❌');
+  });
+
+  it('shows warn for cf-external plugin (optional) when installPath dir is missing', async () => {
+    mockPathExists.mockImplementation(async (p: unknown) => {
+      if (String(p) === '/dev/cf') {
+        return false as never;
+      }
+      return true as never;
+    });
+    const out = await captureStdout(() => doctorCommand());
+    expect(out).toContain('cf-external plugin');
+    expect(out).toContain('⚠️');
+    expect(out).not.toContain('❌');
+  });
+
+  it('shows warn for pr-guardrails plugin (optional) when installPath dir is missing', async () => {
+    mockPathExists.mockImplementation(async (p: unknown) => {
+      if (String(p) === '/dev/pr') {
+        return false as never;
+      }
+      return true as never;
+    });
+    const out = await captureStdout(() => doctorCommand());
+    expect(out).toContain('pr-guardrails plugin');
+    expect(out).toContain('⚠️');
+    expect(out).not.toContain('❌');
+  });
+
+  // ── JSON output ───────────────────────────────────────────────────────────
+
+  it('emits structured JSON when --json flag is set', async () => {
+    const jsonLine = await captureStdout(() => doctorCommand({ json: true }));
+    const parsed = JSON.parse(jsonLine.trim()) as { ok: boolean; checks: unknown[] };
+    expect(parsed.ok).toBe(true);
+    expect(Array.isArray(parsed.checks)).toBe(true);
+    expect(parsed.checks.length).toBeGreaterThan(0);
+  });
+});

package/src/commands/delete.ts

@@ -0,0 +1,63 @@
+import { createInterface } from 'node:readline';
+import { output, info, setOutputMode } from '../util/logger';
+import { getCwdAppName, cleanAppName, mfAppName } from '../util/app-name';
+import { brokerBaseUrl, routingHeaders } from '../constants';
+import { readZthAuth } from '../util/auth/auth-store';
+
+export interface DeleteOptions {
+  yes?: boolean;
+  json?: boolean;
+}
+
+// Type-the-app-name confirmation. The caller must retype the de-scoped app
+// name (what they see in the URL) to guard against accidental deletes.
+async function confirmByName(appSlug: string): Promise<boolean> {
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  const answer = await new Promise<string>(resolve => {
+    rl.question(
+      `This permanently deletes "${appSlug}" and takes it offline. This cannot be undone.\n` +
+        `Type the app name to confirm: `,
+      resolve
+    );
+  });
+  rl.close();
+  return answer.trim() === appSlug;
+}
+
+// Should be run from the consumer app directory — uses process.cwd() to locate it.
+export async function deleteCommand(opts: DeleteOptions = {}): Promise<void> {
+  if (opts.json) {
+    setOutputMode('json');
+  }
+
+  const cwdName = getCwdAppName();
+  if (!cwdName) {
+    throw new Error('Run this from inside a consumer app directory (the one with your package.json).');
+  }
+  const appSlug = cleanAppName(cwdName); // user-facing name (matches the bigbrain.me URL)
+  const appName = mfAppName(cwdName); // canonical mf- bundle name the backend keys on
+
+  // Confirmation. --json is always non-interactive, so it requires --yes.
+  if (!opts.yes) {
+    if (opts.json || !process.stdin.isTTY) {
+      throw new Error('Refusing to delete without confirmation — pass --yes to delete non-interactively.');
+    }
+    if (!(await confirmByName(appSlug))) {
+      throw new Error(`Name did not match "${appSlug}" — aborted, nothing was deleted.`);
+    }
+  }
+
+  const { token } = await readZthAuth();
+
+  info(`deleting "${appName}"`);
+  const res = await fetch(`${brokerBaseUrl()}/z2h-apps/${encodeURIComponent(appName)}`, {
+    method: 'DELETE',
+    headers: { Authorization: `Bearer ${token}`, ...routingHeaders() },
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Delete failed (${res.status}): ${text.slice(0, 1024)}`);
+  }
+
+  output(`[z2h-cli] "${appName}" deleted ✅ — it is now offline.`, { ok: true, appName, deleted: true });
+}