@lawrence369/loop-cli 0.1.0

package/dist/agent/wrapper.js

@@ -0,0 +1,110 @@
+/**
+ * Agent wrapper — entry point for lclaude / lgemini / lcodex binaries.
+ *
+ * Resolves the engine-specific CLI command, launches it through
+ * AgentLauncher, and forwards stdin/stdout for interactive use.
+ */
+import { AgentLauncher } from "./launcher.js";
+const ENGINES = {
+    claude: {
+        command: "claude",
+        defaultArgs: [],
+    },
+    gemini: {
+        command: "gemini",
+        defaultArgs: [],
+    },
+    codex: {
+        command: "codex",
+        defaultArgs: [],
+    },
+};
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+/**
+ * Launch a wrapped agent CLI.
+ *
+ * This function does not return until the agent exits (or is killed).
+ * It sets up the full lifecycle: PtySession, detectors, signal handlers,
+ * and interactive stdin/stdout forwarding.
+ *
+ * @param engineName - One of "claude", "gemini", "codex"
+ * @param extraArgs  - Additional CLI arguments appended after defaults
+ */
+export async function launchWrappedAgent(engineName, extraArgs) {
+    const spec = ENGINES[engineName];
+    if (!spec) {
+        console.error(`Unknown engine: ${engineName}`);
+        console.error(`Supported engines: ${Object.keys(ENGINES).join(", ")}`);
+        process.exit(1);
+    }
+    const args = [...spec.defaultArgs, ...(extraArgs ?? [])];
+    const cwd = process.cwd();
+    const launcher = new AgentLauncher(cwd);
+    const agent = await launcher.launch({
+        agentType: engineName,
+        command: spec.command,
+        args,
+        cwd,
+        nickname: process.env.LOOP_NICKNAME,
+    });
+    // Forward stdin to the PtySession
+    if (process.stdin.isTTY && typeof process.stdin.setRawMode === "function") {
+        process.stdin.setRawMode(true);
+    }
+    process.stdin.resume();
+    const onStdinData = (data) => {
+        const text = typeof data === "string" ? data : data.toString("utf8");
+        agent.ptySession.write(text);
+    };
+    process.stdin.on("data", onStdinData);
+    // Forward PTY output to stdout
+    agent.ptySession.on("pty-data", (data) => {
+        process.stdout.write(data);
+    });
+    // Handle terminal resize
+    const onResize = () => {
+        if (agent.ptySession.isAlive) {
+            const cols = process.stdout.columns ?? 80;
+            const rows = process.stdout.rows ?? 24;
+            agent.ptySession.resize(cols, rows);
+        }
+    };
+    if (process.stdout.isTTY) {
+        process.stdout.on("resize", onResize);
+    }
+    // Wait for exit
+    return new Promise((resolve) => {
+        agent.ptySession.on("exit", async (code) => {
+            try {
+                // Clean up stdin
+                process.stdin.removeListener("data", onStdinData);
+                if (process.stdin.isTTY && typeof process.stdin.setRawMode === "function") {
+                    try {
+                        process.stdin.setRawMode(false);
+                    }
+                    catch {
+                        // May fail if stream is already closed
+                    }
+                }
+                // Clean up resize handler
+                if (process.stdout.isTTY) {
+                    process.stdout.removeListener("resize", onResize);
+                }
+                // Run cleanup (detectors, logger, sockets)
+                await agent.cleanup();
+                // Exit with the agent's code
+                process.exitCode = code;
+                resolve();
+            }
+            catch (err) {
+                // Prevent unhandled rejection from async exit handler
+                console.error("Exit handler error:", err instanceof Error ? err.message : String(err));
+                process.exitCode = code || 1;
+                resolve();
+            }
+        });
+    });
+}
+//# sourceMappingURL=wrapper.js.map

package/dist/bin/lclaude.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=lclaude.d.ts.map

package/dist/bin/lclaude.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { launchWrappedAgent } from "../agent/wrapper.js";
+launchWrappedAgent("claude", process.argv.slice(2)).catch((err) => {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+});
+//# sourceMappingURL=lclaude.js.map

