@vibe-forge/tsconfigs 0.7.2 → 0.9.0

package/dist/apps/server/__tests__/websocket/server.spec.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_buffer_1 = require("node:buffer");
+const vitest_1 = require("vitest");
+const addSessionSubscriberSocket = vitest_1.vi.fn();
+const removeSessionSubscriberSocket = vitest_1.vi.fn();
+const attachSocketToSession = vitest_1.vi.fn();
+const detachSocketFromSession = vitest_1.vi.fn();
+const getAdapterSessionRuntime = vitest_1.vi.fn();
+const startAdapterSession = vitest_1.vi.fn();
+const handleInteractionResponse = vitest_1.vi.fn();
+const processUserMessage = vitest_1.vi.fn();
+const interruptSession = vitest_1.vi.fn();
+const killSession = vitest_1.vi.fn();
+const getSession = vitest_1.vi.fn();
+let connectionHandler;
+vitest_1.vi.mock('ws', () => {
+    class MockWebSocketServer {
+        constructor(_options) { }
+        on(event, handler) {
+            if (event === 'connection') {
+                connectionHandler = handler;
+            }
+        }
+    }
+    return {
+        WebSocketServer: MockWebSocketServer
+    };
+});
+vitest_1.vi.mock('#~/db/index.js', () => ({
+    getDb: vitest_1.vi.fn(() => ({
+        getSession
+    }))
+}));
+vitest_1.vi.mock('#~/services/session/index.js', () => ({
+    startAdapterSession,
+    processUserMessage,
+    interruptSession,
+    killSession
+}));
+vitest_1.vi.mock('#~/services/session/interaction.js', () => ({
+    handleInteractionResponse
+}));
+vitest_1.vi.mock('#~/services/session/runtime.js', () => ({
+    addSessionSubscriberSocket,
+    removeSessionSubscriberSocket,
+    attachSocketToSession,
+    detachSocketFromSession,
+    getAdapterSessionRuntime
+}));
+vitest_1.vi.mock('#~/utils/logger.js', () => ({
+    getSessionLogger: vitest_1.vi.fn(() => ({
+        info: vitest_1.vi.fn(),
+        error: vitest_1.vi.fn()
+    }))
+}));
+(0, vitest_1.describe)('setupWebSocket', () => {
+    (0, vitest_1.beforeEach)(async () => {
+        vitest_1.vi.clearAllMocks();
+        connectionHandler = undefined;
+        getAdapterSessionRuntime.mockReturnValue(undefined);
+        const { setupWebSocket } = await import('#~/websocket/server.js');
+        setupWebSocket({}, {
+            __VF_PROJECT_AI_SERVER_WS_PATH__: '/ws'
+        });
+    });
+    (0, vitest_1.it)('registers session list subscribers only for subscribe=sessions connections', async () => {
+        const ws = {
+            on: vitest_1.vi.fn(),
+            readyState: 1,
+            send: vitest_1.vi.fn()
+        };
+        await connectionHandler?.(ws, {
+            url: '/ws?subscribe=sessions',
+            headers: { host: 'localhost' }
+        });
+        (0, vitest_1.expect)(addSessionSubscriberSocket).toHaveBeenCalledOnce();
+        (0, vitest_1.expect)(addSessionSubscriberSocket).toHaveBeenCalledWith(ws);
+        (0, vitest_1.expect)(startAdapterSession).not.toHaveBeenCalled();
+        (0, vitest_1.expect)(ws.on).toHaveBeenCalledWith('close', vitest_1.expect.any(Function));
+    });
+    (0, vitest_1.it)('does not register regular session sockets as session list subscribers', async () => {
+        startAdapterSession.mockResolvedValue({ sockets: new Set(), session: {} });
+        attachSocketToSession.mockReturnValue({ sockets: new Set([{}]), session: {} });
+        getSession.mockReturnValue({ id: 'sess-1', status: 'running' });
+        const ws = {
+            on: vitest_1.vi.fn(),
+            readyState: 1,
+            send: vitest_1.vi.fn()
+        };
+        await connectionHandler?.(ws, {
+            url: '/ws?sessionId=sess-1',
+            headers: { host: 'localhost' }
+        });
+        (0, vitest_1.expect)(addSessionSubscriberSocket).not.toHaveBeenCalled();
+        (0, vitest_1.expect)(startAdapterSession).toHaveBeenCalledOnce();
+        (0, vitest_1.expect)(startAdapterSession).toHaveBeenCalledWith('sess-1', {
+            model: undefined,
+            systemPrompt: undefined,
+            appendSystemPrompt: true,
+            permissionMode: undefined,
+            promptType: undefined,
+            promptName: undefined,
+            adapter: undefined
+        });
+        (0, vitest_1.expect)(attachSocketToSession).toHaveBeenCalledWith('sess-1', ws, 'adapter');
+    });
+    (0, vitest_1.it)('keeps completed sessions in passive mode when opening the page', async () => {
+        getSession.mockReturnValue({
+            id: 'sess-1',
+            status: 'completed'
+        });
+        const ws = {
+            on: vitest_1.vi.fn(),
+            readyState: 1,
+            send: vitest_1.vi.fn()
+        };
+        await connectionHandler?.(ws, {
+            url: '/ws?sessionId=sess-1',
+            headers: { host: 'localhost' }
+        });
+        (0, vitest_1.expect)(startAdapterSession).not.toHaveBeenCalled();
+        (0, vitest_1.expect)(attachSocketToSession).toHaveBeenCalledWith('sess-1', ws, 'external');
+    });
+    (0, vitest_1.it)('sends a structured error payload when adapter startup fails', async () => {
+        startAdapterSession.mockRejectedValueOnce(new Error('adapter init failed'));
+        getSession.mockReturnValue({ id: 'sess-1', status: 'running' });
+        const ws = {
+            on: vitest_1.vi.fn(),
+            readyState: 1,
+            send: vitest_1.vi.fn()
+        };
+        await connectionHandler?.(ws, {
+            url: '/ws?sessionId=sess-1',
+            headers: { host: 'localhost' }
+        });
+        (0, vitest_1.expect)(ws.send).toHaveBeenCalledOnce();
+        (0, vitest_1.expect)(JSON.parse(String(ws.send.mock.calls[0]?.[0]))).toEqual({
+            type: 'error',
+            data: {
+                message: 'adapter init failed',
+                fatal: true
+            },
+            message: 'adapter init failed'
+        });
+    });
+    (0, vitest_1.it)('sends a structured error payload when a websocket message is invalid JSON', async () => {
+        startAdapterSession.mockResolvedValueOnce({ sockets: new Set(), session: {} });
+        attachSocketToSession.mockReturnValue({ sockets: new Set([{}]), session: {} });
+        getSession.mockReturnValue({ id: 'sess-1', status: 'running' });
+        let messageHandler;
+        const ws = {
+            on: vitest_1.vi.fn((event, handler) => {
+                if (event === 'message')
+                    messageHandler = handler;
+            }),
+            readyState: 1,
+            send: vitest_1.vi.fn()
+        };
+        await connectionHandler?.(ws, {
+            url: '/ws?sessionId=sess-1',
+            headers: { host: 'localhost' }
+        });
+        messageHandler?.(node_buffer_1.Buffer.from('{'));
+        (0, vitest_1.expect)(ws.send).toHaveBeenCalledOnce();
+        const payload = JSON.parse(String(ws.send.mock.calls[0]?.[0]));
+        (0, vitest_1.expect)(payload.type).toBe('error');
+        (0, vitest_1.expect)(payload.data.fatal).toBe(true);
+        (0, vitest_1.expect)(typeof payload.data.message).toBe('string');
+    });
+});

