@dbx-tools/cli 0.9.131 → 0.9.136

package/lib/src/tunnel/proxy.js

@@ -31,13 +31,14 @@ function sendJson(response, status, body, setCookie) {
 /**
  * Hand every Better Auth and compatibility route to the shared gate runtime.
  */
-async function handleAuthRoute(request, response, path, gate, brandName) {
+async function handleAuthRoute(request, response, path, gate, brandName, passkeyNamePrefix) {
     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,
+            passkeyNamePrefix,
             returnTo: tunnelGate.loginReturnTo(request),
         }));
         return true;
@@ -75,14 +76,18 @@ export async function startProxy(options) {
         void (async () => {
             const path = (request.url ?? "/").split("?")[0] ?? "/";
             const brandName = options.brandName ?? "this app";
-            if (gate && (await handleAuthRoute(request, response, path, gate, brandName)))
+            const passkeyNamePrefix = options.passkeyNamePrefix;
+            if (gate &&
+                (await handleAuthRoute(request, response, path, gate, brandName, passkeyNamePrefix))) {
                 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,
+                        passkeyNamePrefix,
                         returnTo: tunnelGate.requestReturnTo(request),
                     });
                     response.writeHead(401, { "content-type": "text/html; charset=utf-8" });
@@ -140,4 +145,4 @@ export async function startProxy(options) {
         });
     })));
 }
-//# 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 { errorUtils, 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: errorUtils.toError(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"]}
+//# 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 { errorUtils, 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  /** Prefix added before the humanized tunnel subdomain in new passkey names. */\n  passkeyNamePrefix?: 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  passkeyNamePrefix?: 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        passkeyNamePrefix,\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      const passkeyNamePrefix = options.passkeyNamePrefix;\n      if (\n        gate &&\n        (await handleAuthRoute(request, response, path, gate, brandName, passkeyNamePrefix))\n      ) {\n        return;\n      }\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            passkeyNamePrefix,\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: errorUtils.toError(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","../src/appkit/cli.ts","../src/appkit/env-export.ts","../src/appkit/index.ts","../src/auth/cli.ts","../src/auth/index.ts","../src/auth/options.ts","../src/genie-code/cli.ts","../src/genie-code/config.ts","../src/genie-code/index.ts","../src/genie-code/install.ts","../src/genie-code/options.ts","../src/genie-code/runner.ts","../src/genie-code/runtime.ts","../src/graphiti/cli.ts","../src/graphiti/index.ts","../src/graphiti/options.ts","../src/lakebase-proxy/cancellation.ts","../src/lakebase-proxy/cli.ts","../src/lakebase-proxy/index.ts","../src/lakebase-proxy/options.ts","../src/lakebase-proxy/protocol.ts","../src/lakebase-proxy/proxy.ts","../src/model-gateway/cli.ts","../src/model-gateway/index.ts","../src/model-gateway/server.ts","../src/tunnel/app.ts","../src/tunnel/cli.ts","../src/tunnel/index.ts","../src/tunnel/options.ts","../src/tunnel/proxy.ts","../index.ts","../bin/dbx-genie.ts","../bin/dbx-graphiti.ts","../bin/dbx-lakebase-proxy.ts","../bin/dbx-model-gateway.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/appkit/index.ts","../src/auth/cli.ts","../src/auth/index.ts","../src/auth/options.ts","../src/brand/cli.ts","../src/brand/export.ts","../src/brand/index.ts","../src/brand/options.ts","../src/brand/run.ts","../src/genie-code/cli.ts","../src/genie-code/config.ts","../src/genie-code/index.ts","../src/genie-code/install.ts","../src/genie-code/options.ts","../src/genie-code/runner.ts","../src/genie-code/runtime.ts","../src/graphiti/cli.ts","../src/graphiti/index.ts","../src/graphiti/options.ts","../src/lakebase-proxy/cancellation.ts","../src/lakebase-proxy/cli.ts","../src/lakebase-proxy/index.ts","../src/lakebase-proxy/options.ts","../src/lakebase-proxy/protocol.ts","../src/lakebase-proxy/proxy.ts","../src/model-gateway/cli.ts","../src/model-gateway/index.ts","../src/model-gateway/server.ts","../src/tunnel/app.ts","../src/tunnel/cli.ts","../src/tunnel/index.ts","../src/tunnel/options.ts","../src/tunnel/proxy.ts","../index.ts","../bin/dbx-genie.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

