bytespost-canvas 0.1.0

package/dist/cli.js

@@ -0,0 +1,747 @@
+#!/usr/bin/env node
+/**
+ * canvas-bridge CLI (SLICE 1 + 2).
+ *
+ *   canvas-bridge serve                  start the daemon (blocks)
+ *   canvas-bridge health                 GET /v1/health, print JSON
+ *   canvas-bridge ls                     GET /v1/tabs
+ *   canvas-bridge screenshot -o <file>   GET /v1/screenshot, write PNG
+ *   canvas-bridge draw <json|file>       POST /v1/draw, print {nodeIds}
+ *   canvas-bridge draw rect --x ...      POST /v1/draw with a typed spec
+ *
+ * `draw` takes either an inline JSON string (a `{nodes:[...]}` body, or a bare
+ * array of specs) or a path to a .json file containing the same.
+ *
+ * Talks to the daemon over plain localhost HTTP. Intentionally tiny.
+ */
+import { createHash } from 'node:crypto';
+import { readFile, writeFile } from 'node:fs/promises';
+import { resolvePort, startDaemon } from './daemon.js';
+import { COMMAND_SPECS, GLOBAL_FLAGS, findCommandSpec, getTopLevelCommands, } from './commandRegistry.js';
+const HOST = '127.0.0.1';
+function baseUrl() {
+    return `http://${HOST}:${resolvePort()}`;
+}
+function fail(message) {
+    console.error(`canvas-bridge: ${message}`);
+    process.exit(1);
+}
+const BOOLEAN_FLAGS = new Set(['help', 'json', 'dry-run', 'yes']);
+const AI_MODES = new Set(['plan', 'auto', 'explain']);
+function isFlagValueToken(token) {
+    return token !== '-o' && !token.startsWith('--');
+}
+function parseArgs(args) {
+    const positionals = [];
+    const flags = {};
+    let trailing = [];
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === '--') {
+            trailing = args.slice(i + 1);
+            positionals.push(...trailing);
+            break;
+        }
+        if (arg.startsWith('--')) {
+            const eq = arg.indexOf('=');
+            if (eq !== -1) {
+                flags[arg.slice(2, eq)] = arg.slice(eq + 1);
+                continue;
+            }
+            const key = arg.slice(2);
+            const next = args[i + 1];
+            if (BOOLEAN_FLAGS.has(key)) {
+                flags[key] = true;
+                continue;
+            }
+            if (key === 'ai') {
+                if (next && AI_MODES.has(next)) {
+                    flags[key] = next;
+                    i += 1;
+                }
+                else {
+                    flags[key] = true;
+                }
+                continue;
+            }
+            if (next && isFlagValueToken(next)) {
+                flags[key] = next;
+                i += 1;
+            }
+            else {
+                flags[key] = true;
+            }
+            continue;
+        }
+        if (arg === '-h') {
+            flags.help = true;
+            continue;
+        }
+        if (arg === '-o' && i + 1 < args.length) {
+            flags.output = args[i + 1];
+            i += 1;
+            continue;
+        }
+        positionals.push(arg);
+    }
+    return { positionals, flags, trailing };
+}
+function flagString(flags, name) {
+    const value = flags[name];
+    return typeof value === 'string' ? value : undefined;
+}
+function flagNumber(flags, name, required = false) {
+    const raw = flagString(flags, name);
+    if (raw === undefined) {
+        if (required)
+            fail(`--${name} is required`);
+        return undefined;
+    }
+    const value = Number(raw);
+    if (!Number.isFinite(value)) {
+        fail(`--${name} must be a number`);
+    }
+    return value;
+}
+function withTab(path, flags) {
+    const tab = flagString(flags, 'tab');
+    if (!tab) {
+        return path;
+    }
+    const join = path.includes('?') ? '&' : '?';
+    return `${path}${join}tab=${encodeURIComponent(tab)}`;
+}
+async function requestText(path, init) {
+    const res = await requestRaw(path, init);
+    const text = await res.text();
+    return { res, text };
+}
+async function requestRaw(path, init) {
+    let res;
+    try {
+        res = await fetch(`${baseUrl()}${path}`, init);
+    }
+    catch (error) {
+        fail(`cannot reach daemon at ${baseUrl()} (is it running? \`canvas-bridge serve\`) — ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return res;
+}
+function printJsonOrText(text, json) {
+    if (json) {
+        console.log(text);
+        return;
+    }
+    const parsed = JSON.parse(text);
+    console.log(formatHuman(parsed));
+}
+function formatHuman(value) {
+    if (value &&
+        typeof value === 'object' &&
+        Array.isArray(value.tabs)) {
+        const tabs = value.tabs;
+        const rows = tabs.map((tab) => [
+            String(tab.id ?? ''),
+            String(tab.app ?? ''),
+            String(tab.document?.name ?? tab.title ?? ''),
+            String(tab.canvasType ?? ''),
+            tab.ready === false ? 'no' : 'yes',
+            String(tab.url ?? ''),
+        ]);
+        return [
+            ['TAB ID', 'APP', 'PROJECT', 'TYPE', 'READY', 'URL'].join('\t'),
+            ...rows.map((row) => row.join('\t')),
+        ].join('\n');
+    }
+    return JSON.stringify(value, null, 2);
+}
+function commandPositionals(parsed) {
+    if (parsed.trailing.length === 0) {
+        return parsed.positionals;
+    }
+    return parsed.positionals.slice(0, -parsed.trailing.length);
+}
+function isHelpRequested(parsed) {
+    return parsed.flags.help === true;
+}
+function isAiRequested(parsed) {
+    return parsed.flags.ai !== undefined;
+}
+function normalizeAiMode(value) {
+    if (value === undefined || value === true) {
+        return 'plan';
+    }
+    if (value === 'plan' || value === 'auto' || value === 'explain') {
+        return value;
+    }
+    fail(`--ai must be one of: plan, auto, explain`);
+}
+function printHelp(positionals, json) {
+    const { spec } = findCommandSpec(positionals);
+    if (json) {
+        console.log(JSON.stringify(spec ? serializeCommandHelp(spec) : serializeRootHelp(positionals), null, 2));
+        return;
+    }
+    console.log(spec ? renderCommandHelp(spec) : renderRootHelp(positionals));
+}
+function serializeRootHelp(prefix = []) {
+    const prefixText = prefix.join(' ');
+    const commands = prefix.length === 0
+        ? getTopLevelCommands()
+        : COMMAND_SPECS
+            .filter((spec) => prefix.every((part, index) => spec.path[index] === part))
+            .map((spec) => ({ name: spec.path.slice(prefix.length).join(' '), summary: spec.summary }))
+            .filter((entry) => entry.name.length > 0);
+    return {
+        command: prefixText ? `canvas ${prefixText}` : 'canvas',
+        summary: prefixText ? 'Canvas command group.' : 'AI-native local canvas control plane.',
+        usage: prefixText ? `canvas ${prefixText} <command> [flags]` : 'canvas <command> [flags]',
+        commands,
+        globalFlags: GLOBAL_FLAGS,
+    };
+}
+function serializeCommandHelp(spec) {
+    return {
+        command: `canvas ${spec.path.join(' ')}`,
+        summary: spec.summary,
+        description: spec.description,
+        usage: spec.usage,
+        args: spec.args ?? [],
+        flags: [...(spec.flags ?? []), ...GLOBAL_FLAGS],
+        examples: spec.examples ?? [],
+        output: spec.output ?? null,
+        ai: spec.ai ?? { supported: false },
+    };
+}
+function renderRootHelp(prefix = []) {
+    const help = serializeRootHelp(prefix);
+    const commands = help.commands ?? [];
+    return [
+        `${help.command}`,
+        '',
+        String(help.summary),
+        '',
+        'Usage:',
+        `  ${help.usage}`,
+        '',
+        'Commands:',
+        ...commands.map((command) => `  ${command.name.padEnd(18)} ${command.summary}`),
+        '',
+        'Global flags:',
+        ...GLOBAL_FLAGS.map(formatFlagHelp),
+        '',
+        'Examples:',
+        '  canvas ls --json',
+        '  canvas draw rect --tab tab_abc123 --x 100 --y 100 --w 240 --h 120',
+        '  canvas draw rect --tab tab_abc123 --ai --prompt-file ./instruction.txt --json',
+        '',
+        'Use `canvas <command> --help` or `canvas <command> -h` for details.',
+    ].join('\n');
+}
+function renderCommandHelp(spec) {
+    const lines = [
+        `canvas ${spec.path.join(' ')}`,
+        '',
+        spec.description,
+        '',
+        'Usage:',
+        `  ${spec.usage}`,
+    ];
+    if (spec.args?.length) {
+        lines.push('', 'Arguments:', ...spec.args.map((arg) => `  <${arg.name}>${arg.required ? ' (required)' : ''}  ${arg.description}`));
+    }
+    const flags = spec.flags ?? [];
+    if (flags.length) {
+        lines.push('', 'Command flags:', ...flags.map(formatFlagHelp));
+    }
+    lines.push('', 'Global flags:', ...GLOBAL_FLAGS.map(formatFlagHelp));
+    if (spec.examples?.length) {
+        lines.push('', 'Examples:', ...spec.examples.map((example) => `  ${example.command}${example.description ? `  # ${example.description}` : ''}`));
+    }
+    if (spec.output) {
+        lines.push('', 'Output:', `  ${spec.output}`);
+    }
+    if (spec.ai?.supported) {
+        lines.push('', 'AI:', '  Add --ai to compile the command, explicit flags, and prompt text into an internal plan.', '  Long prompts: use --prompt-file <path>, --prompt <text>, stdin with --prompt-file -, or trailing text after --.', `  Context: ${spec.ai.context.join(', ') || 'none'}.`, '  Images are not supported in v1.');
+    }
+    return lines.join('\n');
+}
+function formatFlagHelp(flag) {
+    const names = [`--${flag.name}${flag.valueName && flag.type !== 'boolean' ? ` <${flag.valueName}>` : ''}`];
+    if (flag.alias) {
+        names.push(`-${flag.alias}${flag.valueName && flag.type !== 'boolean' ? ` <${flag.valueName}>` : ''}`);
+    }
+    const required = flag.required === true ? ' required.' : flag.required === 'when-multiple-tabs' ? ' required with multiple tabs.' : '';
+    return `  ${names.join(', ').padEnd(30)} ${flag.description}${required}`;
+}
+async function readAiPrompt(parsed) {
+    const parts = [];
+    const sources = [];
+    const inline = flagString(parsed.flags, 'prompt');
+    if (inline !== undefined) {
+        parts.push(inline);
+        sources.push('--prompt');
+    }
+    const file = flagString(parsed.flags, 'prompt-file');
+    if (file !== undefined) {
+        if (isUnsupportedImagePromptFile(file)) {
+            fail('image prompt files are not supported in --ai v1; pass a UTF-8 text file instead');
+        }
+        const text = file === '-' ? await readStdin() : await readFile(file, 'utf8');
+        parts.push(text);
+        sources.push(file === '-' ? 'stdin' : `file:${file}`);
+    }
+    if (parsed.trailing.length > 0) {
+        parts.push(parsed.trailing.join(' '));
+        sources.push('--');
+    }
+    return { text: parts.join('\n\n'), sources };
+}
+function isUnsupportedImagePromptFile(path) {
+    return /\.(png|jpe?g|gif|webp|avif|bmp|ico|svg)$/i.test(path);
+}
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks).toString('utf8');
+}
+function summarizePrompt(prompt) {
+    const sha256 = createHash('sha256').update(prompt.text).digest('hex');
+    return {
+        sources: prompt.sources,
+        charCount: prompt.text.length,
+        sha256,
+        preview: prompt.text.length > 240 ? `${prompt.text.slice(0, 240)}...` : prompt.text,
+    };
+}
+function commandFlagsForPlan(flags, spec) {
+    const globalNames = new Set(GLOBAL_FLAGS.map((flag) => flag.name));
+    const flagSpecs = new Map((spec.flags ?? []).map((flag) => [flag.name, flag]));
+    const result = {};
+    for (const [key, value] of Object.entries(flags)) {
+        if (globalNames.has(key)) {
+            continue;
+        }
+        const flagSpec = flagSpecs.get(key);
+        if (flagSpec?.type === 'number' && typeof value === 'string') {
+            const parsed = Number(value);
+            result[key] = Number.isFinite(parsed) ? parsed : value;
+            continue;
+        }
+        if (flagSpec?.type === 'json' && typeof value === 'string') {
+            try {
+                result[key] = JSON.parse(value);
+            }
+            catch {
+                result[key] = value;
+            }
+            continue;
+        }
+        result[key] = value;
+    }
+    return result;
+}
+async function cmdAiPlan(parsed) {
+    const positionals = commandPositionals(parsed);
+    const { spec, consumed } = findCommandSpec(positionals);
+    if (!spec) {
+        fail(`unknown command for --ai: ${positionals.join(' ') || '(none)'}`);
+    }
+    if (!spec.ai?.supported) {
+        fail(`--ai is not supported for canvas ${spec.path.join(' ')}`);
+    }
+    const mode = normalizeAiMode(parsed.flags.ai);
+    const prompt = await readAiPrompt(parsed);
+    const commandArgs = positionals.slice(consumed);
+    const commandFlags = commandFlagsForPlan(parsed.flags, spec);
+    const plan = {
+        ok: true,
+        command: `canvas ${spec.path.join(' ')}`,
+        ai: {
+            mode,
+            planner: 'local-command-plan-v1',
+            imageInputSupported: false,
+            prompt: summarizePrompt(prompt),
+            context: {
+                requested: spec.ai.context,
+                tab: typeof commandFlags.tab === 'string' ? commandFlags.tab : null,
+            },
+        },
+        plan: {
+            version: 1,
+            risk: spec.ai.safety,
+            internalCommands: [
+                {
+                    op: spec.ai.operation,
+                    args: commandArgs,
+                    flags: commandFlags,
+                    promptRef: prompt.text.length > 0 ? 'ai.prompt' : null,
+                },
+            ],
+            constraints: {
+                explicitFlagsAreHardConstraints: true,
+                imagesSupported: false,
+            },
+        },
+        execution: {
+            status: 'planned_only',
+            reason: mode === 'auto'
+                ? 'Remote paid AI execution is not wired in v1; this command produced the internal plan.'
+                : 'Plan mode does not mutate the canvas.',
+        },
+    };
+    if (parsed.flags.json === true) {
+        console.log(JSON.stringify(plan, null, 2));
+        return;
+    }
+    console.log(renderAiPlanHuman(plan));
+}
+function renderAiPlanHuman(plan) {
+    return [
+        `AI plan: ${plan.command}`,
+        '',
+        `Mode: ${plan.ai.mode}`,
+        `Risk: ${plan.plan.risk}`,
+        `Prompt: ${String(plan.ai.prompt.charCount)} chars from ${plan.ai.prompt.sources.join(', ') || 'none'}`,
+        `Context: ${plan.ai.context.requested.join(', ') || 'none'}${plan.ai.context.tab ? ` (tab ${plan.ai.context.tab})` : ''}`,
+        '',
+        'Internal commands:',
+        ...plan.plan.internalCommands.map((command, index) => `  ${index + 1}. ${command.op} ${JSON.stringify({ args: command.args, flags: command.flags })}`),
+        '',
+        `${plan.execution.status}: ${plan.execution.reason}`,
+        'Use --json for a stable machine-readable plan.',
+    ].join('\n');
+}
+async function cmdServe() {
+    const handle = await startDaemon();
+    const shutdown = () => {
+        void handle.close().then(() => process.exit(0));
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+    // Keep the process alive; startDaemon's listeners hold it open.
+}
+async function cmdHealth() {
+    const { res, text } = await requestText('/v1/health');
+    console.log(text);
+    if (!res.ok) {
+        process.exit(1);
+    }
+}
+async function cmdLs(args) {
+    const parsed = parseArgs(args);
+    const { res, text } = await requestText('/v1/tabs');
+    printJsonOrText(text, parsed.flags.json === true);
+    if (!res.ok) {
+        process.exit(1);
+    }
+}
+async function cmdScreenshot(args) {
+    const parsed = parseArgs(args);
+    const out = flagString(parsed.flags, 'output');
+    if (!out) {
+        fail('screenshot requires -o <file>');
+    }
+    const res = await requestRaw(withTab('/v1/screenshot', parsed.flags));
+    if (!res.ok) {
+        const detail = await res.text().catch(() => '');
+        fail(`screenshot failed: HTTP ${res.status} ${detail}`);
+    }
+    const buf = Buffer.from(await res.arrayBuffer());
+    await writeFile(out, buf);
+    console.log(`wrote ${buf.byteLength} bytes -> ${out}`);
+}
+async function cmdDraw(args) {
+    const parsedArgs = parseArgs(args);
+    const [kindOrPayload] = parsedArgs.positionals;
+    if (kindOrPayload && ['rect', 'text', 'frame', 'line'].includes(kindOrPayload)) {
+        await cmdDrawTyped(kindOrPayload, parsedArgs.flags);
+        return;
+    }
+    const arg = kindOrPayload;
+    if (!arg) {
+        fail('draw requires a JSON string or a path to a .json file');
+    }
+    // Inline JSON if it looks like JSON; otherwise treat it as a file path.
+    const looksInline = /^\s*[[{]/.test(arg);
+    let text;
+    if (looksInline) {
+        text = arg;
+    }
+    else {
+        try {
+            text = await readFile(arg, 'utf8');
+        }
+        catch (error) {
+            fail(`cannot read draw spec file ${arg}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch (error) {
+        fail(`draw spec is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    // Accept either a full {nodes:[...]} body or a bare array of specs.
+    const payload = Array.isArray(parsed) ? { nodes: parsed } : parsed;
+    const { res, text: body } = await requestText(withTab('/v1/draw', parsedArgs.flags), {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify(payload),
+    });
+    console.log(body);
+    if (!res.ok) {
+        process.exit(1);
+    }
+}
+async function cmdDrawTyped(kind, flags) {
+    const node = buildDrawSpec(kind, flags);
+    const { res, text } = await requestText(withTab('/v1/draw', flags), {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ nodes: [node] }),
+    });
+    if (flags.json === true) {
+        console.log(text);
+    }
+    else {
+        printJsonOrText(text, false);
+    }
+    if (!res.ok) {
+        process.exit(1);
+    }
+}
+function buildDrawSpec(kind, flags) {
+    if (kind === 'rect' || kind === 'frame') {
+        return compact({
+            type: kind,
+            x: flagNumber(flags, 'x', true),
+            y: flagNumber(flags, 'y', true),
+            w: flagNumber(flags, 'w', true),
+            h: flagNumber(flags, 'h', true),
+            fill: flagString(flags, 'fill'),
+            stroke: flagString(flags, 'stroke'),
+            strokeWidth: flagNumber(flags, 'stroke-width'),
+            radius: flagNumber(flags, 'radius'),
+            name: flagString(flags, 'name'),
+        });
+    }
+    if (kind === 'text') {
+        return compact({
+            type: 'text',
+            x: flagNumber(flags, 'x', true),
+            y: flagNumber(flags, 'y', true),
+            text: flagString(flags, 'text') ?? '',
+            fontSize: flagNumber(flags, 'font-size'),
+            color: flagString(flags, 'color'),
+            w: flagNumber(flags, 'w'),
+            name: flagString(flags, 'name'),
+        });
+    }
+    if (kind === 'line') {
+        return compact({
+            type: 'line',
+            x1: flagNumber(flags, 'x1', true),
+            y1: flagNumber(flags, 'y1', true),
+            x2: flagNumber(flags, 'x2', true),
+            y2: flagNumber(flags, 'y2', true),
+            stroke: flagString(flags, 'stroke'),
+            width: flagNumber(flags, 'width'),
+            name: flagString(flags, 'name'),
+        });
+    }
+    fail(`unsupported draw type ${kind}`);
+}
+async function cmdTab(args) {
+    const parsed = parseArgs(args);
+    const [subcommand, tabId] = parsed.positionals;
+    if (subcommand !== 'info' || !tabId) {
+        fail('usage: canvas-bridge tab info <tab> [--json]');
+    }
+    const { res, text } = await requestText(`/v1/tabs/${encodeURIComponent(tabId)}`);
+    printJsonOrText(text, parsed.flags.json === true);
+    if (!res.ok)
+        process.exit(1);
+}
+async function cmdDocument(args) {
+    const parsed = parseArgs(args);
+    const [subcommand] = parsed.positionals;
+    const path = subcommand === 'nodes' ? '/v1/document/nodes' : subcommand === 'get' ? '/v1/document' : null;
+    if (!path) {
+        fail('usage: canvas-bridge document <get|nodes> --tab <tab> [--json]');
+    }
+    const { res, text } = await requestText(withTab(path, parsed.flags));
+    printJsonOrText(text, parsed.flags.json === true);
+    if (!res.ok)
+        process.exit(1);
+}
+async function cmdNode(args) {
+    const parsed = parseArgs(args);
+    const [subcommand, nodeId] = parsed.positionals;
+    if (!nodeId || !['get', 'delete', 'update'].includes(subcommand ?? '')) {
+        fail('usage: canvas-bridge node <get|delete|update> <nodeId> --tab <tab>');
+    }
+    const path = withTab(`/v1/node/${encodeURIComponent(nodeId)}`, parsed.flags);
+    if (subcommand === 'get' || subcommand === 'delete') {
+        const { res, text } = await requestText(path, { method: subcommand === 'delete' ? 'DELETE' : 'GET' });
+        printJsonOrText(text, parsed.flags.json === true);
+        if (!res.ok)
+            process.exit(1);
+        return;
+    }
+    const patchText = flagString(parsed.flags, 'patch') ?? flagString(parsed.flags, 'data');
+    if (!patchText) {
+        fail('node update requires --patch JSON');
+    }
+    const { res, text } = await requestText(path, {
+        method: 'PATCH',
+        headers: { 'content-type': 'application/json' },
+        body: patchText,
+    });
+    printJsonOrText(text, parsed.flags.json === true);
+    if (!res.ok)
+        process.exit(1);
+}
+async function cmdSelect(args) {
+    const parsed = parseArgs(args);
+    const [subcommand, nodeId] = parsed.positionals;
+    if (subcommand === 'clear') {
+        const { res, text } = await requestText(withTab('/v1/select/clear', parsed.flags), { method: 'POST' });
+        printJsonOrText(text, parsed.flags.json === true);
+        if (!res.ok)
+            process.exit(1);
+        return;
+    }
+    if (subcommand !== 'set' || !nodeId) {
+        fail('usage: canvas-bridge select <set nodeId|clear> --tab <tab>');
+    }
+    const { res, text } = await requestText(withTab('/v1/select', parsed.flags), {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ nodeId }),
+    });
+    printJsonOrText(text, parsed.flags.json === true);
+    if (!res.ok)
+        process.exit(1);
+}
+async function cmdViewport(args) {
+    const parsed = parseArgs(args);
+    const [subcommand] = parsed.positionals;
+    if (subcommand === 'screenshot') {
+        await cmdScreenshot(args.slice(1));
+        return;
+    }
+    const path = subcommand === 'fit' ? '/v1/viewport/fit' : subcommand === 'zoom' ? '/v1/viewport/zoom' : null;
+    if (!path) {
+        fail('usage: canvas-bridge viewport <screenshot|fit|zoom> --tab <tab>');
+    }
+    const body = subcommand === 'zoom'
+        ? JSON.stringify({ zoom: flagNumber(parsed.flags, 'to', true) })
+        : '{}';
+    const { res, text } = await requestText(withTab(path, parsed.flags), {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body,
+    });
+    printJsonOrText(text, parsed.flags.json === true);
+    if (!res.ok)
+        process.exit(1);
+}
+async function cmdBuilding(args) {
+    const parsed = parseArgs(args);
+    const [buildingType] = parsed.positionals;
+    if (!buildingType) {
+        fail('usage: canvas-bridge building <wall|room|slab|roof|door|window|zone|furniture> --tab <tab> [flags]');
+    }
+    const input = compact({
+        startX: flagNumber(parsed.flags, 'start-x'),
+        startZ: flagNumber(parsed.flags, 'start-z'),
+        endX: flagNumber(parsed.flags, 'end-x'),
+        endZ: flagNumber(parsed.flags, 'end-z'),
+        x: flagNumber(parsed.flags, 'x'),
+        y: flagNumber(parsed.flags, 'y'),
+        z: flagNumber(parsed.flags, 'z'),
+        width: flagNumber(parsed.flags, 'w') ?? flagNumber(parsed.flags, 'width'),
+        depth: flagNumber(parsed.flags, 'd') ?? flagNumber(parsed.flags, 'depth'),
+        label: flagString(parsed.flags, 'label'),
+        type: flagString(parsed.flags, 'type'),
+        color: flagString(parsed.flags, 'color'),
+    });
+    const { res, text } = await requestText(withTab('/v1/building', parsed.flags), {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ buildingType, input }),
+    });
+    printJsonOrText(text, parsed.flags.json === true);
+    if (!res.ok)
+        process.exit(1);
+}
+function compact(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined));
+}
+async function main() {
+    const rawArgs = process.argv.slice(2);
+    const parsed = parseArgs(rawArgs);
+    const positionals = commandPositionals(parsed);
+    if (isHelpRequested(parsed) || positionals.length === 0) {
+        printHelp(positionals, parsed.flags.json === true);
+        return;
+    }
+    if (isAiRequested(parsed)) {
+        await cmdAiPlan(parsed);
+        return;
+    }
+    const [command] = positionals;
+    const commandIndex = rawArgs.findIndex((arg) => arg === command);
+    const rest = commandIndex === -1
+        ? rawArgs.slice(1)
+        : [...rawArgs.slice(0, commandIndex), ...rawArgs.slice(commandIndex + 1)];
+    switch (command) {
+        case 'serve':
+        case 'start':
+            await cmdServe();
+            return;
+        case 'mcp': {
+            const { runMcpServer } = await import('./mcp.js');
+            await runMcpServer();
+            return;
+        }
+        case 'health':
+        case 'status':
+            await cmdHealth();
+            return;
+        case 'ls':
+            await cmdLs(rest);
+            return;
+        case 'tab':
+            await cmdTab(rest);
+            return;
+        case 'screenshot':
+            await cmdScreenshot(rest);
+            return;
+        case 'draw':
+            await cmdDraw(rest);
+            return;
+        case 'document':
+            await cmdDocument(rest);
+            return;
+        case 'node':
+            await cmdNode(rest);
+            return;
+        case 'select':
+            await cmdSelect(rest);
+            return;
+        case 'viewport':
+            await cmdViewport(rest);
+            return;
+        case 'building':
+            await cmdBuilding(rest);
+            return;
+        default:
+            console.error('usage: canvas <serve|start|mcp|health|status|ls|tab|document|node|select|viewport|building|screenshot|draw>');
+            process.exit(command ? 1 : 0);
+    }
+}
+void main();