package/dist/apps/server/src/channels/handlers.d.ts

@@ -0,0 +1,6 @@
+import type { ConfigSource, WSEvent } from '@vibe-forge/core';
+import type { ChannelBaseConfig, ChannelConnection, ChannelInboundEvent } from '@vibe-forge/core/channel';
+import type { ChannelTextMessage } from './middleware/@types';
+import type { ChannelRuntimeState } from './types';
+export declare const handleInboundEvent: (channelKey: string, inbound: ChannelInboundEvent, connection: ChannelConnection<ChannelTextMessage> | undefined, config?: ChannelBaseConfig, configSource?: ConfigSource) => Promise<void>;
+export declare const handleSessionEvent: (states: Map<string, ChannelRuntimeState>, sessionId: string, event: WSEvent) => Promise<void>;

package/dist/apps/server/src/channels/handlers.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleSessionEvent = exports.handleInboundEvent = void 0;
+const index_js_1 = require("#~/db/index.js");
+const events_js_1 = require("#~/services/session/events.js");
+const index_js_2 = require("#~/services/session/index.js");
+const runtime_js_1 = require("#~/services/session/runtime.js");
+const middleware_1 = require("./middleware");
+const i18n_1 = require("./middleware/i18n");
+const state_1 = require("./state");
+const handleInboundEvent = async (channelKey, inbound, connection, config, configSource) => {
+    const ctx = {
+        channelKey,
+        configSource,
+        inbound,
+        connection,
+        config,
+        sessionId: undefined,
+        channelAdapter: undefined,
+        channelPermissionMode: undefined,
+        contentItems: undefined,
+        commandText: '',
+        defineMessages: i18n_1.defineMessages,
+        t: (key) => key,
+        reply: async (text) => {
+            if (!connection)
+                return undefined;
+            const receiveId = inbound.replyTo?.receiveId ?? inbound.channelId;
+            const receiveIdType = inbound.replyTo?.receiveIdType ?? 'chat_id';
+            return connection.sendMessage({ receiveId, receiveIdType, text });
+        },
+        pushFollowUps: async ({ messageId, followUps }) => {
+            if (!connection?.pushFollowUps || !messageId || followUps.length === 0)
+                return;
+            await connection.pushFollowUps({ messageId, followUps });
+        },
+        getBoundSession: () => {
+            if (!ctx.sessionId)
+                return undefined;
+            return (0, index_js_1.getDb)().getSession(ctx.sessionId);
+        },
+        resetSession: () => {
+            const { sessionId } = ctx;
+            if (sessionId) {
+                const updatedIds = (0, index_js_1.getDb)().updateSessionArchivedWithChildren(sessionId, true);
+                for (const updatedId of updatedIds) {
+                    const updatedSession = (0, index_js_1.getDb)().getSession(updatedId);
+                    if (updatedSession != null) {
+                        (0, runtime_js_1.notifySessionUpdated)(updatedId, updatedSession);
+                    }
+                }
+                (0, index_js_1.getDb)().deleteChannelSessionBySessionId(sessionId);
+                (0, state_1.deleteBinding)(sessionId);
+                ctx.sessionId = undefined;
+            }
+        },
+        stopSession: () => {
+            if (ctx.sessionId) {
+                (0, index_js_2.killSession)(ctx.sessionId);
+            }
+        },
+        restartSession: async () => {
+            if (ctx.sessionId) {
+                (0, index_js_2.killSession)(ctx.sessionId);
+                await (0, index_js_2.startAdapterSession)(ctx.sessionId);
+            }
+        },
+        updateSession: (updates) => {
+            if (ctx.sessionId) {
+                (0, index_js_1.getDb)().updateSession(ctx.sessionId, updates);
+            }
+        },
+        getChannelAdapterPreference: () => ctx.channelAdapter,
+        setChannelAdapterPreference: (adapter) => {
+            ctx.channelAdapter = adapter;
+            (0, index_js_1.getDb)().upsertChannelPreference({
+                channelType: inbound.channelType,
+                sessionType: inbound.sessionType,
+                channelId: inbound.channelId,
+                channelKey,
+                adapter,
+                permissionMode: ctx.channelPermissionMode
+            });
+        },
+        getChannelPermissionModePreference: () => ctx.channelPermissionMode,
+        setChannelPermissionModePreference: (permissionMode) => {
+            ctx.channelPermissionMode = permissionMode;
+            (0, index_js_1.getDb)().upsertChannelPreference({
+                channelType: inbound.channelType,
+                sessionType: inbound.sessionType,
+                channelId: inbound.channelId,
+                channelKey,
+                adapter: ctx.channelAdapter,
+                permissionMode
+            });
+        }
+    };
+    await (0, middleware_1.pipeline)(ctx);
+};
+exports.handleInboundEvent = handleInboundEvent;
+const handleSessionEvent = async (states, sessionId, event) => {
+    if (event.type !== 'message' || event.message.role !== 'assistant')
+        return;
+    const text = (0, events_js_1.extractTextFromMessage)(event.message);
+    if (text == null || text === '')
+        return;
+    const unack = (0, state_1.consumePendingUnack)(sessionId);
+    if (unack) {
+        await unack().catch(() => undefined);
+    }
+    const binding = (0, state_1.resolveBinding)(sessionId);
+    if (!binding)
+        return;
+    const state = states.get(binding.channelKey);
+    if (!state?.connection)
+        return;
+    const receiveId = binding.replyReceiveId ?? binding.channelId;
+    const receiveIdType = binding.replyReceiveIdType ?? 'chat_id';
+    await state.connection.sendMessage({ receiveId, receiveIdType, text });
+};
+exports.handleSessionEvent = handleSessionEvent;

