@xmanrui/dsh-im 4.9.1 → 4.11.0

package/plugin-src/host/index.mjs

@@ -13,6 +13,8 @@ import { setImHostLanguage } from '../../src/channels/shared/i18n.mjs';
 import { installDeliveryRpc } from './delivery-rpc.mjs';
 import { installDeliveryHttp } from './delivery-http.mjs';
 import { createDeliveryService } from './delivery-service.mjs';
+import { installInboundTtlRpc } from './inbound-ttl-rpc.mjs';
+import { installSessionSyncCoordinator } from './session-sync-coordinator.mjs';
 import { installUpdateRpc } from './update-rpc.mjs';
 
 export const name = 'dsh-im-host';
@@ -32,8 +34,11 @@ function channelConfig(config, name, deliveryService) {
 
 export function createImHostPlugin(internals = {}) {
   const startUpdate = internals.installUpdateRpc ?? installUpdateRpc;
+  const startInboundTtl = internals.installInboundTtlRpc ?? installInboundTtlRpc;
   const startDelivery = internals.installDeliveryRpc ?? installDeliveryRpc;
   const startDeliveryHttp = internals.installDeliveryHttp ?? installDeliveryHttp;
+  const startSessionSync = internals.installSessionSyncCoordinator
+    ?? installSessionSyncCoordinator;
   const makeDeliveryService = internals.createDeliveryService ?? createDeliveryService;
   const startFeishu = internals.applyFeishu ?? applyFeishu;
   const startWeixin = internals.applyWeixin ?? applyWeixin;
@@ -61,13 +66,18 @@ export function createImHostPlugin(internals = {}) {
     name,
     inject,
     async apply(ctx, config = {}) {
-      const deliveryService = makeDeliveryService();
+      const unavailableSessionSyncChannels = channels
+        .map(([channel]) => channel)
+        .filter((channel) => channel !== 'office'
+          && config[channel]?.harnessBaseUrl !== undefined);
+      const deliveryService = makeDeliveryService({ unavailableSessionSyncChannels });
       if (typeof ctx?.provide === 'function') {
         ctx.provide('dshIm', Object.freeze({
           send: (botId, targetId, text, options) => (
             deliveryService.send(botId, targetId, text, options)
           ),
           listTargets: async (botId) => (await deliveryService.listTargets(botId)).targets,
+          listBots: () => deliveryService.listBots(),
         }));
       }
       const activate = async (readyCtx) => {
@@ -109,6 +119,11 @@ export function createImHostPlugin(internals = {}) {
       } catch (error) {
         logger.error?.('[dsh-im] failed to activate update management; continuing with channels', error);
       }
+      try {
+        startInboundTtl(ctx, { config });
+      } catch (error) {
+        logger.error?.('[dsh-im] failed to activate inbound TTL settings; continuing with channels', error);
+      }
       try {
         startDelivery(ctx, deliveryService, { authority: config.rpcAuthority });
       } catch (error) {
@@ -127,6 +142,16 @@ export function createImHostPlugin(internals = {}) {
     if (failures.length === channels.length) {
       throw new AggregateError(failures, 'dsh-im failed to activate every channel');
     }
+    if (typeof ctx?.on === 'function') {
+      try {
+        startSessionSync(ctx, deliveryService, {
+          logger,
+          inputScope: ctx.root ?? ctx,
+        });
+      } catch (error) {
+        logger.error?.('[dsh-im] failed to activate Session sync; continuing with channels', error);
+      }
+    }
   }
 }
 

package/plugin-src/host/modern-harness-api.mjs

@@ -200,6 +200,7 @@ class ModernHarnessApi {
   #pendingQuestions = new Map();
   #pendingApprovals = new Map();
   #sessionCursors = new Map();
+  #assistantStreams = new Map();
   #disposers = [];
   #disposed = false;
 
@@ -261,6 +262,13 @@ class ModernHarnessApi {
         if (Number.isSafeInteger(event.seq)) this.#rememberCursor(sessionId, event.seq);
         this.#broadcast({ type: 'session/event', sessionId, event });
       }, { global: true }));
+      this.#disposers.push(ctx.on('agent/assistant-stream', ({ agent, frame }) => {
+        this.#acceptAssistantStream(agent, frame);
+      }, { global: true }));
+      this.#disposers.push(ctx.on('agent/disposed', ({ agent }) => {
+        const sessionId = agent?.session?.id;
+        if (typeof sessionId === 'string') this.#assistantStreams.delete(sessionId);
+      }, { global: true }));
       this.#disposers.push(ctx.on(
         'approval/request',
         (request, next) => this.#requestApproval(request, next),
