airfoil 0.3.0 → 0.4.1

package/package.json

@@ -1,40 +1,39 @@
 {
   "name": "airfoil",
-  "version": "0.3.0",
-  "module": "index.ts",
-  "type": "module",
+  "version": "0.4.1",
+  "repository": "useairfoil/typescript-sdk",
+  "bin": {
+    "airfoil": "./dist/index.js"
+  },
   "files": [
     "dist",
     "src",
     "README.md"
   ],
-  "bin": {
-    "airfoil": "./dist/index.js"
+  "type": "module",
+  "main": "./dist/index.js",
+  "exports": {
+    ".": "./dist/index.js"
   },
   "scripts": {
+    "build": "tsdown",
     "typecheck": "tsc --noEmit",
-    "lint": "biome check .",
-    "lint:fix": "bun run lint --write",
-    "format": "biome format --write .",
-    "airfoil:dev": "bun run src/index.ts",
-    "build": "bun build src/index.ts --outdir dist --target node",
-    "compile": "bun build src/index.ts --compile --outfile airfoil",
-    "compile:all": "bun run src/scripts/compile-all.ts"
-  },
-  "devDependencies": {
-    "@types/bun": "^1.3.5"
-  },
-  "peerDependencies": {
-    "typescript": "^5"
+    "dev": "tsx src/index.ts"
   },
   "dependencies": {
     "@clack/prompts": "^0.11.0",
-    "@effect/platform-node": "4.0.0-beta.25",
-    "@useairfoil/flight": "0.2.0",
-    "@useairfoil/wings": "0.2.0",
+    "@effect/platform-node": "4.0.0-beta.83",
+    "@useairfoil/flight": "0.4.3",
+    "@useairfoil/wings": "0.4.1",
     "console-table-printer": "^2.15.0",
-    "effect": "4.0.0-beta.25",
+    "effect": "4.0.0-beta.83",
     "nice-grpc": "^2.1.13",
     "nice-grpc-common": "^2.0.2"
+  },
+  "devDependencies": {
+    "@types/node": "^24.2.0",
+    "tsdown": "^0.15.6",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
   }
 }

package/src/commands/cluster/index.ts

@@ -1,52 +1,25 @@
 import { Effect } from "effect";
 import { Command } from "effect/unstable/cli";
-import { createDataLakeCommand } from "./data-lake/create.js";
-import { deleteDataLakeCommand } from "./data-lake/delete.js";
-import { getDataLakeCommand } from "./data-lake/get.js";
-import { listDataLakesCommand } from "./data-lake/list.js";
-import { createNamespaceCommand } from "./namespace/create.js";
-import { deleteNamespaceCommand } from "./namespace/delete.js";
-import { getNamespaceCommand } from "./namespace/get.js";
-import { listNamespacesCommand } from "./namespace/list.js";
-import { createObjectStoreCommand } from "./object-store/create.js";
-import { deleteObjectStoreCommand } from "./object-store/delete.js";
-import { getObjectStoreCommand } from "./object-store/get.js";
-import { listObjectStoresCommand } from "./object-store/list.js";
-import { createTenantCommand } from "./tenant/create.js";
-import { deleteTenantCommand } from "./tenant/delete.js";
-import { getTenantCommand } from "./tenant/get.js";
-import { listTenantsCommand } from "./tenant/list.js";
-import { createTopicCommand } from "./topic/create.js";
-import { deleteTopicCommand } from "./topic/delete.js";
-import { getTopicCommand } from "./topic/get.js";
-import { listTopicsCommand } from "./topic/list.js";
 
-export const clusterCommand = Command.make(
-  "cluster",
-  {},
-  () => Effect.void,
-).pipe(
-  Command.withDescription("Interact with the cluster metadata server"),
+import { createNamespaceCommand } from "./namespace/create";
+import { deleteNamespaceCommand } from "./namespace/delete";
+import { getNamespaceCommand } from "./namespace/get";
+import { listNamespacesCommand } from "./namespace/list";
+import { createTableCommand } from "./table/create";
+import { deleteTableCommand } from "./table/delete";
+import { getTableCommand } from "./table/get";
+import { listTablesCommand } from "./table/list";
+
+export const clusterCommand = Command.make("cluster", {}, () => Effect.void).pipe(
+  Command.withDescription("Manage Wings namespaces and tables"),
   Command.withSubcommands([
-    createTenantCommand,
-    listTenantsCommand,
-    getTenantCommand,
-    deleteTenantCommand,
     createNamespaceCommand,
     listNamespacesCommand,
     getNamespaceCommand,
     deleteNamespaceCommand,
-    createTopicCommand,
-    listTopicsCommand,
-    getTopicCommand,
-    deleteTopicCommand,
-    createObjectStoreCommand,
-    listObjectStoresCommand,
-    getObjectStoreCommand,
-    deleteObjectStoreCommand,
-    createDataLakeCommand,
-    listDataLakesCommand,
-    getDataLakeCommand,
-    deleteDataLakeCommand,
+    createTableCommand,
+    listTablesCommand,
+    getTableCommand,
+    deleteTableCommand,
   ]),
 );

package/src/commands/cluster/namespace/create.ts

@@ -1,107 +1,314 @@
 import * as p from "@clack/prompts";
-import { WingsClusterMetadata } from "@useairfoil/wings";
+import { Cluster, ClusterClient } from "@useairfoil/wings";
 import { printTable } from "console-table-printer";
-import { Effect } from "effect";
+import { Config, Effect, Option, Redacted } from "effect";
 import { Command, Flag } from "effect/unstable/cli";
-import { makeClusterMetadataLayer } from "../../../utils/client.js";
-import { handleCliError } from "../../../utils/effect.js";
-import { hostOption, portOption } from "../../../utils/options.js";
 
-const parentOption = Flag.string("parent").pipe(
-  Flag.withDescription(
-    "Parent tenant in format: tenants/{tenant} (e.g., 'tenants/default')",
-  ),
-);
+import { makeClusterClientLayer } from "../../../utils/client";
+import { hostOption, portOption } from "../../../utils/options";
+
+type LakeTag = Cluster.Lake.LakeApp["lakeConfig"]["_tag"];
 
 const namespaceIdOption = Flag.string("namespace-id").pipe(
-  Flag.withDescription(
-    "Unique identifier for the namespace (e.g., 'production')",
-  ),
+  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 lakeOption = Flag.string("lake").pipe(
+  Flag.withDescription("Lake format: iceberg, parquet, or delta"),
+  Flag.withDefault("iceberg" as LakeTag),
 );
 
-const flushIntervalMillisOption = Flag.integer("flush-interval-millis").pipe(
-  Flag.withDescription(
-    "Maximum interval at which the current segment is flushed (milliseconds)",
-  ),
-  Flag.withDefault(0),
+const prefixOption = Flag.string("prefix").pipe(
+  Flag.withDescription("Storage prefix (optional)"),
+  Flag.optional,
 );
 
-const objectStoreOption = Flag.string("object-store").pipe(
-  Flag.withDescription(
-    "Object store used by this namespace (format: tenants/{tenant}/object-stores/{object-store})",
-  ),
+function makeLakeConfig(lake: string): Cluster.Lake.LakeApp {
+  switch (lake) {
+    case "iceberg":
+      return { lakeConfig: { _tag: "iceberg" as const, iceberg: {} } };
+    case "parquet":
+      return { lakeConfig: { _tag: "parquet" as const, parquet: {} } };
+    case "delta":
+      return { lakeConfig: { _tag: "delta" as const, delta: {} } };
+    default:
+      throw new Error(`Invalid lake type: "${lake}". Must be iceberg, parquet, or delta.`);
+  }
+}
+
+function displayNamespace(namespace: Cluster.Namespace.Namespace) {
+  printTable([
+    {
+      name: namespace.name,
+      object_store: namespace.objectStore?.objectStoreConfig._tag ?? "-",
+      lake: namespace.lake?.lakeConfig._tag ?? "-",
+    },
+  ]);
+  p.outro("✓ Done");
+}
+
+// ─── AWS ──────────────────────────────────────────────────────────────────────
+
+const createNamespaceAwsCommand = Command.make(
+  "aws",
+  {
+    namespaceId: namespaceIdOption,
+    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,
+  },
+  ({ 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* ClusterClient.createNamespace({
+        namespaceId,
+        objectStore: {
+          objectStoreConfig: {
+            _tag: "aws",
+            aws: {
+              bucketName,
+              prefix: Option.getOrUndefined(prefix),
+              accessKeyId: Redacted.value(accessKeyId),
+              secretAccessKey: Redacted.value(secretAccessKey),
+              region: Option.getOrUndefined(region),
+            },
+          },
+        },
+        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 dataLakeOption = Flag.string("data-lake").pipe(
-  Flag.withDescription(
-    "Data lake used by this namespace (format: tenants/{tenant}/data-lakes/{data-lake})",
-  ),
+// ─── Azure ────────────────────────────────────────────────────────────────────
+
+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,
+  },
+  ({ 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 namespace...");
+
+      const namespace = yield* ClusterClient.createNamespace({
+        namespaceId,
+        objectStore: {
+          objectStoreConfig: {
+            _tag: "azure",
+            azure: {
+              containerName,
+              prefix: Option.getOrUndefined(prefix),
+              storageAccountName,
+              storageAccountKey: Redacted.value(storageAccountKey),
+            },
+          },
+        },
+        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)),
+);
+
+// ─── Google ───────────────────────────────────────────────────────────────────
+
+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,
+  },
+  ({ 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 namespace...");
+
+      const namespace = yield* ClusterClient.createNamespace({
+        namespaceId,
+        objectStore: {
+          objectStoreConfig: {
+            _tag: "google",
+            google: {
+              bucketName,
+              prefix: Option.getOrUndefined(prefix),
+              serviceAccount,
+              serviceAccountKey: Redacted.value(serviceAccountKey),
+            },
+          },
+        },
+        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)),
 );
 
-export const createNamespaceCommand = Command.make(
-  "create-namespace",
+// ─── S3-Compatible ────────────────────────────────────────────────────────────
+
+const createNamespaceS3Command = Command.make(
+  "s3",
   {
-    parent: parentOption,
     namespaceId: namespaceIdOption,
-    flushSizeBytes: flushSizeBytesOption,
-    flushIntervalMillis: flushIntervalMillisOption,
-    objectStore: objectStoreOption,
-    dataLake: dataLakeOption,
+    lake: lakeOption,
+    bucketName: Flag.string("bucket-name").pipe(Flag.withDescription("S3-compatible bucket name")),
+    prefix: prefixOption,
+    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,
     namespaceId,
-    flushSizeBytes,
-    flushIntervalMillis,
-    objectStore,
-    dataLake,
-    host,
-    port,
+    lake,
+    bucketName,
+    prefix,
+    accessKeyId,
+    secretAccessKey,
+    endpoint,
+    allowHttp,
+    region,
   }) =>
     Effect.gen(function* () {
-      p.intro("📁 Create Namespace");
+      p.intro("📁 Create Namespace (S3-Compatible)");
 
-      const layer = makeClusterMetadataLayer(host, port);
+      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")),
-        ),
-      );
+        objectStore: {
+          objectStoreConfig: {
+            _tag: "s3Compatible",
+            s3Compatible: {
+              bucketName,
+              prefix: Option.getOrUndefined(prefix),
+              accessKeyId: Redacted.value(accessKeyId),
+              secretAccessKey: Redacted.value(secretAccessKey),
+              endpoint,
+              allowHttp,
+              region: Option.getOrUndefined(region),
+            },
+          },
+        },
+        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)),
+);
 
-      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(Effect.catch(handleCliError("Failed to create namespace"))),
-).pipe(Command.withDescription("Create a new namespace belonging to a tenant"));
+// ─── Parent command ───────────────────────────────────────────────────────────
+
+export 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,
+  ]),
+);

package/src/commands/cluster/namespace/delete.ts

@@ -1,15 +1,13 @@
 import * as p from "@clack/prompts";
-import { WingsClusterMetadata } from "@useairfoil/wings";
+import { ClusterClient } from "@useairfoil/wings";
 import { Effect } from "effect";
 import { Command, Flag } from "effect/unstable/cli";
-import { makeClusterMetadataLayer } from "../../../utils/client.js";
-import { handleCliError } from "../../../utils/effect.js";
-import { forceOption, hostOption, portOption } from "../../../utils/options.js";
+
+import { makeClusterClientLayer } from "../../../utils/client";
+import { forceOption, hostOption, portOption } from "../../../utils/options";
 
 const nameOption = Flag.string("name").pipe(
-  Flag.withDescription(
-    "Namespace name in format: tenants/{tenant}/namespaces/{namespace}",
-  ),
+  Flag.withDescription("Namespace name in format: namespaces/{namespace}"),
 );
 
 export const deleteNamespaceCommand = Command.make(
@@ -20,7 +18,7 @@ export const deleteNamespaceCommand = Command.make(
     host: hostOption,
     port: portOption,
   },
-  ({ name, force, host, port }) =>
+  ({ name, force }) =>
     Effect.gen(function* () {
       p.intro("🗑️  Delete Namespace");
 
@@ -36,27 +34,21 @@ export const deleteNamespaceCommand = Command.make(
 
         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 namespace...");
 
-      yield* WingsClusterMetadata.deleteNamespace({ name }).pipe(
-        Effect.provide(layer),
-        Effect.tapError(() =>
-          Effect.sync(() => s.stop("Failed to delete 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(Effect.catch(handleCliError("Failed to delete namespace"))),
+    }),
 ).pipe(
-  Command.withDescription(
-    "Delete a namespace from the cluster (fails if namespace has any topics)",
-  ),
+  Command.withDescription("Delete a namespace from the cluster"),
+  Command.provide(({ host, port }) => makeClusterClientLayer(host, port)),
 );

package/src/commands/cluster/namespace/get.ts

@@ -1,16 +1,14 @@
 import * as p from "@clack/prompts";
-import { WingsClusterMetadata } from "@useairfoil/wings";
+import { ClusterClient } from "@useairfoil/wings";
 import { printTable } from "console-table-printer";
 import { Effect } from "effect";
 import { Command, Flag } from "effect/unstable/cli";
-import { makeClusterMetadataLayer } from "../../../utils/client.js";
-import { handleCliError } from "../../../utils/effect.js";
-import { hostOption, portOption } from "../../../utils/options.js";
+
+import { makeClusterClientLayer } from "../../../utils/client";
+import { hostOption, portOption } from "../../../utils/options";
 
 const nameOption = Flag.string("name").pipe(
-  Flag.withDescription(
-    "Namespace name in format: tenants/{tenant}/namespaces/{namespace}",
-  ),
+  Flag.withDescription("Namespace name in format: namespaces/{namespace}"),
 );
 
 export const getNamespaceCommand = Command.make(
@@ -20,18 +18,13 @@ export const getNamespaceCommand = Command.make(
     host: hostOption,
     port: portOption,
   },
-  ({ name, host, port }) =>
+  ({ name }) =>
     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")),
-        ),
+      const namespace = yield* ClusterClient.getNamespace({ name }).pipe(
+        Effect.tapError(() => Effect.sync(() => s.stop("Failed to get namespace"))),
       );
 
       s.stop("Namespace retrieved");
@@ -40,13 +33,14 @@ export const getNamespaceCommand = Command.make(
         printTable([
           {
             name: namespace.name,
-            flush_size_bytes: namespace.flushSizeBytes.toString(),
-            flush_interval_millis: namespace.flushIntervalMillis.toString(),
-            object_store: namespace.objectStore || "-",
-            data_lake: namespace.dataLake || "-",
+            object_store: namespace.objectStore?.objectStoreConfig._tag ?? "-",
+            lake: namespace.lake?.lakeConfig._tag ?? "-",
           },
         ]);
         p.outro("✓ Done");
       });
-    }).pipe(Effect.catch(handleCliError("Failed to get namespace"))),
-).pipe(Command.withDescription("Get details of a specific namespace"));
+    }),
+).pipe(
+  Command.withDescription("Get details of a specific namespace"),
+  Command.provide(({ host, port }) => makeClusterClientLayer(host, port)),
+);