remote-access-mcp 2.1.2 → 2.2.0

package/dist/cli/main.js

@@ -1,78 +1,83 @@
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+import net from 'node:net';
 import { execFileSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-import net from 'node:net';
 import { loadConfig, saveConfig, generateToken, newTokenRecord, configPath, configDir, primaryToken, } from '../core/config.js';
-import { resolveReal } from '../core/policy.js';
+import { resolveReal, TOOL_SCOPES } from '../core/policy.js';
 import { AuditLog } from '../core/audit.js';
+import { platform, isWindows, isMac, isLinux, hasSystemd, platformLabel, } from '../core/platform.js';
+import { resolveCloudflared } from '../core/tunnel.js';
 const PKG_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
 const PKG = JSON.parse(fs.readFileSync(path.join(PKG_ROOT, 'package.json'), 'utf8'));
 // ---------------------------------------------------------------------------
 // help
 // ---------------------------------------------------------------------------
-const HELP = `${PKG.name} v${PKG.version} — turn any Linux server into an AI-agent-accessible machine
+const HELP = `${PKG.name} v${PKG.version} — turn any machine into an AI-agent-accessible endpoint
+Runs on Linux, macOS, and Windows.
 
 Usage:
   ramcp <command> [options]
 
-Commands:
-  init                          Generate config + first token (safe to re-run)
-  start [--host H] [--port P]
-      [--read-only]            Run the gateway in the foreground
-  url [--token ID|name]         Print the MCP connector URL for chatbots
-  status                        Service status summary
-  doctor                        Diagnose token, port, nginx, DNS in one pass
-  version                       Print version
+Getting started:
+  init [--paths a,b]            Create config + first token
+  start [--tunnel]              Run the gateway (--tunnel = public https URL)
+  tunnel                        Start gateway + public URL, print connector link
+  url [token]                   Print the connector URL for a chatbot
+  doctor                        Diagnose everything in one pass
+  status                        Config + service summary
+  upgrade [--dry-run]           Self-update from npm
+  version
 
-  token list [--json]           List tokens (fingerprints only)
-  token add --name N [opts]      Create a token (see options below)
-  token show [ID|name] [--full]  Show a token
-  token rotate [ID|name]         Rotate a token (old one dies instantly)
-  token revoke ID|name           Revoke (delete) a token
-  token add options:
-      --shell / --no-shell       shell execution (default: off)
-      --paths a,b,c              allowed paths (comma-separated)
-      --deny a,b                 denied paths
-      --scopes group,group       tool groups (empty = all)
-      --read-only                refuse mutating tools
-      --rpm N                    max requests per minute
-      --expires YYYY-MM-DD       expiry date
+Paths the AI may touch (per token):
+  policy [--token N]                    Show policy
+  policy allow <path...> [--token N]    Allow one or more directories
+  policy deny <path...>  [--token N]    Deny directories
+  policy shell on|off    [--token N]    Toggle shell execution
+  policy scopes <groups> [--token N]    Limit to tool groups (or 'all')
+  policy readonly on|off                Global read-only kill-switch
 
-  policy [ID|name]               Show a token's policy
-  policy allow <path>            Allow a path (default token)
-  policy deny <path>             Deny a path
-  policy shell on|off            Enable/disable shell (default token)
-  policy readonly on|off         Global read-only kill-switch
+Tokens:
+  token list [--json]
+  token add --name N [--paths a,b] [--shell] [--scopes g,g]
+            [--read-only] [--rpm N] [--expires YYYY-MM-DD]
+  token show [N] [--full] | token rotate [N] | token revoke N
 
-  audit [query] [--tool T] [--since ISO] [--limit N]
-      [--verify] [--json]       Query the tamper-evident audit log
-  audit chain                    Verify hash-chain integrity
+Audit:
+  audit [--tool T] [--since ISO] [--limit N] [--json]
+  audit chain                   Verify tamper-evident hash chain
 
-  service install [--domain D]    Install systemd unit (+ nginx vhost)
-  service uninstall               Remove service + nginx vhost
-  service logs [-f]               Tail gateway logs
-  service status                  Detailed service check
+Service (autostart):
+  service install [--domain D]  systemd (Linux) / launchd (macOS) / schtasks (Windows)
+  service uninstall | logs [-f] | status
 
-  schedule list [--json]         List scheduled tasks
-  upgrade [--dry-run]           Self-upgrade from npm + restart service
+Other:
+  schedule list [--json]
+  scopes                        List available tool groups
 
 Options:
   -h, --help                    Show this help
-  --json                        Machine-readable output (where supported)
+  --json                        Machine-readable output where supported
 `;
 function parseArgs(argv) {
     const [command = '', ...rest] = argv;
     const sub = [];
     const flags = new Set();
     const values = new Map();
+    // Flags that always take a value (so `--paths /a /b` still works positionally)
+    const valueFlags = new Set(['name', 'paths', 'deny', 'scopes', 'rpm', 'expires', 'token', 'host', 'port', 'domain', 'tool', 'since', 'limit']);
     for (let i = 0; i < rest.length; i++) {
         const a = rest[i];
         if (a.startsWith('--')) {
             const key = a.slice(2);
+            const eq = key.indexOf('=');
+            if (eq > 0) {
+                values.set(key.slice(0, eq), key.slice(eq + 1));
+                continue;
+            }
             const next = rest[i + 1];
-            if (next !== undefined && !next.startsWith('-')) {
+            if (valueFlags.has(key) && next !== undefined && !next.startsWith('--')) {
                 values.set(key, next);
                 i++;
             }
@@ -80,7 +85,7 @@ function parseArgs(argv) {
                 flags.add(key);
             }
         }
-        else if (a.startsWith('-') && a.length > 1) {
+        else if (a.startsWith('-') && a.length > 1 && !/^-\d/.test(a)) {
             for (const c of a.slice(1))
                 flags.add(c);
         }
@@ -91,8 +96,9 @@ function parseArgs(argv) {
     return { command, sub, flags, values };
 }
 const jsonOut = (args) => args.flags.has('json');
+const splitList = (s) => (s || '').split(',').map(x => x.trim()).filter(Boolean);
 // ---------------------------------------------------------------------------
-// token lookup helper
+// helpers
 // ---------------------------------------------------------------------------
 function findToken(cfg, idOrName) {
     if (!idOrName)
@@ -104,8 +110,23 @@ function findToken(cfg, idOrName) {
     }
     return t;
 }
-function maskToken(t) {
-    return t.slice(0, 6) + '…' + t.slice(-4);
+const mask = (t) => t.slice(0, 6) + '…' + t.slice(-4);
+function run(cmd, args) {
+    try {
+        return execFileSync(cmd, args, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+    }
+    catch {
+        return '';
+    }
+}
+function banner() {
+    return `
+  ___                        _____
+ | _ \\__ _ __ _ ___ _ _   |_   _|__ _ _ _ __ _ ___
+ |   / _\` / _\` / -_) '_|    | |/ - \\ '_| '_/ _\` / -_)
+ |_|_\\__,_\\__, \\___|_|      |_|\\___/_| |_| \\__,_\\___|
+          |___/         ${PKG.name} v${PKG.version}
+`;
 }
 // ---------------------------------------------------------------------------
 // init
