argsbarg 6.1.2 → 6.1.3

package/src/{cli.ts → runtime/cli.ts}

@@ -2,30 +2,46 @@
 Runtime entry point: validate program, cache derived state, run / invoke / MCP serve.
 */
 
+import { randomUUID } from "node:crypto";
 import { format } from "node:util";
-import { apiServeHttp } from "./api/server.ts";
-import { builtinInterceptRoot, dispatchBuiltin } from "./builtins/dispatch.ts";
-import { cliParseRoot, cliPresentationRoot } from "./builtins/presentation.ts";
+import { builtinInterceptRoot, dispatchBuiltin } from "~/builtins/dispatch.ts";
+import { cliParseRoot, cliPresentationRoot } from "~/builtins/presentation.ts";
+import { bootstrapAppConfig, type EnsureAppConfigOpts, ensureAppConfig } from "~/config/bootstrap.ts";
+import { type AnyAppConfigSnapshot, createAppConfigSnapshot } from "~/config/context.ts";
+import { readAppConfigFileRaw, resolveAppConfigPath } from "~/config/file.ts";
+import { effectiveJsonSchema } from "~/config/schema.ts";
+import { CliContext } from "~/core/context.ts";
+import { LeafInputError, preloadPipableJson } from "~/core/leaf-inputs.ts";
+import { ParseKind, type ParseResult, parse, postParseValidate } from "~/core/parse.ts";
+import { type CliSchemaRootExport, cliSchemaExport } from "~/core/schema.ts";
+import type {
+  CliHandler,
+  CliInvocation,
+  CliLeaf,
+  CliLocals,
+  CliNode,
+  CliProgram,
+  CliRespondOptions,
+  CliRouter,
+  InvokeFailureKind,
+} from "~/core/types.ts";
+import { isCliLeaf, isCliRouter } from "~/core/types.ts";
+import { cliValidateProgram } from "~/core/validate.ts";
+import { cliHelpRender } from "~/help.ts";
+import { isBuiltinInvokePath } from "~/hooks/builtin.ts";
+import { buildInvokeHookContext, classifyFailureKind, runErrorPipeline, runHook } from "~/hooks/run.ts";
+import { httpServeHttp } from "~/http/server.ts";
+import { LogEmitter } from "~/log/emitter.ts";
+import { bootstrapMcpEnv } from "~/mcp/env.ts";
+import { mcpServeStdioLoop } from "~/mcp/server.ts";
+import { createServerRuntime, type ServerHandleContext } from "~/server/context.ts";
+import { resolveHttpServeConfig, resolveMcpServeConfig, type ServeOverrides } from "~/server/overrides.ts";
 import {
   assertBuiltinAllowed,
   type CliCapabilities,
   resolveCapabilities,
   skipsRequiredAppConfigExit,
 } from "./capabilities.ts";
-import { bootstrapAppConfig, type EnsureAppConfigOpts, ensureAppConfig } from "./config/bootstrap.ts";
-import { type AnyAppConfigSnapshot, createAppConfigSnapshot } from "./config/context.ts";
-import { readAppConfigFileRaw, resolveAppConfigPath } from "./config/file.ts";
-import { effectiveJsonSchema } from "./config/schema.ts";
-import { CliContext } from "./context.ts";
-import { cliHelpRender } from "./help.ts";
-import { LeafInputError, preloadPipableJson } from "./leaf-inputs.ts";
-import { bootstrapMcpEnv } from "./mcp/env.ts";
-import { mcpServeStdioLoop } from "./mcp/server.ts";
-import { ParseKind, type ParseResult, parse, postParseValidate } from "./parse.ts";
-import { type CliSchemaExport, cliSchemaExport } from "./schema.ts";
-import type { CliHandler, CliInvocation, CliLeaf, CliNode, CliProgram, CliRespondOptions, CliRouter } from "./types.ts";
-import { isCliLeaf, isCliRouter } from "./types.ts";
-import { cliValidateProgram } from "./validate.ts";
 
 /** Outcome of a non-exiting CLI invocation. */
 export type CliInvokeKind = "ok" | "help" | "error";
@@ -37,6 +53,8 @@ export interface CliInvokeResult {
   stdout: string;
   stderr: string;
   errorMsg?: string;
+  /** Classified failure for HTTP/MCP status mapping. */
+  failureKind?: InvokeFailureKind;
   /** Headless response payload when invocation is `api` or `mcp` and the handler succeeded. */
   response?: CliRespondOptions;
 }