@@ -328,7 +336,7 @@ class ModernHarnessApi {
       cursor = this.#sessionCursors.get(sessionId) ?? snapshot.cursor;
       if (beforeSeq === undefined && cursor === snapshot.cursor) {
         return {
-          events: historyEntries(snapshot.records),
+          events: this.#withAssistantStream(sessionId, historyEntries(snapshot.records)),
           hasMore: snapshot.hasMore === true,
           ...(snapshot.projections === undefined ? {} : { projections: snapshot.projections }),
         };
@@ -342,7 +350,54 @@ class ModernHarnessApi {
         ...(beforeSeq === undefined ? {} : { beforeSeq }),
       },
     }, signal);
-    return { events: historyEntries(page.records), hasMore: page.hasMore === true };
+    return {
+      events: beforeSeq === undefined
+        ? this.#withAssistantStream(sessionId, historyEntries(page.records))
+        : historyEntries(page.records),
+      hasMore: page.hasMore === true,
+    };
+  }
+
+  #acceptAssistantStream(agent, frame) {
+    const sessionId = agent?.session?.id;
+    if (typeof sessionId !== 'string' || !frame || typeof frame !== 'object') return;
+    if (frame.type === 'start') {
+      const nextSeq = agent?.session?.seq;
+      const startedAfterSeq = Number.isSafeInteger(nextSeq) && nextSeq >= 0
+        ? nextSeq - 1
+        : this.#sessionCursors.get(sessionId) ?? -1;
+      this.#assistantStreams.set(sessionId, {
+        attemptId: frame.attemptId,
+        turn: frame.turn,
+        step: frame.step,
+        startedAfterSeq,
+        entries: [],
+      });
+      return;
+    }
+    const stream = this.#assistantStreams.get(sessionId);
+    if (!stream || stream.attemptId !== frame.attemptId) return;
+    if (frame.type === 'end') {
+      this.#assistantStreams.delete(sessionId);
+      return;
+    }
+    if (frame.type !== 'chunk' || frame.index !== stream.entries.length) return;
+    stream.entries.push({
+      type: 'transient',
+      event: {
+        type: 'assistant/chunk',
+        // Match DSH's Web client ordering: live chunks sit in the numeric gap
+        // before the durable assistant/message that replaces them.
+        seq: stream.startedAfterSeq + 1 - 1 / (frame.index + 2),
+        time: frame.time,
+        data: { turn: stream.turn, step: stream.step, chunk: frame.chunk },
+      },
+    });
+  }
+
+  #withAssistantStream(sessionId, entries) {
+    const transient = this.#assistantStreams.get(sessionId)?.entries ?? [];
+    return transient.length === 0 ? entries : [...entries, ...transient];
   }
 
   #rememberCursor(sessionId, cursor) {
