@lawrence369/loop-cli 0.1.0

package/dist/orchestrator/daemon.d.ts

@@ -0,0 +1,74 @@
+import { EventBus } from "../bus/event-bus.js";
+import { type IpcRequest, type IpcResponse } from "./ipc-server.js";
+/**
+ * Status information for the orchestrator daemon.
+ */
+export interface DaemonStatus {
+    pid: number;
+    uptime: number;
+    agents: number;
+    busEvents: number;
+}
+/**
+ * The OrchestratorDaemon manages the lifecycle of:
+ *   - EventBus (message routing)
+ *   - BusDaemon (queue polling / delivery)
+ *   - IpcServer (Unix socket for commands)
+ *
+ * It persists a PID file and logs to the run directory.
+ */
+export declare class OrchestratorDaemon {
+    readonly projectRoot: string;
+    private readonly loopDir;
+    private readonly runDir;
+    private readonly pidPath;
+    private readonly logPath;
+    private readonly socketPath;
+    private eventBus;
+    private busDaemon;
+    private ipcServer;
+    private startTime;
+    private running;
+    constructor(projectRoot: string);
+    /**
+     * Start the daemon. Initializes bus, starts polling, opens IPC socket.
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the daemon gracefully.
+     */
+    stop(): Promise<void>;
+    /**
+     * Ensure the daemon is running. If not, start it.
+     */
+    ensureRunning(): Promise<void>;
+    /**
+     * Check if the daemon is currently running.
+     */
+    isRunning(): boolean;
+    /**
+     * Get the current daemon status.
+     */
+    getStatus(): Promise<DaemonStatus>;
+    /**
+     * Handle an incoming IPC request.
+     */
+    handleRequest(req: IpcRequest): Promise<IpcResponse>;
+    /**
+     * Get the event bus instance.
+     */
+    getEventBus(): EventBus;
+    /**
+     * Get the PID file path (for external tools to check).
+     */
+    getPidPath(): string;
+    /**
+     * Get the socket path (for IPC clients).
+     */
+    getSocketPath(): string;
+    /**
+     * Get the log path.
+     */
+    getLogPath(): string;
+}
+//# sourceMappingURL=daemon.d.ts.map

package/dist/orchestrator/daemon.js

