@turboops/cli 1.0.0-dev.570

package/dist/index.js

@@ -0,0 +1,1507 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command7 } from "commander";
+import chalk8 from "chalk";
+
+// src/services/config.ts
+import Conf from "conf";
+
+// src/utils/logger.ts
+import chalk from "chalk";
+
+// src/utils/output.ts
+var currentMode = "normal";
+var jsonData = {};
+function setOutputMode(mode) {
+  currentMode = mode;
+}
+function isJsonMode() {
+  return currentMode === "json";
+}
+function isQuietMode() {
+  return currentMode === "quiet";
+}
+function shouldShowOutput() {
+  return currentMode === "normal";
+}
+function addJsonData(data) {
+  jsonData = { ...jsonData, ...data };
+}
+function clearJsonData() {
+  jsonData = {};
+}
+function printJsonOutput() {
+  if (isJsonMode()) {
+    console.log(JSON.stringify(jsonData, null, 2));
+  }
+}
+
+// src/utils/logger.ts
+var logger = {
+  info: (message) => {
+    if (shouldShowOutput()) {
+      console.log(chalk.blue("\u2139"), message);
+    }
+  },
+  success: (message) => {
+    if (isJsonMode()) {
+      addJsonData({ success: true, message });
+    } else if (shouldShowOutput()) {
+      console.log(chalk.green("\u2713"), message);
+    }
+  },
+  warning: (message) => {
+    if (isJsonMode()) {
+      addJsonData({ warning: message });
+    } else if (!isQuietMode()) {
+      console.log(chalk.yellow("\u26A0"), message);
+    }
+  },
+  error: (message) => {
+    if (isJsonMode()) {
+      addJsonData({ error: message, success: false });
+    } else {
+      console.error(chalk.red("\u2717"), message);
+    }
+  },
+  debug: (message) => {
+    if (process.env.DEBUG && shouldShowOutput()) {
+      console.log(chalk.gray("\u2299"), message);
+    }
+  },
+  log: (message) => {
+    if (shouldShowOutput()) {
+      console.log(message);
+    }
+  },
+  newline: () => {
+    if (shouldShowOutput()) {
+      console.log();
+    }
+  },
+  header: (title) => {
+    if (shouldShowOutput()) {
+      console.log();
+      console.log(chalk.bold.cyan(title));
+      console.log(chalk.gray("\u2500".repeat(title.length)));
+    }
+  },
+  table: (data) => {
+    if (isJsonMode()) {
+      addJsonData({ data });
+    } else if (shouldShowOutput()) {
+      const maxKeyLength = Math.max(...Object.keys(data).map((k) => k.length));
+      for (const [key, value] of Object.entries(data)) {
+        console.log(`  ${chalk.gray(key.padEnd(maxKeyLength))}  ${value}`);
+      }
+    }
+  },
+  list: (items) => {
+    if (isJsonMode()) {
+      addJsonData({ items });
+    } else if (shouldShowOutput()) {
+      for (const item of items) {
+        console.log(`  ${chalk.gray("\u2022")} ${item}`);
+      }
+    }
+  },
+  json: (data) => {
+    console.log(JSON.stringify(data, null, 2));
+  },
+  /**
+   * Raw output - bypasses all mode checks
+   * Use for output that must always be shown (e.g., streaming logs)
+   */
+  raw: (message) => {
+    console.log(message);
+  }
+};
+
+// src/services/config.ts
+var defaults = {
+  apiUrl: "https://api.turboops.io",
+  token: null,
+  project: null,
+  userId: null
+};
+var config = new Conf({
+  projectName: "turboops-cli",
+  defaults
+});
+var configService = {
+  /**
+   * Get API URL
+   */
+  getApiUrl() {
+    return process.env.TURBOOPS_API_URL || config.get("apiUrl");
+  },
+  /**
+   * Set API URL
+   */
+  setApiUrl(url) {
+    config.set("apiUrl", url);
+  },
+  /**
+   * Get authentication token
+   */
+  getToken() {
+    return process.env.TURBOOPS_TOKEN || config.get("token");
+  },
+  /**
+   * Set authentication token
+   */
+  setToken(token) {
+    config.set("token", token);
+  },
+  /**
+   * Clear authentication token
+   */
+  clearToken() {
+    config.set("token", null);
+    config.set("userId", null);
+  },
+  /**
+   * Get current project
+   */
+  getProject() {
+    return process.env.TURBOOPS_PROJECT || config.get("project");
+  },
+  /**
+   * Set current project
+   */
+  setProject(project) {
+    config.set("project", project);
+  },
+  /**
+   * Clear current project
+   */
+  clearProject() {
+    config.set("project", null);
+  },
+  /**
+   * Get user ID
+   */
+  getUserId() {
+    return config.get("userId");
+  },
+  /**
+   * Set user ID
+   */
+  setUserId(userId) {
+    config.set("userId", userId);
+  },
+  /**
+   * Check if user is authenticated
+   */
+  isAuthenticated() {
+    return !!this.getToken();
+  },
+  /**
+   * Check if project is configured
+   */
+  hasProject() {
+    return !!this.getProject();
+  },
+  /**
+   * Get all configuration
+   */
+  getAll() {
+    return {
+      apiUrl: this.getApiUrl(),
+      token: this.getToken() ? "***" : null,
+      project: this.getProject(),
+      userId: this.getUserId()
+    };
+  },
+  /**
+   * Clear all configuration
+   */
+  clearAll() {
+    config.clear();
+  },
+  /**
+   * Check if using a project token (turbo_xxx format)
+   */
+  isProjectToken() {
+    const token = this.getToken();
+    return !!token && token.startsWith("turbo_");
+  },
+  /**
+   * Show current configuration
+   */
+  show() {
+    const data = this.getAll();
+    const isProjectToken2 = this.isProjectToken();
+    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",
+      Project: data.project || (isProjectToken2 ? "(from token)" : "Not set"),
+      "User ID": data.userId || (isProjectToken2 ? "(N/A for project token)" : "Not set")
+    });
+  }
+};
+
+// src/utils/update-check.ts
+import chalk2 from "chalk";
+import { createRequire } from "module";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { existsSync } from "fs";
+function loadPackageJson() {
+  const require2 = createRequire(import.meta.url);
+  const __dirname = dirname(fileURLToPath(import.meta.url));
+  const paths = [
+    join(__dirname, "../../package.json"),
+    // From src/utils/
+    join(__dirname, "../package.json")
+    // From dist/
+  ];
+  for (const path of paths) {
+    if (existsSync(path)) {
+      return require2(path);
+    }
+  }
+  return { version: "0.0.0", name: "@turboops/cli" };
+}
+var pkg = loadPackageJson();
+async function checkForUpdates() {
+  try {
+    const response = await fetch(
+      `https://registry.npmjs.org/${pkg.name}/latest`,
+      {
+        signal: AbortSignal.timeout(3e3)
+        // 3 second timeout
+      }
+    );
+    if (!response.ok) {
+      return;
+    }
+    const data = await response.json();
+    const latestVersion = data.version;
+    const currentVersion = pkg.version;
+    if (isNewerVersion(latestVersion, currentVersion)) {
+      showUpdateNotice(currentVersion, latestVersion);
+    }
+  } catch {
+  }
+}
+function isNewerVersion(version1, version2) {
+  const v1Parts = version1.split(".").map(Number);
+  const v2Parts = version2.split(".").map(Number);
+  for (let i = 0; i < Math.max(v1Parts.length, v2Parts.length); i++) {
+    const v1 = v1Parts[i] || 0;
+    const v2 = v2Parts[i] || 0;
+    if (v1 > v2) return true;
+    if (v1 < v2) return false;
+  }
+  return false;
+}
+function showUpdateNotice(currentVersion, latestVersion) {
+  console.log();
+  console.log(chalk2.yellow("\u2500".repeat(50)));
+  console.log(
+    chalk2.yellow("  Update available: ") + chalk2.gray(currentVersion) + chalk2.yellow(" \u2192 ") + chalk2.green(latestVersion)
+  );
+  console.log(
+    chalk2.yellow("  Run ") + chalk2.cyan(`npm update -g ${pkg.name}`) + chalk2.yellow(" to update")
+  );
+  console.log(chalk2.yellow("\u2500".repeat(50)));
+}
+function getCurrentVersion() {
+  return pkg.version;
+}
+function getPackageName() {
+  return pkg.name;
+}
+
+// src/commands/login.ts
+import { Command } from "commander";
+import prompts from "prompts";
+
+// src/services/api.ts
+function isProjectToken(token) {
+  return token.startsWith("turbo_");
+}
+var cachedProjectInfo = null;
+var apiClient = {
+  /**
+   * Make an API request
+   */
+  async request(method, path, body) {
+    const apiUrl = configService.getApiUrl();
+    const token = configService.getToken();
+    if (!token) {
+      return {
+        error: "Not authenticated. Run `turbo login` or set TURBOOPS_TOKEN.",
+        status: 401
+      };
+    }
+    const url = `${apiUrl}${path}`;
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`
+    };
+    try {
+      const fetchOptions = {
+        method,
+        headers
+      };
+      if (method !== "GET" && body) {
+        fetchOptions.body = JSON.stringify(body);
+      }
+      const response = await fetch(url, fetchOptions);
+      const data = await response.json().catch(() => null);
+      if (!response.ok) {
+        const errorData = data;
+        return {
+          error: errorData?.message || `HTTP ${response.status}`,
+          status: response.status
+        };
+      }
+      return { data, status: response.status };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Network error";
+      return { error: message, status: 0 };
+    }
+  },
+  /**
+   * Check if using a project token
+   */
+  isUsingProjectToken() {
+    const token = configService.getToken();
+    return !!token && isProjectToken(token);
+  },
+  /**
+   * Validate project token and get project info
+   * Returns cached result if already validated
+   */
+  async validateProjectToken() {
+    const token = configService.getToken();
+    if (!token) {
+      return { error: "No token configured", status: 401 };
+    }
+    if (!isProjectToken(token)) {
+      return { error: "Not a project token", status: 400 };
+    }
+    if (cachedProjectInfo) {
+      return {
+        data: {
+          valid: true,
+          projectId: cachedProjectInfo.projectId,
+          projectSlug: cachedProjectInfo.projectSlug,
+          projectName: cachedProjectInfo.projectSlug
+        },
+        status: 200
+      };
+    }
+    const apiUrl = configService.getApiUrl();
+    try {
+      const response = await fetch(`${apiUrl}/deployment/tokens/validate`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ token })
+      });
+      const data = await response.json();
+      if (!data.valid) {
+        return { error: "Invalid or expired token", status: 401 };
+      }
+      cachedProjectInfo = {
+        projectId: data.projectId,
+        projectSlug: data.projectSlug
+      };
+      return {
+        data: {
+          valid: true,
+          projectId: data.projectId,
+          projectSlug: data.projectSlug,
+          projectName: data.projectName || data.projectSlug
+        },
+        status: 200
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Network error";
+      return { error: message, status: 0 };
+    }
+  },
+  /**
+   * Get project info (works with both user and project tokens)
+   */
+  async getProjectInfo() {
+    if (this.isUsingProjectToken()) {
+      const validation = await this.validateProjectToken();
+      if (validation.error) {
+        return { error: validation.error, status: validation.status };
+      }
+      return this.getProject(validation.data.projectSlug);
+    }
+    const projectSlug = configService.getProject();
+    if (!projectSlug) {
+      return {
+        error: "No project configured. Run `turbo project use <slug>` or use a project token.",
+        status: 400
+      };
+    }
+    return this.getProject(projectSlug);
+  },
+  /**
+   * Login and get token
+   */
+  async login(email, password) {
+    const apiUrl = configService.getApiUrl();
+    try {
+      const response = await fetch(`${apiUrl}/user/login`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ email, password })
+      });
+      const data = await response.json();
+      if (!response.ok) {
+        const errorData = data;
+        return {
+          error: errorData?.message || "Login failed",
+          status: response.status
+        };
+      }
+      return { data, status: response.status };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Network error";
+      return { error: message, status: 0 };
+    }
+  },
+  /**
+   * Get current user
+   */
+  async whoami() {
+    return this.request("GET", "/user/me");
+  },
+  /**
+   * Get project by slug
+   */
+  async getProject(slug) {
+    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
+   */
+  async deploy(environmentId, imageTag) {
+    return this.request("POST", `/deployment/deployments`, {
+      environmentId,
+      imageTag
+    });
+  },
+  /**
+   * Get deployment status
+   */
+  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/environments/${environmentId}/restart`
+    );
+  },
+  /**
+   * Stop containers
+   */
+  async stop(environmentId) {
+    return this.request(
+      "POST",
+      `/deployment/environments/${environmentId}/stop`
+    );
+  },
+  /**
+   * Wake containers
+   */
+  async wake(environmentId) {
+    return this.request(
+      "POST",
+      `/deployment/environments/${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/environments/${environmentId}/env-vars`
+    );
+  },
+  /**
+   * Set environment variable
+   */
+  async setEnvVar(environmentId, key, value, secret) {
+    return this.request(
+      "PUT",
+      `/deployment/environments/${environmentId}/env-vars`,
+      {
+        key,
+        value,
+        secret
+      }
+    );
+  },
+  /**
+   * Delete environment variable
+   */
+  async deleteEnvVar(environmentId, key) {
+    return this.request(
+      "DELETE",
+      `/deployment/environments/${environmentId}/env-vars/${key}`
+    );
+  },
+  /**
+   * Wait for deployment to complete
+   */
+  async waitForDeployment(deploymentId, options) {
+    const timeout = options?.timeout || 6e5;
+    const pollInterval = options?.pollInterval || 3e3;
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeout) {
+      const { data, error } = await this.getDeploymentStatus(deploymentId);
+      if (error) {
+        throw new Error(error);
+      }
+      if (!data) {
+        throw new Error("No deployment data received");
+      }
+      if (options?.onProgress) {
+        options.onProgress(data);
+      }
+      if (["running", "failed", "stopped", "rolled_back"].includes(data.status)) {
+        return data;
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+    throw new Error(`Deployment timeout after ${timeout / 1e3} seconds`);
+  }
+};
+
+// src/utils/spinner.ts
+import ora from "ora";
+function createSpinner(text) {
+  return ora({
+    text,
+    spinner: "dots"
+  });
+}
+async function withSpinner(text, fn, options) {
+  const spinner = createSpinner(text);
+  spinner.start();
+  try {
+    const result = await fn();
+    spinner.succeed(options?.successText || text);
+    return result;
+  } catch (error) {
+    spinner.fail(options?.failText || `Failed: ${text}`);
+    throw error;
+  }
+}
+
+// src/commands/login.ts
+var loginCommand = new Command("login").description("Authenticate with TurboOps API").option("-t, --token <token>", "Use API token directly").action(async (options) => {
+  logger.header("TurboOps Login");
+  if (options.token) {
+    configService.setToken(options.token);
+    const { data: data2, error: error2 } = await withSpinner(
+      "Verifying token...",
+      () => apiClient.whoami()
+    );
+    if (error2 || !data2) {
+      configService.clearToken();
+      logger.error(`Authentication failed: ${error2 || "Invalid token"}`);
+      process.exit(10 /* AUTH_ERROR */);
+    }
+    configService.setUserId(data2.id);
+    addJsonData({
+      authenticated: true,
+      user: { id: data2.id, email: data2.email }
+    });
+    logger.success(`Authenticated as ${data2.email}`);
+    return;
+  }
+  const response = await prompts([
+    {
+      type: "text",
+      name: "email",
+      message: "Email:",
+      validate: (value) => value.includes("@") || "Please enter a valid email"
+    },
+    {
+      type: "password",
+      name: "password",
+      message: "Password:"
+    }
+  ]);
+  if (!response.email || !response.password) {
+    logger.warning("Login cancelled");
+    addJsonData({ authenticated: false, cancelled: true });
+    return;
+  }
+  const { data, error } = await withSpinner(
+    "Logging in...",
+    () => apiClient.login(response.email, response.password)
+  );
+  if (error || !data) {
+    logger.error(`Login failed: ${error || "Unknown error"}`);
+    addJsonData({ authenticated: false, error: error || "Unknown error" });
+    process.exit(10 /* AUTH_ERROR */);
+  }
+  configService.setToken(data.token);
+  configService.setUserId(data.user.id);
+  addJsonData({
+    authenticated: true,
+    user: { id: data.user.id, email: data.user.email }
+  });
+  logger.success(`Logged in as ${data.user.email}`);
+  logger.newline();
+  logger.info("Your credentials have been saved.");
+  logger.info("Run `turbo whoami` to verify your authentication.");
+});
+var logoutCommand = new Command("logout").description("Remove stored authentication").action(() => {
+  configService.clearToken();
+  addJsonData({ loggedOut: true });
+  logger.success("Logged out successfully");
+});
+var whoamiCommand = new Command("whoami").description("Show current authenticated user").action(async () => {
+  if (!configService.isAuthenticated()) {
+    logger.error("Not authenticated. Run `turbo login` first.");
+    addJsonData({ authenticated: false });
+    process.exit(10 /* AUTH_ERROR */);
+  }
+  const { data, error } = await withSpinner(
+    "Fetching user info...",
+    () => apiClient.whoami()
+  );
+  if (error || !data) {
+    logger.error(`Failed to fetch user info: ${error || "Unknown error"}`);
+    addJsonData({ authenticated: false, error: error || "Unknown error" });
+    process.exit(13 /* API_ERROR */);
+  }
+  addJsonData({
+    authenticated: true,
+    user: {
+      id: data.id,
+      email: data.email,
+      name: data.name || null
+    }
+  });
+  logger.header("Current User");
+  logger.table({
+    ID: data.id,
+    Email: data.email,
+    Name: data.name || "-"
+  });
+});
+
+// src/commands/deploy.ts
+import { Command as Command2 } from "commander";
+
+// src/utils/guards.ts
+async function requireAuth() {
+  if (!configService.isAuthenticated()) {
+    logger.error("Not authenticated. Run `turbo login` or set TURBOOPS_TOKEN.");
+    process.exit(10 /* AUTH_ERROR */);
+  }
+  if (apiClient.isUsingProjectToken()) {
+    const { error } = await apiClient.validateProjectToken();
+    if (error) {
+      logger.error(`Invalid project token: ${error}`);
+      process.exit(10 /* AUTH_ERROR */);
+    }
+  }
+}
+async function requireProject() {
+  if (apiClient.isUsingProjectToken()) {
+    const { data, error } = await apiClient.validateProjectToken();
+    if (error || !data) {
+      logger.error(`Invalid project token: ${error || "Unknown error"}`);
+      process.exit(10 /* AUTH_ERROR */);
+    }
+    return data.projectSlug;
+  }
+  const projectSlug = configService.getProject();
+  if (!projectSlug) {
+    logger.error(
+      "No project configured. Run `turbo init` or use --project flag, or use a project token."
+    );
+    process.exit(11 /* CONFIG_ERROR */);
+  }
+  return projectSlug;
+}
+async function requireAuthAndProject() {
+  await requireAuth();
+  return requireProject();
+}
+async function fetchProject(projectSlug, showSpinner = true) {
+  const fetch2 = () => apiClient.getProject(projectSlug);
+  const { data, error } = showSpinner ? await withSpinner("Fetching project...", fetch2) : await fetch2();
+  if (error || !data) {
+    logger.error(`Failed to fetch project: ${error || "Not found"}`);
+    process.exit(12 /* NOT_FOUND */);
+  }
+  return data;
+}
+async function fetchEnvironment(projectId, environmentSlug, showSpinner = true) {
+  const fetch2 = () => apiClient.getEnvironmentBySlug(projectId, environmentSlug);
+  const { data, error } = showSpinner ? await withSpinner("Fetching environment...", fetch2) : await fetch2();
+  if (error || !data) {
+    logger.error(`Environment "${environmentSlug}" not found.`);
+    const { data: envs } = await apiClient.getEnvironments(projectId);
+    if (envs && envs.length > 0) {
+      logger.info("Available environments:");
+      logger.list(envs.map((e) => `${e.slug} (${e.name})`));
+    }
+    process.exit(12 /* NOT_FOUND */);
+  }
+  return data;
+}
+async function getCommandContext(showSpinner = true) {
+  const projectSlug = await requireAuthAndProject();
+  const project = await fetchProject(projectSlug, showSpinner);
+  return { projectSlug, project };
+}
+async function getCommandContextWithEnvironment(environmentSlug, showSpinner = true) {
+  const { projectSlug, project } = await getCommandContext(showSpinner);
+  const environment = await fetchEnvironment(
+    project.id,
+    environmentSlug,
+    showSpinner
+  );
+  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(
+  "[environment]",
+  "Environment slug (optional, shows all if not specified)"
+).action(async (environment) => {
+  const { project } = await getCommandContext();
+  logger.header(`Status: ${project.name}`);
+  const { data: environments, error: envError } = await apiClient.getEnvironments(project.id);
+  if (envError || !environments) {
+    logger.error(
+      `Failed to fetch environments: ${envError || "Unknown error"}`
+    );
+    process.exit(13 /* API_ERROR */);
+  }
+  const envsToShow = environment ? environments.filter((e) => e.slug === environment) : environments;
+  if (envsToShow.length === 0) {
+    if (environment) {
+      logger.error(`Environment "${environment}" not found.`);
+      logger.info("Available environments:");
+      logger.list(environments.map((e) => `${e.slug} (${e.name})`));
+      addJsonData({
+        error: `Environment "${environment}" not found`,
+        availableEnvironments: environments.map((e) => ({
+          slug: e.slug,
+          name: e.name
+        }))
+      });
+    } else {
+      logger.warning("No environments configured for this project.");
+      addJsonData({ environments: [] });
+    }
+    process.exit(12 /* NOT_FOUND */);
+  }
+  addJsonData({
+    project: { name: project.name, slug: project.slug },
+    environments: envsToShow.map((e) => ({
+      name: e.name,
+      slug: e.slug,
+      type: e.type,
+      status: e.status,
+      domain: e.domain
+    }))
+  });
+  for (const env of envsToShow) {
+    logger.newline();
+    console.log(chalk4.bold(env.name) + ` (${env.slug})`);
+    console.log(chalk4.gray("\u2500".repeat(40)));
+    const statusColor = getStatusColor(env.status);
+    logger.table({
+      Status: statusColor(env.status),
+      Type: env.type,
+      Domain: chalk4.cyan(env.domain)
+    });
+  }
+});
+var configCommand = new Command3("config").description("Show current configuration").action(() => {
+  const config2 = configService.getAll();
+  addJsonData({ config: config2 });
+  configService.show();
+});
+function getStatusColor(status) {
+  switch (status) {
+    case "healthy":
+    case "running":
+      return chalk4.green;
+    case "deploying":
+      return chalk4.yellow;
+    case "failed":
+    case "stopped":
+      return chalk4.red;
+    default:
+      return chalk4.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 prompts2 from "prompts";
+import chalk6 from "chalk";
+var initCommand = new Command5("init").description("Initialize TurboOps project in current directory").action(async () => {
+  logger.header("TurboOps Project Initialization");
+  if (!configService.isAuthenticated()) {
+    logger.warning("Not authenticated. Please log in first.");
+    logger.newline();
+    const { shouldLogin } = await prompts2({
+      type: "confirm",
+      name: "shouldLogin",
+      message: "Would you like to log in now?",
+      initial: true
+    });
+    if (!shouldLogin) {
+      logger.info("Run `turbo login` when ready.");
+      addJsonData({ initialized: false, reason: "not_authenticated" });
+      return;
+    }
+    const credentials = await prompts2([
+      {
+        type: "text",
+        name: "email",
+        message: "Email:",
+        validate: (value) => value.includes("@") || "Please enter a valid email"
+      },
+      {
+        type: "password",
+        name: "password",
+        message: "Password:"
+      }
+    ]);
+    if (!credentials.email || !credentials.password) {
+      logger.warning("Login cancelled");
+      addJsonData({ initialized: false, reason: "login_cancelled" });
+      return;
+    }
+    const { data, error } = await withSpinner(
+      "Logging in...",
+      () => apiClient.login(credentials.email, credentials.password)
+    );
+    if (error || !data) {
+      logger.error(`Login failed: ${error || "Unknown error"}`);
+      addJsonData({
+        initialized: false,
+        reason: "login_failed",
+        error: error || "Unknown error"
+      });
+      process.exit(10 /* AUTH_ERROR */);
+    }
+    configService.setToken(data.token);
+    configService.setUserId(data.user.id);
+    logger.success(`Logged in as ${data.user.email}`);
+  }
+  logger.newline();
+  const { projectSlug } = await prompts2({
+    type: "text",
+    name: "projectSlug",
+    message: "Project slug:",
+    hint: "The slug of your TurboOps project",
+    validate: (value) => value.length > 0 || "Project slug is required"
+  });
+  if (!projectSlug) {
+    logger.warning("Initialization cancelled");
+    addJsonData({ initialized: false, reason: "cancelled" });
+    return;
+  }
+  const { data: project, error: projectError } = await withSpinner(
+    "Verifying project...",
+    () => apiClient.getProject(projectSlug)
+  );
+  if (projectError || !project) {
+    logger.error(
+      `Project "${projectSlug}" not found or you don't have access.`
+    );
+    logger.info(
+      "Make sure the project exists in TurboOps and you have permission to access it."
+    );
+    addJsonData({
+      initialized: false,
+      reason: "project_not_found",
+      projectSlug
+    });
+    process.exit(12 /* NOT_FOUND */);
+  }
+  configService.setProject(projectSlug);
+  logger.newline();
+  logger.success("Project initialized!");
+  logger.newline();
+  logger.header("Project Details");
+  logger.table({
+    Name: project.name,
+    Slug: project.slug,
+    Repository: project.repositoryUrl || "-"
+  });
+  const { data: environments } = await apiClient.getEnvironments(project.id);
+  const envList = environments && environments.length > 0 ? environments.map((env) => ({
+    slug: env.slug,
+    name: env.name,
+    type: env.type
+  })) : [];
+  addJsonData({
+    initialized: true,
+    project: {
+      name: project.name,
+      slug: project.slug,
+      repositoryUrl: project.repositoryUrl || null
+    },
+    environments: envList
+  });
+  if (environments && environments.length > 0) {
+    logger.newline();
+    logger.header("Available Environments");
+    for (const env of environments) {
+      console.log(`  ${chalk6.bold(env.slug)} - ${env.name} (${env.type})`);
+    }
+  }
+  logger.newline();
+  logger.header("Next Steps");
+  logger.list([
+    "Run `turbo status` to see all environments",
+    "Run `turbo deploy <environment>` to deploy",
+    "Run `turbo logs <environment>` to view logs"
+  ]);
+});
+
+// src/commands/logs.ts
+import { Command as Command6 } from "commander";
+import chalk7 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) => {
+  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}`);
+    }
+  });
+  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 = chalk7.gray(`[${timestamp}]`) + levelColor(` ${levelStr}`);
+  if (log.step) {
+    output += chalk7.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 chalk7.red;
+    case "warn":
+    case "warning":
+      return chalk7.yellow;
+    case "info":
+      return chalk7.blue;
+    case "debug":
+      return chalk7.gray;
+    case "trace":
+      return chalk7.magenta;
+    default:
+      return chalk7.white;
+  }
+}
+
+// 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.hook("preAction", (thisCommand) => {
+  const opts = thisCommand.opts();
+  clearJsonData();
+  if (opts.json) {
+    setOutputMode("json");
+  } else if (opts.quiet) {
+    setOutputMode("quiet");
+  } else {
+    setOutputMode("normal");
+  }
+  if (opts.project) {
+    configService.setProject(opts.project);
+  }
+  if (opts.token) {
+    configService.setToken(opts.token);
+  }
+  if (opts.api) {
+    configService.setApiUrl(opts.api);
+  }
+  if (opts.verbose) {
+    process.env.DEBUG = "true";
+  }
+  shouldCheckUpdate = opts.updateCheck !== false;
+});
+program.hook("postAction", async () => {
+  printJsonOutput();
+  if (shouldCheckUpdate && !process.env.CI) {
+    checkForUpdates().catch(() => {
+    });
+  }
+});
+program.addCommand(loginCommand);
+program.addCommand(logoutCommand);
+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.command("self-update").description("Update TurboCLI to the latest version").action(async () => {
+  logger.info("Checking for updates...");
+  try {
+    const response = await fetch(
+      `https://registry.npmjs.org/${getPackageName()}/latest`
+    );
+    const data = await response.json();
+    const latestVersion = data.version;
+    if (latestVersion === VERSION) {
+      logger.success(`You are already on the latest version (${VERSION})`);
+    } else {
+      logger.info(`Current version: ${VERSION}`);
+      logger.info(`Latest version: ${latestVersion}`);
+      logger.newline();
+      logger.info("To update TurboCLI, run:");
+      console.log(chalk8.cyan(`  npm update -g ${getPackageName()}`));
+      console.log();
+      logger.info("Or if using npx:");
+      console.log(chalk8.cyan(`  npx ${getPackageName()}@latest`));
+    }
+  } catch {
+    logger.warning("Could not check for updates");
+    logger.info("To update TurboCLI, run:");
+    console.log(chalk8.cyan(`  npm update -g ${getPackageName()}`));
+  }
+});
+program.configureHelp({
+  subcommandTerm: (cmd) => cmd.name()
+});
+program.showHelpAfterError("(add --help for additional information)");
+program.parse();
+if (!process.argv.slice(2).length) {
+  console.log();
+  console.log(chalk8.bold.cyan("  TurboCLI") + chalk8.gray(` v${VERSION}`));
+  console.log(chalk8.gray("  Command line interface for TurboOps deployments"));
+  console.log();
+  program.outputHelp();
+}