lazyclaw 6.3.1 → 6.5.0

package/commands/automation_loops.mjs

@@ -0,0 +1,94 @@
+// Detached loop-worker management commands, extracted from
+// commands/automation.mjs to keep that file under the size gate. Owns the
+// _killLog/KILL_ESCALATE_MS loop-kill escalation state, which is private to
+// cmdLoops.
+import path from 'node:path';
+import { configPath } from '../lib/config.mjs';
+
+// Kill registry — `lazyclaw loops kill <id>` SIGTERMs once and SIGKILLs
+// on a second invocation within KILL_ESCALATE_MS. Module-scoped so two
+// rapid invocations of `cmd loops kill <id>` from the same process see
+// each other; for separate processes the worker also handles SIGKILL by
+// the OS, so the escalation is a UX nicety rather than a correctness gate.
+const _killLog = new Map();
+const KILL_ESCALATE_MS = 5000;
+
+export async function cmdLoops(sub, positional, flags = {}) {
+  const loopsMod = await import('../loops.mjs');
+  const cfgDir = path.dirname(configPath());
+  switch (sub) {
+    case undefined:
+    case 'list': {
+      const items = loopsMod.listLoops(cfgDir).map(loopsMod.reconcileStatus);
+      console.log(JSON.stringify(items, null, 2));
+      return;
+    }
+    case 'show': {
+      const id = positional[0];
+      if (!id) { console.error('Usage: lazyclaw loops show <id>'); process.exit(2); }
+      const meta = loopsMod.reconcileStatus(loopsMod.readMeta(id, cfgDir));
+      if (!meta) { console.error(`no loop "${id}"`); process.exit(1); }
+      const iterations = loopsMod.readIterations(id, cfgDir);
+      const result = loopsMod.readResult(id, cfgDir);
+      console.log(JSON.stringify({ id, meta, iterations, result }, null, 2));
+      return;
+    }
+    case 'kill': {
+      const id = positional[0];
+      if (!id) { console.error('Usage: lazyclaw loops kill <id>'); process.exit(2); }
+      const meta = loopsMod.readMeta(id, cfgDir);
+      if (!meta) { console.error(`no loop "${id}"`); process.exit(1); }
+      if (!meta.pid) { console.error(`loop "${id}" has no pid`); process.exit(1); }
+      const last = _killLog.get(id) || 0;
+      const now = Date.now();
+      const escalate = (now - last) < KILL_ESCALATE_MS && last > 0;
+      const sig = escalate ? 'SIGKILL' : 'SIGTERM';
+      try { process.kill(meta.pid, sig); }
+      catch (e) {
+        if (e?.code !== 'ESRCH') throw e;
+        // Already gone — reconcile and report.
+        loopsMod.patchMeta(id, { status: 'killed', finishedAt: new Date().toISOString() }, cfgDir);
+        console.log(JSON.stringify({ id, pid: meta.pid, signal: sig, status: 'already_gone' }));
+        return;
+      }
+      _killLog.set(id, now);
+      console.log(JSON.stringify({ id, pid: meta.pid, signal: sig, escalated: escalate }));
+      return;
+    }
+    case 'tail': {
+      const id = positional[0];
+      if (!id) { console.error('Usage: lazyclaw loops tail <id>'); process.exit(2); }
+      const dir = loopsMod.loopDir(id, cfgDir);
+      const logPath = path.join(dir, 'iterations.log');
+      const fs = await import('node:fs');
+      if (!fs.existsSync(dir)) { console.error(`no loop "${id}"`); process.exit(1); }
+      // Print everything already on disk first, then poll for new lines
+      // until the worker exits / status is no longer "running".
+      let offset = 0;
+      if (fs.existsSync(logPath)) {
+        const buf = fs.readFileSync(logPath, 'utf8');
+        process.stdout.write(buf);
+        offset = buf.length;
+      }
+      const pollMs = Number(flags['poll-ms']) || 250;
+      const maxMs = Number(flags['max-wait-ms']) || 0; // 0 = wait indefinitely
+      const startedAt = Date.now();
+      while (true) {
+        await new Promise(r => setTimeout(r, pollMs));
+        let cur = '';
+        try { cur = fs.readFileSync(logPath, 'utf8'); } catch { /* file may briefly not exist */ }
+        if (cur.length > offset) {
+          process.stdout.write(cur.slice(offset));
+          offset = cur.length;
+        }
+        const meta = loopsMod.reconcileStatus(loopsMod.readMeta(id, cfgDir));
+        if (!meta || meta.status !== 'running') break;
+        if (maxMs > 0 && Date.now() - startedAt > maxMs) break;
+      }
+      return;
+    }
+    default:
+      console.error('Usage: lazyclaw loops <list|show|kill|tail> ...');
+      process.exit(2);
+  }
+}

