gigadrive 2.0.0 → 2.1.1

package/dist/index.cjs

@@ -24,1163 +24,1544 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/index.ts
-var import_commander = require("commander");
+var import_cli8 = require("@effect/cli");
+var import_platform_node = require("@effect/platform-node");
+var import_network_config2 = require("@gigadrive/network-config");
+var import_effect17 = require("effect");
 
-// src/util/log.ts
-var import_consola = require("consola");
-var verbose = false;
-var consola = (0, import_consola.createConsola)({
-  level: verbose ? 4 : 3,
-  // 4 includes debug messages, 3 is the default (info and above)
-  formatOptions: {
-    colors: true
-  }
-});
-var updateConsola = () => {
-  consola.level = verbose ? 4 : 3;
+// src/commands/build/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");
+
+// src/errors.ts
+var import_effect = require("effect");
+var OAuthDiscoveryError = class extends import_effect.Schema.TaggedError()("OAuthDiscoveryError", {
+  message: import_effect.Schema.String,
+  cause: import_effect.Schema.optional(import_effect.Schema.String)
+}) {
 };
-var setVerbose = (value) => {
-  verbose = value;
-  updateConsola();
+var AuthStorageReadError = class extends import_effect.Schema.TaggedError()("AuthStorageReadError", {
+  message: import_effect.Schema.String
+}) {
 };
-var log = (message) => {
-  consola.info(message);
+var AuthStorageWriteError = class extends import_effect.Schema.TaggedError()("AuthStorageWriteError", {
+  message: import_effect.Schema.String,
+  cause: import_effect.Schema.optional(import_effect.Schema.String)
+}) {
 };
-var error = (message) => {
-  consola.error(message);
+var LoginFlowError = class extends import_effect.Schema.TaggedError()("LoginFlowError", {
+  message: import_effect.Schema.String,
+  cause: import_effect.Schema.optional(import_effect.Schema.String)
+}) {
 };
-var success = (message) => {
-  consola.success(message);
+var TokenExchangeError = class extends import_effect.Schema.TaggedError()("TokenExchangeError", {
+  message: import_effect.Schema.String,
+  statusCode: import_effect.Schema.optional(import_effect.Schema.Number)
+}) {
 };
-var warn = (message) => {
-  consola.warn(message);
+var TokenRefreshError = class extends import_effect.Schema.TaggedError()("TokenRefreshError", {
+  message: import_effect.Schema.String,
+  statusCode: import_effect.Schema.optional(import_effect.Schema.Number)
+}) {
 };
-var debug = (message, ...optionalParams) => {
-  if (!verbose) {
-    return;
-  }
-  consola.debug("[DEBUG]", message, ...optionalParams);
+var NotAuthenticatedError = class extends import_effect.Schema.TaggedError()("NotAuthenticatedError", {
+  message: import_effect.Schema.String
+}) {
 };
-var spinner = (message) => {
-  log(message);
+var UserInfoFetchError = class extends import_effect.Schema.TaggedError()("UserInfoFetchError", {
+  message: import_effect.Schema.String,
+  statusCode: import_effect.Schema.optional(import_effect.Schema.Number)
+}) {
 };
-
-// src/commands/build/index.ts
-var import_build_utils = require("@gigadrive/build-utils");
-var import_fs2 = __toESM(require("fs"), 1);
-var import_path2 = __toESM(require("path"), 1);
-
-// src/util/pm.ts
-var import_fs = __toESM(require("fs"), 1);
-var import_path = __toESM(require("path"), 1);
-
-// ../build-utils/src/exec.ts
-var import_child_process = require("child_process");
-async function exec({
-  command,
-  cwd = process.cwd(),
-  env: env2,
-  onOutput = (data) => console.log(data),
-  onError = (data) => console.error(data)
+var ConfigNotFoundError = class extends import_effect.Schema.TaggedError()("ConfigNotFoundError", {
+  message: import_effect.Schema.String,
+  directory: import_effect.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 = (0, import_child_process.spawn)(spawnCommand, spawnArgs, {
-      cwd,
-      shell: true,
-      env: env2
-    });
-    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 = import_path.default.join(cwd, "package.json");
-  if (!import_fs.default.existsSync(packageJsonPath)) {
-    return null;
-  }
-  if (import_fs.default.existsSync(import_path.default.join(cwd, "yarn.lock"))) {
-    return "yarn";
-  }
-  if (import_fs.default.existsSync(import_path.default.join(cwd, "pnpm-lock.yaml"))) {
-    return "pnpm";
+};
+var ConfigParseError = class extends import_effect.Schema.TaggedError()("ConfigParseError", {
+  message: import_effect.Schema.String,
+  cause: import_effect.Schema.optional(import_effect.Schema.String)
+}) {
+};
+var ConfigValidationError = class extends import_effect.Schema.TaggedError()("ConfigValidationError", {
+  message: import_effect.Schema.String,
+  errors: import_effect.Schema.Array(import_effect.Schema.String)
+}) {
+};
+var PackageJsonNotFoundError = class extends import_effect.Schema.TaggedError()(
+  "PackageJsonNotFoundError",
+  {
+    message: import_effect.Schema.String,
+    directory: import_effect.Schema.String
   }
-  if (import_fs.default.existsSync(import_path.default.join(cwd, "bun.lockb"))) {
-    return "bun";
+) {
+};
+var PackageJsonParseError = class extends import_effect.Schema.TaggedError()("PackageJsonParseError", {
+  message: import_effect.Schema.String,
+  directory: import_effect.Schema.String,
+  cause: import_effect.Schema.optional(import_effect.Schema.String)
+}) {
+};
+var BuildScriptNotFoundError = class extends import_effect.Schema.TaggedError()(
+  "BuildScriptNotFoundError",
+  {
+    message: import_effect.Schema.String
   }
-  if (import_fs.default.existsSync(import_path.default.join(cwd, "package-lock.json"))) {
-    return "npm";
+) {
+};
+var PackageManagerNotFoundError = class extends import_effect.Schema.TaggedError()(
+  "PackageManagerNotFoundError",
+  {
+    message: import_effect.Schema.String,
+    directory: import_effect.Schema.String
   }
-  try {
-    await exec({ command: "bun --version", cwd });
-    return "bun";
-  } catch {
-    return "npm";
+) {
+};
+var ExecError = class extends import_effect.Schema.TaggedError()("ExecError", {
+  message: import_effect.Schema.String,
+  command: import_effect.Schema.String,
+  cause: import_effect.Schema.optional(import_effect.Schema.String)
+}) {
+};
+var DeploymentCreateError = class extends import_effect.Schema.TaggedError()("DeploymentCreateError", {
+  message: import_effect.Schema.String,
+  statusCode: import_effect.Schema.optional(import_effect.Schema.Number)
+}) {
+};
+var UploadStartError = class extends import_effect.Schema.TaggedError()("UploadStartError", {
+  message: import_effect.Schema.String,
+  statusCode: import_effect.Schema.optional(import_effect.Schema.Number)
+}) {
+};
+var PresignedUrlError = class extends import_effect.Schema.TaggedError()("PresignedUrlError", {
+  message: import_effect.Schema.String,
+  partNumber: import_effect.Schema.Number
+}) {
+};
+var UploadPartError = class extends import_effect.Schema.TaggedError()("UploadPartError", {
+  message: import_effect.Schema.String,
+  partNumber: import_effect.Schema.Number
+}) {
+};
+var UploadCompleteError = class extends import_effect.Schema.TaggedError()("UploadCompleteError", {
+  message: import_effect.Schema.String
+}) {
+};
+var DeploymentStatusError = class extends import_effect.Schema.TaggedError()("DeploymentStatusError", {
+  message: import_effect.Schema.String
+}) {
+};
+var DeploymentLogsFetchError = class extends import_effect.Schema.TaggedError()(
+  "DeploymentLogsFetchError",
+  {
+    message: import_effect.Schema.String
   }
+) {
 };
-var installCommand = (pm) => {
-  return {
-    bun: "bun install",
-    npm: "npm install",
-    pnpm: "pnpm install",
-    yarn: "yarn install"
-  }[pm] || "npm install";
+var ArchiveCreateError = class extends import_effect.Schema.TaggedError()("ArchiveCreateError", {
+  message: import_effect.Schema.String,
+  cause: import_effect.Schema.optional(import_effect.Schema.String)
+}) {
 };
-var buildCommand = (pm) => {
-  return {
-    bun: "bun run build",
-    npm: "npm run build",
-    pnpm: "pnpm build",
-    yarn: "yarn build"
-  }[pm] || "npm run build";
+var DeploymentAuthError = class extends import_effect.Schema.TaggedError()("DeploymentAuthError", {
+  message: import_effect.Schema.String
+}) {
+};
+var DeploymentFailedError = class extends import_effect.Schema.TaggedError()("DeploymentFailedError", {
+  message: import_effect.Schema.String
+}) {
+};
+
+// src/services/package-manager.ts
+var import_platform = require("@effect/platform");
+var import_build_utils = require("@gigadrive/build-utils");
+var import_effect2 = require("effect");
+var PackageManagerService = class extends import_effect2.Effect.Service()("PackageManagerService", {
+  accessors: true,
+  effect: import_effect2.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 })
+        )
+      );
+      if (!exists) {
+        return yield* import_effect2.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_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 build = (parent) => {
-  parent.command("build").description("Build the current project").action(async () => {
-    const env2 = {
+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)
+      })
+    });
+    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",
-      // Vercel compatibility
       NOW_BUILDER: "1"
     };
-    const cwd = process.cwd();
-    const packageJsonPath = import_path2.default.join(cwd, "package.json");
-    if (!import_fs2.default.existsSync(packageJsonPath)) {
-      error("No package.json found");
-      return;
-    }
-    const packageJson = JSON.parse(import_fs2.default.readFileSync(packageJsonPath, "utf-8"));
-    const buildScript = packageJson.scripts?.build;
-    if (!buildScript) {
-      error("No build script found in package.json");
-      return;
-    }
-    const packageManager = await getPackageManager({ cwd });
-    if (!packageManager) {
-      error("No package manager found");
-      return;
-    }
-    await (0, import_build_utils.exec)({
-      command: installCommand(packageManager),
-      cwd,
-      env: env2,
-      onOutput: (chunk) => {
-        log(chunk);
-      }
+    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)
+      })
     });
-    await (0, import_build_utils.exec)({
-      command: buildCommand(packageManager),
-      cwd,
-      env: env2,
-      onOutput: (chunk) => {
-        log(chunk);
-      }
+    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)
+      })
     });
-  });
-};
+    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");
+
+// src/services/project-config.ts
 var import_network_config = require("@gigadrive/network-config");
-var import_console = require("console");
-var config = (parent) => {
-  parent.command("config").description("Provide debug info about the project configuration in the current directory").action(async () => {
-    const configPath = (0, import_network_config.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 (0, import_network_config.parseConfig)(configPath, process.cwd());
-    (0, import_console.log)(`Config file found at: ${configPath}`);
-    (0, import_console.log)(JSON.stringify(config2, null, 2));
-  });
+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", {
+  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/index.ts
-var debug2 = (program) => {
-  const debug3 = program.command("debug").description("Provides various debugging utilities");
-  config(debug3);
-};
+// 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/env.ts
-var import_env_core = require("@t3-oss/env-core");
-var import_dotenv = require("dotenv");
-var import_node_fs = __toESM(require("fs"), 1);
-var import_node_path = __toESM(require("path"), 1);
-var import_zod = require("zod");
-(() => {
-  const cwd = process.cwd();
-  const nodeEnv = process.env.NODE_ENV;
-  const candidates = [
-    nodeEnv ? `.env.${nodeEnv}.local` : null,
-    `.env.local`,
-    nodeEnv ? `.env.${nodeEnv}` : null,
-    `.env`
-  ].filter(Boolean);
-  for (const filename of candidates) {
-    const fullPath = import_node_path.default.join(cwd, filename);
-    if (import_node_fs.default.existsSync(fullPath)) {
-      console.debug(`Loading environment variables from ${fullPath}`);
-      (0, import_dotenv.config)({ path: fullPath, override: false });
-    }
-  }
-})();
-var env = (0, import_env_core.createEnv)({
-  server: {
-    GIGADRIVE_NETWORK_OAUTH_ISSUER_URL: import_zod.z.url().min(1).default("https://idp.gigadrive.de"),
-    GIGADRIVE_NETWORK_OAUTH_CLIENT_ID: import_zod.z.string().min(1).default("todo_add_client_id")
-  },
-  runtimeEnv: process.env,
-  emptyStringAsUndefined: true
-});
+// 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/config/oauth.ts
-var cachedConfig = null;
-async function getOAuthConfig() {
-  if (cachedConfig) return cachedConfig;
-  const issuerBase = env.GIGADRIVE_NETWORK_OAUTH_ISSUER_URL.replace(/\/$/, "");
-  const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), 8e3);
-  let discovery = null;
-  try {
-    const discoveryUrl = `${issuerBase}/.well-known/openid-configuration`;
-    const res = await fetch(discoveryUrl, { signal: controller.signal });
-    if (res.ok) {
-      discovery = await res.json();
-    } else {
-      discovery = null;
-    }
-  } catch {
-    discovery = null;
-  } finally {
-    clearTimeout(timeout);
-  }
-  if (!discovery?.authorization_endpoint || !discovery?.token_endpoint || !discovery?.userinfo_endpoint) {
-    throw new Error("OIDC discovery failed or returned incomplete endpoints");
-  }
-  const DEFAULT_SCOPE = "offline_access openid profile email";
-  cachedConfig = {
-    clientId: env.GIGADRIVE_NETWORK_OAUTH_CLIENT_ID,
-    issuer: discovery.issuer ?? issuerBase,
-    authorizeUrl: discovery.authorization_endpoint,
-    tokenUrl: discovery.token_endpoint,
-    scope: DEFAULT_SCOPE,
-    userinfoUrl: discovery.userinfo_endpoint
-  };
-  return cachedConfig;
-}
+// src/commands/login/index.ts
+var import_cli4 = require("@effect/cli");
+var import_effect11 = require("effect");
 
-// src/auth/manager.ts
+// src/services/auth.ts
+var import_effect10 = require("effect");
 var crypto = __toESM(require("crypto"), 1);
-var fs4 = __toESM(require("fs"), 1);
 var http = __toESM(require("http"), 1);
-var os = __toESM(require("os"), 1);
-var path4 = __toESM(require("path"), 1);
-var import_node_url = require("url");
 var import_open = __toESM(require("open"), 1);
-function getAuthStoragePaths() {
-  const homeDir = os.homedir();
-  const authDir = path4.join(homeDir, ".gigadrive");
-  const authFile = path4.join(authDir, "auth.json");
-  return { directory: authDir, file: authFile };
-}
-async function ensureAuthDirectory() {
-  const { directory } = getAuthStoragePaths();
-  try {
-    await fs4.promises.mkdir(directory, { recursive: true, mode: 448 });
-    await fs4.promises.chmod(directory, 448);
-  } catch (error2) {
-    const errorMessage = error2 instanceof Error ? error2.message : "Unknown error";
-    throw new Error(`Failed to create auth directory: ${errorMessage}`);
-  }
-}
-function generatePKCE() {
+
+// 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* () {
+      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({
+        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* import_effect9.Effect.fail(
+          new OAuthDiscoveryError({
+            message: `OIDC discovery returned ${response.status} ${response.statusText}`
+          })
+        );
+      }
+      const json = yield* import_effect9.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(
+          () => new OAuthDiscoveryError({
+            message: "Invalid OIDC discovery document schema"
+          })
+        )
+      );
+      if (!decoded.authorization_endpoint || !decoded.token_endpoint || !decoded.userinfo_endpoint) {
+        return yield* import_effect9.Effect.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* import_effect9.Effect.log("OIDC discovery completed", { issuer: config.issuer });
+      return config;
+    });
+    return { getConfig };
+  })
+}) {
+};
+
+// 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 };
-}
-function base64URLEncode(buffer) {
-  return buffer.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
-}
-var AuthManager = class {
-  accessToken = null;
-  tokenExpirationTime = 0;
-  // Unix timestamp in milliseconds
-  codeVerifier = null;
-  state = null;
-  constructor() {
-  }
-  /**
-   * Retrieves the stored auth data from the local file.
-   * @returns {Promise<StoredAuthData | null>} The stored auth data if found, otherwise null.
-   * @private
-   */
-  async _loadStoredAuthData() {
-    try {
-      const { file } = getAuthStoragePaths();
-      const data = await fs4.promises.readFile(file, "utf8");
-      const authData = JSON.parse(data);
-      if (authData.accessToken && authData.tokenExpirationTime && Date.now() < authData.tokenExpirationTime) {
-        this.accessToken = authData.accessToken;
-        this.tokenExpirationTime = authData.tokenExpirationTime;
+};
+var AuthService = class extends import_effect10.Effect.Service()("AuthService", {
+  accessors: true,
+  dependencies: [OAuthConfigService.Default, AuthStorageService.Default],
+  effect: import_effect10.Effect.gen(function* () {
+    const oauthConfig = yield* OAuthConfigService;
+    const storage = yield* AuthStorageService;
+    let accessToken = null;
+    let tokenExpirationTime = 0;
+    const logout = import_effect10.Effect.gen(function* () {
+      accessToken = null;
+      tokenExpirationTime = 0;
+      yield* storage.remove;
+      yield* import_effect10.Effect.log("Logged out");
+    });
+    const exchangeCodeForTokens = (config, authCode, redirectUri, codeVerifier) => import_effect10.Effect.gen(function* () {
+      const response = yield* import_effect10.Effect.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* import_effect10.Effect.tryPromise({
+          try: () => response.text(),
+          catch: () => new TokenExchangeError({ message: "Failed to read token exchange error response" })
+        });
+        return yield* import_effect10.Effect.fail(
+          new TokenExchangeError({
+            message: `Token exchange failed: ${response.status} ${response.statusText} - ${body}`,
+            statusCode: response.status
+          })
+        );
       }
-      return authData;
-    } catch {
-      return null;
-    }
-  }
-  /**
-   * Stores the auth data in the local file.
-   * @param {StoredAuthData} authData The auth data to store.
-   * @private
-   */
-  async _saveStoredAuthData(authData) {
-    try {
-      await ensureAuthDirectory();
-      const { file } = getAuthStoragePaths();
-      await fs4.promises.writeFile(file, JSON.stringify(authData, null, 2), { encoding: "utf8", mode: 384 });
-      await fs4.promises.chmod(file, 384);
-      console.debug("Auth data saved to local storage.");
-    } catch (error2) {
-      const errorMessage = error2 instanceof Error ? error2.message : "Unknown error";
-      console.error("Error saving auth data to local storage:", errorMessage);
-    }
-  }
-  /**
-   * Deletes the stored auth data from the local file.
-   */
-  async logout() {
-    this.accessToken = null;
-    this.tokenExpirationTime = 0;
-    try {
-      const { file } = getAuthStoragePaths();
-      await fs4.promises.unlink(file);
-      log("Logged out. Auth data removed from local storage.");
-    } catch {
-      log("Logged out.");
-    }
-  }
-  /**
-   * Initiates the OAuth login flow with the IDP via a web portal.
-   * Opens a browser for user authentication and listens for the redirect.
-   * @returns {Promise<boolean>} True if login was successful, false otherwise.
-   */
-  async login() {
-    await this.logout();
-    const { codeVerifier, codeChallenge } = generatePKCE();
-    this.codeVerifier = codeVerifier;
-    this.state = crypto.randomBytes(16).toString("hex");
-    const OAUTH_CONFIG = await getOAuthConfig();
-    const loginState = this.state;
-    if (!loginState) {
-      throw new Error("Internal error: login state not initialized");
-    }
-    const server = http.createServer();
-    let usedRedirectUri = "";
-    const serverPromise = new Promise((resolve, reject) => {
+      const tokens = yield* import_effect10.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 server = http.createServer();
       const redirectPath = "/callback";
       server.listen(0, "127.0.0.1", () => {
         const address = server.address();
         if (!address || typeof address !== "object") {
-          reject(new Error("Failed to determine callback server address"));
+          server.close(() => {
+            resume(import_effect10.Effect.fail(new LoginFlowError({ message: "Failed to determine callback server address" })));
+          });
           return;
         }
         const port = address.port;
-        usedRedirectUri = `http://127.0.0.1:${port}${redirectPath}`;
-        const authUrl = new import_node_url.URL(OAUTH_CONFIG.authorizeUrl);
-        authUrl.searchParams.append("client_id", OAUTH_CONFIG.clientId);
-        authUrl.searchParams.append("redirect_uri", usedRedirectUri);
+        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", OAUTH_CONFIG.scope);
+        authUrl.searchParams.append("scope", config.scope);
         authUrl.searchParams.append("code_challenge", codeChallenge);
         authUrl.searchParams.append("code_challenge_method", "S256");
-        authUrl.searchParams.append("state", loginState);
-        log(`Please open this URL in your browser to log in:
+        authUrl.searchParams.append("state", state);
+        import_effect10.Console.log(`Please open this URL in your browser to log in:
 ${authUrl.toString()}
-`);
-        log("Waiting for login callback...");
+`).pipe(import_effect10.Effect.runSync);
+        import_effect10.Console.log("Waiting for login callback...").pipe(import_effect10.Effect.runSync);
         void (0, import_open.default)(authUrl.toString());
-      });
-      server.on("request", (req, res) => {
-        const base = usedRedirectUri || "http://127.0.0.1/callback";
-        const reqUrl = new import_node_url.URL(req.url || "", base);
-        if (reqUrl.pathname === "/callback") {
+        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 error2 = reqUrl.searchParams.get("error");
+          const oauthError = reqUrl.searchParams.get("error");
           res.writeHead(200, { "Content-Type": "text/html", Connection: "close" });
-          if (error2) {
-            res.end("<h1>Login Failed!</h1><p>Error: " + error2 + "</p><p>You can close this tab.</p>");
-            reject(new Error(`OAuth error: ${error2}`));
+          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(import_effect10.Effect.fail(new LoginFlowError({ message: `OAuth error: ${oauthError}` })));
             return;
           }
-          if (receivedState !== this.state) {
-            res.end("<h1>Login Failed!</h1><p>State mismatch. Possible CSRF attack.</p><p>You can close this tab.</p>");
-            reject(new Error("State mismatch"));
+          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(import_effect10.Effect.fail(new LoginFlowError({ message: "State mismatch" })));
             return;
           }
           if (authCode) {
             res.end("<h1>Login Successful!</h1><p>You can close this tab.</p>");
-            resolve(authCode);
             server.close();
+            resume(import_effect10.Effect.succeed({ authCode, redirectUri }));
           } else {
             res.end("<h1>Login Failed!</h1><p>No authorization code received.</p><p>You can close this tab.</p>");
-            reject(new Error("No authorization code received"));
             server.close();
+            resume(import_effect10.Effect.fail(new LoginFlowError({ message: "No authorization code received" })));
           }
-        } else {
-          res.writeHead(404).end("Not Found");
-        }
+        });
+        server.on("error", (err) => {
+          server.close();
+          resume(import_effect10.Effect.fail(new LoginFlowError({ message: `Local server error: ${err.message}` })));
+        });
       });
-      server.on("error", (err) => {
-        console.error("Local server error:", err);
-        reject(err);
+    });
+    const login = import_effect10.Effect.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* import_effect10.Effect.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* import_effect10.Effect.log("Login successful");
+      return true;
     });
-    try {
-      const authCode = await serverPromise;
-      const tokenResponse = await fetch(OAUTH_CONFIG.tokenUrl, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/x-www-form-urlencoded"
-        },
-        body: new import_node_url.URLSearchParams({
-          grant_type: "authorization_code",
-          client_id: OAUTH_CONFIG.clientId,
-          code: authCode,
-          ...usedRedirectUri ? { redirect_uri: usedRedirectUri } : {},
-          code_verifier: this.codeVerifier || ""
-          // Use the stored codeVerifier
-        }).toString()
+    const refreshAccessToken = import_effect10.Effect.gen(function* () {
+      const stored = yield* storage.load.pipe(
+        import_effect10.Effect.catchTag("AuthStorageReadError", (err) => import_effect10.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 })))
+      );
+      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 response = yield* import_effect10.Effect.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 (!tokenResponse.ok) {
-        const errorData = await tokenResponse.json().catch(() => null);
-        throw new Error(
-          `Token exchange failed: ${tokenResponse.status} ${tokenResponse.statusText} - ${errorData ? JSON.stringify(errorData) : "Unknown error"}`
+      if (!response.ok) {
+        if (response.status === 400) {
+          yield* logout.pipe(import_effect10.Effect.catchAll(() => import_effect10.Effect.void));
+          return yield* import_effect10.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({
+          try: () => response.text(),
+          catch: () => new TokenRefreshError({ message: "Failed to read refresh error response" })
+        });
+        return yield* import_effect10.Effect.fail(
+          new TokenRefreshError({
+            message: `Token refresh failed: ${response.status} ${response.statusText} - ${body}`,
+            statusCode: response.status
+          })
         );
       }
-      const tokens = await tokenResponse.json();
-      this.accessToken = tokens.access_token;
-      this.tokenExpirationTime = Date.now() + (tokens.expires_in || 3600) * 1e3;
-      if (tokens.refresh_token) {
-        await this._saveStoredAuthData({
-          refreshToken: tokens.refresh_token,
-          accessToken: this.accessToken,
-          tokenExpirationTime: this.tokenExpirationTime
-        });
-        success("Login successful!");
-        return true;
-      } else {
-        console.error("Error: No refresh token received from Gigadrive IDP.");
-        return false;
+      const tokens = yield* import_effect10.Effect.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(import_effect10.Effect.catchAll(() => import_effect10.Effect.void));
+      yield* import_effect10.Effect.log("Access token refreshed successfully");
+      return true;
+    });
+    const getAccessToken = import_effect10.Effect.gen(function* () {
+      if (accessToken && Date.now() < tokenExpirationTime) {
+        return accessToken;
       }
-    } catch (error2) {
-      const errorMessage = error2 instanceof Error ? error2.message : "Unknown error";
-      console.error("Login process failed:", errorMessage);
-      this.accessToken = null;
-      this.tokenExpirationTime = 0;
-      return false;
-    } finally {
-      this.codeVerifier = null;
-      this.state = null;
-    }
-  }
-  /**
-   * Refreshes the access token using the stored refresh token.
-   * This method implicitly loads the refresh token from local storage.
-   * @returns {Promise<boolean>} True if refresh was successful, false otherwise.
-   */
-  async refreshAccessToken() {
-    const storedData = await this._loadStoredAuthData();
-    const OAUTH_CONFIG = await getOAuthConfig();
-    if (!storedData?.refreshToken) {
-      error("No refresh token available for refresh. Please log in.");
-      return false;
-    }
-    try {
-      const tokenResponse = await fetch(OAUTH_CONFIG.tokenUrl, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/x-www-form-urlencoded"
+      const stored = yield* storage.load.pipe(
+        import_effect10.Effect.catchAll(() => import_effect10.Effect.succeed(import_effect10.Option.none()))
+      );
+      import_effect10.Option.match(stored, {
+        onNone: () => {
         },
-        body: new import_node_url.URLSearchParams({
-          grant_type: "refresh_token",
-          client_id: OAUTH_CONFIG.clientId,
-          refresh_token: storedData.refreshToken
-        }).toString()
-      });
-      if (!tokenResponse.ok) {
-        const errorData = await tokenResponse.json().catch(() => null);
-        if (tokenResponse.status === 400 && errorData && (errorData.error === "oauth_token_not_found" || errorData.errors?.[0]?.code === "token_invalid" || errorData.errors?.[0]?.code === "token_expired" || errorData.errors?.[0]?.code === "token_revoked")) {
-          console.error("Refresh token is invalid or expired. Please log in again.");
-          await this.logout();
-          return false;
+        onSome: (data) => {
+          if (data.accessToken && data.tokenExpirationTime && Date.now() < data.tokenExpirationTime) {
+            accessToken = data.accessToken;
+            tokenExpirationTime = data.tokenExpirationTime;
+          }
         }
-        throw new Error(
-          `Token refresh failed: ${tokenResponse.status} ${tokenResponse.statusText} - ${errorData ? JSON.stringify(errorData) : "Unknown error"}`
-        );
+      });
+      if (accessToken && Date.now() < tokenExpirationTime) {
+        return accessToken;
       }
-      const tokens = await tokenResponse.json();
-      this.accessToken = tokens.access_token;
-      this.tokenExpirationTime = Date.now() + (tokens.expires_in || 3600) * 1e3;
-      const newRefreshToken = tokens.refresh_token || storedData.refreshToken;
-      if (tokens.refresh_token && tokens.refresh_token !== storedData.refreshToken) {
-        console.debug("New refresh token received and updated.");
+      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 })))
+      );
+      if (!accessToken) {
+        return yield* import_effect10.Effect.fail(
+          new NotAuthenticatedError({ message: "No valid access token available. Please log in first." })
+        );
       }
-      await this._saveStoredAuthData({
-        refreshToken: newRefreshToken,
-        accessToken: this.accessToken,
-        tokenExpirationTime: this.tokenExpirationTime
+      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)}`
+        })
       });
-      console.debug("Access token refreshed successfully!");
-      return true;
-    } catch (error2) {
-      const errorMessage = error2 instanceof Error ? error2.message : "Unknown error";
-      console.error("Error refreshing access token:", errorMessage);
-      this.accessToken = null;
-      this.tokenExpirationTime = 0;
-      return false;
-    }
-  }
-  /**
-   * Provides the current valid access token. If the in-memory token is expired,
-   * it attempts to refresh it using the stored refresh token.
-   * @returns {Promise<string | null>} The valid access token or null if no session.
-   */
-  async getAccessToken() {
-    if (this.accessToken && Date.now() < this.tokenExpirationTime) {
-      return this.accessToken;
-    }
-    console.debug("Access token expired or not available. Attempting to refresh...");
-    if (await this.refreshAccessToken()) {
-      return this.accessToken;
-    }
-    error("No valid access token available. Please log in first.");
-    return null;
-  }
-  /**
-   * Fetches the current user's information from the configured userinfo endpoint.
-   * Attempts a single token refresh and retry on 401/403 responses.
-   */
-  async getUserInfo() {
-    const OAUTH_CONFIG = await getOAuthConfig();
-    const currentToken = await this.getAccessToken();
-    if (!currentToken) {
-      error("Not authenticated. Please log in.");
-      return null;
-    }
-    const fetchUserInfo = async (token) => fetch(OAUTH_CONFIG.userinfoUrl, {
-      headers: {
-        Authorization: `Bearer ${token}`,
-        Accept: "application/json"
+      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);
       }
-    });
-    let response = await fetchUserInfo(currentToken);
-    if (response.status === 401 || response.status === 403) {
-      const refreshed = await this.refreshAccessToken();
-      if (!refreshed || !this.accessToken) {
-        return null;
+      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
+          })
+        );
       }
-      response = await fetchUserInfo(this.accessToken);
-    }
-    if (!response.ok) {
-      const body = await response.text().catch(() => "");
-      throw new Error(
-        `Failed to fetch user info: ${response.status} ${response.statusText}${body ? ` - ${body}` : ""}`
-      );
-    }
-    const data = await response.json();
-    return data;
-  }
+      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 };
+  })
+}) {
 };
-var authManager = new AuthManager();
 
 // src/commands/login/index.ts
-var login = (program) => {
-  program.command("login").description("Login to the platform").action(async () => {
-    log("Initiating login...");
-    const result = await authManager.login();
-    if (result) {
-      try {
-        const info = await authManager.getUserInfo() ?? {};
-        const isNonEmptyString = (value) => typeof value === "string" && value.trim() !== "";
-        const nameField = info.name;
-        const givenNameField = info.given_name;
-        const familyNameField = info.family_name;
-        const preferredUsernameField = info.preferred_username;
-        const emailField = info.email;
-        const inferredName = isNonEmptyString(nameField) && nameField || (isNonEmptyString(givenNameField) && isNonEmptyString(familyNameField) ? `${givenNameField} ${familyNameField}` : void 0) || isNonEmptyString(preferredUsernameField) && preferredUsernameField || isNonEmptyString(emailField) && emailField || "your account";
-        success(`You are now logged in as ${inferredName}.`);
-      } catch {
-        success("You are now logged in.");
-      }
-    } else {
-      error("Login failed. Please try again.");
-    }
-  });
-};
+var loginCommand = import_cli4.Command.make(
+  "login",
+  {},
+  () => import_effect11.Effect.gen(function* () {
+    yield* import_effect11.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 name = auth.inferUserName(info);
+    yield* import_effect11.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}`)
+    })
+  )
+);
+
+// src/commands/platform/index.ts
+var import_cli6 = require("@effect/cli");
+var import_effect15 = require("effect");
 
 // src/commands/platform/deploy/index.ts
-var import_commons = require("@gigadrive/commons");
-var import_network_config2 = require("@gigadrive/network-config");
-var import_fs4 = __toESM(require("fs"), 1);
-var import_os = __toESM(require("os"), 1);
-var import_path4 = __toESM(require("path"), 1);
+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);
 