@@ -0,0 +1,294 @@
+import { join } from "node:path";
+import { EventBus } from "../bus/event-bus.js";
+import { BusDaemon } from "../bus/daemon.js";
+import { IpcServer } from "./ipc-server.js";
+import { isProcessAlive, writePidFile, readPidFile, removePidFile, setupSignalHandlers, } from "../utils/process.js";
+import { ensureDir } from "../utils/fs.js";
+/**
+ * The OrchestratorDaemon manages the lifecycle of:
+ *   - EventBus (message routing)
+ *   - BusDaemon (queue polling / delivery)
+ *   - IpcServer (Unix socket for commands)
+ *
+ * It persists a PID file and logs to the run directory.
+ */
+export class OrchestratorDaemon {
+    projectRoot;
+    loopDir;
+    runDir;
+    pidPath;
+    logPath;
+    socketPath;
+    eventBus;
+    busDaemon = null;
+    ipcServer = null;
+    startTime = 0;
+    running = false;
+    constructor(projectRoot) {
+        this.projectRoot = projectRoot;
+        this.loopDir = join(projectRoot, ".loop");
+        this.runDir = join(this.loopDir, "run");
+        this.pidPath = join(this.runDir, "loop-daemon.pid");
+        this.logPath = join(this.runDir, "loop-daemon.log");
+        this.socketPath = join(this.runDir, "loop.sock");
+        this.eventBus = new EventBus(projectRoot);
+    }
+    /**
+     * Start the daemon. Initializes bus, starts polling, opens IPC socket.
+     */
+    async start() {
+        if (this.running)
+            return;
+        // Ensure run directory exists
+        await ensureDir(this.runDir);
+        // Check if another daemon is already running
+        const existingPid = readPidFile(this.pidPath);
+        if (existingPid !== null && isProcessAlive(existingPid)) {
+            throw new Error(`Daemon already running (pid=${existingPid})`);
+        }
+        // Initialize the event bus
+        await this.eventBus.init();
+        // Write PID file
+        writePidFile(this.pidPath);
+        this.startTime = Date.now();
+        this.running = true;
+        // Start bus daemon
+        this.busDaemon = new BusDaemon(this.eventBus, { pollIntervalMs: 1000 });
+        await this.busDaemon.start();
+        // Start IPC server
+        this.ipcServer = new IpcServer(this.socketPath, (req) => this.handleRequest(req));
+        await this.ipcServer.start();
+        // Set up signal handlers
+        setupSignalHandlers(async () => {
+            await this.stop();
+        });
+    }
+    /**
+     * Stop the daemon gracefully.
+     */
+    async stop() {
+        if (!this.running)
+            return;
+        this.running = false;
+        // Stop IPC server
+        if (this.ipcServer) {
+            await this.ipcServer.stop();
+            this.ipcServer = null;
+        }
+        // Stop bus daemon
+        if (this.busDaemon) {
+            await this.busDaemon.stop();
+            this.busDaemon = null;
+        }
+        // Shut down event bus
+        await this.eventBus.shutdown();
+        // Remove PID file
+        removePidFile(this.pidPath);
+    }
+    /**
+     * Ensure the daemon is running. If not, start it.
+     */
+    async ensureRunning() {
+        if (this.running)
+            return;
+        const existingPid = readPidFile(this.pidPath);
+        if (existingPid !== null && isProcessAlive(existingPid)) {
+            // Another daemon is running, that's fine
+            return;
+        }
+        await this.start();
+    }
+    /**
+     * Check if the daemon is currently running.
+     */
+    isRunning() {
+        if (this.running)
+            return true;
+        // Also check via PID file (might be running in another process)
+        const pid = readPidFile(this.pidPath);
+        return pid !== null && isProcessAlive(pid);
+    }
+    /**
+     * Get the current daemon status.
+     */
+    async getStatus() {
+        const busStatus = await this.eventBus.status();
+        return {
+            pid: process.pid,
+            uptime: this.startTime > 0 ? Math.floor((Date.now() - this.startTime) / 1000) : 0,
+            agents: busStatus.agents,
+            busEvents: busStatus.events,
+        };
+    }
+    /**
+     * Handle an incoming IPC request.
+     */
+    async handleRequest(req) {
+        // Validate incoming request structure
+        if (!req || typeof req !== "object" || typeof req.type !== "string") {
+            return { success: false, type: "ERROR", error: "Invalid request: missing type" };
+        }
+        if (req.data !== undefined && (typeof req.data !== "object" || req.data === null)) {
+            return { success: false, type: "ERROR", error: "Invalid request: data must be an object" };
+        }
+        // Ensure data is always an object for safe property access
+        if (!req.data)
+            req.data = {};
+        try {
+            switch (req.type) {
+                case "STATUS": {
+                    const status = await this.getStatus();
+                    const busStatus = await this.eventBus.status();
+                    return {
+                        success: true,
+                        type: "STATUS",
+                        data: {
+                            ...status,
+                            agentList: busStatus.agentList,
+                        },
+                    };
+                }
+                case "REGISTER_AGENT": {
+                    const agentType = String(req.data.agent_type ?? "claude");
+                    const subscriberId = await this.eventBus.join(agentType, {
+                        nickname: req.data.nickname,
+                        pid: req.data.pid,
+                        tty: req.data.tty,
+                        launch_mode: req.data.launch_mode,
+                    });
+                    return {
+                        success: true,
+                        type: "REGISTER_AGENT",
+                        data: { subscriber_id: subscriberId },
+                    };
+                }
+                case "AGENT_READY": {
+                    const subscriberId = String(req.data.subscriber_id ?? "");
+                    await this.eventBus.getSubscriberManager().updateMetadata(subscriberId, {
+                        activity_state: "idle",
+                        last_seen: new Date().toISOString(),
+                    });
+                    return {
+                        success: true,
+                        type: "AGENT_READY",
+                        data: { subscriber_id: subscriberId },
+                    };
+                }
+                case "AGENT_REPORT": {
+                    const subscriberId = String(req.data.subscriber_id ?? "");
+                    await this.eventBus.getSubscriberManager().updateMetadata(subscriberId, {
+                        last_seen: new Date().toISOString(),
+                        activity_state: String(req.data.activity_state ?? "working"),
+                    });
+                    return {
+                        success: true,
+                        type: "AGENT_REPORT",
+                        data: { subscriber_id: subscriberId },
+                    };
+                }
+                case "BUS_SEND": {
+                    const publisher = String(req.data.publisher ?? "unknown");
+                    const target = String(req.data.target ?? "");
+                    const message = String(req.data.message ?? "");
+                    const event = await this.eventBus.send(publisher, target, message);
+                    return {
+                        success: true,
+                        type: "BUS_SEND",
+                        data: { seq: event.seq, target: event.target },
+                    };
+                }
+                case "BUS_CHECK": {
+                    const subscriberId = String(req.data.subscriber_id ?? "");
+                    const events = await this.eventBus.check(subscriberId);
+                    return {
+                        success: true,
+                        type: "BUS_CHECK",
+                        data: {
+                            subscriber_id: subscriberId,
+                            count: events.length,
+                            events: events,
+                        },
+                    };
+                }
+                case "LAUNCH_AGENT": {
+                    // Placeholder - actual agent launching is handled by the agent launcher
+                    return {
+                        success: true,
+                        type: "LAUNCH_AGENT",
+                        data: { message: "Agent launch request received" },
+                    };
+                }
+                case "CLOSE_AGENT": {
+                    const subscriberId = String(req.data.subscriber_id ?? req.data.agent_id ?? "");
+                    await this.eventBus.leave(subscriberId);
+                    return {
+                        success: true,
+                        type: "CLOSE_AGENT",
+                        data: { subscriber_id: subscriberId },
+                    };
+                }
+                case "RESUME_AGENTS": {
+                    return {
+                        success: true,
+                        type: "RESUME_AGENTS",
+                        data: { message: "Resume request received" },
+                    };
+                }
+                case "LAUNCH_GROUP": {
+                    return {
+                        success: true,
+                        type: "LAUNCH_GROUP",
+                        data: { message: "Group launch request received" },
+                    };
+                }
+                case "STOP_GROUP": {
+                    return {
+                        success: true,
+                        type: "STOP_GROUP",
+                        data: { message: "Group stop request received" },
+                    };
+                }
+                default: {
+                    return {
+                        success: false,
+                        type: "ERROR",
+                        error: `Unknown request type: ${req.type}`,
+                    };
+                }
+            }
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return {
+                success: false,
+                type: req.type,
+                error: message,
+            };
+        }
+    }
+    /**
+     * Get the event bus instance.
+     */
+    getEventBus() {
+        return this.eventBus;
+    }
+    /**
+     * Get the PID file path (for external tools to check).
+     */
+    getPidPath() {
+        return this.pidPath;
+    }
+    /**
+     * Get the socket path (for IPC clients).
+     */
+    getSocketPath() {
+        return this.socketPath;
+    }
+    /**
+     * Get the log path.
+     */
+    getLogPath() {
+        return this.logPath;
+    }
+}
+//# sourceMappingURL=daemon.js.map

