@dbx-tools/cli 0.9.58 → 0.9.60

package/lib/src/tunnel/proxy.js

@@ -0,0 +1,143 @@
+/**
+ * The reverse proxy that makes the wrapper path possible.
+ *
+ * The wrapper claims the PUBLIC port and the wrapped app runs as a child process
+ * on a private loopback port, so - unlike the in-process plugin - there is no
+ * middleware chain to insert the gate into. This proxy is that insertion point: it
+ * answers the login routes itself, applies the gate to everything else, and
+ * forwards what survives to the child.
+ *
+ * The gating DECISION is not reimplemented here. `@dbx-tools/tunnel`'s
+ * `gate.gateRequest` makes it - the same function the Express middleware calls -
+ * and this module only differs in how the outcome is written: a proxied request
+ * instead of `next()`, a `writeHead` instead of `res.json`. That is deliberate:
+ * two independent implementations of "which requests are gated and which headers
+ * are stripped" is the one way this package could become a security bug.
+ *
+ * @module
+ */
+import { createServer } from "node:http";
+import { log } from "@dbx-tools/shared-core";
+import { gate as tunnelGate, headers as tunnelHeaders, loginPage as tunnelLoginPage, } from "@dbx-tools/tunnel";
+import ProxyModule from "http-proxy-3";
+const logger = log.logger("tunnel:proxy");
+function sendJson(response, status, body, setCookie) {
+    response.writeHead(status, {
+        "content-type": "application/json",
+        ...(setCookie ? { "set-cookie": setCookie } : {}),
+    });
+    response.end(JSON.stringify(body));
+}
+/**
+ * Hand every Better Auth and compatibility route to the shared gate runtime.
+ */
+async function handleAuthRoute(request, response, path, gate, brandName) {
+    if (!tunnelGate.isAuthPath(path))
+        return false;
+    if (tunnelGate.wantsHostedLogin(request)) {
+        response.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+        response.end(tunnelLoginPage.loginPageHtml({
+            brandName,
+            returnTo: tunnelGate.loginReturnTo(request),
+        }));
+        return true;
+    }
+    const result = await gate.handler(tunnelGate.webRequest(request));
+    await tunnelGate.sendWebResponse(response, result);
+    return true;
+}
+/**
+ * Start the proxy and resolve once it is listening.
+ *
+ * `publicDomain` is intentionally NOT passed to `gateRequest`: on this path every
+ * request arrived on the public port, so it IS tunnel traffic by construction -
+ * whereas the in-process gate shares a port with the platform front door and has
+ * to tell them apart by `Host`. Passing the request's own host keeps the shared
+ * decision function's contract satisfied without weakening it.
+ */
+export async function startProxy(options) {
+    const proxy = ProxyModule.createProxyServer({
+        target: `http://127.0.0.1:${options.appPort}`,
+        ws: true,
+        xfwd: true,
+    });
+    const headerPolicy = tunnelHeaders.toHeaderPolicy(options.forwardHeaders);
+    const gate = options.gate;
+    const decide = (request) => gate
+        ? tunnelGate.gateRequest(request, {
+            gate,
+            publicDomain: (request.headers.host ?? "").split(":")[0] || "localhost",
+            headerPolicy,
+            gatePaths: options.gatePaths,
+        })
+        : Promise.resolve("pass");
+    const onRequest = (request, response) => {
+        void (async () => {
+            const path = (request.url ?? "/").split("?")[0] ?? "/";
+            const brandName = options.brandName ?? "this app";
+            if (gate && (await handleAuthRoute(request, response, path, gate, brandName)))
+                return;
+            if ((await decide(request)) === "deny") {
+                // A denied browser navigation gets the hosted login page; anything else
+                // (an XHR, a /ws upgrade probe, a non-HTML fetch) gets the 401 JSON.
+                if (gate && tunnelGate.wantsLoginPage(request)) {
+                    const html = tunnelLoginPage.loginPageHtml({
+                        brandName,
+                        returnTo: tunnelGate.requestReturnTo(request),
+                    });
+                    response.writeHead(401, { "content-type": "text/html; charset=utf-8" });
+                    response.end(html);
+                }
+                else {
+                    sendJson(response, 401, tunnelGate.unauthorizedBody(request));
+                }
+                return;
+            }
+            proxy.web(request, response);
+        })().catch((error) => {
+            logger.error("proxy request failed", { error });
+            if (!response.headersSent)
+                sendJson(response, 502, { error: "bad gateway" });
+            else
+                response.end();
+        });
+    };
+    // A websocket upgrade cannot be answered with a 401 body, so a denied one is
+    // destroyed - the client sees the handshake fail, which is what a browser's
+    // WebSocket error handler expects.
+    const onUpgrade = (request, socket, head) => {
+        const upgradeSocket = socket;
+        upgradeSocket.destroySoon ??= () => upgradeSocket.end();
+        const path = (request.url ?? "/").split("?", 1)[0] ?? "/";
+        if (tunnelGate.isAuthPath(path)) {
+            upgradeSocket.destroy();
+            return;
+        }
+        void decide(request)
+            .then((action) => {
+            if (action === "deny")
+                upgradeSocket.destroy();
+            else
+                proxy.ws(request, upgradeSocket, head);
+        })
+            .catch(() => upgradeSocket.destroy());
+    };
+    // One net.Server binds one address, so listen each host on its own server that
+    // shares the same handlers. Binding specific interface IPs (rather than the
+    // default 0.0.0.0) is what lets the gate front an overlay/LAN address while
+    // loopback reaches the upstream ungated.
+    const hosts = options.bindHosts?.length ? options.bindHosts : ["0.0.0.0"];
+    await Promise.all(hosts.map((host) => new Promise((resolve) => {
+        const server = createServer(onRequest);
+        server.on("upgrade", onUpgrade);
+        server.listen(options.publicPort, host, () => {
+            logger.info("proxy listening", {
+                host,
+                publicPort: options.publicPort,
+                appPort: options.appPort,
+            });
+            resolve();
+        });
+    })));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"proxy.js","sourceRoot":"","sources":["../../../src/tunnel/proxy.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The reverse proxy that makes the wrapper path possible.\n *\n * The wrapper claims the PUBLIC port and the wrapped app runs as a child process\n * on a private loopback port, so - unlike the in-process plugin - there is no\n * middleware chain to insert the gate into. This proxy is that insertion point: it\n * answers the login routes itself, applies the gate to everything else, and\n * forwards what survives to the child.\n *\n * The gating DECISION is not reimplemented here. `@dbx-tools/tunnel`'s\n * `gate.gateRequest` makes it - the same function the Express middleware calls -\n * and this module only differs in how the outcome is written: a proxied request\n * instead of `next()`, a `writeHead` instead of `res.json`. That is deliberate:\n * two independent implementations of \"which requests are gated and which headers\n * are stripped\" is the one way this package could become a security bug.\n *\n * @module\n */\n\nimport { createServer, type IncomingMessage, type ServerResponse } from \"node:http\";\nimport type { Socket } from \"node:net\";\nimport { log } from \"@dbx-tools/shared-core\";\nimport {\n  gate as tunnelGate,\n  headers as tunnelHeaders,\n  loginPage as tunnelLoginPage,\n  type AuthGateApi,\n} from \"@dbx-tools/tunnel\";\nimport ProxyModule from \"http-proxy-3\";\n\nconst logger = log.logger(\"tunnel:proxy\");\n\ntype UpgradeSocket = Socket & { destroySoon?: () => void };\n\n/** Listener, upstream application, and optional authentication settings for the wrapper proxy. */\nexport interface ProxyOptions {\n  /** The port this proxy listens on - the port portr and the platform route to. */\n  publicPort: number;\n  /** The private loopback port the wrapped app listens on. */\n  appPort: number;\n  /** The gate handlers. Omitted (an `--insecure` run) forwards everything. */\n  gate?: AuthGateApi;\n  /** Extra `x-` headers tunnel traffic may forward. */\n  forwardHeaders?: readonly string[];\n  /** Path prefixes to gate beyond `/api/` (e.g. `/ws` for a WebSocket app). */\n  gatePaths?: readonly string[];\n  /** Brand name for the hosted login page shown on a denied browser navigation. */\n  brandName?: string;\n  /**\n   * Addresses to listen on. Defaults to a single `0.0.0.0` (every interface),\n   * the portr/platform case. Pass specific interface IPs to expose the gate on\n   * only those - e.g. an overlay/LAN address while loopback reaches the upstream\n   * directly and ungated.\n   */\n  bindHosts?: readonly string[];\n}\n\nfunction sendJson(\n  response: ServerResponse,\n  status: number,\n  body: unknown,\n  setCookie?: string,\n): void {\n  response.writeHead(status, {\n    \"content-type\": \"application/json\",\n    ...(setCookie ? { \"set-cookie\": setCookie } : {}),\n  });\n  response.end(JSON.stringify(body));\n}\n\n/**\n * Hand every Better Auth and compatibility route to the shared gate runtime.\n */\nasync function handleAuthRoute(\n  request: IncomingMessage,\n  response: ServerResponse,\n  path: string,\n  gate: AuthGateApi,\n  brandName: string,\n): Promise<boolean> {\n  if (!tunnelGate.isAuthPath(path)) return false;\n  if (tunnelGate.wantsHostedLogin(request)) {\n    response.writeHead(200, { \"content-type\": \"text/html; charset=utf-8\" });\n    response.end(\n      tunnelLoginPage.loginPageHtml({\n        brandName,\n        returnTo: tunnelGate.loginReturnTo(request),\n      }),\n    );\n    return true;\n  }\n  const result = await gate.handler(tunnelGate.webRequest(request));\n  await tunnelGate.sendWebResponse(response, result);\n  return true;\n}\n\n/**\n * Start the proxy and resolve once it is listening.\n *\n * `publicDomain` is intentionally NOT passed to `gateRequest`: on this path every\n * request arrived on the public port, so it IS tunnel traffic by construction -\n * whereas the in-process gate shares a port with the platform front door and has\n * to tell them apart by `Host`. Passing the request's own host keeps the shared\n * decision function's contract satisfied without weakening it.\n */\nexport async function startProxy(options: ProxyOptions): Promise<void> {\n  const proxy = ProxyModule.createProxyServer({\n    target: `http://127.0.0.1:${options.appPort}`,\n    ws: true,\n    xfwd: true,\n  });\n  const headerPolicy = tunnelHeaders.toHeaderPolicy(options.forwardHeaders);\n  const gate = options.gate;\n\n  const decide = (request: IncomingMessage): Promise<tunnelGate.GateAction> =>\n    gate\n      ? tunnelGate.gateRequest(request, {\n          gate,\n          publicDomain: (request.headers.host ?? \"\").split(\":\")[0] || \"localhost\",\n          headerPolicy,\n          gatePaths: options.gatePaths,\n        })\n      : Promise.resolve<tunnelGate.GateAction>(\"pass\");\n\n  const onRequest = (request: IncomingMessage, response: ServerResponse): void => {\n    void (async () => {\n      const path = (request.url ?? \"/\").split(\"?\")[0] ?? \"/\";\n      const brandName = options.brandName ?? \"this app\";\n      if (gate && (await handleAuthRoute(request, response, path, gate, brandName))) return;\n      if ((await decide(request)) === \"deny\") {\n        // A denied browser navigation gets the hosted login page; anything else\n        // (an XHR, a /ws upgrade probe, a non-HTML fetch) gets the 401 JSON.\n        if (gate && tunnelGate.wantsLoginPage(request)) {\n          const html = tunnelLoginPage.loginPageHtml({\n            brandName,\n            returnTo: tunnelGate.requestReturnTo(request),\n          });\n          response.writeHead(401, { \"content-type\": \"text/html; charset=utf-8\" });\n          response.end(html);\n        } else {\n          sendJson(response, 401, tunnelGate.unauthorizedBody(request));\n        }\n        return;\n      }\n      proxy.web(request, response);\n    })().catch((error: unknown) => {\n      logger.error(\"proxy request failed\", { error });\n      if (!response.headersSent) sendJson(response, 502, { error: \"bad gateway\" });\n      else response.end();\n    });\n  };\n\n  // A websocket upgrade cannot be answered with a 401 body, so a denied one is\n  // destroyed - the client sees the handshake fail, which is what a browser's\n  // WebSocket error handler expects.\n  const onUpgrade = (request: IncomingMessage, socket: Socket, head: Buffer): void => {\n    const upgradeSocket = socket as UpgradeSocket;\n    upgradeSocket.destroySoon ??= () => upgradeSocket.end();\n    const path = (request.url ?? \"/\").split(\"?\", 1)[0] ?? \"/\";\n    if (tunnelGate.isAuthPath(path)) {\n      upgradeSocket.destroy();\n      return;\n    }\n    void decide(request)\n      .then((action) => {\n        if (action === \"deny\") upgradeSocket.destroy();\n        else proxy.ws(request, upgradeSocket, head);\n      })\n      .catch(() => upgradeSocket.destroy());\n  };\n\n  // One net.Server binds one address, so listen each host on its own server that\n  // shares the same handlers. Binding specific interface IPs (rather than the\n  // default 0.0.0.0) is what lets the gate front an overlay/LAN address while\n  // loopback reaches the upstream ungated.\n  const hosts = options.bindHosts?.length ? options.bindHosts : [\"0.0.0.0\"];\n  await Promise.all(\n    hosts.map(\n      (host) =>\n        new Promise<void>((resolve) => {\n          const server = createServer(onRequest);\n          server.on(\"upgrade\", onUpgrade);\n          server.listen(options.publicPort, host, () => {\n            logger.info(\"proxy listening\", {\n              host,\n              publicPort: options.publicPort,\n              appPort: options.appPort,\n            });\n            resolve();\n          });\n        }),\n    ),\n  );\n}\n"]}

