argsbarg 6.1.2 → 6.1.4

package/src/http/server.ts

@@ -0,0 +1,225 @@
+/*
+HTTP tool server for ArgsBarg programs: health, OpenAPI, and REST API invocation.
+*/
+
+import { randomUUID } from "node:crypto";
+import type { CliHttpWireContext, CliProgram } from "~/core/types.ts";
+import {
+  executeHttpRouteCall,
+  headlessFailureToHttpResponse,
+  headlessSuccessToHttpResponse,
+} from "~/headless/tool-call.ts";
+import type { Cli } from "~/runtime/cli.ts";
+import { leafHttpResponseDefaults } from "~/runtime/exposure.ts";
+import type { ResolvedHttpServeConfig } from "~/server/overrides.ts";
+import { generateOpenApi } from "./openapi.ts";
+import { evaluateReadiness } from "./readiness.ts";
+import { API_CORS_HEADERS, apiDocsHtml, apiErrorResponse, apiOptionsResponse } from "./result.ts";
+import { defaultSuccessStatus, matchHttpRoute } from "./routes.ts";
+
+const DEFAULT_HOST = "127.0.0.1";
+const DEFAULT_PORT = 3000;
+
+/** Resolved listen address for the HTTP API server. */
+export function resolveHttpListenAddress(program: CliProgram): { hostname: string; port: number } {
+  const config = program.httpServer;
+  return {
+    hostname: config?.host ?? DEFAULT_HOST,
+    port: config?.port ?? DEFAULT_PORT,
+  };
+}
+
+/** Resolves client IP, optionally honoring X-Forwarded-For. */
+export function resolveClientIp(request: Request, trustProxy: boolean): string {
+  if (trustProxy) {
+    const xff = request.headers.get("x-forwarded-for");
+    if (xff) {
+      return xff.split(",")[0]?.trim() ?? "unknown";
+    }
+  }
+  return "unknown";
+}
+
+/** Writes a JSON HTTP response with CORS headers. */
+function jsonResponse(status: number, body: unknown): Response {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: {
+      ...API_CORS_HEADERS,
+      "content-type": "application/json; charset=utf-8",
+    },
+  });
+}
+
+function parseQuery(url: URL): Record<string, string> {
+  const out: Record<string, string> = {};
+  for (const [k, v] of url.searchParams.entries()) {
+    out[k] = v;
+  }
+  return out;
+}
+
+/** Handles one HTTP request for the API server. */
+export async function handleApiRequest(
+  cli: Cli,
+  request: Request,
+  resolved?: ResolvedHttpServeConfig,
+): Promise<Response> {
+  const httpConfig = resolved ?? cli.server?.http;
+  const trustProxy = httpConfig?.trustProxy ?? cli.program.httpServer?.trustProxy ?? false;
+  const requestId = randomUUID();
+  const url = new URL(request.url);
+  const clientIp = resolveClientIp(request, trustProxy);
+  const wireCtx: CliHttpWireContext = {
+    request,
+    requestId,
+    clientIp,
+    path: url.pathname,
+    method: request.method,
+  };
+  const hooks = cli.server?.httpHooks ?? cli.program.httpServer?.hooks;
+  const emitter = cli.server?.emitter;
+  const started = performance.now();
+
+  const finish = async (response: Response, failureKind?: string, error?: unknown): Promise<Response> => {
+    const durationMs = Math.round(performance.now() - started);
+    if (failureKind && error !== undefined) {
+      await hooks?.onError?.({
+        ...wireCtx,
+        failureKind: failureKind as import("~/core/types.ts").InvokeFailureKind,
+        error,
+      });
+    } else {
+      await hooks?.onResponse?.({ ...wireCtx, status: response.status, durationMs });
+    }
+    emitter?.emitAccess({
+      method: request.method,
+      path: url.pathname,
+      status: response.status,
+      durationMs,
+      requestId,
+      clientIp,
+    });
+    return response;
+  };
+
+  await hooks?.onRequest?.(wireCtx);
+
+  if (request.method === "OPTIONS") {
+    return finish(apiOptionsResponse());
+  }
+
+  const root = cli.program;
+  const path = url.pathname;
+
+  if (request.method === "GET" && (path === "/health" || path === "/health/live")) {
+    return finish(jsonResponse(200, { ok: true }));
+  }
+
+  if (request.method === "GET" && path === "/health/ready") {
+    const runtime = cli.server?.runtime;
+    if (!runtime) {
+      return finish(jsonResponse(200, { ok: true }));
+    }
+    const readiness = await evaluateReadiness(root, "http", runtime, cli.appConfig);
+    return finish(jsonResponse(readiness.ok ? 200 : 503, readiness));
+  }
+
+  if (request.method === "GET" && path === "/openapi.json") {
+    return finish(jsonResponse(200, generateOpenApi(root)));
+  }
+
+  if (request.method === "GET" && path === "/swagger") {
+    return finish(
+      new Response(apiDocsHtml(), {
+        status: 200,
+        headers: {
+          ...API_CORS_HEADERS,
+          "content-type": "text/html; charset=utf-8",
+        },
+      }),
+    );
+  }
+
+  if (path.startsWith("/api")) {
+    const match = matchHttpRoute(root, request.method, path);
+    if (!match.ok) {
+      return finish(apiErrorResponse(404, { error: "Not found" }));
+    }
+
+    let body: Record<string, unknown> = {};
+    if (request.method === "POST" || request.method === "PUT" || request.method === "PATCH") {
+      const rawBody = await request.text();
+      if (rawBody.trim().length > 0) {
+        try {
+          const parsed = JSON.parse(rawBody);
+          if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+            return finish(apiErrorResponse(400, { error: "Request body must be a JSON object" }));
+          }
+          body = parsed as Record<string, unknown>;
+        } catch {
+          return finish(apiErrorResponse(400, { error: "Invalid JSON body" }));
+        }
+      }
+    }
+
+    const query = parseQuery(url);
+    const result = await executeHttpRouteCall(cli, match.route, match.pathParams, query, body, {
+      request,
+      clientIp,
+      requestId,
+    });
+    if (result.ok) {
+      const leafHttp = leafHttpResponseDefaults(match.route.leaf);
+      const hasBody = result.response.body !== undefined;
+      const methodDefault =
+        match.route.leaf.http?.successStatus ??
+        defaultSuccessStatus(match.route.method, hasBody && match.route.method !== "DELETE");
+      return finish(headlessSuccessToHttpResponse(result, leafHttp, methodDefault));
+    }
+    const obscure = httpConfig?.obscureUnexpected ?? false;
+    return finish(headlessFailureToHttpResponse(result, obscure), result.invokeResult?.failureKind, result.message);
+  }
+
+  if (path.startsWith("/tools")) {
+    return finish(apiErrorResponse(404, { error: "Not found" }));
+  }
+
+  return finish(apiErrorResponse(404, { error: "Not found" }));
+}
+
+/** Runs the HTTP API server until the process is interrupted. */
+export async function httpServeHttp(cli: Cli, resolved?: ResolvedHttpServeConfig): Promise<never> {
+  const listen = resolved ?? {
+    hostname: resolveHttpListenAddress(cli.program).hostname,
+    port: resolveHttpListenAddress(cli.program).port,
+    trustProxy: cli.program.httpServer?.trustProxy ?? false,
+    obscureUnexpected: cli.program.httpServer?.errors?.obscureUnexpected ?? false,
+    log: { format: "json" as const, access: true, errors: true, dev: false },
+  };
+  const server = Bun.serve({
+    hostname: listen.hostname,
+    port: listen.port,
+    fetch: (request) => handleApiRequest(cli, request, listen),
+  });
+  const url = `http://${server.hostname}:${server.port}`;
+  const emitter = cli.server?.emitter;
+  if (emitter && listen.log.format === "text") {
+    emitter.emitLifecycle(
+      `${cli.program.key} ${cli.program.version} — HTTP API listening on ${url}`,
+      "http.server.start",
+    );
+  } else {
+    emitter?.emit({
+      level: "info",
+      message: `HTTP API listening on ${url}`,
+      action: "http.server.start",
+      labels: { url },
+    });
+    if (!emitter) {
+      process.stderr.write(`HTTP API listening on ${url}\n`);
+    }
+  }
+  await new Promise<never>(() => {});
+  throw new Error("HTTP API server stopped unexpectedly");
+}

