@hs-x/cli 0.1.0

package/dist/commands/dev.js

@@ -0,0 +1,913 @@
+import { readFile, readdir, stat } from 'node:fs/promises';
+import { createServer } from 'node:http';
+import { join } from 'node:path';
+import { generateProjectArtifacts } from '@hs-x/codegen';
+import { HttpClientRequest, Schema, schemas } from '@hs-x/types';
+import { BRAND_ORANGE_SGR, CLI_VERSION } from '../constants.js';
+import { controlPlaneAuthHeaders } from '../control-plane-fetch.js';
+import { executeCliHttp } from '../effect-http.js';
+import { formatConfigUrl, loadCliConfig } from '../config.js';
+import { createReporter } from '../reporter/index.js';
+import { isInteractive, promptMultiSelect, promptSelect, promptText } from '../prompt.js';
+async function hostedHttp(input) {
+    const headers = { ...(input.headers ?? {}) };
+    let request = HttpClientRequest.make(input.method ?? 'GET')(input.url).pipe(HttpClientRequest.setHeaders(headers));
+    if (input.body !== undefined) {
+        headers['content-type'] = headers['content-type'] ?? 'application/json';
+        request = request.pipe(HttpClientRequest.setHeaders(headers), HttpClientRequest.bodyText(typeof input.body === 'string' ? input.body : JSON.stringify(input.body), headers['content-type']));
+    }
+    return executeCliHttp(request);
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function renderDevHeader(env, stderr, { subject, url }) {
+    const isTTY = Boolean(stderr.isTTY);
+    const color = isTTY && env.NO_COLOR !== '1';
+    const orange = (s) => (color ? `\x1b[${BRAND_ORANGE_SGR}m${s}\x1b[0m` : s);
+    const bold = (s) => (color ? `\x1b[1m${s}\x1b[0m` : s);
+    const dim = (s) => (color ? `\x1b[2m${s}\x1b[0m` : s);
+    const arrow = '▲';
+    const sep = '→';
+    stderr.write(`\n  ${orange(arrow)} ${bold('hs-x dev')}   ${bold(subject)}   ${dim(sep)}   ${url}\n\n`);
+}
+function makeDevRequestLogger(env, stderr, defaultAccountId) {
+    const isTTY = Boolean(stderr.isTTY);
+    const color = isTTY && env.NO_COLOR !== '1';
+    const dim = (s) => (color ? `\x1b[2m${s}\x1b[0m` : s);
+    const green = (s) => (color ? `\x1b[32m${s}\x1b[0m` : s);
+    const red = (s) => (color ? `\x1b[31m${s}\x1b[0m` : s);
+    const yellow = (s) => (color ? `\x1b[33m${s}\x1b[0m` : s);
+    const cyan = (s) => (color ? `\x1b[36m${s}\x1b[0m` : s);
+    const magenta = (s) => (color ? `\x1b[35m${s}\x1b[0m` : s);
+    return ({ method, path, status, durationMs, source = 'local', accountId, detail }) => {
+        const statusColor = status >= 500 ? red : status >= 400 ? yellow : green;
+        const symbol = status >= 400 ? '✗' : '✓';
+        const methodStr = method.padEnd(5);
+        const pathStr = path.length > 35 ? path : path.padEnd(35);
+        const statusStr = statusColor(String(status).padStart(3));
+        const durationStr = `${durationMs}ms`.padStart(7);
+        const effectiveAccountId = accountId ?? defaultAccountId;
+        const acct = effectiveAccountId ? `  ${dim(effectiveAccountId)}` : '';
+        const sourceColor = source === 'prod' ? magenta : cyan;
+        const sourceLabel = sourceColor(source.padEnd(5));
+        stderr.write(`  ${methodStr}  ${pathStr}   ${statusStr}  ${durationStr}${acct}  ${statusColor(symbol)}  ${sourceLabel}\n`);
+        if (detail) {
+            stderr.write(`        ${dim('└')} ${dim(detail)}\n`);
+        }
+    };
+}
+async function resolveAccountIdOrPrompt(input) {
+    const fromFlag = resolveFlag(input.argv, '--account-id') ?? process.env.HSX_ACCOUNT_ID;
+    if (fromFlag && fromFlag.length > 0)
+        return { accountId: fromFlag, fromPrompt: false };
+    const { loadStore } = await import('../account-store.js');
+    const store = await loadStore();
+    const ids = Object.keys(store.accounts);
+    if (ids.length === 0)
+        return { fromPrompt: false };
+    const defaultId = store.defaultAccountId;
+    // Non-interactive, --json, or --yes: accept the configured default rather than
+    // silently degrading to "no account picked" — that path led deploy to exit 0
+    // after building artifacts only, looking like success.
+    const yes = input.argv.includes('--yes') || input.argv.includes('-y');
+    if (input.json || !isInteractive() || yes) {
+        if (defaultId && ids.includes(defaultId)) {
+            return { accountId: defaultId, fromPrompt: false };
+        }
+        return { fromPrompt: false };
+    }
+    const picked = await promptSelect({
+        message: `Which HS-X account for ${input.purpose}?`,
+        ...(defaultId && ids.includes(defaultId) ? { default: defaultId } : {}),
+        options: ids.map((id) => {
+            const a = store.accounts[id];
+            return {
+                value: id,
+                label: id,
+                description: a
+                    ? `portal ${a.hubspotPortalId} — ${a.displayName}${id === defaultId ? ' (default)' : ''}`
+                    : '',
+            };
+        }),
+    });
+    return picked ? { accountId: picked, fromPrompt: true } : { fromPrompt: false };
+}
+async function promptMissingText(message, current, validate) {
+    if (current && current.length > 0)
+        return current;
+    const answer = await promptText({
+        message,
+        ...(validate ? { validate } : {}),
+    });
+    return answer === undefined ? undefined : answer;
+}
+async function readHsxConfigProjectId(root) {
+    try {
+        const contents = await readFile(join(root, 'hsx.config.ts'), 'utf8');
+        const match = contents.match(/\bname\s*:\s*["'`]([^"'`]+)["'`]/);
+        return match?.[1] ? toProjectId(match[1]) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function toProjectId(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9_-]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+function cancelledResult(argv, command) {
+    const reporter = createReporter({ command, argv });
+    reporter.info('Cancelled.');
+    return { exitCode: 130 };
+}
+export async function devCommand({ argv, root, json, }) {
+    if (argv[1] === 'cleanup') {
+        return await devCleanupCommand({ argv, json });
+    }
+    if (argv[1] === 'status') {
+        return await devStatusCommand({ argv, json });
+    }
+    const port = Number(resolveFlag(argv, '--port') ?? '8787');
+    const workers = await discoverWorkerManifests(root);
+    await generateProjectArtifacts({ root, workers });
+    let portalId = resolveFlag(argv, '--portal');
+    let targetOrigin = resolveFlag(argv, '--target-origin');
+    const resolvedDevAcct = await resolveAccountIdOrPrompt({
+        argv,
+        json,
+        purpose: 'this dev session',
+    });
+    const accountId = resolvedDevAcct.accountId;
+    const devCliConfig = loadCliConfig(argv);
+    // Portal id: HubSpot account ids in our store look like `portal-46993937`;
+    // strip the prefix when the user didn't pass --portal explicitly.
+    if (!portalId && accountId) {
+        const derived = accountId.replace(/^portal[-_]?/i, '');
+        if (/^\d+$/.test(derived))
+            portalId = derived;
+    }
+    // Project id: prefer flag/env, otherwise derive from `name` in hsx.config.ts.
+    // Developers shouldn't have to repeat what's already in the project file.
+    const projectId = devCliConfig.projectId ?? (await readHsxConfigProjectId(root));
+    // Control plane is a single deployed instance; default to it. Overrides
+    // (env or flag) exist for self-host / local-cp test runs only.
+    const controlPlaneUrl = formatConfigUrl(devCliConfig.controlPlaneUrl);
+    const developerId = resolveFlag(argv, '--developer-id') ??
+        devCliConfig.userId;
+    const sessionId = resolveFlag(argv, '--session-id') ??
+        `devsess_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+    let ttlSeconds = Number(resolveFlag(argv, '--ttl-seconds') ?? '7200');
+    const selectedCapabilities = resolveFlags(argv, '--capability');
+    const allCapabilities = workers.flatMap((worker) => worker.capabilities
+        .filter((capability) => capability.runtimeNeeds.includes('worker'))
+        .map((capability) => ({
+        id: capability.id,
+        kind: capability.kind,
+        worker: worker.name,
+    })));
+    const allCapabilityIds = allCapabilities.map((c) => c.id);
+    if (!json && isInteractive() && (controlPlaneUrl || portalId || targetOrigin)) {
+        portalId = await promptMissingText('HubSpot portal id for dev override', portalId, (value) => /^\d+$/.test(value) ? undefined : 'Portal id must be numeric.');
+        if (portalId === undefined)
+            return cancelledResult(argv, 'dev');
+        targetOrigin = await promptMissingText('Public dev target origin', targetOrigin, (value) => {
+            try {
+                const url = new URL(value);
+                return url.protocol === 'https:' || url.hostname === '127.0.0.1' || url.hostname === 'localhost'
+                    ? undefined
+                    : 'Use an https URL, localhost, or 127.0.0.1.';
+            }
+            catch {
+                return 'Enter a valid URL.';
+            }
+        });
+        if (targetOrigin === undefined)
+            return cancelledResult(argv, 'dev');
+        if (!resolveFlag(argv, '--ttl-seconds')) {
+            const ttl = await promptSelect({
+                message: 'Dev override TTL',
+                default: '7200',
+                options: [
+                    { value: '3600', label: '1 hour', description: 'short local session' },
+                    { value: '7200', label: '2 hours', description: 'default' },
+                    { value: '14400', label: '4 hours', description: 'long pairing/debugging session' },
+                ],
+            });
+            if (ttl === undefined)
+                return cancelledResult(argv, 'dev');
+            ttlSeconds = Number(ttl);
+        }
+    }
+    // Probe the HubSpot project IR up front so the picker can show UI-extension
+    // nodes alongside HS-X capabilities. No-op if hsproject.json isn't present.
+    const uiExtensionNodes = await probeHubSpotUiNodes({
+        root,
+        portalIdFlag: portalId,
+        accountId,
+    });
+    let capabilityIds = selectedCapabilities.length > 0 ? selectedCapabilities : allCapabilityIds;
+    let selectedUiNodeUids = uiExtensionNodes && uiExtensionNodes.uids.length > 0 ? uiExtensionNodes.uids : undefined;
+    // Unified picker: ask once over HS-X capabilities + HubSpot UI nodes.
+    const totalCandidates = allCapabilities.length + (uiExtensionNodes?.uids.length ?? 0);
+    if (portalId &&
+        !json &&
+        selectedCapabilities.length === 0 &&
+        totalCandidates > 1 &&
+        isInteractive()) {
+        const CAP_PREFIX = 'cap:';
+        const UI_PREFIX = 'ui:';
+        const options = [
+            ...allCapabilities.map((c) => ({
+                value: `${CAP_PREFIX}${c.id}`,
+                label: c.id,
+                description: `${c.kind}  ·  worker ${c.worker}  →  cloudflare override`,
+            })),
+            ...(uiExtensionNodes?.uids ?? []).map((uid) => ({
+                value: `${UI_PREFIX}${uid}`,
+                label: uid,
+                description: 'ui-extension  ·  hubspot dev-session',
+            })),
+        ];
+        const initial = options.map((o) => o.value);
+        const picked = await promptMultiSelect({
+            message: `Which components should run in dev mode? (portal ${portalId})`,
+            initial,
+            minSelected: 1,
+            options,
+        });
+        if (picked === undefined)
+            return cancelledResult(argv, 'dev');
+        capabilityIds = picked
+            .filter((v) => v.startsWith(CAP_PREFIX))
+            .map((v) => v.slice(CAP_PREFIX.length));
+        selectedUiNodeUids = picked
+            .filter((v) => v.startsWith(UI_PREFIX))
+            .map((v) => v.slice(UI_PREFIX.length));
+    }
+    let devOverrideRegistration;
+    // We register a dev override whenever the user has a HubSpot portal in
+    // play. `hs-x connect` gives us the portal id implicitly; only edge cases
+    // (no connected account, no --portal flag) skip registration.
+    const shouldRegisterOverride = Boolean(portalId);
+    if (shouldRegisterOverride) {
+        if (!accountId) {
+            throw new Error('Dev override needs a connected HubSpot account. Run `hs-x connect` or pass --account-id.');
+        }
+        if (!projectId) {
+            throw new Error('Could not determine project id. Add `name: "..."` to `hsx.config.ts`, set `HSX_PROJECT_ID`, or pass --project-id.');
+        }
+        if (!Number.isFinite(ttlSeconds) || ttlSeconds <= 0) {
+            throw new Error('--ttl-seconds must be a positive number.');
+        }
+        if (capabilityIds.length === 0) {
+            throw new Error('No worker-backed capabilities were found for dev override registration.');
+        }
+        // In JSON / scripted mode we still register here (without an auto-managed
+        // tunnel — scripts pass --target-origin themselves). Interactive mode
+        // registers later, after starting the sidecar + auto-tunnel, so the
+        // telemetry URL can be plumbed through.
+        if (json) {
+            if (!targetOrigin) {
+                throw new Error('Dev override registration in --json mode requires --target-origin <url>.');
+            }
+            devOverrideRegistration = await requestDevOverrideRegistration({
+                controlPlaneUrl,
+                accountId,
+                userId: developerId,
+                request: Schema.decodeUnknownSync(schemas.DevOverrideRegisterRequest)({
+                    projectId,
+                    portalId,
+                    targetOrigin,
+                    developerId,
+                    sessionId,
+                    capabilityIds,
+                    ttlSeconds,
+                }),
+            });
+        }
+    }
+    if (json) {
+        write(`${JSON.stringify({
+            ok: true,
+            command: 'dev',
+            url: `http://127.0.0.1:${port}`,
+            workers,
+            ...(devOverrideRegistration
+                ? { mode: 'control-plane-dev-override', devOverrideRegistration }
+                : {}),
+        }, null, 2)}\n`);
+        return { exitCode: 0 };
+    }
+    const startupBegan = Date.now();
+    const renderRequestLog = makeDevRequestLogger(process.env, process.stderr, accountId);
+    const server = createServer((request, response) => {
+        const requestStarted = Date.now();
+        const method = request.method ?? 'GET';
+        const path = request.url ?? '/';
+        response.on('finish', () => {
+            renderRequestLog({
+                method,
+                path,
+                status: response.statusCode,
+                durationMs: Date.now() - requestStarted,
+                source: 'local',
+            });
+        });
+        if (path === '/_hsx/health') {
+            response.writeHead(200, { 'content-type': 'application/json' });
+            response.end(JSON.stringify({ ok: true, cliVersion: CLI_VERSION }));
+            return;
+        }
+        if (path === '/_hsx/manifest') {
+            response.writeHead(200, { 'content-type': 'application/json' });
+            response.end(JSON.stringify({ workers }, null, 2));
+            return;
+        }
+        response.writeHead(404, { 'content-type': 'application/json' });
+        response.end(JSON.stringify({
+            ok: false,
+            error: 'The v0 dev server exposes /_hsx/health and /_hsx/manifest.',
+        }));
+    });
+    await new Promise((resolveListen) => server.listen(port, '127.0.0.1', resolveListen));
+    const elapsed = Date.now() - startupBegan;
+    const reporter = createReporter({ command: 'dev', argv, entry: true });
+    reporter.banner();
+    const capabilityCount = workers.reduce((c, w) => c + w.capabilities.length, 0);
+    const subject = devOverrideRegistration ? `portal ${devOverrideRegistration.portalId}` : 'local';
+    const url = `http://127.0.0.1:${port}`;
+    // Optional: start a HubSpot UI-extension dev session if this directory
+    // contains an hsproject.json AND the user selected at least one UI node.
+    const hubSpotDevSession = selectedUiNodeUids && selectedUiNodeUids.length > 0
+        ? await maybeStartHubSpotDevSession({
+            root,
+            argv,
+            json,
+            accountId,
+            reporter,
+            selectedNodeUids: selectedUiNodeUids,
+        })
+        : undefined;
+    // HS-X dev sidecar — receives frontend logs (and later: backend/request
+    // events) from inside the card iframe and surfaces them in the terminal.
+    // Stable default port 9099 so card code can hard-default the dev-log URL.
+    const hsxLogPort = Number(resolveFlag(argv, '--hsx-log-port') ?? '9099');
+    const devLogStream = await startHsxDevLogStream({
+        port: hsxLogPort,
+        reporter,
+    });
+    // Auto-managed Cloudflare quick tunnel — gives the deployed Worker a public
+    // URL to POST telemetry envelopes to the local sidecar. The developer must
+    // never have to run cloudflared themselves; that's a non-negotiable default.
+    const devTunnel = shouldRegisterOverride
+        ? await startHsxDevTunnel({ port: hsxLogPort, reporter })
+        : undefined;
+    // Now register the dev override. If the developer didn't pass
+    // `--target-origin`, default to observe mode and let the deployed Worker
+    // run as normal — we only need the tunnel for the telemetry tee.
+    if (shouldRegisterOverride && controlPlaneUrl && portalId && accountId && projectId) {
+        const overrideMode = targetOrigin ? 'proxy' : 'observe';
+        const effectiveTargetOrigin = targetOrigin ?? devTunnel?.url ?? `http://127.0.0.1:${hsxLogPort}`;
+        devOverrideRegistration = await requestDevOverrideRegistration({
+            controlPlaneUrl,
+            accountId,
+            userId: developerId,
+            request: Schema.decodeUnknownSync(schemas.DevOverrideRegisterRequest)({
+                projectId,
+                portalId,
+                targetOrigin: effectiveTargetOrigin,
+                developerId,
+                sessionId,
+                capabilityIds,
+                ttlSeconds,
+                mode: overrideMode,
+                ...(devTunnel ? { telemetryUrl: `${devTunnel.url}/__hsx/event` } : {}),
+            }),
+        });
+    }
+    // Vercel-style header: arrow, command, subject, → URL
+    renderDevHeader(process.env, process.stderr, { subject, url });
+    reporter.info(`Ready in ${elapsed}ms — ${workers.length} worker${workers.length === 1 ? '' : 's'} · ${capabilityCount} capabilit${capabilityCount === 1 ? 'y' : 'ies'}${devOverrideRegistration ? ` · portal ${devOverrideRegistration.portalId}` : ''}${hubSpotDevSession ? ` · ui-extension session ${hubSpotDevSession.sessionId}` : ''}${devLogStream ? ` · log stream ${devLogStream.url}` : ''}${devTunnel ? ` · tunnel ${devTunnel.url}` : ''}`);
+    reporter.info('');
+    reporter.info('Press Ctrl+C to stop');
+    reporter.info('');
+    await new Promise((resolveClose) => {
+        const close = async () => {
+            if (hubSpotDevSession) {
+                try {
+                    await hubSpotDevSession.cleanup();
+                }
+                catch (error) {
+                    renderRequestLog({
+                        method: 'CLEANUP',
+                        path: '/dev-session',
+                        status: 500,
+                        durationMs: 0,
+                        source: 'local',
+                        detail: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            }
+            if (devTunnel) {
+                try {
+                    await devTunnel.cleanup();
+                }
+                catch {
+                    // best-effort: tunnel cleanup failures should not block exit.
+                }
+            }
+            if (devLogStream) {
+                try {
+                    await devLogStream.cleanup();
+                }
+                catch {
+                    // best-effort: sidecar shutdown failures should not block exit.
+                }
+            }
+            server.close(() => resolveClose());
+        };
+        process.once('SIGINT', close);
+        process.once('SIGTERM', close);
+    });
+    return { exitCode: 0 };
+}
+async function startHsxDevLogStream(input) {
+    try {
+        const [{ createDevEventBus }, { startDevLogServer }, { startDevStreamRenderer }] = await Promise.all([
+            import('../dev/event-bus.js'),
+            import('../dev/log-server.js'),
+            import('../dev/stream-renderer.js'),
+        ]);
+        const bus = createDevEventBus();
+        const server = await startDevLogServer({ bus, port: input.port });
+        const renderer = startDevStreamRenderer({ bus });
+        return {
+            url: server.url,
+            async cleanup() {
+                renderer.stop();
+                await server.close();
+            },
+        };
+    }
+    catch (error) {
+        input.reporter.warn('HSX_W_DEV_LOG_STREAM_FAILED', `Could not start dev log stream: ${error instanceof Error ? error.message : String(error)}`);
+        return undefined;
+    }
+}
+async function startHsxDevTunnel(input) {
+    const step = input.reporter.step('Cloudflare quick tunnel');
+    try {
+        const { startCloudflaredTunnel } = await import('../dev/tunnel.js');
+        const tunnel = await startCloudflaredTunnel({ port: input.port });
+        step.ok(tunnel.url);
+        return tunnel;
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        step.warn(msg);
+        return undefined;
+    }
+}
+async function probeHubSpotUiNodes(input) {
+    const { access } = await import('node:fs/promises');
+    const { join: pathJoin } = await import('node:path');
+    const projectFile = pathJoin(input.root, 'hsproject.json');
+    try {
+        await access(projectFile);
+    }
+    catch {
+        return undefined;
+    }
+    const portalId = Number.parseInt(input.portalIdFlag ?? input.accountId?.replace(/^portal[-_]?/i, '') ?? '', 10);
+    if (!Number.isFinite(portalId))
+        return undefined;
+    try {
+        const { loadDevStack } = await import('../dev/compat-shim.js');
+        const stack = await loadDevStack();
+        const { readFile: readProj } = await import('node:fs/promises');
+        const projectConfig = JSON.parse(await readProj(projectFile, 'utf8'));
+        const ir = await stack.translateForLocalDev({
+            projectSourceDir: pathJoin(input.root, projectConfig.srcDir),
+            platformVersion: projectConfig.platformVersion,
+            accountId: portalId,
+        }, {});
+        return { uids: Object.keys(ir.intermediateNodesIndexedByUid), portalId };
+    }
+    catch {
+        // IR translate failed — caller falls back to capability-only behavior.
+        return undefined;
+    }
+}
+async function maybeStartHubSpotDevSession(input) {
+    if (input.argv.includes('--no-hubspot') || input.argv.includes('--no-ui-extensions'))
+        return;
+    const portalFlag = resolveFlag(input.argv, '--portal');
+    const portalId = Number.parseInt(portalFlag ?? input.accountId?.replace(/^portal[-_]?/i, '') ?? '', 10);
+    if (!Number.isFinite(portalId)) {
+        input.reporter.warn('HSX_W_DEV_HUBSPOT_NO_PORTAL', 'Found hsproject.json but no HubSpot portal id — pass --portal <id> to enable the UI-extension dev session.');
+        return undefined;
+    }
+    try {
+        const { startDevSession } = await import('../dev/session-manager.js');
+        const session = await startDevSession({
+            accountId: portalId,
+            projectDir: input.root,
+            selectedNodeUids: input.selectedNodeUids,
+        });
+        input.reporter
+            .step('HubSpot UI-extension session')
+            .ok(`id ${session.sessionId} · ${session.nodeUids.length} component${session.nodeUids.length === 1 ? '' : 's'}`);
+        return session;
+    }
+    catch (error) {
+        input.reporter.warn('HSX_W_DEV_HUBSPOT_SESSION_FAILED', `Could not start UI-extension dev session: ${error instanceof Error ? error.message : String(error)}`);
+        return undefined;
+    }
+}
+async function devStatusCommand({ argv, json, }) {
+    const accountId = resolveFlag(argv, '--account-id') ?? process.env.HSX_ACCOUNT_ID;
+    const controlPlaneUrl = resolveFlag(argv, '--control-plane-url') ?? process.env.HSX_CONTROL_PLANE_URL;
+    const userId = resolveFlag(argv, '--user-id') ??
+        resolveFlag(argv, '--developer-id') ??
+        process.env.HSX_USER_ID ??
+        'local-cli-user';
+    if (!accountId || !controlPlaneUrl) {
+        throw new Error('Dev status requires --control-plane-url and --account-id.');
+    }
+    const active = await requestDevOverrideStatus({ controlPlaneUrl, accountId, userId });
+    const result = {
+        ok: true,
+        command: 'dev status',
+        mode: 'control-plane-dev-override-status',
+        accountId,
+        active,
+    };
+    if (json) {
+        write(`${JSON.stringify(result, null, 2)}\n`);
+    }
+    else {
+        const reporter = createReporter({ command: 'dev status', argv });
+        reporter.header(accountId);
+        reporter.block(renderDevOverrides(active.overrides));
+        reporter.done(`${active.overrides.length} active`);
+    }
+    return { exitCode: 0 };
+}
+async function devCleanupCommand({ argv, json, }) {
+    const accountId = resolveFlag(argv, '--account-id') ?? process.env.HSX_ACCOUNT_ID;
+    const controlPlaneUrl = resolveFlag(argv, '--control-plane-url') ?? process.env.HSX_CONTROL_PLANE_URL;
+    const userId = resolveFlag(argv, '--user-id') ??
+        resolveFlag(argv, '--developer-id') ??
+        process.env.HSX_USER_ID ??
+        'local-cli-user';
+    const sessionId = resolveFlag(argv, '--session-id');
+    if (!accountId || !controlPlaneUrl || !sessionId) {
+        throw new Error('Dev cleanup requires --control-plane-url, --account-id, and --session-id.');
+    }
+    const cleared = await requestDevOverrideCleanup({
+        controlPlaneUrl,
+        accountId,
+        userId,
+        sessionId,
+    });
+    const result = {
+        ok: true,
+        command: 'dev cleanup',
+        mode: 'control-plane-dev-override-cleanup',
+        accountId,
+        sessionId,
+        cleared,
+    };
+    if (json) {
+        write(`${JSON.stringify(result, null, 2)}\n`);
+    }
+    else {
+        const reporter = createReporter({ command: 'dev cleanup', argv });
+        reporter.header(sessionId);
+        reporter.step(`Cleared ${cleared.cleared.length} dev overrides`).ok();
+        reporter.done();
+    }
+    return { exitCode: 0 };
+}
+async function requestDevOverrideRegistration({ controlPlaneUrl, accountId, userId, request, }) {
+    const response = await hostedHttp({
+        url: new URL(`/v1/accounts/${encodeURIComponent(accountId)}/dev-overrides`, controlPlaneUrl),
+        method: 'POST',
+        headers: await controlPlaneAuthHeaders(userId),
+        body: request,
+    });
+    const body = await response.json();
+    if (!response.ok) {
+        throw new Error(isRecord(body) && typeof body.message === 'string'
+            ? body.message
+            : `Control-plane dev override registration failed with status ${response.status}`);
+    }
+    return Schema.decodeUnknownSync(schemas.DevOverrideRegisterResponse)(body);
+}
+async function requestDevOverrideStatus({ controlPlaneUrl, accountId, userId, }) {
+    const response = await hostedHttp({
+        url: new URL(`/v1/accounts/${encodeURIComponent(accountId)}/dev-overrides`, controlPlaneUrl),
+        headers: await controlPlaneAuthHeaders(userId),
+    });
+    const body = await response.json();
+    if (!response.ok) {
+        throw new Error(isRecord(body) && typeof body.message === 'string'
+            ? body.message
+            : `Control-plane dev override status failed with status ${response.status}`);
+    }
+    return Schema.decodeUnknownSync(schemas.DevOverrideListResponse)(body);
+}
+async function requestDevOverrideCleanup({ controlPlaneUrl, accountId, userId, sessionId, }) {
+    const response = await hostedHttp({
+        url: new URL(`/v1/accounts/${encodeURIComponent(accountId)}/dev-overrides/${encodeURIComponent(sessionId)}`, controlPlaneUrl),
+        method: 'DELETE',
+        headers: await controlPlaneAuthHeaders(userId),
+    });
+    const body = await response.json();
+    if (!response.ok) {
+        throw new Error(isRecord(body) && typeof body.message === 'string'
+            ? body.message
+            : `Control-plane dev override cleanup failed with status ${response.status}`);
+    }
+    return Schema.decodeUnknownSync(schemas.DevOverrideClearResponse)(body);
+}
+async function discoverWorkerManifests(root, options = {}) {
+    const files = await collectFiles(join(root, 'src'));
+    const workers = [];
+    for (const file of files) {
+        const source = await readFile(file, 'utf8');
+        const workerName = /defineWorker\s*\(\s*["'`]([^"'`]+)["'`]/.exec(source)?.[1];
+        if (!workerName) {
+            continue;
+        }
+        const toolCapabilities = [
+            ...source.matchAll(/(?:worker\.)?(?:tool|action)\s*\(\s*["'`]([^"'`]+)["'`]\s*,\s*\{([\s\S]*?)(?:async\s+)?handler\s*(?:[:(])/g),
+        ].map((match) => ({
+            kind: 'tool',
+            id: match[1] ?? 'unknown',
+            label: /label\s*:\s*["'`]([^"'`]+)["'`]/.exec(match[2] ?? '')?.[1] ?? match[1] ?? 'unknown',
+            objectType: /objectType\s*:\s*["'`]([^"'`]+)["'`]/.exec(match[2] ?? '')?.[1] ?? 'unknown',
+            ...objectFieldsProperty(match[2] ?? '', 'input'),
+            ...objectFieldsProperty(match[2] ?? '', 'output'),
+            runtimeNeeds: ['worker'],
+        }));
+        const cardBackendCapabilities = [
+            ...source.matchAll(/(?:worker\.)?cardBackend\s*\(\s*["'`]([^"'`]+)["'`]\s*,\s*\{([\s\S]*?)(?:async\s+)?handler\s*(?:[:(])/g),
+        ].map((match) => ({
+            kind: 'card-backend',
+            id: match[1] ?? 'unknown',
+            label: /label\s*:\s*["'`]([^"'`]+)["'`]/.exec(match[2] ?? '')?.[1] ?? match[1] ?? 'unknown',
+            runtimeNeeds: ['worker'],
+        }));
+        const sourceDefinitions = discoverSourceDefinitions(source);
+        const syncCapabilities = [
+            ...source.matchAll(/worker\.sync\s*\(\s*([^,]+)\s*,\s*\{([\s\S]*?)\}\s*\)/g),
+        ].map((match) => {
+            const sourceOrId = (match[1] ?? '').trim();
+            const definition = match[2] ?? '';
+            const id = /^["'`]([^"'`]+)["'`]$/.exec(sourceOrId)?.[1];
+            const sourceDefinition = sourceDefinitions.get(sourceOrId);
+            const sourceManifest = sourceDefinition?.kind === 'push'
+                ? {
+                    kind: 'push',
+                    name: sourceDefinition.name,
+                    webhookPath: `/webhooks/${sourceDefinition.name}`,
+                    ...(sourceDefinition.auth ? { auth: { type: sourceDefinition.auth } } : {}),
+                }
+                : sourceDefinition?.kind === 'pull'
+                    ? {
+                        kind: 'pull',
+                        name: sourceDefinition.name,
+                        ...(sourceDefinition.auth ? { auth: { type: sourceDefinition.auth } } : {}),
+                    }
+                    : undefined;
+            return {
+                kind: 'sync',
+                id: id ?? sourceManifest?.name ?? 'unknown',
+                ...(/label\s*:\s*["'`]([^"'`]+)["'`]/.exec(definition)?.[1]
+                    ? { label: /label\s*:\s*["'`]([^"'`]+)["'`]/.exec(definition)?.[1] }
+                    : {}),
+                schedule: /schedule\s*:\s*["'`]([^"'`]+)["'`]/.exec(definition)?.[1] ?? 'manual',
+                ...stringProperty(definition, 'into'),
+                ...schemaProperty(definition),
+                manageSchema: options.noManageSchema ? false : discoverManageSchemaMode(definition),
+                ...(sourceManifest ? { source: sourceManifest } : {}),
+                runtimeNeeds: sourceManifest?.kind === 'push'
+                    ? ['worker', 'durable-object', 'queue']
+                    : ['worker', 'durable-object'],
+            };
+        });
+        workers.push({
+            name: workerName,
+            capabilities: [...toolCapabilities, ...cardBackendCapabilities, ...syncCapabilities],
+        });
+    }
+    return workers;
+}
+function stringProperty(source, propertyName) {
+    const match = new RegExp(`${propertyName}\\s*:\\s*["'\`]([^"'\`]+)["'\`]`).exec(source)?.[1];
+    return match ? { [propertyName]: match } : {};
+}
+function schemaProperty(source) {
+    const body = /schema\s*:\s*\{([\s\S]*?)\}\s*(?:,|$)/.exec(source)?.[1];
+    if (!body) {
+        return {};
+    }
+    const schema = {};
+    for (const match of body.matchAll(/([A-Za-z_$][\w$]*)\s*:\s*["'`]([^"'`]+)["'`]/g)) {
+        if (match[1] && match[2]) {
+            schema[match[1]] = match[2];
+        }
+    }
+    return Object.keys(schema).length > 0 ? { schema } : {};
+}
+function objectFieldsProperty(source, propertyName) {
+    const body = objectLiteralBody(source, propertyName);
+    if (!body) {
+        return {};
+    }
+    const fields = {};
+    for (const match of body.matchAll(/([A-Za-z_$][\w$]*)\s*:\s*\{([\s\S]*?)\}\s*,?/g)) {
+        const fieldName = match[1];
+        const definition = match[2] ?? '';
+        if (!fieldName) {
+            continue;
+        }
+        fields[fieldName] = {
+            ...stringProperty(definition, 'type'),
+            ...stringProperty(definition, 'label'),
+            ...literalProperty(definition, 'default'),
+        };
+    }
+    return Object.keys(fields).length > 0 ? { [propertyName]: fields } : {};
+}
+function objectLiteralBody(source, propertyName) {
+    const start = new RegExp(`${propertyName}\\s*:\\s*\\{`).exec(source);
+    if (!start) {
+        return undefined;
+    }
+    let depth = 0;
+    const bodyStart = start.index + start[0].length;
+    for (let index = bodyStart; index < source.length; index += 1) {
+        const char = source[index];
+        if (char === '{')
+            depth += 1;
+        if (char === '}') {
+            if (depth === 0) {
+                return source.slice(bodyStart, index);
+            }
+            depth -= 1;
+        }
+    }
+    return undefined;
+}
+function literalProperty(source, propertyName) {
+    const match = new RegExp(`${propertyName}\\s*:\\s*([^,}\\n]+)`).exec(source)?.[1]?.trim();
+    if (!match) {
+        return {};
+    }
+    if (/^["'`]/.test(match)) {
+        return stringProperty(source, propertyName);
+    }
+    const numeric = Number(match);
+    if (Number.isFinite(numeric)) {
+        return { [propertyName]: numeric };
+    }
+    if (match === 'true')
+        return { [propertyName]: true };
+    if (match === 'false')
+        return { [propertyName]: false };
+    return {};
+}
+function discoverManageSchemaMode(definition) {
+    const literal = /manageSchema\s*:\s*["'`](properties|full)["'`]/.exec(definition)?.[1];
+    if (literal === 'properties' || literal === 'full') {
+        return literal;
+    }
+    return false;
+}
+function discoverSourceDefinitions(source) {
+    const definitions = new Map();
+    for (const match of source.matchAll(/(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*defineSource(\.push)?\s*\(\s*\{([\s\S]*?)\}\s*\)/g)) {
+        const variableName = match[1];
+        const body = match[3] ?? '';
+        if (!variableName) {
+            continue;
+        }
+        const name = /name\s*:\s*["'`]([^"'`]+)["'`]/.exec(body)?.[1] ?? variableName;
+        const auth = /auth\s*:\s*\{\s*type\s*:\s*["'`](bearer|oauth2|basic|hmac)["'`]/.exec(body)?.[1];
+        definitions.set(variableName, {
+            kind: match[2] ? 'push' : 'pull',
+            name,
+            ...(auth ? { auth } : {}),
+        });
+    }
+    return definitions;
+}
+async function collectFiles(root) {
+    const files = [];
+    async function walk(dir) {
+        let entries;
+        try {
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const path = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                await walk(path);
+            }
+            else if (entry.isFile() && /\.(?:ts|tsx|js|jsx)$/.test(entry.name)) {
+                files.push(path);
+            }
+        }
+    }
+    try {
+        if ((await stat(root)).isDirectory()) {
+            await walk(root);
+        }
+    }
+    catch {
+        return [];
+    }
+    return files.sort();
+}
+function renderDevOverrides(overrides) {
+    if (overrides.length === 0) {
+        return 'No active dev overrides found.\n';
+    }
+    const now = new Date();
+    const portalWidth = Math.max('Portal'.length, ...overrides.map((o) => o.portalId.length));
+    const capabilityWidth = Math.max('Capability'.length, ...overrides.map((o) => o.capabilityId.length));
+    const sessionWidth = Math.max('Session'.length, ...overrides.map((o) => o.sessionId.length));
+    const lines = [
+        `${'Portal'.padEnd(portalWidth)}  ${'Capability'.padEnd(capabilityWidth)}  ${'Session'.padEnd(sessionWidth)}  Expires  Target`,
+    ];
+    for (const override of overrides) {
+        lines.push(`${override.portalId.padEnd(portalWidth)}  ${override.capabilityId.padEnd(capabilityWidth)}  ${override.sessionId.padEnd(sessionWidth)}  ${formatDevExpiry(now, override.expiresAt).padEnd(7)}  ${override.targetOrigin}`);
+    }
+    return `${lines.join('\n')}\n`;
+}
+function formatDevExpiry(now, expiresAt) {
+    const expires = Date.parse(expiresAt);
+    if (!Number.isFinite(expires))
+        return expiresAt;
+    const ms = expires - now.getTime();
+    if (ms <= 0)
+        return 'expired';
+    const minutes = Math.ceil(ms / 60_000);
+    if (minutes < 60)
+        return `${minutes}m`;
+    const hours = Math.ceil(minutes / 60);
+    if (hours < 48)
+        return `${hours}h`;
+    return `${Math.ceil(hours / 24)}d`;
+}
+function isFlagValue(value) {
+    return value !== undefined && value.length > 0 && !value.startsWith('-');
+}
+function resolveFlag(argv, flag) {
+    const index = argv.indexOf(flag);
+    if (index !== -1) {
+        const next = argv[index + 1];
+        if (isFlagValue(next))
+            return next;
+    }
+    const prefix = `${flag}=`;
+    const found = argv.find((arg) => arg.startsWith(prefix));
+    if (!found)
+        return undefined;
+    const value = found.slice(prefix.length);
+    return value.length > 0 ? value : undefined;
+}
+function resolveFlags(argv, flag) {
+    const values = [];
+    const prefix = `${flag}=`;
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        if (arg === flag) {
+            const next = argv[index + 1];
+            if (isFlagValue(next)) {
+                values.push(next);
+                index += 1;
+            }
+            continue;
+        }
+        if (arg?.startsWith(prefix)) {
+            const value = arg.slice(prefix.length);
+            if (value.length > 0)
+                values.push(value);
+        }
+    }
+    return values;
+}
+function write(message) {
+    process.stdout.write(message);
+}
+//# sourceMappingURL=dev.js.map