package/lib/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/bootstrap.ts","../src/bun.ts","../src/cli.ts","../src/root.ts","../index.ts","../bin/dbx-tools.ts"],"version":"5.9.3"}
+{"root":["../src/bootstrap.ts","../src/bun.ts","../src/cli.ts","../src/root.ts","../src/appkit/cli.ts","../src/appkit/env-export.ts","../src/auth/cli.ts","../src/auth/options.ts","../src/graphiti/cli.ts","../src/graphiti/options.ts","../src/lakebase-proxy/cancellation.ts","../src/lakebase-proxy/cli.ts","../src/lakebase-proxy/options.ts","../src/lakebase-proxy/protocol.ts","../src/lakebase-proxy/proxy.ts","../src/model-gateway/cli.ts","../src/model-gateway/server.ts","../src/tunnel/app.ts","../src/tunnel/cli.ts","../src/tunnel/options.ts","../src/tunnel/proxy.ts","../index.ts","../bin/dbx-graphiti.ts","../bin/dbx-lakebase-proxy.ts","../bin/dbx-model-gateway.ts","../bin/dbx-tools.ts"],"version":"5.9.3"}

package/package.json

@@ -8,6 +8,9 @@
   },
   "bin": {
     "dbx": "./lib/bin/dbx-tools.js",
+    "dbx-graphiti": "./lib/bin/dbx-graphiti.js",
+    "dbx-lakebase-proxy": "./lib/bin/dbx-lakebase-proxy.js",
+    "dbx-model-gateway": "./lib/bin/dbx-model-gateway.js",
     "dbx-tools": "./lib/bin/dbx-tools.js"
   },
   "scripts": {
@@ -24,19 +27,32 @@
   },
   "devDependencies": {
     "@types/node": "^24.6.0",
+    "@types/pg": "^8",
     "typescript": "^5.9.3"
   },
   "dependencies": {
     "@clack/prompts": "^1.7.0",
-    "@dbx-tools/cli-appkit-env": "^0.9.58",
-    "@dbx-tools/cli-auth": "^0.9.58",
-    "@dbx-tools/cli-graphiti": "^0.9.58",
-    "@dbx-tools/cli-lakebase-proxy": "^0.9.58",
-    "@dbx-tools/cli-model-gateway": "^0.9.58",
-    "@dbx-tools/cli-tunnel": "^0.9.58",
-    "@dbx-tools/core": "^0.9.58",
-    "@dbx-tools/shared-core": "^0.9.58",
+    "@databricks/appkit": "0.81.0",
+    "@dbx-tools/appkit": "^0.9.60",
+    "@dbx-tools/appkit-model-gateway": "^0.9.60",
+    "@dbx-tools/auth": "^0.9.60",
+    "@dbx-tools/auth-gate": "^0.9.60",
+    "@dbx-tools/cli-args": "^0.9.60",
+    "@dbx-tools/cli-service": "^0.9.60",
+    "@dbx-tools/core": "^0.9.60",
+    "@dbx-tools/databricks": "^0.9.60",
+    "@dbx-tools/email": "^0.9.60",
+    "@dbx-tools/graphiti": "^0.9.60",
+    "@dbx-tools/lakebase": "^0.9.60",
+    "@dbx-tools/postgres": "^0.9.60",
+    "@dbx-tools/shared-auth": "^0.9.60",
+    "@dbx-tools/shared-core": "^0.9.60",
+    "@dbx-tools/shared-email": "^0.9.60",
+    "@dbx-tools/shared-model-gateway": "^0.9.60",
+    "@dbx-tools/tunnel": "^0.9.60",
     "commander": "^15.0.0",
+    "http-proxy-3": "^1.23.1",
+    "pg": "^8.22.0",
     "zod": "4.3.6"
   },
   "main": "./lib/index.js",
