@love-moon/conductor-sdk 0.1.0

package/dist/backend/client.d.ts

@@ -0,0 +1,62 @@
+import { ConductorConfig } from '../config/index.js';
+export type FetchFn = (input: string, init?: RequestInit) => Promise<Response>;
+export interface BackendClientOptions {
+    fetchImpl?: FetchFn;
+    timeoutMs?: number;
+}
+export declare class BackendApiError extends Error {
+    readonly statusCode?: number | undefined;
+    readonly details?: unknown | undefined;
+    constructor(message: string, statusCode?: number | undefined, details?: unknown | undefined, options?: ErrorOptions);
+}
+export declare class ProjectSummary {
+    readonly id: string;
+    readonly name?: string | undefined;
+    readonly description?: string | null | undefined;
+    constructor(id: string, name?: string | undefined, description?: string | null | undefined);
+    static fromJSON(payload: Record<string, any>): ProjectSummary;
+    asObject(): Record<string, unknown>;
+}
+export declare class TaskSummary {
+    readonly id: string;
+    readonly projectId: string | null;
+    readonly title: string;
+    readonly status: string;
+    readonly createdAt?: string | null | undefined;
+    readonly updatedAt?: string | null | undefined;
+    constructor(id: string, projectId: string | null, title: string, status: string, createdAt?: string | null | undefined, updatedAt?: string | null | undefined);
+    static fromJSON(payload: Record<string, any>): TaskSummary;
+}
+export declare class BackendApiClient {
+    private readonly config;
+    private readonly fetchImpl;
+    private readonly baseUrl;
+    private readonly timeoutMs;
+    constructor(config: ConductorConfig, options?: BackendClientOptions);
+    listProjects(): Promise<ProjectSummary[]>;
+    createProject(params: {
+        name: string;
+        description?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<ProjectSummary>;
+    listTasks(params?: {
+        projectId?: string;
+        status?: string;
+    }): Promise<TaskSummary[]>;
+    createTask(params: {
+        id?: string;
+        projectId: string;
+        title: string;
+        backendType?: string;
+        initialContent?: string;
+    }): Promise<TaskSummary>;
+    createMessage(params: {
+        taskId: string;
+        role: string;
+        content: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<any>;
+    private request;
+    private parseJson;
+    private safeJson;
+}

package/dist/backend/client.js

@@ -0,0 +1,207 @@
+export class BackendApiError extends Error {
+    statusCode;
+    details;
+    constructor(message, statusCode, details, options) {
+        super(message, options);
+        this.statusCode = statusCode;
+        this.details = details;
+    }
+}
+export class ProjectSummary {
+    id;
+    name;
+    description;
+    constructor(id, name, description) {
+        this.id = id;
+        this.name = name;
+        this.description = description;
+    }
+    static fromJSON(payload) {
+        const id = payload.id ? String(payload.id) : '';
+        if (!id) {
+            throw new Error('Project payload missing id');
+        }
+        return new ProjectSummary(id, payload.name ?? undefined, payload.description ?? undefined);
+    }
+    asObject() {
+        return {
+            id: this.id,
+            name: this.name,
+            description: this.description,
+        };
+    }
+}
+export class TaskSummary {
+    id;
+    projectId;
+    title;
+    status;
+    createdAt;
+    updatedAt;
+    constructor(id, projectId, title, status, createdAt, updatedAt) {
+        this.id = id;
+        this.projectId = projectId;
+        this.title = title;
+        this.status = status;
+        this.createdAt = createdAt;
+        this.updatedAt = updatedAt;
+    }
+    static fromJSON(payload) {
+        const id = payload.id ? String(payload.id) : '';
+        if (!id) {
+            throw new Error('Task payload missing id');
+        }
+        const title = payload.title ? String(payload.title) : '';
+        const status = payload.status ? String(payload.status) : '';
+        if (!title || !status) {
+            throw new Error('Task payload missing required fields');
+        }
+        return new TaskSummary(id, payload.project_id ? String(payload.project_id) : null, title, status, payload.created_at ?? null, payload.updated_at ?? null);
+    }
+}
+export class BackendApiClient {
+    config;
+    fetchImpl;
+    baseUrl;
+    timeoutMs;
+    constructor(config, options = {}) {
+        this.config = config;
+        this.fetchImpl = options.fetchImpl ?? globalFetch();
+        this.timeoutMs = options.timeoutMs ?? 10_000;
+        this.baseUrl = config.backendUrl.replace(/\/+$/, '');
+    }
+    async listProjects() {
+        const response = await this.request('GET', '/projects');
+        const payload = await this.parseJson(response);
+        if (!Array.isArray(payload)) {
+            throw new BackendApiError('Invalid projects response: expected list', response.status, payload);
+        }
+        const results = [];
+        for (const entry of payload) {
+            if (!entry || typeof entry !== 'object') {
+                continue;
+            }
+            try {
+                results.push(ProjectSummary.fromJSON(entry));
+            }
+            catch {
+                continue;
+            }
+        }
+        return results;
+    }
+    async createProject(params) {
+        const response = await this.request('POST', '/projects', {
+            body: JSON.stringify(params),
+        });
+        const payload = await this.parseJson(response);
+        return ProjectSummary.fromJSON(payload);
+    }
+    async listTasks(params = {}) {
+        const query = new URLSearchParams();
+        if (params.projectId) {
+            query.set('project_id', params.projectId);
+        }
+        if (params.status) {
+            query.set('status', params.status);
+        }
+        const response = await this.request('GET', '/tasks', {
+            query,
+        });
+        const payload = await this.parseJson(response);
+        if (!Array.isArray(payload)) {
+            throw new BackendApiError('Invalid tasks response: expected list', response.status, payload);
+        }
+        const tasks = [];
+        for (const entry of payload) {
+            if (!entry || typeof entry !== 'object') {
+                continue;
+            }
+            try {
+                tasks.push(TaskSummary.fromJSON(entry));
+            }
+            catch {
+                continue;
+            }
+        }
+        return tasks;
+    }
+    async createTask(params) {
+        const response = await this.request('POST', '/tasks', {
+            body: JSON.stringify(params),
+        });
+        const payload = await this.parseJson(response);
+        return TaskSummary.fromJSON(payload);
+    }
+    async createMessage(params) {
+        const response = await this.request('POST', `/tasks/${params.taskId}/messages`, {
+            body: JSON.stringify(params),
+        });
+        return this.parseJson(response);
+    }
+    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 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,
+            });
+            if (!response.ok) {
+                const details = await this.safeJson(response);
+                throw new BackendApiError(`Backend responded with ${response.status}`, response.status, details);
+            }
+            return response;
+        }
+        catch (error) {
+            if (error instanceof BackendApiError) {
+                throw error;
+            }
+            throw new BackendApiError(`Backend request failed: ${error instanceof Error ? error.message : String(error)}`, undefined, undefined, error instanceof Error ? { cause: error } : undefined);
+        }
+        finally {
+            if (timeout) {
+                clearTimeout(timeout);
+            }
+        }
+    }
+    async parseJson(response) {
+        try {
+            return await response.json();
+        }
+        catch (error) {
+            throw new BackendApiError('Failed to parse backend response as JSON', response.status, null, {
+                cause: error instanceof Error ? error : undefined,
+            });
+        }
+    }
+    async safeJson(response) {
+        try {
+            return await response.json();
+        }
+        catch {
+            try {
+                return await response.text();
+            }
+            catch {
+                return null;
+            }
+        }
+    }
+}
+function globalFetch() {
+    if (typeof fetch === 'function') {
+        return fetch.bind(globalThis);
+    }
+    throw new Error('Global fetch is not available; provide fetchImpl');
+}

