@dbx-tools/cli 0.9.58 → 0.9.60

package/bin/dbx-graphiti.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env bun
+
+import { buildProgram } from "../src/graphiti/cli.ts";
+
+await buildProgram("dbx-graphiti").parseAsync(process.argv);

package/bin/dbx-lakebase-proxy.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { buildProgram } from "../src/lakebase-proxy/cli.ts";
+
+await buildProgram("dbx-lakebase-proxy").parseAsync(process.argv);

package/bin/dbx-model-gateway.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env bun
+
+import { buildProgram } from "../src/model-gateway/cli.ts";
+
+await buildProgram("dbx-model-gateway").parseAsync(process.argv);

package/index.ts

@@ -3,10 +3,44 @@
 // Hand edits are overwritten on the next watch; this file is read-only.
 
 export const PACKAGE_IDENTIFIER = "@dbx-tools/cli";
-export const PACKAGE_VERSION = "0.9.58";
+export const PACKAGE_VERSION = "0.9.60";
+export * as appkitCli from "./src/appkit/cli.ts";
+export * as appkitEnvExport from "./src/appkit/env-export.ts";
+export * as authCli from "./src/auth/cli.ts";
+export * as authOptions from "./src/auth/options.ts";
 export * as bootstrap from "./src/bootstrap.ts";
 export * as bun from "./src/bun.ts";
 export * as cli from "./src/cli.ts";
+export * as graphitiCli from "./src/graphiti/cli.ts";
+export * as graphitiOptions from "./src/graphiti/options.ts";
+export * as lakebaseProxyCancellation from "./src/lakebase-proxy/cancellation.ts";
+export * as lakebaseProxyCli from "./src/lakebase-proxy/cli.ts";
+export * as lakebaseProxyOptions from "./src/lakebase-proxy/options.ts";
+export * as lakebaseProxyProtocol from "./src/lakebase-proxy/protocol.ts";
+export * as lakebaseProxyProxy from "./src/lakebase-proxy/proxy.ts";
+export * as modelGatewayCli from "./src/model-gateway/cli.ts";
+export * as modelGatewayServer from "./src/model-gateway/server.ts";
 export * as root from "./src/root.ts";
+export * as tunnelApp from "./src/tunnel/app.ts";
+export * as tunnelCli from "./src/tunnel/cli.ts";
+export * as tunnelOptions from "./src/tunnel/options.ts";
+export * as tunnelProxy from "./src/tunnel/proxy.ts";
+export { EnvExportFormatSchema, EnvCommandOptionsSchema } from "./src/appkit/env-export.ts";
+export type { EnvExportFormat, EnvCommandOptions } from "./src/appkit/env-export.ts";
+export { AuthCliOptionsSchema, TokenCommandOptionsSchema } from "./src/auth/options.ts";
+export type { AuthCliOptions, TokenCommandOptions } from "./src/auth/options.ts";
 export { resolveBunArgv } from "./src/bun.ts";
+export type { GraphitiCliDependencies, GraphitiServiceOptions } from "./src/graphiti/cli.ts";
+export { CancellationRegistry } from "./src/lakebase-proxy/cancellation.ts";
+export type { CancellationTarget, CancellationForwarder } from "./src/lakebase-proxy/cancellation.ts";
+export type { LakebaseProxyCliDependencies } from "./src/lakebase-proxy/cli.ts";
+export { LakebaseProxyOptionsSchema, LakebaseProxyUrlOptionsSchema } from "./src/lakebase-proxy/options.ts";
+export type { LakebaseProxyOptions, ResolvedLakebaseProxyOptions, LakebaseProxyUrlOptions } from "./src/lakebase-proxy/options.ts";
+export { SSL_REQUEST, CANCEL_REQUEST, PROTOCOL_3, PostgresProtocolError } from "./src/lakebase-proxy/protocol.ts";
+export type { StartupMessage, CancelMessage, InitialMessage } from "./src/lakebase-proxy/protocol.ts";
+export { LakebaseProxy } from "./src/lakebase-proxy/proxy.ts";
+export type { ModelGatewayCliDependencies } from "./src/model-gateway/cli.ts";
 export { workspaceRoot } from "./src/root.ts";
+export { TunnelOptionsSchema } from "./src/tunnel/options.ts";
+export type { TunnelOptions, ResolvedTunnelOptions } from "./src/tunnel/options.ts";
+export type { ProxyOptions } from "./src/tunnel/proxy.ts";

