gigadrive 2.1.3 → 2.3.0

package/dist/index.cjs

@@ -24,16 +24,68 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/index.ts
-var import_cli8 = require("@effect/cli");
+var import_cli15 = require("@effect/cli");
 var import_platform_node = require("@effect/platform-node");
 var import_network_config2 = require("@gigadrive/network-config");
-var import_effect17 = require("effect");
+var import_effect29 = require("effect");
 
-// src/commands/build/index.ts
+// package.json
+var package_default = {
+  name: "gigadrive",
+  version: "2.3.0",
+  repository: {
+    type: "git",
+    url: "https://github.com/Gigadrive/sdk.git",
+    directory: "packages/cli"
+  },
+  license: "Apache-2.0",
+  author: "Gigadrive <business@gigadrivegroup.com> (https://gigadrive.de)",
+  type: "module",
+  module: "src/index.ts",
+  bin: {
+    gigadrive: "dist/index.mjs",
+    gn: "dist/index.mjs"
+  },
+  files: [
+    "dist"
+  ],
+  scripts: {
+    build: "tsup",
+    clean: "rm -rf dist",
+    dev: "pnpm build && node dist/index.mjs",
+    typecheck: "tsc --noEmit"
+  },
+  dependencies: {
+    "@effect/cli": "^0.75.0",
+    "@effect/platform": "^0.96.0",
+    "@effect/platform-node": "^0.106.0",
+    "@gigadrive/build-utils": "workspace:*",
+    "@gigadrive/commons": "workspace:*",
+    "@gigadrive/network-config": "workspace:*",
+    "@gigadrive/sdk": "workspace:*",
+    archiver: "^7.0.1",
+    effect: "^3.19.17",
+    ignore: "^7.0.5",
+    open: "^10.2.0"
+  },
+  devDependencies: {
+    "@effect/language-service": "^0.84.0",
+    "@types/archiver": "^6.0.3",
+    esbuild: "^0.28.0",
+    typescript: "catalog:"
+  },
+  engines: {
+    node: ">=20.0.0"
+  },
+  publishConfig: {
+    access: "public"
+  }
+};
+
+// src/commands/ai/index.ts
 var import_cli = require("@effect/cli");
-var import_platform2 = require("@effect/platform");
-var import_build_utils2 = require("@gigadrive/build-utils");
-var import_effect3 = require("effect");
+var import_platform3 = require("@effect/platform");
+var import_effect8 = require("effect");
 
 // src/errors.ts
 var import_effect = require("effect");
@@ -75,11 +127,82 @@ var UserInfoFetchError = class extends import_effect.Schema.TaggedError()("UserI
   statusCode: import_effect.Schema.optional(import_effect.Schema.Number)
 }) {
 };
+var ApiRequestError = class extends import_effect.Schema.TaggedError()("ApiRequestError", {
+  message: import_effect.Schema.String,
+  statusCode: import_effect.Schema.optional(import_effect.Schema.Number),
+  code: import_effect.Schema.optional(import_effect.Schema.String)
+}) {
+};
+var InvalidEnvVarFormatError = class extends import_effect.Schema.TaggedError()(
+  "InvalidEnvVarFormatError",
+  {
+    message: import_effect.Schema.String
+  }
+) {
+};
+var EnvVarNotFoundError = class extends import_effect.Schema.TaggedError()("EnvVarNotFoundError", {
+  message: import_effect.Schema.String
+}) {
+};
+var NoApplicationsFoundError = class extends import_effect.Schema.TaggedError()(
+  "NoApplicationsFoundError",
+  {
+    message: import_effect.Schema.String
+  }
+) {
+};
+var ApplicationNotFoundError = class extends import_effect.Schema.TaggedError()(
+  "ApplicationNotFoundError",
+  {
+    message: import_effect.Schema.String
+  }
+) {
+};
+var EnvFileReadError = class extends import_effect.Schema.TaggedError()("EnvFileReadError", {
+  message: import_effect.Schema.String,
+  cause: import_effect.Schema.optional(import_effect.Schema.String)
+}) {
+};
+var EnvFileWriteError = class extends import_effect.Schema.TaggedError()("EnvFileWriteError", {
+  message: import_effect.Schema.String,
+  cause: import_effect.Schema.optional(import_effect.Schema.String)
+}) {
+};
+var DevCredentialsStoreReadError = class extends import_effect.Schema.TaggedError()(
+  "DevCredentialsStoreReadError",
+  {
+    message: import_effect.Schema.String
+  }
+) {
+};
+var DevCredentialsStoreWriteError = class extends import_effect.Schema.TaggedError()(
+  "DevCredentialsStoreWriteError",
+  {
+    message: import_effect.Schema.String,
+    cause: import_effect.Schema.optional(import_effect.Schema.String)
+  }
+) {
+};
 var ConfigNotFoundError = class extends import_effect.Schema.TaggedError()("ConfigNotFoundError", {
   message: import_effect.Schema.String,
   directory: import_effect.Schema.String
 }) {
 };