package/src/index.ts

@@ -7,40 +7,21 @@ It gives consumers one stable import path without forcing them to know the inter
 module layout.
 */
 
-export { generateOpenApi, openApiJson } from "./api/openapi.ts";
-export { Cli, type CliInvokeKind, type CliInvokeResult } from "./cli.ts";
-export { cliErrWithHelp } from "./cli-errors.ts";
 export { displayAppConfigPath, resolveAppConfigPath } from "./config/file.ts";
-export type { CliLeafInputs } from "./context.ts";
-export { CliContext } from "./context.ts";
+export type { CliLeafInputs } from "./core/context.ts";
+export { CliContext } from "./core/context.ts";
 export {
   parseCommaList,
   parseDate,
   parseDateTime,
   parseDurationMs,
-} from "./formats.ts";
-export type { HeadlessContext } from "./headless.ts";
-export {
-  formatDryRunMessage,
-  requireYesInNonTty,
-  shouldRunHeadless,
-  shouldRunHeadlessWithPositionals,
-  shouldRunHeadlessWithYes,
-  wantsExplicitJson,
-} from "./headless.ts";
+} from "./core/formats.ts";
 export {
   LeafInputError,
-  loadLeafInputs,
   preloadPipableJson,
   readJsonOptionValue,
-  readLeafInputs,
-  readLeafInputsAsync,
-} from "./leaf-inputs.ts";
-export type { McpBundlePaths, PackMcpBundleOpts } from "./mcp/bundle.ts";
-export { defaultMcpBundlePaths, generateMcpManifest, packMcpBundle } from "./mcp/bundle.ts";
+} from "./core/leaf-inputs.ts";
 export type {
-  CliApiResponseConfig,
-  CliApiServerConfig,
   CliAppConfig,
   CliAppConfigEntry,
   CliAppConfigResolveContext,
@@ -49,27 +30,57 @@ export type {
   CliConfigureTargets,
   CliDocsConfig,
   CliDocsTopic,
+  ClientErrorOverride,
   CliHandler,
+  CliHttpServerConfig,
+  CliHttpWireContext,
+  CliHttpWireHooks,
   CliInvocation,
+  CliInvokeHookResult,
   CliLeafKind,
+  CliLocals,
+  CliLogConfig,
   CliMcpBundleConfig,
   CliMcpResource,
   CliMcpServerConfig,
   CliMcpToolConfig,
+  CliMcpWireContext,
+  CliMcpWireHooks,
   CliOption,
   CliPositional,
   CliProgram,
+  CliProgramHooks,
   CliRespondBody,
   CliRespondOptions,
+  ErrorHookContext,
   InstallAgentIntegration,
   InstallTargetSpec,
+  InvokeFailureKind,
+  InvokeHookContext,
+  ReadinessContext,
   ResolvedInstallTarget,
-} from "./types.ts";
+  ServerRuntime,
+  ServerState,
+} from "./core/types.ts";
 export {
   CliFallbackMode,
   CliOptionKind,
   CliSchemaValidationError,
   CliValueFormat,
   isJsonLeaf,
-} from "./types.ts";
+} from "./core/types.ts";
+export type { HeadlessContext } from "./headless/routing.ts";
+export {
+  formatDryRunMessage,
+  requireYesInNonTty,
+  shouldRunHeadless,
+  shouldRunHeadlessWithPositionals,
+  shouldRunHeadlessWithYes,
+  wantsExplicitJson,
+} from "./headless/routing.ts";
+export { generateOpenApi, openApiJson } from "./http/openapi.ts";
+export type { McpBundlePaths, PackMcpBundleOpts } from "./mcp/bundle.ts";
+export { defaultMcpBundlePaths, generateMcpManifest, packMcpBundle } from "./mcp/bundle.ts";
+export { Cli, type CliInvokeKind, type CliInvokeResult } from "./runtime/cli.ts";
+export { cliErrWithHelp } from "./runtime/cli-errors.ts";
 export { isInteractiveTty } from "./utils.ts";

