@tarout/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,2325 @@
+#!/usr/bin/env node
+import {
+  failSpinner,
+  startSpinner,
+  succeedSpinner,
+  updateSpinner
+} from "./chunk-GSKD67K4.js";
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/lib/output.ts
+import chalk from "chalk";
+import Table from "cli-table3";
+
+// src/utils/json.ts
+function jsonSuccess(data, meta) {
+  return {
+    success: true,
+    data,
+    ...meta && { meta }
+  };
+}
+function jsonError(code, message, suggestions) {
+  return {
+    success: false,
+    error: {
+      code,
+      message,
+      ...suggestions && { suggestions }
+    }
+  };
+}
+function outputJson(response) {
+  console.log(JSON.stringify(response, null, 2));
+}
+
+// src/lib/output.ts
+var globalOptions = {
+  json: false,
+  quiet: false,
+  verbose: false,
+  noColor: false,
+  yes: false
+};
+function setGlobalOptions(options) {
+  globalOptions = { ...globalOptions, ...options };
+}
+function isJsonMode() {
+  return globalOptions.json;
+}
+function shouldSkipConfirmation() {
+  return globalOptions.yes;
+}
+function c(colorFn, str) {
+  return globalOptions.noColor ? str : colorFn(str);
+}
+var colors = {
+  success: (str) => c(chalk.green, str),
+  error: (str) => c(chalk.red, str),
+  warn: (str) => c(chalk.yellow, str),
+  info: (str) => c(chalk.blue, str),
+  dim: (str) => c(chalk.dim, str),
+  bold: (str) => c(chalk.bold, str),
+  cyan: (str) => c(chalk.cyan, str)
+};
+function getStatusBadge(status) {
+  const badges = {
+    running: colors.success("\u25CF running"),
+    idle: colors.warn("\u25CB idle"),
+    error: colors.error("\u2717 error"),
+    done: colors.success("\u2713 done"),
+    deploying: colors.info("\u25D0 deploying"),
+    stopped: colors.dim("\u25CB stopped"),
+    cancelled: colors.warn("\u25CB cancelled")
+  };
+  return badges[status.toLowerCase()] || status;
+}
+function log(message) {
+  if (!globalOptions.quiet && !globalOptions.json) {
+    console.log(message);
+  }
+}
+function success(message) {
+  if (!globalOptions.quiet && !globalOptions.json) {
+    console.log(colors.success(`\u2713 ${message}`));
+  }
+}
+function error(message, suggestions) {
+  if (globalOptions.json) {
+    outputJson(jsonError("ERROR", message, suggestions));
+    return;
+  }
+  console.error(colors.error(`Error: ${message}`));
+  if (suggestions && suggestions.length > 0) {
+    console.error("");
+    console.error("Did you mean one of these?");
+    for (const suggestion of suggestions) {
+      console.error(colors.dim(`  - ${suggestion}`));
+    }
+  }
+}
+function table(headers, rows) {
+  if (globalOptions.json) {
+    return;
+  }
+  const t = new Table({
+    head: headers.map((h) => colors.bold(h)),
+    style: { head: [], border: [] },
+    chars: {
+      top: "",
+      "top-mid": "",
+      "top-left": "",
+      "top-right": "",
+      bottom: "",
+      "bottom-mid": "",
+      "bottom-left": "",
+      "bottom-right": "",
+      left: "  ",
+      "left-mid": "",
+      mid: "",
+      "mid-mid": "",
+      right: "",
+      "right-mid": "",
+      middle: "  "
+    }
+  });
+  for (const row of rows) {
+    t.push(row);
+  }
+  console.log(t.toString());
+}
+function outputData(data) {
+  if (globalOptions.json) {
+    outputJson(jsonSuccess(data));
+  }
+}
+function quietOutput(message) {
+  if (globalOptions.quiet || globalOptions.json) {
+    console.log(message);
+  }
+}
+function box(title, content) {
+  if (globalOptions.json || globalOptions.quiet) {
+    return;
+  }
+  console.log("");
+  console.log(colors.bold(title));
+  for (const line of content) {
+    console.log(`  ${line}`);
+  }
+  console.log("");
+}
+
+// src/commands/auth.ts
+import open from "open";
+
+// src/lib/config.ts
+import Conf from "conf";
+var config = new Conf({
+  projectName: "tarout",
+  defaults: {
+    currentProfile: "default",
+    profiles: {}
+  }
+});
+function getConfig() {
+  return config.store;
+}
+function getCurrentProfile() {
+  const cfg = getConfig();
+  return cfg.profiles[cfg.currentProfile] || null;
+}
+function setProfile(name, profile) {
+  config.set(`profiles.${name}`, profile);
+}
+function setCurrentProfile(name) {
+  config.set("currentProfile", name);
+}
+function clearConfig() {
+  config.clear();
+}
+function isLoggedIn() {
+  const profile = getCurrentProfile();
+  return profile !== null && !!profile.token;
+}
+function getToken() {
+  const profile = getCurrentProfile();
+  return profile?.token || null;
+}
+function getApiUrl() {
+  const profile = getCurrentProfile();
+  return profile?.apiUrl || "https://app.tarout.sa";
+}
+function updateProfile(updates) {
+  const cfg = getConfig();
+  const currentProfileName = cfg.currentProfile;
+  const currentProfile = cfg.profiles[currentProfileName];
+  if (currentProfile) {
+    config.set(`profiles.${currentProfileName}`, {
+      ...currentProfile,
+      ...updates
+    });
+  }
+}
+
+// src/lib/auth-server.ts
+import express from "express";
+function startAuthServer() {
+  return new Promise((resolve) => {
+    const app = express();
+    let server;
+    let callbackResolver;
+    let callbackRejecter;
+    const callbackPromise = new Promise((res, rej) => {
+      callbackResolver = res;
+      callbackRejecter = rej;
+    });
+    app.get("/callback", (req, res) => {
+      const {
+        token,
+        userId,
+        userEmail,
+        userName,
+        organizationId,
+        organizationName,
+        environmentId,
+        environmentName,
+        error: error6
+      } = req.query;
+      if (error6) {
+        res.send(`
+          <!DOCTYPE html>
+          <html>
+            <head>
+              <title>Tarout CLI - Authentication Failed</title>
+              <style>
+                body { font-family: system-ui, sans-serif; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0; background: #f5f5f5; }
+                .container { text-align: center; padding: 40px; background: white; border-radius: 12px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); }
+                h1 { color: #dc2626; margin-bottom: 16px; }
+                p { color: #666; }
+              </style>
+            </head>
+            <body>
+              <div class="container">
+                <h1>Authentication Failed</h1>
+                <p>${error6}</p>
+                <p>You can close this window and try again.</p>
+              </div>
+            </body>
+          </html>
+        `);
+        callbackRejecter(new Error(String(error6)));
+        return;
+      }
+      if (!token || !userId || !userEmail || !organizationId || !organizationName || !environmentId || !environmentName) {
+        res.status(400).send("Missing required parameters");
+        callbackRejecter(new Error("Missing required parameters from auth callback"));
+        return;
+      }
+      res.send(`
+        <!DOCTYPE html>
+        <html>
+          <head>
+            <title>Tarout CLI - Authenticated</title>
+            <style>
+              body { font-family: system-ui, sans-serif; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0; background: #f5f5f5; }
+              .container { text-align: center; padding: 40px; background: white; border-radius: 12px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); }
+              h1 { color: #16a34a; margin-bottom: 16px; }
+              p { color: #666; }
+              .checkmark { font-size: 64px; margin-bottom: 16px; }
+            </style>
+          </head>
+          <body>
+            <div class="container">
+              <div class="checkmark">\u2713</div>
+              <h1>Authenticated!</h1>
+              <p>You can close this window and return to the terminal.</p>
+            </div>
+          </body>
+        </html>
+      `);
+      callbackResolver({
+        token: String(token),
+        userId: String(userId),
+        userEmail: String(userEmail),
+        userName: userName ? String(userName) : void 0,
+        organizationId: String(organizationId),
+        organizationName: String(organizationName),
+        environmentId: String(environmentId),
+        environmentName: String(environmentName)
+      });
+    });
+    server = app.listen(0, () => {
+      const address = server.address();
+      const port = typeof address === "object" && address ? address.port : 0;
+      resolve({
+        port,
+        waitForCallback: () => callbackPromise,
+        close: () => server.close()
+      });
+    });
+    setTimeout(() => {
+      callbackRejecter(new Error("Authentication timed out. Please try again."));
+      server.close();
+    }, 5 * 60 * 1e3);
+  });
+}
+
+// src/utils/exit-codes.ts
+var ExitCode = {
+  SUCCESS: 0,
+  GENERAL_ERROR: 1,
+  INVALID_ARGUMENTS: 2,
+  AUTH_ERROR: 3,
+  NOT_FOUND: 4,
+  PERMISSION_DENIED: 5
+};
+function exit(code) {
+  process.exit(code);
+}
+
+// src/lib/errors.ts
+var CliError = class extends Error {
+  constructor(message, code = ExitCode.GENERAL_ERROR, suggestions) {
+    super(message);
+    this.code = code;
+    this.suggestions = suggestions;
+    this.name = "CliError";
+  }
+};
+var AuthError = class extends CliError {
+  constructor(message = "Not logged in. Run 'tarout login' first.") {
+    super(message, ExitCode.AUTH_ERROR);
+  }
+};
+var NotFoundError = class extends CliError {
+  constructor(resource, id, suggestions) {
+    super(`${resource} "${id}" not found`, ExitCode.NOT_FOUND, suggestions);
+  }
+};
+var InvalidArgumentError = class extends CliError {
+  constructor(message) {
+    super(message, ExitCode.INVALID_ARGUMENTS);
+  }
+};
+function handleError(err) {
+  if (err instanceof CliError) {
+    if (isJsonMode()) {
+      outputJson(
+        jsonError(
+          getErrorCode(err.code),
+          err.message,
+          err.suggestions
+        )
+      );
+    } else {
+      error(err.message, err.suggestions);
+    }
+    exit(err.code);
+  }
+  if (err && typeof err === "object" && "code" in err) {
+    const trpcError = err;
+    const exitCode = mapTrpcErrorCode(trpcError.code);
+    if (isJsonMode()) {
+      outputJson(jsonError(trpcError.code, trpcError.message));
+    } else {
+      error(trpcError.message);
+    }
+    exit(exitCode);
+  }
+  const message = err instanceof Error ? err.message : String(err);
+  if (isJsonMode()) {
+    outputJson(jsonError("UNKNOWN_ERROR", message));
+  } else {
+    error(message);
+  }
+  exit(ExitCode.GENERAL_ERROR);
+}
+function getErrorCode(exitCode) {
+  const codes = {
+    [ExitCode.SUCCESS]: "SUCCESS",
+    [ExitCode.GENERAL_ERROR]: "ERROR",
+    [ExitCode.INVALID_ARGUMENTS]: "INVALID_ARGUMENTS",
+    [ExitCode.AUTH_ERROR]: "AUTH_ERROR",
+    [ExitCode.NOT_FOUND]: "NOT_FOUND",
+    [ExitCode.PERMISSION_DENIED]: "PERMISSION_DENIED"
+  };
+  return codes[exitCode] || "ERROR";
+}
+function mapTrpcErrorCode(code) {
+  const mapping = {
+    UNAUTHORIZED: ExitCode.AUTH_ERROR,
+    FORBIDDEN: ExitCode.PERMISSION_DENIED,
+    NOT_FOUND: ExitCode.NOT_FOUND,
+    BAD_REQUEST: ExitCode.INVALID_ARGUMENTS,
+    PARSE_ERROR: ExitCode.INVALID_ARGUMENTS
+  };
+  return mapping[code] || ExitCode.GENERAL_ERROR;
+}
+function findSimilar(target, candidates, maxResults = 3) {
+  const targetLower = target.toLowerCase();
+  return candidates.map((candidate) => ({
+    candidate,
+    score: similarity(targetLower, candidate.toLowerCase())
+  })).filter(({ score }) => score > 0.3).sort((a, b) => b.score - a.score).slice(0, maxResults).map(({ candidate }) => candidate);
+}
+function similarity(s1, s2) {
+  if (s1 === s2) return 1;
+  if (s1.length < 2 || s2.length < 2) return 0;
+  const bigrams1 = /* @__PURE__ */ new Set();
+  for (let i = 0; i < s1.length - 1; i++) {
+    bigrams1.add(s1.slice(i, i + 2));
+  }
+  let intersection = 0;
+  for (let i = 0; i < s2.length - 1; i++) {
+    if (bigrams1.has(s2.slice(i, i + 2))) {
+      intersection++;
+    }
+  }
+  return 2 * intersection / (s1.length - 1 + s2.length - 1);
+}
+
+// src/commands/auth.ts
+function registerAuthCommands(program2) {
+  program2.command("login").description("Authenticate with Tarout via browser").option("--api-url <url>", "Custom API URL", "https://app.tarout.sa").action(async (options) => {
+    try {
+      if (isLoggedIn()) {
+        const profile = getCurrentProfile();
+        if (profile) {
+          log(`Already logged in as ${colors.cyan(profile.userEmail)}`);
+          log(`Organization: ${profile.organizationName}`);
+          log("");
+          log(`Run ${colors.dim("tarout logout")} to sign out first.`);
+          return;
+        }
+      }
+      const apiUrl = options.apiUrl;
+      log("");
+      log("Opening browser to authenticate...");
+      const authServer = await startAuthServer();
+      const callbackUrl = `http://localhost:${authServer.port}/callback`;
+      const authUrl = `${apiUrl}/cli-auth?callback=${encodeURIComponent(callbackUrl)}`;
+      await open(authUrl);
+      const spinner = startSpinner("Waiting for authentication...");
+      try {
+        const authData = await authServer.waitForCallback();
+        succeedSpinner("Authentication successful!");
+        authServer.close();
+        setProfile("default", {
+          token: authData.token,
+          apiUrl,
+          userId: authData.userId,
+          userEmail: authData.userEmail,
+          userName: authData.userName,
+          organizationId: authData.organizationId,
+          organizationName: authData.organizationName,
+          environmentId: authData.environmentId,
+          environmentName: authData.environmentName
+        });
+        setCurrentProfile("default");
+        if (isJsonMode()) {
+          outputData({
+            success: true,
+            user: {
+              id: authData.userId,
+              email: authData.userEmail,
+              name: authData.userName
+            },
+            organization: {
+              id: authData.organizationId,
+              name: authData.organizationName
+            },
+            environment: {
+              id: authData.environmentId,
+              name: authData.environmentName
+            }
+          });
+        } else {
+          log("");
+          success(`Logged in as ${colors.cyan(authData.userEmail)}`);
+          box("Account", [
+            `Organization: ${colors.bold(authData.organizationName)}`,
+            `Environment: ${colors.bold(authData.environmentName)}`
+          ]);
+        }
+      } catch (err) {
+        failSpinner("Authentication failed");
+        authServer.close();
+        throw err;
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  program2.command("logout").description("Sign out and clear stored credentials").action(async () => {
+    try {
+      if (!isLoggedIn()) {
+        if (isJsonMode()) {
+          outputData({ success: true, message: "Already logged out" });
+        } else {
+          log("Already logged out.");
+        }
+        return;
+      }
+      const profile = getCurrentProfile();
+      clearConfig();
+      if (isJsonMode()) {
+        outputData({ success: true, message: "Logged out successfully" });
+      } else {
+        success(`Logged out from ${profile?.userEmail || "Tarout"}`);
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  program2.command("whoami").description("Show current authenticated user").action(async () => {
+    try {
+      if (!isLoggedIn()) {
+        throw new AuthError();
+      }
+      const profile = getCurrentProfile();
+      if (!profile) {
+        throw new AuthError();
+      }
+      if (isJsonMode()) {
+        outputData({
+          user: {
+            id: profile.userId,
+            email: profile.userEmail,
+            name: profile.userName
+          },
+          organization: {
+            id: profile.organizationId,
+            name: profile.organizationName
+          },
+          environment: {
+            id: profile.environmentId,
+            name: profile.environmentName
+          },
+          apiUrl: profile.apiUrl
+        });
+      } else {
+        log("");
+        log(`${colors.bold("User")}`);
+        log(`  Email: ${colors.cyan(profile.userEmail)}`);
+        if (profile.userName) {
+          log(`  Name: ${profile.userName}`);
+        }
+        log("");
+        log(`${colors.bold("Organization")}`);
+        log(`  Name: ${profile.organizationName}`);
+        log(`  ID: ${colors.dim(profile.organizationId)}`);
+        log("");
+        log(`${colors.bold("Environment")}`);
+        log(`  Name: ${profile.environmentName}`);
+        log(`  ID: ${colors.dim(profile.environmentId)}`);
+        log("");
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+
+// src/commands/apps.ts
+import open2 from "open";
+
+// src/lib/api.ts
+import { createTRPCProxyClient, httpBatchLink } from "@trpc/client";
+import superjson from "superjson";
+var client = null;
+function createApiClient() {
+  if (!isLoggedIn()) {
+    throw new AuthError();
+  }
+  const token = getToken();
+  const apiUrl = getApiUrl();
+  return createTRPCProxyClient({
+    transformer: superjson,
+    links: [
+      httpBatchLink({
+        url: `${apiUrl}/api/trpc`,
+        headers: () => ({
+          "x-api-key": token
+        })
+      })
+    ]
+  });
+}
+function getApiClient() {
+  if (!client) {
+    client = createApiClient();
+  }
+  return client;
+}
+
+// src/utils/prompts.ts
+import inquirer from "inquirer";
+async function confirm(message, defaultValue = false) {
+  const { confirmed } = await inquirer.prompt([
+    {
+      type: "confirm",
+      name: "confirmed",
+      message,
+      default: defaultValue
+    }
+  ]);
+  return confirmed;
+}
+async function input(message, defaultValue) {
+  const { value } = await inquirer.prompt([
+    {
+      type: "input",
+      name: "value",
+      message,
+      default: defaultValue
+    }
+  ]);
+  return value;
+}
+async function select(message, choices) {
+  const { value } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "value",
+      message,
+      choices
+    }
+  ]);
+  return value;
+}
+
+// src/commands/apps.ts
+function registerAppsCommands(program2) {
+  const apps = program2.command("apps").description("Manage applications");
+  apps.command("list").alias("ls").description("List all applications").action(async () => {
+    try {
+      if (!isLoggedIn()) throw new AuthError();
+      const client2 = getApiClient();
+      const spinner = startSpinner("Fetching applications...");
+      const applications = await client2.application.allByOrganization.query();
+      succeedSpinner();
+      if (isJsonMode()) {
+        outputData(applications);
+        return;
+      }
+      if (applications.length === 0) {
+        log("");
+        log("No applications found.");
+        log("");
+        log(`Create one with: ${colors.dim("tarout apps create <name>")}`);
+        return;
+      }
+      log("");
+      table(
+        ["ID", "NAME", "STATUS", "DOMAIN", "CREATED"],
+        applications.map((app) => [
+          colors.cyan(app.applicationId.slice(0, 8)),
+          app.name,
+          getStatusBadge(app.applicationStatus),
+          app.domain || colors.dim("-"),
+          formatDate(app.createdAt)
+        ])
+      );
+      log("");
+      log(colors.dim(`${applications.length} application${applications.length === 1 ? "" : "s"}`));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  apps.command("create").argument("[name]", "Application name").description("Create a new application").option("-d, --description <description>", "Application description").action(async (name, options) => {
+    try {
+      if (!isLoggedIn()) throw new AuthError();
+      const profile = getCurrentProfile();
+      if (!profile) throw new AuthError();
+      let appName = name;
+      let description = options.description;
+      if (!appName) {
+        appName = await input("Application name:");
+      }
+      if (!description && !shouldSkipConfirmation()) {
+        description = await input("Description (optional):");
+      }
+      const slug = generateSlug(appName);
+      const client2 = getApiClient();
+      const spinner = startSpinner("Creating application...");
+      const application = await client2.application.create.mutate({
+        name: appName,
+        appName: slug,
+        description: description || void 0,
+        organizationId: profile.organizationId
+      });
+      succeedSpinner("Application created!");
+      if (isJsonMode()) {
+        outputData(application);
+        return;
+      }
+      quietOutput(application.applicationId);
+      box("Application Created", [
+        `ID: ${colors.cyan(application.applicationId)}`,
+        `Name: ${application.name}`,
+        `Slug: ${application.appName}`
+      ]);
+      log("Next steps:");
+      log(`  1. Connect a source: ${colors.dim(`tarout apps info ${application.applicationId.slice(0, 8)}`)}`);
+      log(`  2. Deploy: ${colors.dim(`tarout deploy ${application.applicationId.slice(0, 8)}`)}`);
+      log("");
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  apps.command("delete").alias("rm").argument("<app>", "Application ID or name").description("Delete an application").action(async (appIdentifier) => {
+    try {
+      if (!isLoggedIn()) throw new AuthError();
+      const client2 = getApiClient();
+      const spinner = startSpinner("Finding application...");
+      const apps2 = await client2.application.allByOrganization.query();
+      const app = findApp(apps2, appIdentifier);
+      if (!app) {
+        failSpinner();
+        const suggestions = findSimilar(
+          appIdentifier,
+          apps2.map((a) => a.name)
+        );
+        throw new NotFoundError("Application", appIdentifier, suggestions);
+      }
+      succeedSpinner();
+      if (!shouldSkipConfirmation()) {
+        log("");
+        log(`Application: ${colors.bold(app.name)}`);
+        log(`ID: ${colors.dim(app.applicationId)}`);
+        log("");
+        const confirmed = await confirm(
+          `Are you sure you want to delete "${app.name}"? This cannot be undone.`,
+          false
+        );
+        if (!confirmed) {
+          log("Cancelled.");
+          return;
+        }
+      }
+      const deleteSpinner = startSpinner("Deleting application...");
+      await client2.application.delete.mutate({
+        applicationId: app.applicationId
+      });
+      succeedSpinner("Application deleted!");
+      if (isJsonMode()) {
+        outputData({ deleted: true, applicationId: app.applicationId });
+      } else {
+        quietOutput(app.applicationId);
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  apps.command("info").argument("<app>", "Application ID or name").description("Show application details").action(async (appIdentifier) => {
+    try {
+      if (!isLoggedIn()) throw new AuthError();
+      const client2 = getApiClient();
+      const spinner = startSpinner("Fetching application...");
+      const apps2 = await client2.application.allByOrganization.query();
+      const appSummary = findApp(apps2, appIdentifier);
+      if (!appSummary) {
+        failSpinner();
+        const suggestions = findSimilar(
+          appIdentifier,
+          apps2.map((a) => a.name)
+        );
+        throw new NotFoundError("Application", appIdentifier, suggestions);
+      }
+      const app = await client2.application.one.query({
+        applicationId: appSummary.applicationId
+      });
+      succeedSpinner();
+      if (isJsonMode()) {
+        outputData(app);
+        return;
+      }
+      log("");
+      log(colors.bold(app.name));
+      log(colors.dim(app.applicationId));
+      log("");
+      log(`${colors.bold("Status")}`);
+      log(`  ${getStatusBadge(app.applicationStatus)}`);
+      log("");
+      log(`${colors.bold("Source")}`);
+      if (app.sourceType) {
+        log(`  Type: ${app.sourceType}`);
+        if (app.github) {
+          log(`  Repository: ${app.github.repository}`);
+          log(`  Branch: ${app.github.branch}`);
+        } else if (app.gitlab) {
+          log(`  Repository: ${app.gitlab.gitlabRepository}`);
+          log(`  Branch: ${app.gitlab.gitlabBranch}`);
+        } else if (app.bitbucket) {
+          log(`  Repository: ${app.bitbucket.bitbucketRepository}`);
+          log(`  Branch: ${app.bitbucket.bitbucketBranch}`);
+        }
+      } else {
+        log(`  ${colors.dim("Not configured")}`);
+      }
+      log("");
+      log(`${colors.bold("Build")}`);
+      log(`  Type: ${app.buildType || colors.dim("Not configured")}`);
+      if (app.dockerfile) {
+        log(`  Dockerfile: ${app.dockerfile}`);
+      }
+      log("");
+      log(`${colors.bold("Domain")}`);
+      if (app.domain && app.domain.length > 0) {
+        for (const domain of app.domain) {
+          log(`  ${domain.host}`);
+        }
+      } else {
+        log(`  ${colors.dim("No custom domain")}`);
+      }
+      log("");
+      if (app.cloudServiceUrl) {
+        log(`${colors.bold("Cloud")}`);
+        log(`  URL: ${app.cloudServiceUrl}`);
+        if (app.cloudRegion) {
+          log(`  Region: ${app.cloudRegion}`);
+        }
+        log("");
+      }
+      log(`${colors.bold("Created")}`);
+      log(`  ${new Date(app.createdAt).toLocaleString()}`);
+      log("");
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  apps.command("open").argument("<app>", "Application ID or name").description("Open application URL in browser").action(async (appIdentifier) => {
+    try {
+      if (!isLoggedIn()) throw new AuthError();
+      const client2 = getApiClient();
+      const spinner = startSpinner("Finding application...");
+      const apps2 = await client2.application.allByOrganization.query();
+      const appSummary = findApp(apps2, appIdentifier);
+      if (!appSummary) {
+        failSpinner();
+        const suggestions = findSimilar(
+          appIdentifier,
+          apps2.map((a) => a.name)
+        );
+        throw new NotFoundError("Application", appIdentifier, suggestions);
+      }
+      const app = await client2.application.one.query({
+        applicationId: appSummary.applicationId
+      });
+      succeedSpinner();
+      let url = null;
+      if (app.domain && app.domain.length > 0) {
+        url = `https://${app.domain[0].host}`;
+      } else if (app.cloudServiceUrl) {
+        url = app.cloudServiceUrl;
+      }
+      if (!url) {
+        error("No URL found for this application. Deploy first or add a domain.");
+        return;
+      }
+      if (isJsonMode()) {
+        outputData({ url });
+        return;
+      }
+      log(`Opening ${colors.cyan(url)}...`);
+      await open2(url);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+function findApp(apps, identifier) {
+  const lowerIdentifier = identifier.toLowerCase();
+  return apps.find(
+    (app) => app.applicationId === identifier || app.applicationId.startsWith(identifier) || app.name.toLowerCase() === lowerIdentifier || app.appName?.toLowerCase() === lowerIdentifier
+  );
+}
+function generateSlug(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 63);
+}
+function formatDate(date) {
+  const d = new Date(date);
+  const now = /* @__PURE__ */ new Date();
+  const diffDays = Math.floor(
+    (now.getTime() - d.getTime()) / (1e3 * 60 * 60 * 24)
+  );
+  if (diffDays === 0) {
+    return "Today";
+  } else if (diffDays === 1) {
+    return "Yesterday";
+  } else if (diffDays < 7) {
+    return `${diffDays}d ago`;
+  } else {
+    return d.toLocaleDateString("en-US", { month: "short", day: "numeric" });
+  }
+}
+
+// src/commands/deploy.ts
+function registerDeployCommands(program2) {
+  program2.command("deploy").argument("<app>", "Application ID or name").description("Deploy an application").option("-r, --region <region>", "Deployment region", "me-central1").option("-w, --wait", "Wait for deployment to complete").action(async (appIdentifier, options) => {
+    try {
+      if (!isLoggedIn()) throw new AuthError();
+      const client2 = getApiClient();
+      const spinner = startSpinner("Finding application...");
+      const apps = await client2.application.allByOrganization.query();
+      const app = findApp2(apps, appIdentifier);
+      if (!app) {
+        failSpinner();
+        const suggestions = findSimilar(
+          appIdentifier,
+          apps.map((a) => a.name)
+        );
+        throw new NotFoundError("Application", appIdentifier, suggestions);
+      }
+      updateSpinner(`Deploying ${app.name}...`);
+      const result = await client2.application.deployToCloud.mutate({
+        applicationId: app.applicationId,
+        region: options.region
+      });
+      if (options.wait) {
+        let attempts = 0;
+        const maxAttempts = 120;
+        while (attempts < maxAttempts) {
+          await sleep(5e3);
+          attempts++;
+          const fullApp = await client2.application.one.query({
+            applicationId: app.applicationId
+          });
+          updateSpinner(
+            `Deploying ${app.name}... (${attempts * 5}s)`
+          );
+          if (fullApp.applicationStatus === "done" || fullApp.applicationStatus === "running") {
+            succeedSpinner("Deployment successful!");
+            if (isJsonMode()) {
+              outputData({
+                deploymentId: result.deploymentId,
+                status: fullApp.applicationStatus,
+                url: fullApp.cloudServiceUrl
+              });
+            } else {
+              quietOutput(fullApp.cloudServiceUrl || result.deploymentId);
+              log("");
+              log(`URL: ${colors.cyan(fullApp.cloudServiceUrl || "Pending...")}`);
+              log("");
+            }
+            return;
+          }
+          if (fullApp.applicationStatus === "error") {
+            failSpinner("Deployment failed");
+            throw new CliError("Deployment failed. Check logs for details.", ExitCode.GENERAL_ERROR);
+          }
+        }
+        failSpinner("Deployment timed out");
+        throw new CliError("Deployment timed out after 10 minutes", ExitCode.GENERAL_ERROR);
+      } else {
+        succeedSpinner("Deployment started!");
+        if (isJsonMode()) {
+          outputData({
+            deploymentId: result.deploymentId,
+            status: "deploying"
+          });
+        } else {
+          quietOutput(result.deploymentId);
+          log("");
+          log(`Deployment ID: ${colors.cyan(result.deploymentId)}`);
+          log("");
+          log("Deployment is running in the background.");
+          log(`Check status: ${colors.dim(`tarout deploy:status ${app.applicationId.slice(0, 8)}`)}`);
+          log(`View logs: ${colors.dim(`tarout logs ${app.applicationId.slice(0, 8)}`)}`);
+          log("");
+        }
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  program2.command("deploy:status").argument("<app>", "Application ID or name").description("Check deployment status").action(async (appIdentifier) => {
+    try {
+      if (!isLoggedIn()) throw new AuthError();
+      const client2 = getApiClient();
+      const spinner = startSpinner("Fetching status...");
+      const apps = await client2.application.allByOrganization.query();
+      const appSummary = findApp2(apps, appIdentifier);
+      if (!appSummary) {
+        failSpinner();
+        const suggestions = findSimilar(
+          appIdentifier,
+          apps.map((a) => a.name)
+        );
+        throw new NotFoundError("Application", appIdentifier, suggestions);
+      }
+      const app = await client2.application.one.query({
+        applicationId: appSummary.applicationId
+      });
+      const cloudStatus = await client2.application.getCloudDeploymentStatus.query({
+        applicationId: appSummary.applicationId
+      });
+      succeedSpinner();
+      if (isJsonMode()) {
+        outputData({
+          applicationId: app.applicationId,
+          name: app.name,
+          status: app.applicationStatus,
+          url: app.cloudServiceUrl,
+          cloudStatus
+        });
+        return;
+      }
+      log("");
+      log(`${colors.bold(app.name)}`);
+      log("");
+      log(`Status: ${getStatusBadge(app.applicationStatus)}`);
+      if (app.cloudServiceUrl) {
+        log(`URL: ${colors.cyan(app.cloudServiceUrl)}`);
+      }
+      if (cloudStatus) {
+        log(`Provider: ${cloudStatus.provider}`);
+        log(`Region: ${cloudStatus.region}`);
+        log(`Updated: ${new Date(cloudStatus.updatedAt).toLocaleString()}`);
+      }
+      log("");
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  program2.command("deploy:cancel").argument("<app>", "Application ID or name").description("Cancel a running deployment").action(async (appIdentifier) => {
+    try {
+      if (!isLoggedIn()) throw new AuthError();
+      const client2 = getApiClient();
+      const spinner = startSpinner("Cancelling deployment...");
+      const apps = await client2.application.allByOrganization.query();
+      const app = findApp2(apps, appIdentifier);
+      if (!app) {
+        failSpinner();
+        const suggestions = findSimilar(
+          appIdentifier,
+          apps.map((a) => a.name)
+        );
+        throw new NotFoundError("Application", appIdentifier, suggestions);
+      }
+      await client2.application.cancelDeployment.mutate({
+        applicationId: app.applicationId
+      });
+      succeedSpinner("Deployment cancelled");
+      if (isJsonMode()) {
+        outputData({ cancelled: true, applicationId: app.applicationId });
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  program2.command("deploy:list").argument("<app>", "Application ID or name").description("List recent deployments").option("-n, --limit <number>", "Number of deployments to show", "10").action(async (appIdentifier, options) => {
+    try {
+      if (!isLoggedIn()) throw new AuthError();
+      const client2 = getApiClient();
+      const spinner = startSpinner("Fetching deployments...");
+      const apps = await client2.application.allByOrganization.query();
+      const appSummary = findApp2(apps, appIdentifier);
+      if (!appSummary) {
+        failSpinner();
+        const suggestions = findSimilar(
+          appIdentifier,
+          apps.map((a) => a.name)
+        );
+        throw new NotFoundError("Application", appIdentifier, suggestions);
+      }
+      const deployments = await client2.deployment.all.query({
+        applicationId: appSummary.applicationId
+      });
+      succeedSpinner();
+      const limitedDeployments = deployments.slice(0, parseInt(options.limit, 10));
+      if (isJsonMode()) {
+        outputData(limitedDeployments);
+        return;
+      }
+      if (limitedDeployments.length === 0) {
+        log("");
+        log("No deployments found.");
+        log("");
+        log(`Deploy with: ${colors.dim(`tarout deploy ${appSummary.applicationId.slice(0, 8)}`)}`);
+        return;
+      }
+      log("");
+      table(
+        ["ID", "STATUS", "TITLE", "CREATED"],
+        limitedDeployments.map((d) => [
+          colors.cyan(d.deploymentId.slice(0, 8)),
+          getStatusBadge(d.status),
+          d.title || colors.dim("-"),
+          formatDate2(d.createdAt)
+        ])
+      );
+      log("");
+      log(colors.dim(`${limitedDeployments.length} deployment${limitedDeployments.length === 1 ? "" : "s"}`));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+function registerLogsCommand(program2) {
+  program2.command("logs").argument("<app>", "Application ID or name").description("View application logs").option("-l, --level <level>", "Log level (ALL, ERROR, WARN, INFO, DEBUG)", "ALL").option("-f, --follow", "Stream logs continuously").option("-n, --limit <number>", "Number of logs to show", "100").option("--since <duration>", "Show logs since (e.g., 1h, 30m, 2d)").action(async (appIdentifier, options) => {
+    try {
+      if (!isLoggedIn()) throw new AuthError();
+      const client2 = getApiClient();
+      const spinner = startSpinner("Fetching logs...");
+      const apps = await client2.application.allByOrganization.query();
+      const app = findApp2(apps, appIdentifier);
+      if (!app) {
+        failSpinner();
+        const suggestions = findSimilar(
+          appIdentifier,
+          apps.map((a) => a.name)
+        );
+        throw new NotFoundError("Application", appIdentifier, suggestions);
+      }
+      let timeRange;
+      if (options.since) {
+        const since = parseDuration(options.since);
+        if (since) {
+          timeRange = {
+            start: new Date(Date.now() - since).toISOString(),
+            end: null
+          };
+        }
+      }
+      const logs = await client2.logs.getCloudRunLogs.query({
+        applicationId: app.applicationId,
+        level: options.level.toUpperCase(),
+        limit: parseInt(options.limit, 10),
+        timeRange
+      });
+      succeedSpinner();
+      if (isJsonMode()) {
+        outputData(logs);
+        return;
+      }
+      if (!logs.entries || logs.entries.length === 0) {
+        log("");
+        log("No logs found.");
+        return;
+      }
+      log("");
+      for (const entry of logs.entries) {
+        printLogEntry(entry);
+      }
+      if (options.follow) {
+        log("");
+        log(colors.dim("Streaming logs... (Ctrl+C to stop)"));
+        log("");
+        let lastTimestamp = logs.entries.length > 0 ? new Date(logs.entries[logs.entries.length - 1].timestamp).getTime() : Date.now();
+        while (true) {
+          await sleep(2e3);
+          const newLogs = await client2.logs.getCloudRunLogs.query({
+            applicationId: app.applicationId,
+            level: options.level.toUpperCase(),
+            limit: 50,
+            timeRange: {
+              start: new Date(lastTimestamp + 1).toISOString(),
+              end: null
+            }
+          });
+          if (newLogs.entries && newLogs.entries.length > 0) {
+            for (const entry of newLogs.entries) {
+              const entryTime = new Date(entry.timestamp).getTime();
+              if (entryTime > lastTimestamp) {
+                printLogEntry(entry);
+                lastTimestamp = entryTime;
+              }
+            }
+          }
+        }
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+function findApp2(apps, identifier) {
+  const lowerIdentifier = identifier.toLowerCase();
+  return apps.find(
+    (app) => app.applicationId === identifier || app.applicationId.startsWith(identifier) || app.name.toLowerCase() === lowerIdentifier || app.appName?.toLowerCase() === lowerIdentifier
+  );
+}
+function formatDate2(date) {
+  const d = new Date(date);
+  return d.toLocaleString("en-US", {
+    month: "short",
+    day: "numeric",
+    hour: "2-digit",
+    minute: "2-digit"
+  });
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function parseDuration(duration) {
+  const match = duration.match(/^(\d+)(s|m|h|d)$/);
+  if (!match) return null;
+  const value = parseInt(match[1], 10);
+  const unit = match[2];
+  const multipliers = {
+    s: 1e3,
+    m: 60 * 1e3,
+    h: 60 * 60 * 1e3,
+    d: 24 * 60 * 60 * 1e3
+  };
+  return value * (multipliers[unit] || 0);
+}
+function printLogEntry(entry) {
+  const time = new Date(entry.timestamp);
+  const timeStr = time.toLocaleTimeString("en-US", {
+    hour12: false,
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit"
+  });
+  const levelColors = {
+    ERROR: colors.error,
+    WARN: colors.warn,
+    INFO: colors.info,
+    DEBUG: colors.dim,
+    DEFAULT: colors.dim
+  };
+  const colorFn = levelColors[entry.severity] || levelColors.DEFAULT;
+  const level = entry.severity.padEnd(5);
+  console.log(`${colors.dim(timeStr)}  ${colorFn(level)}  ${entry.message}`);
+}
+
+// src/commands/env.ts
+import { readFileSync, writeFileSync, existsSync } from "fs";
+function registerEnvCommands(program2) {
+  const env = program2.command("env").argument("<app>", "Application ID or name").description("Manage environment variables");
+  env.command("list").alias("ls").description("List all environment variables").option("--reveal", "Show actual values (not masked)").action(async (options, command) => {
+    try {
+      if (!isLoggedIn()) throw new AuthError();
+      const appIdentifier = command.parent.args[0];
+      const client2 = getApiClient();
+      const spinner = startSpinner("Fetching environment variables...");
+      const apps = await client2.application.allByOrganization.query();
+      const app = findApp3(apps, appIdentifier);
+      if (!app) {
+        failSpinner();
+        const suggestions = findSimilar(
+          appIdentifier,
+          apps.map((a) => a.name)
+        );
+        throw new NotFoundError("Application", appIdentifier, suggestions);
+      }
+      const variables = await client2.envVariable.list.query({
+        applicationId: app.applicationId,
+        includeValues: options.reveal || false
+      });
+      succeedSpinner();
+      if (isJsonMode()) {
+        outputData(variables);
+        return;
+      }
+      if (variables.length === 0) {
+        log("");
+        log("No environment variables found.");
+        log("");
+        log(`Set one with: ${colors.dim(`tarout env ${app.name} set KEY=value`)}`);
+        return;
+      }
+      log("");
+      table(
+        ["KEY", "VALUE", "SECRET", "UPDATED"],
+        variables.map((v) => [
+          colors.cyan(v.key),
+          options.reveal ? v.value || colors.dim("-") : maskValue(v.value),
+          v.isSecret ? colors.warn("Yes") : "No",
+          formatDate3(v.updatedAt)
+        ])
+      );
+      log("");
+      log(colors.dim(`${variables.length} variable${variables.length === 1 ? "" : "s"}`));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  env.command("set").argument("<key=value>", "Variable to set (KEY=value format)").description("Set an environment variable").option("-s, --secret", "Mark as secret (default)", true).option("--no-secret", "Mark as non-secret").action(async (keyValue, options, command) => {
+    try {
+      if (!isLoggedIn()) throw new AuthError();
+      const appIdentifier = command.parent.parent.args[0];
+      const eqIndex = keyValue.indexOf("=");
+      if (eqIndex === -1) {
+        throw new InvalidArgumentError(
+          "Invalid format. Use KEY=value (e.g., API_KEY=secret123)"
+        );
+      }
+      const key = keyValue.slice(0, eqIndex);
+      const value = keyValue.slice(eqIndex + 1);
+      if (!key) {
+        throw new InvalidArgumentError("Key cannot be empty");
+      }
+      const client2 = getApiClient();
+      const spinner = startSpinner("Setting environment variable...");
+      const apps = await client2.application.allByOrganization.query();
+      const app = findApp3(apps, appIdentifier);
+      if (!app) {
+        failSpinner();
+        const suggestions = findSimilar(
+          appIdentifier,
+          apps.map((a) => a.name)
+        );
+        throw new NotFoundError("Application", appIdentifier, suggestions);
+      }
+      const existing = await client2.envVariable.list.query({
+        applicationId: app.applicationId,
+        includeValues: false
+      });
+      const existingVar = existing.find((v) => v.key === key);
+      if (existingVar) {
+        await client2.envVariable.update.mutate({
+          applicationId: app.applicationId,
+          key,
+          value,
+          isSecret: options.secret
+        });
+      } else {
+        await client2.envVariable.create.mutate({
+          applicationId: app.applicationId,
+          key,
+          value,
+          isSecret: options.secret
+        });
+      }
+      succeedSpinner(`Set ${key}`);
+      if (isJsonMode()) {
+        outputData({ key, updated: !!existingVar });
+      } else {
+        quietOutput(key);
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  env.command("unset").argument("<key>", "Variable key to remove").description("Remove an environment variable").action(async (key, options, command) => {
+    try {
+      if (!isLoggedIn()) throw new AuthError();
+      const appIdentifier = command.parent.parent.args[0];
+      const client2 = getApiClient();
+      const spinner = startSpinner("Removing environment variable...");
+      const apps = await client2.application.allByOrganization.query();
+      const app = findApp3(apps, appIdentifier);
+      if (!app) {
+        failSpinner();
+        const suggestions = findSimilar(
+          appIdentifier,
+          apps.map((a) => a.name)
+        );
+        throw new NotFoundError("Application", appIdentifier, suggestions);
+      }
+      await client2.envVariable.delete.mutate({
+        applicationId: app.applicationId,
+        key
+      });
+      succeedSpinner(`Removed ${key}`);
+      if (isJsonMode()) {
+        outputData({ key, deleted: true });
+      } else {
+        quietOutput(key);
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  env.command("pull").description("Download environment variables as .env file").option("-o, --output <file>", "Output file path", ".env").option("--reveal", "Include actual secret values").action(async (options, command) => {
+    try {
+      if (!isLoggedIn()) throw new AuthError();
+      const appIdentifier = command.parent.parent.args[0];
+      const client2 = getApiClient();
+      const spinner = startSpinner("Downloading environment variables...");
+      const apps = await client2.application.allByOrganization.query();
+      const app = findApp3(apps, appIdentifier);
+      if (!app) {
+        failSpinner();
+        const suggestions = findSimilar(
+          appIdentifier,
+          apps.map((a) => a.name)
+        );
+        throw new NotFoundError("Application", appIdentifier, suggestions);
+      }
+      if (existsSync(options.output) && !shouldSkipConfirmation()) {
+        succeedSpinner();
+        const confirmed = await confirm(
+          `File ${options.output} already exists. Overwrite?`,
+          false
+        );
+        if (!confirmed) {
+          log("Cancelled.");
+          return;
+        }
+      }
+      const result = await client2.envVariable.export.query({
+        applicationId: app.applicationId,
+        format: "dotenv",
+        maskSecrets: !options.reveal
+      });
+      writeFileSync(options.output, result.content);
+      succeedSpinner(`Saved to ${options.output}`);
+      if (isJsonMode()) {
+        outputData({ file: options.output, content: result.content });
+      } else {
+        quietOutput(options.output);
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  env.command("push").description("Upload environment variables from .env file").option("-i, --input <file>", "Input file path", ".env").option("--replace", "Replace all existing variables (default: merge)").action(async (options, command) => {
+    try {
+      if (!isLoggedIn()) throw new AuthError();
+      const appIdentifier = command.parent.parent.args[0];
+      if (!existsSync(options.input)) {
+        throw new InvalidArgumentError(`File not found: ${options.input}`);
+      }
+      const content = readFileSync(options.input, "utf-8");
+      const client2 = getApiClient();
+      const spinner = startSpinner("Uploading environment variables...");
+      const apps = await client2.application.allByOrganization.query();
+      const app = findApp3(apps, appIdentifier);
+      if (!app) {
+        failSpinner();
+        const suggestions = findSimilar(
+          appIdentifier,
+          apps.map((a) => a.name)
+        );
+        throw new NotFoundError("Application", appIdentifier, suggestions);
+      }
+      const result = await client2.envVariable.import.mutate({
+        applicationId: app.applicationId,
+        content,
+        format: "dotenv",
+        merge: !options.replace
+      });
+      succeedSpinner(`Imported ${result.imported} variables`);
+      if (isJsonMode()) {
+        outputData(result);
+      } else {
+        quietOutput(String(result.imported));
+        if (result.skipped > 0) {
+          log(colors.dim(`Skipped ${result.skipped} (already exist)`));
+        }
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+function findApp3(apps, identifier) {
+  const lowerIdentifier = identifier.toLowerCase();
+  return apps.find(
+    (app) => app.applicationId === identifier || app.applicationId.startsWith(identifier) || app.name.toLowerCase() === lowerIdentifier || app.appName?.toLowerCase() === lowerIdentifier
+  );
+}
+function maskValue(value) {
+  if (!value) return colors.dim("-");
+  if (value.length <= 4) return "****";
+  return value.slice(0, 2) + "****" + value.slice(-2);
+}
+function formatDate3(date) {
+  const d = new Date(date);
+  return d.toLocaleDateString("en-US", { month: "short", day: "numeric" });
+}
+
+// src/commands/db.ts
+import { spawn } from "child_process";
+function registerDbCommands(program2) {
+  const db = program2.command("db").description("Manage databases");
+  db.command("list").alias("ls").description("List all databases").option("-t, --type <type>", "Filter by type (postgres, mysql, redis)").action(async (options) => {
+    try {
+      if (!isLoggedIn()) throw new AuthError();
+      const client2 = getApiClient();
+      const spinner = startSpinner("Fetching databases...");
+      const [postgres, mysql, redis] = await Promise.all([
+        client2.postgres.allByOrganization.query(),
+        client2.mysql.allByOrganization.query(),
+        client2.redis.allByOrganization.query()
+      ]);
+      succeedSpinner();
+      let databases = [];
+      if (!options.type || options.type === "postgres") {
+        databases = databases.concat(
+          postgres.map((db2) => ({
+            id: db2.postgresId,
+            name: db2.name,
+            type: "postgres",
+            status: db2.applicationStatus,
+            created: db2.createdAt
+          }))
+        );
+      }
+      if (!options.type || options.type === "mysql") {
+        databases = databases.concat(
+          mysql.map((db2) => ({
+            id: db2.mysqlId,
+            name: db2.name,
+            type: "mysql",
+            status: db2.applicationStatus,
+            created: db2.createdAt
+          }))
+        );
+      }
+      if (!options.type || options.type === "redis") {
+        databases = databases.concat(
+          redis.map((db2) => ({
+            id: db2.redisId,
+            name: db2.name,
+            type: "redis",
+            status: db2.applicationStatus,
+            created: db2.createdAt
+          }))
+        );
+      }
+      if (isJsonMode()) {
+        outputData(databases);
+        return;
+      }
+      if (databases.length === 0) {
+        log("");
+        log("No databases found.");
+        log("");
+        log(`Create one with: ${colors.dim("tarout db create <name>")}`);
+        return;
+      }
+      log("");
+      table(
+        ["ID", "NAME", "TYPE", "STATUS", "CREATED"],
+        databases.map((db2) => [
+          colors.cyan(db2.id.slice(0, 8)),
+          db2.name,
+          getTypeLabel(db2.type),
+          getStatusBadge(db2.status),
+          formatDate4(db2.created)
+        ])
+      );
+      log("");
+      log(
+        colors.dim(`${databases.length} database${databases.length === 1 ? "" : "s"}`)
+      );
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  db.command("create").argument("[name]", "Database name").description("Create a new database").option("-t, --type <type>", "Database type (postgres, mysql, redis)", "postgres").option("-d, --description <description>", "Database description").action(async (name, options) => {
+    try {
+      if (!isLoggedIn()) throw new AuthError();
+      const profile = getCurrentProfile();
+      if (!profile) throw new AuthError();
+      let dbName = name;
+      let dbType = options.type;
+      if (!dbName) {
+        dbName = await input("Database name:");
+      }
+      if (!options.type && !shouldSkipConfirmation()) {
+        dbType = await select("Database type:", [
+          { name: "PostgreSQL", value: "postgres" },
+          { name: "MySQL", value: "mysql" },
+          { name: "Redis", value: "redis" }
+        ]);
+      }
+      const slug = generateSlug2(dbName);
+      const client2 = getApiClient();
+      const spinner = startSpinner(`Creating ${dbType} database...`);
+      let database;
+      switch (dbType) {
+        case "postgres":
+          database = await client2.postgres.create.mutate({
+            name: dbName,
+            appName: slug,
+            dockerImage: "postgres:17",
+            organizationId: profile.organizationId,
+            description: options.description
+          });
+          break;
+        case "mysql":
+          database = await client2.mysql.create.mutate({
+            name: dbName,
+            appName: slug,
+            dockerImage: "mysql:8",
+            organizationId: profile.organizationId,
+            description: options.description
+          });
+          break;
+        case "redis":
+          database = await client2.redis.create.mutate({
+            name: dbName,
+            appName: slug,
+            dockerImage: "redis:7",
+            organizationId: profile.organizationId,
+            description: options.description
+          });
+          break;
+        default:
+          throw new CliError(`Unsupported database type: ${dbType}`, ExitCode.INVALID_ARGUMENTS);
+      }
+      succeedSpinner("Database created!");
+      const dbId = database.postgresId || database.mysqlId || database.redisId;
+      if (isJsonMode()) {
+        outputData(database);
+        return;
+      }
+      quietOutput(dbId);
+      box("Database Created", [
+        `ID: ${colors.cyan(dbId)}`,
+        `Name: ${database.name}`,
+        `Type: ${getTypeLabel(dbType)}`
+      ]);
+      log("Next steps:");
+      log(`  View connection info: ${colors.dim(`tarout db info ${dbId.slice(0, 8)}`)}`);
+      log("");
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  db.command("delete").alias("rm").argument("<db>", "Database ID or name").description("Delete a database").action(async (dbIdentifier) => {
+    try {
+      if (!isLoggedIn()) throw new AuthError();
+      const client2 = getApiClient();
+      const spinner = startSpinner("Finding database...");
+      const allDbs = await getAllDatabases(client2);
+      const dbInfo = findDatabase(allDbs, dbIdentifier);
+      if (!dbInfo) {
+        failSpinner();
+        const suggestions = findSimilar(
+          dbIdentifier,
+          allDbs.map((d) => d.name)
+        );
+        throw new NotFoundError("Database", dbIdentifier, suggestions);
+      }
+      succeedSpinner();
+      if (!shouldSkipConfirmation()) {
+        log("");
+        log(`Database: ${colors.bold(dbInfo.name)}`);
+        log(`Type: ${getTypeLabel(dbInfo.type)}`);
+        log(`ID: ${colors.dim(dbInfo.id)}`);
+        log("");
+        const confirmed = await confirm(
+          `Are you sure you want to delete "${dbInfo.name}"? This cannot be undone.`,
+          false
+        );
+        if (!confirmed) {
+          log("Cancelled.");
+          return;
+        }
+      }
+      const deleteSpinner = startSpinner("Deleting database...");
+      switch (dbInfo.type) {
+        case "postgres":
+          await client2.postgres.remove.mutate({ postgresId: dbInfo.id });
+          break;
+        case "mysql":
+          await client2.mysql.remove.mutate({ mysqlId: dbInfo.id });
+          break;
+        case "redis":
+          await client2.redis.remove.mutate({ redisId: dbInfo.id });
+          break;
+      }
+      succeedSpinner("Database deleted!");
+      if (isJsonMode()) {
+        outputData({ deleted: true, id: dbInfo.id });
+      } else {
+        quietOutput(dbInfo.id);
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  db.command("info").argument("<db>", "Database ID or name").description("Show database details and connection info").action(async (dbIdentifier) => {
+    try {
+      if (!isLoggedIn()) throw new AuthError();
+      const client2 = getApiClient();
+      const spinner = startSpinner("Fetching database info...");
+      const allDbs = await getAllDatabases(client2);
+      const dbSummary = findDatabase(allDbs, dbIdentifier);
+      if (!dbSummary) {
+        failSpinner();
+        const suggestions = findSimilar(
+          dbIdentifier,
+          allDbs.map((d) => d.name)
+        );
+        throw new NotFoundError("Database", dbIdentifier, suggestions);
+      }
+      let dbDetails;
+      switch (dbSummary.type) {
+        case "postgres":
+          dbDetails = await client2.postgres.one.query({ postgresId: dbSummary.id });
+          break;
+        case "mysql":
+          dbDetails = await client2.mysql.one.query({ mysqlId: dbSummary.id });
+          break;
+        case "redis":
+          dbDetails = await client2.redis.one.query({ redisId: dbSummary.id });
+          break;
+      }
+      succeedSpinner();
+      if (isJsonMode()) {
+        outputData(dbDetails);
+        return;
+      }
+      log("");
+      log(colors.bold(dbDetails.name));
+      log(colors.dim(dbSummary.id));
+      log("");
+      log(`${colors.bold("Status")}`);
+      log(`  ${getStatusBadge(dbDetails.applicationStatus)}`);
+      log(`  Type: ${getTypeLabel(dbSummary.type)}`);
+      log("");
+      log(`${colors.bold("Connection")}`);
+      if (dbSummary.type === "redis") {
+        if (dbDetails.cloudHost) {
+          log(`  Host: ${colors.cyan(dbDetails.cloudHost)}`);
+          log(`  Port: ${dbDetails.cloudPort || 6379}`);
+          if (dbDetails.cloudPassword) {
+            log(`  Password: ${colors.dim("********")}`);
+          }
+        } else {
+          log(`  ${colors.dim("Not yet deployed")}`);
+        }
+      } else {
+        if (dbDetails.cloudInstanceId || dbDetails.databaseName) {
+          log(`  Host: ${colors.cyan(dbDetails.cloudHost || "localhost")}`);
+          log(`  Port: ${dbDetails.cloudPort || (dbSummary.type === "postgres" ? 5432 : 3306)}`);
+          log(`  Database: ${dbDetails.cloudDatabaseName || dbDetails.databaseName}`);
+          log(`  Username: ${dbDetails.cloudUsername || dbDetails.databaseUser}`);
+          log(`  Password: ${colors.dim("********")}`);
+        } else {
+          log(`  ${colors.dim("Not yet deployed")}`);
+        }
+      }
+      log("");
+      if (dbDetails.cloudHost || dbDetails.databaseName) {
+        log(`${colors.bold("Connection String")}`);
+        const connStr = getConnectionString(dbSummary.type, dbDetails);
+        log(`  ${colors.cyan(connStr)}`);
+        log("");
+      }
+      log(`${colors.bold("Created")}`);
+      log(`  ${new Date(dbDetails.createdAt).toLocaleString()}`);
+      log("");
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  db.command("connect").argument("<db>", "Database ID or name").description("Open interactive database shell").action(async (dbIdentifier) => {
+    try {
+      if (!isLoggedIn()) throw new AuthError();
+      const client2 = getApiClient();
+      const spinner = startSpinner("Connecting to database...");
+      const allDbs = await getAllDatabases(client2);
+      const dbSummary = findDatabase(allDbs, dbIdentifier);
+      if (!dbSummary) {
+        failSpinner();
+        const suggestions = findSimilar(
+          dbIdentifier,
+          allDbs.map((d) => d.name)
+        );
+        throw new NotFoundError("Database", dbIdentifier, suggestions);
+      }
+      let dbDetails;
+      switch (dbSummary.type) {
+        case "postgres":
+          dbDetails = await client2.postgres.one.query({ postgresId: dbSummary.id });
+          break;
+        case "mysql":
+          dbDetails = await client2.mysql.one.query({ mysqlId: dbSummary.id });
+          break;
+        case "redis":
+          dbDetails = await client2.redis.one.query({ redisId: dbSummary.id });
+          break;
+      }
+      succeedSpinner();
+      if (!dbDetails.cloudHost && !dbDetails.databaseName) {
+        throw new CliError("Database not deployed yet. Deploy first.", ExitCode.GENERAL_ERROR);
+      }
+      const { command, args, env } = getConnectCommand(dbSummary.type, dbDetails);
+      log("");
+      log(`Connecting to ${colors.bold(dbDetails.name)}...`);
+      log(colors.dim("Press Ctrl+D to exit"));
+      log("");
+      const child = spawn(command, args, {
+        stdio: "inherit",
+        env: { ...process.env, ...env }
+      });
+      child.on("exit", (code) => {
+        process.exit(code || 0);
+      });
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+async function getAllDatabases(client2) {
+  const [postgres, mysql, redis] = await Promise.all([
+    client2.postgres.allByOrganization.query(),
+    client2.mysql.allByOrganization.query(),
+    client2.redis.allByOrganization.query()
+  ]);
+  const databases = [];
+  for (const db of postgres) {
+    databases.push({
+      id: db.postgresId,
+      name: db.name,
+      type: "postgres",
+      status: db.applicationStatus
+    });
+  }
+  for (const db of mysql) {
+    databases.push({
+      id: db.mysqlId,
+      name: db.name,
+      type: "mysql",
+      status: db.applicationStatus
+    });
+  }
+  for (const db of redis) {
+    databases.push({
+      id: db.redisId,
+      name: db.name,
+      type: "redis",
+      status: db.applicationStatus
+    });
+  }
+  return databases;
+}
+function findDatabase(databases, identifier) {
+  const lowerIdentifier = identifier.toLowerCase();
+  return databases.find(
+    (db) => db.id === identifier || db.id.startsWith(identifier) || db.name.toLowerCase() === lowerIdentifier
+  );
+}
+function generateSlug2(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 63);
+}
+function formatDate4(date) {
+  const d = new Date(date);
+  return d.toLocaleDateString("en-US", { month: "short", day: "numeric" });
+}
+function getTypeLabel(type) {
+  const labels = {
+    postgres: colors.info("PostgreSQL"),
+    mysql: colors.warn("MySQL"),
+    redis: colors.error("Redis")
+  };
+  return labels[type] || type;
+}
+function getConnectionString(type, details) {
+  const host = details.cloudHost || "localhost";
+  const user = details.cloudUsername || details.databaseUser || "user";
+  const dbName = details.cloudDatabaseName || details.databaseName || "db";
+  switch (type) {
+    case "postgres":
+      const pgPort = details.cloudPort || 5432;
+      return `postgresql://${user}:****@${host}:${pgPort}/${dbName}`;
+    case "mysql":
+      const myPort = details.cloudPort || 3306;
+      return `mysql://${user}:****@${host}:${myPort}/${dbName}`;
+    case "redis":
+      const redisPort = details.cloudPort || 6379;
+      return `redis://:****@${host}:${redisPort}`;
+    default:
+      return "";
+  }
+}
+function getConnectCommand(type, details) {
+  const host = details.cloudHost || "localhost";
+  const user = details.cloudUsername || details.databaseUser || "user";
+  const password = details.cloudPassword || details.databasePassword || "";
+  const dbName = details.cloudDatabaseName || details.databaseName || "db";
+  switch (type) {
+    case "postgres":
+      return {
+        command: "psql",
+        args: [
+          "-h",
+          host,
+          "-p",
+          String(details.cloudPort || 5432),
+          "-U",
+          user,
+          "-d",
+          dbName
+        ],
+        env: { PGPASSWORD: password }
+      };
+    case "mysql":
+      return {
+        command: "mysql",
+        args: [
+          "-h",
+          host,
+          "-P",
+          String(details.cloudPort || 3306),
+          "-u",
+          user,
+          `-p${password}`,
+          dbName
+        ],
+        env: {}
+      };
+    case "redis":
+      return {
+        command: "redis-cli",
+        args: [
+          "-h",
+          host,
+          "-p",
+          String(details.cloudPort || 6379),
+          ...password ? ["-a", password] : []
+        ],
+        env: {}
+      };
+    default:
+      throw new CliError(`Unsupported database type: ${type}`, ExitCode.INVALID_ARGUMENTS);
+  }
+}
+
+// src/commands/domains.ts
+function registerDomainsCommands(program2) {
+  const domains = program2.command("domains").description("Manage custom domains");
+  domains.command("list").alias("ls").argument("[app]", "Application ID or name (optional)").description("List domains").action(async (appIdentifier) => {
+    try {
+      if (!isLoggedIn()) throw new AuthError();
+      const client2 = getApiClient();
+      const spinner = startSpinner("Fetching domains...");
+      let domainsList;
+      if (appIdentifier) {
+        const apps = await client2.application.allByOrganization.query();
+        const app = findApp4(apps, appIdentifier);
+        if (!app) {
+          failSpinner();
+          const suggestions = findSimilar(
+            appIdentifier,
+            apps.map((a) => a.name)
+          );
+          throw new NotFoundError("Application", appIdentifier, suggestions);
+        }
+        domainsList = await client2.domain.byApplicationId.query({
+          applicationId: app.applicationId
+        });
+      } else {
+        domainsList = await client2.domain.all.query({
+          includeUnlinked: true
+        });
+      }
+      succeedSpinner();
+      if (isJsonMode()) {
+        outputData(domainsList);
+        return;
+      }
+      if (domainsList.length === 0) {
+        log("");
+        log("No domains found.");
+        log("");
+        log(`Add one with: ${colors.dim("tarout domains add <app> <domain>")}`);
+        return;
+      }
+      log("");
+      table(
+        ["DOMAIN", "APPLICATION", "VERIFIED", "SSL"],
+        domainsList.map((d) => [
+          colors.cyan(d.host),
+          d.application?.name || colors.dim("unlinked"),
+          d.isVerified ? colors.success("Yes") : colors.warn("No"),
+          d.certificateType || colors.dim("-")
+        ])
+      );
+      log("");
+      log(colors.dim(`${domainsList.length} domain${domainsList.length === 1 ? "" : "s"}`));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  domains.command("add").argument("<app>", "Application ID or name").argument("<domain>", "Domain name (e.g., app.example.com)").description("Add a custom domain to an application").action(async (appIdentifier, domainName) => {
+    try {
+      if (!isLoggedIn()) throw new AuthError();
+      if (!isValidDomain(domainName)) {
+        throw new InvalidArgumentError(
+          `Invalid domain format: ${domainName}. Use format like: app.example.com`
+        );
+      }
+      const client2 = getApiClient();
+      const spinner = startSpinner("Finding application...");
+      const apps = await client2.application.allByOrganization.query();
+      const app = findApp4(apps, appIdentifier);
+      if (!app) {
+        failSpinner();
+        const suggestions = findSimilar(
+          appIdentifier,
+          apps.map((a) => a.name)
+        );
+        throw new NotFoundError("Application", appIdentifier, suggestions);
+      }
+      updateSpinner2("Adding domain...");
+      const domain = await client2.domain.create.mutate({
+        host: domainName,
+        applicationId: app.applicationId
+      });
+      succeedSpinner("Domain added!");
+      if (isJsonMode()) {
+        outputData(domain);
+        return;
+      }
+      quietOutput(domain.domainId);
+      box("Domain Added", [
+        `Domain: ${colors.cyan(domainName)}`,
+        `Application: ${app.name}`,
+        `Status: ${domain.isVerified ? colors.success("Verified") : colors.warn("Pending verification")}`
+      ]);
+      if (!domain.isVerified) {
+        log("Next steps:");
+        log(`  1. Add DNS record pointing to your app`);
+        log(`  2. Verify: ${colors.dim(`tarout domains verify ${domain.domainId.slice(0, 8)}`)}`);
+        log("");
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  domains.command("remove").alias("rm").argument("<domain>", "Domain ID or hostname").description("Remove a domain").action(async (domainIdentifier) => {
+    try {
+      if (!isLoggedIn()) throw new AuthError();
+      const client2 = getApiClient();
+      const spinner = startSpinner("Finding domain...");
+      const allDomains = await client2.domain.all.query({ includeUnlinked: true });
+      const domain = findDomain(allDomains, domainIdentifier);
+      if (!domain) {
+        failSpinner();
+        const suggestions = findSimilar(
+          domainIdentifier,
+          allDomains.map((d) => d.host)
+        );
+        throw new NotFoundError("Domain", domainIdentifier, suggestions);
+      }
+      succeedSpinner();
+      if (!shouldSkipConfirmation()) {
+        log("");
+        log(`Domain: ${colors.bold(domain.host)}`);
+        if (domain.application) {
+          log(`Application: ${domain.application.name}`);
+        }
+        log("");
+        const confirmed = await confirm(
+          `Are you sure you want to remove "${domain.host}"?`,
+          false
+        );
+        if (!confirmed) {
+          log("Cancelled.");
+          return;
+        }
+      }
+      const deleteSpinner = startSpinner("Removing domain...");
+      await client2.domain.delete.mutate({
+        domainId: domain.domainId
+      });
+      succeedSpinner("Domain removed!");
+      if (isJsonMode()) {
+        outputData({ deleted: true, domainId: domain.domainId });
+      } else {
+        quietOutput(domain.domainId);
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  domains.command("verify").argument("<domain>", "Domain ID or hostname").description("Verify domain DNS configuration").action(async (domainIdentifier) => {
+    try {
+      if (!isLoggedIn()) throw new AuthError();
+      const client2 = getApiClient();
+      const spinner = startSpinner("Finding domain...");
+      const allDomains = await client2.domain.all.query({ includeUnlinked: true });
+      const domain = findDomain(allDomains, domainIdentifier);
+      if (!domain) {
+        failSpinner();
+        const suggestions = findSimilar(
+          domainIdentifier,
+          allDomains.map((d) => d.host)
+        );
+        throw new NotFoundError("Domain", domainIdentifier, suggestions);
+      }
+      updateSpinner2("Verifying DNS configuration...");
+      const result = await client2.domain.validateDomain.mutate({
+        domainId: domain.domainId
+      });
+      succeedSpinner();
+      if (isJsonMode()) {
+        outputData(result);
+        return;
+      }
+      log("");
+      if (result.isValid) {
+        success(`Domain ${colors.cyan(domain.host)} is verified!`);
+        log("");
+        log("DNS records are correctly configured.");
+      } else {
+        error(`Domain ${domain.host} verification failed`);
+        log("");
+        log("Please ensure DNS is configured correctly:");
+        log("");
+        log(`  ${colors.bold("Option 1: CNAME Record")}`);
+        log(`    Name: ${domain.host}`);
+        log(`    Value: ${colors.cyan("your-app.tarout.app")}`);
+        log("");
+        log(`  ${colors.bold("Option 2: A Record")}`);
+        log(`    Name: ${domain.host}`);
+        log(`    Value: ${colors.cyan("(your app's IP address)")}`);
+        log("");
+        log(colors.dim("DNS changes can take up to 48 hours to propagate."));
+      }
+      log("");
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+function findApp4(apps, identifier) {
+  const lowerIdentifier = identifier.toLowerCase();
+  return apps.find(
+    (app) => app.applicationId === identifier || app.applicationId.startsWith(identifier) || app.name.toLowerCase() === lowerIdentifier || app.appName?.toLowerCase() === lowerIdentifier
+  );
+}
+function findDomain(domains, identifier) {
+  const lowerIdentifier = identifier.toLowerCase();
+  return domains.find(
+    (d) => d.domainId === identifier || d.domainId.startsWith(identifier) || d.host.toLowerCase() === lowerIdentifier
+  );
+}
+function isValidDomain(domain) {
+  const pattern = /^([a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
+  return pattern.test(domain);
+}
+function updateSpinner2(text) {
+  import("./spinner-2NALE2OE.js").then(({ startSpinner: startSpinner2 }) => {
+    startSpinner2(text);
+  });
+}
+
+// src/commands/orgs.ts
+function registerOrgsCommands(program2) {
+  const orgs = program2.command("orgs").description("Manage organizations");
+  orgs.command("list").alias("ls").description("List your organizations").action(async () => {
+    try {
+      if (!isLoggedIn()) throw new AuthError();
+      const client2 = getApiClient();
+      const profile = getCurrentProfile();
+      const spinner = startSpinner("Fetching organizations...");
+      const organizations = await client2.organization.all.query();
+      succeedSpinner();
+      if (isJsonMode()) {
+        outputData(organizations);
+        return;
+      }
+      if (organizations.length === 0) {
+        log("");
+        log("No organizations found.");
+        return;
+      }
+      log("");
+      table(
+        ["ID", "NAME", "ACTIVE"],
+        organizations.map((org) => [
+          colors.cyan(org.id.slice(0, 8)),
+          org.name,
+          org.id === profile?.organizationId ? colors.success("*") : ""
+        ])
+      );
+      log("");
+      log(colors.dim(`${organizations.length} organization${organizations.length === 1 ? "" : "s"}`));
+      log("");
+      log(`Current: ${colors.bold(profile?.organizationName || "None")}`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  orgs.command("switch").argument("<org>", "Organization ID or name").description("Switch to a different organization").action(async (orgIdentifier) => {
+    try {
+      if (!isLoggedIn()) throw new AuthError();
+      const client2 = getApiClient();
+      const spinner = startSpinner("Switching organization...");
+      const organizations = await client2.organization.all.query();
+      const org = findOrg(organizations, orgIdentifier);
+      if (!org) {
+        failSpinner();
+        const suggestions = findSimilar(
+          orgIdentifier,
+          organizations.map((o) => o.name)
+        );
+        throw new NotFoundError("Organization", orgIdentifier, suggestions);
+      }
+      const envs = await client2.environment.all.query();
+      const defaultEnv = envs.find((e) => e.organizationId === org.id) || envs[0];
+      updateProfile({
+        organizationId: org.id,
+        organizationName: org.name,
+        environmentId: defaultEnv?.environmentId,
+        environmentName: defaultEnv?.name || "production"
+      });
+      succeedSpinner(`Switched to ${org.name}`);
+      if (isJsonMode()) {
+        outputData({
+          organizationId: org.id,
+          organizationName: org.name,
+          environmentId: defaultEnv?.environmentId,
+          environmentName: defaultEnv?.name
+        });
+      } else {
+        quietOutput(org.id);
+        log("");
+        log(`Organization: ${colors.bold(org.name)}`);
+        log(`Environment: ${colors.bold(defaultEnv?.name || "production")}`);
+        log("");
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+function registerEnvsCommands(program2) {
+  const envs = program2.command("envs").description("Manage environments (production/staging)");
+  envs.command("list").alias("ls").description("List environments").action(async () => {
+    try {
+      if (!isLoggedIn()) throw new AuthError();
+      const client2 = getApiClient();
+      const profile = getCurrentProfile();
+      const spinner = startSpinner("Fetching environments...");
+      const environments = await client2.environment.all.query();
+      succeedSpinner();
+      if (isJsonMode()) {
+        outputData(environments);
+        return;
+      }
+      if (environments.length === 0) {
+        log("");
+        log("No environments found.");
+        return;
+      }
+      log("");
+      table(
+        ["ID", "NAME", "ACTIVE"],
+        environments.map((env) => [
+          colors.cyan(env.environmentId.slice(0, 8)),
+          env.name,
+          env.environmentId === profile?.environmentId ? colors.success("*") : ""
+        ])
+      );
+      log("");
+      log(`Current: ${colors.bold(profile?.environmentName || "None")}`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  envs.command("switch").argument("<env>", "Environment ID or name").description("Switch to a different environment").action(async (envIdentifier) => {
+    try {
+      if (!isLoggedIn()) throw new AuthError();
+      const client2 = getApiClient();
+      const spinner = startSpinner("Switching environment...");
+      const environments = await client2.environment.all.query();
+      const env = findEnv(environments, envIdentifier);
+      if (!env) {
+        failSpinner();
+        const suggestions = findSimilar(
+          envIdentifier,
+          environments.map((e) => e.name)
+        );
+        throw new NotFoundError("Environment", envIdentifier, suggestions);
+      }
+      updateProfile({
+        environmentId: env.environmentId,
+        environmentName: env.name
+      });
+      succeedSpinner(`Switched to ${env.name}`);
+      if (isJsonMode()) {
+        outputData({
+          environmentId: env.environmentId,
+          environmentName: env.name
+        });
+      } else {
+        quietOutput(env.environmentId);
+        log("");
+        log(`Environment: ${colors.bold(env.name)}`);
+        log("");
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+function findOrg(orgs, identifier) {
+  const lowerIdentifier = identifier.toLowerCase();
+  return orgs.find(
+    (org) => org.id === identifier || org.id.startsWith(identifier) || org.name.toLowerCase() === lowerIdentifier
+  );
+}
+function findEnv(envs, identifier) {
+  const lowerIdentifier = identifier.toLowerCase();
+  return envs.find(
+    (env) => env.environmentId === identifier || env.environmentId.startsWith(identifier) || env.name.toLowerCase() === lowerIdentifier
+  );
+}
+
+// src/index.ts
+var program = new Command();
+program.name("tarout").description("Tarout PaaS Command Line Interface").version("0.1.0").option("--json", "Output as JSON (machine-readable)").option("-y, --yes", "Skip all confirmation prompts").option("-q, --quiet", "Minimal output").option("-v, --verbose", "Extra debug information").option("--no-color", "Disable colored output").hook("preAction", (thisCommand) => {
+  const opts = thisCommand.opts();
+  setGlobalOptions({
+    json: opts.json || false,
+    yes: opts.yes || false,
+    quiet: opts.quiet || false,
+    verbose: opts.verbose || false,
+    noColor: opts.color === false
+  });
+});
+registerAuthCommands(program);
+registerAppsCommands(program);
+registerDeployCommands(program);
+registerLogsCommand(program);
+registerEnvCommands(program);
+registerDbCommands(program);
+registerDomainsCommands(program);
+registerOrgsCommands(program);
+registerEnvsCommands(program);
+program.parse();