@ottttto/dsh-scheduled-send 0.2.0

package/src/host-routes.js

@@ -0,0 +1,97 @@
+// Host-side HTTP routes for the browser client. The web GUI cannot subscribe
+// to host cordis events directly; the browser client polls GET state and
+// calls POST/DELETE for scheduling. Payloads are display-safe only (no
+// secrets ever leave the host).
+//
+//   GET    /plugin-data/dsh-scheduled-send/state          → {now, tasks[]}
+//   POST   /plugin-data/dsh-scheduled-send/schedule       → create {content, sendAt, conversationId}
+//   DELETE /plugin-data/dsh-scheduled-send/schedule?id=…  → cancel
+//
+// The model-switch feature (popover dropdown, model-selected confirm route,
+// pending-switch payload) has been REMOVED. A legacy POST body containing a
+// `model` field is accepted and ignored.
+
+export const STATE_PATH = '/plugin-data/dsh-scheduled-send/state';
+export const SCHEDULE_PATH = '/plugin-data/dsh-scheduled-send/schedule';
+
+/**
+ * Register the routes on the host webServer.
+ * @param {object} webServer ctx.webServer (dsh-host-webserver service)
+ * @param {object} cache ctx.scheduledSend state: {scheduler, now}
+ * @returns {() => void} disposer
+ */
+export function registerScheduledSendRoutes(webServer, cache) {
+  const now = () => (typeof cache.now === 'function' ? cache.now() : Date.now());
+  const sendJson = (res, status, payload) => {
+    // dsh-host-webserver contract: the handler owns the raw node response —
+    // it must writeHead/end itself; returning an object writes nothing.
+    res.writeHead(status, { 'content-type': 'application/json', 'cache-control': 'no-store' });
+    res.end(JSON.stringify(payload));
+  };
+  const readBody = async (req) => {
+    let text = '';
+    for await (const chunk of req || []) text += chunk;
+    if (!text) return {};
+    try { return JSON.parse(text); } catch { return null; }
+  };
+
+  const disposers = [];
+
+  // GET state (?conversationId= filters tasks to that conversation)
+  disposers.push(webServer.register({
+    kind: 'exact',
+    path: STATE_PATH,
+    handler: async (req = {}, res) => {
+      if ((req.method || 'GET').toUpperCase() !== 'GET') {
+        sendJson(res, 405, { error: 'method not allowed' });
+        return;
+      }
+      const cid = new URL(req.url ?? '/', 'http://x').searchParams.get('conversationId');
+      const own = (it) => !cid || it?.conversationId === cid;
+      sendJson(res, 200, {
+        now: now(),
+        tasks: (cache.scheduler?.list?.() ?? []).filter(own),
+      });
+    },
+  }));
+
+  // POST/DELETE schedule
+  disposers.push(webServer.register({
+    kind: 'exact',
+    path: SCHEDULE_PATH,
+    handler: async (req = {}, res) => {
+      const method = (req.method || 'GET').toUpperCase();
+      if (method !== 'POST' && method !== 'DELETE') {
+        sendJson(res, 405, { error: 'method not allowed' });
+        return;
+      }
+      if (method === 'DELETE') {
+        const id = new URL(req.url ?? '/', 'http://x').searchParams.get('id');
+        if (!id) { sendJson(res, 400, { error: '缺少 id 参数' }); return; }
+        const ok = await cache.scheduler?.cancel?.(id);
+        sendJson(res, ok ? 200 : 404, ok ? { cancelled: id } : { error: '任务不存在或已发送' });
+        return;
+      }
+      const body = await readBody(req);
+      if (body === null || typeof body !== 'object') { sendJson(res, 400, { error: '请求体必须是 JSON 对象' }); return; }
+      const content = typeof body.content === 'string' ? body.content : '';
+      const sendAt = body.sendAt;
+      const conversationId = typeof body.conversationId === 'string' ? body.conversationId : '';
+      if (!content.trim()) { sendJson(res, 400, { error: '定时内容不能为空' }); return; }
+      if (typeof sendAt !== 'number' || !Number.isFinite(sendAt) || sendAt <= now()) {
+        sendJson(res, 400, { error: 'sendAt 必须是未来的时间戳（epoch ms）' });
+        return;
+      }
+      if (!conversationId) { sendJson(res, 400, { error: '缺少 conversationId（会话绑定）' }); return; }
+      // body.model intentionally ignored (model switching removed)
+      try {
+        const task = await cache.scheduler.schedule({ content, sendAt, conversationId });
+        sendJson(res, 200, { task });
+      } catch (err) {
+        sendJson(res, 400, { error: String(err?.message || err) });
+      }
+    },
+  }));
+
+  return () => { for (const d of disposers) d(); };
+}