package/lib/bin/dbx-graphiti.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};

package/lib/bin/dbx-graphiti.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env bun
+import { buildProgram } from "../src/graphiti/cli.js";
+await buildProgram("dbx-graphiti").parseAsync(process.argv);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGJ4LWdyYXBoaXRpLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vYmluL2RieC1ncmFwaGl0aS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBRUEsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBRXRELE1BQU0sWUFBWSxDQUFDLGNBQWMsQ0FBQyxDQUFDLFVBQVUsQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIjIS91c3IvYmluL2VudiBidW5cblxuaW1wb3J0IHsgYnVpbGRQcm9ncmFtIH0gZnJvbSBcIi4uL3NyYy9ncmFwaGl0aS9jbGkudHNcIjtcblxuYXdhaXQgYnVpbGRQcm9ncmFtKFwiZGJ4LWdyYXBoaXRpXCIpLnBhcnNlQXN5bmMocHJvY2Vzcy5hcmd2KTtcbiJdfQ==

package/lib/bin/dbx-lakebase-proxy.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/lib/bin/dbx-lakebase-proxy.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { buildProgram } from "../src/lakebase-proxy/cli.js";
+await buildProgram("dbx-lakebase-proxy").parseAsync(process.argv);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGJ4LWxha2ViYXNlLXByb3h5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vYmluL2RieC1sYWtlYmFzZS1wcm94eS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQ0EsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLDhCQUE4QixDQUFDO0FBRTVELE1BQU0sWUFBWSxDQUFDLG9CQUFvQixDQUFDLENBQUMsVUFBVSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIiMhL3Vzci9iaW4vZW52IG5vZGVcbmltcG9ydCB7IGJ1aWxkUHJvZ3JhbSB9IGZyb20gXCIuLi9zcmMvbGFrZWJhc2UtcHJveHkvY2xpLnRzXCI7XG5cbmF3YWl0IGJ1aWxkUHJvZ3JhbShcImRieC1sYWtlYmFzZS1wcm94eVwiKS5wYXJzZUFzeW5jKHByb2Nlc3MuYXJndik7XG4iXX0=

package/lib/bin/dbx-model-gateway.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};

package/lib/bin/dbx-model-gateway.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env bun
+import { buildProgram } from "../src/model-gateway/cli.js";
+await buildProgram("dbx-model-gateway").parseAsync(process.argv);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGJ4LW1vZGVsLWdhdGV3YXkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9iaW4vZGJ4LW1vZGVsLWdhdGV3YXkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUVBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUUzRCxNQUFNLFlBQVksQ0FBQyxtQkFBbUIsQ0FBQyxDQUFDLFVBQVUsQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIjIS91c3IvYmluL2VudiBidW5cblxuaW1wb3J0IHsgYnVpbGRQcm9ncmFtIH0gZnJvbSBcIi4uL3NyYy9tb2RlbC1nYXRld2F5L2NsaS50c1wiO1xuXG5hd2FpdCBidWlsZFByb2dyYW0oXCJkYngtbW9kZWwtZ2F0ZXdheVwiKS5wYXJzZUFzeW5jKHByb2Nlc3MuYXJndik7XG4iXX0=

package/lib/index.d.ts

@@ -1,8 +1,42 @@
 export declare const PACKAGE_IDENTIFIER = "@dbx-tools/cli";
-export declare const PACKAGE_VERSION = "0.9.58";
+export declare const PACKAGE_VERSION = "0.9.60";
+export * as appkitCli from "./src/appkit/cli.ts";
+export * as appkitEnvExport from "./src/appkit/env-export.ts";
+export * as authCli from "./src/auth/cli.ts";
+export * as authOptions from "./src/auth/options.ts";
 export * as bootstrap from "./src/bootstrap.ts";
 export * as bun from "./src/bun.ts";
 export * as cli from "./src/cli.ts";