@@ -113,9 +134,20 @@ function maskToken(t) {
 function cmdInit(args) {
     const existing = fs.existsSync(configPath());
     const cfg = existing ? loadConfig() : null;
+    const extraPaths = [...splitList(args.values.get('paths')), ...args.sub].map(resolveReal);
     if (cfg && cfg.tokens.length) {
-        console.log('Config already exists with ' + cfg.tokens.length + ' token(s) — nothing to do.');
-        console.log('Add more tokens with: ramcp token add --name <name>');
+        if (extraPaths.length) {
+            const t = primaryToken(cfg);
+            for (const p of extraPaths)
+                if (!t.allowed_paths.includes(p))
+                    t.allowed_paths.push(p);
+            saveConfig(cfg);
+            console.log(`Added ${extraPaths.length} path(s) to token "${t.name}".`);
+            return;
+        }
+        console.log(`Config already exists with ${cfg.tokens.length} token(s) — nothing to do.`);
+        console.log('Add paths:   ramcp policy allow <dir>');
+        console.log('Add tokens:  ramcp token add --name <name>');
         return;
     }
     const fresh = cfg || {
@@ -128,29 +160,24 @@ function cmdInit(args) {
         read_only: false,
         tokens: [],
     };
-    const rec = newTokenRecord({ name: 'default' });
+    const rec = newTokenRecord({ name: 'default', allowed_paths: extraPaths });
     fresh.tokens.push(rec);
     saveConfig(fresh);
+    console.log(banner());
+    console.log(`platform:  ${platformLabel()}`);
+    console.log(`config:    ${configPath()}`);
+    console.log(`token:     ${mask(rec.token)}  (full: ramcp token show --full)`);
+    console.log(`paths:     ${extraPaths.length ? extraPaths.join(', ') : '(none — add with `ramcp policy allow <dir>`)'}`);
     console.log(`
-  ___                        _____
- | _ \\__ _ __ _ ___ _ _   |_   _|__ _ _ _ __ _ ___
- |   / _\` / _\` / -_) '_|    | |/ - \\ '_| '_/ _\` / -_)
- |_|_\\__,_\\__, \\___|_|      |_|\\___/_| |_| \\__,_\\___|
-          |___/         ${PKG.name} v${PKG.version}
-
-${existing ? '✔ Existing config migrated to v2' : '✔ Config written to ' + configPath()}
-✔ Token "default": ${maskToken(rec.token)} (full: ramcp token show default --full)
-✔ Audit log: ${fresh.audit.enabled ? 'enabled' : 'disabled'} (${fresh.audit.db_path})
-
 Next steps:
-  1. ramcp start                     # run in foreground
-  2. ramcp service install           # systemd + nginx (production)
-  3. ramcp policy allow /srv/myapp   # let the AI touch your project
-  4. ramcp url                       # connector URL for your chatbot
+  1. ramcp policy allow ~/projects     # what the AI may read/write
+  2. ramcp policy shell on             # optional: allow commands
+  3. ramcp tunnel                      # public https URL (laptops, no port forward)
+     or: ramcp service install         # autostart on a server with a domain
 `);
 }
 // ---------------------------------------------------------------------------
-// start
+// start / tunnel
 // ---------------------------------------------------------------------------
 async function cmdStart(args) {
     const { runServer } = await import('../server/run.js');
@@ -158,6 +185,16 @@ async function cmdStart(args) {
         host: args.values.get('host'),
         port: args.values.has('port') ? parseInt(args.values.get('port'), 10) : undefined,
         readOnly: args.flags.has('read-only'),
+        tunnel: args.flags.has('tunnel'),
+    });
+}
+async function cmdTunnel(args) {
+    const { runServer } = await import('../server/run.js');
+    await runServer({
+        host: args.values.get('host'),
+        port: args.values.has('port') ? parseInt(args.values.get('port'), 10) : undefined,
+        readOnly: args.flags.has('read-only'),
+        tunnel: true,
     });
 }
 // ---------------------------------------------------------------------------
@@ -165,33 +202,47 @@ async function cmdStart(args) {
 // ---------------------------------------------------------------------------
 function cmdUrl(args) {
     const cfg = loadConfig();
-    const t = findToken(cfg, args.sub[0]);
+    const t = findToken(cfg, args.sub[0] || args.values.get('token'));
     const host = cfg.public_host || `${cfg.host}:${cfg.port}`;
     const scheme = cfg.public_host ? 'https' : 'http';
     console.log(`${scheme}://${host}/${t.token}${cfg.mcp_path}`);
+    if (!cfg.public_host) {
+        console.log('\n(local URL — run `ramcp tunnel` for a public https link)');
+    }
 }
 // ---------------------------------------------------------------------------
-// token management
+// token
 // ---------------------------------------------------------------------------
 function cmdToken(args) {
     const cfg = loadConfig();
     const sub = args.sub[0];
-    if (sub === 'list') {
+    if (sub === 'list' || !sub) {
         if (jsonOut(args)) {
             console.log(JSON.stringify(cfg.tokens.map(t => ({
                 id: t.id, name: t.name, created: t.created, expires: t.expires || null,
                 scopes: t.scopes, read_only: !!t.read_only, shell: t.shell_enabled,
+                allowed_paths: t.allowed_paths, denied_paths: t.denied_paths,
+                rpm: t.max_requests_per_minute || null,
                 fingerprint: AuditLog.fingerprint(t.token),
             })), null, 2));
             return;
         }
         for (const t of cfg.tokens) {
-            console.log(`${t.id}  ${t.name.padEnd(16)} shell:${t.shell_enabled ? 'on ' : 'off'} ro:${t.read_only ? 'yes' : 'no '} ${t.expires ? 'expires ' + t.expires + ' ' : ''}${t.scopes.length ? 'scopes: ' + t.scopes.join(',') + ' ' : ''}fp:${AuditLog.fingerprint(t.token)}`);
+            const bits = [
+                t.id,
+                t.name.padEnd(16),
+                `shell:${t.shell_enabled ? 'on ' : 'off'}`,
+                `ro:${t.read_only ? 'yes' : 'no '}`,
+                `paths:${t.allowed_paths.length}`,
+                t.expires ? `expires:${t.expires.slice(0, 10)}` : '',
+                t.scopes.length ? `scopes:${t.scopes.join('|')}` : '',
+            ].filter(Boolean);
+            console.log(bits.join('  '));
         }
         return;
     }
     if (sub === 'add') {
-        const name = args.values.get('name');
+        const name = args.values.get('name') || args.sub[1];
         if (!name) {
             console.error('--name is required');
             process.exit(1);
@@ -203,107 +254,145 @@ function cmdToken(args) {
         const rec = newTokenRecord({
             name,
             shell_enabled: args.flags.has('shell') ? true : args.flags.has('no-shell') ? false : undefined,
-            allowed_paths: args.values.get('paths')?.split(',').map(s => s.trim()).filter(Boolean),
-            denied_paths: args.values.get('deny')?.split(',').map(s => s.trim()).filter(Boolean),
-            scopes: args.values.get('scopes')?.split(',').map(s => s.trim()).filter(Boolean),
+            allowed_paths: splitList(args.values.get('paths')).map(resolveReal),
+            denied_paths: splitList(args.values.get('deny')).map(resolveReal),
+            scopes: splitList(args.values.get('scopes')),
             read_only: args.flags.has('read-only'),
             max_requests_per_minute: args.values.has('rpm') ? parseInt(args.values.get('rpm'), 10) : undefined,
             expires: args.values.get('expires'),
         });
-        // resolve allowed paths to real paths
-        rec.allowed_paths = rec.allowed_paths.map(resolveReal);
-        rec.denied_paths = rec.denied_paths.map(resolveReal);
         cfg.tokens.push(rec);
         saveConfig(cfg);
+        const host = cfg.public_host || `${cfg.host}:${cfg.port}`;
+        const scheme = cfg.public_host ? 'https' : 'http';
         console.log(`Token "${name}" created (${rec.id})`);
-        console.log(`URL: https://${cfg.public_host || cfg.host + ':' + cfg.port}/${rec.token}${cfg.mcp_path}`);
-        restartHint();
+        console.log(`URL: ${scheme}://${host}/${rec.token}${cfg.mcp_path}`);
         return;
     }
     if (sub === 'show') {
-        const t = findToken(cfg, args.sub[1]);
-        if (args.flags.has('full'))
-            console.log(t.token);
-        else
-            console.log(`${t.name}: ${maskToken(t.token)} (use --full for the complete token)`);
+        const t = findToken(cfg, args.sub[1] || args.values.get('token'));
+        console.log(args.flags.has('full') ? t.token : `${t.name}: ${mask(t.token)} (--full for the complete token)`);
         return;
     }
     if (sub === 'rotate') {
-        const t = findToken(cfg, args.sub[1]);
+        const t = findToken(cfg, args.sub[1] || args.values.get('token'));
         t.token = generateToken();
         saveConfig(cfg);
         console.log(`Token "${t.name}" rotated: ${t.token}`);
-        console.log('Old token is dead. Update your chatbot connector now.');
-        restartHint();
+        console.log('Old token is dead. Update your chatbot connector.');
         return;
     }
     if (sub === 'revoke') {
-        const t = findToken(cfg, args.sub[1]);
-        cfg.tokens = cfg.tokens.filter(x => x !== t);
-        if (!cfg.tokens.length) {
+        const t = findToken(cfg, args.sub[1] || args.values.get('token'));
+        if (cfg.tokens.length === 1) {
             console.error('Cannot revoke the last token.');
             process.exit(1);
         }
+        cfg.tokens = cfg.tokens.filter(x => x !== t);
         saveConfig(cfg);
         console.log(`Token "${t.name}" (${t.id}) revoked.`);
-        restartHint();
         return;
     }
     console.log('Usage: ramcp token <list|add|show|rotate|revoke> …');
     process.exit(1);
 }
 // ---------------------------------------------------------------------------
-// policy
+// policy — multi-path, token-selectable
 // ---------------------------------------------------------------------------
 function cmdPolicy(args) {
     const cfg = loadConfig();
-    // global readonly toggle has no token selector
-    if (args.sub[0] === 'readonly' && (args.sub[1] === 'on' || args.sub[1] === 'off')) {
-        cfg.read_only = args.sub[1] === 'on';
+    const action = args.sub[0] || 'show';
+    // Global switch (no token selector)
+    if (action === 'readonly') {
+        const val = args.sub[1];
+        if (val !== 'on' && val !== 'off') {
+            console.error('Usage: ramcp policy readonly on|off');
+            process.exit(1);
+        }
+        cfg.read_only = val === 'on';
         saveConfig(cfg);
-        console.log(`Global read-only: ${cfg.read_only ? 'ON — mutating tools refused' : 'off'}`);
-        restartHint();
+        console.log(`Global read-only: ${cfg.read_only ? 'ON — all mutating tools refused' : 'off'}`);
         return;
     }
-    const t = findToken(cfg, args.sub[0] === 'allow' || args.sub[0] === 'deny' || args.sub[0] === 'shell' ? undefined : args.sub[0]);
-    const sub = args.sub[0] === 'allow' || args.sub[0] === 'deny' || args.sub[0] === 'shell' ? args.sub[0] : (args.sub[1] || 'show');
-    if (sub === 'allow' && args.values.size === 0 && !args.sub.find(s => s.startsWith('/'))) {
-        // ramcp policy allow <path> — path is in sub[1] (or sub[2] when selector given)
-    }
-    const pathArg = (() => {
-        const idx = args.sub.indexOf('allow') >= 0 ? args.sub.indexOf('allow') : args.sub.indexOf('deny');
-        return idx >= 0 ? args.sub[idx + 1] : undefined;
-    })();
-    if (sub === 'allow' && pathArg) {
-        const real = resolveReal(pathArg);
-        if (!t.allowed_paths.includes(real))
-            t.allowed_paths.push(real);
+    const t = findToken(cfg, args.values.get('token'));
+    const rest = args.sub.slice(1);
+    if (action === 'allow' || action === 'deny') {
+        const targets = [...rest, ...splitList(args.values.get('paths'))].map(resolveReal);
+        if (!targets.length) {
+            console.error(`Usage: ramcp policy ${action} <path> [path...] [--token N]`);
+            process.exit(1);
+        }
+        for (const p of targets) {
+            if (action === 'allow') {
+                t.denied_paths = t.denied_paths.filter(d => d !== p);
+                if (!t.allowed_paths.includes(p))
+                    t.allowed_paths.push(p);
+            }
+            else {
+                t.allowed_paths = t.allowed_paths.filter(a => a !== p);
+                if (!t.denied_paths.includes(p))
+                    t.denied_paths.push(p);
+            }
+        }
         saveConfig(cfg);
-        console.log(`Allowed: ${real}`);
-        restartHint();
-    }
-    else if (sub === 'deny' && pathArg) {
-        const real = resolveReal(pathArg);
-        t.allowed_paths = t.allowed_paths.filter((p) => p !== real);
-        if (!t.denied_paths.includes(real))
-            t.denied_paths.push(real);
+        console.log(`${action === 'allow' ? 'Allowed' : 'Denied'} for "${t.name}":`);
+        for (const p of targets)
+            console.log(`  ${p}`);
+        return;
+    }
+    if (action === 'shell') {
+        const val = rest[0];
+        if (val !== 'on' && val !== 'off') {
+            console.error('Usage: ramcp policy shell on|off [--token N]');
+            process.exit(1);
+        }
+        t.shell_enabled = val === 'on';
         saveConfig(cfg);
-        console.log(`Denied: ${real}`);
-        restartHint();
+        console.log(`Shell for "${t.name}": ${t.shell_enabled ? 'enabled' : 'disabled'}`);
+        return;
     }
-    else if (sub === 'shell' && (args.sub.includes('on') || args.sub.includes('off'))) {
-        t.shell_enabled = args.sub.includes('on');
+    if (action === 'scopes') {
+        const raw = rest.join(',') || args.values.get('scopes') || '';
+        if (!raw) {
+            console.error('Usage: ramcp policy scopes <group,group|all> [--token N]');
+            process.exit(1);
+        }
+        if (raw === 'all') {
+            t.scopes = [];
+        }
+        else {
+            const groups = splitList(raw);
+            const unknown = groups.filter(g => !(g in TOOL_SCOPES));
+            if (unknown.length) {
+                console.error(`Unknown scope group(s): ${unknown.join(', ')}`);
+                console.error(`Available: ${Object.keys(TOOL_SCOPES).join(', ')}`);
+                process.exit(1);
+            }
+            t.scopes = groups;
+        }
         saveConfig(cfg);
-        console.log(`Shell execution for "${t.name}": ${t.shell_enabled ? 'enabled' : 'disabled'}`);
-        restartHint();
+        console.log(`Scopes for "${t.name}": ${t.scopes.length ? t.scopes.join(', ') : '(all tools)'}`);
+        return;
     }
-    else {
-        console.log(`token:     ${t.name} (${t.id})`);
-        console.log(`allowed:   ${t.allowed_paths.length ? '\n  ' + t.allowed_paths.join('\n  ') : '(none)'}`);
-        console.log(`denied:    ${t.denied_paths.length ? '\n  ' + t.denied_paths.join('\n  ') : '(none)'}`);
-        console.log(`shell:     ${t.shell_enabled ? 'enabled' : 'disabled'}`);
-        console.log(`read_only: ${t.read_only ? 'yes' : 'no'}`);
-        console.log(`scopes:    ${t.scopes.length ? t.scopes.join(', ') : '(all tools)'}`);
+    // show
+    if (jsonOut(args)) {
+        console.log(JSON.stringify({
+            token: t.name, allowed_paths: t.allowed_paths, denied_paths: t.denied_paths,
+            shell: t.shell_enabled, read_only: !!t.read_only, scopes: t.scopes,
+            global_read_only: cfg.read_only,
+        }, null, 2));
+        return;
+    }
+    console.log(`token:      ${t.name} (${t.id})`);
+    console.log(`allowed:    ${t.allowed_paths.length ? '\n  ' + t.allowed_paths.join('\n  ') : '(none — the AI can read nothing)'}`);
+    console.log(`denied:     ${t.denied_paths.length ? '\n  ' + t.denied_paths.join('\n  ') : '(none)'}`);
+    console.log(`shell:      ${t.shell_enabled ? 'enabled' : 'disabled'}`);
+    console.log(`read_only:  ${t.read_only ? 'yes' : 'no'}${cfg.read_only ? '  (global read-only is ON)' : ''}`);
+    console.log(`scopes:     ${t.scopes.length ? t.scopes.join(', ') : '(all tools)'}`);
+}
+function cmdScopes() {
+    for (const [group, tools] of Object.entries(TOOL_SCOPES)) {
+        console.log(`${group.padEnd(12)} ${tools.join(', ')}`);
     }
 }
 // ---------------------------------------------------------------------------
@@ -312,14 +401,14 @@ function cmdPolicy(args) {
 function cmdAudit(args) {
     const cfg = loadConfig();
     if (!cfg.audit.enabled) {
-        console.log('Audit log is disabled (audit.enabled = false).');
+        console.log('Audit log is disabled.');
         return;
     }
     const audit = new AuditLog(cfg.audit.db_path);
     if (args.sub[0] === 'chain' || args.flags.has('verify')) {
-        const tampered = audit.verify();
-        console.log(tampered === null ? '✔ hash chain intact' : `✖ TAMPERED — first bad row id: ${tampered}`);
-        process.exit(tampered === null ? 0 : 2);
+        const bad = audit.verify();
+        console.log(bad === null ? '✔ hash chain intact' : `✖ TAMPERED — first bad entry: line ${bad}`);
+        process.exit(bad === null ? 0 : 2);
     }
     const rows = audit.query({
         tool: args.values.get('tool'),
@@ -328,181 +417,278 @@ function cmdAudit(args) {
     });
     if (jsonOut(args)) {
         console.log(JSON.stringify(rows, null, 2));
+        return;
     }
-    else {
-        if (!rows.length) {
-            console.log('(no audit entries)');
-            return;
-        }
-        for (const r of rows) {
-            const d = new Date(r.ts).toISOString().slice(0, 19);
-            console.log(`${d}  fp:${r.token_fingerprint}  ${r.tool.padEnd(20)} ${r.is_error ? 'ERR ' : 'ok  '} ${r.duration_ms}ms`);
-        }
+    if (!rows.length) {
+        console.log('(no audit entries)');
+        return;
+    }
+    for (const r of rows) {
+        console.log(`${new Date(r.ts).toISOString().slice(0, 19)}  fp:${r.token_fingerprint}  ${r.tool.padEnd(22)} ${r.is_error ? 'ERR' : 'ok '} ${r.duration_ms}ms`);
     }
-    audit.close();
 }
 // ---------------------------------------------------------------------------
 // doctor
 // ---------------------------------------------------------------------------
 async function cmdDoctor(args) {
     const results = [];
-    const ok = (name, msg) => results.push([`✔ ${name}`, msg]);
-    const bad = (name, msg) => results.push([`✖ ${name}`, msg]);
-    const warn = (name, msg) => results.push([`⚠ ${name}`, msg]);
+    const ok = (n, m) => results.push([`✔ ${n}`, m]);
+    const bad = (n, m) => results.push([`✖ ${n}`, m]);
+    const warn = (n, m) => results.push([`⚠ ${n}`, m]);
     const cfg = loadConfig();
-    // 1. token
-    if (cfg.tokens.length)
-        ok('tokens', `${cfg.tokens.length} configured, primary: ${cfg.tokens[0].name}`);
-    else
+    ok('platform', platformLabel());
+    ok('config', configPath());
+    if (cfg.tokens.length) {
+        const withPaths = cfg.tokens.filter(t => t.allowed_paths.length).length;
+        ok('tokens', `${cfg.tokens.length} configured, ${withPaths} with path access`);
+        if (!withPaths)
+            warn('paths', 'no token has any allowed path — add with `ramcp policy allow <dir>`');
+    }
+    else {
         bad('tokens', 'none — run `ramcp init`');
-    // 2. bind port free?
+    }
+    // port / gateway
     const inUse = await new Promise((resolve) => {
         const srv = net.createServer();
         srv.once('error', () => resolve(true));
-        srv.once('listening', () => { srv.close(() => resolve(false)); });
+        srv.once('listening', () => srv.close(() => resolve(false)));
         srv.listen(cfg.port, cfg.host);
     });
-    const serviceActive = fs.existsSync(SERVICE_FILE) && run('systemctl', ['is-active', SERVICE_NAME]).trim() === 'active';
+    const svcActive = serviceIsActive();
     if (inUse) {
-        serviceActive ? ok('port', `${cfg.host}:${cfg.port} in use by the running service`) : warn('port', `${cfg.host}:${cfg.port} in use by ANOTHER process`);
-    }
-    else {
-        serviceActive ? warn('port', `port free but service claims active — crashed?`) : warn('port', `not listening — start with \`ramcp service install\` or \`ramcp start\``);
-    }
-    // 3. gateway answers?
-    if (!inUse || serviceActive) {
         try {
-            const resp = await fetch(`http://${cfg.host}:${cfg.port}/health`);
+            const resp = await fetch(`http://${cfg.host}:${cfg.port}/health`, { signal: AbortSignal.timeout(4000) });
             const body = (await resp.json());
-            if (body.status === 'ok')
-                ok('gateway', `healthy (v${body.version})`);
-            else
-                bad('gateway', `unexpected: ${JSON.stringify(body)}`);
+            body.status === 'ok'
+                ? ok('gateway', `healthy on ${cfg.host}:${cfg.port} (v${body.version})`)
+                : bad('gateway', `unexpected reply: ${JSON.stringify(body)}`);
         }
         catch {
-            bad('gateway', `no answer on ${cfg.host}:${cfg.port}/health`);
+            warn('gateway', `port ${cfg.port} is in use but /health did not answer — another app?`);
         }
     }
-    // 4. nginx vhost?
+    else {
+        warn('gateway', `not running — start with \`ramcp tunnel\` or \`ramcp start\``);
+    }
+    if (svcActive)
+        ok('service', `${serviceLabel()} active`);
+    else if (serviceIsInstalled())
+        warn('service', `${serviceLabel()} installed but not active`);
+    // tunnel readiness
+    const cf = resolveCloudflared();
+    cf ? ok('tunnel', `cloudflared ready (${cf})`) : warn('tunnel', 'cloudflared not installed yet — `ramcp tunnel` downloads it automatically');
+    // public reachability
     if (cfg.public_host) {
-        const vhost = `/etc/nginx/sites-enabled/${cfg.public_host}`;
-        if (fs.existsSync(vhost)) {
-            const conf = fs.readFileSync(vhost, 'utf8');
-            if (conf.includes(`proxy_pass http://${cfg.host}:${cfg.port}`)) {
-                ok('nginx', `vhost for ${cfg.public_host} → ${cfg.host}:${cfg.port}`);
-            }
-            else {
-                warn('nginx', `${vhost} exists but does not proxy to ${cfg.host}:${cfg.port}`);
-            }
-        }
-        else {
-            warn('nginx', `no vhost at ${vhost} — run \`ramcp service install --domain ${cfg.public_host}\``);
-        }
-        // 5. public DNS resolves + Cloudflare edge reachable?
         try {
             const resp = await fetch(`https://${cfg.public_host}/health`, { signal: AbortSignal.timeout(8000) });
             const body = (await resp.json());
-            if (body.status === 'ok')
-                ok('public', `https://${cfg.public_host} healthy end-to-end`);
-            else
-                warn('public', `got status ${resp.status} from edge`);
+            body.status === 'ok' ? ok('public', `https://${cfg.public_host} reachable`) : warn('public', `edge answered ${resp.status}`);
         }
         catch (e) {
-            warn('public', `https://${cfg.public_host} unreachable: ${e.message}`);
+            warn('public', `https://${cfg.public_host} unreachable (${e.message})`);
         }
     }
-    // 6. audit chain
-    if (cfg.audit.enabled && fs.existsSync(cfg.audit.db_path.replace(/\.db$/, '') + '.jsonl')) {
-        const audit = new AuditLog(cfg.audit.db_path);
-        const tampered = audit.verify();
-        tampered === null ? ok('audit', 'hash chain intact') : bad('audit', `tampered at row ${tampered}`);
-        audit.close();
-    }
-    else if (cfg.audit.enabled) {
-        warn('audit', 'enabled but db not created yet');
-    }
-    for (const [name, msg] of results)
-        console.log(`${name.padEnd(14)} ${msg}`);
-    const hasBad = results.some(r => r[0].startsWith('✖'));
-    process.exitCode = hasBad ? 1 : 0;
-}
-function run(cmd, args) {
-    try {
-        return execFileSync(cmd, args, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
-    }
-    catch {
-        return '';
+    // audit
+    if (cfg.audit.enabled) {
+        const file = cfg.audit.db_path.replace(/\.db$/, '') + (cfg.audit.db_path.endsWith('.jsonl') ? '' : '.jsonl');
+        if (fs.existsSync(file) || fs.existsSync(cfg.audit.db_path)) {
+            const a = new AuditLog(cfg.audit.db_path);
+            const t = a.verify();
+            t === null ? ok('audit', 'hash chain intact') : bad('audit', `tampered at line ${t}`);
+        }
+        else {
+            warn('audit', 'enabled, no entries yet');
+        }
     }
+    for (const [n, m] of results)
+        console.log(`${n.padEnd(14)} ${m}`);
+    process.exitCode = results.some(r => r[0].startsWith('✖')) ? 1 : 0;
 }
 // ---------------------------------------------------------------------------
-// service
+// service — systemd / launchd / schtasks
 // ---------------------------------------------------------------------------
 const SERVICE_NAME = 'remote-access-mcp';
-const SERVICE_FILE = `/etc/systemd/system/${SERVICE_NAME}.service`;
-function isSystemdInstalled() {
-    return fs.existsSync(SERVICE_FILE);
+const SYSTEMD_FILE = `/etc/systemd/system/${SERVICE_NAME}.service`;
+const LAUNCHD_LABEL = 'ir.amiralimanzar.ramcp';
+const launchdFile = () => path.join(os.homedir(), 'Library', 'LaunchAgents', `${LAUNCHD_LABEL}.plist`);
+const SCHTASK_NAME = 'RemoteAccessMCP';
+function serviceLabel() {
+    if (hasSystemd())
+        return 'systemd unit';
+    if (isMac())
+        return 'launchd agent';
+    if (isWindows())
+        return 'scheduled task';
+    return 'service';
 }
-function restartHint() {
-    if (isSystemdInstalled()) {
-        console.log('(service restarts automatically on next request — config hot-reloads)');
-    }
+function serviceIsInstalled() {
+    if (hasSystemd())
+        return fs.existsSync(SYSTEMD_FILE);
+    if (isMac())
+        return fs.existsSync(launchdFile());
+    if (isWindows())
+        return run('schtasks', ['/query', '/tn', SCHTASK_NAME]).length > 0;
+    return false;
+}
+function serviceIsActive() {
+    if (hasSystemd())
+        return run('systemctl', ['is-active', SERVICE_NAME]).trim() === 'active';
+    if (isMac())
+        return run('launchctl', ['list']).includes(LAUNCHD_LABEL);
+    if (isWindows())
+        return /Running/i.test(run('schtasks', ['/query', '/tn', SCHTASK_NAME, '/fo', 'LIST', '/v']));
+    return false;
 }
 function cmdService(args) {
     const sub = args.sub[0] || '';
-    if (sub === 'install') {
-        installService(args);
-    }
-    else if (sub === 'uninstall') {
-        uninstallService();
-    }
-    else if (sub === 'logs') {
-        const flags = args.flags.has('f') || args.flags.has('follow') ? ['-f'] : [];
-        try {
-            execFileSync('journalctl', ['-u', SERVICE_NAME, '-n', '100', ...flags], { stdio: 'inherit' });
+    if (sub === 'install')
+        return installService(args);
+    if (sub === 'uninstall')
+        return uninstallService();
+    if (sub === 'status')
+        return cmdStatus();
+    if (sub === 'logs') {
+        if (hasSystemd()) {
+            const f = args.flags.has('f') || args.flags.has('follow') ? ['-f'] : [];
+            try {
+                execFileSync('journalctl', ['-u', SERVICE_NAME, '-n', '100', ...f], { stdio: 'inherit' });
+            }
+            catch (e) {
+                console.error(e.message);
+                process.exit(1);
+            }
+            return;
         }
-        catch (e) {
-            console.error(e.message);
-            process.exit(1);
+        const log = path.join(configDir(), 'gateway.log');
+        if (!fs.existsSync(log)) {
+            console.log(`No log file at ${log}`);
+            return;
         }
+        if (args.flags.has('f') || args.flags.has('follow')) {
+            console.log(`(following ${log} — Ctrl+C to stop)`);
+            let size = fs.statSync(log).size;
+            setInterval(() => {
+                const s = fs.statSync(log).size;
+                if (s > size) {
+                    const fd = fs.openSync(log, 'r');
+                    const buf = Buffer.alloc(s - size);
+                    fs.readSync(fd, buf, 0, buf.length, size);
+                    fs.closeSync(fd);
+                    process.stdout.write(buf.toString());
+                    size = s;
+                }
+            }, 700);
+            return;
+        }
+        const content = fs.readFileSync(log, 'utf8').split('\n').slice(-100).join('\n');
+        console.log(content);
+        return;
     }
-    else if (sub === 'status') {
-        cmdStatus();
-    }
-    else {
-        console.log('Usage: ramcp service <install [--domain D]|uninstall|logs [-f]|status>');
-        process.exit(1);
-    }
+    console.log('Usage: ramcp service <install [--domain D]|uninstall|logs [-f]|status>');
+    process.exit(1);
 }
 function installService(args) {
-    if (process.getuid?.() !== 0) {
-        console.error('service install requires root (sudo).');
-        process.exit(1);
-    }
-    const domain = args.values.get('domain') || '';
     const cfg = loadConfig();
     const nodeBin = process.execPath;
-    const pkgRoot = PKG_ROOT;
-    const unit = `[Unit]
+    const entry = path.join(PKG_ROOT, 'dist', 'server', 'run.js');
+    const dryRun = args.flags.has('dry-run');
+    const wantTunnel = args.flags.has('tunnel');
+    const domain = args.values.get('domain') || '';
+    // ---- Linux (systemd) ----
+    if (hasSystemd()) {
+        if (process.getuid?.() !== 0) {
+            console.error('systemd install requires root (sudo).');
+            process.exit(1);
+        }
+        const unit = `[Unit]
 Description=Remote Access MCP Gateway
 After=network.target
 
 [Service]
 Type=simple
-ExecStart=${nodeBin} ${pkgRoot}/dist/server/run.js
+ExecStart=${nodeBin} ${entry}${wantTunnel ? ' --tunnel' : ''}
 Restart=on-failure
 RestartSec=5
 Environment=NODE_ENV=production
+Environment=HOME=${os.homedir()}
 
 [Install]
 WantedBy=multi-user.target
 `;
-    fs.writeFileSync(SERVICE_FILE, unit);
-    execFileSync('systemctl', ['daemon-reload']);
-    execFileSync('systemctl', ['enable', '--now', SERVICE_NAME]);
-    console.log(`✔ systemd service installed and started: ${SERVICE_NAME}`);
-    if (domain) {
-        const nginxFile = `/etc/nginx/sites-available/${domain}`;
-        const vhost = `server {
+        if (dryRun) {
+            console.log(`--- ${SYSTEMD_FILE} ---\n${unit}`);
+            return;
+        }
+        fs.writeFileSync(SYSTEMD_FILE, unit);
+        execFileSync('systemctl', ['daemon-reload']);
+        execFileSync('systemctl', ['enable', '--now', SERVICE_NAME]);
+        console.log(`✔ systemd service installed and started: ${SERVICE_NAME}`);
+        if (domain)
+            installNginx(domain, cfg, dryRun);
+        else
+            console.log('Tip: --domain mcp.example.com also writes an nginx vhost.');
+        return;
+    }
+    // ---- macOS (launchd, per-user, no sudo) ----
+    if (isMac()) {
+        const out = path.join(configDir(), 'gateway.log');
+        const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>${LAUNCHD_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${nodeBin}</string>
+    <string>${entry}</string>${wantTunnel ? '\n    <string>--tunnel</string>' : ''}
+  </array>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><true/>
+  <key>StandardOutPath</key><string>${out}</string>
+  <key>StandardErrorPath</key><string>${out}</string>
+  <key>EnvironmentVariables</key>
+  <dict><key>HOME</key><string>${os.homedir()}</string></dict>
+</dict>
+</plist>
+`;
+        if (dryRun) {
+            console.log(`--- ${launchdFile()} ---\n${plist}`);
+            return;
+        }
+        fs.mkdirSync(path.dirname(launchdFile()), { recursive: true });
+        fs.writeFileSync(launchdFile(), plist);
+        run('launchctl', ['unload', launchdFile()]);
+        execFileSync('launchctl', ['load', '-w', launchdFile()]);
+        console.log(`✔ launchd agent installed: ${LAUNCHD_LABEL}`);
+        console.log(`  logs: ${out}`);
+        return;
+    }
+    // ---- Windows (Scheduled Task at logon, no admin needed) ----
+    if (isWindows()) {
+        const log = path.join(configDir(), 'gateway.log');
+        const cmd = `"${nodeBin}" "${entry}"${wantTunnel ? ' --tunnel' : ''}`;
+        if (dryRun) {
+            console.log(`schtasks /create /tn ${SCHTASK_NAME} /tr ${cmd} /sc onlogon /rl limited /f`);
+            return;
+        }
+        try {
+            execFileSync('schtasks', ['/create', '/tn', SCHTASK_NAME, '/tr', cmd, '/sc', 'onlogon', '/rl', 'limited', '/f'], { stdio: 'inherit' });
+            execFileSync('schtasks', ['/run', '/tn', SCHTASK_NAME], { stdio: 'inherit' });
+            console.log(`✔ scheduled task installed and started: ${SCHTASK_NAME}`);
+            console.log(`  logs: ${log}`);
+        }
+        catch (e) {
+            console.error(`schtasks failed: ${e.message}`);
+            process.exit(1);
+        }
+        return;
+    }
+    console.error(`No supported service manager on ${platform()}. Run \`ramcp start\` manually or use your own supervisor.`);
+    process.exit(1);
+}
+function installNginx(domain, cfg, dryRun) {
+    const nginxFile = `/etc/nginx/sites-available/${domain}`;
+    const vhost = `server {
     listen 80;
     listen [::]:80;
     server_name ${domain};
@@ -527,75 +713,149 @@ WantedBy=multi-user.target
     error_log  /var/log/nginx/${domain}.error.log;
 }
 `;
-        fs.writeFileSync(nginxFile, vhost);
-        const link = `/etc/nginx/sites-enabled/${domain}`;
-        if (!fs.existsSync(link))
-            fs.symlinkSync(nginxFile, link);
-        try {
-            execFileSync('nginx', ['-t']);
-            execFileSync('systemctl', ['reload', 'nginx']);
-            console.log(`✔ nginx vhost installed: ${domain} → ${cfg.host}:${cfg.port}`);
-        }
-        catch (e) {
-            console.error(`nginx config test failed:\n${e.stdout || e.message}`);
-            process.exit(1);
-        }
+    if (dryRun) {
+        console.log(`--- ${nginxFile} ---\n${vhost}`);
+        return;
     }
-    else {
-        console.log('Note: pass --domain mcp.example.com to also install the nginx vhost.');
+    fs.writeFileSync(nginxFile, vhost);
+    const link = `/etc/nginx/sites-enabled/${domain}`;
+    if (!fs.existsSync(link))
+        fs.symlinkSync(nginxFile, link);
+    try {
+        execFileSync('nginx', ['-t']);
+        execFileSync('systemctl', ['reload', 'nginx']);
+        console.log(`✔ nginx vhost installed: ${domain} → ${cfg.host}:${cfg.port}`);
     }
-}
-function uninstallService() {
-    if (process.getuid?.() !== 0) {
-        console.error('service uninstall requires root (sudo).');
+    catch (e) {
+        console.error(`nginx config test failed:\n${e.stdout || e.message}`);
         process.exit(1);
     }
-    if (fs.existsSync(SERVICE_FILE)) {
-        try {
-            execFileSync('systemctl', ['disable', '--now', SERVICE_NAME]);
+}
+function uninstallService() {
+    if (hasSystemd()) {
+        if (process.getuid?.() !== 0) {
+            console.error('uninstall requires root (sudo).');
+            process.exit(1);
         }
-        catch { /* not running */ }
-        fs.unlinkSync(SERVICE_FILE);
-        execFileSync('systemctl', ['daemon-reload']);
-        console.log(`✔ systemd service removed`);
-    }
-    else {
-        console.log('Service not installed.');
-    }
-    const sitesDir = '/etc/nginx/sites-enabled';
-    if (fs.existsSync(sitesDir)) {
-        const cfg = loadConfig();
-        for (const f of fs.readdirSync(sitesDir)) {
-            try {
-                const content = fs.readFileSync(path.join(sitesDir, f), 'utf8');
-                if (content.includes(`proxy_pass http://${cfg.host}:${cfg.port}`)) {
-                    fs.unlinkSync(path.join(sitesDir, f));
-                    console.log(`✔ nginx vhost removed: ${f}`);
+        if (fs.existsSync(SYSTEMD_FILE)) {
+            run('systemctl', ['disable', '--now', SERVICE_NAME]);
+            fs.unlinkSync(SYSTEMD_FILE);
+            execFileSync('systemctl', ['daemon-reload']);
+            console.log('✔ systemd service removed');
+        }
+        else
+            console.log('Service not installed.');
+        const sitesDir = '/etc/nginx/sites-enabled';
+        if (fs.existsSync(sitesDir)) {
+            const cfg = loadConfig();
+            for (const f of fs.readdirSync(sitesDir)) {
+                try {
+                    if (fs.readFileSync(path.join(sitesDir, f), 'utf8').includes(`proxy_pass http://${cfg.host}:${cfg.port}`)) {
+                        fs.unlinkSync(path.join(sitesDir, f));
+                        console.log(`✔ nginx vhost removed: ${f}`);
+                    }
                 }
+                catch { /* skip */ }
             }
-            catch { /* skip unreadable */ }
+            run('nginx', ['-t']) && run('systemctl', ['reload', 'nginx']);
         }
+        return;
+    }
+    if (isMac()) {
+        if (fs.existsSync(launchdFile())) {
+            run('launchctl', ['unload', '-w', launchdFile()]);
+            fs.unlinkSync(launchdFile());
+            console.log('✔ launchd agent removed');
+        }
+        else
+            console.log('Agent not installed.');
+        return;
+    }
+    if (isWindows()) {
         try {
-            execFileSync('nginx', ['-t']);
-            execFileSync('systemctl', ['reload', 'nginx']);
+            execFileSync('schtasks', ['/delete', '/tn', SCHTASK_NAME, '/f'], { stdio: 'inherit' });
+            console.log('✔ scheduled task removed');
+        }
+        catch {
+            console.log('Task not installed.');
         }
-        catch { /* nginx may be absent */ }
+        return;
     }
+    console.log(`Nothing to uninstall on ${platform()}.`);
 }
 // ---------------------------------------------------------------------------
 // status
 // ---------------------------------------------------------------------------
 function cmdStatus() {
-    const installed = isSystemdInstalled();
-    console.log(`service installed: ${installed ? 'yes' : 'no'}`);
-    if (installed) {
-        console.log(`service status:   ${run('systemctl', ['is-active', SERVICE_NAME]).trim() || 'unknown'}`);
-    }
     const cfg = loadConfig();
-    console.log(`listen:           ${cfg.host}:${cfg.port}`);
-    console.log(`tokens:           ${cfg.tokens.length}`);
-    console.log(`audit:            ${cfg.audit.enabled ? 'on' : 'off'}`);
-    console.log(`read_only:        ${cfg.read_only ? 'on' : 'off'}`);
+    console.log(`platform:          ${platformLabel()}`);
+    console.log(`config:            ${configPath()}`);
+    console.log(`${serviceLabel()}:${' '.repeat(Math.max(1, 19 - serviceLabel().length - 1))}${serviceIsInstalled() ? (serviceIsActive() ? 'installed, active' : 'installed, inactive') : 'not installed'}`);
+    console.log(`listen:            ${cfg.host}:${cfg.port}${cfg.mcp_path}`);
+    console.log(`public_host:       ${cfg.public_host || '(none — use `ramcp tunnel`)'}`);
+    console.log(`tokens:            ${cfg.tokens.length}`);
+    console.log(`allowed paths:     ${cfg.tokens.reduce((n, t) => n + t.allowed_paths.length, 0)}`);
+    console.log(`audit:             ${cfg.audit.enabled ? 'on' : 'off'}`);
+    console.log(`read_only:         ${cfg.read_only ? 'on' : 'off'}`);
+}
+// ---------------------------------------------------------------------------
+// schedule / upgrade
+// ---------------------------------------------------------------------------
+function cmdSchedule(args) {
+    const p = path.join(configDir(), 'schedule.json');
+    if (jsonOut(args)) {
+        console.log(fs.existsSync(p) ? fs.readFileSync(p, 'utf8') : '[]');
+        return;
+    }
+    try {
+        const tasks = JSON.parse(fs.readFileSync(p, 'utf8'));
+        if (!tasks.length) {
+            console.log('(no scheduled tasks)');
+            return;
+        }
+        for (const t of tasks)
+            console.log(`${t.id} | ${t.enabled ? 'on' : 'off'} | ${t.command} | next: ${t.next_run || t.run_at || '-'}`);
+    }
+    catch {
+        console.log('(no scheduled tasks)');
+    }
+}
+async function cmdUpgrade(args) {
+    console.log(`current: v${PKG.version}`);
+    const latest = await fetch('https://registry.npmjs.org/remote-access-mcp/latest')
+        .then(r => r.json()).then((j) => j.version)
+        .catch(() => null);
+    if (!latest) {
+        console.error('could not reach npm registry');
+        process.exit(1);
+    }
+    if (latest === PKG.version) {
+        console.log('already up to date');
+        return;
+    }
+    console.log(`latest:  v${latest}`);
+    if (args.flags.has('dry-run')) {
+        console.log('(dry-run — no changes)');
+        return;
+    }
+    if (isLinux() && process.getuid?.() !== 0) {
+        console.error('upgrade requires root (sudo) for a global npm install');
+        process.exit(1);
+    }
+    execFileSync('npm', ['install', '-g', `remote-access-mcp@${latest}`], { stdio: 'inherit' });
+    if (serviceIsInstalled()) {
+        if (hasSystemd())
+            run('systemctl', ['restart', SERVICE_NAME]);
+        else if (isMac()) {
+            run('launchctl', ['unload', launchdFile()]);
+            run('launchctl', ['load', '-w', launchdFile()]);
+        }
+        else if (isWindows()) {
+            run('schtasks', ['/end', '/tn', SCHTASK_NAME]);
+            run('schtasks', ['/run', '/tn', SCHTASK_NAME]);
+        }
+        console.log(`service restarted on v${latest}`);
+    }
 }
 // ---------------------------------------------------------------------------
 // main
@@ -613,6 +873,9 @@ export async function main(argv) {
         case 'start':
             await cmdStart(args);
             break;
+        case 'tunnel':
+            await cmdTunnel(args);
+            break;
         case 'url':
             cmdUrl(args);
             break;
@@ -622,6 +885,9 @@ export async function main(argv) {
         case 'policy':
             cmdPolicy(args);
             break;
+        case 'scopes':
+            cmdScopes();
+            break;
         case 'audit':
             cmdAudit(args);
             break;
@@ -653,63 +919,4 @@ export async function main(argv) {
             process.exit(1);
     }
 }
-// ---------------------------------------------------------------------------
-// schedule
-// ---------------------------------------------------------------------------
-function cmdSchedule(args) {
-    const p = path.join(os.homedir(), '.config', 'remote-access-mcp', 'schedule.json');
-    if (args.flags.has('json')) {
-        console.log(fs.existsSync(p) ? fs.readFileSync(p, 'utf8') : '[]');
-        return;
-    }
-    try {
-        const tasks = JSON.parse(fs.readFileSync(p, 'utf8'));
-        if (!tasks.length) {
-            console.log('(no scheduled tasks)');
-            return;
-        }
-        for (const t of tasks) {
-            console.log(`${t.id} | ${t.enabled ? 'on' : 'off'} | ${t.command} | next: ${t.next_run || t.run_at || '-'}`);
-        }
-    }
-    catch {
-        console.log('(no scheduled tasks)');
-    }
-}
-// ---------------------------------------------------------------------------
-// upgrade
-// ---------------------------------------------------------------------------
-async function cmdUpgrade(args) {
-    const dryRun = args.flags.has('dry-run');
-    console.log(`current: v${PKG.version}`);
-    // Check latest from npm registry
-    const latest = await fetch('https://registry.npmjs.org/remote-access-mcp/latest')
-        .then(r => r.json())
-        .then((j) => j.version)
-        .catch(() => null);
-    if (!latest) {
-        console.error('could not reach npm registry');
-        process.exit(1);
-    }
-    if (latest === PKG.version) {
-        console.log('already up to date');
-        return;
-    }
-    console.log(`latest:  v${latest}`);
-    if (dryRun) {
-        console.log('(dry-run — no changes made)');
-        return;
-    }
-    if (process.getuid?.() !== 0) {
-        console.error('upgrade requires root (sudo)');
-        process.exit(1);
-    }
-    console.log('upgrading…');
-    const { execFileSync } = await import('node:child_process');
-    execFileSync('npm', ['install', '-g', `remote-access-mcp@${latest}`], { stdio: 'inherit' });
-    if (isSystemdInstalled()) {
-        execFileSync('systemctl', ['restart', SERVICE_NAME]);
-        console.log(`service restarted on v${latest}`);
-    }
-}
 //# sourceMappingURL=main.js.map