aws-runtime-bridge 1.7.48 → 1.7.50

package/package/acode/dist/built-in-file-tools.js

@@ -0,0 +1,231 @@
+import { randomUUID } from 'node:crypto';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+function toDisplayPath(targetPath) {
+    return targetPath.replace(/\\/g, '/');
+}
+async function pathExists(targetPath) {
+    try {
+        await fs.access(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function countOccurrences(content, search) {
+    if (!search) {
+        return 0;
+    }
+    let count = 0;
+    let index = content.indexOf(search);
+    while (index >= 0) {
+        count += 1;
+        index = content.indexOf(search, index + search.length);
+    }
+    return count;
+}
+function readStringArg(args, names, label) {
+    for (const name of names) {
+        const value = args[name];
+        if (typeof value === 'string') {
+            return value;
+        }
+    }
+    throw new Error(`${label} is required`);
+}
+function ensureInsideWorkspace(workspaceRoot, targetPath) {
+    const resolvedTargetPath = path.resolve(targetPath);
+    const relativePath = path.relative(workspaceRoot, resolvedTargetPath);
+    if (relativePath.startsWith('..') || path.isAbsolute(relativePath)) {
+        throw new Error(`Target path is outside workspace: ${resolvedTargetPath}`);
+    }
+    return resolvedTargetPath;
+}
+async function ensureWritableTarget(workspaceRoot, targetPath) {
+    const realParentPath = await fs.realpath(path.dirname(targetPath));
+    ensureInsideWorkspace(workspaceRoot, realParentPath);
+    try {
+        const targetLinkStat = await fs.lstat(targetPath);
+        if (targetLinkStat.isSymbolicLink()) {
+            throw new Error(`Refusing to write through symbolic link: ${targetPath}`);
+        }
+    }
+    catch (error) {
+        const errorCode = typeof error === 'object' && error !== null ? Reflect.get(error, 'code') : undefined;
+        if (errorCode !== 'ENOENT') {
+            throw error;
+        }
+    }
+}
+/**
+ * 解析内置文件工具目标路径。
+ * 主流程：同时校验请求路径与 realpath 工作区边界，防止绝对路径、`..` 与符号链接目录穿透。
+ */
+async function resolveWorkspaceTarget(workingDirectory, rawFilePath) {
+    const requestedRoot = path.resolve(String(workingDirectory || '').trim());
+    const workspaceRoot = await fs.realpath(requestedRoot);
+    const workspaceStat = await fs.stat(workspaceRoot);
+    if (!workspaceStat.isDirectory()) {
+        throw new Error(`Workspace path is not a directory: ${requestedRoot}`);
+    }
+    const normalizedFilePath = rawFilePath.trim();
+    if (!normalizedFilePath) {
+        throw new Error('file_path is required');
+    }
+    const requestedPath = path.isAbsolute(normalizedFilePath)
+        ? path.resolve(normalizedFilePath)
+        : path.resolve(requestedRoot, normalizedFilePath);
+    const requestedRelativePath = path.relative(requestedRoot, requestedPath);
+    if (requestedRelativePath.startsWith('..') || path.isAbsolute(requestedRelativePath)) {
+        throw new Error(`Target path is outside workspace: ${requestedPath}`);
+    }
+    return {
+        workspaceRoot,
+        requestedPath,
+        targetPath: ensureInsideWorkspace(workspaceRoot, path.join(workspaceRoot, requestedRelativePath)),
+    };
+}
+/**
+ * 原子写入完整文件内容。
+ * 主流程：创建父目录 -> 校验 realpath 边界和符号链接 -> 写同目录临时文件 -> rename 覆盖目标。
+ */
+async function writeFileAtomically(workingDirectory, filePath, content) {
+    const target = await resolveWorkspaceTarget(workingDirectory, filePath);
+    const parentPath = path.dirname(target.targetPath);
+    const createdParentDirectory = !(await pathExists(parentPath));
+    await fs.mkdir(parentPath, { recursive: true });
+    await ensureWritableTarget(target.workspaceRoot, target.targetPath);
+    const temporaryPath = path.join(parentPath, `.${path.basename(target.targetPath)}.${process.pid}.${randomUUID()}.tmp`);
+    try {
+        await fs.writeFile(temporaryPath, content, 'utf-8');
+        await fs.rename(temporaryPath, target.targetPath);
+    }
+    catch (error) {
+        await fs.rm(temporaryPath, { force: true });
+        throw error;
+    }
+    return {
+        workspaceRoot: target.workspaceRoot,
+        targetPath: target.targetPath,
+        bytes: Buffer.byteLength(content, 'utf-8'),
+        createdParentDirectory,
+    };
+}
+async function readFileInsideWorkspace(workingDirectory, filePath) {
+    const target = await resolveWorkspaceTarget(workingDirectory, filePath);
+    const realTargetPath = ensureInsideWorkspace(target.workspaceRoot, await fs.realpath(target.targetPath));
+    const stat = await fs.stat(realTargetPath);
+    if (!stat.isFile()) {
+        throw new Error(`Path is not a file: ${realTargetPath}`);
+    }
+    return {
+        workspaceRoot: target.workspaceRoot,
+        targetPath: realTargetPath,
+        content: await fs.readFile(realTargetPath, 'utf-8'),
+    };
+}
+function writeFileTool(workingDirectory) {
+    return {
+        kind: 'builtin',
+        toolName: 'write_file',
+        exposedName: 'write_file',
+        description: 'Create or overwrite a UTF-8 text file inside the current workspace. Parent directories are created automatically.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                file_path: { type: 'string', description: 'Workspace-relative file path to write.' },
+                content: { type: 'string', description: 'Complete UTF-8 file content.' },
+            },
+            required: ['file_path', 'content'],
+            additionalProperties: false,
+        },
+        async execute(args) {
+            const filePath = readStringArg(args, ['file_path', 'filePath'], 'file_path');
+            const content = readStringArg(args, ['content'], 'content');
+            const result = await writeFileAtomically(workingDirectory, filePath, content);
+            return {
+                ok: true,
+                tool: 'write_file',
+                workspacePath: toDisplayPath(result.workspaceRoot),
+                filePath: toDisplayPath(result.targetPath),
+                bytes: result.bytes,
+                createdParentDirectory: result.createdParentDirectory,
+            };
+        },
+    };
+}
+function editFileTool(workingDirectory) {
+    return {
+        kind: 'builtin',
+        toolName: 'edit_file',
+        exposedName: 'edit_file',
+        description: 'Replace exactly one occurrence of old_string with new_string in a UTF-8 workspace text file.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                file_path: { type: 'string', description: 'Workspace-relative file path to edit.' },
+                old_string: { type: 'string', description: 'Existing text to replace. Must occur exactly once.' },
+                new_string: { type: 'string', description: 'Replacement text.' },
+            },
+            required: ['file_path', 'old_string', 'new_string'],
+            additionalProperties: false,
+        },
+        async execute(args) {
+            const filePath = readStringArg(args, ['file_path', 'filePath'], 'file_path');
+            const oldString = readStringArg(args, ['old_string', 'oldString'], 'old_string');
+            const newString = readStringArg(args, ['new_string', 'newString'], 'new_string');
+            if (!oldString) {
+                throw new Error('old_string must not be empty');
+            }
+            const current = await readFileInsideWorkspace(workingDirectory, filePath);
+            const occurrences = countOccurrences(current.content, oldString);
+            if (occurrences === 0) {
+                throw new Error('old_string was not found in file');
+            }
+            if (occurrences > 1) {
+                throw new Error(`old_string occurs ${occurrences} times; provide a unique match`);
+            }
+            const updatedContent = current.content.replace(oldString, newString);
+            const result = await writeFileAtomically(workingDirectory, filePath, updatedContent);
+            return {
+                ok: true,
+                tool: 'edit_file',
+                workspacePath: toDisplayPath(result.workspaceRoot),
+                filePath: toDisplayPath(result.targetPath),
+                replacements: 1,
+                bytes: result.bytes,
+            };
+        },
+    };
+}
+function readFileTool(workingDirectory) {
+    return {
+        kind: 'builtin',
+        toolName: 'read_file',
+        exposedName: 'read_file',
+        description: 'Read a UTF-8 text file inside the current workspace.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                file_path: { type: 'string', description: 'Workspace-relative file path to read.' },
+            },
+            required: ['file_path'],
+            additionalProperties: false,
+        },
+        async execute(args) {
+            const filePath = readStringArg(args, ['file_path', 'filePath'], 'file_path');
+            const result = await readFileInsideWorkspace(workingDirectory, filePath);
+            return {
+                ok: true,
+                tool: 'read_file',
+                workspacePath: toDisplayPath(result.workspaceRoot),
+                filePath: toDisplayPath(result.targetPath),
+                content: result.content,
+            };
+        },
+    };
+}
+export function createBuiltInFileTools(workingDirectory) {
+    return [readFileTool(workingDirectory), writeFileTool(workingDirectory), editFileTool(workingDirectory)];
+}