package/dist/apps/server/src/channels/index.d.ts

@@ -0,0 +1,6 @@
+import type { WSEvent } from '@vibe-forge/core';
+import type { ChannelManager } from './types';
+export declare const initChannels: (configs: ReadonlyArray<{
+    channels?: Record<string, unknown>;
+} | undefined>) => Promise<ChannelManager>;
+export declare const handleChannelSessionEvent: (sessionId: string, event: WSEvent) => Promise<void>;

package/dist/apps/server/src/channels/index.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleChannelSessionEvent = exports.initChannels = void 0;
+const logger_js_1 = require("#~/utils/logger.js");
+const handlers_1 = require("./handlers");
+const loader_1 = require("./loader");
+const collectChannelEntries = (configs) => {
+    const entries = new Map();
+    for (const [index, config] of configs.entries()) {
+        const source = index === 0 ? 'project' : 'user';
+        for (const [key, value] of Object.entries(config?.channels ?? {})) {
+            entries.set(key, { source, value });
+        }
+    }
+    return entries;
+};
+let channelManager = null;
+const initChannels = async (configs) => {
+    const channels = collectChannelEntries(configs);
+    const states = new Map();
+    for (const [key, entry] of channels.entries()) {
+        const value = entry.value;
+        if (value == null || typeof value !== 'object')
+            continue;
+        const rawConfig = value;
+        const type = rawConfig.type;
+        if (typeof type !== 'string' || type === '')
+            continue;
+        try {
+            const mod = (0, loader_1.loadChannelModule)(type);
+            if (rawConfig.enabled === false) {
+                states.set(key, { key, type, status: 'disabled', configSource: entry.source });
+                continue;
+            }
+            const parsed = mod.definition.configSchema.safeParse(rawConfig);
+            if (parsed.success === false) {
+                states.set(key, { key, type, status: 'error', error: parsed.error?.message, configSource: entry.source });
+                continue;
+            }
+            const connectionConfig = parsed.success ? parsed.data : rawConfig;
+            const connection = await mod.create(connectionConfig, { logger: logger_js_1.logger });
+            const state = {
+                key,
+                type,
+                status: 'connected',
+                connection,
+                config: connectionConfig,
+                configSource: entry.source
+            };
+            states.set(key, state);
+            await connection.startReceiving?.({
+                handlers: {
+                    message: async (event) => await (0, handlers_1.handleInboundEvent)(key, event, connection, state.config, state.configSource)
+                }
+            });
+        }
+        catch (err) {
+            states.set(key, {
+                key,
+                type,
+                status: 'error',
+                error: String(err.message ?? err),
+                configSource: entry.source
+            });
+        }
+    }
+    const closeAll = async () => {
+        for (const state of states.values()) {
+            await state.connection?.close?.();
+        }
+    };
+    const manager = {
+        states,
+        handleSessionEvent: async (sessionId, event) => await (0, handlers_1.handleSessionEvent)(states, sessionId, event),
+        closeAll
+    };
+    channelManager = manager;
+    return manager;
+};
+exports.initChannels = initChannels;
+const handleChannelSessionEvent = async (sessionId, event) => {
+    if (!channelManager)
+        return;
+    await channelManager.handleSessionEvent(sessionId, event);
+};
+exports.handleChannelSessionEvent = handleChannelSessionEvent;

