gigadrive 1.1.2 → 2.1.0

package/dist/index.mjs

@@ -1,725 +1,1552 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command } from "commander";
+import { Command as Command8 } from "@effect/cli";
+import { NodeContext, NodeRuntime } from "@effect/platform-node";
+import { NetworkConfigLive as NetworkConfigLive2 } from "@gigadrive/network-config";
+import { Effect as Effect15, Layer, LogLevel, Logger } from "effect";
 
 // src/commands/build/index.ts
+import { Command } from "@effect/cli";
+import { FileSystem as FileSystem2, Path as Path2 } from "@effect/platform";
 import { exec as exec2 } from "@gigadrive/build-utils";
-import fs2 from "fs";
-import path2 from "path";
+import { Console, Effect as Effect2 } from "effect";
 
-// src/util/pm.ts
-import fs from "fs";
-import path from "path";
-
-// ../build-utils/src/exec.ts
-import { spawn } from "child_process";
-async function exec({
-  command,
-  cwd = process.cwd(),
-  env,
-  onOutput = (data) => console.log(data),
-  onError = (data) => console.error(data)
+// src/errors.ts
+import { Schema } from "effect";
+var OAuthDiscoveryError = class extends Schema.TaggedError()("OAuthDiscoveryError", {
+  message: Schema.String,
+  cause: Schema.optional(Schema.String)
 }) {
-  return new Promise((resolve, reject) => {
-    let spawnCommand;
-    let spawnArgs = [];
-    if (typeof command === "string") {
-      const parts = command.split(" ");
-      spawnCommand = parts[0];
-      spawnArgs = parts.slice(1);
-    } else {
-      spawnCommand = command.command;
-      spawnArgs = command.args || [];
-    }
-    const childProcess = spawn(spawnCommand, spawnArgs, {
-      cwd,
-      shell: true,
-      env
-    });
-    childProcess.stdout.on("data", (data) => {
-      onOutput(data.toString().trim());
-    });
-    childProcess.stderr.on("data", (data) => {
-      onError(data.toString().trim());
-    });
-    childProcess.on("error", (error2) => {
-      reject(new Error(`Failed to start process: ${error2.message}`));
-    });
-    childProcess.on("close", (code) => {
-      if (code === 0) {
-        resolve();
-      } else {
-        reject(new Error(`Process exited with code ${code}`));
-      }
-    });
-  });
-}
-
-// src/util/pm.ts
-var getPackageManager = async ({ cwd }) => {
-  const packageJsonPath = path.join(cwd, "package.json");
-  if (!fs.existsSync(packageJsonPath)) {
-    return null;
-  }
-  if (fs.existsSync(path.join(cwd, "yarn.lock"))) {
-    return "yarn";
-  }
-  if (fs.existsSync(path.join(cwd, "pnpm-lock.yaml"))) {
-    return "pnpm";
+};
+var AuthStorageReadError = class extends Schema.TaggedError()("AuthStorageReadError", {
+  message: Schema.String
+}) {
+};
+var AuthStorageWriteError = class extends Schema.TaggedError()("AuthStorageWriteError", {
+  message: Schema.String,
+  cause: Schema.optional(Schema.String)
+}) {
+};
+var LoginFlowError = class extends Schema.TaggedError()("LoginFlowError", {
+  message: Schema.String,
+  cause: Schema.optional(Schema.String)
+}) {
+};
+var TokenExchangeError = class extends Schema.TaggedError()("TokenExchangeError", {
+  message: Schema.String,
+  statusCode: Schema.optional(Schema.Number)
+}) {
+};
+var TokenRefreshError = class extends Schema.TaggedError()("TokenRefreshError", {
+  message: Schema.String,
+  statusCode: Schema.optional(Schema.Number)
+}) {
+};
+var NotAuthenticatedError = class extends Schema.TaggedError()("NotAuthenticatedError", {
+  message: Schema.String
+}) {
+};
+var UserInfoFetchError = class extends Schema.TaggedError()("UserInfoFetchError", {
+  message: Schema.String,
+  statusCode: Schema.optional(Schema.Number)
+}) {
+};
+var ConfigNotFoundError = class extends Schema.TaggedError()("ConfigNotFoundError", {
+  message: Schema.String,
+  directory: Schema.String
+}) {
+};
+var ConfigParseError = class extends Schema.TaggedError()("ConfigParseError", {
+  message: Schema.String,
+  cause: Schema.optional(Schema.String)
+}) {
+};
+var ConfigValidationError = class extends Schema.TaggedError()("ConfigValidationError", {
+  message: Schema.String,
+  errors: Schema.Array(Schema.String)
+}) {
+};
+var PackageJsonNotFoundError = class extends Schema.TaggedError()(
+  "PackageJsonNotFoundError",
+  {
+    message: Schema.String,
+    directory: Schema.String
   }
-  if (fs.existsSync(path.join(cwd, "bun.lockb"))) {
-    return "bun";
+) {
+};
+var PackageJsonParseError = class extends Schema.TaggedError()("PackageJsonParseError", {
+  message: Schema.String,
+  directory: Schema.String,
+  cause: Schema.optional(Schema.String)
+}) {
+};
+var BuildScriptNotFoundError = class extends Schema.TaggedError()(
+  "BuildScriptNotFoundError",
+  {
+    message: Schema.String
   }
-  if (fs.existsSync(path.join(cwd, "package-lock.json"))) {
-    return "npm";
+) {
+};
+var PackageManagerNotFoundError = class extends Schema.TaggedError()(
+  "PackageManagerNotFoundError",
+  {
+    message: Schema.String,
+    directory: Schema.String
   }
-  try {
-    await exec({ command: "bun --version", cwd });
-    return "bun";
-  } catch {
-    return "npm";
+) {
+};
+var ExecError = class extends Schema.TaggedError()("ExecError", {
+  message: Schema.String,
+  command: Schema.String,
+  cause: Schema.optional(Schema.String)
+}) {
+};
+var DeploymentCreateError = class extends Schema.TaggedError()("DeploymentCreateError", {
+  message: Schema.String,
+  statusCode: Schema.optional(Schema.Number)
+}) {
+};
+var UploadStartError = class extends Schema.TaggedError()("UploadStartError", {
+  message: Schema.String,
+  statusCode: Schema.optional(Schema.Number)
+}) {
+};
+var PresignedUrlError = class extends Schema.TaggedError()("PresignedUrlError", {
+  message: Schema.String,
+  partNumber: Schema.Number
+}) {
+};
+var UploadPartError = class extends Schema.TaggedError()("UploadPartError", {
+  message: Schema.String,
+  partNumber: Schema.Number
+}) {
+};
+var UploadCompleteError = class extends Schema.TaggedError()("UploadCompleteError", {
+  message: Schema.String
+}) {
+};
+var DeploymentStatusError = class extends Schema.TaggedError()("DeploymentStatusError", {
+  message: Schema.String
+}) {
+};
+var DeploymentLogsFetchError = class extends Schema.TaggedError()(
+  "DeploymentLogsFetchError",
+  {
+    message: Schema.String
   }
+) {
 };
-var installCommand = (pm) => {
-  return {
-    bun: "bun install",
-    npm: "npm install",
-    pnpm: "pnpm install",
-    yarn: "yarn install"
-  }[pm] || "npm install";
-};
-var buildCommand = (pm) => {
-  return {
-    bun: "bun run build",
-    npm: "npm run build",
-    pnpm: "pnpm build",
-    yarn: "yarn build"
-  }[pm] || "npm run build";
+var ArchiveCreateError = class extends Schema.TaggedError()("ArchiveCreateError", {
+  message: Schema.String,
+  cause: Schema.optional(Schema.String)
+}) {
+};
+var DeploymentAuthError = class extends Schema.TaggedError()("DeploymentAuthError", {
+  message: Schema.String
+}) {
+};
+var DeploymentFailedError = class extends Schema.TaggedError()("DeploymentFailedError", {
+  message: Schema.String
+}) {
+};
+
+// src/services/package-manager.ts
+import { FileSystem, Path } from "@effect/platform";
+import { exec } from "@gigadrive/build-utils";
+import { Effect } from "effect";
+var PackageManagerService = class extends Effect.Service()("PackageManagerService", {
+  accessors: true,
+  effect: Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const pathService = yield* Path.Path;
+    const detect = Effect.fn("PackageManagerService.detect")(function* (cwd) {
+      yield* Effect.annotateCurrentSpan("cwd", cwd);
+      const packageJsonPath = pathService.join(cwd, "package.json");
+      const exists = yield* fs.exists(packageJsonPath).pipe(
+        Effect.mapError(
+          () => new PackageManagerNotFoundError({ message: "Failed to check for package.json", directory: cwd })
+        )
+      );
+      if (!exists) {
+        return yield* 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(Effect.catchAll(() => Effect.succeed(false)));
+        if (lockExists) {
+          yield* Effect.log("Package manager detected from lock file", { packageManager: pm2, lockFile: file });
+          return pm2;
+        }
+      }
+      const bunAvailable = yield* Effect.tryPromise({
+        try: () => exec({ command: "bun --version", cwd }),
+        catch: () => new ExecError({ message: "bun not found", command: "bun --version" })
+      }).pipe(
+        Effect.as(true),
+        Effect.catchTag("ExecError", () => Effect.succeed(false))
+      );
+      const pm = bunAvailable ? "bun" : "npm";
+      yield* 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 build = (parent) => {
-  parent.command("build").description("Build the current project").action(async () => {
-    const env = {
+var buildCommand = Command.make(
+  "build",
+  {},
+  () => Effect2.gen(function* () {
+    const pmService = yield* PackageManagerService;
+    const fs = yield* FileSystem2.FileSystem;
+    const pathService = yield* Path2.Path;
+    const cwd = process.cwd();
+    yield* Effect2.log("Starting build", { cwd });
+    const packageJsonPath = pathService.join(cwd, "package.json");
+    const packageJsonExists = yield* fs.exists(packageJsonPath).pipe(
+      Effect2.mapError(
+        () => new PackageJsonNotFoundError({ message: "Failed to check for package.json", directory: cwd })
+      )
+    );
+    if (!packageJsonExists) {
+      return yield* Effect2.fail(new PackageJsonNotFoundError({ message: "No package.json found", directory: cwd }));
+    }
+    const packageJsonContent = yield* fs.readFileString(packageJsonPath, "utf-8").pipe(
+      Effect2.mapError(() => new PackageJsonNotFoundError({ message: "Failed to read package.json", directory: cwd }))
+    );
+    const packageJson = yield* Effect2.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* Effect2.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",
-      // Vercel compatibility
       NOW_BUILDER: "1"
     };
-    const cwd = process.cwd();
-    const packageJsonPath = path2.join(cwd, "package.json");
-    if (!fs2.existsSync(packageJsonPath)) {
-      console.log("No package.json found");
-      return;
-    }
-    const packageJson = JSON.parse(fs2.readFileSync(packageJsonPath, "utf-8"));
-    const buildScript = packageJson.scripts?.build;
-    if (!buildScript) {
-      console.log("No build script found in package.json");
-      return;
-    }
-    const packageManager = await getPackageManager({ cwd });
-    if (!packageManager) {
-      console.log("No package manager found");
-      return;
-    }
-    await exec2({
-      command: installCommand(packageManager),
-      cwd,
-      env,
-      onOutput: (chunk) => {
-        console.log(chunk);
-      }
+    const installCmd = pmService.installCommand(pm);
+    yield* Console.log(`Running: ${installCmd}`);
+    yield* Effect2.tryPromise({
+      try: () => exec2({
+        command: installCmd,
+        cwd,
+        env: buildEnv,
+        onOutput: (chunk) => {
+          Console.log(chunk).pipe(Effect2.runSync);
+        }
+      }),
+      catch: (error) => new ExecError({
+        message: "Install failed",
+        command: installCmd,
+        cause: error instanceof Error ? error.message : String(error)
+      })
     });
-    await exec2({
-      command: buildCommand(packageManager),
-      cwd,
-      env,
-      onOutput: (chunk) => {
-        console.log(chunk);
+    const buildCmd = pmService.buildCommand(pm);
+    yield* Console.log(`Running: ${buildCmd}`);
+    yield* Effect2.tryPromise({
+      try: () => exec2({
+        command: buildCmd,
+        cwd,
+        env: buildEnv,
+        onOutput: (chunk) => {
+          Console.log(chunk).pipe(Effect2.runSync);
+        }
+      }),
+      catch: (error) => new ExecError({
+        message: "Build failed",
+        command: buildCmd,
+        cause: error instanceof Error ? error.message : String(error)
+      })
+    });
+    yield* Console.log("Build completed successfully.");
+  }).pipe(
+    Effect2.catchTags({
+      PackageJsonNotFoundError: (err) => Console.error(err.message).pipe(Effect2.andThen(Effect2.fail(err))),
+      PackageJsonParseError: (err) => Console.error(err.message).pipe(Effect2.andThen(Effect2.fail(err))),
+      BuildScriptNotFoundError: (err) => Console.error(err.message).pipe(Effect2.andThen(Effect2.fail(err))),
+      PackageManagerNotFoundError: (err) => Console.error(err.message).pipe(Effect2.andThen(Effect2.fail(err))),
+      ExecError: (err) => Console.error(`${err.message}: ${err.cause ?? err.command}`).pipe(Effect2.andThen(Effect2.fail(err)))
+    })
+  )
+);
+
+// src/commands/debug/index.ts
+import { Command as Command3 } from "@effect/cli";
+import { Effect as Effect5 } from "effect";
+
+// src/commands/debug/config/index.ts
+import { Command as Command2 } from "@effect/cli";
+import { Console as Console2, Effect as Effect4 } from "effect";
+
+// src/services/project-config.ts
+import {
+  detectFramework,
+  mergeWithFrameworkDefaults,
+  NetworkConfigLive,
+  parseConfig,
+  parseConfigRaw,
+  postProcessConfig,
+  RawConfigReader
+} from "@gigadrive/network-config";
+import { Effect as Effect3 } from "effect";
+var wrapParseErrors = (effect) => effect.pipe(
+  Effect3.catchTags({
+    ConfigFileNotFoundError: (e) => Effect3.fail(new ConfigParseError({ message: e.message, cause: e.filePath })),
+    ConfigFileEmptyError: (e) => Effect3.fail(new ConfigParseError({ message: e.message, cause: e.filePath })),
+    ConfigFileParseError: (e) => Effect3.fail(new ConfigParseError({ message: e.message, cause: e.cause })),
+    ConfigVersionError: (e) => Effect3.fail(new ConfigParseError({ message: e.message, cause: e.filePath })),
+    ConfigSchemaValidationError: (e) => Effect3.fail(new ConfigParseError({ message: e.message, cause: e.validationErrors.join(", ") })),
+    FunctionConfigError: (e) => Effect3.fail(new ConfigParseError({ message: e.message, cause: e.functionPath }))
+  })
+);
+var ProjectConfigService = class extends Effect3.Service()("ProjectConfigService", {
+  accessors: true,
+  dependencies: [NetworkConfigLive],
+  effect: Effect3.gen(function* () {
+    const rawReader = yield* RawConfigReader;
+    const resolve = Effect3.fn("ProjectConfigService.resolve")(function* (cwd) {
+      yield* Effect3.annotateCurrentSpan("cwd", cwd);
+      yield* Effect3.log("Resolving project config", { cwd });
+      const configPath = yield* rawReader.findConfig(cwd);
+      const detection = yield* detectFramework(cwd).pipe(
+        Effect3.catchTag("FrameworkNotDetectedError", () => Effect3.succeed(null)),
+        Effect3.catchTag(
+          "ManifestReadError",
+          (e) => Effect3.fail(new ConfigParseError({ message: `Framework detection failed: ${e.message}`, cause: e.filePath }))
+        ),
+        Effect3.catchTag(
+          "ManifestParseError",
+          (e) => Effect3.fail(new ConfigParseError({ message: `Framework detection failed: ${e.message}`, cause: e.filePath }))
+        )
+      );
+      if (detection) {
+        yield* Effect3.log("Framework auto-detected", {
+          framework: detection.framework.name,
+          slug: detection.framework.slug
+        });
       }
+      let config;
+      let resolvedConfigPath = null;
+      let framework;
+      if (configPath && detection) {
+        yield* Effect3.log("Config file found, merging with framework defaults", { configPath });
+        resolvedConfigPath = configPath;
+        const userConfig = yield* wrapParseErrors(parseConfigRaw(configPath, cwd));
+        const merged = yield* mergeWithFrameworkDefaults(userConfig, detection.config);
+        config = yield* wrapParseErrors(postProcessConfig(merged, cwd));
+        framework = { name: detection.framework.name, slug: detection.framework.slug };
+      } else if (configPath) {
+        yield* Effect3.log("Config file found", { configPath });
+        resolvedConfigPath = configPath;
+        config = yield* wrapParseErrors(parseConfig(configPath, cwd));
+      } else if (detection) {
+        config = yield* wrapParseErrors(postProcessConfig(detection.config, cwd));
+        framework = { name: detection.framework.name, slug: detection.framework.slug };
+      } else {
+        return yield* Effect3.fail(
+          new ConfigNotFoundError({
+            message: "No config file found and no framework detected.",
+            directory: cwd
+          })
+        );
+      }
+      for (const warning of config.warnings) {
+        yield* Effect3.logWarning(warning);
+      }
+      if (config.errors.length > 0) {
+        return yield* Effect3.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
-import { findConfig, parseConfig } from "@gigadrive/network-config";
-import { log as log2 } from "console";
+var debugConfigCommand = Command2.make(
+  "config",
+  {},
+  () => Effect4.gen(function* () {
+    const projectConfig = yield* ProjectConfigService;
+    const cwd = process.cwd();
+    const { config, configPath } = yield* projectConfig.resolve(cwd);
+    yield* Console2.log(`Config file found at: ${configPath}`);
+    yield* Console2.log(JSON.stringify(config, null, 2));
+  }).pipe(
+    Effect4.catchTags({
+      ConfigNotFoundError: (err) => Console2.error(err.message),
+      ConfigParseError: (err) => Console2.error(`Config parse error: ${err.message}`),
+      ConfigValidationError: (err) => Effect4.gen(function* () {
+        for (const e of err.errors) {
+          yield* Console2.error(e);
+        }
+        yield* Console2.error(err.message);
+      })
+    })
+  )
+);
 
-// src/util/log.ts
-import { createConsola } from "consola";
-var verbose = false;
-var consola = createConsola({
-  level: verbose ? 4 : 3,
-  // 4 includes debug messages, 3 is the default (info and above)
-  formatOptions: {
-    colors: true
-  }
+// src/commands/debug/index.ts
+var debugBase = Command3.make("debug", {}, () => Effect5.void);
+var debugCommand = debugBase.pipe(Command3.withSubcommands([debugConfigCommand]));
+
+// src/commands/login/index.ts
+import { Command as Command4 } from "@effect/cli";
+import { Console as Console4, Effect as Effect9 } from "effect";
+
+// src/services/auth.ts
+import { Console as Console3, Effect as Effect8, Option as Option2 } from "effect";
+import * as crypto from "crypto";
+import * as http from "http";
+import open from "open";
+
+// src/services/auth-storage.ts
+import { FileSystem as FileSystem3, Path as Path3 } from "@effect/platform";
+import { Effect as Effect6, Option, Schema as Schema3 } from "effect";
+import * as os from "os";
+
+// src/domain.ts
+import { Schema as Schema2 } from "effect";
+var DeploymentId = Schema2.String.pipe(Schema2.brand("@Gigadrive/DeploymentId"));
+var ApplicationId = Schema2.String.pipe(Schema2.brand("@Gigadrive/ApplicationId"));
+var UploadId = Schema2.String.pipe(Schema2.brand("@Gigadrive/UploadId"));
+var DeploymentStatus = Schema2.Literal("PENDING", "BUILDING", "PROVISIONING", "FAILED", "ACTIVE", "SUSPENDED");
+var DeploymentLogType = Schema2.Literal("INFO", "ERROR", "WARN");
+var DeploymentLog = Schema2.Struct({
+  id: Schema2.String,
+  message: Schema2.String,
+  type: DeploymentLogType,
+  createdAt: Schema2.String
 });
-var updateConsola = () => {
-  consola.level = verbose ? 4 : 3;
-};
-var setVerbose = (value) => {
-  verbose = value;
-  updateConsola();
-};
-var log = (message) => {
-  consola.info(message);
-};
-var error = (message) => {
-  consola.error(message);
-};
-var success = (message) => {
-  consola.success(message);
+var DeploymentLogPage = Schema2.Struct({
+  totalItems: Schema2.Number,
+  limit: Schema2.Number,
+  offset: Schema2.Number,
+  items: Schema2.Array(DeploymentLog)
+});
+var PackageManager = Schema2.Literal("npm", "yarn", "pnpm", "bun");
+var OAuthTokens = Schema2.Struct({
+  access_token: Schema2.String,
+  refresh_token: Schema2.optional(Schema2.String),
+  expires_in: Schema2.optional(Schema2.Number),
+  token_type: Schema2.optional(Schema2.String)
+});
+var OAuthClientConfig = Schema2.Struct({
+  clientId: Schema2.String,
+  issuer: Schema2.String,
+  authorizeUrl: Schema2.String,
+  tokenUrl: Schema2.String,
+  scope: Schema2.String,
+  userinfoUrl: Schema2.String
+});
+var StoredAuthData = Schema2.Struct({
+  refreshToken: Schema2.String,
+  accessToken: Schema2.optional(Schema2.String),
+  tokenExpirationTime: Schema2.optional(Schema2.Number)
+});
+
+// src/services/auth-storage.ts
+var AuthStorageService = class extends Effect6.Service()("AuthStorageService", {
+  accessors: true,
+  effect: Effect6.gen(function* () {
+    const fs = yield* FileSystem3.FileSystem;
+    const pathService = yield* Path3.Path;
+    const homeDir = os.homedir();
+    const authDir = pathService.join(homeDir, ".gigadrive");
+    const authFile = pathService.join(authDir, "auth.json");
+    const ensureDirectory = Effect6.gen(function* () {
+      yield* fs.makeDirectory(authDir, { recursive: true }).pipe(
+        Effect6.mapError(
+          (error) => new AuthStorageWriteError({
+            message: "Failed to create auth directory",
+            cause: String(error)
+          })
+        )
+      );
+      yield* fs.chmod(authDir, 448).pipe(
+        Effect6.mapError(
+          (error) => new AuthStorageWriteError({
+            message: "Failed to set auth directory permissions",
+            cause: String(error)
+          })
+        )
+      );
+    });
+    const load = Effect6.gen(function* () {
+      const exists = yield* fs.exists(authFile).pipe(Effect6.mapError(() => new AuthStorageReadError({ message: "Failed to check auth file existence" })));
+      if (!exists) return Option.none();
+      const data = yield* fs.readFileString(authFile, "utf8").pipe(Effect6.mapError(() => new AuthStorageReadError({ message: "Failed to read auth file" })));
+      const json = yield* Effect6.try({
+        try: () => JSON.parse(data),
+        catch: () => new AuthStorageReadError({ message: "Auth file contains invalid JSON" })
+      });
+      const authData = yield* Schema3.decodeUnknown(StoredAuthData)(json).pipe(
+        Effect6.mapError(() => new AuthStorageReadError({ message: "Auth file has invalid schema" }))
+      );
+      return Option.some(authData);
+    });
+    const save = Effect6.fn("AuthStorageService.save")(function* (authData) {
+      yield* ensureDirectory;
+      yield* fs.writeFileString(authFile, JSON.stringify(authData, null, 2), { mode: 384 }).pipe(
+        Effect6.mapError(
+          (error) => new AuthStorageWriteError({
+            message: "Failed to write auth file",
+            cause: String(error)
+          })
+        )
+      );
+      yield* Effect6.log("Auth data saved to local storage");
+    });
+    const remove = Effect6.gen(function* () {
+      yield* fs.remove(authFile).pipe(
+        Effect6.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 };
+        }),
+        Effect6.catchAll(
+          (mapped) => mapped.isNotFound ? Effect6.void : Effect6.fail(
+            new AuthStorageWriteError({
+              message: "Failed to remove auth file",
+              cause: String(mapped.original)
+            })
+          )
+        )
+      );
+      yield* Effect6.log("Auth data removed from local storage");
+    });
+    return { load, save, remove };
+  })
+}) {
 };
-var warn = (message) => {
-  consola.warn(message);
+
+// src/services/oauth-config.ts
+import { Config, Effect as Effect7, Schema as Schema4 } from "effect";
+var OAuthEnvConfig = Config.all({
+  issuerUrl: Config.string("GIGADRIVE_NETWORK_OAUTH_ISSUER_URL").pipe(Config.withDefault("https://idp.gigadrive.de")),
+  clientId: Config.string("GIGADRIVE_NETWORK_OAUTH_CLIENT_ID").pipe(Config.withDefault("todo_add_client_id"))
+});
+var OpenIdDiscoveryDocument = Schema4.Struct({
+  issuer: Schema4.optional(Schema4.String),
+  authorization_endpoint: Schema4.optional(Schema4.String),
+  token_endpoint: Schema4.optional(Schema4.String),
+  userinfo_endpoint: Schema4.optional(Schema4.String)
+});
+var DEFAULT_SCOPE = "offline_access openid profile email";
+var OAuthConfigService = class extends Effect7.Service()("OAuthConfigService", {
+  accessors: true,
+  effect: Effect7.gen(function* () {
+    const envConfig = yield* OAuthEnvConfig;
+    let cached = null;
+    const getConfig = Effect7.gen(function* () {
+      if (cached) return cached;
+      const issuerBase = envConfig.issuerUrl.replace(/\/$/, "");
+      const discoveryUrl = `${issuerBase}/.well-known/openid-configuration`;
+      yield* Effect7.log("Fetching OIDC discovery document", { discoveryUrl });
+      const response = yield* Effect7.tryPromise({
+        try: (signal) => fetch(discoveryUrl, { signal }),
+        catch: (error) => new OAuthDiscoveryError({
+          message: "Failed to fetch OIDC discovery document",
+          cause: error instanceof Error ? error.message : String(error)
+        })
+      });
+      if (!response.ok) {
+        return yield* Effect7.fail(
+          new OAuthDiscoveryError({
+            message: `OIDC discovery returned ${response.status} ${response.statusText}`
+          })
+        );
+      }
+      const json = yield* Effect7.tryPromise({
+        try: () => response.json(),
+        catch: () => new OAuthDiscoveryError({
+          message: "Failed to parse OIDC discovery JSON"
+        })
+      });
+      const decoded = yield* Schema4.decodeUnknown(OpenIdDiscoveryDocument)(json).pipe(
+        Effect7.mapError(
+          () => new OAuthDiscoveryError({
+            message: "Invalid OIDC discovery document schema"
+          })
+        )
+      );
+      if (!decoded.authorization_endpoint || !decoded.token_endpoint || !decoded.userinfo_endpoint) {
+        return yield* Effect7.fail(
+          new OAuthDiscoveryError({
+            message: "OIDC discovery returned incomplete endpoints"
+          })
+        );
+      }
+      const config = {
+        clientId: envConfig.clientId,
+        issuer: decoded.issuer ?? issuerBase,
+        authorizeUrl: decoded.authorization_endpoint,
+        tokenUrl: decoded.token_endpoint,
+        scope: DEFAULT_SCOPE,
+        userinfoUrl: decoded.userinfo_endpoint
+      };
+      cached = config;
+      yield* Effect7.log("OIDC discovery completed", { issuer: config.issuer });
+      return config;
+    });
+    return { getConfig };
+  })
+}) {
 };
-var debug = (message, ...optionalParams) => {
-  if (!verbose) {
-    return;
-  }
-  consola.debug("[DEBUG]", message, ...optionalParams);
+
+// src/services/auth.ts
+var escapeHtml = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;").replace(/\//g, "&#x2F;");
+var base64URLEncode = (buffer) => buffer.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+var generatePKCE = () => {
+  const codeVerifier = base64URLEncode(crypto.randomBytes(64));
+  const challengeBytes = crypto.createHash("sha256").update(codeVerifier, "utf8").digest();
+  const codeChallenge = base64URLEncode(challengeBytes);
+  return { codeVerifier, codeChallenge };
 };
-var spinner = (message) => {
-  log(message);
+var AuthService = class extends Effect8.Service()("AuthService", {
+  accessors: true,
+  dependencies: [OAuthConfigService.Default, AuthStorageService.Default],
+  effect: Effect8.gen(function* () {
+    const oauthConfig = yield* OAuthConfigService;
+    const storage = yield* AuthStorageService;
+    let accessToken = null;
+    let tokenExpirationTime = 0;
+    const logout = Effect8.gen(function* () {
+      accessToken = null;
+      tokenExpirationTime = 0;
+      yield* storage.remove;
+      yield* Effect8.log("Logged out");
+    });
+    const exchangeCodeForTokens = (config, authCode, redirectUri, codeVerifier) => Effect8.gen(function* () {
+      const response = yield* Effect8.tryPromise({
+        try: () => fetch(config.tokenUrl, {
+          method: "POST",
+          headers: { "Content-Type": "application/x-www-form-urlencoded" },
+          body: new URLSearchParams({
+            grant_type: "authorization_code",
+            client_id: config.clientId,
+            code: authCode,
+            redirect_uri: redirectUri,
+            code_verifier: codeVerifier
+          }).toString()
+        }),
+        catch: (error) => new TokenExchangeError({
+          message: `Token exchange request failed: ${error instanceof Error ? error.message : String(error)}`
+        })
+      });
+      if (!response.ok) {
+        const body = yield* Effect8.tryPromise({
+          try: () => response.text(),
+          catch: () => new TokenExchangeError({ message: "Failed to read token exchange error response" })
+        });
+        return yield* Effect8.fail(
+          new TokenExchangeError({
+            message: `Token exchange failed: ${response.status} ${response.statusText} - ${body}`,
+            statusCode: response.status
+          })
+        );
+      }
+      const tokens = yield* Effect8.tryPromise({
+        try: () => response.json(),
+        catch: () => new TokenExchangeError({ message: "Failed to parse token exchange response" })
+      });
+      return tokens;
+    });
+    const startCallbackServer = (config, codeChallenge, state) => Effect8.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(Effect8.fail(new LoginFlowError({ message: "Failed to determine callback server address" })));
+          });
+          return;
+        }
+        const port = address.port;
+        const redirectUri = `http://127.0.0.1:${port}${redirectPath}`;
+        const authUrl = new URL(config.authorizeUrl);
+        authUrl.searchParams.append("client_id", config.clientId);
+        authUrl.searchParams.append("redirect_uri", redirectUri);
+        authUrl.searchParams.append("response_type", "code");
+        authUrl.searchParams.append("scope", config.scope);
+        authUrl.searchParams.append("code_challenge", codeChallenge);
+        authUrl.searchParams.append("code_challenge_method", "S256");
+        authUrl.searchParams.append("state", state);
+        Console3.log(`Please open this URL in your browser to log in:
+${authUrl.toString()}
+`).pipe(Effect8.runSync);
+        Console3.log("Waiting for login callback...").pipe(Effect8.runSync);
+        void open(authUrl.toString());
+        server.on("request", (req, res) => {
+          const reqUrl = new URL(req.url || "", redirectUri);
+          if (reqUrl.pathname !== "/callback") {
+            res.writeHead(404).end("Not Found");
+            return;
+          }
+          const authCode = reqUrl.searchParams.get("code");
+          const receivedState = reqUrl.searchParams.get("state");
+          const oauthError = reqUrl.searchParams.get("error");
+          res.writeHead(200, { "Content-Type": "text/html", Connection: "close" });
+          if (oauthError) {
+            const safeOauthError = escapeHtml(oauthError);
+            res.end(`<h1>Login Failed!</h1><p>Error: ${safeOauthError}</p><p>You can close this tab.</p>`);
+            server.close();
+            resume(Effect8.fail(new LoginFlowError({ message: `OAuth error: ${oauthError}` })));
+            return;
+          }
+          if (receivedState !== state) {
+            res.end(
+              "<h1>Login Failed!</h1><p>State mismatch. Possible CSRF attack.</p><p>You can close this tab.</p>"
+            );
+            server.close();
+            resume(Effect8.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(Effect8.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(Effect8.fail(new LoginFlowError({ message: "No authorization code received" })));
+          }
+        });
+        server.on("error", (err) => {
+          server.close();
+          resume(Effect8.fail(new LoginFlowError({ message: `Local server error: ${err.message}` })));
+        });
+      });
+    });
+    const login = Effect8.gen(function* () {
+      yield* logout;
+      const { codeVerifier, codeChallenge } = generatePKCE();
+      const state = crypto.randomBytes(16).toString("hex");
+      const config = yield* oauthConfig.getConfig;
+      const { authCode, redirectUri } = yield* startCallbackServer(config, codeChallenge, state);
+      const tokens = yield* exchangeCodeForTokens(config, authCode, redirectUri, codeVerifier);
+      if (!tokens.refresh_token) {
+        return yield* Effect8.fail(
+          new TokenExchangeError({ message: "No refresh token received from identity provider" })
+        );
+      }
+      accessToken = tokens.access_token;
+      tokenExpirationTime = Date.now() + (tokens.expires_in || 3600) * 1e3;
+      yield* storage.save({
+        refreshToken: tokens.refresh_token,
+        accessToken,
+        tokenExpirationTime
+      });
+      yield* Effect8.log("Login successful");
+      return true;
+    });
+    const refreshAccessToken = Effect8.gen(function* () {
+      const stored = yield* storage.load.pipe(
+        Effect8.catchTag("AuthStorageReadError", (err) => Effect8.fail(new TokenRefreshError({ message: err.message })))
+      );
+      const config = yield* oauthConfig.getConfig.pipe(
+        Effect8.catchTag("OAuthDiscoveryError", (err) => Effect8.fail(new TokenRefreshError({ message: err.message })))
+      );
+      const authData = yield* Option2.match(stored, {
+        onNone: () => Effect8.fail(new TokenRefreshError({ message: "No refresh token available. Please log in." })),
+        onSome: (data) => data.refreshToken ? Effect8.succeed(data) : Effect8.fail(new TokenRefreshError({ message: "No refresh token available. Please log in." }))
+      });
+      const response = yield* Effect8.tryPromise({
+        try: () => fetch(config.tokenUrl, {
+          method: "POST",
+          headers: { "Content-Type": "application/x-www-form-urlencoded" },
+          body: new URLSearchParams({
+            grant_type: "refresh_token",
+            client_id: config.clientId,
+            refresh_token: authData.refreshToken
+          }).toString()
+        }),
+        catch: (error) => new TokenRefreshError({
+          message: `Token refresh request failed: ${error instanceof Error ? error.message : String(error)}`
+        })
+      });
+      if (!response.ok) {
+        if (response.status === 400) {
+          yield* logout.pipe(Effect8.catchAll(() => Effect8.void));
+          return yield* Effect8.fail(
+            new TokenRefreshError({
+              message: "Refresh token is invalid or expired. Please log in again.",
+              statusCode: response.status
+            })
+          );
+        }
+        const body = yield* Effect8.tryPromise({
+          try: () => response.text(),
+          catch: () => new TokenRefreshError({ message: "Failed to read refresh error response" })
+        });
+        return yield* Effect8.fail(
+          new TokenRefreshError({
+            message: `Token refresh failed: ${response.status} ${response.statusText} - ${body}`,
+            statusCode: response.status
+          })
+        );
+      }
+      const tokens = yield* Effect8.tryPromise({
+        try: () => response.json(),
+        catch: () => new TokenRefreshError({ message: "Failed to parse token refresh response" })
+      });
+      accessToken = tokens.access_token;
+      tokenExpirationTime = Date.now() + (tokens.expires_in || 3600) * 1e3;
+      const newRefreshToken = tokens.refresh_token || authData.refreshToken;
+      yield* storage.save({
+        refreshToken: newRefreshToken,
+        accessToken,
+        tokenExpirationTime
+      }).pipe(Effect8.catchAll(() => Effect8.void));
+      yield* Effect8.log("Access token refreshed successfully");
+      return true;
+    });
+    const getAccessToken = Effect8.gen(function* () {
+      if (accessToken && Date.now() < tokenExpirationTime) {
+        return accessToken;
+      }
+      const stored = yield* storage.load.pipe(
+        Effect8.catchAll(() => Effect8.succeed(Option2.none()))
+      );
+      Option2.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* Effect8.log("Access token expired or not available. Attempting to refresh...");
+      yield* refreshAccessToken.pipe(
+        Effect8.catchTag("TokenRefreshError", (err) => Effect8.fail(new NotAuthenticatedError({ message: err.message })))
+      );
+      if (!accessToken) {
+        return yield* Effect8.fail(
+          new NotAuthenticatedError({ message: "No valid access token available. Please log in first." })
+        );
+      }
+      return accessToken;
+    });
+    const getUserInfo = Effect8.gen(function* () {
+      const config = yield* oauthConfig.getConfig;
+      const token = yield* getAccessToken;
+      const fetchUserInfo = (t) => Effect8.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(
+          Effect8.catchTag("TokenRefreshError", (err) => Effect8.fail(new UserInfoFetchError({ message: err.message })))
+        );
+        if (!accessToken) {
+          return yield* Effect8.fail(new UserInfoFetchError({ message: "Token refresh failed" }));
+        }
+        response = yield* fetchUserInfo(accessToken);
+      }
+      if (!response.ok) {
+        const body = yield* Effect8.tryPromise({
+          try: () => response.text(),
+          catch: () => new UserInfoFetchError({ message: "Failed to read user info error response" })
+        });
+        return yield* Effect8.fail(
+          new UserInfoFetchError({
+            message: `Failed to fetch user info: ${response.status} ${response.statusText}${body ? ` - ${body}` : ""}`,
+            statusCode: response.status
+          })
+        );
+      }
+      const data = yield* Effect8.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/commands/debug/config/index.ts
-var config = (parent) => {
-  parent.command("config").description("Provide debug info about the project configuration in the current directory").action(async () => {
-    const configPath = findConfig(process.cwd());
-    if (!configPath) {
-      debug("No config file found");
-      throw new Error("The current project folder does not have a valid config file.");
-    }
-    const config2 = await parseConfig(configPath, process.cwd());
-    log2(`Config file found at: ${configPath}`);
-    log2(JSON.stringify(config2, null, 2));
-  });
-};
+// src/commands/login/index.ts
+var loginCommand = Command4.make(
+  "login",
+  {},
+  () => Effect9.gen(function* () {
+    yield* Console4.log("Initiating login...");
+    const auth = yield* AuthService;
+    yield* auth.login;
+    const info = yield* auth.getUserInfo.pipe(Effect9.catchAll(() => Effect9.succeed({})));
+    const name = auth.inferUserName(info);
+    yield* Console4.log(`You are now logged in as ${name}.`);
+  }).pipe(
+    Effect9.catchTags({
+      LoginFlowError: (err) => Console4.error(`Login failed: ${err.message}`),
+      TokenExchangeError: (err) => Console4.error(`Login failed: ${err.message}`),
+      OAuthDiscoveryError: (err) => Console4.error(`Login failed: ${err.message}`),
+      AuthStorageWriteError: (err) => Console4.error(`Failed to save credentials: ${err.message}`)
+    })
+  )
+);
 
-// src/commands/debug/index.ts
-var debug2 = (program) => {
-  const debug3 = program.command("debug").description("Provides various debugging utilities");
-  config(debug3);
-};
+// src/commands/platform/index.ts
+import { Command as Command6 } from "@effect/cli";
+import { Effect as Effect13 } from "effect";
 
 // src/commands/platform/deploy/index.ts
-import { formatFileSize, objectToQueryString } from "@gigadrive/commons";
-import { findConfig as findConfig2, parseConfig as parseConfig2 } from "@gigadrive/network-config";
-import fs4 from "fs";
-import os from "os";
-import path4 from "path";
+import { Command as Command5 } from "@effect/cli";
+import { FileSystem as FileSystem5, Path as Path5 } from "@effect/platform";
+import { formatFileSize } from "@gigadrive/commons";
+import { Console as Console5, Duration, Effect as Effect12, Schedule, Stream } from "effect";
+import * as os2 from "os";
 
-// src/util/zip.ts
+// src/services/archive.ts
+import { FileSystem as FileSystem4, Path as Path4 } from "@effect/platform";
 import { getFilesForPattern } from "@gigadrive/build-utils";
 import archiver from "archiver";
-import fs3 from "fs";
-import fsPromises from "fs/promises";
+import { Effect as Effect10 } from "effect";
 import ignore from "ignore";
-import path3 from "path";
-var ignoreFileNames = [
-  /*'.gitignore', */
-  ".gigadriveignore",
-  ".vercelignore",
-  ".dockerignore",
-  ".nowignore"
-];
-async function readIgnoreFile(ignorePath) {
-  try {
-    await fsPromises.access(ignorePath);
-    const content = await fsPromises.readFile(ignorePath, "utf8");
-    return content.split("\n").filter((line) => line.trim() !== "");
-  } catch {
-    return [];
-  }
-}
-async function collectIgnorePatterns(dir, baseDir, ignoreRules) {
-  const items = await fsPromises.readdir(dir);
+import * as nodeFs from "fs";
+import * as nodeFsPromises from "fs/promises";
+var IGNORE_FILE_NAMES = [".gigadriveignore", ".vercelignore", ".dockerignore", ".nowignore"];
+var readIgnoreFile = (fs, ignorePath) => fs.readFileString(ignorePath, "utf8").pipe(
+  Effect10.map((content) => content.split("\n").filter((line) => line.trim() !== "")),
+  Effect10.catchAll(() => Effect10.succeed([]))
+);
+var collectIgnorePatterns = (fs, pathService, dir, baseDir, ignoreRules) => Effect10.gen(function* () {
+  const items = yield* fs.readDirectory(dir).pipe(Effect10.mapError(() => new ArchiveCreateError({ message: `Failed to read directory: ${dir}` })));
   for (const item of items) {
-    const fullPath = path3.join(dir, item);
-    const relativePath = path3.relative(baseDir, fullPath);
-    const stat = await fsPromises.lstat(fullPath);
+    const fullPath = pathService.join(dir, item);
+    const relativePath = pathService.relative(baseDir, fullPath);
+    const stat = yield* Effect10.tryPromise({
+      try: () => nodeFsPromises.lstat(fullPath),
+      catch: () => new ArchiveCreateError({ message: `Failed to stat: ${fullPath}` })
+    });
     if (stat.isDirectory()) {
-      if (ignoreRules.ignores(`${relativePath}/`)) {
-        continue;
-      }
-      for (const ignoreFileName of ignoreFileNames) {
-        const ignoreFilePath = path3.join(fullPath, ignoreFileName);
-        try {
-          await fsPromises.access(ignoreFilePath);
-          const patterns = (await readIgnoreFile(ignoreFilePath)).map((pattern) => {
-            return pattern.startsWith("!") ? `!${path3.join(relativePath, pattern.slice(1))}` : path3.join(relativePath, pattern);
-          });
-          ignoreRules.add(patterns);
-        } catch {
+      if (ignoreRules.ignores(`${relativePath}/`)) continue;
+      for (const ignoreFileName of IGNORE_FILE_NAMES) {
+        const ignoreFilePath = pathService.join(fullPath, ignoreFileName);
+        const patterns = yield* readIgnoreFile(fs, ignoreFilePath);
+        if (patterns.length > 0) {
+          ignoreRules.add(
+            patterns.map(
+              (pattern) => pattern.startsWith("!") ? `!${pathService.join(relativePath, pattern.slice(1))}` : pathService.join(relativePath, pattern)
+            )
+          );
         }
       }
-      await collectIgnorePatterns(fullPath, baseDir, ignoreRules);
+      yield* collectIgnorePatterns(fs, pathService, fullPath, baseDir, ignoreRules);
     }
   }
-}
-async function initializeIgnoreRules(baseDir) {
+}).pipe(Effect10.catchAll(() => Effect10.void));
+var initializeIgnoreRules = (fs, pathService, baseDir) => Effect10.gen(function* () {
   const ignoreRules = ignore();
   ignoreRules.add([".git/", "**/.DS_Store", "**/Thumbs.db"]);
-  for (const ignoreFileName of ignoreFileNames) {
-    const ignoreFilePath = path3.join(baseDir, ignoreFileName);
-    try {
-      await fsPromises.access(ignoreFilePath);
-      const patterns = (await readIgnoreFile(ignoreFilePath)).map((pattern) => {
-        return pattern.startsWith("!") ? `!${pattern.slice(1)}` : pattern;
-      });
-      ignoreRules.add(patterns);
-    } catch {
+  for (const ignoreFileName of IGNORE_FILE_NAMES) {
+    const ignoreFilePath = pathService.join(baseDir, ignoreFileName);
+    const patterns = yield* readIgnoreFile(fs, ignoreFilePath);
+    if (patterns.length > 0) {
+      ignoreRules.add(
+        patterns.map((pattern) => pattern.startsWith("!") ? `!${pattern.slice(1)}` : pattern)
+      );
     }
   }
-  await collectIgnorePatterns(baseDir, baseDir, ignoreRules);
+  yield* collectIgnorePatterns(fs, pathService, baseDir, baseDir, ignoreRules);
   return ignoreRules;
-}
-async function getFilesToInclude(dir, ignoreRules, whitelist) {
+});
+var getFilesToInclude = (fs, pathService, dir, ignoreRules) => Effect10.gen(function* () {
   const filesToInclude = [];
-  async function walkDir(currentDir) {
-    const items = await fsPromises.readdir(currentDir);
+  const walkDir = (currentDir) => Effect10.gen(function* () {
+    const items = yield* fs.readDirectory(currentDir).pipe(Effect10.mapError(() => new ArchiveCreateError({ message: `Failed to read directory: ${currentDir}` })));
     for (const item of items) {
-      const fullPath = path3.join(currentDir, item);
-      const relativePath = path3.relative(dir, fullPath);
-      const stat = await fsPromises.lstat(fullPath);
+      const fullPath = pathService.join(currentDir, item);
+      const relativePath = pathService.relative(dir, fullPath);
+      const stat = yield* Effect10.tryPromise({
+        try: () => nodeFsPromises.lstat(fullPath),
+        catch: () => new ArchiveCreateError({ message: `Failed to stat: ${fullPath}` })
+      });
       if (stat.isDirectory()) {
-        if (ignoreRules.ignores(`${relativePath}/`)) {
-          continue;
+        if (!ignoreRules.ignores(`${relativePath}/`)) {
+          yield* walkDir(fullPath);
         }
-        await walkDir(fullPath);
       } else {
         if (!ignoreRules.ignores(relativePath)) {
           filesToInclude.push(fullPath);
-        } else if (ignoreRules.ignores(relativePath) && ignoreRules.test(relativePath).unignored) {
-          filesToInclude.push(fullPath);
         }
       }
     }
-  }
-  await walkDir(dir);
+  }).pipe(Effect10.catchAll(() => Effect10.void));
+  yield* walkDir(dir);
   return filesToInclude;
-}
-async function createZipArchive(inputDir, outputFile, options = {}) {
-  const ignoreRules = options.useIgnoreFiles !== false ? await initializeIgnoreRules(inputDir) : ignore();
-  const filesToInclude = options.whitelist ? await Promise.all(options.whitelist.map((file) => getFilesForPattern(inputDir, file))) : await getFilesToInclude(inputDir, ignoreRules);
-  const output = fs3.createWriteStream(outputFile);
-  const archive = archiver("zip", { zlib: { level: 9 } });
-  return new Promise((resolve, reject) => {
-    output.on("close", () => resolve());
-    archive.on("error", reject);
-    archive.pipe(output);
-    for (const file of filesToInclude.flat()) {
-      archive.file(file, { name: path3.relative(inputDir, file) });
-    }
-    void archive.finalize();
-  });
-}
-
-// src/commands/platform/deploy/index.ts
-var deploy = (parent) => {
-  parent.command("deploy").description("Deploy the current project").action(async () => {
-    debug("Starting deploy command");
-    const configPath = findConfig2(process.cwd());
-    if (!configPath) {
-      debug("No config file found");
-      throw new Error("The current project folder does not have a valid config file.");
-    }
-    debug(`Found config at: ${configPath}`);
-    const config2 = await parseConfig2(configPath, process.cwd());
-    debug("Parsed config", config2);
-    if (config2.warnings.length > 0) {
-      debug(`Found ${config2.warnings.length} warnings in config`);
-      config2.warnings.forEach((message) => {
-        warn(message);
+});
+var ArchiveService = class extends Effect10.Service()("ArchiveService", {
+  accessors: true,
+  effect: Effect10.gen(function* () {
+    const fs = yield* FileSystem4.FileSystem;
+    const pathService = yield* Path4.Path;
+    const createZipArchive = Effect10.fn("ArchiveService.createZipArchive")(function* (inputDir, outputFile, options = {}) {
+      yield* Effect10.annotateCurrentSpan("inputDir", inputDir);
+      yield* Effect10.annotateCurrentSpan("outputFile", outputFile);
+      yield* Effect10.log("Creating zip archive", { inputDir, outputFile });
+      const ignoreRules = options.useIgnoreFiles !== false ? yield* initializeIgnoreRules(fs, pathService, inputDir) : ignore();
+      const filesToInclude = options.whitelist ? yield* Effect10.tryPromise({
+        try: () => Promise.all(
+          options.whitelist.map((file) => getFilesForPattern(file, inputDir, options.excludeFiles ?? []))
+        ),
+        catch: (error) => new ArchiveCreateError({
+          message: "Failed to resolve whitelist patterns",
+          cause: error instanceof Error ? error.message : String(error)
+        })
+      }) : yield* Effect10.gen(function* () {
+        if (options.excludeFiles && options.excludeFiles.length > 0) {
+          ignoreRules.add(options.excludeFiles);
+        }
+        return yield* getFilesToInclude(fs, pathService, inputDir, ignoreRules).pipe(
+          Effect10.map((files) => [files])
+        );
       });
-    }
-    if (config2.errors.length > 0) {
-      debug(`Found ${config2.errors.length} errors in config`);
-      config2.errors.forEach((message) => {
-        error(message);
+      const archiveExists = yield* fs.exists(outputFile).pipe(Effect10.catchAll(() => Effect10.succeed(false)));
+      if (archiveExists) {
+        yield* fs.remove(outputFile).pipe(
+          Effect10.mapError(
+            (error) => new ArchiveCreateError({
+              message: `Failed to remove existing archive: ${String(error)}`
+            })
+          )
+        );
+      }
+      yield* Effect10.tryPromise({
+        try: () => new Promise((resolve, reject) => {
+          const output = nodeFs.createWriteStream(outputFile);
+          const archive = archiver("zip", { zlib: { level: 9 } });
+          output.on("close", () => resolve());
+          output.on("error", reject);
+          archive.on("error", reject);
+          archive.pipe(output);
+          for (const file of filesToInclude.flat()) {
+            archive.file(file, { name: pathService.relative(inputDir, file) });
+          }
+          void archive.finalize();
+        }),
+        catch: (error) => new ArchiveCreateError({
+          message: "Failed to create zip archive",
+          cause: error instanceof Error ? error.message : String(error)
+        })
       });
-      throw new Error("The current project folder does not have a valid config file.");
-    }
-    debug("Creating deployment");
-    const deploymentId = await createDeployment({
-      applicationId: "test"
-      // TODO
+      const fileInfo = yield* fs.stat(outputFile).pipe(
+        Effect10.mapError(
+          (error) => new ArchiveCreateError({
+            message: `Failed to stat archive: ${String(error)}`
+          })
+        )
+      );
+      const size = Number(fileInfo.size);
+      yield* Effect10.log("Archive created", { size });
+      return { path: outputFile, size };
     });
-    debug(`Deployment ID: ${deploymentId}`);
-    debug("Starting deployment process");
-    await handleDeployment(deploymentId, config2);
-  });
-};
-var handleDeployment = async (deploymentId, config2) => {
-  debug("Deployment process initialized");
-  let status = "PENDING";
-  const logs = [];
-  addLog("Deployment ID: " + deploymentId, "INFO", logs);
-  try {
-    debug("Starting upload process");
-    await uploadArchive(deploymentId, logs, config2);
-    debug("Upload completed successfully");
-    addLog("Upload complete.", "INFO", logs);
-    addLog("The deployment pipeline is now being provisioned. This may take a few seconds.", "INFO", logs);
-  } catch (err) {
-    debug(`Upload failed with error: ${err.message}`);
-    addLog(`Upload failed: ${err.message}`, "ERROR", logs);
-    status = "FAILED";
-    error("The deployment failed. Please check the logs for more information.");
-    process.exit(1);
-  }
-  const statusInterval = setInterval(() => {
-    void (async () => {
-      try {
-        debug(`Fetching deployment status for ${deploymentId}`);
-        const newStatus = await getDeploymentStatus(deploymentId);
-        debug(`Current status: ${status}, New status: ${newStatus}`);
-        if (newStatus === "ACTIVE" || newStatus === "FAILED") {
-          debug(`Final status reached: ${newStatus}, clearing interval`);
-          clearInterval(statusInterval);
-          clearInterval(logsInterval);
-          if (newStatus === "ACTIVE") {
-            success(`Deployed to https://${deploymentId}.gigadrivedev.com`);
-          } else {
-            error("The deployment failed. Please check the logs for more information.");
-          }
-          return;
-        }
-        if (newStatus !== status) {
-          debug(`Updating status from ${status} to ${newStatus}`);
-          status = newStatus;
-          spinner(`Status: ${status.toLowerCase().replace(/^\w/, (c) => c.toUpperCase())}`);
-        }
-      } catch (err) {
-        debug(`Error fetching status: ${err.message}`);
+    return { createZipArchive };
+  })
+}) {
+};
+
+// src/services/deployment-api.ts
+import { objectToQueryString } from "@gigadrive/commons";
+import { Config as Config2, Effect as Effect11, Schema as Schema5 } from "effect";
+var CreateDeploymentResponse = Schema5.Struct({ id: Schema5.String });
+var StartUploadResponse = Schema5.Struct({ uploadId: Schema5.String });
+var PresignedUrlResponse = Schema5.Struct({ url: Schema5.String });
+var DeploymentStatusResponse = Schema5.Struct({
+  status: Schema5.Literal("PENDING", "BUILDING", "PROVISIONING", "FAILED", "ACTIVE", "SUSPENDED")
+});
+var DeploymentLogPageResponse = Schema5.Struct({
+  totalItems: Schema5.Number,
+  limit: Schema5.Number,
+  offset: Schema5.Number,
+  items: Schema5.Array(
+    Schema5.Struct({
+      id: Schema5.String,
+      message: Schema5.String,
+      type: Schema5.Literal("INFO", "ERROR", "WARN"),
+      createdAt: Schema5.String
+    })
+  )
+});
+var ApiBaseUrl = Config2.string("GIGADRIVE_API_BASE_URL").pipe(Config2.withDefault("http://localhost:3000"));
+var DeploymentApiService = class extends Effect11.Service()("DeploymentApiService", {
+  accessors: true,
+  effect: Effect11.gen(function* () {
+    const baseUrl = yield* ApiBaseUrl;
+    const authService = yield* AuthService;
+    const getAuthHeaders = Effect11.gen(function* () {
+      const token = yield* authService.getAccessToken.pipe(
+        Effect11.mapError((err) => new DeploymentAuthError({ message: `Authentication failed: ${err.message}` }))
+      );
+      return { Authorization: `Bearer ${token}` };
+    });
+    const createDeployment = Effect11.fn("DeploymentApiService.createDeployment")(function* (applicationId) {
+      yield* Effect11.annotateCurrentSpan("applicationId", applicationId);
+      yield* Effect11.log("Creating deployment", { applicationId });
+      const authHeaders = yield* getAuthHeaders;
+      const response = yield* Effect11.tryPromise({
+        try: () => fetch(`${baseUrl}/${applicationId}/deployments`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", ...authHeaders },
+          body: JSON.stringify({})
+        }),
+        catch: (error) => new DeploymentCreateError({
+          message: `Failed to create deployment: ${error instanceof Error ? error.message : String(error)}`
+        })
+      });
+      if (!response.ok) {
+        const body = yield* Effect11.tryPromise({
+          try: () => response.text(),
+          catch: () => new DeploymentCreateError({
+            message: "Failed to read deployment creation error",
+            statusCode: response.status
+          })
+        });
+        return yield* Effect11.fail(
+          new DeploymentCreateError({
+            message: `Failed to create deployment: ${body}`,
+            statusCode: response.status
+          })
+        );
       }
-    })();
-  }, 1e3);
-  const logsInterval = setInterval(() => {
-    void (async () => {
-      try {
-        debug(`Fetching logs for ${deploymentId}, current log count: ${logs.length}`);
-        const newLogs = await getLogs(deploymentId, {
-          offset: logs.length,
-          limit: 100,
-          "createdAt[gt]": logs[logs.length - 1]?.createdAt
+      const json = yield* Effect11.tryPromise({
+        try: () => response.json(),
+        catch: () => new DeploymentCreateError({ message: "Failed to parse deployment response" })
+      });
+      const decoded = yield* Schema5.decodeUnknown(CreateDeploymentResponse)(json).pipe(
+        Effect11.mapError(() => new DeploymentCreateError({ message: "Invalid deployment response schema" }))
+      );
+      yield* Effect11.log("Deployment created", { deploymentId: decoded.id });
+      return decoded.id;
+    });
+    const startMultipartUpload = Effect11.fn("DeploymentApiService.startMultipartUpload")(function* (deploymentId) {
+      yield* Effect11.annotateCurrentSpan("deploymentId", deploymentId);
+      const authHeaders = yield* getAuthHeaders;
+      const response = yield* Effect11.tryPromise({
+        try: () => fetch(`${baseUrl}/deployments/${deploymentId}/pre-signed-url/start`, {
+          method: "GET",
+          headers: { "Content-Type": "application/json", ...authHeaders }
+        }),
+        catch: (error) => new UploadStartError({
+          message: `Failed to start multipart upload: ${error instanceof Error ? error.message : String(error)}`
+        })
+      });
+      if (!response.ok) {
+        const body = yield* Effect11.tryPromise({
+          try: () => response.text(),
+          catch: () => new UploadStartError({ message: "Failed to read upload start error" })
         });
-        debug(`Fetched ${newLogs.items.length} new logs`);
-        for (const logEntry of newLogs.items) {
-          logs.push(logEntry);
-          if (logEntry.type === "ERROR") {
-            error(logEntry.message);
-          } else if (logEntry.type === "WARN") {
-            warn(logEntry.message);
-          } else {
-            log(logEntry.message);
+        return yield* Effect11.fail(
+          new UploadStartError({ message: `Failed to start multipart upload: ${body}`, statusCode: response.status })
+        );
+      }
+      const json = yield* Effect11.tryPromise({
+        try: () => response.json(),
+        catch: () => new UploadStartError({ message: "Failed to parse upload start response" })
+      });
+      const decoded = yield* Schema5.decodeUnknown(StartUploadResponse)(json).pipe(
+        Effect11.mapError(() => new UploadStartError({ message: "Invalid upload start response schema" }))
+      );
+      return decoded.uploadId;
+    });
+    const getPresignedUrl = Effect11.fn("DeploymentApiService.getPresignedUrl")(function* (deploymentId, uploadId, partNumber) {
+      const authHeaders = yield* getAuthHeaders;
+      const response = yield* Effect11.tryPromise({
+        try: () => fetch(
+          `${baseUrl}/deployments/${deploymentId}/pre-signed-url/part?uploadId=${uploadId}&partNumber=${partNumber}`,
+          {
+            method: "GET",
+            headers: { "Content-Type": "application/json", ...authHeaders }
           }
-        }
-      } catch (err) {
-        debug(`Error fetching logs: ${err.message}`);
+        ),
+        catch: (error) => new PresignedUrlError({
+          message: `Failed to get presigned URL: ${error instanceof Error ? error.message : String(error)}`,
+          partNumber
+        })
+      });
+      if (!response.ok) {
+        const body = yield* Effect11.tryPromise({
+          try: () => response.text(),
+          catch: () => new PresignedUrlError({ message: "Failed to read presigned URL error", partNumber })
+        });
+        return yield* Effect11.fail(
+          new PresignedUrlError({ message: `Failed to get presigned URL: ${body}`, partNumber })
+        );
       }
-    })();
-  }, 1e3);
-  spinner(`Status: ${status.toLowerCase().replace(/^\w/, (c) => c.toUpperCase())}`);
-};
-var addLog = (message, type, logs) => {
-  debug(`Adding log: [${type}] ${message}`);
-  logs.push({
-    id: String(logs.length),
-    message,
-    type,
-    createdAt: (/* @__PURE__ */ new Date()).toISOString()
-  });
-  if (type === "ERROR") {
-    error(message);
-  } else if (type === "WARN") {
-    warn(message);
-  } else {
-    log(message);
-  }
-};
-var uploadArchive = async (deploymentId, logs, config2) => {
-  debug("Starting uploadArchive");
-  addLog("Creating archive...", "INFO", logs);
-  const archivePath = path4.join(process.env.TEMP || os.tmpdir(), `project-${Date.now()}.zip`);
-  debug(`Archive path: ${archivePath}`);
-  if (fs4.existsSync(archivePath)) {
-    debug(`Archive already exists, removing: ${archivePath}`);
-    fs4.unlinkSync(archivePath);
-  }
-  debug("Creating zip archive");
-  await createZipArchive(config2.userArchive?.rootOverwrite || process.cwd(), archivePath, {
-    whitelist: config2.userArchive?.fileWhitelist,
-    useIgnoreFiles: false,
-    useManagedIgnore: false
-  });
-  const fileStats = fs4.statSync(archivePath);
-  const fileSize = fileStats.size;
-  debug(`Archive created, size: ${fileSize} bytes (${formatFileSize(fileSize)})`);
-  addLog(`Archive created (${formatFileSize(fileSize)})`, "INFO", logs);
-  addLog("Uploading archive...", "INFO", logs);
-  debug(`Starting multipart upload for deployment: ${deploymentId}`);
-  const uploadId = await startMultipartUpload(deploymentId);
-  debug(`Upload ID: ${uploadId}`);
-  debug("Uploading archive...");
-  const fileChunkSize = 10 * 1024 * 1024;
-  const numChunks = Math.ceil(fileSize / fileChunkSize);
-  debug(`File size: ${fileSize}, chunk size: ${fileChunkSize}, number of chunks: ${numChunks}`);
-  const promises = [];
-  let start, end;
-  for (let index = 1; index < numChunks + 1; index++) {
-    start = (index - 1) * fileChunkSize;
-    end = index * fileChunkSize;
-    debug(`Processing chunk ${index}/${numChunks}, start: ${start}, end: ${end}`);
-    const presignedUrl = await getPresignedUrl(deploymentId, uploadId, index);
-    debug("Presigned URL for part", index, presignedUrl);
-    const promise = new Promise((resolve, reject) => {
-      void (async () => {
-        try {
-          debug(`Reading chunk ${index} data`);
-          const readStream = fs4.createReadStream(archivePath, {
-            start,
-            end: index < numChunks ? end - 1 : void 0
-          });
-          const chunks = [];
-          readStream.on("data", (chunk) => {
-            chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
-          });
-          await new Promise((resolveRead) => {
-            readStream.on("end", () => resolveRead());
-            readStream.on("error", reject);
-          });
-          const buffer = Buffer.concat(chunks);
-          debug(`Uploading chunk ${index} to presigned URL (${buffer.length} bytes)`);
-          const response = await fetch(presignedUrl, {
-            method: "PUT",
-            headers: {
-              "Content-Type": "application/zip",
-              "Content-Length": String(buffer.length)
-            },
-            body: buffer
-          });
-          resolve(response);
-        } catch (err) {
-          reject(err instanceof Error ? err : new Error(String(err)));
-        }
-      })();
+      const json = yield* Effect11.tryPromise({
+        try: () => response.json(),
+        catch: () => new PresignedUrlError({ message: "Failed to parse presigned URL response", partNumber })
+      });
+      const decoded = yield* Schema5.decodeUnknown(PresignedUrlResponse)(json).pipe(
+        Effect11.mapError(() => new PresignedUrlError({ message: "Invalid presigned URL response schema", partNumber }))
+      );
+      return decoded.url;
     });
-    promises.push(promise);
-  }
-  const finishedParts = [];
-  try {
-    debug(`Waiting for all ${promises.length} upload promises to complete`);
-    const responses = await Promise.all(promises);
-    debug("All upload promises completed");
-    for (let index = 0; index < responses.length; index++) {
-      const res = responses[index];
-      debug(`Checking response for part ${index + 1}, status: ${res.status}`);
-      if (!res.ok) {
-        debug(`Failed to upload part ${index + 1}: ${res.statusText} ${await res.text()}`);
-        throw new Error(`Failed to upload part ${index + 1}: ${res.statusText}`);
+    const uploadPart = Effect11.fn("DeploymentApiService.uploadPart")(function* (presignedUrl, data, partNumber) {
+      yield* Effect11.annotateCurrentSpan("partNumber", partNumber);
+      yield* Effect11.annotateCurrentSpan("size", data.length);
+      const response = yield* Effect11.tryPromise({
+        try: () => fetch(presignedUrl, {
+          method: "PUT",
+          headers: {
+            "Content-Type": "application/zip",
+            "Content-Length": String(data.length)
+          },
+          body: data
+        }),
+        catch: (error) => new UploadPartError({
+          message: `Failed to upload part ${partNumber}: ${error instanceof Error ? error.message : String(error)}`,
+          partNumber
+        })
+      });
+      if (!response.ok) {
+        return yield* Effect11.fail(
+          new UploadPartError({
+            message: `Failed to upload part ${partNumber}: ${response.statusText}`,
+            partNumber
+          })
+        );
       }
-      const etag = res.headers.get("ETag");
+      const etag = response.headers.get("ETag");
       if (!etag) {
-        debug(`Failed to get ETag for part ${index + 1}`);
-        throw new Error(`Failed to get ETag for part ${index + 1}`);
+        return yield* Effect11.fail(
+          new UploadPartError({ message: `No ETag received for part ${partNumber}`, partNumber })
+        );
       }
-      debug(`Part ${index + 1} uploaded successfully, ETag: ${etag}`);
-      finishedParts.push({
-        partNumber: index + 1,
-        etag
+      return { partNumber, etag };
+    });
+    const completeUpload = Effect11.fn("DeploymentApiService.completeUpload")(function* (deploymentId, uploadId, parts) {
+      yield* Effect11.annotateCurrentSpan("deploymentId", deploymentId);
+      yield* Effect11.annotateCurrentSpan("partsCount", parts.length);
+      const authHeaders = yield* getAuthHeaders;
+      const response = yield* Effect11.tryPromise({
+        try: () => fetch(`${baseUrl}/deployments/${deploymentId}/pre-signed-url/complete`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", ...authHeaders },
+          body: JSON.stringify({ uploadId, parts })
+        }),
+        catch: (error) => new UploadCompleteError({
+          message: `Failed to complete upload: ${error instanceof Error ? error.message : String(error)}`
+        })
       });
-    }
-    debug(`Completing upload with ${finishedParts.length} parts`);
-    await completeUpload(deploymentId, uploadId, finishedParts);
-    debug("Upload completed successfully");
-  } catch (err) {
-    const error2 = err;
-    debug(`Upload error: ${error2.message}`);
-    addLog(`Upload error: ${error2.message}`, "ERROR", logs);
-    throw error2;
-  }
-};
-var createDeployment = async ({ applicationId }) => {
-  debug(`Creating deployment for application: ${applicationId}`);
-  const res = await fetch(`http://localhost:3000/${applicationId}/deployments`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify({}),
-    duplex: "half"
-  });
-  if (!res.ok) {
-    const errorText = await res.text();
-    debug(`Failed to create deployment: ${errorText}`);
-    throw new Error("Failed to create deployment: " + errorText);
-  }
-  const deployment = await res.json();
-  debug(`Deployment created with ID: ${deployment.id}`);
-  return deployment.id;
-};
-var startMultipartUpload = async (deploymentId) => {
-  debug(`Starting multipart upload for deployment: ${deploymentId}`);
-  const res = await fetch(`http://localhost:3000/deployments/${deploymentId}/pre-signed-url/start`, {
-    method: "GET",
-    headers: {
-      "Content-Type": "application/json"
-    }
-  });
-  if (!res.ok) {
-    const errorText = await res.text();
-    debug(`Failed to start multipart upload: ${errorText}`);
-    throw new Error("Failed to start multipart upload: " + errorText);
-  }
-  const upload = await res.json();
-  debug(`Multipart upload started with ID: ${upload.uploadId}`);
-  return upload.uploadId;
-};
-var getPresignedUrl = async (deploymentId, uploadId, partNumber) => {
-  debug(`Getting presigned URL for deployment: ${deploymentId}, upload: ${uploadId}, part: ${partNumber}`);
-  const res = await fetch(
-    `http://localhost:3000/deployments/${deploymentId}/pre-signed-url/part?uploadId=${uploadId}&partNumber=${partNumber}`,
-    {
-      method: "GET",
-      headers: {
-        "Content-Type": "application/json"
+      if (!response.ok) {
+        const body = yield* Effect11.tryPromise({
+          try: () => response.text(),
+          catch: () => new UploadCompleteError({ message: "Failed to read upload complete error" })
+        });
+        return yield* Effect11.fail(new UploadCompleteError({ message: `Failed to complete upload: ${body}` }));
       }
-    }
+      yield* Effect11.log("Upload completed successfully");
+    });
+    const getDeploymentStatus = Effect11.fn("DeploymentApiService.getDeploymentStatus")(function* (deploymentId) {
+      const authHeaders = yield* getAuthHeaders;
+      const response = yield* Effect11.tryPromise({
+        try: () => fetch(`${baseUrl}/deployments/${deploymentId}`, {
+          method: "GET",
+          headers: { "Content-Type": "application/json", ...authHeaders }
+        }),
+        catch: (error) => new DeploymentStatusError({
+          message: `Failed to get deployment status: ${error instanceof Error ? error.message : String(error)}`
+        })
+      });
+      if (!response.ok) {
+        const body = yield* Effect11.tryPromise({
+          try: () => response.text(),
+          catch: () => new DeploymentStatusError({ message: "Failed to read deployment status error" })
+        });
+        return yield* Effect11.fail(new DeploymentStatusError({ message: `Failed to get deployment status: ${body}` }));
+      }
+      const json = yield* Effect11.tryPromise({
+        try: () => response.json(),
+        catch: () => new DeploymentStatusError({ message: "Failed to parse deployment status response" })
+      });
+      const decoded = yield* Schema5.decodeUnknown(DeploymentStatusResponse)(json).pipe(
+        Effect11.mapError(() => new DeploymentStatusError({ message: "Invalid deployment status response schema" }))
+      );
+      return decoded.status;
+    });
+    const getLogs = Effect11.fn("DeploymentApiService.getLogs")(function* (deploymentId, options) {
+      const authHeaders = yield* getAuthHeaders;
+      const response = yield* Effect11.tryPromise({
+        try: () => fetch(`${baseUrl}/deployments/${deploymentId}/logs${objectToQueryString(options)}`, {
+          method: "GET",
+          headers: { "Content-Type": "application/json", ...authHeaders }
+        }),
+        catch: (error) => new DeploymentLogsFetchError({
+          message: `Failed to get logs: ${error instanceof Error ? error.message : String(error)}`
+        })
+      });
+      if (!response.ok) {
+        const body = yield* Effect11.tryPromise({
+          try: () => response.text(),
+          catch: () => new DeploymentLogsFetchError({ message: "Failed to read logs error" })
+        });
+        return yield* Effect11.fail(new DeploymentLogsFetchError({ message: `Failed to get logs: ${body}` }));
+      }
+      const json = yield* Effect11.tryPromise({
+        try: () => response.json(),
+        catch: () => new DeploymentLogsFetchError({ message: "Failed to parse logs response" })
+      });
+      const decoded = yield* Schema5.decodeUnknown(DeploymentLogPageResponse)(json).pipe(
+        Effect11.mapError(() => new DeploymentLogsFetchError({ message: "Invalid logs response schema" }))
+      );
+      return decoded;
+    });
+    return {
+      createDeployment,
+      startMultipartUpload,
+      getPresignedUrl,
+      uploadPart,
+      completeUpload,
+      getDeploymentStatus,
+      getLogs
+    };
+  })
+}) {
+};
+
+// src/commands/platform/deploy/index.ts
+var deployCommand = Command5.make(
+  "deploy",
+  {},
+  () => Effect12.gen(function* () {
+    const projectConfig = yield* ProjectConfigService;
+    const deploymentApi = yield* DeploymentApiService;
+    const archiveService = yield* ArchiveService;
+    const pathService = yield* Path5.Path;
+    const cwd = process.cwd();
+    yield* Effect12.log("Starting deploy command");
+    const { config } = yield* projectConfig.resolve(cwd);
+    yield* Console5.log("Creating deployment...");
+    const deploymentId = yield* deploymentApi.createDeployment("test");
+    yield* Console5.log(`Deployment ID: ${deploymentId}`);
+    yield* Console5.log("Creating archive...");
+    const archivePath = pathService.join(os2.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* Console5.log(`Archive created (${formatFileSize(archive.size)})`);
+    yield* Console5.log("Uploading archive...");
+    yield* uploadArchive(deploymentId, archivePath, archive.size);
+    yield* Console5.log("Upload complete.");
+    yield* Console5.log("The deployment pipeline is now being provisioned. This may take a few seconds.");
+    yield* pollDeployment(deploymentId);
+  }).pipe(
+    Effect12.catchTags({
+      ConfigNotFoundError: (err) => Console5.error(err.message).pipe(Effect12.andThen(Effect12.fail(err))),
+      ConfigParseError: (err) => Console5.error(`Config parse error: ${err.message}`).pipe(Effect12.andThen(Effect12.fail(err))),
+      ConfigValidationError: (err) => Effect12.gen(function* () {
+        for (const e of err.errors) {
+          yield* Console5.error(e);
+        }
+        yield* Console5.error(err.message);
+      }).pipe(Effect12.andThen(Effect12.fail(err))),
+      DeploymentCreateError: (err) => Console5.error(`Deployment creation failed: ${err.message}`).pipe(Effect12.andThen(Effect12.fail(err))),
+      ArchiveCreateError: (err) => Console5.error(`Archive creation failed: ${err.message}`).pipe(Effect12.andThen(Effect12.fail(err))),
+      UploadStartError: (err) => Console5.error(`Upload failed: ${err.message}`).pipe(Effect12.andThen(Effect12.fail(err))),
+      UploadPartError: (err) => Console5.error(`Upload failed: ${err.message}`).pipe(Effect12.andThen(Effect12.fail(err))),
+      UploadCompleteError: (err) => Console5.error(`Upload failed: ${err.message}`).pipe(Effect12.andThen(Effect12.fail(err))),
+      PresignedUrlError: (err) => Console5.error(`Upload failed: ${err.message}`).pipe(Effect12.andThen(Effect12.fail(err))),
+      DeploymentAuthError: (err) => Console5.error(`Authentication failed: ${err.message}`).pipe(Effect12.andThen(Effect12.fail(err))),
+      DeploymentFailedError: (err) => Console5.error(err.message).pipe(Effect12.andThen(Effect12.fail(err)))
+    })
+  )
+);
+var uploadArchive = (deploymentId, archivePath, fileSize) => Effect12.gen(function* () {
+  const deploymentApi = yield* DeploymentApiService;
+  const fs = yield* FileSystem5.FileSystem;
+  const uploadId = yield* deploymentApi.startMultipartUpload(deploymentId);
+  const FILE_CHUNK_SIZE = 10 * 1024 * 1024;
+  const numChunks = Math.ceil(fileSize / FILE_CHUNK_SIZE);
+  yield* Effect12.log("Starting multipart upload", { uploadId, numChunks, fileSize });
+  const parts = yield* Effect12.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 Effect12.gen(function* () {
+        const presignedUrl = yield* deploymentApi.getPresignedUrl(deploymentId, uploadId, partNumber);
+        const chunkData = yield* Stream.runCollect(fs.stream(archivePath, { offset: start, bytesToRead })).pipe(
+          Effect12.map((chunks) => {
+            const arrays = Array.from(chunks);
+            return Buffer.concat(arrays);
+          }),
+          Effect12.mapError(
+            (error) => new UploadPartError({
+              message: `Failed to read chunk ${partNumber}: ${String(error)}`,
+              partNumber
+            })
+          )
+        );
+        yield* Effect12.log(`Uploading part ${partNumber}/${numChunks}`, { size: chunkData.length });
+        return yield* deploymentApi.uploadPart(presignedUrl, chunkData, partNumber);
+      });
+    }),
+    { concurrency: 3 }
   );
-  if (!res.ok) {
-    const errorText = await res.text();
-    debug(`Failed to get pre-signed URL: ${errorText}`);
-    throw new Error("Failed to get pre-signed URL: " + errorText);
-  }
-  const upload = await res.json();
-  debug(`Got presigned URL for part ${partNumber}`);
-  return upload.url;
-};
-var completeUpload = async (deploymentId, uploadId, parts) => {
-  debug(`Completing upload for deployment: ${deploymentId}, upload: ${uploadId}, parts: ${parts.length}`);
-  const res = await fetch(`http://localhost:3000/deployments/${deploymentId}/pre-signed-url/complete`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify({
-      uploadId,
-      parts
+  yield* deploymentApi.completeUpload(deploymentId, uploadId, parts);
+});
+var pollDeployment = (deploymentId) => Effect12.gen(function* () {
+  const deploymentApi = yield* DeploymentApiService;
+  let lastStatus = "PENDING";
+  let logOffset = 0;
+  yield* Console5.log("Status: Pending");
+  yield* Effect12.repeat(
+    Effect12.gen(function* () {
+      const newStatus = yield* deploymentApi.getDeploymentStatus(deploymentId).pipe(Effect12.catchTag("DeploymentStatusError", () => Effect12.succeed(lastStatus)));
+      if (newStatus !== lastStatus) {
+        lastStatus = newStatus;
+        const label = newStatus.charAt(0) + newStatus.slice(1).toLowerCase();
+        yield* Console5.log(`Status: ${label}`);
+      }
+      const logsPage = yield* deploymentApi.getLogs(deploymentId, { offset: logOffset, limit: 100 }).pipe(Effect12.catchTag("DeploymentLogsFetchError", () => Effect12.succeed(null)));
+      if (logsPage) {
+        for (const logEntry of logsPage.items) {
+          logOffset++;
+          yield* printLog(logEntry);
+        }
+      }
+      if (newStatus === "ACTIVE") {
+        yield* Console5.log(`Deployed to https://${deploymentId}.gigadrivedev.com`);
+        return yield* Effect12.fail("done");
+      }
+      if (newStatus === "FAILED") {
+        return yield* Effect12.fail(
+          new DeploymentFailedError({
+            message: "The deployment failed. Please check the logs for more information."
+          })
+        );
+      }
     }),
-    duplex: "half"
-  });
-  if (!res.ok) {
-    const errorText = await res.text();
-    debug(`Failed to complete upload: ${errorText}`);
-    throw new Error("Failed to complete upload: " + errorText);
-  }
-  debug("Upload completed successfully");
-};
-var getDeploymentStatus = async (deploymentId) => {
-  debug(`Getting deployment status for: ${deploymentId}`);
-  const res = await fetch(`http://localhost:3000/deployments/${deploymentId}`, {
-    method: "GET",
-    headers: {
-      "Content-Type": "application/json"
-    }
-  });
-  if (!res.ok) {
-    const errorText = await res.text();
-    debug(`Failed to get deployment status: ${errorText}`);
-    throw new Error("Failed to get deployment status: " + errorText);
-  }
-  const deployment = await res.json();
-  debug(`Deployment status: ${deployment.status}`);
-  return deployment.status;
-};
-var getLogs = async (deploymentId, options) => {
-  debug(`Getting logs for deployment: ${deploymentId}, options:`, options ?? "No options");
-  const res = await fetch(`http://localhost:3000/deployments/${deploymentId}/logs${objectToQueryString(options)}`, {
-    method: "GET",
-    headers: {
-      "Content-Type": "application/json"
-    }
-  });
-  if (!res.ok) {
-    const errorText = await res.text();
-    debug(`Failed to get logs: ${errorText}`);
-    throw new Error("Failed to get logs: " + errorText);
+    Schedule.addDelay(Schedule.forever, () => Duration.seconds(1))
+  ).pipe(
+    Effect12.catchAll((err) => {
+      if (err === "done") return Effect12.void;
+      return Effect12.fail(err);
+    })
+  );
+});
+var printLog = (logEntry) => {
+  switch (logEntry.type) {
+    case "ERROR":
+      return Console5.error(logEntry.message);
+    case "WARN":
+      return Console5.warn(logEntry.message);
+    default:
+      return Console5.log(logEntry.message);
   }
-  const logs = await res.json();
-  debug(`Got ${logs.items.length} logs, total: ${logs.totalItems}`);
-  return logs;
 };
 
 // src/commands/platform/index.ts
-var platform = (program) => {
-  const platform2 = program.command("platform").description("Manage the platform");
-  deploy(platform2);
-};
+var platformBase = Command6.make("platform", {}, () => Effect13.void);
+var platformCommand = platformBase.pipe(Command6.withSubcommands([deployCommand]));
+
+// src/commands/whoami/index.ts
+import { Command as Command7 } from "@effect/cli";
+import { Console as Console6, Effect as Effect14 } from "effect";
+var whoamiCommand = Command7.make(
+  "whoami",
+  {},
+  () => Effect14.gen(function* () {
+    const auth = yield* AuthService;
+    const info = yield* auth.getUserInfo;
+    yield* Console6.log(JSON.stringify(info, null, 2));
+  }).pipe(
+    Effect14.catchTags({
+      NotAuthenticatedError: () => Console6.log('You are not logged in. Run "gigadrive login" to authenticate.'),
+      UserInfoFetchError: (err) => Console6.error(`Failed to retrieve user info: ${err.message}`),
+      OAuthDiscoveryError: (err) => Console6.error(`Failed to retrieve user info: ${err.message}`)
+    })
+  )
+);
 
 // src/index.ts
-var { isTTY } = process.stdout;
-var main = async () => {
-  if (process.env.FORCE_TTY === "1") {
-    isTTY = true;
-    process.stdout.isTTY = true;
-    process.stdin.isTTY = true;
-  }
-  let exitCode = 0;
-  const program = new Command();
-  program.option("-v, --verbose", "Enable verbose logging", false);
-  program.hook("preSubcommand", (thisCommand) => {
-    setVerbose(thisCommand.opts().verbose === true);
-    if (thisCommand.opts().verbose) {
-      log("Using verbose mode");
-    }
-  });
-  program.hook("preAction", (thisCommand) => {
-    setVerbose(thisCommand.opts().verbose === true);
-  });
-  platform(program);
-  debug2(program);
-  build(program);
-  try {
-    await program.parseAsync(process.argv);
-  } catch (err) {
-    error(err);
-    exitCode = 1;
-  }
-  return exitCode;
-};
-var handleRejection = (err) => {
-  if (err) {
-    if (err instanceof Error) {
-      handleUnexpected(err);
-    } else {
-      console.error(`An unexpected rejection occurred
-  ${JSON.stringify(err)}`);
-    }
-  } else {
-    console.error("An unexpected empty rejection occurred");
-  }
-  process.exit(1);
-};
-var handleUnexpected = (error2) => {
-  const { message } = error2;
-  console.error(`An unexpected error occurred
-  ${message}`);
-  process.exit(1);
-};
-process.on("unhandledRejection", handleRejection);
-process.on("uncaughtException", handleUnexpected);
-process.on("exit", () => {
-  const terminal = process.stderr.isTTY ? process.stderr : process.stdout.isTTY ? process.stdout : void 0;
-  terminal?.write("\x1B[?25h");
+var gigadrive = Command8.make("gigadrive", {}, () => Effect15.void).pipe(
+  Command8.withSubcommands([loginCommand, whoamiCommand, buildCommand, debugCommand, platformCommand])
+);
+var cli = Command8.run(gigadrive, {
+  name: "Gigadrive CLI",
+  version: "2.0.0"
 });
-main().then((exitCode) => {
-  process.exitCode = exitCode;
-}).catch(handleUnexpected);
+var BaseServices = Layer.mergeAll(
+  OAuthConfigService.Default,
+  AuthStorageService.Default,
+  PackageManagerService.Default,
+  ArchiveService.Default,
+  NetworkConfigLive2,
+  ProjectConfigService.Default
+).pipe(Layer.provideMerge(AuthService.Default));
+var DeploymentApiLive = Layer.provide(DeploymentApiService.Default, BaseServices);
+var ServicesLive = Layer.mergeAll(BaseServices, DeploymentApiLive);
+var AppLive = Layer.mergeAll(ServicesLive, Logger.minimumLogLevel(LogLevel.Info)).pipe(
+  Layer.provideMerge(NodeContext.layer)
+);
+NodeRuntime.runMain(Effect15.provide(cli(process.argv), AppLive));
 //# sourceMappingURL=index.mjs.map