discord-agent-bridge 0.1.0

package/dist/discord/interactionRouter.js

@@ -0,0 +1,954 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { defaultEffortFor, effortChoicesFor, permissionChoicesFor, permissionModeLabel, } from '../core/providerCatalog.js';
+import { ChannelWizard } from './wizard/channelWizard.js';
+import { ResumeWizard } from './wizard/resumeWizard.js';
+import { DirectoryBrowser } from './directoryBrowser.js';
+import { parseCustomId } from './renderers/permissionButtons.js';
+import { ConfigPanel, isConfigPanelId } from './configPanel.js';
+import { buildStatusEmbed } from './renderers/statusEmbed.js';
+import { ensureGuildChannels, createSessionChannel, } from './guildChannels.js';
+import { setLocale, t } from './i18n.js';
+// InteractionCreate router (§4, §7.1, §9). Authorizes FIRST (tier per action), then
+// dispatches slash commands and component interactions. discord.js is not imported
+// as a value: narrow interaction shapes below are satisfied structurally by the real
+// discord.js interactions, so unit tests drive fakes. The client.ts handler narrows
+// a raw Interaction with the discord.js type guards and calls handle().
+// The tier each command requires (§7.1): stop-all is admin; the rest are execute.
+const ACTION_TIER = {
+    'agent.start': 'drive',
+    'agent.resume': 'drive',
+    'agent.close': 'drive',
+    'mode.backend': 'drive',
+    'mode.perm': 'drive',
+    stop: 'drive',
+    'stop-all': 'admin',
+};
+function channelKey(guildId, channelId) {
+    return `${guildId}:${channelId}`;
+}
+export class InteractionRouter {
+    deps;
+    // Active wizards keyed by guildId:channelId, so follow-up component interactions
+    // (folder/backend/model/perm selects, confirm/cancel) route back to the same flow.
+    wizards = new Map();
+    // Active resume flows keyed by guildId:channelId (started from the folder step's
+    // "Resume Session" button), so the backend/session selects route back to the flow.
+    resumeFlows = new Map();
+    // Active /config panels keyed by guildId:channelId, so follow-up role/string
+    // selects + Save route back to the panel that holds the pending selections.
+    configPanels = new Map();
+    constructor(deps) {
+        this.deps = deps;
+    }
+    // Bind the live-gateway resolvers AFTER construction (app boot). The client depends
+    // on this router, so the router cannot capture the client at construction — these
+    // setters mirror wiring.setResolveChannel. Used by /init and /agent start's session-
+    // channel creation + intro post.
+    setResolveGuildProvisioner(fn) {
+        this.deps.resolveGuildProvisioner = fn;
+    }
+    setResolveChannel(fn) {
+        this.deps.resolveChannel = fn;
+    }
+    async handle(interaction) {
+        // Operator visibility (§7.3): log EVERY received interaction to the terminal so
+        // `node dist/cli.js` shows exactly what fired. Redaction is handled by the logger.
+        this.logReceipt(interaction);
+        if (interaction.kind === 'component') {
+            await this.handleComponent(interaction);
+            return;
+        }
+        if (interaction.kind === 'modalSubmit') {
+            await this.handleModalSubmit(interaction);
+            return;
+        }
+        await this.handleSlash(interaction);
+    }
+    // One info line per interaction: type + command/customId + guild + user. This is
+    // the operator's window into what the gateway delivered (see the bug where a slash
+    // command silently timed out — now the terminal shows it fired).
+    logReceipt(i) {
+        if (i.kind === 'slash') {
+            this.deps.logger.info('interaction received', {
+                type: 'slash',
+                command: i.subcommand ? `${i.commandName} ${i.subcommand}` : i.commandName,
+                guildId: i.guildId,
+                userId: i.user.id,
+            });
+        }
+        else {
+            this.deps.logger.info('interaction received', {
+                type: i.kind === 'modalSubmit' ? 'modalSubmit' : 'component',
+                customId: i.customId,
+                guildId: i.guildId,
+                userId: i.user.id,
+            });
+        }
+    }
+    // ---- Slash commands -----------------------------------------------------
+    async handleSlash(i) {
+        const actionKey = i.subcommand ? `${i.commandName}.${i.subcommand}` : i.commandName;
+        // Acknowledge IMMEDIATELY, before any slow work (auth, disk reads, panel/wizard
+        // build, session start/stop). Deferring buys the 15-minute follow-up window so we
+        // never miss Discord's 3-second ack deadline — the root cause of "application did
+        // not respond". Every subsequent user-facing message is an editReply/followUp.
+        // The defer is ephemeral (only the actor sees the ack + any notices); a command
+        // that needs a PUBLIC message (e.g. /mode backend's fresh-context warning) posts
+        // it as a non-ephemeral followUp.
+        if (!(await this.ackDefer(i, { ephemeral: true })))
+            return;
+        // /config has a bespoke bootstrap gate (Administrator OR admin tier) so it works
+        // on first run with an empty allowlist AND later for configured admins — handled
+        // outside the tier-per-action table below.
+        if (actionKey === 'config') {
+            await this.guarded(i, () => this.openConfigPanel(i));
+            return;
+        }
+        // /init creates the guild channel structure (control channel + sessions category).
+        // Same bootstrap gate as /config (Administrator OR admin tier) so a fresh server
+        // admin can run it before any role is configured.
+        if (actionKey === 'init') {
+            await this.guarded(i, () => this.runInit(i));
+            return;
+        }
+        const action = ACTION_TIER[actionKey] ?? 'drive';
+        if (!this.authorize(i, action))
+            return;
+        await this.guarded(i, async () => {
+            switch (actionKey) {
+                case 'agent.start':
+                    await this.startWizard(i);
+                    break;
+                case 'agent.resume':
+                    await this.resume(i);
+                    break;
+                case 'agent.close':
+                    await this.close(i);
+                    break;
+                case 'mode.backend':
+                    await this.switchBackend(i);
+                    break;
+                case 'mode.perm':
+                    await this.switchPerm(i);
+                    break;
+                case 'stop':
+                    await this.stop(i);
+                    break;
+                case 'stop-all':
+                    await this.stopAll(i);
+                    break;
+                default:
+                    break;
+            }
+        });
+    }
+    // Defer the interaction (the first ack) with a best-effort guard. Returns false if
+    // the defer itself failed (a stale/expired interaction) so the caller bails out
+    // rather than doing work whose result can never be delivered. Logs the failure with
+    // its stack so the operator sees it in the terminal.
+    async ackDefer(i, options) {
+        try {
+            await i.deferReply(options);
+            return true;
+        }
+        catch (err) {
+            this.logError('interaction defer failed', err);
+            return false;
+        }
+    }
+    // Run a handler with a GUARANTEED user-visible ack: any thrown error becomes an
+    // ephemeral error message (editReply when already deferred/replied, else reply), so
+    // Discord never shows "did not respond" — worst case the user sees the error. The
+    // error is logged WITH its stack to the operator terminal (redacted by the logger).
+    async guarded(i, fn) {
+        try {
+            await fn();
+        }
+        catch (err) {
+            this.logError('interaction handler failed', err);
+            const payload = { content: t('cmd.error', { error: String(err) }), ephemeral: true };
+            await safe(i.acknowledged ? i.editReply(payload) : i.reply(payload));
+        }
+    }
+    // Log an error to the operator terminal WITH its stack trace (the logger redacts
+    // secrets). A bare `String(err)` drops the stack, so pass the Error through.
+    logError(message, err) {
+        if (err instanceof Error) {
+            this.deps.logger.error(message, { error: err.message, stack: err.stack });
+        }
+        else {
+            this.deps.logger.error(message, { error: String(err) });
+        }
+    }
+    // The permission-mode option list for a backend as English {value,label} pairs. The
+    // backend's declared capabilities.permissionModes stays authoritative for WHICH modes
+    // it accepts (Codex excludes dontAsk/auto); the provider catalog supplies the English
+    // label for each — so the dropdowns show original English identifiers, not Korean.
+    permModeChoicesFor(backend) {
+        const modes = this.deps.modeRegistry.get(backend).capabilities.permissionModes;
+        return modes.map((m) => ({ value: m, label: permissionModeLabel(m) }));
+    }
+    async startWizard(i) {
+        const guildId = i.guildId; // authorize() rejected DMs (no guild)
+        const resolved = this.deps.configResolver.resolve(guildId, i.channelId);
+        const config = this.deps.configStore.load();
+        const backends = this.deps.modeRegistry.list();
+        const profiles = Object.keys(config.profiles);
+        const backend = resolved.mode;
+        // Model list per backend (the router-supplied dynamic seam, falling back to the
+        // resolved model). The wizard reads it once the backend is chosen so a Codex pick
+        // shows Codex models, not Claude ones.
+        const modelsFor = (b) => this.deps.modelsFor?.(b) ?? [{ value: resolved.claudeModel, label: resolved.claudeModel }];
+        // Permission options per backend: Claude PermMode list vs Codex sandbox terms.
+        const permsFor = (b) => permissionChoicesFor(b);
+        // Reasoning-effort options per backend, narrowed for Claude to the chosen model's
+        // SDK-reported supportedEffortLevels when present.
+        const effortsFor = (b, model) => {
+            const supported = modelsFor(b).find((m) => m.value === model)?.supportedEffortLevels;
+            return effortChoicesFor(b, supported);
+        };
+        // Unbounded folder browsing by default (browse anywhere up to '/'), unless the
+        // operator configured explicit browse roots — so the admin can pick a cwd on any
+        // volume (Fix 1). Session file confinement is a separate mechanism and unaffected.
+        const browser = new DirectoryBrowser({
+            ...(this.deps.browseRoots && this.deps.browseRoots.length > 0
+                ? { allowedRoots: this.deps.browseRoots }
+                : {}),
+        });
+        const wizard = new ChannelWizard({
+            guildId,
+            channelId: i.channelId,
+            ownerId: i.user.id,
+            start: (params) => this.startSession(params),
+            defaults: {
+                backend,
+                model: resolved.claudeModel,
+                permMode: resolved.permissionMode,
+                profile: resolved.permissionProfile,
+            },
+            backends,
+            modelsFor,
+            profiles,
+            permsFor,
+            effortsFor,
+            defaultEffortFor,
+            browser,
+        });
+        this.wizards.set(channelKey(guildId, i.channelId), wizard);
+        // Render the FIRST step (the folder picker) and attach it to the deferred reply.
+        // Sending only cmd.start.launched left the user with a text line and nothing to
+        // click — the wizard's embed + component rows (folder select + ⬆/✅ buttons) must
+        // ride the editReply so the picker actually appears (mirrors openConfigPanel).
+        const { embed, rows } = wizard.render();
+        await i.editReply({ content: t('cmd.start.launched'), embeds: [embed], components: rows });
+    }
+    // Open the /config role-tier + defaults panel. Bootstrap gate: allowed if the actor
+    // has the Discord Administrator permission OR our admin tier — so it works on first
+    // run with an empty allowlist AND later for configured admins (§7.1). Prefills the
+    // panel from the guild's current server-layer auth + resolved defaults; a bystander
+    // cannot advance it (owner-bound, mirroring the wizard).
+    async openConfigPanel(i) {
+        if (i.guildId === null) {
+            await i.editReply({ content: t('auth.denied', { reason: 'DM' }) });
+            return;
+        }
+        if (!this.authorizeConfig(i)) {
+            await i.editReply({ content: t('cmd.config.denied') });
+            return;
+        }
+        const guildId = i.guildId;
+        const global = this.deps.configStore.load();
+        const server = this.deps.configStore.loadServerConfig(guildId);
+        const resolved = this.deps.configResolver.resolve(guildId, i.channelId);
+        const backends = this.deps.modeRegistry.list();
+        const models = this.deps.modelsFor?.(resolved.mode) ?? [{ value: resolved.claudeModel, label: resolved.claudeModel }];
+        const permModes = this.permModeChoicesFor(resolved.mode);
+        // Current effective role tiers = server override when present, else global.
+        const panel = new ConfigPanel({
+            guildId,
+            ownerId: i.user.id,
+            configStore: this.deps.configStore,
+            defaults: {
+                adminRoleIds: server?.auth?.adminRoleIds ?? global.auth.adminRoleIds,
+                executeRoleIds: server?.auth?.executeRoleIds ?? global.auth.executeRoleIds,
+                readOnlyRoleIds: server?.auth?.readOnlyRoleIds ?? global.auth.readOnlyRoleIds,
+                backend: resolved.mode,
+                model: resolved.claudeModel,
+                // The /config default-permission select is Claude's PermMode vocabulary; take it
+                // from the config layer (server override else global), NOT the resolved value —
+                // a channel binding may carry a Codex sandbox mode, which does not belong here.
+                permMode: server?.defaults?.permissionMode ?? global.defaults.permissionMode,
+                // locale is per-guild (server override) or the global default. Codex home is
+                // NOT configured here — it auto-resolves to ~/.codex via the resolver default.
+                locale: server?.locale ?? global.locale,
+            },
+            backends,
+            models,
+            permModes,
+        });
+        this.configPanels.set(channelKey(guildId, i.channelId), panel);
+        // A single Discord message allows at most 5 action rows. Role tiers + Save (4 rows)
+        // ride the deferred reply; the defaults follow-up carries backend/model/permMode/
+        // locale selects (4 rows). Both are ephemeral.
+        const { embed, roleRows, defaultRows } = panel.render();
+        await i.editReply({ content: t('cmd.config.opened'), embeds: [embed], components: roleRows });
+        await i.followUp({ components: defaultRows, ephemeral: true });
+    }
+    // /init: idempotently create the A4D-style channel structure (control channel +
+    // sessions category) and persist the ids to servers/<guildId>.json. Re-running
+    // reuses existing channels by their stored ids. Same bootstrap gate as /config.
+    async runInit(i) {
+        if (i.guildId === null) {
+            await i.editReply({ content: t('auth.denied', { reason: 'DM' }) });
+            return;
+        }
+        if (!this.authorizeConfig(i)) {
+            await i.editReply({ content: t('cmd.config.denied') });
+            return;
+        }
+        const provisioner = this.deps.resolveGuildProvisioner
+            ? await this.deps.resolveGuildProvisioner(i.guildId)
+            : null;
+        if (!provisioner) {
+            await i.editReply({ content: t('cmd.init.unavailable') });
+            return;
+        }
+        const channels = await ensureGuildChannels(provisioner, this.deps.configStore);
+        await i.editReply({
+            content: t('cmd.init.done', { control: `<#${channels.controlChannelId}>` }),
+        });
+    }
+    // Route a /config panel component (role/string select or Save) to its panel. Gated
+    // by the same bootstrap rule as opening it and owner-bound: a bystander's stray
+    // select is acknowledged but ignored, so it cannot corrupt an admin's pending edit.
+    async handleConfigComponent(i) {
+        if (!i.guildId) {
+            await safe(i.deferUpdate());
+            return;
+        }
+        if (!this.authorizeConfig(i)) {
+            await safe(i.reply({ content: t('cmd.config.denied'), ephemeral: true }));
+            return;
+        }
+        const panel = this.configPanels.get(channelKey(i.guildId, i.channelId));
+        if (!panel || panel.ownerId !== i.user.id) {
+            await safe(i.deferUpdate());
+            return;
+        }
+        const input = {
+            id: i.customId,
+            ...(i.value !== undefined ? { value: i.value } : {}),
+            ...(i.values !== undefined ? { values: i.values } : {}),
+        };
+        const result = panel.handle(input);
+        if (result.kind === 'saved') {
+            this.configPanels.delete(channelKey(i.guildId, i.channelId));
+            // Save is a button on the primary (ephemeral) message; a fresh ephemeral reply
+            // carries the confirmation summary without disturbing the still-open panel.
+            await safe(i.reply({ content: result.summary, ephemeral: true }));
+            return;
+        }
+        if (result.kind === 'autosaved') {
+            // A defaults select persisted one field immediately; confirm it ephemerally
+            // (a fresh reply, keeping the panel open). If it was the locale select, drive
+            // setLocale so THIS session's subsequent responses use the chosen language.
+            this.applyLocaleIfLocaleSelect(i.customId, i.value);
+            await safe(i.reply({ content: result.notice, ephemeral: true }));
+            return;
+        }
+        // A pending selection or an ignored input: just acknowledge (keep the panel open).
+        await safe(i.deferUpdate());
+    }
+    // Route a submitted modal. The only modal the bot opens is the folder-step 📁 Create
+    // dialog (dir:create); its submit creates the subfolder and re-renders the browser.
+    // Any other modal id is a stray/replayed interaction — acknowledged with a generic
+    // ephemeral notice (no persistence) so it never shows "did not respond".
+    async handleModalSubmit(i) {
+        if (i.customId === 'dir:create') {
+            await this.guarded(i, () => this.handleCreateFolderModal(i));
+            return;
+        }
+        await safe(i.reply({ content: t('cmd.error.generic'), ephemeral: true }));
+    }
+    // When a /config auto-save was the LOCALE select, drive setLocale so this running
+    // process renders subsequent responses in the chosen language (the per-guild locale
+    // is also persisted; the global config.locale still seeds the boot default). A value
+    // outside the known set is left to the module default — never throws.
+    applyLocaleIfLocaleSelect(customId, value) {
+        if (customId !== 'config.default.locale' || !value)
+            return;
+        if (value === 'ko' || value === 'en')
+            setLocale(value);
+    }
+    // The /config bootstrap gate: allow if the actor has the Discord Administrator
+    // permission (works on first run with an empty allowlist) OR clears the admin tier
+    // (works once the allowlist is configured). Never uses the generic tier-denial
+    // reply — the caller sends the /config-specific notice.
+    authorizeConfig(i) {
+        if (i.hasAdminPermission === true)
+            return true;
+        const roleIds = i.member ? i.member.roles.cache.map((r) => r.id) : [];
+        return this.deps.authorizer.authorize({
+            userId: i.user.id,
+            roleIds,
+            action: 'admin',
+            context: { ...(i.guildId ? { guildId: i.guildId } : {}), channelId: i.channelId },
+        }).allowed;
+    }
+    // A4D-style session start: CREATE a dedicated session channel from the picked
+    // folder, start the session bound to THAT new channel (not the command's channel),
+    // wire renderers/permission/sendFile there, and post the status embed + intro. Falls
+    // back to the command's channel when the guild has no /init structure and no
+    // provisioner is available (so a session can still start), but the channel is created
+    // under the sessions category when /init has run. Returns the effective channel id so
+    // the wizard/router can link the new channel to the driver.
+    async startSession(params) {
+        const channelId = await this.resolveSessionChannelId(params);
+        const session = await this.startInChannel({ ...params, channelId });
+        await this.postSessionIntro(channelId, params, session);
+        return { session, channelId };
+    }
+    // orchestrator.start + wire renderers/permission/sendFile for the given channel. The
+    // /mode backend switch reuses this to restart IN PLACE (same channel) — it must not
+    // create a new session channel.
+    async startInChannel(params) {
+        const session = await this.deps.orchestrator.start(params);
+        await this.deps.wiring.attach(params.guildId, params.channelId, params.mode);
+        return session;
+    }
+    // Create the dedicated session channel for this start, or fall back to the command's
+    // channel when no provisioner is wired. When /init has run, the new channel is placed
+    // under the guild's sessions category; otherwise it is created without a parent (or,
+    // if creation is impossible, the command's channel is reused).
+    async resolveSessionChannelId(params) {
+        const provisioner = this.deps.resolveGuildProvisioner
+            ? await this.deps.resolveGuildProvisioner(params.guildId)
+            : null;
+        if (!provisioner)
+            return params.channelId;
+        const channels = this.guildChannels(params.guildId);
+        const created = await createSessionChannel(provisioner, params.cwd, channels?.sessionsCategoryId);
+        return created.id;
+    }
+    // The persisted /init channel structure for a guild, or undefined when /init has not
+    // run. A corrupt server file is treated as absent (loadServerConfig returns null).
+    guildChannels(guildId) {
+        return this.deps.configStore.loadServerConfig(guildId)?.channels;
+    }
+    // Post the pinned-style status embed + a short intro into the new session channel so
+    // the conversation happens there (A4D behavior). Best-effort: a resolve/post failure
+    // is logged but never fails the start (the session is already live).
+    async postSessionIntro(channelId, params, session) {
+        const resolve = this.deps.resolveChannel;
+        if (!resolve)
+            return;
+        try {
+            const channel = await resolve(channelId);
+            if (!channel)
+                return;
+            const usagePanel = this.deps.modeRegistry.has(params.mode)
+                ? this.deps.modeRegistry.get(params.mode).capabilities.usagePanel
+                : true;
+            const embed = buildStatusEmbed({
+                mode: params.mode,
+                cwd: params.cwd,
+                sessionId: session.sessionId,
+                permMode: params.permMode ?? 'default',
+                usagePanel,
+            });
+            await channel.send({ content: t('cmd.start.intro'), embeds: [embed] });
+        }
+        catch (err) {
+            this.logError('failed to post session intro', err);
+        }
+    }
+    async resume(i) {
+        const guildId = i.guildId;
+        const binding = this.deps.channelRegistry.get(guildId, i.channelId);
+        if (!binding || binding.archived) {
+            await i.editReply({ content: t('cmd.resume.none') });
+            return;
+        }
+        // For Claude, listResumable is currently [] — re-bind/inform gracefully.
+        await this.deps.wiring.attach(guildId, i.channelId, binding.mode);
+        await i.editReply({ content: t('cmd.resume.rebound') });
+    }
+    async close(i) {
+        const guildId = i.guildId;
+        await this.deps.orchestrator.stop(guildId, i.channelId);
+        this.deps.wiring.detach(guildId, i.channelId);
+        // A4D behavior: delete the dedicated session channel on close. Guarded — never
+        // delete the control channel or a channel that isn't the closed session's, and
+        // skip when no provisioner is wired. Best-effort: a delete failure still reports
+        // the session closed (the reply may not survive if this channel is the one deleted,
+        // which is expected). Reply BEFORE deleting so the ack lands first.
+        await i.editReply({ content: t('cmd.close.done') });
+        await this.deleteSessionChannel(guildId, i.channelId);
+    }
+    // Delete the session channel that was closed, unless it is the guild's control
+    // channel (never delete /init's control channel). No-op when no provisioner is wired.
+    async deleteSessionChannel(guildId, channelId) {
+        const channels = this.guildChannels(guildId);
+        if (channels && channelId === channels.controlChannelId)
+            return;
+        const provisioner = this.deps.resolveGuildProvisioner
+            ? await this.deps.resolveGuildProvisioner(guildId)
+            : null;
+        if (!provisioner)
+            return;
+        try {
+            await provisioner.deleteChannel(channelId);
+        }
+        catch (err) {
+            this.logError('failed to delete session channel', err);
+        }
+    }
+    async switchBackend(i) {
+        const guildId = i.guildId;
+        const backend = i.getString('backend');
+        if (!backend)
+            return;
+        // Validate the target backend BEFORE any teardown: an unregistered backend (e.g.
+        // Codex before Phase 2 registers it) must NOT stop/detach the running session.
+        if (!this.deps.modeRegistry.has(backend)) {
+            await i.editReply({ content: t('cmd.mode.unavailable', { backend }) });
+            return;
+        }
+        // Require an existing binding: there is no cwd/owner to carry over otherwise, and
+        // falling back to process.cwd() would start a session in the bot's own directory.
+        const binding = this.deps.channelRegistry.get(guildId, i.channelId);
+        if (!binding) {
+            await i.editReply({ content: t('router.noSession') });
+            return;
+        }
+        // Switching the backend starts a fresh context (§9 step 3): stop the current
+        // session, then start a new one on the same cwd/owner/permMode and re-wire.
+        const { cwd, ownerId, permMode, profile } = binding;
+        await this.deps.orchestrator.stop(guildId, i.channelId);
+        this.deps.wiring.detach(guildId, i.channelId);
+        await this.startInChannel({
+            guildId,
+            channelId: i.channelId,
+            mode: backend,
+            cwd,
+            ownerId,
+            permMode,
+            profile,
+        });
+        // Confirmation closes the ephemeral deferred reply (only the actor sees it). The
+        // fresh-context warning (§9 step 3) is PUBLIC so the whole channel sees the context
+        // reset — posted as a non-ephemeral followUp since the deferred reply is ephemeral.
+        await i.editReply({ content: t('cmd.mode.switched', { backend }) });
+        await safe(i.followUp({ content: t('cmd.mode.freshContext', { backend }), ephemeral: false }));
+    }
+    async switchPerm(i) {
+        const guildId = i.guildId;
+        const value = i.getString('value');
+        if (!value)
+            return;
+        const binding = this.deps.channelRegistry.get(guildId, i.channelId);
+        if (!binding) {
+            await i.editReply({ content: t('router.noSession') });
+            return;
+        }
+        // A value that names a known profile switches the profile; otherwise it is a raw
+        // permission mode. Either way the session is kept (applies on next turn/spawn).
+        const config = this.deps.configStore.load();
+        const isProfile = Object.prototype.hasOwnProperty.call(config.profiles, value);
+        const override = isProfile
+            ? { profile: value }
+            : { permMode: value };
+        const resolved = this.deps.permissionResolver.resolve(guildId, i.channelId, override);
+        this.deps.channelRegistry.set({
+            guildId,
+            channelId: i.channelId,
+            mode: binding.mode,
+            sessionId: binding.sessionId,
+            cwd: binding.cwd,
+            ownerId: binding.ownerId,
+            permMode: resolved.permMode,
+            profile: resolved.profile,
+            ...(binding.projectAuth ? { projectAuth: binding.projectAuth } : {}),
+        });
+        await i.editReply({ content: t('cmd.perm.switched', { perm: resolved.profile ?? resolved.permMode }) });
+    }
+    async stop(i) {
+        const guildId = i.guildId;
+        await this.deps.orchestrator.stop(guildId, i.channelId);
+        this.deps.wiring.detach(guildId, i.channelId);
+        await i.editReply({ content: t('cmd.stop.done') });
+    }
+    async stopAll(i) {
+        // Detach every wired channel first so no renderer lingers, then stop all.
+        const bindings = this.deps.channelRegistry.list().filter((b) => !b.archived);
+        for (const b of bindings)
+            this.deps.wiring.detach(b.guildId, b.channelId);
+        await this.deps.orchestrator.stopAll();
+        await i.editReply({ content: t('cmd.stopAll.done', { count: bindings.length }) });
+    }
+    // ---- Component interactions (buttons / selects) -------------------------
+    async handleComponent(i) {
+        // /config panel components own their own ack flow (deferUpdate on a pending pick,
+        // an ephemeral reply on Save / denial). Fast work only (in-memory panel state plus
+        // one small JSON write on Save), so they ack within the window without a leading
+        // defer. Same bootstrap gate as opening the panel; owner-bound.
+        if (isConfigPanelId(i.customId)) {
+            await this.handleConfigComponent(i);
+            return;
+        }
+        // Permission buttons: perm:<reqId>:<action>. These are gated to execute tier
+        // (the driver decides). Route to the channel's PermissionButtonsHandler, passing
+        // the acting user id so the handler enforces that ONLY the prompt's approver
+        // (the session owner) can resolve it — a bystander click is ignored (§7.1/§7.5).
+        if (parseCustomId(i.customId)) {
+            if (!this.authorize(i, 'drive'))
+                return;
+            // Acknowledge FIRST (deferUpdate keeps the existing message), THEN resolve the
+            // permission — resolvePermission touches the session and must never delay the
+            // ack past Discord's 3s window.
+            if (!(await this.ackDeferUpdate(i)))
+                return;
+            await this.guarded(i, async () => {
+                if (i.guildId) {
+                    await this.deps.wiring.resolvePermission(i.guildId, i.channelId, i.customId, i.user.id);
+                }
+            });
+            return;
+        }
+        // The 📁 Create button opens a modal, and showModal IS the ack — it must NOT be
+        // preceded by a deferUpdate (a deferred component can no longer show a modal). So
+        // this is handled BEFORE the generic defer below. Drive-gated + owner-bound.
+        if (i.customId === 'dir:create') {
+            if (!this.authorize(i, 'drive'))
+                return;
+            await this.guarded(i, () => this.openCreateFolderModal(i));
+            return;
+        }
+        // The "Resume Session" button and the resume flow's own selects (resume.*) drive a
+        // separate resume state machine. Deferred-update first (listResumable/resume can
+        // exceed 3s), then routed to the flow.
+        if (i.customId === 'dir:resume' || i.customId.startsWith('resume.')) {
+            if (!this.authorize(i, 'drive'))
+                return;
+            if (!(await this.ackDeferUpdate(i)))
+                return;
+            if (!i.guildId)
+                return;
+            await this.guarded(i, () => this.handleResumeComponent(i));
+            return;
+        }
+        // Otherwise it is a wizard component (folder/backend/model/perm/confirm/cancel).
+        // The wizard flow is a drive action; only the driver who opened it advances it.
+        if (!this.authorize(i, 'drive'))
+            return;
+        // Acknowledge FIRST: the confirm step calls orchestrator.start (spawns an agent),
+        // which can exceed 3s — deferUpdate now, do the work after.
+        if (!(await this.ackDeferUpdate(i)))
+            return;
+        if (!i.guildId)
+            return;
+        await this.guarded(i, async () => {
+            const wizard = this.wizards.get(channelKey(i.guildId, i.channelId));
+            // Enforce wizard ownership: a component from anyone other than the driver who
+            // opened the wizard is acknowledged but ignored, so a bystander's stray select
+            // cannot corrupt another driver's flow (§7.1).
+            if (!wizard || wizard.ownerId !== i.user.id)
+                return;
+            const input = { id: i.customId, ...(i.value !== undefined ? { value: i.value } : {}) };
+            const step = await wizard.handle(input);
+            if (step === 'done' || step === 'cancelled') {
+                this.wizards.delete(channelKey(i.guildId, i.channelId));
+            }
+            // On a successful confirm the session was bound to a freshly created channel;
+            // link it back to the driver (A4D-style "session started in <#newChannel>").
+            if (step === 'done') {
+                const newChannelId = wizard.sessionChannelId();
+                if (newChannelId) {
+                    await safe(i.editReply({ content: t('cmd.start.channelCreated', { channel: `<#${newChannelId}>` }) }));
+                }
+                return;
+            }
+            // Every non-terminal transition re-renders the CURRENT step (folder → backend →
+            // model → perm → confirm) and edits it into the wizard's message, so each step's
+            // picker actually appears. A cancel renders the terminal notice with no rows. The
+            // component was deferUpdate'd above, so editReply updates that same message.
+            const { embed, rows } = wizard.render();
+            await safe(i.editReply({ embeds: [embed], components: rows }));
+        });
+    }
+    // ---- 📁 Create folder --------------------------------------------------
+    // Open the create-folder modal for the active wizard's folder step. Owner-bound: a
+    // bystander (or a stale button with no wizard) is acknowledged (deferUpdate) and
+    // ignored, so it never shows "did not respond". showModal is the ack for the owner's
+    // click — the modal-submit interaction (handleCreateFolderModal) does the mkdir.
+    async openCreateFolderModal(i) {
+        const wizard = i.guildId ? this.wizards.get(channelKey(i.guildId, i.channelId)) : undefined;
+        if (!wizard || wizard.ownerId !== i.user.id) {
+            await safe(i.deferUpdate());
+            return;
+        }
+        await i.showModal({
+            customId: 'dir:create',
+            title: t('dir.create.title'),
+            fields: [
+                {
+                    customId: 'name',
+                    label: t('dir.create.label'),
+                    placeholder: t('dir.create.placeholder'),
+                    required: true,
+                },
+            ],
+        });
+    }
+    // Handle the create-folder modal submit: validate the name, create it as a DIRECT
+    // subfolder of the wizard's CURRENT browsed directory, and re-render the folder step
+    // (so the new folder appears). The name must be a single path segment — reject '/'
+    // or '\\', '.'/'..' traversal, and any absolute path — so a crafted name can only
+    // ever create a direct child of the browsed dir, never escape it. Owner-bound.
+    async handleCreateFolderModal(i) {
+        if (!i.guildId) {
+            await safe(i.reply({ content: t('cmd.error.generic'), ephemeral: true }));
+            return;
+        }
+        const wizard = this.wizards.get(channelKey(i.guildId, i.channelId));
+        if (!wizard || wizard.ownerId !== i.user.id) {
+            await safe(i.reply({ content: t('cmd.error.generic'), ephemeral: true }));
+            return;
+        }
+        const name = i.getField('name').trim();
+        if (!isSafeFolderName(name)) {
+            await safe(i.reply({ content: t('dir.create.invalid'), ephemeral: true }));
+            return;
+        }
+        // Confine to a DIRECT child of the browsed dir: resolve and verify the parent is
+        // exactly the browsed dir (defense in depth beyond the name check above).
+        const parent = wizard.browserCwd();
+        const target = path.join(parent, name);
+        if (path.dirname(target) !== parent) {
+            await safe(i.reply({ content: t('dir.create.invalid'), ephemeral: true }));
+            return;
+        }
+        try {
+            fs.mkdirSync(target, { recursive: true });
+        }
+        catch (err) {
+            await safe(i.reply({ content: t('dir.create.failed', { error: String(err) }), ephemeral: true }));
+            return;
+        }
+        // Re-render the folder step (the browser re-lists children on render, so the new
+        // folder shows) and confirm the creation ephemerally. The modal submit is its own
+        // interaction, so we reply to it directly.
+        const { embed, rows } = wizard.render();
+        await safe(i.reply({ content: t('dir.create.done', { name }), embeds: [embed], components: rows, ephemeral: true }));
+    }
+    // ---- Resume Session flow -----------------------------------------------
+    // Route a resume-flow component: the "Resume Session" button starts a new flow (from
+    // the active wizard's browsed folder); the resume.* selects/buttons advance it. The
+    // interaction is already deferUpdate'd by the caller. Owner-bound to the wizard's
+    // driver so a bystander cannot hijack the resume of another driver's folder pick.
+    async handleResumeComponent(i) {
+        const guildId = i.guildId;
+        const key = channelKey(guildId, i.channelId);
+        if (i.customId === 'dir:resume') {
+            const wizard = this.wizards.get(key);
+            if (!wizard || wizard.ownerId !== i.user.id)
+                return; // owner-bound; ignore strays
+            const flow = this.buildResumeWizard(guildId, i.channelId, i.user.id, wizard.browserCwd());
+            this.resumeFlows.set(key, flow);
+            const { embed, rows } = flow.render();
+            await safe(i.editReply({ embeds: [embed], components: rows }));
+            return;
+        }
+        // A resume.* select/button for an existing flow.
+        const flow = this.resumeFlows.get(key);
+        if (!flow || flow.ownerId !== i.user.id)
+            return;
+        const step = await flow.handle({ id: i.customId, ...(i.value !== undefined ? { value: i.value } : {}) });
+        if (step === 'done' || step === 'cancelled' || step === 'empty') {
+            this.resumeFlows.delete(key);
+        }
+        if (step === 'done') {
+            const newChannelId = flow.sessionChannelId();
+            if (newChannelId) {
+                await safe(i.editReply({ content: t('resume.done', { channel: `<#${newChannelId}>` }), embeds: [], components: [] }));
+            }
+            return;
+        }
+        if (step === 'empty') {
+            // No resumable sessions for the picked backend: ephemeral notice, flow ends.
+            await safe(i.editReply({ content: t('resume.none'), embeds: [], components: [] }));
+            return;
+        }
+        const { embed, rows } = flow.render();
+        await safe(i.editReply({ embeds: [embed], components: rows }));
+    }
+    // Build a ResumeWizard bound to the driver + the folder in view. listResumableFor
+    // dispatches to the chosen backend's mode.listResumable (Claude via listSessions,
+    // Codex via CodexDiscovery); resume creates/binds a session channel and calls
+    // orchestrator.resume there (mirroring the start flow's channel creation).
+    buildResumeWizard(guildId, channelId, ownerId, cwd) {
+        const resolved = this.deps.configResolver.resolve(guildId, channelId);
+        return new ResumeWizard({
+            guildId,
+            channelId,
+            ownerId,
+            cwd,
+            backends: this.deps.modeRegistry.list(),
+            defaultBackend: resolved.mode,
+            listResumableFor: (backend, dir) => this.listResumableFor(backend, dir),
+            resume: (params) => this.resumeSession(params),
+            relativeTime,
+        });
+    }
+    // List resumable sessions for a backend, scoped to `cwd`, via the mode's optional
+    // listResumable. A mode without it (or a throw) yields [] so the picker shows the
+    // empty notice rather than failing. The ModeContext is a MINIMAL read-only context:
+    // listResumable only reads ctx.cwd/ctx.config/ctx.logger (never emits/starts).
+    async listResumableFor(backend, cwd) {
+        if (!this.deps.modeRegistry.has(backend))
+            return [];
+        const mode = this.deps.modeRegistry.get(backend);
+        if (!mode.listResumable)
+            return [];
+        try {
+            const ctx = this.deps.orchestrator.buildListContext(backend, cwd);
+            return await mode.listResumable(ctx);
+        }
+        catch (err) {
+            this.logError('listResumable failed', err);
+            return [];
+        }
+    }
+    // Resume a chosen session: create a dedicated session channel from the picked folder
+    // (like the start flow), resume the backend session bound to THAT channel via
+    // orchestrator.resume, wire renderers/permission/sendFile, and post a resumed-status
+    // embed. Returns the new channel id so the flow links it back to the driver.
+    async resumeSession(params) {
+        const startParams = {
+            guildId: params.guildId,
+            channelId: await this.resolveSessionChannelId({
+                guildId: params.guildId,
+                channelId: params.channelId,
+                mode: params.backend,
+                cwd: params.cwd,
+                ownerId: params.ownerId,
+            }),
+            mode: params.backend,
+            cwd: params.cwd,
+            ownerId: params.ownerId,
+        };
+        const session = await this.deps.orchestrator.resume(startParams, params.sessionId);
+        await this.deps.wiring.attach(startParams.guildId, startParams.channelId, startParams.mode);
+        await this.postResumeIntro(startParams.channelId, startParams, session);
+        return { session, channelId: startParams.channelId };
+    }
+    // Post the resumed-session status embed into the new channel (mirrors
+    // postSessionIntro but titled as a resume). Best-effort; never fails the resume.
+    async postResumeIntro(channelId, params, session) {
+        const resolve = this.deps.resolveChannel;
+        if (!resolve)
+            return;
+        try {
+            const channel = await resolve(channelId);
+            if (!channel)
+                return;
+            const usagePanel = this.deps.modeRegistry.has(params.mode)
+                ? this.deps.modeRegistry.get(params.mode).capabilities.usagePanel
+                : true;
+            const embed = buildStatusEmbed({
+                mode: params.mode,
+                cwd: params.cwd,
+                sessionId: session.sessionId,
+                permMode: params.permMode ?? 'default',
+                usagePanel,
+            });
+            await channel.send({ content: t('cmd.start.intro'), embeds: [{ ...embed, title: t('resume.status.title') }] });
+        }
+        catch (err) {
+            this.logError('failed to post resume intro', err);
+        }
+    }
+    // deferUpdate the component interaction (the first ack, keeping its message). Returns
+    // false when the ack itself failed (stale interaction) so the caller bails out.
+    async ackDeferUpdate(i) {
+        try {
+            await i.deferUpdate();
+            return true;
+        }
+        catch (err) {
+            this.logError('interaction deferUpdate failed', err);
+            return false;
+        }
+    }
+    // ---- Auth ---------------------------------------------------------------
+    // Authorize the interaction for an action; on denial send an ephemeral notice and
+    // return false. DMs (no guild) are rejected by the Authorizer's dmPolicy.
+    authorize(i, action) {
+        const roleIds = i.member ? i.member.roles.cache.map((r) => r.id) : [];
+        const decision = this.deps.authorizer.authorize({
+            userId: i.user.id,
+            roleIds,
+            action,
+            context: { ...(i.guildId ? { guildId: i.guildId } : {}), channelId: i.channelId },
+            // A Discord Administrator is granted the admin tier unconditionally (never
+            // locked out); the adapter populates hasAdminPermission from member permissions.
+            ...(i.hasAdminPermission === true ? { isAdministrator: true } : {}),
+        });
+        if (!decision.allowed) {
+            // Ephemeral denial. A slash interaction is already deferred (edit its reply); a
+            // component interaction is not yet acked (send a fresh ephemeral reply).
+            const payload = { content: t('auth.denied', { reason: decision.reason ?? '' }), ephemeral: true };
+            void safe(i.acknowledged ? i.editReply(payload) : i.reply(payload));
+            return false;
+        }
+        return true;
+    }
+}
+async function safe(p) {
+    try {
+        await p;
+    }
+    catch {
+        // best-effort
+    }
+}
+// True when `name` is a safe SINGLE folder segment for the 📁 Create flow: non-empty,
+// no path separators ('/' or '\\'), not '.'/'..' traversal, and not absolute. This
+// guarantees the created folder is a DIRECT child of the current browsed directory and
+// can never escape it (the router additionally verifies dirname(target) === parent).
+function isSafeFolderName(name) {
+    if (name.length === 0)
+        return false;
+    if (name === '.' || name === '..')
+        return false;
+    if (name.includes('/') || name.includes('\\'))
+        return false;
+    if (path.isAbsolute(name))
+        return false;
+    // A segment that path treats as anything other than itself (e.g. contains a NUL) is
+    // rejected; path.basename normalizes trailing separators, so require an exact match.
+    if (path.basename(name) !== name)
+        return false;
+    return true;
+}
+// Render an updatedAt ISO string as a short relative time for the resume picker
+// (A4D-style "3분 전"). Absent/unparseable → empty (the option just shows its label).
+function relativeTime(updatedAt) {
+    if (!updatedAt)
+        return '';
+    const then = Date.parse(updatedAt);
+    if (Number.isNaN(then))
+        return '';
+    const seconds = Math.max(0, Math.floor((Date.now() - then) / 1000));
+    if (seconds < 60)
+        return t('resume.time.now');
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return t('resume.time.min', { n: minutes });
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return t('resume.time.hour', { n: hours });
+    return t('resume.time.day', { n: Math.floor(hours / 24) });
+}
+//# sourceMappingURL=interactionRouter.js.map