package/dist/apps/server/src/channels/loader.d.ts

@@ -0,0 +1,6 @@
+import type { ChannelCreateFn, ChannelDescriptor } from '@vibe-forge/core/channel';
+export interface LoadedChannel {
+    create: ChannelCreateFn;
+    definition: ChannelDescriptor;
+}
+export declare const loadChannelModule: (type: string) => LoadedChannel;

package/dist/apps/server/src/channels/loader.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadChannelModule = void 0;
+const node_module_1 = require("node:module");
+const nodeRequire = (0, node_module_1.createRequire)(__filename);
+const loadChannelModule = (type) => {
+    const mainSpecifier = `@vibe-forge/channel-${type}`;
+    const connSpecifier = `@vibe-forge/channel-${type}/connection`;
+    const mainMod = nodeRequire(mainSpecifier);
+    const definition = mainMod.channelDefinition;
+    if (definition == null) {
+        throw new TypeError(`${mainSpecifier} must export channelDefinition`);
+    }
+    const connMod = nodeRequire(connSpecifier);
+    const create = connMod.createChannelConnection;
+    if (typeof create !== 'function') {
+        throw new TypeError(`${connSpecifier} must export createChannelConnection`);
+    }
+    return { create, definition };
+};
+exports.loadChannelModule = loadChannelModule;