package/dist/orchestrator/group.d.ts

@@ -0,0 +1,73 @@
+import { OrchestratorDaemon } from "./daemon.js";
+/**
+ * Describes a single agent within a group.
+ */
+export interface GroupAgent {
+    /** Display name / nickname for this agent */
+    name: string;
+    /** Agent engine type (e.g. "claude", "gemini", "codex") */
+    engine: string;
+    /** Optional role description */
+    role?: string;
+}
+/**
+ * Describes a group of agents to be launched together.
+ */
+export interface AgentGroup {
+    /** Unique group name */
+    name: string;
+    /** Agents in this group */
+    agents: GroupAgent[];
+    /** How agents are executed */
+    strategy: "parallel" | "sequential" | "pipeline";
+}
+/** Runtime state for a group member */
+interface GroupMemberState {
+    name: string;
+    engine: string;
+    subscriberId: string;
+    status: "pending" | "active" | "stopped" | "failed";
+    launchedAt: string;
+    stoppedAt: string;
+}
+/** Runtime state for a group */
+interface GroupState {
+    name: string;
+    status: "starting" | "active" | "stopped" | "failed";
+    strategy: "parallel" | "sequential" | "pipeline";
+    members: GroupMemberState[];
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * Orchestrates groups of agents: launching them according to a strategy,
+ * tracking their lifecycle, and stopping them together.
+ */
+export declare class GroupOrchestrator {
+    private readonly daemon;
+    private groups;
+    constructor(daemon: OrchestratorDaemon);
+    /**
+     * Launch a group of agents.
+     * Returns the subscriber IDs of all launched agents.
+     */
+    launchGroup(group: AgentGroup): Promise<string[]>;
+    /**
+     * Stop all agents in a group.
+     */
+    stopGroup(name: string): Promise<void>;
+    /**
+     * List all known groups and their current state.
+     */
+    listGroups(): Promise<AgentGroup[]>;
+    /**
+     * Get the state of a specific group.
+     */
+    getGroupState(name: string): GroupState | undefined;
+    /**
+     * Launch a single agent on the bus, returning its subscriber ID.
+     */
+    private launchSingleAgent;
+}
+export {};
+//# sourceMappingURL=group.d.ts.map

package/dist/orchestrator/group.js

@@ -0,0 +1,166 @@
+/**
+ * Orchestrates groups of agents: launching them according to a strategy,
+ * tracking their lifecycle, and stopping them together.
+ */
+export class GroupOrchestrator {
+    daemon;
+    groups = new Map();
+    constructor(daemon) {
+        this.daemon = daemon;
+    }
+    /**
+     * Launch a group of agents.
+     * Returns the subscriber IDs of all launched agents.
+     */
+    async launchGroup(group) {
+        const eventBus = this.daemon.getEventBus();
+        const now = new Date().toISOString();
+        const state = {
+            name: group.name,
+            status: "starting",
+            strategy: group.strategy,
+            members: group.agents.map((agent) => ({
+                name: agent.name,
+                engine: agent.engine,
+                subscriberId: "",
+                status: "pending",
+                launchedAt: "",
+                stoppedAt: "",
+            })),
+            createdAt: now,
+            updatedAt: now,
+        };
+        this.groups.set(group.name, state);
+        const subscriberIds = [];
+        try {
+            switch (group.strategy) {
+                case "parallel": {
+                    // Launch all agents concurrently
+                    const promises = group.agents.map(async (agent, idx) => {
+                        const subscriberId = await this.launchSingleAgent(eventBus, agent);
+                        const member = state.members[idx];
+                        if (member) {
+                            member.subscriberId = subscriberId;
+                            member.status = "active";
+                            member.launchedAt = new Date().toISOString();
+                        }
+                        return subscriberId;
+                    });
+                    const results = await Promise.allSettled(promises);
+                    for (let i = 0; i < results.length; i++) {
+                        const result = results[i];
+                        if (result.status === "fulfilled") {
+                            subscriberIds.push(result.value);
+                        }
+                        else {
+                            const member = state.members[i];
+                            if (member) {
+                                member.status = "failed";
+                            }
+                        }
+                    }
+                    break;
+                }
+                case "sequential":
+                case "pipeline": {
+                    // Launch agents one at a time in order
+                    for (let i = 0; i < group.agents.length; i++) {
+                        const agent = group.agents[i];
+                        const member = state.members[i];
+                        try {
+                            const subscriberId = await this.launchSingleAgent(eventBus, agent);
+                            member.subscriberId = subscriberId;
+                            member.status = "active";
+                            member.launchedAt = new Date().toISOString();
+                            subscriberIds.push(subscriberId);
+                        }
+                        catch {
+                            member.status = "failed";
+                            // For pipeline, stop on first failure
+                            if (group.strategy === "pipeline") {
+                                state.status = "failed";
+                                state.updatedAt = new Date().toISOString();
+                                this.groups.set(group.name, state);
+                                return subscriberIds;
+                            }
+                        }
+                    }
+                    break;
+                }
+            }
+            // Determine overall group status
+            const allActive = state.members.every((m) => m.status === "active");
+            const anyFailed = state.members.some((m) => m.status === "failed");
+            state.status = allActive ? "active" : anyFailed ? "failed" : "active";
+            state.updatedAt = new Date().toISOString();
+            this.groups.set(group.name, state);
+        }
+        catch (err) {
+            state.status = "failed";
+            state.updatedAt = new Date().toISOString();
+            this.groups.set(group.name, state);
+            throw err;
+        }
+        return subscriberIds;
+    }
+    /**
+     * Stop all agents in a group.
+     */
+    async stopGroup(name) {
+        const state = this.groups.get(name);
+        if (!state) {
+            throw new Error(`Group "${name}" not found`);
+        }
+        const eventBus = this.daemon.getEventBus();
+        // Stop in reverse order
+        for (let i = state.members.length - 1; i >= 0; i--) {
+            const member = state.members[i];
+            if (member.status !== "active" || !member.subscriberId)
+                continue;
+            try {
+                await eventBus.leave(member.subscriberId);
+                member.status = "stopped";
+                member.stoppedAt = new Date().toISOString();
+            }
+            catch {
+                // Best effort - continue stopping others
+            }
+        }
+        state.status = "stopped";
+        state.updatedAt = new Date().toISOString();
+        this.groups.set(name, state);
+    }
+    /**
+     * List all known groups and their current state.
+     */
+    async listGroups() {
+        const groups = [];
+        for (const state of this.groups.values()) {
+            groups.push({
+                name: state.name,
+                strategy: state.strategy,
+                agents: state.members.map((m) => ({
+                    name: m.name,
+                    engine: m.engine,
+                })),
+            });
+        }
+        return groups;
+    }
+    /**
+     * Get the state of a specific group.
+     */
+    getGroupState(name) {
+        return this.groups.get(name);
+    }
+    /**
+     * Launch a single agent on the bus, returning its subscriber ID.
+     */
+    async launchSingleAgent(eventBus, agent) {
+        return eventBus.join(agent.engine, {
+            nickname: agent.name,
+            activity_state: "starting",
+        });
+    }
+}
+//# sourceMappingURL=group.js.map

package/dist/orchestrator/ipc-server.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Request types the IPC server handles.
+ */
+export type IpcRequestType = "REGISTER_AGENT" | "AGENT_READY" | "AGENT_REPORT" | "LAUNCH_AGENT" | "CLOSE_AGENT" | "RESUME_AGENTS" | "STATUS" | "BUS_SEND" | "BUS_CHECK" | "LAUNCH_GROUP" | "STOP_GROUP";
+/**
+ * Incoming IPC request.
+ */
+export interface IpcRequest {
+    type: IpcRequestType;
+    data: Record<string, unknown>;
+}
+/**
+ * Outgoing IPC response.
+ */
+export interface IpcResponse {
+    success: boolean;
+    type: string;
+    data?: Record<string, unknown>;
+    error?: string;
+}
+/** Handler function signature for processing requests. */
+export type IpcRequestHandler = (req: IpcRequest) => Promise<IpcResponse>;
+/**
+ * Unix domain socket IPC server.
+ *
+ * Protocol: newline-delimited JSON (each message is a JSON object
+ * followed by a newline character).
+ */
+export declare class IpcServer {
+    private readonly socketPath;
+    private readonly handler;
+    private server;
+    private sockets;
+    constructor(socketPath: string, handler: IpcRequestHandler);
+    /**
+     * Start listening on the Unix socket.
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the IPC server and close all connections.
+     */
+    stop(): Promise<void>;
+    /**
+     * Send a message to all connected clients.
+     */
+    broadcast(payload: IpcResponse): void;
+    /**
+     * Get the number of connected clients.
+     */
+    get clientCount(): number;
+    /**
+     * Handle a new socket connection.
+     */
+    private handleConnection;
+    /**
+     * Process a single JSON line from a client.
+     */
+    private processLine;
+}
+//# sourceMappingURL=ipc-server.d.ts.map