package/dist/bin/lcodex.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=lcodex.d.ts.map

package/dist/bin/lcodex.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { launchWrappedAgent } from "../agent/wrapper.js";
+launchWrappedAgent("codex", process.argv.slice(2)).catch((err) => {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+});
+//# sourceMappingURL=lcodex.js.map

package/dist/bin/lgemini.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=lgemini.d.ts.map

package/dist/bin/lgemini.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { launchWrappedAgent } from "../agent/wrapper.js";
+launchWrappedAgent("gemini", process.argv.slice(2)).catch((err) => {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+});
+//# sourceMappingURL=lgemini.js.map

package/dist/bus/daemon.d.ts

@@ -0,0 +1,56 @@
+import { EventBus } from "./event-bus.js";
+/**
+ * Options for the BusDaemon.
+ */
+export interface BusDaemonOptions {
+    /** Polling interval in milliseconds. Default: 1000 */
+    pollIntervalMs?: number;
+    /** How often (in poll cycles) to run cleanup. Default: 5 */
+    cleanupEveryNCycles?: number;
+}
+/**
+ * Background daemon that polls subscriber queues and delivers messages.
+ *
+ * In the ufoo model, the daemon checks for pending messages in queue
+ * directories and delivers them to agents (via injection). In this
+ * simplified version, the daemon:
+ *
+ * 1. Periodically cleans up dead agents
+ * 2. Monitors queue directories for pending messages
+ * 3. Emits delivery notifications
+ */
+export declare class BusDaemon {
+    private readonly eventBus;
+    private readonly pollIntervalMs;
+    private readonly cleanupEveryNCycles;
+    private running;
+    private timer;
+    private cleanupCounter;
+    private lastCounts;
+    constructor(eventBus: EventBus, opts?: BusDaemonOptions);
+    /**
+     * Start the daemon polling loop.
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the daemon.
+     */
+    stop(): Promise<void>;
+    /**
+     * Check if the daemon is currently running.
+     */
+    isRunning(): boolean;
+    /**
+     * Main polling loop.
+     */
+    private pollLoop;
+    /**
+     * Single tick: cleanup + check queues.
+     */
+    private tick;
+    /**
+     * Check all subscriber queues for pending messages.
+     */
+    private checkQueues;
+}
+//# sourceMappingURL=daemon.d.ts.map

package/dist/bus/daemon.js