package/commands/channels.mjs

@@ -200,9 +200,40 @@ export async function cmdChannels(sub, positional = [], flags = {}) {
 
   if (sub === 'install') {
     const name = positional[0];
-    if (!name) { process.stderr.write('usage: lazyclaw channels install <@lazyclaw/channel-name>\n'); process.exit(2); }
-    const info = await loader.install(name);
-    process.stdout.write(`installed ${info.name}@${info.version}\n`);
+    if (!name) { process.stderr.write('usage: lazyclaw channels install <name>   (e.g. discord, email, whatsapp)\n'); process.exit(2); }
+    const { isPluginName } = await import('../channels/loader.mjs');
+    // Back-compat: an explicit @lazyclaw/channel-* spec still routes through the
+    // legacy plugin loader (for anyone shipping a real published package).
+    if (isPluginName(name)) {
+      const info = await loader.install(name);
+      process.stdout.write(`installed ${info.name}@${info.version}\n`);
+      return;
+    }
+    const { channelByName, channelReadiness } = await import('./setup_channels.mjs');
+    const spec = channelByName(name.toLowerCase());
+    if (!spec) { process.stderr.write(`unknown channel: ${name} (known: ${KNOWN_CHANNELS.join(', ')})\n`); process.exit(2); }
+    if (spec.builtin) { process.stdout.write(`channel ${spec.name} is built in — no install needed.\n`); return; }
+    if (spec.binary && (!spec.deps || !spec.deps.length)) {
+      process.stderr.write(`channel ${spec.name} needs the external "${spec.binary}" binary on your PATH (not an npm package). Install it from its project, then: lazyclaw channels enable ${spec.name}\n`);
+      process.exit(2);
+    }
+    const deps = spec.deps || [];
+    if (!deps.length) { process.stdout.write(`channel ${spec.name} needs no runtime package — set creds with \`lazyclaw setup\`, then \`lazyclaw channels enable ${spec.name}\`.\n`); return; }
+    // Install the in-tree adapter's runtime deps INTO the config dir; the
+    // gateway resolves them from there (commands/gateway.mjs _loadPluginChannel).
+    const { spawnSync } = await import('node:child_process');
+    process.stdout.write(`installing ${deps.join(', ')} into ${cfgDir} …\n`);
+    const res = spawnSync('npm', ['install', '--no-audit', '--no-fund', '--prefix', cfgDir, ...deps], { stdio: 'inherit', env: process.env });
+    if (res.status !== 0) { process.stderr.write(`npm install failed (exit ${res.status})\n`); process.exit(1); }
+    const r = channelReadiness(spec.name, cfgDir);
+    if (r.ready) {
+      const cfg = readConfig();
+      channelSetEnabled(cfg, spec.name, true);
+      writeConfig(cfg);
+      process.stdout.write(`installed ${deps.join(', ')} — channel ${spec.name} enabled.\n`);
+    } else {
+      process.stdout.write(`installed ${deps.join(', ')}. Still missing: ${[...r.missingDeps, r.missingBinary].filter(Boolean).join(', ')}.\n`);
+    }
     return;
   }
   if (sub === 'remove' || sub === 'uninstall') {
@@ -212,6 +243,18 @@ export async function cmdChannels(sub, positional = [], flags = {}) {
     process.stdout.write(`removed ${name}\n`);
     return;
   }
+  if (sub === 'test') {
+    const name = (positional[0] || '').toLowerCase();
+    if (!name) { process.stderr.write('usage: lazyclaw channels test <name>\n'); process.exit(2); }
+    const { verifyChannel } = await import('./setup_channels.mjs');
+    try { (await import('../dotenv_min.mjs')).loadDotenvIfAny(cfgDir); } catch { /* best-effort */ }
+    const r = await verifyChannel(name);
+    if (flags.json) { process.stdout.write(JSON.stringify({ channel: name, ...r }) + '\n'); return; }
+    if (r.ok === true) process.stdout.write(`✓ ${name} verified — ${r.detail}\n`);
+    else if (r.ok === null) process.stdout.write(`· ${name}: ${r.detail}\n`);
+    else { process.stdout.write(`✗ ${name}: ${r.detail}${r.hint ? `\n  fix: ${r.hint}` : ''}\n`); process.exitCode = 1; }
+    return;
+  }
   if (sub === 'enable' || sub === 'disable') {
     const name = (positional[0] || '').toLowerCase();
     if (!name) { process.stderr.write(`usage: lazyclaw channels ${sub} <name>\n`); process.exit(2); }