@@ -47,6 +63,9 @@
     "types": "./lib/index.d.ts",
     "bin": {
       "dbx": "./lib/bin/dbx-tools.js",
+      "dbx-graphiti": "./lib/bin/dbx-graphiti.js",
+      "dbx-lakebase-proxy": "./lib/bin/dbx-lakebase-proxy.js",
+      "dbx-model-gateway": "./lib/bin/dbx-model-gateway.js",
       "dbx-tools": "./lib/bin/dbx-tools.js"
     },
     "exports": {
@@ -70,10 +89,58 @@
         "types": "./lib/src/root.d.ts",
         "default": "./lib/src/root.js"
       },
+      "./appkit": {
+        "types": "./lib/src/appkit/cli.d.ts",
+        "default": "./lib/src/appkit/cli.js"
+      },
+      "./appkit/env-export": {
+        "types": "./lib/src/appkit/env-export.d.ts",
+        "default": "./lib/src/appkit/env-export.js"
+      },
+      "./auth": {
+        "types": "./lib/src/auth/cli.d.ts",
+        "default": "./lib/src/auth/cli.js"
+      },
+      "./auth/options": {
+        "types": "./lib/src/auth/options.d.ts",
+        "default": "./lib/src/auth/options.js"
+      },
+      "./graphiti": {
+        "types": "./lib/src/graphiti/cli.d.ts",
+        "default": "./lib/src/graphiti/cli.js"
+      },
+      "./graphiti/options": {
+        "types": "./lib/src/graphiti/options.d.ts",
+        "default": "./lib/src/graphiti/options.js"
+      },
+      "./lakebase-proxy": {
+        "types": "./lib/src/lakebase-proxy/cli.d.ts",
+        "default": "./lib/src/lakebase-proxy/cli.js"
+      },
+      "./lakebase-proxy/options": {
+        "types": "./lib/src/lakebase-proxy/options.d.ts",
+        "default": "./lib/src/lakebase-proxy/options.js"
+      },
+      "./model-gateway": {
+        "types": "./lib/src/model-gateway/cli.d.ts",
+        "default": "./lib/src/model-gateway/cli.js"
+      },
+      "./model-gateway/server": {
+        "types": "./lib/src/model-gateway/server.d.ts",
+        "default": "./lib/src/model-gateway/server.js"
+      },
+      "./tunnel": {
+        "types": "./lib/src/tunnel/cli.d.ts",
+        "default": "./lib/src/tunnel/cli.js"
+      },
+      "./tunnel/options": {
+        "types": "./lib/src/tunnel/options.d.ts",
+        "default": "./lib/src/tunnel/options.js"
+      },
       "./package.json": "./package.json"
     }
   },
