wispy-cli 1.1.2 → 1.2.2

package/bin/wispy.mjs

@@ -22,6 +22,231 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
 const args = process.argv.slice(2);
 
+// ── status sub-command ────────────────────────────────────────────────────────
+if (args[0] === "status") {
+  const { readFile } = await import("node:fs/promises");
+  const { homedir } = await import("node:os");
+  const { join } = await import("node:path");
+  const { DeployManager } = await import(
+    path.join(__dirname, "..", "core", "deploy.mjs")
+  );
+
+  const remotePath = join(homedir(), ".wispy", "remote.json");
+  let remote = null;
+  try {
+    remote = JSON.parse(await readFile(remotePath, "utf8"));
+  } catch {}
+
+  const bold = (s) => `\x1b[1m${s}\x1b[0m`;
+  const green = (s) => `\x1b[32m${s}\x1b[0m`;
+  const dim = (s) => `\x1b[2m${s}\x1b[0m`;
+  const cyan = (s) => `\x1b[36m${s}\x1b[0m`;
+  const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
+
+  console.log(`\n🌿 ${bold("Wispy Status")}\n`);
+
+  if (remote?.url) {
+    console.log(`  Mode:   ${yellow("remote")}`);
+    console.log(`  Server: ${cyan(remote.url)}`);
+    console.log(`  Token:  ${dim(remote.token ? remote.token.slice(0, 8) + "..." : "none")}`);
+
+    const dm = new DeployManager();
+    process.stdout.write("  Health: checking... ");
+    const status = await dm.checkRemote(remote.url);
+    if (status.alive) {
+      console.log(green("✓ alive"));
+      if (status.version) console.log(`  Version: ${status.version}`);
+      if (status.uptime != null) console.log(`  Uptime:  ${Math.floor(status.uptime)}s`);
+      if (status.latency) console.log(`  Latency: ${status.latency}ms`);
+    } else {
+      console.log(`\x1b[31m✗ unreachable\x1b[0m`);
+      if (status.error) console.log(`  Error:  ${dim(status.error)}`);
+    }
+  } else {
+    console.log(`  Mode:   ${green("local")}`);
+    console.log(`  Server: http://localhost:18790 ${dim("(when running wispy server)")}`);
+    console.log(dim("\n  Tip: use `wispy connect <url> --token <token>` to use a remote server"));
+  }
+  console.log("");
+  process.exit(0);
+}
+
+// ── connect sub-command ───────────────────────────────────────────────────────
+if (args[0] === "connect" && args[1]) {
+  const { writeFile, mkdir } = await import("node:fs/promises");
+  const { homedir } = await import("node:os");
+  const { join } = await import("node:path");
+  const { DeployManager } = await import(
+    path.join(__dirname, "..", "core", "deploy.mjs")
+  );
+
+  const url = args[1].replace(/\/$/, "");
+  const tokenIdx = args.indexOf("--token");
+  const token = tokenIdx !== -1 ? args[tokenIdx + 1] : "";
+
+  const green = (s) => `\x1b[32m${s}\x1b[0m`;
+  const red = (s) => `\x1b[31m${s}\x1b[0m`;
+  const dim = (s) => `\x1b[2m${s}\x1b[0m`;
+
+  process.stdout.write(`\n🔗 Checking ${url}... `);
+  const dm = new DeployManager();
+  const status = await dm.checkRemote(url);
+
+  if (!status.alive) {
+    console.log(red("unreachable"));
+    if (status.error) console.log(dim(`   ${status.error}`));
+    console.log(red("\n❌ Could not connect to remote wispy server."));
+    process.exit(1);
+  }
+
+  console.log(green("✓ alive"));
+
+  const wispyDir = join(homedir(), ".wispy");
+  await mkdir(wispyDir, { recursive: true });
+  await writeFile(
+    join(wispyDir, "remote.json"),
+    JSON.stringify({ url, token, connectedAt: new Date().toISOString() }, null, 2),
+    "utf8"
+  );
+
+  console.log(green(`\n✅ Connected to ${url}`));
+  console.log(dim("   Local wispy will now proxy to the remote server."));
+  console.log(dim("   Run `wispy disconnect` to go back to local mode.\n"));
+  process.exit(0);
+}
+
+// ── disconnect sub-command ────────────────────────────────────────────────────
+if (args[0] === "disconnect") {
+  const { unlink } = await import("node:fs/promises");
+  const { homedir } = await import("node:os");
+  const { join } = await import("node:path");
+
+  const remotePath = join(homedir(), ".wispy", "remote.json");
+  try {
+    await unlink(remotePath);
+    console.log("\n✅ Disconnected. Wispy is back in local mode.\n");
+  } catch {
+    console.log("\n🌿 Already in local mode.\n");
+  }
+  process.exit(0);
+}
+
+// ── deploy sub-command ────────────────────────────────────────────────────────
+if (args[0] === "deploy") {
+  const { DeployManager } = await import(
+    path.join(__dirname, "..", "core", "deploy.mjs")
+  );
+
+  const sub = args[1];
+  const dm = new DeployManager();
+
+  const green = (s) => `\x1b[32m${s}\x1b[0m`;
+  const dim = (s) => `\x1b[2m${s}\x1b[0m`;
+  const bold = (s) => `\x1b[1m${s}\x1b[0m`;
+  const cyan = (s) => `\x1b[36m${s}\x1b[0m`;
+
+  if (sub === "dockerfile") {
+    process.stdout.write(dm.generateDockerfile());
+    process.exit(0);
+  }
+
+  if (sub === "compose") {
+    process.stdout.write(dm.generateDockerCompose());
+    process.exit(0);
+  }
+
+  if (sub === "systemd") {
+    process.stdout.write(dm.generateSystemd());
+    process.exit(0);
+  }
+
+  if (sub === "railway") {
+    process.stdout.write(dm.generateRailwayConfig() + "\n");
+    process.exit(0);
+  }
+
+  if (sub === "fly") {
+    process.stdout.write(dm.generateFlyConfig());
+    process.exit(0);
+  }
+
+  if (sub === "render") {
+    process.stdout.write(dm.generateRenderConfig());
+    process.exit(0);
+  }
+
+  if (sub === "init") {
+    console.log("\n🌿 Initializing wispy deploy configs...\n");
+    const created = await dm.init(process.cwd());
+    for (const f of created) {
+      console.log(`  ${f.includes("skipped") ? "⏭️ " : "✅"} ${f}`);
+    }
+    console.log(dim("\n  Next steps:"));
+    console.log(dim("  1. Copy .env.example → .env and fill in your API keys"));
+    console.log(dim("  2. docker-compose up -d         — for Docker"));
+    console.log(dim("  3. wispy deploy vps user@host   — for raw VPS (no Docker)\n"));
+    process.exit(0);
+  }
+
+  if (sub === "vps" && args[2]) {
+    const target = args[2];
+    const envIdx = args.indexOf("--env");
+    const envFile = envIdx !== -1 ? args[envIdx + 1] : null;
+
+    try {
+      await dm.deployVPS({ target, envFile });
+    } catch (err) {
+      console.error(`\n❌ Deploy failed: ${err.message}`);
+      process.exit(1);
+    }
+    process.exit(0);
+  }
+
+  if (sub === "status" && args[2]) {
+    const url = args[2];
+    process.stdout.write(`\n📡 Checking ${cyan(url)}... `);
+    const status = await dm.checkRemote(url);
+    if (status.alive) {
+      console.log(green("✓ alive"));
+      if (status.version) console.log(`   Version: ${status.version}`);
+      if (status.uptime != null) console.log(`   Uptime:  ${Math.floor(status.uptime)}s`);
+      if (status.latency) console.log(`   Latency: ${status.latency}ms`);
+    } else {
+      console.log(`\x1b[31m✗ unreachable\x1b[0m`);
+      if (status.error) console.log(`   Error: ${dim(status.error)}`);
+    }
+    console.log("");
+    process.exit(0);
+  }
+
+  // Help
+  console.log(`
+🚀 ${bold("Wispy Deploy Commands")}
+
+  ${cyan("Config generators:")}
+  wispy deploy init                    — generate Dockerfile + compose + .env.example
+  wispy deploy dockerfile              — print Dockerfile to stdout
+  wispy deploy compose                 — print docker-compose.yml
+  wispy deploy systemd                 — print systemd unit file
+  wispy deploy railway                 — print railway.json
+  wispy deploy fly                     — print fly.toml
+  wispy deploy render                  — print render.yaml
+
+  ${cyan("Deploy:")}
+  wispy deploy vps user@host           — SSH deploy: install + systemd setup
+  wispy deploy vps user@host --env .env  — include env file
+
+  ${cyan("Status:")}
+  wispy deploy status https://my.vps  — check if remote wispy is alive
+
+  ${cyan("Remote connect:")}
+  wispy connect https://my.vps:18790 --token <token>   — use remote server
+  wispy disconnect                                       — go back to local
+  wispy status                                           — show current mode
+`);
+  process.exit(0);
+}
+
 // ── cron sub-command ──────────────────────────────────────────────────────────
 if (args[0] === "cron") {
   const { WispyEngine, CronManager, WISPY_DIR } = await import(

package/core/deploy.mjs

@@ -0,0 +1,292 @@
+/**
+ * Wispy Deploy Manager
+ * Helpers for deploying wispy server to VPS/cloud platforms.
+ */
+
+import { randomBytes } from "node:crypto";
+import { writeFile, mkdir, access } from "node:fs/promises";
+import { join } from "node:path";
+import { exec as execCb } from "node:child_process";
+import { promisify } from "node:util";
+
+const exec = promisify(execCb);
+
+export class DeployManager {
+  constructor(config = {}) {
+    this.config = config;
+    this.port = config.port ?? 18790;
+    this.appName = config.appName ?? "wispy";
+  }
+
+  // ── Config generators ──────────────────────────────────────────────────────
+
+  generateDockerfile() {
+    return `FROM node:20-slim
+WORKDIR /app
+RUN npm install -g wispy-cli
+ENV WISPY_SERVER_PORT=${this.port}
+ENV WISPY_SERVER_HOST=0.0.0.0
+# User provides API keys via env vars
+EXPOSE ${this.port}
+CMD ["wispy", "server", "--host", "0.0.0.0"]
+`;
+  }
+
+  generateDockerCompose() {
+    return `version: "3.8"
+services:
+  wispy:
+    build: .
+    ports:
+      - "${this.port}:${this.port}"
+    volumes:
+      - wispy-data:/root/.wispy
+    env_file: .env
+    restart: unless-stopped
+volumes:
+  wispy-data:
+`;
+  }
+
+  generateSystemd() {
+    return `[Unit]
+Description=Wispy AI Assistant Server
+After=network.target
+
+[Service]
+Type=simple
+User=wispy
+ExecStart=/usr/bin/npx wispy-cli server --host 0.0.0.0
+Restart=always
+EnvironmentFile=/etc/wispy/env
+
+[Install]
+WantedBy=multi-user.target
+`;
+  }
+
+  generateRailwayConfig() {
+    return JSON.stringify(
+      {
+        build: { builder: "NIXPACKS" },
+        deploy: {
+          startCommand: "npx wispy-cli server --host 0.0.0.0 --port $PORT",
+          healthcheckPath: "/api/status",
+        },
+      },
+      null,
+      2
+    );
+  }
+
+  generateFlyConfig() {
+    const app = this.appName;
+    return `app = "${app}"
+
+[build]
+  image = "node:20-slim"
+
+[deploy]
+  strategy = "immediate"
+
+[[services]]
+  internal_port = ${this.port}
+  protocol = "tcp"
+
+  [[services.ports]]
+    port = 443
+    handlers = ["tls", "http"]
+
+  [[services.ports]]
+    port = 80
+    handlers = ["http"]
+
+  [[services.http_checks]]
+    interval = 10000
+    timeout = 2000
+    grace_period = "5s"
+    method = "get"
+    path = "/api/status"
+`;
+  }
+
+  generateRenderConfig() {
+    return `services:
+  - type: web
+    name: ${this.appName}
+    runtime: node
+    buildCommand: npm install -g wispy-cli
+    startCommand: wispy server --host 0.0.0.0 --port $PORT
+    healthCheckPath: /api/status
+`;
+  }
+
+  generateEnvExample() {
+    const token = randomBytes(24).toString("hex");
+    return `# Wispy Server Configuration
+WISPY_SERVER_TOKEN=${token}
+WISPY_SERVER_PORT=${this.port}
+WISPY_SERVER_HOST=0.0.0.0
+
+# AI Provider (at least one required)
+GOOGLE_AI_KEY=
+ANTHROPIC_API_KEY=
+OPENAI_API_KEY=
+
+# Optional: Channel bots
+WISPY_TELEGRAM_TOKEN=
+WISPY_DISCORD_TOKEN=
+WISPY_SLACK_BOT_TOKEN=
+WISPY_SLACK_APP_TOKEN=
+`;
+  }
+
+  // ── init: write all config files to cwd ───────────────────────────────────
+
+  async init(outputDir = process.cwd()) {
+    const files = {
+      "Dockerfile": this.generateDockerfile(),
+      "docker-compose.yml": this.generateDockerCompose(),
+      ".env.example": this.generateEnvExample(),
+    };
+
+    const created = [];
+    for (const [name, content] of Object.entries(files)) {
+      const dest = join(outputDir, name);
+      // Don't overwrite existing files unless forced
+      let exists = false;
+      try { await access(dest); exists = true; } catch {}
+      if (!exists) {
+        await writeFile(dest, content, "utf8");
+        created.push(name);
+      } else {
+        created.push(`${name} (skipped — already exists)`);
+      }
+    }
+    return created;
+  }
+
+  // ── VPS deploy via SSH ─────────────────────────────────────────────────────
+
+  async deployVPS(opts = {}) {
+    const { target, envFile } = opts;
+    if (!target) throw new Error("target (user@host) is required");
+
+    const ssh = (cmd) => exec(`ssh ${target} '${cmd}'`);
+    const log = (msg) => console.log(msg);
+
+    log(`\n🚀 Deploying wispy to ${target}...\n`);
+
+    // 1. Check Node.js
+    log("  [1/7] Checking Node.js...");
+    try {
+      const { stdout } = await ssh("node --version");
+      log(`        Node.js ${stdout.trim()} ✓`);
+    } catch {
+      log("  ❌ Node.js is not installed on the remote host.");
+      log("     Install with: curl -fsSL https://deb.nodesource.com/setup_20.x | bash - && apt-get install -y nodejs");
+      throw new Error("Node.js not found on remote host");
+    }
+
+    // 2. Install wispy-cli
+    log("  [2/7] Installing wispy-cli...");
+    await ssh("npm install -g wispy-cli 2>&1 | tail -3");
+    log("        wispy-cli installed ✓");
+
+    // 3. Create wispy user if not exists
+    log("  [3/7] Setting up wispy user...");
+    await ssh("id -u wispy >/dev/null 2>&1 || useradd -r -s /bin/false wispy").catch(() => {});
+    log("        wispy user ready ✓");
+
+    // 4. Copy env file
+    log("  [4/7] Copying env file...");
+    await ssh("mkdir -p /etc/wispy");
+    if (envFile) {
+      const { stdout: envContent } = await exec(`cat "${envFile}"`);
+      // Write via ssh heredoc
+      await exec(`ssh ${target} 'cat > /etc/wispy/env' << 'HEREDOC'\n${envContent}\nHEREDOC`);
+      log("        .env copied ✓");
+    } else {
+      log("        No envFile provided — you'll need to manually create /etc/wispy/env");
+    }
+
+    // 5. Install systemd service
+    log("  [5/7] Installing systemd service...");
+    const unit = this.generateSystemd();
+    await exec(`ssh ${target} 'cat > /etc/systemd/system/wispy.service' << 'HEREDOC'\n${unit}\nHEREDOC`);
+    await ssh("systemctl daemon-reload");
+    log("        systemd service installed ✓");
+
+    // 6. Start service
+    log("  [6/7] Starting wispy service...");
+    await ssh("systemctl enable wispy && systemctl restart wispy");
+    log("        service started ✓");
+
+    // 7. Health check
+    log("  [7/7] Verifying...");
+    await new Promise(r => setTimeout(r, 3000));
+    const host = target.includes("@") ? target.split("@")[1] : target;
+    const url = `http://${host}:${this.port}`;
+    try {
+      const status = await this.checkRemote(url);
+      if (status.alive) {
+        log(`\n✅ Wispy is running at ${url}`);
+        log(`   Version: ${status.version ?? "unknown"}`);
+      } else {
+        log(`\n⚠️  Health check failed — check logs with: ssh ${target} 'journalctl -u wispy -n 50'`);
+      }
+    } catch {
+      log(`\n⚠️  Could not verify — check: ssh ${target} 'systemctl status wispy'`);
+    }
+
+    // Print token hint
+    try {
+      const { stdout: envOut } = await ssh("cat /etc/wispy/env 2>/dev/null | grep WISPY_SERVER_TOKEN || echo ''");
+      const tokenLine = envOut.trim();
+      if (tokenLine) {
+        const token = tokenLine.split("=")[1]?.trim();
+        log(`\n🔑 Connect from local:\n   wispy connect ${url} --token ${token}`);
+      }
+    } catch {}
+  }
+
+  // ── Docker build + push ────────────────────────────────────────────────────
+
+  async deployDocker(opts = {}) {
+    const { image = "wispy-cli", registry } = opts;
+    const tag = registry ? `${registry}/${image}:latest` : `${image}:latest`;
+
+    console.log(`\n🐳 Building Docker image: ${tag}\n`);
+    await exec(`docker build -t ${tag} .`);
+    console.log("✅ Image built");
+
+    if (registry) {
+      console.log(`\n📤 Pushing to ${registry}...`);
+      await exec(`docker push ${tag}`);
+      console.log("✅ Pushed");
+    }
+  }
+
+  // ── Remote status check ────────────────────────────────────────────────────
+
+  async checkRemote(url) {
+    const normalizedUrl = url.replace(/\/$/, "");
+    const start = Date.now();
+    try {
+      const resp = await fetch(`${normalizedUrl}/api/status`, {
+        signal: AbortSignal.timeout(5000),
+      });
+      const latency = Date.now() - start;
+      if (!resp.ok) return { alive: false, latency };
+      const data = await resp.json().catch(() => ({}));
+      return {
+        alive: true,
+        version: data.version,
+        uptime: data.uptime,
+        latency,
+      };
+    } catch (err) {
+      return { alive: false, error: err.message };
+    }
+  }
+}