package/src/log/ecs.test.ts

@@ -0,0 +1,43 @@
+/*
+Unit tests for ECS log line formatting.
+*/
+
+import { describe, expect, test } from "bun:test";
+import { formatEcsLine } from "./ecs.ts";
+
+describe("formatEcsLine", () => {
+  test("includes service fields and event action", () => {
+    const line = formatEcsLine(
+      { name: "myapp", version: "7.0.0" },
+      {
+        level: "info",
+        message: "HTTP API listening",
+        action: "http.server.start",
+      },
+    );
+    const parsed = JSON.parse(line) as Record<string, unknown>;
+    expect(parsed["service.name"]).toBe("myapp");
+    expect(parsed["service.version"]).toBe("7.0.0");
+    expect(parsed["event.action"]).toBe("http.server.start");
+    expect(parsed.message).toBe("HTTP API listening");
+    expect(parsed["log.level"]).toBe("info");
+    expect(typeof parsed["@timestamp"]).toBe("string");
+  });
+
+  test("includes error stack fields", () => {
+    const err = new Error("boom");
+    const line = formatEcsLine(
+      { name: "app", version: "1.0.0" },
+      {
+        level: "error",
+        message: "invoke failed",
+        action: "invoke.error",
+        error: err,
+      },
+    );
+    const parsed = JSON.parse(line) as Record<string, unknown>;
+    expect(parsed["error.message"]).toBe("boom");
+    expect(parsed["error.type"]).toBe("Error");
+    expect(String(parsed["error.stack_trace"])).toContain("boom");
+  });
+});

