@vibe-forge/tsconfigs 0.7.1 → 0.8.0

package/dist/apps/server/src/channels/middleware/commands/command-system.d.ts

@@ -0,0 +1,97 @@
+type CommandArgumentParser<TValue> = (value: string) => TValue;
+export interface CommandArgumentChoice<TValue extends string = string> {
+    readonly value: TValue;
+    readonly title: string;
+    readonly description?: string;
+}
+type CommandArgumentChoices = readonly CommandArgumentChoice[];
+interface BaseArgumentSpec<TValue> {
+    readonly name: string;
+    readonly description?: string;
+    readonly parse: CommandArgumentParser<TValue>;
+    readonly choices?: CommandArgumentChoices;
+}
+export interface RequiredArgumentSpec<TValue> extends BaseArgumentSpec<TValue> {
+    readonly kind: 'required';
+}
+export interface OptionalArgumentSpec<TValue> extends BaseArgumentSpec<TValue> {
+    readonly kind: 'optional';
+}
+export interface VariadicArgumentSpec<TValue> extends BaseArgumentSpec<TValue> {
+    readonly kind: 'variadic';
+}
+export interface RestArgumentSpec<TValue> extends BaseArgumentSpec<TValue> {
+    readonly kind: 'rest';
+}
+export type CommandArgumentSpec<TValue = unknown> = RequiredArgumentSpec<TValue> | OptionalArgumentSpec<TValue> | VariadicArgumentSpec<TValue> | RestArgumentSpec<TValue>;
+type InferArgumentValue<TArgument extends CommandArgumentSpec> = TArgument extends RequiredArgumentSpec<infer TValue> ? TValue : TArgument extends OptionalArgumentSpec<infer TValue> ? TValue | undefined : TArgument extends VariadicArgumentSpec<infer TValue> ? TValue[] : TArgument extends RestArgumentSpec<infer TValue> ? TValue : never;
+export type InferArgumentValues<TArgs extends readonly CommandArgumentSpec[]> = {
+    [K in keyof TArgs]: TArgs[K] extends CommandArgumentSpec ? InferArgumentValue<TArgs[K]> : never;
+};
+interface ParserArgumentOptions<TValue> {
+    description?: string;
+    parse?: CommandArgumentParser<TValue>;
+}
+interface ChoiceArgumentOptions<TChoices extends readonly CommandArgumentChoice[]> {
+    description?: string;
+    choices: TChoices;
+}
+export declare function requiredArg<const TChoices extends readonly CommandArgumentChoice[]>(name: string, options: ChoiceArgumentOptions<TChoices>): RequiredArgumentSpec<TChoices[number]['value']>;
+export declare function requiredArg<TValue = string>(name: string, options?: ParserArgumentOptions<TValue>): RequiredArgumentSpec<TValue>;
+export declare function optionalArg<const TChoices extends readonly CommandArgumentChoice[]>(name: string, options: ChoiceArgumentOptions<TChoices>): OptionalArgumentSpec<TChoices[number]['value']>;
+export declare function optionalArg<TValue = string>(name: string, options?: ParserArgumentOptions<TValue>): OptionalArgumentSpec<TValue>;
+export declare function variadicArg<const TChoices extends readonly CommandArgumentChoice[]>(name: string, options: ChoiceArgumentOptions<TChoices>): VariadicArgumentSpec<TChoices[number]['value']>;
+export declare function variadicArg<TValue = string>(name: string, options?: ParserArgumentOptions<TValue>): VariadicArgumentSpec<TValue>;
+export declare function restArg<const TChoices extends readonly CommandArgumentChoice[]>(name: string, options: ChoiceArgumentOptions<TChoices>): RestArgumentSpec<TChoices[number]['value']>;
+export declare function restArg<TValue = string>(name: string, options?: ParserArgumentOptions<TValue>): RestArgumentSpec<TValue>;
+type MaybePromise<TValue> = TValue | Promise<TValue>;
+export type PermissionLevel = 'everyone' | 'admin';
+export interface CommandActionInput<TContext, TArgs extends readonly CommandArgumentSpec[]> {
+    readonly ctx: TContext;
+    readonly args: InferArgumentValues<TArgs>;
+    readonly rawArgs: readonly string[];
+    readonly commandPath: readonly string[];
+    readonly usage: string;
+}
+export interface CommandSpec<TContext, TArgs extends readonly CommandArgumentSpec[] = readonly CommandArgumentSpec[]> {
+    readonly name: string;
+    readonly aliases: readonly string[];
+    readonly descriptionKey: string | undefined;
+    readonly permission: PermissionLevel;
+    readonly args: TArgs;
+    readonly subcommands: readonly AnyCommandSpec<TContext>[];
+    readonly action: ((input: CommandActionInput<TContext, TArgs>) => MaybePromise<void>) | undefined;
+}
+export type AnyCommandSpec<TContext> = CommandSpec<TContext, any>;
+export interface CommandBuilder<TContext, TArgs extends readonly CommandArgumentSpec[]> {
+    alias(...aliases: string[]): CommandBuilder<TContext, TArgs>;
+    description(key: string): CommandBuilder<TContext, TArgs>;
+    adminOnly(): CommandBuilder<TContext, TArgs>;
+    argument<TSpec extends CommandArgumentSpec>(arg: TSpec): CommandBuilder<TContext, readonly [...TArgs, TSpec]>;
+    subcommand(sub: AnyCommandSpec<TContext>): CommandBuilder<TContext, TArgs>;
+    action(fn: (input: CommandActionInput<TContext, TArgs>) => MaybePromise<void>): CommandSpec<TContext, TArgs>;
+    build(): CommandSpec<TContext, TArgs>;
+}
+export declare const command: <TContext>(name: string) => CommandBuilder<TContext, readonly []>;
+type CommandParseErrorCode = 'unknown-command' | 'missing-subcommand' | 'unknown-subcommand' | 'missing-argument' | 'too-many-arguments' | 'invalid-argument';
+export interface CommandParseError {
+    readonly ok: false;
+    readonly code: CommandParseErrorCode;
+    readonly message: string;
+    readonly usage?: string;
+}
+export interface CommandParseSuccess<TContext> {
+    readonly ok: true;
+    readonly command: AnyCommandSpec<TContext>;
+    readonly args: readonly unknown[];
+    readonly rawArgs: readonly string[];
+    readonly commandPath: readonly string[];
+    readonly usage: string;
+}
+export type CommandParseResult<TContext> = CommandParseError | CommandParseSuccess<TContext>;
+export declare const formatUsage: <TContext>(cmd: AnyCommandSpec<TContext>, ancestors?: readonly string[], prefix?: string) => string;
+export declare const parseCommandString: <TContext>(commands: readonly AnyCommandSpec<TContext>[], input: string, opts?: {
+    t?: (key: string, args?: Record<string, string | number | boolean | undefined>) => string;
+    prefix?: string;
+}) => CommandParseResult<TContext>;
+export {};