-// src/util/zip.ts
-var import_build_utils2 = require("@gigadrive/build-utils");
+// src/services/archive.ts
+var import_platform4 = require("@effect/platform");
+var import_build_utils3 = require("@gigadrive/build-utils");
 var import_archiver = __toESM(require("archiver"), 1);
-var import_fs3 = __toESM(require("fs"), 1);
-var import_promises = __toESM(require("fs/promises"), 1);
+var import_effect12 = require("effect");
 var import_ignore = __toESM(require("ignore"), 1);
-var import_path3 = __toESM(require("path"), 1);
-var ignoreFileNames = [
-  /*'.gitignore', */
-  ".gigadriveignore",
-  ".vercelignore",
-  ".dockerignore",
-  ".nowignore"
-];
-async function readIgnoreFile(ignorePath) {
-  try {
-    await import_promises.default.access(ignorePath);
-    const content = await import_promises.default.readFile(ignorePath, "utf8");
-    return content.split("\n").filter((line) => line.trim() !== "");
-  } catch {
-    return [];
-  }
-}
-async function collectIgnorePatterns(dir, baseDir, ignoreRules) {
-  const items = await import_promises.default.readdir(dir);
+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([]))
+);
+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}` })));
   for (const item of items) {
-    const fullPath = import_path3.default.join(dir, item);
-    const relativePath = import_path3.default.relative(baseDir, fullPath);
-    const stat = await import_promises.default.lstat(fullPath);
+    const fullPath = pathService.join(dir, item);
+    const relativePath = pathService.relative(baseDir, fullPath);
+    const stat = yield* import_effect12.Effect.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 = import_path3.default.join(fullPath, ignoreFileName);
-        try {
-          await import_promises.default.access(ignoreFilePath);
-          const patterns = (await readIgnoreFile(ignoreFilePath)).map((pattern) => {
-            return pattern.startsWith("!") ? `!${import_path3.default.join(relativePath, pattern.slice(1))}` : import_path3.default.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(import_effect12.Effect.catchAll(() => import_effect12.Effect.void));
+var initializeIgnoreRules = (fs, pathService, baseDir) => import_effect12.Effect.gen(function* () {
   const ignoreRules = (0, import_ignore.default)();
   ignoreRules.add([".git/", "**/.DS_Store", "**/Thumbs.db"]);
-  for (const ignoreFileName of ignoreFileNames) {
-    const ignoreFilePath = import_path3.default.join(baseDir, ignoreFileName);
-    try {
-      await import_promises.default.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) => import_effect12.Effect.gen(function* () {
   const filesToInclude = [];
-  async function walkDir(currentDir) {
-    const items = await import_promises.default.readdir(currentDir);
+  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}` })));
     for (const item of items) {
-      const fullPath = import_path3.default.join(currentDir, item);
-      const relativePath = import_path3.default.relative(dir, fullPath);
-      const stat = await import_promises.default.lstat(fullPath);
+      const fullPath = pathService.join(currentDir, item);
+      const relativePath = pathService.relative(dir, fullPath);
+      const stat = yield* import_effect12.Effect.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(import_effect12.Effect.catchAll(() => import_effect12.Effect.void));
+  yield* walkDir(dir);
   return filesToInclude;
-}
-async function createZipArchive(inputDir, outputFile, options = {}) {
-  const ignoreRules = options.useIgnoreFiles !== false ? await initializeIgnoreRules(inputDir) : (0, import_ignore.default)();
-  const filesToInclude = options.whitelist ? await Promise.all(options.whitelist.map((file) => (0, import_build_utils2.getFilesForPattern)(inputDir, file))) : await getFilesToInclude(inputDir, ignoreRules);
-  const output = import_fs3.default.createWriteStream(outputFile);
-  const archive = (0, import_archiver.default)("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: import_path3.default.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 = (0, import_network_config2.findConfig)(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 (0, import_network_config2.parseConfig)(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 import_effect12.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 });
+      const ignoreRules = options.useIgnoreFiles !== false ? yield* initializeIgnoreRules(fs, pathService, inputDir) : (0, import_ignore.default)();
+      const filesToInclude = options.whitelist ? yield* import_effect12.Effect.tryPromise({
+        try: () => Promise.all(
+          options.whitelist.map((file) => (0, import_build_utils3.getFilesForPattern)(file, inputDir, options.excludeFiles ?? []))
+        ),
+        catch: (error) => new ArchiveCreateError({
+          message: "Failed to resolve whitelist patterns",
+          cause: error instanceof Error ? error.message : String(error)
+        })
+      }) : yield* import_effect12.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])
+        );
       });
