gigadrive 1.1.1 → 2.0.0

package/dist/index.mjs

@@ -3,6 +3,45 @@
 // src/index.ts
 import { Command } from "commander";
 
+// src/util/log.ts
+import { createConsola } from "consola";
+var verbose = false;
+var consola = createConsola({
+  level: verbose ? 4 : 3,
+  // 4 includes debug messages, 3 is the default (info and above)
+  formatOptions: {
+    colors: true
+  }
+});
+var updateConsola = () => {
+  consola.level = verbose ? 4 : 3;
+};
+var setVerbose = (value) => {
+  verbose = value;
+  updateConsola();
+};
+var log = (message) => {
+  consola.info(message);
+};
+var error = (message) => {
+  consola.error(message);
+};
+var success = (message) => {
+  consola.success(message);
+};
+var warn = (message) => {
+  consola.warn(message);
+};
+var debug = (message, ...optionalParams) => {
+  if (!verbose) {
+    return;
+  }
+  consola.debug("[DEBUG]", message, ...optionalParams);
+};
+var spinner = (message) => {
+  log(message);
+};
+
 // src/commands/build/index.ts
 import { exec as exec2 } from "@gigadrive/build-utils";
 import fs2 from "fs";
@@ -17,7 +56,7 @@ import { spawn } from "child_process";
 async function exec({
   command,
   cwd = process.cwd(),
-  env,
+  env: env2,
   onOutput = (data) => console.log(data),
   onError = (data) => console.error(data)
 }) {
@@ -35,7 +74,7 @@ async function exec({
     const childProcess = spawn(spawnCommand, spawnArgs, {
       cwd,
       shell: true,
-      env
+      env: env2
     });
     childProcess.stdout.on("data", (data) => {
       onOutput(data.toString().trim());
@@ -77,7 +116,7 @@ var getPackageManager = async ({ cwd }) => {
   try {
     await exec({ command: "bun --version", cwd });
     return "bun";
-  } catch (e) {
+  } catch {
     return "npm";
   }
 };
@@ -101,7 +140,7 @@ var buildCommand = (pm) => {
 // src/commands/build/index.ts
 var build = (parent) => {
   parent.command("build").description("Build the current project").action(async () => {
-    const env = {
+    const env2 = {
       ...process.env,
       NODE_ENV: "production",
       NEBULA: "1",
@@ -112,34 +151,34 @@ var build = (parent) => {
     const cwd = process.cwd();
     const packageJsonPath = path2.join(cwd, "package.json");
     if (!fs2.existsSync(packageJsonPath)) {
-      console.log("No package.json found");
+      error("No package.json found");
       return;
     }
     const packageJson = JSON.parse(fs2.readFileSync(packageJsonPath, "utf-8"));
     const buildScript = packageJson.scripts?.build;
     if (!buildScript) {
-      console.log("No build script found in package.json");
+      error("No build script found in package.json");
       return;
     }
     const packageManager = await getPackageManager({ cwd });
     if (!packageManager) {
-      console.log("No package manager found");
+      error("No package manager found");
       return;
     }
     await exec2({
       command: installCommand(packageManager),
       cwd,
-      env,
+      env: env2,
       onOutput: (chunk) => {
-        console.log(chunk);
+        log(chunk);
       }
     });
     await exec2({
       command: buildCommand(packageManager),
       cwd,
-      env,
+      env: env2,
       onOutput: (chunk) => {
-        console.log(chunk);
+        log(chunk);
       }
     });
   });
@@ -148,47 +187,6 @@ var build = (parent) => {
 // src/commands/debug/config/index.ts
 import { findConfig, parseConfig } from "@gigadrive/network-config";
 import { log as log2 } from "console";
-
-// src/util/log.ts
-import { createConsola } from "consola";
-var verbose = false;
-var consola = createConsola({
-  level: verbose ? 4 : 3,
-  // 4 includes debug messages, 3 is the default (info and above)
-  formatOptions: {
-    colors: true
-  }
-});
-var updateConsola = () => {
-  consola.level = verbose ? 4 : 3;
-};
-var setVerbose = (value) => {
-  verbose = value;
-  updateConsola();
-};
-var log = (message) => {
-  consola.info(message);
-};
-var error = (message) => {
-  consola.error(message);
-};
-var success = (message) => {
-  consola.success(message);
-};
-var warn = (message) => {
-  consola.warn(message);
-};
-var debug = (message, ...optionalParams) => {
-  if (!verbose) {
-    return;
-  }
-  consola.debug("[DEBUG]", message, ...optionalParams);
-};
-var spinner = (message) => {
-  log(message);
-};
-
-// src/commands/debug/config/index.ts
 var config = (parent) => {
   parent.command("config").description("Provide debug info about the project configuration in the current directory").action(async () => {
     const configPath = findConfig(process.cwd());
@@ -208,19 +206,441 @@ var debug2 = (program) => {
   config(debug3);
 };
 
+// src/env.ts
+import { createEnv } from "@t3-oss/env-core";
+import { config as loadEnv } from "dotenv";
+import fs3 from "fs";
+import path3 from "path";
+import { z } from "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 = path3.join(cwd, filename);
+    if (fs3.existsSync(fullPath)) {
+      console.debug(`Loading environment variables from ${fullPath}`);
+      loadEnv({ path: fullPath, override: false });
+    }
+  }
+})();
+var env = createEnv({
+  server: {
+    GIGADRIVE_NETWORK_OAUTH_ISSUER_URL: z.url().min(1).default("https://idp.gigadrive.de"),
+    GIGADRIVE_NETWORK_OAUTH_CLIENT_ID: z.string().min(1).default("todo_add_client_id")
+  },
+  runtimeEnv: process.env,
+  emptyStringAsUndefined: true
+});
+
+// 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/auth/manager.ts
+import * as crypto from "crypto";
+import * as fs4 from "fs";
+import * as http from "http";
+import * as os from "os";
+import * as path4 from "path";
+import { URL, URLSearchParams } from "url";
+import open from "open";
+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() {
+  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;
+      }
+      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 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"));
+          return;
+        }
+        const port = address.port;
+        usedRedirectUri = `http://127.0.0.1:${port}${redirectPath}`;
+        const authUrl = new URL(OAUTH_CONFIG.authorizeUrl);
+        authUrl.searchParams.append("client_id", OAUTH_CONFIG.clientId);
+        authUrl.searchParams.append("redirect_uri", usedRedirectUri);
+        authUrl.searchParams.append("response_type", "code");
+        authUrl.searchParams.append("scope", OAUTH_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.toString()}
+`);
+        log("Waiting for login callback...");
+        void open(authUrl.toString());
+      });
+      server.on("request", (req, res) => {
+        const base = usedRedirectUri || "http://127.0.0.1/callback";
+        const reqUrl = new URL(req.url || "", base);
+        if (reqUrl.pathname === "/callback") {
+          const authCode = reqUrl.searchParams.get("code");
+          const receivedState = reqUrl.searchParams.get("state");
+          const error2 = 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}`));
+            server.close();
+            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"));
+            server.close();
+            return;
+          }
+          if (authCode) {
+            res.end("<h1>Login Successful!</h1><p>You can close this tab.</p>");
+            resolve(authCode);
+            server.close();
+          } 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();
+          }
+        } else {
+          res.writeHead(404).end("Not Found");
+        }
+      });
+      server.on("error", (err) => {
+        console.error("Local server error:", err);
+        reject(err);
+      });
+    });
+    try {
+      const authCode = await serverPromise;
+      const tokenResponse = await fetch(OAUTH_CONFIG.tokenUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded"
+        },
+        body: new 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()
+      });
+      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"}`
+        );
+      }
+      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;
+      }
+    } 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"
+        },
+        body: new 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;
+        }
+        throw new Error(
+          `Token refresh failed: ${tokenResponse.status} ${tokenResponse.statusText} - ${errorData ? JSON.stringify(errorData) : "Unknown error"}`
+        );
+      }
+      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.");
+      }
+      await this._saveStoredAuthData({
+        refreshToken: newRefreshToken,
+        accessToken: this.accessToken,
+        tokenExpirationTime: this.tokenExpirationTime
+      });
+      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 = await fetchUserInfo(currentToken);
+    if (response.status === 401 || response.status === 403) {
+      const refreshed = await this.refreshAccessToken();
+      if (!refreshed || !this.accessToken) {
+        return null;
+      }
+      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;
+  }
+};
+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.");
+    }
+  });
+};
+
 // src/commands/platform/deploy/index.ts
 import { formatFileSize, objectToQueryString } from "@gigadrive/commons";
 import { findConfig as findConfig2, parseConfig as parseConfig2 } from "@gigadrive/network-config";
