@love-moon/conductor-sdk 0.1.0 → 0.1.4

package/dist/backend/client.d.ts

@@ -56,6 +56,23 @@ export declare class BackendApiClient {
         content: string;
         metadata?: Record<string, unknown>;
     }): Promise<any>;
+    matchProjectByPath(params: {
+        hostname: string;
+        path: string;
+    }): Promise<{
+        project: ProjectSummary | null;
+        matchedPath: string | null;
+    }>;
+    getProject(projectId: string): Promise<{
+        id: string;
+        name?: string;
+        description?: string | null;
+        metadata?: Record<string, unknown>;
+    }>;
+    updateProject(projectId: string, params: {
+        name?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<ProjectSummary>;
     private request;
     private parseJson;
     private safeJson;

package/dist/backend/client.js

@@ -139,6 +139,33 @@ export class BackendApiClient {
         });
         return this.parseJson(response);
     }
+    async matchProjectByPath(params) {
+        const response = await this.request('POST', '/projects/match-path', {
+            body: JSON.stringify(params),
+        });
+        const payload = await this.parseJson(response);
+        return {
+            project: payload.project ? ProjectSummary.fromJSON(payload.project) : null,
+            matchedPath: payload.matched_path ?? null,
+        };
+    }
+    async getProject(projectId) {
+        const response = await this.request('GET', `/projects/${projectId}`);
+        const payload = await this.parseJson(response);
+        return {
+            id: payload.id,
+            name: payload.name,
+            description: payload.description,
+            metadata: payload.metadata ?? undefined,
+        };
+    }
+    async updateProject(projectId, params) {
+        const response = await this.request('PATCH', `/projects/${projectId}`, {
+            body: JSON.stringify(params),
+        });
+        const payload = await this.parseJson(response);
+        return ProjectSummary.fromJSON(payload);
+    }
     async request(method, pathname, opts = {}) {
         const url = new URL(`${this.baseUrl}${pathname}`);
         if (opts.query) {

package/dist/mcp/server.d.ts

@@ -8,7 +8,7 @@ export interface MCPServerOptions {
     sessionManager: SessionManager;
     messageRouter: MessageRouter;
     backendSender: BackendSender;
-    backendApi: Pick<BackendApiClient, 'listProjects' | 'listTasks' | 'createProject' | 'createTask'>;
+    backendApi: Pick<BackendApiClient, 'listProjects' | 'listTasks' | 'createProject' | 'createTask' | 'matchProjectByPath' | 'getProject' | 'updateProject'>;
     sessionStore?: SessionDiskStore;
     env?: Record<string, string | undefined>;
 }
@@ -30,6 +30,8 @@ export declare class MCPServer {
     private toolCreateProject;
     private toolListTasks;
     private toolGetLocalProjectId;
+    private toolMatchProjectByPath;
+    private toolBindProjectPath;
     private resolveHostname;
     private waitForTaskCreation;
     private readIntEnv;

package/dist/mcp/server.js

@@ -10,7 +10,8 @@ export class MCPServer {
     constructor(config, options) {
         this.config = config;
         this.options = options;
-        this.sessionStore = options.sessionStore ?? new SessionDiskStore();
+        // 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,
@@ -21,6 +22,8 @@ export class MCPServer {
             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) {
@@ -154,6 +157,54 @@ export class MCPServer {
             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) {

package/dist/session/store.d.ts

@@ -1,3 +1,4 @@
+export declare const DEFAULT_SESSION_DIR: string;
 export declare const DEFAULT_SESSION_PATH: string;
 export declare const DEFAULT_SESSION_ENV = "CODEX_SESSION_ID";
 export declare const DEFAULT_SESSION_FALLBACK_ENV = "SESSION_ID";
@@ -21,6 +22,11 @@ export declare class SessionRecord {
 export declare class SessionDiskStore {
     private readonly filePath;
     constructor(filePath?: string);
+    /**
+     * Create a SessionDiskStore for a specific backend URL.
+     * Sessions are stored in ~/.conductor/sessions/<host>.yaml
+     */
+    static forBackendUrl(backendUrl: string): SessionDiskStore;
     load(): SessionRecord[];
     save(records: SessionRecord[]): void;
     findByPath(projectPath: string): SessionRecord | undefined;

package/dist/session/store.js

@@ -2,6 +2,7 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import yaml from 'yaml';
+export const DEFAULT_SESSION_DIR = path.join(os.homedir(), '.conductor', 'sessions');
 export const DEFAULT_SESSION_PATH = path.join(os.homedir(), '.conductor', 'session.yaml');
 export const DEFAULT_SESSION_ENV = 'CODEX_SESSION_ID';
 export const DEFAULT_SESSION_FALLBACK_ENV = 'SESSION_ID';
@@ -55,6 +56,15 @@ export class SessionDiskStore {
     constructor(filePath = DEFAULT_SESSION_PATH) {
         this.filePath = path.resolve(filePath);
     }
+    /**
+     * Create a SessionDiskStore for a specific backend URL.
+     * Sessions are stored in ~/.conductor/sessions/<host>.yaml
+     */
+    static forBackendUrl(backendUrl) {
+        const host = extractHostKey(backendUrl);
+        const filePath = path.join(DEFAULT_SESSION_DIR, `${host}.yaml`);
+        return new SessionDiskStore(filePath);
+    }
     load() {
         if (!fs.existsSync(this.filePath)) {
             return [];
@@ -145,3 +155,22 @@ export function currentHostname() {
         return 'unknown';
     }
 }
+/**
+ * Extract a safe filename key from a backend URL.
+ * e.g., "http://localhost:6152" -> "localhost_6152"
+ *       "https://conductor-ai.top" -> "conductor-ai.top"
+ */
+function extractHostKey(backendUrl) {
+    try {
+        const url = new URL(backendUrl);
+        const host = url.hostname;
+        const port = url.port;
+        // Replace unsafe characters for filenames
+        const safeHost = host.replace(/[^a-zA-Z0-9.-]/g, '_');
+        return port ? `${safeHost}_${port}` : safeHost;
+    }
+    catch {
+        // Fallback: sanitize the entire URL
+        return backendUrl.replace(/[^a-zA-Z0-9.-]/g, '_').slice(0, 50);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@love-moon/conductor-sdk",
-  "version": "0.1.0",
+  "version": "0.1.4",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",