-  "version": "0.9.58",
+  "version": "0.9.60",
   "types": "./lib/index.d.ts",
   "dbxToolsConfig": {
     "tags": [
@@ -102,6 +169,54 @@
       "types": "./lib/src/root.d.ts",
       "default": "./lib/src/root.js"
     },
+    "./appkit": {
+      "types": "./lib/src/appkit/cli.d.ts",
+      "default": "./lib/src/appkit/cli.js"
+    },
+    "./appkit/env-export": {
+      "types": "./lib/src/appkit/env-export.d.ts",
+      "default": "./lib/src/appkit/env-export.js"
+    },
+    "./auth": {
+      "types": "./lib/src/auth/cli.d.ts",
+      "default": "./lib/src/auth/cli.js"
+    },
+    "./auth/options": {
+      "types": "./lib/src/auth/options.d.ts",
+      "default": "./lib/src/auth/options.js"
+    },
+    "./graphiti": {
+      "types": "./lib/src/graphiti/cli.d.ts",
+      "default": "./lib/src/graphiti/cli.js"
+    },
+    "./graphiti/options": {
+      "types": "./lib/src/graphiti/options.d.ts",
+      "default": "./lib/src/graphiti/options.js"
+    },
+    "./lakebase-proxy": {
+      "types": "./lib/src/lakebase-proxy/cli.d.ts",
+      "default": "./lib/src/lakebase-proxy/cli.js"
+    },
+    "./lakebase-proxy/options": {
+      "types": "./lib/src/lakebase-proxy/options.d.ts",
+      "default": "./lib/src/lakebase-proxy/options.js"
+    },
+    "./model-gateway": {
+      "types": "./lib/src/model-gateway/cli.d.ts",
+      "default": "./lib/src/model-gateway/cli.js"
+    },
+    "./model-gateway/server": {
+      "types": "./lib/src/model-gateway/server.d.ts",
+      "default": "./lib/src/model-gateway/server.js"
+    },
+    "./tunnel": {
+      "types": "./lib/src/tunnel/cli.d.ts",
+      "default": "./lib/src/tunnel/cli.js"
+    },
+    "./tunnel/options": {
+      "types": "./lib/src/tunnel/options.d.ts",
+      "default": "./lib/src/tunnel/options.js"
+    },
     "./package.json": "./package.json"
   },
   "files": [

package/src/appkit/cli.ts

@@ -0,0 +1,72 @@
+/**
+ * `dbx appkit` commander program.
+ *
+ * `env` runs AppKit auto-config and prints the env vars it added or changed as
+ * eval-able `export` / `set` lines (or JSON) - e.g. `eval "$(dbx appkit env)"`
+ * to load a resolved Lakebase connection into your shell.
+ *
+ * This package ships no bin of its own: {@link buildProgram} is mounted as the
+ * `appkit` subcommand of the single `dbx` CLI (`@dbx-tools/cli`), which imports
+ * this module lazily so `dbx dev` never pays for the AppKit load.
+ *
+ * @module
+ */
+
+import { appkit } from "@dbx-tools/appkit";
+import { addArgs, parseArgs } from "@dbx-tools/cli-args";
+import { log } from "@dbx-tools/shared-core";
+import { Command, CommanderError } from "commander";
+
+import {
+  diffEnv,
+  EnvCommandOptionsSchema,
+  formatEnvExport,
+  snapshotEnv,
+  type EnvCommandOptions,
+} from "./env-export.ts";
+
+const logger = log.logger("appkit-env");
+
+/** Run auto-config and write the resulting env delta to stdout. */
+async function writeEnvExport(opts: EnvCommandOptions): Promise<void> {
+  if (opts.quiet) {
+    process.env.LOG_LEVEL = "error";
+  }
+
+  logger.debug("Snapshotting env vars");
+  const before = snapshotEnv();
+  await appkit.autoConfigure({ autoConfigure: "env" });
+  const changes = diffEnv(before, snapshotEnv());
+
+  process.stdout.write(formatEnvExport(changes, opts.format));
+}
+
+/**
+ * Build the `env` command on its own, so a host CLI can mount it under a
+ * different parent than {@link buildProgram}'s.
+ */
+export function buildEnvCommand(name = "env"): Command {
+  const command = addArgs(
+    new Command(name).description("Run AppKit auto-config and print new/changed env vars."),
+    EnvCommandOptionsSchema,
+  );
+  return command.action(async () => {
+    await writeEnvExport(parseArgs(command, EnvCommandOptionsSchema));
+  });
+}
+
+/** Build the `dbx appkit` commander program (no side effects until parsed). */
+export function buildProgram(name = "dbx appkit"): Command {
+  return new Command()
+    .name(name)
+    .description("AppKit helpers: resolve the environment an AppKit app would start with.")
+    .addCommand(buildEnvCommand())
+    .showHelpAfterError();
+}
+
+/** Parse `argv` and run the matching command. Throws {@link CommanderError} on flag errors. */
+export async function runCli(argv: string[]): Promise<void> {
+  await buildProgram().parseAsync(argv);
+}
+
+export { CommanderError };

package/src/appkit/env-export.ts

@@ -0,0 +1,124 @@
+/**
+ * Snapshot `process.env`, diff after auto-config, and format deltas as
+ * eval-able shell `export` / Windows `set` lines or JSON.
+ *
+ * @module
+ */
+
+import { z } from "zod";
+
+export const EnvExportFormatSchema = z
+  .preprocess(
+    (value) => {
+      if (typeof value !== "string") return value;
+      const normalized = value.trim().toLowerCase();
+      if (["export", "shell", "nix", "bash"].includes(normalized)) return "export";
+      if (["windows", "win", "cmd"].includes(normalized)) return "windows";
+      return normalized;
+    },
+    z.enum(["export", "windows", "json"]),
+  )
+  .describe("Environment export output format.");
+
+export type EnvExportFormat = z.output<typeof EnvExportFormatSchema>;
+
+/** Shallow copy of the current process environment. */
+export function snapshotEnv(env: NodeJS.ProcessEnv = process.env): Record<string, string> {
+  const out: Record<string, string> = {};
+  for (const [key, value] of Object.entries(env)) {
+    if (value !== undefined) {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+
+/**
+ * Keys whose values were added, changed, or cleared between snapshots. A key
+ * that went from a non-blank value to blank/removed is emitted with an empty
+ * value so it can be unset. Keys that were already blank/absent and stayed that
+ * way are omitted.
+ */
+export function diffEnv(
+  before: Record<string, string>,
+  after: Record<string, string>,
+): Record<string, string> {
+  const keys = new Set([...Object.keys(before), ...Object.keys(after)]);
+  const out: Record<string, string> = {};
+  for (const key of [...keys].sort()) {
+    // Treat a removed key as blank so a non-blank -> blank/removed transition is a delta.
+    const prev = before[key] ?? "";
+    const next = after[key] ?? "";
+    if (next !== prev) {
+      out[key] = next;
+    }
+  }
+  return out;
+}
+
+/** Select Windows `set` output on Windows and POSIX `export` output elsewhere. */
+export function defaultEnvExportFormat(
+  platform: NodeJS.Platform = process.platform,
+): EnvExportFormat {
+  return platform === "win32" ? "windows" : "export";
+}
+
+export const EnvCommandOptionsSchema = z
+  .object({
+    format: EnvExportFormatSchema.default(defaultEnvExportFormat()).describe(
+      "Output format: export, windows, or json.",
+    ),
+    quiet: z.boolean().default(false).describe("Suppress auto-config log output."),
+  })
+  .strict()
+  .describe("Options for exporting the AppKit auto-config environment.");
+
+export type EnvCommandOptions = z.output<typeof EnvCommandOptionsSchema>;
+
+function escapeExportValue(value: string): string {
+  return value
+    .replace(/\\/g, "\\\\")
+    .replace(/"/g, '\\"')
+    .replace(/\$/g, "\\$")
+    .replace(/`/g, "\\`");
+}
+
+function escapeWindowsSetValue(value: string): string {
+  if (/[\s"&|<>^]/.test(value)) {
+    return `"${value.replace(/"/g, '""')}"`;
+  }
+  return value;
+}
+
+/**
+ * Format env entries for the requested output style. An empty map prints
+ * nothing (no trailing newline).
+ */
+export function formatEnvExport(env: Record<string, string>, format: EnvExportFormat): string {
+  const entries = Object.entries(env).sort(([a], [b]) => a.localeCompare(b));
+  if (entries.length === 0) {
+    return "";
+  }
+
+  switch (format) {
+    case "json":
+      return `${JSON.stringify(Object.fromEntries(entries), null, 2)}\n`;
+    case "windows":
+      return (
+        entries.map(([key, value]) => `set ${key}=${escapeWindowsSetValue(value)}`).join("\n") +
+        "\n"
+      );
+    case "export":
+      return (
+        entries.map(([key, value]) => `export ${key}="${escapeExportValue(value)}"`).join("\n") +
+        "\n"
+      );
+    default:
+      throw new Error(`Unknown env export format: ${format satisfies never}`);
+  }
+}
+
+/** Normalize CLI format aliases to a supported export format. */
+export function parseEnvExportFormat(value: string): EnvExportFormat {
+  return EnvExportFormatSchema.parse(value);
+}