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

package/dist/index.js

@@ -6,6 +6,8 @@ import chalk8 from "chalk";
 
 // src/services/config.ts
 import Conf from "conf";
+import * as fs from "fs";
+import * as path from "path";
 
 // src/utils/logger.ts
 import chalk from "chalk";
@@ -133,9 +135,9 @@ function loadPackageJson() {
     join(__dirname, "../package.json")
     // From dist/
   ];
-  for (const path of paths) {
-    if (existsSync(path)) {
-      return require2(path);
+  for (const path2 of paths) {
+    if (existsSync(path2)) {
+      return require2(path2);
     }
   }
   return { version: "0.0.0", name: "@turboops/cli" };
@@ -200,41 +202,76 @@ var APP_URLS = {
   production: "https://turbo-ops.de",
   dev: "https://dev.turbo-ops.de"
 };
-function getDefaultApiUrl() {
-  const version = getCurrentVersion();
-  const isDevVersion = version.includes("-dev");
-  return isDevVersion ? API_URLS.dev : API_URLS.production;
-}
-var defaults = {
-  apiUrl: API_URLS.production,
+var LOCAL_CONFIG_FILE = ".turboops.json";
+var globalDefaults = {
   token: null,
-  project: null,
   userId: null
 };
-var config = new Conf({
+var globalConfig = new Conf({
   projectName: "turboops-cli",
-  defaults
+  defaults: globalDefaults
 });
+function findProjectRoot() {
+  let currentDir = process.cwd();
+  const root = path.parse(currentDir).root;
+  while (currentDir !== root) {
+    if (fs.existsSync(path.join(currentDir, LOCAL_CONFIG_FILE))) {
+      return currentDir;
+    }
+    if (fs.existsSync(path.join(currentDir, ".git"))) {
+      return currentDir;
+    }
+    if (fs.existsSync(path.join(currentDir, "package.json"))) {
+      return currentDir;
+    }
+    currentDir = path.dirname(currentDir);
+  }
+  return null;
+}
+function getLocalConfigPath() {
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    return null;
+  }
+  return path.join(projectRoot, LOCAL_CONFIG_FILE);
+}
+function readLocalConfig() {
+  const configPath = getLocalConfigPath();
+  if (!configPath || !fs.existsSync(configPath)) {
+    return null;
+  }
+  try {
+    const content = fs.readFileSync(configPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function writeLocalConfig(config) {
+  const projectRoot = findProjectRoot() || process.cwd();
+  const configPath = path.join(projectRoot, LOCAL_CONFIG_FILE);
+  try {
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+    return true;
+  } catch (error) {
+    logger.error(`Failed to write ${LOCAL_CONFIG_FILE}: ${error}`);
+    return false;
+  }
+}
+function getApiUrl() {
+  const version = getCurrentVersion();
+  const isDevVersion = version.includes("-dev");
+  return isDevVersion ? API_URLS.dev : API_URLS.production;
+}
 var configService = {
   /**
-   * Get API URL
-   * Priority: ENV variable > stored config > version-based default
+   * Get API URL (fixed based on CLI version)
    */
   getApiUrl() {
     if (process.env.TURBOOPS_API_URL) {
       return process.env.TURBOOPS_API_URL;
     }
-    const storedUrl = config.get("apiUrl");
-    if (storedUrl === "https://api.turboops.io" || storedUrl === API_URLS.production) {
-      return getDefaultApiUrl();
-    }
-    return storedUrl;
-  },
-  /**
-   * Set API URL
-   */
-  setApiUrl(url) {
-    config.set("apiUrl", url);
+    return getApiUrl();
   },
   /**
    * Get App URL (frontend)
@@ -246,53 +283,65 @@ var configService = {
     return isDevVersion ? APP_URLS.dev : APP_URLS.production;
   },
   /**
-   * Get authentication token
+   * Get authentication token (global - user session)
    */
   getToken() {
-    return process.env.TURBOOPS_TOKEN || config.get("token");
+    return process.env.TURBOOPS_TOKEN || globalConfig.get("token");
   },
   /**
-   * Set authentication token
+   * Set authentication token (global - user session)
    */
   setToken(token) {
-    config.set("token", token);
+    globalConfig.set("token", token);
   },
   /**
    * Clear authentication token
    */
   clearToken() {
-    config.set("token", null);
-    config.set("userId", null);
+    globalConfig.set("token", null);
+    globalConfig.set("userId", null);
   },
   /**
-   * Get current project
+   * Get current project (local - project specific)
    */
   getProject() {
-    return process.env.TURBOOPS_PROJECT || config.get("project");
+    if (process.env.TURBOOPS_PROJECT) {
+      return process.env.TURBOOPS_PROJECT;
+    }
+    const localConfig = readLocalConfig();
+    return localConfig?.project || null;
   },
   /**
-   * Set current project
+   * Set current project (local - writes to .turboops.json)
    */
   setProject(project) {
-    config.set("project", project);
+    const localConfig = readLocalConfig() || { project: "" };
+    localConfig.project = project;
+    writeLocalConfig(localConfig);
   },
   /**
    * Clear current project
    */
   clearProject() {
-    config.set("project", null);
+    const configPath = getLocalConfigPath();
+    if (configPath && fs.existsSync(configPath)) {
+      try {
+        fs.unlinkSync(configPath);
+      } catch {
+      }
+    }
   },
   /**
-   * Get user ID
+   * Get user ID (global - user session)
    */
   getUserId() {
-    return config.get("userId");
+    return globalConfig.get("userId");
   },
   /**
-   * Set user ID
+   * Set user ID (global - user session)
    */
   setUserId(userId) {
-    config.set("userId", userId);
+    globalConfig.set("userId", userId);
   },
   /**
    * Check if user is authenticated
@@ -306,6 +355,19 @@ var configService = {
   hasProject() {
     return !!this.getProject();
   },
+  /**
+   * Check if local config exists
+   */
+  hasLocalConfig() {
+    const configPath = getLocalConfigPath();
+    return !!configPath && fs.existsSync(configPath);
+  },
+  /**
+   * Get local config file path (for display purposes)
+   */
+  getLocalConfigPath() {
+    return getLocalConfigPath();
+  },
   /**
    * Get all configuration
    */
@@ -318,17 +380,25 @@ var configService = {
     };
   },
   /**
-   * Clear all configuration
+   * Clear all configuration (both global and local)
    */
   clearAll() {
-    config.clear();
+    globalConfig.clear();
+    this.clearProject();
   },
   /**
-   * Check if using a project token (turbo_xxx format)
+   * Check if using a project token (turbo_xxx format, but not turbo_cli_xxx)
    */
   isProjectToken() {
     const token = this.getToken();
-    return !!token && token.startsWith("turbo_");
+    return !!token && token.startsWith("turbo_") && !token.startsWith("turbo_cli_");
+  },
+  /**
+   * Check if using a CLI session token (turbo_cli_xxx format)
+   */
+  isCliSessionToken() {
+    const token = this.getToken();
+    return !!token && token.startsWith("turbo_cli_");
   },
   /**
    * Show current configuration
@@ -336,12 +406,15 @@ var configService = {
   show() {
     const data = this.getAll();
     const isProjectToken2 = this.isProjectToken();
+    const isCliToken = this.isCliSessionToken();
+    const localConfigPath = this.getLocalConfigPath();
     logger.header("Configuration");
     logger.table({
       "API URL": data.apiUrl,
       Token: data.token || "Not set",
-      "Token Type": isProjectToken2 ? "Project Token" : data.token ? "User Token" : "N/A",
+      "Token Type": isProjectToken2 ? "Project Token (CI/CD)" : isCliToken ? "CLI Session Token" : data.token ? "User Token" : "N/A",
       Project: data.project || (isProjectToken2 ? "(from token)" : "Not set"),
+      "Project Config": localConfigPath || "(not found)",
       "User ID": data.userId || (isProjectToken2 ? "(N/A for project token)" : "Not set")
     });
   }
@@ -359,7 +432,7 @@ var apiClient = {
   /**
    * Make an API request
    */
-  async request(method, path, body) {
+  async request(method, path2, body) {
     const apiUrl = configService.getApiUrl();
     const token = configService.getToken();
     if (!token) {
@@ -368,7 +441,7 @@ var apiClient = {
         status: 401
       };
     }
-    const url = `${apiUrl}${path}`;
+    const url = `${apiUrl}${path2}`;
     const headers = {
       "Content-Type": "application/json",
       Authorization: `Bearer ${token}`
@@ -513,23 +586,66 @@ var apiClient = {
     return this.request("GET", `/deployment/projects/by-slug/${slug}`);
   },
   /**
-   * Get environments for project
+   * Create a new project
+   */
+  async createProject(data) {
+    const payload = {
+      name: data.name,
+      slug: data.slug
+    };
+    if (data.customer) payload.customer = data.customer;
+    if (data.description) payload.description = data.description;
+    if (data.repositoryUrl) payload.repositoryUrl = data.repositoryUrl;
+    return this.request("POST", "/deployment/projects/simple", payload);
+  },
+  /**
+   * Get all customers
+   */
+  async getCustomers() {
+    return this.request("GET", "/customer");
+  },
+  /**
+   * Get environments (stages) for project
    */
   async getEnvironments(projectId) {
     return this.request(
       "GET",
-      `/deployment/environments?projectId=${projectId}`
+      `/deployment/stages?projectId=${projectId}`
     );
   },
   /**
-   * Get environment by slug
+   * Get environment (stage) by slug
    */
   async getEnvironmentBySlug(projectId, slug) {
     return this.request(
       "GET",
-      `/deployment/environments/by-slug/${projectId}/${slug}`
+      `/deployment/stages/by-slug/${projectId}/${slug}`
     );
   },
+  /**
+   * Create a new stage
+   */
+  async createStage(data) {
+    return this.request("POST", "/deployment/stages/simple", data);
+  },
+  /**
+   * Get deployment-ready servers
+   */
+  async getDeploymentServers() {
+    return this.request("GET", "/server?deploymentReady=true");
+  },
+  /**
+   * Generate CI/CD pipeline configuration
+   */
+  async generatePipeline(projectId, type) {
+    return this.request("GET", `/deployment/projects/${projectId}/pipeline/${type}`);
+  },
+  /**
+   * Get required secrets for pipeline
+   */
+  async getPipelineSecrets(projectId, type) {
+    return this.request("GET", `/deployment/projects/${projectId}/pipeline/${type}/secrets`);
+  },
   /**
    * Trigger deployment
    */
@@ -560,7 +676,7 @@ var apiClient = {
   async restart(environmentId) {
     return this.request(
       "POST",
-      `/deployment/environments/${environmentId}/restart`
+      `/deployment/stages/${environmentId}/restart`
     );
   },
   /**
@@ -569,7 +685,7 @@ var apiClient = {
   async stop(environmentId) {
     return this.request(
       "POST",
-      `/deployment/environments/${environmentId}/stop`
+      `/deployment/stages/${environmentId}/stop`
     );
   },
   /**
@@ -578,7 +694,7 @@ var apiClient = {
   async wake(environmentId) {
     return this.request(
       "POST",
-      `/deployment/environments/${environmentId}/wake`
+      `/deployment/stages/${environmentId}/wake`
     );
   },
   /**
@@ -593,7 +709,7 @@ var apiClient = {
   async getEnvVars(environmentId) {
     return this.request(
       "GET",
-      `/deployment/environments/${environmentId}/env-vars`
+      `/deployment/stages/${environmentId}/env-vars`
     );
   },
   /**
@@ -602,7 +718,7 @@ var apiClient = {
   async setEnvVar(environmentId, key, value, secret) {
     return this.request(
       "PUT",
-      `/deployment/environments/${environmentId}/env-vars`,
+      `/deployment/stages/${environmentId}/env-vars`,
       {
         key,
         value,
@@ -616,7 +732,7 @@ var apiClient = {
   async deleteEnvVar(environmentId, key) {
     return this.request(
       "DELETE",
-      `/deployment/environments/${environmentId}/env-vars/${key}`
+      `/deployment/stages/${environmentId}/env-vars/${key}`
     );
   },
   /**
@@ -1206,11 +1322,77 @@ var statusCommand = new Command3("status").description("Show deployment status")
     });
   }
 });
-var configCommand = new Command3("config").description("Show current configuration").action(() => {
-  const config2 = configService.getAll();
-  addJsonData({ config: config2 });
+var configCommand = new Command3("config").description("Manage configuration");
+configCommand.command("show", { isDefault: true }).description("Show current configuration").action(() => {
+  const config = configService.getAll();
+  addJsonData({ config });
   configService.show();
 });
+configCommand.command("set").description("Set a configuration value").argument("<key>", "Configuration key (token, project)").argument("<value>", "Value to set").action((key, value) => {
+  switch (key.toLowerCase()) {
+    case "token":
+      configService.setToken(value);
+      logger.success("Token saved (global)");
+      addJsonData({ key: "token", saved: true, scope: "global" });
+      break;
+    case "project":
+      configService.setProject(value);
+      logger.success(`Project saved to .turboops.json`);
+      addJsonData({ key: "project", value, saved: true, scope: "local" });
+      break;
+    default:
+      logger.error(`Unknown config key: ${key}`);
+      logger.info("Available keys: token, project");
+      addJsonData({ error: `Unknown config key: ${key}` });
+      process.exit(14 /* VALIDATION_ERROR */);
+  }
+});
+configCommand.command("get").description("Get a configuration value").argument("<key>", "Configuration key (token, project, api-url)").action((key) => {
+  let value = null;
+  switch (key.toLowerCase()) {
+    case "token":
+      value = configService.getToken();
+      if (value) {
+        console.log("***");
+        addJsonData({ key: "token", set: true });
+      } else {
+        console.log("(not set)");
+        addJsonData({ key: "token", set: false });
+      }
+      return;
+    case "project":
+      value = configService.getProject();
+      break;
+    case "api-url":
+      value = configService.getApiUrl();
+      break;
+    default:
+      logger.error(`Unknown config key: ${key}`);
+      logger.info("Available keys: token, project, api-url");
+      addJsonData({ error: `Unknown config key: ${key}` });
+      process.exit(14 /* VALIDATION_ERROR */);
+  }
+  console.log(value || "(not set)");
+  addJsonData({ key, value });
+});
+configCommand.command("clear").description("Clear configuration").option("--all", "Clear all configuration").option("--token", "Clear token only").option("--project", "Clear project only").action((opts) => {
+  if (opts.all) {
+    configService.clearAll();
+    logger.success("All configuration cleared");
+    addJsonData({ cleared: "all" });
+  } else if (opts.token) {
+    configService.clearToken();
+    logger.success("Token cleared");
+    addJsonData({ cleared: "token" });
+  } else if (opts.project) {
+    configService.clearProject();
+    logger.success("Project configuration cleared");
+    addJsonData({ cleared: "project" });
+  } else {
+    logger.error("Specify what to clear: --all, --token, or --project");
+    process.exit(14 /* VALIDATION_ERROR */);
+  }
+});
 function getStatusColor(status) {
   switch (status) {
     case "healthy":
@@ -1367,24 +1549,294 @@ var initCommand = new Command5("init").description("Initialize TurboOps project
     return;
   }
   const { data: project, error: projectError } = await withSpinner(
-    "Verifiziere Projekt...",
+    "Suche Projekt...",
     () => apiClient.getProject(projectSlug)
   );
-  if (projectError || !project) {
-    logger.error(
-      `Projekt "${projectSlug}" nicht gefunden oder Sie haben keinen Zugriff.`
-    );
-    logger.info(
-      "Stellen Sie sicher, dass das Projekt in TurboOps existiert und Sie die Berechtigung haben, darauf zuzugreifen."
-    );
+  if (project) {
+    await setupProject(project);
+    return;
+  }
+  logger.newline();
+  logger.warning(`Projekt "${projectSlug}" nicht gefunden.`);
+  const { shouldCreate } = await prompts({
+    initial: true,
+    message: "M\xF6chten Sie ein neues Projekt anlegen?",
+    name: "shouldCreate",
+    type: "confirm"
+  });
+  if (!shouldCreate) {
+    logger.info("Initialisierung abgebrochen.");
+    addJsonData({ initialized: false, reason: "project_not_found" });
+    return;
+  }
+  await createNewProject(projectSlug);
+});
+async function setupProject(project) {
+  configService.setProject(project.slug);
+  const { data: environments } = await apiClient.getEnvironments(project.id);
+  if (!environments || environments.length === 0) {
+    logger.newline();
+    const { shouldCreateStage } = await prompts({
+      initial: true,
+      message: "Das Projekt hat noch keine Stages. M\xF6chten Sie jetzt eine erstellen?",
+      name: "shouldCreateStage",
+      type: "confirm"
+    });
+    if (shouldCreateStage) {
+      await createFirstStage(project.id, project.slug);
+    }
+  }
+  const fs2 = await import("fs/promises");
+  const path2 = await import("path");
+  const gitlabCiPath = path2.join(process.cwd(), ".gitlab-ci.yml");
+  let hasGitLabPipeline = false;
+  try {
+    await fs2.access(gitlabCiPath);
+    hasGitLabPipeline = true;
+  } catch {
+  }
+  if (!hasGitLabPipeline) {
+    logger.newline();
+    const { shouldCreatePipeline } = await prompts({
+      initial: false,
+      message: "M\xF6chten Sie eine CI/CD Pipeline anlegen?",
+      name: "shouldCreatePipeline",
+      type: "confirm"
+    });
+    if (shouldCreatePipeline) {
+      await createPipeline(project.id);
+    }
+  }
+  await showFinalSummary(project);
+}
+async function createNewProject(slug) {
+  logger.newline();
+  logger.header("Neues Projekt erstellen");
+  const { data: customers } = await withSpinner(
+    "Lade verf\xFCgbare Kunden...",
+    () => apiClient.getCustomers()
+  );
+  const promptQuestions = [
+    {
+      initial: slug.charAt(0).toUpperCase() + slug.slice(1).replace(/-/g, " "),
+      message: "Projektname:",
+      name: "name",
+      type: "text",
+      validate: (value) => value.length > 0 || "Projektname ist erforderlich"
+    }
+  ];
+  if (customers && customers.length > 0) {
+    promptQuestions.push({
+      choices: [
+        { title: "(Kein Kunde)", value: "" },
+        ...customers.map((c) => ({ title: c.name, value: c.id }))
+      ],
+      message: "Kunde (optional):",
+      name: "customer",
+      type: "select"
+    });
+  }
+  promptQuestions.push(
+    {
+      message: "Beschreibung (optional):",
+      name: "description",
+      type: "text"
+    },
+    {
+      message: "Repository URL (optional):",
+      name: "repositoryUrl",
+      type: "text"
+    }
+  );
+  const projectDetails = await prompts(promptQuestions);
+  if (!projectDetails.name) {
+    logger.warning("Projekterstellung abgebrochen");
+    addJsonData({ initialized: false, reason: "cancelled" });
+    return;
+  }
+  const { data: newProject, error: createError } = await withSpinner(
+    "Erstelle Projekt...",
+    () => apiClient.createProject({
+      customer: projectDetails.customer || void 0,
+      description: projectDetails.description || void 0,
+      name: projectDetails.name,
+      repositoryUrl: projectDetails.repositoryUrl || void 0,
+      slug
+    })
+  );
+  if (createError || !newProject) {
+    logger.error(`Projekt konnte nicht erstellt werden: ${createError || "Unbekannter Fehler"}`);
     addJsonData({
+      error: createError || "Unknown error",
       initialized: false,
-      projectSlug,
-      reason: "project_not_found"
+      reason: "create_failed"
     });
-    process.exit(12 /* NOT_FOUND */);
+    process.exit(13 /* API_ERROR */);
   }
-  configService.setProject(projectSlug);
+  logger.success(`Projekt "${newProject.name}" wurde erstellt!`);
+  configService.setProject(newProject.slug);
+  logger.newline();
+  const { shouldCreateStage } = await prompts({
+    initial: true,
+    message: "M\xF6chten Sie jetzt die erste Stage anlegen?",
+    name: "shouldCreateStage",
+    type: "confirm"
+  });
+  if (shouldCreateStage) {
+    await createFirstStage(newProject.id, newProject.slug);
+  }
+  logger.newline();
+  const { shouldCreatePipeline } = await prompts({
+    initial: true,
+    message: "M\xF6chten Sie eine CI/CD Pipeline anlegen?",
+    name: "shouldCreatePipeline",
+    type: "confirm"
+  });
+  if (shouldCreatePipeline) {
+    await createPipeline(newProject.id);
+  }
+  await showFinalSummary(newProject);
+}
+async function createFirstStage(projectId, projectSlug) {
+  logger.newline();
+  logger.header("Erste Stage erstellen");
+  const { data: servers } = await withSpinner(
+    "Lade verf\xFCgbare Server...",
+    () => apiClient.getDeploymentServers()
+  );
+  const stageTypes = [
+    { title: "Development", value: "development" },
+    { title: "Staging", value: "staging" },
+    { title: "Production", value: "production" }
+  ];
+  const stageQuestions = [
+    {
+      choices: stageTypes,
+      initial: 0,
+      message: "Stage-Typ:",
+      name: "type",
+      type: "select"
+    },
+    {
+      initial: (prev) => prev === "production" ? "Production" : prev === "staging" ? "Staging" : "Development",
+      message: "Stage-Name:",
+      name: "name",
+      type: "text",
+      validate: (value) => value.length > 0 || "Name ist erforderlich"
+    },
+    {
+      initial: (_prev, values) => values.type || "",
+      message: "Stage-Slug:",
+      name: "slug",
+      type: "text",
+      validate: (value) => value.length > 0 || "Slug ist erforderlich"
+    },
+    {
+      initial: (_prev, values) => `${values.slug || ""}.${projectSlug}.example.com`,
+      message: "Domain:",
+      name: "domain",
+      type: "text"
+    },
+    {
+      initial: (_prev, values) => values.type === "production" ? "main" : values.type === "staging" ? "staging" : "develop",
+      message: "Branch:",
+      name: "branch",
+      type: "text"
+    }
+  ];
+  if (servers && servers.length > 0) {
+    stageQuestions.push({
+      choices: [
+        { title: "(Sp\xE4ter ausw\xE4hlen)", value: "" },
+        ...servers.map((s) => ({ title: `${s.name} (${s.host})`, value: s.id }))
+      ],
+      message: "Server (optional):",
+      name: "server",
+      type: "select"
+    });
+  }
+  const stageDetails = await prompts(stageQuestions);
+  if (!stageDetails.name || !stageDetails.slug) {
+    logger.warning("Stage-Erstellung abgebrochen");
+    return;
+  }
+  const { data: newStage, error: stageError } = await withSpinner(
+    "Erstelle Stage...",
+    () => apiClient.createStage({
+      project: projectId,
+      name: stageDetails.name,
+      slug: stageDetails.slug,
+      type: stageDetails.type,
+      domain: stageDetails.domain || void 0,
+      server: stageDetails.server || void 0,
+      branch: stageDetails.branch || void 0
+    })
+  );
+  if (stageError || !newStage) {
+    logger.error(`Stage konnte nicht erstellt werden: ${stageError || "Unbekannter Fehler"}`);
+    return;
+  }
+  logger.success(`Stage "${newStage.name}" wurde erstellt!`);
+}
+async function createPipeline(projectId) {
+  logger.newline();
+  logger.header("CI/CD Pipeline erstellen");
+  const pipelineQuestions = [
+    {
+      choices: [
+        { title: "GitLab CI/CD", value: "gitlab" },
+        { title: "GitHub Actions", value: "github" }
+      ],
+      initial: 0,
+      message: "Pipeline-Typ:",
+      name: "pipelineType",
+      type: "select"
+    }
+  ];
+  const pipelineDetails = await prompts(pipelineQuestions);
+  if (!pipelineDetails.pipelineType) {
+    logger.warning("Pipeline-Erstellung abgebrochen");
+    return;
+  }
+  const { data: pipeline, error } = await withSpinner(
+    "Generiere Pipeline...",
+    () => apiClient.generatePipeline(projectId, pipelineDetails.pipelineType)
+  );
+  if (error || !pipeline) {
+    logger.error(`Pipeline konnte nicht generiert werden: ${error || "Unbekannter Fehler"}`);
+    return;
+  }
+  const fs2 = await import("fs/promises");
+  const path2 = await import("path");
+  let filePath;
+  if (pipelineDetails.pipelineType === "github") {
+    const workflowsDir = path2.join(process.cwd(), ".github", "workflows");
+    await fs2.mkdir(workflowsDir, { recursive: true });
+    filePath = path2.join(workflowsDir, "deploy.yml");
+  } else {
+    filePath = path2.join(process.cwd(), ".gitlab-ci.yml");
+  }
+  try {
+    await fs2.writeFile(filePath, pipeline.content, "utf-8");
+    logger.success(`${pipeline.filename} wurde erstellt!`);
+    logger.newline();
+    const { data: secrets } = await apiClient.getPipelineSecrets(projectId, pipelineDetails.pipelineType);
+    if (secrets && secrets.length > 0) {
+      logger.header("Erforderliche CI/CD Secrets");
+      for (const secret of secrets) {
+        const value = secret.isSecret ? chalk6.dim("(geheim)") : chalk6.cyan(secret.value || "-");
+        console.log(`  ${chalk6.bold(secret.name)}: ${value}`);
+        console.log(`    ${chalk6.dim(secret.description)}`);
+      }
+      logger.newline();
+      logger.info("F\xFCgen Sie diese Werte als CI/CD Secrets/Variables hinzu.");
+      logger.info("Projekt-Token k\xF6nnen Sie in der TurboOps Web-UI erstellen.");
+    }
+  } catch (error2) {
+    logger.error(`Fehler beim Schreiben der Pipeline-Datei: ${error2}`);
+  }
+}
+async function showFinalSummary(project) {
   logger.newline();
   logger.success("Projekt initialisiert!");
   logger.newline();
@@ -1411,7 +1863,7 @@ var initCommand = new Command5("init").description("Initialize TurboOps project
   });
   if (environments && environments.length > 0) {
     logger.newline();
-    logger.header("Verf\xFCgbare Umgebungen");
+    logger.header("Verf\xFCgbare Stages");
     for (const env of environments) {
       console.log(`  ${chalk6.bold(env.slug)} - ${env.name} (${env.type})`);
     }
@@ -1419,11 +1871,11 @@ var initCommand = new Command5("init").description("Initialize TurboOps project
   logger.newline();
   logger.header("N\xE4chste Schritte");
   logger.list([
-    "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"
+    "F\xFChren Sie `turbo status` aus, um alle Stages zu sehen",
+    "F\xFChren Sie `turbo deploy <stage>` aus, um zu deployen",
+    "F\xFChren Sie `turbo logs <stage>` aus, um Logs anzuzeigen"
   ]);
-});
+}
 
 // src/commands/logs.ts
 import { Command as Command6 } from "commander";
@@ -1588,7 +2040,7 @@ function getLevelColor(level) {
 var VERSION = getCurrentVersion();
 var shouldCheckUpdate = true;
 var program = new Command7();
-program.name("turbo").description("TurboCLI - Command line interface for TurboOps deployments").version(VERSION, "-v, --version", "Show version number").option("--project <slug>", "Override project slug").option("--token <token>", "Override API token").option("--api <url>", "Override API URL").option("--json", "Output as JSON").option("--quiet", "Only show errors").option("--verbose", "Show debug output").option("--no-update-check", "Skip version check");
+program.name("turbo").description("TurboCLI - Command line interface for TurboOps deployments").version(VERSION, "-v, --version", "Show version number").option("--project <slug>", "Override project slug").option("--token <token>", "Override API token").option("--json", "Output as JSON").option("--quiet", "Only show errors").option("--verbose", "Show debug output").option("--no-update-check", "Skip version check");
 program.hook("preAction", (thisCommand) => {
   const opts = thisCommand.opts();
   clearJsonData();
@@ -1605,9 +2057,6 @@ program.hook("preAction", (thisCommand) => {
   if (opts.token) {
     configService.setToken(opts.token);
   }
-  if (opts.api) {
-    configService.setApiUrl(opts.api);
-  }
   if (opts.verbose) {
     process.env.DEBUG = "true";
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@turboops/cli",
-  "version": "1.0.0-dev.580",
+  "version": "1.0.0-dev.582",
   "description": "TurboCLI - Command line interface for TurboOps deployments",
   "author": "lenne.tech GmbH",
   "license": "MIT",