@@ -0,0 +1,135 @@
+import { readdir, readFile, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { safeNameToSubscriber } from "./store.js";
+/**
+ * Background daemon that polls subscriber queues and delivers messages.
+ *
+ * In the ufoo model, the daemon checks for pending messages in queue
+ * directories and delivers them to agents (via injection). In this
+ * simplified version, the daemon:
+ *
+ * 1. Periodically cleans up dead agents
+ * 2. Monitors queue directories for pending messages
+ * 3. Emits delivery notifications
+ */
+export class BusDaemon {
+    eventBus;
+    pollIntervalMs;
+    cleanupEveryNCycles;
+    running = false;
+    timer = null;
+    cleanupCounter = 0;
+    lastCounts = new Map();
+    constructor(eventBus, opts) {
+        this.eventBus = eventBus;
+        this.pollIntervalMs = opts?.pollIntervalMs ?? 1000;
+        this.cleanupEveryNCycles = opts?.cleanupEveryNCycles ?? 5;
+    }
+    /**
+     * Start the daemon polling loop.
+     */
+    async start() {
+        if (this.running)
+            return;
+        this.running = true;
+        this.pollLoop();
+    }
+    /**
+     * Stop the daemon.
+     */
+    async stop() {
+        this.running = false;
+        if (this.timer !== null) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+    }
+    /**
+     * Check if the daemon is currently running.
+     */
+    isRunning() {
+        return this.running;
+    }
+    /**
+     * Main polling loop.
+     */
+    pollLoop() {
+        if (!this.running)
+            return;
+        this.tick()
+            .catch((err) => {
+            // Log but don't crash
+            const message = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`[bus-daemon] tick error: ${message}\n`);
+        })
+            .finally(() => {
+            if (this.running) {
+                this.timer = setTimeout(() => this.pollLoop(), this.pollIntervalMs);
+            }
+        });
+    }
+    /**
+     * Single tick: cleanup + check queues.
+     */
+    async tick() {
+        // Periodic cleanup
+        this.cleanupCounter++;
+        if (this.cleanupCounter >= this.cleanupEveryNCycles) {
+            this.cleanupCounter = 0;
+            try {
+                const subscriberMgr = this.eventBus.getSubscriberManager();
+                await subscriberMgr.cleanupInactive();
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        }
+        // Check all queues
+        await this.checkQueues();
+    }
+    /**
+     * Check all subscriber queues for pending messages.
+     */
+    async checkQueues() {
+        const queuesDir = join(this.eventBus.busDir, "queues");
+        let entries;
+        try {
+            entries = await readdir(queuesDir);
+        }
+        catch {
+            // Queues dir may not exist yet
+            return;
+        }
+        for (const safeName of entries) {
+            const pendingPath = join(queuesDir, safeName, "pending.jsonl");
+            let fileSize;
+            try {
+                const fileStat = await stat(pendingPath);
+                fileSize = fileStat.size;
+            }
+            catch {
+                continue; // File doesn't exist
+            }
+            if (fileSize === 0)
+                continue;
+            // Count current messages
+            let count = 0;
+            try {
+                const content = await readFile(pendingPath, "utf8");
+                const trimmed = content.trim();
+                count = trimmed ? trimmed.split("\n").length : 0;
+            }
+            catch {
+                continue;
+            }
+            const subscriberId = safeNameToSubscriber(safeName);
+            const lastCount = this.lastCounts.get(safeName) ?? 0;
+            if (count > lastCount) {
+                const now = new Date().toISOString().split("T")[1]?.slice(0, 8) ?? "";
+                process.stderr.write(`[bus-daemon] ${now} New messages for ${subscriberId} (${lastCount} -> ${count})\n`);
+            }
+            this.lastCounts.set(safeName, count);
+        }
+    }
+}
+//# sourceMappingURL=daemon.js.map

package/dist/bus/event-bus.d.ts

@@ -0,0 +1,105 @@
+import { BusStore } from "./store.js";
+import { QueueManager } from "./queue.js";
+import { SubscriberManager, type AgentMetadata } from "./subscriber.js";
+import { MessageManager } from "./message.js";
+/**
+ * A single event on the bus.
+ */
+export interface BusEvent {
+    seq: number;
+    timestamp: string;
+    type: string;
+    event: string;
+    publisher: string;
+    target: string;
+    data: Record<string, unknown>;
+}
+/**
+ * Summary status of the bus.
+ */
+export interface BusStatus {
+    id: string;
+    agents: number;
+    events: number;
+    agentList: Array<{
+        id: string;
+        type: string;
+        nickname: string;
+        status: string;
+    }>;
+}
+/**
+ * The main EventBus class. Orchestrates store, queue, subscriber, and
+ * message managers to provide a unified API for agent communication.
+ */
+export declare class EventBus {
+    readonly projectRoot: string;
+    readonly busDir: string;
+    private store;
+    private subscriberManager;
+    private messageManager;
+    private queueManager;
+    constructor(projectRoot: string);
+    /**
+     * Initialize the event bus (create directory structure, etc).
+     */
+    init(): Promise<void>;
+    /**
+     * Gracefully shut down the event bus.
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Send a targeted message from a publisher to a target.
+     */
+    send(publisher: string, target: string, message: string): Promise<BusEvent>;
+    /**
+     * Broadcast a message from a publisher to all active agents.
+     */
+    broadcast(publisher: string, message: string): Promise<BusEvent>;
+    /**
+     * Join an agent to the bus.
+     * Returns the subscriber ID.
+     */
+    join(agentType: string, metadata?: Partial<AgentMetadata>): Promise<string>;
+    /**
+     * Remove an agent from the bus (mark as inactive).
+     */
+    leave(subscriberId: string): Promise<void>;
+    /**
+     * Peek at pending messages for a subscriber without consuming them.
+     */
+    check(subscriberId: string): Promise<BusEvent[]>;
+    /**
+     * Consume (read and clear) pending messages for a subscriber.
+     */
+    consume(subscriberId: string): Promise<BusEvent[]>;
+    /**
+     * Get the current status of the bus.
+     */
+    status(): Promise<BusStatus>;
+    /**
+     * Get all registered agents.
+     */
+    agents(): Promise<Map<string, AgentMetadata>>;
+    /**
+     * Resolve a target to subscriber IDs (exposed for daemon/orchestrator use).
+     */
+    resolveTarget(target: string): Promise<string[]>;
+    /**
+     * Get the subscriber manager (for orchestrator access).
+     */
+    getSubscriberManager(): SubscriberManager;
+    /**
+     * Get the message manager (for orchestrator access).
+     */
+    getMessageManager(): MessageManager;
+    /**
+     * Get the queue manager (for daemon access).
+     */
+    getQueueManager(): QueueManager;
+    /**
+     * Get the store (for direct access when needed).
+     */
+    getStore(): BusStore;
+}
+//# sourceMappingURL=event-bus.d.ts.map

package/dist/bus/event-bus.js

@@ -0,0 +1,157 @@
+import { join, basename } from "node:path";
+import { BusStore } from "./store.js";
+import { QueueManager } from "./queue.js";
+import { SubscriberManager } from "./subscriber.js";
+import { MessageManager } from "./message.js";
+/**
+ * The main EventBus class. Orchestrates store, queue, subscriber, and
+ * message managers to provide a unified API for agent communication.
+ */
+export class EventBus {
+    projectRoot;
+    busDir;
+    store;
+    subscriberManager;
+    messageManager;
+    queueManager;
+    constructor(projectRoot) {
+        this.projectRoot = projectRoot;
+        this.busDir = join(projectRoot, ".loop", "bus");
+        this.store = new BusStore(this.busDir);
+        this.subscriberManager = new SubscriberManager(this.store);
+        this.messageManager = new MessageManager(this.busDir, this.subscriberManager);
+        this.queueManager = new QueueManager(this.busDir);
+    }
+    /**
+     * Initialize the event bus (create directory structure, etc).
+     */
+    async init() {
+        await this.store.init();
+    }
+    /**
+     * Gracefully shut down the event bus.
+     */
+    async shutdown() {
+        // Currently a no-op; future: close file handles, flush buffers
+    }
+    /**
+     * Send a targeted message from a publisher to a target.
+     */
+    async send(publisher, target, message) {
+        return this.messageManager.createEvent(publisher, target, { message }, "message/targeted");
+    }
+    /**
+     * Broadcast a message from a publisher to all active agents.
+     */
+    async broadcast(publisher, message) {
+        return this.messageManager.createEvent(publisher, "*", { message }, "message/broadcast");
+    }
+    /**
+     * Join an agent to the bus.
+     * Returns the subscriber ID.
+     */
+    async join(agentType, metadata) {
+        return this.subscriberManager.register(agentType, metadata);
+    }
+    /**
+     * Remove an agent from the bus (mark as inactive).
+     */
+    async leave(subscriberId) {
+        await this.subscriberManager.unregister(subscriberId);
+    }
+    /**
+     * Peek at pending messages for a subscriber without consuming them.
+     */
+    async check(subscriberId) {
+        // Update last_seen on check
+        try {
+            await this.subscriberManager.updateMetadata(subscriberId, {
+                last_seen: new Date().toISOString(),
+            });
+        }
+        catch {
+            // Ignore - subscriber may not be registered
+        }
+        return this.queueManager.peek(subscriberId);
+    }
+    /**
+     * Consume (read and clear) pending messages for a subscriber.
+     */
+    async consume(subscriberId) {
+        // Update last_seen on consume
+        try {
+            await this.subscriberManager.updateMetadata(subscriberId, {
+                last_seen: new Date().toISOString(),
+            });
+        }
+        catch {
+            // Ignore - subscriber may not be registered
+        }
+        return this.queueManager.dequeue(subscriberId);
+    }
+    /**
+     * Get the current status of the bus.
+     */
+    async status() {
+        // Clean up dead agents first
+        await this.subscriberManager.cleanupInactive();
+        const agents = await this.subscriberManager.list();
+        const totalEvents = await this.store.countEvents();
+        const agentList = [];
+        let activeCount = 0;
+        for (const [id, meta] of agents) {
+            agentList.push({
+                id,
+                type: meta.agent_type,
+                nickname: meta.nickname,
+                status: meta.status,
+            });
+            if (meta.status === "active") {
+                activeCount++;
+            }
+        }
+        return {
+            id: basename(this.projectRoot) || "loop-workspace",
+            agents: activeCount,
+            events: totalEvents,
+            agentList,
+        };
+    }
+    /**
+     * Get all registered agents.
+     */
+    async agents() {
+        return this.subscriberManager.list();
+    }
+    /**
+     * Resolve a target to subscriber IDs (exposed for daemon/orchestrator use).
+     */
+    async resolveTarget(target) {
+        return this.messageManager.resolveTarget(target);
+    }
+    /**
+     * Get the subscriber manager (for orchestrator access).
+     */
+    getSubscriberManager() {
+        return this.subscriberManager;
+    }
+    /**
+     * Get the message manager (for orchestrator access).
+     */
+    getMessageManager() {
+        return this.messageManager;
+    }
+    /**
+     * Get the queue manager (for daemon access).
+     */
+    getQueueManager() {
+        return this.queueManager;
+    }
+    /**
+     * Get the store (for direct access when needed).
+     */
+    getStore() {
+        return this.store;
+    }
+}
+//# sourceMappingURL=event-bus.js.map

package/dist/bus/message.d.ts

@@ -0,0 +1,48 @@
+import { SubscriberManager } from "./subscriber.js";
+import { QueueManager } from "./queue.js";
+import type { BusEvent } from "./event-bus.js";
+/**
+ * Manages message creation, routing, and delivery.
+ *
+ * Target resolution order:
+ *   1. Exact subscriber ID match (e.g. "claude:abc123")
+ *   2. Nickname match (e.g. "claude-1")
+ *   3. Agent type match (e.g. "claude" -> all active claude agents)
+ *   4. Broadcast ("*" -> all active agents)
+ */
+export declare class MessageManager {
+    private readonly eventsDir;
+    private readonly seqFile;
+    private readonly seqLockFile;
+    private readonly subscriberManager;
+    private readonly queueManager;
+    constructor(busDir: string, subscriberManager: SubscriberManager);
+    /**
+     * Get the next monotonically increasing sequence number.
+     */
+    nextSeq(): Promise<number>;
+    /**
+     * Resolve a target string to a list of subscriber IDs.
+     *
+     * Resolution order:
+     *   1. Exact subscriber ID match
+     *   2. Nickname match
+     *   3. Agent type match (all active agents of that type)
+     *   4. Broadcast "*" (all active agents)
+     */
+    resolveTarget(target: string): Promise<string[]>;
+    /**
+     * Route an event to its target subscribers' queues.
+     */
+    route(event: BusEvent): Promise<void>;
+    /**
+     * Create and persist a new event, then route it to targets.
+     * Returns the created event.
+     */
+    createEvent(publisher: string, target: string, data: Record<string, unknown>, type?: string): Promise<BusEvent>;
+    /**
+     * Get the queue manager (needed by EventBus for consume operations).
+     */
+    getQueueManager(): QueueManager;
+}
+//# sourceMappingURL=message.d.ts.map