@love-moon/conductor-sdk 0.2.5 → 0.2.7

package/dist/backend/client.d.ts

@@ -75,6 +75,10 @@ export declare class BackendApiClient {
         metadata?: Record<string, unknown>;
     }): Promise<ProjectSummary>;
     private request;
+    private buildUrl;
+    private sendRequest;
+    private shouldRetryWithApiPrefix;
+    private withApiPrefix;
     private parseJson;
     private safeJson;
 }

package/dist/backend/client.js

@@ -167,23 +167,16 @@ export class BackendApiClient {
         return ProjectSummary.fromJSON(payload);
     }
     async request(method, pathname, opts = {}) {
-        const url = new URL(`${this.baseUrl}${pathname}`);
-        if (opts.query) {
-            opts.query.forEach((value, key) => url.searchParams.set(key, value));
-        }
+        const url = this.buildUrl(pathname, opts.query);
         const controller = typeof AbortController !== 'undefined' ? new AbortController() : null;
         const timeout = controller ? setTimeout(() => controller.abort(), this.timeoutMs) : null;
         try {
-            const response = await this.fetchImpl(url.toString(), {
-                method,
-                headers: {
-                    Authorization: `Bearer ${this.config.agentToken}`,
-                    Accept: 'application/json',
-                    ...(opts.body ? { 'Content-Type': 'application/json' } : {}),
-                },
-                body: opts.body,
-                signal: controller?.signal,
-            });
+            let response = await this.sendRequest(url, method, opts.body, controller);
+            if (response.status === 404 &&
+                this.shouldRetryWithApiPrefix(pathname, url)) {
+                const retryUrl = this.buildUrl(this.withApiPrefix(pathname), opts.query);
+                response = await this.sendRequest(retryUrl, method, opts.body, controller);
+            }
             if (!response.ok) {
                 const details = await this.safeJson(response);
                 throw new BackendApiError(`Backend responded with ${response.status}`, response.status, details);
@@ -202,6 +195,39 @@ export class BackendApiClient {
             }
         }
     }
+    buildUrl(pathname, query) {
+        const url = new URL(`${this.baseUrl}${pathname}`);
+        if (query) {
+            query.forEach((value, key) => url.searchParams.set(key, value));
+        }
+        return url;
+    }
+    async sendRequest(url, method, body, controller) {
+        return this.fetchImpl(url.toString(), {
+            method,
+            headers: {
+                Authorization: `Bearer ${this.config.agentToken}`,
+                Accept: 'application/json',
+                ...(body ? { 'Content-Type': 'application/json' } : {}),
+            },
+            body,
+            signal: controller?.signal,
+        });
+    }
+    shouldRetryWithApiPrefix(pathname, url) {
+        if (!pathname.startsWith('/'))
+            return false;
+        if (pathname === '/api' || pathname.startsWith('/api/'))
+            return false;
+        // If backendUrl already includes /api in the base path, don't retry.
+        return !url.pathname.startsWith('/api/');
+    }
+    withApiPrefix(pathname) {
+        if (pathname === '/api' || pathname.startsWith('/api/')) {
+            return pathname;
+        }
+        return `/api${pathname}`;
+    }
     async parseJson(response) {
         try {
             return await response.json();

package/dist/client.d.ts

@@ -0,0 +1,64 @@
+import { BackendApiClient } from './backend/index.js';
+import { ConductorConfig } from './config/index.js';
+import { MessageRouter } from './message/index.js';
+import { SessionDiskStore, SessionManager } from './session/index.js';
+import { ConductorWebSocketClient } from './ws/index.js';
+type BackendApiLike = Pick<BackendApiClient, 'listProjects' | 'createProject' | 'listTasks' | 'createTask' | 'matchProjectByPath' | 'getProject' | 'updateProject'>;
+type RealtimeClientLike = Pick<ConductorWebSocketClient, 'registerHandler' | 'connect' | 'disconnect' | 'sendJson'>;
+export interface ConductorClientConnectOptions {
+    config?: ConductorConfig;
+    configFile?: string;
+    env?: Record<string, string | undefined>;
+    extraEnv?: Record<string, string | undefined>;
+    projectPath?: string;
+    backendApi?: BackendApiLike;
+    wsClient?: RealtimeClientLike;
+    sessionManager?: SessionManager;
+    sessionStore?: SessionDiskStore;
+    messageRouter?: MessageRouter;
+    agentHost?: string;
+}
+interface ConductorClientInit {
+    config: ConductorConfig;
+    env: Record<string, string | undefined>;
+    projectPath: string;
+    backendApi: BackendApiLike;
+    wsClient: RealtimeClientLike;
+    sessionManager: SessionManager;
+    sessionStore: SessionDiskStore;
+    messageRouter: MessageRouter;
+    agentHost: string;
+}
+export declare class ConductorClient {
+    private readonly config;
+    private readonly env;
+    private readonly projectPath;
+    private readonly backendApi;
+    private readonly wsClient;
+    private readonly sessions;
+    private readonly sessionStore;
+    private readonly messageRouter;
+    private readonly agentHost;
+    private closed;
+    constructor(init: ConductorClientInit);
+    static connect(options?: ConductorClientConnectOptions): Promise<ConductorClient>;
+    close(): Promise<void>;
+    createTaskSession(payload: Record<string, any>): Promise<Record<string, any>>;
+    sendMessage(taskId: string, content: string, metadata?: Record<string, any>): Promise<Record<string, any>>;
+    sendTaskStatus(taskId: string, payload: Record<string, any>): Promise<Record<string, any>>;
+    sendRuntimeStatus(taskId: string, payload: Record<string, any>): Promise<Record<string, any>>;
+    receiveMessages(taskId: string, limit?: number): Promise<Record<string, any>>;
+    ackMessages(taskId: string, ackToken?: string | null): Promise<Record<string, any> | undefined>;
+    listProjects(): Promise<Record<string, any>>;
+    createProject(name: string, description?: string, metadata?: Record<string, unknown>): Promise<Record<string, any>>;
+    listTasks(payload?: Record<string, any>): Promise<Record<string, any>>;
+    getLocalProjectRecord(payload?: Record<string, any>): Promise<Record<string, any>>;
+    matchProjectByPath(payload?: Record<string, any>): Promise<Record<string, any>>;
+    bindProjectPath(projectId: string, payload?: Record<string, any>): Promise<Record<string, any>>;
+    private readonly handleBackendEvent;
+    private sendEnvelope;
+    private resolveHostname;
+    private waitForTaskCreation;
+    private readIntEnv;
+}
+export {};

package/dist/{mcp/server.js → client.js}

@@ -1,52 +1,77 @@
 import crypto from 'node:crypto';
-import { SessionDiskStore, currentHostname, currentSessionId } from '../session/store.js';
+import { BackendApiClient } from './backend/index.js';
+import { loadConfig } from './config/index.js';
+import { MessageRouter } from './message/index.js';
+import { SessionDiskStore, SessionManager, currentHostname, currentSessionId } from './session/index.js';
+import { ConductorWebSocketClient } from './ws/index.js';
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-export class MCPServer {
+export class ConductorClient {
     config;
-    options;
-    tools;
-    sessionStore;
     env;
-    constructor(config, options) {
-        this.config = config;
-        this.options = options;
-        // Use backend URL to determine session file path (isolates different environments)
-        this.sessionStore = options.sessionStore ?? SessionDiskStore.forBackendUrl(config.backendUrl);
-        this.env = options.env ?? process.env;
-        this.tools = {
-            create_task_session: this.toolCreateTaskSession,
-            send_message: this.toolSendMessage,
-            send_task_status: this.toolSendTaskStatus,
-            send_runtime_status: this.toolSendRuntimeStatus,
-            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,
-            match_project_by_path: this.toolMatchProjectByPath,
-            bind_project_path: this.toolBindProjectPath,
-        };
+    projectPath;
+    backendApi;
+    wsClient;
+    sessions;
+    sessionStore;
+    messageRouter;
+    agentHost;
+    closed = false;
+    constructor(init) {
+        this.config = init.config;
+        this.env = init.env;
+        this.projectPath = init.projectPath;
+        this.backendApi = init.backendApi;
+        this.wsClient = init.wsClient;
+        this.sessions = init.sessionManager;
+        this.sessionStore = init.sessionStore;
+        this.messageRouter = init.messageRouter;
+        this.agentHost = init.agentHost;
+        this.wsClient.registerHandler(this.handleBackendEvent);
+    }
+    static async connect(options = {}) {
+        const env = options.extraEnv ?? options.env ?? process.env;
+        const config = options.config ?? loadConfig(options.configFile, { env });
+        const projectPath = options.projectPath ?? process.cwd();
+        const backendApi = options.backendApi ?? new BackendApiClient(config);
+        const sessions = options.sessionManager ?? new SessionManager();
+        const sessionStore = options.sessionStore ?? SessionDiskStore.forBackendUrl(config.backendUrl);
+        const messageRouter = options.messageRouter ?? new MessageRouter(sessions);
+        const agentHost = resolveAgentHost(env, options.agentHost);
+        const wsClient = options.wsClient ??
+            new ConductorWebSocketClient(config, {
+                hostName: agentHost,
+            });
+        const client = new ConductorClient({
+            config,
+            env,
+            projectPath,
+            backendApi,
+            wsClient,
+            sessionManager: sessions,
+            sessionStore,
+            messageRouter,
+            agentHost,
+        });
+        await client.wsClient.connect();
+        return client;
     }
-    async handleRequest(toolName, payload) {
-        const handler = this.tools[toolName];
-        if (!handler) {
-            throw new Error(`Unknown tool: ${toolName}`);
+    async close() {
+        if (this.closed) {
+            return;
         }
-        return handler.call(this, payload);
+        this.closed = true;
+        await this.wsClient.disconnect();
     }
-    async toolCreateTaskSession(payload) {
-        const projectId = String(payload.project_id || '');
+    async createTaskSession(payload) {
+        const projectId = String(payload.project_id || '').trim();
         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 taskId = String(payload.task_id || safeRandomUuid());
         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({
+        await this.sessions.addSession(taskId, sessionId, projectId);
+        await this.backendApi.createTask({
             id: taskId,
             projectId,
             title,
@@ -55,17 +80,17 @@ export class MCPServer {
                 : typeof payload.backendType === 'string'
                     ? payload.backendType
                     : undefined,
-            initialContent: payload.prefill,
+            initialContent: typeof payload.prefill === 'string' ? payload.prefill : undefined,
             agentHost: typeof payload.agent_host === 'string'
                 ? payload.agent_host
                 : typeof payload.agentHost === 'string'
                     ? payload.agentHost
-                    : this.options.agentHost,
+                    : this.agentHost,
         });
         await this.waitForTaskCreation(projectId, taskId);
         const projectPath = typeof payload.project_path === 'string' && payload.project_path
             ? payload.project_path
-            : process.cwd();
+            : this.projectPath;
         this.sessionStore.upsert({
             projectId,
             taskId,
@@ -79,80 +104,61 @@ export class MCPServer {
             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({
+    async sendMessage(taskId, content, metadata) {
+        await this.sendEnvelope({
             type: 'sdk_message',
             payload: {
                 task_id: taskId,
-                content: payload.content,
-                metadata: payload.metadata,
+                content,
+                metadata,
             },
         });
         return { delivered: true };
     }
-    async toolSendTaskStatus(payload) {
-        const taskId = String(payload.task_id || '');
-        if (!taskId) {
-            throw new Error('task_id required');
-        }
-        await this.options.backendSender({
+    async sendTaskStatus(taskId, payload) {
+        await this.sendEnvelope({
             type: 'task_status_update',
             payload: {
                 task_id: taskId,
-                status: payload.status,
-                summary: payload.summary,
+                status: payload?.status,
+                summary: payload?.summary,
             },
         });
         return { delivered: true };
     }
-    async toolSendRuntimeStatus(payload) {
-        const taskId = String(payload.task_id || '');
-        if (!taskId) {
-            throw new Error('task_id required');
-        }
-        await this.options.backendSender({
+    async sendRuntimeStatus(taskId, payload) {
+        await this.sendEnvelope({
             type: 'task_runtime_status',
             payload: {
                 task_id: taskId,
-                state: payload.state,
-                phase: payload.phase,
-                source: payload.source,
-                reply_in_progress: payload.reply_in_progress,
-                status_line: payload.status_line,
-                status_done_line: payload.status_done_line,
-                reply_preview: payload.reply_preview,
-                reply_to: payload.reply_to,
-                backend: payload.backend,
-                thread_id: payload.thread_id,
-                created_at: payload.created_at,
+                state: payload?.state,
+                phase: payload?.phase,
+                source: payload?.source,
+                reply_in_progress: payload?.reply_in_progress,
+                status_line: payload?.status_line,
+                status_done_line: payload?.status_done_line,
+                reply_preview: payload?.reply_preview,
+                reply_to: payload?.reply_to,
+                backend: payload?.backend,
+                thread_id: payload?.thread_id,
+                created_at: payload?.created_at,
             },
         });
         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);
+    async receiveMessages(taskId, limit = 20) {
+        const messages = await this.sessions.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');
+    async ackMessages(taskId, ackToken) {
+        if (!ackToken) {
+            return undefined;
         }
-        const success = await this.options.sessionManager.ack(taskId, ackToken);
+        const success = await this.sessions.ack(taskId, ackToken);
         return { status: success ? 'ok' : 'ignored' };
     }
-    async toolListProjects(_payload) {
-        const projects = await this.options.backendApi.listProjects();
+    async listProjects() {
+        const projects = await this.backendApi.listProjects();
         return {
             projects: projects.map((project) => typeof project.asObject === 'function'
                 ? project.asObject()
@@ -163,22 +169,12 @@ export class MCPServer {
                 }),
         };
     }
-    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,
-        });
+    async createProject(name, description, metadata) {
+        const project = await this.backendApi.createProject({ name, description, metadata });
         return typeof project.asObject === 'function' ? project.asObject() : project;
     }
-    async toolListTasks(payload) {
-        const tasks = await this.options.backendApi.listTasks({
+    async listTasks(payload = {}) {
+        const tasks = await this.backendApi.listTasks({
             projectId: payload.project_id ? String(payload.project_id) : undefined,
             status: payload.status ? String(payload.status) : undefined,
         });
@@ -193,10 +189,10 @@ export class MCPServer {
             })),
         };
     }
-    async toolGetLocalProjectId(payload) {
+    async getLocalProjectRecord(payload = {}) {
         const projectPath = typeof payload.project_path === 'string' && payload.project_path
             ? payload.project_path
-            : process.cwd();
+            : this.projectPath;
         const record = this.sessionStore.findByPath(projectPath);
         if (!record) {
             throw new Error(`No session record found for project path ${projectPath}`);
@@ -208,13 +204,12 @@ export class MCPServer {
             hostname: record.hostname,
         };
     }
-    async toolMatchProjectByPath(payload) {
+    async matchProjectByPath(payload = {}) {
         const hostname = typeof payload.hostname === 'string' ? payload.hostname : currentHostname();
         const projectPath = typeof payload.project_path === 'string' && payload.project_path
             ? payload.project_path
-            : process.cwd();
-        console.error(`[mcp] match_project_by_path hostname=${hostname} path=${projectPath}`);
-        const result = await this.options.backendApi.matchProjectByPath({
+            : this.projectPath;
+        const result = await this.backendApi.matchProjectByPath({
             hostname,
             path: projectPath,
         });
@@ -231,31 +226,32 @@ export class MCPServer {
             matched_path: null,
         };
     }
-    async toolBindProjectPath(payload) {
-        const projectId = String(payload.project_id || '');
+    async bindProjectPath(projectId, payload = {}) {
         if (!projectId) {
             throw new Error('project_id is required');
         }
         const hostname = typeof payload.hostname === 'string' ? payload.hostname : currentHostname();
         const projectPath = typeof payload.project_path === 'string' && payload.project_path
             ? payload.project_path
-            : process.cwd();
-        console.error(`[mcp] bind_project_path project=${projectId} hostname=${hostname} path=${projectPath}`);
-        // Get current project metadata
-        const project = await this.options.backendApi.getProject(projectId);
+            : this.projectPath;
+        const project = await this.backendApi.getProject(projectId);
         const metadata = (project.metadata || {});
         const localPaths = (metadata.localPaths || {});
-        // Update localPaths with new binding
         localPaths[hostname] = projectPath;
         metadata.localPaths = localPaths;
-        // Update project
-        await this.options.backendApi.updateProject(projectId, { metadata });
+        await this.backendApi.updateProject(projectId, { metadata });
         return {
             success: true,
             hostname,
             path: projectPath,
         };
     }
+    handleBackendEvent = async (payload) => {
+        await this.messageRouter.handleBackendEvent(payload);
+    };
+    async sendEnvelope(envelope) {
+        await this.wsClient.sendJson(envelope);
+    }
     resolveHostname() {
         const records = this.sessionStore.load();
         for (const record of records) {
@@ -273,21 +269,21 @@ export class MCPServer {
         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 });
+                const tasks = await this.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}`);
+                console.warn(`[sdk] createTaskSession 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}`);
+        console.warn(`[sdk] createTaskSession timed out waiting for task ${taskId}`);
     }
     readIntEnv(key, fallback) {
         const raw = this.env[key];
@@ -311,3 +307,25 @@ function formatMessagesResponse(messages) {
         has_more: false,
     };
 }
+function safeRandomUuid() {
+    if (typeof crypto.randomUUID === 'function') {
+        return crypto.randomUUID();
+    }
+    return crypto.randomBytes(16).toString('hex');
+}
+function resolveAgentHost(env, explicit) {
+    if (explicit && explicit.trim()) {
+        return explicit.trim();
+    }
+    const fromAgent = env.CONDUCTOR_AGENT_NAME;
+    if (typeof fromAgent === 'string' && fromAgent.trim()) {
+        return fromAgent.trim();
+    }
+    const fromDaemon = env.CONDUCTOR_DAEMON_NAME;
+    if (typeof fromDaemon === 'string' && fromDaemon.trim()) {
+        return fromDaemon.trim();
+    }
+    const pid = process.pid;
+    const host = env.HOSTNAME || env.COMPUTERNAME || 'unknown-host';
+    return `conductor-fire-${host}-${pid}`;
+}

package/dist/index.d.ts

@@ -3,7 +3,5 @@ export * from './backend/index.js';
 export * from './ws/index.js';
 export * from './session/index.js';
 export * from './message/index.js';
+export * from './client.js';
 export * from './context/index.js';
-export * from './mcp/index.js';
-export * from './reporter/index.js';
-export * from './orchestrator.js';

package/dist/index.js

@@ -3,7 +3,5 @@ export * from './backend/index.js';
 export * from './ws/index.js';
 export * from './session/index.js';
 export * from './message/index.js';
+export * from './client.js';
 export * from './context/index.js';
-export * from './mcp/index.js';
-export * from './reporter/index.js';
-export * from './orchestrator.js';

package/dist/message/router.d.ts

@@ -1,12 +1,14 @@
 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 interface MessageNotifier {
+    notifyNewMessage(taskId: string): Promise<void>;
+}
 export declare class MessageRouter {
     private readonly sessions;
     private readonly notifier?;
     private readonly outboundHandlers;
-    constructor(sessions: SessionManager, notifier?: MCPNotifier | undefined);
+    constructor(sessions: SessionManager, notifier?: MessageNotifier | undefined);
     registerOutboundHandler(handler: OutboundHandler): void;
     handleBackendEvent(payload: BackendPayload): Promise<void>;
     sendToBackend(payload: BackendPayload): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@love-moon/conductor-sdk",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -17,7 +17,6 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.23.0",
     "ws": "^8.18.0",
     "yaml": "^2.6.0",
     "zod": "^3.24.1"

package/dist/bin/mcp-server.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/bin/mcp-server.js

@@ -1,222 +0,0 @@
-#!/usr/bin/env node
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
-import { loadConfig, SessionManager, MessageRouter, BackendApiClient, ConductorWebSocketClient, MCPServer, EventReporter, SDKOrchestrator, MCPNotifier, } from '../index.js';
-async function main() {
-    const config = loadConfig();
-    const sessions = new SessionManager();
-    const notifier = new MCPNotifier();
-    const router = new MessageRouter(sessions, notifier);
-    const backendApi = new BackendApiClient(config);
-    const configuredAgentHost = typeof process.env.CONDUCTOR_AGENT_NAME === 'string' && process.env.CONDUCTOR_AGENT_NAME.trim()
-        ? process.env.CONDUCTOR_AGENT_NAME.trim()
-        : typeof process.env.CONDUCTOR_DAEMON_NAME === 'string' && process.env.CONDUCTOR_DAEMON_NAME.trim()
-            ? process.env.CONDUCTOR_DAEMON_NAME.trim()
-            : defaultConductorFireHostName();
-    const wsClient = new ConductorWebSocketClient(config, { hostName: configuredAgentHost });
-    const backendSender = async (envelope) => {
-        await wsClient.sendJson(envelope);
-    };
-    const reporter = new EventReporter(backendSender);
-    const mcpServerLogic = new MCPServer(config, {
-        sessionManager: sessions,
-        messageRouter: router,
-        backendSender,
-        backendApi,
-        agentHost: configuredAgentHost,
-    });
-    const orchestrator = new SDKOrchestrator({
-        wsClient,
-        messageRouter: router,
-        sessionManager: sessions,
-        mcpServer: mcpServerLogic,
-        reporter,
-    });
-    const server = new Server({
-        name: 'conductor-ts',
-        version: '0.1.0',
-    }, {
-        capabilities: {
-            tools: {},
-        },
-    });
-    server.setRequestHandler(ListToolsRequestSchema, async () => {
-        return {
-            tools: [
-                {
-                    name: 'create_task_session',
-                    description: 'Create a new task session',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            project_id: { type: 'string' },
-                            task_title: { type: 'string' },
-                            agent_host: { type: 'string' },
-                            prefill: { type: 'string' },
-                            project_path: { type: 'string' },
-                        },
-                        required: ['project_id'],
-                    },
-                },
-                {
-                    name: 'list_projects',
-                    description: 'List available projects',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {},
-                    },
-                },
-                {
-                    name: 'create_project',
-                    description: 'Create a project',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            name: { type: 'string' },
-                            description: { type: 'string' },
-                            metadata: { type: 'object' },
-                        },
-                        required: ['name'],
-                    },
-                },
-                {
-                    name: 'list_tasks',
-                    description: 'List tasks',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            project_id: { type: 'string' },
-                            status: { type: 'string' },
-                        },
-                    },
-                },
-                {
-                    name: 'send_message',
-                    description: 'Send a message to a task',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            task_id: { type: 'string' },
-                            content: { type: 'string' },
-                            metadata: { type: 'object' },
-                        },
-                        required: ['task_id', 'content'],
-                    },
-                },
-                {
-                    name: 'send_task_status',
-                    description: 'Send a terminal or lifecycle task status update',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            task_id: { type: 'string' },
-                            status: { type: 'string' },
-                            summary: { type: 'string' },
-                        },
-                        required: ['task_id', 'status'],
-                    },
-                },
-                {
-                    name: 'send_runtime_status',
-                    description: 'Send a runtime status update to a task',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            task_id: { type: 'string' },
-                            state: { type: 'string' },
-                            phase: { type: 'string' },
-                            source: { type: 'string' },
-                            reply_in_progress: { type: 'boolean' },
-                            status_line: { type: 'string' },
-                            status_done_line: { type: 'string' },
-                            reply_preview: { type: 'string' },
-                            reply_to: { type: 'string' },
-                            backend: { type: 'string' },
-                            thread_id: { type: 'string' },
-                            created_at: { type: 'string' },
-                        },
-                        required: ['task_id'],
-                    },
-                },
-                {
-                    name: 'receive_messages',
-                    description: 'Receive messages from a task',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            task_id: { type: 'string' },
-                            limit: { type: 'number' },
-                        },
-                        required: ['task_id'],
-                    },
-                },
-                {
-                    name: 'ack_messages',
-                    description: 'Acknowledge messages',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            task_id: { type: 'string' },
-                            ack_token: { type: 'string' },
-                        },
-                        required: ['task_id', 'ack_token'],
-                    },
-                },
-                {
-                    name: 'get_local_project_id',
-                    description: 'Get project ID for local path',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            project_path: { type: 'string' },
-                        },
-                    },
-                },
-            ],
-        };
-    });
-    server.setRequestHandler(CallToolRequestSchema, async (request) => {
-        const { name, arguments: args } = request.params;
-        try {
-            const result = await mcpServerLogic.handleRequest(name, args || {});
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify(result),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-                isError: true,
-            };
-        }
-    });
-    await orchestrator.start();
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-    // Keep alive
-    process.on('SIGINT', async () => {
-        await orchestrator.stop();
-        await server.close();
-        process.exit(0);
-    });
-}
-function defaultConductorFireHostName() {
-    const pid = process.pid;
-    const host = process.env.HOSTNAME || process.env.COMPUTERNAME || 'unknown-host';
-    return `conductor-fire-${host}-${pid}`;
-}
-main().catch((err) => {
-    console.error(err);
-    process.exit(1);
-});

package/dist/mcp/index.d.ts

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

package/dist/mcp/index.js

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

package/dist/mcp/notifications.d.ts

@@ -1,20 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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' | 'matchProjectByPath' | 'getProject' | 'updateProject'>;
-    sessionStore?: SessionDiskStore;
-    env?: Record<string, string | undefined>;
-    agentHost?: string;
-}
-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 toolSendTaskStatus;
-    private toolSendRuntimeStatus;
-    private toolReceiveMessages;
-    private toolAckMessages;
-    private toolListProjects;
-    private toolCreateProject;
-    private toolListTasks;
-    private toolGetLocalProjectId;
-    private toolMatchProjectByPath;
-    private toolBindProjectPath;
-    private resolveHostname;
-    private waitForTaskCreation;
-    private readIntEnv;
-}
-export {};

package/dist/orchestrator.d.ts

@@ -1,21 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

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

package/dist/reporter/index.js

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