package/src/log/ecs.ts

@@ -0,0 +1,59 @@
+/*
+Elastic Common Schema (ECS) JSON log line formatting for framework observability.
+*/
+
+/** Severity label for ECS `log.level`. */
+export type EcsLogLevel = "debug" | "info" | "warn" | "error";
+
+/** Fields merged into every ECS log line. */
+export interface EcsServiceFields {
+  name: string;
+  version: string;
+}
+
+/** Input for one ECS log event. */
+export interface EcsLogEvent {
+  level: EcsLogLevel;
+  message: string;
+  action?: string;
+  labels?: Record<string, string | number | boolean>;
+  error?: unknown;
+  fields?: Record<string, unknown>;
+}
+
+function errorFields(error: unknown): Record<string, unknown> {
+  if (error instanceof Error) {
+    return {
+      "error.message": error.message,
+      "error.type": error.name,
+      ...(error.stack ? { "error.stack_trace": error.stack } : {}),
+    };
+  }
+  return { "error.message": String(error) };
+}
+
+/** Formats one ECS-compatible JSON log line (newline omitted). */
+export function formatEcsLine(service: EcsServiceFields, event: EcsLogEvent): string {
+  const line: Record<string, unknown> = {
+    "@timestamp": new Date().toISOString(),
+    "log.level": event.level,
+    message: event.message,
+    "service.name": service.name,
+    "service.version": service.version,
+  };
+  if (event.action) {
+    line["event.action"] = event.action;
+  }
+  if (event.labels) {
+    for (const [key, value] of Object.entries(event.labels)) {
+      line[`labels.${key}`] = value;
+    }
+  }
+  if (event.fields) {
+    Object.assign(line, event.fields);
+  }
+  if (event.error !== undefined) {
+    Object.assign(line, errorFields(event.error));
+  }
+  return JSON.stringify(line);
+}

package/src/log/emitter.ts

