@paybond/kit 0.9.8 → 0.11.0

package/dist/cli/router.js

@@ -0,0 +1,378 @@
+import { commandPath, createContext } from "./context.js";
+import { handleA2a, handleAuditExports, handleMandates, handleReceipts, handleSignal, } from "./commands/discovery.js";
+import { handleConfig, handleDoctor, handleDiagnose, handleInitCompletion, handleInitAgentMiddleware, handleInitGuardrail, handleInitWizard, handleLogin, handleMcpInstall, handleMcpServe, handleMcpTools, handleMcpVerifyConfig, handleVersion, handleWhoami, } from "./commands/setup.js";
+import { handlePolicyExtend, handlePolicyImportMcpReceipt, handlePolicyImportX402Receipt, handlePolicyInit, handlePolicyInitOrg, handlePolicyPresetsList, handlePolicyPresetsShow, handlePolicyPreview, handlePolicyTemplates, handlePolicyValidateEvidence, handlePolicyValidateTools, } from "./commands/policy.js";
+import { handleAgent } from "./commands/agent.js";
+import { handleDev } from "./commands/dev.js";
+import { handleGuardrails, handleIntents, handleKeys, handleSpendAuthorize, } from "./commands/workflows.js";
+import { failureEnvelope, prepareCommandOutput, successEnvelope, writeEnvelope, writeTableLines } from "./envelope.js";
+import { defaultGlobalOptions, parseCliArgv } from "./globals.js";
+import { deprecatedAliasWarning } from "./automation.js";
+import { helpForCommand } from "./help.js";
+import { generateRequestId } from "./request-id.js";
+import { colorize, shouldUseColor } from "./color.js";
+import { formatUnknownCommandMessage } from "./suggest.js";
+import { handleCompletionCommand, handleExamplesCommand, handleHelpCommand, handleOnboarding, } from "./ux.js";
+import { CliError, EXIT_SUCCESS, } from "./types.js";
+function isHelp(argv) {
+    return argv.length === 0 || argv.includes("--help") || argv.includes("-h");
+}
+function renderTable(command, result, globals) {
+    const useColor = shouldUseColor(globals);
+    const lines = [colorize(`${command}: ok`, "green", useColor)];
+    for (const [key, value] of Object.entries(result.data)) {
+        if (value && typeof value === "object" && !Array.isArray(value)) {
+            lines.push(`${key}: ${JSON.stringify(value)}`);
+        }
+        else if (Array.isArray(value)) {
+            lines.push(`${key}: ${value.length} item(s)`);
+        }
+        else {
+            lines.push(`${key}: ${String(value)}`);
+        }
+    }
+    if (result.warnings?.length) {
+        lines.push(colorize(`warnings: ${result.warnings.join("; ")}`, "yellow", useColor));
+    }
+    return lines;
+}
+function toErrorShape(err) {
+    if (err instanceof CliError) {
+        if (err.message === "help") {
+            return {
+                shape: { category: "usage", code: "cli.help", message: "help" },
+                exitCode: EXIT_SUCCESS,
+            };
+        }
+        return {
+            shape: {
+                category: err.category,
+                code: err.code,
+                message: err.message,
+                details: err.details ?? {},
+            },
+            exitCode: err.exitCode,
+        };
+    }
+    return {
+        shape: {
+            category: "internal",
+            code: "cli.internal",
+            message: err instanceof Error ? err.message : String(err),
+            details: {},
+        },
+        exitCode: 1,
+    };
+}
+function outputFormatFromArgv(argv) {
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--format" && argv[i + 1] === "json") {
+            return "json";
+        }
+        if (arg === "--format=json") {
+            return "json";
+        }
+    }
+    return "table";
+}
+function requestIdFromArgv(argv) {
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--request-id" && argv[i + 1]) {
+            return argv[i + 1];
+        }
+        if (arg.startsWith("--request-id=")) {
+            return arg.slice("--request-id=".length);
+        }
+    }
+    return generateRequestId();
+}
+export async function runCli(argv, deps = {}) {
+    const stdout = deps.stdout ?? process.stdout;
+    const stderr = deps.stderr ?? process.stderr;
+    let globals;
+    let command;
+    try {
+        ({ globals, command } = parseCliArgv(argv));
+    }
+    catch (err) {
+        const { shape, exitCode } = toErrorShape(err);
+        if (shape.message === "help") {
+            stdout.write(`${helpForCommand("")}\n`);
+            return EXIT_SUCCESS;
+        }
+        if (outputFormatFromArgv(argv) === "json") {
+            writeEnvelope(stdout, failureEnvelope("paybond", { ...defaultGlobalOptions(), format: "json", requestId: requestIdFromArgv(argv) }, shape));
+        }
+        else {
+            stderr.write(`${shape.message}\n`);
+        }
+        return exitCode;
+    }
+    const ctx = createContext(globals, deps);
+    const aliasWarning = deprecatedAliasWarning(process.argv[1]);
+    if (aliasWarning) {
+        stderr.write(`${aliasWarning}\n`);
+    }
+    const helpPath = command.filter((part) => part !== "--help" && part !== "-h").join(" ");
+    if (isHelp(command)) {
+        const text = helpPath ? helpForCommand(helpPath) : helpForCommand("");
+        ctx.stdout.write(`${text}\n`);
+        return EXIT_SUCCESS;
+    }
+    let canonical = "";
+    let result;
+    try {
+        const [head, second, third] = command;
+        const tail = command.slice(2);
+        if (head === "help") {
+            canonical = "help";
+            result = handleHelpCommand(command.slice(1));
+        }
+        else if (head === "examples") {
+            canonical = "examples";
+            result = handleExamplesCommand(command.slice(1));
+        }
+        else if (head === "completion" && second) {
+            canonical = "completion";
+            result = handleCompletionCommand(command.slice(1));
+        }
+        else if (head === "onboarding") {
+            canonical = "onboarding";
+            result = await handleOnboarding(ctx, command.slice(1));
+        }
+        else if (head === "login") {
+            canonical = "login";
+            result = await handleLogin(ctx, command.slice(1));
+        }
+        else if (head === "init" && second === "guardrail") {
+            canonical = "init guardrail";
+            result = await handleInitGuardrail(ctx, command.slice(2));
+        }
+        else if (head === "init" && second === "agent-middleware") {
+            canonical = "init agent-middleware";
+            result = await handleInitAgentMiddleware(ctx, command.slice(2));
+        }
+        else if (head === "init" && second === "completion") {
+            canonical = "init completion";
+            result = await handleInitCompletion(ctx, command.slice(2));
+        }
+        else if (head === "init") {
+            canonical = "init";
+            result = await handleInitWizard(ctx, command.slice(1));
+        }
+        else if (head === "mcp" && second === "serve") {
+            canonical = "mcp serve";
+            result = await handleMcpServe(ctx, command.slice(2));
+        }
+        else if (head === "mcp" && second === "install") {
+            canonical = "mcp install";
+            result = await handleMcpInstall(ctx, command.slice(2));
+        }
+        else if (head === "mcp" && second === "tools") {
+            canonical = "mcp tools";
+            result = await handleMcpTools(ctx);
+        }
+        else if (head === "mcp" && second === "verify-config") {
+            canonical = "mcp verify-config";
+            result = await handleMcpVerifyConfig(ctx, command.slice(2));
+        }
+        else if (head === "doctor") {
+            canonical = "doctor";
+            result = await handleDoctor(ctx, command.slice(1));
+        }
+        else if (head === "dev" && second) {
+            canonical = commandPath(["dev", second]);
+            result = await handleDev(ctx, second, tail);
+        }
+        else if (head === "version") {
+            canonical = "version";
+            result = await handleVersion(ctx, command.slice(1));
+        }
+        else if (head === "diagnose") {
+            canonical = "diagnose";
+            result = await handleDiagnose(ctx, command.slice(1));
+        }
+        else if (head === "config" && second) {
+            canonical = commandPath(["config", second]);
+            result = await handleConfig(ctx, second, tail);
+        }
+        else if (head === "whoami") {
+            canonical = "whoami";
+            result = await handleWhoami(ctx);
+        }
+        else if (head === "keys" && second) {
+            canonical = commandPath(["keys", second]);
+            result = await handleKeys(ctx, second, tail);
+        }
+        else if (head === "intents" && second) {
+            canonical = commandPath(["intents", second]);
+            result = await handleIntents(ctx, second, tail);
+        }
+        else if (head === "guardrails" && second) {
+            canonical = commandPath(["guardrails", second]);
+            result = await handleGuardrails(ctx, second, tail);
+        }
+        else if (head === "spend" && second === "authorize") {
+            canonical = "spend authorize";
+            result = await handleSpendAuthorize(ctx, tail);
+        }
+        else if (head === "signal" && second) {
+            canonical = commandPath(["signal", second]);
+            result = await handleSignal(ctx, second, tail);
+        }
+        else if (head === "receipts" && second) {
+            canonical = commandPath(["receipts", second]);
+            result = await handleReceipts(ctx, second, tail);
+        }
+        else if (head === "mandates" && second) {
+            canonical = commandPath(["mandates", second]);
+            result = await handleMandates(ctx, second, tail);
+        }
+        else if (head === "a2a" && second) {
+            canonical = commandPath(["a2a", second]);
+            result = await handleA2a(ctx, second, tail);
+        }
+        else if (head === "audit" && second === "exports" && third) {
+            canonical = commandPath(["audit", "exports", third]);
+            result = await handleAuditExports(ctx, third, command.slice(3));
+        }
+        else if (head === "policy" && second === "presets" && third === "list") {
+            canonical = "policy presets list";
+            result = await handlePolicyPresetsList(ctx, command.slice(3));
+        }
+        else if (head === "policy" && second === "presets" && third === "show") {
+            canonical = "policy presets show";
+            result = await handlePolicyPresetsShow(ctx, command.slice(3));
+        }
+        else if (head === "policy" && second === "templates") {
+            canonical = "policy templates";
+            result = await handlePolicyTemplates(ctx, command.slice(2));
+        }
+        else if (head === "policy" && second === "preview") {
+            canonical = "policy preview";
+            result = await handlePolicyPreview(ctx, command.slice(2));
+        }
+        else if (head === "policy" && second === "import-mcp-receipt") {
+            canonical = "policy import-mcp-receipt";
+            result = await handlePolicyImportMcpReceipt(ctx, command.slice(2));
+        }
+        else if (head === "policy" && second === "import-x402-receipt") {
+            canonical = "policy import-x402-receipt";
+            result = await handlePolicyImportX402Receipt(ctx, command.slice(2));
+        }
+        else if (head === "policy" && second === "validate-evidence") {
+            canonical = "policy validate-evidence";
+            result = await handlePolicyValidateEvidence(ctx, command.slice(2));
+        }
+        else if (head === "policy" && second === "init-org") {
+            canonical = "policy init-org";
+            result = await handlePolicyInitOrg(ctx, command.slice(2));
+        }
+        else if (head === "policy" && second === "extend") {
+            canonical = "policy extend";
+            result = await handlePolicyExtend(ctx, command.slice(2));
+        }
+        else if (head === "policy" && second === "init") {
+            canonical = "policy init";
+            result = await handlePolicyInit(ctx, command.slice(2));
+        }
+        else if (head === "policy" && second === "validate-tools") {
+            canonical = "policy validate-tools";
+            result = await handlePolicyValidateTools(ctx, command.slice(2));
+        }
+        else if (head === "agent" && second && third) {
+            canonical = commandPath(["agent", second, third]);
+            result = await handleAgent(ctx, second, third, command.slice(3));
+        }
+        else {
+            throw new CliError(formatUnknownCommandMessage(command.join(" ")), {
+                category: "usage",
+                code: "cli.usage.unknown_command",
+            });
+        }
+        const output = prepareCommandOutput(canonical, globals, result);
+        if (globals.format === "json") {
+            writeEnvelope(ctx.stdout, successEnvelope(canonical, globals, { data: output.data, warnings: output.warnings }));
+        }
+        else if (output.automationPlain) {
+            ctx.stdout.write(`${JSON.stringify(output.data, null, 2)}\n`);
+            if (output.warnings.length) {
+                for (const warning of output.warnings) {
+                    ctx.stderr.write(`${warning}\n`);
+                }
+            }
+        }
+        else if (canonical === "help" || canonical === "examples") {
+            ctx.stdout.write(`${String(result.data.text ?? "")}\n`);
+        }
+        else if (canonical === "completion") {
+            ctx.stdout.write(String(result.data.script ?? ""));
+        }
+        else if (canonical === "version" && !("package_name" in result.data)) {
+            ctx.stdout.write(`${String(result.data.version ?? "")}\n`);
+        }
+        else if (canonical === "diagnose") {
+            const lines = Array.isArray(result.data.lines) ? result.data.lines : [];
+            for (const line of lines) {
+                ctx.stdout.write(`${line}\n`);
+            }
+        }
+        else if (canonical === "agent sandbox smoke" && Array.isArray(result.data.checklist_lines)) {
+            writeTableLines(ctx.stdout, result.data.checklist_lines);
+            if (output.warnings.length) {
+                for (const warning of output.warnings) {
+                    ctx.stderr.write(`${warning}\n`);
+                }
+            }
+        }
+        else if ((canonical === "dev smoke" || canonical === "dev loop") &&
+            Array.isArray(result.data.checklist_lines)) {
+            if (canonical === "dev loop" && Array.isArray(result.data.banner_lines)) {
+                writeTableLines(ctx.stdout, result.data.banner_lines);
+            }
+            writeTableLines(ctx.stdout, result.data.checklist_lines);
+            if (output.warnings.length) {
+                for (const warning of output.warnings) {
+                    ctx.stderr.write(`${warning}\n`);
+                }
+            }
+        }
+        else if (canonical === "agent run trace" && Array.isArray(result.data.trace_lines)) {
+            writeTableLines(ctx.stdout, result.data.trace_lines);
+            if (output.warnings.length) {
+                for (const warning of output.warnings) {
+                    ctx.stderr.write(`${warning}\n`);
+                }
+            }
+        }
+        else if (canonical === "policy presets show" && Array.isArray(result.data.yaml_lines)) {
+            writeTableLines(ctx.stdout, result.data.yaml_lines);
+            if (output.warnings.length) {
+                for (const warning of output.warnings) {
+                    ctx.stderr.write(`${warning}\n`);
+                }
+            }
+        }
+        else if (canonical !== "login" && canonical !== "mcp serve" && canonical !== "dev trace") {
+            writeTableLines(ctx.stdout, renderTable(canonical, result, globals));
+        }
+        return EXIT_SUCCESS;
+    }
+    catch (err) {
+        const { shape, exitCode } = toErrorShape(err);
+        if (shape.message === "help") {
+            const text = helpPath ? helpForCommand(helpPath) : helpForCommand("");
+            ctx.stdout.write(`${text}\n`);
+            return EXIT_SUCCESS;
+        }
+        if (globals.format === "json") {
+            writeEnvelope(ctx.stdout, failureEnvelope(canonical || helpPath || "paybond", globals, shape));
+        }
+        else {
+            ctx.stderr.write(`${shape.message}\n`);
+        }
+        return exitCode;
+    }
+}

