lazyclaw 4.3.0 → 5.0.1

package/channels/handoff.mjs

@@ -0,0 +1,41 @@
+// channels/handoff.mjs
+//
+// Migrates an active thread (sessionId) from one channel to another.
+// Pure function over (threads store, live channel map) — the CLI slash
+// and the daemon HTTP route both call this.
+
+export async function runHandoff({ threads, channels, threadId, target, externalId, note = '' }) {
+  const cur = threads.findByThread(threadId);
+  if (!cur) {
+    const err = new Error(`THREAD_NOT_FOUND: ${threadId}`);
+    err.code = 'THREAD_NOT_FOUND';
+    throw err;
+  }
+  if (!channels[target] || typeof channels[target].send !== 'function') {
+    const err = new Error(`CHANNEL_NOT_AVAILABLE: ${target}`);
+    err.code = 'CHANNEL_NOT_AVAILABLE';
+    throw err;
+  }
+  const srcChannel = cur.channel;
+  const srcExternal = cur.externalId;
+
+  // 1. Persist the migration first so a crash mid-notify leaves us in the new home.
+  const next = threads.handoff(threadId, { channel: target, externalId });
+
+  // 2. Notify source (best-effort) so the human knows where the convo went.
+  const tail = note ? ` — ${note}` : '';
+  if (channels[srcChannel] && typeof channels[srcChannel].send === 'function') {
+    try {
+      await channels[srcChannel].send(srcExternal,
+        `handoff: this conversation moved to ${target}${tail}`);
+    } catch (e) {
+      process.stderr.write(`[handoff] source notify failed: ${e.message}\n`);
+    }
+  }
+
+  // 3. Notify target with a resume marker.
+  await channels[target].send(externalId,
+    `resumed from ${srcChannel} (session ${next.sessionId})${tail}`);
+
+  return next;
+}

package/channels/loader.mjs

@@ -0,0 +1,124 @@
+// channels/loader.mjs
+//
+// Plugin loader for @lazyclaw/channel-<name> packages. Installs into
+// <configDir>/node_modules via `npm install <spec>` and dynamic-imports
+// the entry, calling the package's exported register({Channel, addChannel}).
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { spawnSync } from 'node:child_process';
+import { Channel } from './base.mjs';
+
+const PLUGIN_RE = /^@lazyclaw\/channel-[a-z][a-z0-9-]*$/;
+
+export function isPluginName(name) {
+  return typeof name === 'string' && PLUGIN_RE.test(name);
+}
+
+export function listInstalled(configDir) {
+  const root = path.join(String(configDir), 'node_modules', '@lazyclaw');
+  if (!fs.existsSync(root)) return [];
+  const out = [];
+  for (const entry of fs.readdirSync(root)) {
+    if (!entry.startsWith('channel-')) continue;
+    const pj = path.join(root, entry, 'package.json');
+    if (!fs.existsSync(pj)) continue;
+    try {
+      const meta = JSON.parse(fs.readFileSync(pj, 'utf8'));
+      if (!isPluginName(meta.name)) continue;
+      out.push({ name: meta.name, version: meta.version || '0.0.0' });
+    } catch { /* skip */ }
+  }
+  return out;
+}
+
+export function createLoader({ configDir, skipInstall = false, npmBin = 'npm' } = {}) {
+  if (!configDir) throw new Error('createLoader: configDir required');
+  fs.mkdirSync(configDir, { recursive: true });
+
+  /** @type {Map<string, (opts:any)=>Channel>} */
+  const factories = new Map();
+
+  function addChannel(kind, factory) {
+    if (typeof factory !== 'function') {
+      throw new Error(`plugin "${kind}" register() must call addChannel(name, factory)`);
+    }
+    factories.set(kind, factory);
+  }
+
+  function getFactory(kind) {
+    return factories.get(kind) || null;
+  }
+
+  function listKinds() {
+    return Array.from(factories.keys()).sort();
+  }
+
+  async function loadFromPath(declaredName, pkgDir) {
+    if (!isPluginName(declaredName)) {
+      const err = new Error(`INVALID_PLUGIN_NAME: ${declaredName}`);
+      err.code = 'INVALID_PLUGIN_NAME';
+      throw err;
+    }
+    const pj = JSON.parse(fs.readFileSync(path.join(pkgDir, 'package.json'), 'utf8'));
+    const entryRel = pj.main || 'index.mjs';
+    const entry = path.join(pkgDir, entryRel);
+    const mod = await import(pathToFileURL(entry).href);
+    if (typeof mod.register !== 'function') {
+      throw new Error(`plugin ${declaredName} missing register() export`);
+    }
+    await mod.register({ Channel, addChannel });
+    return { name: declaredName, version: pj.version || '0.0.0' };
+  }
+
+  async function install(name) {
+    if (!isPluginName(name)) {
+      const err = new Error(`INVALID_PLUGIN_NAME: ${name}`);
+      err.code = 'INVALID_PLUGIN_NAME';
+      throw err;
+    }
+    if (!skipInstall) {
+      const res = spawnSync(npmBin, ['install', '--no-audit', '--no-fund', name], {
+        cwd: configDir, stdio: 'inherit', env: process.env,
+      });
+      if (res.status !== 0) {
+        throw new Error(`npm install ${name} exited ${res.status}`);
+      }
+    }
+    const pkgDir = path.join(configDir, 'node_modules', name);
+    return loadFromPath(name, pkgDir);
+  }
+
+  async function remove(name) {
+    if (!isPluginName(name)) {
+      const err = new Error(`INVALID_PLUGIN_NAME: ${name}`);
+      err.code = 'INVALID_PLUGIN_NAME';
+      throw err;
+    }
+    const res = spawnSync(npmBin, ['uninstall', name], {
+      cwd: configDir, stdio: 'inherit', env: process.env,
+    });
+    if (res.status !== 0) throw new Error(`npm uninstall ${name} exited ${res.status}`);
+    // factories map stays — restart of daemon picks up the change.
+  }
+
+  async function loadAllInstalled() {
+    const installed = listInstalled(configDir);
+    const loaded = [];
+    for (const { name } of installed) {
+      try {
+        const pkgDir = path.join(configDir, 'node_modules', name);
+        loaded.push(await loadFromPath(name, pkgDir));
+      } catch (e) {
+        process.stderr.write(`[channels] failed to load ${name}: ${e.message}\n`);
+      }
+    }
+    return loaded;
+  }
+
+  return {
+    addChannel, getFactory, listKinds,
+    loadFromPath, loadAllInstalled, install, remove,
+  };
+}