+export * as graphitiCli from "./src/graphiti/cli.ts";
+export * as graphitiOptions from "./src/graphiti/options.ts";
+export * as lakebaseProxyCancellation from "./src/lakebase-proxy/cancellation.ts";
+export * as lakebaseProxyCli from "./src/lakebase-proxy/cli.ts";
+export * as lakebaseProxyOptions from "./src/lakebase-proxy/options.ts";
+export * as lakebaseProxyProtocol from "./src/lakebase-proxy/protocol.ts";
+export * as lakebaseProxyProxy from "./src/lakebase-proxy/proxy.ts";
+export * as modelGatewayCli from "./src/model-gateway/cli.ts";
+export * as modelGatewayServer from "./src/model-gateway/server.ts";
 export * as root from "./src/root.ts";
+export * as tunnelApp from "./src/tunnel/app.ts";
+export * as tunnelCli from "./src/tunnel/cli.ts";
+export * as tunnelOptions from "./src/tunnel/options.ts";
+export * as tunnelProxy from "./src/tunnel/proxy.ts";
+export { EnvExportFormatSchema, EnvCommandOptionsSchema } from "./src/appkit/env-export.ts";
+export type { EnvExportFormat, EnvCommandOptions } from "./src/appkit/env-export.ts";
+export { AuthCliOptionsSchema, TokenCommandOptionsSchema } from "./src/auth/options.ts";
+export type { AuthCliOptions, TokenCommandOptions } from "./src/auth/options.ts";
 export { resolveBunArgv } from "./src/bun.ts";
+export type { GraphitiCliDependencies, GraphitiServiceOptions } from "./src/graphiti/cli.ts";
+export { CancellationRegistry } from "./src/lakebase-proxy/cancellation.ts";
+export type { CancellationTarget, CancellationForwarder } from "./src/lakebase-proxy/cancellation.ts";
+export type { LakebaseProxyCliDependencies } from "./src/lakebase-proxy/cli.ts";
+export { LakebaseProxyOptionsSchema, LakebaseProxyUrlOptionsSchema } from "./src/lakebase-proxy/options.ts";
+export type { LakebaseProxyOptions, ResolvedLakebaseProxyOptions, LakebaseProxyUrlOptions } from "./src/lakebase-proxy/options.ts";
+export { SSL_REQUEST, CANCEL_REQUEST, PROTOCOL_3, PostgresProtocolError } from "./src/lakebase-proxy/protocol.ts";
+export type { StartupMessage, CancelMessage, InitialMessage } from "./src/lakebase-proxy/protocol.ts";
+export { LakebaseProxy } from "./src/lakebase-proxy/proxy.ts";
+export type { ModelGatewayCliDependencies } from "./src/model-gateway/cli.ts";
 export { workspaceRoot } from "./src/root.ts";
+export { TunnelOptionsSchema } from "./src/tunnel/options.ts";
+export type { TunnelOptions, ResolvedTunnelOptions } from "./src/tunnel/options.ts";
+export type { ProxyOptions } from "./src/tunnel/proxy.ts";

package/lib/index.js

@@ -2,11 +2,35 @@
 // Regenerated from the exporting modules in ./src.
 // Hand edits are overwritten on the next watch; this file is read-only.
 export const PACKAGE_IDENTIFIER = "@dbx-tools/cli";
-export const PACKAGE_VERSION = "0.9.58";
+export const PACKAGE_VERSION = "0.9.60";
+export * as appkitCli from "./src/appkit/cli.js";
+export * as appkitEnvExport from "./src/appkit/env-export.js";
+export * as authCli from "./src/auth/cli.js";
+export * as authOptions from "./src/auth/options.js";
 export * as bootstrap from "./src/bootstrap.js";
 export * as bun from "./src/bun.js";
 export * as cli from "./src/cli.js";
+export * as graphitiCli from "./src/graphiti/cli.js";
+export * as graphitiOptions from "./src/graphiti/options.js";
+export * as lakebaseProxyCancellation from "./src/lakebase-proxy/cancellation.js";
+export * as lakebaseProxyCli from "./src/lakebase-proxy/cli.js";
+export * as lakebaseProxyOptions from "./src/lakebase-proxy/options.js";
+export * as lakebaseProxyProtocol from "./src/lakebase-proxy/protocol.js";
+export * as lakebaseProxyProxy from "./src/lakebase-proxy/proxy.js";
+export * as modelGatewayCli from "./src/model-gateway/cli.js";
+export * as modelGatewayServer from "./src/model-gateway/server.js";
 export * as root from "./src/root.js";
