@sylphx/cli 0.1.9 → 0.3.0

package/dist/index.js

@@ -24,13 +24,13 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/index.ts
-var import_chalk17 = __toESM(require("chalk"));
-var import_commander16 = require("commander");
+var import_chalk24 = __toESM(require("chalk"));
+var import_commander23 = require("commander");
 
 // package.json
 var package_default = {
   name: "@sylphx/cli",
-  version: "0.1.9",
+  version: "0.3.0",
   description: "Sylphx Platform CLI \u2014 deploy, manage logs, env vars, and more",
   type: "commonjs",
   bin: {
@@ -73,8 +73,7 @@ var package_default = {
   }
 };
 
-// src/commands/db.ts
-var import_node_readline = __toESM(require("readline"));
+// src/commands/config-cmd.ts
 var import_chalk = __toESM(require("chalk"));
 var import_commander = require("commander");
 var import_ora = __toESM(require("ora"));
@@ -154,6 +153,7 @@ var config = {
 };
 
 // src/api.ts
+var { version } = package_default;
 var BASE_URL = process.env.SYLPHX_API_URL ?? "https://api.sylphx.com";
 var API_BASE = `${BASE_URL}/v1`;
 var AUTH_BASE_URL = "https://sylphx.com";
@@ -178,7 +178,7 @@ async function request(method, path5, options) {
   const headers = {
     Authorization: `Bearer ${token}`,
     "Content-Type": "application/json",
-    "User-Agent": "sylphx-cli/0.1.0"
+    "User-Agent": `sylphx-cli/${version}`
   };
   const res = await fetch(url, {
     method,
@@ -218,13 +218,12 @@ var api = {
       query: { envType }
     });
   },
-  /** Rollback to previous deployment
-   * NOTE: Endpoint needs backend verification; follows RESTful convention.
+  /** Rollback to previous deployment.
+   * Accepts envId (rollback env to previous deploy), deploymentRecordId, or buildRecordId.
+   * One of these is required.
    */
-  async rollback(projectId, envType) {
-    return request("POST", `/projects/${projectId}/rollback`, {
-      body: { envType }
-    });
+  async rollback(projectId, body) {
+    return request("POST", `/projects/${projectId}/rollback`, { body });
   },
   /** List env vars for a project environment */
   async listEnvVars(projectId, envType) {
@@ -252,30 +251,58 @@ var api = {
       query: { envType }
     });
   },
-  /** List domains for a project environment */
-  async listDomains(projectId, envType) {
-    const params = new URLSearchParams({ envType });
-    const res = await request(
-      "GET",
-      `/domains/projects/${projectId}/domains?${params}`
-    );
-    return res.customDomains ?? [];
+  // ── Domain Management (Unified System) ──────────────────────────────────
+  /** List all apex domains for a project environment */
+  async listDomains(projectId, envType = "production") {
+    return request("GET", `/projects/${projectId}/domains`, {
+      query: { envType }
+    });
   },
-  /** Add a domain for a project environment */
-  async addDomain(projectId, domain, envType) {
-    const params = new URLSearchParams({ envType });
-    return request("POST", `/domains/projects/${projectId}/domains?${params}`, {
-      body: { domain }
+  /** Register an apex domain for a project (full domain object with DNS records) */
+  async createDomain(projectId, apexDomain, envType = "production") {
+    return request("POST", `/projects/${projectId}/domains`, {
+      body: { apexDomain, envType }
     });
   },
-  /** Remove a domain from a project environment */
-  async removeDomain(projectId, domain, envType) {
-    const params = new URLSearchParams({ envType });
+  /** Add a hostname binding to an existing domain */
+  async addHostname(projectId, domainId, hostname, opts) {
+    const { envType = "production", ...bodyOpts } = opts ?? {};
+    return request("POST", `/projects/${projectId}/domains/${domainId}/hostnames`, {
+      query: { envType },
+      body: { hostname, ...bodyOpts }
+    });
+  },
+  /** Remove a hostname binding */
+  async removeHostname(projectId, domainId, hostnameId) {
     return request(
       "DELETE",
-      `/domains/projects/${projectId}/domains/${encodeURIComponent(domain)}?${params}`
+      `/projects/${projectId}/domains/${domainId}/hostnames/${hostnameId}`
+    );
+  },
+  /** Trigger DNS check for a hostname */
+  async checkHostname(projectId, domainId, hostnameId) {
+    return request(
+      "POST",
+      `/projects/${projectId}/domains/${domainId}/hostnames/${hostnameId}/check`
+    );
+  },
+  /** Enable email sending for a domain (generates DKIM keypair) */
+  async enableEmail(projectId, domainId, opts) {
+    return request("POST", `/projects/${projectId}/domains/${domainId}/email`, {
+      body: opts ?? {}
+    });
+  },
+  /** Check DKIM DNS propagation and load into Stalwart */
+  async checkEmail(projectId, domainId) {
+    return request(
+      "POST",
+      `/projects/${projectId}/domains/${domainId}/email/check`
     );
   },
+  /** Disable email sending for a domain */
+  async disableEmail(projectId, domainId) {
+    return request("DELETE", `/projects/${projectId}/domains/${domainId}/email`);
+  },
   /** Get current user and orgs */
   async whoami() {
     return request("GET", "/user/me");
@@ -333,12 +360,282 @@ var api = {
   /** CLI auth: poll for token (uses main sylphx.com domain) */
   async pollCliAuth(code) {
     const res = await fetch(`${AUTH_BASE_URL}/api/auth/cli/poll?code=${encodeURIComponent(code)}`, {
-      headers: { "User-Agent": "sylphx-cli/0.1.0" }
+      headers: { "User-Agent": `sylphx-cli/${version}` }
     });
     if (!res.ok) {
       throw new ApiError(res.status, "Failed to poll auth status");
     }
     return res.json();
+  },
+  // ── Services ─────────────────────────────────────────────────────────────
+  /** List services for a project */
+  async listServices(projectId) {
+    const res = await request(
+      "GET",
+      `/projects/${encodeURIComponent(projectId)}/services`
+    );
+    return Array.isArray(res) ? res : res.data ?? [];
+  },
+  /** Get a service by name */
+  async getService(projectId, name) {
+    return request(
+      "GET",
+      `/projects/${encodeURIComponent(projectId)}/services/${encodeURIComponent(name)}`
+    );
+  },
+  /**
+   * Deploy a specific service.
+   * Backend expects { environmentId?, force?, image? } — NOT envType.
+   * Resolves envType → environmentId automatically.
+   */
+  async deployService(projectId, name, envType) {
+    const environmentId = await this.resolveEnvId(projectId, envType);
+    return request(
+      "POST",
+      `/projects/${encodeURIComponent(projectId)}/services/${encodeURIComponent(name)}/deploy`,
+      { body: environmentId ? { environmentId } : {} }
+    );
+  },
+  /** Delete a service */
+  async deleteService(projectId, name) {
+    return request(
+      "DELETE",
+      `/projects/${encodeURIComponent(projectId)}/services/${encodeURIComponent(name)}`
+    );
+  },
+  // ── Volumes ───────────────────────────────────────────────────────────────
+  /** List volumes for a project */
+  async listVolumes(projectId) {
+    const res = await request(
+      "GET",
+      `/projects/${encodeURIComponent(projectId)}/volumes`
+    );
+    return Array.isArray(res) ? res : res.volumes ?? [];
+  },
+  /** Create a volume */
+  async createVolume(projectId, data) {
+    return request(
+      "POST",
+      `/projects/${encodeURIComponent(projectId)}/volumes`,
+      { body: data }
+    );
+  },
+  /** Delete a volume */
+  async deleteVolume(projectId, volId) {
+    return request(
+      "DELETE",
+      `/projects/${encodeURIComponent(projectId)}/volumes/${encodeURIComponent(volId)}`
+    );
+  },
+  // ── Storage (Blob) ────────────────────────────────────────────────────────
+  /** List storage resources for a project.
+   * Backend returns a plain array of binding objects (not wrapped in { data: [...] }).
+   * Optionally filter by envType client-side.
+   */
+  async listStorage(projectId, envType) {
+    const res = await request(
+      "GET",
+      `/projects/${encodeURIComponent(projectId)}/storage`
+    );
+    const list = Array.isArray(res) ? res : [];
+    return envType ? list.filter((r) => !r.envType || r.envType === envType) : list;
+  },
+  /** Provision blob storage for a project environment */
+  async createStorage(projectId, data) {
+    return request("POST", `/projects/${encodeURIComponent(projectId)}/storage`, {
+      body: data
+    });
+  },
+  /** Delete a storage resource */
+  async deleteStorage(projectId, storageId) {
+    return request(
+      "DELETE",
+      `/projects/${encodeURIComponent(projectId)}/storage/${encodeURIComponent(storageId)}`
+    );
+  },
+  // ── Config (remote key-value) ─────────────────────────────────────────────
+  /**
+   * List all config keys for a project.
+   * Backend uses ?env=<envId> (not ?envType). Resolves envType → envId automatically.
+   */
+  async listConfig(projectId, envType) {
+    const query = {};
+    if (envType) {
+      const envId = await this.resolveEnvId(projectId, envType);
+      if (envId) query.env = envId;
+    }
+    const res = await request(
+      "GET",
+      `/projects/${encodeURIComponent(projectId)}/config`,
+      { query }
+    );
+    return Array.isArray(res) ? res : res.data ?? [];
+  },
+  /**
+   * Get a single config key.
+   * Backend uses ?env=<envId> (not ?envType). Resolves envType → envId automatically.
+   */
+  async getConfig(projectId, key, envType) {
+    const query = {};
+    if (envType) {
+      const envId = await this.resolveEnvId(projectId, envType);
+      if (envId) query.env = envId;
+    }
+    return request(
+      "GET",
+      `/projects/${encodeURIComponent(projectId)}/config/${encodeURIComponent(key)}`,
+      { query }
+    );
+  },
+  /**
+   * Set a config key.
+   * Backend expects { key, value, environmentId } (not envType).
+   * Resolves envType → environmentId automatically when envType is provided.
+   */
+  async setConfig(projectId, key, value, envType) {
+    let environmentId = null;
+    if (envType) {
+      environmentId = await this.resolveEnvId(projectId, envType);
+    }
+    return request("POST", `/projects/${encodeURIComponent(projectId)}/config`, {
+      body: { key, value, environmentId }
+    });
+  },
+  /**
+   * Delete a config key.
+   * Backend uses ?env=<envId> (not ?envType). Resolves envType → envId automatically.
+   */
+  async deleteConfig(projectId, key, envType) {
+    const query = {};
+    if (envType) {
+      const envId = await this.resolveEnvId(projectId, envType);
+      if (envId) query.env = envId;
+    }
+    return request(
+      "DELETE",
+      `/projects/${encodeURIComponent(projectId)}/config/${encodeURIComponent(key)}`,
+      { query }
+    );
+  },
+  // ── Environments ──────────────────────────────────────────────────────────
+  /** List environments for a project */
+  async listEnvironments(projectId) {
+    const res = await request(
+      "GET",
+      `/projects/${encodeURIComponent(projectId)}/environments`
+    );
+    return Array.isArray(res) ? res : res.data ?? [];
+  },
+  /**
+   * Resolve an environment type string (e.g. "production") → its envId for the given project.
+   * Returns null if not found. Used internally by config commands.
+   */
+  async resolveEnvId(projectId, envType) {
+    const envs = await this.listEnvironments(projectId);
+    const match = envs.find((e) => (e.envType ?? "").toLowerCase() === envType.toLowerCase());
+    return match?.id ?? null;
+  },
+  /** Promote an environment (e.g. staging → production).
+   * Backend returns { promoted: number, services: [...], sourceEnvironment, targetEnvironment }
+   */
+  async promoteEnvironment(projectId, targetEnvId, sourceEnvId) {
+    return request(
+      "POST",
+      `/projects/${encodeURIComponent(projectId)}/environments/${encodeURIComponent(targetEnvId)}/promote`,
+      { body: { sourceEnvId } }
+    );
+  },
+  // ── Resource Bindings ─────────────────────────────────────────────────────
+  /** List bindings for a resource (which envs it's linked to).
+   * Backend returns { bindings: [...] }.
+   */
+  async listResourceBindings(resourceId) {
+    const res = await request(
+      "GET",
+      `/resources/${encodeURIComponent(resourceId)}/bindings`
+    );
+    return res.bindings ?? [];
+  },
+  /**
+   * Bind a resource to a project environment.
+   * Backend expects { appEnvironmentId, role? }.
+   * Accepts projectId + envType and resolves to appEnvironmentId automatically.
+   */
+  async bindResource(resourceId, data) {
+    const appEnvironmentId = await this.resolveEnvId(data.projectId, data.envType);
+    if (!appEnvironmentId) {
+      throw new Error(`Environment '${data.envType}' not found for project '${data.projectId}'`);
+    }
+    return request(
+      "POST",
+      `/resources/${encodeURIComponent(resourceId)}/bindings`,
+      { body: { appEnvironmentId, role: data.role ?? "primary" } }
+    );
+  },
+  /** Unbind a resource from a project environment */
+  async unbindResource(resourceId, bindingId) {
+    return request(
+      "DELETE",
+      `/resources/${encodeURIComponent(resourceId)}/bindings/${encodeURIComponent(bindingId)}`
+    );
+  },
+  // ── Tasks ─────────────────────────────────────────────────────────────────
+  /**
+   * List task definitions for a project environment.
+   * Uses ?envId=<envId> (resolved from envType automatically).
+   */
+  async listTasks(projectId, envType) {
+    const query = {};
+    if (envType) {
+      const envId = await this.resolveEnvId(projectId, envType);
+      if (envId) query.envId = envId;
+    }
+    const res = await request(
+      "GET",
+      `/projects/${encodeURIComponent(projectId)}/tasks`,
+      { query }
+    );
+    return res.tasks ?? [];
+  },
+  /**
+   * Create or update a task definition (upserts on taskName + environmentId).
+   * Backend requires envId — resolves from envType automatically.
+   */
+  async createTask(projectId, data) {
+    const envId = await this.resolveEnvId(projectId, data.envType);
+    if (!envId)
+      throw new Error(`Environment '${data.envType}' not found for project '${projectId}'`);
+    const { envType: _drop, ...rest } = data;
+    const res = await request(
+      "POST",
+      `/projects/${encodeURIComponent(projectId)}/tasks`,
+      { body: { ...rest, envId } }
+    );
+    return res.task;
+  },
+  /** Get a single task definition */
+  async getTask(projectId, taskId) {
+    const res = await request(
+      "GET",
+      `/projects/${encodeURIComponent(projectId)}/tasks/${encodeURIComponent(taskId)}`
+    );
+    return res.task;
+  },
+  /** Update a task definition */
+  async updateTask(projectId, taskId, data) {
+    const res = await request(
+      "PATCH",
+      `/projects/${encodeURIComponent(projectId)}/tasks/${encodeURIComponent(taskId)}`,
+      { body: data }
+    );
+    return res.task;
+  },
+  /** Delete a task definition */
+  async deleteTask(projectId, taskId) {
+    await request(
+      "DELETE",
+      `/projects/${encodeURIComponent(projectId)}/tasks/${encodeURIComponent(taskId)}`
+    );
   }
 };
 function createLogStream(projectId, envType) {
@@ -349,13 +646,105 @@ function createLogStream(projectId, envType) {
   };
 }
 
+// src/commands/config-cmd.ts
+function requireLinkedApp() {
+  const linked = config.getLinkedApp();
+  if (!linked) {
+    console.log(import_chalk.default.red("No app linked. Run `sylphx link` first."));
+    process.exit(1);
+  }
+  return linked;
+}
+function requireToken() {
+  const token = config.getToken();
+  if (!token) {
+    console.log(import_chalk.default.red("Not authenticated. Run `sylphx login` first."));
+    process.exit(1);
+  }
+  return token;
+}
+var listCmd = new import_commander.Command("list").description("List all remote config keys").option("--env <env>", "Environment (e.g. production, staging)").action(async (opts) => {
+  requireToken();
+  const linked = requireLinkedApp();
+  const spinner = (0, import_ora.default)("Fetching config...").start();
+  try {
+    const entries = await api.listConfig(linked.appId, opts.env);
+    spinner.stop();
+    if (entries.length === 0) {
+      console.log(import_chalk.default.dim("  No config keys set."));
+      return;
+    }
+    console.log();
+    const maxKey = Math.max(...entries.map((e) => e.key.length), 3);
+    for (const e of entries) {
+      const display = typeof e.value === "string" ? e.value : JSON.stringify(e.value);
+      console.log(`  ${import_chalk.default.cyan(e.key.padEnd(maxKey))}  ${import_chalk.default.white(display)}`);
+    }
+    console.log();
+  } catch (err) {
+    spinner.fail(import_chalk.default.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+});
+var getCmd = new import_commander.Command("get").description("Get a remote config value").argument("<key>", "Config key name").option("--env <env>", "Environment (e.g. production, staging)").action(async (key, opts) => {
+  requireToken();
+  const linked = requireLinkedApp();
+  const spinner = (0, import_ora.default)(`Fetching config key '${key}'...`).start();
+  try {
+    const entry = await api.getConfig(linked.appId, key, opts.env);
+    spinner.stop();
+    console.log(
+      typeof entry.value === "string" ? entry.value : JSON.stringify(entry.value, null, 2)
+    );
+  } catch (err) {
+    spinner.fail(import_chalk.default.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+});
+var setCmd = new import_commander.Command("set").description("Set a remote config key").argument("<assignment>", "KEY=VALUE assignment").option("--env <env>", "Environment (e.g. production, staging)").action(async (assignment, opts) => {
+  requireToken();
+  const linked = requireLinkedApp();
+  const eqIdx = assignment.indexOf("=");
+  if (eqIdx === -1) {
+    console.log(import_chalk.default.red("  Invalid format. Use KEY=VALUE."));
+    process.exit(1);
+  }
+  const key = assignment.slice(0, eqIdx);
+  const value = assignment.slice(eqIdx + 1);
+  const spinner = (0, import_ora.default)(`Setting config '${key}'...`).start();
+  try {
+    await api.setConfig(linked.appId, key, value, opts.env);
+    spinner.succeed(import_chalk.default.green(`\u2713 Config '${key}' set`));
+  } catch (err) {
+    spinner.fail(import_chalk.default.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+});
+var rmCmd = new import_commander.Command("rm").description("Delete a remote config key").argument("<key>", "Config key to delete").option("--env <env>", "Environment (e.g. production, staging)").action(async (key, opts) => {
+  requireToken();
+  const linked = requireLinkedApp();
+  const spinner = (0, import_ora.default)(`Deleting config '${key}'...`).start();
+  try {
+    await api.deleteConfig(linked.appId, key, opts.env);
+    spinner.succeed(import_chalk.default.green(`\u2713 Config '${key}' deleted`));
+  } catch (err) {
+    spinner.fail(import_chalk.default.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+});
+var configCommand = new import_commander.Command("config").description("Manage remote config (non-secret key-value store)").addCommand(listCmd).addCommand(getCmd).addCommand(setCmd).addCommand(rmCmd).action(() => configCommand.help());
+
 // src/commands/db.ts
+var import_node_readline = __toESM(require("readline"));
+var import_chalk2 = __toESM(require("chalk"));
+var import_commander2 = require("commander");
+var import_ora2 = __toESM(require("ora"));
 var POLL_INTERVAL_MS = 3e3;
 var POLL_TIMEOUT_MS = 2 * 60 * 1e3;
 function requireAuth() {
   const token = config.getToken();
   if (!token) {
-    console.log(import_chalk.default.red("Not authenticated. Run `sylphx login` first."));
+    console.log(import_chalk2.default.red("Not authenticated. Run `sylphx login` first."));
     process.exit(1);
   }
   return token;
@@ -371,36 +760,36 @@ function prompt(question) {
 }
 function printDatabase(db) {
   console.log("");
-  console.log(import_chalk.default.bold(`  ${db.name}`));
-  console.log(import_chalk.default.dim(`  ${"\u2500".repeat(50)}`));
-  console.log(`  ID         : ${import_chalk.default.white(db.id)}`);
+  console.log(import_chalk2.default.bold(`  ${db.name}`));
+  console.log(import_chalk2.default.dim(`  ${"\u2500".repeat(50)}`));
+  console.log(`  ID         : ${import_chalk2.default.white(db.id)}`);
   console.log(`  Status     : ${statusColour(db.status)}`);
-  console.log(`  Tier       : ${import_chalk.default.white(db.tier)}`);
-  if (db.env) console.log(`  Env        : ${import_chalk.default.white(db.env)}`);
-  if (db.host) console.log(`  Host       : ${import_chalk.default.white(db.host)}`);
-  if (db.port) console.log(`  Port       : ${import_chalk.default.white(String(db.port))}`);
-  if (db.dbName) console.log(`  DB Name    : ${import_chalk.default.white(db.dbName)}`);
-  if (db.dbUser) console.log(`  DB User    : ${import_chalk.default.white(db.dbUser)}`);
-  if (db.storageGb) console.log(`  Storage    : ${import_chalk.default.white(`${db.storageGb} GB`)}`);
+  console.log(`  Tier       : ${import_chalk2.default.white(db.tier)}`);
+  if (db.env) console.log(`  Env        : ${import_chalk2.default.white(db.env)}`);
+  if (db.host) console.log(`  Host       : ${import_chalk2.default.white(db.host)}`);
+  if (db.port) console.log(`  Port       : ${import_chalk2.default.white(String(db.port))}`);
+  if (db.dbName) console.log(`  DB Name    : ${import_chalk2.default.white(db.dbName)}`);
+  if (db.dbUser) console.log(`  DB User    : ${import_chalk2.default.white(db.dbUser)}`);
+  if (db.storageGb) console.log(`  Storage    : ${import_chalk2.default.white(`${db.storageGb} GB`)}`);
   if (db.connectionString) {
     console.log(`  Connection :`);
-    console.log(`    ${import_chalk.default.green(db.connectionString)}`);
+    console.log(`    ${import_chalk2.default.green(db.connectionString)}`);
   }
-  if (db.createdAt) console.log(import_chalk.default.dim(`  Created    : ${db.createdAt}`));
+  if (db.createdAt) console.log(import_chalk2.default.dim(`  Created    : ${db.createdAt}`));
   console.log("");
 }
 function statusColour(status) {
   switch (status) {
     case "ready":
-      return import_chalk.default.green(status);
+      return import_chalk2.default.green(status);
     case "provisioning":
     case "branching":
-      return import_chalk.default.yellow(status);
+      return import_chalk2.default.yellow(status);
     case "error":
     case "failed":
-      return import_chalk.default.red(status);
+      return import_chalk2.default.red(status);
     default:
-      return import_chalk.default.white(status);
+      return import_chalk2.default.white(status);
   }
 }
 async function pollUntilReady(id, spinner) {
@@ -417,152 +806,162 @@ async function pollUntilReady(id, spinner) {
   }
   throw new Error("Timed out waiting for database to become ready (2 min).");
 }
-var dbListCommand = new import_commander.Command("list").description("List all databases").action(async () => {
+var dbListCommand = new import_commander2.Command("list").description("List all databases").action(async () => {
   requireAuth();
-  const spinner = (0, import_ora.default)("Fetching databases...").start();
+  const spinner = (0, import_ora2.default)("Fetching databases...").start();
   try {
     const dbs = await api.listDatabases();
     spinner.stop();
     if (dbs.length === 0) {
-      console.log(import_chalk.default.dim("\n  No databases found.\n"));
+      console.log(import_chalk2.default.dim("\n  No databases found.\n"));
       return;
     }
     const colName = Math.max(4, ...dbs.map((d) => d.name.length));
     const colStatus = Math.max(6, ...dbs.map((d) => d.status.length));
     const colTier = Math.max(4, ...dbs.map((d) => d.tier.length));
     console.log("");
-    console.log(import_chalk.default.bold("  Databases"));
-    console.log(import_chalk.default.dim(`  ${"\u2500".repeat(colName + colStatus + colTier + 20)}`));
+    console.log(import_chalk2.default.bold("  Databases"));
+    console.log(import_chalk2.default.dim(`  ${"\u2500".repeat(colName + colStatus + colTier + 20)}`));
     console.log(
-      import_chalk.default.dim(
+      import_chalk2.default.dim(
         `  ${"NAME".padEnd(colName)}  ${"STATUS".padEnd(colStatus)}  ${"TIER".padEnd(colTier)}  ID`
       )
     );
-    console.log(import_chalk.default.dim(`  ${"\u2500".repeat(colName + colStatus + colTier + 20)}`));
+    console.log(import_chalk2.default.dim(`  ${"\u2500".repeat(colName + colStatus + colTier + 20)}`));
     for (const db of dbs) {
       console.log(
-        `  ${import_chalk.default.cyan(db.name.padEnd(colName))}  ${statusColour(db.status).padEnd(colStatus + 10)}  ${db.tier.padEnd(colTier)}  ${import_chalk.default.dim(db.id)}`
+        `  ${import_chalk2.default.cyan(db.name.padEnd(colName))}  ${statusColour(db.status).padEnd(colStatus + 10)}  ${db.tier.padEnd(colTier)}  ${import_chalk2.default.dim(db.id)}`
       );
     }
     console.log("");
   } catch (err) {
-    spinner.fail(import_chalk.default.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
+    spinner.fail(import_chalk2.default.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
     process.exit(1);
   }
 });
-var dbCreateCommand = new import_commander.Command("create").description("Provision a new database").argument("<name>", "Database name").option("--tier <tier>", "Database tier: standard or performance (default: standard)", "standard").option("--storage <gb>", "Storage in GB (default: 10)", "10").option("--env <env>", "Environment (default: production)", "production").action(async (name, opts) => {
+var dbCreateCommand = new import_commander2.Command("create").description("Provision a new database").argument("<name>", "Database name").option(
+  "--tier <tier>",
+  "Database tier: starter | standard | performance | enterprise1 | enterprise2 (default: standard)",
+  "standard"
+).option("--storage <gb>", "Storage in GB (default: 10)", "10").option("--env <env>", "Environment (default: production)", "production").action(async (name, opts) => {
   requireAuth();
   const storageGb = Number.parseInt(opts.storage, 10);
   if (Number.isNaN(storageGb) || storageGb < 5) {
-    console.log(import_chalk.default.red("Storage must be at least 5 GB."));
+    console.log(import_chalk2.default.red("Storage must be at least 5 GB."));
     process.exit(1);
   }
+  const VALID_TIERS = ["starter", "standard", "performance", "enterprise1", "enterprise2"];
   const tier = opts.tier === "pro" ? "performance" : opts.tier;
-  const spinner = (0, import_ora.default)(
-    `Provisioning database ${import_chalk.default.bold(name)} (${tier}, ${storageGb} GB)...`
+  if (!VALID_TIERS.includes(tier)) {
+    console.log(import_chalk2.default.red(`Invalid tier '${tier}'. Valid: ${VALID_TIERS.join(", ")}`));
+    process.exit(1);
+  }
+  const spinner = (0, import_ora2.default)(
+    `Provisioning database ${import_chalk2.default.bold(name)} (${tier}, ${storageGb} GB)...`
   ).start();
   try {
     const db = await api.createDatabase({ name, env: opts.env, tier, storageGb });
     spinner.text = `Waiting for database to become ready...`;
     const ready = await pollUntilReady(db.id, spinner);
-    spinner.succeed(import_chalk.default.green(`\u2713 Database ${import_chalk.default.bold(ready.name)} is ready`));
+    spinner.succeed(import_chalk2.default.green(`\u2713 Database ${import_chalk2.default.bold(ready.name)} is ready`));
     printDatabase(ready);
   } catch (err) {
-    spinner.fail(import_chalk.default.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
+    spinner.fail(import_chalk2.default.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
     process.exit(1);
   }
 });
-var dbGetCommand = new import_commander.Command("get").description("Get database details including connection string").argument("<id>", "Database ID").action(async (id) => {
+var dbGetCommand = new import_commander2.Command("get").description("Get database details including connection string").argument("<id>", "Database ID").action(async (id) => {
   requireAuth();
-  const spinner = (0, import_ora.default)("Fetching database...").start();
+  const spinner = (0, import_ora2.default)("Fetching database...").start();
   try {
     const db = await api.getDatabase(id);
     spinner.stop();
     printDatabase(db);
   } catch (err) {
-    spinner.fail(import_chalk.default.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
+    spinner.fail(import_chalk2.default.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
     process.exit(1);
   }
 });
-var dbDeleteCommand = new import_commander.Command("delete").description("Delete a database (irreversible)").argument("<id>", "Database ID").option("--force", "Skip confirmation prompt").action(async (id, opts) => {
+var dbDeleteCommand = new import_commander2.Command("delete").description("Delete a database (irreversible)").argument("<id>", "Database ID").option("--force", "Skip confirmation prompt").action(async (id, opts) => {
   requireAuth();
   if (!opts.force) {
     console.log("");
-    console.log(import_chalk.default.red(`  \u26A0  You are about to PERMANENTLY delete database ${import_chalk.default.bold(id)}.`));
-    console.log(import_chalk.default.red("     This deletes all data, backups, and PVCs. IRREVERSIBLE."));
+    console.log(import_chalk2.default.red(`  \u26A0  You are about to PERMANENTLY delete database ${import_chalk2.default.bold(id)}.`));
+    console.log(import_chalk2.default.red("     This deletes all data, backups, and PVCs. IRREVERSIBLE."));
     console.log("");
     const answer = await prompt("  Type the database ID to confirm");
     if (answer !== id) {
-      console.log(import_chalk.default.red("Confirmation did not match. Aborted."));
+      console.log(import_chalk2.default.red("Confirmation did not match. Aborted."));
       process.exit(1);
     }
   }
-  const spinner = (0, import_ora.default)(`Deleting database ${import_chalk.default.bold(id)}...`).start();
+  const spinner = (0, import_ora2.default)(`Deleting database ${import_chalk2.default.bold(id)}...`).start();
   try {
     await api.deleteDatabase(id);
-    spinner.succeed(import_chalk.default.green(`\u2713 Deleted database ${import_chalk.default.bold(id)}`));
+    spinner.succeed(import_chalk2.default.green(`\u2713 Deleted database ${import_chalk2.default.bold(id)}`));
   } catch (err) {
-    spinner.fail(import_chalk.default.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
+    spinner.fail(import_chalk2.default.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
     process.exit(1);
   }
 });
-var dbBranchCommand = new import_commander.Command("branch").description("Branch a database for staging or preview").argument("<id>", "Source database ID").option("--name <name>", "Branch database name").option("--env <env>", "Target environment (default: staging)", "staging").action(async (id, opts) => {
+var dbBranchCommand = new import_commander2.Command("branch").description("Branch a database for staging or preview").argument("<id>", "Source database ID").option("--name <name>", "Branch database name").option("--env <env>", "Target environment (default: staging)", "staging").action(async (id, opts) => {
   requireAuth();
   const branchName = opts.name ?? `${opts.env}-branch`;
-  const spinner = (0, import_ora.default)(
-    `Branching database ${import_chalk.default.bold(id)} \u2192 ${import_chalk.default.bold(branchName)}...`
+  const spinner = (0, import_ora2.default)(
+    `Branching database ${import_chalk2.default.bold(id)} \u2192 ${import_chalk2.default.bold(branchName)}...`
   ).start();
   try {
     const db = await api.branchDatabase(id, { name: branchName, env: opts.env, fast: true });
     spinner.text = `Waiting for branch to become ready...`;
     const ready = await pollUntilReady(db.id, spinner);
-    spinner.succeed(import_chalk.default.green(`\u2713 Branch ${import_chalk.default.bold(ready.name)} is ready`));
+    spinner.succeed(import_chalk2.default.green(`\u2713 Branch ${import_chalk2.default.bold(ready.name)} is ready`));
     printDatabase(ready);
   } catch (err) {
-    spinner.fail(import_chalk.default.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
+    spinner.fail(import_chalk2.default.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
     process.exit(1);
   }
 });
-var dbCommand = new import_commander.Command("db").description("Manage PostgreSQL databases").addCommand(dbListCommand).addCommand(dbCreateCommand).addCommand(dbGetCommand).addCommand(dbDeleteCommand).addCommand(dbBranchCommand);
+var dbCommand = new import_commander2.Command("db").description("Manage PostgreSQL databases").addCommand(dbListCommand).addCommand(dbCreateCommand).addCommand(dbGetCommand).addCommand(dbDeleteCommand).addCommand(dbBranchCommand);
 
 // src/commands/deploy.ts
-var import_chalk3 = __toESM(require("chalk"));
-var import_commander2 = require("commander");
-var import_ora2 = __toESM(require("ora"));
+var import_chalk4 = __toESM(require("chalk"));
+var import_commander3 = require("commander");
+var import_ora3 = __toESM(require("ora"));
 
 // src/utils/logs.ts
-var import_chalk2 = __toESM(require("chalk"));
+var import_chalk3 = __toESM(require("chalk"));
+var { version: version2 } = package_default;
 function formatLogEntry(raw) {
   let entry;
   try {
     entry = JSON.parse(raw);
   } catch {
-    return `  ${import_chalk2.default.white(raw)}`;
+    return `  ${import_chalk3.default.white(raw)}`;
   }
   const message = entry.content ?? entry.message ?? entry.msg ?? raw;
   const level = (entry.level ?? "info").toLowerCase();
   const timestamp = entry.timestamp ?? entry.ts;
-  const prefix = timestamp ? `${import_chalk2.default.dim(`[${new Date(timestamp).toLocaleTimeString()}]`)} ` : "";
+  const prefix = timestamp ? `${import_chalk3.default.dim(`[${new Date(timestamp).toLocaleTimeString()}]`)} ` : "";
   const status = entry.status?.toLowerCase();
   const effectiveLevel = status === "error" || status === "failed" ? "error" : status === "success" || status === "done" ? "success" : level;
   switch (effectiveLevel) {
     case "error":
-      return `  ${prefix}${import_chalk2.default.red("\u2717")} ${import_chalk2.default.red(message)}`;
+      return `  ${prefix}${import_chalk3.default.red("\u2717")} ${import_chalk3.default.red(message)}`;
     case "warn":
-      return `  ${prefix}${import_chalk2.default.yellow("\u26A0")} ${import_chalk2.default.yellow(message)}`;
+      return `  ${prefix}${import_chalk3.default.yellow("\u26A0")} ${import_chalk3.default.yellow(message)}`;
     case "success":
-      return `  ${prefix}${import_chalk2.default.green("\u2713")} ${import_chalk2.default.green(message)}`;
+      return `  ${prefix}${import_chalk3.default.green("\u2713")} ${import_chalk3.default.green(message)}`;
     case "debug":
-      return `  ${prefix}${import_chalk2.default.dim(message)}`;
+      return `  ${prefix}${import_chalk3.default.dim(message)}`;
     default:
-      return `  ${prefix}${import_chalk2.default.white(message)}`;
+      return `  ${prefix}${import_chalk3.default.white(message)}`;
   }
 }
 function streamLogs(url, token, opts = {}) {
   return new Promise((resolve) => {
     const EventSource = require("eventsource");
     const headers = {
-      "User-Agent": "sylphx-cli/0.1.0",
+      "User-Agent": `sylphx-cli/${version2}`,
       Accept: "text/event-stream"
     };
     if (token) {
@@ -615,7 +1014,7 @@ function streamLogs(url, token, opts = {}) {
     es.addEventListener("error", (event) => {
       const errorEvent = event;
       if (errorEvent.message) {
-        console.log(import_chalk2.default.red(`  Stream error: ${errorEvent.message}`));
+        console.log(import_chalk3.default.red(`  Stream error: ${errorEvent.message}`));
       }
       if (opts.exitOnDone) {
         finish(succeeded);
@@ -631,40 +1030,40 @@ function streamLogs(url, token, opts = {}) {
 }
 
 // src/commands/deploy.ts
-var deployCommand = new import_commander2.Command("deploy").description("Trigger a deployment for the linked app").option("--env <env>", "Environment to deploy to (e.g. production, staging)").action(async (opts) => {
+var deployCommand = new import_commander3.Command("deploy").description("Trigger a deployment for the linked app").option("--env <env>", "Environment to deploy to (e.g. production, staging)").action(async (opts) => {
   const token = config.getToken();
   if (!token) {
-    console.log(import_chalk3.default.red("Not authenticated. Run `sylphx login` first."));
+    console.log(import_chalk4.default.red("Not authenticated. Run `sylphx login` first."));
     process.exit(1);
   }
   const linked = config.getLinkedApp();
   if (!linked) {
-    console.log(import_chalk3.default.red("No app linked. Run `sylphx link` first."));
+    console.log(import_chalk4.default.red("No app linked. Run `sylphx link` first."));
     process.exit(1);
   }
   const env = opts.env ?? linked.defaultEnv;
   console.log("");
-  console.log(import_chalk3.default.bold(`  Deploying ${import_chalk3.default.cyan(linked.appId)} \u2192 ${import_chalk3.default.white(env)}`));
+  console.log(import_chalk4.default.bold(`  Deploying ${import_chalk4.default.cyan(linked.appId)} \u2192 ${import_chalk4.default.white(env)}`));
   console.log("");
-  const spinner = (0, import_ora2.default)("Triggering deployment...").start();
+  const spinner = (0, import_ora3.default)("Triggering deployment...").start();
   let deploymentId;
   try {
     const result = await api.triggerDeploy(linked.appId, env);
-    spinner.succeed(import_chalk3.default.green(`Deployment triggered: ${result.status}`));
+    spinner.succeed(import_chalk4.default.green(`Deployment triggered: ${result.status}`));
     deploymentId = result.deploymentId;
     if (deploymentId) {
-      console.log(import_chalk3.default.dim(`  Deployment ID: ${deploymentId}`));
+      console.log(import_chalk4.default.dim(`  Deployment ID: ${deploymentId}`));
     }
     if (result.environment) {
-      console.log(import_chalk3.default.dim(`  Environment:   ${result.environment}`));
+      console.log(import_chalk4.default.dim(`  Environment:   ${result.environment}`));
     }
   } catch (err) {
-    spinner.fail(import_chalk3.default.red(`Deploy failed: ${err instanceof Error ? err.message : String(err)}`));
+    spinner.fail(import_chalk4.default.red(`Deploy failed: ${err instanceof Error ? err.message : String(err)}`));
     process.exit(1);
   }
   console.log("");
-  console.log(import_chalk3.default.bold("  Build Logs"));
-  console.log(import_chalk3.default.dim(`  ${"\u2500".repeat(50)}`));
+  console.log(import_chalk4.default.bold("  Build Logs"));
+  console.log(import_chalk4.default.dim(`  ${"\u2500".repeat(50)}`));
   console.log("");
   const logStream = createLogStream(linked.appId, env);
   const success = await streamLogs(logStream.url, logStream.token, {
@@ -673,140 +1072,387 @@ var deployCommand = new import_commander2.Command("deploy").description("Trigger
   });
   if (!success) {
     console.log("");
-    console.log(import_chalk3.default.red("  Deployment failed."));
+    console.log(import_chalk4.default.red("  Deployment failed."));
     process.exit(1);
   }
   console.log("");
-  console.log(import_chalk3.default.green.bold("  \u2713 Deployment successful!"));
+  console.log(import_chalk4.default.green.bold("  \u2713 Deployment successful!"));
   console.log("");
 });
 
 // src/commands/domains.ts
-var import_chalk4 = __toESM(require("chalk"));
-var import_commander3 = require("commander");
-var import_ora3 = __toESM(require("ora"));
-function requireLinkedApp() {
+var import_chalk5 = __toESM(require("chalk"));
+var import_commander4 = require("commander");
+var import_ora4 = __toESM(require("ora"));
+function requireLinkedApp2() {
   const token = config.getToken();
   if (!token) {
-    console.log(import_chalk4.default.red("Not authenticated. Run `sylphx login` first."));
+    console.error(import_chalk5.default.red("Not authenticated. Run `sylphx login` first."));
     process.exit(1);
   }
   const linked = config.getLinkedApp();
   if (!linked) {
-    console.log(import_chalk4.default.red("No app linked. Run `sylphx link` first."));
+    console.error(import_chalk5.default.red("No project linked. Run `sylphx link` first."));
     process.exit(1);
   }
   return linked;
 }
-var domainsListCommand = new import_commander3.Command("list").description("List custom domains").option("--env <env>", "Environment (e.g. production, staging)").action(async (opts) => {
-  const linked = requireLinkedApp();
-  const env = opts.env ?? linked.defaultEnv;
-  const spinner = (0, import_ora3.default)(`Fetching domains [${env}]...`).start();
+function extractApex(hostname) {
+  const parts = hostname.split(".");
+  return parts.length > 2 ? parts.slice(-2).join(".") : hostname;
+}
+function findDomainByApex(domains, apex) {
+  return domains.find((d) => d.apexDomain === apex);
+}
+function findHostname(domain, hostname) {
+  return domain.hostnames.find((h) => h.hostname === hostname);
+}
+function dnsStatusBadge(status) {
+  switch (status) {
+    case "active":
+    case "verified":
+      return import_chalk5.default.green("\u2713 active");
+    case "verifying":
+      return import_chalk5.default.yellow("\u27F3 verifying");
+    case "pending":
+      return import_chalk5.default.dim("\u25CB pending");
+    case "error":
+    case "failed":
+      return import_chalk5.default.red("\u2717 failed");
+    default:
+      return import_chalk5.default.dim(status);
+  }
+}
+function printDnsRecord(record) {
+  const statusBadge = record.status ? `  ${dnsStatusBadge(record.status)}` : "";
+  console.log(import_chalk5.default.dim(`    ${record.type.padEnd(5)} ${import_chalk5.default.cyan(record.name)}`));
+  console.log(import_chalk5.default.dim(`          \u2192 ${record.value}${statusBadge}`));
+  if (record.description) console.log(import_chalk5.default.dim(`          ${import_chalk5.default.italic(record.description)}`));
+}
+function printHostname(h, indent = "  ") {
+  const primary = h.isPrimary ? import_chalk5.default.green(" [primary]") : "";
+  const redirect = h.redirectTo ? import_chalk5.default.dim(` \u2192 ${h.redirectTo}`) : "";
+  console.log(
+    `${indent}${import_chalk5.default.bold(h.hostname)}${primary}${redirect}  ${dnsStatusBadge(h.dnsStatus)}`
+  );
+  if (h.dnsStatus !== "active") {
+    console.log(
+      `${indent}  ${import_chalk5.default.dim(h.instruction.type)} record: ${import_chalk5.default.cyan(h.instruction.name)} \u2192 ${h.instruction.value}`
+    );
+  }
+  if (h.lastCheckError) {
+    console.log(`${indent}  ${import_chalk5.default.red(h.lastCheckError)}`);
+  }
+}
+function printEmailBinding(email, indent = "  ") {
+  console.log(
+    `${indent}Email: ${dnsStatusBadge(email.dnsStatus)}${email.stalwartLoaded ? import_chalk5.default.dim(" (DKIM loaded)") : ""}`
+  );
+  if (email.defaultFromEmail) {
+    console.log(
+      `${indent}  From: ${email.defaultFromEmail}${email.defaultFromName ? ` <${email.defaultFromName}>` : ""}`
+    );
+  }
+  if (email.dnsStatus !== "verified" && email.records.length > 0) {
+    console.log(`${indent}  ${import_chalk5.default.dim("DNS records to add:")}`);
+    for (const rec of email.records) {
+      printDnsRecord({ ...rec, status: rec.status ?? void 0 });
+    }
+  }
+}
+function printDomainResult(d) {
+  console.log("");
+  console.log(`  ${import_chalk5.default.bold.white(d.apexDomain)}`);
+  if (d.hostnames.length === 0) {
+    console.log(import_chalk5.default.dim("    No hostname bindings"));
+  } else {
+    for (const h of d.hostnames) {
+      printHostname(h, "    ");
+    }
+  }
+  if (d.email) {
+    printEmailBinding(d.email, "    ");
+  }
+}
+var domainsListCommand = new import_commander4.Command("list").description("List all domains and their status").option("--env <env>", "Environment (production, staging, development)", "production").action(async (opts) => {
+  const linked = requireLinkedApp2();
+  const spinner = (0, import_ora4.default)("Fetching domains...").start();
   try {
-    const domains = await api.listDomains(linked.appId, env);
+    const domains = await api.listDomains(linked.appId, opts.env);
     spinner.stop();
     if (domains.length === 0) {
-      console.log(import_chalk4.default.dim("\n  No custom domains configured.\n"));
+      console.log(import_chalk5.default.dim("\n  No domains configured. Run `sylphx domains add <hostname>`\n"));
       return;
     }
     console.log("");
-    console.log(import_chalk4.default.bold(`  Custom Domains [${import_chalk4.default.white(env)}]`));
-    console.log(import_chalk4.default.dim(`  ${"\u2500".repeat(50)}`));
-    console.log("");
+    console.log(import_chalk5.default.bold(`  Domains [${import_chalk5.default.white(opts.env)}]`));
+    console.log(import_chalk5.default.dim(`  ${"\u2500".repeat(50)}`));
     for (const d of domains) {
-      const status = d.status ? import_chalk4.default.dim(` [${d.status}]`) : "";
-      const ssl = d.ssl ? import_chalk4.default.green(" \u{1F512}") : import_chalk4.default.yellow(" \u26A0 no SSL");
-      console.log(`  ${import_chalk4.default.cyan(d.domain)}${status}${ssl}`);
+      printDomainResult(d);
     }
     console.log("");
   } catch (err) {
-    spinner.fail(import_chalk4.default.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
+    spinner.fail(import_chalk5.default.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
     process.exit(1);
   }
 });
-var domainsAddCommand = new import_commander3.Command("add").description("Add a custom domain").argument("<domain>", "Domain to add (e.g. example.com)").option("--env <env>", "Environment (e.g. production, staging)").action(async (domain, opts) => {
-  const linked = requireLinkedApp();
-  const env = opts.env ?? linked.defaultEnv;
-  const spinner = (0, import_ora3.default)(`Adding domain ${domain} [${env}]...`).start();
+var domainsAddCommand = new import_commander4.Command("add").description("Add a hostname binding (auto-registers apex domain if needed)").argument("<hostname>", "Hostname to add (e.g. app.example.com or example.com)").option("--env <env>", "Environment", "production").option("--primary", "Set as primary domain", false).option("--redirect <url>", "Redirect to this URL instead of serving traffic").action(async (hostname, opts) => {
+  const linked = requireLinkedApp2();
+  const apex = extractApex(hostname);
+  const spinner = (0, import_ora4.default)(`Setting up ${hostname}...`).start();
   try {
-    const result = await api.addDomain(linked.appId, domain, env);
-    spinner.succeed(import_chalk4.default.green(`\u2713 Added domain ${import_chalk4.default.bold(result.domain ?? domain)}`));
-    if (result.status) {
-      console.log(import_chalk4.default.dim(`  Status: ${result.status}`));
+    const domains = await api.listDomains(linked.appId, opts.env);
+    let domain = findDomainByApex(domains, apex);
+    if (!domain) {
+      spinner.text = `Registering apex domain ${apex}...`;
+      domain = await api.createDomain(linked.appId, apex, opts.env);
     }
+    spinner.text = `Adding hostname binding ${hostname}...`;
+    const h = await api.addHostname(linked.appId, domain.id, hostname, {
+      isPrimary: opts.primary,
+      redirectTo: opts.redirect,
+      envType: opts.env
+    });
+    spinner.succeed(import_chalk5.default.green(`Added ${import_chalk5.default.bold(hostname)}`));
+    console.log("");
+    console.log(import_chalk5.default.bold("  DNS Record to add:"));
+    console.log("");
+    console.log(
+      `    ${import_chalk5.default.dim(h.instruction.type.padEnd(5))} ${import_chalk5.default.cyan(h.instruction.name)}`
+    );
+    console.log(`    ${import_chalk5.default.dim("value:")} ${h.instruction.value}`);
+    console.log(`    ${import_chalk5.default.dim("TTL:")}   ${h.instruction.ttl}`);
+    console.log("");
+    console.log(import_chalk5.default.dim(`  Status: ${dnsStatusBadge(h.dnsStatus)}`));
+    console.log(import_chalk5.default.dim(`  Run \`sylphx domains verify ${hostname}\` after updating DNS.`));
+    console.log("");
   } catch (err) {
-    spinner.fail(import_chalk4.default.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
+    spinner.fail(import_chalk5.default.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
     process.exit(1);
   }
 });
-var domainsRmCommand = new import_commander3.Command("rm").description("Remove a custom domain").argument("<domain>", "Domain to remove (e.g. example.com)").option("--env <env>", "Environment (e.g. production, staging)").action(async (domain, opts) => {
-  const linked = requireLinkedApp();
-  const env = opts.env ?? linked.defaultEnv;
-  const spinner = (0, import_ora3.default)(`Removing domain ${domain} [${env}]...`).start();
+var domainsRmCommand = new import_commander4.Command("rm").description("Remove a hostname binding").argument("<hostname>", "Hostname to remove").option("--env <env>", "Environment", "production").action(async (hostname, opts) => {
+  const linked = requireLinkedApp2();
+  const apex = extractApex(hostname);
+  const spinner = (0, import_ora4.default)(`Removing ${hostname}...`).start();
+  try {
+    const domains = await api.listDomains(linked.appId, opts.env);
+    const domain = findDomainByApex(domains, apex);
+    if (!domain) {
+      spinner.fail(import_chalk5.default.red(`Domain ${apex} not found`));
+      process.exit(1);
+    }
+    const h = findHostname(domain, hostname);
+    if (!h) {
+      spinner.fail(import_chalk5.default.red(`Hostname ${hostname} not found`));
+      process.exit(1);
+    }
+    await api.removeHostname(linked.appId, domain.id, h.id);
+    spinner.succeed(import_chalk5.default.green(`Removed ${import_chalk5.default.bold(hostname)}`));
+  } catch (err) {
+    spinner.fail(import_chalk5.default.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
+    process.exit(1);
+  }
+});
+var domainsVerifyCommand = new import_commander4.Command("verify").description("Check DNS propagation for a hostname").argument("<hostname>", "Hostname to check").option("--env <env>", "Environment", "production").action(async (hostname, opts) => {
+  const linked = requireLinkedApp2();
+  const apex = extractApex(hostname);
+  const spinner = (0, import_ora4.default)(`Checking DNS for ${hostname}...`).start();
+  try {
+    const domains = await api.listDomains(linked.appId, opts.env);
+    const domain = findDomainByApex(domains, apex);
+    if (!domain) {
+      spinner.fail(
+        import_chalk5.default.red(`Domain ${apex} not found. Run \`sylphx domains add ${hostname}\` first.`)
+      );
+      process.exit(1);
+    }
+    const h = findHostname(domain, hostname);
+    if (!h) {
+      spinner.fail(
+        import_chalk5.default.red(
+          `Hostname ${hostname} not registered. Run \`sylphx domains add ${hostname}\` first.`
+        )
+      );
+      process.exit(1);
+    }
+    const updated = await api.checkHostname(linked.appId, domain.id, h.id);
+    spinner.stop();
+    if (updated.dnsStatus === "active") {
+      console.log(import_chalk5.default.green(`
+  \u2713 ${hostname} is active
+`));
+    } else {
+      console.log(import_chalk5.default.yellow(`
+  \u26A0 ${hostname} \u2014 ${dnsStatusBadge(updated.dnsStatus)}`));
+      if (updated.lastCheckError) console.log(import_chalk5.default.dim(`  ${updated.lastCheckError}`));
+      console.log("");
+      console.log(import_chalk5.default.bold("  DNS record required:"));
+      console.log(
+        `    ${updated.instruction.type} ${import_chalk5.default.cyan(updated.instruction.name)} \u2192 ${updated.instruction.value}`
+      );
+      console.log("");
+    }
+  } catch (err) {
+    spinner.fail(import_chalk5.default.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
+    process.exit(1);
+  }
+});
+var emailEnableCommand = new import_commander4.Command("enable").description("Enable DKIM email sending for a domain").argument("<apex-domain>", "Apex domain to enable email for (e.g. example.com)").option("--from <email>", "Default from address (e.g. support@example.com)").option("--name <name>", 'Default sender display name (e.g. "Acme Support")').option("--env <env>", "Environment", "production").action(async (apexDomain, opts) => {
+  const linked = requireLinkedApp2();
+  const spinner = (0, import_ora4.default)(`Enabling email for ${apexDomain}...`).start();
+  try {
+    const domains = await api.listDomains(linked.appId, opts.env);
+    let domain = findDomainByApex(domains, apexDomain);
+    if (!domain) {
+      spinner.text = `Registering ${apexDomain}...`;
+      domain = await api.createDomain(linked.appId, apexDomain, opts.env);
+    }
+    if (domain.email) {
+      spinner.warn(
+        import_chalk5.default.yellow(
+          `Email already enabled for ${apexDomain}. Use \`sylphx domains email verify\` to check status.`
+        )
+      );
+      return;
+    }
+    const binding = await api.enableEmail(linked.appId, domain.id, {
+      defaultFromEmail: opts.from,
+      defaultFromName: opts.name
+    });
+    spinner.succeed(import_chalk5.default.green(`Email enabled for ${import_chalk5.default.bold(apexDomain)}`));
+    console.log("");
+    console.log(import_chalk5.default.bold("  DNS Records to add:"));
+    console.log("");
+    for (const rec of binding.records) {
+      console.log(`    ${import_chalk5.default.dim(rec.type.padEnd(5))} ${import_chalk5.default.cyan(rec.name)}`);
+      console.log(`    ${import_chalk5.default.dim("value:")} ${rec.value}`);
+      if (rec.priority !== void 0) console.log(`    ${import_chalk5.default.dim("priority:")} ${rec.priority}`);
+      console.log(`    ${import_chalk5.default.dim("TTL:")} ${rec.ttl}`);
+      if (rec.description) console.log(`    ${import_chalk5.default.dim(rec.description)}`);
+      console.log("");
+    }
+    console.log(
+      import_chalk5.default.dim(`  Run \`sylphx domains email verify ${apexDomain}\` after updating DNS.`)
+    );
+    console.log("");
+  } catch (err) {
+    spinner.fail(import_chalk5.default.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
+    process.exit(1);
+  }
+});
+var emailVerifyCommand = new import_commander4.Command("verify").description("Check DKIM DNS propagation").argument("<apex-domain>", "Apex domain to verify").option("--env <env>", "Environment", "production").action(async (apexDomain, opts) => {
+  const linked = requireLinkedApp2();
+  const spinner = (0, import_ora4.default)(`Checking DKIM DNS for ${apexDomain}...`).start();
+  try {
+    const domains = await api.listDomains(linked.appId, opts.env);
+    const domain = findDomainByApex(domains, apexDomain);
+    if (!domain?.email) {
+      spinner.fail(
+        import_chalk5.default.red(
+          `Email not enabled for ${apexDomain}. Run \`sylphx domains email enable ${apexDomain}\` first.`
+        )
+      );
+      process.exit(1);
+    }
+    const binding = await api.checkEmail(linked.appId, domain.id);
+    spinner.stop();
+    if (binding.dnsStatus === "verified") {
+      console.log(import_chalk5.default.green(`
+  \u2713 ${apexDomain} email verified \u2014 DKIM active
+`));
+    } else {
+      console.log(import_chalk5.default.yellow(`
+  ${apexDomain} \u2014 ${dnsStatusBadge(binding.dnsStatus)}`));
+      if (!binding.stalwartLoaded)
+        console.log(import_chalk5.default.dim("  (DKIM not yet loaded into mail server)"));
+      if (binding.verificationError) console.log(import_chalk5.default.red(`  ${binding.verificationError}`));
+      console.log("");
+      console.log(import_chalk5.default.bold("  DNS records still pending:"));
+      for (const rec of binding.records.filter((r) => r.status !== "verified")) {
+        printDnsRecord({ ...rec, status: rec.status ?? void 0 });
+      }
+      console.log("");
+    }
+  } catch (err) {
+    spinner.fail(import_chalk5.default.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
+    process.exit(1);
+  }
+});
+var emailDisableCommand = new import_commander4.Command("disable").description("Disable email sending for a domain").argument("<apex-domain>", "Apex domain").option("--env <env>", "Environment", "production").action(async (apexDomain, opts) => {
+  const linked = requireLinkedApp2();
+  const spinner = (0, import_ora4.default)(`Disabling email for ${apexDomain}...`).start();
   try {
-    await api.removeDomain(linked.appId, domain, env);
-    spinner.succeed(import_chalk4.default.green(`\u2713 Removed domain ${import_chalk4.default.bold(domain)}`));
+    const domains = await api.listDomains(linked.appId, opts.env);
+    const domain = findDomainByApex(domains, apexDomain);
+    if (!domain?.email) {
+      spinner.fail(import_chalk5.default.red(`Email not enabled for ${apexDomain}`));
+      process.exit(1);
+    }
+    await api.disableEmail(linked.appId, domain.id);
+    spinner.succeed(import_chalk5.default.green(`Email disabled for ${import_chalk5.default.bold(apexDomain)}`));
   } catch (err) {
-    spinner.fail(import_chalk4.default.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
+    spinner.fail(import_chalk5.default.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
     process.exit(1);
   }
 });
-var domainsCommand = new import_commander3.Command("domains").description("Manage custom domains").addCommand(domainsListCommand).addCommand(domainsAddCommand).addCommand(domainsRmCommand);
+var domainsEmailCommand = new import_commander4.Command("email").description("Manage email sending for a domain").addCommand(emailEnableCommand).addCommand(emailVerifyCommand).addCommand(emailDisableCommand);
+var domainsCommand = new import_commander4.Command("domains").description("Manage custom domains").addCommand(domainsListCommand).addCommand(domainsAddCommand).addCommand(domainsRmCommand).addCommand(domainsVerifyCommand).addCommand(domainsEmailCommand);
 
 // src/commands/env.ts
 var import_node_fs = __toESM(require("fs"));
 var import_node_path2 = __toESM(require("path"));
-var import_chalk5 = __toESM(require("chalk"));
-var import_commander4 = require("commander");
-var import_ora4 = __toESM(require("ora"));
-function requireLinkedApp2() {
+var import_chalk6 = __toESM(require("chalk"));
+var import_commander5 = require("commander");
+var import_ora5 = __toESM(require("ora"));
+function requireLinkedApp3() {
   const token = config.getToken();
   if (!token) {
-    console.log(import_chalk5.default.red("Not authenticated. Run `sylphx login` first."));
+    console.log(import_chalk6.default.red("Not authenticated. Run `sylphx login` first."));
     process.exit(1);
   }
   const linked = config.getLinkedApp();
   if (!linked) {
-    console.log(import_chalk5.default.red("No app linked. Run `sylphx link` first."));
+    console.log(import_chalk6.default.red("No app linked. Run `sylphx link` first."));
     process.exit(1);
   }
   return linked;
 }
-var envListCommand = new import_commander4.Command("list").description("List environment variables").option("--env <env>", "Environment (e.g. production, staging)").action(async (opts) => {
-  const linked = requireLinkedApp2();
+var envListCommand = new import_commander5.Command("list").description("List environment variables").option("--env <env>", "Environment (e.g. production, staging)").action(async (opts) => {
+  const linked = requireLinkedApp3();
   const env = opts.env ?? linked.defaultEnv;
-  const spinner = (0, import_ora4.default)(`Fetching env vars [${env}]...`).start();
+  const spinner = (0, import_ora5.default)(`Fetching env vars [${env}]...`).start();
   try {
     const vars = await api.listEnvVars(linked.appId, env);
     spinner.stop();
     if (vars.length === 0) {
-      console.log(import_chalk5.default.dim("\n  No environment variables set.\n"));
+      console.log(import_chalk6.default.dim("\n  No environment variables set.\n"));
       return;
     }
     console.log("");
-    console.log(import_chalk5.default.bold(`  Environment Variables [${import_chalk5.default.white(env)}]`));
-    console.log(import_chalk5.default.dim(`  ${"\u2500".repeat(50)}`));
+    console.log(import_chalk6.default.bold(`  Environment Variables [${import_chalk6.default.white(env)}]`));
+    console.log(import_chalk6.default.dim(`  ${"\u2500".repeat(50)}`));
     console.log("");
     const maxKeyLen = Math.max(...vars.map((v) => v.key.length));
     for (const v of vars) {
-      const key = import_chalk5.default.cyan(v.key.padEnd(maxKeyLen));
+      const key = import_chalk6.default.cyan(v.key.padEnd(maxKeyLen));
       const isSecret = v.isSecret ?? v.secret;
-      const value = isSecret ? import_chalk5.default.dim("****** (secret)") : import_chalk5.default.white(v.value);
+      const value = isSecret ? import_chalk6.default.dim("****** (secret)") : import_chalk6.default.white(v.value);
       console.log(`  ${key}  ${value}`);
     }
     console.log("");
   } catch (err) {
-    spinner.fail(import_chalk5.default.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
+    spinner.fail(import_chalk6.default.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
     process.exit(1);
   }
 });
-var envSetCommand = new import_commander4.Command("set").description("Set an environment variable (KEY=VALUE)").argument("<assignment>", "Key=Value assignment, e.g. DATABASE_URL=postgres://...").option("--env <env>", "Environment (e.g. production, staging)").option("--secret", "Mark as secret").action(async (assignment, opts) => {
-  const linked = requireLinkedApp2();
+var envSetCommand = new import_commander5.Command("set").description("Set an environment variable (KEY=VALUE)").argument("<assignment>", "Key=Value assignment, e.g. DATABASE_URL=postgres://...").option("--env <env>", "Environment (e.g. production, staging)").option("--secret", "Mark as secret").action(async (assignment, opts) => {
+  const linked = requireLinkedApp3();
   const env = opts.env ?? linked.defaultEnv;
   const eqIdx = assignment.indexOf("=");
   if (eqIdx < 1) {
     console.log(
-      import_chalk5.default.red(
+      import_chalk6.default.red(
         "Invalid format. Use KEY=VALUE (e.g. sylphx env set DATABASE_URL=postgres://...)"
       )
     );
@@ -815,40 +1461,40 @@ var envSetCommand = new import_commander4.Command("set").description("Set an env
   const key = assignment.slice(0, eqIdx).trim();
   const value = assignment.slice(eqIdx + 1);
   if (!key) {
-    console.log(import_chalk5.default.red("Key cannot be empty."));
+    console.log(import_chalk6.default.red("Key cannot be empty."));
     process.exit(1);
   }
-  const spinner = (0, import_ora4.default)(`Setting ${key} [${env}]...`).start();
+  const spinner = (0, import_ora5.default)(`Setting ${key} [${env}]...`).start();
   try {
     await api.setEnvVar(linked.appId, key, value, env, opts.secret);
-    spinner.succeed(import_chalk5.default.green(`\u2713 Set ${import_chalk5.default.bold(key)} in ${env}`));
+    spinner.succeed(import_chalk6.default.green(`\u2713 Set ${import_chalk6.default.bold(key)} in ${env}`));
   } catch (err) {
-    spinner.fail(import_chalk5.default.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
+    spinner.fail(import_chalk6.default.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
     process.exit(1);
   }
 });
-var envRmCommand = new import_commander4.Command("rm").description("Remove an environment variable").argument("<key>", "Variable name to remove").option("--env <env>", "Environment (e.g. production, staging)").action(async (key, opts) => {
-  const linked = requireLinkedApp2();
+var envRmCommand = new import_commander5.Command("rm").description("Remove an environment variable").argument("<key>", "Variable name to remove").option("--env <env>", "Environment (e.g. production, staging)").action(async (key, opts) => {
+  const linked = requireLinkedApp3();
   const env = opts.env ?? linked.defaultEnv;
-  const spinner = (0, import_ora4.default)(`Removing ${key} [${env}]...`).start();
+  const spinner = (0, import_ora5.default)(`Removing ${key} [${env}]...`).start();
   try {
     await api.deleteEnvVar(linked.appId, key, env);
-    spinner.succeed(import_chalk5.default.green(`\u2713 Removed ${import_chalk5.default.bold(key)} from ${env}`));
+    spinner.succeed(import_chalk6.default.green(`\u2713 Removed ${import_chalk6.default.bold(key)} from ${env}`));
   } catch (err) {
-    spinner.fail(import_chalk5.default.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
+    spinner.fail(import_chalk6.default.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
     process.exit(1);
   }
 });
-var envPullCommand = new import_commander4.Command("pull").description("Download env vars from the platform to a local .env file").option("--env <env>", "Environment (e.g. production, staging)").option("--file <file>", ".env file path", ".env").action(async (opts) => {
-  const linked = requireLinkedApp2();
+var envPullCommand = new import_commander5.Command("pull").description("Download env vars from the platform to a local .env file").option("--env <env>", "Environment (e.g. production, staging)").option("--file <file>", ".env file path", ".env").action(async (opts) => {
+  const linked = requireLinkedApp3();
   const env = opts.env ?? linked.defaultEnv;
   const filePath = import_node_path2.default.resolve(opts.file);
-  const spinner = (0, import_ora4.default)(`Pulling env vars [${env}]...`).start();
+  const spinner = (0, import_ora5.default)(`Pulling env vars [${env}]...`).start();
   try {
     const vars = await api.listEnvVars(linked.appId, env);
     spinner.stop();
     if (vars.length === 0) {
-      console.log(import_chalk5.default.dim("\n  No environment variables to pull.\n"));
+      console.log(import_chalk6.default.dim("\n  No environment variables to pull.\n"));
       return;
     }
     const lines = [
@@ -871,19 +1517,19 @@ var envPullCommand = new import_commander4.Command("pull").description("Download
     }
     lines.push("");
     import_node_fs.default.writeFileSync(filePath, lines.join("\n"), "utf-8");
-    console.log(import_chalk5.default.green(`\u2713 Wrote ${vars.length} variable(s) to ${import_chalk5.default.bold(opts.file)}`));
-    console.log(import_chalk5.default.dim(`  Secrets are shown as ${import_chalk5.default.white("KEY=")} (value omitted).`));
+    console.log(import_chalk6.default.green(`\u2713 Wrote ${vars.length} variable(s) to ${import_chalk6.default.bold(opts.file)}`));
+    console.log(import_chalk6.default.dim(`  Secrets are shown as ${import_chalk6.default.white("KEY=")} (value omitted).`));
   } catch (err) {
-    spinner.fail(import_chalk5.default.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
+    spinner.fail(import_chalk6.default.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
     process.exit(1);
   }
 });
-var envPushCommand = new import_commander4.Command("push").description("Push a local .env file to the platform").option("--env <env>", "Environment (e.g. production, staging)").option("--file <file>", ".env file path", ".env").action(async (opts) => {
-  const linked = requireLinkedApp2();
+var envPushCommand = new import_commander5.Command("push").description("Push a local .env file to the platform").option("--env <env>", "Environment (e.g. production, staging)").option("--file <file>", ".env file path", ".env").action(async (opts) => {
+  const linked = requireLinkedApp3();
   const env = opts.env ?? linked.defaultEnv;
   const filePath = import_node_path2.default.resolve(opts.file);
   if (!import_node_fs.default.existsSync(filePath)) {
-    console.log(import_chalk5.default.red(`File not found: ${opts.file}`));
+    console.log(import_chalk6.default.red(`File not found: ${opts.file}`));
     process.exit(1);
   }
   const content = import_node_fs.default.readFileSync(filePath, "utf-8");
@@ -903,29 +1549,29 @@ var envPushCommand = new import_commander4.Command("push").description("Push a l
     vars.push({ key, value, secret: false });
   }
   if (vars.length === 0) {
-    console.log(import_chalk5.default.yellow("  No variables to push (all lines empty or comments)."));
+    console.log(import_chalk6.default.yellow("  No variables to push (all lines empty or comments)."));
     return;
   }
-  const spinner = (0, import_ora4.default)(`Pushing ${vars.length} variable(s) to [${env}]...`).start();
+  const spinner = (0, import_ora5.default)(`Pushing ${vars.length} variable(s) to [${env}]...`).start();
   try {
     await api.setEnvVars(linked.appId, vars, env);
-    spinner.succeed(import_chalk5.default.green(`\u2713 Pushed ${vars.length} variable(s) to ${import_chalk5.default.bold(env)}`));
-    console.log(import_chalk5.default.dim(`  Run ${import_chalk5.default.cyan("sylphx deploy")} to apply the new variables.`));
+    spinner.succeed(import_chalk6.default.green(`\u2713 Pushed ${vars.length} variable(s) to ${import_chalk6.default.bold(env)}`));
+    console.log(import_chalk6.default.dim(`  Run ${import_chalk6.default.cyan("sylphx deploy")} to apply the new variables.`));
   } catch (err) {
-    spinner.fail(import_chalk5.default.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
+    spinner.fail(import_chalk6.default.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
     process.exit(1);
   }
 });
-var envCommand = new import_commander4.Command("env").description("Manage environment variables").addCommand(envListCommand).addCommand(envSetCommand).addCommand(envRmCommand).addCommand(envPullCommand).addCommand(envPushCommand);
+var envCommand = new import_commander5.Command("env").description("Manage environment variables").addCommand(envListCommand).addCommand(envSetCommand).addCommand(envRmCommand).addCommand(envPullCommand).addCommand(envPushCommand);
 
 // src/commands/init.ts
 var import_node_child_process = require("child_process");
 var import_node_fs2 = __toESM(require("fs"));
 var import_node_path3 = __toESM(require("path"));
 var import_node_readline2 = __toESM(require("readline"));
-var import_chalk6 = __toESM(require("chalk"));
-var import_commander5 = require("commander");
-var import_ora5 = __toESM(require("ora"));
+var import_chalk7 = __toESM(require("chalk"));
+var import_commander6 = require("commander");
+var import_ora6 = __toESM(require("ora"));
 function prompt2(question, defaultValue) {
   return new Promise((resolve) => {
     const rl = import_node_readline2.default.createInterface({ input: process.stdin, output: process.stdout });
@@ -960,10 +1606,10 @@ function detectGitRemote() {
     return void 0;
   }
 }
-var initCommand = new import_commander5.Command("init").description("Create and link a new Sylphx project in one step").argument("[name]", "Project name (detected from package.json if omitted)").option("--git", "Auto-detect git remote URL and set as gitRepository").option("--port <port>", "Application port").action(async (nameArg, opts) => {
+var initCommand = new import_commander6.Command("init").description("Create and link a new Sylphx project in one step").argument("[name]", "Project name (detected from package.json if omitted)").option("--git", "Auto-detect git remote URL and set as gitRepository").option("--port <port>", "Application port").action(async (nameArg, opts) => {
   const token = config.getToken();
   if (!token) {
-    console.log(import_chalk6.default.red("Not authenticated. Run `sylphx login` first."));
+    console.log(import_chalk7.default.red("Not authenticated. Run `sylphx login` first."));
     process.exit(1);
   }
   const pkg = readPackageJson();
@@ -971,51 +1617,51 @@ var initCommand = new import_commander5.Command("init").description("Create and
   let projectName;
   if (detectedName) {
     projectName = detectedName;
-    console.log(import_chalk6.default.dim(`  Project name: ${import_chalk6.default.white(projectName)}`));
+    console.log(import_chalk7.default.dim(`  Project name: ${import_chalk7.default.white(projectName)}`));
   } else {
     projectName = await prompt2("  Project name");
     if (!projectName) {
-      console.log(import_chalk6.default.red("Project name is required."));
+      console.log(import_chalk7.default.red("Project name is required."));
       process.exit(1);
     }
   }
   const slug = slugify(projectName);
   let orgId = config.getDefaultOrg();
   if (!orgId) {
-    const spinner2 = (0, import_ora5.default)("Fetching your organizations...").start();
+    const spinner2 = (0, import_ora6.default)("Fetching your organizations...").start();
     let orgs = [];
     try {
       const me = await api.whoami();
       orgs = me.orgs;
       spinner2.stop();
     } catch (err) {
-      spinner2.fail(import_chalk6.default.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
+      spinner2.fail(import_chalk7.default.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
       process.exit(1);
     }
     if (orgs.length === 0) {
-      console.log(import_chalk6.default.red("No organizations found. Create one at https://app.sylphx.com."));
+      console.log(import_chalk7.default.red("No organizations found. Create one at https://app.sylphx.com."));
       process.exit(1);
     }
     if (orgs.length === 1 && orgs[0]) {
       orgId = orgs[0].slug;
-      console.log(import_chalk6.default.dim(`  Using org: ${import_chalk6.default.white(orgId)}`));
+      console.log(import_chalk7.default.dim(`  Using org: ${import_chalk7.default.white(orgId)}`));
     } else {
-      console.log(import_chalk6.default.bold("\n  Your organizations:\n"));
+      console.log(import_chalk7.default.bold("\n  Your organizations:\n"));
       orgs.forEach((org, i) => {
-        console.log(`    ${import_chalk6.default.cyan(String(i + 1))}. ${org.slug} ${import_chalk6.default.dim(`(${org.name})`)}`);
+        console.log(`    ${import_chalk7.default.cyan(String(i + 1))}. ${org.slug} ${import_chalk7.default.dim(`(${org.name})`)}`);
       });
       console.log("");
       const choice = await prompt2("  Select org (number)");
       const idx = Number.parseInt(choice, 10) - 1;
       if (Number.isNaN(idx) || idx < 0 || idx >= orgs.length || !orgs[idx]) {
-        console.log(import_chalk6.default.red("Invalid selection."));
+        console.log(import_chalk7.default.red("Invalid selection."));
         process.exit(1);
       }
       orgId = orgs[idx]?.slug;
     }
   }
   if (!orgId) {
-    console.log(import_chalk6.default.red("Could not determine org."));
+    console.log(import_chalk7.default.red("Could not determine org."));
     process.exit(1);
   }
   let gitRepository;
@@ -1026,9 +1672,9 @@ var initCommand = new import_commander5.Command("init").description("Create and
       if (sshMatch?.[1]) gitRepository = sshMatch[1];
       const httpsMatch = gitRepository.match(/github\.com\/(.+?)(?:\.git)?$/);
       if (httpsMatch?.[1]) gitRepository = httpsMatch[1];
-      console.log(import_chalk6.default.dim(`  Git repo: ${import_chalk6.default.white(gitRepository)}`));
+      console.log(import_chalk7.default.dim(`  Git repo: ${import_chalk7.default.white(gitRepository)}`));
     } else {
-      console.log(import_chalk6.default.yellow("  \u26A0 No git remote found (--git flag ignored)."));
+      console.log(import_chalk7.default.yellow("  \u26A0 No git remote found (--git flag ignored)."));
     }
   }
   let appPort;
@@ -1036,10 +1682,10 @@ var initCommand = new import_commander5.Command("init").description("Create and
     appPort = Number.parseInt(opts.port, 10);
   } else if (pkg) {
     appPort = detectPortFromPackage(pkg);
-    if (appPort) console.log(import_chalk6.default.dim(`  Detected port: ${import_chalk6.default.white(String(appPort))}`));
+    if (appPort) console.log(import_chalk7.default.dim(`  Detected port: ${import_chalk7.default.white(String(appPort))}`));
   }
   console.log("");
-  const spinner = (0, import_ora5.default)(`Creating project ${import_chalk6.default.bold(projectName)}...`).start();
+  const spinner = (0, import_ora6.default)(`Creating project ${import_chalk7.default.bold(projectName)}...`).start();
   try {
     const project = await api.createProject({
       name: projectName,
@@ -1049,17 +1695,17 @@ var initCommand = new import_commander5.Command("init").description("Create and
     });
     config.linkApp({ appId: project.id, orgId, defaultEnv: "production" });
     config.setDefaultOrg(orgId);
-    spinner.succeed(import_chalk6.default.green(`\u2713 Created and linked project ${import_chalk6.default.bold(project.name)}`));
+    spinner.succeed(import_chalk7.default.green(`\u2713 Created and linked project ${import_chalk7.default.bold(project.name)}`));
     console.log("");
-    console.log(import_chalk6.default.dim(`  Project ID : ${project.id}`));
-    console.log(import_chalk6.default.dim(`  Slug       : ${project.slug}`));
-    console.log(import_chalk6.default.dim(`  Org        : ${orgId}`));
-    console.log(import_chalk6.default.dim(`  Directory  : ${process.cwd()}`));
+    console.log(import_chalk7.default.dim(`  Project ID : ${project.id}`));
+    console.log(import_chalk7.default.dim(`  Slug       : ${project.slug}`));
+    console.log(import_chalk7.default.dim(`  Org        : ${orgId}`));
+    console.log(import_chalk7.default.dim(`  Directory  : ${process.cwd()}`));
     console.log("");
-    console.log(import_chalk6.default.dim(`  ${import_chalk6.default.cyan("sylphx deploy")}   \u2014 deploy to production when ready`));
+    console.log(import_chalk7.default.dim(`  ${import_chalk7.default.cyan("sylphx deploy")}   \u2014 deploy to production when ready`));
     console.log("");
   } catch (err) {
-    spinner.fail(import_chalk6.default.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
+    spinner.fail(import_chalk7.default.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
     process.exit(1);
   }
 });
@@ -1068,9 +1714,9 @@ var initCommand = new import_commander5.Command("init").description("Create and
 var import_node_fs3 = __toESM(require("fs"));
 var import_node_path4 = __toESM(require("path"));
 var import_node_readline3 = __toESM(require("readline"));
-var import_chalk7 = __toESM(require("chalk"));
-var import_commander6 = require("commander");
-var import_ora6 = __toESM(require("ora"));
+var import_chalk8 = __toESM(require("chalk"));
+var import_commander7 = require("commander");
+var import_ora7 = __toESM(require("ora"));
 function readPackageName() {
   try {
     const pkgPath = import_node_path4.default.join(process.cwd(), "package.json");
@@ -1092,86 +1738,86 @@ function prompt3(question) {
     });
   });
 }
-var linkCommand = new import_commander6.Command("link").description("Link current directory to a Sylphx app").option("--org <org>", "Organization slug").action(async (opts) => {
+var linkCommand = new import_commander7.Command("link").description("Link current directory to a Sylphx app").option("--org <org>", "Organization slug").action(async (opts) => {
   const token = config.getToken();
   if (!token) {
-    console.log(import_chalk7.default.red("Not authenticated. Run `sylphx login` first."));
+    console.log(import_chalk8.default.red("Not authenticated. Run `sylphx login` first."));
     process.exit(1);
   }
   const pkgName = readPackageName();
   if (pkgName) {
-    console.log(import_chalk7.default.dim(`  Detected package: ${import_chalk7.default.white(pkgName)}`));
+    console.log(import_chalk8.default.dim(`  Detected package: ${import_chalk8.default.white(pkgName)}`));
   }
   let orgId = opts.org ?? config.getDefaultOrg();
   if (!orgId) {
-    const spinner = (0, import_ora6.default)("Fetching your organizations...").start();
+    const spinner = (0, import_ora7.default)("Fetching your organizations...").start();
     let orgs = [];
     try {
       const me = await api.whoami();
       orgs = me.orgs;
       spinner.stop();
     } catch (err) {
-      spinner.fail(import_chalk7.default.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
+      spinner.fail(import_chalk8.default.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
       process.exit(1);
     }
     if (orgs.length === 0) {
-      console.log(import_chalk7.default.red("No organizations found."));
+      console.log(import_chalk8.default.red("No organizations found."));
       process.exit(1);
     }
     if (orgs.length === 1 && orgs[0]) {
       orgId = orgs[0].slug;
-      console.log(import_chalk7.default.dim(`  Using org: ${import_chalk7.default.white(orgId)}`));
+      console.log(import_chalk8.default.dim(`  Using org: ${import_chalk8.default.white(orgId)}`));
     } else {
-      console.log(import_chalk7.default.bold("\n  Your organizations:\n"));
+      console.log(import_chalk8.default.bold("\n  Your organizations:\n"));
       orgs.forEach((org, i) => {
-        console.log(`    ${import_chalk7.default.cyan(String(i + 1))}. ${org.slug} ${import_chalk7.default.dim(`(${org.name})`)}`);
+        console.log(`    ${import_chalk8.default.cyan(String(i + 1))}. ${org.slug} ${import_chalk8.default.dim(`(${org.name})`)}`);
       });
       console.log("");
       const choice = await prompt3("  Select org (number): ");
       const idx = Number.parseInt(choice, 10) - 1;
       if (Number.isNaN(idx) || idx < 0 || idx >= orgs.length || !orgs[idx]) {
-        console.log(import_chalk7.default.red("Invalid selection."));
+        console.log(import_chalk8.default.red("Invalid selection."));
         process.exit(1);
       }
       orgId = orgs[idx]?.slug;
     }
   }
-  const spinner2 = (0, import_ora6.default)("Fetching projects...").start();
+  const spinner2 = (0, import_ora7.default)("Fetching projects...").start();
   let apps = [];
   try {
     apps = await api.listProjects();
     spinner2.stop();
   } catch (err) {
-    spinner2.fail(import_chalk7.default.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
+    spinner2.fail(import_chalk8.default.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
     process.exit(1);
   }
   if (apps.length === 0) {
-    console.log(import_chalk7.default.yellow("No apps found for this org."));
+    console.log(import_chalk8.default.yellow("No apps found for this org."));
     process.exit(1);
   }
-  console.log(import_chalk7.default.bold("\n  Available apps:\n"));
+  console.log(import_chalk8.default.bold("\n  Available apps:\n"));
   apps.forEach((app, i) => {
-    console.log(`    ${import_chalk7.default.cyan(String(i + 1))}. ${app.slug} ${import_chalk7.default.dim(`(${app.name})`)}`);
+    console.log(`    ${import_chalk8.default.cyan(String(i + 1))}. ${app.slug} ${import_chalk8.default.dim(`(${app.name})`)}`);
   });
   console.log("");
   const appChoice = await prompt3("  Select app (number): ");
   const appIdx = Number.parseInt(appChoice, 10) - 1;
   if (Number.isNaN(appIdx) || appIdx < 0 || appIdx >= apps.length || !apps[appIdx]) {
-    console.log(import_chalk7.default.red("Invalid selection."));
+    console.log(import_chalk8.default.red("Invalid selection."));
     process.exit(1);
   }
   const selectedApp = apps[appIdx];
   if (!selectedApp) {
-    console.log(import_chalk7.default.red("Invalid selection."));
+    console.log(import_chalk8.default.red("Invalid selection."));
     process.exit(1);
   }
   let defaultEnv = "production";
   const envs = selectedApp.environments ?? [];
   if (envs.length > 1) {
-    console.log(import_chalk7.default.bold("\n  Available environments:\n"));
+    console.log(import_chalk8.default.bold("\n  Available environments:\n"));
     envs.forEach((env, i) => {
       console.log(
-        `    ${import_chalk7.default.cyan(String(i + 1))}. ${env.envType ?? env.slug ?? env.name} ${import_chalk7.default.dim(`(${env.name})`)}`
+        `    ${import_chalk8.default.cyan(String(i + 1))}. ${env.envType ?? env.slug ?? env.name} ${import_chalk8.default.dim(`(${env.name})`)}`
       );
     });
     console.log("");
@@ -1194,18 +1840,19 @@ var linkCommand = new import_commander6.Command("link").description("Link curren
     config.setDefaultOrg(orgId);
   }
   console.log("");
-  console.log(import_chalk7.default.green(`\u2713 Linked to ${import_chalk7.default.bold(selectedApp.slug)}`));
+  console.log(import_chalk8.default.green(`\u2713 Linked to ${import_chalk8.default.bold(selectedApp.slug)}`));
   console.log(
-    import_chalk7.default.dim(`  App ID: ${selectedApp.id} | Env: ${defaultEnv} | Dir: ${process.cwd()}`)
+    import_chalk8.default.dim(`  App ID: ${selectedApp.id} | Env: ${defaultEnv} | Dir: ${process.cwd()}`)
   );
   console.log("");
 });
 
 // src/commands/login.ts
 var import_node_crypto = __toESM(require("crypto"));
-var import_chalk8 = __toESM(require("chalk"));
-var import_commander7 = require("commander");
-var import_ora7 = __toESM(require("ora"));
+var import_chalk9 = __toESM(require("chalk"));
+var import_commander8 = require("commander");
+var import_ora8 = __toESM(require("ora"));
+var { version: version3 } = package_default;
 var BASE_URL2 = process.env.SYLPHX_API_URL ?? "https://sylphx.com";
 var POLL_INTERVAL_MS2 = 2e3;
 var POLL_TIMEOUT_MS2 = 5 * 60 * 1e3;
@@ -1214,7 +1861,7 @@ async function initCode(code) {
     method: "POST",
     headers: {
       "Content-Type": "application/json",
-      "User-Agent": "sylphx-cli/0.1.0"
+      "User-Agent": `sylphx-cli/${version3}`
     },
     body: JSON.stringify({ code })
   });
@@ -1222,22 +1869,17 @@ async function initCode(code) {
     throw new Error(`Failed to initialize auth code (HTTP ${res.status})`);
   }
 }
-var loginCommand = new import_commander7.Command("login").description("Authenticate with the Sylphx platform").option(
-  "--token <token>",
-  "Authenticate with a pre-existing API token (for CI/CD)"
-).action(async (opts) => {
+var loginCommand = new import_commander8.Command("login").description("Authenticate with the Sylphx platform").option("--token <token>", "Authenticate with a pre-existing API token (for CI/CD)").action(async (opts) => {
   if (opts.token) {
-    const spinner2 = (0, import_ora7.default)("Validating token...").start();
+    const spinner2 = (0, import_ora8.default)("Validating token...").start();
     try {
       config.setToken(opts.token);
       const me = await api.whoami();
       config.setToken(opts.token);
-      spinner2.succeed(
-        import_chalk8.default.green(`Authenticated as ${import_chalk8.default.bold(me.user.email)}`)
-      );
+      spinner2.succeed(import_chalk9.default.green(`Authenticated as ${import_chalk9.default.bold(me.user.email)}`));
     } catch (err) {
       config.clearToken();
-      spinner2.fail(import_chalk8.default.red("Invalid token"));
+      spinner2.fail(import_chalk9.default.red("Invalid token"));
       process.exit(1);
     }
     return;
@@ -1245,18 +1887,18 @@ var loginCommand = new import_commander7.Command("login").description("Authentic
   const code = import_node_crypto.default.randomBytes(16).toString("hex").slice(0, 20).toUpperCase();
   const authUrl = `${BASE_URL2}/cli-auth?code=${code}`;
   console.log("");
-  console.log(import_chalk8.default.bold("  Sylphx CLI Authentication"));
+  console.log(import_chalk9.default.bold("  Sylphx CLI Authentication"));
   console.log("");
   console.log("  Opening browser to:");
-  console.log(`  ${import_chalk8.default.cyan(authUrl)}`);
+  console.log(`  ${import_chalk9.default.cyan(authUrl)}`);
   console.log("");
-  console.log(`  One-time code: ${import_chalk8.default.yellow.bold(code)}`);
+  console.log(`  One-time code: ${import_chalk9.default.yellow.bold(code)}`);
   console.log("");
   try {
     await initCode(code);
   } catch (err) {
     console.log(
-      import_chalk8.default.yellow(
+      import_chalk9.default.yellow(
         `  Warning: Could not register code: ${err instanceof Error ? err.message : String(err)}`
       )
     );
@@ -1265,13 +1907,9 @@ var loginCommand = new import_commander7.Command("login").description("Authentic
     const { default: open } = await import("open");
     await open(authUrl);
   } catch {
-    console.log(
-      import_chalk8.default.dim(
-        "  Could not open browser automatically. Please visit the URL above."
-      )
-    );
+    console.log(import_chalk9.default.dim("  Could not open browser automatically. Please visit the URL above."));
   }
-  const spinner = (0, import_ora7.default)("Waiting for browser authorization...").start();
+  const spinner = (0, import_ora8.default)("Waiting for browser authorization...").start();
   const deadline = Date.now() + POLL_TIMEOUT_MS2;
   while (Date.now() < deadline) {
     await sleep(POLL_INTERVAL_MS2);
@@ -1281,28 +1919,24 @@ var loginCommand = new import_commander7.Command("login").description("Authentic
         config.setToken(result.token);
         try {
           const me = await api.whoami();
-          spinner.succeed(
-            import_chalk8.default.green(`Authenticated as ${import_chalk8.default.bold(me.user.email)}`)
-          );
+          spinner.succeed(import_chalk9.default.green(`Authenticated as ${import_chalk9.default.bold(me.user.email)}`));
         } catch {
-          spinner.succeed(import_chalk8.default.green("Authenticated successfully"));
+          spinner.succeed(import_chalk9.default.green("Authenticated successfully"));
         }
         console.log("");
-        console.log(
-          `  Token stored at: ${import_chalk8.default.dim(config.getConfigPath())}`
-        );
+        console.log(`  Token stored at: ${import_chalk9.default.dim(config.getConfigPath())}`);
         console.log("");
         return;
       }
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       if (msg.includes("404") || msg.includes("expired")) {
-        spinner.fail(import_chalk8.default.red("Code expired or invalid. Please try again."));
+        spinner.fail(import_chalk9.default.red("Code expired or invalid. Please try again."));
         process.exit(1);
       }
     }
   }
-  spinner.fail(import_chalk8.default.red("Authentication timed out. Please try again."));
+  spinner.fail(import_chalk9.default.red("Authentication timed out. Please try again."));
   process.exit(1);
 });
 function sleep(ms) {
@@ -1310,43 +1944,43 @@ function sleep(ms) {
 }
 
 // src/commands/logout.ts
-var import_chalk9 = __toESM(require("chalk"));
-var import_commander8 = require("commander");
-var logoutCommand = new import_commander8.Command("logout").description("Clear stored credentials").action(() => {
+var import_chalk10 = __toESM(require("chalk"));
+var import_commander9 = require("commander");
+var logoutCommand = new import_commander9.Command("logout").description("Clear stored credentials").action(() => {
   const token = config.getToken();
   if (!token) {
-    console.log(import_chalk9.default.yellow("You are not currently logged in."));
+    console.log(import_chalk10.default.yellow("You are not currently logged in."));
     return;
   }
   config.clearToken();
-  console.log(import_chalk9.default.green("\u2713 Logged out successfully."));
+  console.log(import_chalk10.default.green("\u2713 Logged out successfully."));
   console.log(
-    import_chalk9.default.dim(`  Credentials cleared from ${config.getConfigPath()}`)
+    import_chalk10.default.dim(`  Credentials cleared from ${config.getConfigPath()}`)
   );
 });
 
 // src/commands/logs.ts
-var import_chalk10 = __toESM(require("chalk"));
-var import_commander9 = require("commander");
-var logsCommand = new import_commander9.Command("logs").description("Stream build/runtime logs").option("--env <env>", "Environment (e.g. production, staging)").option("-f, --follow", "Follow log output (stream continuously)").action(async (opts) => {
+var import_chalk11 = __toESM(require("chalk"));
+var import_commander10 = require("commander");
+var logsCommand = new import_commander10.Command("logs").description("Stream build/runtime logs").option("--env <env>", "Environment (e.g. production, staging)").option("-f, --follow", "Follow log output (stream continuously)").action(async (opts) => {
   const token = config.getToken();
   if (!token) {
-    console.log(import_chalk10.default.red("Not authenticated. Run `sylphx login` first."));
+    console.log(import_chalk11.default.red("Not authenticated. Run `sylphx login` first."));
     process.exit(1);
   }
   const linked = config.getLinkedApp();
   if (!linked) {
-    console.log(import_chalk10.default.red("No app linked. Run `sylphx link` first."));
+    console.log(import_chalk11.default.red("No app linked. Run `sylphx link` first."));
     process.exit(1);
   }
   const env = opts.env ?? linked.defaultEnv;
   console.log("");
   console.log(
-    import_chalk10.default.bold(
-      `  Logs for ${import_chalk10.default.cyan(linked.appId)} [${import_chalk10.default.white(env)}]${opts.follow ? import_chalk10.default.dim(" (following...)") : ""}`
+    import_chalk11.default.bold(
+      `  Logs for ${import_chalk11.default.cyan(linked.appId)} [${import_chalk11.default.white(env)}]${opts.follow ? import_chalk11.default.dim(" (following...)") : ""}`
     )
   );
-  console.log(import_chalk10.default.dim(`  ${"\u2500".repeat(50)}`));
+  console.log(import_chalk11.default.dim(`  ${"\u2500".repeat(50)}`));
   console.log("");
   const logStream = createLogStream(linked.appId, env);
   await streamLogs(logStream.url, logStream.token, {
@@ -1359,21 +1993,21 @@ var logsCommand = new import_commander9.Command("logs").description("Stream buil
 });
 
 // src/commands/open.ts
-var import_chalk11 = __toESM(require("chalk"));
-var import_commander10 = require("commander");
-var import_ora8 = __toESM(require("ora"));
-var openCommand = new import_commander10.Command("open").description("Open the app in your browser").option("--env <env>", "Environment (e.g. production, staging)").action(async (opts) => {
+var import_chalk12 = __toESM(require("chalk"));
+var import_commander11 = require("commander");
+var import_ora9 = __toESM(require("ora"));
+var openCommand = new import_commander11.Command("open").description("Open the app in your browser").option("--env <env>", "Environment (e.g. production, staging)").action(async (opts) => {
   const token = config.getToken();
   if (!token) {
-    console.log(import_chalk11.default.red("Not authenticated. Run `sylphx login` first."));
+    console.log(import_chalk12.default.red("Not authenticated. Run `sylphx login` first."));
     process.exit(1);
   }
   const linked = config.getLinkedApp();
   if (!linked) {
-    console.log(import_chalk11.default.red("No app linked. Run `sylphx link` first."));
+    console.log(import_chalk12.default.red("No app linked. Run `sylphx link` first."));
     process.exit(1);
   }
-  const spinner = (0, import_ora8.default)("Fetching app URL...").start();
+  const spinner = (0, import_ora9.default)("Fetching app URL...").start();
   let url;
   try {
     const status = await api.getDeploymentStatus(linked.appId);
@@ -1383,7 +2017,7 @@ var openCommand = new import_commander10.Command("open").description("Open the a
     const resolvedUrl = status.url ?? envMatch?.url ?? null;
     if (!resolvedUrl) {
       url = `https://sylphx.com/console/apps/${linked.appId}`;
-      console.log(import_chalk11.default.yellow("  No URL found, opening console instead."));
+      console.log(import_chalk12.default.yellow("  No URL found, opening console instead."));
     } else {
       url = resolvedUrl;
     }
@@ -1391,28 +2025,28 @@ var openCommand = new import_commander10.Command("open").description("Open the a
     spinner.stop();
     url = `https://sylphx.com/console/apps/${linked.appId}`;
   }
-  console.log(`  Opening ${import_chalk11.default.cyan(url)}`);
+  console.log(`  Opening ${import_chalk12.default.cyan(url)}`);
   try {
     const { default: open } = await import("open");
     await open(url);
   } catch (err) {
     console.log(
-      import_chalk11.default.red(`Failed to open browser: ${err instanceof Error ? err.message : String(err)}`)
+      import_chalk12.default.red(`Failed to open browser: ${err instanceof Error ? err.message : String(err)}`)
     );
-    console.log(import_chalk11.default.dim(`  URL: ${url}`));
+    console.log(import_chalk12.default.dim(`  URL: ${url}`));
     process.exit(1);
   }
 });
 
 // src/commands/projects.ts
 var import_node_readline4 = __toESM(require("readline"));
-var import_chalk12 = __toESM(require("chalk"));
-var import_commander11 = require("commander");
-var import_ora9 = __toESM(require("ora"));
+var import_chalk13 = __toESM(require("chalk"));
+var import_commander12 = require("commander");
+var import_ora10 = __toESM(require("ora"));
 function requireAuth2() {
   const token = config.getToken();
   if (!token) {
-    console.log(import_chalk12.default.red("Not authenticated. Run `sylphx login` first."));
+    console.log(import_chalk13.default.red("Not authenticated. Run `sylphx login` first."));
     process.exit(1);
   }
   return token;
@@ -1429,41 +2063,41 @@ function prompt4(question) {
     });
   });
 }
-var projectsListCommand = new import_commander11.Command("list").description("List all projects").action(async () => {
+var projectsListCommand = new import_commander12.Command("list").description("List all projects").action(async () => {
   requireAuth2();
-  const spinner = (0, import_ora9.default)("Fetching projects...").start();
+  const spinner = (0, import_ora10.default)("Fetching projects...").start();
   try {
     const projects = await api.listProjects();
     spinner.stop();
     if (projects.length === 0) {
-      console.log(import_chalk12.default.dim("\n  No projects found.\n"));
+      console.log(import_chalk13.default.dim("\n  No projects found.\n"));
       return;
     }
     const colSlug = Math.max(4, ...projects.map((p) => p.slug.length));
     const colName = Math.max(4, ...projects.map((p) => p.name.length));
     console.log("");
-    console.log(import_chalk12.default.bold("  Projects"));
-    console.log(import_chalk12.default.dim(`  ${"\u2500".repeat(colSlug + colName + 30)}`));
+    console.log(import_chalk13.default.bold("  Projects"));
+    console.log(import_chalk13.default.dim(`  ${"\u2500".repeat(colSlug + colName + 30)}`));
     console.log(
-      import_chalk12.default.dim(`  ${"SLUG".padEnd(colSlug)}  ${"NAME".padEnd(colName)}  ${"ENVIRONMENTS"}`)
+      import_chalk13.default.dim(`  ${"SLUG".padEnd(colSlug)}  ${"NAME".padEnd(colName)}  ${"ENVIRONMENTS"}`)
     );
-    console.log(import_chalk12.default.dim(`  ${"\u2500".repeat(colSlug + colName + 30)}`));
+    console.log(import_chalk13.default.dim(`  ${"\u2500".repeat(colSlug + colName + 30)}`));
     for (const p of projects) {
-      const envNames = p.environments && p.environments.length > 0 ? p.environments.map((e) => e.name || e.envType || e.id).join(", ") : import_chalk12.default.dim("\u2014");
+      const envNames = p.environments && p.environments.length > 0 ? p.environments.map((e) => e.name || e.envType || e.id).join(", ") : import_chalk13.default.dim("\u2014");
       console.log(
-        `  ${import_chalk12.default.cyan(p.slug.padEnd(colSlug))}  ${p.name.padEnd(colName)}  ${envNames}`
+        `  ${import_chalk13.default.cyan(p.slug.padEnd(colSlug))}  ${p.name.padEnd(colName)}  ${envNames}`
       );
     }
     console.log("");
   } catch (err) {
-    spinner.fail(import_chalk12.default.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
+    spinner.fail(import_chalk13.default.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
     process.exit(1);
   }
 });
-var projectsCreateCommand = new import_commander11.Command("create").description("Create a new project (without linking the current directory)").argument("<name>", "Project name").option("--git <repo>", "Git repository (e.g. owner/repo)").option("--port <port>", "Application port").action(async (name, opts) => {
+var projectsCreateCommand = new import_commander12.Command("create").description("Create a new project (without linking the current directory)").argument("<name>", "Project name").option("--git <repo>", "Git repository (e.g. owner/repo)").option("--port <port>", "Application port").action(async (name, opts) => {
   requireAuth2();
   const slug = slugify2(name);
-  const spinner = (0, import_ora9.default)(`Creating project ${import_chalk12.default.bold(name)}...`).start();
+  const spinner = (0, import_ora10.default)(`Creating project ${import_chalk13.default.bold(name)}...`).start();
   try {
     const project = await api.createProject({
       name,
@@ -1471,75 +2105,77 @@ var projectsCreateCommand = new import_commander11.Command("create").description
       ...opts.git ? { gitRepository: opts.git } : {},
       ...opts.port ? { port: Number.parseInt(opts.port, 10) } : {}
     });
-    spinner.succeed(import_chalk12.default.green(`\u2713 Created project ${import_chalk12.default.bold(project.name)}`));
+    spinner.succeed(import_chalk13.default.green(`\u2713 Created project ${import_chalk13.default.bold(project.name)}`));
     console.log("");
-    console.log(import_chalk12.default.dim(`  ID   : ${project.id}`));
-    console.log(import_chalk12.default.dim(`  Slug : ${project.slug}`));
+    console.log(import_chalk13.default.dim(`  ID   : ${project.id}`));
+    console.log(import_chalk13.default.dim(`  Slug : ${project.slug}`));
     console.log("");
     console.log(
-      import_chalk12.default.dim(`  Run ${import_chalk12.default.cyan("sylphx link")} to link this project to a directory.`)
+      import_chalk13.default.dim(`  Run ${import_chalk13.default.cyan("sylphx link")} to link this project to a directory.`)
     );
     console.log("");
   } catch (err) {
-    spinner.fail(import_chalk12.default.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
+    spinner.fail(import_chalk13.default.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
     process.exit(1);
   }
 });
-var projectsDeleteCommand = new import_commander11.Command("delete").description("Delete a project").argument("<id>", "Project ID or slug").option("--force", "Skip confirmation prompt").action(async (id, opts) => {
+var projectsDeleteCommand = new import_commander12.Command("delete").description("Delete a project").argument("<id>", "Project ID or slug").option("--force", "Skip confirmation prompt").action(async (id, opts) => {
   requireAuth2();
   if (!opts.force) {
     console.log("");
     console.log(
-      import_chalk12.default.yellow(`  \u26A0  You are about to permanently delete project ${import_chalk12.default.bold(id)}.`)
+      import_chalk13.default.yellow(`  \u26A0  You are about to permanently delete project ${import_chalk13.default.bold(id)}.`)
     );
-    console.log(import_chalk12.default.yellow("     This action cannot be undone."));
+    console.log(import_chalk13.default.yellow("     This action cannot be undone."));
     console.log("");
     const answer = await prompt4("  Type the project ID/slug to confirm");
     if (answer !== id) {
-      console.log(import_chalk12.default.red("Confirmation did not match. Aborted."));
+      console.log(import_chalk13.default.red("Confirmation did not match. Aborted."));
       process.exit(1);
     }
   }
-  const spinner = (0, import_ora9.default)(`Deleting project ${import_chalk12.default.bold(id)}...`).start();
+  const spinner = (0, import_ora10.default)(`Deleting project ${import_chalk13.default.bold(id)}...`).start();
   try {
     await api.deleteProject(id);
-    spinner.succeed(import_chalk12.default.green(`\u2713 Deleted project ${import_chalk12.default.bold(id)}`));
+    spinner.succeed(import_chalk13.default.green(`\u2713 Deleted project ${import_chalk13.default.bold(id)}`));
   } catch (err) {
-    spinner.fail(import_chalk12.default.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
+    spinner.fail(import_chalk13.default.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
     process.exit(1);
   }
 });
-var projectsCommand = new import_commander11.Command("projects").description("Manage Sylphx projects").addCommand(projectsListCommand).addCommand(projectsCreateCommand).addCommand(projectsDeleteCommand);
+var projectsCommand = new import_commander12.Command("projects").description("Manage Sylphx projects").addCommand(projectsListCommand).addCommand(projectsCreateCommand).addCommand(projectsDeleteCommand);
 
-// src/commands/rollback.ts
-var import_chalk13 = __toESM(require("chalk"));
-var import_commander12 = require("commander");
-var import_ora10 = __toESM(require("ora"));
-var rollbackCommand = new import_commander12.Command("rollback").description("Rollback to the previous deployment").option("--env <env>", "Environment (e.g. production, staging)").option("--force", "Skip confirmation prompt").action(async (opts) => {
+// src/commands/promote.ts
+var import_chalk14 = __toESM(require("chalk"));
+var import_commander13 = require("commander");
+var import_ora11 = __toESM(require("ora"));
+var promoteCommand = new import_commander13.Command("promote").description("Promote an environment (e.g. staging \u2192 production)").option("--from <env>", "Source environment (default: staging)", "staging").option("--to <env>", "Target environment (default: production)", "production").option("--force", "Skip confirmation prompt").action(async (opts) => {
   const token = config.getToken();
   if (!token) {
-    console.log(import_chalk13.default.red("Not authenticated. Run `sylphx login` first."));
+    console.log(import_chalk14.default.red("Not authenticated. Run `sylphx login` first."));
     process.exit(1);
   }
   const linked = config.getLinkedApp();
   if (!linked) {
-    console.log(import_chalk13.default.red("No app linked. Run `sylphx link` first."));
+    console.log(import_chalk14.default.red("No app linked. Run `sylphx link` first."));
+    process.exit(1);
+  }
+  if (opts.from === opts.to) {
+    console.log(import_chalk14.default.red("Source and target environments must be different."));
     process.exit(1);
   }
-  const env = opts.env ?? linked.defaultEnv;
   if (!opts.force) {
-    const readline5 = await import("readline");
-    const rl = readline5.createInterface({
-      input: process.stdin,
-      output: process.stdout
-    });
-    await new Promise((resolve, reject) => {
+    const readline9 = await import("readline");
+    const rl = readline9.createInterface({ input: process.stdin, output: process.stdout });
+    await new Promise((resolve) => {
       rl.question(
-        import_chalk13.default.yellow(`  Rollback ${import_chalk13.default.bold(linked.appId)} [${env}]? (y/N) `),
+        import_chalk14.default.yellow(
+          `  Promote ${import_chalk14.default.bold(linked.appId)}: ${import_chalk14.default.cyan(opts.from)} \u2192 ${import_chalk14.default.green(opts.to)}? (y/N) `
+        ),
         (answer) => {
           rl.close();
           if (answer.toLowerCase() !== "y") {
-            console.log(import_chalk13.default.dim("  Cancelled."));
+            console.log(import_chalk14.default.dim("  Cancelled."));
             process.exit(0);
           }
           resolve();
@@ -1547,152 +2183,929 @@ var rollbackCommand = new import_commander12.Command("rollback").description("Ro
       );
     });
   }
-  const spinner = (0, import_ora10.default)(`Rolling back ${linked.appId} [${env}]...`).start();
+  const spinner = (0, import_ora11.default)(`Resolving environments...`).start();
   try {
-    const result = await api.rollback(linked.appId, env);
-    spinner.succeed(import_chalk13.default.green(`\u2713 Rollback initiated: ${result.status}`));
-    if (result.deploymentId) {
-      console.log(import_chalk13.default.dim(`  Deployment ID: ${result.deploymentId}`));
+    const envs = await api.listEnvironments(linked.appId);
+    const sourceEnv = envs.find(
+      (e) => (e.envType ?? e.name ?? "").toLowerCase() === opts.from.toLowerCase()
+    );
+    const targetEnv = envs.find(
+      (e) => (e.envType ?? e.name ?? "").toLowerCase() === opts.to.toLowerCase()
+    );
+    if (!sourceEnv) {
+      spinner.fail(import_chalk14.default.red(`Source environment '${opts.from}' not found.`));
+      console.log(import_chalk14.default.dim(`  Available: ${envs.map((e) => e.envType ?? e.name).join(", ")}`));
+      process.exit(1);
     }
-    if (result.message) {
-      console.log(import_chalk13.default.dim(`  ${result.message}`));
+    if (!targetEnv) {
+      spinner.fail(import_chalk14.default.red(`Target environment '${opts.to}' not found.`));
+      console.log(import_chalk14.default.dim(`  Available: ${envs.map((e) => e.envType ?? e.name).join(", ")}`));
+      process.exit(1);
+    }
+    spinner.text = `Promoting ${opts.from} \u2192 ${opts.to}...`;
+    const result = await api.promoteEnvironment(linked.appId, targetEnv.id, sourceEnv.id);
+    if (result.promoted === 0) {
+      spinner.warn(
+        import_chalk14.default.yellow(
+          `No services promoted from ${import_chalk14.default.bold(opts.from)} \u2014 nothing to push (source may have no deployed image yet)`
+        )
+      );
+    } else {
+      spinner.succeed(
+        import_chalk14.default.green(
+          `\u2713 Promoted ${import_chalk14.default.bold(opts.from)} \u2192 ${import_chalk14.default.bold(opts.to)} (${result.promoted} service${result.promoted !== 1 ? "s" : ""})`
+        )
+      );
+      console.log(
+        import_chalk14.default.dim(`
+  Deployments queued. Run ${import_chalk14.default.cyan("sylphx status")} to monitor.`)
+      );
     }
   } catch (err) {
-    spinner.fail(
-      import_chalk13.default.red(`Rollback failed: ${err instanceof Error ? err.message : String(err)}`)
-    );
+    spinner.fail(import_chalk14.default.red(`Promote failed: ${err instanceof Error ? err.message : String(err)}`));
     process.exit(1);
   }
 });
 
-// src/commands/status.ts
-var import_chalk14 = __toESM(require("chalk"));
-var import_commander13 = require("commander");
-var import_ora11 = __toESM(require("ora"));
-function statusColor(status) {
-  const s = status.toLowerCase();
-  if (s === "running" || s === "active" || s === "healthy" || s === "success") {
-    return import_chalk14.default.green(status);
-  }
-  if (s === "deploying" || s === "building" || s === "pending") {
-    return import_chalk14.default.yellow(status);
-  }
-  if (s === "error" || s === "failed" || s === "stopped") {
-    return import_chalk14.default.red(status);
+// src/commands/resources.ts
+var import_chalk15 = __toESM(require("chalk"));
+var import_commander14 = require("commander");
+var import_ora12 = __toESM(require("ora"));
+function requireLinkedApp4() {
+  const linked = config.getLinkedApp();
+  if (!linked) {
+    console.log(import_chalk15.default.red("No app linked. Run `sylphx link` first."));
+    process.exit(1);
   }
-  return import_chalk14.default.white(status);
+  return linked;
 }
-var statusCommand = new import_commander13.Command("status").description("Show deployment status").option("--env <env>", "Environment (e.g. production, staging)").action(async (opts) => {
+function requireToken2() {
   const token = config.getToken();
   if (!token) {
-    console.log(import_chalk14.default.red("Not authenticated. Run `sylphx login` first."));
+    console.log(import_chalk15.default.red("Not authenticated. Run `sylphx login` first."));
     process.exit(1);
   }
-  const linked = config.getLinkedApp();
-  if (!linked) {
-    console.log(import_chalk14.default.red("No app linked. Run `sylphx link` first."));
+  return token;
+}
+var listCmd2 = new import_commander14.Command("list").description("List managed resources (databases, volumes, storage)").option("--kind <kind>", "Filter by kind: database, volume, storage").action(async (opts) => {
+  requireToken2();
+  const spinner = (0, import_ora12.default)("Fetching resources...").start();
+  try {
+    const resources = await api.listDatabases();
+    spinner.stop();
+    if (resources.length === 0) {
+      console.log(import_chalk15.default.dim(`  No resources found.`));
+      return;
+    }
+    console.log();
+    console.log(
+      `  ${import_chalk15.default.bold("NAME".padEnd(24))}  ${"KIND".padEnd(12)}  ${"STATUS".padEnd(14)}  ID`
+    );
+    console.log(`  ${"\u2500".repeat(72)}`);
+    for (const r of resources) {
+      const statusColor2 = r.status === "ready" ? import_chalk15.default.green((r.status ?? "unknown").padEnd(14)) : import_chalk15.default.yellow((r.status ?? "unknown").padEnd(14));
+      console.log(
+        `  ${import_chalk15.default.cyan(r.name.padEnd(24))}  ${"database".padEnd(12)}  ${statusColor2}  ${import_chalk15.default.dim(r.id)}`
+      );
+    }
+    console.log();
+  } catch (err) {
+    spinner.fail(import_chalk15.default.red(err instanceof Error ? err.message : String(err)));
     process.exit(1);
   }
-  const env = opts.env ?? linked.defaultEnv;
-  const spinner = (0, import_ora11.default)(`Fetching status [${env}]...`).start();
+});
+var getCmd2 = new import_commander14.Command("get").description("Get details of a resource").argument("<id>", "Resource ID").action(async (id) => {
+  requireToken2();
+  const spinner = (0, import_ora12.default)(`Fetching resource ${id}...`).start();
   try {
-    const status = await api.getDeploymentStatus(linked.appId);
+    const r = await api.getDatabase(id);
     spinner.stop();
-    console.log("");
-    console.log(import_chalk14.default.bold("  Deployment Status"));
-    console.log(import_chalk14.default.dim(`  ${"\u2500".repeat(40)}`));
-    console.log("");
-    console.log(`  App:         ${import_chalk14.default.cyan(linked.appId)}`);
-    console.log(`  Environment: ${import_chalk14.default.white(env)}`);
-    console.log(`  Status:      ${statusColor(status.status)}`);
-    if (status.deployedAt) {
-      const date = new Date(status.deployedAt);
-      console.log(`  Deployed:    ${import_chalk14.default.white(date.toLocaleString())}`);
+    console.log();
+    console.log(`  ${import_chalk15.default.bold("Name:")}     ${import_chalk15.default.cyan(r.name)}`);
+    console.log(`  ${import_chalk15.default.bold("ID:")}       ${r.id}`);
+    console.log(
+      `  ${import_chalk15.default.bold("Status:")}   ${r.status === "ready" ? import_chalk15.default.green(r.status) : import_chalk15.default.yellow(r.status ?? "unknown")}`
+    );
+    if (r.tier) console.log(`  ${import_chalk15.default.bold("Tier:")}     ${r.tier}`);
+    if (r.host) console.log(`  ${import_chalk15.default.bold("Host:")}     ${r.host}${r.port ? `:${r.port}` : ""}`);
+    if (r.connectionString) {
+      console.log(`  ${import_chalk15.default.bold("DSN:")}      ${import_chalk15.default.dim(r.connectionString)}`);
     }
-    const envMatch = status.environments?.find((e) => e.envType === env) ?? status.environments?.find((e) => e.envType === "production") ?? status.environments?.[0];
-    const displayUrl = status.url ?? envMatch?.url ?? null;
-    if (displayUrl) {
-      console.log(`  URL:         ${import_chalk14.default.cyan(displayUrl)}`);
+    if (r.env) console.log(`  ${import_chalk15.default.bold("Env:")}      ${r.env}`);
+    console.log();
+  } catch (err) {
+    spinner.fail(import_chalk15.default.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+});
+var bindingsCmd = new import_commander14.Command("bindings").description("List project bindings for a resource").argument("<id>", "Resource ID").action(async (id) => {
+  requireToken2();
+  const spinner = (0, import_ora12.default)(`Fetching bindings for ${id}...`).start();
+  try {
+    const bindings = await api.listResourceBindings(id);
+    spinner.stop();
+    if (bindings.length === 0) {
+      console.log(import_chalk15.default.dim("  No bindings. Use `sylphx resources bind <id>` to link."));
+      return;
     }
-    if (envMatch?.lastDeployedAt) {
+    console.log();
+    console.log(
+      `  ${import_chalk15.default.bold("BINDING ID".padEnd(26))}  ${"PROJECT".padEnd(24)}  ${"ENV".padEnd(12)}  ROLE`
+    );
+    console.log(`  ${"\u2500".repeat(80)}`);
+    for (const b of bindings) {
+      const project = b.projectName ?? b.projectSlug ?? "\u2014";
+      const env = b.envName ?? "\u2014";
       console.log(
-        `  Deployed:    ${import_chalk14.default.white(new Date(envMatch.lastDeployedAt).toLocaleString())}`
+        `  ${import_chalk15.default.dim(b.id.padEnd(26))}  ${project.padEnd(24)}  ${env.padEnd(12)}  ${b.role}`
       );
     }
-    if (status.replicas) {
-      const { ready, desired } = status.replicas;
-      const replicaColor = ready === desired ? import_chalk14.default.green : import_chalk14.default.yellow;
-      console.log(`  Replicas:    ${replicaColor(`${ready}/${desired}`)}`);
-    }
-    console.log("");
+    console.log();
   } catch (err) {
-    spinner.fail(import_chalk14.default.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
+    spinner.fail(import_chalk15.default.red(err instanceof Error ? err.message : String(err)));
     process.exit(1);
   }
 });
-
-// src/commands/unlink.ts
-var import_chalk15 = __toESM(require("chalk"));
-var import_commander14 = require("commander");
-var unlinkCommand = new import_commander14.Command("unlink").description("Unlink current directory from its linked app").action(() => {
+var bindCmd = new import_commander14.Command("bind").description("Bind a resource to this project environment").argument("<id>", "Resource ID (e.g. res_xxx)").option("--env <env>", "Environment (default: production)", "production").option(
+  "--role <role>",
+  "Binding role: primary, replica, analytics, backup (default: primary)",
+  "primary"
+).action(async (id, opts) => {
+  requireToken2();
+  const linked = requireLinkedApp4();
+  const spinner = (0, import_ora12.default)(`Binding resource ${id} to ${linked.appId} [${opts.env}]...`).start();
+  try {
+    const binding = await api.bindResource(id, {
+      projectId: linked.appId,
+      envType: opts.env,
+      role: opts.role
+    });
+    spinner.succeed(import_chalk15.default.green(`\u2713 Resource bound (${binding.role})`));
+    console.log();
+    console.log(`  ${import_chalk15.default.dim("Binding ID:")} ${binding.id}`);
+    console.log(`  ${import_chalk15.default.dim("Env:")}        ${binding.envName ?? opts.env}`);
+    console.log(
+      import_chalk15.default.dim(
+        `
+  Run ${import_chalk15.default.cyan("sylphx deploy")} to apply the connection vars to your deployment.`
+      )
+    );
+  } catch (err) {
+    spinner.fail(import_chalk15.default.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+});
+var unbindCmd = new import_commander14.Command("unbind").description("Remove a resource binding").argument("<id>", "Resource ID").argument("<binding-id>", "Binding ID (from `sylphx resources bindings <id>`)").action(async (id, bindingId) => {
+  requireToken2();
+  const spinner = (0, import_ora12.default)(`Removing binding ${bindingId}...`).start();
+  try {
+    await api.unbindResource(id, bindingId);
+    spinner.succeed(import_chalk15.default.green(`\u2713 Binding removed`));
+  } catch (err) {
+    spinner.fail(import_chalk15.default.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+});
+var resourcesCommand = new import_commander14.Command("resources").description("Manage resources and project bindings").addCommand(listCmd2).addCommand(getCmd2).addCommand(bindingsCmd).addCommand(bindCmd).addCommand(unbindCmd).action(() => resourcesCommand.help());
+
+// src/commands/rollback.ts
+var import_chalk16 = __toESM(require("chalk"));
+var import_commander15 = require("commander");
+var import_ora13 = __toESM(require("ora"));
+var rollbackCommand = new import_commander15.Command("rollback").description("Rollback to the previous deployment").option("--env <env>", "Environment to rollback (e.g. production, staging)").option("--deployment <id>", "Rollback to a specific deployment ID").option("--force", "Skip confirmation prompt").action(async (opts) => {
+  const token = config.getToken();
+  if (!token) {
+    console.log(import_chalk16.default.red("Not authenticated. Run `sylphx login` first."));
+    process.exit(1);
+  }
+  const linked = config.getLinkedApp();
+  if (!linked) {
+    console.log(import_chalk16.default.red("No app linked. Run `sylphx link` first."));
+    process.exit(1);
+  }
+  const envType = opts.env ?? linked.defaultEnv ?? "production";
+  if (!opts.force) {
+    const readline9 = await import("readline");
+    const rl = readline9.createInterface({ input: process.stdin, output: process.stdout });
+    await new Promise((resolve) => {
+      const label = opts.deployment ? `deployment ${import_chalk16.default.bold(opts.deployment)}` : `previous deployment`;
+      rl.question(
+        import_chalk16.default.yellow(`  Rollback ${import_chalk16.default.bold(linked.appId)} [${envType}] to ${label}? (y/N) `),
+        (answer) => {
+          rl.close();
+          if (answer.toLowerCase() !== "y") {
+            console.log(import_chalk16.default.dim("  Cancelled."));
+            process.exit(0);
+          }
+          resolve();
+        }
+      );
+    });
+  }
+  const spinner = (0, import_ora13.default)(`Rolling back ${linked.appId} [${envType}]...`).start();
+  try {
+    let rollbackBody;
+    if (opts.deployment) {
+      rollbackBody = { deploymentRecordId: opts.deployment };
+    } else {
+      const status = await api.getDeploymentStatus(linked.appId);
+      const envEntry = status.environments?.find(
+        (e) => (e.envType ?? "").toLowerCase() === envType.toLowerCase()
+      );
+      if (!envEntry?.envId) {
+        spinner.fail(
+          import_chalk16.default.red(
+            `Could not find environment '${envType}'. Run \`sylphx status\` to see available environments.`
+          )
+        );
+        process.exit(1);
+      }
+      rollbackBody = { envId: envEntry.envId };
+    }
+    const result = await api.rollback(linked.appId, rollbackBody);
+    spinner.succeed(import_chalk16.default.green(`\u2713 Rollback initiated`));
+    if (result.deploymentId) {
+      console.log(import_chalk16.default.dim(`  Deployment ID: ${result.deploymentId}`));
+    }
+    if (result.status) {
+      console.log(import_chalk16.default.dim(`  Status: ${result.status}`));
+    }
+    if (result.message) {
+      console.log(import_chalk16.default.dim(`  ${result.message}`));
+    }
+    console.log(import_chalk16.default.dim(`
+  Run ${import_chalk16.default.cyan("sylphx status")} to monitor progress.`));
+  } catch (err) {
+    spinner.fail(
+      import_chalk16.default.red(`Rollback failed: ${err instanceof Error ? err.message : String(err)}`)
+    );
+    process.exit(1);
+  }
+});
+
+// src/commands/services.ts
+var import_node_readline5 = __toESM(require("readline"));
+var import_chalk17 = __toESM(require("chalk"));
+var import_commander16 = require("commander");
+var import_ora14 = __toESM(require("ora"));
+function requireLinkedApp5() {
+  const linked = config.getLinkedApp();
+  if (!linked) {
+    console.log(import_chalk17.default.red("No app linked. Run `sylphx link` first."));
+    process.exit(1);
+  }
+  return linked;
+}
+function requireToken3() {
+  const token = config.getToken();
+  if (!token) {
+    console.log(import_chalk17.default.red("Not authenticated. Run `sylphx login` first."));
+    process.exit(1);
+  }
+  return token;
+}
+var listCmd3 = new import_commander16.Command("list").description("List all services in this project").action(async () => {
+  requireToken3();
+  const linked = requireLinkedApp5();
+  const spinner = (0, import_ora14.default)("Fetching services...").start();
+  try {
+    const services = await api.listServices(linked.appId);
+    spinner.stop();
+    if (services.length === 0) {
+      console.log(import_chalk17.default.dim("  No services defined."));
+      return;
+    }
+    console.log();
+    console.log(`  ${import_chalk17.default.bold("NAME".padEnd(24))}  ${"REPO".padEnd(36)}  ENVS`);
+    console.log(`  ${"\u2500".repeat(70)}`);
+    for (const svc of services) {
+      const repo = svc.githubRepo ?? import_chalk17.default.dim("\u2014");
+      const envs = svc.environmentCount ?? 0;
+      console.log(`  ${import_chalk17.default.cyan(svc.name.padEnd(24))}  ${repo.padEnd(36)}  ${envs}`);
+    }
+    console.log();
+  } catch (err) {
+    spinner.fail(import_chalk17.default.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+});
+var getCmd3 = new import_commander16.Command("get").description("Show details of a service").argument("<name>", "Service name").action(async (name) => {
+  requireToken3();
+  const linked = requireLinkedApp5();
+  const spinner = (0, import_ora14.default)(`Fetching service '${name}'...`).start();
+  try {
+    const svc = await api.getService(linked.appId, name);
+    spinner.stop();
+    console.log();
+    console.log(`  ${import_chalk17.default.bold("Name:")}           ${import_chalk17.default.cyan(svc.name)}`);
+    console.log(`  ${import_chalk17.default.bold("ID:")}             ${svc.id}`);
+    if (svc.githubRepo) console.log(`  ${import_chalk17.default.bold("Repo:")}           ${svc.githubRepo}`);
+    if (svc.githubBranch) console.log(`  ${import_chalk17.default.bold("Branch:")}         ${svc.githubBranch}`);
+    if (svc.dockerfilePath)
+      console.log(`  ${import_chalk17.default.bold("Dockerfile:")}     ${svc.dockerfilePath}`);
+    if (svc.port) console.log(`  ${import_chalk17.default.bold("Port:")}           ${svc.port}`);
+    if (svc.publicNetworking !== void 0 && svc.publicNetworking !== null)
+      console.log(
+        `  ${import_chalk17.default.bold("Public:")}         ${svc.publicNetworking ? import_chalk17.default.green("yes") : import_chalk17.default.dim("no")}`
+      );
+    console.log();
+  } catch (err) {
+    spinner.fail(import_chalk17.default.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+});
+var deployCmd = new import_commander16.Command("deploy").description("Deploy a specific service").argument("<name>", "Service name").option("--env <env>", "Environment (default: production)", "production").action(async (name, opts) => {
+  requireToken3();
+  const linked = requireLinkedApp5();
+  const spinner = (0, import_ora14.default)(`Deploying service '${name}' [${opts.env}]...`).start();
+  try {
+    const result = await api.deployService(linked.appId, name, opts.env);
+    spinner.succeed(import_chalk17.default.green(`\u2713 Deploy triggered for service '${name}'`));
+    if (result.deploymentId) {
+      console.log(import_chalk17.default.dim(`  Deployment ID: ${result.deploymentId}`));
+    }
+    console.log(import_chalk17.default.dim(`
+  Run ${import_chalk17.default.cyan("sylphx status")} to monitor.`));
+  } catch (err) {
+    spinner.fail(import_chalk17.default.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+});
+var rmCmd2 = new import_commander16.Command("rm").description("Delete a service").argument("<name>", "Service name").option("--force", "Skip confirmation prompt").action(async (name, opts) => {
+  requireToken3();
+  const linked = requireLinkedApp5();
+  if (!opts.force) {
+    const rl = import_node_readline5.default.createInterface({ input: process.stdin, output: process.stdout });
+    await new Promise((resolve) => {
+      rl.question(import_chalk17.default.yellow(`  Delete service ${import_chalk17.default.bold(name)}? (y/N) `), (answer) => {
+        rl.close();
+        if (answer.toLowerCase() !== "y") {
+          console.log(import_chalk17.default.dim("  Cancelled."));
+          process.exit(0);
+        }
+        resolve();
+      });
+    });
+  }
+  const spinner = (0, import_ora14.default)(`Deleting service '${name}'...`).start();
+  try {
+    await api.deleteService(linked.appId, name);
+    spinner.succeed(import_chalk17.default.green(`\u2713 Service '${name}' deleted`));
+  } catch (err) {
+    spinner.fail(import_chalk17.default.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+});
+var servicesCommand = new import_commander16.Command("services").description("Manage project services").addCommand(listCmd3).addCommand(getCmd3).addCommand(deployCmd).addCommand(rmCmd2).action(() => servicesCommand.help());
+
+// src/commands/status.ts
+var import_chalk18 = __toESM(require("chalk"));
+var import_commander17 = require("commander");
+var import_ora15 = __toESM(require("ora"));
+function statusColor(status) {
+  const s = status.toLowerCase();
+  if (s === "running" || s === "active" || s === "healthy" || s === "success") {
+    return import_chalk18.default.green(status);
+  }
+  if (s === "deploying" || s === "building" || s === "pending") {
+    return import_chalk18.default.yellow(status);
+  }
+  if (s === "error" || s === "failed" || s === "stopped") {
+    return import_chalk18.default.red(status);
+  }
+  return import_chalk18.default.white(status);
+}
+var statusCommand = new import_commander17.Command("status").description("Show deployment status").option("--env <env>", "Environment (e.g. production, staging)").action(async (opts) => {
+  const token = config.getToken();
+  if (!token) {
+    console.log(import_chalk18.default.red("Not authenticated. Run `sylphx login` first."));
+    process.exit(1);
+  }
+  const linked = config.getLinkedApp();
+  if (!linked) {
+    console.log(import_chalk18.default.red("No app linked. Run `sylphx link` first."));
+    process.exit(1);
+  }
+  const env = opts.env ?? linked.defaultEnv;
+  const spinner = (0, import_ora15.default)(`Fetching status [${env}]...`).start();
+  try {
+    const status = await api.getDeploymentStatus(linked.appId);
+    spinner.stop();
+    console.log("");
+    console.log(import_chalk18.default.bold("  Deployment Status"));
+    console.log(import_chalk18.default.dim(`  ${"\u2500".repeat(40)}`));
+    console.log("");
+    console.log(`  App:         ${import_chalk18.default.cyan(linked.appId)}`);
+    console.log(`  Environment: ${import_chalk18.default.white(env)}`);
+    console.log(`  Status:      ${statusColor(status.status)}`);
+    if (status.deployedAt) {
+      const date = new Date(status.deployedAt);
+      console.log(`  Deployed:    ${import_chalk18.default.white(date.toLocaleString())}`);
+    }
+    const envMatch = status.environments?.find((e) => e.envType === env) ?? status.environments?.find((e) => e.envType === "production") ?? status.environments?.[0];
+    const displayUrl = status.url ?? envMatch?.url ?? null;
+    if (displayUrl) {
+      console.log(`  URL:         ${import_chalk18.default.cyan(displayUrl)}`);
+    }
+    if (envMatch?.lastDeployedAt) {
+      console.log(
+        `  Deployed:    ${import_chalk18.default.white(new Date(envMatch.lastDeployedAt).toLocaleString())}`
+      );
+    }
+    if (status.replicas) {
+      const { ready, desired } = status.replicas;
+      const replicaColor = ready === desired ? import_chalk18.default.green : import_chalk18.default.yellow;
+      console.log(`  Replicas:    ${replicaColor(`${ready}/${desired}`)}`);
+    }
+    console.log("");
+  } catch (err) {
+    spinner.fail(import_chalk18.default.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
+    process.exit(1);
+  }
+});
+
+// src/commands/storage.ts
+var import_node_readline6 = __toESM(require("readline"));
+var import_chalk19 = __toESM(require("chalk"));
+var import_commander18 = require("commander");
+var import_ora16 = __toESM(require("ora"));
+function requireLinkedApp6() {
+  const linked = config.getLinkedApp();
+  if (!linked) {
+    console.log(import_chalk19.default.red("No app linked. Run `sylphx link` first."));
+    process.exit(1);
+  }
+  return linked;
+}
+function requireToken4() {
+  const token = config.getToken();
+  if (!token) {
+    console.log(import_chalk19.default.red("Not authenticated. Run `sylphx login` first."));
+    process.exit(1);
+  }
+  return token;
+}
+var listCmd4 = new import_commander18.Command("list").description("List storage resources for this project").option("--env <env>", "Environment (default: production)", "production").action(async (opts) => {
+  requireToken4();
+  const linked = requireLinkedApp6();
+  const spinner = (0, import_ora16.default)("Fetching storage resources...").start();
+  try {
+    const resources = await api.listStorage(linked.appId, opts.env);
+    spinner.stop();
+    if (resources.length === 0) {
+      console.log(import_chalk19.default.dim("  No storage resources provisioned."));
+      console.log(
+        import_chalk19.default.dim(`
+  Run ${import_chalk19.default.cyan("sylphx storage create")} to provision storage.`)
+      );
+      return;
+    }
+    console.log();
+    for (const r of resources) {
+      const label = [r.role ?? "primary", r.envType].filter(Boolean).join(" \xB7 ");
+      console.log(`  ${import_chalk19.default.cyan(label)}  ${import_chalk19.default.dim(r.id)}`);
+      if (r.publicUrl) {
+        console.log(`    ${import_chalk19.default.dim("URL:")}    ${import_chalk19.default.cyan(r.publicUrl)}`);
+      }
+      if (r.bucket) {
+        console.log(`    ${import_chalk19.default.dim("Bucket:")} ${r.bucket}`);
+      }
+    }
+    console.log();
+  } catch (err) {
+    spinner.fail(import_chalk19.default.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+});
+var createCmd = new import_commander18.Command("create").description("Provision blob storage for this project").argument("[name]", "Storage resource name (default: primary)", "primary").option("--env <env>", "Environment (default: production)", "production").action(async (name, opts) => {
+  requireToken4();
+  const linked = requireLinkedApp6();
+  const spinner = (0, import_ora16.default)(`Provisioning storage '${name}' [${opts.env}]...`).start();
+  try {
+    const resource = await api.createStorage(linked.appId, { name, envType: opts.env });
+    spinner.succeed(import_chalk19.default.green(`\u2713 Storage '${name}' provisioned`));
+    console.log();
+    console.log(`  ${import_chalk19.default.dim("ID:")}         ${resource.id}`);
+    if (resource.publicUrl) {
+      console.log(`  ${import_chalk19.default.dim("Public URL:")} ${import_chalk19.default.cyan(resource.publicUrl)}`);
+    }
+    if (resource.envVars && Object.keys(resource.envVars).length > 0) {
+      console.log();
+      console.log(import_chalk19.default.bold("  Env vars to add to your project:"));
+      for (const [k, v] of Object.entries(resource.envVars)) {
+        console.log(`    ${import_chalk19.default.cyan(k)}=${v}`);
+      }
+      console.log();
+      console.log(
+        import_chalk19.default.dim(
+          `  Run ${import_chalk19.default.cyan("sylphx env set KEY=VALUE")} to add these to your project.`
+        )
+      );
+    }
+  } catch (err) {
+    spinner.fail(import_chalk19.default.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+});
+var rmCmd3 = new import_commander18.Command("rm").description("Delete a storage resource").argument("<id>", "Storage resource ID").option("--force", "Skip confirmation prompt").action(async (id, opts) => {
+  requireToken4();
+  const linked = requireLinkedApp6();
+  if (!opts.force) {
+    const rl = import_node_readline6.default.createInterface({ input: process.stdin, output: process.stdout });
+    await new Promise((resolve) => {
+      rl.question(
+        import_chalk19.default.yellow(`  \u26A0\uFE0F  Delete storage ${import_chalk19.default.bold(id)}? This is irreversible. (y/N) `),
+        (answer) => {
+          rl.close();
+          if (answer.toLowerCase() !== "y") {
+            console.log(import_chalk19.default.dim("  Cancelled."));
+            process.exit(0);
+          }
+          resolve();
+        }
+      );
+    });
+  }
+  const spinner = (0, import_ora16.default)(`Deleting storage ${id}...`).start();
+  try {
+    await api.deleteStorage(linked.appId, id);
+    spinner.succeed(import_chalk19.default.green(`\u2713 Storage ${id} deleted`));
+  } catch (err) {
+    spinner.fail(import_chalk19.default.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+});
+var storageCommand = new import_commander18.Command("storage").description("Manage blob storage resources").addCommand(listCmd4).addCommand(createCmd).addCommand(rmCmd3).action(() => storageCommand.help());
+
+// src/commands/tasks.ts
+var import_node_readline7 = __toESM(require("readline"));
+var import_chalk20 = __toESM(require("chalk"));
+var import_commander19 = require("commander");
+var import_ora17 = __toESM(require("ora"));
+function requireLinkedApp7() {
+  const linked = config.getLinkedApp();
+  if (!linked) {
+    console.log(import_chalk20.default.red("No app linked. Run `sylphx link` first."));
+    process.exit(1);
+  }
+  return linked;
+}
+function requireToken5() {
+  const token = config.getToken();
+  if (!token) {
+    console.log(import_chalk20.default.red("Not authenticated. Run `sylphx login` first."));
+    process.exit(1);
+  }
+  return token;
+}
+function formatMode(mode) {
+  switch (mode) {
+    case "job":
+      return import_chalk20.default.blue("job");
+    case "cron":
+      return import_chalk20.default.magenta("cron");
+    case "service":
+      return import_chalk20.default.green("service");
+    default:
+      return import_chalk20.default.dim(mode);
+  }
+}
+var listCmd5 = new import_commander19.Command("list").description("List task definitions for this project").option("--env <env>", "Environment (default: production)", "production").action(async (opts) => {
+  requireToken5();
+  const linked = requireLinkedApp7();
+  const spinner = (0, import_ora17.default)("Fetching tasks...").start();
+  try {
+    const tasks = await api.listTasks(linked.appId, opts.env);
+    spinner.stop();
+    if (tasks.length === 0) {
+      console.log(import_chalk20.default.dim(`  No task definitions for [${opts.env}].`));
+      console.log(
+        import_chalk20.default.dim(`
+  Run ${import_chalk20.default.cyan("sylphx tasks create <name>")} to define a task.`)
+      );
+      return;
+    }
+    console.log();
+    console.log(
+      `  ${import_chalk20.default.bold("NAME".padEnd(28))}  ${"MODE".padEnd(10)}  ${"IMAGE / HANDLER".padEnd(40)}  ID`
+    );
+    console.log(`  ${"\u2500".repeat(90)}`);
+    for (const t of tasks) {
+      const label = t.imageRef ?? t.handlerPath ?? import_chalk20.default.dim("\u2014");
+      console.log(
+        `  ${import_chalk20.default.cyan(t.taskName.padEnd(28))}  ${formatMode(t.executionMode ?? "job").padEnd(10)}  ${String(label).padEnd(40)}  ${import_chalk20.default.dim(t.id)}`
+      );
+    }
+    console.log();
+  } catch (err) {
+    spinner.fail(import_chalk20.default.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+});
+var getCmd4 = new import_commander19.Command("get").description("Show details of a task definition").argument("<task-id>", "Task ID (task_xxx)").action(async (taskId) => {
+  requireToken5();
+  const linked = requireLinkedApp7();
+  const spinner = (0, import_ora17.default)(`Fetching task ${taskId}...`).start();
+  try {
+    const t = await api.getTask(linked.appId, taskId);
+    spinner.stop();
+    console.log();
+    console.log(`  ${import_chalk20.default.bold("Name:")}       ${import_chalk20.default.cyan(t.taskName)}`);
+    console.log(`  ${import_chalk20.default.bold("ID:")}         ${t.id}`);
+    console.log(`  ${import_chalk20.default.bold("Mode:")}       ${formatMode(t.executionMode ?? "job")}`);
+    if (t.imageRef) console.log(`  ${import_chalk20.default.bold("Image:")}      ${t.imageRef}`);
+    if (t.handlerPath) console.log(`  ${import_chalk20.default.bold("Handler:")}    ${t.handlerPath}`);
+    if (t.command?.length) console.log(`  ${import_chalk20.default.bold("Command:")}    ${t.command.join(" ")}`);
+    if (t.timeoutSeconds) console.log(`  ${import_chalk20.default.bold("Timeout:")}    ${t.timeoutSeconds}s`);
+    if (t.machineConfig) {
+      const { cpu, memory, gpu } = t.machineConfig;
+      const parts = [cpu && `cpu=${cpu}`, memory && `mem=${memory}`, gpu && `gpu=${gpu}`].filter(Boolean).join("  ");
+      if (parts) console.log(`  ${import_chalk20.default.bold("Resources:")}  ${parts}`);
+    }
+    if (t.retryConfig) {
+      console.log(
+        `  ${import_chalk20.default.bold("Retry:")}      max=${t.retryConfig.maxAttempts ?? 1}, backoff=${t.retryConfig.backoff ?? "fixed"}`
+      );
+    }
+    if (t.volumeMounts?.length) {
+      console.log(`  ${import_chalk20.default.bold("Volumes:")}`);
+      for (const m of t.volumeMounts) {
+        const ro = m.readOnly ? " (ro)" : "";
+        console.log(`    ${m.mountPath}${ro} \u2190 ${m.volumeId}`);
+      }
+    }
+    console.log();
+  } catch (err) {
+    spinner.fail(import_chalk20.default.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+});
+var createCmd2 = new import_commander19.Command("create").description("Create (or upsert) a task definition").argument("<name>", "Task name (unique within the environment)").option("--env <env>", "Environment (default: production)", "production").option("--mode <mode>", "Execution mode: job | cron | service (default: job)", "job").option("--image <ref>", "Docker image reference").option("--handler <path>", "Handler function path (e.g. src/tasks/send-email.ts)").option("--cmd <cmd>", 'Command to run (comma-separated, e.g. "node,dist/worker.js")').option("--timeout <secs>", "Timeout in seconds").option("--cpu <cpu>", "CPU request (e.g. 0.5, 2)").option("--memory <mem>", "Memory request (e.g. 512Mi, 2Gi)").action(
+  async (name, opts) => {
+    requireToken5();
+    const linked = requireLinkedApp7();
+    if (!["job", "cron", "service"].includes(opts.mode)) {
+      console.log(import_chalk20.default.red(`  --mode must be one of: job, cron, service`));
+      process.exit(1);
+    }
+    const spinner = (0, import_ora17.default)(`Creating task '${name}' [${opts.env}]...`).start();
+    try {
+      const task = await api.createTask(linked.appId, {
+        taskName: name,
+        envType: opts.env,
+        executionMode: opts.mode,
+        imageRef: opts.image,
+        handlerPath: opts.handler,
+        command: opts.cmd ? opts.cmd.split(",").map((s) => s.trim()) : void 0,
+        timeoutSeconds: opts.timeout ? Number.parseInt(opts.timeout, 10) : void 0,
+        machineConfig: opts.cpu || opts.memory ? { cpu: opts.cpu, memory: opts.memory } : void 0
+      });
+      spinner.succeed(import_chalk20.default.green(`\u2713 Task '${task.taskName}' created`));
+      console.log();
+      console.log(`  ${import_chalk20.default.dim("ID:")}   ${task.id}`);
+      console.log(`  ${import_chalk20.default.dim("Mode:")} ${task.executionMode}`);
+      if (task.imageRef) console.log(`  ${import_chalk20.default.dim("Image:")} ${task.imageRef}`);
+      console.log();
+    } catch (err) {
+      spinner.fail(import_chalk20.default.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+  }
+);
+var updateCmd = new import_commander19.Command("update").description("Update a task definition").argument("<task-id>", "Task ID (task_xxx)").option("--mode <mode>", "Execution mode: job | cron | service").option("--image <ref>", "Docker image reference").option("--handler <path>", "Handler function path").option("--cmd <cmd>", "Command (comma-separated)").option("--timeout <secs>", "Timeout in seconds").option("--cpu <cpu>", "CPU request").option("--memory <mem>", "Memory request").action(
+  async (taskId, opts) => {
+    requireToken5();
+    const linked = requireLinkedApp7();
+    const patch = {};
+    if (opts.mode) patch.executionMode = opts.mode;
+    if (opts.image) patch.imageRef = opts.image;
+    if (opts.handler) patch.handlerPath = opts.handler;
+    if (opts.cmd) patch.command = opts.cmd.split(",").map((s) => s.trim());
+    if (opts.timeout) patch.timeoutSeconds = Number.parseInt(opts.timeout, 10);
+    if (opts.cpu || opts.memory) patch.machineConfig = { cpu: opts.cpu, memory: opts.memory };
+    if (Object.keys(patch).length === 0) {
+      console.log(import_chalk20.default.yellow("  Nothing to update. Pass at least one option."));
+      process.exit(1);
+    }
+    const spinner = (0, import_ora17.default)(`Updating task ${taskId}...`).start();
+    try {
+      const task = await api.updateTask(linked.appId, taskId, patch);
+      spinner.succeed(import_chalk20.default.green(`\u2713 Task '${task.taskName}' updated`));
+    } catch (err) {
+      spinner.fail(import_chalk20.default.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+  }
+);
+var rmCmd4 = new import_commander19.Command("rm").description("Delete a task definition").argument("<task-id>", "Task ID (task_xxx)").option("--force", "Skip confirmation").action(async (taskId, opts) => {
+  requireToken5();
+  const linked = requireLinkedApp7();
+  if (!opts.force) {
+    const rl = import_node_readline7.default.createInterface({ input: process.stdin, output: process.stdout });
+    await new Promise((resolve) => {
+      rl.question(import_chalk20.default.yellow(`  Delete task ${import_chalk20.default.bold(taskId)}? (y/N) `), (answer) => {
+        rl.close();
+        if (answer.toLowerCase() !== "y") {
+          console.log(import_chalk20.default.dim("  Cancelled."));
+          process.exit(0);
+        }
+        resolve();
+      });
+    });
+  }
+  const spinner = (0, import_ora17.default)(`Deleting task ${taskId}...`).start();
+  try {
+    await api.deleteTask(linked.appId, taskId);
+    spinner.succeed(import_chalk20.default.green(`\u2713 Task ${taskId} deleted`));
+  } catch (err) {
+    spinner.fail(import_chalk20.default.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+});
+var tasksCommand = new import_commander19.Command("tasks").description("Manage task definitions (jobs, crons, services)").addCommand(listCmd5).addCommand(getCmd4).addCommand(createCmd2).addCommand(updateCmd).addCommand(rmCmd4).action(() => tasksCommand.help());
+
+// src/commands/unlink.ts
+var import_chalk21 = __toESM(require("chalk"));
+var import_commander20 = require("commander");
+var unlinkCommand = new import_commander20.Command("unlink").description("Unlink current directory from its linked app").action(() => {
   const linked = config.getLinkedApp();
   if (!linked) {
-    console.log(import_chalk15.default.yellow("  This directory is not linked to any app."));
+    console.log(import_chalk21.default.yellow("  This directory is not linked to any app."));
     process.exit(0);
   }
   const appId = linked.appId;
   config.unlinkApp();
   console.log("");
-  console.log(import_chalk15.default.green(`\u2713 Unlinked from ${import_chalk15.default.bold(appId)}`));
-  console.log(import_chalk15.default.dim(`  Directory: ${process.cwd()}`));
+  console.log(import_chalk21.default.green(`\u2713 Unlinked from ${import_chalk21.default.bold(appId)}`));
+  console.log(import_chalk21.default.dim(`  Directory: ${process.cwd()}`));
   console.log("");
 });
 
+// src/commands/volumes.ts
+var import_node_readline8 = __toESM(require("readline"));
+var import_chalk22 = __toESM(require("chalk"));
+var import_commander21 = require("commander");
+var import_ora18 = __toESM(require("ora"));
+function requireLinkedApp8() {
+  const linked = config.getLinkedApp();
+  if (!linked) {
+    console.log(import_chalk22.default.red("No app linked. Run `sylphx link` first."));
+    process.exit(1);
+  }
+  return linked;
+}
+function requireToken6() {
+  const token = config.getToken();
+  if (!token) {
+    console.log(import_chalk22.default.red("Not authenticated. Run `sylphx login` first."));
+    process.exit(1);
+  }
+  return token;
+}
+var listCmd6 = new import_commander21.Command("list").description("List persistent volumes for this project").action(async () => {
+  requireToken6();
+  const linked = requireLinkedApp8();
+  const spinner = (0, import_ora18.default)("Fetching volumes...").start();
+  try {
+    const volumes = await api.listVolumes(linked.appId);
+    spinner.stop();
+    if (volumes.length === 0) {
+      console.log(import_chalk22.default.dim("  No volumes provisioned."));
+      console.log(
+        import_chalk22.default.dim(`
+  Run ${import_chalk22.default.cyan("sylphx volumes create <name>")} to provision.`)
+      );
+      return;
+    }
+    console.log();
+    console.log(
+      `  ${import_chalk22.default.bold("NAME".padEnd(24))}  ${"SIZE".padEnd(8)}  ${"STATUS".padEnd(14)}  ID`
+    );
+    console.log(`  ${"\u2500".repeat(70)}`);
+    for (const v of volumes) {
+      const statusColor2 = v.status === "ready" ? import_chalk22.default.green((v.status ?? "unknown").padEnd(14)) : import_chalk22.default.yellow((v.status ?? "unknown").padEnd(14));
+      const size = v.sizeGb ? `${v.sizeGb}Gi`.padEnd(8) : "\u2014".padEnd(8);
+      console.log(
+        `  ${import_chalk22.default.cyan(v.name.padEnd(24))}  ${size}  ${statusColor2}  ${import_chalk22.default.dim(v.id)}`
+      );
+    }
+    console.log();
+  } catch (err) {
+    spinner.fail(import_chalk22.default.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+});
+var createCmd3 = new import_commander21.Command("create").description("Provision a persistent volume").argument("<name>", "Volume name").option("--size <gb>", "Size in GiB (default: 10)", "10").option(
+  "--access-mode <mode>",
+  "ReadWriteOnce or ReadWriteMany (default: ReadWriteOnce)",
+  "ReadWriteOnce"
+).option("--mount <path>", "Default mount path (optional)").action(async (name, opts) => {
+  requireToken6();
+  const linked = requireLinkedApp8();
+  const sizeGb = Number.parseInt(opts.size, 10);
+  if (Number.isNaN(sizeGb) || sizeGb < 1) {
+    console.log(import_chalk22.default.red("  --size must be a number >= 1"));
+    process.exit(1);
+  }
+  if (!["ReadWriteOnce", "ReadWriteMany"].includes(opts.accessMode)) {
+    console.log(import_chalk22.default.red("  --access-mode must be ReadWriteOnce or ReadWriteMany"));
+    process.exit(1);
+  }
+  const spinner = (0, import_ora18.default)(`Provisioning volume '${name}' (${sizeGb}Gi)...`).start();
+  try {
+    const result = await api.createVolume(linked.appId, {
+      name,
+      sizeGb,
+      accessMode: opts.accessMode,
+      mountPath: opts.mount
+    });
+    const vol = result.volume;
+    spinner.succeed(import_chalk22.default.green(`\u2713 Volume '${vol.name}' provisioned`));
+    console.log();
+    console.log(`  ${import_chalk22.default.dim("ID:")}     ${vol.id}`);
+    console.log(`  ${import_chalk22.default.dim("Size:")}   ${vol.sizeGb}Gi`);
+    console.log(`  ${import_chalk22.default.dim("Access:")} ${vol.accessMode ?? "ReadWriteOnce"}`);
+    console.log();
+  } catch (err) {
+    spinner.fail(import_chalk22.default.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+});
+var rmCmd5 = new import_commander21.Command("rm").description("Delete a persistent volume").argument("<id>", "Volume ID").option("--force", "Skip confirmation prompt").action(async (id, opts) => {
+  requireToken6();
+  const linked = requireLinkedApp8();
+  if (!opts.force) {
+    const rl = import_node_readline8.default.createInterface({ input: process.stdin, output: process.stdout });
+    await new Promise((resolve) => {
+      rl.question(
+        import_chalk22.default.yellow(`  \u26A0\uFE0F  Delete volume ${import_chalk22.default.bold(id)}? This will destroy all data. (y/N) `),
+        (answer) => {
+          rl.close();
+          if (answer.toLowerCase() !== "y") {
+            console.log(import_chalk22.default.dim("  Cancelled."));
+            process.exit(0);
+          }
+          resolve();
+        }
+      );
+    });
+  }
+  const spinner = (0, import_ora18.default)(`Deleting volume ${id}...`).start();
+  try {
+    await api.deleteVolume(linked.appId, id);
+    spinner.succeed(import_chalk22.default.green(`\u2713 Volume ${id} deleted`));
+  } catch (err) {
+    spinner.fail(import_chalk22.default.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+});
+var volumesCommand = new import_commander21.Command("volumes").description("Manage persistent volumes").addCommand(listCmd6).addCommand(createCmd3).addCommand(rmCmd5).action(() => volumesCommand.help());
+
 // src/commands/whoami.ts
-var import_chalk16 = __toESM(require("chalk"));
-var import_commander15 = require("commander");
-var import_ora12 = __toESM(require("ora"));
-var whoamiCommand = new import_commander15.Command("whoami").description("Show current user, org, and linked app").action(async () => {
+var import_chalk23 = __toESM(require("chalk"));
+var import_commander22 = require("commander");
+var import_ora19 = __toESM(require("ora"));
+var whoamiCommand = new import_commander22.Command("whoami").description("Show current user, org, and linked app").action(async () => {
   const token = config.getToken();
   if (!token) {
-    console.log(import_chalk16.default.red("Not authenticated. Run `sylphx login` first."));
+    console.log(import_chalk23.default.red("Not authenticated. Run `sylphx login` first."));
     process.exit(1);
   }
-  const spinner = (0, import_ora12.default)("Fetching account info...").start();
+  const spinner = (0, import_ora19.default)("Fetching account info...").start();
   try {
     const me = await api.whoami();
     spinner.stop();
     console.log("");
-    console.log(import_chalk16.default.bold("  Account"));
-    console.log(`    User:  ${import_chalk16.default.cyan(me.user.email)}`);
-    console.log(`    Name:  ${import_chalk16.default.white(me.user.name)}`);
-    console.log(`    ID:    ${import_chalk16.default.dim(me.user.id)}`);
+    console.log(import_chalk23.default.bold("  Account"));
+    console.log(`    User:  ${import_chalk23.default.cyan(me.user.email)}`);
+    console.log(`    Name:  ${import_chalk23.default.white(me.user.name)}`);
+    console.log(`    ID:    ${import_chalk23.default.dim(me.user.id)}`);
     if (me.orgs.length > 0) {
       console.log("");
-      console.log(import_chalk16.default.bold("  Organizations"));
+      console.log(import_chalk23.default.bold("  Organizations"));
       for (const org of me.orgs) {
         console.log(
-          `    ${import_chalk16.default.cyan(org.slug)} ${import_chalk16.default.dim(`(${org.name})`)}`
+          `    ${import_chalk23.default.cyan(org.slug)} ${import_chalk23.default.dim(`(${org.name})`)}`
         );
       }
     }
     const linkedApp = config.getLinkedApp();
     if (linkedApp) {
       console.log("");
-      console.log(import_chalk16.default.bold("  Linked App"));
-      console.log(`    App:  ${import_chalk16.default.cyan(linkedApp.appId)}`);
-      console.log(`    Org:  ${import_chalk16.default.white(linkedApp.orgId)}`);
-      console.log(`    Env:  ${import_chalk16.default.white(linkedApp.defaultEnv)}`);
+      console.log(import_chalk23.default.bold("  Linked App"));
+      console.log(`    App:  ${import_chalk23.default.cyan(linkedApp.appId)}`);
+      console.log(`    Org:  ${import_chalk23.default.white(linkedApp.orgId)}`);
+      console.log(`    Env:  ${import_chalk23.default.white(linkedApp.defaultEnv)}`);
     } else {
       console.log("");
       console.log(
-        import_chalk16.default.dim("  No app linked. Run `sylphx link` to link one.")
+        import_chalk23.default.dim("  No app linked. Run `sylphx link` to link one.")
       );
     }
     console.log("");
   } catch (err) {
     spinner.fail(
-      import_chalk16.default.red(
+      import_chalk23.default.red(
         `Failed: ${err instanceof Error ? err.message : String(err)}`
       )
     );
@@ -1701,44 +3114,51 @@ var whoamiCommand = new import_commander15.Command("whoami").description("Show c
 });
 
 // src/index.ts
-var { version } = package_default;
-var program = new import_commander16.Command();
-program.name("sylphx").description(`${import_chalk17.default.bold("Sylphx Platform CLI")} \u2014 deploy and manage your applications`).version(version, "-v, --version", "Print version").helpOption("-h, --help", "Show help").addHelpText(
+var { version: version4 } = package_default;
+var program = new import_commander23.Command();
+program.name("sylphx").description(`${import_chalk24.default.bold("Sylphx Platform CLI")} \u2014 deploy and manage your applications`).version(version4, "-v, --version", "Print version").helpOption("-h, --help", "Show help").addHelpText(
   "after",
   `
-${import_chalk17.default.bold("Examples:")}
-  ${import_chalk17.default.cyan("sylphx login")}                       Authenticate with Sylphx
-  ${import_chalk17.default.cyan("sylphx init my-app")}                 Create and link a new project
-  ${import_chalk17.default.cyan("sylphx link")}                        Link current directory to an app
-  ${import_chalk17.default.cyan("sylphx unlink")}                      Unlink current directory from its app
-  ${import_chalk17.default.cyan("sylphx deploy")}                      Deploy to production
-  ${import_chalk17.default.cyan("sylphx deploy --env staging")}        Deploy to staging
-  ${import_chalk17.default.cyan("sylphx logs -f")}                     Stream live logs
-  ${import_chalk17.default.cyan("sylphx env list")}                    List environment variables
-  ${import_chalk17.default.cyan("sylphx env set PORT=3000")}           Set an env var
-  ${import_chalk17.default.cyan("sylphx env pull --file .env")}        Pull env vars to a local .env file
-  ${import_chalk17.default.cyan("sylphx env push --file .env")}        Push .env to the platform
-  ${import_chalk17.default.cyan("sylphx status")}                      Check deployment status
-  ${import_chalk17.default.cyan("sylphx projects list")}               List all projects
-  ${import_chalk17.default.cyan("sylphx db create my-db")}             Provision a database
-  ${import_chalk17.default.cyan("sylphx db list")}                     List databases
+${import_chalk24.default.bold("Examples:")}
+  ${import_chalk24.default.cyan("sylphx login")}                       Authenticate with Sylphx
+  ${import_chalk24.default.cyan("sylphx init my-app")}                 Create and link a new project
+  ${import_chalk24.default.cyan("sylphx link")}                        Link current directory to an app
+  ${import_chalk24.default.cyan("sylphx deploy")}                      Deploy to production
+  ${import_chalk24.default.cyan("sylphx deploy --env staging")}        Deploy to staging
+  ${import_chalk24.default.cyan("sylphx promote --from staging")}      Promote staging build \u2192 production
+  ${import_chalk24.default.cyan("sylphx rollback")}                    Rollback to previous deployment
+  ${import_chalk24.default.cyan("sylphx logs -f")}                     Stream live logs
+  ${import_chalk24.default.cyan("sylphx status")}                      Check deployment status
+  ${import_chalk24.default.cyan("sylphx env list")}                    List environment variables
+  ${import_chalk24.default.cyan("sylphx env set PORT=3000")}           Set an env var
+  ${import_chalk24.default.cyan("sylphx config list")}                 List remote config keys
+  ${import_chalk24.default.cyan("sylphx config set KEY=value")}        Set a remote config key
+  ${import_chalk24.default.cyan("sylphx db create my-db")}             Provision a PostgreSQL database
+  ${import_chalk24.default.cyan("sylphx storage create")}              Provision blob storage
+  ${import_chalk24.default.cyan("sylphx volumes create data --size 20")}  Provision a persistent volume
+  ${import_chalk24.default.cyan("sylphx services list")}               List project services
+  ${import_chalk24.default.cyan("sylphx services deploy web")}         Deploy a specific service
+  ${import_chalk24.default.cyan("sylphx tasks list")}                  List task definitions
+  ${import_chalk24.default.cyan("sylphx tasks create <name> --image nginx")}  Create a task
+  ${import_chalk24.default.cyan("sylphx resources bind <id>")}         Bind a resource to this project
+  ${import_chalk24.default.cyan("sylphx projects list")}               List all projects
 
-${import_chalk17.default.bold("Documentation:")}
-  ${import_chalk17.default.underline("https://docs.sylphx.com/cli")}
+${import_chalk24.default.bold("Documentation:")}
+  ${import_chalk24.default.underline("https://docs.sylphx.com/cli")}
 `
 );
-program.addCommand(loginCommand).addCommand(logoutCommand).addCommand(whoamiCommand).addCommand(initCommand).addCommand(linkCommand).addCommand(unlinkCommand).addCommand(deployCommand).addCommand(logsCommand).addCommand(envCommand).addCommand(domainsCommand).addCommand(rollbackCommand).addCommand(openCommand).addCommand(statusCommand).addCommand(projectsCommand).addCommand(dbCommand);
+program.addCommand(loginCommand).addCommand(logoutCommand).addCommand(whoamiCommand).addCommand(initCommand).addCommand(linkCommand).addCommand(unlinkCommand).addCommand(projectsCommand).addCommand(deployCommand).addCommand(promoteCommand).addCommand(rollbackCommand).addCommand(statusCommand).addCommand(logsCommand).addCommand(envCommand).addCommand(configCommand).addCommand(dbCommand).addCommand(storageCommand).addCommand(volumesCommand).addCommand(resourcesCommand).addCommand(tasksCommand).addCommand(servicesCommand).addCommand(domainsCommand).addCommand(openCommand);
 program.on("command:*", (operands) => {
-  console.error(import_chalk17.default.red(`
-  Unknown command: ${import_chalk17.default.bold(operands[0] ?? "")}
+  console.error(import_chalk24.default.red(`
+  Unknown command: ${import_chalk24.default.bold(operands[0] ?? "")}
 `));
-  console.log(`  Run ${import_chalk17.default.cyan("sylphx --help")} for usage.
+  console.log(`  Run ${import_chalk24.default.cyan("sylphx --help")} for usage.
 `);
   process.exit(1);
 });
 program.parseAsync(process.argv).catch((err) => {
   const msg = err instanceof Error ? err.message : String(err);
-  console.error(import_chalk17.default.red(`
+  console.error(import_chalk24.default.red(`
   Error: ${msg}
 `));
   process.exit(1);