agor-live 0.23.1 → 0.23.2

package/dist/daemon/mcp/tools/gateway-channels.js

@@ -72,13 +72,17 @@ import {
   ThreadSessionMapRepository
 } from "@agor/core/db";
 import {
-  getConnector
+  buildSlackManifest,
+  getConnector,
+  requiredBotEvents,
+  requiredBotScopes
 } from "@agor/core/gateway";
 import {
   GATEWAY_REDACTED_SENTINEL,
-  GATEWAY_SENSITIVE_CONFIG_FIELDS,
-  hasMinimumRole as hasMinimumRole3,
-  ROLES as ROLES4
+  GATEWAY_SENSITIVE_CONFIG_FIELDS as GATEWAY_SENSITIVE_CONFIG_FIELDS2,
+  getRequiredSecretFields as getRequiredSecretFields2,
+  hasMinimumRole as hasMinimumRole5,
+  ROLES as ROLES6
 } from "@agor/core/types";
 
 // ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/external.js
@@ -15312,7 +15316,7 @@ var modelConfigInputSchema = external_exports.union([
 import { ROLES as ROLES3 } from "@agor/core/types";
 
 // src/mcp/tools/widgets.ts
-import { MessageRole as MessageRole2 } from "@agor/core/types";
+import { getRequiredSecretFields, hasMinimumRole as hasMinimumRole4, MessageRole as MessageRole2, ROLES as ROLES5 } from "@agor/core/types";
 
 // src/utils/append-system-message.ts
 import { generateId as generateId2, SessionRepository as SessionRepository2 } from "@agor/core/db";
@@ -15395,6 +15399,30 @@ var envVarsSubmitSchema = external_exports.object({
   }
 });
 
+// src/widgets/gateway-token/index.ts
+import { Forbidden as Forbidden2 } from "@agor/core/feathers";
+import {
+  GATEWAY_SENSITIVE_CONFIG_FIELDS,
+  hasMinimumRole as hasMinimumRole3,
+  ROLES as ROLES4
+} from "@agor/core/types";
+var MAX_TOKEN_LENGTH = 8192;
+var gatewayTokenParamsSchema = external_exports.object({
+  gatewayChannelId: external_exports.string().min(1).describe("Gateway channel whose credentials are being set."),
+  channelType: external_exports.enum(["slack", "discord", "whatsapp", "telegram", "github", "teams"]).describe("Platform type of the channel; drives per-field placeholders."),
+  channelName: external_exports.string().min(1).max(200).describe("Human-readable channel name for the form heading and prompts."),
+  fields: external_exports.array(external_exports.enum(GATEWAY_SENSITIVE_CONFIG_FIELDS)).min(1).max(GATEWAY_SENSITIVE_CONFIG_FIELDS.length).refine((fields) => new Set(fields).size === fields.length, {
+    message: "Token field names must be unique"
+  }).describe("Secret config field names to collect (subset of the sensitive fields)."),
+  reason: external_exports.string().min(1).max(200).describe("One sentence explaining why the tokens are needed. Renders as a muted line.")
+}).strict();
+var gatewayTokenSubmitSchema = external_exports.object({
+  tokens: external_exports.partialRecord(
+    external_exports.enum(GATEWAY_SENSITIVE_CONFIG_FIELDS),
+    external_exports.string().min(1).max(MAX_TOKEN_LENGTH)
+  ).describe("Map of sensitive field name \u2192 credential value.")
+}).strict();
+
 // src/mcp/server.ts
 var DEBUG_MCP_REQUESTS = process.env.AGOR_DEBUG_MCP_REQUESTS === "1" || process.env.DEBUG?.includes("mcp-requests");
 function textResult(data) {
@@ -15431,12 +15459,25 @@ Discover tools: search domains/summaries \u2192 get details for one tool \u2192
 
 // src/mcp/tools/gateway-channels.ts
 function requireAdmin(ctx, action) {
-  if (!hasMinimumRole3(ctx.authenticatedUser?.role, ROLES4.ADMIN)) {
+  if (!hasMinimumRole5(ctx.authenticatedUser?.role, ROLES6.ADMIN)) {
     throw new Error(`Access denied: admin role required to ${action}`);
   }
 }
+async function resolveCallerSessionBranchId(ctx) {
+  if (!ctx.sessionId) return null;
+  const session = await new SessionRepository3(ctx.db).findById(ctx.sessionId);
+  if (!session) {
+    throw new Error("Gateway access denied: calling session not found");
+  }
+  return session.branch_id;
+}
+function sessionBranchReadDeniedError() {
+  return new Error(
+    "Gateway read denied: this Slack thread belongs to a gateway channel targeting a different branch than the calling session's. Sessions can read Slack thread history only through gateway channels whose target branch matches their own."
+  );
+}
 async function canUseGatewayOutbound(ctx, branchRepo, branch) {
-  if (hasMinimumRole3(ctx.authenticatedUser?.role, ROLES4.ADMIN)) return true;
+  if (hasMinimumRole5(ctx.authenticatedUser?.role, ROLES6.ADMIN)) return true;
   const userId = ctx.userId;
   const isOwner = await branchRepo.isOwner(branch.branch_id, userId);
   const effective = await branchRepo.resolveUserPermission(branch, userId);
@@ -15513,44 +15554,48 @@ var gatewayChannelCreateSchema = external_exports.strictObject({
   agenticConfig: agenticConfigSchema.optional()
 }).superRefine((value, issue2) => {
   const config2 = value.config ?? {};
-  if (value.channelType === "slack") {
-    if (!config2.bot_token) {
-      issue2.addIssue({
-        code: "custom",
-        path: ["config", "bot_token"],
-        message: "config.bot_token is required for Slack. Prefer a bot token stored outside the transcript when possible."
-      });
-    }
-    if (config2.connection_mode === "socket" && !config2.app_token) {
-      issue2.addIssue({
-        code: "custom",
-        path: ["config", "app_token"],
-        message: "config.app_token is required for Slack Socket Mode."
-      });
-    }
-  }
-  if (value.channelType === "github") {
-    for (const field of ["app_id", "private_key", "installation_id", "watch_repos"]) {
+  if (value.enabled !== false) {
+    const requiredSecretMessages = {
+      bot_token: "config.bot_token is required for Slack. Prefer a bot token stored outside the transcript when possible.",
+      app_token: "config.app_token is required for Slack Socket Mode.",
+      private_key: "config.private_key is required for GitHub gateway channels.",
+      app_password: "config.app_password is required for Teams gateway channels."
+    };
+    for (const field of getRequiredSecretFields2(value.channelType, config2)) {
       if (!config2[field]) {
         issue2.addIssue({
           code: "custom",
           path: ["config", field],
-          message: `config.${field} is required for GitHub gateway channels.`
+          message: requiredSecretMessages[field] ?? `config.${field} is required for ${value.channelType} gateway channels.`
         });
       }
     }
   }
-  if (value.channelType === "teams") {
-    for (const field of ["app_id", "app_password"]) {
+  if (value.channelType === "github") {
+    for (const field of ["app_id", "installation_id", "watch_repos"]) {
       if (!config2[field]) {
         issue2.addIssue({
           code: "custom",
           path: ["config", field],
-          message: `config.${field} is required for Teams gateway channels.`
+          message: `config.${field} is required for GitHub gateway channels.`
         });
       }
     }
   }
+  if (value.channelType === "teams" && !config2.app_id) {
+    issue2.addIssue({
+      code: "custom",
+      path: ["config", "app_id"],
+      message: "config.app_id is required for Teams gateway channels."
+    });
+  }
+  if (value.channelType === "slack" && config2.align_slack_users !== true && !value.agorUserId) {
+    issue2.addIssue({
+      code: "custom",
+      path: ["agorUserId"],
+      message: "Run-as-selected-user needs agorUserId \u2014 set config.align_slack_users:true to align by email, or pass agorUserId."
+    });
+  }
 });
 var slackThreadHistorySchema = external_exports.strictObject({
   sessionId: mcpOptionalId(
@@ -15650,22 +15695,29 @@ async function requireBranchAllForGatewayHistory(ctx, branchRepo, branch) {
   );
 }
 function isAdmin(ctx) {
-  return hasMinimumRole3(ctx.authenticatedUser?.role, ROLES4.ADMIN);
+  return hasMinimumRole5(ctx.authenticatedUser?.role, ROLES6.ADMIN);
 }
 async function resolveSlackThreadHistoryTarget(ctx, args) {
   const channelRepo = new GatewayChannelRepository(ctx.db);
   const threadMapRepo = new ThreadSessionMapRepository(ctx.db);
   const branchRepo = new BranchRepository6(ctx.db);
+  const callerSessionBranchId = await resolveCallerSessionBranchId(ctx);
   if (args.sessionId) {
     const session = await ctx.app.service("sessions").get(args.sessionId, ctx.baseServiceParams);
     const mapping2 = await threadMapRepo.findBySession(session.session_id);
     if (!mapping2) {
       throw new Error(`No gateway thread mapping found for session ${session.session_id}.`);
     }
+    if (callerSessionBranchId && mapping2.branch_id !== callerSessionBranchId) {
+      throw sessionBranchReadDeniedError();
+    }
     const channel2 = await channelRepo.findById(mapping2.channel_id);
     if (!channel2) {
       throw new Error(`Gateway channel not found for session mapping ${mapping2.id}.`);
     }
+    if (callerSessionBranchId && channel2.target_branch_id !== callerSessionBranchId) {
+      throw sessionBranchReadDeniedError();
+    }
     const branch2 = await branchRepo.findById(mapping2.branch_id);
     return {
       channel: channel2,
@@ -15680,6 +15732,9 @@ async function resolveSlackThreadHistoryTarget(ctx, args) {
   if (!channel) {
     throw new Error(`Gateway channel not found: ${args.gatewayChannelId}`);
   }
+  if (callerSessionBranchId && channel.target_branch_id !== callerSessionBranchId) {
+    throw sessionBranchReadDeniedError();
+  }
   const mapping = await threadMapRepo.findByChannelAndThread(channel.id, args.threadId);
   if (mapping) {
     const branch2 = await branchRepo.findById(mapping.branch_id);
@@ -15731,7 +15786,7 @@ var gatewayChannelUpdateSchema = external_exports.strictObject({
 });
 function redactGatewayChannel(channel) {
   const config2 = { ...channel.config ?? {} };
-  for (const field of GATEWAY_SENSITIVE_CONFIG_FIELDS) {
+  for (const field of GATEWAY_SENSITIVE_CONFIG_FIELDS2) {
     if (config2[field]) config2[field] = GATEWAY_REDACTED_SENTINEL;
   }
   let agentic_config = channel.agentic_config;
@@ -15789,6 +15844,51 @@ function toServiceUpdateData(args) {
   }
   return updates;
 }
+var slackManifestGenerateSchema = external_exports.strictObject({
+  appName: mcpRequiredString("appName", 'Slack app display name, e.g. "Agor".'),
+  botDisplayName: mcpOptionalNonEmptyString(
+    "botDisplayName",
+    "Bot user display name. Defaults to appName."
+  ),
+  publicChannels: external_exports.boolean().default(false).describe("Listen in public channels (#channel) via @mention."),
+  privateChannels: external_exports.boolean().default(false).describe("Listen in private channels (groups) via @mention."),
+  groupDms: external_exports.boolean().default(false).describe("Listen in group DMs (multi-person IMs) via @mention."),
+  alignUsers: external_exports.boolean().default(true).describe(
+    "Resolve Slack user email \u2192 Agor user (adds the users:read.email scope). Defaults to true: each Slack user runs as their matched Agor account and unmatched users are rejected, so no fixed run-as user is needed. Set false to run every message as one fixed Agor user (then pass agorUserId to agor_gateway_channels_create)."
+  ),
+  outbound: external_exports.boolean().default(false).describe("Proactive outbound: post to channels by name and DM users by email."),
+  restrictToChannelIds: external_exports.array(external_exports.string().min(1)).optional().describe(
+    "Slack channel ID whitelist. Maps to config.allowed_channel_ids when you call agor_gateway_channels_create; it does NOT change the manifest scopes or events."
+  )
+});
+function toSlackWizardOptions(args) {
+  return {
+    appName: args.appName,
+    ...args.botDisplayName ? { botDisplayName: args.botDisplayName } : {},
+    publicChannels: args.publicChannels,
+    privateChannels: args.privateChannels,
+    groupDms: args.groupDms,
+    alignUsers: args.alignUsers,
+    outbound: args.outbound
+  };
+}
+function toCreateChannelConfigHint(args) {
+  const config2 = {
+    connection_mode: "socket",
+    enable_channels: args.publicChannels,
+    enable_groups: args.privateChannels,
+    enable_mpim: args.groupDms,
+    align_slack_users: args.alignUsers,
+    outbound_enabled: args.outbound
+  };
+  if (args.restrictToChannelIds && args.restrictToChannelIds.length > 0) {
+    config2.allowed_channel_ids = args.restrictToChannelIds;
+  }
+  return { channelType: "slack", config: config2 };
+}
+function identityModeSetupStep(alignUsers) {
+  return alignUsers ? "Identity: the channel is set to align Slack users \u2014 each Slack user runs as their matched Agor account and unmatched users are rejected, so no run-as user is needed. Tell me if you would rather every message run as one fixed Agor user (that requires picking a user and passing agorUserId)." : "Identity: the channel is set to run every message as one fixed Agor user, which requires passing agorUserId to agor_gateway_channels_create. Tell me if you would rather align Slack users so each runs as their own matched Agor account instead.";
+}
 function registerGatewayChannelTools(server, ctx) {
   server.registerTool(
     "agor_gateway_channels_list",
@@ -15834,7 +15934,7 @@ function registerGatewayChannelTools(server, ctx) {
   server.registerTool(
     "agor_gateway_channels_create",
     {
-      description: 'Create a gateway channel definition (admin-only) through the same gateway-channels service used by the UI. Current connectors: Slack, GitHub, Teams. Slack example config: { bot_token, app_token, connection_mode:"socket", enable_channels:true, require_mention:true, allowed_channel_ids:["C123"] }. Secrets are encrypted by the service and returned redacted; prefer environment/template references where possible because raw secrets in tool arguments may appear in the MCP transcript.',
+      description: 'Create a gateway channel definition (admin-only) through the same gateway-channels service used by the UI. Current connectors: Slack, GitHub, Teams. For interactive/agent-driven setup, create the channel disabled and without secrets (enabled:false, no tokens), then collect credentials with agor_widgets_request_gateway_token so the user enters them in a secure inline form \u2014 raw secrets passed in tool arguments leak into the MCP transcript. Passing secrets directly here is for programmatic/non-interactive use only. Non-interactive Slack example config: { bot_token, app_token, connection_mode:"socket", enable_channels:true, require_mention:true, allowed_channel_ids:["C123"] }. Secrets are encrypted by the service and returned redacted.',
       annotations: { destructiveHint: false, idempotentHint: false },
       inputSchema: gatewayChannelCreateSchema
     },
@@ -15844,12 +15944,50 @@ function registerGatewayChannelTools(server, ctx) {
       return textResult({
         gateway_channel: redactGatewayChannel(created),
         next_steps: [
+          "If this channel was created disabled without tokens (the recommended interactive path), collect its credentials by calling agor_widgets_request_gateway_token for this channel so the user enters the tokens in the secure form that appears at the end of this message. Do NOT ask the user to paste xoxb-/xapp- tokens into the chat, and do NOT pass tokens as agor_gateway_channels_create arguments during interactive setup.",
+          ...created.channel_type === "slack" ? [
+            identityModeSetupStep(
+              created.config?.align_slack_users === true
+            )
+          ] : [],
           "Verify the channel in Settings > Gateway Channels or with agor_gateway_channels_list.",
           "Channel credentials, env vars, and inbound channel keys are intentionally redacted from MCP responses."
         ]
       });
     }
   );
+  server.registerTool(
+    "agor_gateway_slack_manifest_generate",
+    {
+      description: "Generate a ready-to-install Slack app manifest from desired gateway capabilities (admin-only). The agent-driven equivalent of the Slack setup wizard, backed by the same core generator. Returns the manifest JSON, the derived bot scopes/events, ordered setup steps, and the channel config to pass to agor_gateway_channels_create. This is pure: it creates no Slack app, no Agor channel, and validates no tokens.",
+      annotations: { readOnlyHint: true },
+      inputSchema: slackManifestGenerateSchema
+    },
+    async (args) => {
+      requireAdmin(ctx, "generate Slack app manifests");
+      const options = toSlackWizardOptions(args);
+      return textResult({
+        manifest: buildSlackManifest(options),
+        bot_scopes: requiredBotScopes(options),
+        bot_events: requiredBotEvents(options),
+        setup_steps: [
+          'Open https://api.slack.com/apps?new_app=1 and choose "Create New App".',
+          'Select "From a manifest", pick the target workspace, paste the manifest JSON below, and click "Create".',
+          'Install the app to the workspace, then open OAuth & Permissions and copy the Bot User OAuth Token (starts with "xoxb-").',
+          'Open Basic Information \u2192 App-Level Tokens \u2192 Generate Token and Scopes, add the connections:write scope, generate it, and copy the App-Level Token (starts with "xapp-").',
+          'Once the app is installed and you hold the xoxb-/xapp- tokens, call agor_gateway_channels_create with channelType "slack", enabled:false, no tokens, and create_channel_config_hint below to create the channel as a draft.',
+          "Then call agor_widgets_request_gateway_token for that channel so the user enters the xoxb-/xapp- tokens in the secure form that appears at the end of this message, which enables the channel. Do NOT ask the user to paste xoxb-/xapp- tokens into the chat, and do NOT pass tokens as agor_gateway_channels_create arguments.",
+          identityModeSetupStep(args.alignUsers)
+        ],
+        create_channel_config_hint: toCreateChannelConfigHint(args),
+        caveats: [
+          "GENERATED ONLY \u2014 no Slack app created, no Agor channel created, no tokens validated, no event delivery verified.",
+          "The app-level connections:write token is generated manually and is NOT part of the manifest bot scopes.",
+          "restrictToChannelIds maps to config.allowed_channel_ids when you call create \u2014 it does NOT change the manifest scopes or events."
+        ]
+      });
+    }
+  );
   server.registerTool(
     "agor_gateway_channels_update",
     {
@@ -15873,7 +16011,7 @@ function registerGatewayChannelTools(server, ctx) {
   server.registerTool(
     "agor_gateway_outbound_targets_list",
     {
-      description: "List Slack gateway outbound targets the caller can use. Returns only outbound-enabled channels where the caller has branch all permission or admin access. Secrets and inbound channel keys are never returned.",
+      description: "List Slack gateway outbound targets the caller can use. Returns only outbound-enabled channels where the caller has branch all permission or admin access; when called from a session, results are additionally scoped to channels targeting the session's branch. Secrets and inbound channel keys are never returned.",
       annotations: { readOnlyHint: true },
       inputSchema: external_exports.strictObject({
         branchId: mcpOptionalId("branchId", "Branch", "Filter by target branch ID."),
@@ -15888,15 +16026,24 @@ function registerGatewayChannelTools(server, ctx) {
     async (args) => {
       const channelRepo = new GatewayChannelRepository(ctx.db);
       const branchRepo = new BranchRepository6(ctx.db);
+      const callerSessionBranchId = await resolveCallerSessionBranchId(ctx);
       const branchFilter = args.branchId ? await branchRepo.findById(args.branchId) : null;
-      const branchFilterId = branchFilter?.branch_id;
+      const requestedBranchId = branchFilter?.branch_id;
+      if (callerSessionBranchId && args.branchId && requestedBranchId !== callerSessionBranchId) {
+        return textResult({
+          channels: [],
+          binding: "Results are scoped to the calling session's branch; the requested branchId targets a different branch, so this session cannot use its channels."
+        });
+      }
+      const branchFilterId = callerSessionBranchId ?? requestedBranchId;
       const allChannels = args.gatewayChannelId ? [await channelRepo.findById(args.gatewayChannelId)] : await channelRepo.findAll();
       const channels = [];
       for (const channel of allChannels) {
         if (!channel) continue;
         if (args.channelType && channel.channel_type !== args.channelType) continue;
         if (channel.channel_type !== "slack") continue;
-        if (args.branchId && channel.target_branch_id !== branchFilterId) continue;
+        if ((callerSessionBranchId || args.branchId) && channel.target_branch_id !== branchFilterId)
+          continue;
         if (!channel.enabled) continue;
         const outbound = getOutboundConfig(channel);
         if (!outbound.outbound_enabled) continue;
@@ -15919,13 +16066,18 @@ function registerGatewayChannelTools(server, ctx) {
           ]
         });
       }
-      return textResult({ channels });
+      return textResult({
+        channels,
+        ...callerSessionBranchId && channels.length === 0 ? {
+          hint: "No outbound-enabled channel targets this session's branch \u2014 ask an operator to create/enable one."
+        } : {}
+      });
     }
   );
   server.registerTool(
     "agor_gateway_slack_thread_history_get",
     {
-      description: "Fetch Slack thread history for a gateway-mapped Slack thread without exposing Slack tokens. Prefer sessionId to resolve the gateway thread mapping from an accessible Agor session. Alternatively pass gatewayChannelId + threadId: mapped threads require admin or branch all permission on the mapped branch; unmapped arbitrary thread reads are admin-only. Slack message text is untrusted external content.",
+      description: "Fetch Slack thread history for a gateway-mapped Slack thread without exposing Slack tokens. Prefer sessionId to resolve the gateway thread mapping from an accessible Agor session. Alternatively pass gatewayChannelId + threadId: mapped threads require admin or branch all permission on the mapped branch; unmapped arbitrary thread reads are admin-only. When called from a session, reads are restricted to threads whose target branch matches the calling session's branch. Slack message text is untrusted external content.",
       annotations: { readOnlyHint: true },
       inputSchema: slackThreadHistorySchema
     },
@@ -15993,7 +16145,7 @@ function registerGatewayChannelTools(server, ctx) {
   server.registerTool(
     "agor_gateway_emit_message",
     {
-      description: "Send a proactive Slack message through an outbound-enabled gateway channel and persist a seed/audit record. Targets may be Slack channel IDs, channel names, or user emails; v0 intentionally starts a fresh Slack thread/DM message for each emit and does not create a thread-session mapping until a human replies.",
+      description: "Send a proactive Slack message through an outbound-enabled gateway channel and persist a seed/audit record. Targets may be Slack channel IDs, channel names, or user emails; v0 intentionally starts a fresh Slack thread/DM message for each emit and does not create a thread-session mapping until a human replies. When called from a session, outbound is restricted to channels whose target branch matches the calling session's branch.",
       annotations: { destructiveHint: false, idempotentHint: false },
       inputSchema: external_exports.strictObject({
         gatewayChannelId: mcpRequiredId(

package/dist/daemon/mcp/tools/knowledge.js

@@ -14992,11 +14992,15 @@ import {
   ThreadSessionMapRepository
 } from "@agor/core/db";
 import {
-  getConnector
+  buildSlackManifest,
+  getConnector,
+  requiredBotEvents,
+  requiredBotScopes
 } from "@agor/core/gateway";
 import {
   GATEWAY_REDACTED_SENTINEL,
   GATEWAY_SENSITIVE_CONFIG_FIELDS,
+  getRequiredSecretFields,
   hasMinimumRole as hasMinimumRole3,
   ROLES as ROLES3
 } from "@agor/core/types";
@@ -15056,44 +15060,48 @@ var gatewayChannelCreateSchema = external_exports.strictObject({
   agenticConfig: agenticConfigSchema.optional()
 }).superRefine((value, issue2) => {
   const config2 = value.config ?? {};
-  if (value.channelType === "slack") {
-    if (!config2.bot_token) {
-      issue2.addIssue({
-        code: "custom",
-        path: ["config", "bot_token"],
-        message: "config.bot_token is required for Slack. Prefer a bot token stored outside the transcript when possible."
-      });
-    }
-    if (config2.connection_mode === "socket" && !config2.app_token) {
-      issue2.addIssue({
-        code: "custom",
-        path: ["config", "app_token"],
-        message: "config.app_token is required for Slack Socket Mode."
-      });
-    }
-  }
-  if (value.channelType === "github") {
-    for (const field of ["app_id", "private_key", "installation_id", "watch_repos"]) {
+  if (value.enabled !== false) {
+    const requiredSecretMessages = {
+      bot_token: "config.bot_token is required for Slack. Prefer a bot token stored outside the transcript when possible.",
+      app_token: "config.app_token is required for Slack Socket Mode.",
+      private_key: "config.private_key is required for GitHub gateway channels.",
+      app_password: "config.app_password is required for Teams gateway channels."
+    };
+    for (const field of getRequiredSecretFields(value.channelType, config2)) {
       if (!config2[field]) {
         issue2.addIssue({
           code: "custom",
           path: ["config", field],
-          message: `config.${field} is required for GitHub gateway channels.`
+          message: requiredSecretMessages[field] ?? `config.${field} is required for ${value.channelType} gateway channels.`
         });
       }
     }
   }
-  if (value.channelType === "teams") {
-    for (const field of ["app_id", "app_password"]) {
+  if (value.channelType === "github") {
+    for (const field of ["app_id", "installation_id", "watch_repos"]) {
       if (!config2[field]) {
         issue2.addIssue({
           code: "custom",
           path: ["config", field],
-          message: `config.${field} is required for Teams gateway channels.`
+          message: `config.${field} is required for GitHub gateway channels.`
         });
       }
     }
   }
+  if (value.channelType === "teams" && !config2.app_id) {
+    issue2.addIssue({
+      code: "custom",
+      path: ["config", "app_id"],
+      message: "config.app_id is required for Teams gateway channels."
+    });
+  }
+  if (value.channelType === "slack" && config2.align_slack_users !== true && !value.agorUserId) {
+    issue2.addIssue({
+      code: "custom",
+      path: ["agorUserId"],
+      message: "Run-as-selected-user needs agorUserId \u2014 set config.align_slack_users:true to align by email, or pass agorUserId."
+    });
+  }
 });
 var slackThreadHistorySchema = external_exports.strictObject({
   sessionId: mcpOptionalId(
@@ -15157,6 +15165,23 @@ var gatewayChannelUpdateSchema = external_exports.strictObject({
   ),
   agenticConfig: agenticConfigSchema.nullable().optional().describe("Replace agent/session defaults. null clears the gateway agentic config.")
 });
+var slackManifestGenerateSchema = external_exports.strictObject({
+  appName: mcpRequiredString("appName", 'Slack app display name, e.g. "Agor".'),
+  botDisplayName: mcpOptionalNonEmptyString(
+    "botDisplayName",
+    "Bot user display name. Defaults to appName."
+  ),
+  publicChannels: external_exports.boolean().default(false).describe("Listen in public channels (#channel) via @mention."),
+  privateChannels: external_exports.boolean().default(false).describe("Listen in private channels (groups) via @mention."),
+  groupDms: external_exports.boolean().default(false).describe("Listen in group DMs (multi-person IMs) via @mention."),
+  alignUsers: external_exports.boolean().default(true).describe(
+    "Resolve Slack user email \u2192 Agor user (adds the users:read.email scope). Defaults to true: each Slack user runs as their matched Agor account and unmatched users are rejected, so no fixed run-as user is needed. Set false to run every message as one fixed Agor user (then pass agorUserId to agor_gateway_channels_create)."
+  ),
+  outbound: external_exports.boolean().default(false).describe("Proactive outbound: post to channels by name and DM users by email."),
+  restrictToChannelIds: external_exports.array(external_exports.string().min(1)).optional().describe(
+    "Slack channel ID whitelist. Maps to config.allowed_channel_ids when you call agor_gateway_channels_create; it does NOT change the manifest scopes or events."
+  )
+});
 
 // src/mcp/tools/mcp-servers.ts
 import {
@@ -15515,7 +15540,7 @@ var modelConfigInputSchema = external_exports.union([
 import { ROLES as ROLES4 } from "@agor/core/types";
 
 // src/mcp/tools/widgets.ts
-import { MessageRole as MessageRole2 } from "@agor/core/types";
+import { getRequiredSecretFields as getRequiredSecretFields2, hasMinimumRole as hasMinimumRole5, MessageRole as MessageRole2, ROLES as ROLES6 } from "@agor/core/types";
 
 // src/utils/append-system-message.ts
 import { generateId as generateId2, SessionRepository as SessionRepository3 } from "@agor/core/db";
@@ -15598,6 +15623,30 @@ var envVarsSubmitSchema = external_exports.object({
   }
 });
 
+// src/widgets/gateway-token/index.ts
+import { Forbidden as Forbidden2 } from "@agor/core/feathers";
+import {
+  GATEWAY_SENSITIVE_CONFIG_FIELDS as GATEWAY_SENSITIVE_CONFIG_FIELDS2,
+  hasMinimumRole as hasMinimumRole4,
+  ROLES as ROLES5
+} from "@agor/core/types";
+var MAX_TOKEN_LENGTH = 8192;
+var gatewayTokenParamsSchema = external_exports.object({
+  gatewayChannelId: external_exports.string().min(1).describe("Gateway channel whose credentials are being set."),
+  channelType: external_exports.enum(["slack", "discord", "whatsapp", "telegram", "github", "teams"]).describe("Platform type of the channel; drives per-field placeholders."),
+  channelName: external_exports.string().min(1).max(200).describe("Human-readable channel name for the form heading and prompts."),
+  fields: external_exports.array(external_exports.enum(GATEWAY_SENSITIVE_CONFIG_FIELDS2)).min(1).max(GATEWAY_SENSITIVE_CONFIG_FIELDS2.length).refine((fields) => new Set(fields).size === fields.length, {
+    message: "Token field names must be unique"
+  }).describe("Secret config field names to collect (subset of the sensitive fields)."),
+  reason: external_exports.string().min(1).max(200).describe("One sentence explaining why the tokens are needed. Renders as a muted line.")
+}).strict();
+var gatewayTokenSubmitSchema = external_exports.object({
+  tokens: external_exports.partialRecord(
+    external_exports.enum(GATEWAY_SENSITIVE_CONFIG_FIELDS2),
+    external_exports.string().min(1).max(MAX_TOKEN_LENGTH)
+  ).describe("Map of sensitive field name \u2192 credential value.")
+}).strict();
+
 // src/mcp/server.ts
 var DEBUG_MCP_REQUESTS = process.env.AGOR_DEBUG_MCP_REQUESTS === "1" || process.env.DEBUG?.includes("mcp-requests");
 function coerceString(value) {