-    }
-    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(import_effect12.Effect.catchAll(() => import_effect12.Effect.succeed(false)));
+      if (archiveExists) {
+        yield* fs.remove(outputFile).pipe(
+          import_effect12.Effect.mapError(
+            (error) => new ArchiveCreateError({
+              message: `Failed to remove existing archive: ${String(error)}`
+            })
+          )
+        );
+      }
+      yield* import_effect12.Effect.tryPromise({
+        try: () => new Promise((resolve, reject) => {
+          const output = nodeFs.createWriteStream(outputFile);
+          const archive = (0, import_archiver.default)("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(
+        import_effect12.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 });
+      return { path: outputFile, size };
     });
-    debug(`Deployment ID: ${deploymentId}`);
-    debug("Starting deployment process");
-    await handleDeployment(deploymentId, config2);
-  });
+    return { createZipArchive };
+  })
+}) {
 };
-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}`);
+
+// 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", {
+  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({})
+        }),
+        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
+          })
+        );
       }
-    })();
-  }, 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* 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;
+    });
+    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 }
+        }),
+        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" })
         });
-        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* 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;
+    });
+    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 }
           }
-        }
-      } 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* 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 })
+        );
       }
-    })();
-  }, 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 = import_path4.default.join(process.env.TEMP || import_os.default.tmpdir(), `project-${Date.now()}.zip`);
-  debug(`Archive path: ${archivePath}`);
-  if (import_fs4.default.existsSync(archivePath)) {
-    debug(`Archive already exists, removing: ${archivePath}`);
-    import_fs4.default.unlinkSync(archivePath);
-  }
-  debug("Creating zip archive");
-  await createZipArchive(config2.userArchive?.rootOverwrite || process.cwd(), archivePath, {
-    whitelist: config2.userArchive?.fileWhitelist,
-    useIgnoreFiles: false,
-    useManagedIgnore: false
-  });
-  const fileStats = import_fs4.default.statSync(archivePath);
-  const fileSize = fileStats.size;
-  debug(`Archive created, size: ${fileSize} bytes (${(0, import_commons.formatFileSize)(fileSize)})`);
-  addLog(`Archive created (${(0, import_commons.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 promises2 = [];
-  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 = import_fs4.default.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* 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;
     });
-    promises2.push(promise);
-  }
-  const finishedParts = [];
-  try {
-    debug(`Waiting for all ${promises2.length} upload promises to complete`);
-    const responses = await Promise.all(promises2);
-    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 = 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
+        }),
+        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 = 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* import_effect13.Effect.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 = 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 })
+        }),
+        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* 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}` }));
       }
-    }
-  );
-  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;
+      yield* import_effect13.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 }
+        }),
+        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;
+    });
+    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 }
+        }),
+        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" })
+      });
+      const decoded = yield* import_effect13.Schema.decodeUnknown(DeploymentLogPageResponse)(json).pipe(
+        import_effect13.Effect.mapError(() => new DeploymentLogsFetchError({ message: "Invalid logs response schema" }))
+      );
+      return decoded;
+    });
+    return {
+      createDeployment,
+      startMultipartUpload,
+      getPresignedUrl,
+      uploadPart,
+      completeUpload,
+      getDeploymentStatus,
+      getLogs
+    };
+  })
+}) {
 };
-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
+
+// src/commands/platform/deploy/index.ts
+var deployCommand = import_cli5.Command.make(
+  "deploy",
+  {},
+  () => import_effect14.Effect.gen(function* () {
+    const projectConfig = yield* ProjectConfigService;
+    const deploymentApi = yield* DeploymentApiService;
+    const archiveService = yield* ArchiveService;
+    const pathService = yield* import_platform5.Path.Path;
+    const cwd = process.cwd();
+    yield* import_effect14.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`);
+    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* 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* 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* () {
+        for (const e of err.errors) {
+          yield* import_effect14.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)))
+    })
+  )
+);
+var uploadArchive = (deploymentId, archivePath, fileSize) => import_effect14.Effect.gen(function* () {
+  const deploymentApi = yield* DeploymentApiService;
+  const fs = yield* import_platform5.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(
+    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* () {
+        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 arrays = Array.from(chunks);
+            return Buffer.concat(arrays);
+          }),
+          import_effect14.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 });
+        return yield* deploymentApi.uploadPart(presignedUrl, chunkData, partNumber);
+      });
     }),