package/dist/cli/smoke-deep-links.d.ts

@@ -0,0 +1,15 @@
+import type { GlobalOptions } from "./types.js";
+/** Deep links returned by `paybond agent sandbox smoke` for local trace and hosted replay. */
+export type AgentSandboxSmokeDeepLinks = Readonly<{
+    trace_url: string;
+    console_url?: string;
+    agent_trace_url?: string;
+}>;
+/**
+ * Builds trace, console dossier, and hosted agent-trace replay URLs for sandbox smoke JSON.
+ */
+export declare function buildAgentSandboxSmokeDeepLinks(input: {
+    bind: Record<string, unknown>;
+}): AgentSandboxSmokeDeepLinks;
+/** Inserts trace/console/replay checklist lines before the trailing Success row. */
+export declare function appendSmokeDeepLinkChecklistLines(checklistLines: ReadonlyArray<string>, deepLinks: AgentSandboxSmokeDeepLinks, globals: GlobalOptions): string[];

package/dist/cli/smoke-deep-links.js

@@ -0,0 +1,63 @@
+import { devTraceUrl } from "../dev/trace-buffer.js";
+import { colorize, shouldUseColor } from "./color.js";
+const HARBOR_INTENT_UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const DEFAULT_LOCAL_PUBLIC_ORIGIN = "http://127.0.0.1:3000";
+function stripTrailingSlashes(value) {
+    return value.replace(/\/+$/, "");
+}
+function resolvePublicOrigin() {
+    const configured = process.env.PAYBOND_PUBLIC_BASE_URL?.trim() ||
+        process.env.PAYBOND_CONSOLE_BASE_URL?.trim();
+    return stripTrailingSlashes(configured && configured.length > 0 ? configured : DEFAULT_LOCAL_PUBLIC_ORIGIN);
+}
+function resolveConsoleOrigin() {
+    const configured = process.env.PAYBOND_CONSOLE_BASE_URL?.trim() ||
+        process.env.PAYBOND_PUBLIC_BASE_URL?.trim();
+    return stripTrailingSlashes(configured && configured.length > 0 ? configured : DEFAULT_LOCAL_PUBLIC_ORIGIN);
+}
+function harborIntentId(bind) {
+    const raw = bind.intent_id;
+    if (typeof raw !== "string") {
+        return undefined;
+    }
+    const trimmed = raw.trim();
+    return HARBOR_INTENT_UUID.test(trimmed) ? trimmed : undefined;
+}
+/**
+ * Builds trace, console dossier, and hosted agent-trace replay URLs for sandbox smoke JSON.
+ */
+export function buildAgentSandboxSmokeDeepLinks(input) {
+    const runId = String(input.bind.run_id ?? "smoke-1");
+    const links = {
+        trace_url: devTraceUrl(undefined, runId),
+    };
+    const intentId = harborIntentId(input.bind);
+    if (!intentId) {
+        return links;
+    }
+    const consoleOrigin = resolveConsoleOrigin();
+    const publicOrigin = resolvePublicOrigin();
+    return {
+        ...links,
+        console_url: `${consoleOrigin}/console/operations/intents/${encodeURIComponent(intentId)}`,
+        agent_trace_url: `${publicOrigin}/demo/agent-trace?intent=${encodeURIComponent(intentId)}`,
+    };
+}
+/** Inserts trace/console/replay checklist lines before the trailing Success row. */
+export function appendSmokeDeepLinkChecklistLines(checklistLines, deepLinks, globals) {
+    const useColor = shouldUseColor(globals);
+    const mark = (line) => colorize(line, "green", useColor);
+    const linkLines = [
+        mark(`✓ Trace → ${deepLinks.trace_url}`),
+        ...(deepLinks.console_url ? [mark(`✓ Console → ${deepLinks.console_url}`)] : []),
+        ...(deepLinks.agent_trace_url ? [mark(`✓ Replay → ${deepLinks.agent_trace_url}`)] : []),
+    ];
+    if (checklistLines.length === 0) {
+        return linkLines;
+    }
+    const last = checklistLines.at(-1);
+    if (last === "Success" || last === mark("Success")) {
+        return [...checklistLines.slice(0, -1), ...linkLines, last];
+    }
+    return [...checklistLines, ...linkLines];
+}