package/dist/apps/server/src/channels/middleware/@types/index.d.ts

@@ -0,0 +1,55 @@
+import type { ChatMessageContent, ConfigSource, Session, SessionPermissionMode } from '@vibe-forge/core';
+import type { ChannelBaseConfig, ChannelConnection, ChannelFollowUp, ChannelInboundEvent, ChannelSendResult } from '@vibe-forge/core/channel';
+import type { LanguageCode, MessageArgs, MessageCatalog } from '../i18n';
+export interface ChannelTextMessage {
+    receiveId: string;
+    receiveIdType: string;
+    text: string;
+}
+export interface ChannelContext {
+    channelKey: string;
+    configSource?: ConfigSource;
+    inbound: ChannelInboundEvent;
+    connection: ChannelConnection<ChannelTextMessage> | undefined;
+    config: ChannelBaseConfig | undefined;
+    /** Resolved from DB before running the middleware chain */
+    sessionId: string | undefined;
+    /** Channel-level preferred adapter used when the next session is created */
+    channelAdapter: string | undefined;
+    /** Channel-level preferred permission mode used when the next session is created */
+    channelPermissionMode: SessionPermissionMode | undefined;
+    /** Parsed rich content items from inbound.raw, if any */
+    contentItems: ChatMessageContent[] | undefined;
+    /** Normalized text stripped of @-tags and speaker prefixes, used for command matching */
+    commandText: string;
+    /** Register i18n messages into the shared middleware catalog */
+    defineMessages: (lang: LanguageCode, messages: MessageCatalog) => void;
+    /** Translate an i18n key using the channel's configured language */
+    t: (key: string, args?: MessageArgs) => string;
+    /** Send a text reply back to the channel; no-op when connection is unavailable */
+    reply: (text: string) => Promise<ChannelSendResult | undefined>;
+    /** Attach follow-up bubbles below a sent message when the channel supports it */
+    pushFollowUps: (input: {
+        messageId?: string;
+        followUps: readonly ChannelFollowUp[];
+    }) => Promise<void>;
+    /** Get the session bound to the current channel, or undefined */
+    getBoundSession: () => Session | undefined;
+    /** Archive and unbind the current session */
+    resetSession: () => void;
+    /** Stop the running session (kill the process) */
+    stopSession: () => void;
+    /** Restart the current session (kill + start) */
+    restartSession: () => Promise<void>;
+    /** Update session fields in DB */
+    updateSession: (updates: Partial<Pick<Session, 'model' | 'adapter' | 'permissionMode'>>) => void;
+    /** Read the adapter preference for the next session created in this channel */
+    getChannelAdapterPreference: () => string | undefined;
+    /** Persist the adapter preference for the next session created in this channel */
+    setChannelAdapterPreference: (adapter: string | undefined) => void;
+    /** Read the permission mode preference for the next session created in this channel */
+    getChannelPermissionModePreference: () => SessionPermissionMode | undefined;
+    /** Persist the permission mode preference for the next session created in this channel */
+    setChannelPermissionModePreference: (permissionMode: SessionPermissionMode | undefined) => void;
+}
+export type ChannelMiddleware = (ctx: ChannelContext, next: () => Promise<void>) => Promise<void>;

