@sylphx/cli 0.1.0

package/README.md

@@ -0,0 +1,136 @@
+# @sylphx/cli
+
+[![npm version](https://img.shields.io/npm/v/@sylphx/cli.svg?style=flat)](https://www.npmjs.com/package/@sylphx/cli)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.0-blue?logo=typescript)](https://www.typescriptlang.org/)
+
+The official CLI tool for the [Sylphx Platform](https://sylphx.com). Deploy, manage logs, environment variables, domains, and more — directly from your terminal.
+
+📖 **Full documentation:** [sylphx.com/docs/cli](https://sylphx.com/docs/cli)
+
+## Installation
+
+```bash
+npm install -g @sylphx/cli
+# or
+bun add -g @sylphx/cli
+```
+
+## Quick Start
+
+```bash
+# Authenticate
+sylphx login
+
+# Link your project to a Sylphx app
+cd my-project
+sylphx link
+
+# Deploy!
+sylphx deploy
+```
+
+## Commands
+
+### Authentication
+
+```bash
+sylphx login                    # Opens browser for OAuth flow
+sylphx login --token <TOKEN>    # Direct token auth (CI/CD)
+sylphx logout                   # Clear stored credentials
+sylphx whoami                   # Show current user + org + app
+```
+
+### Project Management
+
+```bash
+sylphx link                     # Link current directory to a Sylphx app
+sylphx status                   # Show deployment status
+sylphx open                     # Open app in browser
+```
+
+### Deployments
+
+```bash
+sylphx deploy                         # Deploy to default environment
+sylphx deploy --env staging           # Deploy to staging
+sylphx rollback                       # Rollback to previous deployment
+sylphx rollback --env production      # Rollback production
+```
+
+### Logs
+
+```bash
+sylphx logs                           # Show recent logs
+sylphx logs -f                        # Follow logs (stream continuously)
+sylphx logs --env staging             # Logs for staging environment
+```
+
+### Environment Variables
+
+```bash
+sylphx env list                       # List all env vars
+sylphx env list --env staging         # List staging env vars
+sylphx env set DATABASE_URL=postgres://...
+sylphx env set PORT=3000 --env staging
+sylphx env rm DATABASE_URL            # Remove an env var
+```
+
+### Domains
+
+```bash
+sylphx domains list                   # List custom domains
+sylphx domains add example.com        # Add a domain
+sylphx domains rm example.com         # Remove a domain
+```
+
+## Configuration
+
+Config is stored in `~/.sylphx/config.json`:
+
+```json
+{
+  "token": "slx_cli_...",
+  "defaultOrg": "my-org",
+  "apps": {
+    "/path/to/project": {
+      "appId": "app-uuid",
+      "orgId": "org-slug",
+      "defaultEnv": "production"
+    }
+  }
+}
+```
+
+## CI/CD Usage
+
+For automated environments, use a pre-generated token:
+
+```bash
+sylphx login --token $SYLPHX_API_TOKEN
+sylphx deploy --env production
+```
+
+Or set the env var:
+
+```bash
+SYLPHX_API_TOKEN=slx_cli_... sylphx deploy
+```
+
+## Environment Variables
+
+| Variable | Description |
+|---|---|
+| `SYLPHX_API_URL` | Override API base URL (default: `https://sylphx.com`) |
+
+## Development
+
+```bash
+bun install
+bun run dev -- --help     # Run CLI in dev mode
+bun run build             # Build for production
+```
+
+## License
+
+MIT © Sylphx

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,1156 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/index.ts
+var import_chalk13 = __toESM(require("chalk"));
+var import_commander12 = require("commander");
+
+// src/commands/deploy.ts
+var import_chalk2 = __toESM(require("chalk"));
+var import_commander = require("commander");
+var import_ora = __toESM(require("ora"));
+
+// src/config.ts
+var import_node_os = __toESM(require("os"));
+var import_node_path = __toESM(require("path"));
+var import_conf = __toESM(require("conf"));
+var store = new import_conf.default({
+  projectName: "sylphx",
+  projectSuffix: "",
+  cwd: import_node_path.default.join(import_node_os.default.homedir(), ".sylphx"),
+  defaults: {
+    apps: {}
+  },
+  schema: {
+    token: {
+      type: "string"
+    },
+    defaultOrg: {
+      type: "string"
+    },
+    apps: {
+      type: "object"
+    }
+  }
+});
+var config = {
+  /** Get the stored API token */
+  getToken() {
+    return store.get("token");
+  },
+  /** Set the API token */
+  setToken(token) {
+    store.set("token", token);
+  },
+  /** Clear the API token */
+  clearToken() {
+    store.delete("token");
+  },
+  /** Get default org */
+  getDefaultOrg() {
+    return store.get("defaultOrg");
+  },
+  /** Set default org */
+  setDefaultOrg(org) {
+    store.set("defaultOrg", org);
+  },
+  /** Get linked app for a directory */
+  getLinkedApp(dir) {
+    const key = dir ?? process.cwd();
+    const apps = store.get("apps") ?? {};
+    return apps[key];
+  },
+  /** Link an app to a directory */
+  linkApp(link, dir) {
+    const key = dir ?? process.cwd();
+    const apps = store.get("apps") ?? {};
+    apps[key] = link;
+    store.set("apps", apps);
+  },
+  /** Unlink an app from a directory */
+  unlinkApp(dir) {
+    const key = dir ?? process.cwd();
+    const apps = store.get("apps") ?? {};
+    delete apps[key];
+    store.set("apps", apps);
+  },
+  /** Get the config file path */
+  getConfigPath() {
+    return store.path;
+  },
+  /** Clear all config */
+  clear() {
+    store.clear();
+  }
+};
+
+// src/api.ts
+var BASE_URL = process.env.SYLPHX_API_URL ?? "https://sylphx.com";
+var API_BASE = `${BASE_URL}/api/console/v1`;
+var ApiError = class extends Error {
+  constructor(status, message, body) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.name = "ApiError";
+  }
+};
+async function request(method, path3, options) {
+  const token = options?.token ?? config.getToken();
+  if (!token) {
+    throw new ApiError(401, "Not authenticated. Run `sylphx login` first.");
+  }
+  let url = `${API_BASE}${path3}`;
+  if (options?.query) {
+    const params = new URLSearchParams(options.query);
+    url += `?${params.toString()}`;
+  }
+  const headers = {
+    Authorization: `Bearer ${token}`,
+    "Content-Type": "application/json",
+    "User-Agent": "sylphx-cli/0.1.0"
+  };
+  const res = await fetch(url, {
+    method,
+    headers,
+    body: options?.body ? JSON.stringify(options.body) : void 0
+  });
+  if (!res.ok) {
+    let body;
+    try {
+      body = await res.json();
+    } catch {
+      body = await res.text();
+    }
+    const message = typeof body === "object" && body !== null && "message" in body ? String(body.message) : `HTTP ${res.status}`;
+    throw new ApiError(res.status, message, body);
+  }
+  if (res.status === 204) {
+    return void 0;
+  }
+  return res.json();
+}
+var api = {
+  /** Get deployment status for an app */
+  async getDeploymentStatus(appId) {
+    return request("GET", "/deployments/status", {
+      query: { appId }
+    });
+  },
+  /** Trigger a deploy for an environment */
+  async triggerDeploy(envId) {
+    return request("POST", `/deployments/${envId}/deploy`);
+  },
+  /** Get deployment history for an environment */
+  async getDeploymentHistory(envId) {
+    return request("GET", `/deployments/${envId}/history`);
+  },
+  /** Rollback to previous deployment */
+  async rollback(envId) {
+    return request("POST", `/deployments/${envId}/rollback`);
+  },
+  /** List env vars for an environment */
+  async listEnvVars(envId) {
+    return request("GET", `/deployments/${envId}/envvars`);
+  },
+  /** Set an env var */
+  async setEnvVar(envId, key, value) {
+    return request("POST", `/deployments/${envId}/envvars`, {
+      body: { key, value }
+    });
+  },
+  /** Delete an env var */
+  async deleteEnvVar(envId, key) {
+    return request(
+      "DELETE",
+      `/deployments/${envId}/envvars/${encodeURIComponent(key)}`
+    );
+  },
+  /** List domains for an environment */
+  async listDomains(envId) {
+    return request("GET", `/deployments/${envId}/domains`);
+  },
+  /** Add a domain */
+  async addDomain(envId, domain) {
+    return request("POST", `/deployments/${envId}/domains`, {
+      body: { domain }
+    });
+  },
+  /** Remove a domain */
+  async removeDomain(envId, domain) {
+    return request(
+      "DELETE",
+      `/deployments/${envId}/domains/${encodeURIComponent(domain)}`
+    );
+  },
+  /** Get current user and orgs */
+  async whoami() {
+    return request("GET", "/auth/me");
+  },
+  /** List apps for an org */
+  async listApps(orgId) {
+    return request("GET", "/apps", {
+      query: { orgId }
+    });
+  },
+  /** CLI auth: poll for token */
+  async pollCliAuth(code) {
+    const res = await fetch(
+      `${BASE_URL}/api/auth/cli/poll?code=${encodeURIComponent(code)}`,
+      {
+        headers: { "User-Agent": "sylphx-cli/0.1.0" }
+      }
+    );
+    if (!res.ok) {
+      throw new ApiError(res.status, "Failed to poll auth status");
+    }
+    return res.json();
+  }
+};
+function createLogStream(envId) {
+  return {
+    url: `${API_BASE}/deployments/${envId}/logs`,
+    token: config.getToken()
+  };
+}
+
+// src/utils/logs.ts
+var import_chalk = __toESM(require("chalk"));
+function formatLogEntry(raw) {
+  let entry;
+  try {
+    entry = JSON.parse(raw);
+  } catch {
+    return `  ${import_chalk.default.white(raw)}`;
+  }
+  const message = entry.message ?? entry.msg ?? raw;
+  const level = (entry.level ?? "info").toLowerCase();
+  const timestamp = entry.timestamp ?? entry.ts;
+  const prefix = timestamp ? `${import_chalk.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_chalk.default.red("\u2717")} ${import_chalk.default.red(message)}`;
+    case "warn":
+      return `  ${prefix}${import_chalk.default.yellow("\u26A0")} ${import_chalk.default.yellow(message)}`;
+    case "success":
+      return `  ${prefix}${import_chalk.default.green("\u2713")} ${import_chalk.default.green(message)}`;
+    case "debug":
+      return `  ${prefix}${import_chalk.default.dim(message)}`;
+    default:
+      return `  ${prefix}${import_chalk.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"
+    };
+    if (token) {
+      headers.Authorization = `Bearer ${token}`;
+    }
+    const es = new EventSource(url, {
+      fetch: (input, init) => fetch(input, {
+        ...init,
+        headers: {
+          ...typeof init?.headers === "object" ? init.headers : {},
+          ...headers
+        }
+      })
+    });
+    let succeeded = false;
+    let timeout;
+    const finish = (success) => {
+      clearTimeout(timeout);
+      es.close();
+      resolve(success);
+    };
+    if (opts.exitOnDone) {
+      timeout = setTimeout(
+        () => {
+          finish(succeeded);
+        },
+        5 * 60 * 1e3
+      );
+    }
+    es.addEventListener("message", (event) => {
+      const data = String(event.data ?? "");
+      if (!data || data === "ping") return;
+      console.log(formatLogEntry(data));
+      try {
+        const parsed = JSON.parse(data);
+        const status = parsed.status?.toLowerCase() ?? "";
+        const level = parsed.level?.toLowerCase() ?? "";
+        const msg = (parsed.message ?? parsed.msg ?? "").toLowerCase();
+        if (status === "success" || status === "done" || level === "success" || msg.includes("deployment successful") || msg.includes("build complete")) {
+          succeeded = true;
+          if (opts.exitOnDone) {
+            setTimeout(() => finish(true), 500);
+          }
+        } else if (status === "error" || status === "failed" || level === "error" || msg.includes("deployment failed") || msg.includes("build failed")) {
+          succeeded = false;
+          if (opts.exitOnDone) {
+            setTimeout(() => finish(false), 500);
+          }
+        }
+      } catch {
+      }
+    });
+    es.addEventListener("done", () => {
+      if (opts.exitOnDone) {
+        finish(succeeded);
+      }
+    });
+    es.addEventListener("error", (event) => {
+      const errorEvent = event;
+      if (errorEvent.message) {
+        console.log(import_chalk.default.red(`  Stream error: ${errorEvent.message}`));
+      }
+      if (opts.exitOnDone) {
+        finish(succeeded);
+      } else {
+        es.close();
+        resolve(false);
+      }
+    });
+    if (!opts.follow) {
+      timeout = setTimeout(() => finish(succeeded), 1e4);
+    }
+  });
+}
+
+// src/commands/deploy.ts
+var deployCommand = new import_commander.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_chalk2.default.red("Not authenticated. Run `sylphx login` first."));
+    process.exit(1);
+  }
+  const linked = config.getLinkedApp();
+  if (!linked) {
+    console.log(import_chalk2.default.red("No app linked. Run `sylphx link` first."));
+    process.exit(1);
+  }
+  const env = opts.env ?? linked.defaultEnv;
+  console.log("");
+  console.log(
+    import_chalk2.default.bold(
+      `  Deploying ${import_chalk2.default.cyan(linked.appId)} \u2192 ${import_chalk2.default.white(env)}`
+    )
+  );
+  console.log("");
+  const spinner = (0, import_ora.default)("Triggering deployment...").start();
+  let envId;
+  try {
+    envId = linked.appId;
+    const status = await api.getDeploymentStatus(linked.appId);
+    envId = linked.appId;
+    const result = await api.triggerDeploy(linked.appId);
+    spinner.succeed(import_chalk2.default.green(`Deployment triggered: ${result.status}`));
+    if (result.deploymentId) {
+      console.log(import_chalk2.default.dim(`  Deployment ID: ${result.deploymentId}`));
+    }
+  } catch (err) {
+    spinner.fail(
+      import_chalk2.default.red(
+        `Deploy failed: ${err instanceof Error ? err.message : String(err)}`
+      )
+    );
+    process.exit(1);
+  }
+  console.log("");
+  console.log(import_chalk2.default.bold("  Build Logs"));
+  console.log(import_chalk2.default.dim(`  ${"\u2500".repeat(50)}`));
+  console.log("");
+  const logStream = createLogStream(envId);
+  const success = await streamLogs(logStream.url, logStream.token, {
+    follow: true,
+    exitOnDone: true
+  });
+  if (!success) {
+    console.log("");
+    console.log(import_chalk2.default.red("  Deployment failed."));
+    process.exit(1);
+  }
+  console.log("");
+  console.log(import_chalk2.default.green.bold("  \u2713 Deployment successful!"));
+  console.log("");
+});
+
+// src/commands/domains.ts
+var import_chalk3 = __toESM(require("chalk"));
+var import_commander2 = require("commander");
+var import_ora2 = __toESM(require("ora"));
+function requireLinkedApp() {
+  const token = config.getToken();
+  if (!token) {
+    console.log(import_chalk3.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."));
+    process.exit(1);
+  }
+  return linked;
+}
+var domainsListCommand = new import_commander2.Command("list").description("List custom domains").action(async () => {
+  const linked = requireLinkedApp();
+  const envId = linked.appId;
+  const spinner = (0, import_ora2.default)("Fetching domains...").start();
+  try {
+    const domains = await api.listDomains(envId);
+    spinner.stop();
+    if (domains.length === 0) {
+      console.log(import_chalk3.default.dim("\n  No custom domains configured.\n"));
+      return;
+    }
+    console.log("");
+    console.log(import_chalk3.default.bold("  Custom Domains"));
+    console.log(import_chalk3.default.dim(`  ${"\u2500".repeat(50)}`));
+    console.log("");
+    for (const d of domains) {
+      const status = d.status ? import_chalk3.default.dim(` [${d.status}]`) : "";
+      const ssl = d.ssl ? import_chalk3.default.green(" \u{1F512}") : import_chalk3.default.yellow(" \u26A0 no SSL");
+      console.log(`  ${import_chalk3.default.cyan(d.domain)}${status}${ssl}`);
+    }
+    console.log("");
+  } catch (err) {
+    spinner.fail(
+      import_chalk3.default.red(
+        `Failed: ${err instanceof Error ? err.message : String(err)}`
+      )
+    );
+    process.exit(1);
+  }
+});
+var domainsAddCommand = new import_commander2.Command("add").description("Add a custom domain").argument("<domain>", "Domain to add (e.g. example.com)").action(async (domain) => {
+  const linked = requireLinkedApp();
+  const envId = linked.appId;
+  const spinner = (0, import_ora2.default)(`Adding domain ${domain}...`).start();
+  try {
+    const result = await api.addDomain(envId, domain);
+    spinner.succeed(
+      import_chalk3.default.green(`\u2713 Added domain ${import_chalk3.default.bold(result.domain ?? domain)}`)
+    );
+    if (result.status) {
+      console.log(import_chalk3.default.dim(`  Status: ${result.status}`));
+    }
+  } catch (err) {
+    spinner.fail(
+      import_chalk3.default.red(
+        `Failed: ${err instanceof Error ? err.message : String(err)}`
+      )
+    );
+    process.exit(1);
+  }
+});
+var domainsRmCommand = new import_commander2.Command("rm").description("Remove a custom domain").argument("<domain>", "Domain to remove (e.g. example.com)").action(async (domain) => {
+  const linked = requireLinkedApp();
+  const envId = linked.appId;
+  const spinner = (0, import_ora2.default)(`Removing domain ${domain}...`).start();
+  try {
+    await api.removeDomain(envId, domain);
+    spinner.succeed(import_chalk3.default.green(`\u2713 Removed domain ${import_chalk3.default.bold(domain)}`));
+  } catch (err) {
+    spinner.fail(
+      import_chalk3.default.red(
+        `Failed: ${err instanceof Error ? err.message : String(err)}`
+      )
+    );
+    process.exit(1);
+  }
+});
+var domainsCommand = new import_commander2.Command("domains").description("Manage custom domains").addCommand(domainsListCommand).addCommand(domainsAddCommand).addCommand(domainsRmCommand);
+
+// src/commands/env.ts
+var import_chalk4 = __toESM(require("chalk"));
+var import_commander3 = require("commander");
+var import_ora3 = __toESM(require("ora"));
+function requireLinkedApp2() {
+  const token = config.getToken();
+  if (!token) {
+    console.log(import_chalk4.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."));
+    process.exit(1);
+  }
+  return linked;
+}
+var envListCommand = new import_commander3.Command("list").description("List environment variables").option("--env <env>", "Environment (e.g. production, staging)").action(async (opts) => {
+  const linked = requireLinkedApp2();
+  const env = opts.env ?? linked.defaultEnv;
+  const envId = linked.appId;
+  const spinner = (0, import_ora3.default)(`Fetching env vars [${env}]...`).start();
+  try {
+    const vars = await api.listEnvVars(envId);
+    spinner.stop();
+    if (vars.length === 0) {
+      console.log(import_chalk4.default.dim("\n  No environment variables set.\n"));
+      return;
+    }
+    console.log("");
+    console.log(import_chalk4.default.bold(`  Environment Variables [${import_chalk4.default.white(env)}]`));
+    console.log(import_chalk4.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_chalk4.default.cyan(v.key.padEnd(maxKeyLen));
+      const value = v.isSecret ? import_chalk4.default.dim("****** (secret)") : import_chalk4.default.white(v.value);
+      console.log(`  ${key}  ${value}`);
+    }
+    console.log("");
+  } catch (err) {
+    spinner.fail(
+      import_chalk4.default.red(
+        `Failed: ${err instanceof Error ? err.message : String(err)}`
+      )
+    );
+    process.exit(1);
+  }
+});
+var envSetCommand = new import_commander3.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();
+    const env = opts.env ?? linked.defaultEnv;
+    const envId = linked.appId;
+    const eqIdx = assignment.indexOf("=");
+    if (eqIdx < 1) {
+      console.log(
+        import_chalk4.default.red(
+          "Invalid format. Use KEY=VALUE (e.g. sylphx env set DATABASE_URL=postgres://...)"
+        )
+      );
+      process.exit(1);
+    }
+    const key = assignment.slice(0, eqIdx).trim();
+    const value = assignment.slice(eqIdx + 1);
+    if (!key) {
+      console.log(import_chalk4.default.red("Key cannot be empty."));
+      process.exit(1);
+    }
+    const spinner = (0, import_ora3.default)(`Setting ${key} [${env}]...`).start();
+    try {
+      await api.setEnvVar(envId, key, value);
+      spinner.succeed(import_chalk4.default.green(`\u2713 Set ${import_chalk4.default.bold(key)} in ${env}`));
+    } catch (err) {
+      spinner.fail(
+        import_chalk4.default.red(
+          `Failed: ${err instanceof Error ? err.message : String(err)}`
+        )
+      );
+      process.exit(1);
+    }
+  }
+);
+var envRmCommand = new import_commander3.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();
+  const env = opts.env ?? linked.defaultEnv;
+  const envId = linked.appId;
+  const spinner = (0, import_ora3.default)(`Removing ${key} [${env}]...`).start();
+  try {
+    await api.deleteEnvVar(envId, key);
+    spinner.succeed(import_chalk4.default.green(`\u2713 Removed ${import_chalk4.default.bold(key)} from ${env}`));
+  } catch (err) {
+    spinner.fail(
+      import_chalk4.default.red(
+        `Failed: ${err instanceof Error ? err.message : String(err)}`
+      )
+    );
+    process.exit(1);
+  }
+});
+var envCommand = new import_commander3.Command("env").description("Manage environment variables").addCommand(envListCommand).addCommand(envSetCommand).addCommand(envRmCommand);
+
+// src/commands/link.ts
+var import_node_fs = __toESM(require("fs"));
+var import_node_path2 = __toESM(require("path"));
+var import_node_readline = __toESM(require("readline"));
+var import_chalk5 = __toESM(require("chalk"));
+var import_commander4 = require("commander");
+var import_ora4 = __toESM(require("ora"));
+function readPackageName() {
+  try {
+    const pkgPath = import_node_path2.default.join(process.cwd(), "package.json");
+    const pkg = JSON.parse(import_node_fs.default.readFileSync(pkgPath, "utf-8"));
+    return pkg.name;
+  } catch {
+    return void 0;
+  }
+}
+function prompt(question) {
+  return new Promise((resolve) => {
+    const rl = import_node_readline.default.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+var linkCommand = new import_commander4.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_chalk5.default.red("Not authenticated. Run `sylphx login` first."));
+    process.exit(1);
+  }
+  const pkgName = readPackageName();
+  if (pkgName) {
+    console.log(import_chalk5.default.dim(`  Detected package: ${import_chalk5.default.white(pkgName)}`));
+  }
+  let orgId = opts.org ?? config.getDefaultOrg();
+  if (!orgId) {
+    const spinner = (0, import_ora4.default)("Fetching your organizations...").start();
+    let orgs = [];
+    try {
+      const me = await api.whoami();
+      orgs = me.orgs;
+      spinner.stop();
+    } catch (err) {
+      spinner.fail(
+        import_chalk5.default.red(
+          `Failed: ${err instanceof Error ? err.message : String(err)}`
+        )
+      );
+      process.exit(1);
+    }
+    if (orgs.length === 0) {
+      console.log(import_chalk5.default.red("No organizations found."));
+      process.exit(1);
+    }
+    if (orgs.length === 1 && orgs[0]) {
+      orgId = orgs[0].slug;
+      console.log(import_chalk5.default.dim(`  Using org: ${import_chalk5.default.white(orgId)}`));
+    } else {
+      console.log(import_chalk5.default.bold("\n  Your organizations:\n"));
+      orgs.forEach((org, i) => {
+        console.log(
+          `    ${import_chalk5.default.cyan(String(i + 1))}. ${org.slug} ${import_chalk5.default.dim(`(${org.name})`)}`
+        );
+      });
+      console.log("");
+      const choice = await prompt("  Select org (number): ");
+      const idx = Number.parseInt(choice, 10) - 1;
+      if (Number.isNaN(idx) || idx < 0 || idx >= orgs.length || !orgs[idx]) {
+        console.log(import_chalk5.default.red("Invalid selection."));
+        process.exit(1);
+      }
+      orgId = orgs[idx]?.slug;
+    }
+  }
+  const spinner2 = (0, import_ora4.default)(`Fetching apps for org ${orgId}...`).start();
+  let apps = [];
+  try {
+    apps = await api.listApps(orgId);
+    spinner2.stop();
+  } catch (err) {
+    spinner2.fail(
+      import_chalk5.default.red(
+        `Failed: ${err instanceof Error ? err.message : String(err)}`
+      )
+    );
+    process.exit(1);
+  }
+  if (apps.length === 0) {
+    console.log(import_chalk5.default.yellow("No apps found for this org."));
+    process.exit(1);
+  }
+  console.log(import_chalk5.default.bold("\n  Available apps:\n"));
+  apps.forEach((app, i) => {
+    console.log(
+      `    ${import_chalk5.default.cyan(String(i + 1))}. ${app.slug} ${import_chalk5.default.dim(`(${app.name})`)}`
+    );
+  });
+  console.log("");
+  const appChoice = await prompt("  Select app (number): ");
+  const appIdx = Number.parseInt(appChoice, 10) - 1;
+  if (Number.isNaN(appIdx) || appIdx < 0 || appIdx >= apps.length || !apps[appIdx]) {
+    console.log(import_chalk5.default.red("Invalid selection."));
+    process.exit(1);
+  }
+  const selectedApp = apps[appIdx];
+  if (!selectedApp) {
+    console.log(import_chalk5.default.red("Invalid selection."));
+    process.exit(1);
+  }
+  let defaultEnv = "production";
+  const envs = selectedApp.environments ?? [];
+  if (envs.length > 1) {
+    console.log(import_chalk5.default.bold("\n  Available environments:\n"));
+    envs.forEach((env, i) => {
+      console.log(
+        `    ${import_chalk5.default.cyan(String(i + 1))}. ${env.slug} ${import_chalk5.default.dim(`(${env.name})`)}`
+      );
+    });
+    console.log("");
+    const envChoice = await prompt(
+      "  Select default environment (number, or Enter for production): "
+    );
+    if (envChoice) {
+      const envIdx = Number.parseInt(envChoice, 10) - 1;
+      if (!Number.isNaN(envIdx) && envIdx >= 0 && envIdx < envs.length && envs[envIdx]) {
+        defaultEnv = envs[envIdx]?.slug;
+      }
+    }
+  }
+  config.linkApp({
+    appId: selectedApp.id,
+    orgId,
+    defaultEnv
+  });
+  if (orgId) {
+    config.setDefaultOrg(orgId);
+  }
+  console.log("");
+  console.log(import_chalk5.default.green(`\u2713 Linked to ${import_chalk5.default.bold(selectedApp.slug)}`));
+  console.log(
+    import_chalk5.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_chalk6 = __toESM(require("chalk"));
+var import_commander5 = require("commander");
+var import_ora5 = __toESM(require("ora"));
+var BASE_URL2 = process.env.SYLPHX_API_URL ?? "https://sylphx.com";
+var POLL_INTERVAL_MS = 2e3;
+var POLL_TIMEOUT_MS = 5 * 60 * 1e3;
+async function initCode(code) {
+  const res = await fetch(`${BASE_URL2}/api/auth/cli/init`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "User-Agent": "sylphx-cli/0.1.0"
+    },
+    body: JSON.stringify({ code })
+  });
+  if (!res.ok) {
+    throw new Error(`Failed to initialize auth code (HTTP ${res.status})`);
+  }
+}
+var loginCommand = new import_commander5.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_ora5.default)("Validating token...").start();
+    try {
+      config.setToken(opts.token);
+      const me = await api.whoami();
+      config.setToken(opts.token);
+      spinner2.succeed(
+        import_chalk6.default.green(`Authenticated as ${import_chalk6.default.bold(me.user.email)}`)
+      );
+    } catch (err) {
+      config.clearToken();
+      spinner2.fail(import_chalk6.default.red("Invalid token"));
+      process.exit(1);
+    }
+    return;
+  }
+  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_chalk6.default.bold("  Sylphx CLI Authentication"));
+  console.log("");
+  console.log("  Opening browser to:");
+  console.log(`  ${import_chalk6.default.cyan(authUrl)}`);
+  console.log("");
+  console.log(`  One-time code: ${import_chalk6.default.yellow.bold(code)}`);
+  console.log("");
+  try {
+    await initCode(code);
+  } catch (err) {
+    console.log(
+      import_chalk6.default.yellow(
+        `  Warning: Could not register code: ${err instanceof Error ? err.message : String(err)}`
+      )
+    );
+  }
+  try {
+    const { default: open } = await import("open");
+    await open(authUrl);
+  } catch {
+    console.log(
+      import_chalk6.default.dim(
+        "  Could not open browser automatically. Please visit the URL above."
+      )
+    );
+  }
+  const spinner = (0, import_ora5.default)("Waiting for browser authorization...").start();
+  const deadline = Date.now() + POLL_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    await sleep(POLL_INTERVAL_MS);
+    try {
+      const result = await api.pollCliAuth(code);
+      if (result.status === "authorized" && result.token) {
+        config.setToken(result.token);
+        try {
+          const me = await api.whoami();
+          spinner.succeed(
+            import_chalk6.default.green(`Authenticated as ${import_chalk6.default.bold(me.user.email)}`)
+          );
+        } catch {
+          spinner.succeed(import_chalk6.default.green("Authenticated successfully"));
+        }
+        console.log("");
+        console.log(
+          `  Token stored at: ${import_chalk6.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_chalk6.default.red("Code expired or invalid. Please try again."));
+        process.exit(1);
+      }
+    }
+  }
+  spinner.fail(import_chalk6.default.red("Authentication timed out. Please try again."));
+  process.exit(1);
+});
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/commands/logout.ts
+var import_chalk7 = __toESM(require("chalk"));
+var import_commander6 = require("commander");
+var logoutCommand = new import_commander6.Command("logout").description("Clear stored credentials").action(() => {
+  const token = config.getToken();
+  if (!token) {
+    console.log(import_chalk7.default.yellow("You are not currently logged in."));
+    return;
+  }
+  config.clearToken();
+  console.log(import_chalk7.default.green("\u2713 Logged out successfully."));
+  console.log(
+    import_chalk7.default.dim(`  Credentials cleared from ${config.getConfigPath()}`)
+  );
+});
+
+// src/commands/logs.ts
+var import_chalk8 = __toESM(require("chalk"));
+var import_commander7 = require("commander");
+var logsCommand = new import_commander7.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_chalk8.default.red("Not authenticated. Run `sylphx login` first."));
+    process.exit(1);
+  }
+  const linked = config.getLinkedApp();
+  if (!linked) {
+    console.log(import_chalk8.default.red("No app linked. Run `sylphx link` first."));
+    process.exit(1);
+  }
+  const env = opts.env ?? linked.defaultEnv;
+  const envId = linked.appId;
+  console.log("");
+  console.log(
+    import_chalk8.default.bold(
+      `  Logs for ${import_chalk8.default.cyan(linked.appId)} [${import_chalk8.default.white(env)}]${opts.follow ? import_chalk8.default.dim(" (following...)") : ""}`
+    )
+  );
+  console.log(import_chalk8.default.dim(`  ${"\u2500".repeat(50)}`));
+  console.log("");
+  const logStream = createLogStream(envId);
+  await streamLogs(logStream.url, logStream.token, {
+    follow: opts.follow ?? false,
+    exitOnDone: false
+  });
+  if (!opts.follow) {
+    console.log("");
+  }
+});
+
+// src/commands/open.ts
+var import_chalk9 = __toESM(require("chalk"));
+var import_commander8 = require("commander");
+var import_ora6 = __toESM(require("ora"));
+var openCommand = new import_commander8.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_chalk9.default.red("Not authenticated. Run `sylphx login` first."));
+    process.exit(1);
+  }
+  const linked = config.getLinkedApp();
+  if (!linked) {
+    console.log(import_chalk9.default.red("No app linked. Run `sylphx link` first."));
+    process.exit(1);
+  }
+  const spinner = (0, import_ora6.default)("Fetching app URL...").start();
+  let url;
+  try {
+    const status = await api.getDeploymentStatus(linked.appId);
+    spinner.stop();
+    if (!status.url) {
+      url = `https://sylphx.com/console/apps/${linked.appId}`;
+      console.log(import_chalk9.default.yellow("  No URL found, opening console instead."));
+    } else {
+      url = status.url;
+    }
+  } catch {
+    spinner.stop();
+    url = `https://sylphx.com/console/apps/${linked.appId}`;
+  }
+  console.log(`  Opening ${import_chalk9.default.cyan(url)}`);
+  try {
+    const { default: open } = await import("open");
+    await open(url);
+  } catch (err) {
+    console.log(
+      import_chalk9.default.red(
+        `Failed to open browser: ${err instanceof Error ? err.message : String(err)}`
+      )
+    );
+    console.log(import_chalk9.default.dim(`  URL: ${url}`));
+    process.exit(1);
+  }
+});
+
+// src/commands/rollback.ts
+var import_chalk10 = __toESM(require("chalk"));
+var import_commander9 = require("commander");
+var import_ora7 = __toESM(require("ora"));
+var rollbackCommand = new import_commander9.Command("rollback").description("Rollback to the previous deployment").option("--env <env>", "Environment (e.g. production, staging)").option("--force", "Skip confirmation prompt").action(async (opts) => {
+  const token = config.getToken();
+  if (!token) {
+    console.log(import_chalk10.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."));
+    process.exit(1);
+  }
+  const env = opts.env ?? linked.defaultEnv;
+  const envId = linked.appId;
+  if (!opts.force) {
+    const readline2 = await import("readline");
+    const rl = readline2.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    await new Promise((resolve, reject) => {
+      rl.question(
+        import_chalk10.default.yellow(
+          `  Rollback ${import_chalk10.default.bold(linked.appId)} [${env}]? (y/N) `
+        ),
+        (answer) => {
+          rl.close();
+          if (answer.toLowerCase() !== "y") {
+            console.log(import_chalk10.default.dim("  Cancelled."));
+            process.exit(0);
+          }
+          resolve();
+        }
+      );
+    });
+  }
+  const spinner = (0, import_ora7.default)(`Rolling back ${linked.appId} [${env}]...`).start();
+  try {
+    const result = await api.rollback(envId);
+    spinner.succeed(import_chalk10.default.green(`\u2713 Rollback initiated: ${result.status}`));
+    if (result.deploymentId) {
+      console.log(import_chalk10.default.dim(`  Deployment ID: ${result.deploymentId}`));
+    }
+    if (result.message) {
+      console.log(import_chalk10.default.dim(`  ${result.message}`));
+    }
+  } catch (err) {
+    spinner.fail(
+      import_chalk10.default.red(
+        `Rollback failed: ${err instanceof Error ? err.message : String(err)}`
+      )
+    );
+    process.exit(1);
+  }
+});
+
+// src/commands/status.ts
+var import_chalk11 = __toESM(require("chalk"));
+var import_commander10 = require("commander");
+var import_ora8 = __toESM(require("ora"));
+function statusColor(status) {
+  const s = status.toLowerCase();
+  if (s === "running" || s === "active" || s === "healthy" || s === "success") {
+    return import_chalk11.default.green(status);
+  }
+  if (s === "deploying" || s === "building" || s === "pending") {
+    return import_chalk11.default.yellow(status);
+  }
+  if (s === "error" || s === "failed" || s === "stopped") {
+    return import_chalk11.default.red(status);
+  }
+  return import_chalk11.default.white(status);
+}
+var statusCommand = new import_commander10.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_chalk11.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."));
+    process.exit(1);
+  }
+  const env = opts.env ?? linked.defaultEnv;
+  const spinner = (0, import_ora8.default)(`Fetching status [${env}]...`).start();
+  try {
+    const status = await api.getDeploymentStatus(linked.appId);
+    spinner.stop();
+    console.log("");
+    console.log(import_chalk11.default.bold("  Deployment Status"));
+    console.log(import_chalk11.default.dim(`  ${"\u2500".repeat(40)}`));
+    console.log("");
+    console.log(`  App:         ${import_chalk11.default.cyan(linked.appId)}`);
+    console.log(`  Environment: ${import_chalk11.default.white(env)}`);
+    console.log(`  Status:      ${statusColor(status.status)}`);
+    if (status.deployedAt) {
+      const date = new Date(status.deployedAt);
+      console.log(`  Deployed:    ${import_chalk11.default.white(date.toLocaleString())}`);
+    }
+    if (status.url) {
+      console.log(`  URL:         ${import_chalk11.default.cyan(status.url)}`);
+    }
+    console.log("");
+  } catch (err) {
+    spinner.fail(
+      import_chalk11.default.red(
+        `Failed: ${err instanceof Error ? err.message : String(err)}`
+      )
+    );
+    process.exit(1);
+  }
+});
+
+// src/commands/whoami.ts
+var import_chalk12 = __toESM(require("chalk"));
+var import_commander11 = require("commander");
+var import_ora9 = __toESM(require("ora"));
+var whoamiCommand = new import_commander11.Command("whoami").description("Show current user, org, and linked app").action(async () => {
+  const token = config.getToken();
+  if (!token) {
+    console.log(import_chalk12.default.red("Not authenticated. Run `sylphx login` first."));
+    process.exit(1);
+  }
+  const spinner = (0, import_ora9.default)("Fetching account info...").start();
+  try {
+    const me = await api.whoami();
+    spinner.stop();
+    console.log("");
+    console.log(import_chalk12.default.bold("  Account"));
+    console.log(`    User:  ${import_chalk12.default.cyan(me.user.email)}`);
+    console.log(`    Name:  ${import_chalk12.default.white(me.user.name)}`);
+    console.log(`    ID:    ${import_chalk12.default.dim(me.user.id)}`);
+    if (me.orgs.length > 0) {
+      console.log("");
+      console.log(import_chalk12.default.bold("  Organizations"));
+      for (const org of me.orgs) {
+        console.log(
+          `    ${import_chalk12.default.cyan(org.slug)} ${import_chalk12.default.dim(`(${org.name})`)}`
+        );
+      }
+    }
+    const linkedApp = config.getLinkedApp();
+    if (linkedApp) {
+      console.log("");
+      console.log(import_chalk12.default.bold("  Linked App"));
+      console.log(`    App:  ${import_chalk12.default.cyan(linkedApp.appId)}`);
+      console.log(`    Org:  ${import_chalk12.default.white(linkedApp.orgId)}`);
+      console.log(`    Env:  ${import_chalk12.default.white(linkedApp.defaultEnv)}`);
+    } else {
+      console.log("");
+      console.log(
+        import_chalk12.default.dim("  No app linked. Run `sylphx link` to link one.")
+      );
+    }
+    console.log("");
+  } catch (err) {
+    spinner.fail(
+      import_chalk12.default.red(
+        `Failed: ${err instanceof Error ? err.message : String(err)}`
+      )
+    );
+    process.exit(1);
+  }
+});
+
+// src/index.ts
+var program = new import_commander12.Command();
+program.name("sylphx").description(
+  `${import_chalk13.default.bold("Sylphx Platform CLI")} \u2014 deploy and manage your applications`
+).version("0.1.0", "-v, --version", "Print version").helpOption("-h, --help", "Show help").addHelpText(
+  "after",
+  `
+${import_chalk13.default.bold("Examples:")}
+  ${import_chalk13.default.cyan("sylphx login")}                    Authenticate with Sylphx
+  ${import_chalk13.default.cyan("sylphx link")}                     Link current project to an app
+  ${import_chalk13.default.cyan("sylphx deploy")}                   Deploy to production
+  ${import_chalk13.default.cyan("sylphx deploy --env staging")}     Deploy to staging
+  ${import_chalk13.default.cyan("sylphx logs -f")}                  Stream live logs
+  ${import_chalk13.default.cyan("sylphx env list")}                 List environment variables
+  ${import_chalk13.default.cyan("sylphx env set PORT=3000")}        Set an env var
+  ${import_chalk13.default.cyan("sylphx status")}                   Check deployment status
+
+${import_chalk13.default.bold("Documentation:")}
+  ${import_chalk13.default.underline("https://docs.sylphx.com/cli")}
+`
+);
+program.addCommand(loginCommand).addCommand(logoutCommand).addCommand(whoamiCommand).addCommand(linkCommand).addCommand(deployCommand).addCommand(logsCommand).addCommand(envCommand).addCommand(domainsCommand).addCommand(rollbackCommand).addCommand(openCommand).addCommand(statusCommand);
+program.on("command:*", (operands) => {
+  console.error(
+    import_chalk13.default.red(`
+  Unknown command: ${import_chalk13.default.bold(operands[0] ?? "")}
+`)
+  );
+  console.log(`  Run ${import_chalk13.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_chalk13.default.red(`
+  Error: ${msg}
+`));
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,44 @@
+{
+	"name": "@sylphx/cli",
+	"version": "0.1.0",
+	"description": "Sylphx Platform CLI — deploy, manage logs, env vars, and more",
+	"type": "commonjs",
+	"bin": {
+		"sylphx": "./dist/index.js"
+	},
+	"scripts": {
+		"build": "tsup src/index.ts --format cjs --dts",
+		"dev": "tsx src/index.ts",
+		"typecheck": "tsc --noEmit",
+		"test": "vitest run",
+		"test:watch": "vitest",
+		"test:coverage": "vitest run --coverage",
+		"clean": "rm -rf dist",
+		"prepublishOnly": "tsup src/index.ts --format cjs --dts"
+	},
+	"files": [
+		"dist",
+		"README.md"
+	],
+	"publishConfig": {
+		"access": "public",
+		"registry": "https://registry.npmjs.org/"
+	},
+	"dependencies": {
+		"chalk": "^5.3.0",
+		"commander": "^12.1.0",
+		"conf": "^13.0.0",
+		"eventsource": "^2.0.2",
+		"open": "^10.1.0",
+		"ora": "^8.1.0"
+	},
+	"devDependencies": {
+		"@types/eventsource": "^1.1.15",
+		"@types/node": "^22.0.0",
+		"@vitest/coverage-v8": "^2.0.0",
+		"tsup": "^8.3.0",
+		"tsx": "^4.19.0",
+		"typescript": "^5.7.0",
+		"vitest": "^2.0.0"
+	}
+}