happy2 0.0.13 → 0.0.15

package/packages/happy2-server/dist/modules/plugin/service.js

@@ -5,25 +5,46 @@ import { join } from "node:path";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { realtimeTopics } from "../realtime/index.js";
 import { chatUpdateMetadata } from "../chat/chatUpdateMetadata.js";
+import { channelCreateWithMembers } from "../chat/channelCreateWithMembers.js";
+import { channelMembersUpdate } from "../chat/channelMembersUpdate.js";
+import { messageSend } from "../message/messageSend.js";
 import { pluginInstall } from "./pluginInstall.js";
 import { pluginFindBySource } from "./pluginFindBySource.js";
 import { pluginGetSource } from "./pluginGetSource.js";
 import { pluginGetImage } from "./pluginGetImage.js";
 import { pluginAuthorizeManagement } from "./pluginAuthorizeManagement.js";
 import { pluginInstallationGetRuntimeConfiguration } from "./pluginInstallationGetRuntimeConfiguration.js";
+import { pluginInstallationGetRequestUninstallContext } from "./pluginInstallationGetRequestUninstallContext.js";
+import { pluginInstallationUninstall } from "./pluginInstallationUninstall.js";
 import { pluginInstallationListIds } from "./pluginInstallationListIds.js";
 import { pluginInstallationListReadyMcpIds } from "./pluginInstallationListReadyMcpIds.js";
 import { pluginInstallationUpdateStatus } from "./pluginInstallationUpdateStatus.js";
+import { pluginInstallationPermissionsUpdate } from "./pluginInstallationPermissionsUpdate.js";
+import { pluginInstallationGetContainerName } from "./pluginInstallationGetContainerName.js";
+import { pluginAgentCallContextGet } from "./pluginAgentCallContextGet.js";
 import { pluginRemoveMissingBuiltins } from "./pluginRemoveMissingBuiltins.js";
 import { pluginMcpToolsReplace } from "./pluginMcpToolsReplace.js";
 import { pluginMcpToolsListReady } from "./pluginMcpToolsListReady.js";
 import { pluginSkillsListReady } from "./pluginSkillsListReady.js";
 import { pluginSkillsListInstalled } from "./pluginSkillsListInstalled.js";
+import { pluginApiPermissionSections } from "./impl/apiPermissions.js";
+import { effectiveContainer } from "./impl/effectiveContainer.js";
 import { pluginContainerInstanceAuthorize } from "./pluginContainerInstanceAuthorize.js";
 import { pluginContainerInstanceInvalidate } from "./pluginContainerInstanceInvalidate.js";
 import { pluginUninstall } from "./pluginUninstall.js";
 import { pluginArchiveExtract } from "./archive.js";
 import { pluginPackageLoadSource } from "./catalog.js";
+import { pluginManagementRequestBeginInstall } from "./pluginManagementRequestBeginInstall.js";
+import { pluginManagementRequestBeginUninstall } from "./pluginManagementRequestBeginUninstall.js";
+import { pluginManagementRequestCompleteInstall } from "./pluginManagementRequestCompleteInstall.js";
+import { pluginManagementRequestCompleteUninstall } from "./pluginManagementRequestCompleteUninstall.js";
+import { pluginManagementRequestCreateInstall } from "./pluginManagementRequestCreateInstall.js";
+import { pluginManagementRequestCreateUninstall } from "./pluginManagementRequestCreateUninstall.js";
+import { pluginManagementRequestDeny } from "./pluginManagementRequestDeny.js";
+import { pluginManagementRequestGetPackage } from "./pluginManagementRequestGetPackage.js";
+import { pluginManagementRequestList } from "./pluginManagementRequestList.js";
+import { pluginManagementRequestListTerminalIds } from "./pluginManagementRequestListTerminalIds.js";
+import { pluginManagementRequestRecoverProcessing } from "./pluginManagementRequestRecoverProcessing.js";
 import { RemotePluginMcpTransport } from "./utils/remoteMcpTransport.js";
 import { downloadedPluginSource, remotePluginSource, remotePluginSourceFromInstalled, uploadedPluginSource, } from "./source.js";
 import { PluginError, MAX_PLUGIN_MCP_TOOLS, } from "./types.js";
@@ -34,12 +55,14 @@ const MAX_RIG_PLUGIN_FUNCTIONS = 128;
 const MAX_RIG_PLUGIN_SKILLS = 128;
 const PREPARATION_TTL_MS = 15 * 60_000;
 const PLUGIN_CHAT_META_KEY = "happy2/chat";
