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

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 path3 of paths) {
+    if (existsSync(path3)) {
+      return require2(path3);
     }
   }
   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")
     });
   }
@@ -352,14 +425,14 @@ import { Command } from "commander";
 
 // src/services/api.ts
 function isProjectToken(token) {
-  return token.startsWith("turbo_");
+  return token.startsWith("turbo_") && !token.startsWith("turbo_cli_");
 }
 var cachedProjectInfo = null;
 var apiClient = {
   /**
    * Make an API request
    */
-  async request(method, path, body) {
+  async request(method, path3, 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}${path3}`;
     const headers = {
       "Content-Type": "application/json",
       Authorization: `Bearer ${token}`
@@ -513,136 +586,106 @@ var apiClient = {
     return this.request("GET", `/deployment/projects/by-slug/${slug}`);
   },
   /**
-   * Get environments for project
-   */
-  async getEnvironments(projectId) {
-    return this.request(
-      "GET",
-      `/deployment/environments?projectId=${projectId}`
-    );
-  },
-  /**
-   * Get environment by slug
-   */
-  async getEnvironmentBySlug(projectId, slug) {
-    return this.request(
-      "GET",
-      `/deployment/environments/by-slug/${projectId}/${slug}`
-    );
-  },
-  /**
-   * Trigger deployment
+   * Create a new project
    */
-  async deploy(environmentId, imageTag) {
-    return this.request("POST", `/deployment/deployments`, {
-      environmentId,
-      imageTag
-    });
+  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 deployment status
+   * Get all customers
    */
-  async getDeploymentStatus(deploymentId) {
-    return this.request("GET", `/deployment/deployments/${deploymentId}`);
+  async getCustomers() {
+    return this.request("GET", "/customer");
   },
   /**
-   * Rollback deployment
+   * Get environments (stages) for project
    */
-  async rollback(environmentId, targetDeploymentId) {
-    return this.request("POST", `/deployment/deployments/rollback`, {
-      environmentId,
-      targetDeploymentId
-    });
+  async getEnvironments(projectId) {
+    return this.request(
+      "GET",
+      `/deployment/stages?projectId=${projectId}`
+    );
   },
   /**
-   * Restart containers
+   * Get environment (stage) by slug
    */
-  async restart(environmentId) {
+  async getEnvironmentBySlug(projectId, slug) {
     return this.request(
-      "POST",
-      `/deployment/environments/${environmentId}/restart`
+      "GET",
+      `/deployment/stages/by-slug/${projectId}/${slug}`
     );
   },
   /**
-   * Stop containers
+   * Create a new stage
    */
-  async stop(environmentId) {
-    return this.request(
-      "POST",
-      `/deployment/environments/${environmentId}/stop`
-    );
+  async createStage(data) {
+    return this.request("POST", "/deployment/stages/simple", data);
   },
   /**
-   * Wake containers
+   * Get deployment-ready servers
    */
-  async wake(environmentId) {
-    return this.request(
-      "POST",
-      `/deployment/environments/${environmentId}/wake`
-    );
+  async getDeploymentServers() {
+    return this.request("GET", "/server?deploymentReady=true");
   },
   /**
-   * Get deployment logs
+   * Generate CI/CD pipeline configuration
    */
-  async getLogs(deploymentId) {
-    return this.request("GET", `/deployment/deployments/${deploymentId}/logs`);
+  async generatePipeline(projectId, type) {
+    return this.request("GET", `/deployment/projects/${projectId}/pipeline/${type}`);
   },
   /**
-   * Get environment variables
+   * Get required secrets for pipeline
    */
-  async getEnvVars(environmentId) {
-    return this.request(
-      "GET",
-      `/deployment/environments/${environmentId}/env-vars`
-    );
+  async getPipelineSecrets(projectId, type) {
+    return this.request("GET", `/deployment/projects/${projectId}/pipeline/${type}/secrets`);
   },
   /**
-   * Set environment variable
+   * Trigger a deployment
    */
-  async setEnvVar(environmentId, key, value, secret) {
-    return this.request(
-      "PUT",
-      `/deployment/environments/${environmentId}/env-vars`,
-      {
-        key,
-        value,
-        secret
-      }
-    );
+  async deploy(stageId, imageTag) {
+    const body = { stage: stageId };
+    if (imageTag) body.imageTag = imageTag;
+    return this.request("POST", "/deployment/deployments", body);
   },
   /**
-   * Delete environment variable
+   * Get deployment status
    */
-  async deleteEnvVar(environmentId, key) {
-    return this.request(
-      "DELETE",
-      `/deployment/environments/${environmentId}/env-vars/${key}`
-    );
+  async getDeploymentStatus(deploymentId) {
+    return this.request("GET", `/deployment/deployments/${deploymentId}`);
   },
   /**
    * Wait for deployment to complete
    */
-  async waitForDeployment(deploymentId, options) {
-    const timeout = options?.timeout || 6e5;
-    const pollInterval = options?.pollInterval || 3e3;
+  async waitForDeployment(deploymentId, options = {}) {
+    const { timeout = 6e5, pollInterval = 3e3, onProgress } = options;
     const startTime = Date.now();
-    while (Date.now() - startTime < timeout) {
+    while (true) {
       const { data, error } = await this.getDeploymentStatus(deploymentId);
       if (error) {
-        throw new Error(error);
+        throw new Error(`Failed to get deployment status: ${error}`);
       }
       if (!data) {
         throw new Error("No deployment data received");
       }
-      if (options?.onProgress) {
-        options.onProgress(data);
+      if (onProgress) {
+        onProgress(data);
       }
-      if (["running", "failed", "stopped", "rolled_back"].includes(data.status)) {
+      const terminalStatuses = ["running", "failed", "stopped", "rolled_back"];
+      if (terminalStatuses.includes(data.status)) {
         return data;
       }
-      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+      if (Date.now() - startTime > timeout) {
+        throw new Error(`Deployment timeout after ${timeout / 1e3} seconds`);
+      }
+      await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
     }
-    throw new Error(`Deployment timeout after ${timeout / 1e3} seconds`);
   }
 };
 
@@ -758,7 +801,7 @@ var authService = {
       if (result.status === "expired" || result.status === "consumed") {
         return { error: "Autorisierungscode abgelaufen oder bereits verwendet", success: false };
       }
-      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+      await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
     }
     return { error: "Zeit\xFCberschreitung bei der Anmeldung", success: false };
   },
@@ -923,8 +966,9 @@ var whoamiCommand = new Command("whoami").description("Show current authenticate
   });
 });
 
-// src/commands/deploy.ts
+// src/commands/status.ts
 import { Command as Command2 } from "commander";
+import chalk3 from "chalk";
 
 // src/utils/guards.ts
 async function requireAuth() {
@@ -1000,159 +1044,8 @@ async function getCommandContextWithEnvironment(environmentSlug, showSpinner = t
   return { projectSlug, project, environment };
 }
 
-// src/commands/deploy.ts
-import chalk3 from "chalk";
-var deployCommand = new Command2("deploy").description("Deploy to an environment").argument(
-  "<environment>",
-  "Environment slug (e.g., production, staging, dev)"
-).option("-i, --image <tag>", "Specific image tag to deploy").option("-w, --wait", "Wait for deployment to complete (default: true)", true).option("--no-wait", "Do not wait for deployment to complete").option("--timeout <ms>", "Timeout in milliseconds for --wait", "600000").action(async (environment, options) => {
-  const { environment: env } = await getCommandContextWithEnvironment(environment);
-  logger.header(`Deploying to ${environment}`);
-  const { data: deployment, error: deployError } = await withSpinner(
-    `Starting deployment...`,
-    () => apiClient.deploy(env.id, options.image)
-  );
-  if (deployError || !deployment) {
-    logger.error(
-      `Failed to start deployment: ${deployError || "Unknown error"}`
-    );
-    process.exit(13 /* API_ERROR */);
-  }
-  logger.success(`Deployment started: ${deployment.id}`);
-  addJsonData({ deploymentId: deployment.id });
-  if (!options.wait) {
-    logger.info(`View deployment status: turbo status ${environment}`);
-    return;
-  }
-  logger.newline();
-  const spinner = createSpinner("Deploying...");
-  spinner.start();
-  try {
-    const finalStatus = await apiClient.waitForDeployment(deployment.id, {
-      timeout: parseInt(options.timeout),
-      onProgress: (status) => {
-        spinner.text = getStatusText(status);
-      }
-    });
-    if (finalStatus.status === "running") {
-      spinner.succeed(`Deployment successful!`);
-      const resultData = {
-        environment: env.name,
-        environmentSlug: env.slug,
-        imageTag: finalStatus.imageTag,
-        status: finalStatus.status,
-        healthyContainers: finalStatus.healthStatus?.healthy || 0,
-        totalContainers: finalStatus.healthStatus?.total || 0,
-        domain: env.domain
-      };
-      addJsonData(resultData);
-      logger.newline();
-      logger.table({
-        Environment: env.name,
-        Image: finalStatus.imageTag,
-        Status: chalk3.green(finalStatus.status),
-        Health: `${finalStatus.healthStatus?.healthy || 0}/${finalStatus.healthStatus?.total || 0} healthy`
-      });
-      logger.newline();
-      logger.info(`View at: https://${env.domain}`);
-    } else if (finalStatus.status === "failed") {
-      spinner.fail("Deployment failed!");
-      addJsonData({ status: "failed", error: finalStatus.errorMessage });
-      logger.error(finalStatus.errorMessage || "Unknown error");
-      process.exit(3 /* HEALTH_CHECK_FAILED */);
-    } else {
-      spinner.warn(`Deployment ended with status: ${finalStatus.status}`);
-      addJsonData({ status: finalStatus.status });
-      process.exit(1 /* ERROR */);
-    }
-  } catch (error) {
-    spinner.fail("Deployment failed!");
-    const message = error instanceof Error ? error.message : "Unknown error";
-    addJsonData({ error: message });
-    logger.error(message);
-    if (message.includes("timeout")) {
-      process.exit(2 /* TIMEOUT */);
-    }
-    process.exit(1 /* ERROR */);
-  }
-});
-var rollbackCommand = new Command2("rollback").description("Rollback to a previous deployment").argument("<environment>", "Environment slug").option("--to <id>", "Specific deployment ID to rollback to").action(async (environment, options) => {
-  const { environment: env } = await getCommandContextWithEnvironment(environment);
-  logger.header(`Rolling back ${environment}`);
-  const { data, error } = await withSpinner(
-    "Starting rollback...",
-    () => apiClient.rollback(env.id, options.to)
-  );
-  if (error || !data) {
-    logger.error(`Rollback failed: ${error || "Unknown error"}`);
-    process.exit(13 /* API_ERROR */);
-  }
-  addJsonData({
-    status: "rollback_initiated",
-    imageTag: data.imageTag,
-    deploymentId: data.id
-  });
-  logger.success(`Rollback initiated to ${data.imageTag}`);
-  logger.info("Run `turbo status` to monitor the rollback.");
-});
-var restartCommand = new Command2("restart").description("Restart containers in an environment").argument("<environment>", "Environment slug").action(async (environment) => {
-  const { environment: env } = await getCommandContextWithEnvironment(environment);
-  const { error } = await withSpinner(
-    "Restarting containers...",
-    () => apiClient.restart(env.id)
-  );
-  if (error) {
-    logger.error(`Restart failed: ${error}`);
-    process.exit(13 /* API_ERROR */);
-  }
-  addJsonData({ status: "restarting", environment: env.slug });
-  logger.success("Containers are being restarted");
-});
-var stopCommand = new Command2("stop").description("Stop containers in an environment").argument("<environment>", "Environment slug").action(async (environment) => {
-  const { environment: env } = await getCommandContextWithEnvironment(environment);
-  const { error } = await withSpinner(
-    "Stopping containers...",
-    () => apiClient.stop(env.id)
-  );
-  if (error) {
-    logger.error(`Stop failed: ${error}`);
-    process.exit(13 /* API_ERROR */);
-  }
-  addJsonData({ status: "stopped", environment: env.slug });
-  logger.success("Containers have been stopped");
-});
-var wakeCommand = new Command2("wake").description("Wake (start) stopped containers in an environment").argument("<environment>", "Environment slug").action(async (environment) => {
-  const { environment: env } = await getCommandContextWithEnvironment(environment);
-  const { error } = await withSpinner(
-    "Starting containers...",
-    () => apiClient.wake(env.id)
-  );
-  if (error) {
-    logger.error(`Wake failed: ${error}`);
-    process.exit(13 /* API_ERROR */);
-  }
-  addJsonData({ status: "starting", environment: env.slug });
-  logger.success("Containers are starting");
-});
-function getStatusText(status) {
-  switch (status.status) {
-    case "pending":
-      return "Waiting for deployment to start...";
-    case "deploying":
-      return `Deploying ${status.imageTag}...`;
-    case "running":
-      return "Deployment complete!";
-    case "failed":
-      return "Deployment failed";
-    default:
-      return `Status: ${status.status}`;
-  }
-}
-
 // src/commands/status.ts