package/dist/apps/server/src/channels/middleware/commands/command-system.js

@@ -0,0 +1,312 @@
+"use strict";
+// ── Argument types ──────────────────────────────────────────────────────────
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCommandString = exports.formatUsage = exports.command = void 0;
+exports.requiredArg = requiredArg;
+exports.optionalArg = optionalArg;
+exports.variadicArg = variadicArg;
+exports.restArg = restArg;
+// ── Argument builders ───────────────────────────────────────────────────────
+const identity = (value) => value;
+const createChoiceParser = (choices) => {
+    return (value) => {
+        const match = choices.find(choice => choice.value === value);
+        if (match)
+            return match.value;
+        throw new Error(`Invalid value: ${value}. Supported: ${choices.map(choice => choice.value).join(', ')}`);
+    };
+};
+const resolveArgumentConfig = (options) => ({
+    description: options.description,
+    parse: options.parse ?? identity,
+    choices: undefined
+});
+const resolveChoiceArgumentConfig = (options) => ({
+    description: options.description,
+    parse: createChoiceParser(options.choices),
+    choices: options.choices
+});
+function requiredArg(name, options = {}) {
+    const config = 'choices' in options ? resolveChoiceArgumentConfig(options) : resolveArgumentConfig(options);
+    return {
+        kind: 'required',
+        name,
+        description: config.description,
+        parse: config.parse,
+        choices: config.choices
+    };
+}
+function optionalArg(name, options = {}) {
+    const config = 'choices' in options ? resolveChoiceArgumentConfig(options) : resolveArgumentConfig(options);
+    return {
+        kind: 'optional',
+        name,
+        description: config.description,
+        parse: config.parse,
+        choices: config.choices
+    };
+}
+function variadicArg(name, options = {}) {
+    const config = 'choices' in options ? resolveChoiceArgumentConfig(options) : resolveArgumentConfig(options);
+    return {
+        kind: 'variadic',
+        name,
+        description: config.description,
+        parse: config.parse,
+        choices: config.choices
+    };
+}
+function restArg(name, options = {}) {
+    const config = 'choices' in options ? resolveChoiceArgumentConfig(options) : resolveArgumentConfig(options);
+    return {
+        kind: 'rest',
+        name,
+        description: config.description,
+        parse: config.parse,
+        choices: config.choices
+    };
+}
+const command = (name) => {
+    const state = {
+        name,
+        aliases: [],
+        descriptionKey: undefined,
+        permission: 'everyone',
+        args: [],
+        subcommands: [],
+        action: undefined
+    };
+    const freeze = () => ({
+        name: state.name,
+        aliases: state.aliases,
+        descriptionKey: state.descriptionKey,
+        permission: state.permission,
+        args: state.args,
+        subcommands: state.subcommands,
+        action: state.action
+    });
+    const builder = {
+        alias(...aliases) {
+            state.aliases.push(...aliases);
+            return builder;
+        },
+        description(key) {
+            state.descriptionKey = key;
+            return builder;
+        },
+        adminOnly() {
+            state.permission = 'admin';
+            return builder;
+        },
+        argument(arg) {
+            state.args.push(arg);
+            return builder;
+        },
+        subcommand(sub) {
+            state.subcommands.push(sub);
+            return builder;
+        },
+        action(fn) {
+            state.action = fn;
+            return freeze();
+        },
+        build() {
+            return freeze();
+        }
+    };
+    return builder;
+};
+exports.command = command;
+const formatArgumentUsage = (argument) => {
+    const choiceSuffix = argument.choices && argument.choices.length > 0
+        ? `:${argument.choices.map(choice => choice.value).join('|')}`
+        : '';
+    switch (argument.kind) {
+        case 'required':
+            return `<${argument.name}${choiceSuffix}>`;
+        case 'optional':
+            return `[${argument.name}${choiceSuffix}]`;
+        case 'variadic':
+            return `<${argument.name}${choiceSuffix}...>`;
+        case 'rest':
+            return `<${argument.name}${choiceSuffix}>`;
+    }
+};
+const joinPath = (segments) => segments.join(' ');
+const formatChoiceSummary = (choices, translate) => choices
+    .map(choice => `${choice.value}(${translate(choice.title)})`)
+    .join(', ');
+const formatChoiceGuidance = (choices, translate) => choices.map((choice) => {
+    const title = translate(choice.title);
+    const description = choice.description ? translate(choice.description) : '';
+    return `- ${choice.value}：${title}${description ? `，${description}` : ''}`;
+});
+const formatChoiceErrorMessage = (rawValue, choices, translate) => {
+    const summary = formatChoiceSummary(choices, translate);
+    const guidance = formatChoiceGuidance(choices, translate);
+    return `${translate('system.choiceError', { value: rawValue, choices: summary })}\n${translate('label.choices')}：\n${guidance.join('\n')}`;
+};
+const formatMissingArgumentMessage = (spec, translate) => {
+    const base = translate('system.missingArgument', { name: spec.name });
+    if (!spec.choices || spec.choices.length === 0) {
+        return base;
+    }
+    return `${base}\n${translate('label.choices')}：\n${formatChoiceGuidance(spec.choices, translate).join('\n')}`;
+};
+const matchesName = (cmd, token) => cmd.name === token || cmd.aliases.includes(token);
+const parseArgValue = (spec, rawValue, translate) => {
+    if (spec.choices && spec.choices.length > 0) {
+        const matched = spec.choices.find(choice => choice.value === rawValue);
+        if (matched) {
+            return { ok: true, value: matched.value };
+        }
+        return { ok: false, message: formatChoiceErrorMessage(rawValue, spec.choices, translate) };
+    }
+    try {
+        return { ok: true, value: spec.parse(rawValue) };
+    }
+    catch (error) {
+        return { ok: false, message: error instanceof Error ? error.message : String(error) };
+    }
+};
+const formatUsage = (cmd, ancestors = [], prefix = '/') => {
+    const name = ancestors.length === 0 ? `${prefix}${cmd.name}` : cmd.name;
+    const path = [...ancestors, name];
+    const args = cmd.args.map(formatArgumentUsage);
+    return joinPath([...path, ...args]);
+};
+exports.formatUsage = formatUsage;
+// ── Parse command string ────────────────────────────────────────────────────
+const parseCommandString = (commands, input, opts = {}) => {
+    const { t: translate = (key) => key, prefix = '/' } = opts;
+    const tokens = input.trim().split(/\s+/).filter(Boolean);
+    const rootToken = tokens[0];
+    if (!rootToken) {
+        return { ok: false, code: 'unknown-command', message: translate('system.emptyCommand') };
+    }
+    const stripped = rootToken.startsWith(prefix) ? rootToken.slice(prefix.length) : rootToken;
+    const rootCommand = commands.find(cmd => matchesName(cmd, stripped));
+    if (!rootCommand) {
+        return { ok: false, code: 'unknown-command', message: translate('system.unknownCommand', { token: rootToken }) };
+    }
+    let current = rootCommand;
+    let commandPath = [`${prefix}${rootCommand.name}`];
+    let index = 1;
+    while (true) {
+        const nextToken = tokens[index];
+        if (!nextToken)
+            break;
+        const nextCommand = current.subcommands.find(cmd => matchesName(cmd, nextToken));
+        if (!nextCommand)
+            break;
+        current = nextCommand;
+        commandPath = [...commandPath, nextCommand.name];
+        index += 1;
+    }
+    if (current.subcommands.length > 0 && current.action == null) {
+        const nextToken = tokens[index];
+        const usage = (0, exports.formatUsage)(current, commandPath.slice(0, -1), prefix);
+        if (!nextToken) {
+            return {
+                ok: false,
+                code: 'missing-subcommand',
+                message: translate('system.missingSubcommand', { path: joinPath(commandPath) }),
+                usage
+            };
+        }
+        return {
+            ok: false,
+            code: 'unknown-subcommand',
+            message: translate('system.unknownSubcommand', { token: nextToken }),
+            usage
+        };
+    }
+    const argSpecs = current.args;
+    const rawArgs = tokens.slice(index);
+    const parsedValues = [];
+    let rawIndex = 0;
+    for (const spec of argSpecs) {
+        if (spec.kind === 'variadic') {
+            const values = [];
+            while (rawIndex < rawArgs.length) {
+                const parsed = parseArgValue(spec, rawArgs[rawIndex], translate);
+                if (!parsed.ok) {
+                    return {
+                        ok: false,
+                        code: 'invalid-argument',
+                        message: parsed.message,
+                        usage: (0, exports.formatUsage)(current, commandPath.slice(0, -1), prefix)
+                    };
+                }
+                values.push(parsed.value);
+                rawIndex += 1;
+            }
+            parsedValues.push(values);
+            continue;
+        }
+        if (spec.kind === 'rest') {
+            const rawValue = rawArgs.slice(rawIndex).join(' ');
+            if (rawValue === '') {
+                return {
+                    ok: false,
+                    code: 'missing-argument',
+                    message: formatMissingArgumentMessage(spec, translate),
+                    usage: (0, exports.formatUsage)(current, commandPath.slice(0, -1), prefix)
+                };
+            }
+            const parsed = parseArgValue(spec, rawValue, translate);
+            if (!parsed.ok) {
+                return {
+                    ok: false,
+                    code: 'invalid-argument',
+                    message: parsed.message,
+                    usage: (0, exports.formatUsage)(current, commandPath.slice(0, -1), prefix)
+                };
+            }
+            parsedValues.push(parsed.value);
+            rawIndex = rawArgs.length;
+            continue;
+        }
+        const rawValue = rawArgs[rawIndex];
+        if (rawValue == null) {
+            if (spec.kind === 'optional') {
+                parsedValues.push(undefined);
+                continue;
+            }
+            return {
+                ok: false,
+                code: 'missing-argument',
+                message: formatMissingArgumentMessage(spec, translate),
+                usage: (0, exports.formatUsage)(current, commandPath.slice(0, -1), prefix)
+            };
+        }
+        const parsed = parseArgValue(spec, rawValue, translate);
+        if (!parsed.ok) {
+            return {
+                ok: false,
+                code: 'invalid-argument',
+                message: parsed.message,
+                usage: (0, exports.formatUsage)(current, commandPath.slice(0, -1), prefix)
+            };
+        }
+        parsedValues.push(parsed.value);
+        rawIndex += 1;
+    }
+    if (rawIndex < rawArgs.length) {
+        return {
+            ok: false,
+            code: 'too-many-arguments',
+            message: translate('system.tooManyArguments', { extra: rawArgs.slice(rawIndex).join(' ') }),
+            usage: (0, exports.formatUsage)(current, commandPath.slice(0, -1), prefix)
+        };
+    }
+    return {
+        ok: true,
+        command: current,
+        args: parsedValues,
+        rawArgs,
+        commandPath,
+        usage: (0, exports.formatUsage)(current, commandPath.slice(0, -1), prefix)
+    };
+};
+exports.parseCommandString = parseCommandString;

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

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

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

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.channelCommandMiddleware = void 0;
+const i18n_1 = require("../i18n");
+const access_1 = require("./access");
+const cmd_access_1 = require("./cmd.access");
+const cmd_general_1 = require("./cmd.general");
+const cmd_session_1 = require("./cmd.session");
+const command_system_1 = require("./command-system");
+const utils_1 = require("./utils");
+let _sharedMessagesRegistered = false;
+const ensureSharedMessagesRegistered = (ctx) => {
+    if (_sharedMessagesRegistered)
+        return;
+    const register = ctx.defineMessages ?? i18n_1.defineMessages;
+    register('zh', {
+        'system.unknownCommand': ({ token }) => `未知指令：${token}`,
+        'system.emptyCommand': '空指令。',
+        'system.missingSubcommand': ({ path }) => `缺少子指令：${path}`,
+        'system.unknownSubcommand': ({ token }) => `未知子指令：${token}`,
+        'system.missingArgument': ({ name }) => `缺少参数：<${name}>`,
+        'system.tooManyArguments': ({ extra }) => `参数过多：${extra}`,
+        'system.invalidArgument': ({ message }) => `${message}`,
+        'system.usage': ({ usage }) => `用法：${usage}`,
+        'system.helpHint': '请发送 {prefix}help 查看支持的命令。',
+        'system.executionFailed': '指令执行失败，请稍后重试。',
+        'system.noPermission': '您没有权限执行该操作，只有管理员才能执行该指令。',
+        'system.supportedCommands': '支持的指令：',
+        'system.choiceError': ({ value, choices }) => `参数值无效：${value}。支持：${choices}`,
+        'label.usage': '用法',
+        'label.arguments': '参数',
+        'label.choices': '可选值',
+        'label.description': '说明',
+        'label.aliases': '别名',
+        'label.subcommands': '子指令',
+        'label.none': '无',
+        'label.yes': '是',
+        'label.no': '否',
+        'label.admin': '管理员',
+        'label.user': '普通用户',
+        'label.group': '群聊',
+        'label.direct': '私聊',
+        'label.notSet': '未设置',
+        'label.unnamed': '未命名会话'
+    });
+    register('en', {
+        'system.unknownCommand': ({ token }) => `Unknown command: ${token}`,
+        'system.emptyCommand': 'Empty command.',
+        'system.missingSubcommand': ({ path }) => `Missing subcommand: ${path}`,
+        'system.unknownSubcommand': ({ token }) => `Unknown subcommand: ${token}`,
+        'system.missingArgument': ({ name }) => `Missing argument: <${name}>`,
+        'system.tooManyArguments': ({ extra }) => `Too many arguments: ${extra}`,
+        'system.invalidArgument': ({ message }) => `${message}`,
+        'system.usage': ({ usage }) => `Usage: ${usage}`,
+        'system.helpHint': 'Send {prefix}help to see available commands.',
+        'system.executionFailed': 'Command execution failed, please try again later.',
+        'system.noPermission': 'You do not have permission. Only admins can execute this command.',
+        'system.supportedCommands': 'Available commands:',
+        'system.choiceError': ({ value, choices }) => `Invalid value: ${value}. Supported: ${choices}`,
+        'label.usage': 'Usage',
+        'label.arguments': 'Arguments',
+        'label.choices': 'Choices',
+        'label.description': 'Description',
+        'label.aliases': 'Aliases',
+        'label.subcommands': 'Subcommands',
+        'label.none': 'None',
+        'label.yes': 'Yes',
+        'label.no': 'No',
+        'label.admin': 'Admin',
+        'label.user': 'User',
+        'label.group': 'Group',
+        'label.direct': 'Direct',
+        'label.notSet': 'Not set',
+        'label.unnamed': 'Unnamed session'
+    });
+    _sharedMessagesRegistered = true;
+};
+const getPrefix = (ctx) => ctx.config?.commandPrefix ?? '/';
+let _allCommands;
+const getAllCommands = () => {
+    if (_allCommands)
+        return _allCommands;
+    _allCommands = [
+        ...(0, cmd_general_1.generalCommands)(getPrefix, getAllCommands),
+        ...(0, cmd_session_1.sessionCommands)(),
+        ...(0, cmd_access_1.accessCommands)()
+    ];
+    return _allCommands;
+};
+const formatParseError = (ctx, prefix, message, usage) => {
+    if (!usage) {
+        return `${message}\n${ctx.t('system.helpHint').replace('{prefix}', prefix)}`;
+    }
+    return `${message}\n${ctx.t('label.usage')}：${usage}`;
+};
+const handleCommand = async (ctx) => {
+    const prefix = getPrefix(ctx);
+    const commands = getAllCommands();
+    const parsed = (0, command_system_1.parseCommandString)(commands, ctx.commandText, { t: ctx.t, prefix });
+    if (!parsed.ok) {
+        if (parsed.code === 'unknown-command')
+            return false;
+        await ctx.reply(formatParseError(ctx, prefix, parsed.message, parsed.usage));
+        return true;
+    }
+    if (parsed.command.permission === 'admin' && !(0, access_1.isAdmin)(ctx)) {
+        await ctx.reply(ctx.t('system.noPermission'));
+        return true;
+    }
+    await parsed.command.action?.({
+        ctx,
+        args: [...parsed.args],
+        rawArgs: parsed.rawArgs,
+        commandPath: parsed.commandPath,
+        usage: parsed.usage
+    });
+    return true;
+};
+const channelCommandMiddleware = async (ctx, next) => {
+    ensureSharedMessagesRegistered(ctx);
+    const prefix = getPrefix(ctx);
+    const command = (0, utils_1.splitCommand)(ctx.commandText)[0] ?? '';
+    if (command === '' || !command.startsWith(prefix)) {
+        await next();
+        return;
+    }
+    await ctx.inbound.ack?.().catch(() => undefined);
+    const handled = await handleCommand(ctx).catch(async (error) => {
+        console.error('[channels] command execution failed:', error);
+        await ctx.reply(ctx.t('system.executionFailed'));
+        return true;
+    });
+    await ctx.inbound.unack?.().catch(() => undefined);
+    if (!handled) {
+        await next();
+    }
+};
+exports.channelCommandMiddleware = channelCommandMiddleware;

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