package/dist/cli/suggest.d.ts

@@ -0,0 +1,4 @@
+export declare function suggestCommandPath(input: string): string | undefined;
+export declare function suggestGlobalFlag(input: string): string | undefined;
+export declare function formatUnknownCommandMessage(input: string): string;
+export declare function formatUnknownGlobalFlagMessage(flag: string): string;

package/dist/cli/suggest.js

@@ -0,0 +1,58 @@
+import { COMMAND_PATHS, GLOBAL_FLAG_NAMES } from "./command-spec.js";
+function levenshtein(a, b) {
+    const rows = a.length + 1;
+    const cols = b.length + 1;
+    const matrix = Array.from({ length: rows }, () => Array(cols).fill(0));
+    for (let i = 0; i < rows; i += 1) {
+        matrix[i][0] = i;
+    }
+    for (let j = 0; j < cols; j += 1) {
+        matrix[0][j] = j;
+    }
+    for (let i = 1; i < rows; i += 1) {
+        for (let j = 1; j < cols; j += 1) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            matrix[i][j] = Math.min(matrix[i - 1][j] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j - 1] + cost);
+        }
+    }
+    return matrix[a.length][b.length];
+}
+function bestSuggestion(input, candidates) {
+    const needle = input.trim().toLowerCase();
+    if (!needle) {
+        return undefined;
+    }
+    let best;
+    for (const candidate of candidates) {
+        const distance = levenshtein(needle, candidate.toLowerCase());
+        const threshold = Math.max(2, Math.floor(candidate.length / 3));
+        if (distance > threshold) {
+            continue;
+        }
+        if (!best || distance < best.distance) {
+            best = { value: candidate, distance };
+        }
+    }
+    return best?.value;
+}
+export function suggestCommandPath(input) {
+    return bestSuggestion(input, COMMAND_PATHS);
+}
+export function suggestGlobalFlag(input) {
+    const normalized = input.split("=")[0] ?? input;
+    return bestSuggestion(normalized, GLOBAL_FLAG_NAMES);
+}
+export function formatUnknownCommandMessage(input) {
+    const suggestion = suggestCommandPath(input);
+    if (suggestion) {
+        return `unknown command: ${input} (did you mean "${suggestion}"?)`;
+    }
+    return `unknown command: ${input}`;
+}
+export function formatUnknownGlobalFlagMessage(flag) {
+    const suggestion = suggestGlobalFlag(flag);
+    if (suggestion) {
+        return `unknown global flag: ${flag} (did you mean ${suggestion}?)`;
+    }
+    return `unknown global flag: ${flag}`;
+}

