@love-moon/conductor-sdk 0.1.0

package/dist/session/manager.d.ts

@@ -0,0 +1,39 @@
+export interface MessageInput {
+    messageId: string;
+    role: string;
+    content: string;
+    ackToken?: string | null;
+}
+export declare class MessageRecord {
+    readonly messageId: string;
+    readonly role: string;
+    readonly content: string;
+    readonly createdAt: Date;
+    readonly ackToken?: string | null;
+    constructor(init: MessageInput);
+}
+export declare class SessionState {
+    readonly taskId: string;
+    readonly sessionId: string;
+    readonly projectId: string;
+    readonly createdAt: Date;
+    lastMessageAt: Date;
+    status: string;
+    pendingMessages: MessageRecord[];
+    ackToken: string | null;
+    constructor(taskId: string, sessionId: string, projectId: string, createdAt?: Date);
+}
+export declare class SessionManager {
+    private readonly sessions;
+    private readonly lock;
+    private readonly messageEvents;
+    addSession(taskId: string, sessionId: string, projectId: string): Promise<SessionState>;
+    getSession(taskId: string): Promise<SessionState | undefined>;
+    addMessage(taskId: string, message: MessageInput): Promise<void>;
+    popMessages(taskId: string, limit?: number): Promise<MessageRecord[]>;
+    waitForMessages(taskId: string, limit?: number): Promise<MessageRecord[]>;
+    ack(taskId: string, ackToken: string): Promise<boolean>;
+    listSessions(): Promise<SessionState[]>;
+    endSession(taskId: string): Promise<void>;
+    private ensureEvent;
+}

package/dist/session/manager.js

@@ -0,0 +1,162 @@
+import { EventEmitter } from 'node:events';
+export class MessageRecord {
+    messageId;
+    role;
+    content;
+    createdAt;
+    ackToken;
+    constructor(init) {
+        this.messageId = init.messageId;
+        this.role = init.role;
+        this.content = init.content;
+        this.ackToken = init.ackToken;
+        this.createdAt = new Date();
+    }
+}
+export class SessionState {
+    taskId;
+    sessionId;
+    projectId;
+    createdAt;
+    lastMessageAt;
+    status = 'ACTIVE';
+    pendingMessages = [];
+    ackToken = null;
+    constructor(taskId, sessionId, projectId, createdAt = new Date()) {
+        this.taskId = taskId;
+        this.sessionId = sessionId;
+        this.projectId = projectId;
+        this.createdAt = createdAt;
+        this.lastMessageAt = createdAt;
+    }
+}
+class AsyncLock {
+    emitter = new EventEmitter();
+    tail = Promise.resolve();
+    async runExclusive(fn) {
+        const run = this.tail.then(fn, fn);
+        this.tail = run
+            .then(() => undefined)
+            .catch(() => undefined);
+        return run;
+    }
+}
+class MessageEvent {
+    waiter;
+    resolver = null;
+    constructor() {
+        this.waiter = this.reset();
+    }
+    async wait() {
+        await this.waiter;
+    }
+    signal() {
+        this.resolver?.();
+        this.waiter = this.reset();
+    }
+    clear() {
+        this.waiter = this.reset();
+    }
+    reset() {
+        return new Promise((resolve) => {
+            this.resolver = resolve;
+        });
+    }
+}
+export class SessionManager {
+    sessions = new Map();
+    lock = new AsyncLock();
+    messageEvents = new Map();
+    async addSession(taskId, sessionId, projectId) {
+        return this.lock.runExclusive(async () => {
+            const state = new SessionState(taskId, sessionId, projectId);
+            this.sessions.set(taskId, state);
+            this.messageEvents.set(taskId, new MessageEvent());
+            return state;
+        });
+    }
+    async getSession(taskId) {
+        return this.lock.runExclusive(async () => this.sessions.get(taskId));
+    }
+    async addMessage(taskId, message) {
+        await this.lock.runExclusive(async () => {
+            const session = this.sessions.get(taskId);
+            if (!session) {
+                return;
+            }
+            const record = new MessageRecord(message);
+            session.pendingMessages.push(record);
+            session.lastMessageAt = record.createdAt;
+            this.ensureEvent(taskId).signal();
+        });
+    }
+    async popMessages(taskId, limit = 20) {
+        return this.lock.runExclusive(async () => {
+            const session = this.sessions.get(taskId);
+            if (!session) {
+                return [];
+            }
+            const items = [];
+            while (session.pendingMessages.length && items.length < limit) {
+                const next = session.pendingMessages.shift();
+                if (next) {
+                    items.push(next);
+                }
+            }
+            if (items.length) {
+                session.ackToken = items[items.length - 1].ackToken ?? null;
+            }
+            const event = this.ensureEvent(taskId);
+            if (session.pendingMessages.length) {
+                event.signal();
+            }
+            else {
+                event.clear();
+            }
+            return items;
+        });
+    }
+    async waitForMessages(taskId, limit = 20) {
+        const event = this.ensureEvent(taskId);
+        // Loop until a batch is available.
+        while (true) {
+            const messages = await this.popMessages(taskId, limit);
+            if (messages.length) {
+                return messages;
+            }
+            await event.wait();
+        }
+    }
+    async ack(taskId, ackToken) {
+        return this.lock.runExclusive(async () => {
+            const session = this.sessions.get(taskId);
+            if (!session) {
+                return false;
+            }
+            if (session.ackToken && session.ackToken === ackToken) {
+                session.ackToken = null;
+                return true;
+            }
+            return false;
+        });
+    }
+    async listSessions() {
+        return this.lock.runExclusive(async () => Array.from(this.sessions.values()));
+    }
+    async endSession(taskId) {
+        await this.lock.runExclusive(async () => {
+            const session = this.sessions.get(taskId);
+            if (session) {
+                session.status = 'ENDED';
+            }
+        });
+    }
+    ensureEvent(taskId) {
+        let event = this.messageEvents.get(taskId);
+        if (!event) {
+            event = new MessageEvent();
+            this.messageEvents.set(taskId, event);
+        }
+        return event;
+    }
+}

