@mingmaple/dsh-handover 0.0.0-stage → 0.9.12

package/src/lib/rpc-carrier.mjs

@@ -0,0 +1,65 @@
+/**
+ * DSH 认证的 /api 载体（客户端设置页取数/下指令的**主通道**）。
+ *
+ * 为什么不用裸 fetch：本机 GUI 服务器对非浏览器策略的请求直接 403「Browser access is disabled」，
+ * 而 DSH 的 /api 载体自带浏览器鉴权与 Host/Origin 信任，dsh-im 的设置页正是走这条。
+ * 契约（与 DSH 内置管理 RPC 一致）：
+ *   入：POST /api/dsh-handover  body={type:'client-request', rpcId, method:'dsh-handover', payload:{method, payload}}
+ *   出：{type:'server-response', rpcId, result:{ok:true,value} | {ok:false,error:{code,message,details}}}
+ * 旧宿主没有 connection 服务时静默跳过，HTTP 路由继续兜底。
+ */
+const CARRIER_PATH = '/api/dsh-handover';
+const CARRIER_METHOD = 'dsh-handover';
+
+export function registerRpcCarrier(ctx, api, log) {
+  const say = typeof log === 'function' ? log : () => {};
+  let inner;
+  try {
+    inner = (cc) => {
+      const conn = cc && cc.connection ? cc.connection : null;
+      const reg = conn && conn.fetch && typeof conn.fetch.register === 'function' ? conn.fetch : null;
+      if (!reg) { say('载体：connection.fetch.register 不可用，退回 HTTP 路由'); return; }
+      let dispose = null;
+      try {
+        dispose = reg.register.call(reg, {
+          path: CARRIER_PATH,
+          methods: ['POST'],
+          requestBody: 'buffered',
+          async fetch(request) {
+            if (request.method !== 'POST') return new Response('method not allowed', { status: 405 });
+            let msg = null;
+            try { msg = await request.json(); } catch { return new Response('body is not JSON', { status: 400 }); }
+            const rpcId = msg && typeof msg.rpcId === 'string' ? msg.rpcId : 'invalid-request';
+            const call = msg && msg.payload;
+            const sane = msg && msg.type === 'client-request' && msg.method === CARRIER_METHOD
+              && call && typeof call.method === 'string' && Object.prototype.hasOwnProperty.call(call, 'payload');
+            if (!sane) {
+              return Response.json({ type: 'server-response', rpcId, result: { ok: false, error: { code: 'bad-request', message: '信封不合法', details: {} } } });
+            }
+            let r;
+            try { r = await api.call(call.method, call.payload); }
+            catch (e) { r = { ok: false, error: { code: 'failed', message: String(e && e.message ? e.message : e), details: {} } }; }
+            say('载体 ' + call.method + (r.ok ? ' ok' : (' 失败：' + String((r.error && r.error.message) || ''))));
+            return Response.json({ type: 'server-response', rpcId, result: r });
+          },
+        });
+        say('载体：已注册 ' + CARRIER_PATH);
+      } catch (e) {
+        say('载体注册失败：' + String(e && e.message ? e.message : e));
+        return;
+      }
+      try {
+        if (typeof cc.effect === 'function') cc.effect(() => dispose, 'dsh-handover: /api 载体');
+      } catch { /* ignore */ }
+    };
+  } catch (e) {
+    say('载体装配失败：' + String(e && e.message ? e.message : e));
+    return;
+  }
+  try {
+    if (typeof ctx.inject === 'function') ctx.inject(['connection'], inner);
+    else say('载体：宿主不支持 ctx.inject，退回 HTTP 路由');
+  } catch (e) {
+    say('载体装配失败：' + String(e && e.message ? e.message : e));
+  }
+}

package/src/lib/scaffold.mjs