@@ -0,0 +1,2 @@
+export declare const splitCommand: (commandText: string) => string[];
+export declare const dedupe: (items: string[]) => string[];

package/dist/apps/server/src/channels/middleware/commands/utils.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dedupe = exports.splitCommand = void 0;
+const splitCommand = (commandText) => commandText.trim().split(/\s+/).filter(Boolean);
+exports.splitCommand = splitCommand;
+const dedupe = (items) => Array.from(new Set(items.filter(item => item !== '')));
+exports.dedupe = dedupe;

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

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

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deduplicateMiddleware = void 0;
+const state_1 = require("../state");
+const deduplicateMiddleware = async (ctx, next) => {
+    const { inbound } = ctx;
+    if ((0, state_1.isDuplicateMessage)(`${inbound.channelType}:${inbound.sessionType}:${inbound.channelId}:${inbound.messageId}`)) {
+        return;
+    }
+    await next();
+};
+exports.deduplicateMiddleware = deduplicateMiddleware;

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

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

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

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dispatchMiddleware = void 0;
+const create_js_1 = require("#~/services/session/create.js");
+const index_js_1 = require("#~/services/session/index.js");
+const _utils_1 = require("../@utils");
+const prompt_1 = require("./prompt");
+const buildChannelTags = (inbound) => {
+    if (inbound.sessionType === 'direct' && inbound.senderId) {
+        return [`channel:${inbound.channelType}:direct:${inbound.senderId}`];
+    }
+    if (inbound.sessionType === 'group') {
+        return [`channel:${inbound.channelType}:group:${inbound.channelId}`];
+    }
+    return [];
+};
+const dispatchMiddleware = async (ctx, next) => {
+    const { inbound, connection, config } = ctx;
+    const hasContent = ctx.contentItems != null && ctx.contentItems.length > 0;
+    if (!ctx.sessionId) {
+        const session = await (0, create_js_1.createSessionWithInitialMessage)({
+            title: (0, _utils_1.stripSpeakerPrefix)(inbound.text ?? '').split('\n')[0],
+            initialMessage: hasContent ? undefined : inbound.text,
+            initialContent: hasContent ? ctx.contentItems : undefined,
+            shouldStart: true,
+            adapter: ctx.channelAdapter,
+            permissionMode: ctx.channelPermissionMode,
+            tags: buildChannelTags(inbound),
+            systemPrompt: await (0, prompt_1.buildSessionSystemPrompt)(inbound, config, connection)
+        });
+        ctx.sessionId = session.id;
+    }
+    else {
+        (0, index_js_1.processUserMessage)(ctx.sessionId, hasContent ? ctx.contentItems : inbound.text ?? '');
+    }
+    await next();
+};
+exports.dispatchMiddleware = dispatchMiddleware;