@@ -0,0 +1,166 @@
+/*
+Framework log emitter: ECS json or human text to stderr with optional file tee.
+*/
+
+import { appendFileSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import type { CliProgram } from "~/core/types.ts";
+import { type EcsLogEvent, type EcsLogLevel, formatEcsLine } from "./ecs.ts";
+
+/** Resolved logging options for a server or invoke session. */
+export interface ResolvedLogConfig {
+  format: "json" | "text";
+  file?: string;
+  access: boolean;
+  errors: boolean;
+  dev: boolean;
+}
+
+/** Options for {@link LogEmitter}. */
+export interface LogEmitterOpts {
+  program: CliProgram;
+  resolved: ResolvedLogConfig;
+}
+
+const OBSCURE_CLIENT_MESSAGE = "An unexpected error occurred.";
+
+/** Fixed client message when `obscureUnexpected` hides internal failures. */
+export function obscureUnexpectedClientMessage(): string {
+  return OBSCURE_CLIENT_MESSAGE;
+}
+
+/** Merges program defaults with CLI flag / serve overrides. */
+export function resolveLogConfig(program: CliProgram, overrides: Partial<ResolvedLogConfig> = {}): ResolvedLogConfig {
+  const log = program.log;
+  return {
+    format: overrides.format ?? log?.format ?? "json",
+    file: overrides.file ?? log?.file,
+    access: overrides.access ?? log?.access ?? true,
+    errors: overrides.errors ?? log?.errors ?? true,
+    dev: overrides.dev ?? false,
+  };
+}
+
+/** Tee framework logs to stderr and an optional append-only file. */
+export class LogEmitter {
+  private readonly service: { name: string; version: string };
+  private readonly resolved: ResolvedLogConfig;
+
+  constructor(opts: LogEmitterOpts) {
+    this.service = { name: opts.program.key, version: opts.program.version };
+    this.resolved = opts.resolved;
+  }
+
+  get config(): ResolvedLogConfig {
+    return this.resolved;
+  }
+
+  /** Emits one log event to stderr (and optional file). */
+  emit(event: EcsLogEvent): void {
+    const line = this.formatLine(event);
+    process.stderr.write(`${line}\n`);
+    this.appendFile(line);
+  }
+
+  /** Human startup line or ECS/json event for lifecycle milestones. */
+  emitLifecycle(message: string, action: string, labels?: Record<string, string | number | boolean>): void {
+    if (this.resolved.format === "text") {
+      process.stderr.write(`${message}\n`);
+      this.appendFile(message);
+      return;
+    }
+    this.emit({ level: "info", message, action, labels });
+  }
+
+  /** Access log for one HTTP request or MCP RPC. */
+  emitAccess(fields: {
+    method: string;
+    path: string;
+    status: number;
+    durationMs: number;
+    requestId?: string;
+    clientIp?: string;
+  }): void {
+    if (!this.resolved.access) {
+      return;
+    }
+    if (this.resolved.format === "text") {
+      const rid = fields.requestId ? ` ${fields.requestId}` : "";
+      const line = `${fields.method} ${fields.path} ${fields.status} ${fields.durationMs}ms${rid}`;
+      process.stderr.write(`${line}\n`);
+      this.appendFile(line);
+      return;
+    }
+    this.emit({
+      level: "info",
+      message: `${fields.method} ${fields.path}`,
+      action: "http.access",
+      labels: {
+        ...(fields.requestId ? { request_id: fields.requestId } : {}),
+        ...(fields.clientIp ? { client_ip: fields.clientIp } : {}),
+        http_method: fields.method,
+        http_path: fields.path,
+        http_status: fields.status,
+        duration_ms: fields.durationMs,
+      },
+    });
+  }
+
+  /** Error log after the hook pipeline (real stack always included). */
+  emitInvokeError(
+    failureKind: string,
+    error: unknown,
+    clientMessage: string,
+    labels?: Record<string, string | number | boolean>,
+  ): void {
+    if (!this.resolved.errors) {
+      return;
+    }
+    this.emit({
+      level: failureKind === "unexpected" ? "error" : "warn",
+      message: clientMessage,
+      action: "invoke.error",
+      labels: { failure_kind: failureKind, ...labels },
+      error,
+    });
+    if (this.resolved.dev && error instanceof Error && error.stack) {
+      process.stderr.write(`${error.stack}\n`);
+      this.appendFile(error.stack);
+    }
+  }
+
+  private formatLine(event: EcsLogEvent): string {
+    if (this.resolved.format === "text") {
+      return this.formatTextLine(event);
+    }
+    return formatEcsLine(this.service, event);
+  }
+
+  private formatTextLine(event: EcsLogEvent): string {
+    const level = event.level.toUpperCase();
+    const action = event.action ? ` [${event.action}]` : "";
+    let line = `${level}${action}: ${event.message}`;
+    if (event.error instanceof Error && event.error.stack) {
+      line = `${line}\n${event.error.stack}`;
+    }
+    return line;
+  }
+
+  private appendFile(line: string): void {
+    const file = this.resolved.file;
+    if (!file) {
+      return;
+    }
+    try {
+      mkdirSync(dirname(file), { recursive: true });
+      appendFileSync(file, `${line}\n`, "utf8");
+    } catch {
+      // Best-effort file tee; stderr already has the line.
+    }
+  }
+}
+
+/** Maps ECS level strings for quick call sites. */
+export function ecsLevel(level: EcsLogLevel): EcsLogLevel {
+  return level;
+}

package/src/mcp/bundle.ts

@@ -6,8 +6,8 @@ Expects `dist/<program.key>` as the compiled binary input.
 import { cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { basename, join, resolve } from "node:path";
-import { buildProgramUserConfig } from "../config/manifest.ts";
-import type { CliMcpBundleConfig, CliProgram } from "../types.ts";
+import { buildProgramUserConfig } from "~/config/manifest.ts";
+import type { CliMcpBundleConfig, CliProgram } from "~/core/types.ts";
 import { packClaudePlugin } from "./claude.ts";
 import { collectMcpTools, mcpServerId } from "./tools.ts";
 import { zipStore } from "./zip.ts";

package/src/mcp/claude.test.ts

@@ -7,7 +7,7 @@ import { execSync } from "node:child_process";
 import { mkdirSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import type { CliProgram } from "../types.ts";
+import type { CliProgram } from "~/core/types.ts";
 import {
   defaultClaudePluginPaths,
   generatePluginManifest,

package/src/mcp/claude.ts

@@ -17,10 +17,10 @@ import {
 } from "node:fs";
 import { tmpdir } from "node:os";
 import { basename, join, relative, resolve } from "node:path";
-import { buildPluginMcpEnvMapping, buildProgramUserConfig } from "../config/manifest.ts";
-import { generatePluginSkillBundle } from "../skill/generate.ts";
-import { applyPluginSkillHint } from "../skill/hint.ts";
-import type { CliMcpBundleConfig, CliProgram } from "../types.ts";
+import { buildPluginMcpEnvMapping, buildProgramUserConfig } from "~/config/manifest.ts";
+import type { CliMcpBundleConfig, CliProgram } from "~/core/types.ts";
+import { generatePluginSkillBundle } from "~/skill/generate.ts";
+import { applyPluginSkillHint } from "~/skill/hint.ts";
 import { defaultMcpBundlePaths, type PackMcpBundleOpts } from "./bundle.ts";
 import { mcpServerId } from "./tools.ts";
 import { type ZipFileEntry, zipStore } from "./zip.ts";

package/src/{hidden-mcpb.test.ts → mcp/hidden-mcpb.test.ts}

@@ -6,13 +6,13 @@ import { describe, expect, test } from "bun:test";
 import { mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { exportPresentationBuiltins } from "./builtins/export.ts";
-import { cliParseRoot, cliPresentationRoot } from "./builtins/presentation.ts";
-import { cliHelpRender } from "./help.ts";
-import { defaultMcpBundlePaths, generateMcpManifest, packMcpBundle, runMcpBundle } from "./mcp/bundle.ts";
-import { collectMcpTools } from "./mcp/tools.ts";
-import { cliSchemaExport } from "./schema.ts";
-import { CliOptionKind, type CliProgram } from "./types.ts";
+import { exportPresentationBuiltins } from "~/builtins/export.ts";
+import { cliParseRoot, cliPresentationRoot } from "~/builtins/presentation.ts";
+import { cliSchemaExport } from "~/core/schema.ts";
+import { CliOptionKind, type CliProgram } from "~/core/types.ts";
+import { cliHelpRender } from "~/help.ts";
+import { defaultMcpBundlePaths, generateMcpManifest, packMcpBundle, runMcpBundle } from "./bundle.ts";
+import { collectMcpTools } from "./tools.ts";
 
 const hiddenFixture: CliProgram = {
   key: "myapp",
@@ -27,7 +27,8 @@ const hiddenFixture: CliProgram = {
     },
     {
       key: "secret",
-      hidden: true,
+      cli: { hidden: true },
+      mcpTool: { hidden: true },
       description: "Hidden command.",
       handler: () => {},
     },
@@ -42,7 +43,7 @@ const hiddenFixture: CliProgram = {
         },
         {
           name: "secret-flag",
-          hidden: true,
+          cli: { hidden: true },
           description: "Hidden option.",
           kind: CliOptionKind.Presence,
         },

package/src/mcp/result.ts

@@ -2,8 +2,8 @@
 This module builds MCP tools/call success results from handler respond payloads.
 */
 
-import { encodeRespondBodyBase64 } from "../respond.ts";
-import type { CliRespondOptions } from "../types.ts";
+import { encodeRespondBodyBase64 } from "~/core/respond.ts";
+import type { CliRespondOptions } from "~/core/types.ts";
 
 /** Text content block in an MCP tool result. */
 export interface McpTextContent {