package/channels/threads.mjs

@@ -0,0 +1,116 @@
+// channels/threads.mjs
+//
+// threadId -> { channel, externalId, sessionId, lastTurnAt } JSONL store.
+// Append-only on disk; in-memory map for read. The threadId is stable
+// across /handoff so cross-channel migrations preserve session context.
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as crypto from 'node:crypto';
+
+const FILE = 'threads.jsonl';
+
+function readAll(file) {
+  if (!fs.existsSync(file)) return [];
+  const raw = fs.readFileSync(file, 'utf8');
+  const out = [];
+  for (const line of raw.split('\n')) {
+    if (!line) continue;
+    try { out.push(JSON.parse(line)); } catch { /* skip corrupt */ }
+  }
+  return out;
+}
+
+function newThreadId() {
+  return 'th_' + crypto.randomBytes(8).toString('hex');
+}
+
+export function openThreads(configDir) {
+  const dir = String(configDir || '.');
+  fs.mkdirSync(dir, { recursive: true });
+  const file = path.join(dir, FILE);
+
+  /** @type {Map<string, {threadId,channel,externalId,sessionId,lastTurnAt}>} */
+  const byThread = new Map();
+  /** @type {Map<string, string>} channel|externalId -> threadId */
+  const byExternal = new Map();
+
+  function externalKey(channel, externalId) {
+    return `${channel}|${externalId}`;
+  }
+
+  function apply(row) {
+    if (row.op === 'delete') {
+      const existing = byThread.get(row.threadId);
+      if (existing) {
+        byExternal.delete(externalKey(existing.channel, existing.externalId));
+        byThread.delete(row.threadId);
+      }
+      return;
+    }
+    const prev = byThread.get(row.threadId);
+    if (prev) byExternal.delete(externalKey(prev.channel, prev.externalId));
+    byThread.set(row.threadId, {
+      threadId: row.threadId,
+      channel: row.channel,
+      externalId: row.externalId,
+      sessionId: row.sessionId,
+      lastTurnAt: row.lastTurnAt,
+    });
+    byExternal.set(externalKey(row.channel, row.externalId), row.threadId);
+  }
+
+  for (const row of readAll(file)) apply(row);
+
+  function append(row) {
+    fs.appendFileSync(file, JSON.stringify(row) + '\n');
+    apply(row);
+  }
+
+  function upsert({ channel, externalId, sessionId, threadId }) {
+    if (!channel || !externalId || !sessionId) {
+      throw new Error('upsert requires channel, externalId, sessionId');
+    }
+    const existingId = byExternal.get(externalKey(channel, externalId));
+    const id = threadId || existingId || newThreadId();
+    const row = {
+      op: 'upsert', threadId: id, channel, externalId, sessionId,
+      lastTurnAt: Date.now(),
+    };
+    append(row);
+    return byThread.get(id);
+  }
+
+  function findByExternal(channel, externalId) {
+    const id = byExternal.get(externalKey(channel, externalId));
+    return id ? byThread.get(id) : null;
+  }
+
+  function findByThread(threadId) {
+    return byThread.get(threadId) || null;
+  }
+
+  function handoff(threadId, { channel, externalId }) {
+    const cur = byThread.get(threadId);
+    if (!cur) {
+      const err = new Error(`THREAD_NOT_FOUND: ${threadId}`);
+      err.code = 'THREAD_NOT_FOUND';
+      throw err;
+    }
+    if (!channel || !externalId) {
+      throw new Error('handoff requires channel and externalId');
+    }
+    const row = {
+      op: 'upsert', threadId, channel, externalId,
+      sessionId: cur.sessionId, lastTurnAt: Date.now(),
+    };
+    append(row);
+    return byThread.get(threadId);
+  }
+
+  function list() {
+    return Array.from(byThread.values());
+  }
+
+  return { upsert, findByExternal, findByThread, handoff, list };
+}