+export * as tunnelApp from "./src/tunnel/app.js";
+export * as tunnelCli from "./src/tunnel/cli.js";
+export * as tunnelOptions from "./src/tunnel/options.js";
+export * as tunnelProxy from "./src/tunnel/proxy.js";
+export { EnvExportFormatSchema, EnvCommandOptionsSchema } from "./src/appkit/env-export.js";
+export { AuthCliOptionsSchema, TokenCommandOptionsSchema } from "./src/auth/options.js";
 export { resolveBunArgv } from "./src/bun.js";
+export { CancellationRegistry } from "./src/lakebase-proxy/cancellation.js";
+export { LakebaseProxyOptionsSchema, LakebaseProxyUrlOptionsSchema } from "./src/lakebase-proxy/options.js";
+export { SSL_REQUEST, CANCEL_REQUEST, PROTOCOL_3, PostgresProtocolError } from "./src/lakebase-proxy/protocol.js";
+export { LakebaseProxy } from "./src/lakebase-proxy/proxy.js";
 export { workspaceRoot } from "./src/root.js";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwyQ0FBMkM7QUFDM0MsbURBQW1EO0FBQ25ELHdFQUF3RTtBQUV4RSxNQUFNLENBQUMsTUFBTSxrQkFBa0IsR0FBRyxnQkFBZ0IsQ0FBQztBQUNuRCxNQUFNLENBQUMsTUFBTSxlQUFlLEdBQUcsUUFBUSxDQUFDO0FBQ3hDLE9BQU8sS0FBSyxTQUFTLE1BQU0sb0JBQW9CLENBQUM7QUFDaEQsT0FBTyxLQUFLLEdBQUcsTUFBTSxjQUFjLENBQUM7QUFDcEMsT0FBTyxLQUFLLEdBQUcsTUFBTSxjQUFjLENBQUM7QUFDcEMsT0FBTyxLQUFLLElBQUksTUFBTSxlQUFlLENBQUM7QUFDdEMsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGNBQWMsQ0FBQztBQUM5QyxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sZUFBZSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gR0VORVJBVEVEIGJ5IHByb2plbiB3YXRjaCAtIERPIE5PVCBFRElULlxuLy8gUmVnZW5lcmF0ZWQgZnJvbSB0aGUgZXhwb3J0aW5nIG1vZHVsZXMgaW4gLi9zcmMuXG4vLyBIYW5kIGVkaXRzIGFyZSBvdmVyd3JpdHRlbiBvbiB0aGUgbmV4dCB3YXRjaDsgdGhpcyBmaWxlIGlzIHJlYWQtb25seS5cblxuZXhwb3J0IGNvbnN0IFBBQ0tBR0VfSURFTlRJRklFUiA9IFwiQGRieC10b29scy9jbGlcIjtcbmV4cG9ydCBjb25zdCBQQUNLQUdFX1ZFUlNJT04gPSBcIjAuOS41OFwiO1xuZXhwb3J0ICogYXMgYm9vdHN0cmFwIGZyb20gXCIuL3NyYy9ib290c3RyYXAudHNcIjtcbmV4cG9ydCAqIGFzIGJ1biBmcm9tIFwiLi9zcmMvYnVuLnRzXCI7XG5leHBvcnQgKiBhcyBjbGkgZnJvbSBcIi4vc3JjL2NsaS50c1wiO1xuZXhwb3J0ICogYXMgcm9vdCBmcm9tIFwiLi9zcmMvcm9vdC50c1wiO1xuZXhwb3J0IHsgcmVzb2x2ZUJ1bkFyZ3YgfSBmcm9tIFwiLi9zcmMvYnVuLnRzXCI7XG5leHBvcnQgeyB3b3Jrc3BhY2VSb290IH0gZnJvbSBcIi4vc3JjL3Jvb3QudHNcIjtcbiJdfQ==
+export { TunnelOptionsSchema } from "./src/tunnel/options.js";
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/appkit/cli.d.ts

@@ -0,0 +1,24 @@
+/**
+ * `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 { Command, CommanderError } from "commander";
+/**
+ * Build the `env` command on its own, so a host CLI can mount it under a
+ * different parent than {@link buildProgram}'s.
+ */
+export declare function buildEnvCommand(name?: string): Command;
+/** Build the `dbx appkit` commander program (no side effects until parsed). */
+export declare function buildProgram(name?: string): Command;
+/** Parse `argv` and run the matching command. Throws {@link CommanderError} on flag errors. */
+export declare function runCli(argv: string[]): Promise<void>;
+export { CommanderError };