package/dist/cli/support-diagnostics.d.ts

@@ -0,0 +1,19 @@
+import { describeCredentialSource } from "./credentials.js";
+import type { CliContext } from "./context.js";
+export type SupportDiagnostics = {
+    package_name: string;
+    package_version: string;
+    runtime: string;
+    platform: {
+        os: string;
+        arch: string;
+    };
+    config_path: string;
+    env_file_path: string;
+    gateway_url: string;
+    request_id: string;
+    mcp_tool_count: number;
+    credential_source: Awaited<ReturnType<typeof describeCredentialSource>>;
+};
+export declare function buildSupportDiagnostics(ctx: CliContext): Promise<SupportDiagnostics>;
+export declare function formatSupportDiagnosticsTable(diagnostics: SupportDiagnostics): string[];

package/dist/cli/support-diagnostics.js

@@ -0,0 +1,47 @@
+import path from "node:path";
+import { configFilePath } from "./config.js";
+import { describeCredentialSource } from "./credentials.js";
+import { packageVersion } from "./doctor-agent.js";
+import { PaybondMCPServer } from "../mcp-server.js";
+function resolvedEnvFilePath(ctx) {
+    const envFile = ctx.globals.envFile;
+    return path.isAbsolute(envFile) ? path.resolve(envFile) : path.resolve(ctx.cwd, envFile);
+}
+export async function buildSupportDiagnostics(ctx) {
+    const server = new PaybondMCPServer({
+        gatewayBaseUrl: ctx.globals.gateway,
+        apiKey: "paybond_sk_sandbox_redacted_redacted_aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+    });
+    return {
+        package_name: "@paybond/kit",
+        package_version: packageVersion(),
+        runtime: `node ${process.version}`,
+        platform: {
+            os: process.platform,
+            arch: process.arch,
+        },
+        config_path: configFilePath(),
+        env_file_path: resolvedEnvFilePath(ctx),
+        gateway_url: ctx.globals.gateway,
+        request_id: ctx.globals.requestId,
+        mcp_tool_count: server.listTools().length,
+        credential_source: await describeCredentialSource(ctx.globals, ctx.cwd),
+    };
+}
+export function formatSupportDiagnosticsTable(diagnostics) {
+    const lines = [
+        `package: ${diagnostics.package_name} ${diagnostics.package_version}`,
+        `runtime: ${diagnostics.runtime}`,
+        `platform: ${diagnostics.platform.os} ${diagnostics.platform.arch}`,
+        `config_path: ${diagnostics.config_path}`,
+        `env_file_path: ${diagnostics.env_file_path}`,
+        `gateway_url: ${diagnostics.gateway_url}`,
+        `request_id: ${diagnostics.request_id}`,
+        `mcp_tool_count: ${diagnostics.mcp_tool_count}`,
+        `credential_source: ${JSON.stringify(diagnostics.credential_source)}`,
+    ];
+    if (diagnostics.credential_source.profile) {
+        lines.push(`profile: ${diagnostics.credential_source.profile}`);
+    }
+    return lines;
+}

package/dist/cli/telemetry.d.ts

@@ -0,0 +1,17 @@
+import type { CliContext } from "./context.js";
+export type CliTelemetryCommand = "dev loop" | "dev smoke";
+export declare function hashCliInstallId(installId: string): string;
+export declare function resolveCliInstallId(): Promise<string>;
+export declare function cliTelemetryEnabled(gateway: string): Promise<boolean>;
+/**
+ * Fire-and-forget adoption telemetry for successful local dev commands.
+ * Failures are swallowed so CLI workflows never depend on analytics.
+ */
+export declare function reportCliCommandSuccess(ctx: CliContext, input: Readonly<{
+    commandPath: CliTelemetryCommand;
+    offline: boolean;
+}>): Promise<void>;
+export declare function scheduleCliCommandTelemetry(ctx: CliContext, input: Readonly<{
+    commandPath: CliTelemetryCommand;
+    offline: boolean;
+}>): void;