package/dist/apps/server/src/channels/middleware/dispatch/prompt/agent-rules.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Tries to load `AGENTS.channel.<channelType>.md` from:
+ *   1. <projectRoot>/AGENTS.channel.<channelType>.md
+ *   2. <projectRoot>/.ai/rules/AGENTS.channel.<channelType>.md
+ * Returns the first file found, or undefined.
+ */
+export declare const loadChannelAgentRules: (channelType: string) => Promise<string | undefined>;

package/dist/apps/server/src/channels/middleware/dispatch/prompt/agent-rules.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadChannelAgentRules = void 0;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const node_process_1 = require("node:process");
+/**
+ * Tries to load `AGENTS.channel.<channelType>.md` from:
+ *   1. <projectRoot>/AGENTS.channel.<channelType>.md
+ *   2. <projectRoot>/.ai/rules/AGENTS.channel.<channelType>.md
+ * Returns the first file found, or undefined.
+ */
+const loadChannelAgentRules = async (channelType) => {
+    const filename = `AGENTS.channel.${channelType}.md`;
+    const root = node_process_1.env.__VF_PROJECT_WORKSPACE_FOLDER__ ?? (0, node_process_1.cwd)();
+    const candidates = [
+        (0, node_path_1.join)(root, filename),
+        (0, node_path_1.join)(root, '.ai', 'rules', filename)
+    ];
+    for (const candidate of candidates) {
+        try {
+            const content = await (0, promises_1.readFile)(candidate, 'utf8');
+            if (content.trim())
+                return content.trim();
+        }
+        catch {
+            // file not found — try next candidate
+        }
+    }
+    return undefined;
+};
+exports.loadChannelAgentRules = loadChannelAgentRules;

package/dist/apps/server/src/channels/middleware/dispatch/prompt/context.d.ts

@@ -0,0 +1,2 @@
+import type { ChannelBaseConfig, ChannelInboundEvent } from '@vibe-forge/core/channel';
+export declare const buildChannelContextPrompt: (inbound: ChannelInboundEvent, config: ChannelBaseConfig | undefined) => string | undefined;