@anytowork/cli 0.12.26 → 0.12.27

package/src/listener/install.js

@@ -0,0 +1,200 @@
+// Always-on listener: start at login on macOS, Linux and Windows (plan 01 section 2.5).
+//
+// The generators (plist / unit / task arguments / cron line) are pure functions so tests can check the files without
+// installing anything. They write the absolute path of node and of this command, plus the PATH of the moment of
+// installing, because a login-time job does not see the owner's shell setup.
+// Install is safe to repeat (it replaces what is there); uninstall removes the same things.
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { execFile } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+export function labelOf(profile) { return `work.anytowork.listen.${profile || 'default'}`; }
+export function unitNameOf(profile) { return `anytowork-listen-${profile || 'default'}.service`; }
+export function taskNameOf(profile) { return `AnytoWork Listen ${profile || 'default'}`; }
+export function cronMarkOf(profile) { return `# anytowork-listen:${profile || 'default'}`; }
+
+/** The arguments after the entry script that run the listener. */
+export function runArgs(profile) {
+  return ['listen', 'run', ...(profile ? ['--profile', profile] : [])];
+}
+
+function xml(s) {
+  return String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+}
+
+/** macOS LaunchAgent plist text. */
+export function launchdPlist({ label, node, entry, profile, pathEnv, configDir, logFile }) {
+  const args = [node, entry, ...runArgs(profile)];
+  const env = { PATH: pathEnv || '/usr/local/bin:/usr/bin:/bin', ...(configDir ? { ANYTOWORK_CONFIG_DIR: configDir } : {}) };
+  return `<?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>${xml(label)}</string>
+  <key>ProgramArguments</key>
+  <array>
+${args.map((a) => `    <string>${xml(a)}</string>`).join('\n')}
+  </array>
+  <key>EnvironmentVariables</key>
+  <dict>
+${Object.entries(env).map(([k, v]) => `    <key>${xml(k)}</key><string>${xml(v)}</string>`).join('\n')}
+  </dict>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key>
+  <dict><key>SuccessfulExit</key><false/></dict>
+  <key>ThrottleInterval</key><integer>30</integer>
+  <key>StandardOutPath</key><string>${xml(logFile)}</string>
+  <key>StandardErrorPath</key><string>${xml(logFile)}</string>
+</dict>
+</plist>
+`;
+}
+
+function sdQuote(s) { return `"${String(s).replace(/(["\\])/g, '\\$1')}"`; }
+
+/** Linux systemd --user unit text. */
+export function systemdUnit({ node, entry, profile, pathEnv, configDir }) {
+  const exec = [node, entry, ...runArgs(profile)].map(sdQuote).join(' ');
+  return `[Unit]
+Description=AnytoWork always-on listener (${profile || 'default'})
+After=network-online.target
+
+[Service]
+ExecStart=${exec}
+Environment=${sdQuote(`PATH=${pathEnv || '/usr/local/bin:/usr/bin:/bin'}`)}
+${configDir ? `Environment=${sdQuote(`ANYTOWORK_CONFIG_DIR=${configDir}`)}\n` : ''}Restart=on-failure
+RestartSec=30
+
+[Install]
+WantedBy=default.target
+`;
+}
+
+function shSingle(s) { return `'${String(s).replace(/'/g, `'\\''`)}'`; }
+
+/** The crontab line used when there is no systemd (container, minimal Linux). */
+export function cronLine({ node, entry, profile, configDir }) {
+  const cmd = [shSingle(node), shSingle(entry), ...runArgs(profile).map(shSingle)].join(' ');
+  const envPart = configDir ? `ANYTOWORK_CONFIG_DIR=${shSingle(configDir)} ` : '';
+  return `@reboot ${envPart}${cmd} >/dev/null 2>&1 ${cronMarkOf(profile)}`;
+}
+
+/** Windows: the arguments of `schtasks /Create` (run at the user's logon, no administrator needed). */
+export function schtasksCreateArgs({ node, entry, profile }) {
+  const tr = [`"${node}"`, `"${entry}"`, ...runArgs(profile)].join(' ');
+  return ['/Create', '/TN', taskNameOf(profile), '/SC', 'ONLOGON', '/TR', tr, '/F'];
+}
+
+/** Default way to run a system command; resolves {code, stdout, stderr}, never rejects. */
+export function defaultRunCmd(cmd, args, opts = {}) {
+  return new Promise((resolve) => {
+    try {
+      const child = execFile(cmd, args, { windowsHide: true, timeout: 60_000 }, (error, stdout, stderr) => {
+        resolve({ code: error ? (typeof error.code === 'number' ? error.code : 1) : 0, stdout: String(stdout || ''), stderr: String(stderr || ''), missing: !!(error && error.code === 'ENOENT') });
+      });
+      if (opts.input != null) { child.stdin.on('error', () => {}); child.stdin.end(opts.input); }
+    } catch { resolve({ code: 1, stdout: '', stderr: 'spawn', missing: true }); }
+  });
+}
+
+/** Absolute path of the command-line entry script (bin/anytowork.js). */
+export function defaultEntryPath() {
+  return fileURLToPath(new URL('../../bin/anytowork.js', import.meta.url));
+}
+
+/**
+ * Set up start at login.
+ * @returns {Promise<{kind: 'launchd'|'systemd'|'cron'|'schtasks'|'none', file?: string, notes: string[]}>}
+ *   kind 'none' = nothing could be set up (the caller says to use poll every minute instead).
+ */
+export async function installAutostart(o) {
+  const platform = o.platform || process.platform;
+  const runCmd = o.runCmd || defaultRunCmd;
+  const home = o.home || os.homedir();
+  const node = o.node || process.execPath;
+  const entry = o.entry || defaultEntryPath();
+  const pathEnv = o.pathEnv != null ? o.pathEnv : process.env.PATH;
+  const common = { node, entry, profile: o.profile || null, pathEnv, configDir: o.configDir || null };
+  const notes = [];
+
+  if (platform === 'darwin') {
+    const label = labelOf(o.profile);
+    const dir = path.join(home, 'Library', 'LaunchAgents');
+    const file = path.join(dir, `${label}.plist`);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(file, launchdPlist({ ...common, label, logFile: o.logFile }), { mode: 0o644 });
+    const uid = String(o.uid != null ? o.uid : (process.getuid ? process.getuid() : 501));
+    await runCmd('launchctl', ['bootout', `gui/${uid}/${label}`]);          // ignore: it may not be loaded yet
+    const r = await runCmd('launchctl', ['bootstrap', `gui/${uid}`, file]);
+    if (r.code !== 0) throw new Error(`launchctl: ${(r.stderr || '').trim().slice(0, 200)}`);
+    return { kind: 'launchd', file, notes };
+  }
+
+  if (platform === 'win32') {
+    const create = await runCmd('schtasks', schtasksCreateArgs(common));
+    if (create.code !== 0) throw new Error(`schtasks: ${(create.stderr || create.stdout || '').trim().slice(0, 200)}`);
+    await runCmd('schtasks', ['/Run', '/TN', taskNameOf(o.profile)]);
+    return { kind: 'schtasks', notes };
+  }
+
+  // Linux and the rest: systemd --user first, then crontab @reboot, otherwise nothing.
+  const sd = await runCmd('systemctl', ['--user', '--version']);
+  if (sd.code === 0 && !sd.missing) {
+    const dir = path.join(home, '.config', 'systemd', 'user');
+    const file = path.join(dir, unitNameOf(o.profile));
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(file, systemdUnit(common), { mode: 0o644 });
+    await runCmd('systemctl', ['--user', 'daemon-reload']);
+    const r = await runCmd('systemctl', ['--user', 'enable', '--now', unitNameOf(o.profile)]);
+    if (r.code === 0) { notes.push('linger'); return { kind: 'systemd', file, notes }; }
+    // The user manager is not reachable (container, ssh without a session): fall through to cron.
+  }
+  const ct = await runCmd('crontab', ['-l']);
+  if (!ct.missing) {
+    const mark = cronMarkOf(o.profile);
+    const kept = (ct.code === 0 ? ct.stdout : '').split('\n').filter((l) => l && !l.includes(mark));
+    kept.push(cronLine(common));
+    const w = await runCmd('crontab', ['-'], { input: `${kept.join('\n')}\n` });
+    if (w.code === 0) {
+      if (o.startNow) await o.startNow();
+      return { kind: 'cron', notes };
+    }
+  }
+  return { kind: 'none', notes };
+}
+
+/** Undo installAutostart; unknown or missing pieces are skipped. */
+export async function uninstallAutostart(o) {
+  const platform = o.platform || process.platform;
+  const runCmd = o.runCmd || defaultRunCmd;
+  const home = o.home || os.homedir();
+  if (platform === 'darwin') {
+    const label = labelOf(o.profile);
+    const uid = String(o.uid != null ? o.uid : (process.getuid ? process.getuid() : 501));
+    await runCmd('launchctl', ['bootout', `gui/${uid}/${label}`]);
+    try { fs.unlinkSync(path.join(home, 'Library', 'LaunchAgents', `${label}.plist`)); } catch { /* none */ }
+    return;
+  }
+  if (platform === 'win32') {
+    await runCmd('schtasks', ['/End', '/TN', taskNameOf(o.profile)]);
+    await runCmd('schtasks', ['/Delete', '/TN', taskNameOf(o.profile), '/F']);
+    return;
+  }
+  const unit = path.join(home, '.config', 'systemd', 'user', unitNameOf(o.profile));
+  if (fs.existsSync(unit)) {
+    await runCmd('systemctl', ['--user', 'disable', '--now', unitNameOf(o.profile)]);
+    try { fs.unlinkSync(unit); } catch { /* none */ }
+    await runCmd('systemctl', ['--user', 'daemon-reload']);
+  }
+  const ct = await runCmd('crontab', ['-l']);
+  if (!ct.missing && ct.code === 0) {
+    const mark = cronMarkOf(o.profile);
+    if (ct.stdout.includes(mark)) {
+      const kept = ct.stdout.split('\n').filter((l) => l && !l.includes(mark));
+      await runCmd('crontab', ['-'], { input: kept.length ? `${kept.join('\n')}\n` : '' });
+    }
+  }
+}

package/src/listener/prompt.js

@@ -0,0 +1,68 @@
+// Always-on listener: the words handed to the Agent when it is woken (plan 01 section 2.2).
+//
+// The prompt travels only on standard input and in a temporary file, never on a command line. Everything the
+// platform sent as finished words (`rules.text`, `boundary.text`) is used as it is; the local tables in
+// wb-rules-text.js are only the fallback for an older platform.
+
+import { renderWbRules, boundaryLines, identityText } from '../wb-rules-text.js';
+import { pickLang } from '../model-pledge.js';
+
+const REWAKE_LINE = {
+  zh: '刚才叫过你一次，还没看到你读消息。',
+  en: 'You were called a moment ago and have not read the message yet.',
+};
+
+function langOf(payload, env) {
+  const l = payload && typeof payload.lang === 'string' ? payload.lang.toLowerCase() : '';
+  if (l.startsWith('en')) return 'en';
+  if (l.startsWith('zh')) return 'zh';
+  return pickLang(env);
+}
+
+/**
+ * @param {object} payload the `wb.wake` payload ({group, session, from, summary, rules, boundary, rewake, ...})
+ * @returns {string}
+ */
+export function buildPrompt(payload, env = process.env) {
+  const p = payload || {};
+  const lang = langOf(p, env);
+  const envLang = { ...env, ANYTOWORK_LANG: lang };
+  const g = p.group || {};
+  const s = p.session || {};
+  const sid = s.id || '';
+  const place = g.kind === 'dm'
+    ? (lang === 'en' ? 'private chat' : '私聊')
+    : (g.name || (lang === 'en' ? 'group chat' : '群聊'));
+  const where = s.title ? `${place} / ${s.title}` : place;
+  const from = p.from || {};
+  const who = identityText(from, envLang)
+    || (from.type === 'agent' ? (from.name || (lang === 'en' ? 'another Agent' : '另一个 Agent'))
+      : (from.type === 'member' ? (from.name || (lang === 'en' ? 'a group member' : '群成员'))
+        : (lang === 'en' ? 'Your owner' : '主人')));
+  const lines = [];
+  if (lang === 'en') {
+    lines.push(`[AnytoWork] ${who} called you in "${where}": ${p.summary || ''}`);
+  } else {
+    lines.push(`[AnytoWork] ${who}在「${where}」叫你：${p.summary || ''}`);
+  }
+  // A message from another owner's Agent carries a fixed source line (empty for anyone else).
+  for (const l of boundaryLines({ source: p.source }, envLang)) lines.push(l);
+  const rules = renderWbRules(p.rules, envLang);
+  if (rules) lines.push(rules);
+  for (const l of boundaryLines({ rules: p.rules, boundary: p.boundary }, envLang)) lines.push(l);
+  if (p.workspace_path) {
+    lines.push(lang === 'en' ? `Files of this group are in the space "${p.workspace_path}".` : `这个群的文件放在空间「${p.workspace_path}」`);
+  }
+  lines.push(lang === 'en'
+    ? `Session id ${sid}. This is an automatic call from the platform.`
+    : `会话编号 ${sid}。这是平台自动叫醒。`);
+  if (p.rewake === true) lines.push(REWAKE_LINE[lang]);
+  return lines.join('\n');
+}
+
+/** The fixed prompt used by `listen test`: it asks the Agent to do nothing but answer. */
+export function testPrompt(env = process.env) {
+  return pickLang(env) === 'en'
+    ? '[AnytoWork] This is a start-up test of the listener. Do nothing in AnytoWork; just reply "ok".'
+    : '[AnytoWork] 这是常驻监听的启动测试。不用在 AnytoWork 里做任何事，回一句「好」即可。';
+}

package/src/listener/queue.js

@@ -0,0 +1,94 @@
+// Always-on listener: who runs next (plan 01 section 2.3).
+//
+// Pure bookkeeping, no timers and no processes, so it can be tested with a fake clock.
+//   - one session never runs twice at once: a wake that arrives while it runs (or waits) is merged into ONE waiting
+//     run that starts after the current one ends;
+//   - at most `maxParallel` sessions run at the same time;
+//   - another Agent calling the same session is let through at most once per `agentWakeGapMs`
+//     (people are never limited; the platform's own second call, `rewake`, is not limited either);
+//   - messages from people inside `humanMergeMs` of the last start are merged into one run;
+//   - at most `queueMax` sessions wait; beyond that the oldest is dropped (the platform's second call covers it).
+
+import { LISTENER_DEFAULTS } from './config.js';
+
+export class WakeQueue {
+  /**
+   * @param {object} opts { config?: partial limits, nowMs?: () => number }
+   */
+  constructor(opts = {}) {
+    this.cfg = { ...LISTENER_DEFAULTS, ...(opts.config || {}) };
+    this.nowMs = opts.nowMs || Date.now;
+    this.waiting = new Map();   // sid -> job waiting to start
+    this.running = new Set();   // sid
+    this.lastStart = new Map(); // sid -> ms of the latest start
+  }
+
+  /**
+   * @param {object} wake { sid, human, rewake, ... any other fields are kept on the job }
+   * @returns {{result: 'queued'|'merged'|'throttled', dropped?: string}}
+   */
+  add(wake) {
+    const now = this.nowMs();
+    const sid = wake.sid;
+    const last = this.lastStart.get(sid);
+    if (!wake.human && !wake.rewake && last != null && now - last < this.cfg.agentWakeGapMs) {
+      return { result: 'throttled' };
+    }
+    const have = this.waiting.get(sid);
+    if (have) {
+      // Merge: the newest wake's details, the earliest arrival time, "human" if any of them was.
+      this.waiting.set(sid, { ...have, ...wake, addedAt: have.addedAt, readyAt: have.readyAt, human: have.human || wake.human });
+      return { result: 'merged' };
+    }
+    let readyAt = now;
+    if (wake.human && last != null && now - last < this.cfg.humanMergeMs) readyAt = last + this.cfg.humanMergeMs;
+    this.waiting.set(sid, { ...wake, addedAt: now, readyAt });
+    let dropped;
+    if (this.waiting.size > this.cfg.queueMax) {
+      let oldest = null;
+      for (const j of this.waiting.values()) if (!oldest || j.addedAt < oldest.addedAt) oldest = j;
+      this.waiting.delete(oldest.sid);
+      dropped = oldest.sid;
+    }
+    return { result: 'queued', dropped };
+  }
+
+  /** The next job that may start now (oldest first), or null. Marks it running. */
+  take() {
+    const now = this.nowMs();
+    if (this.running.size >= this.cfg.maxParallel) return null;
+    let pick = null;
+    for (const j of this.waiting.values()) {
+      if (this.running.has(j.sid) || j.readyAt > now) continue;
+      if (!pick || j.addedAt < pick.addedAt) pick = j;
+    }
+    if (!pick) return null;
+    this.waiting.delete(pick.sid);
+    this.running.add(pick.sid);
+    this.lastStart.set(pick.sid, now);
+    return { ...pick, waited: now - pick.addedAt > 2000 };
+  }
+
+  /** A run ended. */
+  done(sid) {
+    this.running.delete(sid);
+  }
+
+  /** Milliseconds until the earliest waiting job could start by time alone, or null when nothing waits. */
+  nextDelayMs() {
+    const now = this.nowMs();
+    let best = null;
+    for (const j of this.waiting.values()) {
+      const d = Math.max(0, j.readyAt - now);
+      if (best == null || d < best) best = d;
+    }
+    return best;
+  }
+
+  /** Forget everything waiting (the listener paused). */
+  clearWaiting() {
+    this.waiting.clear();
+  }
+
+  get size() { return this.waiting.size; }
+}