@agentrhq/webcmd 0.3.0 → 0.3.2

package/dist/src/hosted/manifest.test.js

@@ -1,8 +1,20 @@
-import { describe, expect, it } from 'vitest';
+import { Writable } from 'node:stream';
+import { describe, expect, it, vi } from 'vitest';
+import { commandHelpData, formatCommandHelpText, formatSiteHelpText, renderStructuredHelp, siteHelpData, } from '../help.js';
+import { serializeCommand } from '../serialization.js';
+import { Strategy } from '../registry.js';
 import { commandNamesForSite, findHostedCommand, hostedListRows, renderHostedCommandHelp, renderHostedSiteHelp, siteNames, } from './manifest.js';
+import { makeHostedConfig } from './config.js';
+import { runHostedCli } from './runner.js';
+import { formatRootHelp } from '../command-presentation.js';
+import { HOSTED_ROOT_HELP } from '../completion-shared.js';
 const manifest = {
     userId: 'user_demo',
-    generatedAt: '2026-07-08T00:00:00.000Z',
+    metadata: {
+        contractSchemaVersion: 1,
+        webcmdPackageVersion: '0.3.0',
+        generatedAt: '2026-07-08T00:00:00.000Z',
+    },
     commands: [
         {
             site: 'github',
@@ -26,9 +38,34 @@ const manifest = {
             strategy: 'LOCAL',
             browser: false,
             args: [],
+            columns: [],
         },
     ],
 };
+const equivalentLocalCommand = {
+    site: 'github',
+    name: 'whoami',
+    aliases: ['me'],
+    description: 'Show GitHub identity',
+    access: 'read',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    args: [],
+    columns: ['username'],
+    domain: 'github.com',
+};
+function sink() {
+    let data = '';
+    return {
+        stream: new Writable({
+            write(chunk, _encoding, callback) {
+                data += String(chunk);
+                callback();
+            },
+        }),
+        text: () => data,
+    };
+}
 describe('hosted manifest helpers', () => {
     it('filters LOCAL commands from hosted list rows', () => {
         expect(hostedListRows(manifest, true).map((row) => row.command)).toEqual(['github/whoami']);
@@ -43,4 +80,85 @@ describe('hosted manifest helpers', () => {
         expect(renderHostedSiteHelp(manifest, 'github')).toContain('whoami');
         expect(renderHostedCommandHelp(manifest.commands[0])).toContain('Output columns: username');
     });
+    it('matches local site and command help byte-for-byte for equal metadata', () => {
+        expect(renderHostedSiteHelp(manifest, 'github')).toBe(formatSiteHelpText('github', [equivalentLocalCommand]));
+        expect(renderHostedCommandHelp(manifest.commands[0])).toBe(formatCommandHelpText(equivalentLocalCommand));
+    });
+    it('matches local structured list rows for equal metadata', () => {
+        expect(hostedListRows({ ...manifest, commands: [manifest.commands[0]] }, true))
+            .toEqual([serializeCommand(equivalentLocalCommand)]);
+    });
+    it('describes universal hosted surfaces and accepted local-only commands at the root', async () => {
+        const stdout = sink();
+        const result = await runHostedCli(['--help'], {
+            config: makeHostedConfig({ apiBaseUrl: 'https://api.example.com', apiKey: 'key' }),
+            stdout: stdout.stream,
+        });
+        expect(result).toEqual({ handled: true, exitCode: 0 });
+        expect(stdout.text()).toBe(formatRootHelp(HOSTED_ROOT_HELP));
+        expect(stdout.text()).toContain('completion');
+        expect(stdout.text()).toContain('--profile <name>');
+        expect(stdout.text()).toContain('Local-only commands:');
+        expect(stdout.text()).toContain('Run `webcmd setup` and choose local mode to use local-only commands.');
+    });
+    it('completes private hosted manifest commands without local discovery', async () => {
+        const stdout = sink();
+        const privateManifest = {
+            ...manifest,
+            commands: [
+                ...manifest.commands,
+                {
+                    site: 'private-tools',
+                    name: 'deploy-preview',
+                    aliases: ['preview'],
+                    command: 'private-tools/deploy-preview',
+                    description: 'Deploy a private preview',
+                    access: 'write',
+                    strategy: 'PUBLIC',
+                    browser: false,
+                    args: [],
+                    columns: ['url'],
+                },
+            ],
+        };
+        const fetchImpl = vi.fn(async () => new Response(JSON.stringify({ ok: true, manifest: privateManifest }), { status: 200 }));
+        const result = await runHostedCli(['--get-completions', '--cursor', '2', 'private-tools'], {
+            config: makeHostedConfig({ apiBaseUrl: 'https://api.example.com', apiKey: 'key' }),
+            stdout: stdout.stream,
+            fetchImpl,
+        });
+        expect(result).toEqual({ handled: true, exitCode: 0 });
+        expect(stdout.text().trim().split('\n')).toEqual(['deploy-preview', 'preview']);
+        expect(fetchImpl).toHaveBeenCalledTimes(1);
+    });
+    it.each([
+        ['json', 'json'],
+        ['yaml', 'yaml'],
+        ['yml', 'yaml'],
+    ])('matches local structured site and command help bytes for -f %s', async (requested, rendered) => {
+        const fetchImpl = async () => new Response(JSON.stringify({ ok: true, manifest }), { status: 200 });
+        const siteStdout = sink();
+        await runHostedCli(['github', '--help', '-f', requested], {
+            config: makeHostedConfig({ apiBaseUrl: 'https://api.example.com', apiKey: 'key' }),
+            stdout: siteStdout.stream,
+            fetchImpl,
+        });
+        expect(siteStdout.text()).toBe(renderStructuredHelp(siteHelpData('github', [equivalentLocalCommand]), rendered));
+        const commandStdout = sink();
+        await runHostedCli(['github', 'whoami', '--help', '-f', requested], {
+            config: makeHostedConfig({ apiBaseUrl: 'https://api.example.com', apiKey: 'key' }),
+            stdout: commandStdout.stream,
+            fetchImpl,
+        });
+        expect(commandStdout.text()).toBe(renderStructuredHelp(commandHelpData(equivalentLocalCommand), rendered));
+    });
+    it('uses only executable hosted root capabilities as root completion candidates', async () => {
+        const stdout = sink();
+        await runHostedCli(['--get-completions', '--cursor', '1'], {
+            config: makeHostedConfig({ apiBaseUrl: 'https://api.example.com', apiKey: 'key' }),
+            stdout: stdout.stream,
+            fetchImpl: async () => new Response(JSON.stringify({ ok: true, manifest }), { status: 200 }),
+        });
+        expect(stdout.text().trim().split('\n')).toEqual(['browser', 'completion', 'github', 'list', 'setup']);
+    });
 });

package/dist/src/hosted/output-parity.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/hosted/output-parity.test.js

@@ -0,0 +1,108 @@
+import { Writable } from 'node:stream';
+import { Command } from 'commander';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { Strategy } from '../registry.js';
+import { registerCommandToProgram } from '../commanderAdapter.js';
+import { makeHostedConfig } from './config.js';
+import { runHostedCli } from './runner.js';
+const { mockExecuteCommand } = vi.hoisted(() => ({
+    mockExecuteCommand: vi.fn(),
+}));
+vi.mock('../execution.js', async () => {
+    const actual = await vi.importActual('../execution.js');
+    return { ...actual, executeCommand: mockExecuteCommand };
+});
+const command = {
+    site: 'github',
+    name: 'whoami',
+    description: 'Show GitHub identity',
+    access: 'read',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [],
+    columns: ['username'],
+};
+const manifest = {
+    userId: 'user_demo',
+    metadata: {
+        contractSchemaVersion: 1,
+        webcmdPackageVersion: '0.3.0',
+        generatedAt: '2026-07-14T00:00:00.000Z',
+    },
+    commands: [{
+            site: 'github',
+            name: 'whoami',
+            command: 'github/whoami',
+            description: 'Show GitHub identity',
+            access: 'read',
+            strategy: 'PUBLIC',
+            browser: false,
+            args: [],
+            columns: ['username'],
+        }],
+};
+function sink(isTTY) {
+    let data = '';
+    const stream = new Writable({
+        write(chunk, _encoding, callback) {
+            data += String(chunk);
+            callback();
+        },
+    });
+    Object.defineProperty(stream, 'isTTY', { value: isTTY });
+    return { stream, text: () => data };
+}
+function clock() {
+    const values = [1_000, 1_250];
+    return () => values.shift() ?? 1_250;
+}
+async function localBytes(result, argv, isTTY, footerExtra) {
+    mockExecuteCommand.mockResolvedValueOnce(result);
+    const stdout = sink(isTTY);
+    const program = new Command();
+    const site = program.command('github');
+    registerCommandToProgram(site, {
+        ...command,
+        ...(footerExtra ? { footerExtra: () => footerExtra } : {}),
+    }, { stdout: stdout.stream, now: clock() });
+    await program.parseAsync(['node', 'webcmd', 'github', 'whoami', ...argv]);
+    return stdout.text();
+}
+async function hostedBytes(result, argv, isTTY, footerExtra) {
+    const stdout = sink(isTTY);
+    await runHostedCli(['github', 'whoami', ...argv], {
+        config: makeHostedConfig({ apiBaseUrl: 'https://api.example.com', apiKey: 'key' }),
+        stdout: stdout.stream,
+        now: clock(),
+        fetchImpl: async (url) => String(url).endsWith('/v1/manifest')
+            ? new Response(JSON.stringify({ ok: true, manifest }), { status: 200 })
+            : new Response(JSON.stringify({
+                ok: true,
+                result,
+                columns: ['username'],
+                ...(footerExtra ? { footerExtra } : {}),
+                execution: { id: 'exec_parity', command: 'github/whoami', status: 'succeeded' },
+            }), { status: 200 }),
+    });
+    return stdout.text();
+}
+beforeEach(() => {
+    mockExecuteCommand.mockReset();
+});
+describe('local/hosted command output differential', () => {
+    it('suppresses a null result in both modes', async () => {
+        const result = null;
+        const hosted = await hostedBytes(result, ['-f', 'json'], false);
+        const local = await localBytes(result, ['-f', 'json'], false);
+        expect(hosted).toBe(local);
+        expect(local).toBe('');
+    });
+    it.each([undefined, 'canonical footer'])('matches canonical local TTY table decorations byte-for-byte with footer %s', async (footerExtra) => {
+        const result = [{ username: 'octocat' }];
+        const hosted = await hostedBytes(result, ['-f', 'table'], true, footerExtra);
+        const local = await localBytes(result, ['-f', 'table'], true, footerExtra);
+        expect(hosted).toBe(local);
+        expect(local).toContain('  github/whoami');
+        expect(local).toContain(`1 items | 0.3s | github/whoami${footerExtra ? ` | ${footerExtra}` : ''}`);
+    });
+});

package/dist/src/hosted/root-command-surface.test.d.ts

@@ -0,0 +1 @@
+export {};