@love-moon/conductor-sdk 0.1.0

package/dist/context/project_context.js

@@ -0,0 +1,92 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+export class ProjectContext {
+    root;
+    constructor(targetPath) {
+        const resolvedPath = path.resolve(targetPath ?? process.cwd());
+        this.root = fs.realpathSync(resolvedPath);
+    }
+    guess() {
+        const repoRoot = this.gitRoot(this.root);
+        return {
+            projectRoot: this.root,
+            repoRoot: repoRoot ?? undefined,
+        };
+    }
+    listFiles(relativeToRepo = true) {
+        const guess = this.guess();
+        if (guess.repoRoot) {
+            const files = this.gitListFiles(guess.repoRoot);
+            if (relativeToRepo) {
+                return files;
+            }
+            return files.map((file) => path.join(guess.repoRoot, file));
+        }
+        const result = [];
+        for (const filePath of walkFiles(guess.projectRoot)) {
+            result.push(relativeToRepo ? path.relative(guess.projectRoot, filePath) : filePath);
+        }
+        return result.sort();
+    }
+    readFile(relativePath) {
+        const guess = this.guess();
+        const base = guess.repoRoot ?? guess.projectRoot;
+        const target = path.resolve(base, relativePath);
+        return fs.readFileSync(target, 'utf-8');
+    }
+    getDiff(staged = false) {
+        const guess = this.guess();
+        if (!guess.repoRoot) {
+            return '';
+        }
+        const args = ['diff'];
+        if (staged) {
+            args.push('--staged');
+        }
+        return runGit(args, guess.repoRoot);
+    }
+    gitRoot(start) {
+        try {
+            const repoPath = runGit(['rev-parse', '--show-toplevel'], start).trim();
+            return fs.realpathSync(repoPath);
+        }
+        catch {
+            return null;
+        }
+    }
+    gitListFiles(repoRoot) {
+        try {
+            const output = runGit(['ls-files'], repoRoot);
+            return output
+                .split(/\r?\n/)
+                .map((line) => line.trim())
+                .filter(Boolean);
+        }
+        catch {
+            return [];
+        }
+    }
+}
+function runGit(args, cwd) {
+    const result = spawnSync('git', args, {
+        cwd,
+        encoding: 'utf-8',
+    });
+    if (result.status !== 0) {
+        throw new Error(result.stderr || 'git command failed');
+    }
+    return result.stdout;
+}
+function* walkFiles(root) {
+    const entries = fs.readdirSync(root, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(root, entry.name);
+        if (entry.isDirectory()) {
+            yield* walkFiles(fullPath);
+        }
+        else if (entry.isFile()) {
+            yield fullPath;
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from './config/index.js';
+export * from './backend/index.js';
+export * from './ws/index.js';
+export * from './session/index.js';
+export * from './message/index.js';
+export * from './context/index.js';
+export * from './mcp/index.js';
+export * from './reporter/index.js';
+export * from './orchestrator.js';

package/dist/index.js

@@ -0,0 +1,9 @@
+export * from './config/index.js';
+export * from './backend/index.js';
+export * from './ws/index.js';
+export * from './session/index.js';
+export * from './message/index.js';
+export * from './context/index.js';
+export * from './mcp/index.js';
+export * from './reporter/index.js';
+export * from './orchestrator.js';

package/dist/mcp/index.d.ts

@@ -0,0 +1,2 @@
+export * from './notifications.js';
+export * from './server.js';

package/dist/mcp/index.js

@@ -0,0 +1,2 @@
+export * from './notifications.js';
+export * from './server.js';

package/dist/mcp/notifications.d.ts

@@ -0,0 +1,20 @@
+export interface LogSession {
+    sendLogMessage(args: {
+        level: string;
+        data: string;
+        logger?: string;
+    }): Promise<void>;
+}
+export interface MCPContext {
+    requestContext?: {
+        session?: LogSession;
+    };
+}
+export declare class MCPNotifier {
+    private session?;
+    private readonly lock;
+    bindContext(ctx?: MCPContext | null): Promise<void>;
+    setSession(session: LogSession): Promise<void>;
+    notifyNewMessage(taskId: string): Promise<void>;
+    private getSession;
+}

package/dist/mcp/notifications.js

@@ -0,0 +1,44 @@
+class AsyncLock {
+    tail = Promise.resolve();
+    async runExclusive(fn) {
+        const run = this.tail.then(fn, fn);
+        this.tail = run
+            .then(() => undefined)
+            .catch(() => undefined);
+        return run;
+    }
+}
+export class MCPNotifier {
+    session;
+    lock = new AsyncLock();
+    async bindContext(ctx) {
+        if (!ctx?.requestContext?.session) {
+            return;
+        }
+        await this.setSession(ctx.requestContext.session);
+    }
+    async setSession(session) {
+        await this.lock.runExclusive(async () => {
+            this.session = session;
+        });
+    }
+    async notifyNewMessage(taskId) {
+        const session = await this.getSession();
+        if (!session) {
+            return;
+        }
+        try {
+            await session.sendLogMessage({
+                level: 'info',
+                data: `任务 ${taskId} 收到了新的消息，请调用 receive_messages 工具查看。`,
+                logger: 'conductor.notifications',
+            });
+        }
+        catch {
+            // Best-effort notification; ignore errors.
+        }
+    }
+    async getSession() {
+        return this.lock.runExclusive(async () => this.session);
+    }
+}

package/dist/mcp/server.d.ts

@@ -0,0 +1,37 @@
+import { BackendPayload, MessageRouter } from '../message/router.js';
+import { SessionManager } from '../session/manager.js';
+import { SessionDiskStore } from '../session/store.js';
+import { ConductorConfig } from '../config/index.js';
+import { BackendApiClient } from '../backend/index.js';
+type BackendSender = (payload: BackendPayload) => Promise<void>;
+export interface MCPServerOptions {
+    sessionManager: SessionManager;
+    messageRouter: MessageRouter;
+    backendSender: BackendSender;
+    backendApi: Pick<BackendApiClient, 'listProjects' | 'listTasks' | 'createProject' | 'createTask'>;
+    sessionStore?: SessionDiskStore;
+    env?: Record<string, string | undefined>;
+}
+type ToolRequest = Record<string, any>;
+type ToolResponse = Record<string, any>;
+export declare class MCPServer {
+    private readonly config;
+    private readonly options;
+    private readonly tools;
+    private readonly sessionStore;
+    private readonly env;
+    constructor(config: ConductorConfig, options: MCPServerOptions);
+    handleRequest(toolName: string, payload: ToolRequest): Promise<ToolResponse>;
+    private toolCreateTaskSession;
+    private toolSendMessage;
+    private toolReceiveMessages;
+    private toolAckMessages;
+    private toolListProjects;
+    private toolCreateProject;
+    private toolListTasks;
+    private toolGetLocalProjectId;
+    private resolveHostname;
+    private waitForTaskCreation;
+    private readIntEnv;
+}
+export {};

package/dist/mcp/server.js

@@ -0,0 +1,211 @@
+import crypto from 'node:crypto';
+import { SessionDiskStore, currentHostname, currentSessionId } from '../session/store.js';
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+export class MCPServer {
+    config;
+    options;
+    tools;
+    sessionStore;
+    env;
+    constructor(config, options) {
+        this.config = config;
+        this.options = options;
+        this.sessionStore = options.sessionStore ?? new SessionDiskStore();
+        this.env = options.env ?? process.env;
+        this.tools = {
+            create_task_session: this.toolCreateTaskSession,
+            send_message: this.toolSendMessage,
+            receive_messages: this.toolReceiveMessages,
+            ack_messages: this.toolAckMessages,
+            list_projects: this.toolListProjects,
+            create_project: this.toolCreateProject,
+            list_tasks: this.toolListTasks,
+            get_local_project_id: this.toolGetLocalProjectId,
+        };
+    }
+    async handleRequest(toolName, payload) {
+        const handler = this.tools[toolName];
+        if (!handler) {
+            throw new Error(`Unknown tool: ${toolName}`);
+        }
+        return handler.call(this, payload);
+    }
+    async toolCreateTaskSession(payload) {
+        const projectId = String(payload.project_id || '');
+        if (!projectId) {
+            throw new Error('project_id is required');
+        }
+        const title = String(payload.task_title || 'Untitled');
+        const taskId = String(payload.task_id || crypto.randomUUID());
+        const sessionId = String(payload.session_id || taskId);
+        console.error(`[mcp] create_task_session task=${taskId} project=${projectId} title=${title} session=${sessionId}`);
+        await this.options.sessionManager.addSession(taskId, sessionId, projectId);
+        // Create task in database via HTTP API
+        await this.options.backendApi.createTask({
+            id: taskId,
+            projectId,
+            title,
+            initialContent: payload.prefill,
+        });
+        await this.waitForTaskCreation(projectId, taskId);
+        const projectPath = typeof payload.project_path === 'string' && payload.project_path
+            ? payload.project_path
+            : process.cwd();
+        this.sessionStore.upsert({
+            projectId,
+            taskId,
+            projectPath,
+            sessionId: currentSessionId(this.env),
+            hostname: this.resolveHostname(),
+        });
+        return {
+            task_id: taskId,
+            session_id: sessionId,
+            app_url: payload.app_url,
+        };
+    }
+    async toolSendMessage(payload) {
+        const taskId = String(payload.task_id || '');
+        if (!taskId) {
+            throw new Error('task_id required');
+        }
+        await this.options.backendSender({
+            type: 'sdk_message',
+            payload: {
+                task_id: taskId,
+                content: payload.content,
+                metadata: payload.metadata,
+            },
+        });
+        return { delivered: true };
+    }
+    async toolReceiveMessages(payload) {
+        const taskId = String(payload.task_id || '');
+        if (!taskId) {
+            throw new Error('task_id required');
+        }
+        const limit = typeof payload.limit === 'number' ? payload.limit : 20;
+        const messages = await this.options.sessionManager.popMessages(taskId, limit);
+        return formatMessagesResponse(messages);
+    }
+    async toolAckMessages(payload) {
+        const taskId = String(payload.task_id || '');
+        const ackToken = String(payload.ack_token || '');
+        if (!taskId || !ackToken) {
+            throw new Error('task_id and ack_token required');
+        }
+        const success = await this.options.sessionManager.ack(taskId, ackToken);
+        return { status: success ? 'ok' : 'ignored' };
+    }
+    async toolListProjects(_payload) {
+        const projects = await this.options.backendApi.listProjects();
+        return {
+            projects: projects.map((project) => typeof project.asObject === 'function'
+                ? project.asObject()
+                : {
+                    id: project.id,
+                    name: project.name ?? null,
+                    description: project.description ?? null,
+                }),
+        };
+    }
+    async toolCreateProject(payload) {
+        const name = String(payload.name || '').trim();
+        if (!name) {
+            throw new Error('name is required');
+        }
+        const description = payload.description ? String(payload.description) : undefined;
+        const metadata = payload.metadata && typeof payload.metadata === 'object' ? payload.metadata : undefined;
+        const project = await this.options.backendApi.createProject({
+            name,
+            description,
+            metadata,
+        });
+        return typeof project.asObject === 'function' ? project.asObject() : project;
+    }
+    async toolListTasks(payload) {
+        const tasks = await this.options.backendApi.listTasks({
+            projectId: payload.project_id ? String(payload.project_id) : undefined,
+            status: payload.status ? String(payload.status) : undefined,
+        });
+        return {
+            tasks: tasks.map((task) => ({
+                id: task.id,
+                project_id: task.project_id ?? task.projectId ?? null,
+                title: task.title,
+                status: task.status,
+                created_at: task.created_at ?? task.createdAt ?? null,
+                updated_at: task.updated_at ?? task.updatedAt ?? null,
+            })),
+        };
+    }
+    async toolGetLocalProjectId(payload) {
+        const projectPath = typeof payload.project_path === 'string' && payload.project_path
+            ? payload.project_path
+            : process.cwd();
+        const record = this.sessionStore.findByPath(projectPath);
+        if (!record) {
+            throw new Error(`No session record found for project path ${projectPath}`);
+        }
+        return {
+            project_id: record.projectId,
+            task_id: Array.from(record.taskIds),
+            session_id: record.sessionId,
+            hostname: record.hostname,
+        };
+    }
+    resolveHostname() {
+        const records = this.sessionStore.load();
+        for (const record of records) {
+            if (record.hostname) {
+                return record.hostname;
+            }
+        }
+        return currentHostname();
+    }
+    async waitForTaskCreation(projectId, taskId) {
+        const retries = this.readIntEnv('CONDUCTOR_TASK_CREATE_RETRIES', 10);
+        if (retries <= 0) {
+            return;
+        }
+        const delayMs = this.readIntEnv('CONDUCTOR_TASK_CREATE_DELAY_MS', 250);
+        for (let attempt = 0; attempt < retries; attempt += 1) {
+            try {
+                const tasks = await this.options.backendApi.listTasks({ projectId });
+                if (tasks.some((task) => String(task?.id || '') === taskId)) {
+                    return;
+                }
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                console.warn(`[mcp] create_task_session unable to confirm task ${taskId}: ${message}`);
+                return;
+            }
+            if (attempt < retries - 1) {
+                await sleep(delayMs);
+            }
+        }
+        console.warn(`[mcp] create_task_session timed out waiting for task ${taskId}`);
+    }
+    readIntEnv(key, fallback) {
+        const raw = this.env[key];
+        if (!raw) {
+            return fallback;
+        }
+        const value = parseInt(raw, 10);
+        return Number.isFinite(value) ? value : fallback;
+    }
+}
+function formatMessagesResponse(messages) {
+    return {
+        messages: messages.map((msg) => ({
+            message_id: msg.messageId,
+            role: msg.role,
+            content: msg.content,
+            ack_token: msg.ackToken,
+            created_at: msg.createdAt.toISOString(),
+        })),
+        next_ack_token: messages.length ? messages[messages.length - 1].ackToken ?? null : null,
+        has_more: false,
+    };
+}

package/dist/message/index.d.ts

@@ -0,0 +1 @@
+export * from './router.js';

package/dist/message/index.js

@@ -0,0 +1 @@
+export * from './router.js';

package/dist/message/router.d.ts

@@ -0,0 +1,19 @@
+import { SessionManager } from '../session/manager.js';
+import { MCPNotifier } from '../mcp/notifications.js';
+export type BackendPayload = Record<string, any>;
+export type OutboundHandler = (payload: BackendPayload) => Promise<void> | void;
+export declare class MessageRouter {
+    private readonly sessions;
+    private readonly notifier?;
+    private readonly outboundHandlers;
+    constructor(sessions: SessionManager, notifier?: MCPNotifier | undefined);
+    registerOutboundHandler(handler: OutboundHandler): void;
+    handleBackendEvent(payload: BackendPayload): Promise<void>;
+    sendToBackend(payload: BackendPayload): Promise<void>;
+    private notify;
+    private resolveMessageId;
+    private coerceRole;
+    private coerceContent;
+    private formatActionContent;
+    private ensureSession;
+}

package/dist/message/router.js

@@ -0,0 +1,122 @@
+import crypto from 'node:crypto';
+const RANDOM_UUID = () => (typeof crypto.randomUUID === 'function' ? crypto.randomUUID() : crypto.randomBytes(16).toString('hex'));
+export class MessageRouter {
+    sessions;
+    notifier;
+    outboundHandlers = [];
+    constructor(sessions, notifier) {
+        this.sessions = sessions;
+        this.notifier = notifier;
+    }
+    registerOutboundHandler(handler) {
+        this.outboundHandlers.push(handler);
+    }
+    async handleBackendEvent(payload) {
+        const eventType = payload?.type;
+        const data = payload?.payload && typeof payload.payload === 'object' ? payload.payload : {};
+        const taskId = typeof data.task_id === 'string' ? data.task_id : undefined;
+        if (!taskId) {
+            return;
+        }
+        const projectId = typeof data.project_id === 'string' ? data.project_id : undefined;
+        if (eventType === 'task_user_message') {
+            await this.ensureSession(taskId, projectId);
+            await this.sessions.addMessage(taskId, {
+                messageId: this.resolveMessageId(data),
+                role: this.coerceRole(data.role, 'user'),
+                content: this.coerceContent(data.content),
+                ackToken: data.ack_token ? String(data.ack_token) : null,
+            });
+            await this.notify(taskId);
+        }
+        else if (eventType === 'task_action') {
+            await this.ensureSession(taskId, projectId);
+            await this.sessions.addMessage(taskId, {
+                messageId: this.resolveMessageId(data),
+                role: this.coerceRole(data.role, 'action'),
+                content: this.formatActionContent(data),
+                ackToken: data.ack_token ? String(data.ack_token) : null,
+            });
+            await this.notify(taskId);
+        }
+        else if (eventType === 'task_status_update') {
+            const session = await this.sessions.getSession(taskId);
+            if (session && typeof data.status === 'string') {
+                session.status = data.status;
+            }
+        }
+    }
+    async sendToBackend(payload) {
+        for (const handler of this.outboundHandlers) {
+            const result = handler(payload);
+            if (result && typeof result.then === 'function') {
+                await result;
+            }
+        }
+    }
+    async notify(taskId) {
+        if (!this.notifier) {
+            return;
+        }
+        await this.notifier.notifyNewMessage(taskId);
+    }
+    resolveMessageId(data) {
+        const candidates = [data.message_id, data.action_id, data.id, data.request_id];
+        for (const candidate of candidates) {
+            if (typeof candidate === 'string' && candidate.trim()) {
+                return candidate;
+            }
+            if (typeof candidate === 'number') {
+                return String(candidate);
+            }
+        }
+        return RANDOM_UUID();
+    }
+    coerceRole(role, fallback) {
+        if (typeof role === 'string' && role.trim()) {
+            return role;
+        }
+        return fallback;
+    }
+    coerceContent(content) {
+        if (typeof content === 'string') {
+            return content;
+        }
+        if (content === undefined || content === null) {
+            return '';
+        }
+        try {
+            return JSON.stringify(content);
+        }
+        catch {
+            return String(content);
+        }
+    }
+    formatActionContent(data) {
+        if (typeof data.content === 'string' && data.content.trim()) {
+            return data.content;
+        }
+        const action = typeof data.action === 'string' && data.action.trim() ? data.action : 'action';
+        const args = data.args;
+        if (args && typeof args === 'object') {
+            const command = args.command;
+            if (typeof command === 'string' && command.trim()) {
+                return `${action}: ${command.trim()}`;
+            }
+            try {
+                return `${action}: ${JSON.stringify(args)}`;
+            }
+            catch {
+                return `${action}: ${String(args)}`;
+            }
+        }
+        return action;
+    }
+    async ensureSession(taskId, projectId) {
+        const session = await this.sessions.getSession(taskId);
+        if (session || !projectId) {
+            return;
+        }
+        await this.sessions.addSession(taskId, taskId, projectId);
+    }
+}

package/dist/orchestrator.d.ts

@@ -0,0 +1,21 @@
+import { MessageRouter } from './message/index.js';
+import { EventReporter } from './reporter/index.js';
+import { SessionManager } from './session/index.js';
+import { ConductorWebSocketClient } from './ws/client.js';
+import { MCPServer } from './mcp/server.js';
+export interface OrchestratorDeps {
+    wsClient: ConductorWebSocketClient;
+    messageRouter: MessageRouter;
+    sessionManager: SessionManager;
+    mcpServer: MCPServer;
+    reporter: EventReporter;
+}
+export declare class SDKOrchestrator {
+    private readonly deps;
+    private readonly wsClient;
+    private readonly router;
+    constructor(deps: OrchestratorDeps);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private handleBackendEvent;
+}

package/dist/orchestrator.js

@@ -0,0 +1,20 @@
+export class SDKOrchestrator {
+    deps;
+    wsClient;
+    router;
+    constructor(deps) {
+        this.deps = deps;
+        this.wsClient = deps.wsClient;
+        this.router = deps.messageRouter;
+        this.wsClient.registerHandler((payload) => this.handleBackendEvent(payload));
+    }
+    async start() {
+        await this.wsClient.connect();
+    }
+    async stop() {
+        await this.wsClient.disconnect();
+    }
+    async handleBackendEvent(payload) {
+        await this.router.handleBackendEvent(payload);
+    }
+}

package/dist/reporter/event_stream.d.ts

@@ -0,0 +1,7 @@
+export type BackendSender = (payload: Record<string, any>) => Promise<void>;
+export declare class EventReporter {
+    private readonly backendSender;
+    constructor(backendSender: BackendSender);
+    emit(eventType: string, payload: Record<string, any>): Promise<void>;
+    taskStatus(taskId: string, status: string, summary?: string | null): Promise<void>;
+}

package/dist/reporter/event_stream.js

@@ -0,0 +1,20 @@
+export class EventReporter {
+    backendSender;
+    constructor(backendSender) {
+        this.backendSender = backendSender;
+    }
+    async emit(eventType, payload) {
+        await this.backendSender({
+            type: eventType,
+            timestamp: new Date().toISOString(),
+            payload,
+        });
+    }
+    async taskStatus(taskId, status, summary) {
+        await this.emit('task_status_update', {
+            task_id: taskId,
+            status,
+            summary: summary ?? undefined,
+        });
+    }
+}

package/dist/reporter/index.d.ts

@@ -0,0 +1 @@
+export * from './event_stream.js';

package/dist/reporter/index.js

@@ -0,0 +1 @@
+export * from './event_stream.js';

package/dist/session/index.d.ts

@@ -0,0 +1,2 @@
+export * from './manager.js';
+export * from './store.js';

package/dist/session/index.js

@@ -0,0 +1,2 @@
+export * from './manager.js';
+export * from './store.js';