@antasphere/chassis-cli 0.0.0-stage → 1.0.1

package/test/suite/cli.test.ts

@@ -0,0 +1,301 @@
+import { mkdtemp, readFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { describe, expect, it } from 'vitest';
+import type { CliIo } from '@antasphere/chassis-cli';
+import { cli, run } from '@chassis-cli-test/host';
+
+// The literals that spell the tool come from the host (its identity).
+const { bin, envPrefix: P } = cli.identity;
+
+/**
+ * Unit coverage: each command hits the right method + path (via a recording
+ * fake fetch), the no-API-key guard fires, and a 403 maps to a friendly line.
+ * The upload/download filesystem paths are exercised by the server-side
+ * integration test.
+ */
+
+interface Canned {
+  status?: number;
+  body?: unknown;
+}
+
+function harness(responses: Canned[] = [{ status: 200, body: {} }]) {
+  const calls: Array<{ method: string; path: string }> = [];
+  const out: string[] = [];
+  const err: string[] = [];
+  const queue = [...responses];
+  const fetch = (async (input: string | URL | Request, init?: RequestInit) => {
+    const url = new URL(input.toString());
+    // pathname + search so cursor/limit threading is assertable.
+    calls.push({ method: (init?.method ?? 'GET').toUpperCase(), path: url.pathname + url.search });
+    const r = queue.shift() ?? { status: 200, body: {} };
+    return new Response(JSON.stringify(r.body ?? {}), {
+      status: r.status ?? 200,
+      headers: { 'content-type': 'application/json' }
+    });
+  }) as typeof globalThis.fetch;
+  const io: CliIo = {
+    env: {},
+    out: { write: (s) => out.push(s) },
+    err: { write: (s) => err.push(s) },
+    fetch
+  };
+  return { io, calls, out: () => out.join(''), err: () => err.join('') };
+}
+
+const INSTANCE = {
+  name: 'Acme',
+  version: '1.0.0',
+  edition: 'oss',
+  setupRequired: false,
+  auth: { methods: ['password', 'api-key', 'oauth'], passwordReset: false }
+};
+const ME = {
+  user: { id: 'u1', name: 'Ada', email: 'ada@x.co' },
+  workspace: { id: 'w1', name: 'Acme' },
+  workspaces: [
+    {
+      id: 'w1',
+      name: 'Acme',
+      role: 'owner',
+      hubOrigin: false,
+      centralAccountId: null,
+      look: { theme: null, pattern: null, field: null, grain: null },
+      suspended: false,
+      default: true
+    }
+  ],
+  activeWorkspaceId: 'w1',
+  role: 'owner',
+  via: 'api_key',
+  scopes: ['items:read']
+};
+
+describe(`${bin} CLI`, () => {
+  it('instance → GET /api/v1/instance (no key needed)', async () => {
+    const h = harness([{ body: INSTANCE }]);
+    const code = await run(['instance', '--url', 'http://x'], h.io);
+    expect(code).toBe(0);
+    expect(h.calls).toEqual([{ method: 'GET', path: '/api/v1/instance' }]);
+    expect(h.out()).toContain('Acme');
+  });
+
+  it('whoami → GET /api/v1/me with the key', async () => {
+    const h = harness([{ body: ME }]);
+    const code = await run(['whoami', '--url', 'http://x', '--api-key', 'key_a_b'], h.io);
+    expect(code).toBe(0);
+    expect(h.calls).toEqual([{ method: 'GET', path: '/api/v1/me' }]);
+    expect(h.out()).toContain('ada@x.co');
+  });
+
+  it(`reads ${P}_URL / ${P}_API_KEY from the environment`, async () => {
+    const h = harness([{ body: ME }]);
+    h.io.env[`${P}_URL`] = 'http://from-env';
+    h.io.env[`${P}_API_KEY`] = 'key_env';
+    const code = await run(['whoami'], h.io);
+    expect(code).toBe(0);
+    expect(h.calls[0]).toEqual({ method: 'GET', path: '/api/v1/me' });
+  });
+
+  it('files list → GET /api/v1/files', async () => {
+    const h = harness([{ body: { files: [], nextCursor: null } }]);
+    const code = await run(['files', 'list', '--url', 'http://x', '--api-key', 'k'], h.io);
+    expect(code).toBe(0);
+    expect(h.calls).toEqual([{ method: 'GET', path: '/api/v1/files' }]);
+    expect(h.out()).toContain('No files.');
+  });
+
+  it('files list threads --cursor and --limit onto the query string', async () => {
+    const h = harness([{ body: { files: [], nextCursor: null } }]);
+    const code = await run(
+      ['files', 'list', '--limit', '2', '--cursor', 'abc', '--url', 'http://x', '--api-key', 'k'],
+      h.io
+    );
+    expect(code).toBe(0);
+    expect(h.calls).toEqual([{ method: 'GET', path: '/api/v1/files?cursor=abc&limit=2' }]);
+  });
+
+  it('files list --all follows nextCursor and outputs every page', async () => {
+    const fileA = { id: 'f-a', sizeBytes: 10, originalName: 'a.txt' };
+    const fileB = { id: 'f-b', sizeBytes: 20, originalName: 'b.txt' };
+    const h = harness([
+      { body: { files: [fileA], nextCursor: 'f-a' } },
+      { body: { files: [fileB], nextCursor: null } }
+    ]);
+    const code = await run(['files', 'list', '--all', '--url', 'http://x', '--api-key', 'k'], h.io);
+    expect(code).toBe(0);
+    expect(h.calls).toEqual([
+      { method: 'GET', path: '/api/v1/files' },
+      { method: 'GET', path: '/api/v1/files?cursor=f-a' }
+    ]);
+    expect(h.out()).toContain('a.txt');
+    expect(h.out()).toContain('b.txt');
+  });
+
+  it('files list --json prints the wire shape { files, nextCursor }', async () => {
+    const fileA = { id: 'f-a', sizeBytes: 10, originalName: 'a.txt' };
+    const h = harness([{ body: { files: [fileA], nextCursor: 'f-a' } }]);
+    const code = await run(['files', 'list', '--json', '--url', 'http://x', '--api-key', 'k'], h.io);
+    expect(code).toBe(0);
+    expect(JSON.parse(h.out())).toEqual({ files: [fileA], nextCursor: 'f-a' });
+  });
+
+  it('files rm → DELETE /api/v1/files/:id', async () => {
+    const h = harness([{ body: {} }]);
+    const code = await run(['files', 'rm', 'abc', '--url', 'http://x', '--api-key', 'k'], h.io);
+    expect(code).toBe(0);
+    expect(h.calls).toEqual([{ method: 'DELETE', path: '/api/v1/files/abc' }]);
+  });
+
+  it('export → GET /api/v1/workspace/export streamed to disk', async () => {
+    const h = harness([{ body: { fake: 'zip-bytes' } }]);
+    const out = join(await mkdtemp(join(tmpdir(), 'cli-export-')), 'bundle.zip');
+    const code = await run(['export', '-o', out, '--url', 'http://x', '--api-key', 'k'], h.io);
+    expect(code).toBe(0);
+    expect(h.calls).toEqual([{ method: 'GET', path: '/api/v1/workspace/export' }]);
+    expect(await readFile(out, 'utf8')).toBe(JSON.stringify({ fake: 'zip-bytes' }));
+    expect(h.out()).toContain(out);
+  });
+
+  it('requires an API key for authenticated commands (exit 1, one discovery probe only)', async () => {
+    // With no key at all, the runner asks discovery whether this is a cloud
+    // instance (connect-on-demand seam); a non-cloud answer keeps the
+    // classic error and no other request is made.
+    const h = harness([{ body: INSTANCE }]);
+    const code = await run(['whoami', '--url', 'http://x'], h.io);
+    expect(code).toBe(1);
+    expect(h.calls).toEqual([{ method: 'GET', path: '/api/v1/instance' }]);
+    expect(h.err()).toContain('API key is required');
+  });
+
+  it('maps a 403 to a friendly stderr line and exit 1', async () => {
+    const h = harness([{ status: 403, body: { error: { code: 'forbidden', message: 'Not allowed here' } } }]);
+    const code = await run(['files', 'list', '--url', 'http://x', '--api-key', 'k'], h.io);
+    expect(code).toBe(1);
+    expect(h.err()).toContain('not allowed to do that');
+  });
+
+  it('a 403 plan_required prints the message and the upgrade link, not the key hint', async () => {
+    const h = harness([
+      {
+        status: 403,
+        body: {
+          error: {
+            code: 'plan_required',
+            message: 'This needs the pro plan',
+            details: {
+              key: 'files.maxBytes',
+              plan: 'free',
+              requiredPlan: 'pro',
+              upgradeUrl: 'https://account.antasphere.com/orgs/acme'
+            }
+          }
+        }
+      }
+    ]);
+    const code = await run(['files', 'list', '--url', 'http://x', '--api-key', 'k'], h.io);
+    expect(code).toBe(1);
+    expect(h.err()).toBe(
+      'Error: This needs the pro plan — upgrade the plan at https://account.antasphere.com/orgs/acme\n'
+    );
+  });
+
+  it('a 402 entitlement_denied prints the price, the balance and the top-up link (PRDCT-2664)', async () => {
+    const h = harness([
+      {
+        status: 402,
+        body: {
+          error: {
+            code: 'entitlement_denied',
+            message: 'Not enough credits',
+            details: {
+              credits: 1500,
+              balance: 20,
+              topUpUrl: 'https://account.antasphere.com/orgs/acme/billing'
+            }
+          }
+        }
+      }
+    ]);
+    const code = await run(['files', 'list', '--url', 'http://x', '--api-key', 'k'], h.io);
+    expect(code).toBe(1);
+    expect(h.err()).toBe(
+      'Error: Not enough credits — this needs 1500 credits and the organization holds 20; ' +
+        'top up at https://account.antasphere.com/orgs/acme/billing\n'
+    );
+  });
+
+  it('a 402 whose details carry the link alone prints no figure: never "undefined credits"', async () => {
+    const h = harness([
+      {
+        status: 402,
+        body: {
+          error: {
+            code: 'entitlement_denied',
+            message: 'Not enough credits',
+            details: { topUpUrl: 'https://account.antasphere.com/orgs/acme/billing' }
+          }
+        }
+      }
+    ]);
+    const code = await run(['files', 'list', '--url', 'http://x', '--api-key', 'k'], h.io);
+    expect(code).toBe(1);
+    expect(h.err()).toBe(
+      'Error: Not enough credits — top up at https://account.antasphere.com/orgs/acme/billing\n'
+    );
+  });
+
+  it('a 402 with the price alone prints the price and the link', async () => {
+    const h = harness([
+      {
+        status: 402,
+        body: {
+          error: {
+            code: 'entitlement_denied',
+            message: 'Not enough credits',
+            details: { credits: 1500, topUpUrl: 'https://account.antasphere.com/orgs/acme/billing' }
+          }
+        }
+      }
+    ]);
+    const code = await run(['files', 'list', '--url', 'http://x', '--api-key', 'k'], h.io);
+    expect(code).toBe(1);
+    expect(h.err()).toBe(
+      'Error: Not enough credits — this needs 1500 credits; top up at https://account.antasphere.com/orgs/acme/billing\n'
+    );
+  });
+
+  it('the gate’s own 402 message already carries the link: printed once, never twice (verifier round 1)', async () => {
+    const url = 'https://account.antasphere.com/orgs/acme/billing';
+    const message = `This needs 1500 credits and the organization holds 20; top up at ${url}`;
+    const h = harness([
+      {
+        status: 402,
+        body: {
+          error: {
+            code: 'entitlement_denied',
+            message,
+            details: { credits: 1500, balance: 20, topUpUrl: url }
+          }
+        }
+      }
+    ]);
+    const code = await run(['files', 'list', '--url', 'http://x', '--api-key', 'k'], h.io);
+    expect(code).toBe(1);
+    expect(h.err()).toBe(`Error: ${message}\n`);
+    expect(h.err().split(url).length - 1).toBe(1);
+  });
+
+  it('a 413 entitlement_denied without details (the self-hosted cap) prints the message alone', async () => {
+    const h = harness([
+      {
+        status: 413,
+        body: { error: { code: 'entitlement_denied', message: 'File exceeds the 100 MB limit' } }
+      }
+    ]);
+    const code = await run(['files', 'list', '--url', 'http://x', '--api-key', 'k'], h.io);
+    expect(code).toBe(1);
+    expect(h.err()).toBe('Error: File exceeds the 100 MB limit\n');
+  });
+});

package/test/suite/config.test.ts

@@ -0,0 +1,59 @@
+import { statSync } from 'node:fs';
+import { describe, expect, it } from 'vitest';
+import { redactKey } from '@antasphere/chassis-cli';
+import { tempConfigEnv } from '@antasphere/chassis-cli/testing';
+import { cli } from '@chassis-cli-test/host';
+
+// The kit's config store, and the literals that spell the tool (its identity).
+const { clearConfig, configPath, loadConfig, saveConfig } = cli;
+const { tool, keyPrefix: K } = cli.identity;
+
+describe('CLI config store', () => {
+  it(`round-trips profiles through $XDG_CONFIG_HOME/antasphere/tools/${tool}.json`, async () => {
+    const env = await tempConfigEnv();
+    expect(loadConfig(env)).toEqual({ profiles: {} });
+    saveConfig(env, {
+      activeProfile: 'dev',
+      profiles: { dev: { apiKey: `${K}_a_b`, baseUrl: 'http://localhost:3100' } }
+    });
+    const loaded = loadConfig(env);
+    expect(loaded.activeProfile).toBe('dev');
+    expect(loaded.profiles.dev).toEqual({ apiKey: `${K}_a_b`, baseUrl: 'http://localhost:3100' });
+  });
+
+  it('creates the dir 0700 and the file 0600', async () => {
+    const env = await tempConfigEnv();
+    const path = saveConfig(env, { profiles: { p: { apiKey: `${K}_x_y` } } });
+    expect((statSync(path).mode & 0o777).toString(8)).toBe('600');
+    const dir = path.slice(0, path.lastIndexOf('/'));
+    expect((statSync(dir).mode & 0o777).toString(8)).toBe('700');
+  });
+
+  it('falls back to HOME/.config when XDG_CONFIG_HOME is unset', () => {
+    // The tool's namespace of the SHARED antasphere config home
+    // (@antasphere/cli-core) — moved there from ~/.config/<legacyConfigDir>/.
+    expect(configPath({ HOME: '/home/u' })).toBe(`/home/u/.config/antasphere/tools/${tool}.json`);
+    expect(configPath({ XDG_CONFIG_HOME: '/xdg' })).toBe(`/xdg/antasphere/tools/${tool}.json`);
+    expect(configPath({})).toBeNull();
+  });
+
+  it('treats a corrupt config file as empty instead of crashing', async () => {
+    const env = await tempConfigEnv();
+    const path = saveConfig(env, { profiles: {} });
+    const { writeFileSync } = await import('node:fs');
+    writeFileSync(path, 'not json');
+    expect(loadConfig(env)).toEqual({ profiles: {} });
+  });
+
+  it('clear removes the file', async () => {
+    const env = await tempConfigEnv();
+    saveConfig(env, { profiles: { p: {} } });
+    clearConfig(env);
+    expect(loadConfig(env)).toEqual({ profiles: {} });
+  });
+
+  it('redacts keys to prefix…suffix', () => {
+    expect(redactKey(`${K}_abcdefgh_0123456789abcdefghijklmnop`)).toBe(`${K}_abcdefgh_…mnop`);
+    expect(redactKey('short')).toBe('****');
+  });
+});