package/dist/backend/index.d.ts

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

package/dist/backend/index.js

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

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

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

package/dist/bin/mcp-server.js

@@ -0,0 +1,175 @@
+#!/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 wsClient = new ConductorWebSocketClient(config);
+    const backendSender = async (envelope) => {
+        await wsClient.sendJson(envelope);
+    };
+    const reporter = new EventReporter(backendSender);
+    const mcpServerLogic = new MCPServer(config, {
+        sessionManager: sessions,
+        messageRouter: router,
+        backendSender,
+        backendApi,
+    });
+    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' },
+                            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: '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);
+    });
+}
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/config/index.d.ts

@@ -0,0 +1,33 @@
+export declare const CONFIG_ENV_VAR = "CONDUCTOR_CONFIG";
+export declare const AGENT_TOKEN_ENV_VAR = "CONDUCTOR_AGENT_TOKEN";
+export declare const BACKEND_URL_ENV_VAR = "CONDUCTOR_BACKEND_URL";
+export declare const WS_URL_ENV_VAR = "CONDUCTOR_WS_URL";
+export declare const LOG_LEVEL_ENV_VAR = "CONDUCTOR_LOG_LEVEL";
+export declare class ConfigError extends Error {
+}
+export declare class ConfigFileNotFound extends ConfigError {
+    readonly filePath: string;
+    constructor(filePath: string);
+}
+export declare class ConfigValidationError extends ConfigError {
+    readonly errors: string[];
+    constructor(errors: string[]);
+}
+export interface ConductorConfigInit {
+    agentToken: string;
+    backendUrl: string;
+    websocketUrl?: string;
+    logLevel?: string;
+}
+export declare class ConductorConfig {
+    readonly agentToken: string;
+    readonly backendUrl: string;
+    readonly websocketUrl?: string;
+    readonly logLevel: string;
+    constructor(init: ConductorConfigInit);
+    get resolvedWebsocketUrl(): string;
+}
+export interface LoadConfigOptions {
+    env?: Record<string, string | undefined>;
+}
+export declare function loadConfig(targetPath?: string, options?: LoadConfigOptions): ConductorConfig;