package/src/index.js

@@ -0,0 +1,75 @@
+// dsh-scheduled-send — host-side cordis plugin entry.
+// Assembles the scheduled-send service: persistent task queue (scheduler),
+// due-time delivery into the ORIGINAL conversation as a normal user bubble
+// (delivery), and the host HTTP routes the browser client talks to
+// (host-routes). Model switching has been REMOVED: legacy tasks carrying a
+// `model` field deliver normally with the field ignored.
+
+import { createScheduler } from './scheduler.js';
+import { installAgentTracking, createFollowupDelivery } from './delivery.js';
+import { registerScheduledSendRoutes } from './host-routes.js';
+
+/**
+ * Cordis plugin metadata: the loader reads the named `inject` export to wire
+ * required host services into ctx before apply() runs. Without it, reading
+ * `ctx.webServer` throws "cannot get property without inject" at boot.
+ */
+export const inject = ['webServer'];
+export const name = 'dsh-scheduled-send';
+
+/**
+ * @param {object} ctx host plugin context
+ * @param {object} [config] {dataDir} overrides
+ * @param {object} [deps] test hooks: trackAgents(ctx), createUserMessage(spec),
+ *        deliverDue(item), clock, timers.
+ */
+export async function apply(ctx, config = {}, deps = {}) {
+  const dataDir = config.dataDir || `${process.env.HOME}/.dsh/dsh-scheduled-send`;
+  const clock = deps.clock || config.clock || { now: () => Date.now() };
+  const timers = deps.timers || config.timers || undefined;
+
+  // agent tracking: agent.id IS the conversation id, so tasks bind back to
+  // their original conversation even across restarts (会话绑定+补发).
+  const tracking = deps.trackAgents ? deps.trackAgents(ctx) : installAgentTracking(ctx);
+
+  const cache = {
+    dataDir,
+    now: () => clock.now(),
+  };
+
+  const deliverDue = deps.deliverDue ?? createFollowupDelivery({
+    tracking,
+    createUserMessage: deps.createUserMessage,
+  });
+
+  cache.scheduler = await createScheduler({
+    dataDir,
+    clock,
+    timers,
+    deliver: deliverDue,
+  });
+  cache.agentTracking = tracking;
+
+  // cordis Context is a proxy: arbitrary properties must be registered as
+  // services via ctx.provide() — a bare `ctx.scheduledSend = cache` throws
+  // "cannot set property without provide" at plugin load time.
+  if (typeof ctx.provide === 'function') ctx.provide('scheduledSend', cache);
+  else ctx.scheduledSend = cache; // test/plain-object contexts
+
+  if (ctx.webServer?.register) {
+    cache.disposeRoutes = registerScheduledSendRoutes(ctx.webServer, cache);
+  } else {
+    ctx.logger?.warn?.('[dsh-scheduled-send] webServer 不可用，客户端路由未注册');
+  }
+
+  ctx.on?.('dispose', () => {
+    cache.scheduler?.dispose?.();
+    tracking.dispose?.();
+    cache.disposeRoutes?.();
+  });
+
+  // cordis treats apply()'s return value as an effect disposer: a plain
+  // object here throws "TypeError: Invalid effect" at boot. Cleanup is
+  // registered via ctx.on('dispose'); the state is exposed as the
+  // 'scheduledSend' service above. Return nothing.
+}

package/src/scheduler.js

