openclaw-scheduler 0.2.0

package/setup.mjs

@@ -0,0 +1,724 @@
+#!/usr/bin/env node
+/**
+ * OpenClaw Scheduler -- Interactive Setup Wizard
+ *
+ * Run from the scheduler directory:
+ *   node setup.mjs
+ *
+ * What it does:
+ *  1. Runs DB migrations (creates/upgrades scheduler.db)
+ *  2. Appends scheduler queue/consumer entries to MEMORY.md + workspace-index.md
+ *  3. Creates Inbox Consumer + Stuck Run Detector scheduler jobs
+ *  4. Installs a macOS launchd service (LaunchAgent or LaunchDaemon, optional)
+ */
+
+import readline from 'readline';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { execSync } from 'child_process';
+
+import { fileURLToPath } from 'url';
+import { ensureSchedulerDbParent, resolveSchedulerDbPath } from './paths.js';
+import { createJob } from './jobs.js';
+import { initDb } from './db.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const VALID_MAC_SERVICE_MODES = new Set(['agent', 'daemon', 'skip']);
+
+function xmlEscape(value) {
+  return String(value)
+    .replaceAll('&', '&')
+    .replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;')
+    .replaceAll('"', '&quot;')
+    .replaceAll("'", '&apos;');
+}
+
+function printSetupUsage() {
+  process.stdout.write(`OpenClaw Scheduler setup
+
+Usage:
+  node setup.mjs [--service-mode agent|daemon|skip]
+
+Options:
+  --service-mode <mode>   macOS only. Choose launchd install mode.
+                          agent  -> user LaunchAgent (best for auto-login workstation use)
+                          daemon -> system LaunchDaemon (best for headless/pre-login startup)
+                          skip   -> do not install a macOS service
+  -h, --help             Show this help
+`);
+}
+
+function parseSetupArgs(argv) {
+  const options = { help: false, serviceMode: null };
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === '--help' || arg === '-h') {
+      options.help = true;
+      continue;
+    }
+    if (arg === '--service-mode') {
+      const value = argv[i + 1];
+      if (!value) throw new Error('--service-mode requires a value: agent, daemon, or skip');
+      options.serviceMode = value;
+      i += 1;
+      continue;
+    }
+    if (arg.startsWith('--service-mode=')) {
+      options.serviceMode = arg.split('=')[1] || '';
+      continue;
+    }
+    throw new Error(`Unknown option: ${arg}`);
+  }
+  if (options.serviceMode && !VALID_MAC_SERVICE_MODES.has(options.serviceMode)) {
+    throw new Error(`Invalid --service-mode "${options.serviceMode}". Use agent, daemon, or skip.`);
+  }
+  return options;
+}
+
+const setupOptions = (() => {
+  try {
+    return parseSetupArgs(process.argv.slice(2));
+  } catch (err) {
+    process.stderr.write(`Error: ${err.message}\n`);
+    printSetupUsage();
+    process.exit(1);
+  }
+})();
+
+if (setupOptions.help) {
+  printSetupUsage();
+  process.exit(0);
+}
+
+// --- Helpers ------------------------------------------------------------------
+
+const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+const ask = (q, def) => new Promise(resolve => {
+  const hint = def ? ` (${def})` : '';
+  rl.question(`${q}${hint}: `, ans => resolve(ans.trim() || def || ''));
+});
+const confirm = async (q) => {
+  const ans = await ask(`${q} [y/N]`);
+  return /^y(es)?$/i.test(ans);
+};
+const print = (msg = '') => console.log(msg);
+const ok   = (msg) => console.log(`  [ok] ${msg}`);
+const warn = (msg) => console.log(`  [WARN] ${msg}`);
+const skip = (msg) => console.log(`  [skip] ${msg}`);
+
+function appendIfMissing(filePath, anchor, content) {
+  if (!fs.existsSync(filePath)) return false;
+  const existing = fs.readFileSync(filePath, 'utf8');
+  if (existing.includes(anchor)) return 'exists';
+  fs.appendFileSync(filePath, '\n' + content + '\n');
+  return true;
+}
+
+function getNpmConfigValue(key) {
+  try {
+    return execSync(`npm config get ${key}`, { encoding: 'utf8' }).trim();
+  } catch {
+    return '';
+  }
+}
+
+function getGatewayToken(homeDir) {
+  if (process.env.OPENCLAW_GATEWAY_TOKEN) return process.env.OPENCLAW_GATEWAY_TOKEN;
+  try {
+    const cfgPath = path.join(homeDir, '.openclaw', 'openclaw.json');
+    const cfg = JSON.parse(fs.readFileSync(cfgPath, 'utf8'));
+    return cfg?.gateway?.auth?.token || '';
+  } catch {
+    return '';
+  }
+}
+
+// --- Main ---------------------------------------------------------------------
+
+print();
+print('+======================================================+');
+print('|     OpenClaw Scheduler -- Setup Wizard               |');
+print('+======================================================+');
+print();
+print('This wizard will:');
+print('  * Run DB migrations');
+print('  * Add scheduler queue + consumer notes to agent memory files');
+print('  * Create Inbox Consumer + Stuck Run Detector jobs');
+print('  * Install a macOS LaunchAgent or LaunchDaemon (optional)');
+print();
+
+// --- Step 1: Paths ------------------------------------------------------------
+
+print('-- Step 1: Paths ---------------------------------------');
+const schedulerPath = __dirname;
+const defaultWorkspace = path.join(os.homedir(), '.openclaw', 'workspace');
+const workspacePath = await ask('Workspace path', defaultWorkspace);
+const defaultGateway = 'http://127.0.0.1:18789';
+const gatewayUrl = await ask('Gateway URL', defaultGateway);
+const deliverTo = await ask('Telegram delivery ID for alerts (user or group ID, or blank to skip)');
+const schedulerDbPath = resolveSchedulerDbPath({ env: process.env });
+if (schedulerDbPath !== ':memory:') ensureSchedulerDbParent(schedulerDbPath);
+
+print();
+print(`  Scheduler:  ${schedulerPath}`);
+print(`  Workspace:  ${workspacePath}`);
+print(`  Gateway:    ${gatewayUrl}`);
+print(`  Deliver to: ${deliverTo || '(none -- skipping job creation)'}`);
+print();
+
+// --- Preflight: npm install behavior -----------------------------------------
+
+print('-- Preflight: npm install behavior -------------------');
+const ignoreScripts = getNpmConfigValue('ignore-scripts').toLowerCase();
+if (ignoreScripts === 'true') {
+  warn('Detected npm config: ignore-scripts=true');
+  warn('better-sqlite3 requires install scripts to build/load native bindings.');
+  warn('Recommended fix:');
+  warn('  npm config set ignore-scripts false');
+  warn('  npm install --ignore-scripts=false');
+  const continueAnyway = await confirm('Continue setup anyway?');
+  if (!continueAnyway) {
+    print('Setup aborted. Fix npm config, then rerun: node setup.mjs');
+    rl.close();
+    process.exit(1);
+  }
+} else {
+  ok('npm install scripts are enabled');
+}
+print();
+
+// --- Step 2: DB migrations ----------------------------------------------------
+
+print('-- Step 2: Database migrations -------------------------');
+try {
+  const { setDbPath } = await import(path.join(schedulerPath, 'db.js'));
+  setDbPath(schedulerDbPath);
+  const migrate = (await import(path.join(schedulerPath, 'migrate-consolidate.js'))).default;
+  const ran = migrate();
+  if (ran) {
+    ok(`Migrations applied -> ${schedulerDbPath}`);
+  } else {
+    ok(`DB already up to date -> ${schedulerDbPath}`);
+  }
+} catch (err) {
+  warn(`Migration failed: ${err.message}`);
+  warn('Continuing -- you can run migrations manually: node migrate-consolidate.js');
+}
+print();
+
+// --- Step 3: Memory files ----------------------------------------------------
+
+print('-- Step 3: Agent memory files --------------------------');
+
+const memoryMd = path.join(workspacePath, 'MEMORY.md');
+const memoryEntry = `- **Scheduler Queue Pattern:** Use \`node ${schedulerPath}/cli.js msg send <from> <to> "body"\` for signal-only queue entries.
+  Inbox Consumer (\`${schedulerPath}/scripts/inbox-consumer.mjs\`) drains pending queue messages to Telegram.
+  Stuck Run Detector (\`${schedulerPath}/scripts/stuck-run-detector.mjs\`) alerts on stale \`running\` runs.`;
+
+const memResult = appendIfMissing(memoryMd, 'Scheduler Queue Pattern', memoryEntry);
+if (memResult === true)       ok('Appended scheduler queue entry -> MEMORY.md');
+else if (memResult === 'exists') skip('Scheduler queue entry already in MEMORY.md');
+else                          warn(`MEMORY.md not found at ${memoryMd} -- skipping`);
+
+const workspaceIndex = path.join(workspacePath, 'memory', 'workspace-index.md');
+const indexSection = `### Scheduler & Dispatch
+> Covers: standalone scheduler, message queue, inbox consumer
+
+| File | Covers | Load |
+|------|--------|------|
+| \`${schedulerPath}/\` | Standalone SQLite scheduler. CLI: \`node cli.js\`. launchd service: \`ai.openclaw.scheduler\`. | Any scheduler/cron work |
+| \`${schedulerPath}/cli.js\` | Queue + run operations: \`msg send\`, \`msg inbox\`, \`runs running\`, \`runs stale\`. | Day-to-day scheduler operations |
+| \`${schedulerPath}/scripts/inbox-consumer.mjs\` | Drains queue messages for one agent and delivers to Telegram. | Queue/inbox consumption |
+| \`${schedulerPath}/scripts/stuck-run-detector.mjs\` | Detects stale \`running\` runs and exits non-zero for alerts. | Run health monitoring |`;
+
+// Try inserting before a common section header, fall back to append.
+// NOTE: the link emoji anchors must match the actual markdown heading in
+// workspace index files -- do not replace with ASCII.
+const idxAnchors = ['### Automation', '### Memory', '## \u{1F517}', '---\n\n## \u{1F517}'];
+let idxResult = false;
+if (fs.existsSync(workspaceIndex)) {
+  const existing = fs.readFileSync(workspaceIndex, 'utf8');
+  if (existing.includes('inbox-consumer.mjs') || existing.includes('stuck-run-detector.mjs')) {
+    idxResult = 'exists';
+  } else {
+    for (const anchor of idxAnchors) {
+      if (existing.includes(anchor)) {
+        fs.writeFileSync(workspaceIndex, existing.replace(anchor, indexSection + '\n\n' + anchor));
+        idxResult = true;
+        break;
+      }
+    }
+    if (!idxResult) {
+      fs.appendFileSync(workspaceIndex, '\n' + indexSection + '\n');
+      idxResult = true;
+    }
+  }
+}
+
+if (idxResult === true)        ok(`Added Scheduler & Dispatch section -> workspace-index.md`);
+else if (idxResult === 'exists') skip('Scheduler section already in workspace-index.md');
+else                           warn(`workspace-index.md not found at ${workspaceIndex} -- skipping`);
+
+print();
+
+// --- Step 4: Scheduler jobs --------------------------------------------------
+
+print('-- Step 4: Scheduler jobs ------------------------------');
+
+if (!deliverTo) {
+  skip('No delivery ID provided -- skipping job creation');
+  skip('You can add jobs manually with: node cli.js jobs add \'{ ... }\'');
+} else {
+  try {
+    await initDb();
+
+    const { listJobs } = await import('./jobs.js');
+    const existingNames = listJobs().map(r => r.name);
+
+    // Inbox Consumer
+    const icScript = path.join(schedulerPath, 'scripts', 'inbox-consumer.mjs');
+    const icName = 'Inbox Consumer';
+    if (existingNames.includes(icName)) {
+      skip(`"${icName}" job already exists`);
+    } else if (!fs.existsSync(icScript)) {
+      warn(`inbox-consumer.mjs not found at ${icScript}`);
+      warn('Install is incomplete. Re-clone scheduler repo or add the job manually.');
+    } else {
+      createJob({
+        name: icName,
+        schedule_cron: '*/5 * * * *',
+        session_target: 'shell',
+        payload_message: `node ${icScript} --to '${deliverTo.replace(/'/g, "'\\''")}'`,
+        payload_timeout_seconds: 60,
+        delivery_mode: 'announce',
+        delivery_channel: 'telegram',
+        delivery_to: deliverTo,
+        run_timeout_ms: 120000,
+        enabled: true,
+        origin: 'system',
+      });
+      ok(`Created "${icName}" job (*/5 * * * *)`);
+    }
+
+    // Stuck Run Detector
+    const srdName = 'Stuck Run Detector';
+    const srdScript = path.join(schedulerPath, 'scripts', 'stuck-run-detector.mjs');
+    const srdCmd = `node ${srdScript} --threshold-min 45`;  // coding tasks regularly take 30m+
+    if (existingNames.includes(srdName)) {
+      skip(`"${srdName}" job already exists`);
+    } else if (!fs.existsSync(srdScript)) {
+      warn(`stuck-run-detector.mjs not found at ${srdScript}`);
+      warn('Install is incomplete. Re-clone scheduler repo or add the job manually.');
+    } else {
+      createJob({
+        name: srdName,
+        schedule_cron: '*/10 * * * *',
+        session_target: 'shell',
+        payload_message: srdCmd,
+        payload_timeout_seconds: 30,
+        delivery_mode: 'announce',
+        delivery_channel: 'telegram',
+        delivery_to: deliverTo,
+        run_timeout_ms: 120000,
+        enabled: true,
+        origin: 'system',
+      });
+      ok(`Created "${srdName}" job (*/10 * * * *)`);
+    }
+  } catch (err) {
+    warn(`Job creation failed: ${err.message}`);
+  }
+}
+
+print();
+
+// --- Step 5: Service / auto-start --------------------------------------------
+
+const platform = process.platform;
+const nodePath  = process.execPath;
+const indexPath = path.join(schedulerPath, 'dispatcher.js');
+const logPath   = platform === 'win32'
+  ? path.join(os.tmpdir(), 'openclaw-scheduler.log')
+  : '/tmp/openclaw-scheduler.log';
+
+// Detect WSL (WSL runs as linux; WSL_DISTRO_NAME is set by Microsoft)
+const isWSL = platform === 'linux' && (
+  process.env.WSL_DISTRO_NAME ||
+  process.env.WSL_INTEROP ||
+  (() => { try { return fs.readFileSync('/proc/version', 'utf8').toLowerCase().includes('microsoft'); } catch { return false; } })()
+);
+// WSL2 has systemd support; WSL1 does not
+const wslVersion = isWSL && (() => {
+  try { return fs.readFileSync('/proc/version', 'utf8').includes('WSL2') ? 2 : 1; } catch { return null; }
+})();
+let macServiceSummary = null;
+
+// -- macOS ------------------------------------------------------------------
+if (platform === 'darwin') {
+  print('-- Step 5: Service (macOS launchd) ---------------------');
+  const serviceUser = os.userInfo().username;
+  const serviceUid = typeof process.getuid === 'function' ? process.getuid() : null;
+  const gatewayToken = getGatewayToken(os.homedir());
+  const envPath = process.env.PATH || '/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin';
+  const serviceModes = {
+    agent: {
+      mode: 'agent',
+      title: 'LaunchAgent',
+      label: 'ai.openclaw.scheduler',
+      plistPath: path.join(os.homedir(), 'Library', 'LaunchAgents', 'ai.openclaw.scheduler.plist'),
+      domain: serviceUid == null ? null : `gui/${serviceUid}`,
+      installPrompt: 'Install LaunchAgent (recommended for a personal Mac with auto-login)?',
+      comment: 'OpenClaw Scheduler -- LaunchAgent (best for workstation/auto-login use)',
+      installMode: 'user',
+    },
+    daemon: {
+      mode: 'daemon',
+      title: 'LaunchDaemon',
+      label: 'ai.openclaw.scheduler',
+      plistPath: '/Library/LaunchDaemons/ai.openclaw.scheduler.plist',
+      domain: 'system',
+      installPrompt: 'Install LaunchDaemon (recommended for a headless Mac or startup before login)?',
+      comment: 'OpenClaw Scheduler -- LaunchDaemon (survives headless reboots)',
+      installMode: 'system',
+    },
+  };
+  const existingModes = Object.values(serviceModes).filter(cfg => fs.existsSync(cfg.plistPath));
+  let selectedServiceMode = setupOptions.serviceMode;
+  if (!selectedServiceMode) {
+    print('  Choose how the scheduler should start on macOS:');
+    print('  * agent  = user LaunchAgent (best for personal Macs with auto-login)');
+    print('  * daemon = system LaunchDaemon (best for headless or pre-login startup)');
+    print('  * skip   = do not install a service right now');
+    selectedServiceMode = (await ask('Service mode', 'agent')).toLowerCase();
+    while (!VALID_MAC_SERVICE_MODES.has(selectedServiceMode)) {
+      warn('Choose agent, daemon, or skip.');
+      selectedServiceMode = (await ask('Service mode', 'agent')).toLowerCase();
+    }
+  }
+
+  if (selectedServiceMode === 'skip') {
+    skip('Skipped macOS service install');
+    print('  Re-run later with: node setup.mjs --service-mode agent');
+    print('                 or: node setup.mjs --service-mode daemon');
+  } else {
+    const service = serviceModes[selectedServiceMode];
+    const otherModes = existingModes.filter(cfg => cfg.mode !== service.mode);
+    if (otherModes.length) {
+      warn(`Detected existing ${otherModes.map(cfg => cfg.title).join(' + ')} install(s):`);
+      for (const cfg of otherModes) {
+        print(`  * ${cfg.title}: ${cfg.plistPath}`);
+      }
+      const continueWithDuplicate = await confirm(`Install ${service.title} anyway? (This can run two schedulers if you leave both enabled)`);
+      if (!continueWithDuplicate) {
+        skip(`Skipped ${service.title} install`);
+        if (otherModes.length > 0) {
+          print(`  Leaving existing ${otherModes[0].title} in place.`);
+          macServiceSummary = otherModes[0];
+        }
+      } else {
+        macServiceSummary = service;
+      }
+    } else {
+      macServiceSummary = service;
+    }
+
+    if (macServiceSummary && macServiceSummary !== service) {
+      // User declined new service and kept existing one -- skip install block
+    } else if (macServiceSummary && fs.existsSync(service.plistPath)) {
+      skip(`${service.title} already installed`);
+      print(`  Path: ${service.plistPath}`);
+      if (service.domain) {
+        const restartPrefix = service.mode === 'daemon' ? 'sudo ' : '';
+        print(`  To restart: ${restartPrefix}launchctl kickstart -k ${service.domain}/${service.label}`);
+      }
+    } else if (macServiceSummary) {
+      const install = await confirm(service.installPrompt);
+      if (install) {
+        const tokenXml = gatewayToken
+          ? `    <key>OPENCLAW_GATEWAY_TOKEN</key>\n    <string>${xmlEscape(gatewayToken)}</string>\n`
+          : '';
+        const userXml = service.mode === 'daemon'
+          ? `  <key>UserName</key>\n  <string>${xmlEscape(serviceUser)}</string>\n`
+          : '';
+        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>Comment</key>
+  <string>${xmlEscape(service.comment)}</string>
+  <key>Label</key>
+  <string>${service.label}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${xmlEscape(nodePath)}</string>
+    <string>--no-warnings</string>
+    <string>${xmlEscape(indexPath)}</string>
+  </array>
+${userXml}  <key>WorkingDirectory</key>
+  <string>${xmlEscape(schedulerPath)}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>HOME</key>
+    <string>${xmlEscape(os.homedir())}</string>
+    <key>PATH</key>
+    <string>${xmlEscape(envPath)}</string>
+    <key>OPENCLAW_GATEWAY_URL</key>
+    <string>${xmlEscape(gatewayUrl)}</string>
+    <key>SCHEDULER_DB</key>
+    <string>${xmlEscape(schedulerDbPath)}</string>
+${tokenXml}  </dict>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>ThrottleInterval</key>
+  <integer>30</integer>
+  <key>StandardOutPath</key>
+  <string>${xmlEscape(logPath)}</string>
+  <key>StandardErrorPath</key>
+  <string>${xmlEscape(logPath)}</string>
+</dict>
+</plist>`;
+        if (service.mode === 'daemon') {
+          const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'oc-'));
+          const tmpPlistPath = path.join(tmpDir, 'ai.openclaw.scheduler.plist');
+          fs.writeFileSync(tmpPlistPath, plist, { mode: 0o600 });
+          try {
+            execSync(`sudo install -o root -g wheel -m 644 "${tmpPlistPath}" "${service.plistPath}"`, { stdio: 'inherit' });
+            execSync(`sudo launchctl bootstrap ${service.domain} "${service.plistPath}"`, { stdio: 'inherit' });
+            try { fs.rmSync(tmpDir, { recursive: true }); } catch {}
+            ok(`${service.title} installed and bootstrapped`);
+          } catch (err) {
+            ok(`${service.title} plist written -> ${tmpPlistPath}`);
+            warn(`Auto-bootstrap failed: ${err.message.trim()}`);
+            warn(`Run manually: sudo install -o root -g wheel -m 644 "${tmpPlistPath}" "${service.plistPath}"`);
+            warn(`Then: sudo launchctl bootstrap ${service.domain} "${service.plistPath}"`);
+          }
+        } else {
+          fs.mkdirSync(path.dirname(service.plistPath), { recursive: true });
+          fs.writeFileSync(service.plistPath, plist);
+          try {
+            execSync(`launchctl bootstrap ${service.domain} "${service.plistPath}"`, { stdio: 'inherit' });
+            ok(`${service.title} installed and bootstrapped`);
+          } catch (err) {
+            ok(`${service.title} plist written -> ${service.plistPath}`);
+            warn(`Auto-bootstrap failed: ${err.message.trim()}`);
+            warn(`Run manually: launchctl bootstrap ${service.domain} "${service.plistPath}"`);
+          }
+        }
+        print(`  Logs: ${logPath}`);
+      } else {
+        skip(`Skipped ${service.title} install -- run again to install later`);
+        macServiceSummary = null;
+      }
+    }
+  }
+
+// -- Linux ------------------------------------------------------------------
+} else if (platform === 'linux') {
+  if (isWSL) {
+    const wslLabel = wslVersion ? `WSL${wslVersion}` : 'WSL';
+    print(`-- Step 5: Service (${wslLabel}) ------------------------------`);
+    if (wslVersion === 1) {
+      print('  WSL1 detected -- systemd not supported. Using PM2.');
+    } else {
+      print('  WSL2 detected. Systemd is supported if enabled in /etc/wsl.conf.');
+      print('  If not enabled: add [boot] systemd=true to /etc/wsl.conf, then wsl --shutdown.');
+    }
+  } else {
+    print('-- Step 5: Service (Linux) -----------------------------');
+  }
+
+  const gatewayToken = getGatewayToken(os.homedir());
+
+  // Detect whether systemd user session is available
+  let hasSystemd = false;
+  if (isWSL && wslVersion === 1) {
+    hasSystemd = false; // WSL1 never has systemd
+  } else {
+    try { execSync('systemctl --user status', { stdio: 'ignore' }); hasSystemd = true; } catch {}
+    if (!hasSystemd) {
+      try { execSync('systemctl --user list-units', { stdio: 'ignore' }); hasSystemd = true; } catch {}
+    }
+  }
+
+  // Check for PM2
+  let hasPm2 = false;
+  try { execSync('pm2 --version', { stdio: 'ignore' }); hasPm2 = true; } catch {}
+
+  if (hasSystemd) {
+    const unitDir  = path.join(os.homedir(), '.config', 'systemd', 'user');
+    const unitPath = path.join(unitDir, 'openclaw-scheduler.service');
+
+    if (fs.existsSync(unitPath)) {
+      skip('systemd user service already installed');
+      print(`  Path: ${unitPath}`);
+      print('  To restart: systemctl --user restart openclaw-scheduler');
+    } else {
+      const install = await confirm('Install systemd user service (auto-start on login)?');
+      if (install) {
+        const unit = `[Unit]
+Description=OpenClaw Scheduler
+After=network.target
+
+[Service]
+Type=simple
+WorkingDirectory=${schedulerPath}
+ExecStart=${nodePath} --no-warnings ${indexPath}
+Environment=OPENCLAW_GATEWAY_URL=${gatewayUrl}${gatewayToken ? `\nEnvironment="OPENCLAW_GATEWAY_TOKEN=${gatewayToken.replace(/"/g, '\\"')}"` : ''}
+Environment=SCHEDULER_DB=${schedulerDbPath}
+Restart=always
+RestartSec=5
+StandardOutput=append:${logPath}
+StandardError=append:${logPath}
+
+[Install]
+WantedBy=default.target
+`;
+        fs.mkdirSync(unitDir, { recursive: true, mode: 0o700 });
+        fs.writeFileSync(unitPath, unit, { mode: 0o600 });
+        try {
+          execSync('systemctl --user daemon-reload');
+          execSync('systemctl --user enable --now openclaw-scheduler');
+          ok('systemd user service installed and started');
+        } catch (err) {
+          ok(`Unit file written -> ${unitPath}`);
+          warn(`Auto-start failed: ${err.message.trim()}`);
+          warn('Run manually:');
+          warn('  systemctl --user daemon-reload');
+          warn('  systemctl --user enable --now openclaw-scheduler');
+        }
+        print(`  Logs: ${logPath}  (or: journalctl --user -u openclaw-scheduler -f)`);
+      } else {
+        skip('Skipped -- run again to install later');
+      }
+    }
+  } else if (hasPm2) {
+    print('  systemd user session not available -- using PM2');
+    const pm2Name = 'openclaw-scheduler';
+    let pm2Running = false;
+    try {
+      const out = execSync('pm2 list --no-color', { encoding: 'utf8' });
+      pm2Running = out.includes(pm2Name);
+    } catch {}
+
+    if (pm2Running) {
+      skip(`PM2 process "${pm2Name}" already running`);
+      print('  To restart: pm2 restart openclaw-scheduler');
+    } else {
+      const install = await confirm('Register with PM2 (auto-start on login)?');
+      if (install) {
+        try {
+          execSync(
+            `pm2 start "${indexPath}" --name "${pm2Name}" --cwd "${schedulerPath}" ` +
+            `--log "${logPath}"`,
+            {
+              stdio: 'inherit',
+              env: {
+                ...process.env,
+                OPENCLAW_GATEWAY_URL: gatewayUrl,
+                SCHEDULER_DB: schedulerDbPath,
+              },
+            }
+          );
+          execSync('pm2 save');
+          ok('PM2 process started and saved');
+          print('  Run `pm2 startup` and follow the instructions to survive reboots.');
+        } catch (err) {
+          warn(`PM2 start failed: ${err.message.trim()}`);
+        }
+      } else {
+        skip('Skipped -- run again to install later');
+      }
+    }
+  } else {
+    warn('Neither systemd user session nor PM2 found');
+    print('  Options:');
+    print('  * Install PM2:  npm install -g pm2');
+    print('  * Or run manually:  node dispatcher.js &');
+    print('  * See INSTALL-LINUX.md for systemd setup without a user session');
+  }
+
+// -- Windows (native) -------------------------------------------------------
+} else if (platform === 'win32') {
+  print('-- Step 5: Service (Windows) ---------------------------');
+  print();
+  warn('Native Windows detected.');
+  print('  OpenClaw Scheduler is designed to run inside WSL (Windows Subsystem for Linux).');
+  print('  Running natively on Windows is not supported.');
+  print();
+  print('  Setup steps:');
+  print('  1. Install WSL2:  wsl --install  (in PowerShell as Admin)');
+  print('  2. Open your WSL terminal and run this wizard again from there:');
+  print(`     cd ${schedulerPath.replace(/\\/g, '/')}`);
+  print('     node setup.mjs');
+  print();
+  print('  WSL2 with systemd enabled gives the best experience (auto-start on login).');
+  print('  See INSTALL-WINDOWS.md for the full WSL2 + systemd setup guide.');
+
+// -- Unknown ----------------------------------------------------------------
+} else {
+  skip(`Unsupported platform: ${platform}`);
+  print('  Start manually: node dispatcher.js');
+}
+
+print();
+
+// --- Done ---------------------------------------------------------------------
+
+print('-- Done! -----------------------------------------------');
+print();
+print('Next steps:');
+
+if (platform === 'darwin') {
+  if (macServiceSummary?.domain) {
+    const prefix = macServiceSummary.mode === 'daemon' ? 'sudo ' : '';
+    print(`  * Service mode:   ${macServiceSummary.title}`);
+    print(`  * Check service:  ${prefix}launchctl print ${macServiceSummary.domain}/${macServiceSummary.label}`);
+    print(`  * Restart:        ${prefix}launchctl kickstart -k ${macServiceSummary.domain}/${macServiceSummary.label}`);
+  } else {
+    print('  * Install later:  node setup.mjs --service-mode agent');
+    print('                    node setup.mjs --service-mode daemon');
+  }
+} else if (platform === 'linux') {
+  if (isWSL) {
+    print('  * Check service:  systemctl --user status openclaw-scheduler  (or: pm2 status)');
+    print('  * Logs:           journalctl --user -u openclaw-scheduler -f   (or: pm2 logs)');
+    print('  * Note: if WSL session closes, restart with: systemctl --user start openclaw-scheduler');
+  } else {
+    print('  * Check service:  systemctl --user status openclaw-scheduler  (or: pm2 status)');
+    print('  * Logs:           journalctl --user -u openclaw-scheduler -f   (or: pm2 logs)');
+  }
+} else if (platform === 'win32') {
+  print('  * Run setup inside WSL -- see instructions above');
+}
+
+print('  * Scheduler CLI:  node cli.js status');
+print('  * List jobs:      node cli.js jobs list');
+print('  * Queue test:     node cli.js msg send system main "setup smoke test"');
+print(`  * Logs:           ${logPath}`);
+print('  * Docs:           README.md');
+print();
+print('-- [WARN] Important: activate memory changes -------------');
+print();
+print('  Memory file changes (MEMORY.md, workspace-index.md) only take');
+print('  effect in NEW sessions. Your agent\'s current session won\'t see');
+print('  them until it explicitly re-reads the files.');
+print();
+print('  Tell your agent now:');
+print();
+if (workspacePath) {
+  print(`    "Read ${path.join(workspacePath, 'MEMORY.md')} and`);
+  print(`     ${path.join(workspacePath, 'memory', 'workspace-index.md')} --`);
+  print('     scheduler queue pattern notes were added. Load them into your context."');
+} else {
+  print('    "Read your MEMORY.md and memory/workspace-index.md --');
+  print('     scheduler queue pattern notes were added. Load them into your context."');
+}
+print();
+print('  Future sessions will pick it up automatically via memory_search.');
+print();
+
+rl.close();