mobygate 0.3.0

package/bin/mobygate.js

@@ -0,0 +1,443 @@
+#!/usr/bin/env node
+/**
+ * mobygate CLI — install, run, and manage the proxy.
+ *
+ * Sub-commands:
+ *   init       Interactive setup: check prereqs, write config,
+ *              install launchd/systemd/Task-Scheduler services,
+ *              start the proxy, smoke-test.
+ *   start      Load the server service (or start the proxy directly
+ *              if no service is installed).
+ *   stop       Unload the server service.
+ *   restart    Stop + start.
+ *   status     Show service state, auth state, /health probe.
+ *   logs       Tail the server log.
+ *   auth       Auth status + force-refresh probe.
+ *   uninstall  Remove installed services and the config directory.
+ *
+ * Run `mobygate <command> --help` for per-command flags.
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { resolve, dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { spawnSync } from 'child_process';
+import { createInterface } from 'readline';
+
+import { loadConfig, writeConfig, writeState, readState, CONFIG_DIR, CONFIG_PATH, LOGS_DIR } from '../lib/config.js';
+import {
+  PLATFORM, IS_MAC, IS_LINUX, IS_WIN,
+  resolveNodeBin,
+  writeMacServerPlist, launchctlLoad, launchctlUnload,
+  plistPathForLabel, queryLaunchd, uninstallAllServices,
+  installWindowsServices, uninstallWindowsServices,
+  queryWindowsTask, startWindowsTask, stopWindowsTask, WIN_LABELS,
+  installLinuxServices, uninstallLinuxServices,
+  queryLinuxUnit, startLinuxUnit, stopLinuxUnit, LINUX_UNITS,
+  nonMacInstallInstructions,
+} from '../lib/platform.js';
+import { getAuthStatus, forceRefresh } from '../scripts/auth-helper.js';
+import { banner, compactBanner } from '../lib/ascii.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const REPO_ROOT = resolve(dirname(__filename), '..');
+const SERVER_LABEL = 'ai.mobygate.server';
+const AUTH_LABEL = 'ai.mobygate.auth-refresh';
+
+// ---------- tiny helpers ----------
+
+const c = {
+  bold: (s) => `\x1b[1m${s}\x1b[0m`,
+  dim:  (s) => `\x1b[2m${s}\x1b[0m`,
+  green:(s) => `\x1b[32m${s}\x1b[0m`,
+  red:  (s) => `\x1b[31m${s}\x1b[0m`,
+  yell: (s) => `\x1b[33m${s}\x1b[0m`,
+  cyan: (s) => `\x1b[36m${s}\x1b[0m`,
+};
+
+function print(...args) { console.log(...args); }
+function die(msg, code = 1) { console.error(c.red('✗ ' + msg)); process.exit(code); }
+function ok(msg)    { print(c.green('✓ ') + msg); }
+function warn(msg)  { print(c.yell('! ') + msg); }
+function info(msg)  { print(c.cyan('→ ') + msg); }
+function section(title) { print('\n' + c.bold(title)); }
+
+function prompt(q, def = '') {
+  return new Promise((res) => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const defaultText = def ? c.dim(` [${def}]`) : '';
+    rl.question(`${q}${defaultText} `, (ans) => { rl.close(); res((ans || '').trim() || def); });
+  });
+}
+
+async function confirm(q, def = true) {
+  const tag = def ? 'Y/n' : 'y/N';
+  const ans = (await prompt(`${q} (${tag})`, '')).toLowerCase();
+  if (!ans) return def;
+  return ans.startsWith('y');
+}
+
+// ---------- commands ----------
+
+async function cmdInit() {
+  const pkg = JSON.parse(readFileSync(join(REPO_ROOT, 'package.json'), 'utf8'));
+  print(banner({ version: pkg.version }));
+  section('mobygate init');
+  print(c.dim(`Platform: ${PLATFORM}  Install path: ${REPO_ROOT}`));
+  print(c.dim(`Config:   ${CONFIG_PATH}`));
+  print('');
+
+  // ---- Prereq: node version ----
+  const major = parseInt(process.versions.node.split('.')[0], 10);
+  if (major < 18) die(`Node 18+ required (you have ${process.version}). Upgrade via fnm/nvm/volta.`);
+  ok(`Node ${process.version}`);
+
+  // ---- Prereq: claude CLI present ----
+  const claudeProbe = spawnSync(IS_WIN ? 'where' : 'which', ['claude'], { encoding: 'utf8' });
+  if (claudeProbe.status !== 0) {
+    warn('`claude` CLI not found on PATH.');
+    print(c.dim('  The proxy uses Claude Code\'s CLI to resolve OAuth credentials.'));
+    print(c.dim('  Install: https://docs.claude.com/en/docs/claude-code'));
+    const proceed = await confirm('Continue anyway? (you can set CLAUDE_BIN in config.yaml later)', false);
+    if (!proceed) die('Aborted.');
+  } else {
+    ok(`claude CLI at ${claudeProbe.stdout.trim().split('\n')[0]}`);
+  }
+
+  // ---- Prereq: claude auth status ----
+  try {
+    const authStatus = await getAuthStatus();
+    if (authStatus.ok && authStatus.loggedIn) {
+      ok(`Logged in as ${authStatus.email || '(email unknown)'} (${authStatus.subscriptionType || authStatus.authMethod})`);
+    } else {
+      warn('Not logged into Claude Max.');
+      print(c.dim('  Run `claude auth login` in another terminal, then re-run `mobygate init`.'));
+      const proceed = await confirm('Continue without login?', false);
+      if (!proceed) die('Aborted.');
+    }
+  } catch (e) {
+    warn(`Couldn't check auth status: ${e.message}`);
+  }
+
+  // ---- Config ----
+  section('Configuration');
+  const existing = loadConfig();
+  const port = await prompt('HTTP port', String(existing.port));
+  const defaultModel = await prompt('Default model', existing.default_model);
+  const sessionTtl = await prompt('Session TTL (minutes)', String(existing.session_ttl_minutes));
+  const claudeBin = claudeProbe.status === 0
+    ? (await prompt('CLAUDE_BIN override (blank = PATH)', existing.claude_bin || ''))
+    : (await prompt('CLAUDE_BIN (absolute path to claude binary)', existing.claude_bin || ''));
+
+  const configPath = writeConfig({
+    port: parseInt(port, 10) || 3456,
+    default_model: defaultModel,
+    session_ttl_minutes: parseInt(sessionTtl, 10) || 60,
+    claude_bin: claudeBin,
+  });
+  ok(`Wrote ${configPath}`);
+
+  // ---- Logs dir (canonical per-user location, outside install dir) ----
+  const logsDir = LOGS_DIR;
+  if (!existsSync(logsDir)) mkdirSync(logsDir, { recursive: true });
+  ok(`Logs: ${logsDir}`);
+
+  // ---- Services ----
+  section('Services');
+  const nodeBin = resolveNodeBin();
+  const portNum = parseInt(port, 10) || 3456;
+  if (IS_MAC) {
+    // Server plist
+    const serverPlist = writeMacServerPlist({
+      installPath: REPO_ROOT,
+      nodeBin,
+      port: portNum,
+      logsDir,
+    });
+    launchctlLoad(serverPlist);
+    ok(`Installed ${SERVER_LABEL} (launchd)`);
+
+    // Auth refresh plist (we ship a template in launchd/ — copy + rewrite
+    // WorkingDirectory, node path, and log paths to match this install).
+    const authSrc = join(REPO_ROOT, 'launchd', 'ai.mobygate.auth-refresh.plist');
+    if (existsSync(authSrc)) {
+      const authDst = plistPathForLabel(AUTH_LABEL);
+      const tmpl = readFileSync(authSrc, 'utf8')
+        // WorkingDirectory + any path that referenced the repo root
+        .replace(/\/Users\/farhan\/openclaude\/claude-max-sdk-proxy\/logs/g, logsDir)
+        .replace(/\/Users\/farhan\/openclaude\/claude-max-sdk-proxy/g, REPO_ROOT)
+        // node binary baked into ProgramArguments
+        .replace(/\/Users\/farhan\/\.local\/share\/fnm\/aliases\/default\/bin\/node/g, nodeBin);
+      writeFileSync(authDst, tmpl);
+      launchctlLoad(authDst);
+      ok(`Installed ${AUTH_LABEL} (launchd, every ${existing.auth_refresh_interval_hours}h)`);
+    }
+  } else if (IS_WIN) {
+    // Register Task Scheduler entries and kick the server task now.
+    const r = installWindowsServices({
+      installPath: REPO_ROOT,
+      nodeBin,
+      port: portNum,
+      authRefreshHours: existing.auth_refresh_interval_hours,
+    });
+    for (const t of r.installed) ok(`Installed ${t} (Task Scheduler, user-level)`);
+    for (const e of r.errors) warn(`Failed to register ${e.task}: ${e.stderr || '(no error detail)'}`);
+    if (!r.ok) {
+      warn('Some tasks failed. You can retry manually — here is the PowerShell:');
+      print(nonMacInstallInstructions({ installPath: REPO_ROOT, nodeBin, port: portNum }));
+    }
+  } else if (IS_LINUX) {
+    // Install + enable systemd user units
+    const r = installLinuxServices({
+      installPath: REPO_ROOT,
+      nodeBin,
+      port: portNum,
+      authRefreshHours: existing.auth_refresh_interval_hours,
+    });
+    for (const u of r.installed) ok(`Installed ${u} (systemd user unit)`);
+    for (const e of r.errors) warn(`Failed on ${e.unit}: ${e.stderr || '(no error detail)'}`);
+    if (!r.ok) {
+      warn('Some units failed. You can retry manually:');
+      print(nonMacInstallInstructions({ installPath: REPO_ROOT, nodeBin, port: portNum }));
+    } else {
+      info('Tip: for the server to run when you are not logged in, enable linger:');
+      print(c.dim(`  sudo loginctl enable-linger ${process.env.USER || process.env.USERNAME || 'your-user'}`));
+    }
+  } else {
+    warn(`${PLATFORM} — automated service install not supported.`);
+    print(nonMacInstallInstructions({ installPath: REPO_ROOT, nodeBin, port: portNum }));
+  }
+
+  writeState({
+    install_path: REPO_ROOT,
+    installed_version: '0.1.0',
+    installed_at: new Date().toISOString(),
+    platform: PLATFORM,
+    node_bin: nodeBin,
+  });
+
+  // ---- Smoke ----
+  section('Smoke test');
+  if (IS_MAC || IS_WIN || IS_LINUX) {
+    // Service managers need a beat to actually launch the process
+    await new Promise((r) => setTimeout(r, 2500));
+    try {
+      const h = await fetch(`http://localhost:${portNum}/health`, { signal: AbortSignal.timeout(3000) });
+      if (h.ok) ok('Server responded on /health');
+      else warn(`Health check returned ${h.status}`);
+    } catch (e) {
+      warn(`Health check failed: ${e.message}`);
+      if (IS_WIN) print(c.dim('  Run `mobygate logs` or check Task Scheduler history for startup errors.'));
+      else if (IS_LINUX) print(c.dim('  Run `journalctl --user -u mobygate-server -n 50` or check logs/server.err.log.'));
+      else print(c.dim('  Check logs/server.err.log for startup errors.'));
+    }
+  } else {
+    info('Start the server manually (see instructions above) then run `mobygate status`.');
+  }
+
+  section('Done');
+  print(`Dashboard: ${c.cyan(`http://localhost:${port}`)}`);
+  print(`Configure: ${c.cyan(CONFIG_PATH)}`);
+  print(`Try:       ${c.cyan('mobygate status')} | ${c.cyan('mobygate logs')} | ${c.cyan('mobygate auth')}`);
+}
+
+function cmdStart() {
+  if (IS_MAC) {
+    const p = plistPathForLabel(SERVER_LABEL);
+    if (!existsSync(p)) return die(`${SERVER_LABEL} not installed — run \`mobygate init\` first.`);
+    launchctlLoad(p);
+    ok(`Loaded ${SERVER_LABEL}`);
+  } else if (IS_WIN) {
+    const r = startWindowsTask(WIN_LABELS.server);
+    if (!r.ok) return die(`Failed to start ${WIN_LABELS.server}: ${r.stderr || 'unknown'}`);
+    ok(`Started ${WIN_LABELS.server}`);
+  } else if (IS_LINUX) {
+    const r = startLinuxUnit(LINUX_UNITS.server);
+    if (!r.ok) return die(`Failed to start ${LINUX_UNITS.server}: ${r.stderr || 'unknown'}`);
+    ok(`Started ${LINUX_UNITS.server}`);
+  } else {
+    die('`mobygate start` not supported on this platform. Start manually: node server.js');
+  }
+}
+
+function cmdStop() {
+  if (IS_MAC) {
+    const p = plistPathForLabel(SERVER_LABEL);
+    launchctlUnload(p);
+    ok(`Unloaded ${SERVER_LABEL}`);
+  } else if (IS_WIN) {
+    const r = stopWindowsTask(WIN_LABELS.server);
+    if (!r.ok) return die(`Failed to stop ${WIN_LABELS.server}: ${r.stderr || 'unknown'}`);
+    ok(`Stopped ${WIN_LABELS.server}`);
+  } else if (IS_LINUX) {
+    const r = stopLinuxUnit(LINUX_UNITS.server);
+    if (!r.ok) return die(`Failed to stop ${LINUX_UNITS.server}: ${r.stderr || 'unknown'}`);
+    ok(`Stopped ${LINUX_UNITS.server}`);
+  } else {
+    die('`mobygate stop` not supported on this platform.');
+  }
+}
+
+function cmdRestart() {
+  cmdStop();
+  cmdStart();
+}
+
+async function cmdStatus() {
+  const pkg = JSON.parse(readFileSync(join(REPO_ROOT, 'package.json'), 'utf8'));
+  print(compactBanner({ version: pkg.version }));
+  section('mobygate status');
+  const config = loadConfig();
+  print(c.dim(`Config:  ${config.source}`));
+  print(c.dim(`Port:    ${config.port}`));
+  print(c.dim(`Model:   ${config.default_model}`));
+
+  if (IS_MAC) {
+    for (const label of [SERVER_LABEL, AUTH_LABEL]) {
+      const s = queryLaunchd(label);
+      if (!s.loaded) { warn(`${label}: not loaded`); continue; }
+      const pidPart = s.pid ? `pid ${s.pid}` : 'not running';
+      const exitPart = s.lastExit !== null && s.lastExit !== 0 ? ` last exit ${c.red(s.lastExit)}` : '';
+      ok(`${label}: ${pidPart}${exitPart}`);
+    }
+  } else if (IS_WIN) {
+    for (const name of [WIN_LABELS.server, WIN_LABELS.auth]) {
+      const s = queryWindowsTask(name);
+      if (!s.exists) { warn(`${name}: not installed`); continue; }
+      const resultPart = s.lastResult !== null && s.lastResult !== 0 ? ` last result ${c.red(s.lastResult)}` : '';
+      ok(`${name}: ${s.state || 'unknown'}${resultPart}`);
+    }
+  } else if (IS_LINUX) {
+    for (const unit of [LINUX_UNITS.server, LINUX_UNITS.timer]) {
+      const s = queryLinuxUnit(unit);
+      if (!s.exists) { warn(`${unit}: not installed`); continue; }
+      const pidPart = s.mainPid ? ` pid ${s.mainPid}` : '';
+      const state = s.active === 'failed' ? c.red(s.active) : s.active;
+      ok(`${unit}: ${state}${pidPart}`);
+    }
+  }
+
+  try {
+    const h = await fetch(`http://localhost:${config.port}/health`, { signal: AbortSignal.timeout(2000) });
+    if (h.ok) {
+      const j = await h.json();
+      ok(`/health OK — ${j.activeSessions} active session(s)`);
+    } else {
+      warn(`/health returned ${h.status}`);
+    }
+  } catch (e) {
+    warn(`/health unreachable: ${e.message}`);
+  }
+
+  try {
+    const auth = await getAuthStatus();
+    if (auth.ok && auth.loggedIn) ok(`auth: ${auth.email || 'logged in'} (${auth.subscriptionType || auth.authMethod})`);
+    else warn(`auth: not logged in`);
+  } catch (e) {
+    warn(`auth check failed: ${e.message}`);
+  }
+}
+
+function cmdLogs() {
+  const logFile = join(LOGS_DIR, 'server.log');
+  if (!existsSync(logFile)) return die(`No log file at ${logFile} — is the server running?`);
+  // Delegate to tail -f
+  const cmd = IS_WIN ? 'powershell' : 'tail';
+  const args = IS_WIN ? ['-Command', `Get-Content -Path "${logFile}" -Wait -Tail 50`] : ['-f', '-n', '50', logFile];
+  spawnSync(cmd, args, { stdio: 'inherit' });
+}
+
+async function cmdAuth() {
+  section('mobygate auth');
+  const status = await getAuthStatus();
+  print(JSON.stringify(status, null, 2));
+  if (!status.ok || !status.loggedIn) {
+    warn('Not logged in — run `claude auth login`.');
+    return;
+  }
+  info('Probing...');
+  const probe = await forceRefresh();
+  if (probe.ok) ok(`probe succeeded in ${probe.durationMs}ms`);
+  else die(`probe failed: ${probe.error}`);
+}
+
+async function cmdUninstall() {
+  const y = await confirm('Remove installed services and leave the repo in place?', false);
+  if (!y) return info('Aborted.');
+  if (IS_MAC) {
+    const results = uninstallAllServices();
+    for (const r of results) {
+      if (r.removed) ok(`Removed ${r.label}`);
+      else info(`${r.label}: ${r.reason || r.error || 'n/a'}`);
+    }
+  } else if (IS_WIN) {
+    const results = uninstallWindowsServices({ installPath: REPO_ROOT });
+    for (const r of results) {
+      if (r.removed) ok(`Removed ${r.name}`);
+      else info(`${r.name}: ${r.reason || r.error || 'n/a'}`);
+    }
+  } else if (IS_LINUX) {
+    const results = uninstallLinuxServices();
+    for (const r of results) {
+      if (r.removed) ok(`Removed ${r.unit}`);
+      else info(`${r.unit}: ${r.stopped ? 'stopped' : 'not present'}`);
+    }
+  } else {
+    info('Uninstall for this platform not supported.');
+  }
+}
+
+function cmdVersion() {
+  const pkg = JSON.parse(readFileSync(join(REPO_ROOT, 'package.json'), 'utf8'));
+  print(`mobygate v${pkg.version}`);
+}
+
+function usage() {
+  print(`mobygate — OpenAI → Claude Max local gateway
+
+Usage:
+  mobygate init       Interactive setup: config, services, smoke test
+  mobygate start      Start the proxy service
+  mobygate stop       Stop the proxy service
+  mobygate restart    Stop + start
+  mobygate status     Show service + auth + /health state
+  mobygate logs       Tail the server log
+  mobygate auth       Show auth status + run a refresh probe
+  mobygate uninstall  Remove installed services
+  mobygate version    Print version
+
+Config: ~/.mobygate/config.yaml  (env vars override)
+Repo:   ${REPO_ROOT}
+`);
+}
+
+// ---------- dispatch ----------
+
+const cmd = process.argv[2];
+const COMMANDS = {
+  init: cmdInit,
+  start: cmdStart,
+  stop: cmdStop,
+  restart: cmdRestart,
+  status: cmdStatus,
+  logs: cmdLogs,
+  auth: cmdAuth,
+  uninstall: cmdUninstall,
+  version: cmdVersion,
+  '--version': cmdVersion,
+  '-v': cmdVersion,
+  help: usage,
+  '--help': usage,
+  '-h': usage,
+};
+
+if (!cmd || !COMMANDS[cmd]) {
+  usage();
+  process.exit(cmd ? 1 : 0);
+}
+
+try {
+  await COMMANDS[cmd]();
+} catch (e) {
+  die(`${e.message}\n${e.stack?.split('\n').slice(1, 4).join('\n') || ''}`);
+}