@@ -66,6 +84,8 @@ export class Cli {
   private readonly parseRootMerged: CliRouter;
   private readonly presentationRoot: CliRouter;
   private _appConfig?: AnyAppConfigSnapshot;
+  /** Active HTTP/MCP server handle (set during serve). */
+  server?: ServerHandleContext;
 
   constructor(program: CliProgram) {
     cliValidateProgram(program);
@@ -86,7 +106,7 @@ export class Cli {
     return this._appConfig;
   }
 
-  exportCommandSchema(): CliSchemaExport {
+  exportCommandSchema(): CliSchemaRootExport {
     return cliSchemaExport(this.program);
   }
 
@@ -148,6 +168,8 @@ export class Cli {
       snapshot,
       undefined,
       preloadedJson,
+      pr.pathParams,
+      { requestId: randomUUID() } as CliLocals,
     );
     try {
       this.ensureValidatedLeafInputs(ctx, leaf);
@@ -169,7 +191,13 @@ export class Cli {
 
   async invoke(
     argv: string[],
-    opts?: { invocation?: CliInvocation; toolArgs?: Record<string, unknown> },
+    opts?: {
+      invocation?: CliInvocation;
+      toolArgs?: Record<string, unknown>;
+      requestId?: string;
+      http?: { request: Request; clientIp: string; requestId: string };
+      mcp?: { rpcMethod: string; toolName?: string; requestId: string };
+    },
   ): Promise<CliInvokeResult> {
     const invocation = opts?.invocation ?? "mcp";
     const prep = this.prepareDispatch(argv, { presentationFallback: true });
@@ -181,6 +209,7 @@ export class Cli {
           stdout: "",
           stderr: "",
           errorMsg: "Help is not available via tool calls.",
+          failureKind: "help",
         };
       }
       return {
@@ -189,6 +218,7 @@ export class Cli {
         stdout: "",
         stderr: prep.error.errorMsg,
         errorMsg: prep.error.errorMsg,
+        failureKind: "validation",
       };
     }
 
@@ -198,6 +228,8 @@ export class Cli {
       exitOnMissing: false,
     });
 
+    const runtime = this.server?.runtime;
+    const requestId = opts?.requestId ?? opts?.http?.requestId ?? opts?.mcp?.requestId ?? randomUUID();
     const ctx = new CliContext(
       this.program.key,
       pr.path,
@@ -207,8 +239,30 @@ export class Cli {
       invocation,
       snapshot,
       opts?.toolArgs,
+      {},
+      pr.pathParams,
+      { requestId } as CliLocals,
+      runtime,
     );
 
+    const skipHooks = isBuiltinInvokePath(pr.path);
+    const hooks = this.program.hooks;
+    const obscureUnexpected =
+      invocation === "http"
+        ? (this.server?.http?.obscureUnexpected ?? this.program.httpServer?.errors?.obscureUnexpected ?? false)
+        : invocation === "mcp"
+          ? (this.server?.mcp?.obscureUnexpected ?? this.program.mcpServer?.errors?.obscureUnexpected ?? false)
+          : false;
+    const emitter = this.server?.emitter;
+
+    const hookCtx = () =>
+      buildInvokeHookContext(ctx, {
+        path: pr.path,
+        runtime,
+        http: opts?.http,
+        mcp: opts?.mcp,
+      });
+
     let stdout = "";
     let stderr = "";
     const origExit = process.exit;
@@ -252,6 +306,33 @@ export class Cli {
       stderr += `${format(...args)}\n`;
     };
 
+    const finishError = async (
+      err: unknown,
+      kindOpts: Parameters<typeof classifyFailureKind>[1],
+    ): Promise<CliInvokeResult> => {
+      const failureKind = classifyFailureKind(err, kindOpts);
+      if (!skipHooks) {
+        const piped = await runErrorPipeline(hookCtx(), err, failureKind, hooks, emitter, obscureUnexpected);
+        return {
+          kind: "error",
+          exitCode: piped.clientError.exitCode ?? 1,
+          stdout,
+          stderr: `${piped.errorMsg}\n`,
+          errorMsg: piped.errorMsg,
+          failureKind: piped.failureKind,
+        };
+      }
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        kind: "error",
+        exitCode: 1,
+        stdout,
+        stderr: `${message}\n`,
+        errorMsg: message,
+        failureKind,
+      };
+    };
+
     try {
       if (pr.kind === ParseKind.Ok) {
         await dispatchBuiltin(this.program, pr, {
@@ -260,6 +341,10 @@ export class Cli {
         });
       }
 
+      if (!skipHooks) {
+        await runHook(() => hooks?.beforeInvoke?.(hookCtx()), "beforeInvoke");
+      }
+
       this.ensureValidatedLeafInputs(ctx, leaf);
       const handlerResult = await Promise.resolve(leaf.handler(ctx));
       if (handlerResult !== undefined && ctx.getResponse() === undefined) {
@@ -267,53 +352,44 @@ export class Cli {
       }
 
       const response = ctx.getResponse();
-      return {
+      const okResult: CliInvokeResult = {
         kind: "ok",
         exitCode: 0,
         stdout,
         stderr,
         ...(response ? { response } : {}),
       };
+
+      if (!skipHooks) {
+        await runHook(() => hooks?.afterInvoke?.({ ...hookCtx(), result: okResult }), "afterInvoke");
+      }
+
+      return okResult;
     } catch (err) {
       if (err instanceof CliInvokeExit) {
         if (err.code === 0) {
           const response = ctx.getResponse();
-          return {
+          const okResult: CliInvokeResult = {
             kind: "ok",
             exitCode: 0,
             stdout,
             stderr,
             ...(response ? { response } : {}),
           };
+          if (!skipHooks) {
+            await runHook(() => hooks?.afterInvoke?.({ ...hookCtx(), result: okResult }), "afterInvoke");
+          }
+          return okResult;
         }
-        const msg = stderr.trim() || `Exit code ${err.code}`;
-        return { kind: "error", exitCode: err.code, stdout, stderr, errorMsg: msg };
+        return finishError(err, {});
       }
       if (err instanceof LeafInputError) {
-        return {
-          kind: "error",
-          exitCode: 1,
-          stdout,
-          stderr: `${err.message}\n`,
-          errorMsg: err.message,
-        };
+        return finishError(err, { parseError: true });
       }
       if (err instanceof Error) {
-        return {
-          kind: "error",
-          exitCode: 1,
-          stdout,
-          stderr: `${err.message}\n`,
-          errorMsg: err.message,
-        };
+        return finishError(err, {});
       }
-      return {
-        kind: "error",
-        exitCode: 1,
-        stdout,
-        stderr: "Unknown error\n",
-        errorMsg: "Unknown error",
-      };
+      return finishError(err, {});
     } finally {
       process.exit = origExit;
       process.stdout.write = origStdoutWrite;
@@ -325,12 +401,28 @@ export class Cli {
     }
   }
 
-  async serveMcp(): Promise<never> {
+  async serveMcp(overrides: ServeOverrides = {}): Promise<never> {
     try {
       if (this.program.mcpServer) {
         bootstrapMcpEnv(this.program.mcpServer);
       }
-      bootstrapAppConfig(this.program, { validateFile: false });
+      const resolved = resolveMcpServeConfig(this.program, overrides);
+      const runtime = createServerRuntime(this.program, "mcp");
+      const emitter = new LogEmitter({ program: this.program, resolved: resolved.log });
+      this.server = {
+        runtime,
+        emitter,
+        mcp: resolved,
+        mcpHooks: this.program.mcpServer?.hooks,
+      };
+      bootstrapAppConfig(this.program, { validateFile: "soft", runtime, emitter });
+      const shutdown = () => {
+        emitter.emit({ level: "info", message: "server stopping", action: "server.stop" });
+        process.exit(0);
+      };
+      process.once("SIGINT", shutdown);
+      process.once("SIGTERM", shutdown);
+      emitter.emitLifecycle(`${this.program.key} ${this.program.version} — MCP ready (stdio)`, "mcp.server.ready");
       await mcpServeStdioLoop(this);
       process.exit(0);
     } catch (err) {
@@ -343,10 +435,25 @@ export class Cli {
     }
   }
 
-  async serveApi(): Promise<never> {
+  async serveHttp(overrides: ServeOverrides = {}): Promise<never> {
     try {
-      bootstrapAppConfig(this.program, { validateFile: false });
-      await apiServeHttp(this);
+      const resolved = resolveHttpServeConfig(this.program, overrides);
+      const runtime = createServerRuntime(this.program, "http");
+      const emitter = new LogEmitter({ program: this.program, resolved: resolved.log });
+      this.server = {
+        runtime,
+        emitter,
+        http: resolved,
+        httpHooks: this.program.httpServer?.hooks,
+      };
+      bootstrapAppConfig(this.program, { validateFile: "soft", runtime, emitter });
+      const shutdown = () => {
+        emitter.emit({ level: "info", message: "server stopping", action: "server.stop" });
+        process.exit(0);
+      };
+      process.once("SIGINT", shutdown);
+      process.once("SIGTERM", shutdown);
+      await httpServeHttp(this, resolved);
       process.exit(0);
     } catch (err) {
       if (err instanceof Error) {
@@ -416,6 +523,7 @@ export class Cli {
             path: pr.path,
             args: pr.args,
             opts: pr.opts,
+            pathParams: pr.pathParams,
             helpExplicit: false,
             helpPath: [],
             errorMsg: msg,
@@ -432,6 +540,7 @@ export class Cli {
             path: pr.path,
             args: pr.args,
             opts: pr.opts,
+            pathParams: pr.pathParams,
             helpExplicit: false,
             helpPath: [],
             errorMsg: msg,
@@ -450,6 +559,7 @@ export class Cli {
           path: pr.path,
           args: pr.args,
           opts: pr.opts,
+          pathParams: pr.pathParams,
           helpExplicit: false,
           helpPath: [],
           errorMsg: msg,

package/src/runtime/exposure.ts

@@ -0,0 +1,102 @@
+/*
+Per-surface exposure helpers (cli, http, mcpTool).
+Parsing uses the full tree; presentation/schema/MCP/HTTP discovery use these filters.
+*/
+
+import type { CliLeaf, CliNode, CliNodeBase, CliOption } from "~/core/types.ts";
+import { isCliRouter } from "~/core/types.ts";
+
+/** True when the node is omitted from CLI help, schema, and completions (still invocable). */
+export function isCliHidden(node: CliNodeBase): boolean {
+  return node.cli?.hidden === true;
+}
+
+/** True when the option is omitted from CLI help, schema, and completions. */
+export function isOptionCliHidden(opt: CliOption): boolean {
+  return opt.cli?.hidden === true;
+}
+
+/** True when the node is omitted from cli-schema export. */
+export function isCliSchemaHidden(node: CliNodeBase): boolean {
+  if (node.cli?.schema?.enabled === false) {
+    return true;
+  }
+  if (node.cli?.schema?.hidden === true) {
+    return true;
+  }
+  return isCliHidden(node);
+}
+
+/** True when the node is omitted from shell completions. */
+export function isCliCompletionsHidden(node: CliNodeBase): boolean {
+  if (node.cli?.completions?.enabled === false) {
+    return true;
+  }
+  if (node.cli?.completions?.hidden === true) {
+    return true;
+  }
+  return isCliHidden(node);
+}
+
+/** True when the leaf is omitted from MCP tools/list. */
+export function isMcpHidden(leaf: CliLeaf): boolean {
+  if (leaf.mcpTool?.enabled === false) {
+    return true;
+  }
+  return leaf.mcpTool?.hidden === true;
+}
+
+/** True when the node is not callable via CLI (`cli.enabled: false`, cascades from parent). */
+export function isCliCallable(node: CliNodeBase, parentEnabled = true): boolean {
+  if (!parentEnabled) {
+    return false;
+  }
+  if (node.cli?.enabled === false) {
+    return false;
+  }
+  return true;
+}
+
+/** True when the leaf is omitted from HTTP route table / OpenAPI. */
+export function isHttpHidden(node: CliNodeBase): boolean {
+  return node.http?.hidden === true;
+}
+
+/** True when the leaf is not exposed on HTTP (disabled or hidden). */
+export function isHttpDisabled(node: CliNodeBase): boolean {
+  return node.http?.enabled === false;
+}
+
+/** Options visible in help, schema, completions, and MCP tool inputSchema. */
+export function visibleOptions(options: CliOption[] | undefined): CliOption[] {
+  return (options ?? []).filter((o) => !isOptionCliHidden(o));
+}
+
+/** Strips CLI-hidden commands and options from one node for presentation export. */
+export function presentationNode(node: CliNode): CliNode | null {
+  if (isCliHidden(node)) {
+    return null;
+  }
+  const options = visibleOptions(node.options);
+  if (isCliRouter(node)) {
+    const commands = node.commands.map((ch) => presentationNode(ch)).filter((ch): ch is CliNode => ch !== null);
+    return { ...node, options, commands };
+  }
+  return { ...node, options };
+}
+
+/** Subcommands visible in help listings. */
+export function visibleSubcommands(cmds: CliNode[]): CliNode[] {
+  return cmds.filter((c) => !isCliHidden(c));
+}
+
+/** Default HTTP response metadata from a leaf `http` block. */
+export function leafHttpResponseDefaults(leaf: CliLeaf): {
+  contentType?: string;
+  contentDisposition?: string;
+} {
+  return {
+    contentType: leaf.http?.successContentType,
+    contentDisposition: leaf.http?.contentDisposition,
+  };
+}

package/src/{invoke.test.ts → runtime/invoke.test.ts}

@@ -5,16 +5,16 @@ Domain-specific regression tests (split from index.test.ts).
 import { expect, test } from "bun:test";
 import { join } from "node:path";
 import { $ } from "bun";
-import { Cli, type CliContext, CliOptionKind } from "./index.ts";
-import { ParseKind, parse, postParseValidate } from "./parse.ts";
-import { testProgram, varargsReadFixture } from "./test-fixtures.ts";
-import type { CliLeaf } from "./types.ts";
-import { isCliRouter } from "./types.ts";
-import { cliValidateProgram } from "./validate.ts";
+import { ParseKind, parse, postParseValidate } from "~/core/parse.ts";
+import type { CliLeaf } from "~/core/types.ts";
+import { isCliRouter } from "~/core/types.ts";
+import { cliValidateProgram } from "~/core/validate.ts";
+import { Cli, type CliContext, CliOptionKind } from "~/index";
+import { testProgram, varargsReadFixture } from "~/test/fixtures.ts";
 
 /** Tests that ctx.invocation is cli via Cli.run. */
 test("ctx.invocation is cli via Cli.run", async () => {
-  const indexPath = join(import.meta.dir, "index.ts");
+  const indexPath = join(import.meta.dir, "../index.ts");
   const { stdout } = await $`bun -e ${`
 import { Cli, CliProgram } from ${JSON.stringify(indexPath)};
 const program = {
@@ -45,6 +45,30 @@ test("ctx.invocation is mcp via Cli.invoke", async () => {
   expect(seen).toBe("mcp");
 });
 
+/** Tests that ctx.locals.requestId is seeded before handler on invoke. */
+test("Cli.invoke seeds ctx.locals.requestId", async () => {
+  let requestId = "";
+  const root = testProgram({
+    key: "app",
+    description: "",
+    hooks: {
+      beforeInvoke: (ctx: CliContext) => {
+        requestId = String(ctx.locals.requestId ?? "");
+      },
+    },
+    handler: () => {},
+  });
+  cliValidateProgram(root);
+  const wireId = "00000000-0000-4000-8000-000000000001";
+  const result = await new Cli(root).invoke([], {
+    invocation: "http",
+    requestId: wireId,
+    http: { request: new Request("http://localhost/"), clientIp: "127.0.0.1", requestId: wireId },
+  });
+  expect(result.kind).toBe("ok");
+  expect(requestId).toBe(wireId);
+});
+
 /** Cli.invoke rejects invalid Enum value. */
 test("Cli.invoke rejects invalid Enum value", async () => {
   const root = testProgram({

package/src/server/context.ts

@@ -0,0 +1,25 @@
+/*
+Per-server mutable handle context passed through HTTP/MCP dispatch.
+*/
+
+import type { CliHttpWireHooks, CliMcpWireHooks, ServerRuntime, ServerState } from "~/core/types.ts";
+import type { LogEmitter } from "~/log/emitter.ts";
+import type { ResolvedHttpServeConfig, ResolvedMcpServeConfig } from "./overrides.ts";
+
+/** Shared server state for one HTTP or MCP serve session. */
+export interface ServerHandleContext {
+  runtime: ServerRuntime;
+  emitter: LogEmitter;
+  http?: ResolvedHttpServeConfig;
+  mcp?: ResolvedMcpServeConfig;
+  httpHooks?: CliHttpWireHooks;
+  mcpHooks?: CliMcpWireHooks;
+}
+
+/** Creates a fresh {@link ServerRuntime} for HTTP or MCP. */
+export function createServerRuntime(
+  program: import("~/core/types.ts").CliProgram,
+  surface: "http" | "mcp",
+): ServerRuntime {
+  return { state: {} as ServerState, program, surface };
+}

package/src/server/overrides.ts

@@ -0,0 +1,112 @@
+/*
+CLI flag and programmatic overrides merged into HTTP/MCP server runtime config.
+*/
+
+import { join } from "node:path";
+import { resolveAppConfigDir } from "~/config/file.ts";
+import type { CliProgram } from "~/core/types.ts";
+import type { ResolvedLogConfig } from "~/log/emitter.ts";
+
+/** Overrides from `myapp http` / `serveHttp()` flags and embedders. */
+export interface ServeOverrides {
+  host?: string;
+  port?: number;
+  trustProxy?: boolean;
+  obscureErrors?: boolean;
+  logFormat?: "json" | "text";
+  logFile?: string;
+  noAccessLog?: boolean;
+  dev?: boolean;
+}
+
+/** Resolved HTTP listen and error options after merging schema + overrides. */
+export interface ResolvedHttpServeConfig {
+  hostname: string;
+  port: number;
+  trustProxy: boolean;
+  obscureUnexpected: boolean;
+  log: ResolvedLogConfig;
+}
+
+/** Resolved MCP serve options after merging schema + overrides. */
+export interface ResolvedMcpServeConfig {
+  obscureUnexpected: boolean;
+  log: ResolvedLogConfig;
+}
+
+function resolveLogFile(program: CliProgram, logFile: string | undefined): string | undefined {
+  if (!logFile) {
+    return undefined;
+  }
+  if (logFile.startsWith("/") || logFile.startsWith("~")) {
+    return logFile;
+  }
+  return join(resolveAppConfigDir(program), logFile);
+}
+
+/** Builds resolved HTTP server config (CLI flags > program schema). */
+export function resolveHttpServeConfig(program: CliProgram, overrides: ServeOverrides = {}): ResolvedHttpServeConfig {
+  const http = program.httpServer;
+  const obscureUnexpected = overrides.obscureErrors ?? http?.errors?.obscureUnexpected ?? false;
+  return {
+    hostname: overrides.host ?? http?.host ?? "127.0.0.1",
+    port: overrides.port ?? http?.port ?? 3000,
+    trustProxy: overrides.trustProxy ?? http?.trustProxy ?? false,
+    obscureUnexpected,
+    log: {
+      format: overrides.logFormat ?? program.log?.format ?? "json",
+      file: resolveLogFile(program, overrides.logFile ?? program.log?.file),
+      access: overrides.noAccessLog ? false : (program.log?.access ?? true),
+      errors: program.log?.errors ?? true,
+      dev: overrides.dev ?? false,
+    },
+  };
+}
+
+/** Builds resolved MCP server config (CLI flags > program schema). */
+export function resolveMcpServeConfig(program: CliProgram, overrides: ServeOverrides = {}): ResolvedMcpServeConfig {
+  const mcp = program.mcpServer;
+  return {
+    obscureUnexpected: overrides.obscureErrors ?? mcp?.errors?.obscureUnexpected ?? false,
+    log: {
+      format: overrides.logFormat ?? program.log?.format ?? "json",
+      file: resolveLogFile(program, overrides.logFile ?? program.log?.file),
+      access: program.log?.access ?? true,
+      errors: program.log?.errors ?? true,
+      dev: overrides.dev ?? false,
+    },
+  };
+}
+
+/** Parses `http` / `mcp serve` CLI opts into {@link ServeOverrides}. */
+export function serveOverridesFromOpts(opts: Record<string, string>, surface: "http" | "mcp"): ServeOverrides {
+  const out: ServeOverrides = {};
+  if (opts.host) {
+    out.host = opts.host;
+  }
+  if (opts.port) {
+    const port = Number(opts.port);
+    if (!Number.isNaN(port)) {
+      out.port = port;
+    }
+  }
+  if (opts["trust-proxy"]) {
+    out.trustProxy = true;
+  }
+  if (opts["obscure-errors"]) {
+    out.obscureErrors = true;
+  }
+  if (opts["log-format"] === "json" || opts["log-format"] === "text") {
+    out.logFormat = opts["log-format"];
+  }
+  if (opts["log-file"]) {
+    out.logFile = opts["log-file"];
+  }
+  if (opts["no-access-log"] && surface === "http") {
+    out.noAccessLog = true;
+  }
+  if (opts.dev) {
+    out.dev = true;
+  }
+  return out;
+}