package/lib/src/appkit/cli.js

@@ -0,0 +1,54 @@
+/**
+ * `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, } from "./env-export.js";
+const logger = log.logger("appkit-env");
+/** Run auto-config and write the resulting env delta to stdout. */
+async function writeEnvExport(opts) {
+    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") {
+    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") {
+    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) {
+    await buildProgram().parseAsync(argv);
+}
+export { CommanderError };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/appkit/env-export.d.ts

@@ -0,0 +1,40 @@
+/**
+ * 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 declare const EnvExportFormatSchema: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodEnum<{
+    json: "json";
+    export: "export";
+    windows: "windows";
+}>>;
+export type EnvExportFormat = z.output<typeof EnvExportFormatSchema>;
+/** Shallow copy of the current process environment. */
+export declare function snapshotEnv(env?: NodeJS.ProcessEnv): Record<string, string>;
+/**
+ * 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 declare function diffEnv(before: Record<string, string>, after: Record<string, string>): Record<string, string>;
+/** Select Windows `set` output on Windows and POSIX `export` output elsewhere. */
+export declare function defaultEnvExportFormat(platform?: NodeJS.Platform): EnvExportFormat;
+export declare const EnvCommandOptionsSchema: z.ZodObject<{
+    format: z.ZodDefault<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodEnum<{
+        json: "json";
+        export: "export";
+        windows: "windows";
+    }>>>;
+    quiet: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export type EnvCommandOptions = z.output<typeof EnvCommandOptionsSchema>;
+/**
+ * Format env entries for the requested output style. An empty map prints
+ * nothing (no trailing newline).
+ */
+export declare function formatEnvExport(env: Record<string, string>, format: EnvExportFormat): string;
+/** Normalize CLI format aliases to a supported export format. */
+export declare function parseEnvExportFormat(value: string): EnvExportFormat;

package/lib/src/appkit/env-export.js

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

package/lib/src/auth/cli.d.ts

@@ -0,0 +1,20 @@
+/**
+ * `dbx auth` Commander program for Databricks OAuth.
+ *
+ * The command delegates profile resolution and token lifecycle to
+ * `@dbx-tools/auth`.
+ *
+ * @module
+ */
+import * as databricks from "@dbx-tools/auth";
+import { Command, CommanderError } from "commander";
+interface AuthCliDependencies {
+    createAuthClient: typeof databricks.client.createAuthClient;
+    writeJson(value: unknown): void;
+    writeText(value: string): void;
+}
+/** Build the `dbx auth` Commander program without parsing arguments. */
+export declare function buildProgram(name?: string, overrides?: Partial<AuthCliDependencies>): Command;
+/** Parse `argv` and run the selected auth operation. */
+export declare function runCli(argv: string[]): Promise<void>;
+export { CommanderError };

package/lib/src/auth/cli.js

@@ -0,0 +1,118 @@
+/**
+ * `dbx auth` Commander program for Databricks OAuth.
+ *
+ * The command delegates profile resolution and token lifecycle to
+ * `@dbx-tools/auth`.
+ *
+ * @module
+ */
+import * as databricks from "@dbx-tools/auth";
+import { addArgs, parseArgs } from "@dbx-tools/cli-args";
+import { Command, CommanderError } from "commander";
+import { AuthCliOptionsSchema, databricksAuthOptions, TokenCommandOptionsSchema, } from "./options.js";
+const DEFAULT_DEPENDENCIES = {
+    createAuthClient: databricks.client.createAuthClient,
+    writeJson: (value) => {
+        process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+    },
+    writeText: (value) => {
+        process.stdout.write(`${value}\n`);
+    },
+};
+/** Open the selected authentication client. */
+async function openAuth(options, dependencies) {
+    return {
+        auth: await dependencies.createAuthClient(databricksAuthOptions(options)),
+        close: async () => { },
+    };
+}
+/** Execute an auth action and close resources owned by the command. */
+async function withAuth(options, dependencies, action) {
+    const context = await openAuth(options, dependencies);
+    try {
+        await action(context);
+    }
+    finally {
+        await context.close();
+    }
+}
+/** Shape a generated token record for stable CLI JSON output. */
+function tokenJson(token) {
+    return {
+        access_token: token.accessToken,
+        token_type: token.tokenType,
+        ...(token.expiry ? { expiry: token.expiry } : {}),
+        ...(token.scopes.length ? { scopes: token.scopes } : {}),
+    };
+}
+/** Select the serializable identity fields from an authentication client. */
+function clientInfo(auth) {
+    return {
+        ...(auth.profile ? { profile: auth.profile } : {}),
+        host: auth.host,
+        ...(auth.accountId ? { accountId: auth.accountId } : {}),
+        ...(auth.workspaceId ? { workspaceId: auth.workspaceId } : {}),
+        target: auth.target,
+        authType: auth.authType,
+        principal: auth.principal,
+    };
+}
+/** Build the `dbx auth` Commander program without parsing arguments. */
+export function buildProgram(name = "dbx auth", overrides = {}) {
+    const dependencies = { ...DEFAULT_DEPENDENCIES, ...overrides };
+    const program = addArgs(new Command()
+        .name(name)
+        .description("Authenticate to Databricks with user or machine OAuth")
+        .showHelpAfterError(), AuthCliOptionsSchema);
+    const options = () => parseArgs(program, AuthCliOptionsSchema);
+    program
+        .command("login")
+        .description("Force browser login and return an access token")
+        .action(async () => {
+        await withAuth(options(), dependencies, async ({ auth }) => {
+            dependencies.writeJson(tokenJson(await auth.token({ login: true })));
+        });
+    });
+    const tokenCommand = addArgs(program.command("token").description("Return a valid access token, logging in when needed"), TokenCommandOptionsSchema);
+    tokenCommand.action(async () => {
+        const tokenOptions = parseArgs(tokenCommand, TokenCommandOptionsSchema);
+        await withAuth(options(), dependencies, async ({ auth }) => {
+            const token = await auth.token({
+                ...(tokenOptions.login ? {} : { login: false }),
+                ...(tokenOptions.forceRefresh ? { refresh: true } : {}),
+            });
+            dependencies.writeJson(tokenJson(token));
+        });
+    });
+    program
+        .command("profile")
+        .description("Print the configured or automatically detected profile")
+        .action(async () => {
+        await withAuth(options(), dependencies, async ({ auth }) => {
+            dependencies.writeText(auth.profile ?? "ambient");
+        });
+    });
+    program
+        .command("logout")
+        .description("Delete the stored credential for the selected profile")
+        .action(async () => {
+        await withAuth(options(), dependencies, async ({ auth }) => {
+            await auth.logout();
+        });
+    });
+    program
+        .command("status")
+        .description("Show the resolved authentication client configuration")
+        .action(async () => {
+        await withAuth(options(), dependencies, async ({ auth }) => {
+            dependencies.writeJson(clientInfo(auth));
+        });
+    });
+    return program;
+}
+/** Parse `argv` and run the selected auth operation. */
+export async function runCli(argv) {
+    await buildProgram().parseAsync(argv);
+}
+export { CommanderError };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cli.js","sourceRoot":"","sources":["../../../src/auth/cli.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * `dbx auth` Commander program for Databricks OAuth.\n *\n * The command delegates profile resolution and token lifecycle to\n * `@dbx-tools/auth`.\n *\n * @module\n */\n\nimport * as databricks from \"@dbx-tools/auth\";\nimport { addArgs, parseArgs } from \"@dbx-tools/cli-args\";\nimport type { DatabricksAuthClientInfo } from \"@dbx-tools/shared-auth/client\";\nimport { Command, CommanderError } from \"commander\";\n\nimport {\n  AuthCliOptionsSchema,\n  databricksAuthOptions,\n  TokenCommandOptionsSchema,\n  type AuthCliOptions,\n} from \"./options.ts\";\n\ninterface AuthContext {\n  auth: databricks.AuthClient;\n  close(): Promise<void>;\n}\n\ninterface AuthCliDependencies {\n  createAuthClient: typeof databricks.client.createAuthClient;\n  writeJson(value: unknown): void;\n  writeText(value: string): void;\n}\n\nconst DEFAULT_DEPENDENCIES: AuthCliDependencies = {\n  createAuthClient: databricks.client.createAuthClient,\n  writeJson: (value) => {\n    process.stdout.write(`${JSON.stringify(value, null, 2)}\\n`);\n  },\n  writeText: (value) => {\n    process.stdout.write(`${value}\\n`);\n  },\n};\n\n/** Open the selected authentication client. */\nasync function openAuth(\n  options: AuthCliOptions,\n  dependencies: AuthCliDependencies,\n): Promise<AuthContext> {\n  return {\n    auth: await dependencies.createAuthClient(databricksAuthOptions(options)),\n    close: async () => {},\n  };\n}\n\n/** Execute an auth action and close resources owned by the command. */\nasync function withAuth(\n  options: AuthCliOptions,\n  dependencies: AuthCliDependencies,\n  action: (context: AuthContext) => Promise<void>,\n): Promise<void> {\n  const context = await openAuth(options, dependencies);\n  try {\n    await action(context);\n  } finally {\n    await context.close();\n  }\n}\n\n/** Shape a generated token record for stable CLI JSON output. */\nfunction tokenJson(token: databricks.AccessToken): Record<string, unknown> {\n  return {\n    access_token: token.accessToken,\n    token_type: token.tokenType,\n    ...(token.expiry ? { expiry: token.expiry } : {}),\n    ...(token.scopes.length ? { scopes: token.scopes } : {}),\n  };\n}\n\n/** Select the serializable identity fields from an authentication client. */\nfunction clientInfo(auth: databricks.AuthClient): DatabricksAuthClientInfo {\n  return {\n    ...(auth.profile ? { profile: auth.profile } : {}),\n    host: auth.host,\n    ...(auth.accountId ? { accountId: auth.accountId } : {}),\n    ...(auth.workspaceId ? { workspaceId: auth.workspaceId } : {}),\n    target: auth.target,\n    authType: auth.authType,\n    principal: auth.principal,\n  };\n}\n\n/** Build the `dbx auth` Commander program without parsing arguments. */\nexport function buildProgram(\n  name = \"dbx auth\",\n  overrides: Partial<AuthCliDependencies> = {},\n): Command {\n  const dependencies = { ...DEFAULT_DEPENDENCIES, ...overrides };\n  const program = addArgs(\n    new Command()\n      .name(name)\n      .description(\"Authenticate to Databricks with user or machine OAuth\")\n      .showHelpAfterError(),\n    AuthCliOptionsSchema,\n  );\n  const options = (): AuthCliOptions => parseArgs(program, AuthCliOptionsSchema);\n\n  program\n    .command(\"login\")\n    .description(\"Force browser login and return an access token\")\n    .action(async () => {\n      await withAuth(options(), dependencies, async ({ auth }) => {\n        dependencies.writeJson(tokenJson(await auth.token({ login: true })));\n      });\n    });\n\n  const tokenCommand = addArgs(\n    program.command(\"token\").description(\"Return a valid access token, logging in when needed\"),\n    TokenCommandOptionsSchema,\n  );\n  tokenCommand.action(async () => {\n    const tokenOptions = parseArgs(tokenCommand, TokenCommandOptionsSchema);\n    await withAuth(options(), dependencies, async ({ auth }) => {\n      const token = await auth.token({\n        ...(tokenOptions.login ? {} : { login: false }),\n        ...(tokenOptions.forceRefresh ? { refresh: true } : {}),\n      });\n      dependencies.writeJson(tokenJson(token));\n    });\n  });\n\n  program\n    .command(\"profile\")\n    .description(\"Print the configured or automatically detected profile\")\n    .action(async () => {\n      await withAuth(options(), dependencies, async ({ auth }) => {\n        dependencies.writeText(auth.profile ?? \"ambient\");\n      });\n    });\n\n  program\n    .command(\"logout\")\n    .description(\"Delete the stored credential for the selected profile\")\n    .action(async () => {\n      await withAuth(options(), dependencies, async ({ auth }) => {\n        await auth.logout();\n      });\n    });\n\n  program\n    .command(\"status\")\n    .description(\"Show the resolved authentication client configuration\")\n    .action(async () => {\n      await withAuth(options(), dependencies, async ({ auth }) => {\n        dependencies.writeJson(clientInfo(auth));\n      });\n    });\n\n  return program;\n}\n\n/** Parse `argv` and run the selected auth operation. */\nexport async function runCli(argv: string[]): Promise<void> {\n  await buildProgram().parseAsync(argv);\n}\n\nexport { CommanderError };\n"]}