package/package/acode/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/package/acode/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}

package/package/acode/dist/cli.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+import { randomUUID } from 'node:crypto';
+import path from 'node:path';
+import { ACodeRuntime } from './runtime.js';
+function getFlagValue(args, name) {
+    const index = args.indexOf(name);
+    if (index >= 0) {
+        return args[index + 1];
+    }
+    const prefixed = args.find((arg) => arg.startsWith(`${name}=`));
+    return prefixed ? prefixed.slice(name.length + 1) : undefined;
+}
+async function main() {
+    const args = process.argv.slice(2);
+    const cwd = path.resolve(getFlagValue(args, '--cwd') || process.cwd());
+    const configPath = getFlagValue(args, '--config');
+    const skillsDir = getFlagValue(args, '--skills-dir');
+    const prompt = getFlagValue(args, '--prompt') || args.filter((arg) => !arg.startsWith('--')).join(' ');
+    const runtime = new ACodeRuntime({
+        sessionId: getFlagValue(args, '--session-id') || randomUUID(),
+        workingDirectory: cwd,
+        configPath,
+        skillsDir,
+        initialPrompt: prompt,
+        model: getFlagValue(args, '--model'),
+    });
+    runtime.on('event', (event) => {
+        process.stdout.write(`${JSON.stringify(event)}\n`);
+    });
+    await runtime.start();
+    await runtime.stop();
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`[acode] ${message}\n`);
+    process.exitCode = 1;
+});