package/dist/config/index.js

@@ -0,0 +1,152 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import yaml from 'yaml';
+export const CONFIG_ENV_VAR = 'CONDUCTOR_CONFIG';
+export const AGENT_TOKEN_ENV_VAR = 'CONDUCTOR_AGENT_TOKEN';
+export const BACKEND_URL_ENV_VAR = 'CONDUCTOR_BACKEND_URL';
+export const WS_URL_ENV_VAR = 'CONDUCTOR_WS_URL';
+export const LOG_LEVEL_ENV_VAR = 'CONDUCTOR_LOG_LEVEL';
+const DEFAULT_CONFIG_PATH = path.join(os.homedir(), '.conductor', 'config.yaml');
+const ALLOWED_LOG_LEVELS = new Set(['debug', 'info', 'warning', 'error', 'critical']);
+export class ConfigError extends Error {
+}
+export class ConfigFileNotFound extends ConfigError {
+    filePath;
+    constructor(filePath) {
+        super(`Conductor config file not found at ${filePath}`);
+        this.filePath = filePath;
+    }
+}
+export class ConfigValidationError extends ConfigError {
+    errors;
+    constructor(errors) {
+        super(`Invalid Conductor configuration:\n- ${errors.join('\n- ')}`);
+        this.errors = errors;
+    }
+}
+export class ConductorConfig {
+    agentToken;
+    backendUrl;
+    websocketUrl;
+    logLevel;
+    constructor(init) {
+        this.agentToken = init.agentToken;
+        this.backendUrl = init.backendUrl;
+        this.websocketUrl = init.websocketUrl;
+        this.logLevel = (init.logLevel || 'info').toLowerCase();
+    }
+    get resolvedWebsocketUrl() {
+        if (this.websocketUrl) {
+            return this.websocketUrl;
+        }
+        const url = new URL(this.backendUrl);
+        const scheme = url.protocol === 'https:' ? 'wss' : 'ws';
+        return `${scheme}://${url.host}/ws/agent`;
+    }
+}
+export function loadConfig(targetPath, options = {}) {
+    const env = options.env ?? process.env;
+    const configPath = resolveConfigPath(targetPath, env);
+    const rawData = readYaml(configPath);
+    const merged = applyEnvOverrides(rawData, env);
+    const validationErrors = [];
+    const agentToken = normalizeToken(merged.agent_token);
+    if (!agentToken) {
+        validationErrors.push('agent_token: must be provided');
+    }
+    let backendUrl;
+    if (merged.backend_url) {
+        try {
+            backendUrl = new URL(String(merged.backend_url)).toString();
+        }
+        catch {
+            validationErrors.push('backend_url: must be a valid URL');
+        }
+    }
+    else {
+        backendUrl = 'https://api.conductor.local';
+    }
+    const logLevel = normalizeLogLevel(merged.log_level);
+    if (!logLevel) {
+        validationErrors.push(`log_level: must be one of ${Array.from(ALLOWED_LOG_LEVELS).join(', ')}`);
+    }
+    let websocketUrl;
+    if (merged.websocket_url) {
+        try {
+            websocketUrl = new URL(String(merged.websocket_url)).toString();
+        }
+        catch {
+            validationErrors.push('websocket_url: must be a valid URL');
+        }
+    }
+    if (validationErrors.length) {
+        throw new ConfigValidationError(validationErrors);
+    }
+    return new ConductorConfig({
+        agentToken: agentToken,
+        backendUrl: backendUrl,
+        websocketUrl,
+        logLevel: logLevel,
+    });
+}
+function resolveConfigPath(explicitPath, env) {
+    const candidate = explicitPath ||
+        env[CONFIG_ENV_VAR] ||
+        DEFAULT_CONFIG_PATH;
+    const normalized = normalizePath(candidate);
+    if (!fs.existsSync(normalized)) {
+        throw new ConfigFileNotFound(normalized);
+    }
+    return normalized;
+}
+function normalizePath(value) {
+    const expanded = value.startsWith('~')
+        ? path.join(os.homedir(), value.slice(1))
+        : value;
+    return path.resolve(expanded);
+}
+function readYaml(filePath) {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    let parsed;
+    try {
+        parsed = yaml.parse(content) ?? {};
+    }
+    catch (error) {
+        throw new ConfigValidationError([`Failed to parse YAML at ${filePath}: ${String(error)}`]);
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new ConfigValidationError([`Expected mapping at root of ${filePath}`]);
+    }
+    return parsed;
+}
+function applyEnvOverrides(data, env) {
+    const merged = { ...data };
+    if (env[AGENT_TOKEN_ENV_VAR]) {
+        merged.agent_token = env[AGENT_TOKEN_ENV_VAR];
+    }
+    if (env[BACKEND_URL_ENV_VAR]) {
+        merged.backend_url = env[BACKEND_URL_ENV_VAR];
+    }
+    if (env[WS_URL_ENV_VAR]) {
+        merged.websocket_url = env[WS_URL_ENV_VAR];
+    }
+    if (env[LOG_LEVEL_ENV_VAR]) {
+        merged.log_level = env[LOG_LEVEL_ENV_VAR];
+    }
+    return merged;
+}
+function normalizeToken(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed || undefined;
+}
+function normalizeLogLevel(value) {
+    if (typeof value !== 'string') {
+        return 'info';
+    }
+    const lowered = value.trim().toLowerCase();
+    return ALLOWED_LOG_LEVELS.has(lowered) ? lowered : undefined;
+}

package/dist/context/index.d.ts

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

package/dist/context/index.js

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

package/dist/context/project_context.d.ts

@@ -0,0 +1,14 @@
+export interface GuessResult {
+    projectRoot: string;
+    repoRoot?: string;
+}
+export declare class ProjectContext {
+    private readonly root;
+    constructor(targetPath?: string);
+    guess(): GuessResult;
+    listFiles(relativeToRepo?: boolean): string[];
+    readFile(relativePath: string): string;
+    getDiff(staged?: boolean): string;
+    private gitRoot;
+    private gitListFiles;
+}