@dsbot-channel/core 0.7.0 → 0.7.1

package/dist/adapter-plugin.js

@@ -46,10 +46,16 @@ export function makeAdapterPlugin(spec) {
             source: `${spec.name} plugin`,
         };
         const mount = ctx.get(MOUNT_SERVICE);
-        if (mount === undefined)
+        if (mount === undefined) {
             registry.addInstance(instance);
-        else
-            mount.add(instance);
+            return;
+        }
+        mount.add(instance);
+        const remove = mount.remove;
+        if (remove === undefined)
+            return;
+        // A reload disposes this plugin first, so the instance leaves the gateway before it is applied again.
+        ctx.effect(() => () => Promise.resolve(remove.call(mount, instance.channel, instance.source)).catch(() => undefined), `${spec.name}: adapter instance`);
     };
     const plugin = { name: spec.name, inject: [REGISTRY_SERVICE], Config: AdapterPluginConfig, apply };
     return { Config: AdapterPluginConfig, apply, plugin };

package/dist/plugin.js

@@ -685,6 +685,14 @@ async function applyWith(ctx, raw, options = {}, skillFile) {
     const bots = botScopes(effective, written, rawProfile.policy);
     const pipelines = new SessionPipelines({ bots });
     const channels = mountAdapters(effective, settings, warn, registry, (index) => writtenRaw[index], rawProfile.policy, roster);
+    // One live view: the push router and the capability gate read these, so a late mount or an unmount is
+    // visible to them at once without rebuilding anything per send.
+    const byChannel = new Map(channels.map((channel) => [channel.config.channel, channel]));
+    const pushChannels = channels.map((channel) => ({
+        channel: channel.config.channel,
+        botName: channel.config.botName,
+    }));
+    let refreshSendText = () => undefined;
     const scoreService = ctx.get('dsbot-channel/score');
     const judgeService = ctx.get('dsbot-channel/judge');
     const declaredPipelines = pipelineScopesOf(effective).map((scopes) => resolvePipeline(scopes).nodes);
@@ -1100,6 +1108,8 @@ async function applyWith(ctx, raw, options = {}, skillFile) {
     const chanceCounts = new Map();
     const selections = new Map();
     const started = [];
+    const handles = new Map();
+    const windowsByChannel = new Map();
     const runtimes = [];
     const configLayers = [];
     ctx.effect(() => async () => {
@@ -1143,6 +1153,7 @@ async function applyWith(ctx, raw, options = {}, skillFile) {
             const context = new ContextBuffer(turnSettings.context);
             const windows = new TurnWindows({ now: clock, setTimer, clearTimer }, { limits: { maxBatch: turnSettings.maxBatch, maxChars: turnSettings.maxChars }, windowMs: turnSettings.coalesceMs });
             windowBuffers.push(windows);
+            windowsByChannel.set(adapter.channel, windows);
             const mergedPolicy = effectivePolicy(rawProfile.policy, writtenBlock?.policy);
             const compiled = compilePolicy(mergedPolicy);
             const policyBlock = mergedPolicy;
@@ -1401,7 +1412,9 @@ async function applyWith(ctx, raw, options = {}, skillFile) {
                 windows.offer(`${adapter.botName}|${message.sessionKey}`, { eventKey: message.eventKey, chars: message.body.text.length, value: message }, (batch) => runBatch(batch));
                 return { ok: true };
             };
-            started.push(await transport.start({ onMessage, resolveSecret }));
+            const handle = await transport.start({ onMessage, resolveSecret });
+            started.push(handle);
+            handles.set(adapter.channel, handle);
         }
     };
     try {
@@ -1451,15 +1464,23 @@ async function applyWith(ctx, raw, options = {}, skillFile) {
         writtenRaw.push(raw);
         channels.push(...fresh);
         mountedBy.set(config.channel, source);
-        for (const mounted of fresh)
+        for (const mounted of fresh) {
             reporting.add(mounted.adapter);
+            byChannel.set(mounted.config.channel, mounted);
+            pushChannels.push({ channel: mounted.config.channel, botName: mounted.config.botName });
+        }
         try {
             checkReplyModes(fresh);
             refreshBots();
         }
         catch (error) {
-            for (const mounted of fresh)
+            for (const mounted of fresh) {
                 reporting.delete(mounted.adapter);
+                byChannel.delete(mounted.config.channel);
+                const pushed = pushChannels.findIndex((one) => one.channel === mounted.config.channel);
+                if (pushed >= 0)
+                    pushChannels.splice(pushed, 1);
+            }
             mountedBy.delete(config.channel);
             channels.splice(channels.length - fresh.length, fresh.length);
             writtenRaw.pop();
@@ -1471,10 +1492,89 @@ async function applyWith(ctx, raw, options = {}, skillFile) {
             identity = readIdentity(true);
             readImportTarget();
         }
+        refreshSendText();
         startQueued(fresh);
     };
+    /** Drops one mounted channel: every live view forgets it, and its listener and sessions are released. */
+    const removeChannel = (channel, source) => {
+        const run = async () => {
+            const mounted = byChannel.get(channel);
+            if (mounted === undefined)
+                return;
+            const declared = mountedBy.get(channel);
+            if (source !== undefined && declared !== undefined && declared !== source)
+                return;
+            const windows = windowsByChannel.get(channel);
+            if (windows !== undefined) {
+                const at = windowBuffers.indexOf(windows);
+                if (at >= 0)
+                    windowBuffers.splice(at, 1);
+                windows.clear();
+                windowsByChannel.delete(channel);
+            }
+            const sessions = selections.get(channel);
+            if (sessions !== undefined) {
+                const at = runtimes.indexOf(sessions);
+                if (at >= 0)
+                    runtimes.splice(at, 1);
+                selections.delete(channel);
+                sessions.dispose();
+            }
+            const handle = handles.get(channel);
+            handles.delete(channel);
+            if (handle !== undefined) {
+                const at = started.indexOf(handle);
+                if (at >= 0)
+                    started.splice(at, 1);
+                try {
+                    await handle.stop();
+                }
+                catch (error) {
+                    warn(`dsbot-channel: stopping "${channel}" failed: ${String(error)}`);
+                }
+            }
+            const configAt = mounts.indexOf(mounted.config);
+            if (configAt >= 0) {
+                mounts.splice(configAt, 1);
+                writtenRaw.splice(configAt, 1);
+            }
+            const at = channels.indexOf(mounted);
+            if (at >= 0)
+                channels.splice(at, 1);
+            const pushed = pushChannels.findIndex((one) => one.channel === channel);
+            if (pushed >= 0)
+                pushChannels.splice(pushed, 1);
+            byChannel.delete(channel);
+            mountedBy.delete(channel);
+            reporting.delete(mounted.adapter);
+            chanceCounts.delete(channel);
+            const layerAt = configLayers.findIndex((entry) => entry.channel === channel);
+            if (layerAt >= 0)
+                configLayers.splice(layerAt, 1);
+            if (!channels.some((one) => one.config.botName === mounted.config.botName)) {
+                const ledgerAt = ledgers.findIndex((one) => one.bot === mounted.config.botName);
+                if (ledgerAt >= 0)
+                    ledgers.splice(ledgerAt, 1);
+            }
+            try {
+                refreshBots();
+                identity = readIdentity(true);
+                readImportTarget();
+                const dangling = [...identityPending.values(), ...importPending.values()].filter((error) => error.message.includes(channel));
+                if (dangling.length > 0)
+                    warn(`dsbot-channel: after unmounting "${channel}": ${dangling[0].message}`);
+            }
+            catch (error) {
+                warn(`dsbot-channel: re-checking the profile after unmounting "${channel}" failed: ${String(error)}`);
+            }
+            refreshSendText();
+        };
+        const queued = starting.then(run);
+        starting = queued.then(() => undefined, () => undefined);
+        return queued;
+    };
     ctx.provide(MOUNT_SERVICE);
-    ctx.set(MOUNT_SERVICE, { add: addInstance });
+    ctx.set(MOUNT_SERVICE, { add: addInstance, remove: removeChannel });
     // An instance queued while the gateway was still applying is mounted here instead of being lost.
     for (const one of registry.takeInstances())
         addInstance(one);
@@ -1507,12 +1607,8 @@ async function applyWith(ctx, raw, options = {}, skillFile) {
     ctx.provide('dsbot-channel.peers');
     ctx.set('dsbot-channel.peers', started);
     if (tools !== undefined && typeof tools.register === 'function') {
-        const byChannel = new Map(channels.map((channel) => [channel.config.channel, channel]));
         const router = new PushRouter({
-            channels: channels.map((channel) => ({
-                channel: channel.config.channel,
-                botName: channel.config.botName,
-            })),
+            channels: pushChannels,
             source: (sessionId) => (sessionId === undefined ? undefined : sources.get(sessionId)),
             checkTarget: (channel, target) => byChannel.get(channel)?.adapter.checkTarget(target),
             describeTargets: (channel) => byChannel.get(channel)?.adapter.describeTargets() ?? '',
@@ -1556,7 +1652,19 @@ async function applyWith(ctx, raw, options = {}, skillFile) {
                 return sent;
             },
         });
-        ctx.effect(() => tools.register(createSendText(router)), 'dsbot-channel: send_text tool');
+        let releaseSendText;
+        // The description lists the live channels, so a mount or an unmount republished it.
+        refreshSendText = () => {
+            releaseSendText?.();
+            releaseSendText = tools.register(createSendText(router));
+        };
+        ctx.effect(() => {
+            refreshSendText();
+            return () => {
+                releaseSendText?.();
+                releaseSendText = undefined;
+            };
+        }, 'dsbot-channel: send_text tool');
         const gate = new CapabilityGate({
             router,
             capabilities: (channel) => byChannel.get(channel)?.adapter.capabilities,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dsbot-channel/core",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "Core of dsbot-channel: gateway, sessions, pipeline, tools and the adapter registry.",
   "type": "module",
   "main": "dist/index.js",