-import fs4 from "fs";
-import os from "os";
-import path4 from "path";
+import fs6 from "fs";
+import os2 from "os";
+import path6 from "path";
 
 // src/util/zip.ts
 import { getFilesForPattern } from "@gigadrive/build-utils";
 import archiver from "archiver";
-import fs3 from "fs";
+import fs5 from "fs";
+import fsPromises from "fs/promises";
 import ignore from "ignore";
-import path3 from "path";
+import path5 from "path";
 var ignoreFileNames = [
   /*'.gitignore', */
   ".gigadriveignore",
@@ -228,89 +648,95 @@ var ignoreFileNames = [
   ".dockerignore",
   ".nowignore"
 ];
-function readIgnoreFile(ignorePath) {
-  if (fs3.existsSync(ignorePath)) {
-    return fs3.readFileSync(ignorePath, "utf8").split("\n").filter((line) => line.trim() !== "");
+async function readIgnoreFile(ignorePath) {
+  try {
+    await fsPromises.access(ignorePath);
+    const content = await fsPromises.readFile(ignorePath, "utf8");
+    return content.split("\n").filter((line) => line.trim() !== "");
+  } catch {
+    return [];
   }
-  return [];
 }
-function collectIgnorePatterns(dir, baseDir, ignoreRules) {
-  const items = fs3.readdirSync(dir);
-  items.forEach((item) => {
-    const fullPath = path3.join(dir, item);
-    const relativePath = path3.relative(baseDir, fullPath);
-    const stat = fs3.lstatSync(fullPath);
+async function collectIgnorePatterns(dir, baseDir, ignoreRules) {
+  const items = await fsPromises.readdir(dir);
+  for (const item of items) {
+    const fullPath = path5.join(dir, item);
+    const relativePath = path5.relative(baseDir, fullPath);
+    const stat = await fsPromises.lstat(fullPath);
     if (stat.isDirectory()) {
       if (ignoreRules.ignores(`${relativePath}/`)) {
-        return;
+        continue;
       }
-      ignoreFileNames.forEach((ignoreFileName) => {
-        const ignoreFilePath = path3.join(fullPath, ignoreFileName);
-        if (fs3.existsSync(ignoreFilePath)) {
-          const patterns = readIgnoreFile(ignoreFilePath).map((pattern) => {
-            return pattern.startsWith("!") ? `!${path3.join(relativePath, pattern.slice(1))}` : path3.join(relativePath, pattern);
+      for (const ignoreFileName of ignoreFileNames) {
+        const ignoreFilePath = path5.join(fullPath, ignoreFileName);
+        try {
+          await fsPromises.access(ignoreFilePath);
+          const patterns = (await readIgnoreFile(ignoreFilePath)).map((pattern) => {
+            return pattern.startsWith("!") ? `!${path5.join(relativePath, pattern.slice(1))}` : path5.join(relativePath, pattern);
           });
           ignoreRules.add(patterns);
+        } catch {
         }
-      });
-      collectIgnorePatterns(fullPath, baseDir, ignoreRules);
+      }
+      await collectIgnorePatterns(fullPath, baseDir, ignoreRules);
     }
-  });
+  }
 }
-function initializeIgnoreRules(baseDir) {
+async function initializeIgnoreRules(baseDir) {
   const ignoreRules = ignore();
   ignoreRules.add([".git/", "**/.DS_Store", "**/Thumbs.db"]);
-  ignoreFileNames.forEach((ignoreFileName) => {
-    const ignoreFilePath = path3.join(baseDir, ignoreFileName);
-    if (fs3.existsSync(ignoreFilePath)) {
-      const patterns = readIgnoreFile(ignoreFilePath).map((pattern) => {
+  for (const ignoreFileName of ignoreFileNames) {
+    const ignoreFilePath = path5.join(baseDir, ignoreFileName);
+    try {
+      await fsPromises.access(ignoreFilePath);
+      const patterns = (await readIgnoreFile(ignoreFilePath)).map((pattern) => {
         return pattern.startsWith("!") ? `!${pattern.slice(1)}` : pattern;
       });
       ignoreRules.add(patterns);
+    } catch {
     }
-  });
-  collectIgnorePatterns(baseDir, baseDir, ignoreRules);
+  }
+  await collectIgnorePatterns(baseDir, baseDir, ignoreRules);
   return ignoreRules;
 }
 async function getFilesToInclude(dir, ignoreRules, whitelist) {
   const filesToInclude = [];
-  function walkSync(currentDir) {
-    const items = fs3.readdirSync(currentDir);
-    items.forEach((item) => {
-      const fullPath = path3.join(currentDir, item);
-      const relativePath = path3.relative(dir, fullPath);
-      const stat = fs3.lstatSync(fullPath);
+  async function walkDir(currentDir) {
+    const items = await fsPromises.readdir(currentDir);
+    for (const item of items) {
+      const fullPath = path5.join(currentDir, item);
+      const relativePath = path5.relative(dir, fullPath);
+      const stat = await fsPromises.lstat(fullPath);
       if (stat.isDirectory()) {
         if (ignoreRules.ignores(`${relativePath}/`)) {
-          return;
+          continue;
         }
-        walkSync(fullPath);
+        await walkDir(fullPath);
       } else {
         if (!ignoreRules.ignores(relativePath)) {
           filesToInclude.push(fullPath);
         } else if (ignoreRules.ignores(relativePath) && ignoreRules.test(relativePath).unignored) {
           filesToInclude.push(fullPath);
-        } else {
         }
       }
-    });
+    }
   }
-  walkSync(dir);
+  await walkDir(dir);
   return filesToInclude;
 }
 async function createZipArchive(inputDir, outputFile, options = {}) {
-  const ignoreRules = options.useIgnoreFiles !== false ? initializeIgnoreRules(inputDir) : ignore();
+  const ignoreRules = options.useIgnoreFiles !== false ? await initializeIgnoreRules(inputDir) : ignore();
   const filesToInclude = options.whitelist ? await Promise.all(options.whitelist.map((file) => getFilesForPattern(inputDir, file))) : await getFilesToInclude(inputDir, ignoreRules);
-  const output = fs3.createWriteStream(outputFile);
+  const output = fs5.createWriteStream(outputFile);
   const archive = archiver("zip", { zlib: { level: 9 } });
   return new Promise((resolve, reject) => {
     output.on("close", () => resolve());
     archive.on("error", reject);
     archive.pipe(output);
-    filesToInclude.forEach((file) => {
-      archive.file(file, { name: path3.relative(inputDir, file) });
-    });
-    archive.finalize();
+    for (const file of filesToInclude.flat()) {
+      archive.file(file, { name: path5.relative(inputDir, file) });
+    }
+    void archive.finalize();
   });
 }
 
@@ -367,53 +793,57 @@ var handleDeployment = async (deploymentId, config2) => {
     error("The deployment failed. Please check the logs for more information.");
     process.exit(1);
   }
-  const statusInterval = setInterval(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.");
+  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;
         }
-        return;
-      }
-      if (newStatus !== status) {
-        debug(`Updating status from ${status} to ${newStatus}`);
-        status = newStatus;
-        spinner(`Status: ${status.toLowerCase().replace(/^\w/, (c) => c.toUpperCase())}`);
+        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}`);
       }
-    } catch (err) {
-      debug(`Error fetching status: ${err.message}`);
-    }
+    })();
   }, 1e3);
-  const logsInterval = setInterval(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
-      });
-      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);
+  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
+        });
+        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);
+          }
         }
+      } catch (err) {
+        debug(`Error fetching logs: ${err.message}`);
       }
-    } catch (err) {
-      debug(`Error fetching logs: ${err.message}`);
-    }
+    })();
   }, 1e3);
   spinner(`Status: ${status.toLowerCase().replace(/^\w/, (c) => c.toUpperCase())}`);
 };
@@ -436,11 +866,11 @@ var addLog = (message, type, logs) => {
 var uploadArchive = async (deploymentId, logs, config2) => {
   debug("Starting uploadArchive");
   addLog("Creating archive...", "INFO", logs);
-  const archivePath = path4.join(process.env.TEMP || os.tmpdir(), `project-${Date.now()}.zip`);
+  const archivePath = path6.join(process.env.TEMP || os2.tmpdir(), `project-${Date.now()}.zip`);
   debug(`Archive path: ${archivePath}`);
-  if (fs4.existsSync(archivePath)) {
+  if (fs6.existsSync(archivePath)) {
     debug(`Archive already exists, removing: ${archivePath}`);
-    fs4.unlinkSync(archivePath);
+    fs6.unlinkSync(archivePath);
   }
   debug("Creating zip archive");
   await createZipArchive(config2.userArchive?.rootOverwrite || process.cwd(), archivePath, {
@@ -448,7 +878,7 @@ var uploadArchive = async (deploymentId, logs, config2) => {
     useIgnoreFiles: false,
     useManagedIgnore: false
   });
-  const fileStats = fs4.statSync(archivePath);
+  const fileStats = fs6.statSync(archivePath);
   const fileSize = fileStats.size;
   debug(`Archive created, size: ${fileSize} bytes (${formatFileSize(fileSize)})`);
   addLog(`Archive created (${formatFileSize(fileSize)})`, "INFO", logs);
@@ -460,7 +890,7 @@ var uploadArchive = async (deploymentId, logs, config2) => {
   const fileChunkSize = 10 * 1024 * 1024;
   const numChunks = Math.ceil(fileSize / fileChunkSize);
   debug(`File size: ${fileSize}, chunk size: ${fileChunkSize}, number of chunks: ${numChunks}`);
-  const promises = [];
+  const promises2 = [];
   let start, end;
   for (let index = 1; index < numChunks + 1; index++) {
     start = (index - 1) * fileChunkSize;
@@ -468,42 +898,44 @@ var uploadArchive = async (deploymentId, logs, config2) => {
     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(async (resolve, reject) => {
-      try {
-        debug(`Reading chunk ${index} data`);
-        const readStream = fs4.createReadStream(archivePath, {
-          start,
-          end: index < numChunks ? end - 1 : void 0
-        });
-        const chunks = [];
-        readStream.on("data", (chunk) => {
-          chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
-        });
-        await new Promise((resolveRead) => {
-          readStream.on("end", () => resolveRead());
-          readStream.on("error", reject);
-        });
-        const buffer = Buffer.concat(chunks);
-        debug(`Uploading chunk ${index} to presigned URL (${buffer.length} bytes)`);
-        const response = await fetch(presignedUrl, {
-          method: "PUT",
-          headers: {
-            "Content-Type": "application/zip",
-            "Content-Length": String(buffer.length)
-          },
-          body: buffer
-        });
-        resolve(response);
-      } catch (err) {
-        reject(err);
-      }
+    const promise = new Promise((resolve, reject) => {
+      void (async () => {
+        try {
+          debug(`Reading chunk ${index} data`);
+          const readStream = fs6.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)));
+        }
+      })();
     });
-    promises.push(promise);
+    promises2.push(promise);
   }
   const finishedParts = [];
   try {
-    debug(`Waiting for all ${promises.length} upload promises to complete`);
-    const responses = await Promise.all(promises);
+    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];
@@ -627,7 +1059,7 @@ var getDeploymentStatus = async (deploymentId) => {
   return deployment.status;
 };
 var getLogs = async (deploymentId, options) => {
-  debug(`Getting logs for deployment: ${deploymentId}, options:`, options);
+  debug(`Getting logs for deployment: ${deploymentId}, options:`, options ?? "No options");
   const res = await fetch(`http://localhost:3000/deployments/${deploymentId}/logs${objectToQueryString(options)}`, {
     method: "GET",
     headers: {
@@ -650,6 +1082,23 @@ var platform = (program) => {
   deploy(platform2);
 };
 
+// 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}`);
+    }
+  });
+};
+
 // src/index.ts
 var { isTTY } = process.stdout;
 var main = async () => {
@@ -661,7 +1110,7 @@ var main = async () => {
   let exitCode = 0;
   const program = new Command();
   program.option("-v, --verbose", "Enable verbose logging", false);
-  program.hook("preSubcommand", (thisCommand, actionCommand) => {
+  program.hook("preSubcommand", (thisCommand) => {
     setVerbose(thisCommand.opts().verbose === true);
     if (thisCommand.opts().verbose) {
       log("Using verbose mode");
@@ -673,6 +1122,8 @@ var main = async () => {
   platform(program);
   debug2(program);
   build(program);
+  login(program);
+  whoami(program);
   try {
     await program.parseAsync(process.argv);
   } catch (err) {
@@ -681,13 +1132,13 @@ var main = async () => {
   }
   return exitCode;
 };
-var handleRejection = async (err) => {
+var handleRejection = (err) => {
   if (err) {
     if (err instanceof Error) {
-      await handleUnexpected(err);
+      handleUnexpected(err);
     } else {
       console.error(`An unexpected rejection occurred
-  ${err}`);
+  ${JSON.stringify(err)}`);
     }
   } else {
     console.error("An unexpected empty rejection occurred");
@@ -706,7 +1157,7 @@ process.on("exit", () => {
   const terminal = process.stderr.isTTY ? process.stderr : process.stdout.isTTY ? process.stdout : void 0;
   terminal?.write("\x1B[?25h");
 });
-main().then(async (exitCode) => {
-  process.exitCode = exitCode;
+main().then((exitCode) => {
+  process.exit(exitCode);
 }).catch(handleUnexpected);
 //# sourceMappingURL=index.mjs.map