package/package/acode/dist/commands/commandLoader.d.ts

@@ -0,0 +1,7 @@
+import type { ACodeCommandSpec } from '../types.js';
+/**
+ * 从命令目录加载 Markdown slash commands。
+ * 主流程：跳过不存在目录与隐藏文件 -> 解析 `.md` 文件 -> 按文件名稳定排序。
+ */
+export declare function loadAcodeCommands(commandDirs: readonly string[]): Promise<ACodeCommandSpec[]>;
+//# sourceMappingURL=commandLoader.d.ts.map

package/package/acode/dist/commands/commandLoader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commandLoader.d.ts","sourceRoot":"","sources":["../../src/commands/commandLoader.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAYpD;;;GAGG;AACH,wBAAsB,iBAAiB,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAgBnG"}

package/package/acode/dist/commands/commandLoader.js

@@ -0,0 +1,33 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { parseAcodeCommandMarkdown } from './commandParser.js';
+async function pathExists(targetPath) {
+    try {
+        await fs.access(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * 从命令目录加载 Markdown slash commands。
+ * 主流程：跳过不存在目录与隐藏文件 -> 解析 `.md` 文件 -> 按文件名稳定排序。
+ */
+export async function loadAcodeCommands(commandDirs) {
+    const commands = [];
+    for (const commandDir of commandDirs) {
+        if (!(await pathExists(commandDir))) {
+            continue;
+        }
+        const entries = await fs.readdir(commandDir, { withFileTypes: true });
+        for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+            if (!entry.isFile() || entry.name.startsWith('.') || path.extname(entry.name).toLowerCase() !== '.md') {
+                continue;
+            }
+            const sourcePath = path.join(commandDir, entry.name);
+            commands.push(parseAcodeCommandMarkdown(sourcePath, await fs.readFile(sourcePath, 'utf-8')));
+        }
+    }
+    return commands;
+}

package/package/acode/dist/commands/commandParser.d.ts

@@ -0,0 +1,7 @@
+import type { ACodeCommandSpec } from '../types.js';
+/**
+ * 解析 Markdown slash command。
+ * 主流程：读取可选 YAML frontmatter -> 使用正文作为 prompt 模板 -> 缺省命令名取文件名。
+ */
+export declare function parseAcodeCommandMarkdown(sourcePath: string, rawMarkdown: string): ACodeCommandSpec;
+//# sourceMappingURL=commandParser.d.ts.map

package/package/acode/dist/commands/commandParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commandParser.d.ts","sourceRoot":"","sources":["../../src/commands/commandParser.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AA6DpD;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,gBAAgB,CAuBnG"}

package/package/acode/dist/commands/commandParser.js

@@ -0,0 +1,77 @@
+import path from 'node:path';
+function parseScalar(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    if ((trimmed.startsWith('"') && trimmed.endsWith('"')) || (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+        return trimmed.slice(1, -1).trim();
+    }
+    return trimmed;
+}
+function parseList(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        return [];
+    }
+    const withoutBrackets = trimmed.startsWith('[') && trimmed.endsWith(']') ? trimmed.slice(1, -1) : trimmed;
+    return withoutBrackets
+        .split(',')
+        .map((item) => parseScalar(item) ?? '')
+        .filter(Boolean);
+}
+function fallbackCommandName(sourcePath) {
+    return path.basename(sourcePath, path.extname(sourcePath)).trim();
+}
+function parseFrontmatter(rawFrontmatter) {
+    const parsed = {};
+    for (const line of rawFrontmatter.split(/\r?\n/)) {
+        const match = line.match(/^\s*([A-Za-z][A-Za-z0-9_-]*)\s*:\s*(.*)$/);
+        if (!match) {
+            continue;
+        }
+        const key = match[1];
+        const value = match[2] ?? '';
+        if (key === 'name') {
+            parsed.name = parseScalar(value);
+        }
+        if (key === 'description') {
+            parsed.description = parseScalar(value);
+        }
+        if (key === 'allowedTools' || key === 'allowed-tools') {
+            parsed.allowedTools = parseList(value);
+        }
+        if (key === 'argumentHint' || key === 'argument-hint') {
+            parsed.argumentHint = parseScalar(value);
+        }
+    }
+    return parsed;
+}
+/**
+ * 解析 Markdown slash command。
+ * 主流程：读取可选 YAML frontmatter -> 使用正文作为 prompt 模板 -> 缺省命令名取文件名。
+ */
+export function parseAcodeCommandMarkdown(sourcePath, rawMarkdown) {
+    const normalized = rawMarkdown.replace(/^\uFEFF/, '');
+    let body = normalized;
+    let metadata = {};
+    if (normalized.startsWith('---')) {
+        const end = normalized.indexOf('\n---', 3);
+        if (end >= 0) {
+            metadata = parseFrontmatter(normalized.slice(3, end));
+            body = normalized.slice(end + '\n---'.length).replace(/^\r?\n/, '');
+        }
+    }
+    const name = (metadata.name || fallbackCommandName(sourcePath)).replace(/^\/+/, '').trim();
+    if (!name) {
+        throw new Error(`ACode command name is empty: ${sourcePath}`);
+    }
+    return {
+        name,
+        description: metadata.description,
+        allowedTools: metadata.allowedTools,
+        argumentHint: metadata.argumentHint,
+        body: body.trim(),
+        sourcePath,
+    };
+}

package/package/acode/dist/commands/commandRegistry.d.ts

@@ -0,0 +1,13 @@
+import type { ACodeCommandSpec } from '../types.js';
+export interface ExpandedAcodeCommand {
+    command: ACodeCommandSpec;
+    prompt: string;
+    argumentsText: string;
+}
+export declare class ACodeCommandRegistry {
+    private readonly commands;
+    constructor(commands: readonly ACodeCommandSpec[]);
+    list(): ACodeCommandSpec[];
+    expand(input: string): ExpandedAcodeCommand | null;
+}
+//# sourceMappingURL=commandRegistry.d.ts.map

package/package/acode/dist/commands/commandRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commandRegistry.d.ts","sourceRoot":"","sources":["../../src/commands/commandRegistry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEpD,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,gBAAgB,CAAC;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,CAAC;CACvB;AAMD,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAuC;gBAEpD,QAAQ,EAAE,SAAS,gBAAgB,EAAE;IAMjD,IAAI,IAAI,gBAAgB,EAAE;IAI1B,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,oBAAoB,GAAG,IAAI;CAgBnD"}

package/package/acode/dist/commands/commandRegistry.js

@@ -0,0 +1,30 @@
+function normalizeCommandName(name) {
+    return name.replace(/^\/+/, '').trim().toLowerCase();
+}
+export class ACodeCommandRegistry {
+    constructor(commands) {
+        this.commands = new Map();
+        for (const command of commands) {
+            this.commands.set(normalizeCommandName(command.name), command);
+        }
+    }
+    list() {
+        return [...this.commands.values()];
+    }
+    expand(input) {
+        const match = input.trim().match(/^\/([^\s]+)(?:\s+(.*))?$/s);
+        if (!match) {
+            return null;
+        }
+        const command = this.commands.get(normalizeCommandName(match[1] ?? ''));
+        if (!command) {
+            return null;
+        }
+        const argumentsText = (match[2] ?? '').trim();
+        return {
+            command,
+            argumentsText,
+            prompt: command.body.replace(/\$ARGUMENTS/g, argumentsText),
+        };
+    }
+}

package/package/acode/dist/config.d.ts

@@ -0,0 +1,4 @@
+import type { ACodeConfigFile, ACodeSkillMetadata } from './types.js';
+export declare function loadAcodeConfig(configPath: string | undefined): Promise<ACodeConfigFile>;
+export declare function loadAcodeSkills(skillsDir: string | undefined): Promise<ACodeSkillMetadata[]>;
+//# sourceMappingURL=config.d.ts.map

package/package/acode/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAWtE,wBAAsB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC,eAAe,CAAC,CAU9F;AA8CD,wBAAsB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAgBlG"}

package/package/acode/dist/config.js

@@ -0,0 +1,80 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+async function pathExists(target) {
+    try {
+        await fs.access(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function loadAcodeConfig(configPath) {
+    if (!configPath || !(await pathExists(configPath))) {
+        return {};
+    }
+    const raw = await fs.readFile(configPath, 'utf-8');
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        return {};
+    }
+    return parsed;
+}
+function parseYamlStringValue(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    if ((trimmed.startsWith('"') && trimmed.endsWith('"')) || (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+        return trimmed.slice(1, -1).trim();
+    }
+    return trimmed;
+}
+function fallbackNameFromDirectory(directory) {
+    return path.basename(directory).replace(/\.skill$/, '').replace(/[-_]/g, ' ');
+}
+async function readSkillMetadata(directory) {
+    const skillFile = path.join(directory, 'SKILL.md');
+    if (!(await pathExists(skillFile))) {
+        return null;
+    }
+    const raw = (await fs.readFile(skillFile, 'utf-8')).replace(/^\uFEFF/, '');
+    const metadata = {};
+    if (raw.startsWith('---')) {
+        const end = raw.indexOf('\n---', 3);
+        if (end >= 0) {
+            for (const line of raw.slice(3, end).split(/\r?\n/)) {
+                const match = line.match(/^\s*(name|description)\s*:\s*(.*)$/);
+                if (!match) {
+                    continue;
+                }
+                const value = parseYamlStringValue(match[2] ?? '');
+                if (value) {
+                    metadata[match[1]] = value;
+                }
+            }
+        }
+    }
+    return {
+        name: metadata.name || fallbackNameFromDirectory(directory),
+        description: metadata.description,
+        directory,
+    };
+}
+export async function loadAcodeSkills(skillsDir) {
+    if (!skillsDir || !(await pathExists(skillsDir))) {
+        return [];
+    }
+    const entries = await fs.readdir(skillsDir, { withFileTypes: true });
+    const skills = [];
+    for (const entry of entries) {
+        if (entry.name.startsWith('.') || (!entry.isDirectory() && !entry.isSymbolicLink())) {
+            continue;
+        }
+        const metadata = await readSkillMetadata(path.join(skillsDir, entry.name));
+        if (metadata) {
+            skills.push(metadata);
+        }
+    }
+    return skills;
+}

package/package/acode/dist/hooks/hookBus.d.ts

@@ -0,0 +1,19 @@
+import type { ACodeHookEvent, ACodeHookEventName, ACodeHookHandler, ACodeHookResult } from '../types.js';
+export interface ACodeHookBusOptions {
+    sessionId: string;
+    now?: () => string;
+    onError?: (event: ACodeHookEvent, error: unknown) => void;
+}
+export declare class ACodeHookBus {
+    private readonly options;
+    private readonly handlers;
+    constructor(options: ACodeHookBusOptions);
+    register(handler: ACodeHookHandler): void;
+    /**
+     * 分发 ACode 生命周期 Hook。
+     * 主流程：按注册顺序执行 handler -> fail-open 记录错误 -> 遇到 deny 立即返回。
+     */
+    dispatch(name: ACodeHookEventName, data: Record<string, unknown>): Promise<ACodeHookResult[]>;
+}
+export declare function findDeniedHookResult(results: readonly ACodeHookResult[]): ACodeHookResult | undefined;
+//# sourceMappingURL=hookBus.d.ts.map

package/package/acode/dist/hooks/hookBus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hookBus.d.ts","sourceRoot":"","sources":["../../src/hooks/hookBus.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEzG,MAAM,WAAW,mBAAmB;IAClC,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,cAAc,EAAE,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CAC3D;AAED,qBAAa,YAAY;IAGX,OAAO,CAAC,QAAQ,CAAC,OAAO;IAFpC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA0B;gBAEtB,OAAO,EAAE,mBAAmB;IAEzD,QAAQ,CAAC,OAAO,EAAE,gBAAgB,GAAG,IAAI;IAIzC;;;OAGG;IACG,QAAQ,CAAC,IAAI,EAAE,kBAAkB,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;CAuBpG;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,SAAS,eAAe,EAAE,GAAG,eAAe,GAAG,SAAS,CAErG"}

package/package/acode/dist/hooks/hookBus.js

@@ -0,0 +1,40 @@
+export class ACodeHookBus {
+    constructor(options) {
+        this.options = options;
+        this.handlers = [];
+    }
+    register(handler) {
+        this.handlers.push(handler);
+    }
+    /**
+     * 分发 ACode 生命周期 Hook。
+     * 主流程：按注册顺序执行 handler -> fail-open 记录错误 -> 遇到 deny 立即返回。
+     */
+    async dispatch(name, data) {
+        const event = {
+            name,
+            sessionId: this.options.sessionId,
+            timestamp: this.options.now?.() ?? new Date().toISOString(),
+            data,
+        };
+        const results = [];
+        for (const handler of this.handlers) {
+            try {
+                const result = await handler(event);
+                if (result) {
+                    results.push(result);
+                    if (result.decision === 'deny') {
+                        return results;
+                    }
+                }
+            }
+            catch (error) {
+                this.options.onError?.(event, error);
+            }
+        }
+        return results;
+    }
+}
+export function findDeniedHookResult(results) {
+    return results.find((result) => result.decision === 'deny');
+}

package/package/acode/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from './commands/commandRegistry.js';
+export * from './commands/commandLoader.js';
+export * from './commands/commandParser.js';
+export * from './config.js';
+export * from './hooks/hookBus.js';
+export * from './runtime.js';
+export * from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/package/acode/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAC;AAC9C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,aAAa,CAAC;AAC5B,cAAc,oBAAoB,CAAC;AACnC,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC"}

package/package/acode/dist/index.js

@@ -0,0 +1,7 @@
+export * from './commands/commandRegistry.js';
+export * from './commands/commandLoader.js';
+export * from './commands/commandParser.js';
+export * from './config.js';
+export * from './hooks/hookBus.js';
+export * from './runtime.js';
+export * from './types.js';