@love-moon/conductor-sdk 0.2.13 → 0.2.14

package/dist/backend/client.d.ts

@@ -22,9 +22,12 @@ export declare class TaskSummary {
     readonly projectId: string | null;
     readonly title: string;
     readonly status: string;
+    readonly backendType?: string | null | undefined;
+    readonly sessionId?: string | null | undefined;
+    readonly sessionFilePath?: string | null | undefined;
     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);
+    constructor(id: string, projectId: string | null, title: string, status: string, backendType?: string | null | undefined, sessionId?: string | null | undefined, sessionFilePath?: string | null | undefined, createdAt?: string | null | undefined, updatedAt?: string | null | undefined);
     static fromJSON(payload: Record<string, any>): TaskSummary;
 }
 export declare class BackendApiClient {
@@ -48,8 +51,21 @@ export declare class BackendApiClient {
         projectId: string;
         title: string;
         backendType?: string;
+        sessionId?: string | null;
+        sessionFilePath?: string | null;
         initialContent?: string;
         agentHost?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<TaskSummary>;
+    updateTask(taskId: string, params: {
+        projectId?: string;
+        title?: string;
+        status?: string;
+        agentHost?: string | null;
+        metadata?: Record<string, unknown> | null;
+        backendType?: string | null;
+        sessionId?: string | null;
+        sessionFilePath?: string | null;
     }): Promise<TaskSummary>;
     createMessage(params: {
         taskId: string;

package/dist/backend/client.js

@@ -36,13 +36,19 @@ export class TaskSummary {
     projectId;
     title;
     status;
+    backendType;
+    sessionId;
+    sessionFilePath;
     createdAt;
     updatedAt;
-    constructor(id, projectId, title, status, createdAt, updatedAt) {
+    constructor(id, projectId, title, status, backendType, sessionId, sessionFilePath, createdAt, updatedAt) {
         this.id = id;
         this.projectId = projectId;
         this.title = title;
         this.status = status;
+        this.backendType = backendType;
+        this.sessionId = sessionId;
+        this.sessionFilePath = sessionFilePath;
         this.createdAt = createdAt;
         this.updatedAt = updatedAt;
     }
@@ -56,7 +62,7 @@ export class TaskSummary {
         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);
+        return new TaskSummary(id, payload.project_id ? String(payload.project_id) : null, title, status, payload.backend_type ?? payload.backendType ?? null, payload.session_id ?? payload.sessionId ?? null, payload.session_file_path ?? payload.sessionFilePath ?? null, payload.created_at ?? null, payload.updated_at ?? null);
     }
 }
 export class BackendApiClient {
@@ -133,6 +139,13 @@ export class BackendApiClient {
         const payload = await this.parseJson(response);
         return TaskSummary.fromJSON(payload);
     }
+    async updateTask(taskId, params) {
+        const response = await this.request('PATCH', `/tasks/${taskId}`, {
+            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),

package/dist/client.d.ts

@@ -3,7 +3,7 @@ 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 BackendApiLike = Pick<BackendApiClient, 'listProjects' | 'createProject' | 'listTasks' | 'createTask' | 'updateTask' | 'matchProjectByPath' | 'getProject' | 'updateProject'>;
 type RealtimeClientLike = Pick<ConductorWebSocketClient, 'registerHandler' | 'connect' | 'disconnect' | 'sendJson'>;
 export interface ConductorClientConnectOptions {
     config?: ConductorConfig;
@@ -81,6 +81,8 @@ export declare class ConductorClient {
     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>>;
+    getLocalTaskRecord(payload?: Record<string, any>): Promise<Record<string, any>>;
+    bindTaskSession(taskId: string, 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;

package/dist/client.js

@@ -3,7 +3,7 @@ import { BackendApiClient } from './backend/index.js';
 import { loadConfig } from './config/index.js';
 import { getPlanLimitMessageFromError } from './limits/index.js';
 import { MessageRouter } from './message/index.js';
-import { SessionDiskStore, SessionManager, currentHostname, currentSessionId } from './session/index.js';
+import { SessionDiskStore, SessionManager, currentHostname } from './session/index.js';
 import { ConductorWebSocketClient } from './ws/index.js';
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 export class ConductorClient {
@@ -75,19 +75,42 @@ export class ConductorClient {
         }
         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);
+        const explicitSessionId = typeof payload.session_id === 'string' && payload.session_id.trim()
+            ? payload.session_id.trim()
+            : null;
+        const explicitSessionFilePath = typeof payload.session_file_path === 'string' && payload.session_file_path.trim()
+            ? payload.session_file_path.trim()
+            : typeof payload.sessionFilePath === 'string' && payload.sessionFilePath.trim()
+                ? payload.sessionFilePath.trim()
+                : null;
+        const explicitDaemonName = typeof payload.daemon_name === 'string' && payload.daemon_name.trim()
+            ? payload.daemon_name.trim()
+            : typeof payload.daemonName === 'string' && payload.daemonName.trim()
+                ? payload.daemonName.trim()
+                : null;
+        const backendType = typeof payload.backend_type === 'string'
+            ? payload.backend_type
+            : typeof payload.backendType === 'string'
+                ? payload.backendType
+                : undefined;
+        const metadata = payload.metadata && typeof payload.metadata === 'object' && !Array.isArray(payload.metadata)
+            ? { ...payload.metadata }
+            : {};
+        if (explicitDaemonName && metadata.daemonName === undefined) {
+            metadata.daemonName = explicitDaemonName;
+        }
+        const logicalSessionId = explicitSessionId || taskId;
+        await this.sessions.addSession(taskId, logicalSessionId, projectId);
         try {
             await this.backendApi.createTask({
                 id: taskId,
                 projectId,
                 title,
-                backendType: typeof payload.backend_type === 'string'
-                    ? payload.backend_type
-                    : typeof payload.backendType === 'string'
-                        ? payload.backendType
-                        : undefined,
+                backendType,
+                sessionId: logicalSessionId,
+                sessionFilePath: explicitSessionFilePath,
                 initialContent: typeof payload.prefill === 'string' ? payload.prefill : undefined,
+                metadata: Object.keys(metadata).length > 0 ? metadata : undefined,
                 agentHost: typeof payload.agent_host === 'string'
                     ? payload.agent_host
                     : typeof payload.agentHost === 'string'
@@ -110,12 +133,14 @@ export class ConductorClient {
             projectId,
             taskId,
             projectPath,
-            sessionId: currentSessionId(this.env),
+            sessionId: logicalSessionId,
+            sessionFilePath: explicitSessionFilePath,
+            backendType,
             hostname: this.resolveHostname(),
         });
         return {
             task_id: taskId,
-            session_id: sessionId,
+            session_id: logicalSessionId,
             app_url: payload.app_url,
         };
     }
@@ -253,6 +278,9 @@ export class ConductorClient {
                 project_id: task.project_id ?? task.projectId ?? null,
                 title: task.title,
                 status: task.status,
+                backend_type: task.backend_type ?? task.backendType ?? null,
+                session_id: task.session_id ?? task.sessionId ?? null,
+                session_file_path: task.session_file_path ?? task.sessionFilePath ?? null,
                 created_at: task.created_at ?? task.createdAt ?? null,
                 updated_at: task.updated_at ?? task.updatedAt ?? null,
             })),
@@ -273,6 +301,80 @@ export class ConductorClient {
             hostname: record.hostname,
         };
     }
+    async getLocalTaskRecord(payload = {}) {
+        const taskId = typeof payload.task_id === 'string' ? payload.task_id.trim() : '';
+        if (!taskId) {
+            throw new Error('task_id is required');
+        }
+        const record = this.sessionStore.findByTaskId(taskId);
+        if (!record) {
+            throw new Error(`No session record found for task ${taskId}`);
+        }
+        return {
+            project_id: record.projectId,
+            task_id: taskId,
+            task_ids: Array.from(record.taskIds),
+            project_path: record.projectPath,
+            session_id: record.sessionId ?? null,
+            session_file_path: record.sessionFilePath ?? null,
+            backend_type: record.backendType ?? null,
+            hostname: record.hostname,
+        };
+    }
+    async bindTaskSession(taskId, payload = {}) {
+        const normalizedTaskId = String(taskId || '').trim();
+        if (!normalizedTaskId) {
+            throw new Error('task_id is required');
+        }
+        const existing = this.sessionStore.findByTaskId(normalizedTaskId);
+        const inMemorySession = await this.sessions.getSession(normalizedTaskId);
+        const projectId = existing?.projectId ||
+            inMemorySession?.projectId ||
+            (typeof payload.project_id === 'string' && payload.project_id.trim() ? payload.project_id.trim() : 'unknown-project');
+        const projectPath = existing?.projectPath ||
+            (typeof payload.project_path === 'string' && payload.project_path
+                ? payload.project_path
+                : this.projectPath);
+        const record = this.sessionStore.upsert({
+            projectId,
+            taskId: normalizedTaskId,
+            projectPath,
+            sessionId: typeof payload.session_id === 'string'
+                ? payload.session_id
+                : payload.session_id === null
+                    ? null
+                    : existing?.sessionId ?? null,
+            sessionFilePath: typeof payload.session_file_path === 'string'
+                ? payload.session_file_path
+                : payload.session_file_path === null
+                    ? null
+                    : existing?.sessionFilePath ?? null,
+            backendType: typeof payload.backend_type === 'string'
+                ? payload.backend_type
+                : payload.backend_type === null
+                    ? null
+                    : existing?.backendType ?? null,
+            hostname: typeof payload.hostname === 'string'
+                ? payload.hostname
+                : existing?.hostname ?? this.resolveHostname(),
+        });
+        if (typeof this.backendApi.updateTask === 'function') {
+            await this.backendApi.updateTask(normalizedTaskId, {
+                backendType: record.backendType ?? null,
+                sessionId: record.sessionId ?? null,
+                sessionFilePath: record.sessionFilePath ?? null,
+            });
+        }
+        return {
+            project_id: record.projectId,
+            task_id: normalizedTaskId,
+            session_id: record.sessionId ?? null,
+            session_file_path: record.sessionFilePath ?? null,
+            backend_type: record.backendType ?? null,
+            project_path: record.projectPath,
+            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

package/dist/config/index.d.ts

@@ -18,12 +18,14 @@ export interface ConductorConfigInit {
     backendUrl: string;
     websocketUrl?: string;
     logLevel?: string;
+    daemonName?: string;
 }
 export declare class ConductorConfig {
     readonly agentToken: string;
     readonly backendUrl: string;
     readonly websocketUrl?: string;
     readonly logLevel: string;
+    readonly daemonName?: string;
     constructor(init: ConductorConfigInit);
     get resolvedWebsocketUrl(): string;
 }

package/dist/config/index.js

@@ -30,11 +30,13 @@ export class ConductorConfig {
     backendUrl;
     websocketUrl;
     logLevel;
+    daemonName;
     constructor(init) {
         this.agentToken = init.agentToken;
         this.backendUrl = init.backendUrl;
         this.websocketUrl = init.websocketUrl;
         this.logLevel = (init.logLevel || 'info').toLowerCase();
+        this.daemonName = normalizeOptionalString(init.daemonName);
     }
     get resolvedWebsocketUrl() {
         if (this.websocketUrl) {
@@ -88,6 +90,7 @@ export function loadConfig(targetPath, options = {}) {
         backendUrl: backendUrl,
         websocketUrl,
         logLevel: logLevel,
+        daemonName: normalizeOptionalString(merged.daemon_name),
     });
 }
 function resolveConfigPath(explicitPath, env) {
@@ -143,6 +146,13 @@ function normalizeToken(value) {
     const trimmed = value.trim();
     return trimmed || undefined;
 }
+function normalizeOptionalString(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed || undefined;
+}
 function normalizeLogLevel(value) {
     if (typeof value !== 'string') {
         return 'info';

package/dist/session/store.d.ts

@@ -7,6 +7,8 @@ export interface SessionRecordInit {
     taskIds: string[];
     projectPath: string;
     sessionId?: string | null;
+    sessionFilePath?: string | null;
+    backendType?: string | null;
     hostname?: string | null;
 }
 export declare class SessionRecord {
@@ -14,6 +16,8 @@ export declare class SessionRecord {
     taskIds: string[];
     projectPath: string;
     sessionId?: string | null;
+    sessionFilePath?: string | null;
+    backendType?: string | null;
     hostname?: string | null;
     constructor(init: SessionRecordInit);
     static fromJSON(payload: Record<string, any>): SessionRecord;
@@ -21,6 +25,7 @@ export declare class SessionRecord {
 }
 export declare class SessionDiskStore {
     private readonly filePath;
+    private readonly lockPath;
     constructor(filePath?: string);
     /**
      * Create a SessionDiskStore for a specific backend URL.
@@ -28,15 +33,22 @@ export declare class SessionDiskStore {
      */
     static forBackendUrl(backendUrl: string): SessionDiskStore;
     load(): SessionRecord[];
+    private loadUnlocked;
     save(records: SessionRecord[]): void;
+    private saveUnlocked;
     findByPath(projectPath: string): SessionRecord | undefined;
+    findByTaskId(taskId: string): SessionRecord | undefined;
     upsert(params: {
         projectId: string;
         taskId: string;
         projectPath: string;
         sessionId?: string | null;
+        sessionFilePath?: string | null;
+        backendType?: string | null;
         hostname?: string | null;
     }): SessionRecord;
+    private withLock;
+    private acquireLock;
 }
 export declare function currentSessionId(env?: Record<string, string | undefined>): string | undefined;
 export declare function currentHostname(): string;

package/dist/session/store.js

@@ -6,17 +6,38 @@ export const DEFAULT_SESSION_DIR = path.join(os.homedir(), '.conductor', 'sessio
 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';
+const SESSION_LOCK_TIMEOUT_MS = 10_000;
+const SESSION_LOCK_RETRY_MS = 50;
+const sleepSync = (ms) => {
+    if (ms <= 0)
+        return;
+    try {
+        const buffer = new SharedArrayBuffer(4);
+        const arr = new Int32Array(buffer);
+        Atomics.wait(arr, 0, 0, ms);
+    }
+    catch {
+        const startedAt = Date.now();
+        while (Date.now() - startedAt < ms) {
+            // busy wait fallback
+        }
+    }
+};
 export class SessionRecord {
     projectId;
     taskIds;
     projectPath;
     sessionId;
+    sessionFilePath;
+    backendType;
     hostname;
     constructor(init) {
         this.projectId = init.projectId;
         this.taskIds = init.taskIds;
         this.projectPath = init.projectPath;
         this.sessionId = init.sessionId ?? null;
+        this.sessionFilePath = init.sessionFilePath ?? null;
+        this.backendType = init.backendType ?? null;
         this.hostname = init.hostname ?? null;
     }
     static fromJSON(payload) {
@@ -32,12 +53,16 @@ export class SessionRecord {
                 ? [rawTasks]
                 : [];
         const sessionId = payload.session_id ? String(payload.session_id) : null;
+        const sessionFilePath = payload.session_file_path ? String(payload.session_file_path) : null;
+        const backendType = payload.backend_type ? String(payload.backend_type) : null;
         const hostname = payload.hostname ? String(payload.hostname) : null;
         return new SessionRecord({
             projectId,
             projectPath,
             taskIds,
             sessionId,
+            sessionFilePath,
+            backendType,
             hostname,
         });
     }
@@ -47,14 +72,18 @@ export class SessionRecord {
             task_id: Array.from(this.taskIds),
             project_path: this.projectPath,
             session_id: this.sessionId,
+            session_file_path: this.sessionFilePath,
+            backend_type: this.backendType,
             hostname: this.hostname,
         };
     }
 }
 export class SessionDiskStore {
     filePath;
+    lockPath;
     constructor(filePath = DEFAULT_SESSION_PATH) {
         this.filePath = path.resolve(filePath);
+        this.lockPath = `${this.filePath}.lock`;
     }
     /**
      * Create a SessionDiskStore for a specific backend URL.
@@ -66,6 +95,9 @@ export class SessionDiskStore {
         return new SessionDiskStore(filePath);
     }
     load() {
+        return this.withLock(() => this.loadUnlocked());
+    }
+    loadUnlocked() {
         if (!fs.existsSync(this.filePath)) {
             return [];
         }
@@ -108,40 +140,116 @@ export class SessionDiskStore {
         }
     }
     save(records) {
+        this.withLock(() => this.saveUnlocked(records));
+    }
+    saveUnlocked(records) {
         const payload = {
             sessions: records.map((record) => record.toJSON()),
         };
         fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
-        fs.writeFileSync(this.filePath, yaml.stringify(payload), 'utf-8');
+        const tempPath = `${this.filePath}.${process.pid}.${Date.now()}.tmp`;
+        fs.writeFileSync(tempPath, yaml.stringify(payload), 'utf-8');
+        fs.renameSync(tempPath, this.filePath);
     }
     findByPath(projectPath) {
         const normalized = path.resolve(projectPath);
         return this.load().find((record) => path.resolve(record.projectPath) === normalized);
     }
+    findByTaskId(taskId) {
+        const normalizedTaskId = String(taskId || '').trim();
+        if (!normalizedTaskId) {
+            return undefined;
+        }
+        return this.load().find((record) => record.taskIds.includes(normalizedTaskId));
+    }
     upsert(params) {
-        const normalized = path.resolve(params.projectPath);
-        const records = this.load();
-        let record = records.find((entry) => path.resolve(entry.projectPath) === normalized);
-        if (!record) {
-            record = new SessionRecord({
-                projectId: params.projectId,
-                taskIds: [params.taskId],
-                projectPath: normalized,
-                sessionId: params.sessionId,
-                hostname: params.hostname,
-            });
-            records.push(record);
+        const normalizedTaskId = String(params.taskId || '').trim();
+        if (!normalizedTaskId) {
+            throw new Error('taskId is required');
         }
-        else {
-            record.projectId = params.projectId;
-            record.sessionId = params.sessionId ?? record.sessionId;
-            record.hostname = params.hostname ?? record.hostname;
-            if (!record.taskIds.includes(params.taskId)) {
-                record.taskIds.push(params.taskId);
+        const normalizedPath = path.resolve(params.projectPath);
+        return this.withLock(() => {
+            const records = this.loadUnlocked();
+            let record = records.find((entry) => entry.taskIds.includes(normalizedTaskId));
+            if (!record) {
+                record = new SessionRecord({
+                    projectId: params.projectId,
+                    taskIds: [normalizedTaskId],
+                    projectPath: normalizedPath,
+                    sessionId: params.sessionId ?? null,
+                    sessionFilePath: params.sessionFilePath ?? null,
+                    backendType: params.backendType ?? null,
+                    hostname: params.hostname,
+                });
+                records.push(record);
+            }
+            else {
+                record.projectId = params.projectId;
+                record.projectPath = normalizedPath;
+                if (!record.taskIds.includes(normalizedTaskId)) {
+                    record.taskIds.push(normalizedTaskId);
+                }
+                if (params.sessionId !== undefined) {
+                    const normalizedSessionId = String(params.sessionId || '').trim();
+                    record.sessionId = normalizedSessionId || null;
+                }
+                if (params.sessionFilePath !== undefined) {
+                    const normalizedSessionFilePath = String(params.sessionFilePath || '').trim();
+                    record.sessionFilePath = normalizedSessionFilePath || null;
+                }
+                if (params.backendType !== undefined) {
+                    const normalizedBackendType = String(params.backendType || '').trim();
+                    record.backendType = normalizedBackendType || null;
+                }
+                if (params.hostname !== undefined) {
+                    const normalizedHostname = String(params.hostname || '').trim();
+                    record.hostname = normalizedHostname || null;
+                }
+            }
+            this.saveUnlocked(records);
+            return record;
+        });
+    }
+    withLock(fn) {
+        const release = this.acquireLock();
+        try {
+            return fn();
+        }
+        finally {
+            release();
+        }
+    }
+    acquireLock() {
+        const startedAt = Date.now();
+        while (true) {
+            try {
+                const fd = fs.openSync(this.lockPath, 'wx');
+                return () => {
+                    try {
+                        fs.closeSync(fd);
+                    }
+                    catch {
+                        // ignore close failure
+                    }
+                    try {
+                        fs.unlinkSync(this.lockPath);
+                    }
+                    catch {
+                        // ignore unlink failure
+                    }
+                };
+            }
+            catch (error) {
+                const code = error.code;
+                if (code !== 'EEXIST') {
+                    throw error;
+                }
+                if (Date.now() - startedAt > SESSION_LOCK_TIMEOUT_MS) {
+                    throw new Error(`Timed out waiting for session store lock: ${this.lockPath}`);
+                }
+                sleepSync(SESSION_LOCK_RETRY_MS);
             }
         }
-        this.save(records);
-        return record;
     }
 }
 export function currentSessionId(env = process.env) {

package/package.json

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