+var ProjectNotLinkedError = class extends import_effect.Schema.TaggedError()("ProjectNotLinkedError", {
+  message: import_effect.Schema.String,
+  directory: import_effect.Schema.String
+}) {
+};
+var ProjectLinkReadError = class extends import_effect.Schema.TaggedError()("ProjectLinkReadError", {
+  message: import_effect.Schema.String,
+  cause: import_effect.Schema.optional(import_effect.Schema.String)
+}) {
+};
+var ProjectLinkWriteError = class extends import_effect.Schema.TaggedError()("ProjectLinkWriteError", {
+  message: import_effect.Schema.String,
+  cause: import_effect.Schema.optional(import_effect.Schema.String)
+}) {
+};
 var ConfigParseError = class extends import_effect.Schema.TaggedError()("ConfigParseError", {
   message: import_effect.Schema.String,
   cause: import_effect.Schema.optional(import_effect.Schema.String)
@@ -160,6 +283,13 @@ var DeploymentLogsFetchError = class extends import_effect.Schema.TaggedError()(
   }
 ) {
 };
+var DeploymentHostnamesFetchError = class extends import_effect.Schema.TaggedError()(
+  "DeploymentHostnamesFetchError",
+  {
+    message: import_effect.Schema.String
+  }
+) {
+};
 var ArchiveCreateError = class extends import_effect.Schema.TaggedError()("ArchiveCreateError", {
   message: import_effect.Schema.String,
   cause: import_effect.Schema.optional(import_effect.Schema.String)
@@ -174,431 +304,184 @@ var DeploymentFailedError = class extends import_effect.Schema.TaggedError()("De
 }) {
 };
 
-// src/services/package-manager.ts
+// src/services/api-client.ts
+var import_sdk = require("@gigadrive/sdk");
+var import_effect6 = require("effect");
+
+// src/services/auth.ts
+var import_effect5 = require("effect");
+var crypto = __toESM(require("crypto"), 1);
+var http = __toESM(require("http"), 1);
+var import_open = __toESM(require("open"), 1);
+
+// src/services/auth-storage.ts
 var import_platform = require("@effect/platform");
-var import_build_utils = require("@gigadrive/build-utils");
+var import_effect3 = require("effect");
+var os = __toESM(require("os"), 1);
+
+// src/domain.ts
 var import_effect2 = require("effect");
-var PackageManagerService = class extends import_effect2.Effect.Service()("PackageManagerService", {
+var DeploymentId = import_effect2.Schema.String.pipe(import_effect2.Schema.brand("@Gigadrive/DeploymentId"));
+var ApplicationId = import_effect2.Schema.String.pipe(import_effect2.Schema.brand("@Gigadrive/ApplicationId"));
+var UploadId = import_effect2.Schema.String.pipe(import_effect2.Schema.brand("@Gigadrive/UploadId"));
+var PackageManager = import_effect2.Schema.Literal("npm", "yarn", "pnpm", "bun");
+var OAuthTokens = import_effect2.Schema.Struct({
+  access_token: import_effect2.Schema.String,
+  refresh_token: import_effect2.Schema.optional(import_effect2.Schema.String),
+  expires_in: import_effect2.Schema.optional(import_effect2.Schema.Number),
+  token_type: import_effect2.Schema.optional(import_effect2.Schema.String)
+});
+var OAuthClientConfig = import_effect2.Schema.Struct({
+  clientId: import_effect2.Schema.String,
+  issuer: import_effect2.Schema.String,
+  authorizeUrl: import_effect2.Schema.String,
+  tokenUrl: import_effect2.Schema.String,
+  scope: import_effect2.Schema.String,
+  userinfoUrl: import_effect2.Schema.String
+});
+var StoredAuthData = import_effect2.Schema.Struct({
+  refreshToken: import_effect2.Schema.String,
+  accessToken: import_effect2.Schema.optional(import_effect2.Schema.String),
+  tokenExpirationTime: import_effect2.Schema.optional(import_effect2.Schema.Number)
+});
+var ProjectLink = import_effect2.Schema.Struct({
+  applicationId: import_effect2.Schema.String,
+  organizationId: import_effect2.Schema.optional(import_effect2.Schema.String)
+});
+var DevKeyEntry = import_effect2.Schema.Struct({
+  apiKeyId: import_effect2.Schema.String
+});
+var DevKeyStore = import_effect2.Schema.Record({ key: import_effect2.Schema.String, value: DevKeyEntry });
+
+// src/services/auth-storage.ts
+var AuthStorageService = class extends import_effect3.Effect.Service()("AuthStorageService", {
   accessors: true,
-  effect: import_effect2.Effect.gen(function* () {
+  effect: import_effect3.Effect.gen(function* () {
     const fs = yield* import_platform.FileSystem.FileSystem;
     const pathService = yield* import_platform.Path.Path;
-    const detect = import_effect2.Effect.fn("PackageManagerService.detect")(function* (cwd) {
-      yield* import_effect2.Effect.annotateCurrentSpan("cwd", cwd);
-      const packageJsonPath = pathService.join(cwd, "package.json");
-      const exists = yield* fs.exists(packageJsonPath).pipe(
-        import_effect2.Effect.mapError(
-          () => new PackageManagerNotFoundError({ message: "Failed to check for package.json", directory: cwd })
+    const homeDir = os.homedir();
+    const authDir = pathService.join(homeDir, ".gigadrive");
+    const authFile = pathService.join(authDir, "auth.json");
+    const ensureDirectory = import_effect3.Effect.gen(function* () {
+      yield* fs.makeDirectory(authDir, { recursive: true }).pipe(
+        import_effect3.Effect.mapError(
+          (error) => new AuthStorageWriteError({
+            message: "Failed to create auth directory",
+            cause: String(error)
+          })
         )
       );
-      if (!exists) {
-        return yield* import_effect2.Effect.fail(
-          new PackageManagerNotFoundError({
-            message: "No package.json found",
-            directory: cwd
+      yield* fs.chmod(authDir, 448).pipe(
+        import_effect3.Effect.mapError(
+          (error) => new AuthStorageWriteError({
+            message: "Failed to set auth directory permissions",
+            cause: String(error)
           })
-        );
-      }
-      const lockChecks = [
-        { file: "yarn.lock", pm: "yarn" },
-        { file: "pnpm-lock.yaml", pm: "pnpm" },
-        { file: "bun.lockb", pm: "bun" },
-        { file: "package-lock.json", pm: "npm" }
-      ];
-      for (const { file, pm: pm2 } of lockChecks) {
-        const lockExists = yield* fs.exists(pathService.join(cwd, file)).pipe(import_effect2.Effect.catchAll(() => import_effect2.Effect.succeed(false)));
-        if (lockExists) {
-          yield* import_effect2.Effect.log("Package manager detected from lock file", { packageManager: pm2, lockFile: file });
-          return pm2;
-        }
-      }
-      const bunAvailable = yield* import_effect2.Effect.tryPromise({
-        try: () => (0, import_build_utils.exec)({ command: "bun --version", cwd }),
-        catch: () => new ExecError({ message: "bun not found", command: "bun --version" })
-      }).pipe(
-        import_effect2.Effect.as(true),
-        import_effect2.Effect.catchTag("ExecError", () => import_effect2.Effect.succeed(false))
+        )
       );
-      const pm = bunAvailable ? "bun" : "npm";
-      yield* import_effect2.Effect.log("Package manager detected via fallback", { packageManager: pm });
-      return pm;
     });
-    const installCommand = (pm) => ({
-      bun: "bun install",
-      npm: "npm install",
-      pnpm: "pnpm install",
-      yarn: "yarn install"
-    })[pm];
-    const buildCommand2 = (pm) => ({
-      bun: "bun run build",
-      npm: "npm run build",
-      pnpm: "pnpm build",
-      yarn: "yarn build"
-    })[pm];
-    return { detect, installCommand, buildCommand: buildCommand2 };
-  })
-}) {
-};
-
-// src/commands/build/index.ts
-var buildCommand = import_cli.Command.make(
-  "build",
-  {},
-  () => import_effect3.Effect.gen(function* () {
-    const pmService = yield* PackageManagerService;
-    const fs = yield* import_platform2.FileSystem.FileSystem;
-    const pathService = yield* import_platform2.Path.Path;
-    const cwd = process.cwd();
-    yield* import_effect3.Effect.log("Starting build", { cwd });
-    const packageJsonPath = pathService.join(cwd, "package.json");
-    const packageJsonExists = yield* fs.exists(packageJsonPath).pipe(
-      import_effect3.Effect.mapError(
-        () => new PackageJsonNotFoundError({ message: "Failed to check for package.json", directory: cwd })
-      )
-    );
-    if (!packageJsonExists) {
-      return yield* import_effect3.Effect.fail(new PackageJsonNotFoundError({ message: "No package.json found", directory: cwd }));
-    }
-    const packageJsonContent = yield* fs.readFileString(packageJsonPath, "utf-8").pipe(
-      import_effect3.Effect.mapError(() => new PackageJsonNotFoundError({ message: "Failed to read package.json", directory: cwd }))
-    );
-    const packageJson = yield* import_effect3.Effect.try({
-      try: () => JSON.parse(packageJsonContent),
-      catch: (error) => new PackageJsonParseError({
-        message: "Failed to parse package.json",
-        directory: cwd,
-        cause: error instanceof Error ? error.message : String(error)
-      })
+    const load = import_effect3.Effect.gen(function* () {
+      const exists = yield* fs.exists(authFile).pipe(import_effect3.Effect.mapError(() => new AuthStorageReadError({ message: "Failed to check auth file existence" })));
+      if (!exists) return import_effect3.Option.none();
+      const data = yield* fs.readFileString(authFile, "utf8").pipe(import_effect3.Effect.mapError(() => new AuthStorageReadError({ message: "Failed to read auth file" })));
+      const json = yield* import_effect3.Effect.try({
+        try: () => JSON.parse(data),
+        catch: () => new AuthStorageReadError({ message: "Auth file contains invalid JSON" })
+      });
+      const authData = yield* import_effect3.Schema.decodeUnknown(StoredAuthData)(json).pipe(
+        import_effect3.Effect.mapError(() => new AuthStorageReadError({ message: "Auth file has invalid schema" }))
+      );
+      return import_effect3.Option.some(authData);
     });
-    if (!packageJson.scripts?.build) {
-      return yield* import_effect3.Effect.fail(new BuildScriptNotFoundError({ message: "No build script found in package.json" }));
-    }
-    const pm = yield* pmService.detect(cwd);
-    const buildEnv = {
-      ...process.env,
-      NODE_ENV: "production",
-      NEBULA: "1",
-      VERCEL: "1",
-      NOW_BUILDER: "1"
-    };
-    const installCmd = pmService.installCommand(pm);
-    yield* import_effect3.Console.log(`Running: ${installCmd}`);
-    yield* import_effect3.Effect.tryPromise({
-      try: () => (0, import_build_utils2.exec)({
-        command: installCmd,
-        cwd,
-        env: buildEnv,
-        onOutput: (chunk) => {
-          import_effect3.Console.log(chunk).pipe(import_effect3.Effect.runSync);
-        }
-      }),
-      catch: (error) => new ExecError({
-        message: "Install failed",
-        command: installCmd,
-        cause: error instanceof Error ? error.message : String(error)
-      })
+    const save = import_effect3.Effect.fn("AuthStorageService.save")(function* (authData) {
+      yield* ensureDirectory;
+      yield* fs.writeFileString(authFile, JSON.stringify(authData, null, 2), { mode: 384 }).pipe(
+        import_effect3.Effect.mapError(
+          (error) => new AuthStorageWriteError({
+            message: "Failed to write auth file",
+            cause: String(error)
+          })
+        )
+      );
+      yield* import_effect3.Effect.log("Auth data saved to local storage");
     });
-    const buildCmd = pmService.buildCommand(pm);
-    yield* import_effect3.Console.log(`Running: ${buildCmd}`);
-    yield* import_effect3.Effect.tryPromise({
-      try: () => (0, import_build_utils2.exec)({
-        command: buildCmd,
-        cwd,
-        env: buildEnv,
-        onOutput: (chunk) => {
-          import_effect3.Console.log(chunk).pipe(import_effect3.Effect.runSync);
-        }
-      }),
-      catch: (error) => new ExecError({
-        message: "Build failed",
-        command: buildCmd,
-        cause: error instanceof Error ? error.message : String(error)
-      })
+    const remove = import_effect3.Effect.gen(function* () {
+      yield* fs.remove(authFile).pipe(
+        import_effect3.Effect.mapError((error) => {
+          const cause = error instanceof Error ? error : error.error;
+          const code = cause && typeof cause === "object" && "code" in cause ? cause.code : "";
+          return { isNotFound: code === "ENOENT" || String(error).includes("ENOENT"), original: error };
+        }),
+        import_effect3.Effect.catchAll(
+          (mapped) => mapped.isNotFound ? import_effect3.Effect.void : import_effect3.Effect.fail(
+            new AuthStorageWriteError({
+              message: "Failed to remove auth file",
+              cause: String(mapped.original)
+            })
+          )
+        )
+      );
+      yield* import_effect3.Effect.log("Auth data removed from local storage");
     });
-    yield* import_effect3.Console.log("Build completed successfully.");
-  }).pipe(
-    import_effect3.Effect.catchTags({
-      PackageJsonNotFoundError: (err) => import_effect3.Console.error(err.message).pipe(import_effect3.Effect.andThen(import_effect3.Effect.fail(err))),
-      PackageJsonParseError: (err) => import_effect3.Console.error(err.message).pipe(import_effect3.Effect.andThen(import_effect3.Effect.fail(err))),
-      BuildScriptNotFoundError: (err) => import_effect3.Console.error(err.message).pipe(import_effect3.Effect.andThen(import_effect3.Effect.fail(err))),
-      PackageManagerNotFoundError: (err) => import_effect3.Console.error(err.message).pipe(import_effect3.Effect.andThen(import_effect3.Effect.fail(err))),
-      ExecError: (err) => import_effect3.Console.error(`${err.message}: ${err.cause ?? err.command}`).pipe(import_effect3.Effect.andThen(import_effect3.Effect.fail(err)))
-    })
-  )
-);
-
-// src/commands/debug/index.ts
-var import_cli3 = require("@effect/cli");
-var import_effect6 = require("effect");
-
-// src/commands/debug/config/index.ts
-var import_cli2 = require("@effect/cli");
-var import_effect5 = require("effect");
+    return { load, save, remove };
+  })
+}) {
+};
 
-// src/services/project-config.ts
-var import_network_config = require("@gigadrive/network-config");
+// src/services/oauth-config.ts
 var import_effect4 = require("effect");
-var wrapParseErrors = (effect) => effect.pipe(
-  import_effect4.Effect.catchTags({
-    ConfigFileNotFoundError: (e) => import_effect4.Effect.fail(new ConfigParseError({ message: e.message, cause: e.filePath })),
-    ConfigFileEmptyError: (e) => import_effect4.Effect.fail(new ConfigParseError({ message: e.message, cause: e.filePath })),
-    ConfigFileParseError: (e) => import_effect4.Effect.fail(new ConfigParseError({ message: e.message, cause: e.cause })),
-    ConfigVersionError: (e) => import_effect4.Effect.fail(new ConfigParseError({ message: e.message, cause: e.filePath })),
-    ConfigSchemaValidationError: (e) => import_effect4.Effect.fail(new ConfigParseError({ message: e.message, cause: e.validationErrors.join(", ") })),
-    FunctionConfigError: (e) => import_effect4.Effect.fail(new ConfigParseError({ message: e.message, cause: e.functionPath }))
-  })
-);
-var ProjectConfigService = class extends import_effect4.Effect.Service()("ProjectConfigService", {
+var OAuthEnvConfig = import_effect4.Config.all({
+  issuerUrl: import_effect4.Config.string("GIGADRIVE_NETWORK_OAUTH_ISSUER_URL").pipe(import_effect4.Config.withDefault("https://idp.gigadrive.de")),
+  // Default is the first-party CLI's public OAuth client (seeded in the Network
+  // repo). Override with GIGADRIVE_NETWORK_OAUTH_CLIENT_ID per environment.
+  clientId: import_effect4.Config.string("GIGADRIVE_NETWORK_OAUTH_CLIENT_ID").pipe(
+    import_effect4.Config.withDefault("0195c11c-0000-7000-8000-000000000001")
+  )
+});
+var OpenIdDiscoveryDocument = import_effect4.Schema.Struct({
+  issuer: import_effect4.Schema.optional(import_effect4.Schema.String),
+  authorization_endpoint: import_effect4.Schema.optional(import_effect4.Schema.String),
+  token_endpoint: import_effect4.Schema.optional(import_effect4.Schema.String),
+  userinfo_endpoint: import_effect4.Schema.optional(import_effect4.Schema.String)
+});
+var CLI_SCOPES = [
+  // Identity / OIDC
+  "offline_access",
+  "openid",
+  "profile",
+  "email",
+  // Network API capabilities
+  "network:applications:read",
+  "network:env_vars:read",
+  "network:env_vars:write",
+  "network:env_vars:delete",
+  "network:deployments:read",
+  "network:deployments:write",
+  "network:deployments:trigger",
+  "network:ai_gateway:chat",
+  "network:ai_gateway:models",
+  "network:ai_gateway:usage:read",
+  "network:ai_gateway:budgets:read",
+  "network:ai_gateway:budgets:write",
+  "network:ai_gateway:policies:read",
+  "network:ai_gateway:policies:write",
+  // Provisioning local-dev API credentials
+  "platform:api_keys:read",
+  "platform:api_keys:write",
+  "platform:api_keys:delete"
+];
+var DEFAULT_SCOPE = CLI_SCOPES.join(" ");
+var OAuthConfigService = class extends import_effect4.Effect.Service()("OAuthConfigService", {
   accessors: true,
-  dependencies: [import_network_config.NetworkConfigLive],
   effect: import_effect4.Effect.gen(function* () {
-    const rawReader = yield* import_network_config.RawConfigReader;
-    const resolve = import_effect4.Effect.fn("ProjectConfigService.resolve")(function* (cwd) {
-      yield* import_effect4.Effect.annotateCurrentSpan("cwd", cwd);
-      yield* import_effect4.Effect.log("Resolving project config", { cwd });
-      const configPath = yield* rawReader.findConfig(cwd);
-      const detection = yield* (0, import_network_config.detectFramework)(cwd).pipe(
-        import_effect4.Effect.catchTag("FrameworkNotDetectedError", () => import_effect4.Effect.succeed(null)),
-        import_effect4.Effect.catchTag(
-          "ManifestReadError",
-          (e) => import_effect4.Effect.fail(new ConfigParseError({ message: `Framework detection failed: ${e.message}`, cause: e.filePath }))
-        ),
-        import_effect4.Effect.catchTag(
-          "ManifestParseError",
-          (e) => import_effect4.Effect.fail(new ConfigParseError({ message: `Framework detection failed: ${e.message}`, cause: e.filePath }))
-        )
-      );
-      if (detection) {
-        yield* import_effect4.Effect.log("Framework auto-detected", {
-          framework: detection.framework.name,
-          slug: detection.framework.slug
-        });
-      }
-      let config;
-      let resolvedConfigPath = null;
-      let framework;
-      if (configPath && detection) {
-        yield* import_effect4.Effect.log("Config file found, merging with framework defaults", { configPath });
-        resolvedConfigPath = configPath;
-        const userConfig = yield* wrapParseErrors((0, import_network_config.parseConfigRaw)(configPath, cwd));
-        const merged = yield* (0, import_network_config.mergeWithFrameworkDefaults)(userConfig, detection.config);
-        config = yield* wrapParseErrors((0, import_network_config.postProcessConfig)(merged, cwd));
-        framework = { name: detection.framework.name, slug: detection.framework.slug };
-      } else if (configPath) {
-        yield* import_effect4.Effect.log("Config file found", { configPath });
-        resolvedConfigPath = configPath;
-        config = yield* wrapParseErrors((0, import_network_config.parseConfig)(configPath, cwd));
-      } else if (detection) {
-        config = yield* wrapParseErrors((0, import_network_config.postProcessConfig)(detection.config, cwd));
-        framework = { name: detection.framework.name, slug: detection.framework.slug };
-      } else {
-        return yield* import_effect4.Effect.fail(
-          new ConfigNotFoundError({
-            message: "No config file found and no framework detected.",
-            directory: cwd
-          })
-        );
-      }
-      for (const warning of config.warnings) {
-        yield* import_effect4.Effect.logWarning(warning);
-      }
-      if (config.errors.length > 0) {
-        return yield* import_effect4.Effect.fail(
-          new ConfigValidationError({
-            message: "Config file has validation errors",
-            errors: config.errors
-          })
-        );
-      }
-      return { config, configPath: resolvedConfigPath, framework };
-    });
-    return { resolve };
-  })
-}) {
-};
-
-// src/commands/debug/config/index.ts
-var debugConfigCommand = import_cli2.Command.make(
-  "config",
-  {},
-  () => import_effect5.Effect.gen(function* () {
-    const projectConfig = yield* ProjectConfigService;
-    const cwd = process.cwd();
-    const { config, configPath } = yield* projectConfig.resolve(cwd);
-    yield* import_effect5.Console.log(`Config file found at: ${configPath}`);
-    yield* import_effect5.Console.log(JSON.stringify(config, null, 2));
-  }).pipe(
-    import_effect5.Effect.catchTags({
-      ConfigNotFoundError: (err) => import_effect5.Console.error(err.message),
-      ConfigParseError: (err) => import_effect5.Console.error(`Config parse error: ${err.message}`),
-      ConfigValidationError: (err) => import_effect5.Effect.gen(function* () {
-        for (const e of err.errors) {
-          yield* import_effect5.Console.error(e);
-        }
-        yield* import_effect5.Console.error(err.message);
-      })
-    })
-  )
-);
-
-// src/commands/debug/index.ts
-var debugBase = import_cli3.Command.make("debug", {}, () => import_effect6.Effect.void);
-var debugCommand = debugBase.pipe(import_cli3.Command.withSubcommands([debugConfigCommand]));
-
-// src/commands/login/index.ts
-var import_cli4 = require("@effect/cli");
-var import_effect11 = require("effect");
-
-// src/services/auth.ts
-var import_effect10 = require("effect");
-var crypto = __toESM(require("crypto"), 1);
-var http = __toESM(require("http"), 1);
-var import_open = __toESM(require("open"), 1);
-
-// src/services/auth-storage.ts
-var import_platform3 = require("@effect/platform");
-var import_effect8 = require("effect");
-var os = __toESM(require("os"), 1);
-
-// src/domain.ts
-var import_effect7 = require("effect");
-var DeploymentId = import_effect7.Schema.String.pipe(import_effect7.Schema.brand("@Gigadrive/DeploymentId"));
-var ApplicationId = import_effect7.Schema.String.pipe(import_effect7.Schema.brand("@Gigadrive/ApplicationId"));
-var UploadId = import_effect7.Schema.String.pipe(import_effect7.Schema.brand("@Gigadrive/UploadId"));
-var DeploymentStatus = import_effect7.Schema.Literal("PENDING", "BUILDING", "PROVISIONING", "FAILED", "ACTIVE", "SUSPENDED");
-var DeploymentLogType = import_effect7.Schema.Literal("INFO", "ERROR", "WARN");
-var DeploymentLog = import_effect7.Schema.Struct({
-  id: import_effect7.Schema.String,
-  message: import_effect7.Schema.String,
-  type: DeploymentLogType,
-  createdAt: import_effect7.Schema.String
-});
-var DeploymentLogPage = import_effect7.Schema.Struct({
-  totalItems: import_effect7.Schema.Number,
-  limit: import_effect7.Schema.Number,
-  offset: import_effect7.Schema.Number,
-  items: import_effect7.Schema.Array(DeploymentLog)
-});
-var PackageManager = import_effect7.Schema.Literal("npm", "yarn", "pnpm", "bun");
-var OAuthTokens = import_effect7.Schema.Struct({
-  access_token: import_effect7.Schema.String,
-  refresh_token: import_effect7.Schema.optional(import_effect7.Schema.String),
-  expires_in: import_effect7.Schema.optional(import_effect7.Schema.Number),
-  token_type: import_effect7.Schema.optional(import_effect7.Schema.String)
-});
-var OAuthClientConfig = import_effect7.Schema.Struct({
-  clientId: import_effect7.Schema.String,
-  issuer: import_effect7.Schema.String,
-  authorizeUrl: import_effect7.Schema.String,
-  tokenUrl: import_effect7.Schema.String,
-  scope: import_effect7.Schema.String,
-  userinfoUrl: import_effect7.Schema.String
-});
-var StoredAuthData = import_effect7.Schema.Struct({
-  refreshToken: import_effect7.Schema.String,
-  accessToken: import_effect7.Schema.optional(import_effect7.Schema.String),
-  tokenExpirationTime: import_effect7.Schema.optional(import_effect7.Schema.Number)
-});
-
-// src/services/auth-storage.ts
-var AuthStorageService = class extends import_effect8.Effect.Service()("AuthStorageService", {
-  accessors: true,
-  effect: import_effect8.Effect.gen(function* () {
-    const fs = yield* import_platform3.FileSystem.FileSystem;
-    const pathService = yield* import_platform3.Path.Path;
-    const homeDir = os.homedir();
-    const authDir = pathService.join(homeDir, ".gigadrive");
-    const authFile = pathService.join(authDir, "auth.json");
-    const ensureDirectory = import_effect8.Effect.gen(function* () {
-      yield* fs.makeDirectory(authDir, { recursive: true }).pipe(
-        import_effect8.Effect.mapError(
-          (error) => new AuthStorageWriteError({
-            message: "Failed to create auth directory",
-            cause: String(error)
-          })
-        )
-      );
-      yield* fs.chmod(authDir, 448).pipe(
-        import_effect8.Effect.mapError(
-          (error) => new AuthStorageWriteError({
-            message: "Failed to set auth directory permissions",
-            cause: String(error)
-          })
-        )
-      );
-    });
-    const load = import_effect8.Effect.gen(function* () {
-      const exists = yield* fs.exists(authFile).pipe(import_effect8.Effect.mapError(() => new AuthStorageReadError({ message: "Failed to check auth file existence" })));
-      if (!exists) return import_effect8.Option.none();
-      const data = yield* fs.readFileString(authFile, "utf8").pipe(import_effect8.Effect.mapError(() => new AuthStorageReadError({ message: "Failed to read auth file" })));
-      const json = yield* import_effect8.Effect.try({
-        try: () => JSON.parse(data),
-        catch: () => new AuthStorageReadError({ message: "Auth file contains invalid JSON" })
-      });
-      const authData = yield* import_effect8.Schema.decodeUnknown(StoredAuthData)(json).pipe(
-        import_effect8.Effect.mapError(() => new AuthStorageReadError({ message: "Auth file has invalid schema" }))
-      );
-      return import_effect8.Option.some(authData);
-    });
-    const save = import_effect8.Effect.fn("AuthStorageService.save")(function* (authData) {
-      yield* ensureDirectory;
-      yield* fs.writeFileString(authFile, JSON.stringify(authData, null, 2), { mode: 384 }).pipe(
-        import_effect8.Effect.mapError(
-          (error) => new AuthStorageWriteError({
-            message: "Failed to write auth file",
-            cause: String(error)
-          })
-        )
-      );
-      yield* import_effect8.Effect.log("Auth data saved to local storage");
-    });
-    const remove = import_effect8.Effect.gen(function* () {
-      yield* fs.remove(authFile).pipe(
-        import_effect8.Effect.mapError((error) => {
-          const cause = error instanceof Error ? error : error.error;
-          const code = cause && typeof cause === "object" && "code" in cause ? cause.code : "";
-          return { isNotFound: code === "ENOENT" || String(error).includes("ENOENT"), original: error };
-        }),
-        import_effect8.Effect.catchAll(
-          (mapped) => mapped.isNotFound ? import_effect8.Effect.void : import_effect8.Effect.fail(
-            new AuthStorageWriteError({
-              message: "Failed to remove auth file",
-              cause: String(mapped.original)
-            })
-          )
-        )
-      );
-      yield* import_effect8.Effect.log("Auth data removed from local storage");
-    });
-    return { load, save, remove };
-  })
-}) {
-};
-
-// src/services/oauth-config.ts
-var import_effect9 = require("effect");
-var OAuthEnvConfig = import_effect9.Config.all({
-  issuerUrl: import_effect9.Config.string("GIGADRIVE_NETWORK_OAUTH_ISSUER_URL").pipe(import_effect9.Config.withDefault("https://idp.gigadrive.de")),
-  clientId: import_effect9.Config.string("GIGADRIVE_NETWORK_OAUTH_CLIENT_ID").pipe(import_effect9.Config.withDefault("todo_add_client_id"))
-});
-var OpenIdDiscoveryDocument = import_effect9.Schema.Struct({
-  issuer: import_effect9.Schema.optional(import_effect9.Schema.String),
-  authorization_endpoint: import_effect9.Schema.optional(import_effect9.Schema.String),
-  token_endpoint: import_effect9.Schema.optional(import_effect9.Schema.String),
-  userinfo_endpoint: import_effect9.Schema.optional(import_effect9.Schema.String)
-});
-var DEFAULT_SCOPE = "offline_access openid profile email";
-var OAuthConfigService = class extends import_effect9.Effect.Service()("OAuthConfigService", {
-  accessors: true,
-  effect: import_effect9.Effect.gen(function* () {
     const envConfig = yield* OAuthEnvConfig;
     let cached = null;
-    const getConfig = import_effect9.Effect.gen(function* () {
+    const getConfig = import_effect4.Effect.gen(function* () {
       if (cached) return cached;
       const issuerBase = envConfig.issuerUrl.replace(/\/$/, "");
       const discoveryUrl = `${issuerBase}/.well-known/openid-configuration`;
-      yield* import_effect9.Effect.log("Fetching OIDC discovery document", { discoveryUrl });
-      const response = yield* import_effect9.Effect.tryPromise({
+      yield* import_effect4.Effect.log("Fetching OIDC discovery document", { discoveryUrl });
+      const response = yield* import_effect4.Effect.tryPromise({
         try: (signal) => fetch(discoveryUrl, { signal }),
         catch: (error) => new OAuthDiscoveryError({
           message: "Failed to fetch OIDC discovery document",
@@ -606,27 +489,27 @@ var OAuthConfigService = class extends import_effect9.Effect.Service()("OAuthCon
         })
       });
       if (!response.ok) {
-        return yield* import_effect9.Effect.fail(
+        return yield* import_effect4.Effect.fail(
           new OAuthDiscoveryError({
             message: `OIDC discovery returned ${response.status} ${response.statusText}`
           })
         );
       }
-      const json = yield* import_effect9.Effect.tryPromise({
+      const json = yield* import_effect4.Effect.tryPromise({
         try: () => response.json(),
         catch: () => new OAuthDiscoveryError({
           message: "Failed to parse OIDC discovery JSON"
         })
       });
-      const decoded = yield* import_effect9.Schema.decodeUnknown(OpenIdDiscoveryDocument)(json).pipe(
-        import_effect9.Effect.mapError(
+      const decoded = yield* import_effect4.Schema.decodeUnknown(OpenIdDiscoveryDocument)(json).pipe(
+        import_effect4.Effect.mapError(
           () => new OAuthDiscoveryError({
             message: "Invalid OIDC discovery document schema"
           })
         )
       );
       if (!decoded.authorization_endpoint || !decoded.token_endpoint || !decoded.userinfo_endpoint) {
-        return yield* import_effect9.Effect.fail(
+        return yield* import_effect4.Effect.fail(
           new OAuthDiscoveryError({
             message: "OIDC discovery returned incomplete endpoints"
           })
@@ -641,7 +524,7 @@ var OAuthConfigService = class extends import_effect9.Effect.Service()("OAuthCon
         userinfoUrl: decoded.userinfo_endpoint
       };
       cached = config;
-      yield* import_effect9.Effect.log("OIDC discovery completed", { issuer: config.issuer });
+      yield* import_effect4.Effect.log("OIDC discovery completed", { issuer: config.issuer });
       return config;
     });
     return { getConfig };
@@ -658,22 +541,22 @@ var generatePKCE = () => {
   const codeChallenge = base64URLEncode(challengeBytes);
   return { codeVerifier, codeChallenge };
 };
-var AuthService = class extends import_effect10.Effect.Service()("AuthService", {
+var AuthService = class extends import_effect5.Effect.Service()("AuthService", {
   accessors: true,
   dependencies: [OAuthConfigService.Default, AuthStorageService.Default],
-  effect: import_effect10.Effect.gen(function* () {
+  effect: import_effect5.Effect.gen(function* () {
     const oauthConfig = yield* OAuthConfigService;
     const storage = yield* AuthStorageService;
     let accessToken = null;
     let tokenExpirationTime = 0;
-    const logout = import_effect10.Effect.gen(function* () {
+    const logout = import_effect5.Effect.gen(function* () {
       accessToken = null;
       tokenExpirationTime = 0;
       yield* storage.remove;
-      yield* import_effect10.Effect.log("Logged out");
+      yield* import_effect5.Effect.log("Logged out");
     });
-    const exchangeCodeForTokens = (config, authCode, redirectUri, codeVerifier) => import_effect10.Effect.gen(function* () {
-      const response = yield* import_effect10.Effect.tryPromise({
+    const exchangeCodeForTokens = (config, authCode, redirectUri, codeVerifier) => import_effect5.Effect.gen(function* () {
+      const response = yield* import_effect5.Effect.tryPromise({
         try: () => fetch(config.tokenUrl, {
           method: "POST",
           headers: { "Content-Type": "application/x-www-form-urlencoded" },
@@ -690,31 +573,31 @@ var AuthService = class extends import_effect10.Effect.Service()("AuthService",
         })
       });
       if (!response.ok) {
-        const body = yield* import_effect10.Effect.tryPromise({
+        const body = yield* import_effect5.Effect.tryPromise({
           try: () => response.text(),
           catch: () => new TokenExchangeError({ message: "Failed to read token exchange error response" })
         });
-        return yield* import_effect10.Effect.fail(
+        return yield* import_effect5.Effect.fail(
           new TokenExchangeError({
             message: `Token exchange failed: ${response.status} ${response.statusText} - ${body}`,
             statusCode: response.status
           })
         );
       }
-      const tokens = yield* import_effect10.Effect.tryPromise({
+      const tokens = yield* import_effect5.Effect.tryPromise({
         try: () => response.json(),
         catch: () => new TokenExchangeError({ message: "Failed to parse token exchange response" })
       });
       return tokens;
     });
-    const startCallbackServer = (config, codeChallenge, state) => import_effect10.Effect.async((resume) => {
+    const startCallbackServer = (config, codeChallenge, state) => import_effect5.Effect.async((resume) => {
       const server = http.createServer();
       const redirectPath = "/callback";
       server.listen(0, "127.0.0.1", () => {
         const address = server.address();
         if (!address || typeof address !== "object") {
           server.close(() => {
-            resume(import_effect10.Effect.fail(new LoginFlowError({ message: "Failed to determine callback server address" })));
+            resume(import_effect5.Effect.fail(new LoginFlowError({ message: "Failed to determine callback server address" })));
           });
           return;
         }
@@ -728,10 +611,10 @@ var AuthService = class extends import_effect10.Effect.Service()("AuthService",
         authUrl.searchParams.append("code_challenge", codeChallenge);
         authUrl.searchParams.append("code_challenge_method", "S256");
         authUrl.searchParams.append("state", state);
-        import_effect10.Console.log(`Please open this URL in your browser to log in:
+        import_effect5.Console.log(`Please open this URL in your browser to log in:
 ${authUrl.toString()}
-`).pipe(import_effect10.Effect.runSync);
-        import_effect10.Console.log("Waiting for login callback...").pipe(import_effect10.Effect.runSync);
+`).pipe(import_effect5.Effect.runSync);
+        import_effect5.Console.log("Waiting for login callback...").pipe(import_effect5.Effect.runSync);
         void (0, import_open.default)(authUrl.toString());
         server.on("request", (req, res) => {
           const reqUrl = new URL(req.url || "", redirectUri);
@@ -747,7 +630,7 @@ ${authUrl.toString()}
             const safeOauthError = escapeHtml(oauthError);
             res.end(`<h1>Login Failed!</h1><p>Error: ${safeOauthError}</p><p>You can close this tab.</p>`);
             server.close();
-            resume(import_effect10.Effect.fail(new LoginFlowError({ message: `OAuth error: ${oauthError}` })));
+            resume(import_effect5.Effect.fail(new LoginFlowError({ message: `OAuth error: ${oauthError}` })));
             return;
           }
           if (receivedState !== state) {
@@ -755,26 +638,26 @@ ${authUrl.toString()}
               "<h1>Login Failed!</h1><p>State mismatch. Possible CSRF attack.</p><p>You can close this tab.</p>"
             );
             server.close();
-            resume(import_effect10.Effect.fail(new LoginFlowError({ message: "State mismatch" })));
+            resume(import_effect5.Effect.fail(new LoginFlowError({ message: "State mismatch" })));
             return;
           }
           if (authCode) {
             res.end("<h1>Login Successful!</h1><p>You can close this tab.</p>");
             server.close();
-            resume(import_effect10.Effect.succeed({ authCode, redirectUri }));
+            resume(import_effect5.Effect.succeed({ authCode, redirectUri }));
           } else {
             res.end("<h1>Login Failed!</h1><p>No authorization code received.</p><p>You can close this tab.</p>");
             server.close();
-            resume(import_effect10.Effect.fail(new LoginFlowError({ message: "No authorization code received" })));
+            resume(import_effect5.Effect.fail(new LoginFlowError({ message: "No authorization code received" })));
           }
         });
         server.on("error", (err) => {
           server.close();
-          resume(import_effect10.Effect.fail(new LoginFlowError({ message: `Local server error: ${err.message}` })));
+          resume(import_effect5.Effect.fail(new LoginFlowError({ message: `Local server error: ${err.message}` })));
         });
       });
     });
-    const login = import_effect10.Effect.gen(function* () {
+    const login = import_effect5.Effect.gen(function* () {
       yield* logout;
       const { codeVerifier, codeChallenge } = generatePKCE();
       const state = crypto.randomBytes(16).toString("hex");
@@ -782,7 +665,7 @@ ${authUrl.toString()}
       const { authCode, redirectUri } = yield* startCallbackServer(config, codeChallenge, state);
       const tokens = yield* exchangeCodeForTokens(config, authCode, redirectUri, codeVerifier);
       if (!tokens.refresh_token) {
-        return yield* import_effect10.Effect.fail(
+        return yield* import_effect5.Effect.fail(
           new TokenExchangeError({ message: "No refresh token received from identity provider" })
         );
       }
@@ -793,21 +676,21 @@ ${authUrl.toString()}
         accessToken,
         tokenExpirationTime
       });
-      yield* import_effect10.Effect.log("Login successful");
+      yield* import_effect5.Effect.log("Login successful");
       return true;
     });
-    const refreshAccessToken = import_effect10.Effect.gen(function* () {
+    const refreshAccessToken = import_effect5.Effect.gen(function* () {
       const stored = yield* storage.load.pipe(
-        import_effect10.Effect.catchTag("AuthStorageReadError", (err) => import_effect10.Effect.fail(new TokenRefreshError({ message: err.message })))
+        import_effect5.Effect.catchTag("AuthStorageReadError", (err) => import_effect5.Effect.fail(new TokenRefreshError({ message: err.message })))
       );
       const config = yield* oauthConfig.getConfig.pipe(
-        import_effect10.Effect.catchTag("OAuthDiscoveryError", (err) => import_effect10.Effect.fail(new TokenRefreshError({ message: err.message })))
+        import_effect5.Effect.catchTag("OAuthDiscoveryError", (err) => import_effect5.Effect.fail(new TokenRefreshError({ message: err.message })))
       );
-      const authData = yield* import_effect10.Option.match(stored, {
-        onNone: () => import_effect10.Effect.fail(new TokenRefreshError({ message: "No refresh token available. Please log in." })),
-        onSome: (data) => data.refreshToken ? import_effect10.Effect.succeed(data) : import_effect10.Effect.fail(new TokenRefreshError({ message: "No refresh token available. Please log in." }))
+      const authData = yield* import_effect5.Option.match(stored, {
+        onNone: () => import_effect5.Effect.fail(new TokenRefreshError({ message: "No refresh token available. Please log in." })),
+        onSome: (data) => data.refreshToken ? import_effect5.Effect.succeed(data) : import_effect5.Effect.fail(new TokenRefreshError({ message: "No refresh token available. Please log in." }))
       });
-      const response = yield* import_effect10.Effect.tryPromise({
+      const response = yield* import_effect5.Effect.tryPromise({
         try: () => fetch(config.tokenUrl, {
           method: "POST",
           headers: { "Content-Type": "application/x-www-form-urlencoded" },
@@ -823,26 +706,26 @@ ${authUrl.toString()}
       });
       if (!response.ok) {
         if (response.status === 400) {
-          yield* logout.pipe(import_effect10.Effect.catchAll(() => import_effect10.Effect.void));
-          return yield* import_effect10.Effect.fail(
+          yield* logout.pipe(import_effect5.Effect.catchAll(() => import_effect5.Effect.void));
+          return yield* import_effect5.Effect.fail(
             new TokenRefreshError({
               message: "Refresh token is invalid or expired. Please log in again.",
               statusCode: response.status
             })
           );
         }
-        const body = yield* import_effect10.Effect.tryPromise({
+        const body = yield* import_effect5.Effect.tryPromise({
           try: () => response.text(),
           catch: () => new TokenRefreshError({ message: "Failed to read refresh error response" })
         });
-        return yield* import_effect10.Effect.fail(
+        return yield* import_effect5.Effect.fail(
           new TokenRefreshError({
             message: `Token refresh failed: ${response.status} ${response.statusText} - ${body}`,
             statusCode: response.status
           })
         );
       }
-      const tokens = yield* import_effect10.Effect.tryPromise({
+      const tokens = yield* import_effect5.Effect.tryPromise({
         try: () => response.json(),
         catch: () => new TokenRefreshError({ message: "Failed to parse token refresh response" })
       });
@@ -853,148 +736,1485 @@ ${authUrl.toString()}
         refreshToken: newRefreshToken,
         accessToken,
         tokenExpirationTime
-      }).pipe(import_effect10.Effect.catchAll(() => import_effect10.Effect.void));
-      yield* import_effect10.Effect.log("Access token refreshed successfully");
+      }).pipe(import_effect5.Effect.catchAll(() => import_effect5.Effect.void));
+      yield* import_effect5.Effect.log("Access token refreshed successfully");
       return true;
     });
-    const getAccessToken = import_effect10.Effect.gen(function* () {
-      if (accessToken && Date.now() < tokenExpirationTime) {
-        return accessToken;
-      }
-      const stored = yield* storage.load.pipe(
-        import_effect10.Effect.catchAll(() => import_effect10.Effect.succeed(import_effect10.Option.none()))
+    const getAccessToken = import_effect5.Effect.gen(function* () {
+      if (accessToken && Date.now() < tokenExpirationTime) {
+        return accessToken;
+      }
+      const stored = yield* storage.load.pipe(
+        import_effect5.Effect.catchAll(() => import_effect5.Effect.succeed(import_effect5.Option.none()))
+      );
+      import_effect5.Option.match(stored, {
+        onNone: () => {
+        },
+        onSome: (data) => {
+          if (data.accessToken && data.tokenExpirationTime && Date.now() < data.tokenExpirationTime) {
+            accessToken = data.accessToken;
+            tokenExpirationTime = data.tokenExpirationTime;
+          }
+        }
+      });
+      if (accessToken && Date.now() < tokenExpirationTime) {
+        return accessToken;
+      }
+      yield* import_effect5.Effect.log("Access token expired or not available. Attempting to refresh...");
+      yield* refreshAccessToken.pipe(
+        import_effect5.Effect.catchTag("TokenRefreshError", (err) => import_effect5.Effect.fail(new NotAuthenticatedError({ message: err.message })))
+      );
+      if (!accessToken) {
+        return yield* import_effect5.Effect.fail(
+          new NotAuthenticatedError({ message: "No valid access token available. Please log in first." })
+        );
+      }
+      return accessToken;
+    });
+    const getUserInfo = import_effect5.Effect.gen(function* () {
+      const config = yield* oauthConfig.getConfig;
+      const token = yield* getAccessToken;
+      const fetchUserInfo = (t) => import_effect5.Effect.tryPromise({
+        try: () => fetch(config.userinfoUrl, {
+          headers: {
+            Authorization: `Bearer ${t}`,
+            Accept: "application/json"
+          }
+        }),
+        catch: (error) => new UserInfoFetchError({
+          message: `Failed to fetch user info: ${error instanceof Error ? error.message : String(error)}`
+        })
+      });
+      let response = yield* fetchUserInfo(token);
+      if (response.status === 401 || response.status === 403) {
+        yield* refreshAccessToken.pipe(
+          import_effect5.Effect.catchTag("TokenRefreshError", (err) => import_effect5.Effect.fail(new UserInfoFetchError({ message: err.message })))
+        );
+        if (!accessToken) {
+          return yield* import_effect5.Effect.fail(new UserInfoFetchError({ message: "Token refresh failed" }));
+        }
+        response = yield* fetchUserInfo(accessToken);
+      }
+      if (!response.ok) {
+        const body = yield* import_effect5.Effect.tryPromise({
+          try: () => response.text(),
+          catch: () => new UserInfoFetchError({ message: "Failed to read user info error response" })
+        });
+        return yield* import_effect5.Effect.fail(
+          new UserInfoFetchError({
+            message: `Failed to fetch user info: ${response.status} ${response.statusText}${body ? ` - ${body}` : ""}`,
+            statusCode: response.status
+          })
+        );
+      }
+      const data = yield* import_effect5.Effect.tryPromise({
+        try: () => response.json(),
+        catch: () => new UserInfoFetchError({ message: "Failed to parse user info response" })
+      });
+      return data;
+    });
+    const inferUserName = (info) => {
+      const isNonEmptyString = (value) => typeof value === "string" && value.trim() !== "";
+      const name = info.name;
+      const givenName = info.given_name;
+      const familyName = info.family_name;
+      const preferredUsername = info.preferred_username;
+      const email = info.email;
+      return isNonEmptyString(name) && name || (isNonEmptyString(givenName) && isNonEmptyString(familyName) ? `${givenName} ${familyName}` : void 0) || isNonEmptyString(preferredUsername) && preferredUsername || isNonEmptyString(email) && email || "your account";
+    };
+    return { login, logout, getAccessToken, getUserInfo, refreshAccessToken, inferUserName };
+  })
+}) {
+};
+
+// src/services/api-client.ts
+var ApiBaseUrl = import_effect6.Config.string("GIGADRIVE_API_BASE_URL").pipe(import_effect6.Config.withDefault("https://api.gigadrive.network"));
+var toApiRequestError = (error) => {
+  if (error instanceof import_sdk.ApiError) {
+    return new ApiRequestError({ message: error.message, statusCode: error.status, code: error.code });
+  }
+  return new ApiRequestError({ message: error instanceof Error ? error.message : String(error) });
+};
+var ApiClientService = class extends import_effect6.Effect.Service()("ApiClientService", {
+  accessors: true,
+  effect: import_effect6.Effect.gen(function* () {
+    const baseUrl = yield* ApiBaseUrl;
+    const authService = yield* AuthService;
+    const getClient = import_effect6.Effect.gen(function* () {
+      const token = yield* authService.getAccessToken;
+      return new import_sdk.GigadriveClient({ bearerToken: token, baseUrl });
+    });
+    const request = (f) => import_effect6.Effect.gen(function* () {
+      const client = yield* getClient;
+      return yield* import_effect6.Effect.tryPromise({
+        try: () => f(client),
+        catch: toApiRequestError
+      });
+    });
+    return { getClient, request };
+  })
+}) {
+};
+
+// src/services/project-link.ts
+var import_platform2 = require("@effect/platform");
+var import_effect7 = require("effect");
+var LINK_DIR = ".gigadrive";
+var LINK_FILE = "project.json";
+var ProjectLinkService = class extends import_effect7.Effect.Service()("ProjectLinkService", {
+  accessors: true,
+  effect: import_effect7.Effect.gen(function* () {
+    const fs = yield* import_platform2.FileSystem.FileSystem;
+    const pathService = yield* import_platform2.Path.Path;
+    const linkDir = (projectFolder) => pathService.join(projectFolder, LINK_DIR);
+    const linkFile = (projectFolder) => pathService.join(projectFolder, LINK_DIR, LINK_FILE);
+    const load = import_effect7.Effect.fn("ProjectLinkService.load")(function* (projectFolder) {
+      const file = linkFile(projectFolder);
+      const exists = yield* fs.exists(file).pipe(import_effect7.Effect.mapError(() => new ProjectLinkReadError({ message: "Failed to check project link existence" })));
+      if (!exists) return import_effect7.Option.none();
+      const data = yield* fs.readFileString(file, "utf8").pipe(import_effect7.Effect.mapError(() => new ProjectLinkReadError({ message: "Failed to read project link file" })));
+      const json = yield* import_effect7.Effect.try({
+        try: () => JSON.parse(data),
+        catch: () => new ProjectLinkReadError({ message: `${LINK_DIR}/${LINK_FILE} contains invalid JSON` })
+      });
+      const link = yield* import_effect7.Schema.decodeUnknown(ProjectLink)(json).pipe(
+        import_effect7.Effect.mapError(() => new ProjectLinkReadError({ message: `${LINK_DIR}/${LINK_FILE} has an invalid schema` }))
+      );
+      return import_effect7.Option.some(link);
+    });
+    const resolve = import_effect7.Effect.fn("ProjectLinkService.resolve")(function* (projectFolder) {
+      const link = yield* load(projectFolder);
+      return yield* import_effect7.Option.match(link, {
+        onNone: () => import_effect7.Effect.fail(
+          new ProjectNotLinkedError({
+            message: 'This directory is not linked to an application. Run "gigadrive link" first.',
+            directory: projectFolder
+          })
+        ),
+        onSome: (value) => import_effect7.Effect.succeed(value)
+      });
+    });
+    const save = import_effect7.Effect.fn("ProjectLinkService.save")(function* (projectFolder, link) {
+      yield* fs.makeDirectory(linkDir(projectFolder), { recursive: true }).pipe(
+        import_effect7.Effect.mapError(
+          (error) => new ProjectLinkWriteError({ message: "Failed to create .gigadrive directory", cause: String(error) })
+        )
+      );
+      yield* fs.writeFileString(linkFile(projectFolder), `${JSON.stringify(link, null, 2)}
+`).pipe(
+        import_effect7.Effect.mapError(
+          (error) => new ProjectLinkWriteError({ message: "Failed to write project link file", cause: String(error) })
+        )
+      );
+      yield* import_effect7.Effect.log("Project link saved", { applicationId: link.applicationId });
+    });
+    const remove = import_effect7.Effect.fn("ProjectLinkService.remove")(function* (projectFolder) {
+      yield* fs.remove(linkFile(projectFolder), { force: true }).pipe(
+        import_effect7.Effect.mapError(
+          (error) => new ProjectLinkWriteError({ message: "Failed to remove project link file", cause: String(error) })
+        )
+      );
+    });
+    return { load, resolve, save, remove };
+  })
+}) {
+};
+
+// src/commands/ai/index.ts
+var orgOption = import_cli.Options.text("org").pipe(
+  import_cli.Options.withAlias("o"),
+  import_cli.Options.withDescription("Organization ID (defaults to the linked organization)"),
+  import_cli.Options.optional
+);
+var appOption = import_cli.Options.text("app").pipe(
+  import_cli.Options.withAlias("a"),
+  import_cli.Options.withDescription("Restrict to this application ID"),
+  import_cli.Options.optional
+);
+var fromOption = import_cli.Options.text("from").pipe(
+  import_cli.Options.withDescription("Include usage at or after this ISO 8601 timestamp"),
+  import_cli.Options.optional
+);
+var toOption = import_cli.Options.text("to").pipe(
+  import_cli.Options.withDescription("Include usage before or at this ISO 8601 timestamp"),
+  import_cli.Options.optional
+);
+var fileOption = import_cli.Options.text("file").pipe(
+  import_cli.Options.withAlias("f"),
+  import_cli.Options.withDescription('Path to a JSON file, or "-" for stdin (default: stdin)'),
+  import_cli.Options.optional
+);
+var resolveOrgId = (org) => import_effect8.Effect.gen(function* () {
+  if (import_effect8.Option.isSome(org)) return org.value;
+  const projectLink = yield* ProjectLinkService;
+  const link = yield* projectLink.resolve(process.cwd());
+  if (link.organizationId === void 0) {
+    return yield* import_effect8.Effect.fail(
+      new ProjectNotLinkedError({
+        message: 'No organization is linked. Pass --org <id> or re-run "gigadrive link".',
+        directory: process.cwd()
+      })
+    );
+  }
+  return link.organizationId;
+});
+var readStdin = import_effect8.Effect.async((resume) => {
+  let data = "";
+  const stdin = process.stdin;
+  stdin.setEncoding("utf8");
+  const onData = (chunk) => {
+    data += chunk;
+  };
+  const cleanup = () => {
+    stdin.off("data", onData);
+    stdin.off("end", onEnd);
+    stdin.off("error", onError);
+  };
+  const onEnd = () => {
+    cleanup();
+    resume(import_effect8.Effect.succeed(data));
+  };
+  const onError = (err) => {
+    cleanup();
+    resume(import_effect8.Effect.fail(new ApiRequestError({ message: `Failed to read stdin: ${err.message}` })));
+  };
+  stdin.on("data", onData);
+  stdin.on("end", onEnd);
+  stdin.on("error", onError);
+  stdin.resume();
+});
+var readJsonInput = (file) => import_effect8.Effect.gen(function* () {
+  const path = import_effect8.Option.getOrUndefined(file);
+  let raw;
+  if (path === void 0 || path === "-") {
+    raw = yield* readStdin;
+  } else {
+    const fs = yield* import_platform3.FileSystem.FileSystem;
+    raw = yield* fs.readFileString(path, "utf8").pipe(import_effect8.Effect.mapError((e) => new ApiRequestError({ message: `Failed to read ${path}: ${String(e)}` })));
+  }
+  return yield* import_effect8.Effect.try({
+    try: () => JSON.parse(raw),
+    catch: () => new ApiRequestError({ message: "Input is not valid JSON." })
+  });
+});
+var governanceErrorHandlers = {
+  NotAuthenticatedError: (err) => import_effect8.Console.error('You are not logged in. Run "gigadrive login" to authenticate.').pipe(
+    import_effect8.Effect.andThen(import_effect8.Effect.fail(err))
+  ),
+  ApiRequestError: (err) => import_effect8.Console.error(err.message).pipe(import_effect8.Effect.andThen(import_effect8.Effect.fail(err))),
+  ProjectNotLinkedError: (err) => import_effect8.Console.error(err.message).pipe(import_effect8.Effect.andThen(import_effect8.Effect.fail(err))),
+  ProjectLinkReadError: (err) => import_effect8.Console.error(err.message).pipe(import_effect8.Effect.andThen(import_effect8.Effect.fail(err)))
+};
+var usageSummaryCommand = import_cli.Command.make(
+  "summary",
+  { org: orgOption, app: appOption, from: fromOption, to: toOption },
+  ({ org, app, from, to }) => import_effect8.Effect.gen(function* () {
+    const apiClient = yield* ApiClientService;
+    const orgId = yield* resolveOrgId(org);
+    const summary = yield* apiClient.request(
+      (client) => client.organizations.aiGateway.usage.summary(orgId, {
+        applicationId: import_effect8.Option.getOrUndefined(app),
+        from: import_effect8.Option.getOrUndefined(from),
+        to: import_effect8.Option.getOrUndefined(to)
+      })
+    );
+    yield* import_effect8.Console.log(JSON.stringify(summary, null, 2));
+  }).pipe(import_effect8.Effect.catchTags(governanceErrorHandlers))
+);
+var usageRequestsCommand = import_cli.Command.make(
+  "requests",
+  { org: orgOption, app: appOption, from: fromOption, to: toOption },
+  ({ org, app, from, to }) => import_effect8.Effect.gen(function* () {
+    const apiClient = yield* ApiClientService;
+    const orgId = yield* resolveOrgId(org);
+    const { items, total } = yield* apiClient.request(
+      (client) => client.organizations.aiGateway.usage.requests(orgId, {
+        applicationId: import_effect8.Option.getOrUndefined(app),
+        from: import_effect8.Option.getOrUndefined(from),
+        to: import_effect8.Option.getOrUndefined(to)
+      })
+    );
+    if (items.length === 0) {
+      yield* import_effect8.Console.log("No AI Gateway requests found.");
+      return;
+    }
+    for (const e of items) {
+      yield* import_effect8.Console.log(
+        `${e.createdAt}  ${e.modelRequested}  ${e.status}  ${e.totalTokens} tok  ${e.billableCostMicros}\xB5$`
+      );
+    }
+    yield* import_effect8.Console.log(`
+${total} request(s).`);
+  }).pipe(import_effect8.Effect.catchTags(governanceErrorHandlers))
+);
+var outOption = import_cli.Options.text("out").pipe(
+  import_cli.Options.withDescription("Write the CSV to this file instead of stdout"),
+  import_cli.Options.optional
+);
+var usageExportCommand = import_cli.Command.make(
+  "export",
+  { org: orgOption, app: appOption, from: fromOption, to: toOption, out: outOption },
+  ({ org, app, from, to, out }) => import_effect8.Effect.gen(function* () {
+    const apiClient = yield* ApiClientService;
+    const orgId = yield* resolveOrgId(org);
+    const csv = yield* apiClient.request(
+      (client) => client.organizations.aiGateway.usage.export(orgId, {
+        applicationId: import_effect8.Option.getOrUndefined(app),
+        from: import_effect8.Option.getOrUndefined(from),
+        to: import_effect8.Option.getOrUndefined(to)
+      })
+    );
+    const outPath = import_effect8.Option.getOrUndefined(out);
+    if (outPath === void 0) {
+      yield* import_effect8.Console.log(csv);
+    } else {
+      const fs = yield* import_platform3.FileSystem.FileSystem;
+      yield* fs.writeFileString(outPath, csv).pipe(import_effect8.Effect.mapError((e) => new ApiRequestError({ message: `Failed to write ${outPath}: ${String(e)}` })));
+      yield* import_effect8.Console.log(`Wrote ${outPath}.`);
+    }
+  }).pipe(import_effect8.Effect.catchTags(governanceErrorHandlers))
+);
+var usageCommand = import_cli.Command.make("usage", {}, () => import_effect8.Effect.void).pipe(
+  import_cli.Command.withSubcommands([usageSummaryCommand, usageRequestsCommand, usageExportCommand])
+);
+var budgetsGetCommand = import_cli.Command.make(
+  "get",
+  { org: orgOption },
+  ({ org }) => import_effect8.Effect.gen(function* () {
+    const apiClient = yield* ApiClientService;
+    const orgId = yield* resolveOrgId(org);
+    const { items } = yield* apiClient.request((client) => client.organizations.aiGateway.budgets.list(orgId));
+    yield* import_effect8.Console.log(JSON.stringify(items, null, 2));
+  }).pipe(import_effect8.Effect.catchTags(governanceErrorHandlers))
+);
+var budgetsSetCommand = import_cli.Command.make(
+  "set",
+  { org: orgOption, file: fileOption },
+  ({ org, file }) => import_effect8.Effect.gen(function* () {
+    const apiClient = yield* ApiClientService;
+    const orgId = yield* resolveOrgId(org);
+    const parsed = yield* readJsonInput(file);
+    const budgets = Array.isArray(parsed) ? parsed : parsed.budgets;
+    if (!Array.isArray(budgets)) {
+      return yield* import_effect8.Effect.fail(
+        new ApiRequestError({
+          message: 'Expected a JSON array of budgets, or an object of the form { "budgets": [...] }.'
+        })
+      );
+    }
+    const { items } = yield* apiClient.request(
+      (client) => client.organizations.aiGateway.budgets.replace(orgId, budgets)
+    );
+    yield* import_effect8.Console.log(`Saved ${items.length} budget(s).`);
+  }).pipe(import_effect8.Effect.catchTags(governanceErrorHandlers))
+);
+var budgetsCommand = import_cli.Command.make("budgets", {}, () => import_effect8.Effect.void).pipe(
+  import_cli.Command.withSubcommands([budgetsGetCommand, budgetsSetCommand])
+);
+var policiesGetCommand = import_cli.Command.make(
+  "get",
+  { org: orgOption, app: appOption },
+  ({ org, app }) => import_effect8.Effect.gen(function* () {
+    const apiClient = yield* ApiClientService;
+    const orgId = yield* resolveOrgId(org);
+    const policy = yield* apiClient.request(
+      (client) => client.organizations.aiGateway.policies.get(orgId, { applicationId: import_effect8.Option.getOrUndefined(app) })
+    );
+    yield* import_effect8.Console.log(policy === null ? "No policy set." : JSON.stringify(policy, null, 2));
+  }).pipe(import_effect8.Effect.catchTags(governanceErrorHandlers))
+);
+var policiesSetCommand = import_cli.Command.make(
+  "set",
+  { org: orgOption, file: fileOption },
+  ({ org, file }) => import_effect8.Effect.gen(function* () {
+    const apiClient = yield* ApiClientService;
+    const orgId = yield* resolveOrgId(org);
+    const parsed = yield* readJsonInput(file);
+    const policy = yield* apiClient.request(
+      (client) => client.organizations.aiGateway.policies.put(orgId, parsed)
+    );
+    yield* import_effect8.Console.log(`Policy saved${policy.applicationId ? ` for application ${policy.applicationId}` : ""}.`);
+  }).pipe(import_effect8.Effect.catchTags(governanceErrorHandlers))
+);
+var policiesCommand = import_cli.Command.make("policies", {}, () => import_effect8.Effect.void).pipe(
+  import_cli.Command.withSubcommands([policiesGetCommand, policiesSetCommand])
+);
+var inferenceErrorHandlers = {
+  NotAuthenticatedError: (err) => import_effect8.Console.error('You are not logged in. Run "gigadrive login" to authenticate.').pipe(
+    import_effect8.Effect.andThen(import_effect8.Effect.fail(err))
+  ),
+  ApiRequestError: (err) => import_effect8.Console.error(err.message).pipe(import_effect8.Effect.andThen(import_effect8.Effect.fail(err)))
+};
+var modelsListCommand = import_cli.Command.make(
+  "list",
+  {},
+  () => import_effect8.Effect.gen(function* () {
+    const apiClient = yield* ApiClientService;
+    const { items } = yield* apiClient.request((client) => client.aiGateway.listModels());
+    for (const m of items) {
+      yield* import_effect8.Console.log(`${m.id}  ${m.name}  (ctx ${m.contextWindow})`);
+    }
+  }).pipe(import_effect8.Effect.catchTags(inferenceErrorHandlers))
+);
+var modelIdArg = import_cli.Args.text({ name: "model-id" }).pipe(import_cli.Args.withDescription("The model ID, e.g. openai/gpt-4o"));
+var modelsGetCommand = import_cli.Command.make(
+  "get",
+  { modelId: modelIdArg },
+  ({ modelId }) => import_effect8.Effect.gen(function* () {
+    const apiClient = yield* ApiClientService;
+    const model = yield* apiClient.request((client) => client.aiGateway.getModel(modelId));
+    yield* import_effect8.Console.log(JSON.stringify(model, null, 2));
+  }).pipe(import_effect8.Effect.catchTags(inferenceErrorHandlers))
+);
+var modelsCommand = import_cli.Command.make("models", {}, () => import_effect8.Effect.void).pipe(
+  import_cli.Command.withSubcommands([modelsListCommand, modelsGetCommand])
+);
+var modelOption = import_cli.Options.text("model").pipe(
+  import_cli.Options.withAlias("m"),
+  import_cli.Options.withDescription("The model ID to use, e.g. openai/gpt-4o")
+);
+var streamOption = import_cli.Options.boolean("stream").pipe(import_cli.Options.withDescription("Stream the response token by token"));
+var promptArg = import_cli.Args.text({ name: "prompt" }).pipe(
+  import_cli.Args.withDescription('The prompt text, or "-" to read from stdin')
+);
+var chatCommand = import_cli.Command.make(
+  "chat",
+  { prompt: promptArg, model: modelOption, stream: streamOption },
+  ({ prompt, model, stream }) => import_effect8.Effect.gen(function* () {
+    const apiClient = yield* ApiClientService;
+    const text = prompt === "-" ? yield* readStdin : prompt;
+    const messages = [{ role: "user", content: text }];
+    if (stream) {
+      const client = yield* apiClient.getClient;
+      yield* import_effect8.Effect.tryPromise({
+        try: async () => {
+          for await (const chunk of client.aiGateway.chatCompletionsStream({ model, messages })) {
+            process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
+          }
+          process.stdout.write("\n");
+        },
+        catch: (error) => new ApiRequestError({ message: error instanceof Error ? error.message : String(error) })
+      });
+      return;
+    }
+    const response = yield* apiClient.request((client) => client.aiGateway.chatCompletions({ model, messages }));
+    const content = response.choices[0]?.message.content;
+    yield* import_effect8.Console.log(typeof content === "string" ? content : JSON.stringify(content));
+  }).pipe(import_effect8.Effect.catchTags(inferenceErrorHandlers))
+);
+var aiBase = import_cli.Command.make("ai", {}, () => import_effect8.Effect.void);
+var aiCommand = aiBase.pipe(
+  import_cli.Command.withSubcommands([usageCommand, budgetsCommand, policiesCommand, modelsCommand, chatCommand])
+);
+
+// src/commands/apps/index.ts
+var import_cli2 = require("@effect/cli");
+var import_effect9 = require("effect");
+var orgOption2 = import_cli2.Options.text("org").pipe(
+  import_cli2.Options.withAlias("o"),
+  import_cli2.Options.withDescription("Only list applications belonging to this organization ID"),
+  import_cli2.Options.optional
+);
+var appsListCommand = import_cli2.Command.make(
+  "list",
+  { org: orgOption2 },
+  ({ org }) => import_effect9.Effect.gen(function* () {
+    const apiClient = yield* ApiClientService;
+    const organizationId = import_effect9.Option.getOrUndefined(org);
+    const { items, total } = yield* apiClient.request((client) => client.applications.list({ organizationId }));
+    if (items.length === 0) {
+      yield* import_effect9.Console.log("No applications found.");
+      return;
+    }
+    for (const app of items) {
+      yield* import_effect9.Console.log(`${app.id}  ${app.name}  (${app.organization.name})`);
+    }
+    yield* import_effect9.Console.log(`
+${total} application(s).`);
+  }).pipe(
+    import_effect9.Effect.catchTags({
+      NotAuthenticatedError: (err) => import_effect9.Console.error('You are not logged in. Run "gigadrive login" to authenticate.').pipe(
+        import_effect9.Effect.andThen(import_effect9.Effect.fail(err))
+      ),
+      ApiRequestError: (err) => import_effect9.Console.error(`Failed to list applications: ${err.message}`).pipe(import_effect9.Effect.andThen(import_effect9.Effect.fail(err)))
+    })
+  )
+);
+var appsBase = import_cli2.Command.make("apps", {}, () => import_effect9.Effect.void);
+var appsCommand = appsBase.pipe(import_cli2.Command.withSubcommands([appsListCommand]));
+
+// src/commands/build/index.ts
+var import_cli3 = require("@effect/cli");
+var import_platform5 = require("@effect/platform");
+var import_build_utils2 = require("@gigadrive/build-utils");
+var import_effect11 = require("effect");
+
+// src/services/package-manager.ts
+var import_platform4 = require("@effect/platform");
+var import_build_utils = require("@gigadrive/build-utils");
+var import_effect10 = require("effect");
+var PackageManagerService = class extends import_effect10.Effect.Service()("PackageManagerService", {
+  accessors: true,
+  effect: import_effect10.Effect.gen(function* () {
+    const fs = yield* import_platform4.FileSystem.FileSystem;
+    const pathService = yield* import_platform4.Path.Path;
+    const detect = import_effect10.Effect.fn("PackageManagerService.detect")(function* (cwd) {
+      yield* import_effect10.Effect.annotateCurrentSpan("cwd", cwd);
+      const packageJsonPath = pathService.join(cwd, "package.json");
+      const exists = yield* fs.exists(packageJsonPath).pipe(
+        import_effect10.Effect.mapError(
+          () => new PackageManagerNotFoundError({ message: "Failed to check for package.json", directory: cwd })
+        )
+      );
+      if (!exists) {
+        return yield* import_effect10.Effect.fail(
+          new PackageManagerNotFoundError({
+            message: "No package.json found",
+            directory: cwd
+          })
+        );
+      }
+      const lockChecks = [
+        { file: "yarn.lock", pm: "yarn" },
+        { file: "pnpm-lock.yaml", pm: "pnpm" },
+        { file: "bun.lockb", pm: "bun" },
+        { file: "package-lock.json", pm: "npm" }
+      ];
+      for (const { file, pm: pm2 } of lockChecks) {
+        const lockExists = yield* fs.exists(pathService.join(cwd, file)).pipe(import_effect10.Effect.catchAll(() => import_effect10.Effect.succeed(false)));
+        if (lockExists) {
+          yield* import_effect10.Effect.log("Package manager detected from lock file", { packageManager: pm2, lockFile: file });
+          return pm2;
+        }
+      }
+      const bunAvailable = yield* import_effect10.Effect.tryPromise({
+        try: () => (0, import_build_utils.exec)({ command: "bun --version", cwd }),
+        catch: () => new ExecError({ message: "bun not found", command: "bun --version" })
+      }).pipe(
+        import_effect10.Effect.as(true),
+        import_effect10.Effect.catchTag("ExecError", () => import_effect10.Effect.succeed(false))
+      );
+      const pm = bunAvailable ? "bun" : "npm";
+      yield* import_effect10.Effect.log("Package manager detected via fallback", { packageManager: pm });
+      return pm;
+    });
+    const installCommand = (pm) => ({
+      bun: "bun install",
+      npm: "npm install",
+      pnpm: "pnpm install",
+      yarn: "yarn install"
+    })[pm];
+    const buildCommand2 = (pm) => ({
+      bun: "bun run build",
+      npm: "npm run build",
+      pnpm: "pnpm build",
+      yarn: "yarn build"
+    })[pm];
+    return { detect, installCommand, buildCommand: buildCommand2 };
+  })
+}) {
+};
+
+// src/commands/build/index.ts
+var buildCommand = import_cli3.Command.make(
+  "build",
+  {},
+  () => import_effect11.Effect.gen(function* () {
+    const pmService = yield* PackageManagerService;
+    const fs = yield* import_platform5.FileSystem.FileSystem;
+    const pathService = yield* import_platform5.Path.Path;
+    const cwd = process.cwd();
+    yield* import_effect11.Effect.log("Starting build", { cwd });
+    const packageJsonPath = pathService.join(cwd, "package.json");
+    const packageJsonExists = yield* fs.exists(packageJsonPath).pipe(
+      import_effect11.Effect.mapError(
+        () => new PackageJsonNotFoundError({ message: "Failed to check for package.json", directory: cwd })
+      )
+    );
+    if (!packageJsonExists) {
+      return yield* import_effect11.Effect.fail(new PackageJsonNotFoundError({ message: "No package.json found", directory: cwd }));
+    }
+    const packageJsonContent = yield* fs.readFileString(packageJsonPath, "utf-8").pipe(
+      import_effect11.Effect.mapError(() => new PackageJsonNotFoundError({ message: "Failed to read package.json", directory: cwd }))
+    );
+    const packageJson = yield* import_effect11.Effect.try({
+      try: () => JSON.parse(packageJsonContent),
+      catch: (error) => new PackageJsonParseError({
+        message: "Failed to parse package.json",
+        directory: cwd,
+        cause: error instanceof Error ? error.message : String(error)
+      })
+    });
+    if (!packageJson.scripts?.build) {
+      return yield* import_effect11.Effect.fail(new BuildScriptNotFoundError({ message: "No build script found in package.json" }));
+    }
+    const pm = yield* pmService.detect(cwd);
+    const buildEnv = {
+      ...process.env,
+      NODE_ENV: "production",
+      NEBULA: "1",
+      VERCEL: "1",
+      NOW_BUILDER: "1"
+    };
+    const installCmd = pmService.installCommand(pm);
+    yield* import_effect11.Console.log(`Running: ${installCmd}`);
+    yield* import_effect11.Effect.tryPromise({
+      try: () => (0, import_build_utils2.exec)({
+        command: installCmd,
+        cwd,
+        env: buildEnv,
+        onOutput: (chunk) => {
+          import_effect11.Console.log(chunk).pipe(import_effect11.Effect.runSync);
+        }
+      }),
+      catch: (error) => new ExecError({
+        message: "Install failed",
+        command: installCmd,
+        cause: error instanceof Error ? error.message : String(error)
+      })
+    });
+    const buildCmd = pmService.buildCommand(pm);
+    yield* import_effect11.Console.log(`Running: ${buildCmd}`);
+    yield* import_effect11.Effect.tryPromise({
+      try: () => (0, import_build_utils2.exec)({
+        command: buildCmd,
+        cwd,
+        env: buildEnv,
+        onOutput: (chunk) => {
+          import_effect11.Console.log(chunk).pipe(import_effect11.Effect.runSync);
+        }
+      }),
+      catch: (error) => new ExecError({
+        message: "Build failed",
+        command: buildCmd,
+        cause: error instanceof Error ? error.message : String(error)
+      })
+    });
+    yield* import_effect11.Console.log("Build completed successfully.");
+  }).pipe(
+    import_effect11.Effect.catchTags({
+      PackageJsonNotFoundError: (err) => import_effect11.Console.error(err.message).pipe(import_effect11.Effect.andThen(import_effect11.Effect.fail(err))),
+      PackageJsonParseError: (err) => import_effect11.Console.error(err.message).pipe(import_effect11.Effect.andThen(import_effect11.Effect.fail(err))),
+      BuildScriptNotFoundError: (err) => import_effect11.Console.error(err.message).pipe(import_effect11.Effect.andThen(import_effect11.Effect.fail(err))),
+      PackageManagerNotFoundError: (err) => import_effect11.Console.error(err.message).pipe(import_effect11.Effect.andThen(import_effect11.Effect.fail(err))),
+      ExecError: (err) => import_effect11.Console.error(`${err.message}: ${err.cause ?? err.command}`).pipe(import_effect11.Effect.andThen(import_effect11.Effect.fail(err)))
+    })
+  )
+);
+
+// src/commands/debug/index.ts
+var import_cli5 = require("@effect/cli");
+var import_effect14 = require("effect");
+
+// src/commands/debug/config/index.ts
+var import_cli4 = require("@effect/cli");
+var import_effect13 = require("effect");
+
+// src/services/project-config.ts
+var import_network_config = require("@gigadrive/network-config");
+var import_effect12 = require("effect");
+var wrapParseErrors = (effect) => effect.pipe(
+  import_effect12.Effect.catchTags({
+    ConfigFileNotFoundError: (e) => import_effect12.Effect.fail(new ConfigParseError({ message: e.message, cause: e.filePath })),
+    ConfigFileEmptyError: (e) => import_effect12.Effect.fail(new ConfigParseError({ message: e.message, cause: e.filePath })),
+    ConfigFileParseError: (e) => import_effect12.Effect.fail(new ConfigParseError({ message: e.message, cause: e.cause })),
+    ConfigVersionError: (e) => import_effect12.Effect.fail(new ConfigParseError({ message: e.message, cause: e.filePath })),
+    ConfigSchemaValidationError: (e) => import_effect12.Effect.fail(new ConfigParseError({ message: e.message, cause: e.validationErrors.join(", ") })),
+    FunctionConfigError: (e) => import_effect12.Effect.fail(new ConfigParseError({ message: e.message, cause: e.functionPath }))
+  })
+);
+var ProjectConfigService = class extends import_effect12.Effect.Service()("ProjectConfigService", {
+  accessors: true,
+  dependencies: [import_network_config.NetworkConfigLive],
+  effect: import_effect12.Effect.gen(function* () {
+    const rawReader = yield* import_network_config.RawConfigReader;
+    const resolve = import_effect12.Effect.fn("ProjectConfigService.resolve")(function* (cwd) {
+      yield* import_effect12.Effect.annotateCurrentSpan("cwd", cwd);
+      yield* import_effect12.Effect.log("Resolving project config", { cwd });
+      const configPath = yield* rawReader.findConfig(cwd);
+      const detection = yield* (0, import_network_config.detectFramework)(cwd).pipe(
+        import_effect12.Effect.catchTag("FrameworkNotDetectedError", () => import_effect12.Effect.succeed(null)),
+        import_effect12.Effect.catchTag(
+          "ManifestReadError",
+          (e) => import_effect12.Effect.fail(new ConfigParseError({ message: `Framework detection failed: ${e.message}`, cause: e.filePath }))
+        ),
+        import_effect12.Effect.catchTag(
+          "ManifestParseError",
+          (e) => import_effect12.Effect.fail(new ConfigParseError({ message: `Framework detection failed: ${e.message}`, cause: e.filePath }))
+        )
+      );
+      if (detection) {
+        yield* import_effect12.Effect.log("Framework auto-detected", {
+          framework: detection.framework.name,
+          slug: detection.framework.slug
+        });
+      }
+      let config;
+      let resolvedConfigPath = null;
+      let framework;
+      if (configPath && detection) {
+        yield* import_effect12.Effect.log("Config file found, merging with framework defaults", { configPath });
+        resolvedConfigPath = configPath;
+        const userConfig = yield* wrapParseErrors((0, import_network_config.parseConfigRaw)(configPath, cwd));
+        const merged = yield* (0, import_network_config.mergeWithFrameworkDefaults)(userConfig, detection.config);
+        config = yield* wrapParseErrors((0, import_network_config.postProcessConfig)(merged, cwd));
+        framework = { name: detection.framework.name, slug: detection.framework.slug };
+      } else if (configPath) {
+        yield* import_effect12.Effect.log("Config file found", { configPath });
+        resolvedConfigPath = configPath;
+        config = yield* wrapParseErrors((0, import_network_config.parseConfig)(configPath, cwd));
+      } else if (detection) {
+        config = yield* wrapParseErrors((0, import_network_config.postProcessConfig)(detection.config, cwd));
+        framework = { name: detection.framework.name, slug: detection.framework.slug };
+      } else {
+        return yield* import_effect12.Effect.fail(
+          new ConfigNotFoundError({
+            message: "No config file found and no framework detected.",
+            directory: cwd
+          })
+        );
+      }
+      for (const warning of config.warnings) {
+        yield* import_effect12.Effect.logWarning(warning);
+      }
+      if (config.errors.length > 0) {
+        return yield* import_effect12.Effect.fail(
+          new ConfigValidationError({
+            message: "Config file has validation errors",
+            errors: config.errors
+          })
+        );
+      }
+      return { config, configPath: resolvedConfigPath, framework };
+    });
+    return { resolve };
+  })
+}) {
+};
+
+// src/commands/debug/config/index.ts
+var debugConfigCommand = import_cli4.Command.make(
+  "config",
+  {},
+  () => import_effect13.Effect.gen(function* () {
+    const projectConfig = yield* ProjectConfigService;
+    const cwd = process.cwd();
+    const { config, configPath } = yield* projectConfig.resolve(cwd);
+    yield* import_effect13.Console.log(`Config file found at: ${configPath}`);
+    yield* import_effect13.Console.log(JSON.stringify(config, null, 2));
+  }).pipe(
+    import_effect13.Effect.catchTags({
+      ConfigNotFoundError: (err) => import_effect13.Console.error(err.message),
+      ConfigParseError: (err) => import_effect13.Console.error(`Config parse error: ${err.message}`),
+      ConfigValidationError: (err) => import_effect13.Effect.gen(function* () {
+        for (const e of err.errors) {
+          yield* import_effect13.Console.error(e);
+        }
+        yield* import_effect13.Console.error(err.message);
+      })
+    })
+  )
+);
+
+// src/commands/debug/index.ts
+var debugBase = import_cli5.Command.make("debug", {}, () => import_effect14.Effect.void);
+var debugCommand = debugBase.pipe(import_cli5.Command.withSubcommands([debugConfigCommand]));
+
+// src/commands/deployments/index.ts
+var import_cli6 = require("@effect/cli");
+var import_effect15 = require("effect");
+var DEPLOYMENT_STATUSES = ["PENDING", "QUEUED", "STARTING", "BUILDING", "PROVISIONING", "ACTIVE", "FAILED"];
+var appOption2 = import_cli6.Options.text("app").pipe(
+  import_cli6.Options.withAlias("a"),
+  import_cli6.Options.withDescription("Filter by application ID (defaults to the linked application)"),
+  import_cli6.Options.optional
+);
+var orgOption3 = import_cli6.Options.text("org").pipe(
+  import_cli6.Options.withAlias("o"),
+  import_cli6.Options.withDescription("Filter by organization ID"),
+  import_cli6.Options.optional
+);
+var statusOption = import_cli6.Options.choice("status", DEPLOYMENT_STATUSES).pipe(
+  import_cli6.Options.withAlias("s"),
+  import_cli6.Options.withDescription("Filter by deployment status"),
+  import_cli6.Options.optional
+);
+var resolveApplicationFilter = (app) => import_effect15.Option.match(app, {
+  onSome: (id) => import_effect15.Effect.succeed(id),
+  onNone: () => import_effect15.Effect.gen(function* () {
+    const projectLink = yield* ProjectLinkService;
+    const link = yield* projectLink.load(process.cwd());
+    return import_effect15.Option.match(link, { onNone: () => void 0, onSome: (l) => l.applicationId });
+  })
+});
+var deploymentsListCommand = import_cli6.Command.make(
+  "list",
+  { app: appOption2, org: orgOption3, status: statusOption },
+  ({ app, org, status }) => import_effect15.Effect.gen(function* () {
+    const apiClient = yield* ApiClientService;
+    const applicationId = yield* resolveApplicationFilter(app);
+    const { items, total } = yield* apiClient.request(
+      (client) => client.deployments.list({
+        applicationId,
+        organizationId: import_effect15.Option.getOrUndefined(org),
+        status: import_effect15.Option.getOrUndefined(status)
+      })
+    );
+    if (items.length === 0) {
+      yield* import_effect15.Console.log("No deployments found.");
+      return;
+    }
+    for (const d of items) {
+      yield* import_effect15.Console.log(`${d.id}  ${d.status.padEnd(12)}  ${d.createdAt}`);
+    }
+    yield* import_effect15.Console.log(`
+${total} deployment(s).`);
+  }).pipe(
+    import_effect15.Effect.catchTags({
+      NotAuthenticatedError: (err) => import_effect15.Console.error('You are not logged in. Run "gigadrive login" to authenticate.').pipe(
+        import_effect15.Effect.andThen(import_effect15.Effect.fail(err))
+      ),
+      ApiRequestError: (err) => import_effect15.Console.error(`Failed to list deployments: ${err.message}`).pipe(import_effect15.Effect.andThen(import_effect15.Effect.fail(err))),
+      ProjectLinkReadError: (err) => import_effect15.Console.error(err.message).pipe(import_effect15.Effect.andThen(import_effect15.Effect.fail(err)))
+    })
+  )
+);
+var deploymentIdArg = import_cli6.Args.text({ name: "deployment-id" }).pipe(import_cli6.Args.withDescription("The deployment ID to inspect"));
+var deploymentsInspectCommand = import_cli6.Command.make(
+  "inspect",
+  { deploymentId: deploymentIdArg },
+  ({ deploymentId }) => import_effect15.Effect.gen(function* () {
+    const apiClient = yield* ApiClientService;
+    const deployment = yield* apiClient.request((client) => client.deployments.get(deploymentId));
+    yield* import_effect15.Console.log(`ID:          ${deployment.id}`);
+    yield* import_effect15.Console.log(`Application:  ${deployment.applicationId}`);
+    yield* import_effect15.Console.log(`Status:      ${deployment.status}`);
+    yield* import_effect15.Console.log(`Created:     ${deployment.createdAt}`);
+    yield* import_effect15.Console.log(`Updated:     ${deployment.updatedAt}`);
+    const hostnames = yield* apiClient.request((client) => client.deployments.getHostnames(deploymentId)).pipe(import_effect15.Effect.catchAll(() => import_effect15.Effect.succeed({ items: [], total: 0 })));
+    if (hostnames.items.length > 0) {
+      yield* import_effect15.Console.log("Hostnames:");
+      for (const h of hostnames.items) {
+        yield* import_effect15.Console.log(`  https://${h.hostname}${h.active ? "" : " (inactive)"}`);
+      }
+    }
+  }).pipe(
+    import_effect15.Effect.catchTags({
+      NotAuthenticatedError: (err) => import_effect15.Console.error('You are not logged in. Run "gigadrive login" to authenticate.').pipe(
+        import_effect15.Effect.andThen(import_effect15.Effect.fail(err))
+      ),
+      ApiRequestError: (err) => import_effect15.Console.error(`Failed to inspect deployment: ${err.message}`).pipe(import_effect15.Effect.andThen(import_effect15.Effect.fail(err)))
+    })
+  )
+);
+var deploymentsBase = import_cli6.Command.make("deployments", {}, () => import_effect15.Effect.void);
+var deploymentsCommand = deploymentsBase.pipe(
+  import_cli6.Command.withSubcommands([deploymentsListCommand, deploymentsInspectCommand])
+);
+
+// src/commands/env/index.ts
+var import_cli7 = require("@effect/cli");
+var import_effect19 = require("effect");
+
+// src/services/env-file.ts
+var import_platform6 = require("@effect/platform");
+var import_effect16 = require("effect");
+
+// src/lib/dotenv.ts
+var DEFAULT_ENV_HEADER = "# Generated by `gigadrive env pull` \u2014 do not edit by hand.";
+var UNQUOTED_SAFE = /^[A-Za-z0-9_.\-/@:+]*$/;
+var formatEnvValue = (value) => {
+  if (UNQUOTED_SAFE.test(value)) {
+    return value;
+  }
+  const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+  return `"${escaped}"`;
+};
+var serializeEnv = (entries, opts) => {
+  const header = opts?.header ?? DEFAULT_ENV_HEADER;
+  if (entries.length === 0) {
+    return `${header}
+`;
+  }
+  const body = entries.map((e) => `${e.key}=${formatEnvValue(e.value)}`).join("\n");
+  return `${header}
+${body}
+`;
+};
+var parseEnv = (content) => {
+  const result = {};
+  for (const rawLine of content.split("\n")) {
+    const line = rawLine.trim();
+    if (line.length === 0 || line.startsWith("#")) {
+      continue;
+    }
+    const eq = line.indexOf("=");
+    if (eq <= 0) {
+      continue;
+    }
+    const key = line.slice(0, eq).trim();
+    let value = line.slice(eq + 1).trim();
+    if (value.length >= 2 && value.startsWith('"') && value.endsWith('"')) {
+      value = value.slice(1, -1).replace(/\\(\\|"|n|r|t)/g, (_, ch) => {
+        switch (ch) {
+          case "n":
+            return "\n";
+          case "r":
+            return "\r";
+          case "t":
+            return "	";
+          case '"':
+            return '"';
+          default:
+            return "\\";
+        }
+      });
+    }
+    result[key] = value;
+  }
+  return result;
+};
+
+// src/services/env-file.ts
+var EnvFileService = class extends import_effect16.Effect.Service()("EnvFileService", {
+  accessors: true,
+  effect: import_effect16.Effect.gen(function* () {
+    const fs = yield* import_platform6.FileSystem.FileSystem;
+    const pathService = yield* import_platform6.Path.Path;
+    const exists = import_effect16.Effect.fn("EnvFileService.exists")(function* (filePath) {
+      return yield* fs.exists(filePath).pipe(import_effect16.Effect.mapError(() => new EnvFileReadError({ message: `Failed to check whether ${filePath} exists` })));
+    });
+    const read = import_effect16.Effect.fn("EnvFileService.read")(function* (filePath) {
+      const present = yield* exists(filePath);
+      if (!present) return import_effect16.Option.none();
+      const contents = yield* fs.readFileString(filePath, "utf8").pipe(import_effect16.Effect.mapError(() => new EnvFileReadError({ message: `Failed to read ${filePath}` })));
+      return import_effect16.Option.some(contents);
+    });
+    const write = import_effect16.Effect.fn("EnvFileService.write")(function* (filePath, entries, opts) {
+      const dir = pathService.dirname(filePath);
+      yield* fs.makeDirectory(dir, { recursive: true }).pipe(
+        import_effect16.Effect.mapError(
+          (error) => new EnvFileWriteError({ message: `Failed to create directory for ${filePath}`, cause: String(error) })
+        )
+      );
+      yield* fs.writeFileString(filePath, serializeEnv(entries, opts), { mode: 384 }).pipe(
+        import_effect16.Effect.mapError(
+          (error) => new EnvFileWriteError({ message: `Failed to write ${filePath}`, cause: String(error) })
+        )
+      );
+      yield* fs.chmod(filePath, 384).pipe(
+        import_effect16.Effect.mapError(
+          (error) => new EnvFileWriteError({ message: `Failed to secure ${filePath}`, cause: String(error) })
+        )
+      );
+    });
+    const ensureGitignored = import_effect16.Effect.fn("EnvFileService.ensureGitignored")(function* (dir, entry) {
+      const gitignorePath = pathService.join(dir, ".gitignore");
+      const existing = yield* read(gitignorePath);
+      const current = import_effect16.Option.getOrElse(existing, () => "");
+      const alreadyIgnored = current.split("\n").some((line) => line.trim() === entry);
+      if (alreadyIgnored) {
+        return false;
+      }
+      const separator = current.length > 0 && !current.endsWith("\n") ? "\n" : "";
+      yield* fs.writeFileString(gitignorePath, `${current}${separator}${entry}
+`).pipe(
+        import_effect16.Effect.mapError(
+          (error) => new EnvFileWriteError({ message: "Failed to update .gitignore", cause: String(error) })
+        )
+      );
+      return true;
+    });
+    return { exists, read, write, ensureGitignored };
+  })
+}) {
+};
+
+// src/services/local-credentials.ts
+var import_effect18 = require("effect");
+var os3 = __toESM(require("os"), 1);
+
+// src/services/dev-credentials-store.ts
+var import_platform7 = require("@effect/platform");
+var import_effect17 = require("effect");
+var os2 = __toESM(require("os"), 1);
+var DevCredentialsStore = class extends import_effect17.Effect.Service()("DevCredentialsStore", {
+  accessors: true,
+  effect: import_effect17.Effect.gen(function* () {
+    const fs = yield* import_platform7.FileSystem.FileSystem;
+    const pathService = yield* import_platform7.Path.Path;
+    const homeDir = os2.homedir();
+    const storeDir = pathService.join(homeDir, ".gigadrive");
+    const storeFile = pathService.join(storeDir, "dev-keys.json");
+    const ensureDirectory = import_effect17.Effect.gen(function* () {
+      yield* fs.makeDirectory(storeDir, { recursive: true }).pipe(
+        import_effect17.Effect.mapError(
+          (error) => new DevCredentialsStoreWriteError({ message: "Failed to create ~/.gigadrive", cause: String(error) })
+        )
+      );
+      yield* fs.chmod(storeDir, 448).pipe(
+        import_effect17.Effect.mapError(
+          (error) => new DevCredentialsStoreWriteError({
+            message: "Failed to set ~/.gigadrive permissions",
+            cause: String(error)
+          })
+        )
+      );
+    });
+    const load = import_effect17.Effect.gen(function* () {
+      const present = yield* fs.exists(storeFile).pipe(import_effect17.Effect.mapError(() => new DevCredentialsStoreReadError({ message: "Failed to check dev-keys.json" })));
+      if (!present) return {};
+      const data = yield* fs.readFileString(storeFile, "utf8").pipe(import_effect17.Effect.mapError(() => new DevCredentialsStoreReadError({ message: "Failed to read dev-keys.json" })));
+      const json = yield* import_effect17.Effect.try({
+        try: () => JSON.parse(data),
+        catch: () => new DevCredentialsStoreReadError({ message: "dev-keys.json contains invalid JSON" })
+      });
+      return yield* import_effect17.Schema.decodeUnknown(DevKeyStore)(json).pipe(
+        import_effect17.Effect.mapError(() => new DevCredentialsStoreReadError({ message: "dev-keys.json has an invalid schema" }))
+      );
+    });
+    const get = import_effect17.Effect.fn("DevCredentialsStore.get")(function* (applicationId) {
+      const store = yield* load;
+      const entry = store[applicationId];
+      return entry ? import_effect17.Option.some(entry) : import_effect17.Option.none();
+    });
+    const set = import_effect17.Effect.fn("DevCredentialsStore.set")(function* (applicationId, entry) {
+      const store = yield* load;
+      const next = { ...store, [applicationId]: entry };
+      yield* ensureDirectory;
+      yield* fs.writeFileString(storeFile, `${JSON.stringify(next, null, 2)}
+`, { mode: 384 }).pipe(
+        import_effect17.Effect.mapError(
+          (error) => new DevCredentialsStoreWriteError({ message: "Failed to write dev-keys.json", cause: String(error) })
+        )
+      );
+    });
+    return { get, set };
+  })
+}) {
+};
+
+// src/services/local-credentials.ts
+var DEV_KEY_SCOPES = ["network:env_vars:read"];
+var ApiBaseUrl2 = import_effect18.Config.string("GIGADRIVE_API_BASE_URL").pipe(import_effect18.Config.withDefault("https://api.gigadrive.network"));
+var credentialEntries = (clientId, clientSecret, baseUrl) => [
+  { key: "GIGADRIVE_CLIENT_ID", value: clientId },
+  { key: "GIGADRIVE_CLIENT_SECRET", value: clientSecret },
+  { key: "GIGADRIVE_API_BASE_URL", value: baseUrl }
+];
+var LocalCredentialsService = class extends import_effect18.Effect.Service()("LocalCredentialsService", {
+  accessors: true,
+  dependencies: [ApiClientService.Default, DevCredentialsStore.Default],
+  effect: import_effect18.Effect.gen(function* () {
+    const apiClient = yield* ApiClientService;
+    const store = yield* DevCredentialsStore;
+    const baseUrl = yield* ApiBaseUrl2;
+    const keyName = (applicationId) => `cli-dev:${os3.hostname()}:${applicationId}`;
+    const provision = import_effect18.Effect.fn("LocalCredentialsService.provision")(function* (input) {
+      const stored = yield* store.get(input.applicationId);
+      const existing = input.existingContent ? parseEnv(input.existingContent) : {};
+      const existingClientId = existing["GIGADRIVE_CLIENT_ID"];
+      const existingClientSecret = existing["GIGADRIVE_CLIENT_SECRET"];
+      const canReuse = !input.rotate && existingClientId !== void 0 && existingClientSecret !== void 0 && import_effect18.Option.isSome(stored) && stored.value.apiKeyId === existingClientId;
+      if (canReuse) {
+        return credentialEntries(existingClientId, existingClientSecret, baseUrl);
+      }
+      if (import_effect18.Option.isSome(stored)) {
+        yield* apiClient.request((client) => client.apiKeys.delete(stored.value.apiKeyId)).pipe(import_effect18.Effect.catchTag("ApiRequestError", () => import_effect18.Effect.void));
+      }
+      const created = yield* apiClient.request(
+        (client) => client.apiKeys.create({
+          name: keyName(input.applicationId),
+          applicationId: input.applicationId,
+          scopes: DEV_KEY_SCOPES
+        })
+      );
+      yield* store.set(input.applicationId, { apiKeyId: created.id });
+      return credentialEntries(created.id, created.secret, baseUrl);
+    });
+    return { provision };
+  })
+}) {
+};
+
+// src/commands/env/index.ts
+var appOption3 = import_cli7.Options.text("app").pipe(
+  import_cli7.Options.withAlias("a"),
+  import_cli7.Options.withDescription("Operate on this application (overrides the linked application)"),
+  import_cli7.Options.optional
+);
+var orgOption4 = import_cli7.Options.text("org").pipe(
+  import_cli7.Options.withAlias("o"),
+  import_cli7.Options.withDescription("Operate on this organization instead of an application"),
+  import_cli7.Options.optional
+);
+var sensitiveOption = import_cli7.Options.boolean("sensitive").pipe(
+  import_cli7.Options.withDescription("Store the value as sensitive (hidden in API responses)")
+);
+var envIdOption = import_cli7.Options.text("env").pipe(
+  import_cli7.Options.withAlias("e"),
+  import_cli7.Options.withDescription("Environment ID for an environment-scoped variable (application scope only)"),
+  import_cli7.Options.optional
+);
+var keyValueArg = import_cli7.Args.text({ name: "key=value" }).pipe(
+  import_cli7.Args.withDescription("Variable assignment, e.g. DATABASE_URL=postgres://user:pass@host/db")
+);
+var keyOrIdArg = import_cli7.Args.text({ name: "key-or-id" }).pipe(import_cli7.Args.withDescription("Variable key or ID to remove"));
+var fileArg = import_cli7.Args.text({ name: "file" }).pipe(
+  import_cli7.Args.withDescription("Output file to write (default: .env.local)"),
+  import_cli7.Args.optional
+);
+var environmentOption = import_cli7.Options.text("environment").pipe(
+  import_cli7.Options.withAlias("e"),
+  import_cli7.Options.withDescription("Environment slug to resolve overrides for (e.g. preview). Omit for the local baseline"),
+  import_cli7.Options.optional
+);
+var yesOption = import_cli7.Options.boolean("yes").pipe(
+  import_cli7.Options.withAlias("y"),
+  import_cli7.Options.withDescription("Overwrite an existing file without confirmation")
+);
+var withCredentialsOption = import_cli7.Options.boolean("with-credentials").pipe(
+  import_cli7.Options.withDescription("Also provision API-key credentials so the local app can call the API as this application")
+);
+var rotateOption = import_cli7.Options.boolean("rotate").pipe(
+  import_cli7.Options.withDescription("Force a fresh API key when provisioning credentials, revoking the previous one")
+);
+var resolveScope = (app, org) => import_effect19.Effect.gen(function* () {
+  if (import_effect19.Option.isSome(org)) {
+    return { kind: "organization", id: org.value };
+  }
+  const projectLink = yield* ProjectLinkService;
+  const id = yield* import_effect19.Option.match(app, {
+    onSome: (value) => import_effect19.Effect.succeed(value),
+    onNone: () => projectLink.resolve(process.cwd()).pipe(import_effect19.Effect.map((link) => link.applicationId))
+  });
+  return { kind: "application", id };
+});
+var envListCommand = import_cli7.Command.make(
+  "list",
+  { app: appOption3, org: orgOption4 },
+  ({ app, org }) => import_effect19.Effect.gen(function* () {
+    const apiClient = yield* ApiClientService;
+    const scope = yield* resolveScope(app, org);
+    const { items } = yield* apiClient.request(
+      (client) => scope.kind === "organization" ? client.organizations.envVars.list(scope.id) : client.applications.envVars.list(scope.id)
+    );
+    if (items.length === 0) {
+      yield* import_effect19.Console.log("No environment variables set.");
+      return;
+    }
+    for (const v of items) {
+      yield* import_effect19.Console.log(`${v.key}=${v.sensitive ? "***" : v.value ?? ""}`);
+    }
+  }).pipe(
+    import_effect19.Effect.catchTags({
+      NotAuthenticatedError: (err) => import_effect19.Console.error('You are not logged in. Run "gigadrive login" to authenticate.').pipe(
+        import_effect19.Effect.andThen(import_effect19.Effect.fail(err))
+      ),
+      ApiRequestError: (err) => import_effect19.Console.error(`Failed to list environment variables: ${err.message}`).pipe(import_effect19.Effect.andThen(import_effect19.Effect.fail(err))),
+      ProjectNotLinkedError: (err) => import_effect19.Console.error(err.message).pipe(import_effect19.Effect.andThen(import_effect19.Effect.fail(err))),
+      ProjectLinkReadError: (err) => import_effect19.Console.error(err.message).pipe(import_effect19.Effect.andThen(import_effect19.Effect.fail(err)))
+    })
+  )
+);
+var envSetCommand = import_cli7.Command.make(
+  "set",
+  { keyValue: keyValueArg, app: appOption3, org: orgOption4, sensitive: sensitiveOption, env: envIdOption },
+  ({ keyValue, app, org, sensitive, env }) => import_effect19.Effect.gen(function* () {
+    const separator = keyValue.indexOf("=");
+    if (separator <= 0) {
+      return yield* import_effect19.Effect.fail(
+        new InvalidEnvVarFormatError({
+          message: 'Invalid format. Use KEY=VALUE, e.g. "gigadrive env set DATABASE_URL=postgres://...".'
+        })
+      );
+    }
+    const key = keyValue.slice(0, separator);
+    const value = keyValue.slice(separator + 1);
+    const apiClient = yield* ApiClientService;
+    const scope = yield* resolveScope(app, org);
+    const environmentId = import_effect19.Option.getOrUndefined(env);
+    const created = yield* apiClient.request(
+      (client) => scope.kind === "organization" ? client.organizations.envVars.create(scope.id, { key, value, sensitive }) : client.applications.envVars.create(scope.id, { key, value, sensitive, environmentId })
+    );
+    yield* import_effect19.Console.log(`Set ${created.key}.`);
+  }).pipe(
+    import_effect19.Effect.catchTags({
+      InvalidEnvVarFormatError: (err) => import_effect19.Console.error(err.message).pipe(import_effect19.Effect.andThen(import_effect19.Effect.fail(err))),
+      NotAuthenticatedError: (err) => import_effect19.Console.error('You are not logged in. Run "gigadrive login" to authenticate.').pipe(
+        import_effect19.Effect.andThen(import_effect19.Effect.fail(err))
+      ),
+      ApiRequestError: (err) => import_effect19.Console.error(`Failed to set environment variable: ${err.message}`).pipe(import_effect19.Effect.andThen(import_effect19.Effect.fail(err))),
+      ProjectNotLinkedError: (err) => import_effect19.Console.error(err.message).pipe(import_effect19.Effect.andThen(import_effect19.Effect.fail(err))),
+      ProjectLinkReadError: (err) => import_effect19.Console.error(err.message).pipe(import_effect19.Effect.andThen(import_effect19.Effect.fail(err)))
+    })
+  )
+);
+var envRmCommand = import_cli7.Command.make(
+  "rm",
+  { keyOrId: keyOrIdArg, app: appOption3, org: orgOption4 },
+  ({ keyOrId, app, org }) => import_effect19.Effect.gen(function* () {
+    const apiClient = yield* ApiClientService;
+    const scope = yield* resolveScope(app, org);
+    const { items } = yield* apiClient.request(
+      (client) => scope.kind === "organization" ? client.organizations.envVars.list(scope.id) : client.applications.envVars.list(scope.id)
+    );
+    const target = items.find((v) => v.id === keyOrId || v.key === keyOrId);
+    if (target === void 0) {
+      return yield* import_effect19.Effect.fail(
+        new EnvVarNotFoundError({ message: `No environment variable matching "${keyOrId}".` })
+      );
+    }
+    yield* apiClient.request(
+      (client) => scope.kind === "organization" ? client.organizations.envVars.delete(scope.id, target.id) : client.applications.envVars.delete(scope.id, target.id)
+    );
+    yield* import_effect19.Console.log(`Removed ${target.key}.`);
+  }).pipe(
+    import_effect19.Effect.catchTags({
+      EnvVarNotFoundError: (err) => import_effect19.Console.error(err.message).pipe(import_effect19.Effect.andThen(import_effect19.Effect.fail(err))),
+      NotAuthenticatedError: (err) => import_effect19.Console.error('You are not logged in. Run "gigadrive login" to authenticate.').pipe(
+        import_effect19.Effect.andThen(import_effect19.Effect.fail(err))
+      ),
+      ApiRequestError: (err) => import_effect19.Console.error(`Failed to remove environment variable: ${err.message}`).pipe(import_effect19.Effect.andThen(import_effect19.Effect.fail(err))),
+      ProjectNotLinkedError: (err) => import_effect19.Console.error(err.message).pipe(import_effect19.Effect.andThen(import_effect19.Effect.fail(err))),
+      ProjectLinkReadError: (err) => import_effect19.Console.error(err.message).pipe(import_effect19.Effect.andThen(import_effect19.Effect.fail(err)))
+    })
+  )
+);
+var envPullCommand = import_cli7.Command.make(
+  "pull",
+  {
+    file: fileArg,
+    app: appOption3,
+    environment: environmentOption,
+    yes: yesOption,
+    withCredentials: withCredentialsOption,
+    rotate: rotateOption
+  },
+  ({ file, app, environment, yes, withCredentials, rotate }) => import_effect19.Effect.gen(function* () {
+    const apiClient = yield* ApiClientService;
+    const projectLink = yield* ProjectLinkService;
+    const envFile = yield* EnvFileService;
+    const applicationId = yield* import_effect19.Option.match(app, {
+      onSome: (value) => import_effect19.Effect.succeed(value),
+      onNone: () => projectLink.resolve(process.cwd()).pipe(import_effect19.Effect.map((link) => link.applicationId))
+    });
+    const target = import_effect19.Option.getOrElse(file, () => ".env.local");
+    const environmentSlug = import_effect19.Option.getOrUndefined(environment);
+    const { items, omittedSensitive } = yield* apiClient.request(
+      (client) => client.applications.envVars.pull(applicationId, environmentSlug ? { environment: environmentSlug } : void 0)
+    );
+    const existing = yield* envFile.read(target);
+    if (import_effect19.Option.isSome(existing) && !yes) {
+      const overwrite = yield* import_cli7.Prompt.run(
+        import_cli7.Prompt.confirm({ message: `${target} already exists. Overwrite?`, initial: false })
       );
-      import_effect10.Option.match(stored, {
-        onNone: () => {
-        },
-        onSome: (data) => {
-          if (data.accessToken && data.tokenExpirationTime && Date.now() < data.tokenExpirationTime) {
-            accessToken = data.accessToken;
-            tokenExpirationTime = data.tokenExpirationTime;
-          }
-        }
-      });
-      if (accessToken && Date.now() < tokenExpirationTime) {
-        return accessToken;
+      if (!overwrite) {
+        return yield* import_effect19.Console.log("Cancelled.");
       }
-      yield* import_effect10.Effect.log("Access token expired or not available. Attempting to refresh...");
-      yield* refreshAccessToken.pipe(
-        import_effect10.Effect.catchTag("TokenRefreshError", (err) => import_effect10.Effect.fail(new NotAuthenticatedError({ message: err.message })))
+    }
+    let credentialEntries2 = [];
+    if (withCredentials) {
+      const localCredentials = yield* LocalCredentialsService;
+      credentialEntries2 = yield* localCredentials.provision({
+        applicationId,
+        rotate,
+        existingContent: import_effect19.Option.getOrUndefined(existing)
+      });
+    }
+    const entries = [...items.map((v) => ({ key: v.key, value: v.value })), ...credentialEntries2];
+    yield* envFile.write(target, entries);
+    const gitignored = yield* envFile.ensureGitignored(process.cwd(), target);
+    yield* import_effect19.Console.log(
+      `Pulled ${items.length} environment variable(s)${withCredentials ? " and API credentials" : ""} to ${target}.`
+    );
+    if (omittedSensitive > 0) {
+      yield* import_effect19.Console.log(
+        `Skipped ${omittedSensitive} sensitive variable(s); secrets live only in production/preview environments.`
       );
-      if (!accessToken) {
-        return yield* import_effect10.Effect.fail(
-          new NotAuthenticatedError({ message: "No valid access token available. Please log in first." })
-        );
-      }
-      return accessToken;
-    });
-    const getUserInfo = import_effect10.Effect.gen(function* () {
-      const config = yield* oauthConfig.getConfig;
-      const token = yield* getAccessToken;
-      const fetchUserInfo = (t) => import_effect10.Effect.tryPromise({
-        try: () => fetch(config.userinfoUrl, {
-          headers: {
-            Authorization: `Bearer ${t}`,
-            Accept: "application/json"
-          }
-        }),
-        catch: (error) => new UserInfoFetchError({
-          message: `Failed to fetch user info: ${error instanceof Error ? error.message : String(error)}`
+    }
+    if (gitignored) {
+      yield* import_effect19.Console.log(`Added ${target} to .gitignore.`);
+    }
+  }).pipe(
+    import_effect19.Effect.catchTags({
+      // Ctrl+C during the overwrite prompt is a deliberate cancel — exit 0.
+      QuitException: () => import_effect19.Console.log("Cancelled."),
+      NotAuthenticatedError: (err) => import_effect19.Console.error('You are not logged in. Run "gigadrive login" to authenticate.').pipe(
+        import_effect19.Effect.andThen(import_effect19.Effect.fail(err))
+      ),
+      ApiRequestError: (err) => import_effect19.Console.error(`Failed to pull environment variables: ${err.message}`).pipe(import_effect19.Effect.andThen(import_effect19.Effect.fail(err))),
+      ProjectNotLinkedError: (err) => import_effect19.Console.error(err.message).pipe(import_effect19.Effect.andThen(import_effect19.Effect.fail(err))),
+      ProjectLinkReadError: (err) => import_effect19.Console.error(err.message).pipe(import_effect19.Effect.andThen(import_effect19.Effect.fail(err))),
+      EnvFileReadError: (err) => import_effect19.Console.error(err.message).pipe(import_effect19.Effect.andThen(import_effect19.Effect.fail(err))),
+      EnvFileWriteError: (err) => import_effect19.Console.error(err.message).pipe(import_effect19.Effect.andThen(import_effect19.Effect.fail(err))),
+      DevCredentialsStoreReadError: (err) => import_effect19.Console.error(err.message).pipe(import_effect19.Effect.andThen(import_effect19.Effect.fail(err))),
+      DevCredentialsStoreWriteError: (err) => import_effect19.Console.error(err.message).pipe(import_effect19.Effect.andThen(import_effect19.Effect.fail(err)))
+    })
+  )
+);
+var envBase = import_cli7.Command.make("env", {}, () => import_effect19.Effect.void);
+var envCommand = envBase.pipe(
+  import_cli7.Command.withSubcommands([envListCommand, envSetCommand, envRmCommand, envPullCommand])
+);
+
+// src/commands/link/index.ts
+var import_cli8 = require("@effect/cli");
+var import_effect20 = require("effect");
+var appOption4 = import_cli8.Options.text("app").pipe(
+  import_cli8.Options.withAlias("a"),
+  import_cli8.Options.withDescription("Application ID to link (skips the interactive picker)"),
+  import_cli8.Options.optional
+);
+var orgOption5 = import_cli8.Options.text("org").pipe(
+  import_cli8.Options.withAlias("o"),
+  import_cli8.Options.withDescription("Only list applications belonging to this organization ID"),
+  import_cli8.Options.optional
+);
+var linkCommand = import_cli8.Command.make(
+  "link",
+  { app: appOption4, org: orgOption5 },
+  ({ app, org }) => import_effect20.Effect.gen(function* () {
+    const apiClient = yield* ApiClientService;
+    const projectLink = yield* ProjectLinkService;
+    const cwd = process.cwd();
+    const organizationId = import_effect20.Option.getOrUndefined(org);
+    const { items: apps } = yield* apiClient.request((client) => client.applications.list({ organizationId }));
+    if (apps.length === 0) {
+      return yield* import_effect20.Effect.fail(
+        new NoApplicationsFoundError({
+          message: 'No applications found. Create one in the Gigadrive console, then run "gigadrive link" again.'
         })
-      });
-      let response = yield* fetchUserInfo(token);
-      if (response.status === 401 || response.status === 403) {
-        yield* refreshAccessToken.pipe(
-          import_effect10.Effect.catchTag("TokenRefreshError", (err) => import_effect10.Effect.fail(new UserInfoFetchError({ message: err.message })))
-        );
-        if (!accessToken) {
-          return yield* import_effect10.Effect.fail(new UserInfoFetchError({ message: "Token refresh failed" }));
-        }
-        response = yield* fetchUserInfo(accessToken);
-      }
-      if (!response.ok) {
-        const body = yield* import_effect10.Effect.tryPromise({
-          try: () => response.text(),
-          catch: () => new UserInfoFetchError({ message: "Failed to read user info error response" })
-        });
-        return yield* import_effect10.Effect.fail(
-          new UserInfoFetchError({
-            message: `Failed to fetch user info: ${response.status} ${response.statusText}${body ? ` - ${body}` : ""}`,
-            statusCode: response.status
+      );
+    }
+    const explicitAppId = import_effect20.Option.getOrUndefined(app);
+    let applicationId;
+    let linkedOrganizationId;
+    if (explicitAppId !== void 0) {
+      const match = apps.find((a) => a.id === explicitAppId);
+      if (match === void 0) {
+        return yield* import_effect20.Effect.fail(
+          new ApplicationNotFoundError({
+            message: `Application "${explicitAppId}" was not found among your applications.`
           })
         );
       }
-      const data = yield* import_effect10.Effect.tryPromise({
-        try: () => response.json(),
-        catch: () => new UserInfoFetchError({ message: "Failed to parse user info response" })
-      });
-      return data;
-    });
-    const inferUserName = (info) => {
-      const isNonEmptyString = (value) => typeof value === "string" && value.trim() !== "";
-      const name = info.name;
-      const givenName = info.given_name;
-      const familyName = info.family_name;
-      const preferredUsername = info.preferred_username;
-      const email = info.email;
-      return isNonEmptyString(name) && name || (isNonEmptyString(givenName) && isNonEmptyString(familyName) ? `${givenName} ${familyName}` : void 0) || isNonEmptyString(preferredUsername) && preferredUsername || isNonEmptyString(email) && email || "your account";
-    };
-    return { login, logout, getAccessToken, getUserInfo, refreshAccessToken, inferUserName };
-  })
-}) {
-};
+      applicationId = match.id;
+      linkedOrganizationId = match.organization.id;
+    } else if (apps.length === 1) {
+      applicationId = apps[0].id;
+      linkedOrganizationId = apps[0].organization.id;
+    } else {
+      const chosen = yield* import_cli8.Prompt.run(
+        import_cli8.Prompt.select({
+          message: "Select an application to link",
+          choices: apps.map((a) => ({ title: `${a.name} (${a.organization.name})`, value: a }))
+        })
+      );
+      applicationId = chosen.id;
+      linkedOrganizationId = chosen.organization.id;
+    }
+    yield* projectLink.save(cwd, { applicationId, organizationId: linkedOrganizationId });
+    yield* import_effect20.Console.log(`Linked this directory to application ${applicationId}.`);
+    yield* import_effect20.Console.log('Tip: add ".gigadrive/" to your .gitignore.');
+  }).pipe(
+    import_effect20.Effect.catchTags({
+      // Ctrl+C during the picker is a deliberate cancel — exit 0.
+      QuitException: () => import_effect20.Console.log("Cancelled."),
+      NotAuthenticatedError: (err) => import_effect20.Console.error('You are not logged in. Run "gigadrive login" to authenticate.').pipe(
+        import_effect20.Effect.andThen(import_effect20.Effect.fail(err))
+      ),
+      ApiRequestError: (err) => import_effect20.Console.error(`Failed to list applications: ${err.message}`).pipe(import_effect20.Effect.andThen(import_effect20.Effect.fail(err))),
+      NoApplicationsFoundError: (err) => import_effect20.Console.error(err.message).pipe(import_effect20.Effect.andThen(import_effect20.Effect.fail(err))),
+      ApplicationNotFoundError: (err) => import_effect20.Console.error(err.message).pipe(import_effect20.Effect.andThen(import_effect20.Effect.fail(err))),
+      ProjectLinkWriteError: (err) => import_effect20.Console.error(err.message).pipe(import_effect20.Effect.andThen(import_effect20.Effect.fail(err)))
+    })
+  )
+);
+var unlinkCommand = import_cli8.Command.make(
+  "unlink",
+  {},
+  () => import_effect20.Effect.gen(function* () {
+    const projectLink = yield* ProjectLinkService;
+    yield* projectLink.remove(process.cwd());
+    yield* import_effect20.Console.log("Unlinked this directory.");
+  }).pipe(
+    import_effect20.Effect.catchTags({
+      ProjectLinkWriteError: (err) => import_effect20.Console.error(err.message).pipe(import_effect20.Effect.andThen(import_effect20.Effect.fail(err)))
+    })
+  )
+);
 
 // src/commands/login/index.ts
-var loginCommand = import_cli4.Command.make(
+var import_cli9 = require("@effect/cli");
+var import_effect21 = require("effect");
+var loginCommand = import_cli9.Command.make(
   "login",
   {},
-  () => import_effect11.Effect.gen(function* () {
-    yield* import_effect11.Console.log("Initiating login...");
+  () => import_effect21.Effect.gen(function* () {
+    yield* import_effect21.Console.log("Initiating login...");
     const auth = yield* AuthService;
     yield* auth.login;
-    const info = yield* auth.getUserInfo.pipe(import_effect11.Effect.catchAll(() => import_effect11.Effect.succeed({})));
+    const info = yield* auth.getUserInfo.pipe(import_effect21.Effect.catchAll(() => import_effect21.Effect.succeed({})));
     const name = auth.inferUserName(info);
-    yield* import_effect11.Console.log(`You are now logged in as ${name}.`);
+    yield* import_effect21.Console.log(`You are now logged in as ${name}.`);
   }).pipe(
-    import_effect11.Effect.catchTags({
-      LoginFlowError: (err) => import_effect11.Console.error(`Login failed: ${err.message}`),
-      TokenExchangeError: (err) => import_effect11.Console.error(`Login failed: ${err.message}`),
-      OAuthDiscoveryError: (err) => import_effect11.Console.error(`Login failed: ${err.message}`),
-      AuthStorageWriteError: (err) => import_effect11.Console.error(`Failed to save credentials: ${err.message}`)
+    import_effect21.Effect.catchTags({
+      LoginFlowError: (err) => import_effect21.Console.error(`Login failed: ${err.message}`),
+      TokenExchangeError: (err) => import_effect21.Console.error(`Login failed: ${err.message}`),
+      OAuthDiscoveryError: (err) => import_effect21.Console.error(`Login failed: ${err.message}`),
+      AuthStorageWriteError: (err) => import_effect21.Console.error(`Failed to save credentials: ${err.message}`)
+    })
+  )
+);
+
+// src/commands/logout/index.ts
+var import_cli10 = require("@effect/cli");
+var import_effect22 = require("effect");
+var logoutCommand = import_cli10.Command.make(
+  "logout",
+  {},
+  () => import_effect22.Effect.gen(function* () {
+    const auth = yield* AuthService;
+    yield* auth.logout;
+    yield* import_effect22.Console.log("Logged out.");
+  }).pipe(
+    import_effect22.Effect.catchTags({
+      AuthStorageWriteError: (err) => import_effect22.Console.error(`Failed to log out: ${err.message}`).pipe(import_effect22.Effect.andThen(import_effect22.Effect.fail(err)))
     })
   )
 );
 
 // src/commands/platform/index.ts
-var import_cli6 = require("@effect/cli");
-var import_effect15 = require("effect");
+var import_cli12 = require("@effect/cli");
+var import_effect26 = require("effect");
 
 // src/commands/platform/deploy/index.ts
-var import_cli5 = require("@effect/cli");
-var import_platform5 = require("@effect/platform");
-var import_commons2 = require("@gigadrive/commons");
-var import_effect14 = require("effect");
-var os2 = __toESM(require("os"), 1);
+var import_cli11 = require("@effect/cli");
+var import_platform9 = require("@effect/platform");
+var import_commons = require("@gigadrive/commons");
+var import_effect25 = require("effect");
+var os4 = __toESM(require("os"), 1);
 
 // src/services/archive.ts
-var import_platform4 = require("@effect/platform");
+var import_platform8 = require("@effect/platform");
 var import_build_utils3 = require("@gigadrive/build-utils");
 var import_archiver = __toESM(require("archiver"), 1);
-var import_effect12 = require("effect");
+var import_effect23 = require("effect");
 var import_ignore = __toESM(require("ignore"), 1);
 var nodeFs = __toESM(require("fs"), 1);
 var nodeFsPromises = __toESM(require("fs/promises"), 1);
 var IGNORE_FILE_NAMES = [".gigadriveignore", ".vercelignore", ".dockerignore", ".nowignore"];
 var readIgnoreFile = (fs, ignorePath) => fs.readFileString(ignorePath, "utf8").pipe(
-  import_effect12.Effect.map((content) => content.split("\n").filter((line) => line.trim() !== "")),
-  import_effect12.Effect.catchAll(() => import_effect12.Effect.succeed([]))
+  import_effect23.Effect.map((content) => content.split("\n").filter((line) => line.trim() !== "")),
+  import_effect23.Effect.catchAll(() => import_effect23.Effect.succeed([]))
 );
-var collectIgnorePatterns = (fs, pathService, dir, baseDir, ignoreRules) => import_effect12.Effect.gen(function* () {
-  const items = yield* fs.readDirectory(dir).pipe(import_effect12.Effect.mapError(() => new ArchiveCreateError({ message: `Failed to read directory: ${dir}` })));
+var collectIgnorePatterns = (fs, pathService, dir, baseDir, ignoreRules) => import_effect23.Effect.gen(function* () {
+  const items = yield* fs.readDirectory(dir).pipe(import_effect23.Effect.mapError(() => new ArchiveCreateError({ message: `Failed to read directory: ${dir}` })));
   for (const item of items) {
     const fullPath = pathService.join(dir, item);
     const relativePath = pathService.relative(baseDir, fullPath);
-    const stat = yield* import_effect12.Effect.tryPromise({
+    const stat = yield* import_effect23.Effect.tryPromise({
       try: () => nodeFsPromises.lstat(fullPath),
       catch: () => new ArchiveCreateError({ message: `Failed to stat: ${fullPath}` })
     });
@@ -1014,8 +2234,8 @@ var collectIgnorePatterns = (fs, pathService, dir, baseDir, ignoreRules) => impo
       yield* collectIgnorePatterns(fs, pathService, fullPath, baseDir, ignoreRules);
     }
   }
-}).pipe(import_effect12.Effect.catchAll(() => import_effect12.Effect.void));
-var initializeIgnoreRules = (fs, pathService, baseDir) => import_effect12.Effect.gen(function* () {
+}).pipe(import_effect23.Effect.catchAll(() => import_effect23.Effect.void));
+var initializeIgnoreRules = (fs, pathService, baseDir) => import_effect23.Effect.gen(function* () {
   const ignoreRules = (0, import_ignore.default)();
   ignoreRules.add([".git/", "**/.DS_Store", "**/Thumbs.db"]);
   for (const ignoreFileName of IGNORE_FILE_NAMES) {
@@ -1030,14 +2250,14 @@ var initializeIgnoreRules = (fs, pathService, baseDir) => import_effect12.Effect
   yield* collectIgnorePatterns(fs, pathService, baseDir, baseDir, ignoreRules);
   return ignoreRules;
 });
-var getFilesToInclude = (fs, pathService, dir, ignoreRules) => import_effect12.Effect.gen(function* () {
+var getFilesToInclude = (fs, pathService, dir, ignoreRules) => import_effect23.Effect.gen(function* () {
   const filesToInclude = [];
-  const walkDir = (currentDir) => import_effect12.Effect.gen(function* () {
-    const items = yield* fs.readDirectory(currentDir).pipe(import_effect12.Effect.mapError(() => new ArchiveCreateError({ message: `Failed to read directory: ${currentDir}` })));
+  const walkDir = (currentDir) => import_effect23.Effect.gen(function* () {
+    const items = yield* fs.readDirectory(currentDir).pipe(import_effect23.Effect.mapError(() => new ArchiveCreateError({ message: `Failed to read directory: ${currentDir}` })));
     for (const item of items) {
       const fullPath = pathService.join(currentDir, item);
       const relativePath = pathService.relative(dir, fullPath);
-      const stat = yield* import_effect12.Effect.tryPromise({
+      const stat = yield* import_effect23.Effect.tryPromise({
         try: () => nodeFsPromises.lstat(fullPath),
         catch: () => new ArchiveCreateError({ message: `Failed to stat: ${fullPath}` })
       });
@@ -1051,21 +2271,21 @@ var getFilesToInclude = (fs, pathService, dir, ignoreRules) => import_effect12.E
         }
       }
     }
-  }).pipe(import_effect12.Effect.catchAll(() => import_effect12.Effect.void));
+  }).pipe(import_effect23.Effect.catchAll(() => import_effect23.Effect.void));
   yield* walkDir(dir);
   return filesToInclude;
 });
-var ArchiveService = class extends import_effect12.Effect.Service()("ArchiveService", {
+var ArchiveService = class extends import_effect23.Effect.Service()("ArchiveService", {
   accessors: true,
-  effect: import_effect12.Effect.gen(function* () {
-    const fs = yield* import_platform4.FileSystem.FileSystem;
-    const pathService = yield* import_platform4.Path.Path;
-    const createZipArchive = import_effect12.Effect.fn("ArchiveService.createZipArchive")(function* (inputDir, outputFile, options = {}) {
-      yield* import_effect12.Effect.annotateCurrentSpan("inputDir", inputDir);
-      yield* import_effect12.Effect.annotateCurrentSpan("outputFile", outputFile);
-      yield* import_effect12.Effect.log("Creating zip archive", { inputDir, outputFile });
+  effect: import_effect23.Effect.gen(function* () {
+    const fs = yield* import_platform8.FileSystem.FileSystem;
+    const pathService = yield* import_platform8.Path.Path;
+    const createZipArchive = import_effect23.Effect.fn("ArchiveService.createZipArchive")(function* (inputDir, outputFile, options = {}) {
+      yield* import_effect23.Effect.annotateCurrentSpan("inputDir", inputDir);
+      yield* import_effect23.Effect.annotateCurrentSpan("outputFile", outputFile);
+      yield* import_effect23.Effect.log("Creating zip archive", { inputDir, outputFile });
       const ignoreRules = options.useIgnoreFiles !== false ? yield* initializeIgnoreRules(fs, pathService, inputDir) : (0, import_ignore.default)();
-      const filesToInclude = options.whitelist ? yield* import_effect12.Effect.tryPromise({
+      const filesToInclude = options.whitelist ? yield* import_effect23.Effect.tryPromise({
         try: () => Promise.all(
           options.whitelist.map((file) => (0, import_build_utils3.getFilesForPattern)(file, inputDir, options.excludeFiles ?? []))
         ),
@@ -1073,25 +2293,25 @@ var ArchiveService = class extends import_effect12.Effect.Service()("ArchiveServ
           message: "Failed to resolve whitelist patterns",
           cause: error instanceof Error ? error.message : String(error)
         })
-      }) : yield* import_effect12.Effect.gen(function* () {
+      }) : yield* import_effect23.Effect.gen(function* () {
         if (options.excludeFiles && options.excludeFiles.length > 0) {
           ignoreRules.add(options.excludeFiles);
         }
         return yield* getFilesToInclude(fs, pathService, inputDir, ignoreRules).pipe(
-          import_effect12.Effect.map((files) => [files])
+          import_effect23.Effect.map((files) => [files])
         );
       });
-      const archiveExists = yield* fs.exists(outputFile).pipe(import_effect12.Effect.catchAll(() => import_effect12.Effect.succeed(false)));
+      const archiveExists = yield* fs.exists(outputFile).pipe(import_effect23.Effect.catchAll(() => import_effect23.Effect.succeed(false)));
       if (archiveExists) {
         yield* fs.remove(outputFile).pipe(
-          import_effect12.Effect.mapError(
+          import_effect23.Effect.mapError(
             (error) => new ArchiveCreateError({
               message: `Failed to remove existing archive: ${String(error)}`
             })
           )
         );
       }
-      yield* import_effect12.Effect.tryPromise({
+      yield* import_effect23.Effect.tryPromise({
         try: () => new Promise((resolve, reject) => {
           const output = nodeFs.createWriteStream(outputFile);
           const archive = (0, import_archiver.default)("zip", { zlib: { level: 9 } });
@@ -1110,14 +2330,14 @@ var ArchiveService = class extends import_effect12.Effect.Service()("ArchiveServ
         })
       });
       const fileInfo = yield* fs.stat(outputFile).pipe(
-        import_effect12.Effect.mapError(
+        import_effect23.Effect.mapError(
           (error) => new ArchiveCreateError({
             message: `Failed to stat archive: ${String(error)}`
           })
         )
       );
       const size = Number(fileInfo.size);
-      yield* import_effect12.Effect.log("Archive created", { size });
+      yield* import_effect23.Effect.log("Archive created", { size });
       return { path: outputFile, size };
     });
     return { createZipArchive };
@@ -1126,250 +2346,104 @@ var ArchiveService = class extends import_effect12.Effect.Service()("ArchiveServ
 };
 
 // src/services/deployment-api.ts
-var import_commons = require("@gigadrive/commons");
-var import_effect13 = require("effect");
-var CreateDeploymentResponse = import_effect13.Schema.Struct({ id: import_effect13.Schema.String });
-var StartUploadResponse = import_effect13.Schema.Struct({ uploadId: import_effect13.Schema.String });
-var PresignedUrlResponse = import_effect13.Schema.Struct({ url: import_effect13.Schema.String });
-var DeploymentStatusResponse = import_effect13.Schema.Struct({
-  status: import_effect13.Schema.Literal("PENDING", "BUILDING", "PROVISIONING", "FAILED", "ACTIVE", "SUSPENDED")
-});
-var DeploymentLogPageResponse = import_effect13.Schema.Struct({
-  totalItems: import_effect13.Schema.Number,
-  limit: import_effect13.Schema.Number,
-  offset: import_effect13.Schema.Number,
-  items: import_effect13.Schema.Array(
-    import_effect13.Schema.Struct({
-      id: import_effect13.Schema.String,
-      message: import_effect13.Schema.String,
-      type: import_effect13.Schema.Literal("INFO", "ERROR", "WARN"),
-      createdAt: import_effect13.Schema.String
-    })
-  )
-});
-var ApiBaseUrl = import_effect13.Config.string("GIGADRIVE_API_BASE_URL").pipe(import_effect13.Config.withDefault("http://localhost:3000"));
-var DeploymentApiService = class extends import_effect13.Effect.Service()("DeploymentApiService", {
+var import_effect24 = require("effect");
+var DeploymentApiService = class extends import_effect24.Effect.Service()("DeploymentApiService", {
   accessors: true,
-  effect: import_effect13.Effect.gen(function* () {
-    const baseUrl = yield* ApiBaseUrl;
-    const authService = yield* AuthService;
-    const getAuthHeaders = import_effect13.Effect.gen(function* () {
-      const token = yield* authService.getAccessToken.pipe(
-        import_effect13.Effect.mapError((err) => new DeploymentAuthError({ message: `Authentication failed: ${err.message}` }))
-      );
-      return { Authorization: `Bearer ${token}` };
-    });
-    const createDeployment = import_effect13.Effect.fn("DeploymentApiService.createDeployment")(function* (applicationId) {
-      yield* import_effect13.Effect.annotateCurrentSpan("applicationId", applicationId);
-      yield* import_effect13.Effect.log("Creating deployment", { applicationId });
-      const authHeaders = yield* getAuthHeaders;
-      const response = yield* import_effect13.Effect.tryPromise({
-        try: () => fetch(`${baseUrl}/${applicationId}/deployments`, {
-          method: "POST",
-          headers: { "Content-Type": "application/json", ...authHeaders },
-          body: JSON.stringify({})
-        }),
+  dependencies: [ApiClientService.Default],
+  effect: import_effect24.Effect.gen(function* () {
+    const apiClient = yield* ApiClientService;
+    const getClient = apiClient.getClient.pipe(
+      import_effect24.Effect.mapError((err) => new DeploymentAuthError({ message: `Authentication failed: ${err.message}` }))
+    );
+    const createDeployment = import_effect24.Effect.fn("DeploymentApiService.createDeployment")(function* (applicationId) {
+      yield* import_effect24.Effect.annotateCurrentSpan("applicationId", applicationId);
+      yield* import_effect24.Effect.log("Creating deployment", { applicationId });
+      const client = yield* getClient;
+      const deployment = yield* import_effect24.Effect.tryPromise({
+        try: () => client.deployments.create({ applicationId }),
         catch: (error) => new DeploymentCreateError({
           message: `Failed to create deployment: ${error instanceof Error ? error.message : String(error)}`
         })
       });
-      if (!response.ok) {
-        const body = yield* import_effect13.Effect.tryPromise({
-          try: () => response.text(),
-          catch: () => new DeploymentCreateError({
-            message: "Failed to read deployment creation error",
-            statusCode: response.status
-          })
-        });
-        return yield* import_effect13.Effect.fail(
-          new DeploymentCreateError({
-            message: `Failed to create deployment: ${body}`,
-            statusCode: response.status
-          })
-        );
-      }
-      const json = yield* import_effect13.Effect.tryPromise({
-        try: () => response.json(),
-        catch: () => new DeploymentCreateError({ message: "Failed to parse deployment response" })
-      });
-      const decoded = yield* import_effect13.Schema.decodeUnknown(CreateDeploymentResponse)(json).pipe(
-        import_effect13.Effect.mapError(() => new DeploymentCreateError({ message: "Invalid deployment response schema" }))
-      );
-      yield* import_effect13.Effect.log("Deployment created", { deploymentId: decoded.id });
-      return decoded.id;
+      yield* import_effect24.Effect.log("Deployment created", { deploymentId: deployment.id });
+      return deployment.id;
     });
-    const startMultipartUpload = import_effect13.Effect.fn("DeploymentApiService.startMultipartUpload")(function* (deploymentId) {
-      yield* import_effect13.Effect.annotateCurrentSpan("deploymentId", deploymentId);
-      const authHeaders = yield* getAuthHeaders;
-      const response = yield* import_effect13.Effect.tryPromise({
-        try: () => fetch(`${baseUrl}/deployments/${deploymentId}/pre-signed-url/start`, {
-          method: "GET",
-          headers: { "Content-Type": "application/json", ...authHeaders }
-        }),
+    const startMultipartUpload = import_effect24.Effect.fn("DeploymentApiService.startMultipartUpload")(function* (deploymentId) {
+      yield* import_effect24.Effect.annotateCurrentSpan("deploymentId", deploymentId);
+      const client = yield* getClient;
+      const result = yield* import_effect24.Effect.tryPromise({
+        try: () => client.deployments.startUpload(deploymentId),
         catch: (error) => new UploadStartError({
           message: `Failed to start multipart upload: ${error instanceof Error ? error.message : String(error)}`
         })
       });
-      if (!response.ok) {
-        const body = yield* import_effect13.Effect.tryPromise({
-          try: () => response.text(),
-          catch: () => new UploadStartError({ message: "Failed to read upload start error" })
-        });
-        return yield* import_effect13.Effect.fail(
-          new UploadStartError({ message: `Failed to start multipart upload: ${body}`, statusCode: response.status })
-        );
-      }
-      const json = yield* import_effect13.Effect.tryPromise({
-        try: () => response.json(),
-        catch: () => new UploadStartError({ message: "Failed to parse upload start response" })
-      });
-      const decoded = yield* import_effect13.Schema.decodeUnknown(StartUploadResponse)(json).pipe(
-        import_effect13.Effect.mapError(() => new UploadStartError({ message: "Invalid upload start response schema" }))
-      );
-      return decoded.uploadId;
+      return result.uploadId;
     });
-    const getPresignedUrl = import_effect13.Effect.fn("DeploymentApiService.getPresignedUrl")(function* (deploymentId, uploadId, partNumber) {
-      const authHeaders = yield* getAuthHeaders;
-      const response = yield* import_effect13.Effect.tryPromise({
-        try: () => fetch(
-          `${baseUrl}/deployments/${deploymentId}/pre-signed-url/part?uploadId=${uploadId}&partNumber=${partNumber}`,
-          {
-            method: "GET",
-            headers: { "Content-Type": "application/json", ...authHeaders }
-          }
-        ),
+    const getPresignedUrl = import_effect24.Effect.fn("DeploymentApiService.getPresignedUrl")(function* (deploymentId, uploadId, partNumber) {
+      const client = yield* getClient;
+      const result = yield* import_effect24.Effect.tryPromise({
+        try: () => client.deployments.getPresignedUrl(deploymentId, uploadId, partNumber),
         catch: (error) => new PresignedUrlError({
           message: `Failed to get presigned URL: ${error instanceof Error ? error.message : String(error)}`,
           partNumber
         })
       });
-      if (!response.ok) {
-        const body = yield* import_effect13.Effect.tryPromise({
-          try: () => response.text(),
-          catch: () => new PresignedUrlError({ message: "Failed to read presigned URL error", partNumber })
-        });
-        return yield* import_effect13.Effect.fail(
-          new PresignedUrlError({ message: `Failed to get presigned URL: ${body}`, partNumber })
-        );
-      }
-      const json = yield* import_effect13.Effect.tryPromise({
-        try: () => response.json(),
-        catch: () => new PresignedUrlError({ message: "Failed to parse presigned URL response", partNumber })
-      });
-      const decoded = yield* import_effect13.Schema.decodeUnknown(PresignedUrlResponse)(json).pipe(
-        import_effect13.Effect.mapError(() => new PresignedUrlError({ message: "Invalid presigned URL response schema", partNumber }))
-      );
-      return decoded.url;
+      return result.url;
     });
-    const uploadPart = import_effect13.Effect.fn("DeploymentApiService.uploadPart")(function* (presignedUrl, data, partNumber) {
-      yield* import_effect13.Effect.annotateCurrentSpan("partNumber", partNumber);
-      yield* import_effect13.Effect.annotateCurrentSpan("size", data.length);
-      const response = yield* import_effect13.Effect.tryPromise({
-        try: () => fetch(presignedUrl, {
-          method: "PUT",
-          headers: {
-            "Content-Type": "application/zip",
-            "Content-Length": String(data.length)
-          },
-          body: data
-        }),
+    const uploadPart = import_effect24.Effect.fn("DeploymentApiService.uploadPart")(function* (presignedUrl, data, partNumber) {
+      yield* import_effect24.Effect.annotateCurrentSpan("partNumber", partNumber);
+      yield* import_effect24.Effect.annotateCurrentSpan("size", data.length);
+      const client = yield* getClient;
+      const result = yield* import_effect24.Effect.tryPromise({
+        try: () => client.deployments.uploadPart(presignedUrl, data, partNumber),
         catch: (error) => new UploadPartError({
           message: `Failed to upload part ${partNumber}: ${error instanceof Error ? error.message : String(error)}`,
           partNumber
         })
       });
-      if (!response.ok) {
-        return yield* import_effect13.Effect.fail(
-          new UploadPartError({
-            message: `Failed to upload part ${partNumber}: ${response.statusText}`,
-            partNumber
-          })
-        );
-      }
-      const etag = response.headers.get("ETag");
-      if (!etag) {
-        return yield* import_effect13.Effect.fail(
-          new UploadPartError({ message: `No ETag received for part ${partNumber}`, partNumber })
-        );
-      }
-      return { partNumber, etag };
+      return result;
     });
-    const completeUpload = import_effect13.Effect.fn("DeploymentApiService.completeUpload")(function* (deploymentId, uploadId, parts) {
-      yield* import_effect13.Effect.annotateCurrentSpan("deploymentId", deploymentId);
-      yield* import_effect13.Effect.annotateCurrentSpan("partsCount", parts.length);
-      const authHeaders = yield* getAuthHeaders;
-      const response = yield* import_effect13.Effect.tryPromise({
-        try: () => fetch(`${baseUrl}/deployments/${deploymentId}/pre-signed-url/complete`, {
-          method: "POST",
-          headers: { "Content-Type": "application/json", ...authHeaders },
-          body: JSON.stringify({ uploadId, parts })
-        }),
+    const completeUpload = import_effect24.Effect.fn("DeploymentApiService.completeUpload")(function* (deploymentId, uploadId, parts) {
+      yield* import_effect24.Effect.annotateCurrentSpan("deploymentId", deploymentId);
+      yield* import_effect24.Effect.annotateCurrentSpan("partsCount", parts.length);
+      const client = yield* getClient;
+      yield* import_effect24.Effect.tryPromise({
+        try: () => client.deployments.completeUpload(deploymentId, uploadId, parts),
         catch: (error) => new UploadCompleteError({
           message: `Failed to complete upload: ${error instanceof Error ? error.message : String(error)}`
         })
       });
-      if (!response.ok) {
-        const body = yield* import_effect13.Effect.tryPromise({
-          try: () => response.text(),
-          catch: () => new UploadCompleteError({ message: "Failed to read upload complete error" })
-        });
-        return yield* import_effect13.Effect.fail(new UploadCompleteError({ message: `Failed to complete upload: ${body}` }));
-      }
-      yield* import_effect13.Effect.log("Upload completed successfully");
+      yield* import_effect24.Effect.log("Upload completed successfully");
     });
-    const getDeploymentStatus = import_effect13.Effect.fn("DeploymentApiService.getDeploymentStatus")(function* (deploymentId) {
-      const authHeaders = yield* getAuthHeaders;
-      const response = yield* import_effect13.Effect.tryPromise({
-        try: () => fetch(`${baseUrl}/deployments/${deploymentId}`, {
-          method: "GET",
-          headers: { "Content-Type": "application/json", ...authHeaders }
-        }),
+    const getDeploymentStatus = import_effect24.Effect.fn("DeploymentApiService.getDeploymentStatus")(function* (deploymentId) {
+      const client = yield* getClient;
+      const deployment = yield* import_effect24.Effect.tryPromise({
+        try: () => client.deployments.get(deploymentId),
         catch: (error) => new DeploymentStatusError({
           message: `Failed to get deployment status: ${error instanceof Error ? error.message : String(error)}`
         })
       });
-      if (!response.ok) {
-        const body = yield* import_effect13.Effect.tryPromise({
-          try: () => response.text(),
-          catch: () => new DeploymentStatusError({ message: "Failed to read deployment status error" })
-        });
-        return yield* import_effect13.Effect.fail(new DeploymentStatusError({ message: `Failed to get deployment status: ${body}` }));
-      }
-      const json = yield* import_effect13.Effect.tryPromise({
-        try: () => response.json(),
-        catch: () => new DeploymentStatusError({ message: "Failed to parse deployment status response" })
-      });
-      const decoded = yield* import_effect13.Schema.decodeUnknown(DeploymentStatusResponse)(json).pipe(
-        import_effect13.Effect.mapError(() => new DeploymentStatusError({ message: "Invalid deployment status response schema" }))
-      );
-      return decoded.status;
+      return deployment.status;
     });
-    const getLogs = import_effect13.Effect.fn("DeploymentApiService.getLogs")(function* (deploymentId, options) {
-      const authHeaders = yield* getAuthHeaders;
-      const response = yield* import_effect13.Effect.tryPromise({
-        try: () => fetch(`${baseUrl}/deployments/${deploymentId}/logs${(0, import_commons.objectToQueryString)(options)}`, {
-          method: "GET",
-          headers: { "Content-Type": "application/json", ...authHeaders }
-        }),
+    const getLogs = import_effect24.Effect.fn("DeploymentApiService.getLogs")(function* (deploymentId, options) {
+      const client = yield* getClient;
+      const result = yield* import_effect24.Effect.tryPromise({
+        try: () => client.deployments.getLogs(deploymentId, options),
         catch: (error) => new DeploymentLogsFetchError({
           message: `Failed to get logs: ${error instanceof Error ? error.message : String(error)}`
         })
       });
-      if (!response.ok) {
-        const body = yield* import_effect13.Effect.tryPromise({
-          try: () => response.text(),
-          catch: () => new DeploymentLogsFetchError({ message: "Failed to read logs error" })
-        });
-        return yield* import_effect13.Effect.fail(new DeploymentLogsFetchError({ message: `Failed to get logs: ${body}` }));
-      }
-      const json = yield* import_effect13.Effect.tryPromise({
-        try: () => response.json(),
-        catch: () => new DeploymentLogsFetchError({ message: "Failed to parse logs response" })
+      return result;
+    });
+    const getHostnames = import_effect24.Effect.fn("DeploymentApiService.getHostnames")(function* (deploymentId) {
+      const client = yield* getClient;
+      const result = yield* import_effect24.Effect.tryPromise({
+        try: () => client.deployments.getHostnames(deploymentId),
+        catch: (error) => new DeploymentHostnamesFetchError({
+          message: `Failed to get hostnames: ${error instanceof Error ? error.message : String(error)}`
+        })
       });
-      const decoded = yield* import_effect13.Schema.decodeUnknown(DeploymentLogPageResponse)(json).pipe(
-        import_effect13.Effect.mapError(() => new DeploymentLogsFetchError({ message: "Invalid logs response schema" }))
-      );
-      return decoded;
+      return result.items;
     });
     return {
       createDeployment,
@@ -1378,89 +2452,102 @@ var DeploymentApiService = class extends import_effect13.Effect.Service()("Deplo
       uploadPart,
       completeUpload,
       getDeploymentStatus,
-      getLogs
+      getLogs,
+      getHostnames
     };
   })
 }) {
 };
 
 // src/commands/platform/deploy/index.ts
-var deployCommand = import_cli5.Command.make(
+var appOption5 = import_cli11.Options.text("app").pipe(
+  import_cli11.Options.withAlias("a"),
+  import_cli11.Options.withDescription("Application ID to deploy to (overrides the linked application)"),
+  import_cli11.Options.optional
+);
+var deployCommand = import_cli11.Command.make(
   "deploy",
-  {},
-  () => import_effect14.Effect.gen(function* () {
+  { app: appOption5 },
+  ({ app }) => import_effect25.Effect.gen(function* () {
     const projectConfig = yield* ProjectConfigService;
     const deploymentApi = yield* DeploymentApiService;
     const archiveService = yield* ArchiveService;
-    const pathService = yield* import_platform5.Path.Path;
+    const projectLink = yield* ProjectLinkService;
+    const pathService = yield* import_platform9.Path.Path;
     const cwd = process.cwd();
-    yield* import_effect14.Effect.log("Starting deploy command");
+    const applicationId = yield* import_effect25.Option.match(app, {
+      onSome: (id) => import_effect25.Effect.succeed(id),
+      onNone: () => projectLink.resolve(cwd).pipe(import_effect25.Effect.map((link) => link.applicationId))
+    });
+    yield* import_effect25.Effect.log("Starting deploy command");
     const { config } = yield* projectConfig.resolve(cwd);
-    yield* import_effect14.Console.log("Creating deployment...");
-    const deploymentId = yield* deploymentApi.createDeployment("test");
-    yield* import_effect14.Console.log(`Deployment ID: ${deploymentId}`);
-    yield* import_effect14.Console.log("Creating archive...");
-    const archivePath = pathService.join(os2.tmpdir(), `project-${Date.now()}.zip`);
+    yield* import_effect25.Console.log("Creating deployment...");
+    const deploymentId = yield* deploymentApi.createDeployment(applicationId);
+    yield* import_effect25.Console.log(`Deployment ID: ${deploymentId}`);
+    yield* import_effect25.Console.log("Creating archive...");
+    const archivePath = pathService.join(os4.tmpdir(), `project-${Date.now()}.zip`);
     const archive = yield* archiveService.createZipArchive(config.userArchive?.rootOverwrite || cwd, archivePath, {
       whitelist: config.userArchive?.fileWhitelist,
       excludeFiles: config.excludeFiles,
       useIgnoreFiles: false,
       useManagedIgnore: false
     });
-    yield* import_effect14.Console.log(`Archive created (${(0, import_commons2.formatFileSize)(archive.size)})`);
-    yield* import_effect14.Console.log("Uploading archive...");
+    yield* import_effect25.Console.log(`Archive created (${(0, import_commons.formatFileSize)(archive.size)})`);
+    yield* import_effect25.Console.log("Uploading archive...");
     yield* uploadArchive(deploymentId, archivePath, archive.size);
-    yield* import_effect14.Console.log("Upload complete.");
-    yield* import_effect14.Console.log("The deployment pipeline is now being provisioned. This may take a few seconds.");
+    yield* import_effect25.Console.log("Upload complete.");
+    yield* import_effect25.Console.log("The deployment pipeline is now being provisioned. This may take a few seconds.");
     yield* pollDeployment(deploymentId);
   }).pipe(
-    import_effect14.Effect.catchTags({
-      ConfigNotFoundError: (err) => import_effect14.Console.error(err.message).pipe(import_effect14.Effect.andThen(import_effect14.Effect.fail(err))),
-      ConfigParseError: (err) => import_effect14.Console.error(`Config parse error: ${err.message}`).pipe(import_effect14.Effect.andThen(import_effect14.Effect.fail(err))),
-      ConfigValidationError: (err) => import_effect14.Effect.gen(function* () {
+    import_effect25.Effect.catchTags({
+      ProjectNotLinkedError: (err) => import_effect25.Console.error(err.message).pipe(import_effect25.Effect.andThen(import_effect25.Effect.fail(err))),
+      ProjectLinkReadError: (err) => import_effect25.Console.error(err.message).pipe(import_effect25.Effect.andThen(import_effect25.Effect.fail(err))),
+      ConfigNotFoundError: (err) => import_effect25.Console.error(err.message).pipe(import_effect25.Effect.andThen(import_effect25.Effect.fail(err))),
+      ConfigParseError: (err) => import_effect25.Console.error(`Config parse error: ${err.message}`).pipe(import_effect25.Effect.andThen(import_effect25.Effect.fail(err))),
+      ConfigValidationError: (err) => import_effect25.Effect.gen(function* () {
         for (const e of err.errors) {
-          yield* import_effect14.Console.error(e);
+          yield* import_effect25.Console.error(e);
         }
-        yield* import_effect14.Console.error(err.message);
-      }).pipe(import_effect14.Effect.andThen(import_effect14.Effect.fail(err))),
-      DeploymentCreateError: (err) => import_effect14.Console.error(`Deployment creation failed: ${err.message}`).pipe(import_effect14.Effect.andThen(import_effect14.Effect.fail(err))),
-      ArchiveCreateError: (err) => import_effect14.Console.error(`Archive creation failed: ${err.message}`).pipe(import_effect14.Effect.andThen(import_effect14.Effect.fail(err))),
-      UploadStartError: (err) => import_effect14.Console.error(`Upload failed: ${err.message}`).pipe(import_effect14.Effect.andThen(import_effect14.Effect.fail(err))),
-      UploadPartError: (err) => import_effect14.Console.error(`Upload failed: ${err.message}`).pipe(import_effect14.Effect.andThen(import_effect14.Effect.fail(err))),
-      UploadCompleteError: (err) => import_effect14.Console.error(`Upload failed: ${err.message}`).pipe(import_effect14.Effect.andThen(import_effect14.Effect.fail(err))),
-      PresignedUrlError: (err) => import_effect14.Console.error(`Upload failed: ${err.message}`).pipe(import_effect14.Effect.andThen(import_effect14.Effect.fail(err))),
-      DeploymentAuthError: (err) => import_effect14.Console.error(`Authentication failed: ${err.message}`).pipe(import_effect14.Effect.andThen(import_effect14.Effect.fail(err))),
-      DeploymentFailedError: (err) => import_effect14.Console.error(err.message).pipe(import_effect14.Effect.andThen(import_effect14.Effect.fail(err)))
+        yield* import_effect25.Console.error(err.message);
+      }).pipe(import_effect25.Effect.andThen(import_effect25.Effect.fail(err))),
+      DeploymentCreateError: (err) => import_effect25.Console.error(`Deployment creation failed: ${err.message}`).pipe(import_effect25.Effect.andThen(import_effect25.Effect.fail(err))),
+      ArchiveCreateError: (err) => import_effect25.Console.error(`Archive creation failed: ${err.message}`).pipe(import_effect25.Effect.andThen(import_effect25.Effect.fail(err))),
+      UploadStartError: (err) => import_effect25.Console.error(`Upload failed: ${err.message}`).pipe(import_effect25.Effect.andThen(import_effect25.Effect.fail(err))),
+      UploadPartError: (err) => import_effect25.Console.error(`Upload failed: ${err.message}`).pipe(import_effect25.Effect.andThen(import_effect25.Effect.fail(err))),
+      UploadCompleteError: (err) => import_effect25.Console.error(`Upload failed: ${err.message}`).pipe(import_effect25.Effect.andThen(import_effect25.Effect.fail(err))),
+      PresignedUrlError: (err) => import_effect25.Console.error(`Upload failed: ${err.message}`).pipe(import_effect25.Effect.andThen(import_effect25.Effect.fail(err))),
+      DeploymentAuthError: (err) => import_effect25.Console.error(`Authentication failed: ${err.message}`).pipe(import_effect25.Effect.andThen(import_effect25.Effect.fail(err))),
+      DeploymentFailedError: (err) => import_effect25.Console.error(err.message).pipe(import_effect25.Effect.andThen(import_effect25.Effect.fail(err)))
     })
   )
 );
-var uploadArchive = (deploymentId, archivePath, fileSize) => import_effect14.Effect.gen(function* () {
+var uploadArchive = (deploymentId, archivePath, fileSize) => import_effect25.Effect.gen(function* () {
   const deploymentApi = yield* DeploymentApiService;
-  const fs = yield* import_platform5.FileSystem.FileSystem;
+  const fs = yield* import_platform9.FileSystem.FileSystem;
   const uploadId = yield* deploymentApi.startMultipartUpload(deploymentId);
   const FILE_CHUNK_SIZE = 10 * 1024 * 1024;
   const numChunks = Math.ceil(fileSize / FILE_CHUNK_SIZE);
-  yield* import_effect14.Effect.log("Starting multipart upload", { uploadId, numChunks, fileSize });
-  const parts = yield* import_effect14.Effect.all(
+  yield* import_effect25.Effect.log("Starting multipart upload", { uploadId, numChunks, fileSize });
+  const parts = yield* import_effect25.Effect.all(
     Array.from({ length: numChunks }, (_, i) => {
       const partNumber = i + 1;
       const start = i * FILE_CHUNK_SIZE;
       const bytesToRead = partNumber < numChunks ? FILE_CHUNK_SIZE : fileSize - start;
-      return import_effect14.Effect.gen(function* () {
+      return import_effect25.Effect.gen(function* () {
         const presignedUrl = yield* deploymentApi.getPresignedUrl(deploymentId, uploadId, partNumber);
-        const chunkData = yield* import_effect14.Stream.runCollect(fs.stream(archivePath, { offset: start, bytesToRead })).pipe(
-          import_effect14.Effect.map((chunks) => {
+        const chunkData = yield* import_effect25.Stream.runCollect(fs.stream(archivePath, { offset: start, bytesToRead })).pipe(
+          import_effect25.Effect.map((chunks) => {
             const arrays = Array.from(chunks);
             return Buffer.concat(arrays);
           }),
-          import_effect14.Effect.mapError(
+          import_effect25.Effect.mapError(
             (error) => new UploadPartError({
               message: `Failed to read chunk ${partNumber}: ${String(error)}`,
               partNumber
             })
           )
         );
-        yield* import_effect14.Effect.log(`Uploading part ${partNumber}/${numChunks}`, { size: chunkData.length });
+        yield* import_effect25.Effect.log(`Uploading part ${partNumber}/${numChunks}`, { size: chunkData.length });
         return yield* deploymentApi.uploadPart(presignedUrl, chunkData, partNumber);
       });
     }),
@@ -1468,20 +2555,20 @@ var uploadArchive = (deploymentId, archivePath, fileSize) => import_effect14.Eff
   );
   yield* deploymentApi.completeUpload(deploymentId, uploadId, parts);
 });
-var pollDeployment = (deploymentId) => import_effect14.Effect.gen(function* () {
+var pollDeployment = (deploymentId) => import_effect25.Effect.gen(function* () {
   const deploymentApi = yield* DeploymentApiService;
   let lastStatus = "PENDING";
   let logOffset = 0;
-  yield* import_effect14.Console.log("Status: Pending");
-  yield* import_effect14.Effect.repeat(
-    import_effect14.Effect.gen(function* () {
-      const newStatus = yield* deploymentApi.getDeploymentStatus(deploymentId).pipe(import_effect14.Effect.catchTag("DeploymentStatusError", () => import_effect14.Effect.succeed(lastStatus)));
+  yield* import_effect25.Console.log("Status: Pending");
+  yield* import_effect25.Effect.repeat(
+    import_effect25.Effect.gen(function* () {
+      const newStatus = yield* deploymentApi.getDeploymentStatus(deploymentId).pipe(import_effect25.Effect.catchTag("DeploymentStatusError", () => import_effect25.Effect.succeed(lastStatus)));
       if (newStatus !== lastStatus) {
         lastStatus = newStatus;
         const label = newStatus.charAt(0) + newStatus.slice(1).toLowerCase();
-        yield* import_effect14.Console.log(`Status: ${label}`);
+        yield* import_effect25.Console.log(`Status: ${label}`);
       }
-      const logsPage = yield* deploymentApi.getLogs(deploymentId, { offset: logOffset, limit: 100 }).pipe(import_effect14.Effect.catchTag("DeploymentLogsFetchError", () => import_effect14.Effect.succeed(null)));
+      const logsPage = yield* deploymentApi.getLogs(deploymentId, { offset: logOffset, limit: 100 }).pipe(import_effect25.Effect.catchTag("DeploymentLogsFetchError", () => import_effect25.Effect.succeed(null)));
       if (logsPage) {
         for (const logEntry of logsPage.items) {
           logOffset++;
@@ -1489,79 +2576,247 @@ var pollDeployment = (deploymentId) => import_effect14.Effect.gen(function* () {
         }
       }
       if (newStatus === "ACTIVE") {
-        yield* import_effect14.Console.log(`Deployed to https://${deploymentId}.gigadrivedev.com`);
-        return yield* import_effect14.Effect.fail("done");
+        const hostnames = yield* deploymentApi.getHostnames(deploymentId).pipe(import_effect25.Effect.catchTag("DeploymentHostnamesFetchError", () => import_effect25.Effect.succeed([])));
+        const active = hostnames.find((h) => h.active) ?? hostnames.at(0);
+        if (active) {
+          yield* import_effect25.Console.log(`Deployed to https://${active.hostname}`);
+        } else {
+          yield* import_effect25.Console.log("Deployment is live.");
+        }
+        return yield* import_effect25.Effect.fail("done");
       }
       if (newStatus === "FAILED") {
-        return yield* import_effect14.Effect.fail(
+        return yield* import_effect25.Effect.fail(
           new DeploymentFailedError({
             message: "The deployment failed. Please check the logs for more information."
           })
         );
       }
     }),
-    import_effect14.Schedule.addDelay(import_effect14.Schedule.forever, () => import_effect14.Duration.seconds(1))
+    import_effect25.Schedule.addDelay(import_effect25.Schedule.forever, () => import_effect25.Duration.seconds(1))
   ).pipe(
-    import_effect14.Effect.catchAll((err) => {
-      if (err === "done") return import_effect14.Effect.void;
-      return import_effect14.Effect.fail(err);
+    import_effect25.Effect.catchAll((err) => {
+      if (err === "done") return import_effect25.Effect.void;
+      return import_effect25.Effect.fail(err);
     })
   );
 });
 var printLog = (logEntry) => {
   switch (logEntry.type) {
     case "ERROR":
-      return import_effect14.Console.error(logEntry.message);
+      return import_effect25.Console.error(logEntry.message);
     case "WARN":
-      return import_effect14.Console.warn(logEntry.message);
+      return import_effect25.Console.warn(logEntry.message);
     default:
-      return import_effect14.Console.log(logEntry.message);
+      return import_effect25.Console.log(logEntry.message);
   }
 };
 
 // src/commands/platform/index.ts
-var platformBase = import_cli6.Command.make("platform", {}, () => import_effect15.Effect.void);
-var platformCommand = platformBase.pipe(import_cli6.Command.withSubcommands([deployCommand]));
+var platformBase = import_cli12.Command.make("platform", {}, () => import_effect26.Effect.void);
+var platformCommand = platformBase.pipe(import_cli12.Command.withSubcommands([deployCommand]));
+
+// src/commands/setup/index.ts
+var import_cli13 = require("@effect/cli");
+var import_effect27 = require("effect");
+var fileArg2 = import_cli13.Args.text({ name: "file" }).pipe(
+  import_cli13.Args.withDescription("Output file to write (default: .env.local)"),
+  import_cli13.Args.optional
+);
+var appOption6 = import_cli13.Options.text("app").pipe(
+  import_cli13.Options.withAlias("a"),
+  import_cli13.Options.withDescription("Application ID to set up (skips the interactive picker)"),
+  import_cli13.Options.optional
+);
+var orgOption6 = import_cli13.Options.text("org").pipe(
+  import_cli13.Options.withAlias("o"),
+  import_cli13.Options.withDescription("Only list applications belonging to this organization ID when picking"),
+  import_cli13.Options.optional
+);
+var environmentOption2 = import_cli13.Options.text("environment").pipe(
+  import_cli13.Options.withAlias("e"),
+  import_cli13.Options.withDescription("Environment slug to resolve overrides for (e.g. preview)"),
+  import_cli13.Options.optional
+);
+var yesOption2 = import_cli13.Options.boolean("yes").pipe(
+  import_cli13.Options.withAlias("y"),
+  import_cli13.Options.withDescription("Overwrite an existing file without confirmation")
+);
+var rotateOption2 = import_cli13.Options.boolean("rotate").pipe(
+  import_cli13.Options.withDescription("Force a fresh API key, revoking the previous one")
+);
+var setupCommand = import_cli13.Command.make(
+  "setup",
+  {
+    file: fileArg2,
+    app: appOption6,
+    org: orgOption6,
+    environment: environmentOption2,
+    yes: yesOption2,
+    rotate: rotateOption2
+  },
+  ({ file, app, org, environment, yes, rotate }) => import_effect27.Effect.gen(function* () {
+    const apiClient = yield* ApiClientService;
+    const projectLink = yield* ProjectLinkService;
+    const envFile = yield* EnvFileService;
+    const localCredentials = yield* LocalCredentialsService;
+    const cwd = process.cwd();
+    const existingLink = yield* projectLink.load(cwd);
+    let applicationId;
+    if (import_effect27.Option.isSome(existingLink)) {
+      applicationId = existingLink.value.applicationId;
+      if (import_effect27.Option.isSome(app) || import_effect27.Option.isSome(org)) {
+        yield* import_effect27.Console.log(
+          `Note: this directory is already linked to ${applicationId}; ignoring --app/--org. Run "gigadrive unlink" first to target a different application.`
+        );
+      }
+    } else {
+      const organizationId = import_effect27.Option.getOrUndefined(org);
+      const { items: apps } = yield* apiClient.request((client) => client.applications.list({ organizationId }));
+      if (apps.length === 0) {
+        return yield* import_effect27.Effect.fail(
+          new NoApplicationsFoundError({
+            message: 'No applications found. Create one in the Gigadrive console, then run "gigadrive setup" again.'
+          })
+        );
+      }
+      const explicitAppId = import_effect27.Option.getOrUndefined(app);
+      let chosen;
+      if (explicitAppId !== void 0) {
+        const match = apps.find((a) => a.id === explicitAppId);
+        if (match === void 0) {
+          return yield* import_effect27.Effect.fail(
+            new ApplicationNotFoundError({
+              message: `Application "${explicitAppId}" was not found among your applications.`
+            })
+          );
+        }
+        chosen = match;
+      } else if (apps.length === 1) {
+        chosen = apps[0];
+      } else {
+        chosen = yield* import_cli13.Prompt.run(
+          import_cli13.Prompt.select({
+            message: "Select an application to set up",
+            choices: apps.map((a) => ({ title: `${a.name} (${a.organization.name})`, value: a }))
+          })
+        );
+      }
+      applicationId = chosen.id;
+      yield* projectLink.save(cwd, { applicationId, organizationId: chosen.organization.id });
+      yield* import_effect27.Console.log(`Linked this directory to application ${applicationId}.`);
+    }
+    const target = import_effect27.Option.getOrElse(file, () => ".env.local");
+    const environmentSlug = import_effect27.Option.getOrUndefined(environment);
+    const { items, omittedSensitive } = yield* apiClient.request(
+      (client) => client.applications.envVars.pull(applicationId, environmentSlug ? { environment: environmentSlug } : void 0)
+    );
+    const existing = yield* envFile.read(target);
+    if (import_effect27.Option.isSome(existing) && !yes) {
+      const overwrite = yield* import_cli13.Prompt.run(
+        import_cli13.Prompt.confirm({ message: `${target} already exists. Overwrite?`, initial: false })
+      );
+      if (!overwrite) {
+        return yield* import_effect27.Console.log("Cancelled.");
+      }
+    }
+    const credentialEntries2 = yield* localCredentials.provision({
+      applicationId,
+      rotate,
+      existingContent: import_effect27.Option.getOrUndefined(existing)
+    });
+    const entries = [...items.map((v) => ({ key: v.key, value: v.value })), ...credentialEntries2];
+    yield* envFile.write(target, entries);
+    const gitignored = yield* envFile.ensureGitignored(cwd, target);
+    yield* import_effect27.Console.log("\nLocal dev environment ready.");
+    yield* import_effect27.Console.log(`  \u2022 Wrote ${items.length} variable(s) and API credentials to ${target}.`);
+    if (omittedSensitive > 0) {
+      yield* import_effect27.Console.log(
+        `  \u2022 Skipped ${omittedSensitive} sensitive variable(s) (only production/preview hold secrets).`
+      );
+    }
+    if (gitignored) {
+      yield* import_effect27.Console.log(`  \u2022 Added ${target} to .gitignore.`);
+    }
+    yield* import_effect27.Console.log("  \u2022 Your app can now call the Gigadrive API via the SDK (GIGADRIVE_CLIENT_ID/SECRET).");
+  }).pipe(
+    import_effect27.Effect.catchTags({
+      // Ctrl+C during a prompt is a deliberate cancel — exit 0.
+      QuitException: () => import_effect27.Console.log("Cancelled."),
+      NotAuthenticatedError: (err) => import_effect27.Console.error('You are not logged in. Run "gigadrive login" to authenticate.').pipe(
+        import_effect27.Effect.andThen(import_effect27.Effect.fail(err))
+      ),
+      ApiRequestError: (err) => import_effect27.Console.error(`Setup failed: ${err.message}`).pipe(import_effect27.Effect.andThen(import_effect27.Effect.fail(err))),
+      NoApplicationsFoundError: (err) => import_effect27.Console.error(err.message).pipe(import_effect27.Effect.andThen(import_effect27.Effect.fail(err))),
+      ApplicationNotFoundError: (err) => import_effect27.Console.error(err.message).pipe(import_effect27.Effect.andThen(import_effect27.Effect.fail(err))),
+      ProjectLinkReadError: (err) => import_effect27.Console.error(err.message).pipe(import_effect27.Effect.andThen(import_effect27.Effect.fail(err))),
+      ProjectLinkWriteError: (err) => import_effect27.Console.error(err.message).pipe(import_effect27.Effect.andThen(import_effect27.Effect.fail(err))),
+      EnvFileReadError: (err) => import_effect27.Console.error(err.message).pipe(import_effect27.Effect.andThen(import_effect27.Effect.fail(err))),
+      EnvFileWriteError: (err) => import_effect27.Console.error(err.message).pipe(import_effect27.Effect.andThen(import_effect27.Effect.fail(err))),
+      DevCredentialsStoreReadError: (err) => import_effect27.Console.error(err.message).pipe(import_effect27.Effect.andThen(import_effect27.Effect.fail(err))),
+      DevCredentialsStoreWriteError: (err) => import_effect27.Console.error(err.message).pipe(import_effect27.Effect.andThen(import_effect27.Effect.fail(err)))
+    })
+  )
+);
 
 // src/commands/whoami/index.ts
-var import_cli7 = require("@effect/cli");
-var import_effect16 = require("effect");
-var whoamiCommand = import_cli7.Command.make(
+var import_cli14 = require("@effect/cli");
+var import_effect28 = require("effect");
+var whoamiCommand = import_cli14.Command.make(
   "whoami",
   {},
-  () => import_effect16.Effect.gen(function* () {
+  () => import_effect28.Effect.gen(function* () {
     const auth = yield* AuthService;
     const info = yield* auth.getUserInfo;
-    yield* import_effect16.Console.log(JSON.stringify(info, null, 2));
+    yield* import_effect28.Console.log(JSON.stringify(info, null, 2));
   }).pipe(
-    import_effect16.Effect.catchTags({
-      NotAuthenticatedError: () => import_effect16.Console.log('You are not logged in. Run "gigadrive login" to authenticate.'),
-      UserInfoFetchError: (err) => import_effect16.Console.error(`Failed to retrieve user info: ${err.message}`),
-      OAuthDiscoveryError: (err) => import_effect16.Console.error(`Failed to retrieve user info: ${err.message}`)
+    import_effect28.Effect.catchTags({
+      NotAuthenticatedError: () => import_effect28.Console.log('You are not logged in. Run "gigadrive login" to authenticate.'),
+      UserInfoFetchError: (err) => import_effect28.Console.error(`Failed to retrieve user info: ${err.message}`),
+      OAuthDiscoveryError: (err) => import_effect28.Console.error(`Failed to retrieve user info: ${err.message}`)
     })
   )
 );
 
 // src/index.ts
-var gigadrive = import_cli8.Command.make("gigadrive", {}, () => import_effect17.Effect.void).pipe(
-  import_cli8.Command.withSubcommands([loginCommand, whoamiCommand, buildCommand, debugCommand, platformCommand])
+var gigadrive = import_cli15.Command.make("gigadrive", {}, () => import_effect29.Effect.void).pipe(
+  import_cli15.Command.withSubcommands([
+    loginCommand,
+    logoutCommand,
+    whoamiCommand,
+    linkCommand,
+    unlinkCommand,
+    appsCommand,
+    envCommand,
+    deploymentsCommand,
+    aiCommand,
+    buildCommand,
+    debugCommand,
+    platformCommand,
+    setupCommand
+  ])
 );
-var cli = import_cli8.Command.run(gigadrive, {
+var cli = import_cli15.Command.run(gigadrive, {
   name: "Gigadrive CLI",
-  version: "2.0.0"
+  version: package_default.version
 });
-var BaseServices = import_effect17.Layer.mergeAll(
+var BaseServices = import_effect29.Layer.mergeAll(
   OAuthConfigService.Default,
   AuthStorageService.Default,
   PackageManagerService.Default,
   ArchiveService.Default,
   import_network_config2.NetworkConfigLive,
-  ProjectConfigService.Default
-).pipe(import_effect17.Layer.provideMerge(AuthService.Default));
-var DeploymentApiLive = import_effect17.Layer.provide(DeploymentApiService.Default, BaseServices);
-var ServicesLive = import_effect17.Layer.mergeAll(BaseServices, DeploymentApiLive);
-var AppLive = import_effect17.Layer.mergeAll(ServicesLive, import_effect17.Logger.minimumLogLevel(import_effect17.LogLevel.Info)).pipe(
-  import_effect17.Layer.provideMerge(import_platform_node.NodeContext.layer)
-);
-import_platform_node.NodeRuntime.runMain(import_effect17.Effect.provide(cli(process.argv), AppLive));
+  ProjectConfigService.Default,
+  ProjectLinkService.Default,
+  EnvFileService.Default,
+  DevCredentialsStore.Default
+).pipe(import_effect29.Layer.provideMerge(AuthService.Default));
+var ApiClientLive = import_effect29.Layer.provide(ApiClientService.Default, BaseServices);
+var DeploymentApiLive = import_effect29.Layer.provide(DeploymentApiService.Default, BaseServices);
+var LocalCredentialsLive = import_effect29.Layer.provide(LocalCredentialsService.Default, BaseServices);
+var ServicesLive = import_effect29.Layer.mergeAll(BaseServices, ApiClientLive, DeploymentApiLive, LocalCredentialsLive);
+var AppLive = import_effect29.Layer.mergeAll(ServicesLive, import_effect29.Logger.minimumLogLevel(import_effect29.LogLevel.Info)).pipe(
+  import_effect29.Layer.provideMerge(import_platform_node.NodeContext.layer)
+);
+import_platform_node.NodeRuntime.runMain(import_effect29.Effect.provide(cli(process.argv), AppLive));
 //# sourceMappingURL=index.cjs.map