airfoil 0.4.0 → 0.4.1

package/dist/index.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import { NodeRuntime, NodeServices } from "@effect/platform-node";
-import { Effect, FileSystem, Option, Path, String } from "effect";
+import { Config, Effect, FileSystem, Layer, Option, Path, Redacted, Stream, String as String$1 } from "effect";
 import { Argument, Command, Flag, Prompt } from "effect/unstable/cli";
 import { FetchHttpClient, HttpClient, HttpClientResponse } from "effect/unstable/http";
 import * as p from "@clack/prompts";
-import { WingsClusterMetadata } from "@useairfoil/wings";
+import { ClusterClient } from "@useairfoil/wings";
 import { printTable } from "console-table-printer";
 import * as fs from "node:fs";
 import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
@@ -15,18 +15,18 @@ import { ArrowFlightSqlClient } from "@useairfoil/flight";
 import { Metadata } from "nice-grpc-common";
 
 //#region package.json
-var version$1 = "0.3.0";
+var version$1 = "0.4.0";
 
 //#endregion
 //#region src/utils/client.ts
-const makeClusterMetadataLayer = (host, port) => WingsClusterMetadata.layer({ host: `${host}:${port}` });
+const makeClusterClientLayer = (host, port) => ClusterClient.layer({ host: `${host}:${port}` });
 
 //#endregion
 //#region src/utils/options.ts
 /**
 * Common server connection options
 */
-const hostOption = Flag.string("host").pipe(Flag.withDescription("Server host"), Flag.withDefault("localhost"));
+const hostOption = Flag.string("host").pipe(Flag.withDescription("Server host"), Flag.withDefault("127.0.0.1"));
 const portOption = Flag.integer("port").pipe(Flag.withDescription("Server port"), Flag.withAlias("p"), Flag.withDefault(7777));
 /**
 * Common pagination options
@@ -39,674 +39,263 @@ const pageTokenOption = Flag.optional(Flag.string("page-token").pipe(Flag.withDe
 const forceOption = Flag.boolean("force").pipe(Flag.withDescription("Skip confirmation prompt"), Flag.withDefault(false));
 
 //#endregion
-//#region src/commands/cluster/data-lake/create-iceberg.ts
-const parentOption$11 = Flag.string("parent").pipe(Flag.withDescription("Parent tenant in format: tenants/{tenant}"));
-const dataLakeIdOption$1 = Flag.string("data-lake-id").pipe(Flag.withDescription("Unique identifier for the data lake"));
-const createDataLakeIcebergCommand = Command.make("iceberg", {
-	parent: parentOption$11,
-	dataLakeId: dataLakeIdOption$1,
-	host: hostOption,
-	port: portOption
-}, ({ parent, dataLakeId, host, port }) => Effect.gen(function* () {
-	p.intro("🏞️  Create Iceberg Data Lake");
-	const layer = makeClusterMetadataLayer(host, port);
-	const s = p.spinner();
-	s.start("Creating Iceberg data lake...");
-	const result = yield* WingsClusterMetadata.createDataLake({
-		parent,
-		dataLakeId,
-		dataLakeConfig: {
+//#region src/commands/cluster/namespace/create.ts
+const namespaceIdOption = Flag.string("namespace-id").pipe(Flag.withDescription("Unique identifier for the namespace (e.g., 'production')"));
+const lakeOption = Flag.string("lake").pipe(Flag.withDescription("Lake format: iceberg, parquet, or delta"), Flag.withDefault("iceberg"));
+const prefixOption = Flag.string("prefix").pipe(Flag.withDescription("Storage prefix (optional)"), Flag.optional);
+function makeLakeConfig(lake) {
+	switch (lake) {
+		case "iceberg": return { lakeConfig: {
 			_tag: "iceberg",
 			iceberg: {}
-		}
-	}).pipe(Effect.provide(layer), Effect.tapError(() => Effect.sync(() => s.stop("Failed to create data lake"))));
-	s.stop("Iceberg data lake created successfully");
-	yield* Effect.sync(() => {
-		printTable([{
-			name: result.name,
-			type: "Iceberg"
-		}]);
-		p.outro("✓ Done");
-	});
-})).pipe(Command.withDescription("Create a new Iceberg data lake"));
-
-//#endregion
-//#region src/commands/cluster/data-lake/create-parquet.ts
-const parentOption$10 = Flag.string("parent").pipe(Flag.withDescription("Parent tenant in format: tenants/{tenant}"));
-const dataLakeIdOption = Flag.string("data-lake-id").pipe(Flag.withDescription("Unique identifier for the data lake"));
-const createDataLakeParquetCommand = Command.make("parquet", {
-	parent: parentOption$10,
-	dataLakeId: dataLakeIdOption,
-	host: hostOption,
-	port: portOption
-}, ({ parent, dataLakeId, host, port }) => Effect.gen(function* () {
-	p.intro("🏞️  Create Parquet Data Lake");
-	const layer = makeClusterMetadataLayer(host, port);
-	const s = p.spinner();
-	s.start("Creating Parquet data lake...");
-	const result = yield* WingsClusterMetadata.createDataLake({
-		parent,
-		dataLakeId,
-		dataLakeConfig: {
+		} };
+		case "parquet": return { lakeConfig: {
 			_tag: "parquet",
 			parquet: {}
-		}
-	}).pipe(Effect.provide(layer), Effect.tapError(() => Effect.sync(() => s.stop("Failed to create data lake"))));
-	s.stop("Parquet data lake created successfully");
-	yield* Effect.sync(() => {
-		printTable([{
-			name: result.name,
-			type: "Parquet"
-		}]);
-		p.outro("✓ Done");
-	});
-})).pipe(Command.withDescription("Create a new Parquet data lake"));
-
-//#endregion
-//#region src/commands/cluster/data-lake/create.ts
-const createDataLakeCommand = Command.make("create-data-lake", {}, () => Effect.void).pipe(Command.withDescription("Create a new data lake"), Command.withSubcommands([createDataLakeIcebergCommand, createDataLakeParquetCommand]));
-
-//#endregion
-//#region src/commands/cluster/data-lake/delete.ts
-const nameOption$9 = Flag.string("name").pipe(Flag.withDescription("Data lake name in format: tenants/{tenant}/data-lakes/{data-lake}"));
-const deleteDataLakeCommand = Command.make("delete-data-lake", {
-	name: nameOption$9,
-	force: forceOption,
-	host: hostOption,
-	port: portOption
-}, ({ name, force, host, port }) => Effect.gen(function* () {
-	p.intro("🗑️  Delete Data Lake");
-	if (!force) {
-		const confirm = yield* Effect.tryPromise({
-			try: () => p.confirm({
-				message: `Are you sure you want to delete data lake ${name}?`,
-				initialValue: false
-			}),
-			catch: () => /* @__PURE__ */ new Error("Failed to confirm deletion")
-		});
-		if (p.isCancel(confirm) || !confirm) {
-			p.cancel("Deletion cancelled");
-			process.exit(0);
-		}
+		} };
+		case "delta": return { lakeConfig: {
+			_tag: "delta",
+			delta: {}
+		} };
+		default: throw new Error(`Invalid lake type: "${lake}". Must be iceberg, parquet, or delta.`);
 	}