+const PLUGIN_USERS_META_KEY = "happy2/users";
 /** Coordinates durable plugin installs with asynchronous container preparation, MCP health probes, restart recovery, and local connection creation. */
 export class PluginService {
     executor;
     pubsub;
     catalog;
     packages;
+    packageLinks;
     secrets;
     runtime;
     tokens;
@@ -52,11 +75,12 @@ export class PluginService {
     commandHandles = new Map();
     preparations = new Map();
     closed = false;
-    constructor(executor, pubsub, catalog, packages, secrets, runtime, tokens, urlPolicy, remoteTransport, hostApiUrl, archiveDownloader, onError) {
+    constructor(executor, pubsub, catalog, packages, packageLinks, secrets, runtime, tokens, urlPolicy, remoteTransport, hostApiUrl, archiveDownloader, onError) {
         this.executor = executor;
         this.pubsub = pubsub;
         this.catalog = catalog;
         this.packages = packages;
+        this.packageLinks = packageLinks;
         this.secrets = secrets;
         this.runtime = runtime;
         this.tokens = tokens;
@@ -68,6 +92,10 @@ export class PluginService {
     }
     async start() {
         await this.packages.cleanupTemporary();
+        for (const hint of await pluginManagementRequestRecoverProcessing(this.executor))
+            await this.publish(hint).catch(this.onError);
+        for (const requestId of await pluginManagementRequestListTerminalIds(this.executor))
+            await this.packages.removeRequest(requestId).catch(this.onError);
         const removed = await pluginRemoveMissingBuiltins(this.executor, this.catalog.list().map(({ source }) => source.reference));
         await Promise.all([
             ...removed.plugins.map(({ pluginId }) => this.packages.remove(pluginId).catch(this.onError)),
@@ -79,24 +107,70 @@ export class PluginService {
             this.activate(installationId);
     }
     async install(input) {
-        await pluginAuthorizeManagement(this.executor, input.actorUserId);
+        if (input.actorUserId)
+            await pluginAuthorizeManagement(this.executor, input.actorUserId);
+        else if (!input.actorInstallationId)
+            throw new PluginError("forbidden", "Plugin installation authority is required");
         const plugin = this.catalog.get(input.shortName);
         if (!plugin)
             throw new PluginError("not_found", "Built-in plugin was not found");
-        const installationId = createId();
-        const existing = await pluginFindBySource(this.executor, plugin.source.kind, plugin.source.reference);
+        return this.installPackage({ ...input, plugin });
+    }
+    async installArchive(input) {
+        await pluginAuthorizeManagement(this.executor, input.actorUserId);
+        const prepared = await this.prepareRequestedArchive(input.archive, {
+            kind: "archive",
+            reference: "pending",
+        });
+        try {
+            return await this.installPackage({
+                ...input,
+                permissions: [],
+                plugin: prepared.plugin,
+            });
+        }
+        finally {
+            await prepared.cleanup();
+        }
+    }
+    async installLink(input) {
+        await pluginAuthorizeManagement(this.executor, input.actorUserId);
+        const downloaded = await this.downloadPackage(input.url);
+        const prepared = await this.prepareRequestedArchive(downloaded.body, {
+            kind: "link",
+            reference: downloaded.url,
+        });
+        try {
+            return await this.installPackage({
+                ...input,
+                permissions: [],
+                plugin: prepared.plugin,
+            });
+        }
+        finally {
+            await prepared.cleanup();
+        }
+    }
+    async installPackage(input) {
+        const installationId = input.installationId ?? createId();
+        const existing = await pluginFindBySource(this.executor, input.plugin.source.kind, input.plugin.source.reference);
         const candidateId = existing ? undefined : createId();
         const candidate = candidateId
-            ? { pluginId: candidateId, ...(await this.packages.install(plugin, candidateId)) }
+            ? {
+                pluginId: candidateId,
+                ...(await this.packages.install(input.plugin, candidateId)),
+            }
             : undefined;
         let result;
         try {
             result = await pluginInstall(this.executor, this.secrets, {
                 actorUserId: input.actorUserId,
+                actorInstallationId: input.actorInstallationId,
                 installationId,
-                plugin,
+                plugin: input.plugin,
                 candidate,
                 variables: input.variables,
+                permissions: input.permissions,
                 containerImageId: input.containerImageId,
             });
         }
@@ -154,6 +228,7 @@ export class PluginService {
                     plugin: prepared.plugin,
                     candidate,
                     variables: input.variables,
+                    permissions: input.permissions,
                     containerImageId: input.containerImageId,
                 });
             }
@@ -242,6 +317,58 @@ export class PluginService {
             },
         };
     }
+    async updatePermissions(input) {
+        const result = await pluginInstallationPermissionsUpdate(this.executor, input);
+        if (!result.changed)
+            return result.installation;
+        if (result.hint)
+            await this.publish(result.hint).catch(this.onError);
+        await this.stopActivation(input.installationId);
+        if (result.containerName)
+            await this.runtime.removeLocal(result.containerName).catch(this.onError);
+        this.activate(input.installationId);
+        return result.installation;
+    }
+    async uninstallInstallation(input) {
+        if (input.actorUserId)
+            await pluginAuthorizeManagement(this.executor, input.actorUserId);
+        else if (!input.actorInstallationId)
+            throw new PluginError("forbidden", "Plugin installation authority is required");
+        const containerName = await pluginInstallationGetContainerName(this.executor, input.installationId);
+        await this.stopActivation(input.installationId);
+        try {
+            if (containerName)
+                await this.runtime.removeLocal(containerName);
+            const result = await pluginInstallationUninstall(this.executor, input);
+            if (result.pluginRemoved)
+                await this.packages.remove(result.pluginId);
+            await this.publish(result.hint).catch(this.onError);
+        }
+        catch (error) {
+            this.activate(input.installationId);
+            throw error;
+        }
+    }
+    async downloadPackage(url) {
+        try {
+            return await this.packageLinks.download(url);
+        }
+        catch (error) {
+            if (error instanceof PluginError)
+                throw error;
+            throw new PluginError("broken_configuration", errorMessage(error));
+        }
+    }
+    async prepareRequestedArchive(archive, source) {
+        try {
+            return await this.packages.prepareArchive(archive, source);
+        }
+        catch (error) {
+            if (error instanceof PluginError)
+                throw error;
+            throw new PluginError("broken_configuration", errorMessage(error));
+        }
+    }
     async image(actorUserId, pluginId) {
         const image = await pluginGetImage(this.executor, actorUserId, pluginId);
         const body = await this.packages.readImage(image.pluginId, image.packageDirectory, image.storageKey, image.shortName, image.packageDigest);
@@ -254,6 +381,165 @@ export class PluginService {
             checksumSha256: image.checksumSha256,
         };
     }
+    async requestInstallLink(input) {
+        const downloaded = await this.downloadPackage(input.url);
+        const prepared = await this.prepareRequestedArchive(downloaded.body, {
+            kind: "link",
+            reference: downloaded.url,
+        });
+        const requestId = createId();
+        try {
+            if (prepared.plugin.manifest.variables.length)
+                throw new PluginError("broken_configuration", "Plugins that require configuration must be installed directly by an administrator");
+            const container = effectiveContainer(prepared.plugin.manifest);
+            if (container && !container.dockerfile)
+                throw new PluginError("broken_configuration", "Plugins that require an administrator-selected image cannot be requested from chat");
+            const packageDirectory = await this.packages.stageRequest(prepared.plugin, requestId);
+            try {
+                const result = await pluginManagementRequestCreateInstall(this.executor, {
+                    id: requestId,
+                    actorUserId: input.agentCall.actorUserId,
+                    agentUserId: input.agentCall.agentUserId,
+                    callId: input.agentCall.callId,
+                    chatId: input.agentCall.chatId,
+                    requesterInstallationId: input.requesterInstallationId,
+                    displayName: prepared.plugin.manifest.displayName,
+                    shortName: prepared.plugin.manifest.shortName,
+                    description: prepared.plugin.manifest.description,
+                    reason: input.reason,
+                    sourceKind: "link",
+                    sourceReference: downloaded.url,
+                    packageDigest: prepared.plugin.packageDigest,
+                    packageDirectory,
+                    installationId: createId(),
+                });
+                if (!result.created)
+                    await this.packages.removeRequest(requestId);
+                if (result.hint)
+                    await this.publish(result.hint).catch(this.onError);
+                return result.request;
+            }
+            catch (error) {
+                await this.packages.removeRequest(requestId);
+                throw error;
+            }
+        }
+        finally {
+            await prepared.cleanup();
+        }
+    }
+    async requestUninstall(input) {
+        const target = await pluginInstallationGetRequestUninstallContext(this.executor, input.targetInstallationId);
+        const plugin = await this.packages.loadInstalled(target.pluginId, target.packageDirectory, target.shortName, target.packageDigest, target.source);
+        const requestId = createId();
+        const packageDirectory = await this.packages.stageRequest(plugin, requestId);
+        try {
+            const result = await pluginManagementRequestCreateUninstall(this.executor, {
+                id: requestId,
+                actorUserId: input.agentCall.actorUserId,
+                agentUserId: input.agentCall.agentUserId,
+                callId: input.agentCall.callId,
+                chatId: input.agentCall.chatId,
+                requesterInstallationId: input.requesterInstallationId,
+                targetInstallationId: input.targetInstallationId,
+                displayName: target.displayName,
+                shortName: target.shortName,
+                description: target.description,
+                reason: input.reason,
+                source: target.source,
+                packageDigest: target.packageDigest,
+                packageDirectory,
+            });
+            if (!result.created)
+                await this.packages.removeRequest(requestId);
+            if (result.hint)
+                await this.publish(result.hint).catch(this.onError);
+            return result.request;
+        }
+        catch (error) {
+            await this.packages.removeRequest(requestId);
+            throw error;
+        }
+    }
+    listManagementRequests(actorUserId, chatId) {
+        return pluginManagementRequestList(this.executor, actorUserId, chatId);
+    }
+    async managementRequestImage(input) {
+        const request = await pluginManagementRequestGetPackage(this.executor, input.actorUserId, input.chatId, input.requestId);
+        return this.packages.readRequestImage(request.id, request.packageDirectory, request.source, request.packageDigest);
+    }
+    async approveManagementRequest(input) {
+        const work = await pluginManagementRequestBeginInstall(this.executor, input);
+        await this.publish(work.hint).catch(this.onError);
+        try {
+            const plugin = await this.packages.loadRequest(work.id, work.packageDirectory, work.source, work.packageDigest);
+            await this.installPackage({
+                actorUserId: input.actorUserId,
+                installationId: work.installationId,
+                plugin,
+                variables: {},
+                permissions: [],
+            });
+        }
+        catch (error) {
+            const hint = await pluginManagementRequestCompleteInstall(this.executor, {
+                ...input,
+                installationId: work.installationId,
+                error: errorMessage(error),
+            });
+            await this.publish(hint).catch(this.onError);
+            await this.packages.removeRequest(input.requestId).catch(this.onError);
+            throw error;
+        }
+        const hint = await pluginManagementRequestCompleteInstall(this.executor, {
+            ...input,
+            installationId: work.installationId,
+        });
+        await this.publish(hint).catch(this.onError);
+        await this.packages.removeRequest(input.requestId).catch(this.onError);
+        const requests = await pluginManagementRequestList(this.executor, input.actorUserId, input.chatId);
+        const request = requests.find(({ id }) => id === input.requestId);
+        if (!request)
+            throw new Error("Completed plugin management request was not found");
+        return request;
+    }
+    async denyManagementRequest(input) {
+        const hint = await pluginManagementRequestDeny(this.executor, input);
+        await this.publish(hint).catch(this.onError);
+        await this.packages.removeRequest(input.requestId).catch(this.onError);
+        const requests = await pluginManagementRequestList(this.executor, input.actorUserId, input.chatId);
+        const request = requests.find(({ id }) => id === input.requestId);
+        if (!request)
+            throw new Error("Denied plugin management request was not found");
+        return request;
+    }
+    async approveUninstallManagementRequest(input) {
+        const work = await pluginManagementRequestBeginUninstall(this.executor, input);
+        await this.publish(work.hint).catch(this.onError);
+        try {
+            await this.uninstallInstallation({
+                actorUserId: input.actorUserId,
+                installationId: work.targetInstallationId,
+            });
+        }
+        catch (error) {
+            const hint = await pluginManagementRequestCompleteUninstall(this.executor, {
+                ...input,
+                error: errorMessage(error),
+            });
+            await this.publish(hint).catch(this.onError);
+            await this.packages.removeRequest(input.requestId).catch(this.onError);
+            throw error;
+        }
+        const hint = await pluginManagementRequestCompleteUninstall(this.executor, input);
+        await this.publish(hint).catch(this.onError);
+        await this.packages.removeRequest(input.requestId).catch(this.onError);
+        const requests = await pluginManagementRequestList(this.executor, input.actorUserId, input.chatId);
+        const request = requests.find(({ id }) => id === input.requestId);
+        if (!request)
+            throw new Error("Completed plugin uninstall request was not found");
+        return request;
+    }
     async openLocal(installationId) {
         const configuration = await pluginInstallationGetRuntimeConfiguration(this.executor, this.secrets, installationId);
         if (configuration.type !== "local" || !configuration.mcp)
@@ -315,7 +601,8 @@ export class PluginService {
     }
     async callFunction(functionName, args, context, signal) {
         try {
-            return await withOperationTimeout(FUNCTION_EXECUTION_TIMEOUT_MS, "Plugin MCP function execution", signal, (operationSignal) => this.callFunctionWithSignal(functionName, args, context, operationSignal));
+            const agentCall = await pluginAgentCallContextGet(this.executor, context.sessionId, context.callId);
+            return await withOperationTimeout(FUNCTION_EXECUTION_TIMEOUT_MS, "Plugin MCP function execution", signal, (operationSignal) => this.callFunctionWithSignal(functionName, args, context, agentCall, operationSignal));
         }
         catch (error) {
             if (signal?.aborted)
@@ -329,7 +616,7 @@ export class PluginService {
             };
         }
     }
-    async callFunctionWithSignal(functionName, args, context, signal) {
+    async callFunctionWithSignal(functionName, args, context, agentCall, signal) {
         const installationId = pluginFunctionInstallationId(functionName);
         if (!installationId)
             throw new Error(`Unknown plugin function ${JSON.stringify(functionName)}`);
@@ -347,8 +634,17 @@ export class PluginService {
         const chatToken = await this.tokens.issuePluginChatToken({
             installationId,
             chatId: context.chatId,
+            actorUserId: context.triggeredByUserId,
+            agentUserId: context.agentUserId,
         });
-        const result = await this.withClient(installationId, signal, async (client) => {
+        const referencedUsers = await Promise.all(context.users.map(async (user) => ({
+            ...user,
+            token: await this.tokens.issuePluginUserToken({
+                installationId,
+                userId: user.id,
+            }),
+        })));
+        const result = await this.withClient(installationId, signal, agentCall, async (client) => {
             const result = await client.callTool({
                 name: cached.name,
                 arguments: jsonArguments(args),
@@ -356,7 +652,9 @@ export class PluginService {
                     [PLUGIN_CHAT_META_KEY]: {
                         id: context.chatId,
                         token: chatToken,
+                        triggeredByUserId: context.triggeredByUserId,
                     },
+                    [PLUGIN_USERS_META_KEY]: referencedUsers,
                 },
             });
             if (result.isError)
@@ -393,6 +691,14 @@ export class PluginService {
         catch {
             throw new PluginError("forbidden", "Plugin runtime token is invalid");
         }
+        if (claims.agentCall) {
+            const active = await pluginAgentCallContextGet(this.executor, claims.agentCall.sessionId, claims.agentCall.callId).catch(() => undefined);
+            if (!active ||
+                active.actorUserId !== claims.agentCall.actorUserId ||
+                active.agentUserId !== claims.agentCall.agentUserId ||
+                active.chatId !== claims.agentCall.chatId)
+                throw new PluginError("forbidden", "Plugin agent-call capability is no longer active");
+        }
         if (!claims.permissions.includes(permission))
             throw new PluginError("forbidden", `Plugin runtime lacks ${permission} permission`);
         const authorized = await pluginContainerInstanceAuthorize(this.executor, claims.installationId, claims.containerInstanceId);
@@ -409,19 +715,10 @@ export class PluginService {
                 await this.publish(hint).catch(this.onError);
             throw new PluginError("forbidden", "Plugin container incarnation is not running");
         }
-        return claims.installationId;
+        return claims;
     }
     async chatUpdate(runtimeToken, chatToken, input) {
-        const installationId = await this.authorizeHost(runtimeToken, "chats:update");
-        let claims;
-        try {
-            claims = await this.tokens.verifyPluginChatToken(chatToken);
-        }
-        catch {
-            throw new PluginError("forbidden", "Plugin chat token is invalid");
-        }
-        if (claims.installationId !== installationId)
-            throw new PluginError("forbidden", "Plugin chat token belongs to another installation");
+        const claims = await this.authorizeChat(runtimeToken, chatToken, "chats:update");
         const result = await chatUpdateMetadata(this.executor, {
             chatId: claims.chatId,
             ...input,
@@ -437,6 +734,122 @@ export class PluginService {
         });
         return { chat: result.chat, sync: result.hint };
     }
+    async channelMembersUpdate(runtimeToken, chatToken, input) {
+        const claims = await this.authorizeChat(runtimeToken, chatToken, "channels:manage");
+        const [addUserIds, removeUserIds] = await Promise.all([
+            this.authorizeUsers(claims.installationId, input.add),
+            this.authorizeUsers(claims.installationId, input.remove),
+        ]);
+        const result = await channelMembersUpdate(this.executor, {
+            actorUserId: claims.actorUserId,
+            chatId: claims.chatId,
+            addUserIds,
+            removeUserIds,
+        });
+        await this.publishHints(result.hints, [...addUserIds, ...removeUserIds]);
+        return {
+            chatId: claims.chatId,
+            addedUserIds: addUserIds,
+            removedUserIds: removeUserIds,
+            sync: result.hints,
+        };
+    }
+    async channelCreate(runtimeToken, chatToken, input, agents) {
+        const claims = await this.authorizeChat(runtimeToken, chatToken, "channels:manage");
+        const memberUserIds = await this.authorizeUsers(claims.installationId, input.members);
+        const clientMutationId = input.idempotencyKey
+            ? `${claims.installationId}:${input.idempotencyKey}`
+            : undefined;
+        if (input.initialMessage?.audience === "agents" && !agents)
+            throw new PluginError("not_ready", "AI agents are not enabled on this server");
+        const created = await channelCreateWithMembers(this.executor, {
+            actorUserId: claims.actorUserId,
+            name: input.name,
+            slug: pluginChannelSlug(input.name),
+            topic: input.description,
+            memberUserIds,
+            clientMutationId,
+            ...(input.initialMessage?.audience === "agents"
+                ? { defaultAgentUserId: claims.agentUserId }
+                : {}),
+        });
+        const hints = [...created.hints];
+        let initialMessage;
+        if (input.initialMessage) {
+            const agentTurns = input.initialMessage.audience === "agents"
+                ? await agents.prepareTurns({
+                    actorUserId: claims.actorUserId,
+                    agentUserIds: [],
+                    chatId: created.chat.id,
+                })
+                : [];
+            const sent = await messageSend(this.executor, {
+                actorUserId: claims.actorUserId,
+                chatId: created.chat.id,
+                text: input.initialMessage.text,
+                audience: input.initialMessage.audience,
+                agentTurns,
+                clientMutationId,
+            });
+            initialMessage = sent.message;
+            hints.push(sent.hint);
+            if (agentTurns.length)
+                agents.startTurn(created.chat.id);
+        }
+        await this.publishHints(hints, [claims.actorUserId, ...memberUserIds]);
+        return {
+            chat: created.chat,
+            ...(initialMessage ? { initialMessage } : {}),
+            sync: hints,
+        };
+    }
+    async authorizeChat(runtimeToken, chatToken, permission) {
+        const { installationId } = await this.authorizeHost(runtimeToken, permission);
+        let claims;
+        try {
+            claims = await this.tokens.verifyPluginChatToken(chatToken);
+        }
+        catch {
+            throw new PluginError("forbidden", "Plugin chat token is invalid");
+        }
+        if (claims.installationId !== installationId)
+            throw new PluginError("forbidden", "Plugin chat token belongs to another installation");
+        return claims;
+    }
+    async authorizeUsers(installationId, capabilities) {
+        return Promise.all(capabilities.map(async (capability) => {
+            let claims;
+            try {
+                claims = await this.tokens.verifyPluginUserToken(capability.token);
+            }
+            catch {
+                throw new PluginError("forbidden", "Plugin user token is invalid");
+            }
+            if (claims.installationId !== installationId)
+                throw new PluginError("forbidden", "Plugin user token belongs to another installation");
+            if (claims.userId !== capability.id)
+                throw new PluginError("forbidden", "Plugin user token belongs to another user");
+            return claims.userId;
+        }));
+    }
+    async publishHints(hints, userIds) {
+        const publications = [];
+        for (const hint of hints) {
+            const event = { type: "sync", ...hint };
+            const topics = new Set([
+                realtimeTopics.server,
+                ...hint.chats.map(({ chatId }) => realtimeTopics.chat(chatId)),
+                ...userIds.map((userId) => realtimeTopics.user(userId)),
+            ]);
+            for (const topic of topics)
+                publications.push(this.pubsub.publish(topic, event));
+        }
+        await Promise.allSettled(publications).then((results) => {
+            for (const result of results)
+                if (result.status === "rejected")
+                    this.onError(result.reason);
+        });
+    }
     async close() {
         this.closed = true;
         for (const { controller } of this.activations.values())
@@ -522,7 +935,14 @@ export class PluginService {
             .finally(() => this.activations.delete(installationId));
         this.activations.set(installationId, { controller, promise });
     }
-    async withClient(installationId, signal, action) {
+    async stopActivation(installationId) {
+        const activation = this.activations.get(installationId);
+        activation?.controller.abort();
+        if (activation)
+            await activation.promise;
+        this.closeCommand(installationId);
+    }
+    async withClient(installationId, signal, agentCall, action) {
         signal?.throwIfAborted();
         const configuration = await pluginInstallationGetRuntimeConfiguration(this.executor, this.secrets, installationId);
         if (configuration.type === "skills_only")
@@ -530,7 +950,7 @@ export class PluginService {
         if (configuration.type === "local" && !configuration.mcp)
             return undefined;
         const localToken = configuration.type === "local"
-            ? await this.pluginRuntimeToken(configuration)
+            ? await this.pluginRuntimeToken(configuration, agentCall)
             : undefined;
         const transport = configuration.type === "local"
             ? await this.runtime.openLocal({
@@ -640,10 +1060,10 @@ export class PluginService {
                     this.commandHandles.delete(installationId);
                 commandHandle.close();
             }
-            if (signal.aborted && this.closed)
-                return;
             if (preparedContainerName)
                 await this.runtime.removeLocal(preparedContainerName).catch(this.onError);
+            if (signal.aborted)
+                return;
             const broken = error instanceof PluginError && error.code === "broken_configuration";
             await this.status(installationId, broken ? "broken_configuration" : "failed", broken
                 ? "Plugin configuration must be corrected before it can start."
@@ -721,7 +1141,11 @@ export class PluginService {
         await this.publish(hint).catch(this.onError);
     }
     publish(hint) {
-        return this.pubsub.publish(realtimeTopics.server, { type: "sync", ...hint });
+        const event = { type: "sync", ...hint };
+        return Promise.all([
+            this.pubsub.publish(realtimeTopics.server, event),
+            ...hint.chats.map(({ chatId }) => this.pubsub.publish(realtimeTopics.chat(chatId), event)),
+        ]).then(() => undefined);
     }
     closeCommand(installationId) {
         const handle = this.commandHandles.get(installationId);
@@ -748,13 +1172,14 @@ export class PluginService {
             HAPPY2_PLUGIN_API_TOKEN: token,
         };
     }
-    pluginRuntimeToken(configuration) {
+    pluginRuntimeToken(configuration, agentCall) {
         if (!configuration.containerInstanceId)
             throw new PluginError("not_ready", "Plugin container incarnation is unavailable");
         return this.tokens.issuePluginRuntimeToken({
             installationId: configuration.installationId,
             containerInstanceId: configuration.containerInstanceId,
             permissions: configuration.permissions,
+            ...(agentCall ? { agentCall } : {}),
         });
     }
 }
@@ -771,6 +1196,17 @@ function pluginFunctionName(installationId, toolName) {
     const digest = createHash("sha256").update(toolName).digest("hex").slice(0, 16);
     return `plugin_${installationId}_${normalized || "tool"}_${digest}`;
 }
+function pluginChannelSlug(name) {
+    const suffix = createId();
+    const base = name
+        .normalize("NFKD")
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 63 - suffix.length)
+        .replace(/-+$/g, "");
+    return `${base || "channel"}-${suffix}`;
+}
 function pluginFunctionInstallationId(functionName) {
     const match = /^plugin_([a-z0-9]+)_/u.exec(functionName);
     return match?.[1];
@@ -899,6 +1335,7 @@ function preparedSummary(plugin, preparedToken, expiresAt) {
         description: plugin.manifest.description,
         skills: plugin.skills.map(({ name, description }) => ({ name, description })),
         variables: plugin.manifest.variables,
+        apiPermissions: pluginApiPermissionSections(effectiveContainer(plugin.manifest)?.permissions ?? []),
         ...(mcp
             ? {
                 mcp: {