@@ -0,0 +1,118 @@
+/**
+ * 首次安装向导：在用户粘贴的目录里建「全局根」，并把整套文件体系铺好。
+ * 只用 node:fs / node:path（跨平台，Windows / macOS / Linux / Android 的 PRoot Ubuntu 都一样）。
+ * 安全边界：只新建；目标已存在且非空就一个字都不改。已有文件绝不覆盖。
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+/** 插件自带的模板目录（dist/templates 或 src/templates）。 */
+const TPL = new URL('../templates/', import.meta.url);
+
+function template(name) {
+  return fs.readFileSync(new URL(name, TPL), 'utf8');
+}
+
+const DEFAULT_ROOT_NAME = '_Workspace';
+
+/** 目录清单（'/' 分隔，落地时换成本机分隔符）。 */
+const DIRS = [
+  '_Control_Center/records',
+  '_Control_Center/rules',
+  '_Control_Center/templates',
+  '_Control_Center/tools',
+  '_Control_Center/user',
+  'Projects',
+  '_Project_Meta',
+  '_Misc/tasks',
+  '_Archives/_Global/Backups',
+  '_Temp',
+];
+
+const FILES = [
+  ['_Control_Center/records/Global_Handover.md', 'Handover.global.skeleton.md'],
+  ['_Control_Center/records/Global_Changelog.md', 'Changelog.skeleton.md'],
+  ['_Control_Center/rules/Workspace_Charter.md', 'Charter.skeleton.md'],
+  ['_Control_Center/templates/Prompt_Templates.md', 'Prompt_Templates.md'],
+  // 规则类：工作区没有这份时，ho_charter 会退回同名内置版本；这里先铺一份可改的默认口径。
+  ['_Control_Center/rules/Handover_Rules.md', 'rules/Handover_Rules.md'],
+  ['_Control_Center/rules/Migration_Rules.md', 'rules/Migration_Rules.md'],
+  ['_Control_Center/rules/Misc_Task_Standard.md', 'rules/Misc_Task_Standard.md'],
+  ['_Control_Center/user/Writing_Rules.md', 'rules/Writing_Rules.md'],
+];
+
+/** 规整用户粘贴的路径：去掉引号/尾分隔符、展开 ~、解析成绝对路径。 */
+function normalizeParent(input) {
+  let s = String(input || '').trim();
+  if (!s) return { error: '先粘贴一个目录（父目录，全局根会建在它里面）' };
+  s = s.replace(/^["']+|["']+$/g, '').trim();
+  if (!s) return { error: '先粘贴一个目录' };
+  if (s === '~') s = os.homedir();
+  else if (s.startsWith('~/') || s.startsWith('~\\')) s = path.join(os.homedir(), s.slice(2));
+  const abs = path.resolve(s);
+  let st = null;
+  try { st = fs.statSync(abs); } catch { st = null; }
+  if (st && !st.isDirectory()) return { error: '这不是一个目录：' + abs, path: abs };
+  // 目标父目录不存在就建：允许直接指定尚不存在的路径。
+  if (!st) {
+    try { fs.mkdirSync(abs, { recursive: true }); }
+    catch (e) { return { error: '建不出这个目录：' + abs + '（' + String(e && e.message ? e.message : e) + '）', path: abs }; }
+  }
+  return { parent: abs, createdParent: !st };
+}
+
+/**
+ * 建全局根。
+ * @param parentInput 用户在设置页粘贴的路径
+ * @param opts {{ name?: string }} 根目录名，默认 _Workspace
+ * @returns {{ ok: boolean, root?: string, created?: string[], written?: string[], skipped?: string[], error?: string }}
+ */
+export function createGlobalWorkspace(parentInput, opts) {
+  const t = normalizeParent(parentInput);
+  if (t.error) return { ok: false, error: t.error };
+
+  const name = (opts && typeof opts.name === 'string' && opts.name.trim()) || DEFAULT_ROOT_NAME;
+  if (name.indexOf('/') !== -1 || name.indexOf('\\') !== -1 || name === '.' || name === '..') {
+    return { ok: false, error: '根目录名不能带路径分隔符：' + name };
+  }
+  const sameName = path.basename(t.parent).toLowerCase() === name.toLowerCase();
+  const root = sameName ? t.parent : path.join(t.parent, name);
+
+  let existed = false;
+  if (fs.existsSync(root)) {
+    let names = null;
+    try { names = fs.readdirSync(root); } catch { /* 读不了当作非空 */ }
+    if (names === null || names.length > 0) {
+      return { ok: false, root, error: '目标已存在且非空，未做任何改动：' + root };
+    }
+    existed = true;
+  }
+
+  const created = [];
+  try {
+    fs.mkdirSync(root, { recursive: true });
+    for (const d of DIRS) {
+      const p = path.join(root, d.split('/').join(path.sep));
+      fs.mkdirSync(p, { recursive: true });
+      created.push(d);
+    }
+  } catch (e) {
+    return { ok: false, root, error: '建目录失败：' + (e && e.message ? e.message : e) };
+  }
+
+  const written = [];
+  const skipped = [];
+  for (const [rel, tpl] of FILES) {
+    const dst = path.join(root, rel.split('/').join(path.sep));
+    if (fs.existsSync(dst)) { skipped.push(rel); continue; }
+    try {
+      fs.writeFileSync(dst, template(tpl), 'utf8');
+      written.push(rel);
+    } catch (e) {
+      return { ok: false, root, created, written, error: '写文件失败（' + rel + '）：' + (e && e.message ? e.message : e) };
+    }
+  }
+
+  return { ok: true, root, existed, created, written, skipped };
+}

package/src/lib/schedule.mjs

@@ -0,0 +1,223 @@
+import fsx from "node:fs";
+import osx from "node:os";
+import pathx from "node:path";
+import { checkConsent } from './consent.mjs';
+import { sendPrompt } from './prompt.mjs';
+
+/**
+ * 压缩调度：compactNow 只允许 idle，所以 ho_checkpoint 只登记，轮次结束后由这里排程。
+ * 做法：短间隔轮询 ctx.agents.get(sessionId).status，直到非 running 再压缩；成功后投续跑消息。
+ */
+
+/** 填续跑模板：{n}/{max}/{handover}/{role}。没有交接路径时用「未设置角色」模板。 */
+export function fillResumePrompt(cfg, input) {
+  const i = input || {};
+  const hasPath = !!i.handover;
+  const tpl = hasPath ? String(cfg.resumePrompt || '') : String(cfg.resumePromptUnknown || cfg.resumePrompt || '');
+  return tpl
+    .split('{n}').join(String(i.n === undefined ? 0 : i.n))
+    .split('{max}').join(String(cfg.maxCompactions))
+    .split('{handover}').join(hasPath ? i.handover : '（未解析）')
+    .split('{role}').join(i.role || 'plain');
+}
+
+export function createScheduler(deps) {
+  const { ctx, cfg } = deps;
+  const logger = deps.logger || null;
+  const pending = new Map();
+  const timers = new Map();
+  let disposed = false;
+
+  // 用全局定时器：cordis 的 ctx.setTimeout 绑定调用方 fiber，工具调用返回后可能被一并释放
+  // 用全局定时器：cordis 的 ctx.setTimeout 绑定调用方 fiber，工具调用返回后可能被一并释放。
+  function later(fn, ms) {
+    return setTimeout(fn, ms);
+  }
+
+  function note(msg) {
+    try { if (logger && logger.info) logger.info("dsh-handover: " + msg); } catch { /* ignore */ }
+    try {
+      const f = pathx.join(osx.homedir(), ".dsh", "storages", "dsh-handover", "logs", "schedule.log");
+      fsx.mkdirSync(pathx.dirname(f), { recursive: true });
+      const line = new Date().toISOString() + " " + msg + String.fromCharCode(10);
+      const bom = fsx.existsSync(f) ? "" : String.fromCharCode(0xfeff);
+      fsx.appendFileSync(f, bom + line);
+    } catch { /* ignore */ }
+  }
+
+  /** 服务解析：优先 ctx 直取，其次 ctx.get（inject 未声明的服务只能用后者）。 */
+  function service(name) {
+    try { const v = ctx[name]; if (v) return v; } catch { /* ignore */ }
+    try { return typeof ctx.get === 'function' ? ctx.get(name) : null; } catch { return null; }
+  }
+
+  function agentOf(sessionId) {
+    const agents = service('agents');
+    try { return agents && agents.get ? agents.get(sessionId) : null; } catch { return null; }
+  }
+
+  /** compaction 可能是「每个 agent 提供」的会话作用域服务：先 agent.ctx，再退回 profile 级 ctx。 */
+  function compactionOf(agent) {
+    try {
+      const c = agent && agent.ctx;
+      if (c) {
+        let v = null;
+        try { v = c.compaction; } catch { /* ignore */ }
+        if (!v) { try { v = typeof c.get === 'function' ? c.get('compaction') : null; } catch { /* ignore */ } }
+        if (v) return v;
+      }
+    } catch { /* ignore */ }
+    return service('compaction');
+  }
+
+  async function compactOnce(sessionId) {
+    const agent = agentOf(sessionId);
+    if (!agent) throw new Error("agent 不在内存中（会话可能已休眠）");
+    const compaction = compactionOf(agent);
+    if (!compaction || typeof compaction.compactNow !== "function") throw new Error("compaction.compactNow 不可用（profile 级与会话作用域都没取到）");
+    const ac = new AbortController();
+    const timer = later(() => ac.abort(new Error("timeout")), cfg.compactTimeoutMs || 120000);
+    try {
+      return await compaction.compactNow(agent, ac.signal);
+    } finally {
+      if (timer) { try { clearTimeout(timer); } catch { /* ignore */ } }
+    }
+  }
+
+  /** 续跑文案：按该会话的角色取模板，并把 {handover} 填成它自己的交接绝对路径。 */
+  function resumeText(sessionId, n) {
+    let info = null;
+    let hp = null;
+    try { info = typeof deps.roleOf === 'function' ? deps.roleOf(sessionId) : null; } catch { info = null; }
+    try { hp = typeof deps.handoverFor === 'function' ? deps.handoverFor(sessionId) : null; } catch { hp = null; }
+    return fillResumePrompt(cfg, { n, handover: hp && hp.path ? hp.path : '', role: info && info.role ? info.role : 'plain' });
+  }
+
+  function promptSelf(sessionId, text) {
+    return sendPrompt(service('sessionController'), sessionId, text, 'queue');
+  }
+
+  /**
+   * 等会话空闲。官方插件规范明确「不要轮询 agent.status」，所以优先用 agent.whenIdle()；
+   * 老宿主没有这个方法时，退回 1 秒一次的低频轮询（只在等待期生效，不是常驻轮询）。
+   */
+  async function waitIdle(agent, ms) {
+    if (typeof agent.whenIdle === "function") {
+      let timer = null;
+      const timedOut = new Promise((resolve) => { timer = later(() => resolve("timeout"), ms); });
+      try {
+        const r = await Promise.race([Promise.resolve(agent.whenIdle()).then(() => "idle"), timedOut]);
+        return r === "idle" && agent.status !== "running";
+      } catch {
+        return false;
+      } finally {
+        if (timer) { try { clearTimeout(timer); } catch { /* ignore */ } }
+      }
+    }
+    const deadline = Date.now() + ms;
+    while (Date.now() < deadline) {
+      if (agent.status !== "running") return true;
+      await new Promise((resolve) => later(resolve, 1000));
+    }
+    return agent.status !== "running";
+  }
+
+  async function attempt(sessionId) {
+    const job = pending.get(sessionId);
+    if (!job || disposed) return;
+    const agent = agentOf(sessionId);
+    if (!agent) { fail(sessionId, "会话不在内存，无法压缩"); return; }
+    if (agent.status === "running") {
+      const idle = await waitIdle(agent, cfg.waitIdleMs || 180000);
+      if (!idle) { fail(sessionId, "等了 " + Math.round((cfg.waitIdleMs || 180000) / 1000) + " 秒会话仍未空闲"); return; }
+    }
+    try {
+      const result = await compactOnce(sessionId);
+      if (!result) {
+        job.done("no-span");
+        pending.delete(sessionId);
+        return;
+      }
+      note("compacted " + sessionId + " shadowed=" + (result.shadowedTokenCount || "?"));
+      // resume=wait：任务已收尾，压缩后不唤醒，等用户派新任务。
+      // resume=continue（默认）：照旧投续跑消息，按交接 §2 继续。
+      if (cfg.autoResume !== false && job.resume !== "wait") {
+        const text = resumeText(sessionId, job.n);
+        try {
+          await promptSelf(sessionId, text);
+          job.done("ok", result);
+        } catch (e) {
+          job.done("resume-failed", result);
+          note("resume prompt failed: " + e.message);
+        }
+      } else {
+        if (job.resume === "wait") note("resume skipped (wait): " + sessionId);
+        job.done(job.resume === "wait" ? "ok-wait" : "ok", result);
+      }
+      pending.delete(sessionId);
+    } catch (e) {
+      const code = e && e.code;
+      if (code === "busy") {
+        if (Date.now() - job.startedAt > (cfg.waitIdleMs || 180000)) { fail(sessionId, "压缩一直 busy（有别的压缩或排队工作）"); return; }
+        retryLater(sessionId, 800);
+        return;
+      }
+      job.attempts++;
+      if (job.attempts >= (cfg.compactAttempts || 3)) { fail(sessionId, "压缩失败：" + (e.message || code)); return; }
+      retryLater(sessionId, 800);
+    }
+  }
+
+  function retryLater(sessionId, ms) {
+    if (disposed) return;
+    const old = timers.get(sessionId);
+    if (old) { try { clearTimeout(old); } catch { /* ignore */ } }
+    const t = later(() => { timers.delete(sessionId); attempt(sessionId); }, ms);
+    timers.set(sessionId, t);
+  }
+
+  function fail(sessionId, msg) {
+    const job = pending.get(sessionId);
+    if (job) job.done("failed", null, msg);
+    pending.delete(sessionId);
+    note("checkpoint failed " + sessionId + ": " + msg);
+    try {
+      promptSelf(sessionId, "【dsh-handover】压缩未执行：" + msg + "。历史没有被压缩，交接已就绪；请把这条消息原样告诉用户，不要自行重试压缩。").catch(() => {});
+    } catch { /* ignore */ }
+  }
+
+  /** 登记一次压缩请求；返回 Promise，settle 时给出结果（供工具侧只做登记、不等待）。 */
+  function request(sessionId, opts) {
+    return new Promise((resolve) => {
+      let settled = false;
+      const done = (status, result, error) => {
+        if (settled) return;
+        settled = true;
+        resolve({ status, result: result || null, error: error || null, at: Date.now() });
+      };
+      // 双保险只对「没验过授权」的调用方生效。入口工具（ho_checkpoint、全局代排）已校验并消费了授权，
+  // 之后再查必然查不到，压缩会被这一步全部挡掉。
+      if (opts.consent !== 'checked') {
+        const cs = checkConsent(sessionId);
+        if (!cs.ok) {
+          note("拒绝压缩 " + sessionId + "：" + cs.reason);
+          done("no-consent", null, cs.reason);
+          return;
+        }
+      }
+      pending.set(sessionId, { n: opts.n || 0, resume: opts.resume === "wait" ? "wait" : "continue", attempts: 0, done, startedAt: Date.now() });
+      retryLater(sessionId, opts.delayMs === undefined ? 600 : opts.delayMs);
+    });
+  }
+
+  function dispose() {
+    disposed = true;
+    for (const t of timers.values()) {
+      try { clearTimeout(t); } catch { /* ignore */ }
+    }
+    timers.clear();
+    pending.clear();
+  }
+
+  return { request, dispose, pending };
+}

package/src/lib/session-create.mjs

@@ -0,0 +1,42 @@
+/**
+ * 新建会话的唯一落点：建会话、改名、登记角色、当场装配。
+ * ho_sessions(new)、设置页一键部署与补建全局会话共用这一段，避免三处各写一遍。
+ */
+
+/**
+ * @param env 插件环境（需要 controller、writeRole、applyScopedLive）
+ * @param opts { workspaceId?, cwd?, title?, role?, project?, task? }
+ * @returns { sessionId, workspaceId, error }
+ */
+export async function newSessionIn(env, opts) {
+  const o = opts || {};
+  const controller = typeof env.controller === 'function' ? env.controller() : null;
+  if (!controller || typeof controller.create !== 'function') {
+    return { error: 'sessionController.create 不可用' };
+  }
+  const workspaceId = String(o.workspaceId || '');
+  const cwd = String(o.cwd || '');
+  if (!workspaceId && !cwd) return { error: '建会话要么给 workspaceId，要么给 cwd' };
+  let created = null;
+  try {
+    created = workspaceId ? await controller.create({ workspaceId }) : await controller.create({ cwd });
+  } catch (e) {
+    return { error: '建会话失败：' + String(e && e.message ? e.message : e) };
+  }
+  const sessionId = String((created && created.sessionId) || '');
+  if (!sessionId) return { error: 'create 没有返回 sessionId' };
+  const title = String(o.title || '');
+  if (title) {
+    try { if (typeof controller.rename === 'function') await controller.rename({ sessionId, title }); } catch { /* 改名失败可事后 peer_rename */ }
+  }
+  const role = String(o.role || '');
+  if (role && role !== 'plain' && typeof env.writeRole === 'function') {
+    try {
+      env.writeRole(sessionId, { role, project: String(o.project || ''), task: String(o.task || ''), source: 'create' });
+    } catch { /* 角色登记失败不影响建会话 */ }
+  }
+  if (typeof env.applyScopedLive === 'function') {
+    try { env.applyScopedLive(sessionId, { role: role || 'plain', project: String(o.project || ''), task: String(o.task || '') }); } catch { /* 下一轮的开轮核对会补齐 */ }
+  }
+  return { sessionId, workspaceId };
+}