@turboops/cli 1.0.0-dev.579 → 1.0.0-dev.580

package/dist/index.js

@@ -196,6 +196,10 @@ var API_URLS = {
   production: "https://api.turbo-ops.de",
   dev: "https://api.dev.turbo-ops.de"
 };
+var APP_URLS = {
+  production: "https://turbo-ops.de",
+  dev: "https://dev.turbo-ops.de"
+};
 function getDefaultApiUrl() {
   const version = getCurrentVersion();
   const isDevVersion = version.includes("-dev");
@@ -232,6 +236,15 @@ var configService = {
   setApiUrl(url) {
     config.set("apiUrl", url);
   },
+  /**
+   * Get App URL (frontend)
+   * Returns the appropriate frontend URL based on CLI version
+   */
+  getAppUrl() {
+    const version = getCurrentVersion();
+    const isDevVersion = version.includes("-dev");
+    return isDevVersion ? APP_URLS.dev : APP_URLS.production;
+  },
   /**
    * Get authentication token
    */
@@ -336,7 +349,6 @@ var configService = {
 
 // src/commands/login.ts
 import { Command } from "commander";
-import prompts from "prompts";
 
 // src/services/api.ts
 function isProjectToken(token) {
@@ -634,6 +646,137 @@ var apiClient = {
   }
 };
 
+// src/services/auth.ts
+import os from "os";
+var authService = {
+  /**
+   * Start browser-based authentication flow
+   * Returns the auth code and URL for the browser
+   */
+  async initAuth() {
+    const apiUrl = configService.getApiUrl();
+    const version = getCurrentVersion();
+    const platform = os.platform();
+    const hostname = os.hostname();
+    try {
+      const response = await fetch(`${apiUrl}/cli/auth/init`, {
+        body: JSON.stringify({
+          cliVersion: version,
+          hostname,
+          platform
+        }),
+        headers: {
+          "Content-Type": "application/json"
+        },
+        method: "POST"
+      });
+      if (!response.ok) {
+        return null;
+      }
+      return await response.json();
+    } catch {
+      return null;
+    }
+  },
+  /**
+   * Poll for authentication status
+   */
+  async pollAuth(code, pollToken) {
+    const apiUrl = configService.getApiUrl();
+    try {
+      const response = await fetch(`${apiUrl}/cli/auth/poll/${code}`, {
+        headers: {
+          "X-Poll-Token": pollToken
+        }
+      });
+      if (!response.ok) {
+        return { status: "expired" };
+      }
+      return await response.json();
+    } catch {
+      return { status: "expired" };
+    }
+  },
+  /**
+   * Validate a CLI token
+   */
+  async validateToken(token) {
+    const apiUrl = configService.getApiUrl();
+    try {
+      const response = await fetch(`${apiUrl}/cli/auth/validate`, {
+        headers: {
+          Authorization: `Bearer ${token}`
+        }
+      });
+      if (!response.ok) {
+        return { valid: false };
+      }
+      return await response.json();
+    } catch {
+      return { valid: false };
+    }
+  },
+  /**
+   * Perform browser-based login
+   * Opens browser, waits for user to authorize, returns user info
+   */
+  async browserLogin() {
+    const open = (await import("open")).default;
+    logger.info("Initialisiere Anmeldung...");
+    const authInit = await this.initAuth();
+    if (!authInit) {
+      return { error: "Konnte Authentifizierung nicht initialisieren", success: false };
+    }
+    logger.newline();
+    logger.info("Bitte autorisieren Sie die CLI in Ihrem Browser.");
+    logger.newline();
+    logger.info(`Autorisierungscode: ${authInit.code}`);
+    logger.newline();
+    try {
+      await open(authInit.authUrl);
+      logger.info("Browser wurde ge\xF6ffnet...");
+    } catch {
+      logger.warning("Browser konnte nicht ge\xF6ffnet werden.");
+      logger.info(`Bitte \xF6ffnen Sie diese URL manuell: ${authInit.authUrl}`);
+    }
+    logger.newline();
+    logger.info("Warte auf Autorisierung...");
+    const maxAttempts = 150;
+    const pollInterval = 2e3;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const result = await this.pollAuth(authInit.code, authInit.pollToken);
+      if (result.status === "authorized" && result.token) {
+        configService.setToken(result.token);
+        if (result.user) {
+          configService.setUserId(result.user.id);
+        }
+        return {
+          success: true,
+          user: result.user
+        };
+      }
+      if (result.status === "expired" || result.status === "consumed") {
+        return { error: "Autorisierungscode abgelaufen oder bereits verwendet", success: false };
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+    return { error: "Zeit\xFCberschreitung bei der Anmeldung", success: false };
+  },
+  /**
+   * Check if current token is a CLI token and validate it
+   */
+  async checkCliToken() {
+    const token = configService.getToken();
+    if (!token) {
+      return { valid: false };
+    }
+    if (!token.startsWith("turbo_cli_")) {
+      return { valid: true };
+    }
+    return await this.validateToken(token);
+  }
+};
+
 // src/utils/spinner.ts
 import ora from "ora";
 function createSpinner(text) {
@@ -660,60 +803,59 @@ var loginCommand = new Command("login").description("Authenticate with TurboOps
   logger.header("TurboOps Login");
   if (options.token) {
     configService.setToken(options.token);
-    const { data: data2, error: error2 } = await withSpinner(
+    if (options.token.startsWith("turbo_cli_")) {
+      const { data: data2, error: error2 } = await withSpinner("Verifying token...", async () => {
+        const result2 = await authService.validateToken(options.token);
+        if (result2.valid && result2.user) {
+          return { data: result2.user, error: void 0 };
+        }
+        return { data: void 0, error: "Invalid token" };
+      });
+      if (error2 || !data2) {
+        configService.clearToken();
+        logger.error(`Authentication failed: ${error2 || "Invalid token"}`);
+        process.exit(10 /* AUTH_ERROR */);
+      }
+      configService.setUserId(data2.id);
+      addJsonData({
+        authenticated: true,
+        user: { email: data2.email, id: data2.id }
+      });
+      logger.success(`Authenticated as ${data2.email}`);
+      return;
+    }
+    const { data, error } = await withSpinner(
       "Verifying token...",
       () => apiClient.whoami()
     );
-    if (error2 || !data2) {
+    if (error || !data) {
       configService.clearToken();
-      logger.error(`Authentication failed: ${error2 || "Invalid token"}`);
+      logger.error(`Authentication failed: ${error || "Invalid token"}`);
       process.exit(10 /* AUTH_ERROR */);
     }
-    configService.setUserId(data2.id);
+    configService.setUserId(data.id);
     addJsonData({
       authenticated: true,
-      user: { id: data2.id, email: data2.email }
+      user: { email: data.email, id: data.id }
     });
-    logger.success(`Authenticated as ${data2.email}`);
+    logger.success(`Authenticated as ${data.email}`);
     return;
   }
-  const response = await prompts([
-    {
-      type: "text",
-      name: "email",
-      message: "Email:",
-      validate: (value) => value.includes("@") || "Please enter a valid email"
-    },
-    {
-      type: "password",
-      name: "password",
-      message: "Password:"
-    }
-  ]);
-  if (!response.email || !response.password) {
-    logger.warning("Login cancelled");
-    addJsonData({ authenticated: false, cancelled: true });
-    return;
-  }
-  const { data, error } = await withSpinner(
-    "Logging in...",
-    () => apiClient.login(response.email, response.password)
-  );
-  if (error || !data) {
-    logger.error(`Login failed: ${error || "Unknown error"}`);
-    addJsonData({ authenticated: false, error: error || "Unknown error" });
+  const result = await authService.browserLogin();
+  if (!result.success) {
+    logger.error(`Login failed: ${result.error || "Unknown error"}`);
+    addJsonData({ authenticated: false, error: result.error || "Unknown error" });
     process.exit(10 /* AUTH_ERROR */);
   }
-  configService.setToken(data.token);
-  configService.setUserId(data.user.id);
   addJsonData({
     authenticated: true,
-    user: { id: data.user.id, email: data.user.email }
+    user: result.user ? { email: result.user.email, fullName: result.user.fullName, id: result.user.id } : void 0
   });
-  logger.success(`Logged in as ${data.user.email}`);
   logger.newline();
-  logger.info("Your credentials have been saved.");
-  logger.info("Run `turbo whoami` to verify your authentication.");
+  logger.success(`Angemeldet als ${result.user?.email || "Unknown"}`);
+  logger.newline();
+  logger.info("Ihre Anmeldedaten wurden gespeichert.");
+  logger.info("F\xFChren Sie `turbo whoami` aus, um Ihre Authentifizierung zu \xFCberpr\xFCfen.");
 });
 var logoutCommand = new Command("logout").description("Remove stored authentication").action(() => {
   configService.clearToken();
@@ -726,6 +868,36 @@ var whoamiCommand = new Command("whoami").description("Show current authenticate
     addJsonData({ authenticated: false });
     process.exit(10 /* AUTH_ERROR */);
   }
+  const token = configService.getToken();
+  if (token?.startsWith("turbo_cli_")) {
+    const { data: data2, error: error2 } = await withSpinner("Fetching user info...", async () => {
+      const result = await authService.validateToken(token);
+      if (result.valid && result.user) {
+        return { data: result.user, error: void 0 };
+      }
+      return { data: void 0, error: "Invalid token" };
+    });
+    if (error2 || !data2) {
+      logger.error(`Failed to fetch user info: ${error2 || "Unknown error"}`);
+      addJsonData({ authenticated: false, error: error2 || "Unknown error" });
+      process.exit(13 /* API_ERROR */);
+    }
+    addJsonData({
+      authenticated: true,
+      user: {
+        email: data2.email,
+        id: data2.id,
+        name: data2.fullName || null
+      }
+    });
+    logger.header("Current User");
+    logger.table({
+      Email: data2.email,
+      ID: data2.id,
+      Name: data2.fullName || "-"
+    });
+    return;
+  }
   const { data, error } = await withSpinner(
     "Fetching user info...",
     () => apiClient.whoami()
@@ -738,15 +910,15 @@ var whoamiCommand = new Command("whoami").description("Show current authenticate
   addJsonData({
     authenticated: true,
     user: {
-      id: data.id,
       email: data.email,
+      id: data.id,
       name: data.name || null
     }
   });
   logger.header("Current User");
   logger.table({
-    ID: data.id,
     Email: data.email,
+    ID: data.id,
     Name: data.name || "-"
   });
 });
@@ -1151,128 +1323,105 @@ envCommand.addCommand(envUnsetCommand);
 
 // src/commands/init.ts
 import { Command as Command5 } from "commander";
-import prompts2 from "prompts";
+import prompts from "prompts";
 import chalk6 from "chalk";
 var initCommand = new Command5("init").description("Initialize TurboOps project in current directory").action(async () => {
   logger.header("TurboOps Project Initialization");
   if (!configService.isAuthenticated()) {
-    logger.warning("Not authenticated. Please log in first.");
+    logger.warning("Nicht authentifiziert. Bitte melden Sie sich zuerst an.");
     logger.newline();
-    const { shouldLogin } = await prompts2({
-      type: "confirm",
+    const { shouldLogin } = await prompts({
+      initial: true,
+      message: "M\xF6chten Sie sich jetzt anmelden?",
       name: "shouldLogin",
-      message: "Would you like to log in now?",
-      initial: true
+      type: "confirm"
     });
     if (!shouldLogin) {
-      logger.info("Run `turbo login` when ready.");
+      logger.info("F\xFChren Sie `turbo login` aus, wenn Sie bereit sind.");
       addJsonData({ initialized: false, reason: "not_authenticated" });
       return;
     }
-    const credentials = await prompts2([
-      {
-        type: "text",
-        name: "email",
-        message: "Email:",
-        validate: (value) => value.includes("@") || "Please enter a valid email"
-      },
-      {
-        type: "password",
-        name: "password",
-        message: "Password:"
-      }
-    ]);
-    if (!credentials.email || !credentials.password) {
-      logger.warning("Login cancelled");
-      addJsonData({ initialized: false, reason: "login_cancelled" });
-      return;
-    }
-    const { data, error } = await withSpinner(
-      "Logging in...",
-      () => apiClient.login(credentials.email, credentials.password)
-    );
-    if (error || !data) {
-      logger.error(`Login failed: ${error || "Unknown error"}`);
+    const result = await authService.browserLogin();
+    if (!result.success) {
+      logger.error(`Anmeldung fehlgeschlagen: ${result.error || "Unbekannter Fehler"}`);
       addJsonData({
+        error: result.error || "Unknown error",
         initialized: false,
-        reason: "login_failed",
-        error: error || "Unknown error"
+        reason: "login_failed"
       });
       process.exit(10 /* AUTH_ERROR */);
     }
-    configService.setToken(data.token);
-    configService.setUserId(data.user.id);
-    logger.success(`Logged in as ${data.user.email}`);
+    logger.success(`Angemeldet als ${result.user?.email || "Unknown"}`);
   }
   logger.newline();
-  const { projectSlug } = await prompts2({
-    type: "text",
+  const { projectSlug } = await prompts({
+    hint: "Der Slug Ihres TurboOps-Projekts",
+    message: "Projekt-Slug:",
     name: "projectSlug",
-    message: "Project slug:",
-    hint: "The slug of your TurboOps project",
-    validate: (value) => value.length > 0 || "Project slug is required"
+    type: "text",
+    validate: (value) => value.length > 0 || "Projekt-Slug ist erforderlich"
   });
   if (!projectSlug) {
-    logger.warning("Initialization cancelled");
+    logger.warning("Initialisierung abgebrochen");
     addJsonData({ initialized: false, reason: "cancelled" });
     return;
   }
   const { data: project, error: projectError } = await withSpinner(
-    "Verifying project...",
+    "Verifiziere Projekt...",
     () => apiClient.getProject(projectSlug)
   );
   if (projectError || !project) {
     logger.error(
-      `Project "${projectSlug}" not found or you don't have access.`
+      `Projekt "${projectSlug}" nicht gefunden oder Sie haben keinen Zugriff.`
     );
     logger.info(
-      "Make sure the project exists in TurboOps and you have permission to access it."
+      "Stellen Sie sicher, dass das Projekt in TurboOps existiert und Sie die Berechtigung haben, darauf zuzugreifen."
     );
     addJsonData({
       initialized: false,
-      reason: "project_not_found",
-      projectSlug
+      projectSlug,
+      reason: "project_not_found"
     });
     process.exit(12 /* NOT_FOUND */);
   }
   configService.setProject(projectSlug);
   logger.newline();
-  logger.success("Project initialized!");
+  logger.success("Projekt initialisiert!");
   logger.newline();
-  logger.header("Project Details");
+  logger.header("Projektdetails");
   logger.table({
     Name: project.name,
-    Slug: project.slug,
-    Repository: project.repositoryUrl || "-"
+    Repository: project.repositoryUrl || "-",
+    Slug: project.slug
   });
   const { data: environments } = await apiClient.getEnvironments(project.id);
   const envList = environments && environments.length > 0 ? environments.map((env) => ({
-    slug: env.slug,
     name: env.name,
+    slug: env.slug,
     type: env.type
   })) : [];
   addJsonData({
+    environments: envList,
     initialized: true,
     project: {
       name: project.name,
-      slug: project.slug,
-      repositoryUrl: project.repositoryUrl || null
-    },
-    environments: envList
+      repositoryUrl: project.repositoryUrl || null,
+      slug: project.slug
+    }
   });
   if (environments && environments.length > 0) {
     logger.newline();
-    logger.header("Available Environments");
+    logger.header("Verf\xFCgbare Umgebungen");
     for (const env of environments) {
       console.log(`  ${chalk6.bold(env.slug)} - ${env.name} (${env.type})`);
     }
   }
   logger.newline();
-  logger.header("Next Steps");
+  logger.header("N\xE4chste Schritte");
   logger.list([
-    "Run `turbo status` to see all environments",
-    "Run `turbo deploy <environment>` to deploy",
-    "Run `turbo logs <environment>` to view logs"
+    "F\xFChren Sie `turbo status` aus, um alle Umgebungen zu sehen",
+    "F\xFChren Sie `turbo deploy <umgebung>` aus, um zu deployen",
+    "F\xFChren Sie `turbo logs <umgebung>` aus, um Logs anzuzeigen"
   ]);
 });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@turboops/cli",
-  "version": "1.0.0-dev.579",
+  "version": "1.0.0-dev.580",
   "description": "TurboCLI - Command line interface for TurboOps deployments",
   "author": "lenne.tech GmbH",
   "license": "MIT",
@@ -26,6 +26,7 @@
     "chalk": "^5.3.0",
     "commander": "^12.1.0",
     "conf": "^13.0.1",
+    "open": "^10.1.0",
     "ora": "^8.0.1",
     "prompts": "^2.4.2",
     "socket.io-client": "^4.7.0"