package/dist/apps/server/src/channels/middleware/@types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/apps/server/src/channels/middleware/@utils/index.d.ts

@@ -0,0 +1,5 @@
+import type { ChatMessageContent } from '@vibe-forge/core';
+import type { ChannelInboundEvent } from '@vibe-forge/core/channel';
+export declare const stripSpeakerPrefix: (text: string) => string;
+export declare const stripLeadingAtTags: (text: string) => string;
+export declare const getInboundContentItems: (inbound: ChannelInboundEvent) => ChatMessageContent[] | undefined;

package/dist/apps/server/src/channels/middleware/@utils/index.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInboundContentItems = exports.stripLeadingAtTags = exports.stripSpeakerPrefix = void 0;
+const stripSpeakerPrefix = (text) => {
+    const lines = text.split('\n');
+    if (lines.length < 2)
+        return text;
+    if (/^\[[^\]]+\]\s*:\s*$/.test(lines[0]?.trim() ?? '')) {
+        return lines.slice(1).join('\n');
+    }
+    return text;
+};
+exports.stripSpeakerPrefix = stripSpeakerPrefix;
+const stripLeadingAtTags = (text) => {
+    let result = text;
+    while (true) {
+        const trimmed = result.trimStart();
+        if (!trimmed.startsWith('<at '))
+            return result;
+        const endIndex = trimmed.indexOf('</at>');
+        if (endIndex < 0)
+            return result;
+        result = trimmed.slice(endIndex + '</at>'.length);
+    }
+};
+exports.stripLeadingAtTags = stripLeadingAtTags;
+const isRecord = (value) => {
+    return typeof value === 'object' && value != null;
+};
+const isChatMessageContent = (value) => {
+    if (!isRecord(value))
+        return false;
+    const type = value.type;
+    if (type === 'text') {
+        return typeof value.text === 'string';
+    }
+    if (type === 'image') {
+        return typeof value.url === 'string' &&
+            (value.name == null || typeof value.name === 'string') &&
+            (value.size == null || typeof value.size === 'number') &&
+            (value.mimeType == null || typeof value.mimeType === 'string');
+    }
+    if (type === 'tool_use') {
+        return typeof value.id === 'string' && typeof value.name === 'string';
+    }
+    if (type === 'tool_result') {
+        return typeof value.tool_use_id === 'string' &&
+            (value.is_error == null || typeof value.is_error === 'boolean');
+    }
+    return false;
+};
+const getInboundContentItems = (inbound) => {
+    const raw = inbound.raw;
+    if (!isRecord(raw))
+        return undefined;
+    const maybe = raw.contentItems;
+    if (!Array.isArray(maybe))
+        return undefined;
+    const items = [];
+    for (const item of maybe) {
+        if (!isChatMessageContent(item))
+            return undefined;
+        items.push(item);
+    }
+    return items;
+};
+exports.getInboundContentItems = getInboundContentItems;