@@ -0,0 +1,146 @@
+// Scheduled sending (定时发送): persistent task queue in <dataDir>/tasks.json.
+// Each task carries {content, sendAt, conversationId, model?} and fires via
+// the deliver callback at sendAt. The queue survives restarts (restored +
+// re-armed; overdue tasks are re-delivered to their ORIGINAL conversation),
+// NO_LIVE_AGENT failures keep the original due time so the task is resent as
+// soon as the session reappears (恢复后补发), other failures retry with
+// bounded backoff. Clock and timers are injectable for tests.
+
+import { fs } from './deps.js';
+
+function queuePath(dataDir) {
+  return `${dataDir}/tasks.json`;
+}
+
+/**
+ * Create the scheduler.
+ * @param {object} opts
+ * @param {string} opts.dataDir persistence directory
+ * @param {{now:()=>number}} [opts.clock] injectable clock (default Date)
+ * @param {{setTimeoutAt:(fn,atMs)=>id, clearTimeout:(id)=>void}} [opts.timers]
+ *        injectable timer queue; defaults to global setTimeout/clearTimeout
+ * @param {(item:object)=>Promise<void>} opts.deliver deliver one due task
+ */
+export async function createScheduler({ dataDir, clock = { now: () => Date.now() }, timers = defaultTimers(), deliver } = {}) {
+  if (typeof deliver !== 'function') throw new Error('createScheduler: deliver callback required');
+  await fs.mkdir(dataDir, { recursive: true });
+  const path = queuePath(dataDir);
+
+  // restore persisted queue (best-effort)
+  let queue = [];
+  try {
+    const parsed = JSON.parse(await fs.readFile(path, 'utf8'));
+    if (Array.isArray(parsed.items)) queue = parsed.items.filter((it) => it && it.id && typeof it.sendAt === 'number');
+  } catch {
+    /* missing/corrupt → start empty */
+  }
+
+  let seq = queue.reduce((m, it) => Math.max(m, Number(String(it.id).split('-')[1]) || 0), 0);
+  let armed = null; // { timerId }
+
+  const persist = async () => {
+    await fs.writeFile(path, JSON.stringify({ items: queue }, null, 2) + '\n', 'utf8');
+  };
+
+  const nextDue = () => queue.reduce((m, it) => (m === null || it.sendAt < m ? it.sendAt : m), null);
+
+  const fireDue = async () => {
+    const now = clock.now();
+    // fire in sendAt order (ascending)
+    const due = queue.filter((it) => it.sendAt <= now).sort((a, b) => a.sendAt - b.sendAt);
+    for (const item of due) {
+      queue = queue.filter((it) => it.id !== item.id); // remove first; re-queue on failure
+      try {
+        await deliver(item);
+      } catch (err) {
+        item.attempts = (item.attempts || 0) + 1;
+        item.lastError = String(err && err.message);
+        if (err && err.code === 'NO_LIVE_AGENT') {
+          // target session not live yet: keep the ORIGINAL due time so the
+          // task is resent as soon as the session appears (恢复后补发), not
+          // delayed by delivery backoff.
+        } else {
+          // keep for retry: re-add with backoff pushed due time
+          item.sendAt = Math.max(clock.now(), now) + Math.min(60_000 * 2 ** (item.attempts - 1), 300_000);
+        }
+        queue.push(item);
+      }
+    }
+    if (due.length) await persist().catch(() => {});
+    arm();
+  };
+
+  const arm = () => {
+    if (armed) {
+      timers.clearTimeout(armed.timerId);
+      armed = null;
+    }
+    const due = nextDue();
+    if (due === null) return;
+    const delay = Math.max(0, due - clock.now());
+    const timerId = timers.setTimeoutAt(() => {
+      armed = null;
+      return fireDue(); // return the promise so injectable timer queues can await
+    }, clock.now() + delay);
+    armed = { timerId };
+  };
+
+  arm();
+  await persist().catch(() => {}); // ensure the file exists after first create
+
+  return {
+    /** Schedule a task. sendAt (epoch ms) is required; default is computed by the caller. */
+    async schedule({ content, sendAt, conversationId, model, meta }) {
+      if (typeof content !== 'string' || !content.trim()) throw new Error('定时内容不能为空');
+      if (typeof sendAt !== 'number' || !Number.isFinite(sendAt)) throw new Error('sendAt 必须是时间戳（epoch ms）');
+      const item = {
+        id: `task-${++seq}-${sendAt}`,
+        content,
+        sendAt,
+        conversationId: conversationId || null,
+        model: model || null,
+        meta: meta || null,
+        createdAt: clock.now(),
+        attempts: 0,
+      };
+      queue.push(item);
+      await persist();
+      arm();
+      return item;
+    },
+    /** Cancel a pending task before it fires. Returns true when removed. */
+    async cancel(id) {
+      const before = queue.length;
+      queue = queue.filter((it) => it.id !== id);
+      if (queue.length !== before) {
+        await persist();
+        arm();
+        return true;
+      }
+      return false;
+    },
+    /** Pending tasks sorted by sendAt ascending (display order). */
+    list() {
+      return [...queue].sort((a, b) => a.sendAt - b.sendAt).map((it) => ({ ...it }));
+    },
+    /** Manual tick (for tests / external loops). */
+    tick: fireDue,
+    async dispose() {
+      if (armed) timers.clearTimeout(armed.timerId);
+      armed = null;
+    },
+  };
+}
+
+function defaultTimers() {
+  return {
+    // setTimeoutAt receives an ABSOLUTE epoch-ms target (same contract as the
+    // injectable test timers); convert to a relative delay for real setTimeout.
+    setTimeoutAt: (fn, atMs) => {
+      const t = setTimeout(fn, Math.max(0, atMs - Date.now()));
+      t.unref?.();
+      return t;
+    },
+    clearTimeout: (t) => clearTimeout(t),
+  };
+}