lazyclaw 6.0.0 → 6.1.0

package/commands/setup_channels.mjs

@@ -0,0 +1,207 @@
+// commands/setup_channels.mjs — Hermes-style "where will you run it?"
+// onboarding step plus the outbound-webhook step, split out of
+// commands/setup.mjs (CLAUDE.md §7: one file = one responsibility, and to
+// keep setup.mjs under its size-gate ceiling).
+//
+// Credentials are written to <cfgDir>/.env (0600) — the same file the
+// channel modules read via dotenv_min. Metadata (enabled / boundAgent) is
+// written to cfg.channels.<name>, the exact shape daemon/routes/ops.mjs
+// and the dashboard read. Plugin channels are recorded the same way with an
+// honest "needs a plugin package" notice — we never pretend a channel works
+// when it requires an uninstalled package or an external binary.
+import { readConfig, writeConfig } from '../lib/config.mjs';
+import { writeDotenvMerge } from '../dotenv_min.mjs';
+import { messageAdd } from '../config_features.mjs';
+
+// fields[].key is the answer key; .env is the env var it maps to; .secret
+// masks it on echo; .optional lets the user skip it.
+export const CHANNEL_CATALOG = [
+  { name: 'slack',    builtin: true,  label: 'Slack',
+    fields: [
+      { key: 'token', env: 'SLACK_BOT_TOKEN', prompt: 'Bot token (xoxb-…)', secret: true },
+      { key: 'appToken', env: 'SLACK_APP_TOKEN', prompt: 'App-level token (xapp-…, for inbound / Socket Mode)', secret: true, optional: true },
+    ] },
+  { name: 'telegram', builtin: true,  label: 'Telegram',
+    fields: [{ key: 'token', env: 'TELEGRAM_BOT_TOKEN', prompt: 'Bot token (from @BotFather)', secret: true }] },
+  { name: 'matrix',   builtin: true,  label: 'Matrix',
+    fields: [
+      { key: 'homeserver', env: 'MATRIX_HOMESERVER', prompt: 'Homeserver URL (https://matrix.org)' },
+      { key: 'token',      env: 'MATRIX_ACCESS_TOKEN', prompt: 'Access token', secret: true },
+      { key: 'userId',     env: 'MATRIX_USER_ID', prompt: 'User id (@you:matrix.org)' },
+    ] },
+  { name: 'http',     builtin: true,  label: 'HTTP (generic inbound endpoint)', fields: [] },
+  { name: 'discord',  builtin: false, plugin: '@lazyclaw/channel-discord', label: 'Discord',
+    fields: [{ key: 'token', env: 'DISCORD_BOT_TOKEN', prompt: 'Bot token', secret: true }] },
+  { name: 'email',    builtin: false, plugin: '@lazyclaw/channel-email', label: 'Email (IMAP/SMTP)',
+    fields: [
+      { key: 'host', env: 'EMAIL_IMAP_HOST', prompt: 'IMAP host' },
+      { key: 'user', env: 'EMAIL_IMAP_USER', prompt: 'IMAP user' },
+      { key: 'pass', env: 'EMAIL_IMAP_PASS', prompt: 'IMAP password', secret: true },
+    ] },
+  { name: 'signal',   builtin: false, plugin: '@lazyclaw/channel-signal', label: 'Signal (needs signal-cli)',
+    fields: [{ key: 'account', env: 'SIGNAL_ACCOUNT', prompt: 'Signal account (+15551234567)' }] },
+  { name: 'voice',    builtin: false, plugin: '@lazyclaw/channel-voice', label: 'Voice (Whisper transcription)',
+    fields: [{ key: 'apiKey', env: 'OPENAI_API_KEY', prompt: 'OpenAI API key (whisper)', secret: true }] },
+  { name: 'whatsapp', builtin: false, plugin: '@lazyclaw/channel-whatsapp', label: 'WhatsApp (web session)',
+    fields: [] },
+];
+
+export function channelByName(name) {
+  return CHANNEL_CATALOG.find((c) => c.name === name) || null;
+}
+
+// Pure: turn collected answers into { envVars, channelConfig, needsPlugin }.
+// Empty/whitespace answers are dropped so a skipped optional field doesn't
+// write an empty env var.
+export function buildChannelEntry(name, answers = {}) {
+  const spec = channelByName(name);
+  if (!spec) throw new Error(`unknown channel: ${name}`);
+  const envVars = {};
+  for (const f of spec.fields) {
+    const v = (answers[f.key] == null ? '' : String(answers[f.key])).trim();
+    if (v) envVars[f.env] = v;
+  }
+  return {
+    envVars,
+    channelConfig: { enabled: true },
+    needsPlugin: spec.builtin ? null : spec.plugin,
+  };
+}
+
+// Side-effecting persist used by the interactive step (and unit-tested with a
+// temp cfgDir). Writes creds to <cfgDir>/.env and metadata to cfg.channels.
+// readConfig()/writeConfig() resolve configPath() fresh on every call (it
+// reads LAZYCLAW_CONFIG_DIR at use-time, nothing import-cached), so they
+// target <cfgDir>/config.json when the caller has pointed the env var there.
+export function persistChannel(cfgDir, name, answers) {
+  const entry = buildChannelEntry(name, answers);
+  if (Object.keys(entry.envVars).length) writeDotenvMerge(cfgDir, entry.envVars);
+  const cfg = readConfig();
+  cfg.channels = cfg.channels && typeof cfg.channels === 'object' ? cfg.channels : {};
+  cfg.channels[name] = { ...(cfg.channels[name] || {}), ...entry.channelConfig };
+  writeConfig(cfg);
+  return entry;
+}
+
+const mask = (v) => {
+  const s = String(v);
+  return s.length <= 4 ? '••••' : `${s.slice(0, 3)}…${s.slice(-2)}`;
+};
+
+// Interactive channel step. `prompt(label)` resolves to a trimmed string;
+// `write(text)` sinks UI output (defaults to process.stdout). Returns
+// { skipped, channel?, needsPlugin? }. Never echoes a secret field value.
+export async function runChannelStep({ cfgDir, prompt, colors, write = (s) => process.stdout.write(s) }) {
+  const { dim, ok, warn } = colors;
+  const list = CHANNEL_CATALOG.map((c) => `${c.name}${c.builtin ? '' : ' *'}`).join(' · ');
+  write(`  ${dim('Where will you talk to the agent? Built-in: slack/telegram/matrix/http. (* = needs a plugin package.)')}\n`);
+  write(`  ${dim(list)}\n\n`);
+  const pick = (await prompt('  channel (Enter to skip): ')).trim().toLowerCase();
+  if (!pick) { write(`  ${dim('— skipped —')}\n\n`); return { skipped: true }; }
+  const spec = channelByName(pick);
+  if (!spec) { write(`  ${warn('skipped:')} unknown channel "${pick}"\n\n`); return { skipped: true }; }
+
+  const answers = {};
+  for (const f of spec.fields) {
+    const v = (await prompt(`  ${spec.label} — ${f.prompt}${f.optional ? ' (optional)' : ''}: `)).trim();
+    if (v) answers[f.key] = v;
+  }
+  try {
+    const entry = persistChannel(cfgDir, pick, answers);
+    const credKeys = Object.keys(entry.envVars);
+    write(`  ${ok('✓ channel enabled:')} ${pick}  ${credKeys.length ? dim(`creds: ${credKeys.join(', ')}`) : ''}\n`);
+    for (const f of spec.fields) {
+      if (f.secret && answers[f.key]) write(`    ${dim(`${f.env} = ${mask(answers[f.key])}  (stored in ${cfgDir}/.env, 0600)`)}\n`);
+    }
+    if (entry.needsPlugin) {
+      write(`  ${warn('plugin required:')} ${entry.needsPlugin}\n`);
+      write(`    ${dim(`install with: lazyclaw channels install ${entry.needsPlugin}  (or npm install --prefix ${cfgDir} ${entry.needsPlugin})`)}\n`);
+    }
+    write('\n');
+    return { skipped: false, channel: pick, needsPlugin: entry.needsPlugin };
+  } catch (e) {
+    write(`  ${warn('skipped:')} ${e?.message || e}\n\n`);
+    return { skipped: true };
+  }
+}
+
+// Outbound webhook step (moved verbatim-in-spirit from setup.mjs).
+export async function runWebhookStep({ prompt, colors, write = (s) => process.stdout.write(s) }) {
+  const { dim, ok, warn } = colors;
+  write(`  ${dim('Outbound webhook for `lazyclaw message send <name> <text>`. Slack / Discord Incoming Webhook URLs work as-is.')}\n\n`);
+  const hookName = (await prompt('  webhook name (Enter to skip): ')).trim();
+  if (!hookName) { write(`  ${dim('— skipped —')}\n\n`); return { skipped: true }; }
+  const hookUrl = (await prompt('  webhook URL: ')).trim();
+  if (!hookUrl) { write(`  ${warn('skipped:')} URL required\n\n`); return { skipped: true }; }
+  try {
+    const fresh = readConfig();
+    messageAdd(fresh, hookName, hookUrl);
+    writeConfig(fresh);
+    write(`  ${ok('✓ webhook saved:')} ${hookName}\n\n`);
+    return { skipped: false, name: hookName };
+  } catch (e) {
+    write(`  ${warn('skipped:')} ${e?.message || e}\n\n`);
+    return { skipped: true };
+  }
+}
+
+// Context-window step (asked right after the model pick): how much past
+// conversation to keep each turn — a sliding history budget, NOT the model's
+// hard limit. Enter on both prompts keeps the defaults.
+export async function runContextStep({ prompt, colors, write = (s) => process.stdout.write(s) }) {
+  const { dim, ok } = colors;
+  const cf = await import('../config_features.mjs');
+  const cur = cf.chatWindowGet(readConfig());
+  write(`  ${dim(`Context window — how much past conversation to send each turn (sliding budget, not the model's hard limit). Now: ${cur.turns} turns · ${cur.tokens} tokens.`)}\n\n`);
+  const turnsRaw = (await prompt(`  turns to keep (Enter = ${cur.turns}): `)).trim();
+  const tokensRaw = (await prompt(`  token budget (Enter = ${cur.tokens}): `)).trim();
+  if (!turnsRaw && !tokensRaw) { write(`  ${dim('— kept defaults —')}\n\n`); return { skipped: true }; }
+  const turns = parseInt(turnsRaw, 10);
+  const tokens = parseInt(tokensRaw, 10);
+  const cfg = readConfig();
+  cf.chatWindowSet(cfg, {
+    ...(Number.isFinite(turns) && turns > 0 ? { turns } : {}),
+    ...(Number.isFinite(tokens) && tokens >= 256 ? { tokens } : {}),
+  });
+  writeConfig(cfg);
+  const w = cf.chatWindowGet(cfg);
+  write(`  ${ok('✓ context window:')} ${w.turns} turns · ${w.tokens} tokens\n`);
+  write(`  ${dim('change later: /context turns <N> | tokens <N>')}\n\n`);
+  return { skipped: false, ...w };
+}
+
+// Optional orchestration step: enable the multi-agent planner+workers pipeline.
+// Defaults the planner to the configured provider and workers to [planner];
+// the user can layer more workers later via /orchestrator or the CLI.
+export async function runOrchestratorStep({ prompt, colors, write = (s) => process.stdout.write(s) }) {
+  const { dim, ok } = colors;
+  const cf = await import('../config_features.mjs');
+  // Reuse the same searchable provider/model picker as the model step, so
+  // planner + workers are chosen from a list (arrow keys / filter), not typed.
+  const { _pickProviderInteractive } = await import('../tui/pickers.mjs');
+  const toSpec = (p) => (p && p.provider) ? (p.model ? `${p.provider}:${p.model}` : p.provider) : null;
+  write(`  ${dim('Multi-agent: a planner splits your task into subtasks, workers run them in parallel, then a synthesis step merges the results. Skip for a single agent.')}\n\n`);
+  const yn = (await prompt('  enable orchestration? [y/N] ')).trim().toLowerCase();
+  if (yn !== 'y' && yn !== 'yes') { write(`  ${dim('— skipped —')}\n\n`); return { skipped: true }; }
+  const cfg = readConfig();
+  const base = cfg.provider && cfg.provider !== 'orchestrator' ? cfg.provider : 'claude-cli';
+  // Planner — pick from the provider/model list (Esc keeps the default).
+  write(`  ${dim('Pick the PLANNER (decomposes the task):')}\n`);
+  const planner = toSpec(await _pickProviderInteractive()) || base;
+  // Workers — pick one or more from the same list.
+  const workers = [];
+  let more = true;
+  while (more) {
+    write(`  ${dim(`Pick a WORKER (runs the subtasks)${workers.length ? ` — ${workers.length} added` : ''}:`)}\n`);
+    const spec = toSpec(await _pickProviderInteractive());
+    if (spec && !workers.includes(spec)) workers.push(spec);
+    more = ((await prompt('  add another worker? [y/N] ')).trim().toLowerCase().startsWith('y'));
+  }
+  if (!workers.length) workers.push(planner);
+  cf.orchestratorSet(cfg, { planner, workers });
+  cf.orchestratorEnable(cfg, true);
+  writeConfig(cfg);
+  write(`  ${ok('✓ orchestration enabled:')} planner ${planner} · workers ${workers.join(', ')}\n`);
+  write(`  ${dim('change later: /orchestrator  or  lazyclaw orchestrator status')}\n\n`);
+  return { skipped: false, planner, workers };
+}

package/commands/skills.mjs

@@ -0,0 +1,218 @@
+// Skill management commands (list/show/install/remove/search/curate/classify),
+// extracted from cli.mjs in Phase D3. Self-contained over skills*.mjs modules.
+import path from 'node:path';
+import fs from 'node:fs';
+import { configPath } from '../lib/config.mjs';
+
+export async function cmdSkills(sub, positional, flags = {}) {
+  const skillsMod = await import('../skills.mjs');
+  const cfgDir = path.dirname(configPath());
+  switch (sub) {
+    case undefined:
+    case 'list': {
+      // Same --filter / --limit semantic as v3.33's sessions list:
+      // case-insensitive name substring, then post-filter cap.
+      let items = skillsMod.listSkills(cfgDir);
+      if (flags.filter) {
+        const f = String(flags.filter).toLowerCase();
+        items = items.filter(s => s.name.toLowerCase().includes(f));
+      }
+      if (flags.limit !== undefined) {
+        const n = parseInt(flags.limit, 10);
+        if (Number.isFinite(n) && n > 0) items = items.slice(0, n);
+      }
+      console.log(JSON.stringify(items.map(s => ({ name: s.name, bytes: s.bytes, summary: s.summary })), null, 2));
+      return;
+    }
+    case 'show': {
+      const name = positional[0];
+      if (!name) { console.error('Usage: lazyclaw skills show <name>'); process.exit(2); }
+      try { process.stdout.write(skillsMod.loadSkill(name, cfgDir)); }
+      catch (e) { console.error(e.message); process.exit(1); }
+      return;
+    }
+    case 'install': {
+      // Four forms:
+      //   1. install user/repo[@ref][:subpath]   — GitHub bundle
+      //   2. install <name> --from <path>
+      //   3. install <name> --from-url <https://...>
+      //   4. install <name>                       — body via stdin
+      // Detect form 1 via a slash in the first positional and the
+      // absence of any --from* flag (so a literal local skill name
+      // with `/` still routes to the explicit-flag branch — though
+      // skillPath() rejects slashes anyway).
+      const name = positional[0];
+      if (!name) { console.error('Usage: lazyclaw skills install <user/repo[@ref][:path]> | <name> [--from <path> | --from-url <https://...>]'); process.exit(2); }
+      if (name.includes('/') && !flags.from && !flags['from-url']) {
+        const inst = await import('../skills_install.mjs');
+        try {
+          const r = await inst.installFromGithub(name, cfgDir, {
+            prefix: flags.prefix || '',
+            force: !!flags.force,
+            maxBytes: flags['max-bytes'] !== undefined ? parseInt(flags['max-bytes'], 10) : undefined,
+            timeoutMs: flags['timeout-ms'] !== undefined ? parseInt(flags['timeout-ms'], 10) : undefined,
+          });
+          console.log(JSON.stringify({
+            ok: true,
+            spec: `${r.spec.owner}/${r.spec.repo}@${r.spec.ref}${r.spec.subpath ? ':' + r.spec.subpath : ''}`,
+            installed: r.installed,
+            skipped: r.skipped,
+          }, null, 2));
+          return;
+        } catch (e) {
+          console.error(`error: ${e?.message || e}`);
+          process.exit(1);
+        }
+      }
+      let content;
+      if (flags['from-url']) {
+        const url = String(flags['from-url']);
+        // Refuse http/file/data — only https. The skill content goes
+        // straight into the system prompt, so source authenticity matters.
+        if (!url.startsWith('https://')) {
+          console.error('skills install --from-url requires an https:// URL');
+          process.exit(2);
+        }
+        const fetchFn = globalThis.fetch;
+        if (!fetchFn) { console.error('fetch is not available in this Node runtime'); process.exit(1); }
+        // Configurable max size — protect against pathological responses
+        // that would balloon the prompt and the disk file. 1 MiB cap.
+        const MAX_BYTES = 1_048_576;
+        try {
+          const res = await fetchFn(url, { redirect: 'follow' });
+          if (!res.ok) { console.error(`fetch ${url} → ${res.status}`); process.exit(1); }
+          // Stream the body so we can stop at the cap rather than loading
+          // an arbitrarily large response into memory.
+          const reader = res.body?.getReader?.();
+          if (!reader) { content = await res.text(); }
+          else {
+            const chunks = [];
+            let total = 0;
+            while (true) {
+              const { value, done } = await reader.read();
+              if (done) break;
+              total += value.length;
+              if (total > MAX_BYTES) {
+                console.error(`skills install: response exceeds ${MAX_BYTES} bytes; refusing`);
+                process.exit(1);
+              }
+              chunks.push(value);
+            }
+            content = new TextDecoder('utf-8', { fatal: false }).decode(Buffer.concat(chunks.map(c => Buffer.from(c))));
+          }
+        } catch (e) {
+          console.error(`skills install fetch failed: ${e?.message || e}`);
+          process.exit(1);
+        }
+      } else if (flags.from) {
+        content = fs.readFileSync(flags.from, 'utf8');
+      } else {
+        content = await new Promise(resolve => {
+          let buf = '';
+          process.stdin.setEncoding('utf8');
+          process.stdin.on('data', d => { buf += d; });
+          process.stdin.on('end', () => resolve(buf));
+        });
+      }
+      const written = skillsMod.installSkill(name, content, cfgDir);
+      console.log(JSON.stringify({ ok: true, name, path: written, bytes: content.length }));
+      return;
+    }
+    case 'remove': {
+      const name = positional[0];
+      if (!name) { console.error('Usage: lazyclaw skills remove <name>'); process.exit(2); }
+      skillsMod.removeSkill(name, cfgDir);
+      console.log(JSON.stringify({ ok: true, removed: name }));
+      return;
+    }
+    case 'search': {
+      // Mirror of `lazyclaw sessions search` — case-insensitive substring
+      // by default, --regex for pattern mode. Returns per-skill match
+      // count + first-excerpt window (40 chars before/after match).
+      // The skill body IS markdown so users typically search for terms
+      // mentioned in instructions or examples.
+      const query = positional[0];
+      if (!query) { console.error('Usage: lazyclaw skills search <query> [--regex]'); process.exit(2); }
+      const useRegex = !!flags.regex;
+      let matcher;
+      if (useRegex) {
+        try { matcher = new RegExp(query, 'i'); }
+        catch (e) { console.error(`invalid regex: ${e.message}`); process.exit(2); }
+      } else {
+        const q = query.toLowerCase();
+        matcher = { test: (s) => String(s).toLowerCase().includes(q) };
+      }
+      const items = skillsMod.listSkills(cfgDir);
+      const matches = [];
+      for (const s of items) {
+        let body;
+        try { body = skillsMod.loadSkill(s.name, cfgDir); }
+        catch { continue; }   // file may have been removed mid-listing
+        // Count matches across the whole body, not per-line. For a
+        // skill body that's a few KB this is plenty fast and the count
+        // matches the user's intuition of "how many times does it
+        // mention X."
+        let matchCount = 0;
+        let firstExcerpt = null;
+        if (useRegex) {
+          // Re-anchor the regex with /gi so we can iterate; the original
+          // matcher was /i for boolean test() above. Rebuild here.
+          const gFlag = new RegExp(query, 'gi');
+          for (const m of body.matchAll(gFlag)) {
+            matchCount++;
+            if (firstExcerpt === null) {
+              const pos = m.index ?? 0;
+              const start = Math.max(0, pos - 40);
+              const end = Math.min(body.length, pos + m[0].length + 40);
+              firstExcerpt = (start > 0 ? '…' : '') + body.slice(start, end) + (end < body.length ? '…' : '');
+            }
+          }
+        } else {
+          const lower = body.toLowerCase();
+          const q = query.toLowerCase();
+          let pos = 0;
+          while (true) {
+            const i = lower.indexOf(q, pos);
+            if (i < 0) break;
+            matchCount++;
+            if (firstExcerpt === null) {
+              const start = Math.max(0, i - 40);
+              const end = Math.min(body.length, i + q.length + 40);
+              firstExcerpt = (start > 0 ? '…' : '') + body.slice(start, end) + (end < body.length ? '…' : '');
+            }
+            pos = i + q.length;
+          }
+        }
+        if (matchCount > 0) {
+          matches.push({
+            name: s.name,
+            bytes: s.bytes,
+            matchCount,
+            excerpt: firstExcerpt,
+          });
+        }
+      }
+      console.log(JSON.stringify({ query, regex: useRegex, matches }, null, 2));
+      return;
+    }
+    case 'curate': {
+      // Lifecycle sweep: agent-authored skills unused >90d move into
+      // skills/.archive/ (recoverable). Human-authored skills are never
+      // moved. The real clock is injected here; the module stays pure.
+      const curator = await import('../skills_curator.mjs');
+      const r = curator.curate(cfgDir, Date.now());
+      console.log(JSON.stringify(r, null, 2));
+      return;
+    }
+    case 'classify': {
+      const name = positional[0];
+      if (!name) { console.error('Usage: lazyclaw skills classify <name>'); process.exit(2); }
+      const curator = await import('../skills_curator.mjs');
+      console.log(JSON.stringify({ name, state: curator.classify(name, cfgDir, Date.now()), usage: curator.usageOf(name, cfgDir) }, null, 2));
+      return;
+    }
+    default:
+      console.error('Usage: lazyclaw skills <list|show <name>|install <name> [--from path]|remove <name>|search <query> [--regex]|curate|classify <name>>');
+      process.exit(2);
+  }
+}