package/dist/apps/server/src/channels/middleware/access-control.d.ts

@@ -0,0 +1,4 @@
+import type { ChannelBaseConfig, ChannelInboundEvent } from '@vibe-forge/core/channel';
+import type { ChannelMiddleware } from './@types';
+export declare const checkChannelAccess: (inbound: ChannelInboundEvent, config: ChannelBaseConfig | undefined) => boolean;
+export declare const accessControlMiddleware: ChannelMiddleware;

package/dist/apps/server/src/channels/middleware/access-control.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.accessControlMiddleware = exports.checkChannelAccess = void 0;
+const checkChannelAccess = (inbound, config) => {
+    if (!config)
+        return true;
+    const access = config.access;
+    if (!access)
+        return true;
+    const senderId = inbound.senderId;
+    // Admins bypass all access controls
+    if (senderId && access.admins && access.admins.includes(senderId))
+        return true;
+    // Check chat type permissions (default: both allowed)
+    if (inbound.sessionType === 'direct' && access.allowPrivateChat === false)
+        return false;
+    if (inbound.sessionType === 'group' && access.allowGroupChat === false)
+        return false;
+    // Group-level whitelist / blacklist (only applies to group messages)
+    if (inbound.sessionType === 'group') {
+        const channelId = inbound.channelId;
+        if (access.blockedGroups && access.blockedGroups.includes(channelId))
+            return false;
+        if (access.allowedGroups && access.allowedGroups.length > 0 && !access.allowedGroups.includes(channelId)) {
+            return false;
+        }
+    }
+    // Sender blacklist (takes priority over whitelist)
+    if (senderId && access.blockedSenders && access.blockedSenders.includes(senderId))
+        return false;
+    // Sender whitelist
+    if (access.allowedSenders && access.allowedSenders.length > 0) {
+        if (!senderId || !access.allowedSenders.includes(senderId))
+            return false;
+    }
+    return true;
+};
+exports.checkChannelAccess = checkChannelAccess;
+const accessControlMiddleware = async (ctx, next) => {
+    if (!(0, exports.checkChannelAccess)(ctx.inbound, ctx.config))
+        return;
+    await next();
+};
+exports.accessControlMiddleware = accessControlMiddleware;

package/dist/apps/server/src/channels/middleware/ack.d.ts

@@ -0,0 +1,2 @@
+import type { ChannelMiddleware } from './@types';
+export declare const ackMiddleware: ChannelMiddleware;

package/dist/apps/server/src/channels/middleware/ack.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ackMiddleware = void 0;
+const ackMiddleware = async (ctx, next) => {
+    await ctx.inbound.ack?.().catch(() => undefined);
+    await next();
+};
+exports.ackMiddleware = ackMiddleware;

package/dist/apps/server/src/channels/middleware/admin-gate.d.ts

@@ -0,0 +1,2 @@
+import type { ChannelMiddleware } from './@types';
+export declare const adminGateMiddleware: ChannelMiddleware;

package/dist/apps/server/src/channels/middleware/admin-gate.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adminGateMiddleware = void 0;
+const adminGateMiddleware = async (ctx, next) => {
+    // Already has a session — no gate needed
+    if (ctx.sessionId) {
+        await next();
+        return;
+    }
+    const admins = ctx.config?.access?.admins;
+    if (admins && admins.length > 0) {
+        const senderId = ctx.inbound.senderId;
+        if (!senderId || !admins.includes(senderId)) {
+            await ctx.reply('当前频道尚未初始化会话，请联系管理员发起对话。');
+            return;
+        }
+    }
+    await next();
+};
+exports.adminGateMiddleware = adminGateMiddleware;

package/dist/apps/server/src/channels/middleware/bind-session.d.ts

@@ -0,0 +1,2 @@
+import type { ChannelMiddleware } from './@types';
+export declare const bindSessionMiddleware: ChannelMiddleware;