-    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${(0, import_commons.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);
+    { concurrency: 3 }
+  );
+  yield* deploymentApi.completeUpload(deploymentId, uploadId, parts);
+});
+var pollDeployment = (deploymentId) => import_effect14.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)));
+      if (newStatus !== lastStatus) {
+        lastStatus = newStatus;
+        const label = newStatus.charAt(0) + newStatus.slice(1).toLowerCase();
+        yield* import_effect14.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)));
+      if (logsPage) {
+        for (const logEntry of logsPage.items) {
+          logOffset++;
+          yield* printLog(logEntry);
+        }
+      }
+      if (newStatus === "ACTIVE") {
+        yield* import_effect14.Console.log(`Deployed to https://${deploymentId}.gigadrivedev.com`);
+        return yield* import_effect14.Effect.fail("done");
+      }
+      if (newStatus === "FAILED") {
+        return yield* import_effect14.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))
+  ).pipe(
+    import_effect14.Effect.catchAll((err) => {
+      if (err === "done") return import_effect14.Effect.void;
+      return import_effect14.Effect.fail(err);
+    })
+  );
+});
+var printLog = (logEntry) => {
+  switch (logEntry.type) {
+    case "ERROR":
+      return import_effect14.Console.error(logEntry.message);
+    case "WARN":
+      return import_effect14.Console.warn(logEntry.message);
+    default:
+      return import_effect14.Console.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 = import_cli6.Command.make("platform", {}, () => import_effect15.Effect.void);
+var platformCommand = platformBase.pipe(import_cli6.Command.withSubcommands([deployCommand]));
 
 // src/commands/whoami/index.ts
-var whoami = (program) => {
-  program.command("whoami").description("Show the currently authenticated user information").action(async () => {
-    try {
-      const info = await authManager.getUserInfo();
-      if (!info) {
-        console.log('You are not logged in. Run "gigadrive login" to authenticate.');
-        return;
-      }
-      console.log(JSON.stringify(info, null, 2));
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      console.error(`Failed to retrieve user info: ${msg}`);
-    }
-  });
-};
+var import_cli7 = require("@effect/cli");
+var import_effect16 = require("effect");
+var whoamiCommand = import_cli7.Command.make(
+  "whoami",
+  {},
+  () => import_effect16.Effect.gen(function* () {
+    const auth = yield* AuthService;
+    const info = yield* auth.getUserInfo;
+    yield* import_effect16.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}`)
+    })
+  )
+);
 
 // 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 import_commander.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);
-  login(program);
-  whoami(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 = import_cli8.Command.make("gigadrive", {}, () => import_effect17.Effect.void).pipe(
+  import_cli8.Command.withSubcommands([loginCommand, whoamiCommand, buildCommand, debugCommand, platformCommand])
+);
+var cli = import_cli8.Command.run(gigadrive, {
+  name: "Gigadrive CLI",
+  version: "2.0.0"
 });
-main().then((exitCode) => {
-  process.exit(exitCode);
-}).catch(handleUnexpected);
+var BaseServices = import_effect17.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));
 //# sourceMappingURL=index.cjs.map