-	const layer = makeClusterMetadataLayer(host, port);
-	const s = p.spinner();
-	s.start("Deleting data lake...");
-	yield* WingsClusterMetadata.deleteDataLake({ name }).pipe(Effect.provide(layer), Effect.tapError(() => Effect.sync(() => s.stop("Failed to delete data lake"))));
-	s.stop("Data lake deleted successfully");
+}
+function displayNamespace(namespace) {
+	printTable([{
+		name: namespace.name,
+		object_store: namespace.objectStore?.objectStoreConfig._tag ?? "-",
+		lake: namespace.lake?.lakeConfig._tag ?? "-"
+	}]);
 	p.outro("✓ Done");
-})).pipe(Command.withDescription("Delete a data lake from the cluster"));
-
-//#endregion
-//#region src/commands/cluster/data-lake/get.ts
-const nameOption$8 = Flag.string("name").pipe(Flag.withDescription("Data lake name in format: tenants/{tenant}/data-lakes/{data-lake}"));
-const getDataLakeCommand = Command.make("get-data-lake", {
-	name: nameOption$8,
-	host: hostOption,
-	port: portOption
-}, ({ name, host, port }) => Effect.gen(function* () {
-	const layer = makeClusterMetadataLayer(host, port);
-	const s = p.spinner();
-	s.start("Fetching data lake...");
-	const dataLake = yield* WingsClusterMetadata.getDataLake({ name }).pipe(Effect.provide(layer), Effect.tapError(() => Effect.sync(() => s.stop("Failed to get data lake"))));
-	s.stop("Data lake retrieved");
-	yield* Effect.sync(() => {
-		printTable([{
-			name: dataLake.name,
-			type: dataLake.dataLakeConfig._tag || "-"
-		}]);
-		p.outro("✓ Done");
-	});
-})).pipe(Command.withDescription("Get details of a specific data lake"));
-
-//#endregion
-//#region src/commands/cluster/data-lake/list.ts
-const parentOption$9 = Flag.string("parent").pipe(Flag.withDescription("Parent tenant in format: tenants/{tenant}"));
-const listDataLakesCommand = Command.make("list-data-lakes", {
-	parent: parentOption$9,
-	pageSize: pageSizeOption,
-	pageToken: pageTokenOption,
-	host: hostOption,
-	port: portOption
-}, ({ parent, pageSize, pageToken, host, port }) => Effect.gen(function* () {
-	const layer = makeClusterMetadataLayer(host, port);
-	const s = p.spinner();
-	s.start("Fetching data lakes...");
-	const response = yield* WingsClusterMetadata.listDataLakes({
-		parent,
-		pageSize,
-		pageToken: Option.getOrUndefined(pageToken)
-	}).pipe(Effect.provide(layer), Effect.tapError(() => Effect.sync(() => s.stop("Failed to list data lakes"))));
-	s.stop(`Found ${response.dataLakes.length} data lake(s)`);
-	yield* Effect.sync(() => {
-		if (response.dataLakes.length === 0) p.log.warn("No data lakes found");
-		else printTable(response.dataLakes.map((dataLake) => ({
-			name: dataLake.name,
-			type: dataLake.dataLakeConfig._tag || "-"
-		})));
-		if (response.nextPageToken) p.log.info(`Next page token: ${response.nextPageToken}`);
-		p.outro("✓ Done");
-	});
-})).pipe(Command.withDescription("List all data lakes belonging to a tenant"));
-
-//#endregion
-//#region src/commands/cluster/namespace/create.ts
-const parentOption$8 = Flag.string("parent").pipe(Flag.withDescription("Parent tenant in format: tenants/{tenant} (e.g., 'tenants/default')"));
-const namespaceIdOption = Flag.string("namespace-id").pipe(Flag.withDescription("Unique identifier for the namespace (e.g., 'production')"));
-const flushSizeBytesOption = Flag.integer("flush-size-bytes").pipe(Flag.withDescription("Size at which the current segment is flushed to object storage"), Flag.withDefault(0));
-const flushIntervalMillisOption = Flag.integer("flush-interval-millis").pipe(Flag.withDescription("Maximum interval at which the current segment is flushed (milliseconds)"), Flag.withDefault(0));
-const objectStoreOption = Flag.string("object-store").pipe(Flag.withDescription("Object store used by this namespace (format: tenants/{tenant}/object-stores/{object-store})"));
-const dataLakeOption = Flag.string("data-lake").pipe(Flag.withDescription("Data lake used by this namespace (format: tenants/{tenant}/data-lakes/{data-lake})"));
-const createNamespaceCommand = Command.make("create-namespace", {
-	parent: parentOption$8,
+}
+const createNamespaceAwsCommand = Command.make("aws", {
 	namespaceId: namespaceIdOption,
-	flushSizeBytes: flushSizeBytesOption,
-	flushIntervalMillis: flushIntervalMillisOption,
-	objectStore: objectStoreOption,
-	dataLake: dataLakeOption,
+	lake: lakeOption,
+	bucketName: Flag.string("bucket-name").pipe(Flag.withDescription("AWS S3 bucket name")),
+	prefix: prefixOption,
+	accessKeyId: Flag.redacted("access-key-id").pipe(Flag.withDescription("AWS access key ID (or set AWS_ACCESS_KEY_ID env var)"), Flag.withFallbackConfig(Config.redacted("AWS_ACCESS_KEY_ID"))),
+	secretAccessKey: Flag.redacted("secret-access-key").pipe(Flag.withDescription("AWS secret access key (or set AWS_SECRET_ACCESS_KEY env var)"), Flag.withFallbackConfig(Config.redacted("AWS_SECRET_ACCESS_KEY"))),
+	region: Flag.string("region").pipe(Flag.withDescription("AWS region (e.g., us-east-1)"), Flag.optional),
 	host: hostOption,
 	port: portOption
-}, ({ parent, namespaceId, flushSizeBytes, flushIntervalMillis, objectStore, dataLake, host, port }) => Effect.gen(function* () {
-	p.intro("📁 Create Namespace");
-	const layer = makeClusterMetadataLayer(host, port);
+}, ({ namespaceId, lake, bucketName, prefix, accessKeyId, secretAccessKey, region }) => Effect.gen(function* () {
+	p.intro("📁 Create Namespace (AWS S3)");
+	const lakeConfig = yield* Effect.try({
+		try: () => makeLakeConfig(lake),
+		catch: (e) => e instanceof Error ? e : new Error(String(e))
+	});
 	const s = p.spinner();
 	s.start("Creating namespace...");
-	const namespace = yield* WingsClusterMetadata.createNamespace({
-		parent,
+	const namespace = yield* ClusterClient.createNamespace({
 		namespaceId,
-		flushSizeBytes: BigInt(flushSizeBytes),
-		flushIntervalMillis: BigInt(flushIntervalMillis),
-		objectStore,
-		dataLake
-	}).pipe(Effect.provide(layer), Effect.tapError(() => Effect.sync(() => s.stop("Failed to create namespace"))));
-	s.stop("Namespace created successfully");
-	yield* Effect.sync(() => {
-		printTable([{
-			name: namespace.name,
-			flush_size_bytes: namespace.flushSizeBytes.toString(),
-			flush_interval_millis: namespace.flushIntervalMillis.toString(),
-			object_store: namespace.objectStore || "-",
-			data_lake: namespace.dataLake || "-"
-		}]);
-		p.outro("✓ Done");
-	});
-})).pipe(Command.withDescription("Create a new namespace belonging to a tenant"));
-
-//#endregion
-//#region src/commands/cluster/namespace/delete.ts
-const nameOption$7 = Flag.string("name").pipe(Flag.withDescription("Namespace name in format: tenants/{tenant}/namespaces/{namespace}"));
-const deleteNamespaceCommand = Command.make("delete-namespace", {
-	name: nameOption$7,
-	force: forceOption,
-	host: hostOption,
-	port: portOption
-}, ({ name, force, host, port }) => Effect.gen(function* () {
-	p.intro("🗑️  Delete Namespace");
-	if (!force) {
-		const confirm = yield* Effect.tryPromise({
-			try: () => p.confirm({
-				message: `Are you sure you want to delete namespace ${name}?`,
-				initialValue: false
-			}),
-			catch: () => /* @__PURE__ */ new Error("Failed to confirm deletion")
-		});
-		if (p.isCancel(confirm) || !confirm) {
-			p.cancel("Deletion cancelled");
-			process.exit(0);
-		}
-	}
-	const layer = makeClusterMetadataLayer(host, port);
-	const s = p.spinner();
-	s.start("Deleting namespace...");
-	yield* WingsClusterMetadata.deleteNamespace({ name }).pipe(Effect.provide(layer), Effect.tapError(() => Effect.sync(() => s.stop("Failed to delete namespace"))));
-	s.stop("Namespace deleted successfully");
-	p.outro("✓ Done");
-})).pipe(Command.withDescription("Delete a namespace from the cluster (fails if namespace has any topics)"));
-
-//#endregion
-//#region src/commands/cluster/namespace/get.ts
-const nameOption$6 = Flag.string("name").pipe(Flag.withDescription("Namespace name in format: tenants/{tenant}/namespaces/{namespace}"));
-const getNamespaceCommand = Command.make("get-namespace", {
-	name: nameOption$6,
-	host: hostOption,
-	port: portOption
-}, ({ name, host, port }) => Effect.gen(function* () {
-	const layer = makeClusterMetadataLayer(host, port);
-	const s = p.spinner();
-	s.start("Fetching namespace...");
-	const namespace = yield* WingsClusterMetadata.getNamespace({ name }).pipe(Effect.provide(layer), Effect.tapError(() => Effect.sync(() => s.stop("Failed to get namespace"))));
-	s.stop("Namespace retrieved");
-	yield* Effect.sync(() => {
-		printTable([{
-			name: namespace.name,
-			flush_size_bytes: namespace.flushSizeBytes.toString(),
-			flush_interval_millis: namespace.flushIntervalMillis.toString(),
-			object_store: namespace.objectStore || "-",
-			data_lake: namespace.dataLake || "-"
-		}]);
-		p.outro("✓ Done");
-	});
-})).pipe(Command.withDescription("Get details of a specific namespace"));
-
-//#endregion
-//#region src/commands/cluster/namespace/list.ts
-const parentOption$7 = Flag.string("parent").pipe(Flag.withDescription("Parent tenant in format: tenants/{tenant} (e.g., 'tenants/default')"));
-const listNamespacesCommand = Command.make("list-namespaces", {
-	parent: parentOption$7,
-	pageSize: pageSizeOption,
-	pageToken: pageTokenOption,
-	host: hostOption,
-	port: portOption
-}, ({ parent, pageSize, pageToken, host, port }) => Effect.gen(function* () {
-	const layer = makeClusterMetadataLayer(host, port);
-	const s = p.spinner();
-	s.start("Fetching namespaces...");
-	const response = yield* WingsClusterMetadata.listNamespaces({
-		parent,
-		pageSize,
-		pageToken: Option.getOrUndefined(pageToken)
-	}).pipe(Effect.provide(layer), Effect.tapError(() => Effect.sync(() => s.stop("Failed to list namespaces"))));
-	s.stop(`Found ${response.namespaces.length} namespace(s)`);
-	yield* Effect.sync(() => {
-		if (response.namespaces.length === 0) p.log.warn("No namespaces found");
-		else printTable(response.namespaces.map((namespace) => ({
-			name: namespace.name,
-			flush_size_bytes: namespace.flushSizeBytes.toString(),
-			flush_interval_millis: namespace.flushIntervalMillis.toString(),
-			object_store: namespace.objectStore || "-",
-			data_lake: namespace.dataLake || "-"
-		})));
-		if (response.nextPageToken) p.log.info(`Next page token: ${response.nextPageToken}`);
-		p.outro("✓ Done");
-	});
-})).pipe(Command.withDescription("List all namespaces belonging to a tenant"));
-
-//#endregion
-//#region src/commands/cluster/object-store/create-aws.ts
-const parentOption$6 = Flag.string("parent").pipe(Flag.withDescription("Parent tenant in format: tenants/{tenant}"));
-const objectStoreIdOption$3 = Flag.string("object-store-id").pipe(Flag.withDescription("Unique identifier for the object store"));
-const bucketNameOption$2 = Flag.string("bucket-name").pipe(Flag.withDescription("AWS S3 bucket name"));
-const prefixOption$3 = Flag.string("prefix").pipe(Flag.withDescription("Bucket prefix (optional)"), Flag.optional);
-const accessKeyIdOption$1 = Flag.string("access-key-id").pipe(Flag.withDescription("AWS_ACCESS_KEY_ID"));
-const secretAccessKeyOption$1 = Flag.string("secret-access-key").pipe(Flag.withDescription("AWS_SECRET_ACCESS_KEY"));
-const regionOption$1 = Flag.string("region").pipe(Flag.withDescription("AWS_DEFAULT_REGION (e.g., us-east-1)"), Flag.optional);
-const createObjectStoreAwsCommand = Command.make("aws", {
-	parent: parentOption$6,
-	objectStoreId: objectStoreIdOption$3,
-	bucketName: bucketNameOption$2,
-	prefix: prefixOption$3,
-	accessKeyId: accessKeyIdOption$1,
-	secretAccessKey: secretAccessKeyOption$1,
-	region: regionOption$1,
-	host: hostOption,
-	port: portOption
-}, ({ parent, objectStoreId, bucketName, prefix, accessKeyId, secretAccessKey, region, host, port }) => Effect.gen(function* () {
-	p.intro("🗄️  Create AWS S3 Object Store");
-	const layer = makeClusterMetadataLayer(host, port);
-	const s = p.spinner();
-	s.start("Creating AWS S3 object store...");
-	const result = yield* WingsClusterMetadata.createObjectStore({
-		parent,
-		objectStoreId,
-		objectStoreConfig: {
+		objectStore: { objectStoreConfig: {
 			_tag: "aws",
 			aws: {
 				bucketName,
 				prefix: Option.getOrUndefined(prefix),
-				accessKeyId,
-				secretAccessKey,
+				accessKeyId: Redacted.value(accessKeyId),
+				secretAccessKey: Redacted.value(secretAccessKey),
 				region: Option.getOrUndefined(region)
 			}
-		}
-	}).pipe(Effect.provide(layer), Effect.tapError(() => Effect.sync(() => s.stop("Failed to create AWS object store"))));
-	s.stop("AWS S3 object store created successfully");
-	yield* Effect.sync(() => {
-		printTable([{
-			name: result.name,
-			type: "AWS S3",
-			bucket: bucketName,
-			region: Option.getOrUndefined(region) || "-"
-		}]);
-		p.outro("✓ Done");
-	});
-})).pipe(Command.withDescription("Create a new AWS S3 object store"));
-
-//#endregion
-//#region src/commands/cluster/object-store/create-azure.ts
-const parentOption$5 = Flag.string("parent").pipe(Flag.withDescription("Parent tenant in format: tenants/{tenant}"));
-const objectStoreIdOption$2 = Flag.string("object-store-id").pipe(Flag.withDescription("Unique identifier for the object store"));
-const containerNameOption = Flag.string("container-name").pipe(Flag.withDescription("Azure container name"));
-const prefixOption$2 = Flag.string("prefix").pipe(Flag.withDescription("Container prefix (optional)"), Flag.optional);
-const storageAccountNameOption = Flag.string("storage-account-name").pipe(Flag.withDescription("AZURE_STORAGE_ACCOUNT_NAME"));
-const storageAccountKeyOption = Flag.string("storage-account-key").pipe(Flag.withDescription("AZURE_STORAGE_ACCOUNT_KEY"));
-const createObjectStoreAzureCommand = Command.make("azure", {
-	parent: parentOption$5,
-	objectStoreId: objectStoreIdOption$2,
-	containerName: containerNameOption,
-	prefix: prefixOption$2,
-	storageAccountName: storageAccountNameOption,
-	storageAccountKey: storageAccountKeyOption,
+		} },
+		lake: lakeConfig
+	}).pipe(Effect.tapError(() => Effect.sync(() => s.stop("Failed to create namespace"))));
+	s.stop("Namespace created successfully");
+	yield* Effect.sync(() => displayNamespace(namespace));
+})).pipe(Command.withDescription("Create a namespace backed by AWS S3"), Command.provide(({ host, port }) => makeClusterClientLayer(host, port)));
+const createNamespaceAzureCommand = Command.make("azure", {
+	namespaceId: namespaceIdOption,
+	lake: lakeOption,
+	containerName: Flag.string("container-name").pipe(Flag.withDescription("Azure Blob container name")),
+	prefix: prefixOption,
+	storageAccountName: Flag.string("storage-account-name").pipe(Flag.withDescription("Azure storage account name")),
+	storageAccountKey: Flag.redacted("storage-account-key").pipe(Flag.withDescription("Azure storage account key (or set AZURE_STORAGE_ACCOUNT_KEY env var)"), Flag.withFallbackConfig(Config.redacted("AZURE_STORAGE_ACCOUNT_KEY"))),
 	host: hostOption,
 	port: portOption
-}, ({ parent, objectStoreId, containerName, prefix, storageAccountName, storageAccountKey, host, port }) => Effect.gen(function* () {
-	p.intro("🗄️  Create Azure Blob Storage Object Store");
-	const layer = makeClusterMetadataLayer(host, port);
+}, ({ namespaceId, lake, containerName, prefix, storageAccountName, storageAccountKey }) => Effect.gen(function* () {
+	p.intro("📁 Create Namespace (Azure Blob)");
+	const lakeConfig = yield* Effect.try({
+		try: () => makeLakeConfig(lake),
+		catch: (e) => e instanceof Error ? e : new Error(String(e))
+	});
 	const s = p.spinner();
-	s.start("Creating Azure object store...");
-	const result = yield* WingsClusterMetadata.createObjectStore({
-		parent,
-		objectStoreId,
-		objectStoreConfig: {
+	s.start("Creating namespace...");
+	const namespace = yield* ClusterClient.createNamespace({
+		namespaceId,
+		objectStore: { objectStoreConfig: {
 			_tag: "azure",
 			azure: {
 				containerName,
 				prefix: Option.getOrUndefined(prefix),
 				storageAccountName,
-				storageAccountKey
+				storageAccountKey: Redacted.value(storageAccountKey)
 			}
-		}
-	}).pipe(Effect.provide(layer), Effect.tapError(() => Effect.sync(() => s.stop("Failed to create Azure object store"))));
-	s.stop("Azure object store created successfully");
-	yield* Effect.sync(() => {
-		printTable([{
-			name: result.name,
-			type: "Azure Blob",
-			container: containerName,
-			account: storageAccountName
-		}]);
-		p.outro("✓ Done");
-	});
-})).pipe(Command.withDescription("Create a new Azure Blob Storage object store"));
-
-//#endregion
-//#region src/commands/cluster/object-store/create-google.ts
-const parentOption$4 = Flag.string("parent").pipe(Flag.withDescription("Parent tenant in format: tenants/{tenant}"));
-const objectStoreIdOption$1 = Flag.string("object-store-id").pipe(Flag.withDescription("Unique identifier for the object store"));
-const bucketNameOption$1 = Flag.string("bucket-name").pipe(Flag.withDescription("Google Cloud Storage bucket name"));
-const prefixOption$1 = Flag.string("prefix").pipe(Flag.withDescription("Bucket prefix (optional)"), Flag.optional);
-const serviceAccountOption = Flag.string("service-account").pipe(Flag.withDescription("GOOGLE_SERVICE_ACCOUNT"));
-const serviceAccountKeyOption = Flag.string("service-account-key").pipe(Flag.withDescription("GOOGLE_SERVICE_ACCOUNT_KEY"));
-const createObjectStoreGoogleCommand = Command.make("google", {
-	parent: parentOption$4,
-	objectStoreId: objectStoreIdOption$1,
-	bucketName: bucketNameOption$1,
-	prefix: prefixOption$1,
-	serviceAccount: serviceAccountOption,
-	serviceAccountKey: serviceAccountKeyOption,
+		} },
+		lake: lakeConfig
+	}).pipe(Effect.tapError(() => Effect.sync(() => s.stop("Failed to create namespace"))));
+	s.stop("Namespace created successfully");
+	yield* Effect.sync(() => displayNamespace(namespace));
+})).pipe(Command.withDescription("Create a namespace backed by Azure Blob Storage"), Command.provide(({ host, port }) => makeClusterClientLayer(host, port)));
+const createNamespaceGoogleCommand = Command.make("google", {
+	namespaceId: namespaceIdOption,
+	lake: lakeOption,
+	bucketName: Flag.string("bucket-name").pipe(Flag.withDescription("GCS bucket name")),
+	prefix: prefixOption,
+	serviceAccount: Flag.string("service-account").pipe(Flag.withDescription("GCP service account email")),
+	serviceAccountKey: Flag.redacted("service-account-key").pipe(Flag.withDescription("GCP service account key JSON (or set GOOGLE_SERVICE_ACCOUNT_KEY env var)"), Flag.withFallbackConfig(Config.redacted("GOOGLE_SERVICE_ACCOUNT_KEY"))),
 	host: hostOption,
 	port: portOption
-}, ({ parent, objectStoreId, bucketName, prefix, serviceAccount, serviceAccountKey, host, port }) => Effect.gen(function* () {
-	p.intro("🗄️  Create Google Cloud Storage Object Store");
-	const layer = makeClusterMetadataLayer(host, port);
+}, ({ namespaceId, lake, bucketName, prefix, serviceAccount, serviceAccountKey }) => Effect.gen(function* () {
+	p.intro("📁 Create Namespace (Google Cloud Storage)");
+	const lakeConfig = yield* Effect.try({
+		try: () => makeLakeConfig(lake),
+		catch: (e) => e instanceof Error ? e : new Error(String(e))
+	});
 	const s = p.spinner();
-	s.start("Creating Google Cloud Storage object store...");
-	const result = yield* WingsClusterMetadata.createObjectStore({
-		parent,
-		objectStoreId,
-		objectStoreConfig: {
+	s.start("Creating namespace...");
+	const namespace = yield* ClusterClient.createNamespace({
+		namespaceId,
+		objectStore: { objectStoreConfig: {
 			_tag: "google",
 			google: {
 				bucketName,
 				prefix: Option.getOrUndefined(prefix),
 				serviceAccount,
-				serviceAccountKey
+				serviceAccountKey: Redacted.value(serviceAccountKey)
 			}
-		}
-	}).pipe(Effect.provide(layer), Effect.tapError(() => Effect.sync(() => s.stop("Failed to create Google object store"))));
-	s.stop("Google Cloud Storage object store created successfully");
-	yield* Effect.sync(() => {
-		printTable([{
-			name: result.name,
-			type: "Google Cloud",
-			bucket: bucketName,
-			service_account: serviceAccount
-		}]);
-		p.outro("✓ Done");
-	});
-})).pipe(Command.withDescription("Create a new Google Cloud Storage object store"));
-
-//#endregion
-//#region src/commands/cluster/object-store/create-s3.ts
-const parentOption$3 = Flag.string("parent").pipe(Flag.withDescription("Parent tenant in format: tenants/{tenant}"));
-const objectStoreIdOption = Flag.string("object-store-id").pipe(Flag.withDescription("Unique identifier for the object store"));
-const bucketNameOption = Flag.string("bucket-name").pipe(Flag.withDescription("S3 bucket name"));
-const prefixOption = Flag.string("prefix").pipe(Flag.withDescription("Bucket prefix (optional)"), Flag.optional);
-const accessKeyIdOption = Flag.string("access-key-id").pipe(Flag.withDescription("AWS_ACCESS_KEY_ID"));
-const secretAccessKeyOption = Flag.string("secret-access-key").pipe(Flag.withDescription("AWS_SECRET_ACCESS_KEY"));
-const regionOption = Flag.string("region").pipe(Flag.withDescription("AWS_DEFAULT_REGION"), Flag.optional);
-const endpointOption = Flag.string("endpoint").pipe(Flag.withDescription("AWS_ENDPOINT (e.g., https://nyc3.digitaloceanspaces.com)"));
-const createObjectStoreS3Command = Command.make("s3", {
-	parent: parentOption$3,
-	objectStoreId: objectStoreIdOption,
-	bucketName: bucketNameOption,
+		} },
+		lake: lakeConfig
+	}).pipe(Effect.tapError(() => Effect.sync(() => s.stop("Failed to create namespace"))));
+	s.stop("Namespace created successfully");
+	yield* Effect.sync(() => displayNamespace(namespace));
+})).pipe(Command.withDescription("Create a namespace backed by Google Cloud Storage"), Command.provide(({ host, port }) => makeClusterClientLayer(host, port)));
+const createNamespaceS3Command = Command.make("s3", {
+	namespaceId: namespaceIdOption,
+	lake: lakeOption,
+	bucketName: Flag.string("bucket-name").pipe(Flag.withDescription("S3-compatible bucket name")),
 	prefix: prefixOption,
-	accessKeyId: accessKeyIdOption,
-	secretAccessKey: secretAccessKeyOption,
-	region: regionOption,
-	endpoint: endpointOption,
+	accessKeyId: Flag.redacted("access-key-id").pipe(Flag.withDescription("Access key ID (or set S3_ACCESS_KEY_ID env var)"), Flag.withFallbackConfig(Config.redacted("S3_ACCESS_KEY_ID"))),
+	secretAccessKey: Flag.redacted("secret-access-key").pipe(Flag.withDescription("Secret access key (or set S3_SECRET_ACCESS_KEY env var)"), Flag.withFallbackConfig(Config.redacted("S3_SECRET_ACCESS_KEY"))),
+	endpoint: Flag.string("endpoint").pipe(Flag.withDescription("S3-compatible endpoint URL (e.g., http://minio:9000)")),
+	allowHttp: Flag.boolean("allow-http").pipe(Flag.withDescription("Allow plain HTTP connections"), Flag.withDefault(false)),
+	region: Flag.string("region").pipe(Flag.withDescription("Region"), Flag.optional),
 	host: hostOption,
 	port: portOption
-}, ({ parent, objectStoreId, bucketName, prefix, accessKeyId, secretAccessKey, region, endpoint, host, port }) => Effect.gen(function* () {
-	p.intro("🗄️  Create S3-Compatible Object Store");
-	const layer = makeClusterMetadataLayer(host, port);
+}, ({ namespaceId, lake, bucketName, prefix, accessKeyId, secretAccessKey, endpoint, allowHttp, region }) => Effect.gen(function* () {
+	p.intro("📁 Create Namespace (S3-Compatible)");
+	const lakeConfig = yield* Effect.try({
+		try: () => makeLakeConfig(lake),
+		catch: (e) => e instanceof Error ? e : new Error(String(e))
+	});
 	const s = p.spinner();
-	s.start("Creating S3-compatible object store...");
-	const result = yield* WingsClusterMetadata.createObjectStore({
-		parent,
-		objectStoreId,
-		objectStoreConfig: {
+	s.start("Creating namespace...");
+	const namespace = yield* ClusterClient.createNamespace({
+		namespaceId,
+		objectStore: { objectStoreConfig: {
 			_tag: "s3Compatible",
 			s3Compatible: {
 				bucketName,
 				prefix: Option.getOrUndefined(prefix),
-				accessKeyId,
-				secretAccessKey,
-				region: Option.getOrUndefined(region),
+				accessKeyId: Redacted.value(accessKeyId),
+				secretAccessKey: Redacted.value(secretAccessKey),
 				endpoint,
-				allowHttp: false
+				allowHttp,
+				region: Option.getOrUndefined(region)
 			}
-		}
-	}).pipe(Effect.provide(layer), Effect.tapError(() => Effect.sync(() => s.stop("Failed to create S3-compatible object store"))));
-	s.stop("S3-compatible object store created successfully");
-	yield* Effect.sync(() => {
-		printTable([{
-			name: result.name,
-			type: "S3-Compatible",
-			bucket: bucketName,
-			endpoint
-		}]);
-		p.outro("✓ Done");
-	});
-})).pipe(Command.withDescription("Create a new S3-compatible object store (MinIO, DigitalOcean, etc.)"));
-
-//#endregion
-//#region src/commands/cluster/object-store/create.ts
-const createObjectStoreCommand = Command.make("create-object-store", {}, () => Effect.void).pipe(Command.withDescription("Create a new object store"), Command.withSubcommands([
-	createObjectStoreAwsCommand,
-	createObjectStoreAzureCommand,
-	createObjectStoreGoogleCommand,
-	createObjectStoreS3Command
+		} },
+		lake: lakeConfig
+	}).pipe(Effect.tapError(() => Effect.sync(() => s.stop("Failed to create namespace"))));
+	s.stop("Namespace created successfully");
+	yield* Effect.sync(() => displayNamespace(namespace));
+})).pipe(Command.withDescription("Create a namespace backed by an S3-compatible object store"), Command.provide(({ host, port }) => makeClusterClientLayer(host, port)));
+const createNamespaceCommand = Command.make("create-namespace", {}, () => Effect.void).pipe(Command.withDescription("Create a new namespace (choose a storage provider as subcommand: aws, azure, google, s3)"), Command.withSubcommands([
+	createNamespaceAwsCommand,
+	createNamespaceAzureCommand,
+	createNamespaceGoogleCommand,
+	createNamespaceS3Command
 ]));
 
 //#endregion
-//#region src/commands/cluster/object-store/delete.ts
-const nameOption$5 = Flag.string("name").pipe(Flag.withDescription("Object store name in format: tenants/{tenant}/object-stores/{object-store}"));
-const deleteObjectStoreCommand = Command.make("delete-object-store", {
-	name: nameOption$5,
+//#region src/commands/cluster/namespace/delete.ts
+const nameOption$3 = Flag.string("name").pipe(Flag.withDescription("Namespace name in format: namespaces/{namespace}"));
+const deleteNamespaceCommand = Command.make("delete-namespace", {
+	name: nameOption$3,
 	force: forceOption,
 	host: hostOption,
 	port: portOption
-}, ({ name, force, host, port }) => Effect.gen(function* () {
-	p.intro("🗑️  Delete Object Store");
+}, ({ name, force }) => Effect.gen(function* () {
+	p.intro("🗑️  Delete Namespace");
 	if (!force) {
 		const confirm = yield* Effect.tryPromise({
 			try: () => p.confirm({
-				message: `Are you sure you want to delete object store ${name}?`,
+				message: `Are you sure you want to delete namespace ${name}?`,
 				initialValue: false
 			}),
 			catch: () => /* @__PURE__ */ new Error("Failed to confirm deletion")
 		});
 		if (p.isCancel(confirm) || !confirm) {
 			p.cancel("Deletion cancelled");
-			process.exit(0);
+			return;
 		}
 	}
-	const layer = makeClusterMetadataLayer(host, port);
 	const s = p.spinner();
-	s.start("Deleting object store...");
-	yield* WingsClusterMetadata.deleteObjectStore({ name }).pipe(Effect.provide(layer), Effect.tapError(() => Effect.sync(() => s.stop("Failed to delete object store"))));
-	s.stop("Object store deleted successfully");
+	s.start("Deleting namespace...");
+	yield* ClusterClient.deleteNamespace({ name }).pipe(Effect.tapError(() => Effect.sync(() => s.stop("Failed to delete namespace"))));
+	s.stop("Namespace deleted successfully");
 	p.outro("✓ Done");
-})).pipe(Command.withDescription("Delete an object store from the cluster"));
+})).pipe(Command.withDescription("Delete a namespace from the cluster"), Command.provide(({ host, port }) => makeClusterClientLayer(host, port)));
 
 //#endregion
-//#region src/commands/cluster/object-store/get.ts
-const nameOption$4 = Flag.string("name").pipe(Flag.withDescription("Object store name in format: tenants/{tenant}/object-stores/{object-store}"));
-const getObjectStoreCommand = Command.make("get-object-store", {
-	name: nameOption$4,
+//#region src/commands/cluster/namespace/get.ts
+const nameOption$2 = Flag.string("name").pipe(Flag.withDescription("Namespace name in format: namespaces/{namespace}"));
+const getNamespaceCommand = Command.make("get-namespace", {
+	name: nameOption$2,
 	host: hostOption,
 	port: portOption
-}, ({ name, host, port }) => Effect.gen(function* () {
-	const layer = makeClusterMetadataLayer(host, port);
+}, ({ name }) => Effect.gen(function* () {
 	const s = p.spinner();
-	s.start("Fetching object store...");
-	const objectStore = yield* WingsClusterMetadata.getObjectStore({ name }).pipe(Effect.provide(layer), Effect.tapError(() => Effect.sync(() => s.stop("Failed to get object store"))));
-	s.stop("Object store retrieved");
+	s.start("Fetching namespace...");
+	const namespace = yield* ClusterClient.getNamespace({ name }).pipe(Effect.tapError(() => Effect.sync(() => s.stop("Failed to get namespace"))));
+	s.stop("Namespace retrieved");
 	yield* Effect.sync(() => {
 		printTable([{
-			name: objectStore.name,
-			type: objectStore.objectStoreConfig._tag || "-"
+			name: namespace.name,
+			object_store: namespace.objectStore?.objectStoreConfig._tag ?? "-",
+			lake: namespace.lake?.lakeConfig._tag ?? "-"
 		}]);
 		p.outro("✓ Done");
 	});
-})).pipe(Command.withDescription("Get details of a specific object store"));
+})).pipe(Command.withDescription("Get details of a specific namespace"), Command.provide(({ host, port }) => makeClusterClientLayer(host, port)));
 
 //#endregion
-//#region src/commands/cluster/object-store/list.ts
-const parentOption$2 = Flag.string("parent").pipe(Flag.withDescription("Parent tenant in format: tenants/{tenant}"));
-const listObjectStoresCommand = Command.make("list-object-stores", {
-	parent: parentOption$2,
+//#region src/commands/cluster/namespace/list.ts
+const listNamespacesCommand = Command.make("list-namespaces", {
 	pageSize: pageSizeOption,
 	pageToken: pageTokenOption,
 	host: hostOption,
 	port: portOption
-}, ({ parent, pageSize, pageToken, host, port }) => Effect.gen(function* () {
-	const layer = makeClusterMetadataLayer(host, port);
+}, ({ pageSize, pageToken }) => Effect.gen(function* () {
 	const s = p.spinner();
-	s.start("Fetching object stores...");
-	const response = yield* WingsClusterMetadata.listObjectStores({
-		parent,
+	s.start("Fetching namespaces...");
+	const response = yield* ClusterClient.listNamespaces({
 		pageSize,
 		pageToken: Option.getOrUndefined(pageToken)
-	}).pipe(Effect.provide(layer), Effect.tapError(() => Effect.sync(() => s.stop("Failed to list object stores"))));
-	s.stop(`Found ${response.objectStores.length} object store(s)`);
+	}).pipe(Effect.tapError(() => Effect.sync(() => s.stop("Failed to list namespaces"))));
+	s.stop(`Found ${response.namespaces.length} namespace(s)`);
 	yield* Effect.sync(() => {
-		if (response.objectStores.length === 0) p.log.warn("No object stores found");
-		else printTable(response.objectStores.map((objectStore) => ({
-			name: objectStore.name,
-			type: objectStore.objectStoreConfig._tag || "-"
+		if (response.namespaces.length === 0) p.log.warn("No namespaces found");
+		else printTable(response.namespaces.map((namespace) => ({
+			name: namespace.name,
+			object_store: namespace.objectStore?.objectStoreConfig._tag ?? "-",
+			lake: namespace.lake?.lakeConfig._tag ?? "-"
 		})));
 		if (response.nextPageToken) p.log.info(`Next page token: ${response.nextPageToken}`);
 		p.outro("✓ Done");
 	});
-})).pipe(Command.withDescription("List all object stores belonging to a tenant"));
-
-//#endregion
-//#region src/commands/cluster/tenant/create.ts
-const tenantIdOption = Flag.string("tenant-id").pipe(Flag.withDescription("Unique identifier for the tenant (e.g., 'acme-corp')"));
-const createTenantCommand = Command.make("create-tenant", {
-	tenantId: tenantIdOption,
-	host: hostOption,
-	port: portOption
-}, ({ tenantId, host, port }) => Effect.gen(function* () {
-	p.intro("🏢 Create Tenant");
-	const layer = makeClusterMetadataLayer(host, port);
-	const s = p.spinner();
-	s.start("Creating tenant...");
-	const tenant = yield* WingsClusterMetadata.createTenant({ tenantId }).pipe(Effect.provide(layer), Effect.tapError(() => Effect.sync(() => s.stop("Failed to create tenant"))));
-	s.stop("Tenant created successfully");
-	yield* Effect.sync(() => {
-		printTable([{ name: tenant.name }]);
-		p.outro("✓ Done");
-	});
-})).pipe(Command.withDescription("Create a new tenant in the cluster"));
-
-//#endregion
-//#region src/commands/cluster/tenant/delete.ts
-const nameOption$3 = Flag.string("name").pipe(Flag.withDescription("Tenant name in format: tenants/{tenant} (e.g., 'tenants/acme-corp')"));
-const deleteTenantCommand = Command.make("delete-tenant", {
-	name: nameOption$3,
-	force: forceOption,
-	host: hostOption,
-	port: portOption
-}, ({ name, force, host, port }) => Effect.gen(function* () {
-	p.intro("🗑️  Delete Tenant");
-	if (!force) {
-		const confirm = yield* Effect.tryPromise({
-			try: () => p.confirm({
-				message: `Are you sure you want to delete tenant ${name}?`,
-				initialValue: false
-			}),
-			catch: () => /* @__PURE__ */ new Error("Failed to confirm deletion")
-		});
-		if (p.isCancel(confirm) || !confirm) {
-			p.cancel("Deletion cancelled");
-			process.exit(0);
-		}
-	}
-	const layer = makeClusterMetadataLayer(host, port);
-	const s = p.spinner();
-	s.start("Deleting tenant...");
-	yield* WingsClusterMetadata.deleteTenant({ name }).pipe(Effect.provide(layer), Effect.tapError(() => Effect.sync(() => s.stop("Failed to delete tenant"))));
-	s.stop("Tenant deleted successfully");
-	p.outro("✓ Done");
-})).pipe(Command.withDescription("Delete a tenant from the cluster (fails if tenant has any namespaces)"));
-
-//#endregion
-//#region src/commands/cluster/tenant/get.ts
-const nameOption$2 = Flag.string("name").pipe(Flag.withDescription("Tenant name in format: tenants/{tenant} (e.g., 'tenants/acme-corp')"));
-const getTenantCommand = Command.make("get-tenant", {
-	name: nameOption$2,
-	host: hostOption,
-	port: portOption
-}, ({ name, host, port }) => Effect.gen(function* () {
-	const layer = makeClusterMetadataLayer(host, port);
-	const s = p.spinner();
-	s.start("Fetching tenant...");
-	const tenant = yield* WingsClusterMetadata.getTenant({ name }).pipe(Effect.provide(layer), Effect.tapError(() => Effect.sync(() => s.stop("Failed to get tenant"))));
-	s.stop("Tenant retrieved");
-	yield* Effect.sync(() => {
-		printTable([{ name: tenant.name }]);
-		p.outro("✓ Done");
-	});
-})).pipe(Command.withDescription("Get details of a specific tenant"));
-
-//#endregion
-//#region src/commands/cluster/tenant/list.ts
-const listTenantsCommand = Command.make("list-tenants", {
-	pageSize: pageSizeOption,
-	pageToken: pageTokenOption,
-	host: hostOption,
-	port: portOption
-}, ({ pageSize, pageToken, host, port }) => Effect.gen(function* () {
-	const layer = makeClusterMetadataLayer(host, port);
-	const s = p.spinner();
-	s.start("Fetching tenants...");
-	const response = yield* WingsClusterMetadata.listTenants({
-		pageSize,
-		pageToken: Option.getOrUndefined(pageToken)
-	}).pipe(Effect.provide(layer), Effect.tapError(() => Effect.sync(() => s.stop("Failed to list tenants"))));
-	s.stop(`Found ${response.tenants.length} tenant(s)`);
-	yield* Effect.sync(() => {
-		if (response.tenants.length === 0) p.log.warn("No tenants found");
-		else printTable(response.tenants.map((tenant) => ({ name: tenant.name })));
-		if (response.nextPageToken) p.log.info(`Next page token: ${response.nextPageToken}`);
-		p.outro("✓ Done");
-	});
-})).pipe(Command.withDescription("List all tenants in the cluster"));
+})).pipe(Command.withDescription("List all namespaces in the cluster"), Command.provide(({ host, port }) => makeClusterClientLayer(host, port)));
 
 //#endregion
-//#region src/commands/cluster/topic/create.ts
+//#region src/commands/cluster/table/create.ts
 const SUPPORTED_INLINE_TYPES = [
 	"Int8",
 	"Int16",
@@ -734,18 +323,15 @@ const SUPPORTED_INLINE_TYPES = [
 	"DurationMicrosecond",
 	"DurationNanosecond"
 ];
-const parentOption$1 = Flag.string("parent").pipe(Flag.withDescription("Parent namespace in format: tenants/{tenant}/namespaces/{namespace}"));
-const topicIdOption = Flag.string("topic-id").pipe(Flag.withDescription("Unique identifier for the topic"));
-const descriptionOption = Flag.string("description").pipe(Flag.withDescription("Topic description"), Flag.optional);
+const parentOption$1 = Flag.string("parent").pipe(Flag.withDescription("Parent namespace in format: namespaces/{namespace}"));
+const tableIdOption = Flag.string("table-id").pipe(Flag.withDescription("Unique identifier for the table"));
+const descriptionOption = Flag.string("description").pipe(Flag.withDescription("Table description"), Flag.optional);
 const fieldsOption = Flag.string("fields").pipe(Flag.withDescription("Field definitions in format \"name:Type\" or \"name:Type?\" for nullable"), Flag.atLeast(0));
 const schemaFileOption = Flag.string("schema-file").pipe(Flag.withDescription("Path to JSON file containing FieldConfig[] (for complex types)"), Flag.optional);
-const partitionKeyOption = Flag.string("partition-key").pipe(Flag.withDescription("Name of the field used for partitioning"), Flag.optional);
-const freshnessSecondsOption = Flag.integer("freshness-seconds").pipe(Flag.withDescription("How often to compact the topic (seconds)"), Flag.withDefault(60));
-const ttlSecondsOption = Flag.integer("ttl-seconds").pipe(Flag.withDescription("How long to keep topic data (seconds)"), Flag.optional);
-const targetFileSizeBytesOption = Flag.integer("target-file-size-bytes").pipe(Flag.withDescription("Target file size for compaction (bytes)"), Flag.withDefault(1024 * 1024));
-/**
-* Parse a field string in format "name:Type" or "name:Type?" (nullable)
-*/
+const keyFieldOption = Flag.string("key-field").pipe(Flag.withDescription("Name of the field used as the primary key"));
+const versionFieldOption = Flag.string("version-field").pipe(Flag.withDescription("Name of the field used as the version/timestamp"));
+const partitionFieldOption = Flag.string("partition-field").pipe(Flag.withDescription("Name of the field used for partitioning"), Flag.optional);
+const freshnessSecondsOption = Flag.integer("freshness-seconds").pipe(Flag.withDescription("Target freshness interval for compaction (seconds)"), Flag.withDefault(60));
 function parseFieldString(fieldStr, index) {
 	const match = fieldStr.match(/^([^:]+):([^?]+)(\?)?$/);
 	if (!match) throw new Error(`Invalid field format: "${fieldStr}". Expected format: "name:Type" or "name:Type?"`);
@@ -762,15 +348,9 @@ function parseFieldString(fieldStr, index) {
 		id: BigInt(index + 1)
 	};
 }
-/**
-* Parse multiple field strings into FieldConfig array
-*/
 function parseFieldsFromArgs(fields) {
 	return fields.map((field, index) => parseFieldString(field, index));
 }
-/**
-* Load fields from a JSON schema file with basic validation
-*/
 function loadFieldsFromFile(filePath) {
 	if (!fs.existsSync(filePath)) throw new Error(`Schema file not found: "${filePath}"`);
 	const content = fs.readFileSync(filePath, "utf-8");
@@ -790,192 +370,190 @@ function loadFieldsFromFile(filePath) {
 		};
 	});
 }
-const createTopicCommand = Command.make("create-topic", {
+const createTableCommand = Command.make("create-table", {
 	parent: parentOption$1,
-	topicId: topicIdOption,
+	tableId: tableIdOption,
 	description: descriptionOption,
 	fields: fieldsOption,
 	schemaFile: schemaFileOption,
-	partitionKey: partitionKeyOption,
+	keyField: keyFieldOption,
+	versionField: versionFieldOption,
+	partitionField: partitionFieldOption,
 	freshnessSeconds: freshnessSecondsOption,
-	ttlSeconds: ttlSecondsOption,
-	targetFileSizeBytes: targetFileSizeBytesOption,
 	host: hostOption,
 	port: portOption
-}, ({ parent, topicId, description, fields, schemaFile, partitionKey, freshnessSeconds, ttlSeconds, targetFileSizeBytes, host, port }) => Effect.gen(function* () {
-	p.intro("📋 Create Topic");
+}, ({ parent, tableId, description, fields, schemaFile, keyField, versionField, partitionField, freshnessSeconds }) => Effect.gen(function* () {
+	p.intro("📋 Create Table");
 	const schemaFilePath = Option.getOrUndefined(schemaFile);
 	const hasFields = fields.length > 0;
 	if (!hasFields && !schemaFilePath) return yield* Effect.fail(/* @__PURE__ */ new Error("Either --fields or --schema-file must be provided"));
 	if (hasFields && schemaFilePath) return yield* Effect.fail(/* @__PURE__ */ new Error("Cannot use both --fields and --schema-file. Choose one."));
-	const topicFields = yield* Effect.try({
+	const tableFields = yield* Effect.try({
 		try: () => schemaFilePath ? loadFieldsFromFile(schemaFilePath) : parseFieldsFromArgs(fields),
 		catch: (error) => error instanceof Error ? error : /* @__PURE__ */ new Error("Failed to parse fields")
 	});
-	if (topicFields.length === 0) return yield* Effect.fail(/* @__PURE__ */ new Error("At least one field is required"));
-	const partitionKeyName = Option.getOrUndefined(partitionKey);
-	let partitionKeyId;
-	if (partitionKeyName) {
-		const index = topicFields.findIndex((field) => field.name === partitionKeyName);
-		if (index === -1) return yield* Effect.fail(/* @__PURE__ */ new Error(`Partition key field "${partitionKeyName}" not found in fields. Available fields: ${topicFields.map((field) => field.name).join(", ")}`));
-		const partitionField = topicFields[index];
-		if (!partitionField) return yield* Effect.fail(/* @__PURE__ */ new Error(`Partition key field "${partitionKeyName}" not found in fields. Available fields: ${topicFields.map((field) => field.name).join(", ")}`));
-		partitionKeyId = partitionField.id;
-	}
-	const layer = makeClusterMetadataLayer(host, port);
+	if (tableFields.length === 0) return yield* Effect.fail(/* @__PURE__ */ new Error("At least one field is required"));
+	const resolveField = (fieldName, role) => {
+		const field = tableFields.find((f) => f.name === fieldName);
+		if (!field) throw new Error(`${role} field "${fieldName}" not found. Available fields: ${tableFields.map((f) => f.name).join(", ")}`);
+		return field.id;
+	};
+	const keyFieldId = yield* Effect.try({
+		try: () => resolveField(keyField, "Key"),
+		catch: (e) => e instanceof Error ? e : new Error(String(e))
+	});
+	const versionFieldId = yield* Effect.try({
+		try: () => resolveField(versionField, "Version"),
+		catch: (e) => e instanceof Error ? e : new Error(String(e))
+	});
+	const partitionFieldName = Option.getOrUndefined(partitionField);
+	const partitionFieldId = partitionFieldName ? yield* Effect.try({
+		try: () => resolveField(partitionFieldName, "Partition"),
+		catch: (e) => e instanceof Error ? e : new Error(String(e))
+	}) : void 0;
 	const s = p.spinner();
-	s.start("Creating topic...");
-	const topic = yield* WingsClusterMetadata.createTopic({
+	s.start("Creating table...");
+	const table = yield* ClusterClient.createTable({
 		parent,
-		topicId,
+		tableId,
 		description: Option.getOrUndefined(description),
-		fields: topicFields,
-		partitionKey: partitionKeyId,
-		compaction: {
-			freshnessSeconds: BigInt(freshnessSeconds),
-			ttlSeconds: Option.getOrUndefined(Option.map(ttlSeconds, (ttl) => BigInt(ttl))),
-			targetFileSizeBytes: BigInt(targetFileSizeBytes)
-		}
-	}).pipe(Effect.provide(layer), Effect.tapError(() => Effect.sync(() => s.stop("Failed to create topic"))));
-	s.stop("Topic created successfully");
+		fields: tableFields,
+		keyFieldId,
+		versionFieldId,
+		partitionFieldId,
+		targetFreshnessSeconds: BigInt(freshnessSeconds)
+	}).pipe(Effect.tapError(() => Effect.sync(() => s.stop("Failed to create table"))));
+	s.stop("Table created successfully");
 	yield* Effect.sync(() => {
 		printTable([{
-			name: topic.name,
-			description: topic.description || "-",
-			partition_key: topic.partitionKey !== void 0 ? topicFields.find((field) => field.id === topic.partitionKey)?.name || topic.partitionKey.toString() : "-",
-			freshness_seconds: topic.compaction.freshnessSeconds.toString(),
-			ttl_seconds: topic.compaction.ttlSeconds?.toString() || "-",
-			target_file_size_bytes: topic.compaction.targetFileSizeBytes.toString(),
-			fields_count: topic.schema.fields.length.toString()
+			name: table.name,
+			description: table.description || "-",
+			key_field_id: table.keyFieldId.toString(),
+			version_field_id: table.versionFieldId.toString(),
+			partition_field_id: table.partitionFieldId?.toString() || "-",
+			freshness_seconds: table.targetFreshnessSeconds.toString(),
+			fields_count: table.schema.fields.length.toString()
 		}]);
-		if (topic.schema.fields.length > 0) {
+		if (table.schema.fields.length > 0) {
 			console.log("\nFields:");
-			printTable(topic.schema.fields.map((field, index) => ({
-				index: index.toString(),
+			printTable(table.schema.fields.map((field) => ({
 				name: field.name,
+				id: field.id.toString(),
 				type: field.arrowType?._tag ?? "unknown",
 				nullable: field.nullable ? "yes" : "no"
 			})));
 		}
 		p.outro("✓ Done");
 	});
-})).pipe(Command.withDescription("Create a new topic belonging to a namespace"));
+})).pipe(Command.withDescription("Create a new table belonging to a namespace"), Command.provide(({ host, port }) => makeClusterClientLayer(host, port)));
 
 //#endregion
-//#region src/commands/cluster/topic/delete.ts
-const nameOption$1 = Flag.string("name").pipe(Flag.withDescription("Topic name in format: tenants/{tenant}/namespaces/{namespace}/topics/{topic}"));
-const forceDeleteOption = Flag.boolean("force-delete").pipe(Flag.withDescription("Also delete data associated with the topic"), Flag.withDefault(false));
-const deleteTopicCommand = Command.make("delete-topic", {
+//#region src/commands/cluster/table/delete.ts
+const nameOption$1 = Flag.string("name").pipe(Flag.withDescription("Table name in format: namespaces/{namespace}/tables/{table}"));
+const deleteTableCommand = Command.make("delete-table", {
 	name: nameOption$1,
-	forceDelete: forceDeleteOption,
 	force: forceOption,
 	host: hostOption,
 	port: portOption
-}, ({ name, forceDelete, force, host, port }) => Effect.gen(function* () {
-	p.intro("🗑️  Delete Topic");
+}, ({ name, force }) => Effect.gen(function* () {
+	p.intro("🗑️  Delete Table");
 	if (!force) {
 		const confirm = yield* Effect.tryPromise({
 			try: () => p.confirm({
-				message: `Are you sure you want to delete topic ${name}?${forceDelete ? " (including all data)" : ""}`,
+				message: `Are you sure you want to delete table ${name}?`,
 				initialValue: false
 			}),
 			catch: () => /* @__PURE__ */ new Error("Failed to confirm deletion")
 		});
 		if (p.isCancel(confirm) || !confirm) {
 			p.cancel("Deletion cancelled");
-			process.exit(0);
+			return;
 		}
 	}
-	const layer = makeClusterMetadataLayer(host, port);
 	const s = p.spinner();
-	s.start("Deleting topic...");
-	yield* WingsClusterMetadata.deleteTopic({
-		name,
-		force: forceDelete
-	}).pipe(Effect.provide(layer), Effect.tapError(() => Effect.sync(() => s.stop("Failed to delete topic"))));
-	s.stop("Topic deleted successfully");
+	s.start("Deleting table...");
+	yield* ClusterClient.deleteTable({ name }).pipe(Effect.tapError(() => Effect.sync(() => s.stop("Failed to delete table"))));
+	s.stop("Table deleted successfully");
 	p.outro("✓ Done");
-})).pipe(Command.withDescription("Delete a topic from the cluster"));
+})).pipe(Command.withDescription("Delete a table from the cluster"), Command.provide(({ host, port }) => makeClusterClientLayer(host, port)));
 
 //#endregion
-//#region src/commands/cluster/topic/get.ts
-const nameOption = Flag.string("name").pipe(Flag.withDescription("Topic name in format: tenants/{tenant}/namespaces/{namespace}/topics/{topic}"));
-const getTopicCommand = Command.make("get-topic", {
+//#region src/commands/cluster/table/get.ts
+const nameOption = Flag.string("name").pipe(Flag.withDescription("Table name in format: namespaces/{namespace}/tables/{table}"));
+const getTableCommand = Command.make("get-table", {
 	name: nameOption,
 	host: hostOption,
 	port: portOption
-}, ({ name, host, port }) => Effect.gen(function* () {
-	const layer = makeClusterMetadataLayer(host, port);
+}, ({ name }) => Effect.gen(function* () {
 	const s = p.spinner();
-	s.start("Fetching topic...");
-	const topic = yield* WingsClusterMetadata.getTopic({ name }).pipe(Effect.provide(layer), Effect.tapError(() => Effect.sync(() => s.stop("Failed to get topic"))));
-	s.stop("Topic retrieved");
+	s.start("Fetching table...");
+	const table = yield* ClusterClient.getTable({ name }).pipe(Effect.tapError(() => Effect.sync(() => s.stop("Failed to get table"))));
+	s.stop("Table retrieved");
 	yield* Effect.sync(() => {
 		printTable([{
-			name: topic.name,
-			description: topic.description || "-",
-			partition_key: topic.partitionKey?.toString() || "-",
-			freshness_seconds: topic.compaction.freshnessSeconds.toString(),
-			ttl_seconds: topic.compaction.ttlSeconds?.toString() || "-"
+			name: table.name,
+			description: table.description || "-",
+			key_field_id: table.keyFieldId.toString(),
+			version_field_id: table.versionFieldId.toString(),
+			partition_field_id: table.partitionFieldId?.toString() || "-",
+			freshness_seconds: table.targetFreshnessSeconds.toString()
 		}]);
+		if (table.schema.fields.length > 0) {
+			console.log("\nFields:");
+			printTable(table.schema.fields.map((field) => ({
+				name: field.name,
+				id: field.id.toString(),
+				type: field.arrowType?._tag ?? "unknown",
+				nullable: field.nullable ? "yes" : "no"
+			})));
+		}
 		p.outro("✓ Done");
 	});
-})).pipe(Command.withDescription("Get details of a specific topic"));
+})).pipe(Command.withDescription("Get details of a specific table"), Command.provide(({ host, port }) => makeClusterClientLayer(host, port)));
 
 //#endregion
-//#region src/commands/cluster/topic/list.ts
-const parentOption = Flag.string("parent").pipe(Flag.withDescription("Parent namespace in format: tenants/{tenant}/namespaces/{namespace}"));
-const listTopicsCommand = Command.make("list-topics", {
+//#region src/commands/cluster/table/list.ts
+const parentOption = Flag.string("parent").pipe(Flag.withDescription("Parent namespace in format: namespaces/{namespace}"));
+const listTablesCommand = Command.make("list-tables", {
 	parent: parentOption,
 	pageSize: pageSizeOption,
 	pageToken: pageTokenOption,
 	host: hostOption,
 	port: portOption
-}, ({ parent, pageSize, pageToken, host, port }) => Effect.gen(function* () {
-	const layer = makeClusterMetadataLayer(host, port);
+}, ({ parent, pageSize, pageToken }) => Effect.gen(function* () {
 	const s = p.spinner();
-	s.start("Fetching topics...");
-	const response = yield* WingsClusterMetadata.listTopics({
+	s.start("Fetching tables...");
+	const response = yield* ClusterClient.listTables({
 		parent,
 		pageSize,
 		pageToken: Option.getOrUndefined(pageToken)
-	}).pipe(Effect.provide(layer), Effect.tapError(() => Effect.sync(() => s.stop("Failed to list topics"))));
-	s.stop(`Found ${response.topics.length} topic(s)`);
+	}).pipe(Effect.tapError(() => Effect.sync(() => s.stop("Failed to list tables"))));
+	s.stop(`Found ${response.tables.length} table(s)`);
 	yield* Effect.sync(() => {
-		if (response.topics.length === 0) p.log.warn("No topics found");
-		else printTable(response.topics.map((topic) => ({
-			name: topic.name,
-			description: topic.description || "-",
-			partition_key: topic.partitionKey?.toString() || "-"
+		if (response.tables.length === 0) p.log.warn("No tables found");
+		else printTable(response.tables.map((table) => ({
+			name: table.name,
+			description: table.description || "-",
+			key_field_id: table.keyFieldId.toString(),
+			partition_field_id: table.partitionFieldId?.toString() || "-",
+			freshness_seconds: table.targetFreshnessSeconds.toString()
 		})));
 		if (response.nextPageToken) p.log.info(`Next page token: ${response.nextPageToken}`);
 		p.outro("✓ Done");
 	});
-})).pipe(Command.withDescription("List all topics belonging to a namespace"));
+})).pipe(Command.withDescription("List all tables belonging to a namespace"), Command.provide(({ host, port }) => makeClusterClientLayer(host, port)));
 
 //#endregion
 //#region src/commands/cluster/index.ts
-const clusterCommand = Command.make("cluster", {}, () => Effect.void).pipe(Command.withDescription("Interact with the cluster metadata server"), Command.withSubcommands([
-	createTenantCommand,
-	listTenantsCommand,
-	getTenantCommand,
-	deleteTenantCommand,
+const clusterCommand = Command.make("cluster", {}, () => Effect.void).pipe(Command.withDescription("Manage Wings namespaces and tables"), Command.withSubcommands([
 	createNamespaceCommand,
 	listNamespacesCommand,
 	getNamespaceCommand,
 	deleteNamespaceCommand,
-	createTopicCommand,
-	listTopicsCommand,
-	getTopicCommand,
-	deleteTopicCommand,
-	createObjectStoreCommand,
-	listObjectStoresCommand,
-	getObjectStoreCommand,
-	deleteObjectStoreCommand,
-	createDataLakeCommand,
-	listDataLakesCommand,
-	getDataLakeCommand,
-	deleteDataLakeCommand
+	createTableCommand,
+	listTablesCommand,
+	getTableCommand,
+	deleteTableCommand
 ]));
 
 //#endregion
@@ -983,34 +561,114 @@ const clusterCommand = Command.make("cluster", {}, () => Effect.void).pipe(Comma
 const checkDockerVersion = () => Effect.gen(function* () {
 	const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
 	const docker = ChildProcess.make("docker", ["--version"]);
-	return yield* spawner.string(docker).pipe(Effect.map(String.trim));
+	return yield* spawner.string(docker).pipe(Effect.map(String$1.trim));
 });
 const createDockerVolume = (volumeName) => Effect.gen(function* () {
-	yield* (yield* ChildProcess.make("docker", [
+	const exitCode = yield* (yield* ChildProcess.make("docker", [
 		"volume",
 		"create",
 		volumeName
 	])).exitCode;
+	if (exitCode !== 0) return yield* Effect.fail(/* @__PURE__ */ new Error(`Docker volume create failed with code ${exitCode}`));
+});
+const createDockerNetwork = (networkName) => Effect.gen(function* () {
+	const exitCode = yield* (yield* ChildProcess.make("docker", [
+		"network",
+		"create",
+		networkName
+	])).exitCode;
+	if (exitCode !== 0) return yield* Effect.fail(/* @__PURE__ */ new Error(`Docker network create failed with code ${exitCode}`));
+});
+const removeDockerContainer = (containerName) => Effect.gen(function* () {
+	yield* (yield* ChildProcess.make("docker", [
+		"rm",
+		"-f",
+		containerName
+	], {
+		stdout: "ignore",
+		stderr: "ignore"
+	})).exitCode;
+});
+const removeDockerNetwork = (networkName) => Effect.gen(function* () {
+	yield* (yield* ChildProcess.make("docker", [
+		"network",
+		"rm",
+		networkName
+	], {
+		stdout: "ignore",
+		stderr: "ignore"
+	})).exitCode;
+});
+const pullDockerImage = (image) => Effect.gen(function* () {
+	const exitCode = yield* (yield* ChildProcess.make("docker", ["pull", image], {
+		stdout: "inherit",
+		stderr: "inherit"
+	})).exitCode;
+	if (exitCode !== 0) return yield* Effect.fail(/* @__PURE__ */ new Error(`Docker pull failed with code ${exitCode}`));
 });
 const runDockerContainer = (image, volumeName) => Effect.gen(function* () {
+	const networkName = "airfoil-dev";
+	const seaweedContainerName = "airfoil-seaweedfs";
+	yield* removeDockerContainer(seaweedContainerName);
+	yield* removeDockerNetwork(networkName);
+	yield* createDockerNetwork(networkName);
+	yield* Effect.addFinalizer(() => removeDockerNetwork(networkName).pipe(Effect.catchCause(() => Effect.void)));
+	const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+	const seaweed = ChildProcess.make("docker", [
+		"run",
+		"-d",
+		"--rm",
+		"--name",
+		seaweedContainerName,
+		"--network",
+		networkName,
+		"--network-alias",
+		"seaweedfs",
+		"-e",
+		"AWS_ACCESS_KEY_ID=wingsdevaccesskey",
+		"-e",
+		"AWS_SECRET_ACCESS_KEY=wingsdevsecretkey",
+		"-e",
+		"S3_BUCKET=default-bucket",
+		"-v",
+		`${volumeName}:/data`,
+		"-p",
+		"8333:8333",
+		"chrislusf/seaweedfs:4.29",
+		"weed",
+		"mini",
+		"-s3",
+		"-dir=/data"
+	]);
+	yield* spawner.string(seaweed).pipe(Effect.map(String$1.trim));
+	yield* Effect.addFinalizer(() => removeDockerContainer(seaweedContainerName).pipe(Effect.catchCause(() => Effect.void)));
 	const exitCode = yield* (yield* ChildProcess.make("docker", [
 		"run",
 		"-it",
 		"--rm",
 		"--name",
 		"wings-dev",
-		"-v",
-		`${volumeName}:/tmp`,
+		"--network",
+		networkName,
+		"-e",
+		"AWS_ACCESS_KEY_ID=wingsdevaccesskey",
+		"-e",
+		"AWS_SECRET_ACCESS_KEY=wingsdevsecretkey",
+		"-e",
+		"AWS_ENDPOINT=http://seaweedfs:8333",
+		"-e",
+		"AWS_BUCKET_NAME=default-bucket",
+		"-e",
+		"AWS_DEFAULT_REGION=us-east-1",
+		"-e",
+		"AWS_ALLOW_HTTP=true",
 		"-p",
 		"7777:7777",
-		"-p",
-		"7780:7780",
 		image,
 		"dev",
-		"--http.address=0.0.0.0:7780",
-		"--metadata.address=0.0.0.0:7777"
+		"--grpc.address=0.0.0.0:7777"
 	])).exitCode;
-	if (exitCode !== 0) yield* Effect.fail(/* @__PURE__ */ new Error(`Docker process exited with code ${exitCode}`));
+	if (exitCode !== 0) return yield* Effect.fail(/* @__PURE__ */ new Error(`Docker process exited with code ${exitCode}`));
 });
 
 //#endregion
@@ -1051,18 +709,21 @@ const downloadWings = (version$2, targetPath, isStress = false) => Effect.gen(fu
 	const fs$1 = yield* FileSystem.FileSystem;
 	const client = yield* HttpClient.HttpClient;
 	const filename = getBinaryFilename(isStress);
+	const tempPath = `${targetPath}.download`;
 	const url = `${GITHUB_RELEASES_URL}/${version$2 === "latest" ? "latest/download" : `download/${version$2}`}/${filename}`;
 	yield* fs$1.makeDirectory(WINGS_DIR, { recursive: true });
-	const response = yield* client.get(url);
-	const buffer = yield* HttpClientResponse.matchStatus({
-		200: (response$1) => response$1.arrayBuffer,
-		orElse: (response$1) => {
-			throw new Error(`Failed to download Wings from ${url}: ${response$1.status}`);
-		}
-	})(response);
-	yield* fs$1.writeFile(targetPath, new Uint8Array(buffer));
-	yield* verifyChecksum(version$2, targetPath, isStress);
-	yield* fs$1.chmod(targetPath, 493);
+	yield* fs$1.remove(tempPath).pipe(Effect.ignore);
+	yield* Effect.gen(function* () {
+		const response = yield* client.get(url);
+		const buffer = yield* HttpClientResponse.matchStatus({
+			200: (response$1) => response$1.arrayBuffer,
+			orElse: (response$1) => Effect.fail(/* @__PURE__ */ new Error(`Failed to download Wings from ${url}: ${response$1.status}`))
+		})(response);
+		yield* fs$1.writeFile(tempPath, new Uint8Array(buffer));
+		yield* verifyChecksum(version$2, tempPath, isStress);
+		yield* fs$1.chmod(tempPath, 493);
+		yield* fs$1.rename(tempPath, targetPath);
+	}).pipe(Effect.onError(() => fs$1.remove(tempPath).pipe(Effect.ignore)));
 });
 /**
 * Download and verify the checksum of a Wings binary
@@ -1090,7 +751,7 @@ const verifyChecksum = (version$2, filePath, isStress = false) => Effect.gen(fun
 //#endregion
 //#region src/commands/dev.ts
 const dockerOption = Flag.boolean("docker").pipe(Flag.withDescription("Run Wings using Docker (recommended)"), Flag.withDefault(false));
-const versionOption = Flag.string("version").pipe(Flag.withDescription("Specify Wings version (e.g., v0.1.0-alpha.11 or 'latest')"), Flag.withDefault("latest"));
+const versionOption = Flag.string("version").pipe(Flag.withDescription("Specify Wings version (e.g., v0.1.0-alpha.14 or 'latest')"), Flag.withDefault("latest"));
 const tagOption = Flag.string("tag").pipe(Flag.withDescription("Docker image tag (only with --docker)"), Flag.withDefault("latest"));
 const forcePullOption = Flag.boolean("force-pull").pipe(Flag.withDescription("Force pull Docker image even if it exists locally"), Flag.withDefault(false));
 const stressOption = Flag.boolean("stress").pipe(Flag.withDescription("Use Wings stress binary variant"), Flag.withDefault(false));
@@ -1104,7 +765,6 @@ const devCommand = Command.make("dev", {
 	yes: yesOption
 }, (options) => options.docker ? runWithDocker(options) : runWithBinary(options)).pipe(Command.withDescription("Download and run Wings dev server locally (Docker recommended for portability)"));
 const runWithBinary = (options) => Effect.gen(function* () {
-	const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
 	const fs$1 = yield* FileSystem.FileSystem;
 	yield* Effect.logInfo("🪽 Airfoil Dev");
 	const version$2 = options.version;
@@ -1122,12 +782,11 @@ const runWithBinary = (options) => Effect.gen(function* () {
 		yield* downloadWings(version$2, wingsPath, isStress);
 	} else yield* Effect.logInfo(`Using cached Wings${isStress ? " stress" : ""} binary (${version$2})`);
 	yield* Effect.logInfo(`Starting Wings dev server...`);
-	const proc = ChildProcess.make(wingsPath, ["dev"], {
+	const exitCode = yield* (yield* ChildProcess.make(wingsPath, ["dev"], {
 		stdin: "inherit",
 		stdout: "inherit"
-	});
-	const exitCode = yield* (yield* spawner.spawn(proc)).exitCode;
-	if (exitCode !== 0) yield* Effect.fail(/* @__PURE__ */ new Error(`Process exited with code ${exitCode}`));
+	})).exitCode;
+	if (exitCode !== 0) return yield* Effect.fail(/* @__PURE__ */ new Error(`Process exited with code ${exitCode}`));
 });
 const runWithDocker = (options) => Effect.gen(function* () {
 	yield* Effect.logInfo("🐳 Airfoil Dev (Docker)");
@@ -1138,8 +797,12 @@ const runWithDocker = (options) => Effect.gen(function* () {
 	}
 	const image = `docker.useairfoil.com/airfoil/wings:${tag}`;
 	yield* Effect.logInfo(`Using Docker image: ${image}`);
-	yield* Effect.logInfo("Ports: 7777 (gRPC), 7780 (http)");
+	yield* Effect.logInfo("Ports: 7777 (gRPC)");
 	yield* checkDockerVersion();
+	if (options.forcePull) {
+		yield* Effect.logInfo(`Pulling Docker image: ${image}`);
+		yield* pullDockerImage(image);
+	}
 	yield* createDockerVolume("wings-data");
 	yield* runDockerContainer(image, "wings-data");
 });
@@ -1148,7 +811,7 @@ const runWithDocker = (options) => Effect.gen(function* () {
 //#region src/commands/sql.ts
 const queryArg = Argument.string("query").pipe(Argument.withDescription("SQL query to execute"), Argument.optional);
 const fileOption = Flag.string("file").pipe(Flag.withAlias("f"), Flag.withDescription("Execute SQL from file"), Flag.optional);
-const namespaceOption = Flag.string("namespace").pipe(Flag.withAlias("n"), Flag.withDescription("Wings namespace"), Flag.withDefault("tenants/default/namespaces/default"));
+const namespaceOption = Flag.string("namespace").pipe(Flag.withAlias("n"), Flag.withDescription("Wings namespace"), Flag.withDefault("namespaces/default"));
 const jsonOption = Flag.boolean("json").pipe(Flag.withDescription("Output results as JSON"), Flag.withDefault(false));
 const sqlCommand = Command.make("sql", {
 	query: queryArg,
@@ -1165,15 +828,13 @@ const sqlCommand = Command.make("sql", {
 	if (!sqlQuery) return yield* Effect.fail(/* @__PURE__ */ new Error("No query provided. Use a query argument or --file option."));
 	const hostPort = `${host}:${port}`;
 	yield* Effect.logInfo(`Namespace: ${namespace}`);
-	const client = new ArrowFlightSqlClient({ host: hostPort }, { defaultCallOptions: { "*": { metadata: Metadata({ "x-wings-namespace": namespace }) } } });
-	const flightInfo = yield* Effect.tryPromise({
-		try: () => client.executeQuery({ query: sqlQuery }),
-		catch: (error) => error instanceof Error ? error : /* @__PURE__ */ new Error("Query failed")
+	const client = yield* ArrowFlightSqlClient.make({
+		host: hostPort,
+		defaultCallOptions: { "*": { metadata: Metadata({ "x-wings-namespace": namespace }) } }
 	});
-	const data = (yield* Effect.tryPromise({
-		try: () => Array.fromAsync(client.executeFlightInfo(flightInfo)),
-		catch: (error) => error instanceof Error ? error : /* @__PURE__ */ new Error("Query failed")
-	})).flatMap((batch) => batch.toArray());
+	const flightInfo = yield* client.executeQuery({ query: sqlQuery });
+	const batches = yield* client.executeFlightInfo(flightInfo).pipe(Stream.runCollect);
+	const data = Array.from(batches).flatMap(({ batch }) => batch.toArray());
 	if (json) yield* Effect.log(JSON.stringify(data, null, 2));
 	else if (data.length === 0) yield* Effect.logWarning("No results returned");
 	else printTable(data, { defaultColumnOptions: { alignment: "left" } });
@@ -1187,7 +848,8 @@ const program = Command.make("airfoil", {}, () => Effect.void).pipe(Command.with
 	sqlCommand,
 	clusterCommand
 ]));
-Command.run(program, { version }).pipe(Effect.provide(FetchHttpClient.layer), Effect.provide(NodeServices.layer), Effect.scoped, NodeRuntime.runMain);
+const cli = Command.run(program, { version });
+NodeRuntime.runMain(cli.pipe(Effect.provide(Layer.mergeAll(FetchHttpClient.layer, NodeServices.layer)), Effect.scoped));
 
 //#endregion
 export {  };