selfnify-host 0.0.0-stage → 1.0.0

package/host.js

@@ -0,0 +1,872 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const http = require('http');
+const https = require('https');
+const crypto = require('crypto');
+const readline = require('readline');
+
+const VERSION = '1.0.0';
+const DEFAULT_URL = 'https://host.lume.dpdns.org';
+const CONFIG_DIR = path.join(os.homedir(), '.selfnify');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'host.json');
+const EXCLUDE_DIRS = new Set(['.git', 'node_modules', '.venv', 'venv', 'target', '__pycache__', '.idea', '.vscode']);
+const EXCLUDE_FILES = new Set(['.env', '.DS_Store']);
+const MAX_UPLOAD_MB = 95;
+const NAME_RE = /^[a-z0-9][a-z0-9_-]{0,31}$/;
+const COMMANDS = new Set([
+  'start', 'stop', 'restart', 'delete', 'status', 'list', 'logs', 'env', 'config',
+  'deploy', 'login', 'logout', 'pin', 'help', 'version',
+]);
+
+const VALUE_FLAGS = { '--mem': 'mem', '--env': 'env', '-n': 'lines', '--lines': 'lines', '--server': 'server' };
+const BOOL_FLAGS = {
+  '--autostart': 'autostart',
+  '--no-autostart': 'no-autostart',
+  '--no-install': 'no-install',
+  '--dry-run': 'dry-run',
+  '-v': 'verbose',
+  '--verbose': 'verbose',
+  '--no-color': 'no-color',
+  '-f': 'follow',
+  '--follow': 'follow',
+  '--install': 'install',
+  '-h': 'help',
+  '--help': 'help',
+};
+
+// ------------------------------------------------------------------ output
+
+const state = { verbose: false, color: Boolean(process.stdout.isTTY) && !process.env.NO_COLOR };
+const paint = (code) => (s) => (state.color ? '\x1b[' + code + 'm' + s + '\x1b[0m' : String(s));
+const c = { dim: paint('2'), red: paint('31'), green: paint('32'), yellow: paint('33'), cyan: paint('36'), bold: paint('1') };
+const out = (s) => process.stdout.write((s === undefined ? '' : s) + '\n');
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+class CliError extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+  }
+}
+
+// One line per step: "[2/6] Packing files      ok  42 files, 1.2 MB"
+async function step(n, total, label, fn) {
+  const tag = n ? c.dim('[' + n + '/' + total + ']') + ' ' : '';
+  const prefix = '  ' + tag + label.padEnd(26);
+  const live = Boolean(process.stdout.isTTY);
+  const show = (text) => {
+    if (live) process.stdout.write('\r\x1b[K' + prefix + text);
+  };
+  show(c.dim('...'));
+  try {
+    const detail = await fn({ progress: (text) => show(c.dim(text)) });
+    const line = prefix + c.green('ok') + (detail ? '  ' + c.dim(detail) : '');
+    process.stdout.write((live ? '\r\x1b[K' : '') + line + '\n');
+    return detail;
+  } catch (e) {
+    process.stdout.write((live ? '\r\x1b[K' : '') + prefix + c.red('failed') + '\n');
+    throw e;
+  }
+}
+
+function table(headers, rows) {
+  const widths = headers.map((h, i) => Math.max(h.length, ...rows.map((r) => String(r[i]).length)));
+  const fmt = (r) => '  ' + r.map((cell, i) => String(cell).padEnd(widths[i])).join('  ');
+  out(c.dim(fmt(headers)));
+  rows.forEach((r) => out(fmt(r)));
+}
+
+// ------------------------------------------------------------ config + pin
+
+function loadConfig() {
+  try {
+    return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+  } catch (e) {
+    return {};
+  }
+}
+
+function saveConfig(cfg) {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(cfg, null, 2), { mode: 0o600 });
+  try {
+    fs.chmodSync(CONFIG_FILE, 0o600);
+  } catch (e) {
+    /* windows */
+  }
+}
+
+function normalizeUrl(url) {
+  let u = String(url).trim().replace(/\/+$/, '');
+  if (!/^https?:\/\//.test(u)) u = 'https://' + u;
+  return u;
+}
+
+const hostOf = (url) => {
+  try {
+    return new URL(url).host;
+  } catch (e) {
+    return url;
+  }
+};
+
+function hashPin(pin, salt) {
+  return crypto.scryptSync(pin, salt, 32).toString('hex');
+}
+
+function makePin(pin) {
+  const salt = crypto.randomBytes(16).toString('hex');
+  return { salt, hash: hashPin(pin, salt) };
+}
+
+function checkPin(rec, pin) {
+  if (!rec) return false;
+  const a = Buffer.from(hashPin(pin, rec.salt), 'hex');
+  const b = Buffer.from(rec.hash, 'hex');
+  return a.length === b.length && crypto.timingSafeEqual(a, b);
+}
+
+// ----------------------------------------------------------------- prompts
+
+function ask(question) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    let answered = false;
+    rl.on('close', () => {
+      if (!answered) resolve('');
+    });
+    rl.question(question, (answer) => {
+      answered = true;
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+function askHidden(question) {
+  if (!process.stdin.isTTY) return ask(question);
+  return new Promise((resolve) => {
+    const stdin = process.stdin;
+    let buf = '';
+    process.stdout.write(question);
+    const finish = (value) => {
+      stdin.setRawMode(false);
+      stdin.removeListener('data', onData);
+      stdin.pause();
+      process.stdout.write('\n');
+      resolve(value);
+    };
+    const onData = (chunk) => {
+      for (const ch of chunk.toString('utf8')) {
+        if (ch === '\r' || ch === '\n') return finish(buf.trim());
+        if (ch === '\u0003') {
+          stdin.setRawMode(false);
+          process.stdout.write('\n');
+          process.exit(130);
+        }
+        if (ch === '\u007f' || ch === '\b') buf = buf.slice(0, -1);
+        else if (ch >= ' ') buf += ch;
+      }
+      return undefined;
+    };
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.on('data', onData);
+  });
+}
+
+async function requirePin(cfg, action) {
+  if (!cfg.pin) throw new CliError('no PIN set yet. Run: host login');
+  for (let i = 0; i < 3; i++) {
+    const pin = await askHidden('  PIN to ' + action + ': ');
+    if (checkPin(cfg.pin, pin)) return;
+    out(c.red('  wrong PIN') + c.dim(' (' + (2 - i) + ' tries left)'));
+  }
+  throw new CliError('too many wrong PINs');
+}
+
+async function chooseNewPin() {
+  for (let i = 0; i < 5; i++) {
+    const p1 = await askHidden('  Choose a PIN (4-8 digits): ');
+    if (!/^\d{4,8}$/.test(p1)) {
+      out(c.yellow('  PIN must be 4 to 8 digits'));
+      continue;
+    }
+    const p2 = await askHidden('  Repeat PIN: ');
+    if (p1 !== p2) {
+      out(c.yellow("  PINs didn't match"));
+      continue;
+    }
+    return p1;
+  }
+  throw new CliError('could not set a PIN');
+}
+
+// --------------------------------------------------------------------- api
+
+function request(method, apiPath, opts) {
+  const o = opts || {};
+  const cfg = o.cfg || loadConfig();
+  if (!cfg.password) return Promise.reject(new CliError('not logged in. Run: host login'));
+  const url = new URL((cfg.url || DEFAULT_URL) + apiPath);
+  const lib = url.protocol === 'http:' ? http : https;
+  const headers = { Authorization: 'Bearer ' + cfg.password, 'User-Agent': 'selfnify-host/' + VERSION };
+  let payload = null;
+  if (o.raw) {
+    payload = o.raw;
+    headers['Content-Type'] = 'application/gzip';
+  } else if (o.body !== undefined) {
+    payload = Buffer.from(JSON.stringify(o.body));
+    headers['Content-Type'] = 'application/json';
+  }
+  if (payload) headers['Content-Length'] = payload.length;
+  if (state.verbose) out(c.dim('  -> ' + method + ' ' + apiPath));
+  return new Promise((resolve, reject) => {
+    const req = lib.request(url, { method, headers }, (res) => {
+      const chunks = [];
+      res.on('data', (d) => chunks.push(d));
+      res.on('end', () => {
+        const text = Buffer.concat(chunks).toString('utf8');
+        let data = null;
+        try {
+          data = JSON.parse(text);
+        } catch (e) {
+          /* not json */
+        }
+        if (state.verbose) out(c.dim('  <- ' + res.statusCode));
+        if (res.statusCode >= 200 && res.statusCode < 300 && data) return resolve(data);
+        let msg = (data && data.error) || 'HTTP ' + res.statusCode;
+        if (!data && text.includes('1010')) msg = 'blocked by Cloudflare (error 1010), tell the host admin';
+        else if (!data && res.statusCode === 502) msg = 'server is not answering (is the service running?)';
+        if (res.statusCode === 401) msg += ' (run: host login)';
+        return reject(new CliError(msg, res.statusCode));
+      });
+    });
+    req.setTimeout(o.timeout || 120000, () => req.destroy(new Error('request timed out')));
+    req.on('error', (e) => reject(new CliError("can't reach the server (" + e.message + ')')));
+    if (payload) req.write(payload);
+    req.end();
+  });
+}
+
+const bp = (name, sub) => '/bots/' + encodeURIComponent(name) + (sub || '');
+
+// ----------------------------------------------------------------- helpers
+
+function parseArgs(argv) {
+  const flags = {};
+  const pos = [];
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (VALUE_FLAGS[a]) {
+      if (i + 1 >= argv.length) throw new CliError(a + ' needs a value');
+      i += 1;
+      flags[VALUE_FLAGS[a]] = argv[i];
+    } else if (BOOL_FLAGS[a]) {
+      flags[BOOL_FLAGS[a]] = true;
+    } else if (a.startsWith('--') && a.includes('=')) {
+      const parts = a.slice(2).split('=');
+      flags[parts[0]] = parts.slice(1).join('=');
+    } else if (a.startsWith('-') && a.length > 1 && !/^-\d/.test(a)) {
+      throw new CliError('unknown flag ' + a + '. Try: host help');
+    } else {
+      pos.push(a);
+    }
+  }
+  return { flags, pos };
+}
+
+function requireName(name, usage) {
+  if (!name) throw new CliError('which bot? usage: ' + usage);
+  return name;
+}
+
+function parseEnvFile(file) {
+  let text;
+  try {
+    text = fs.readFileSync(file, 'utf8');
+  } catch (e) {
+    throw new CliError("can't read " + file + ' (' + e.message + ')');
+  }
+  const pairs = {};
+  text.split(/\r?\n/).forEach((raw) => {
+    let line = raw.trim();
+    if (!line || line.startsWith('#') || !line.includes('=')) return;
+    if (line.startsWith('export ')) line = line.slice(7);
+    const idx = line.indexOf('=');
+    const key = line.slice(0, idx).trim();
+    let value = line.slice(idx + 1).trim();
+    if (value.length >= 2 && value[0] === value[value.length - 1] && '"\''.includes(value[0])) {
+      value = value.slice(1, -1);
+    }
+    pairs[key] = value;
+  });
+  return pairs;
+}
+
+function parseStart(str) {
+  const tokens = String(str).trim().split(/\s+/);
+  const cmd = tokens[0].toLowerCase().replace(/\.exe$/, '');
+  let lang = null;
+  if (['python', 'python3', 'py'].includes(cmd)) lang = 'python';
+  else if (['node', 'nodejs'].includes(cmd)) lang = 'node';
+  else if (['cargo', 'rust'].includes(cmd)) lang = 'rust';
+  if (!lang) throw new CliError('don\'t know how to run "' + str + '". Use: python, node or cargo');
+  return { lang, entry: tokens[1] || null };
+}
+
+function detectStart(dir) {
+  const has = (f) => fs.existsSync(path.join(dir, f));
+  if (has('Cargo.toml')) return 'cargo';
+  if (has('package.json')) return 'node';
+  if (has('requirements.txt') || has('main.py') || has('bot.py')) return 'python';
+  return null;
+}
+
+function nodeMain(dir) {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf8'));
+    if (pkg.main) return pkg.main;
+  } catch (e) {
+    /* no package.json */
+  }
+  return 'index.js';
+}
+
+const defaultEntry = (lang) => ({ python: 'main.py', node: 'index.js', rust: '' }[lang]);
+const sanitizeName = (s) => s.toLowerCase().replace(/[^a-z0-9_-]/g, '-').replace(/^[-_]+/, '').slice(0, 32);
+
+async function packDir(dir) {
+  const tar = require('tar');
+  const entries = fs.readdirSync(dir).filter((n) => !EXCLUDE_DIRS.has(n) && !EXCLUDE_FILES.has(n));
+  if (entries.length === 0) throw new CliError('nothing to upload in ' + dir);
+  const files = [];
+  const filter = (p, stat) => {
+    const parts = String(p).split(/[\\/]/);
+    if (parts.some((s) => EXCLUDE_DIRS.has(s))) return false;
+    const base = parts[parts.length - 1];
+    if (EXCLUDE_FILES.has(base) || base.endsWith('.pyc')) return false;
+    if (stat && typeof stat.isSymbolicLink === 'function' && stat.isSymbolicLink()) return false;
+    if (stat && typeof stat.isFile === 'function' && stat.isFile()) files.push(String(p));
+    return true;
+  };
+  const stream = tar.c({ gzip: true, cwd: dir, portable: true, filter }, entries);
+  const chunks = [];
+  await new Promise((resolve, reject) => {
+    stream.on('data', (d) => chunks.push(d));
+    stream.on('end', resolve);
+    stream.on('error', reject);
+  });
+  if (files.length === 0) throw new CliError('no files to upload in ' + dir);
+  return { data: Buffer.concat(chunks), files };
+}
+
+async function installBot(name, lang, progress) {
+  try {
+    await request('POST', bp(name, '/install'));
+  } catch (e) {
+    if (/nothing to install/.test(e.message)) return 'nothing to install';
+    throw e;
+  }
+  const t0 = Date.now();
+  for (;;) {
+    await sleep(3000);
+    const b = await request('GET', bp(name));
+    const secs = Math.round((Date.now() - t0) / 1000);
+    if (b.status !== 'installing') {
+      if (!/finished OK/.test(b.note || '')) {
+        const l = await request('GET', bp(name, '/logs') + '?lines=25&kind=install');
+        out();
+        out(c.dim(l.logs));
+        throw new CliError('install failed (log above)');
+      }
+      return secs + 's';
+    }
+    progress((lang === 'rust' ? 'building, Rust is slow, relax  ' : 'installing  ') + secs + 's');
+    if (secs > 3600) throw new CliError('install is taking over an hour. Check: host logs ' + name + ' --install');
+  }
+}
+
+// ---------------------------------------------------------------- commands
+
+async function cmdLogin(flags, first) {
+  const old = loadConfig();
+  const url = normalizeUrl(flags.server || old.url || DEFAULT_URL);
+  if (!process.stdin.isTTY) throw new CliError('login needs a terminal');
+  out();
+  out(c.bold(first ? "  Welcome to selfnify host. Let's log you in." : '  Login'));
+  out(c.dim('  server: ' + url));
+  if (old.pin && old.password) await requirePin(old, 'log in again');
+  const password = await askHidden('  Password: ');
+  if (!password) throw new CliError("password can't be empty");
+  const who = await step(null, 0, 'Checking password', async () => {
+    const r = await request('GET', '/status', { cfg: { url, password } });
+    return 'hi ' + r.you.name;
+  });
+  const pin = await chooseNewPin();
+  saveConfig({ url, password, pin: makePin(pin), bots: old.bots || {} });
+  out(c.green('  Saved.') + c.dim(' Password and PIN are stored on this device only (' + CONFIG_FILE + ').'));
+  out(c.dim('  The PIN is asked before big changes like delete. ' + (who || '')));
+  out();
+}
+
+async function ensureLogin(flags) {
+  const cfg = loadConfig();
+  if (cfg.password && cfg.url) return cfg;
+  if (!process.stdin.isTTY) throw new CliError('not logged in. Run: host login');
+  await cmdLogin(flags, true);
+  return loadConfig();
+}
+
+async function cmdLogout() {
+  const cfg = loadConfig();
+  if (!cfg.password) {
+    out(c.dim('  already logged out'));
+    return;
+  }
+  await requirePin(cfg, 'log out');
+  fs.unlinkSync(CONFIG_FILE);
+  out(c.green('  Logged out.') + c.dim(' Saved password, PIN and deploy shortcuts removed from this device.'));
+}
+
+async function cmdPin() {
+  const cfg = loadConfig();
+  if (!cfg.password) throw new CliError('not logged in. Run: host login');
+  await requirePin(cfg, 'change your PIN');
+  const pin = await chooseNewPin();
+  cfg.pin = makePin(pin);
+  saveConfig(cfg);
+  out(c.green('  PIN changed.'));
+}
+
+async function cmdList() {
+  const r = await request('GET', '/bots');
+  if (!r.bots.length) {
+    out(c.dim('  no bots yet. Deploy one: host ./mybot start node main index.js name mybot'));
+    return;
+  }
+  table(
+    ['BOT', 'LANG', 'STATUS', 'RAM', 'AUTO', 'NOTE'],
+    r.bots.map((b) => [b.name, b.language, b.status, b.rss_mb + '/' + b.mem_mb + ' MB', b.autostart ? 'yes' : 'no', (b.note || '').slice(0, 40)])
+  );
+}
+
+async function cmdStatus(name) {
+  if (!name) {
+    const s = await request('GET', '/status');
+    const quota = s.you.quota_gb === null ? 'no limit' : s.you.quota_gb + ' GB';
+    out(c.bold('  ' + s.you.name) + c.dim('  @ ' + hostOf(loadConfig().url)));
+    out('  storage   ' + s.you.used_mb + ' MB of ' + quota);
+    out('  server    ' + s.server.bots_running + ' of ' + s.server.bots_total + ' bots running, ' + s.server.ram_free_mb + ' MB RAM free');
+    return;
+  }
+  const b = await request('GET', bp(name));
+  const col = b.status === 'running' ? c.green : b.status === 'installing' ? c.yellow : c.dim;
+  out(c.bold('  ' + b.name) + '  ' + col(b.status + (b.pid ? ' (pid ' + b.pid + ')' : '')));
+  out('  language   ' + b.language + (b.language === 'rust' ? '' : '   main ' + b.entry));
+  out('  memory     ' + b.rss_mb + ' / ' + b.mem_mb + ' MB');
+  out('  autostart  ' + (b.autostart ? 'on' : 'off') + '   restart on crash ' + (b.restart_on_crash ? 'on' : 'off'));
+  out('  env vars   ' + (b.env_keys.join(', ') || '(none)'));
+  if (b.note) out('  note       ' + b.note);
+}
+
+async function cmdAction(action, name) {
+  requireName(name, 'host ' + action + ' <bot>');
+  const verb = { start: 'Starting', stop: 'Stopping', restart: 'Restarting' }[action];
+  await step(null, 0, verb + ' ' + name, async () => {
+    if (action === 'restart') {
+      try {
+        await request('POST', bp(name, '/stop'));
+      } catch (e) {
+        if (e.status === 404) throw e;
+      }
+      const b = await request('POST', bp(name, '/start'));
+      return b.status + (b.pid ? ' (pid ' + b.pid + ')' : '');
+    }
+    const b = await request('POST', bp(name, '/' + action));
+    return b.status + (b.pid ? ' (pid ' + b.pid + ')' : '');
+  });
+}
+
+async function cmdDelete(name) {
+  requireName(name, 'host delete <bot>');
+  const cfg = loadConfig();
+  const b = await request('GET', bp(name));
+  out('  ' + c.bold(name) + c.dim(' (' + b.language + ', ' + b.status + ')') + ' will be deleted with ALL its files.');
+  await requirePin(cfg, 'delete ' + name);
+  await step(null, 0, 'Deleting ' + name, async () => {
+    await request('DELETE', bp(name));
+    return 'gone';
+  });
+  const fresh = loadConfig();
+  if (fresh.bots && fresh.bots[name]) {
+    delete fresh.bots[name];
+    saveConfig(fresh);
+  }
+}
+
+function overlap(prev, cur) {
+  for (let size = Math.min(prev.length, cur.length); size > 0; size--) {
+    let ok = true;
+    for (let i = 0; i < size; i++) {
+      if (prev[prev.length - size + i] !== cur[i]) {
+        ok = false;
+        break;
+      }
+    }
+    if (ok) return size;
+  }
+  return 0;
+}
+
+async function cmdLogs(name, flags) {
+  requireName(name, 'host logs <bot> [-f] [-n 50] [--install]');
+  const n = Math.max(1, parseInt(flags.lines || '50', 10) || 50);
+  const kind = flags.install ? 'install' : 'run';
+  const fetchLines = async (count) => (await request('GET', bp(name, '/logs') + '?lines=' + count + '&kind=' + kind)).logs;
+  if (!flags.follow) {
+    out((await fetchLines(n)) || c.dim('  (no logs yet)'));
+    return;
+  }
+  let prev = (await fetchLines(200)).split('\n').filter((l) => l.length);
+  out(prev.length ? prev.slice(-n).join('\n') : c.dim('  (no logs yet)'));
+  out(c.dim('  -- following, Ctrl+C to stop --'));
+  process.on('SIGINT', () => {
+    out();
+    process.exit(0);
+  });
+  let warned = false;
+  for (;;) {
+    await sleep(2000);
+    try {
+      const cur = (await fetchLines(200)).split('\n').filter((l) => l.length);
+      cur.slice(overlap(prev, cur)).forEach((l) => out(l));
+      if (cur.length) prev = cur;
+      warned = false;
+    } catch (e) {
+      if (!warned) out(c.yellow('  connection problem, retrying...'));
+      warned = true;
+    }
+  }
+}
+
+async function cmdEnv(name, sub, rest) {
+  requireName(name, 'host env <bot> push [file] | set K=V ... | unset K ... | list');
+  if (!sub) throw new CliError('usage: host env ' + name + ' push [file] | set K=V ... | unset K ... | list');
+  if (sub === 'list') {
+    const b = await request('GET', bp(name));
+    out('  env vars on ' + name + ': ' + (b.env_keys.join(', ') || '(none)'));
+    return;
+  }
+  let pairs;
+  if (sub === 'set') {
+    pairs = {};
+    rest.forEach((item) => {
+      const idx = item.indexOf('=');
+      if (idx < 1) throw new CliError('use KEY=VALUE for each variable');
+      pairs[item.slice(0, idx)] = item.slice(idx + 1);
+    });
+  } else if (sub === 'unset') {
+    pairs = {};
+    rest.forEach((k) => {
+      pairs[k] = null;
+    });
+  } else if (sub === 'push') {
+    pairs = parseEnvFile(rest[0] || '.env');
+  } else {
+    throw new CliError("unknown env command '" + sub + "'");
+  }
+  if (!Object.keys(pairs).length) throw new CliError('nothing to send');
+  await step(null, 0, 'Updating env vars', async () => {
+    const r = await request('POST', bp(name, '/env'), { body: pairs });
+    return r.env_keys.length + ' on the server';
+  });
+  out(c.dim('  restart to apply: host restart ' + name));
+}
+
+async function cmdConfig(name, flags) {
+  requireName(name, 'host config <bot> [--mem MB] [--autostart|--no-autostart] [--main file]');
+  const body = {};
+  if (flags.autostart) body.autostart = true;
+  if (flags['no-autostart']) body.autostart = false;
+  if (flags.mem !== undefined) {
+    const mem = parseInt(flags.mem, 10);
+    if (!(mem >= 30)) throw new CliError('--mem needs a number, 30 or more (MB)');
+    body.mem_mb = mem;
+  }
+  if (flags.main) body.entry = flags.main;
+  if (Object.keys(body).length) {
+    await step(null, 0, 'Updating ' + name, async () => {
+      await request('POST', bp(name, '/config'), { body });
+      return Object.keys(body).join(', ');
+    });
+  }
+  await cmdStatus(name);
+}
+
+async function deploy(opts, flags) {
+  const t0 = Date.now();
+  const dir = path.resolve(opts.path);
+  if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) throw new CliError('"' + opts.path + '" is not a folder');
+  const startStr = opts.start || detectStart(dir);
+  if (!startStr) throw new CliError('could not tell the language. Add: start python | node | cargo');
+  const parsed = parseStart(startStr);
+  const lang = parsed.lang;
+  const main = opts.main || parsed.entry || (lang === 'node' ? nodeMain(dir) : defaultEntry(lang));
+  const name = opts.name || sanitizeName(path.basename(dir));
+  if (!NAME_RE.test(name)) throw new CliError('bad bot name "' + name + '": use a-z, 0-9, _ or -, max 32 characters');
+  if (lang !== 'rust' && !fs.existsSync(path.join(dir, main))) throw new CliError('main file "' + main + '" not found in ' + dir);
+  let mem;
+  if (flags.mem !== undefined) {
+    mem = parseInt(flags.mem, 10);
+    if (!(mem >= 30)) throw new CliError('--mem needs a number, 30 or more (MB)');
+  }
+
+  const dry = Boolean(flags['dry-run']);
+  const total = dry ? 2 : 5 + (flags.env ? 1 : 0) + (flags['no-install'] ? 0 : 1);
+  let n = 0;
+  const next = (label, fn) => step(++n, total, label, fn);
+
+  out();
+  out('  ' + c.bold('Deploying ' + name) + c.dim('   ' + lang + (lang === 'rust' ? '' : ', main ' + main)));
+  out(c.dim('  from ' + dir));
+  out();
+
+  const cfg = loadConfig();
+  await next('Checking login', async () => {
+    const s = await request('GET', '/status');
+    return s.you.name + ' @ ' + hostOf(cfg.url);
+  });
+
+  let pack;
+  await next('Packing files', async () => {
+    pack = await packDir(dir);
+    const mb = pack.data.length / 1024 / 1024;
+    if (mb > MAX_UPLOAD_MB) throw new CliError('upload is ' + mb.toFixed(1) + ' MB (limit about ' + MAX_UPLOAD_MB + ' MB). Look for big files that do not belong.');
+    return pack.files.length + ' files, ' + mb.toFixed(1) + ' MB';
+  });
+
+  if (dry) {
+    out();
+    pack.files.slice(0, 25).forEach((f) => out(c.dim('    ' + f)));
+    if (pack.files.length > 25) out(c.dim('    ... and ' + (pack.files.length - 25) + ' more'));
+    out(c.yellow('\n  dry run: nothing was uploaded'));
+    return;
+  }
+
+  let bot = null;
+  await next('Preparing bot', async () => {
+    try {
+      bot = await request('GET', bp(name));
+    } catch (e) {
+      if (e.status !== 404) throw e;
+    }
+    if (!bot) {
+      const body = { name, language: lang };
+      if (lang !== 'rust') body.entry = main;
+      if (mem) body.mem_mb = mem;
+      if (flags.autostart) body.autostart = true;
+      bot = await request('POST', '/bots', { body });
+      return 'created';
+    }
+    if (bot.language !== lang) {
+      throw new CliError('"' + name + '" already exists as a ' + bot.language + ' bot. Delete it first or pick another name.');
+    }
+    const patch = {};
+    if (lang !== 'rust' && bot.entry !== main) patch.entry = main;
+    if (mem) patch.mem_mb = mem;
+    if (flags.autostart) patch.autostart = true;
+    if (Object.keys(patch).length) bot = await request('POST', bp(name, '/config'), { body: patch });
+    return 'found, updating';
+  });
+
+  await next('Uploading', async ({ progress }) => {
+    if (bot.status === 'installing') throw new CliError('an install is already running for this bot, try again in a minute');
+    if (bot.status === 'running') {
+      progress('stopping old version');
+      await request('POST', bp(name, '/stop'));
+    }
+    progress('sending ' + (pack.data.length / 1024 / 1024).toFixed(1) + ' MB');
+    const r = await request('PUT', bp(name, '/upload'), { raw: pack.data, timeout: 900000 });
+    return r.extracted_mb + ' MB on the server';
+  });
+
+  if (flags.env) {
+    await next('Sending env vars', async () => {
+      const pairs = parseEnvFile(flags.env);
+      if (!Object.keys(pairs).length) throw new CliError('no variables found in ' + flags.env);
+      const r = await request('POST', bp(name, '/env'), { body: pairs });
+      return r.env_keys.length + ' on the server';
+    });
+  }
+
+  if (!flags['no-install']) {
+    await next('Installing dependencies', ({ progress }) => installBot(name, lang, progress));
+  }
+
+  let finalLine = '';
+  await next('Starting', async () => {
+    await request('POST', bp(name, '/start'));
+    await sleep(4000);
+    const now = await request('GET', bp(name));
+    if (now.status !== 'running') {
+      const l = await request('GET', bp(name, '/logs') + '?lines=15&kind=run');
+      out();
+      out(c.dim(l.logs || '  (no output)'));
+      throw new CliError('the bot stopped right after starting (log above)');
+    }
+    finalLine = 'running (pid ' + now.pid + ')';
+    return finalLine;
+  });
+
+  const fresh = loadConfig();
+  fresh.bots = Object.assign({}, fresh.bots, { [name]: { path: dir, start: startStr, main: opts.main || null } });
+  saveConfig(fresh);
+
+  out();
+  out('  ' + c.green('Done') + c.dim(' in ' + Math.round((Date.now() - t0) / 1000) + 's'));
+  out(c.dim('  logs: host logs ' + name + ' -f    stop: host stop ' + name + '    redeploy: host deploy ' + name));
+  out();
+}
+
+function parseDeployArgs(pos) {
+  const opts = { path: pos[0], start: null, main: null, name: null };
+  for (let i = 1; i < pos.length; i += 2) {
+    const key = String(pos[i]).toLowerCase();
+    if (!['start', 'main', 'name'].includes(key) || pos[i + 1] === undefined) {
+      throw new CliError('unexpected "' + pos[i] + '". Usage: host <path> start <cmd> main <file> name <bot>');
+    }
+    opts[key] = pos[i + 1];
+  }
+  return opts;
+}
+
+function printHelp() {
+  const h = (s) => out(c.bold(s));
+  out();
+  out('  ' + c.bold('selfnify host') + c.dim(' v' + VERSION + '  -  run your bots on the Selfnify server'));
+  out();
+  h('  Deploy a bot');
+  out('    host <path> start <cmd> main <file> name <bot>');
+  out(c.dim('      host ./mybot start node main index.js name mybot'));
+  out(c.dim('      host . start python main main.py name musicbot'));
+  out(c.dim('      start = python | node | cargo     main = file to run     name = bot name'));
+  out(c.dim('      leave out start/main/name and it guesses from your folder'));
+  out();
+  h('  Manage');
+  out('    host start <bot>        host stop <bot>        host restart <bot>');
+  out('    host status [bot]       host list');
+  out('    host logs <bot> [-f] [-n 50] [--install]');
+  out('    host delete <bot>       ' + c.dim('(asks for your PIN)'));
+  out('    host deploy <bot>       ' + c.dim('redeploy with the same settings as last time'));
+  out('    host env <bot> push [file] | set K=V ... | unset K ... | list');
+  out('    host config <bot> [--mem MB] [--autostart|--no-autostart] [--main file]');
+  out();
+  h('  Account');
+  out('    host login    host logout    host pin    host help    host version');
+  out();
+  h('  Flags');
+  out('    --mem MB   --autostart   --no-install   --env <file>   --dry-run');
+  out('    -f/--follow   -n <lines>   --install   --server <url>   -v/--verbose   --no-color');
+  out();
+  out(c.dim('  Also works as: selfnify <same commands>'));
+  out();
+}
+
+async function main() {
+  const { flags, pos } = parseArgs(process.argv.slice(2));
+  state.verbose = Boolean(flags.verbose);
+  if (flags['no-color']) state.color = false;
+  if (!pos.length || (flags.help && !pos.length)) {
+    printHelp();
+    return;
+  }
+  const first = pos[0].toLowerCase();
+
+  if (!COMMANDS.has(first)) {
+    if (!fs.existsSync(pos[0]) && pos[1] && COMMANDS.has(String(pos[1]).toLowerCase())) {
+      throw new CliError('did you mean: host ' + pos[1] + ' ' + pos[0] + ' ?');
+    }
+    const opts = parseDeployArgs(pos);
+    await ensureLogin(flags);
+    await deploy(opts, flags);
+    return;
+  }
+
+  switch (first) {
+    case 'help':
+      printHelp();
+      return;
+    case 'version':
+      out('selfnify-host ' + VERSION);
+      return;
+    case 'login':
+      await cmdLogin(flags, false);
+      return;
+    case 'logout':
+      await cmdLogout();
+      return;
+    case 'pin':
+      await cmdPin();
+      return;
+    default:
+      break;
+  }
+
+  if (flags.help) {
+    printHelp();
+    return;
+  }
+
+  const cfg = await ensureLogin(flags);
+  switch (first) {
+    case 'start':
+    case 'stop':
+    case 'restart':
+      await cmdAction(first, pos[1]);
+      break;
+    case 'delete':
+      await cmdDelete(pos[1]);
+      break;
+    case 'status':
+      await cmdStatus(pos[1]);
+      break;
+    case 'list':
+      await cmdList();
+      break;
+    case 'logs':
+      await cmdLogs(pos[1], flags);
+      break;
+    case 'env':
+      await cmdEnv(pos[1], pos[2], pos.slice(3));
+      break;
+    case 'config':
+      await cmdConfig(pos[1], flags);
+      break;
+    case 'deploy': {
+      const name = requireName(pos[1], 'host deploy <bot>');
+      const saved = (cfg.bots || {})[name];
+      if (!saved) {
+        throw new CliError('no saved deploy for "' + name + '". Deploy it once with: host <path> start <cmd> main <file> name ' + name);
+      }
+      await deploy({ path: saved.path, start: saved.start, main: saved.main, name }, flags);
+      break;
+    }
+    default:
+      break;
+  }
+}
+
+main().catch((e) => {
+  if (e instanceof CliError) {
+    out(c.red('  error: ') + e.message);
+  } else {
+    out(c.red('  unexpected error: ') + (e && e.message ? e.message : e));
+    if (state.verbose && e && e.stack) out(c.dim(e.stack));
+  }
+  process.exitCode = 1;
+});

package/package.json

@@ -1,6 +1,26 @@
-{
-  "name": "selfnify-host",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+{
+  "name": "selfnify-host",
+  "version": "1.0.0",
+  "description": "Deploy and manage bots (Python, Node.js, Rust) on the Selfnify host with one command.",
+  "bin": {
+    "host": "host.js",
+    "selfnify": "host.js"
+  },
+  "files": [
+    "host.js"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "tar": "^7.4.3"
+  },
+  "keywords": [
+    "selfnify",
+    "bot",
+    "hosting",
+    "discord",
+    "cli"
+  ],
+  "license": "MIT"
 }

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.