@@ -556,6 +611,7 @@ class ModernHarnessApi {
     if (this.#disposed) return;
     this.#disposed = true;
     for (const subscription of [...this.#mux]) subscription.close();
+    this.#assistantStreams.clear();
     for (const pending of [...this.#pendingApprovals.values()]) pending.settle('cancelled');
     for (const pending of [...this.#pendingQuestions.values()]) pending.settle(
       'cancelled',

package/plugin-src/host/session-sync-coordinator.mjs

@@ -0,0 +1,217 @@
+import {
+  AssistantTextAccumulator,
+  consumeDshImInputOrigin,
+  textFromHarnessContent,
+} from '../../src/channels/shared/harness-client.mjs';
+
+const DSH_USER_PREFIX = '[来自 DSH]\n';
+const DSH_ASSISTANT_PREFIX = '[DSH 助手]\n';
+
+function completedTurn(reason) {
+  return (typeof reason === 'string' ? reason : reason?.kind) === 'completed';
+}
+
+function recipientKey(target) {
+  return JSON.stringify([target.channel, target.botId, target.targetId]);
+}
+
+function sessionIdOf(session) {
+  const value = session?.id ?? session?.sessionId;
+  return typeof value === 'string' && value ? value : null;
+}
+
+function userInputOrigin(scope, event) {
+  const source = event?.data?.source;
+  if (source?.kind !== 'user' || typeof source.rpcId !== 'string' || !source.rpcId) {
+    return 'other';
+  }
+  return consumeDshImInputOrigin(scope, source.rpcId) ? 'im' : 'dsh';
+}
+
+function validRecipient(target) {
+  return target && typeof target === 'object'
+    && typeof target.channel === 'string' && target.channel
+    && typeof target.botId === 'string' && target.botId
+    && typeof target.targetId === 'string' && target.targetId;
+}
+
+export function createSessionSyncCoordinator({ deliveryService, logger = console }) {
+  if (typeof deliveryService?.listSessionSyncTargets !== 'function'
+    || typeof deliveryService?.sendSessionSyncText !== 'function') {
+    throw new TypeError('Session sync requires a complete delivery service');
+  }
+
+  const turns = new Map();
+  const tails = new Map();
+  let closed = false;
+
+  const logFailure = (phase, target, error) => {
+    logger.warn?.(
+      `[dsh-im] ignored Session sync ${phase} failure`
+        + (target ? ` (${target.channel}/${target.botId}/${target.targetId})` : '')
+        + ` [${error?.code ?? error?.name ?? 'unknown-error'}]`,
+    );
+  };
+
+  const deliver = async (sessionId, targets, text, phase) => {
+    const unique = new Map();
+    for (const target of targets) {
+      if (validRecipient(target)) unique.set(recipientKey(target), target);
+    }
+    const entries = [...unique.entries()];
+    const results = await Promise.allSettled(entries.map(([, target]) => (
+      deliveryService.sendSessionSyncText(
+        target.botId,
+        target.targetId,
+        sessionId,
+        text,
+      )
+    )));
+    const successful = new Map();
+    results.forEach((result, index) => {
+      const [key, target] = entries[index];
+      if (result.status === 'fulfilled') successful.set(key, target);
+      else logFailure(phase, target, result.reason);
+    });
+    return successful;
+  };
+
+  const processEvent = async (sessionId, event, origin) => {
+    if (closed || !event || typeof event !== 'object') return;
+
+    if (event.type === 'turn/start') {
+      const turn = event.data?.turn;
+      if (!Number.isSafeInteger(turn)) return;
+      turns.set(sessionId, {
+        turn,
+        step: null,
+        origin: 'unknown',
+        recipients: null,
+        assistant: new AssistantTextAccumulator(),
+      });
+      return;
+    }
+
+    const state = turns.get(sessionId);
+    if (!state) return;
+
+    if (event.type === 'step/start') {
+      if (event.data?.turn !== undefined && event.data.turn !== state.turn) return;
+      state.step = Number.isSafeInteger(event.data?.step) ? event.data.step : null;
+      return;
+    }
+
+    if (event.type === 'step/end') {
+      if (event.data?.turn !== undefined && event.data.turn !== state.turn) return;
+      if (event.data?.step === undefined || event.data.step === state.step) state.step = null;
+      return;
+    }
+
+    if (event.type === 'user/message') {
+      if (event.surfaceOp !== 'append') return;
+      if (state.origin === 'unknown') state.origin = origin;
+      if (state.origin !== 'dsh' || origin !== 'dsh') return;
+      const text = textFromHarnessContent(event.data?.content);
+      if (!text) return;
+
+      let targets;
+      try {
+        targets = await deliveryService.listSessionSyncTargets(sessionId);
+      } catch (error) {
+        logFailure('lookup', null, error);
+        targets = [];
+      }
+      const successful = await deliver(
+        sessionId,
+        targets,
+        `${DSH_USER_PREFIX}${text}`,
+        'user delivery',
+      );
+      if (state.recipients === null) {
+        state.recipients = successful;
+      } else {
+        for (const key of [...state.recipients.keys()]) {
+          if (!successful.has(key)) state.recipients.delete(key);
+        }
+      }
+      return;
+    }
+
+    if (event.type === 'assistant/message') {
+      if (state.origin !== 'dsh' || event.surfaceOp !== 'append'
+        || event.data?.interrupted === true
+        || (event.data?.turn !== undefined && event.data.turn !== state.turn)) return;
+      const text = textFromHarnessContent(event.data?.message?.content);
+      const step = Number.isSafeInteger(event.data?.step) ? event.data.step : state.step;
+      state.assistant.setCanonical(step, text);
+      return;
+    }
+
+    if (event.type !== 'turn/end' || event.data?.turn !== state.turn) return;
+    turns.delete(sessionId);
+    if (state.origin !== 'dsh' || !completedTurn(event.data?.reason)
+      || !state.recipients?.size || !state.assistant.text) return;
+    await deliver(
+      sessionId,
+      state.recipients.values(),
+      `${DSH_ASSISTANT_PREFIX}${state.assistant.text}`,
+      'assistant delivery',
+    );
+  };
+
+  const enqueue = (sessionId, event, origin = 'other') => {
+    if (closed || typeof sessionId !== 'string' || !sessionId) return Promise.resolve();
+    const previous = tails.get(sessionId) ?? Promise.resolve();
+    const task = previous.then(
+      () => processEvent(sessionId, event, origin),
+      () => processEvent(sessionId, event, origin),
+    );
+    const tail = task.catch((error) => logFailure('event handling', null, error)).finally(() => {
+      if (tails.get(sessionId) === tail) tails.delete(sessionId);
+    });
+    tails.set(sessionId, tail);
+    return tail;
+  };
+
+  return Object.freeze({
+    enqueue,
+    async whenIdle() {
+      while (tails.size > 0) await Promise.allSettled([...tails.values()]);
+    },
+    close() {
+      closed = true;
+      turns.clear();
+    },
+  });
+}
+
+export function installSessionSyncCoordinator(ctx, deliveryService, {
+  logger = console,
+  inputScope = ctx?.root ?? ctx,
+} = {}) {
+  if (typeof ctx?.on !== 'function') {
+    throw new TypeError('Session sync requires Host session events');
+  }
+  const coordinator = createSessionSyncCoordinator({ deliveryService, logger });
+  const disposeEvent = ctx.on('session/event', (session, event) => {
+    const sessionId = sessionIdOf(session);
+    if (!sessionId) return;
+    // Origin lookup must be synchronous: the originating ask may clean its id
+    // immediately after this event callback returns.
+    const origin = event?.type === 'user/message'
+      ? userInputOrigin(inputScope, event)
+      : 'other';
+    void coordinator.enqueue(sessionId, event, origin);
+  }, { global: true });
+  let disposed = false;
+  const close = () => {
+    if (disposed) return;
+    disposed = true;
+    disposeEvent?.();
+    coordinator.close();
+  };
+  if (typeof ctx.effect === 'function') {
+    ctx.effect(() => close, 'dsh-im: Session sync coordinator');
+  }
+  return Object.freeze({ ...coordinator, close });
+}

package/scripts/verify-package.mjs

@@ -141,15 +141,21 @@ if ((client.match(/\.slots\.inject\(\s*["']settings\.section["']/gu) ?? []).leng
 if (client.includes('settings.plugins.tab') || clientSources.includes('settings.plugins.tab')) {
   throw new Error('client source or bundle still contains the legacy Plugins-tab settings entry');
 }
-// Connections still have no channel-enable toggle. Only the shared context
-// editor owns checkable inputs. Its reusable scope component contains one
-// switch template and one mapped field-input template; it renders both twice.
+// Connections still have no channel-enable toggle. Checkable inputs are owned
+// only by the shared context editor and the saved-target Session sync row.
+// The context editor contains one switch template and one mapped field-input
+// template; the delivery target adds one ordinary checkbox template.
 const contextEditorSource = await readFile(resolve(root, 'plugin-src/client/context-enhancement.js'), 'utf8');
-const otherClientSources = clientSources.replace(contextEditorSource, '');
+const deliverySettingsSource = await readFile(resolve(root, 'plugin-src/client/delivery-settings.js'), 'utf8');
+const otherClientSources = clientSources
+  .replace(contextEditorSource, '')
+  .replace(deliverySettingsSource, '');
 if (/role:\s*["']switch|type:\s*["']checkbox/.test(otherClientSources)
+  || (deliverySettingsSource.match(/type:\s*["']checkbox["']/g) ?? []).length !== 1
+  || /role:\s*["']switch["']/u.test(deliverySettingsSource)
   || (client.match(/role:\s*["']switch["']/g) ?? []).length !== 1
-  || (client.match(/type:\s*["']checkbox["']/g) ?? []).length !== 2) {
-  throw new Error('checkable inputs must be limited to the context-enhancement editor');
+  || (client.match(/type:\s*["']checkbox["']/g) ?? []).length !== 3) {
+  throw new Error('checkable inputs must be limited to context enhancement and Session sync');
 }
 for (const marker of ['bot.context-enhancement.set', '<dsh_im_source>', '<dsh_im_source_guidance>']) {
   if (!host.includes(marker) || !client.includes(marker)) {