agent-muster 0.1.0

package/bin/agent-muster.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import('../dist/cli.js');

package/dist/adapters.js

@@ -0,0 +1,190 @@
+function object(value) {
+    return value && typeof value === 'object' ? value : undefined;
+}
+function string(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+function tokens(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : 0;
+}
+function hasTokens(usage, keys) {
+    return keys.some(key => typeof usage[key] === 'number');
+}
+function detail(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    return typeof value === 'string' ? value : JSON.stringify(value, null, 2);
+}
+function json(line) {
+    try {
+        return object(JSON.parse(line));
+    }
+    catch {
+        return { type: 'plain', text: line };
+    }
+}
+const codex = {
+    id: 'codex',
+    launch(prompt, externalSessionId, model, images) {
+        const imageArgs = images?.flatMap(image => ['--image', image.path]) || [];
+        return {
+            command: 'codex',
+            args: externalSessionId
+                ? ['exec', 'resume', ...imageArgs, '--json', '--skip-git-repo-check', ...(model ? ['--model', model] : []), externalSessionId, '-']
+                : ['exec', ...imageArgs, '--json', '--skip-git-repo-check', ...(model ? ['--model', model] : []), '-'],
+            prompt,
+        };
+    },
+    read(line) {
+        const event = json(line);
+        if (!event)
+            return {};
+        if (event.type === 'thread.started')
+            return { externalSessionId: string(event.thread_id) };
+        if (event.type === 'turn.completed') {
+            const usage = object(event.usage);
+            if (usage && hasTokens(usage, ['input_tokens', 'output_tokens']))
+                return { usage: { inputTokens: tokens(usage.input_tokens), outputTokens: tokens(usage.output_tokens) }, usageIsTotal: true };
+        }
+        if (event.type === 'item.completed') {
+            const item = object(event.item);
+            if (item?.type === 'agent_message')
+                return { text: string(item.text) };
+            if (item?.type === 'command_execution')
+                return { tools: [{ name: `$ ${string(item.command) || 'command'}`, detail: string(item.aggregated_output) }] };
+            if (item?.type === 'mcp_tool_call')
+                return { tools: [{ name: `${string(item.server) || 'MCP'} / ${string(item.tool) || 'tool'}`, detail: detail(item.result) }] };
+            if (item?.type === 'file_change') {
+                const changes = item.changes;
+                if (Array.isArray(changes))
+                    return { changes: changes.flatMap(value => {
+                            const change = object(value);
+                            const path = string(change?.path);
+                            return path ? [{ path, kind: string(change?.kind) || 'update', diff: string(change?.unified_diff) }] : [];
+                        }) };
+                const entries = object(changes);
+                if (entries)
+                    return { changes: Object.entries(entries).map(([path, value]) => {
+                            const change = object(value);
+                            return { path, kind: string(change?.type) || 'update', diff: string(change?.unified_diff) };
+                        }) };
+            }
+        }
+        if (event.type === 'error')
+            return { error: string(event.message) || 'Codex error' };
+        if (event.type === 'plain')
+            return { text: string(event.text) };
+        return {};
+    },
+};
+const claude = {
+    id: 'claude',
+    launch(prompt, externalSessionId, model, images) {
+        return {
+            command: 'claude',
+            args: ['-p', '--verbose', '--output-format', 'stream-json', ...(images?.length ? ['--input-format', 'stream-json'] : []), ...(externalSessionId ? ['--resume', externalSessionId] : []), ...(model ? ['--model', model] : [])],
+            prompt: images?.length ? JSON.stringify({
+                type: 'user', message: { role: 'user', content: [
+                        { type: 'text', text: prompt },
+                        ...images.map(image => ({ type: 'image', source: { type: 'base64', media_type: image.mimeType, data: image.data } })),
+                    ] },
+            }) : prompt,
+        };
+    },
+    read(line) {
+        const event = json(line);
+        if (!event)
+            return {};
+        const externalSessionId = string(event.session_id);
+        if (event.type === 'assistant') {
+            const message = object(event.message);
+            const content = Array.isArray(message?.content) ? message.content : [];
+            const text = content.map(part => {
+                const block = object(part);
+                if (block?.type === 'text')
+                    return string(block.text);
+                return undefined;
+            }).filter(Boolean).join('\n');
+            const tools = content.flatMap(part => {
+                const block = object(part);
+                return block?.type === 'tool_use' ? [{ name: string(block.name) || 'tool', detail: detail(block.input) }] : [];
+            });
+            const usage = object(message?.usage);
+            return { externalSessionId, text: text || undefined, tools, usage: usage && hasTokens(usage, ['input_tokens', 'cache_creation_input_tokens', 'cache_read_input_tokens', 'output_tokens']) ? {
+                    inputTokens: tokens(usage.input_tokens) + tokens(usage.cache_creation_input_tokens) + tokens(usage.cache_read_input_tokens),
+                    outputTokens: tokens(usage.output_tokens),
+                } : undefined };
+        }
+        if (event.type === 'result') {
+            return { externalSessionId, error: event.is_error ? string(event.result) || 'Claude error' : undefined };
+        }
+        if (event.type === 'plain')
+            return { text: string(event.text) };
+        return { externalSessionId };
+    },
+};
+const pi = {
+    id: 'pi',
+    launch(prompt, externalSessionId, model, images) {
+        return {
+            command: 'pi',
+            args: ['--mode', 'json', ...(externalSessionId ? ['--session', externalSessionId] : []), ...(model ? ['--model', model] : []), ...(images?.map(image => `@${image.path}`) || [])],
+            prompt,
+        };
+    },
+    read(line) {
+        const event = json(line);
+        if (!event)
+            return {};
+        if (event.type === 'session')
+            return { externalSessionId: string(event.id) };
+        if (event.type === 'tool_execution_start')
+            return { tools: [{ name: string(event.toolName) || 'tool', detail: detail(event.args) }] };
+        if (event.type === 'message_end') {
+            const message = object(event.message);
+            if (message?.role !== 'assistant')
+                return {};
+            const content = Array.isArray(message.content) ? message.content : [];
+            const text = content.map(part => {
+                const block = object(part);
+                return block?.type === 'text' ? string(block.text) : undefined;
+            }).filter(Boolean).join('\n');
+            const usage = object(message.usage);
+            return { text: text || undefined, error: string(message.errorMessage), usage: usage && hasTokens(usage, ['input', 'cacheRead', 'cacheWrite', 'output']) ? {
+                    inputTokens: tokens(usage.input) + tokens(usage.cacheRead) + tokens(usage.cacheWrite),
+                    outputTokens: tokens(usage.output),
+                } : undefined };
+        }
+        return {};
+    },
+};
+const kimi = {
+    id: 'kimi',
+    launch(prompt, externalSessionId, model) {
+        return {
+            command: 'kimi',
+            args: ['--output-format', 'stream-json', ...(externalSessionId ? ['--session', externalSessionId] : []), ...(model ? ['--model', model] : []), '-p', prompt],
+        };
+    },
+    read(line) {
+        const event = json(line);
+        if (!event)
+            return {};
+        if (event.role === 'meta' && event.type === 'session.resume_hint')
+            return { externalSessionId: string(event.session_id) };
+        if (event.role === 'assistant') {
+            const calls = Array.isArray(event.tool_calls) ? event.tool_calls : [];
+            const tools = calls.map(call => {
+                const invocation = object(object(call)?.function);
+                return { name: string(invocation?.name) || 'tool', detail: detail(invocation?.arguments) };
+            });
+            const usage = object(event.usage);
+            return { text: string(event.content), tools, usage: usage && hasTokens(usage, ['prompt_tokens', 'completion_tokens']) ? {
+                    inputTokens: tokens(usage.prompt_tokens),
+                    outputTokens: tokens(usage.completion_tokens),
+                } : undefined };
+        }
+        return {};
+    },
+};
+export const adapters = { codex, claude, pi, kimi };

package/dist/agents.js

@@ -0,0 +1,141 @@
+import { access, readFile } from 'node:fs/promises';
+import { constants } from 'node:fs';
+import { delimiter, join } from 'node:path';
+import { homedir } from 'node:os';
+import { execFile, spawn } from 'node:child_process';
+import { promisify } from 'node:util';
+import { createInterface } from 'node:readline';
+const execFileAsync = promisify(execFile);
+const definitions = [
+    { id: 'codex', name: 'Codex', command: 'codex' },
+    { id: 'claude', name: 'Claude Code', command: 'claude' },
+    { id: 'pi', name: 'Pi', command: 'pi' },
+    { id: 'kimi', name: 'Kimi', command: 'kimi' },
+];
+async function executablePath(command) {
+    const pathValue = process.env.PATH;
+    if (!pathValue)
+        return undefined;
+    const extensions = process.platform === 'win32' ? ['.exe', '.cmd', '.bat'] : [''];
+    for (const directory of pathValue.split(delimiter)) {
+        if (!directory)
+            continue;
+        for (const extension of extensions) {
+            const path = join(directory, command + extension);
+            try {
+                await access(path, constants.X_OK);
+                return path;
+            }
+            catch { /* Continue scanning PATH. */ }
+        }
+    }
+}
+function contextWindow(value) {
+    const match = /^(\d+(?:\.\d+)?)([KM])?$/.exec(value);
+    return match ? Math.round(Number(match[1]) * (match[2] === 'M' ? 1_000_000 : match[2] === 'K' ? 1_000 : 1)) : undefined;
+}
+function codexModels() {
+    return new Promise((resolve, reject) => {
+        const child = spawn('codex', ['app-server'], { stdio: ['pipe', 'pipe', 'ignore'] });
+        const lines = createInterface({ input: child.stdout });
+        let finished = false;
+        const finish = (error, models) => {
+            if (finished)
+                return;
+            finished = true;
+            clearTimeout(timer);
+            lines.close();
+            child.kill();
+            if (error)
+                reject(error);
+            else if (models)
+                resolve(models);
+        };
+        const timer = setTimeout(() => finish(new Error('Codex model query timed out')), 15000);
+        child.on('error', error => finish(error));
+        child.stdin.on('error', error => finish(error));
+        child.on('exit', () => finish(new Error('Codex exited before returning models')));
+        lines.on('line', line => {
+            try {
+                const message = JSON.parse(line);
+                if (message.error) {
+                    finish(new Error(message.error.message));
+                    return;
+                }
+                if (message.id === 1) {
+                    child.stdin.write(`${JSON.stringify({ method: 'initialized' })}\n`);
+                    child.stdin.write(`${JSON.stringify({ id: 2, method: 'model/list', params: { limit: 100, includeHidden: true } })}\n`);
+                }
+                if (message.id === 2 && message.result)
+                    finish(undefined, message.result.data);
+            }
+            catch (error) {
+                finish(error);
+            }
+        });
+        child.stdin.write(`${JSON.stringify({ id: 1, method: 'initialize', params: { clientInfo: { name: 'agent_muster', version: '0.1.0' } } })}\n`);
+    });
+}
+async function availableModels(agent) {
+    if (agent === 'claude')
+        return ['sonnet', 'opus', 'haiku', 'fable'].map(id => ({ id, name: id }));
+    if (agent === 'codex') {
+        const models = await codexModels();
+        const catalog = JSON.parse(await readFile(join(homedir(), '.codex', 'models_cache.json'), 'utf8'));
+        return models.filter(model => model.model !== 'gpt-6.1-sol').map(model => ({ id: model.model, name: model.displayName, contextWindow: catalog.models.find(item => item.slug === model.model)?.context_window }));
+    }
+    if (agent === 'pi') {
+        const { stdout } = await execFileAsync('pi', ['--list-models'], { timeout: 5000 });
+        return stdout.trim().split(/\r?\n/).slice(1).flatMap(line => {
+            const [provider, model, limit] = line.trim().split(/\s+/);
+            if (!provider || !model)
+                return [];
+            return [{ id: `${provider}/${model}`, name: `${provider}/${model}`, contextWindow: contextWindow(limit) }];
+        });
+    }
+    if (agent === 'kimi') {
+        const { stdout } = await execFileAsync('kimi', ['provider', 'list', '--json'], { timeout: 5000 });
+        const catalog = JSON.parse(stdout);
+        return Object.entries(catalog.models).map(([id, model]) => ({ id, name: model.displayName || id, contextWindow: model.maxContextSize }));
+    }
+    return [];
+}
+async function configuredModel(agent) {
+    if (agent === 'codex') {
+        const config = await readFile(join(homedir(), '.codex', 'config.toml'), 'utf8');
+        return /^model\s*=\s*['"]([^'"]+)['"]/m.exec(config)?.[1];
+    }
+    if (agent === 'claude') {
+        const config = JSON.parse(await readFile(join(homedir(), '.claude', 'settings.json'), 'utf8'));
+        return config.model;
+    }
+    if (agent === 'pi') {
+        const config = JSON.parse(await readFile(join(homedir(), '.pi', 'agent', 'settings.json'), 'utf8'));
+        return config.defaultProvider && config.defaultModel ? `${config.defaultProvider}/${config.defaultModel}` : undefined;
+    }
+    if (agent === 'kimi') {
+        const { stdout } = await execFileAsync('kimi', ['provider', 'list'], { timeout: 5000 });
+        return /^Default model:\s*(\S+)/m.exec(stdout)?.[1];
+    }
+}
+export class AgentRegistry {
+    agents = new Map();
+    async scan() {
+        const agents = await Promise.all(definitions.map(async (definition) => {
+            const installed = Boolean(await executablePath(definition.command));
+            const [models, defaultModel] = installed ? await Promise.all([
+                availableModels(definition.id).catch(() => []),
+                configuredModel(definition.id).catch(() => undefined),
+            ]) : [[], undefined];
+            return { ...definition, installed, models, defaultModel };
+        }));
+        this.agents = new Map(agents.map(agent => [agent.id, agent]));
+        return agents;
+    }
+    list() {
+        return [...this.agents.values()];
+    }
+    get(id) {
+        return this.agents.get(id);
+    }
+}

package/dist/cli.js

@@ -0,0 +1,58 @@
+import { spawn } from 'node:child_process';
+import { AgentRegistry } from './agents.js';
+import { DingTalkBridge } from './dingtalk-bridge.js';
+import { DingTalkRegistry } from './dingtalk.js';
+import { ProjectRegistry } from './projects.js';
+import { SessionManager } from './sessions.js';
+import { startServer } from './server.js';
+function openBrowser(url) {
+    const command = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'cmd' : 'xdg-open';
+    const args = process.platform === 'win32' ? ['/c', 'start', '', url] : [url];
+    spawn(command, args, { detached: true, stdio: 'ignore' }).unref();
+}
+async function main() {
+    const [command = 'web', ...options] = process.argv.slice(2);
+    const registry = new AgentRegistry();
+    await registry.scan();
+    const sessions = new SessionManager();
+    await sessions.load();
+    const projects = new ProjectRegistry();
+    await projects.load();
+    const dingtalk = new DingTalkRegistry();
+    await dingtalk.load();
+    if (command === 'agents') {
+        console.log('Installed Agents\n');
+        for (const agent of registry.list())
+            console.log(`${agent.name}\nCommand: ${agent.command}\nStatus: ${agent.installed ? 'Available' : 'Unavailable'}\n`);
+        return;
+    }
+    if (command === 'sessions') {
+        console.log('ID                                         Agent    Project                Status');
+        for (const session of sessions.list()) {
+            console.log(`${session.id.padEnd(43)}${session.agent.padEnd(9)}${(session.cwd.split(/[\\/]/).at(-1) || '').padEnd(23)}${session.status}`);
+        }
+        return;
+    }
+    if (command !== 'web')
+        throw new Error(`Unknown command: ${command}`);
+    for (const { sessionId, appId } of dingtalk.sessionBindings())
+        sessions.linkDingTalkSession(sessionId, appId);
+    new DingTalkBridge(dingtalk, registry, sessions);
+    const portIndex = options.indexOf('--port');
+    const port = portIndex >= 0 ? Number(options[portIndex + 1]) : 17321;
+    if (!Number.isInteger(port) || port < 1 || port > 65535)
+        throw new Error('Port must be 1–65535');
+    const server = await startServer(port, registry, projects, sessions, dingtalk);
+    dingtalk.startSubscriptions();
+    const url = `http://127.0.0.1:${port}`;
+    console.log(`Agent Muster started\n\nWeb: ${url}\n\nDetected Agents:`);
+    for (const agent of registry.list())
+        console.log(`${agent.installed ? '✓' : '✗'} ${agent.name}`);
+    console.log('\nPress Ctrl+C to stop');
+    if (!options.includes('--no-open'))
+        openBrowser(url);
+    const shutdown = () => { dingtalk.shutdown(); sessions.shutdown(); server.close(); server.closeAllConnections(); };
+    process.once('SIGINT', shutdown);
+    process.once('SIGTERM', shutdown);
+}
+main().catch(error => { console.error(error.message); process.exitCode = 1; });

package/dist/dingtalk-bridge.js

@@ -0,0 +1,129 @@
+const terminalStatuses = new Set(['completed', 'failed', 'stopped']);
+function waitForCompletion(sessions, session) {
+    if (terminalStatuses.has(session.status) && !sessions.isRunning(session.id))
+        return Promise.resolve();
+    return new Promise(resolve => {
+        const check = () => {
+            if (!terminalStatuses.has(session.status) || sessions.isRunning(session.id))
+                return;
+            sessions.off(session.id, onEvent);
+            sessions.off(`${session.id}:idle`, check);
+            resolve();
+        };
+        const onEvent = (event) => { if (event.type === 'status')
+            check(); };
+        sessions.on(session.id, onEvent);
+        sessions.on(`${session.id}:idle`, check);
+        check();
+    });
+}
+export class DingTalkBridge {
+    dingtalk;
+    agents;
+    sessions;
+    queues = new Map();
+    seen = new Set();
+    constructor(dingtalk, agents, sessions) {
+        this.dingtalk = dingtalk;
+        this.agents = agents;
+        this.sessions = sessions;
+        dingtalk.on('message', event => this.enqueue(event));
+    }
+    enqueue({ appId, message }) {
+        if (!message.msgId || !message.conversationId || !['1', '2'].includes(message.conversationType))
+            return;
+        const messageKey = `${appId}:${message.msgId}`;
+        if (this.seen.has(messageKey))
+            return;
+        this.seen.add(messageKey);
+        if (this.seen.size > 1000)
+            this.seen.delete(this.seen.values().next().value);
+        const conversation = `${message.conversationType}:${message.conversationId}`;
+        const key = `${appId}:${conversation}`;
+        const task = (this.queues.get(key) || Promise.resolve())
+            .then(() => this.process(appId, conversation, message))
+            .catch(async (error) => {
+            console.error(`DingTalk message processing failed for ${appId} (message ${message.msgId}, conversation ${conversation}, type ${message.msgtype}):`, error);
+            try {
+                await this.dingtalk.reply(appId, message.sessionWebhook, 'Agent 执行失败，请在 Agent Muster 中查看会话日志。');
+            }
+            catch (replyError) {
+                console.error(`DingTalk error reply failed for ${appId}:`, replyError);
+            }
+        });
+        this.queues.set(key, task);
+        void task.finally(() => { if (this.queues.get(key) === task)
+            this.queues.delete(key); });
+    }
+    async process(appId, conversation, message) {
+        if (!['text', 'picture', 'richText'].includes(message.msgtype))
+            return;
+        if (message.msgtype === 'text' && !message.text.content.trim())
+            return;
+        const binding = this.dingtalk.getBinding(appId);
+        if (!binding?.project || !binding.agent) {
+            await this.dingtalk.reply(appId, message.sessionWebhook, '请先在 Agent Muster 中为此应用绑定项目和 Agent。');
+            return;
+        }
+        if (!this.agents.get(binding.agent)?.installed) {
+            await this.dingtalk.reply(appId, message.sessionWebhook, '绑定的 Agent 当前不可用。');
+            return;
+        }
+        await this.dingtalk.setConversationTarget(appId, conversation, message);
+        let content;
+        const images = [];
+        if (message.msgtype === 'text')
+            content = message.text.content.trim();
+        else {
+            const parts = message.msgtype === 'picture' ? [{ ...message.content, type: 'picture' }] : message.content.richText;
+            const promptParts = [];
+            for (const part of parts) {
+                if (part.type === 'picture') {
+                    const downloadCode = part.downloadCode ?? part.pictureDownloadCode;
+                    if (!downloadCode)
+                        throw new Error('钉钉图片消息缺少下载码');
+                    if (binding.agent === 'kimi')
+                        throw new Error('当前 Kimi CLI 不支持图片附件输入');
+                    images.push(await this.dingtalk.downloadImage(appId, message.robotCode, downloadCode));
+                }
+                else
+                    promptParts.push(part.text);
+            }
+            content = promptParts.join('').trim();
+            if (!content && images.length)
+                content = '请查看这张图片。';
+            if (!content)
+                return;
+        }
+        const dingtalkConversation = {
+            type: message.conversationType === '2' ? 'group' : 'single',
+            ...(message.conversationType === '2' ? { groupName: message.conversationTitle } : {}),
+            senderName: message.senderNick,
+            senderStaffId: message.senderStaffId,
+        };
+        const prompt = message.conversationType === '2'
+            ? `${message.senderNick}（${message.senderStaffId}）在群聊中说：\n${content}`
+            : content;
+        const previousId = this.dingtalk.getSession(appId, conversation);
+        let session = previousId ? this.sessions.get(previousId) : undefined;
+        if (session)
+            this.sessions.linkDingTalkSession(session.id, appId);
+        if (session && !terminalStatuses.has(session.status))
+            await waitForCompletion(this.sessions, session);
+        const lastEventId = session?.events.at(-1)?.id || 0;
+        if (session)
+            this.sessions.send(session.id, prompt, undefined, dingtalkConversation, images);
+        else {
+            session = await this.sessions.create(binding.agent, binding.project, prompt, undefined, appId, dingtalkConversation, images);
+            await this.dingtalk.setSession(appId, conversation, session.id);
+        }
+        await waitForCompletion(this.sessions, session);
+        if (session.status === 'failed') {
+            console.error(`DingTalk Agent execution failed for ${appId} (message ${message.msgId}, conversation ${conversation}, session ${session.id}):`, session.events.filter(event => event.id > lastEventId && event.type === 'error').map(event => event.text).join('\n'));
+        }
+        const reply = session.status === 'completed'
+            ? session.events.filter(event => event.id > lastEventId && event.type === 'output').at(-1)?.text.trim() || 'Agent 已执行完成。'
+            : 'Agent 执行失败，请在 Agent Muster 中查看会话日志。';
+        await this.dingtalk.reply(appId, message.sessionWebhook, reply);
+    }
+}