package/dist/session/store.d.ts

@@ -0,0 +1,36 @@
+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";
+export interface SessionRecordInit {
+    projectId: string;
+    taskIds: string[];
+    projectPath: string;
+    sessionId?: string | null;
+    hostname?: string | null;
+}
+export declare class SessionRecord {
+    projectId: string;
+    taskIds: string[];
+    projectPath: string;
+    sessionId?: string | null;
+    hostname?: string | null;
+    constructor(init: SessionRecordInit);
+    static fromJSON(payload: Record<string, any>): SessionRecord;
+    toJSON(): Record<string, unknown>;
+}
+export declare class SessionDiskStore {
+    private readonly filePath;
+    constructor(filePath?: string);
+    load(): SessionRecord[];
+    save(records: SessionRecord[]): void;
+    findByPath(projectPath: string): SessionRecord | undefined;
+    upsert(params: {
+        projectId: string;
+        taskId: string;
+        projectPath: string;
+        sessionId?: string | null;
+        hostname?: string | null;
+    }): SessionRecord;
+}
+export declare function currentSessionId(env?: Record<string, string | undefined>): string | undefined;
+export declare function currentHostname(): string;

package/dist/session/store.js

@@ -0,0 +1,147 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import yaml from 'yaml';
+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';
+export class SessionRecord {
+    projectId;
+    taskIds;
+    projectPath;
+    sessionId;
+    hostname;
+    constructor(init) {
+        this.projectId = init.projectId;
+        this.taskIds = init.taskIds;
+        this.projectPath = init.projectPath;
+        this.sessionId = init.sessionId ?? null;
+        this.hostname = init.hostname ?? null;
+    }
+    static fromJSON(payload) {
+        const projectId = payload.project_id ? String(payload.project_id) : '';
+        const projectPath = payload.project_path ? String(payload.project_path) : '';
+        if (!projectId || !projectPath) {
+            throw new Error('Session record missing project_id or project_path');
+        }
+        const rawTasks = payload.task_id || payload.task_ids || [];
+        const taskIds = Array.isArray(rawTasks)
+            ? rawTasks.map((task) => String(task)).filter(Boolean)
+            : typeof rawTasks === 'string'
+                ? [rawTasks]
+                : [];
+        const sessionId = payload.session_id ? String(payload.session_id) : null;
+        const hostname = payload.hostname ? String(payload.hostname) : null;
+        return new SessionRecord({
+            projectId,
+            projectPath,
+            taskIds,
+            sessionId,
+            hostname,
+        });
+    }
+    toJSON() {
+        return {
+            project_id: this.projectId,
+            task_id: Array.from(this.taskIds),
+            project_path: this.projectPath,
+            session_id: this.sessionId,
+            hostname: this.hostname,
+        };
+    }
+}
+export class SessionDiskStore {
+    filePath;
+    constructor(filePath = DEFAULT_SESSION_PATH) {
+        this.filePath = path.resolve(filePath);
+    }
+    load() {
+        if (!fs.existsSync(this.filePath)) {
+            return [];
+        }
+        try {
+            const contents = fs.readFileSync(this.filePath, 'utf-8');
+            const parsed = yaml.parse(contents) ?? {};
+            const entries = Array.isArray(parsed.sessions) ? parsed.sessions : parsed;
+            if (!entries || typeof entries !== 'object') {
+                return [];
+            }
+            const list = [];
+            if (Array.isArray(entries)) {
+                for (const entry of entries) {
+                    if (entry && typeof entry === 'object') {
+                        try {
+                            list.push(SessionRecord.fromJSON(entry));
+                        }
+                        catch {
+                            continue;
+                        }
+                    }
+                }
+            }
+            else if (Array.isArray(entries.sessions)) {
+                for (const entry of entries.sessions) {
+                    if (entry && typeof entry === 'object') {
+                        try {
+                            list.push(SessionRecord.fromJSON(entry));
+                        }
+                        catch {
+                            continue;
+                        }
+                    }
+                }
+            }
+            return list;
+        }
+        catch {
+            return [];
+        }
+    }
+    save(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');
+    }
+    findByPath(projectPath) {
+        const normalized = path.resolve(projectPath);
+        return this.load().find((record) => path.resolve(record.projectPath) === normalized);
+    }
+    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);
+        }
+        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);
+            }
+        }
+        this.save(records);
+        return record;
+    }
+}
+export function currentSessionId(env = process.env) {
+    return env[DEFAULT_SESSION_ENV] || env[DEFAULT_SESSION_FALLBACK_ENV];
+}
+export function currentHostname() {
+    try {
+        return os.hostname();
+    }
+    catch {
+        return 'unknown';
+    }
+}

