@turboops/cli 1.0.0-dev.588 → 1.0.0-dev.590

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command8 } from "commander";
+import { Command as Command7 } from "commander";
 import chalk8 from "chalk";
 
 // src/services/config.ts
@@ -194,13 +194,16 @@ function getPackageName() {
 }
 
 // src/services/config.ts
+var BUILD_ENV = true ? "dev" : void 0;
 var API_URLS = {
-  production: "https://api.turbo-ops.de",
-  dev: "https://api.dev.turbo-ops.de"
+  local: "http://localhost:3000",
+  dev: "https://api.dev.turbo-ops.de",
+  prod: "https://api.turbo-ops.de"
 };
 var APP_URLS = {
-  production: "https://turbo-ops.de",
-  dev: "https://dev.turbo-ops.de"
+  local: "http://localhost:3001",
+  dev: "https://dev.turbo-ops.de",
+  prod: "https://turbo-ops.de"
 };
 var LOCAL_CONFIG_FILE = ".turboops.json";
 var globalDefaults = {
@@ -258,10 +261,16 @@ function writeLocalConfig(config) {
     return false;
   }
 }
-function getApiUrl() {
+function getVersionBasedEnvironment() {
   const version = getCurrentVersion();
   const isDevVersion = version.includes("-dev");
-  return isDevVersion ? API_URLS.dev : API_URLS.production;
+  return isDevVersion ? "dev" : "prod";
+}
+function getEnvironment() {
+  return BUILD_ENV || getVersionBasedEnvironment();
+}
+function getApiUrl() {
+  return API_URLS[getEnvironment()];
 }
 var configService = {
   /**
@@ -275,12 +284,16 @@ var configService = {
   },
   /**
    * Get App URL (frontend)
-   * Returns the appropriate frontend URL based on CLI version
+   * Returns the appropriate frontend URL based on environment
    */
   getAppUrl() {
-    const version = getCurrentVersion();
-    const isDevVersion = version.includes("-dev");
-    return isDevVersion ? APP_URLS.dev : APP_URLS.production;
+    return APP_URLS[getEnvironment()];
+  },
+  /**
+   * Get current environment
+   */
+  getEnvironment() {
+    return getEnvironment();
   },
   /**
    * Get authentication token (global - user session)
@@ -408,8 +421,10 @@ var configService = {
     const isProjectToken2 = this.isProjectToken();
     const isCliToken = this.isCliSessionToken();
     const localConfigPath = this.getLocalConfigPath();
+    const env = getEnvironment();
     logger.header("Configuration");
     logger.table({
+      Environment: env,
       "API URL": data.apiUrl,
       Token: data.token || "Not set",
       "Token Type": isProjectToken2 ? "Project Token (CI/CD)" : isCliToken ? "CLI Session Token" : data.token ? "User Token" : "N/A",
@@ -655,6 +670,12 @@ var apiClient = {
   async getDeploymentServers() {
     return this.request("GET", "/server?deploymentReady=true");
   },
+  /**
+   * Update project's detected configuration (partial update)
+   */
+  async updateProjectConfig(projectId, config) {
+    return this.request("PATCH", `/deployment/projects/${projectId}/config`, config);
+  },
   /**
    * Generate CI/CD pipeline configuration
    */
@@ -1213,16 +1234,18 @@ import prompts2 from "prompts";
 // src/services/ai-tools.ts
 import { execSync, spawn } from "child_process";
 import prompts from "prompts";
+import ora2 from "ora";
+import chalk4 from "chalk";
 var AI_TOOLS = {
   claude: {
     name: "Claude Code",
     command: "claude",
-    promptFlag: "-p"
+    args: ["-p", "--dangerously-skip-permissions", "--verbose", "--output-format", "stream-json"]
   },
   codex: {
     name: "OpenAI Codex",
     command: "codex",
-    promptFlag: ""
+    args: []
   }
 };
 var aiToolsService = {
@@ -1271,32 +1294,171 @@ var aiToolsService = {
   },
   /**
    * Run AI tool with a prompt in the current directory
-   * The tool runs interactively, inheriting stdio
+   * Runs non-interactively with real-time output streaming
    */
-  async runWithPrompt(tool, prompt) {
+  async runWithPrompt(tool, prompt, verbose = false) {
     const config = AI_TOOLS[tool];
     logger.newline();
-    logger.info(`Starte ${config.name}...`);
-    logger.info("Das AI-Tool wird interaktiv ausgef\xFChrt. Folgen Sie den Anweisungen.");
-    logger.newline();
+    const args = [...config.args, prompt];
+    if (verbose) {
+      console.log(chalk4.cyan("[DEBUG] === AI Tool Debug Mode ==="));
+      console.log(chalk4.dim(`[DEBUG] Tool: ${config.name}`));
+      console.log(chalk4.dim(`[DEBUG] Command: ${config.command}`));
+      console.log(chalk4.dim(`[DEBUG] Args: ${config.args.join(" ")} + prompt (${prompt.length} chars)`));
+      console.log(chalk4.dim(`[DEBUG] CWD: ${process.cwd()}`));
+      console.log(chalk4.dim(`[DEBUG] Prompt preview: ${prompt.substring(0, 100)}...`));
+      console.log("");
+    }
+    const spinner = ora2({
+      text: `${config.name} arbeitet...`,
+      color: "cyan"
+    }).start();
     return new Promise((resolve2) => {
-      const args = config.promptFlag ? [config.promptFlag, prompt] : [prompt];
+      if (verbose) {
+        spinner.stop();
+        console.log(chalk4.dim("[DEBUG] Spawning child process..."));
+        spinner.start();
+      }
       const child = spawn(config.command, args, {
-        stdio: "inherit",
         cwd: process.cwd(),
-        shell: process.platform === "win32"
+        shell: process.platform === "win32",
+        stdio: ["pipe", "pipe", "pipe"],
+        // stdin must be piped and closed for non-interactive mode
+        env: {
+          ...process.env,
+          FORCE_COLOR: "1"
+        }
+      });
+      child.stdin?.end();
+      if (verbose) {
+        spinner.stop();
+        console.log(chalk4.dim(`[DEBUG] Child process spawned, PID: ${child.pid}`));
+        console.log(chalk4.dim(`[DEBUG] Waiting for output...`));
+        spinner.start();
+      }
+      let filesModified = [];
+      let rawOutput = "";
+      child.stdout?.on("data", (data) => {
+        const text = data.toString();
+        rawOutput += text;
+        if (verbose) {
+          spinner.stop();
+          console.log(chalk4.dim(`[STDOUT] ${text.substring(0, 500)}`));
+          spinner.start();
+        }
+        for (const line of text.split("\n")) {
+          if (!line.trim()) continue;
+          try {
+            const event = JSON.parse(line);
+            if (verbose) {
+              spinner.stop();
+              console.log(chalk4.dim(`[EVENT] type=${event.type}`));
+              spinner.start();
+            }
+            switch (event.type) {
+              case "assistant":
+                if (event.message?.content) {
+                  for (const block of event.message.content) {
+                    if (block.type === "text" && block.text) {
+                      spinner.text = truncateText(block.text, 60);
+                    }
+                    if (block.type === "tool_use") {
+                      const action = formatToolAction(block.name, block.input);
+                      spinner.text = action;
+                      if (verbose) {
+                        spinner.stop();
+                        console.log(chalk4.dim(`[TOOL] ${block.name}: ${JSON.stringify(block.input).substring(0, 200)}`));
+                        spinner.start();
+                      }
+                    }
+                  }
+                }
+                break;
+              case "result":
+                if (event.tool_name === "Write" || event.tool_name === "Edit") {
+                  const filePath = event.input?.file_path || event.input?.path;
+                  if (filePath && !filesModified.includes(filePath)) {
+                    filesModified.push(filePath);
+                  }
+                }
+                break;
+            }
+          } catch {
+            if (line.trim()) {
+              spinner.text = truncateText(line, 60);
+            }
+          }
+        }
+      });
+      child.stderr?.on("data", (data) => {
+        const text = data.toString().trim();
+        if (verbose) {
+          spinner.stop();
+          console.log(chalk4.yellow(`[STDERR] ${text}`));
+          spinner.start();
+        }
+        if (text && !text.includes("ExperimentalWarning")) {
+          spinner.warn(text);
+          spinner.start();
+        }
       });
       child.on("close", (code) => {
+        if (verbose) {
+          spinner.stop();
+          console.log(chalk4.dim(`[DEBUG] Process exited with code: ${code}`));
+          console.log(chalk4.dim(`[DEBUG] Total output length: ${rawOutput.length} chars`));
+          if (rawOutput.length === 0) {
+            console.log(chalk4.yellow(`[DEBUG] No output received from ${config.name}!`));
+          }
+        }
+        if (code === 0) {
+          spinner.succeed(`${config.name} abgeschlossen`);
+          if (filesModified.length > 0) {
+            logger.newline();
+            logger.info("Ge\xE4nderte Dateien:");
+            for (const file of filesModified) {
+              console.log(`  ${chalk4.green("\u2713")} ${file}`);
+            }
+          }
+        } else {
+          spinner.fail(`${config.name} fehlgeschlagen (Exit Code: ${code})`);
+        }
         logger.newline();
         resolve2(code === 0);
       });
       child.on("error", (err) => {
-        logger.error(`Fehler beim Ausf\xFChren von ${config.name}: ${err.message}`);
+        if (verbose) {
+          console.log(chalk4.red(`[ERROR] Spawn error: ${err.message}`));
+        }
+        spinner.fail(`Fehler beim Ausf\xFChren von ${config.name}: ${err.message}`);
         resolve2(false);
       });
     });
   }
 };
+function truncateText(text, maxLength) {
+  const cleaned = text.replace(/\n/g, " ").trim();
+  if (cleaned.length <= maxLength) return cleaned;
+  return cleaned.slice(0, maxLength - 3) + "...";
+}
+function formatToolAction(toolName, input) {
+  switch (toolName) {
+    case "Read":
+      return `Lese ${input.file_path || "Datei"}...`;
+    case "Write":
+      return `Schreibe ${input.file_path || "Datei"}...`;
+    case "Edit":
+      return `Bearbeite ${input.file_path || "Datei"}...`;
+    case "Bash":
+      return `F\xFChre Befehl aus...`;
+    case "Glob":
+      return `Suche Dateien...`;
+    case "Grep":
+      return `Durchsuche Code...`;
+    default:
+      return `${toolName}...`;
+  }
+}
 
 // src/utils/detect-project.ts
 import * as fs2 from "fs/promises";
@@ -1304,30 +1466,11 @@ import * as path2 from "path";
 async function detectProjectConfig() {
   const cwd = process.cwd();
   const result = {
-    hasDockerfile: false,
     hasDockerCompose: false,
     hasGitLabPipeline: false,
     hasGitHubPipeline: false,
     hasTurboOpsInPipeline: false
   };
-  const dockerfilePaths = [
-    "Dockerfile",
-    "dockerfile",
-    "docker/Dockerfile",
-    "api/Dockerfile",
-    "app/Dockerfile",
-    "projects/api/Dockerfile",
-    "projects/app/Dockerfile"
-  ];
-  for (const dockerPath of dockerfilePaths) {
-    try {
-      await fs2.access(path2.join(cwd, dockerPath));
-      result.hasDockerfile = true;
-      result.dockerfilePath = dockerPath;
-      break;
-    } catch {
-    }
-  }
   const composePaths = ["docker-compose.yml", "docker-compose.yaml", "compose.yml", "compose.yaml"];
   for (const composePath of composePaths) {
     try {
@@ -1367,8 +1510,12 @@ async function detectProjectConfig() {
 }
 
 // src/commands/init.ts
-import chalk4 from "chalk";
+import chalk5 from "chalk";
 var initCommand = new Command3("init").description("Initialize TurboOps project in current directory").action(async () => {
+  const verbose = process.env.DEBUG === "true";
+  if (verbose) {
+    console.log("[DEBUG] Verbose mode enabled");
+  }
   logger.header("TurboOps Project Initialization");
   if (!configService.isAuthenticated()) {
     logger.warning("Nicht authentifiziert. Bitte melden Sie sich zuerst an.");
@@ -1414,7 +1561,7 @@ var initCommand = new Command3("init").description("Initialize TurboOps project
     () => apiClient.getProject(projectSlug)
   );
   if (project) {
-    await setupProject(project);
+    await setupProject(project, verbose);
     return;
   }
   logger.newline();
@@ -1430,48 +1577,27 @@ var initCommand = new Command3("init").description("Initialize TurboOps project
     addJsonData({ initialized: false, reason: "project_not_found" });
     return;
   }
-  await createNewProject(projectSlug);
+  await createNewProject(projectSlug, verbose);
 });
-async function setupProject(project) {
+async function setupProject(project, verbose = false) {
   configService.setProject(project.slug);
   const { data: environments } = await apiClient.getEnvironments(project.id);
   if (!environments || environments.length === 0) {
     logger.newline();
     const { shouldCreateStage } = await prompts2({
       initial: true,
-      message: "Das Projekt hat noch keine Stages. M\xF6chten Sie jetzt eine erstellen?",
+      message: "Das Projekt hat noch keine Stages. Standard-Stages erstellen (dev, test, prod)?",
       name: "shouldCreateStage",
       type: "confirm"
     });
     if (shouldCreateStage) {
-      await createFirstStage(project.id, project.slug);
+      await createDefaultStages(project.id, project.slug);
     }
   }
-  const fs4 = await import("fs/promises");
-  const path4 = await import("path");
-  const gitlabCiPath = path4.join(process.cwd(), ".gitlab-ci.yml");
-  let hasGitLabPipeline = false;
-  try {
-    await fs4.access(gitlabCiPath);
-    hasGitLabPipeline = true;
-  } catch {
-  }
-  if (!hasGitLabPipeline) {
-    logger.newline();
-    const { shouldCreatePipeline } = await prompts2({
-      initial: false,
-      message: "M\xF6chten Sie eine CI/CD Pipeline anlegen?",
-      name: "shouldCreatePipeline",
-      type: "confirm"
-    });
-    if (shouldCreatePipeline) {
-      await createPipeline(project.id);
-    }
-  }
-  await offerAiAssistance(project.slug);
+  await offerAiAssistance(project.slug, project.id, verbose);
   await showFinalSummary(project);
 }
-async function createNewProject(slug) {
+async function createNewProject(slug, verbose = false) {
   logger.newline();
   logger.header("Neues Projekt erstellen");
   const { data: customers } = await withSpinner(
@@ -1545,105 +1671,76 @@ async function createNewProject(slug) {
   logger.newline();
   const { shouldCreateStage } = await prompts2({
     initial: true,
-    message: "M\xF6chten Sie jetzt die erste Stage anlegen?",
+    message: "Standard-Stages erstellen (dev, test, prod)?",
     name: "shouldCreateStage",
     type: "confirm"
   });
   if (shouldCreateStage) {
-    await createFirstStage(newProject.id, newProject.slug);
-  }
-  logger.newline();
-  const { shouldCreatePipeline } = await prompts2({
-    initial: true,
-    message: "M\xF6chten Sie eine CI/CD Pipeline anlegen?",
-    name: "shouldCreatePipeline",
-    type: "confirm"
-  });
-  if (shouldCreatePipeline) {
-    await createPipeline(newProject.id);
+    await createDefaultStages(newProject.id, newProject.slug);
   }
+  await offerAiAssistance(newProject.slug, newProject.id, verbose);
   await showFinalSummary(newProject);
 }
-async function createFirstStage(projectId, projectSlug) {
+var DEFAULT_STAGES = [
+  {
+    name: "Development",
+    slug: "dev",
+    type: "development",
+    branch: "dev",
+    stageOrder: 0
+  },
+  {
+    name: "Test",
+    slug: "test",
+    type: "staging",
+    branch: "test",
+    stageOrder: 1
+  },
+  {
+    name: "Production",
+    slug: "prod",
+    type: "production",
+    branch: "main",
+    stageOrder: 2
+  }
+];
+async function createDefaultStages(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 prompts2(stageQuestions);
-  if (!stageDetails.name || !stageDetails.slug) {
+  logger.header("Standard-Stages erstellen");
+  const { baseDomain } = await prompts2({
+    type: "text",
+    name: "baseDomain",
+    message: "Basis-Domain (z.B. example.com):",
+    initial: "example.com"
+  });
+  if (!baseDomain) {
     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.newline();
+  logger.info("Erstelle 3 Standard-Stages:");
+  for (const stage of DEFAULT_STAGES) {
+    const domain = `${stage.slug}.${projectSlug}.${baseDomain}`;
+    const { data: newStage, error } = await withSpinner(
+      `Erstelle ${stage.name}...`,
+      () => apiClient.createStage({
+        project: projectId,
+        name: stage.name,
+        slug: stage.slug,
+        type: stage.type,
+        stageOrder: stage.stageOrder,
+        domain,
+        branch: stage.branch
+      })
+    );
+    if (error || !newStage) {
+      logger.error(`  \u2717 ${stage.name}: ${error || "Unbekannter Fehler"}`);
+    } else {
+      logger.success(`  \u2713 ${stage.name} (${stage.slug}) - ${domain}`);
+    }
   }
-  logger.success(`Stage "${newStage.name}" wurde erstellt!`);
+  logger.newline();
+  logger.info("Server k\xF6nnen sp\xE4ter in der Web-UI zugewiesen werden.");
 }
 async function createPipeline(projectId) {
   logger.newline();
@@ -1686,14 +1783,20 @@ async function createPipeline(projectId) {
   try {
     await fs4.writeFile(filePath, pipeline.content, "utf-8");
     logger.success(`${pipeline.filename} wurde erstellt!`);
+    await apiClient.updateProjectConfig(projectId, {
+      pipelineConfig: {
+        hasPipeline: true,
+        pipelineType: pipelineDetails.pipelineType
+      }
+    });
     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)}`);
+        const value = secret.isSecret ? chalk5.dim("(geheim)") : chalk5.cyan(secret.value || "-");
+        console.log(`  ${chalk5.bold(secret.name)}: ${value}`);
+        console.log(`    ${chalk5.dim(secret.description)}`);
       }
       logger.newline();
       logger.info("F\xFCgen Sie diese Werte als CI/CD Secrets/Variables hinzu.");
@@ -1732,20 +1835,63 @@ async function showFinalSummary(project) {
     logger.newline();
     logger.header("Verf\xFCgbare Stages");
     for (const env of environments) {
-      console.log(`  ${chalk4.bold(env.slug)} - ${env.name} (${env.type})`);
+      console.log(`  ${chalk5.bold(env.slug)} - ${env.name} (${env.type})`);
     }
   }
   logger.newline();
+  logger.header("CI/CD Token einrichten");
+  console.log(chalk5.cyan("  1. Projekt-Token erstellen:"));
+  console.log(`     ${chalk5.dim("\u2192")} TurboOps Web-UI \xF6ffnen`);
+  console.log(`     ${chalk5.dim("\u2192")} Projekt "${project.name}" ausw\xE4hlen`);
+  console.log(`     ${chalk5.dim("\u2192")} Settings \u2192 Tokens \u2192 "Neuer Token"`);
+  logger.newline();
+  console.log(chalk5.cyan("  2. Token als CI/CD Secret hinterlegen:"));
+  console.log(chalk5.dim("     GitLab:"));
+  console.log(`     ${chalk5.dim("\u2192")} Settings \u2192 CI/CD \u2192 Variables`);
+  console.log(`     ${chalk5.dim("\u2192")} Variable: ${chalk5.bold("TURBOOPS_TOKEN")} = <dein-token>`);
+  console.log(`     ${chalk5.dim("\u2192")} Flags: Protected, Masked`);
+  logger.newline();
+  console.log(chalk5.dim("     GitHub:"));
+  console.log(`     ${chalk5.dim("\u2192")} Settings \u2192 Secrets and variables \u2192 Actions`);
+  console.log(`     ${chalk5.dim("\u2192")} New repository secret: ${chalk5.bold("TURBOOPS_TOKEN")}`);
+  logger.newline();
   logger.header("N\xE4chste Schritte");
   logger.list([
-    "F\xFChren Sie `turbo status` aus, um alle Stages zu sehen",
-    "F\xFChren Sie `turbo logs <stage>` aus, um Logs anzuzeigen"
+    "Projekt-Token in TurboOps erstellen (siehe oben)",
+    "Token als CI/CD Secret hinterlegen",
+    "Pipeline committen und pushen",
+    "`turbo status` ausf\xFChren um Deployments zu pr\xFCfen"
   ]);
 }
-async function offerAiAssistance(projectSlug) {
+async function offerAiAssistance(projectSlug, projectId, verbose = false) {
   const detection = await detectProjectConfig();
-  if (!detection.hasDockerCompose) {
-    logger.newline();
+  logger.newline();
+  logger.header("Docker Setup");
+  if (detection.hasDockerCompose) {
+    logger.success("docker-compose.yml gefunden.");
+    const { error } = await apiClient.updateProjectConfig(projectId, {
+      detectedConfig: {
+        hasCompose: true,
+        composePath: "docker-compose.yml"
+      }
+    });
+    if (error) {
+      logger.warning(`API Update fehlgeschlagen: ${error}`);
+    }
+    const { dockerAction } = await prompts2({
+      type: "select",
+      name: "dockerAction",
+      message: "Docker-Setup:",
+      choices: [
+        { title: "Bestehende docker-compose.yml verwenden", value: "keep" },
+        { title: "Neu erstellen mit AI (\xFCberschreibt bestehende)", value: "create" }
+      ],
+      initial: 0
+    });
+    if (dockerAction === "create") {
+      await createDockerSetupWithAI(projectId, verbose);
+    }
+  } else {
     logger.warning("Keine docker-compose.yml gefunden.");
     logger.info("TurboOps Deployment ben\xF6tigt eine docker-compose.yml auf Root-Ebene.");
     const { shouldCreateDocker } = await prompts2({
@@ -1755,265 +1901,303 @@ async function offerAiAssistance(projectSlug) {
       initial: true
     });
     if (shouldCreateDocker) {
-      await createDockerSetupWithAI();
+      await createDockerSetupWithAI(projectId, verbose);
     }
   }
-  if ((detection.hasGitLabPipeline || detection.hasGitHubPipeline) && !detection.hasTurboOpsInPipeline) {
-    logger.newline();
+  logger.newline();
+  logger.header("CI/CD Pipeline");
+  const hasPipeline = detection.hasGitLabPipeline || detection.hasGitHubPipeline;
+  if (hasPipeline) {
     const pipelineType = detection.hasGitLabPipeline ? "GitLab" : "GitHub";
-    const { shouldIntegrate } = await prompts2({
+    if (detection.hasTurboOpsInPipeline) {
+      logger.success(`${pipelineType} Pipeline mit TurboOps gefunden.`);
+      const { error } = await apiClient.updateProjectConfig(projectId, {
+        pipelineConfig: {
+          hasPipeline: true,
+          pipelineType: detection.hasGitLabPipeline ? "gitlab" : "github"
+        }
+      });
+      if (error) {
+        logger.warning(`API Update fehlgeschlagen: ${error}`);
+      }
+      const { pipelineAction } = await prompts2({
+        type: "select",
+        name: "pipelineAction",
+        message: "Pipeline-Setup:",
+        choices: [
+          { title: "Bestehende Pipeline behalten", value: "keep" },
+          { title: "Mit AI neu integrieren (\xFCberschreibt TurboOps-Teil)", value: "integrate" }
+        ],
+        initial: 0
+      });
+      if (pipelineAction === "integrate") {
+        await integratePipelineWithAI(detection, projectSlug, verbose, projectId);
+      }
+    } else {
+      logger.info(`${pipelineType} Pipeline gefunden (ohne TurboOps).`);
+      const { shouldIntegrate } = await prompts2({
+        type: "confirm",
+        name: "shouldIntegrate",
+        message: "TurboOps mit AI in bestehende Pipeline integrieren?",
+        initial: true
+      });
+      if (shouldIntegrate) {
+        await integratePipelineWithAI(detection, projectSlug, verbose, projectId);
+      }
+    }
+  } else {
+    logger.warning("Keine CI/CD Pipeline gefunden.");
+    const { shouldCreatePipeline } = await prompts2({
       type: "confirm",
-      name: "shouldIntegrate",
-      message: `${pipelineType} Pipeline gefunden ohne TurboOps. Mit AI integrieren lassen?`,
+      name: "shouldCreatePipeline",
+      message: "Pipeline erstellen?",
       initial: true
     });
-    if (shouldIntegrate) {
-      await integratePipelineWithAI(detection, projectSlug);
+    if (shouldCreatePipeline) {
+      await createPipeline(projectId);
     }
   }
 }
-async function createDockerSetupWithAI() {
+async function createDockerSetupWithAI(projectId, verbose = false) {
   const tool = await aiToolsService.selectTool();
   if (!tool) return;
-  const prompt = `Analysiere dieses Projekt und erstelle ein vollst\xE4ndiges Docker-Setup f\xFCr Production Deployment.
-
-**Wichtig: TurboOps ben\xF6tigt eine docker-compose.yml auf Root-Ebene!**
+  const prompt = `Analysiere dieses Projekt und erstelle ein Docker-Setup f\xFCr TurboOps Production Deployment.
 
-Anforderungen:
-1. Erstelle eine "docker-compose.yml" im Projekt-Root
-   - Services f\xFCr alle Komponenten (z.B. api, app, db wenn n\xF6tig)
-   - Verwende build-Direktive mit Pfad zu den Dockerfiles
-   - Health-Checks f\xFCr alle Services
-   - Production-geeignete Konfiguration
+=== TURBOOPS ANFORDERUNGEN ===
+- docker-compose.yml MUSS auf Root-Ebene liegen
+- ALLE Abh\xE4ngigkeiten m\xFCssen enthalten sein (DB, Redis, etc.) - production-ready!
+- Images m\xFCssen immutable sein (keine Volume-Mounts f\xFCr Code)
+- Datenbank-Volumes f\xFCr Persistenz sind erlaubt (named volumes)
+- Environment-Variablen via \${VARIABLE} Syntax (werden zur Laufzeit injiziert)
 
-2. Erstelle Dockerfiles in den entsprechenden Unterordnern
-   - Multi-stage builds f\xFCr kleine Images
-   - F\xFCr jeden Service ein eigenes Dockerfile (z.B. ./api/Dockerfile, ./app/Dockerfile)
-   - Optimiert f\xFCr Production
-
-3. Erstelle eine ".dockerignore" auf Root-Ebene
-   - node_modules, .git, etc. ausschlie\xDFen
+=== ZU ERSTELLENDE DATEIEN ===
 
-4. Falls Monorepo: Beachte die Projekt-Struktur
-   - Pr\xFCfe ob projects/, packages/, apps/ Ordner existieren
-
-Beispiel docker-compose.yml Struktur:
+1. docker-compose.yml (Root-Ebene) - ALLE Abh\xE4ngigkeiten enthalten!
 \`\`\`yaml
-version: '3.8'
 services:
+  # === DATENBANKEN & SERVICES ===
+  mongo:
+    image: mongo:7
+    volumes:
+      - mongo_data:/data/db
+    environment:
+      - MONGO_INITDB_ROOT_USERNAME=\${MONGO_USER:-admin}
+      - MONGO_INITDB_ROOT_PASSWORD=\${MONGO_PASSWORD}
+    healthcheck:
+      test: ["CMD", "mongosh", "--eval", "db.adminCommand('ping')"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+    restart: unless-stopped
+
+  redis:
+    image: redis:7-alpine
+    volumes:
+      - redis_data:/data
+    healthcheck:
+      test: ["CMD", "redis-cli", "ping"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+    restart: unless-stopped
+
+  # === APPLICATION SERVICES ===
   api:
     build:
       context: .
-      dockerfile: ./api/Dockerfile
+      dockerfile: ./projects/api/Dockerfile  # oder ./api/Dockerfile
     ports:
       - "3000:3000"
+    environment:
+      - NODE_ENV=production
+      - MONGO_URI=mongodb://\${MONGO_USER:-admin}:\${MONGO_PASSWORD}@mongo:27017/app?authSource=admin
+      - REDIS_URL=redis://redis:6379
+    depends_on:
+      mongo:
+        condition: service_healthy
+      redis:
+        condition: service_healthy
     healthcheck:
-      test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
+      test: ["CMD", "wget", "-q", "--spider", "http://localhost:3000/health"]
       interval: 30s
       timeout: 10s
       retries: 3
+      start_period: 40s
+    restart: unless-stopped
+
+  app:
+    build:
+      context: .
+      dockerfile: ./projects/app/Dockerfile  # oder ./app/Dockerfile
+    ports:
+      - "3001:3000"
+    environment:
+      - NUXT_PUBLIC_API_URL=http://api:3000
+    depends_on:
+      api:
+        condition: service_healthy
+    healthcheck:
+      test: ["CMD", "wget", "-q", "--spider", "http://localhost:3000"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+    restart: unless-stopped
+
+volumes:
+  mongo_data:
+  redis_data:
 \`\`\`
 
-Erstelle alle notwendigen Dateien.`;
-  const success = await aiToolsService.runWithPrompt(tool, prompt);
+2. Dockerfile f\xFCr jeden Service (im jeweiligen Ordner)
+\`\`\`dockerfile
+# Multi-stage build
+FROM node:20-alpine AS builder
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci
+COPY . .
+RUN npm run build
+
+FROM node:20-alpine AS runner
+WORKDIR /app
+ENV NODE_ENV=production
+# Non-root user f\xFCr Sicherheit
+RUN addgroup -g 1001 -S nodejs && adduser -S nodejs -u 1001
+COPY --from=builder --chown=nodejs:nodejs /app/dist ./dist
+COPY --from=builder --chown=nodejs:nodejs /app/node_modules ./node_modules
+COPY --from=builder --chown=nodejs:nodejs /app/package.json ./
+USER nodejs
+EXPOSE 3000
+CMD ["node", "dist/main.js"]
+\`\`\`
+
+3. .dockerignore (Root-Ebene)
+\`\`\`
+node_modules
+.git
+.env*
+*.log
+dist
+.nuxt
+.output
+coverage
+\`\`\`
+
+=== WICHTIGE REGELN ===
+- Pr\xFCfe die tats\xE4chliche Projektstruktur (projects/, packages/, apps/, oder flach)
+- Passe Pfade entsprechend an
+- NestJS: CMD ["node", "dist/main.js"]
+- Nuxt: CMD ["node", ".output/server/index.mjs"]
+- Nutze wget statt curl f\xFCr healthchecks (curl nicht in alpine)
+- Named volumes f\xFCr Datenbank-Persistenz (mongo_data, redis_data, etc.)
+- Keine Code-Volume-Mounts (Code ist im Image)
+- depends_on mit condition: service_healthy f\xFCr korrekten Start-Order
+- Erkenne ben\xF6tigte Services aus package.json (mongoose \u2192 mongo, ioredis \u2192 redis, etc.)
+
+Erstelle alle notwendigen Dateien basierend auf der erkannten Projektstruktur und Abh\xE4ngigkeiten.`;
+  const success = await aiToolsService.runWithPrompt(tool, prompt, verbose);
   if (success) {
     logger.success("Docker-Setup wurde erstellt!");
+    await apiClient.updateProjectConfig(projectId, {
+      detectedConfig: {
+        hasCompose: true,
+        composePath: "docker-compose.yml"
+      }
+    });
   }
 }
-async function integratePipelineWithAI(detection, projectSlug) {
+async function integratePipelineWithAI(detection, projectSlug, verbose = false, projectId) {
   const tool = await aiToolsService.selectTool();
   if (!tool) return;
-  const pipelineType = detection.hasGitLabPipeline ? "GitLab CI" : "GitHub Actions";
+  const pipelineType = detection.hasGitLabPipeline ? "gitlab" : "github";
   const pipelineFile = detection.pipelinePath;
-  const prompt = `Integriere TurboOps Deployment in die bestehende ${pipelineType} Pipeline.
+  let templateContent = "";
+  if (projectId) {
+    const { data: pipelineTemplate, error } = await withSpinner(
+      "Lade TurboOps Pipeline-Template...",
+      () => apiClient.generatePipeline(projectId, pipelineType)
+    );
+    if (error || !pipelineTemplate) {
+      logger.warning(`Pipeline-Template konnte nicht geladen werden: ${error || "Unbekannter Fehler"}`);
+      logger.info("Claude Code wird ein generisches Template verwenden.");
+    } else {
+      templateContent = pipelineTemplate.content;
+    }
+  }
+  const pipelineTypeName = pipelineType === "gitlab" ? "GitLab CI" : "GitHub Actions";
+  const prompt = templateContent ? `WICHTIG: Integriere das TurboOps Deployment-Template EXAKT wie vorgegeben in die bestehende ${pipelineTypeName} Pipeline.
+
+Bestehende Pipeline-Datei: ${pipelineFile}
+
+=== TURBOOPS TEMPLATE (NICHT VER\xC4NDERN!) ===
+\`\`\`yaml
+${templateContent}
+\`\`\`
+=== ENDE TEMPLATE ===
+
+STRIKTE REGELN:
+1. Das TurboOps Template MUSS EXAKT so \xFCbernommen werden wie oben angegeben
+2. KEINE \xC4nderungen an:
+   - Variables (IMAGE_NAME, DOCKER_TLS_CERTDIR)
+   - Job-Namen (build, deploy-dev, deploy-test, deploy-prod)
+   - Script-Befehlen (turbo deploy, docker build, etc.)
+   - Branch-Rules (die sind korrekt f\xFCr die konfigurierten Stages)
+   - needs/dependencies zwischen Jobs
+3. NUR erlaubte \xC4nderungen:
+   - Stages der bestehenden Pipeline VOR den TurboOps-Stages einf\xFCgen
+   - Bestehende Jobs der Pipeline BEHALTEN (z.B. lint, test)
+   - TurboOps "build" Job muss von bestehenden Build-Jobs abh\xE4ngen (needs)
+
+MERGE-STRATEGIE:
+- Bestehende stages: [lint, test, build] + TurboOps stages: [build, deploy-dev, deploy-test, deploy-prod]
+- Ergebnis: stages: [lint, test, build, turboops-build, deploy-dev, deploy-test, deploy-prod]
+- Der TurboOps "build" Job sollte in "turboops-build" umbenannt werden falls es bereits einen "build" Job gibt
+- turboops-build needs: [build] (vom bestehenden build Job)
+
+Modifiziere die Datei "${pipelineFile}" entsprechend.` : `Erstelle eine neue ${pipelineTypeName} Pipeline f\xFCr TurboOps Deployment.
 
 Projekt-Slug: ${projectSlug}
 Pipeline-Datei: ${pipelineFile}
 
-Anforderungen:
-1. Die bestehende Pipeline-Struktur beibehalten
-2. Einen neuen Deploy-Job/Step hinzuf\xFCgen der nach dem Build l\xE4uft
-3. TurboOps CLI installieren: npm install -g @turboops/cli
-4. Token setzen: turbo config set token \${TURBOOPS_TOKEN}
-5. Deploy ausf\xFChren: turbo deploy <environment> --image <image-tag> --wait
+Erstelle eine Standard-Pipeline mit:
+1. Build-Stage: Docker Image bauen und pushen
+2. Deploy-Stages f\xFCr jede Umgebung (dev, test, prod)
 
-Die erste Stage braucht --image, weitere Stages k\xF6nnen ohne --image deployen (Promotion).
+Jede Stage deployed nur auf ihrem Branch (dev->dev, test->test, main->prod).
 
-F\xFCge am Ende einen Kommentar hinzu welche Secrets ben\xF6tigt werden:
-- TURBOOPS_TOKEN: TurboOps Projekt-Token
+Verwende:
+- Image: docker:24-dind f\xFCr Build
+- Image: node:20-alpine f\xFCr Deploy
+- Registry: registry.turbo-ops.de/${projectSlug}
+- TurboOps CLI: npm install -g @turboops/cli
 
-Modifiziere die Datei "${pipelineFile}" entsprechend.`;
-  const success = await aiToolsService.runWithPrompt(tool, prompt);
+Befehle:
+- turbo config set token \${TURBOOPS_TOKEN}
+- turbo deploy <stage-slug> --image <image-tag> --wait
+
+Secrets ben\xF6tigt: TURBOOPS_TOKEN
+
+Erstelle die Datei "${pipelineFile}".`;
+  const success = await aiToolsService.runWithPrompt(tool, prompt, verbose);
   if (success) {
     logger.success("Pipeline wurde mit AI aktualisiert!");
-    logger.newline();
-    logger.info("Vergessen Sie nicht, das CI/CD Secret TURBOOPS_TOKEN zu konfigurieren.");
-  }
-}
-
-// src/commands/logs.ts
-import { Command as Command4 } from "commander";
-import chalk5 from "chalk";
-import { io } from "socket.io-client";
-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) {
-    if (isJsonMode()) {
-      logger.error("JSON output mode is not supported with --follow flag");
-      process.exit(14 /* VALIDATION_ERROR */);
-    }
-    await streamLogs(env.id, options.service);
-  } else {
-    await fetchHistoricalLogs(
-      env.id,
-      parseInt(options.lines),
-      options.service
-    );
-  }
-});
-async function fetchHistoricalLogs(environmentId, lines, service) {
-  logger.info("Fetching logs...");
-  const { data, error } = await apiClient.request(
-    "GET",
-    `/deployment/environments/${environmentId}/logs?lines=${lines}${service ? `&service=${service}` : ""}`
-  );
-  if (error) {
-    logger.error(`Failed to fetch logs: ${error}`);
-    process.exit(13 /* API_ERROR */);
-  }
-  if (!data?.logs || data.logs.length === 0) {
-    logger.info("No logs available.");
-    addJsonData({ logs: [] });
-    return;
-  }
-  addJsonData({
-    logs: data.logs.map((log) => ({
-      timestamp: log.timestamp,
-      level: log.level,
-      message: log.message,
-      step: log.step
-    })),
-    count: data.logs.length
-  });
-  logger.newline();
-  for (const log of data.logs) {
-    printLogEntry(log);
-  }
-  logger.newline();
-  logger.info(`Showing last ${lines} lines. Use -f to follow live logs.`);
-}
-async function streamLogs(environmentId, service) {
-  const apiUrl = configService.getApiUrl();
-  const token = configService.getToken();
-  if (!token) {
-    logger.error("Not authenticated");
-    process.exit(10 /* AUTH_ERROR */);
-  }
-  const wsUrl = buildWebSocketUrl(apiUrl);
-  logger.info("Connecting to log stream...");
-  const socket = io(`${wsUrl}/deployments`, {
-    auth: { token },
-    reconnection: true,
-    reconnectionAttempts: 5,
-    reconnectionDelay: 1e3
-  });
-  socket.on("connect", () => {
-    logger.success("Connected to log stream");
-    logger.info("Streaming logs... (Press Ctrl+C to stop)");
-    logger.newline();
-    socket.emit("join:logs", {
-      environmentId,
-      service
-    });
-  });
-  socket.on("log", (entry) => {
-    printLogEntry(entry);
-  });
-  socket.on("logs:batch", (entries) => {
-    for (const entry of entries) {
-      printLogEntry(entry);
-    }
-  });
-  socket.on("error", (error) => {
-    logger.error(`Stream error: ${error.message}`);
-  });
-  socket.on("connect_error", (error) => {
-    logger.error(`Connection error: ${error.message}`);
-    process.exit(15 /* NETWORK_ERROR */);
-  });
-  socket.on("disconnect", (reason) => {
-    if (reason === "io server disconnect") {
-      logger.warning("Disconnected by server");
-    } else {
-      logger.warning(`Disconnected: ${reason}`);
+    if (projectId) {
+      await apiClient.updateProjectConfig(projectId, {
+        pipelineConfig: {
+          hasPipeline: true,
+          pipelineType
+        }
+      });
     }
-  });
-  socket.on("reconnect", () => {
-    logger.info("Reconnected to log stream");
-    socket.emit("join:logs", { environmentId, service });
-  });
-  process.on("SIGINT", () => {
     logger.newline();
-    logger.info("Stopping log stream...");
-    socket.emit("leave:logs", { environmentId });
-    socket.disconnect();
-    process.exit(0 /* SUCCESS */);
-  });
-  await new Promise(() => {
-  });
-}
-function buildWebSocketUrl(apiUrl) {
-  try {
-    const url = new URL(apiUrl);
-    const wsProtocol = url.protocol === "https:" ? "wss:" : "ws:";
-    return `${wsProtocol}//${url.host}`;
-  } catch {
-    return apiUrl.replace(/^https:/, "wss:").replace(/^http:/, "ws:").replace(/\/api\/?$/, "");
-  }
-}
-function printLogEntry(log) {
-  const timestamp = formatTimestamp(log.timestamp);
-  const levelColor = getLevelColor(log.level);
-  const levelStr = log.level.toUpperCase().padEnd(5);
-  let output = chalk5.gray(`[${timestamp}]`) + levelColor(` ${levelStr}`);
-  if (log.step) {
-    output += chalk5.cyan(` [${log.step}]`);
-  }
-  output += ` ${log.message}`;
-  logger.raw(output);
-}
-function formatTimestamp(timestamp) {
-  try {
-    const date = new Date(timestamp);
-    return date.toISOString().replace("T", " ").slice(0, 19);
-  } catch {
-    return timestamp;
-  }
-}
-function getLevelColor(level) {
-  switch (level.toLowerCase()) {
-    case "error":
-    case "fatal":
-      return chalk5.red;
-    case "warn":
-    case "warning":
-      return chalk5.yellow;
-    case "info":
-      return chalk5.blue;
-    case "debug":
-      return chalk5.gray;
-    case "trace":
-      return chalk5.magenta;
-    default:
-      return chalk5.white;
+    logger.info("Vergessen Sie nicht, das CI/CD Secret TURBOOPS_TOKEN zu konfigurieren.");
   }
 }
 
 // src/commands/deploy.ts
-import { Command as Command5 } from "commander";
+import { Command as Command4 } 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(
+var deployCommand = new Command4("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"
@@ -2117,12 +2301,12 @@ function getStatusColor2(status) {
 }
 
 // src/commands/pipeline.ts
-import { Command as Command6 } from "commander";
+import { Command as Command5 } from "commander";
 import prompts3 from "prompts";
 import chalk7 from "chalk";
 import * as fs3 from "fs/promises";
 import * as path3 from "path";
-var pipelineCommand = new Command6("pipeline").description("Manage CI/CD pipeline configuration");
+var pipelineCommand = new Command5("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");
@@ -2355,7 +2539,7 @@ Modifiziere die Datei "${pipelinePath}" entsprechend.`;
 }
 
 // src/commands/docker.ts
-import { Command as Command7 } from "commander";
+import { Command as Command6 } from "commander";
 import prompts4 from "prompts";
 var DOCKER_SETUP_PROMPT = `Analysiere dieses Projekt und erstelle ein vollst\xE4ndiges Docker-Setup f\xFCr Production Deployment.
 
@@ -2397,7 +2581,7 @@ services:
 \`\`\`
 
 Erstelle alle notwendigen Dateien.`;
-var dockerCommand = new Command7("docker").description("Manage Docker configuration");
+var dockerCommand = new Command6("docker").description("Manage Docker configuration");
 dockerCommand.command("generate").description("Docker-Setup (docker-compose + Dockerfiles) mit AI erstellen").option("-f, --force", "Bestehende Dateien \xFCberschreiben").action(async (options) => {
   logger.header("Docker-Setup generieren");
   const detection = await detectProjectConfig();
@@ -2440,7 +2624,7 @@ dockerCommand.command("generate").description("Docker-Setup (docker-compose + Do
 // src/index.ts
 var VERSION = getCurrentVersion();
 var shouldCheckUpdate = true;
-var program = new Command8();
+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("--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();
@@ -2476,7 +2660,6 @@ program.addCommand(whoamiCommand);
 program.addCommand(initCommand);
 program.addCommand(statusCommand);
 program.addCommand(configCommand);
-program.addCommand(logsCommand);
 program.addCommand(deployCommand);
 program.addCommand(pipelineCommand);
 program.addCommand(dockerCommand);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@turboops/cli",
-  "version": "1.0.0-dev.588",
+  "version": "1.0.0-dev.590",
   "description": "TurboCLI - Command line interface for TurboOps deployments",
   "author": "lenne.tech GmbH",
   "license": "MIT",
@@ -14,7 +14,10 @@
   ],
   "scripts": {
     "build": "tsup src/index.ts --format esm --dts --clean",
-    "dev": "tsup src/index.ts --format esm --watch",
+    "build:local": "tsup src/index.ts --format esm --dts --clean --define.__TURBOOPS_ENV__=\"'local'\"",
+    "build:dev": "tsup src/index.ts --format esm --dts --clean --define.__TURBOOPS_ENV__=\"'dev'\"",
+    "build:prod": "tsup src/index.ts --format esm --dts --clean --define.__TURBOOPS_ENV__=\"'prod'\"",
+    "dev": "tsup src/index.ts --format esm --watch --define.__TURBOOPS_ENV__=\"'local'\"",
     "start": "node dist/index.js",
     "lint": "oxlint --fix -c oxlint.json",
     "typecheck": "tsc --noEmit",