@love-moon/conductor-sdk 0.2.6 → 0.2.8

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,80 @@
+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;
+    onConnected?: (event: {
+        isReconnect: boolean;
+    }) => void;
+    onDisconnected?: () => void;
+}
+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>>;
+    sendAgentResume(payload?: {
+        active_tasks?: string[];
+        source?: string;
+        metadata?: Record<string, any>;
+    }): Promise<Record<string, any>>;
+    sendAgentCommandAck(payload: {
+        request_id: string;
+        task_id?: string;
+        event_type?: string;
+        accepted?: boolean;
+    }): 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 maybeAckInboundCommand;
+    private resolveHostname;
+    private waitForTaskCreation;
+    private readIntEnv;
+}
+export {};

package/dist/client.js

@@ -0,0 +1,391 @@
+import crypto from 'node:crypto';
+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 ConductorClient {
+    config;
+    env;
+    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,
+                onConnected: options.onConnected,
+                onDisconnected: options.onDisconnected,
+            });
+        const client = new ConductorClient({
+            config,
+            env,
+            projectPath,
+            backendApi,
+            wsClient,
+            sessionManager: sessions,
+            sessionStore,
+            messageRouter,
+            agentHost,
+        });
+        await client.wsClient.connect();
+        return client;
+    }
+    async close() {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        await this.wsClient.disconnect();
+    }
+    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 || safeRandomUuid());
+        const sessionId = String(payload.session_id || taskId);
+        await this.sessions.addSession(taskId, sessionId, projectId);
+        await this.backendApi.createTask({
+            id: taskId,
+            projectId,
+            title,
+            backendType: typeof payload.backend_type === 'string'
+                ? payload.backend_type
+                : typeof payload.backendType === 'string'
+                    ? payload.backendType
+                    : undefined,
+            initialContent: typeof payload.prefill === 'string' ? payload.prefill : undefined,
+            agentHost: typeof payload.agent_host === 'string'
+                ? payload.agent_host
+                : typeof payload.agentHost === 'string'
+                    ? payload.agentHost
+                    : this.agentHost,
+        });
+        await this.waitForTaskCreation(projectId, taskId);
+        const projectPath = typeof payload.project_path === 'string' && payload.project_path
+            ? payload.project_path
+            : this.projectPath;
+        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 sendMessage(taskId, content, metadata) {
+        await this.sendEnvelope({
+            type: 'sdk_message',
+            payload: {
+                task_id: taskId,
+                content,
+                metadata,
+            },
+        });
+        return { delivered: true };
+    }
+    async sendTaskStatus(taskId, payload) {
+        await this.sendEnvelope({
+            type: 'task_status_update',
+            payload: {
+                task_id: taskId,
+                status: payload?.status,
+                summary: payload?.summary,
+            },
+        });
+        return { delivered: true };
+    }
+    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,
+            },
+        });
+        return { delivered: true };
+    }
+    async sendAgentResume(payload = {}) {
+        await this.sendEnvelope({
+            type: 'agent_resume',
+            payload: {
+                active_tasks: Array.isArray(payload.active_tasks)
+                    ? payload.active_tasks.map((taskId) => String(taskId)).filter(Boolean)
+                    : [],
+                source: payload.source,
+                metadata: payload.metadata,
+            },
+        });
+        return { delivered: true };
+    }
+    async sendAgentCommandAck(payload) {
+        const requestId = String(payload.request_id || '').trim();
+        if (!requestId) {
+            throw new Error('request_id is required');
+        }
+        await this.sendEnvelope({
+            type: 'agent_command_ack',
+            payload: {
+                request_id: requestId,
+                task_id: payload.task_id,
+                event_type: payload.event_type,
+                accepted: payload.accepted !== false,
+            },
+        });
+        return { delivered: true };
+    }
+    async receiveMessages(taskId, limit = 20) {
+        const messages = await this.sessions.popMessages(taskId, limit);
+        return formatMessagesResponse(messages);
+    }
+    async ackMessages(taskId, ackToken) {
+        if (!ackToken) {
+            return undefined;
+        }
+        const success = await this.sessions.ack(taskId, ackToken);
+        return { status: success ? 'ok' : 'ignored' };
+    }
+    async listProjects() {
+        const projects = await this.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 createProject(name, description, metadata) {
+        const project = await this.backendApi.createProject({ name, description, metadata });
+        return typeof project.asObject === 'function' ? project.asObject() : project;
+    }
+    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,
+        });
+        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 getLocalProjectRecord(payload = {}) {
+        const projectPath = typeof payload.project_path === 'string' && payload.project_path
+            ? payload.project_path
+            : this.projectPath;
+        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,
+        };
+    }
+    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
+            : this.projectPath;
+        const result = await this.backendApi.matchProjectByPath({
+            hostname,
+            path: projectPath,
+        });
+        if (result.project) {
+            return {
+                project_id: result.project.id,
+                project_name: result.project.name,
+                matched_path: result.matchedPath,
+            };
+        }
+        return {
+            project_id: null,
+            project_name: null,
+            matched_path: null,
+        };
+    }
+    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
+            : this.projectPath;
+        const project = await this.backendApi.getProject(projectId);
+        const metadata = (project.metadata || {});
+        const localPaths = (metadata.localPaths || {});
+        localPaths[hostname] = projectPath;
+        metadata.localPaths = localPaths;
+        await this.backendApi.updateProject(projectId, { metadata });
+        return {
+            success: true,
+            hostname,
+            path: projectPath,
+        };
+    }
+    handleBackendEvent = async (payload) => {
+        await this.messageRouter.handleBackendEvent(payload);
+        await this.maybeAckInboundCommand(payload);
+    };
+    async sendEnvelope(envelope) {
+        await this.wsClient.sendJson(envelope);
+    }
+    async maybeAckInboundCommand(payload) {
+        const eventType = typeof payload?.type === 'string' ? payload.type : '';
+        if (eventType !== 'task_user_message' && eventType !== 'task_action') {
+            return;
+        }
+        const data = payload?.payload && typeof payload.payload === 'object'
+            ? payload.payload
+            : null;
+        if (!data) {
+            return;
+        }
+        const requestId = typeof data.request_id === 'string' ? data.request_id.trim() : '';
+        if (!requestId) {
+            return;
+        }
+        try {
+            await this.sendAgentCommandAck({
+                request_id: requestId,
+                task_id: typeof data.task_id === 'string' ? data.task_id : undefined,
+                event_type: eventType,
+                accepted: true,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.warn(`[sdk] failed to ack inbound command ${requestId}: ${message}`);
+        }
+    }
+    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.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(`[sdk] createTaskSession unable to confirm task ${taskId}: ${message}`);
+                return;
+            }
+            if (attempt < retries - 1) {
+                await sleep(delayMs);
+            }
+        }
+        console.warn(`[sdk] createTaskSession 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,
+    };
+}
+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.6",
+  "version": "0.2.8",
   "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/mcp/server.js

@@ -1,313 +0,0 @@
-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;
-        // 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,
-        };
-    }
-    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,
-            backendType: typeof payload.backend_type === 'string'
-                ? payload.backend_type
-                : typeof payload.backendType === 'string'
-                    ? payload.backendType
-                    : undefined,
-            initialContent: payload.prefill,
-            agentHost: typeof payload.agent_host === 'string'
-                ? payload.agent_host
-                : typeof payload.agentHost === 'string'
-                    ? payload.agentHost
-                    : this.options.agentHost,
-        });
-        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 toolSendTaskStatus(payload) {
-        const taskId = String(payload.task_id || '');
-        if (!taskId) {
-            throw new Error('task_id required');
-        }
-        await this.options.backendSender({
-            type: 'task_status_update',
-            payload: {
-                task_id: taskId,
-                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({
-            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,
-            },
-        });
-        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,
-        };
-    }
-    async toolMatchProjectByPath(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({
-            hostname,
-            path: projectPath,
-        });
-        if (result.project) {
-            return {
-                project_id: result.project.id,
-                project_name: result.project.name,
-                matched_path: result.matchedPath,
-            };
-        }
-        return {
-            project_id: null,
-            project_name: null,
-            matched_path: null,
-        };
-    }
-    async toolBindProjectPath(payload) {
-        const projectId = String(payload.project_id || '');
-        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);
-        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 });
-        return {
-            success: true,
-            hostname,
-            path: projectPath,
-        };
-    }
-    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/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';