@xmanrui/dsh-im 4.10.0 → 4.11.0

package/plugin-src/host/delivery-adapter.mjs

@@ -1,4 +1,8 @@
-import { deliverySuggestionsFromSessions } from './delivery-suggestions.mjs';
+import {
+  deliverySuggestionsFromSessions,
+  privateConversationKeyMatchesTarget,
+  resolvePrivateConversationKey,
+} from './delivery-suggestions.mjs';
 
 const CHANNELS = new Set([
   'weixin',
@@ -22,6 +26,12 @@ function invalidTarget(message) {
   return error;
 }
 
+function sessionSyncUnavailable(message = 'Session sync is unavailable for this target') {
+  const error = new Error(message);
+  error.code = 'session-sync-unavailable';
+  return error;
+}
+
 function isRecord(value) {
   return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
@@ -129,6 +139,49 @@ export function normalizeDeliveryTarget(channel, value, { targetIdRequired = tru
   return normalized;
 }
 
+function targetWithoutSessionSync(target) {
+  return {
+    targetId: target.targetId,
+    ...(target.name === undefined ? {} : { name: target.name }),
+    kind: target.kind,
+    route: target.route,
+  };
+}
+
+function sessionSyncConfigs(workspaces, botId) {
+  if (typeof workspaces.listSessionSyncTargets !== 'function') return [];
+  const targets = workspaces.listSessionSyncTargets();
+  return botId === undefined ? targets : targets.filter((target) => target.botId === botId);
+}
+
+function stateSessions(state) {
+  if (!state || typeof state.snapshot !== 'function') return null;
+  const sessions = state.snapshot()?.sessions;
+  return sessions && typeof sessions === 'object' && !Array.isArray(sessions) ? sessions : null;
+}
+
+function sessionSyncView(channel, target, sessions, configured) {
+  if (configured) {
+    const valid = privateConversationKeyMatchesTarget(
+      channel,
+      configured.conversationKey,
+      target,
+    );
+    if (!valid || !sessions) return { enabled: true, state: 'unavailable' };
+    return {
+      enabled: true,
+      state: typeof sessions[configured.conversationKey] === 'string'
+        && Boolean(sessions[configured.conversationKey])
+        ? 'active'
+        : 'waiting',
+    };
+  }
+  const conversationKey = sessions
+    ? resolvePrivateConversationKey(channel, sessions, target)
+    : null;
+  return { enabled: false, state: conversationKey ? 'off' : 'unavailable' };
+}
+
 /** Bind one channel's existing workspace store and unwrapped controller to DeliveryService. */
 export function createDeliveryAdapter({ channel, workspaces, coreController, stateFor }) {
   if (!supportsDeliveryChannel(channel)) throw new TypeError(`Unsupported delivery channel: ${channel}`);
@@ -145,7 +198,22 @@ export function createDeliveryAdapter({ channel, workspaces, coreController, sta
     channel,
     ownsBot: (botId) => workspaces.has(botId),
     listBots: () => workspaces.listBotIds(),
-    listTargets: (botId) => workspaces.listDeliveryTargets(botId),
+    async listTargets(botId) {
+      const targets = workspaces.listDeliveryTargets(botId);
+      const configured = new Map(
+        sessionSyncConfigs(workspaces, botId).map((target) => [target.targetId, target]),
+      );
+      let sessions = null;
+      try {
+        sessions = stateSessions(await stateFor(botId));
+      } catch {
+        // Target CRUD remains usable when its persisted conversation state cannot be read.
+      }
+      return targets.map((target) => ({
+        ...target,
+        sessionSync: sessionSyncView(channel, target, sessions, configured.get(target.targetId)),
+      }));
+    },
     async listSuggestions(botId) {
       const state = await stateFor(botId);
       if (!state || typeof state.snapshot !== 'function') {
@@ -169,12 +237,82 @@ export function createDeliveryAdapter({ channel, workspaces, coreController, sta
     ),
     deleteTarget: (botId, targetId) => workspaces.deleteDeliveryTarget(botId, targetId),
     async sendText(botId, target, text, options = {}) {
-      const normalized = normalizeDeliveryTarget(channel, target);
+      const normalized = normalizeDeliveryTarget(channel, targetWithoutSessionSync(target));
       if (typeof coreController.sendProactiveText !== 'function') {
         throw new TypeError('delivery controller cannot send proactive text');
       }
       await coreController.sendProactiveText(botId, normalized, text, options);
       return { sent: true };
     },
+    async setSessionSync(botId, targetId, enabled) {
+      if (typeof workspaces.setDeliveryTargetSessionSync !== 'function') {
+        throw sessionSyncUnavailable();
+      }
+      const target = workspaces.deliveryTargetFor(botId, targetId);
+      if (!target) {
+        const error = new Error('Unknown target');
+        error.code = 'unknown-target';
+        throw error;
+      }
+      if (!enabled) {
+        await workspaces.setDeliveryTargetSessionSync(botId, targetId, null);
+        let sessions = null;
+        try {
+          sessions = stateSessions(await stateFor(botId));
+        } catch {
+          // The setting is already safely disabled; only its availability is unknown.
+        }
+        return sessionSyncView(channel, target, sessions, null);
+      }
+      const sessions = stateSessions(await stateFor(botId));
+      const conversationKey = resolvePrivateConversationKey(channel, sessions, target);
+      if (!conversationKey) throw sessionSyncUnavailable();
+      await workspaces.setDeliveryTargetSessionSync(botId, targetId, conversationKey);
+      return { enabled: true, state: 'active' };
+    },
+    async listSessionSyncTargets(sessionId) {
+      if (typeof sessionId !== 'string' || !sessionId) {
+        throw new TypeError('sessionId is required');
+      }
+      const matches = [];
+      for (const configured of sessionSyncConfigs(workspaces)) {
+        const target = workspaces.deliveryTargetFor(configured.botId, configured.targetId);
+        if (!target || !privateConversationKeyMatchesTarget(
+          channel,
+          configured.conversationKey,
+          target,
+        )) continue;
+        let sessions;
+        try {
+          sessions = stateSessions(await stateFor(configured.botId));
+        } catch {
+          continue;
+        }
+        if (sessions?.[configured.conversationKey] === sessionId) {
+          matches.push({ botId: configured.botId, targetId: configured.targetId });
+        }
+      }
+      return matches;
+    },
+    async sendSessionSyncText(botId, targetId, sessionId, text, options = {}) {
+      if (typeof text !== 'string' || !text.trim()) throw new TypeError('text is required');
+      const configured = sessionSyncConfigs(workspaces, botId)
+        .find((target) => target.targetId === targetId);
+      const target = workspaces.deliveryTargetFor(botId, targetId);
+      if (!configured || !target || !privateConversationKeyMatchesTarget(
+        channel,
+        configured.conversationKey,
+        target,
+      )) throw sessionSyncUnavailable('Session sync target is no longer enabled');
+      const sessions = stateSessions(await stateFor(botId));
+      if (sessions?.[configured.conversationKey] !== sessionId) {
+        throw sessionSyncUnavailable('Session sync target is no longer bound to this Session');
+      }
+      if (typeof coreController.sendProactiveText !== 'function') {
+        throw new TypeError('delivery controller cannot send proactive text');
+      }
+      await coreController.sendProactiveText(botId, target, text, options);
+      return { sent: true };
+    },
   });
 }

package/plugin-src/host/delivery-rpc.mjs

@@ -9,6 +9,7 @@ export const DELIVERY_ENDPOINTS = Object.freeze({
   createTarget: 'target.create',
   updateTarget: 'target.update',
   deleteTarget: 'target.delete',
+  setSessionSync: 'target.session-sync.set',
   testTarget: 'target.test',
 });
 
@@ -22,6 +23,7 @@ const PUBLIC_ERRORS = new Set([
   'bot-not-connected',
   'target-rejected',
   'delivery-failed',
+  'session-sync-unavailable',
   'cancelled',
 ]);
 
@@ -85,6 +87,11 @@ function validPayload(endpoint, payload) {
       || (exactKeys(payload, ['botId', 'target'])
         && validBotId(payload.botId) && validDraftTarget(payload.target));
   }
+  if (endpoint === DELIVERY_ENDPOINTS.setSessionSync) {
+    return exactKeys(payload, ['botId', 'targetId', 'enabled'])
+      && validBotId(payload.botId) && validTargetId(payload.targetId)
+      && typeof payload.enabled === 'boolean';
+  }
   return exactKeys(payload, ['botId', 'targetId'])
     && validBotId(payload.botId) && validTargetId(payload.targetId);
 }
@@ -131,6 +138,11 @@ export function createDeliveryRpcHandler(service) {
         value = await service.updateTarget(payload.botId, payload.targetId, payload.target);
       } else if (endpoint === DELIVERY_ENDPOINTS.deleteTarget) {
         value = await service.deleteTarget(payload.botId, payload.targetId);
+      } else if (endpoint === DELIVERY_ENDPOINTS.setSessionSync) {
+        if (typeof service.setSessionSync !== 'function') {
+          throw new TypeError('Session sync is unavailable');
+        }
+        value = await service.setSessionSync(payload.botId, payload.targetId, payload.enabled);
       } else {
         value = await service.send(
           payload.botId,

package/plugin-src/host/delivery-service.mjs

@@ -25,9 +25,16 @@ const DELIVERY_ERROR_CODES = new Set([
   'bot-not-connected',
   'target-rejected',
   'delivery-failed',
+  'session-sync-unavailable',
   'cancelled',
 ]);
 
+const SESSION_SYNC_METHODS = Object.freeze([
+  'setSessionSync',
+  'listSessionSyncTargets',
+  'sendSessionSyncText',
+]);
+
 function deliveryError(code, message = code, options) {
   const error = new Error(message, options);
   error.code = code;
@@ -93,8 +100,29 @@ function validateAdapter(adapter) {
   return adapter;
 }
 
+function sessionSyncState(value, available) {
+  const enabled = value?.enabled === true;
+  if (!available) return { enabled, state: 'unavailable' };
+  const state = value?.state;
+  if (['off', 'active', 'waiting', 'unavailable'].includes(state)) {
+    return { enabled, state };
+  }
+  return { enabled: false, state: 'unavailable' };
+}
+
 export class DeliveryService {
   #adapters = new Map();
+  #unavailableSessionSyncChannels;
+
+  constructor({ unavailableSessionSyncChannels = [] } = {}) {
+    if (!Array.isArray(unavailableSessionSyncChannels)
+      || unavailableSessionSyncChannels.some((channel) => (
+        typeof channel !== 'string' || !CHANNEL_PATTERN.test(channel)
+      ))) {
+      throw new TypeError('unavailableSessionSyncChannels must contain valid channel ids');
+    }
+    this.#unavailableSessionSyncChannels = new Set(unavailableSessionSyncChannels);
+  }
 
   registerAdapter(value) {
     const adapter = validateAdapter(value);
@@ -113,7 +141,15 @@ export class DeliveryService {
     try {
       const targets = await adapter.listTargets(id);
       if (!Array.isArray(targets)) throw new TypeError('Adapter returned invalid targets');
-      return { botId: id, channel: adapter.channel, targets };
+      const available = this.#supportsSessionSync(adapter);
+      return {
+        botId: id,
+        channel: adapter.channel,
+        targets: targets.map((target) => ({
+          ...target,
+          sessionSync: sessionSyncState(target?.sessionSync, available),
+        })),
+      };
     } catch (error) {
       throw publicOperationError(error);
     }
@@ -188,6 +224,72 @@ export class DeliveryService {
     }
   }
 
+  async setSessionSync(botId, targetId, enabled) {
+    const id = botIdOf(botId);
+    const targetKey = targetIdOf(targetId);
+    if (typeof enabled !== 'boolean') throw deliveryError('bad-request', 'Invalid enabled state');
+    const adapter = await this.#adapterFor(id);
+    const hasMethods = SESSION_SYNC_METHODS.every((method) => typeof adapter[method] === 'function');
+    if (!hasMethods || (enabled && !this.#supportsSessionSync(adapter))) {
+      throw deliveryError('session-sync-unavailable', 'Session sync is unavailable');
+    }
+    try {
+      return await adapter.setSessionSync(id, targetKey, enabled);
+    } catch (error) {
+      throw publicOperationError(error);
+    }
+  }
+
+  async listSessionSyncTargets(sessionId) {
+    if (typeof sessionId !== 'string' || !sessionId) {
+      throw deliveryError('bad-request', 'Invalid Session id');
+    }
+    const targets = [];
+    for (const { adapter } of this.#adapters.values()) {
+      if (!this.#supportsSessionSync(adapter)) continue;
+      try {
+        const listed = await adapter.listSessionSyncTargets(sessionId);
+        if (!Array.isArray(listed)) throw new TypeError('Adapter returned invalid sync targets');
+        for (const target of listed) {
+          targets.push({
+            channel: adapter.channel,
+            botId: botIdOf(target?.botId),
+            targetId: targetIdOf(target?.targetId),
+          });
+        }
+      } catch (error) {
+        console.warn(
+          `[dsh-im] ignored ${adapter.channel} Session sync target lookup failure`
+            + ` (${error?.code ?? error?.name ?? 'unknown-error'})`,
+        );
+      }
+    }
+    return targets;
+  }
+
+  async sendSessionSyncText(botId, targetId, sessionId, text, { signal } = {}) {
+    const id = botIdOf(botId);
+    const targetKey = targetIdOf(targetId);
+    if (typeof sessionId !== 'string' || !sessionId
+      || typeof text !== 'string' || !text.trim()) {
+      throw deliveryError('bad-request', 'Invalid session sync delivery');
+    }
+    cancellation(signal);
+    const adapter = await this.#adapterFor(id);
+    if (!this.#supportsSessionSync(adapter)) {
+      throw deliveryError('session-sync-unavailable', 'Session sync is unavailable');
+    }
+    try {
+      await adapter.sendSessionSyncText(id, targetKey, sessionId, text, { signal });
+      return { sent: true };
+    } catch (error) {
+      if (signal?.aborted || error?.name === 'AbortError' || error?.code === 'ABORT_ERR') {
+        throw deliveryError('cancelled', 'Request cancelled', { cause: error });
+      }
+      throw publicOperationError(error);
+    }
+  }
+
   async send(botId, targetIdOrDraft, text, { signal } = {}) {
     const id = botIdOf(botId);
     const targetKey = typeof targetIdOrDraft === 'string'
@@ -232,8 +334,13 @@ export class DeliveryService {
     }
     throw deliveryError('unknown-bot', 'Unknown bot');
   }
+
+  #supportsSessionSync(adapter) {
+    return !this.#unavailableSessionSyncChannels.has(adapter.channel)
+      && SESSION_SYNC_METHODS.every((method) => typeof adapter[method] === 'function');
+  }
 }
 
-export function createDeliveryService() {
-  return new DeliveryService();
+export function createDeliveryService(options) {
+  return new DeliveryService(options);
 }

package/plugin-src/host/delivery-suggestions.mjs

@@ -115,6 +115,52 @@ export function deliverySuggestionFromConversationKey(channel, key) {
   }
 }
 
+/** Convert only a persisted private-chat key into its stable delivery route. */
+export function privateDeliverySuggestionFromConversationKey(channel, key) {
+  const separator = typeof key === 'string' ? key.indexOf(':') : -1;
+  const prefix = separator > 0 ? key.slice(0, separator) : '';
+  const privatePrefix = {
+    weixin: 'p2p',
+    feishu: 'p2p',
+    dingtalk: 'p2p',
+    wecom: 'direct',
+    qq: 'c2c',
+    slack: 'direct',
+    telegram: 'direct',
+    discord: 'direct',
+    whatsapp: 'direct',
+  }[channel];
+  if (!privatePrefix || prefix !== privatePrefix) return null;
+  return deliverySuggestionFromConversationKey(channel, key);
+}
+
+function routeIdentity(value) {
+  if (!isRecord(value?.route) || typeof value.kind !== 'string') return null;
+  return JSON.stringify([
+    value.kind,
+    Object.keys(value.route).sort().map((key) => [key, value.route[key]]),
+  ]);
+}
+
+/** Check that one saved private conversation key still identifies this target route. */
+export function privateConversationKeyMatchesTarget(channel, key, target) {
+  const suggestion = privateDeliverySuggestionFromConversationKey(channel, key);
+  const suggestionIdentity = routeIdentity(suggestion);
+  return suggestionIdentity !== null && suggestionIdentity === routeIdentity(target);
+}
+
+/** Resolve exactly one current private conversation for a normalized delivery target. */
+export function resolvePrivateConversationKey(channel, sessions, target) {
+  if (!CHANNELS.has(channel) || !isRecord(sessions)) return null;
+  const matches = [];
+  for (const [key, sessionId] of Object.entries(sessions)) {
+    if (typeof sessionId !== 'string' || !sessionId) continue;
+    if (privateConversationKeyMatchesTarget(channel, key, target)) matches.push(key);
+    if (matches.length > 1) return null;
+  }
+  return matches[0] ?? null;
+}
+
 /**
  * Extract and de-duplicate stable delivery routes from a persisted sessions map.
  * Session ids and every other state field are intentionally ignored.

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

@@ -55,12 +55,12 @@ function deepFreeze(value) {
   return Object.freeze(value);
 }
 
-function steeringMessage(text) {
+function steeringMessage(text, rpcId) {
   return deepFreeze({
     id: randomUUID(),
     role: 'user',
     content: [{ type: 'text', text }],
-    source: { kind: 'user' },
+    source: { kind: 'user', rpcId },
   });
 }
 
@@ -71,7 +71,7 @@ function agentBusyError(cause) {
 }
 
 function createControlExecutor(agents) {
-  return ({ sessionId, expectedTurn, promptRpcId, action, text }) => {
+  return ({ sessionId, expectedTurn, promptRpcId, inputRpcId, action, text }) => {
     const agent = agents.get(sessionId);
     // An unattached Session cannot be coordinated in-process. Let the client
     // retain its legacy HTTP path for deployments where attachment is lazy.
@@ -83,10 +83,11 @@ function createControlExecutor(agents) {
       return true;
     }
     if (action === 'steer') {
-      if (typeof text !== 'string' || !text.trim()) return false;
+      if (typeof text !== 'string' || !text.trim()
+        || typeof inputRpcId !== 'string' || !inputRpcId) return false;
       // inject() never wakes an idle driver. Because validation and injection
       // share one JS tick, this context can only target this live turn's next step.
-      agent.inject(steeringMessage(text));
+      agent.inject(steeringMessage(text, inputRpcId));
       return true;
     }
     throw new TypeError(`Unsupported Harness control action: ${String(action)}`);

package/plugin-src/host/index.mjs

@@ -14,6 +14,7 @@ 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';
@@ -36,6 +37,8 @@ export function createImHostPlugin(internals = {}) {
   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;
@@ -63,7 +66,11 @@ 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) => (
@@ -135,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);
+      }
+    }
   }
 }