@@ -34,30 +34,34 @@
   "dependencies": {
     "@clack/prompts": "^1.7.0",
     "@databricks/appkit": "0.81.0",
-    "@dbx-tools/appkit": "^0.9.131",
-    "@dbx-tools/appkit-memory": "^0.9.131",
-    "@dbx-tools/appkit-model-gateway": "^0.9.131",
-    "@dbx-tools/auth": "^0.9.131",
-    "@dbx-tools/auth-gate": "^0.9.131",
-    "@dbx-tools/cli-args": "^0.9.131",
-    "@dbx-tools/cli-service": "^0.9.131",
-    "@dbx-tools/core": "^0.9.131",
-    "@dbx-tools/databricks": "^0.9.131",
-    "@dbx-tools/email": "^0.9.131",
-    "@dbx-tools/lakebase": "^0.9.131",
-    "@dbx-tools/postgres": "^0.9.131",
-    "@dbx-tools/shared-auth": "^0.9.131",
-    "@dbx-tools/shared-core": "^0.9.131",
-    "@dbx-tools/shared-email": "^0.9.131",
-    "@dbx-tools/shared-genie-code": "^0.9.131",
-    "@dbx-tools/shared-model-gateway": "^0.9.131",
-    "@dbx-tools/tunnel": "^0.9.131",
+    "@dbx-tools/appkit": "^0.9.136",
+    "@dbx-tools/appkit-generator": "^0.9.136",
+    "@dbx-tools/appkit-memory": "^0.9.136",
+    "@dbx-tools/appkit-model-gateway": "^0.9.136",
+    "@dbx-tools/appkit-web-search": "^0.9.136",
+    "@dbx-tools/auth": "^0.9.136",
+    "@dbx-tools/auth-gate": "^0.9.136",
+    "@dbx-tools/cli-args": "^0.9.136",
+    "@dbx-tools/cli-service": "^0.9.136",
+    "@dbx-tools/core": "^0.9.136",
+    "@dbx-tools/databricks": "^0.9.136",
+    "@dbx-tools/email": "^0.9.136",
+    "@dbx-tools/lakebase": "^0.9.136",
+    "@dbx-tools/postgres": "^0.9.136",
+    "@dbx-tools/shared-auth": "^0.9.136",
+    "@dbx-tools/shared-core": "^0.9.136",
+    "@dbx-tools/shared-email": "^0.9.136",
+    "@dbx-tools/shared-generator": "^0.9.136",
+    "@dbx-tools/shared-genie-code": "^0.9.136",
+    "@dbx-tools/shared-model-gateway": "^0.9.136",
+    "@dbx-tools/tunnel": "^0.9.136",
     "commander": "^15.0.0",
     "concurrently": "^10.0.3",
     "get-port": "^7.1.0",
     "http-proxy-3": "^1.23.1",
     "pg": "^8.22.0",
     "smol-toml": "1.8.0",
+    "yaml": "^2.9.0",
     "zod": "4.3.6"
   },
   "main": "./lib/index.js",
@@ -115,6 +119,22 @@
         "types": "./lib/src/auth/options.d.ts",
         "default": "./lib/src/auth/options.js"
       },
