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

package/README.md

@@ -1,6 +1,6 @@
 # TurboCLI
 
-Command line interface for TurboOps deployments.
+Command line interface for TurboOps.
 
 ## Installation
 
@@ -17,7 +17,7 @@ npx @turboops/cli
 ### Authentication
 
 ```bash
-# Login interactively
+# Login interactively (opens browser)
 turbo login
 
 # Login with token (for CI/CD)
@@ -37,100 +37,115 @@ turbo logout
 turbo init
 
 # Show current configuration
-turbo config
-```
+turbo config show
 
-### Deployment
+# Set configuration value
+turbo config set project <slug>
 
-```bash
-# Deploy to an environment
-turbo deploy production
-turbo deploy staging
-turbo deploy dev
+# Get configuration value
+turbo config get project
 
-# Deploy specific image
-turbo deploy production --image v1.2.3
+# Clear configuration
+turbo config clear --all
+turbo config clear --token
+turbo config clear --project
+```
 
-# Deploy without waiting
-turbo deploy production --no-wait
+### Status
 
-# Rollback to previous deployment
-turbo rollback production
+```bash
+# Show status of all environments
+turbo status
 
-# Rollback to specific deployment
-turbo rollback production --to <deployment-id>
+# Show status of specific environment
+turbo status production
 ```
 
-### Container Management
+### Logs
 
 ```bash
-# Restart containers
-turbo restart production
+# View logs
+turbo logs production
 
-# Stop containers
-turbo stop production
+# Follow logs (stream)
+turbo logs production --follow
 
-# Start stopped containers
-turbo wake production
+# Limit lines
+turbo logs production --lines 50
 
-# Show status
-turbo status
-turbo status production
+# Filter by service
+turbo logs production --service api
 ```
 
-### Environment Variables
+### Deployment (CI/CD)
 
-```bash
-# List environment variables
-turbo env production
+The deploy command is designed for CI/CD pipelines using Project Tokens.
 
-# Show secret values
-turbo env production --reveal
+```bash
+# Trigger deployment and wait for completion (default)
+turbo deploy production
 
-# Set variable
-turbo env production set API_KEY=secret123
+# Deploy specific image tag
+turbo deploy production --image my-app:v1.2.3
 
-# Set as secret
-turbo env production set API_KEY=secret123 --secret
+# Deploy without waiting (fire-and-forget)
+turbo deploy staging --no-wait
 
-# Remove variable
-turbo env production unset API_KEY
+# Custom timeout (default: 10 minutes)
+turbo deploy production --timeout 900000
 ```
 
-### Logs
+**Options:**
+
+| Option | Description |
+|--------|-------------|
+| `-i, --image <tag>` | Docker image tag to deploy |
+| `-w, --wait` | Wait for deployment to complete (default) |
+| `--no-wait` | Do not wait for deployment to complete |
+| `--timeout <ms>` | Timeout in milliseconds when waiting (default: 600000) |
+
+**Note:** This command requires a Project Token with `deploy` permission. Set the token via `TURBOOPS_TOKEN` environment variable or `--token` flag.
+
+### Pipeline Management
+
+Generate and manage CI/CD pipeline configurations.
 
 ```bash
-# View logs
-turbo logs production
+# Generate pipeline interactively
+turbo pipeline generate
 
-# Follow logs (stream)
-turbo logs production --follow
+# Generate GitLab CI pipeline
+turbo pipeline generate --type gitlab
 
-# Limit lines
-turbo logs production --lines 50
-```
+# Generate GitHub Actions pipeline
+turbo pipeline generate --type github
 
-## CI/CD Usage
+# Force overwrite existing pipeline
+turbo pipeline generate --type gitlab --force
 
-### GitLab CI
+# Custom output path
+turbo pipeline generate --type gitlab --output ./ci/pipeline.yml
 
-```yaml
-deploy:
-  stage: deploy
-  script:
-    - npx @turboops/cli deploy production --wait
-  environment:
-    name: production
+# Show required secrets
+turbo pipeline secrets
+
+# Show secrets for specific pipeline type
+turbo pipeline secrets --type github
 ```
 
-### GitHub Actions
+**Options for `pipeline generate`:**
+
+| Option | Description |
+|--------|-------------|
+| `-t, --type <type>` | Pipeline type: `gitlab` or `github` |
+| `-f, --force` | Overwrite existing pipeline file |
+| `-o, --output <path>` | Custom output path |
 
-```yaml
-- name: Deploy
-  run: npx @turboops/cli deploy production --wait
-  env:
-    TURBOOPS_TOKEN: ${{ secrets.TURBOOPS_TOKEN }}
-    TURBOOPS_PROJECT: ${{ vars.TURBOOPS_PROJECT }}
+### Self-Update
+
+```bash
+# Check for updates and show upgrade instructions
+turbo self-update
 ```
 
 ## Environment Variables