package/dist/ws/client.d.ts

@@ -0,0 +1,49 @@
+import { ConductorConfig } from '../config/index.js';
+export type WebSocketHandler = (payload: Record<string, any>) => Promise<void> | void;
+export interface WebSocketLike {
+    send(data: string): Promise<void> | void;
+    ping(): Promise<void> | void;
+    close(): Promise<void> | void;
+    closed?: boolean;
+    [Symbol.asyncIterator](): AsyncIterableIterator<string>;
+}
+export interface ConnectOptions {
+    headers: Record<string, string>;
+}
+export type ConnectImpl = (url: string, options: ConnectOptions) => Promise<WebSocketLike>;
+export interface WebSocketClientOptions {
+    reconnectDelay?: number;
+    heartbeatInterval?: number;
+    extraHeaders?: Record<string, string>;
+    connectImpl?: ConnectImpl;
+    hostName?: string;
+}
+export declare class ConductorWebSocketClient {
+    private readonly url;
+    private readonly token;
+    private readonly reconnectDelay;
+    private readonly heartbeatInterval;
+    private readonly connectImpl;
+    private readonly handlers;
+    private readonly extraHeaders;
+    private conn;
+    private stop;
+    private listenTask;
+    private heartbeatTask;
+    private readonly lock;
+    private waitController;
+    constructor(config: ConductorConfig, options?: WebSocketClientOptions);
+    registerHandler(handler: WebSocketHandler): void;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    sendJson(payload: Record<string, any>): Promise<void>;
+    private ensureConnection;
+    private openConnection;
+    private cancelTasks;
+    private listenLoop;
+    private heartbeatLoop;
+    private dispatch;
+    private isConnectionClosed;
+    private sendWithReconnect;
+    private isNotOpenError;
+}