+      "./brand": {
+        "types": "./lib/src/brand/cli.d.ts",
+        "default": "./lib/src/brand/cli.js"
+      },
+      "./brand/export": {
+        "types": "./lib/src/brand/export.d.ts",
+        "default": "./lib/src/brand/export.js"
+      },
+      "./brand/options": {
+        "types": "./lib/src/brand/options.d.ts",
+        "default": "./lib/src/brand/options.js"
+      },
+      "./brand/run": {
+        "types": "./lib/src/brand/run.d.ts",
+        "default": "./lib/src/brand/run.js"
+      },
       "./graphiti": {
         "types": "./lib/src/graphiti/cli.d.ts",
         "default": "./lib/src/graphiti/cli.js"
@@ -158,7 +178,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.9.131",
+  "version": "0.9.136",
   "types": "./lib/index.d.ts",
   "dbxToolsConfig": {
     "tags": [
@@ -207,6 +227,22 @@
       "types": "./lib/src/auth/options.d.ts",
       "default": "./lib/src/auth/options.js"
     },
+    "./brand": {
+      "types": "./lib/src/brand/cli.d.ts",
+      "default": "./lib/src/brand/cli.js"
+    },
+    "./brand/export": {
+      "types": "./lib/src/brand/export.d.ts",
+      "default": "./lib/src/brand/export.js"
+    },
+    "./brand/options": {
+      "types": "./lib/src/brand/options.d.ts",
+      "default": "./lib/src/brand/options.js"
+    },
+    "./brand/run": {
+      "types": "./lib/src/brand/run.d.ts",
+      "default": "./lib/src/brand/run.js"
+    },
     "./graphiti": {
       "types": "./lib/src/graphiti/cli.d.ts",
       "default": "./lib/src/graphiti/cli.js"

package/src/brand/cli.ts

@@ -0,0 +1,52 @@
+/**
+ * `dbx brand` researched brand-package export.
+ *
+ * @module
+ */
+
+import { addArgs, parseArgs } from "@dbx-tools/cli-args";
+import { Command } from "commander";
+
+import { BrandExportOptionsSchema } from "./options.ts";
+import { exportBrandFromPrompt } from "./run.ts";
+
+/** Replaceable command boundaries used by tests and embedders. */
+export interface BrandCliDependencies {
+  readonly exportBrandFromPrompt?: typeof exportBrandFromPrompt;
+  readonly writeProgress?: (value: string) => void;
+  readonly writeResult?: (value: unknown) => void;
+}
+
+/** Build the lazily loaded `dbx brand` command. */
+export function buildProgram(name = "dbx brand", dependencies: BrandCliDependencies = {}): Command {
+  const runExport = dependencies.exportBrandFromPrompt ?? exportBrandFromPrompt;
+  const writeProgress =
+    dependencies.writeProgress ?? ((value: string) => process.stderr.write(`${value}\n`));
+  const writeResult =
+    dependencies.writeResult ??
+    ((value: unknown) => process.stdout.write(`${JSON.stringify(value, null, 2)}\n`));
+  const program = addArgs(
+    new Command()
+      .name(name)
+      .description(
+        "Research a brand brief and export brand.yaml with web and mobile visual references",
+      ),
+    BrandExportOptionsSchema,
+  );
+  program
+    .argument("<prompt>", "brand, company, product, or design brief to research")
+    .action(async (prompt: string) => {
+      const options = parseArgs(program, BrandExportOptionsSchema);
+      const result = await runExport(prompt, options, {
+        onProgress(event) {
+          writeProgress(`[${event.stage}] ${event.message}`);
+        },
+      });
+      writeResult({
+        brand: result.brandYamlPath,
+        manifest: result.manifestPath,
+        references: result.referenceCount,
+      });
+    });
+  return program;
+}

package/src/brand/export.ts

@@ -0,0 +1,144 @@
+/**
+ * Brand package filesystem export.
+ *
+ * @module
+ */
+
+import { access, mkdir, rename, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import type { BrandResearch } from "@dbx-tools/appkit-generator";
+import type { BrandPackage } from "@dbx-tools/shared-generator";
+import { BrandPackageSchema } from "@dbx-tools/shared-generator";
+import { stringify } from "yaml";
+
+/** Inputs required to write a generated brand package. */
+export interface WriteBrandPackageOptions {
+  readonly outputDirectory: string;
+  readonly prompt: string;
+  readonly brandPackage: BrandPackage;
+  readonly research: BrandResearch;
+  readonly force?: boolean;
+}
+
+/** Files written for a generated brand package. */
+export interface WrittenBrandPackage {
+  readonly outputDirectory: string;
+  readonly brandYamlPath: string;
+  readonly manifestPath: string;
+  readonly referenceCount: number;
+}
+
+function imageExtension(contentType?: string): string {
+  if (!contentType) return ".img";
+  const normalized = contentType.split(";", 1)[0].trim().toLowerCase();
+  switch (normalized) {
+    case "image/avif":
+      return ".avif";
+    case "image/gif":
+      return ".gif";
+    case "image/jpeg":
+      return ".jpg";
+    case "image/png":
+      return ".png";
+    case "image/svg+xml":
+      return ".svg";
+    case "image/webp":
+      return ".webp";
+    default:
+      return ".img";
+  }
+}
+
+function fileSlug(value: string): string {
+  return (
+    value
+      .normalize("NFKD")
+      .replace(/[\u0300-\u036f]/g, "")
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, "-")
+      .replace(/^-+|-+$/g, "")
+      .slice(0, 60) || "reference"
+  );
+}
+
+async function writeAtomic(filePath: string, content: string | Uint8Array): Promise<void> {
+  await mkdir(path.dirname(filePath), { recursive: true });
+  const temporaryPath = `${filePath}.${process.pid}.${crypto.randomUUID()}.tmp`;
+  await writeFile(temporaryPath, content);
+  await rename(temporaryPath, filePath);
+}
+
+async function fileExists(filePath: string): Promise<boolean> {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Write a normal `brand.yaml` plus research provenance and downloaded visual
+ * references.
+ */
+export async function writeBrandPackage(
+  options: WriteBrandPackageOptions,
+): Promise<WrittenBrandPackage> {
+  const outputDirectory = path.resolve(options.outputDirectory);
+  const brandYamlPath = path.join(outputDirectory, "brand.yaml");
+  const packageExists = await fileExists(brandYamlPath);
+  if (packageExists && !options.force) {
+    throw new Error(`Brand package already exists at ${brandYamlPath}; pass --force to replace it`);
+  }
+  if (options.force) {
+    await rm(path.join(outputDirectory, "references"), { recursive: true, force: true });
+  }
+
+  const visualReferences = structuredClone(options.brandPackage.visualReferences);
+  let referenceCount = 0;
+  for (
+    let referenceIndex = 0;
+    referenceIndex < options.research.visualReferences.length;
+    referenceIndex += 1
+  ) {
+    const researchReference = options.research.visualReferences[referenceIndex];
+    const exportedReference = visualReferences[referenceIndex];
+    if (!exportedReference) continue;
+    for (let imageIndex = 0; imageIndex < researchReference.images.length; imageIndex += 1) {
+      const researchImage = researchReference.images[imageIndex];
+      const exportedImage = exportedReference.images[imageIndex];
+      if (!exportedImage || !researchImage.data) continue;
+      const fileName = `${fileSlug(researchReference.appName)}-${imageIndex + 1}${imageExtension(researchImage.contentType)}`;
+      const relativePath = path.posix.join("references", researchReference.platform, fileName);
+      await writeAtomic(path.join(outputDirectory, relativePath), researchImage.data);
+      exportedImage.localPath = `./${relativePath}`;
+      referenceCount += 1;
+    }
+  }
+
+  const brandPackage = BrandPackageSchema.parse({
+    ...options.brandPackage,
+    visualReferences,
+  });
+  const manifestPath = path.join(outputDirectory, "brand-package.json");
+  await writeAtomic(brandYamlPath, stringify(brandPackage.brand, { indent: 2 }));
+  await writeAtomic(
+    manifestPath,
+    `${JSON.stringify(
+      {
+        prompt: options.prompt,
+        generatedAt: new Date().toISOString(),
+        ...brandPackage,
+      },
+      null,
+      2,
+    )}\n`,
+  );
+
+  return {
+    outputDirectory,
+    brandYamlPath,
+    manifestPath,
+    referenceCount,
+  };
+}

package/src/brand/index.ts

@@ -0,0 +1,13 @@
+// GENERATED by projen watch - DO NOT EDIT.
+// Regenerated from the exporting modules in ./src.
+// Hand edits are overwritten on the next watch; this file is read-only.
+
+export * as cli from "./cli.ts";
+export * as exportModule from "./export.ts";
+export * as options from "./options.ts";
+export * as run from "./run.ts";
+export type { BrandCliDependencies } from "./cli.ts";
+export type { WriteBrandPackageOptions, WrittenBrandPackage } from "./export.ts";
+export { BrandExportOptionsSchema } from "./options.ts";
+export type { BrandExportOptions } from "./options.ts";
+export type { BrandExportCallbacks } from "./run.ts";

package/src/brand/options.ts

@@ -0,0 +1,48 @@
+/**
+ * `dbx brand` option contracts.
+ *
+ * @module
+ */
+
+import { DatabricksAuthOptionsSchema } from "@dbx-tools/auth/config";
+import { z } from "zod";
+
+/** Options for exporting one researched brand package. */
+export const BrandExportOptionsSchema = z
+  .object({
+    profile: DatabricksAuthOptionsSchema.shape.profile,
+    name: z.string().trim().min(1).optional().describe("Known canonical brand name."),
+    website: z.string().url().optional().describe("Known official HTTPS website."),
+    output: z
+      .string()
+      .trim()
+      .min(1)
+      .default("branding")
+      .describe("Output directory for brand.yaml, provenance, and visual references."),
+    model: z
+      .string()
+      .trim()
+      .min(1)
+      .optional()
+      .describe("Optional Databricks model preference for brand synthesis."),
+    maxSources: z.coerce
+      .number()
+      .int()
+      .min(1)
+      .max(8)
+      .default(4)
+      .describe("Maximum general web sources to read."),
+    sourceMaxLength: z.coerce
+      .number()
+      .int()
+      .min(1_000)
+      .max(20_000)
+      .default(8_000)
+      .describe("Maximum characters retained from each source page."),
+    force: z.boolean().default(false).describe("Replace files in an existing output directory."),
+  })
+  .strict()
+  .describe("Options for exporting a researched brand package.");
+
+/** Resolved brand export options. */
+export type BrandExportOptions = z.output<typeof BrandExportOptionsSchema>;

package/src/brand/run.ts

@@ -0,0 +1,85 @@
+/**
+ * Standalone researched brand generation for the consolidated CLI.
+ *
+ * @module
+ */
+
+import type { BrandResearch } from "@dbx-tools/appkit-generator";
+import { generateBrandPackage } from "@dbx-tools/appkit-generator/generate";
+import {
+  runWebAssetPageFetch,
+  runWebFetch,
+  runWebImageFetch,
+} from "@dbx-tools/appkit-web-search/fetch";
+import { createWebSearchRuntime } from "@dbx-tools/appkit-web-search/runtime";
+import { runWebSearch } from "@dbx-tools/appkit-web-search/search";
+import { createWorkspaceClient } from "@dbx-tools/databricks/workspace-client";
+import type { BrandGenerationProgressEvent } from "@dbx-tools/shared-generator";
+
+import { writeBrandPackage, type WrittenBrandPackage } from "./export.ts";
+import type { BrandExportOptions } from "./options.ts";
+
+/** Optional observers for one CLI brand generation run. */
+export interface BrandExportCallbacks {
+  readonly onProgress?: (event: BrandGenerationProgressEvent) => void | Promise<void>;
+}
+
+/**
+ * Research a freeform brand brief, synthesize a portable context, and export
+ * the package to disk.
+ */
+export async function exportBrandFromPrompt(
+  prompt: string,
+  options: BrandExportOptions,
+  callbacks: BrandExportCallbacks = {},
+): Promise<WrittenBrandPackage> {
+  const workspaceClient = await createWorkspaceClient({
+    ...(options.profile ? { profile: options.profile } : {}),
+  });
+  const host = (await workspaceClient.config.getHost()).toString();
+  const runtime = createWebSearchRuntime({
+    ...(options.model ? { model: options.model } : {}),
+  });
+  let research: BrandResearch | undefined;
+  const brandPackage = await generateBrandPackage(
+    {
+      prompt,
+      ...(options.name ? { name: options.name } : {}),
+      ...(options.website ? { website: options.website } : {}),
+    },
+    {
+      client: {
+        search: (request, signal) =>
+          runWebSearch(
+            request,
+            runtime,
+            {
+              client: workspaceClient,
+              host,
+              ...(options.profile ? { cacheIdentity: `profile:${options.profile}` } : {}),
+            },
+            signal,
+          ),
+        fetch: (request, signal) => runWebFetch(request, runtime, signal),
+        fetchAssetPage: (request, signal) => runWebAssetPageFetch(request, runtime, signal),
+        fetchImage: (request, signal) => runWebImageFetch(request, runtime, signal),
+      },
+      workspaceClient,
+      ...(options.model ? { model: options.model } : {}),
+      maxSources: options.maxSources,
+      sourceMaxLength: options.sourceMaxLength,
+      ...(callbacks.onProgress ? { onProgress: callbacks.onProgress } : {}),
+      onResearch(value) {
+        research = value;
+      },
+    },
+  );
+  if (!research) throw new Error("Brand generation completed without research provenance");
+  return writeBrandPackage({
+    outputDirectory: options.output,
+    prompt,
+    brandPackage,
+    research,
+    force: options.force,
+  });
+}

package/src/cli.ts

@@ -4,6 +4,7 @@
  * `dev` bootstraps or repairs a workspace and forwards to projen.
  * `appkit` provides AppKit environment helpers.
  * `auth` manages Databricks OAuth and access tokens.
+ * `brand` researches and exports portable brand packages.
  * `tunnel` runs a public portr tunnel with passwordless access gating.
  *
  * Feature commands load their sibling packages only when selected and forward
@@ -88,7 +89,7 @@ export function buildProgram(name: string = PROGRAM_NAMES[0]): Command {
   const program = new Command()
     .name(name)
     .description(
-      "Databricks developer tools: workspace lifecycle, AppKit env, auth, tunnels, and local proxies",
+      "Databricks developer tools: workspace lifecycle, AppKit env, auth, brand generation, tunnels, and local proxies",
     )
     .enablePositionalOptions()
     .showHelpAfterError()
@@ -97,7 +98,7 @@ export function buildProgram(name: string = PROGRAM_NAMES[0]): Command {
   program
     .command("dev")
     .description("Bootstrap or repair a dbx-tools workspace, then forward to projen")
-    .argument("[projenArgs...]", "projen task and arguments (e.g. sync --watch)")
+    .argument("[projenArgs...]", "Projen task and arguments, for example sync --watch")
     .allowUnknownOption()
     .allowExcessArguments()
     .helpOption(false)
@@ -119,6 +120,13 @@ export function buildProgram(name: string = PROGRAM_NAMES[0]): Command {
     async () => (await import("./auth/cli.ts")).buildProgram,
   );
 
+  addForwardedCommand(
+    program,
+    "brand",
+    "Research and export a portable brand package",
+    async () => (await import("./brand/cli.ts")).buildProgram,
+  );
+
   addForwardedCommand(
     program,
     "tunnel",
@@ -163,6 +171,7 @@ export async function buildDocumentationProgram(name: string = PROGRAM_NAMES[0])
   const children = [
     (await import("./appkit/cli.ts")).buildProgram("appkit"),
     (await import("./auth/cli.ts")).buildProgram("auth"),
+    (await import("./brand/cli.ts")).buildProgram("brand"),
     (await import("./tunnel/cli.ts")).buildProgram("tunnel"),
     (await import("./lakebase-proxy/cli.ts")).buildProgram("lakebase-proxy"),
     (await import("./model-gateway/cli.ts")).buildProgram("model-gateway"),

package/src/genie-code/cli.ts

@@ -34,7 +34,7 @@ export function buildProgram(
       .description("Run Genie Code through an authenticated local Databricks model gateway")
       .argument(
         "[genieArgs...]",
-        "arguments and unknown flags forwarded to Genie Code; wrapper options may be separated with --",
+        "Arguments and unknown flags forwarded to Genie Code. Separate wrapper options with --",
       )
       .allowUnknownOption()
       .passThroughOptions()

package/src/tunnel/cli.ts

@@ -132,6 +132,7 @@ async function run(raw: TunnelOptions, command: readonly string[]): Promise<void
     forwardHeaders: resolved.gate.forwardHeaders,
     gatePaths: resolved.gate.gatePaths,
     brandName: resolved.gate.brandName,
+    passkeyNamePrefix: resolved.gate.passkeyNamePrefix,
     bindHosts: resolved.bindHosts,
   });