@@ -146,7 +161,6 @@ deploy:
 ```bash
 --project <slug>      Override project slug
 --token <token>       Override API token
---api <url>           Override API URL
 --json                Output as JSON
 --quiet               Only show errors
 --verbose             Show debug output
@@ -160,7 +174,11 @@ deploy:
 | 0 | Success |
 | 1 | General error |
 | 2 | Timeout |
-| 3 | Health check failed |
+| 3 | Network error |
+| 10 | Authentication error |
+| 11 | Not found |
+| 12 | API error |
+| 20 | Validation error |
 
 ## License
 

package/dist/index.js

@@ -135,9 +135,9 @@ function loadPackageJson() {
     join(__dirname, "../package.json")
     // From dist/
   ];
-  for (const path2 of paths) {
-    if (existsSync(path2)) {
-      return require2(path2);
+  for (const path3 of paths) {
+    if (existsSync(path3)) {
+      return require2(path3);
     }
   }
   return { version: "0.0.0", name: "@turboops/cli" };
@@ -425,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, path2, body) {
+  async request(method, path3, body) {
     const apiUrl = configService.getApiUrl();
     const token = configService.getToken();
     if (!token) {
@@ -441,7 +441,7 @@ var apiClient = {
         status: 401
       };
     }
-    const url = `${apiUrl}${path2}`;
+    const url = `${apiUrl}${path3}`;
     const headers = {
       "Content-Type": "application/json",
       Authorization: `Bearer ${token}`
@@ -647,13 +647,12 @@ var apiClient = {
     return this.request("GET", `/deployment/projects/${projectId}/pipeline/${type}/secrets`);
   },
   /**
-   * Trigger deployment
+   * Trigger a deployment
    */
-  async deploy(environmentId, imageTag) {
-    return this.request("POST", `/deployment/deployments`, {
-      environmentId,
-      imageTag
-    });
+  async deploy(stageId, imageTag) {
+    const body = { stage: stageId };
+    if (imageTag) body.imageTag = imageTag;
+    return this.request("POST", "/deployment/deployments", body);
   },
   /**
    * Get deployment status
@@ -661,104 +660,32 @@ var apiClient = {
   async getDeploymentStatus(deploymentId) {
     return this.request("GET", `/deployment/deployments/${deploymentId}`);
   },
-  /**
-   * Rollback deployment
-   */
-  async rollback(environmentId, targetDeploymentId) {
-    return this.request("POST", `/deployment/deployments/rollback`, {
-      environmentId,
-      targetDeploymentId
-    });
-  },
-  /**
-   * Restart containers
-   */
-  async restart(environmentId) {
-    return this.request(
-      "POST",
-      `/deployment/stages/${environmentId}/restart`
-    );
-  },
-  /**
-   * Stop containers
-   */
-  async stop(environmentId) {
-    return this.request(
-      "POST",
-      `/deployment/stages/${environmentId}/stop`
-    );
-  },
-  /**
-   * Wake containers
-   */
-  async wake(environmentId) {
-    return this.request(
-      "POST",
-      `/deployment/stages/${environmentId}/wake`
-    );
-  },
-  /**
-   * Get deployment logs
-   */
-  async getLogs(deploymentId) {
-    return this.request("GET", `/deployment/deployments/${deploymentId}/logs`);
-  },
-  /**
-   * Get environment variables
-   */
-  async getEnvVars(environmentId) {
-    return this.request(
-      "GET",
-      `/deployment/stages/${environmentId}/env-vars`
-    );
-  },
-  /**
-   * Set environment variable
-   */
-  async setEnvVar(environmentId, key, value, secret) {
-    return this.request(
-      "PUT",
-      `/deployment/stages/${environmentId}/env-vars`,
-      {
-        key,
-        value,
-        secret
-      }
-    );
-  },
-  /**
-   * Delete environment variable
-   */
-  async deleteEnvVar(environmentId, key) {
-    return this.request(
-      "DELETE",
-      `/deployment/stages/${environmentId}/env-vars/${key}`
-    );
-  },
   /**
    * 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`);
   }
 };
 
@@ -874,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 };
   },
@@ -1039,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() {
@@ -1116,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) => {
@@ -1312,17 +1089,17 @@ 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("Manage configuration");
+var configCommand = new Command2("config").description("Manage configuration");
 configCommand.command("show", { isDefault: true }).description("Show current configuration").action(() => {
   const config = configService.getAll();
   addJsonData({ config });
@@ -1397,117 +1174,22 @@ 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.");
@@ -1548,7 +1230,7 @@ var initCommand = new Command5("init").description("Initialize TurboOps project
     addJsonData({ initialized: false, reason: "cancelled" });
     return;
   }
-  const { data: project, error: projectError } = await withSpinner(
+  const { data: project } = await withSpinner(
     "Suche Projekt...",
     () => apiClient.getProject(projectSlug)
   );
@@ -1586,12 +1268,12 @@ async function setupProject(project) {
       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");
+  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 fs2.access(gitlabCiPath);
+    await fs3.access(gitlabCiPath);
     hasGitLabPipeline = true;
   } catch {
   }
@@ -1806,27 +1488,27 @@ async function createPipeline(projectId) {
     logger.error(`Pipeline konnte nicht generiert werden: ${error || "Unbekannter Fehler"}`);
     return;
   }
-  const fs2 = await import("fs/promises");
-  const path2 = await import("path");
+  const fs3 = await import("fs/promises");
+  const path3 = 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");
+    const workflowsDir = path3.join(process.cwd(), ".github", "workflows");
+    await fs3.mkdir(workflowsDir, { recursive: true });
+    filePath = path3.join(workflowsDir, "deploy.yml");
   } else {
-    filePath = path2.join(process.cwd(), ".gitlab-ci.yml");
+    filePath = path3.join(process.cwd(), ".gitlab-ci.yml");
   }
   try {
-    await fs2.writeFile(filePath, pipeline.content, "utf-8");
+    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 ? chalk6.dim("(geheim)") : chalk6.cyan(secret.value || "-");
-        console.log(`  ${chalk6.bold(secret.name)}: ${value}`);
-        console.log(`    ${chalk6.dim(secret.description)}`);
+        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.");
@@ -1865,23 +1547,22 @@ async function showFinalSummary(project) {
     logger.newline();
     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 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";
-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) {
@@ -2002,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);
@@ -2021,19 +1702,257 @@ 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 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 chalk7.white;
+      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
@@ -2075,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 {

package/package.json

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