-import { Command as Command3 } from "commander";
-import chalk4 from "chalk";
-var statusCommand = new Command3("status").description("Show deployment status").argument(
+var statusCommand = new Command2("status").description("Show deployment status").argument(
   "[environment]",
   "Environment slug (optional, shows all if not specified)"
 ).action(async (environment) => {
@@ -1196,136 +1089,107 @@ var statusCommand = new Command3("status").description("Show deployment status")
   });
   for (const env of envsToShow) {
     logger.newline();
-    console.log(chalk4.bold(env.name) + ` (${env.slug})`);
-    console.log(chalk4.gray("\u2500".repeat(40)));
+    console.log(chalk3.bold(env.name) + ` (${env.slug})`);
+    console.log(chalk3.gray("\u2500".repeat(40)));
     const statusColor = getStatusColor(env.status);
     logger.table({
       Status: statusColor(env.status),
       Type: env.type,
-      Domain: chalk4.cyan(env.domain)
+      Domain: chalk3.cyan(env.domain)
     });
   }
 });
-var configCommand = new Command3("config").description("Show current configuration").action(() => {
-  const config2 = configService.getAll();
-  addJsonData({ config: config2 });
+var configCommand = new Command2("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":
     case "running":
-      return chalk4.green;
+      return chalk3.green;
     case "deploying":
-      return chalk4.yellow;
+      return chalk3.yellow;
     case "failed":
     case "stopped":
-      return chalk4.red;
+      return chalk3.red;
     default:
-      return chalk4.gray;
+      return chalk3.gray;
   }
 }
 
-// src/commands/env.ts
-import { Command as Command4 } from "commander";
-import chalk5 from "chalk";
-var envCommand = new Command4("env").description("Manage environment variables").argument("<environment>", "Environment slug").option("-r, --reveal", "Show secret values (normally masked)").action(async (environment, options) => {
-  const { environment: env } = await getCommandContextWithEnvironment(environment);
-  const { data: envVars, error } = await withSpinner(
-    "Fetching environment variables...",
-    () => apiClient.getEnvVars(env.id)
-  );
-  if (error || !envVars) {
-    logger.error(
-      `Failed to fetch environment variables: ${error || "Unknown error"}`
-    );
-    process.exit(13 /* API_ERROR */);
-  }
-  addJsonData({
-    environment: env.name,
-    environmentSlug: env.slug,
-    variables: envVars.map((v) => ({
-      key: v.key,
-      secret: v.secret
-    }))
-  });
-  logger.header(`Environment Variables: ${env.name}`);
-  if (envVars.length === 0) {
-    logger.warning("No environment variables configured.");
-    return;
-  }
-  for (const v of envVars) {
-    const icon = v.secret ? chalk5.yellow("\u{1F512}") : chalk5.gray("  ");
-    const value = v.secret && !options.reveal ? chalk5.gray("\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022") : chalk5.green("(set)");
-    console.log(`${icon} ${chalk5.bold(v.key)} = ${value}`);
-  }
-  logger.newline();
-  logger.info(
-    "Use `turbo env <environment> set KEY=value` to add/update variables."
-  );
-  logger.info("Use `turbo env <environment> unset KEY` to remove variables.");
-});
-var envSetCommand = new Command4("set").description("Set an environment variable").argument("<key=value>", "Variable to set (e.g., API_KEY=secret123)").option("-s, --secret", "Mark as secret (value will be encrypted)").action(async (keyValue, options, cmd) => {
-  const environment = cmd.parent?.args[0];
-  if (!environment) {
-    logger.error("Environment not specified");
-    process.exit(14 /* VALIDATION_ERROR */);
-  }
-  const [key, ...valueParts] = keyValue.split("=");
-  const value = valueParts.join("=");
-  if (!key || !value) {
-    logger.error("Invalid format. Use: KEY=value");
-    process.exit(14 /* VALIDATION_ERROR */);
-  }
-  const { environment: env } = await getCommandContextWithEnvironment(environment);
-  const { error } = await withSpinner(
-    `Setting ${key}...`,
-    () => apiClient.setEnvVar(env.id, key, value, options.secret || false)
-  );
-  if (error) {
-    logger.error(`Failed to set variable: ${error}`);
-    process.exit(13 /* API_ERROR */);
-  }
-  addJsonData({
-    action: "set",
-    key,
-    secret: options.secret || false,
-    environment: env.slug
-  });
-  logger.success(`Set ${key}${options.secret ? " (secret)" : ""}`);
-  logger.info("Changes will take effect on the next deployment.");
-});
-var envUnsetCommand = new Command4("unset").description("Remove an environment variable").argument("<key>", "Variable key to remove").action(async (key, _options, cmd) => {
-  const environment = cmd.parent?.args[0];
-  if (!environment) {
-    logger.error("Environment not specified");
-    process.exit(14 /* VALIDATION_ERROR */);
-  }
-  const { environment: env } = await getCommandContextWithEnvironment(environment);
-  const { error } = await withSpinner(
-    `Removing ${key}...`,
-    () => apiClient.deleteEnvVar(env.id, key)
-  );
-  if (error) {
-    logger.error(`Failed to remove variable: ${error}`);
-    process.exit(13 /* API_ERROR */);
-  }
-  addJsonData({
-    action: "unset",
-    key,
-    environment: env.slug
-  });
-  logger.success(`Removed ${key}`);
-  logger.info("Changes will take effect on the next deployment.");
-});
-envCommand.addCommand(envSetCommand);
-envCommand.addCommand(envUnsetCommand);
-
 // src/commands/init.ts
-import { Command as Command5 } from "commander";
+import { Command as Command3 } from "commander";
 import prompts from "prompts";
-import chalk6 from "chalk";
-var initCommand = new Command5("init").description("Initialize TurboOps project in current directory").action(async () => {
+import chalk4 from "chalk";
+var initCommand = new Command3("init").description("Initialize TurboOps project in current directory").action(async () => {
   logger.header("TurboOps Project Initialization");
   if (!configService.isAuthenticated()) {
     logger.warning("Nicht authentifiziert. Bitte melden Sie sich zuerst an.");
@@ -1366,25 +1230,295 @@ var initCommand = new Command5("init").description("Initialize TurboOps project
     addJsonData({ initialized: false, reason: "cancelled" });
     return;
   }
-  const { data: project, error: projectError } = await withSpinner(
-    "Verifiziere Projekt...",
+  const { data: project } = await withSpinner(
+    "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 fs3 = await import("fs/promises");
+  const path3 = await import("path");
+  const gitlabCiPath = path3.join(process.cwd(), ".gitlab-ci.yml");
+  let hasGitLabPipeline = false;
+  try {
+    await fs3.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 */);
+  }
+  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);
   }
-  configService.setProject(projectSlug);
+  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 fs3 = await import("fs/promises");
+  const path3 = await import("path");
+  let filePath;
+  if (pipelineDetails.pipelineType === "github") {
+    const workflowsDir = path3.join(process.cwd(), ".github", "workflows");
+    await fs3.mkdir(workflowsDir, { recursive: true });
+    filePath = path3.join(workflowsDir, "deploy.yml");
+  } else {
+    filePath = path3.join(process.cwd(), ".gitlab-ci.yml");
+  }
+  try {
+    await fs3.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 ? chalk4.dim("(geheim)") : chalk4.cyan(secret.value || "-");
+        console.log(`  ${chalk4.bold(secret.name)}: ${value}`);
+        console.log(`    ${chalk4.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,25 +1545,24 @@ 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})`);
+      console.log(`  ${chalk4.bold(env.slug)} - ${env.name} (${env.type})`);
     }
   }
   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 logs <stage>` aus, um Logs anzuzeigen"
   ]);
-});
+}
 
 // src/commands/logs.ts
-import { Command as Command6 } from "commander";
-import chalk7 from "chalk";
+import { Command as Command4 } from "commander";
+import chalk5 from "chalk";
 import { io } from "socket.io-client";
-var logsCommand = new Command6("logs").description("View deployment logs").argument("<environment>", "Environment slug").option("-n, --lines <number>", "Number of lines to show", "100").option("-f, --follow", "Follow log output (stream)").option("--service <name>", "Filter logs by service name").action(async (environment, options) => {
+var logsCommand = new Command4("logs").description("View deployment logs").argument("<environment>", "Environment slug").option("-n, --lines <number>", "Number of lines to show", "100").option("-f, --follow", "Follow log output (stream)").option("--service <name>", "Filter logs by service name").action(async (environment, options) => {
   const { environment: env } = await getCommandContextWithEnvironment(environment);
   logger.header(`Logs: ${env.name}`);
   if (options.follow) {
@@ -1550,9 +1683,9 @@ function printLogEntry(log) {
   const timestamp = formatTimestamp(log.timestamp);
   const levelColor = getLevelColor(log.level);
   const levelStr = log.level.toUpperCase().padEnd(5);
-  let output = chalk7.gray(`[${timestamp}]`) + levelColor(` ${levelStr}`);
+  let output = chalk5.gray(`[${timestamp}]`) + levelColor(` ${levelStr}`);
   if (log.step) {
-    output += chalk7.cyan(` [${log.step}]`);
+    output += chalk5.cyan(` [${log.step}]`);
   }
   output += ` ${log.message}`;
   logger.raw(output);
@@ -1569,26 +1702,264 @@ function getLevelColor(level) {
   switch (level.toLowerCase()) {
     case "error":
     case "fatal":
-      return chalk7.red;
+      return chalk5.red;
     case "warn":
     case "warning":
-      return chalk7.yellow;
+      return chalk5.yellow;
     case "info":
-      return chalk7.blue;
+      return chalk5.blue;
     case "debug":
-      return chalk7.gray;
+      return chalk5.gray;
     case "trace":
-      return chalk7.magenta;
+      return chalk5.magenta;
     default:
-      return chalk7.white;
+      return chalk5.white;
   }
 }
 
+// src/commands/deploy.ts
+import { Command as Command5 } from "commander";
+import chalk6 from "chalk";
+var deployCommand = new Command5("deploy").description("Trigger a deployment (for CI/CD pipelines)").argument("<environment>", "Environment slug (e.g., production, staging)").option("-i, --image <tag>", "Docker image tag to deploy").option("-w, --wait", "Wait for deployment to complete", true).option("--no-wait", "Do not wait for deployment to complete").option(
+  "--timeout <ms>",
+  "Timeout in milliseconds when waiting",
+  "600000"
+).action(async (environment, options) => {
+  const { project, environment: env } = await getCommandContextWithEnvironment(environment);
+  logger.header(`Deploying: ${project.name} \u2192 ${env.name}`);
+  logger.info("Triggering deployment...");
+  const { data: deployment, error } = await apiClient.deploy(
+    env.id,
+    options.image
+  );
+  if (error) {
+    logger.error(`Failed to trigger deployment: ${error}`);
+    process.exit(13 /* API_ERROR */);
+  }
+  if (!deployment) {
+    logger.error("No deployment data received");
+    process.exit(13 /* API_ERROR */);
+  }
+  logger.success(`Deployment triggered: ${deployment.id}`);
+  addJsonData({
+    deploymentId: deployment.id,
+    status: deployment.status,
+    environment: env.slug,
+    project: project.slug,
+    imageTag: options.image || "latest"
+  });
+  if (!options.wait) {
+    logger.info("Deployment started. Use --wait to wait for completion.");
+    return;
+  }
+  logger.newline();
+  logger.info("Waiting for deployment to complete...");
+  const timeout = parseInt(options.timeout);
+  let lastStatus = "";
+  try {
+    const finalStatus = await apiClient.waitForDeployment(deployment.id, {
+      timeout,
+      pollInterval: 3e3,
+      onProgress: (status) => {
+        if (status.status !== lastStatus) {
+          lastStatus = status.status;
+          const statusColor = getStatusColor2(status.status);
+          if (!isJsonMode()) {
+            logger.info(`Status: ${statusColor(status.status)}`);
+          }
+        }
+      }
+    });
+    addJsonData({
+      finalStatus: finalStatus.status,
+      completedAt: finalStatus.completedAt,
+      healthStatus: finalStatus.healthStatus
+    });
+    if (finalStatus.status === "running") {
+      logger.newline();
+      logger.success("Deployment completed successfully!");
+      if (finalStatus.healthStatus) {
+        logger.info(
+          `Health: ${finalStatus.healthStatus.healthy}/${finalStatus.healthStatus.total} containers healthy`
+        );
+      }
+    } else if (finalStatus.status === "failed") {
+      logger.newline();
+      logger.error("Deployment failed!");
+      if (finalStatus.errorMessage) {
+        logger.error(`Error: ${finalStatus.errorMessage}`);
+      }
+      process.exit(1 /* ERROR */);
+    } else {
+      logger.newline();
+      logger.warning(`Deployment ended with status: ${finalStatus.status}`);
+      process.exit(1 /* ERROR */);
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unknown error";
+    if (message.includes("timeout")) {
+      logger.error(`Deployment timed out after ${timeout / 1e3} seconds`);
+      addJsonData({ error: "timeout" });
+      process.exit(2 /* TIMEOUT */);
+    }
+    logger.error(`Error waiting for deployment: ${message}`);
+    process.exit(1 /* ERROR */);
+  }
+});
+function getStatusColor2(status) {
+  switch (status) {
+    case "running":
+      return chalk6.green;
+    case "failed":
+    case "rolled_back":
+      return chalk6.red;
+    case "deploying":
+    case "pending":
+      return chalk6.yellow;
+    case "stopped":
+      return chalk6.gray;
+    default:
+      return chalk6.white;
+  }
+}
+
+// src/commands/pipeline.ts
+import { Command as Command6 } from "commander";
+import prompts2 from "prompts";
+import chalk7 from "chalk";
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
+var pipelineCommand = new Command6("pipeline").description("Manage CI/CD pipeline configuration");
+pipelineCommand.command("generate").description("Generate CI/CD pipeline configuration").option("-t, --type <type>", "Pipeline type (gitlab, github)").option("-f, --force", "Overwrite existing pipeline file").option("-o, --output <path>", "Custom output path").action(async (options) => {
+  const { project } = await getCommandContext();
+  logger.header("CI/CD Pipeline generieren");
+  let pipelineType = options.type;
+  if (!pipelineType) {
+    const { selectedType } = await prompts2({
+      choices: [
+        { title: "GitLab CI/CD", value: "gitlab" },
+        { title: "GitHub Actions", value: "github" }
+      ],
+      initial: 0,
+      message: "Pipeline-Typ:",
+      name: "selectedType",
+      type: "select"
+    });
+    if (!selectedType) {
+      logger.warning("Pipeline-Generierung abgebrochen");
+      addJsonData({ generated: false, reason: "cancelled" });
+      return;
+    }
+    pipelineType = selectedType;
+  }
+  if (!["gitlab", "github"].includes(pipelineType)) {
+    logger.error(`Ung\xFCltiger Pipeline-Typ: ${pipelineType}. Erlaubt: gitlab, github`);
+    process.exit(14 /* VALIDATION_ERROR */);
+  }
+  let outputPath;
+  if (options.output) {
+    outputPath = path2.resolve(options.output);
+  } else if (pipelineType === "github") {
+    outputPath = path2.join(process.cwd(), ".github", "workflows", "deploy.yml");
+  } else {
+    outputPath = path2.join(process.cwd(), ".gitlab-ci.yml");
+  }
+  if (!options.force) {
+    try {
+      await fs2.access(outputPath);
+      const { shouldOverwrite } = await prompts2({
+        initial: false,
+        message: `${path2.basename(outputPath)} existiert bereits. \xDCberschreiben?`,
+        name: "shouldOverwrite",
+        type: "confirm"
+      });
+      if (!shouldOverwrite) {
+        logger.info("Pipeline-Generierung abgebrochen");
+        addJsonData({ generated: false, reason: "file_exists" });
+        return;
+      }
+    } catch {
+    }
+  }
+  const { data: pipeline, error } = await withSpinner(
+    "Generiere Pipeline...",
+    () => apiClient.generatePipeline(project.id, pipelineType)
+  );
+  if (error || !pipeline) {
+    logger.error(`Pipeline konnte nicht generiert werden: ${error || "Unbekannter Fehler"}`);
+    addJsonData({ error: error || "Unknown error", generated: false });
+    process.exit(13 /* API_ERROR */);
+  }
+  const outputDir = path2.dirname(outputPath);
+  await fs2.mkdir(outputDir, { recursive: true });
+  try {
+    await fs2.writeFile(outputPath, pipeline.content, "utf-8");
+    logger.success(`${path2.relative(process.cwd(), outputPath)} wurde erstellt!`);
+    addJsonData({
+      filename: path2.relative(process.cwd(), outputPath),
+      generated: true,
+      project: project.slug,
+      type: pipelineType
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unknown error";
+    logger.error(`Fehler beim Schreiben der Datei: ${message}`);
+    addJsonData({ error: message, generated: false });
+    process.exit(1 /* ERROR */);
+  }
+  logger.newline();
+  await showSecrets(project.id, pipelineType);
+});
+pipelineCommand.command("secrets").description("Show required CI/CD secrets").option("-t, --type <type>", "Pipeline type (gitlab, github)", "gitlab").action(async (options) => {
+  const { project } = await getCommandContext();
+  const pipelineType = options.type;
+  if (!["gitlab", "github"].includes(pipelineType)) {
+    logger.error(`Ung\xFCltiger Pipeline-Typ: ${pipelineType}. Erlaubt: gitlab, github`);
+    process.exit(14 /* VALIDATION_ERROR */);
+  }
+  logger.header(`CI/CD Secrets f\xFCr ${pipelineType === "gitlab" ? "GitLab" : "GitHub"}`);
+  await showSecrets(project.id, pipelineType);
+});
+async function showSecrets(projectId, pipelineType) {
+  const { data: secrets, error } = await apiClient.getPipelineSecrets(projectId, pipelineType);
+  if (error) {
+    logger.error(`Fehler beim Laden der Secrets: ${error}`);
+    return;
+  }
+  if (!secrets || secrets.length === 0) {
+    logger.info("Keine Secrets erforderlich.");
+    addJsonData({ secrets: [] });
+    return;
+  }
+  const secretsList = [];
+  for (const secret of secrets) {
+    const value = secret.isSecret ? chalk7.dim("(geheim)") : chalk7.cyan(secret.value || "-");
+    console.log(`  ${chalk7.bold(secret.name)}: ${value}`);
+    console.log(`    ${chalk7.dim(secret.description)}`);
+    console.log();
+    secretsList.push({
+      description: secret.description,
+      name: secret.name,
+      value: secret.isSecret ? void 0 : secret.value
+    });
+  }
+  addJsonData({ secrets: secretsList });
+  logger.info("F\xFCgen Sie diese Werte als CI/CD Secrets/Variables hinzu.");
+  if (pipelineType === "gitlab") {
+    logger.info("GitLab: Settings \u2192 CI/CD \u2192 Variables");
+  } else {
+    logger.info("GitHub: Settings \u2192 Secrets and variables \u2192 Actions");
+  }
+  logger.newline();
+  logger.info("Projekt-Token k\xF6nnen Sie in der TurboOps Web-UI erstellen:");
+  logger.info("Projekt \u2192 Settings \u2192 Tokens \u2192 Neuen Token erstellen");
+}
+
 // src/index.ts
 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 +1976,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";
   }
@@ -1626,13 +1994,9 @@ program.addCommand(whoamiCommand);
 program.addCommand(initCommand);
 program.addCommand(statusCommand);
 program.addCommand(configCommand);
-program.addCommand(deployCommand);
-program.addCommand(rollbackCommand);
-program.addCommand(restartCommand);
-program.addCommand(stopCommand);
-program.addCommand(wakeCommand);
-program.addCommand(envCommand);
 program.addCommand(logsCommand);
+program.addCommand(deployCommand);
+program.addCommand(pipelineCommand);
 program.command("self-update").description("Update TurboCLI to the latest version").action(async () => {
   logger.info("Checking for updates...");
   try {