@lawrence369/loop-cli 0.1.0

package/dist/agent/launcher.js

@@ -0,0 +1,243 @@
+/**
+ * AgentLauncher — unified agent lifecycle manager.
+ *
+ * Handles:
+ *   1. Ensuring the .loop/ project directory exists
+ *   2. Detecting (or using specified) launch mode
+ *   3. Spawning a PtySession via the appropriate terminal adapter
+ *   4. Setting up ReadyDetector + ActivityDetector
+ *   5. Registering with the daemon via IPC (fail-silently if no daemon)
+ *   6. SIGTERM / SIGINT cleanup
+ *
+ * Simplified port of ufoo's launcher.js.
+ */
+import * as fs from "node:fs";
+import * as net from "node:net";
+import * as path from "node:path";
+import { randomUUID } from "node:crypto";
+import { PtySession } from "./pty-session.js";
+import { ActivityDetector } from "./activity.js";
+import { ReadyDetector } from "./ready-detector.js";
+import { detectTerminal } from "../terminal/detect.js";
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function loopDir(projectRoot) {
+    return path.join(projectRoot, ".loop");
+}
+function runDir(projectRoot) {
+    return path.join(loopDir(projectRoot), "run");
+}
+function daemonSocketPath(projectRoot) {
+    return path.join(runDir(projectRoot), "daemon.sock");
+}
+function connectSocket(sockPath) {
+    return new Promise((resolve, reject) => {
+        const client = net.createConnection(sockPath, () => resolve(client));
+        client.on("error", reject);
+    });
+}
+async function connectWithRetry(sockPath, retries, delayMs) {
+    for (let i = 0; i < retries; i += 1) {
+        try {
+            return await connectSocket(sockPath);
+        }
+        catch {
+            await new Promise((r) => setTimeout(r, delayMs));
+        }
+    }
+    return null;
+}
+/**
+ * Best-effort daemon registration.  Returns the subscriber ID from the
+ * daemon or a locally-generated one if the daemon is unreachable.
+ */
+async function registerWithDaemon(projectRoot, agentType, subscriberId, nickname) {
+    const sockPath = daemonSocketPath(projectRoot);
+    const client = await connectWithRetry(sockPath, 3, 200);
+    if (!client)
+        return subscriberId; // daemon not running — proceed anyway
+    return new Promise((resolve) => {
+        let buffer = "";
+        let settled = false;
+        const timeout = setTimeout(() => {
+            if (settled)
+                return;
+            settled = true;
+            try {
+                client.destroy();
+            }
+            catch { /* ignore */ }
+            resolve(subscriberId); // fall back to local ID
+        }, 5_000);
+        const cleanup = () => {
+            clearTimeout(timeout);
+            client.removeAllListeners();
+            try {
+                client.end();
+            }
+            catch { /* ignore */ }
+        };
+        client.on("error", () => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            resolve(subscriberId);
+        });
+        client.on("data", (data) => {
+            buffer += data.toString("utf8");
+            const lines = buffer.split(/\r?\n/);
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                let payload;
+                try {
+                    payload = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                if (payload.type === "register_ok" && typeof payload.subscriberId === "string") {
+                    if (settled)
+                        return;
+                    settled = true;
+                    cleanup();
+                    resolve(payload.subscriberId);
+                    return;
+                }
+                if (payload.type === "error") {
+                    if (settled)
+                        return;
+                    settled = true;
+                    cleanup();
+                    resolve(subscriberId); // fall back
+                    return;
+                }
+            }
+        });
+        const req = {
+            type: "register_agent",
+            agentType,
+            nickname,
+            parentPid: process.pid,
+        };
+        client.write(JSON.stringify(req) + "\n");
+    });
+}
+// ---------------------------------------------------------------------------
+// AgentLauncher
+// ---------------------------------------------------------------------------
+export class AgentLauncher {
+    _projectRoot;
+    constructor(projectRoot) {
+        this._projectRoot = projectRoot;
+    }
+    /**
+     * Launch an agent, returning a handle with the PtySession and detectors.
+     */
+    async launch(opts) {
+        // 1. Ensure .loop/ directory structure
+        const loopRoot = loopDir(this._projectRoot);
+        const run = runDir(this._projectRoot);
+        for (const dir of [loopRoot, run]) {
+            try {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            catch {
+                // May already exist
+            }
+        }
+        // 2. Resolve launch mode
+        const mode = opts.launchMode ?? detectTerminal();
+        // 3. Generate subscriber ID
+        const sessionId = randomUUID().slice(0, 8);
+        const localSubscriberId = `${opts.agentType}:${sessionId}`;
+        // 4. Set environment variables for child process
+        const childEnv = {
+            ...(opts.env ?? {}),
+            LOOP_SUBSCRIBER_ID: localSubscriberId,
+            LOOP_AGENT_TYPE: opts.agentType,
+            LOOP_LAUNCH_MODE: mode,
+        };
+        if (opts.nickname) {
+            childEnv.LOOP_NICKNAME = opts.nickname;
+        }
+        // 5. Create PtySession
+        const ptySession = new PtySession(opts.command, opts.args, {
+            cwd: opts.cwd,
+            env: childEnv,
+            engine: opts.agentType,
+        });
+        // 6. Enable I/O logging
+        ptySession.enableLogging(run);
+        // 7. Enable inject socket
+        const injectSocketDir = path.join(loopRoot, "sockets");
+        const sanitizedId = localSubscriberId.replace(/:/g, "_");
+        const injectSockPath = path.join(injectSocketDir, `${sanitizedId}.sock`);
+        ptySession.enableInjectSocket(injectSockPath);
+        // 8. Set up detectors
+        const readyDetector = new ReadyDetector(ptySession);
+        const activityDetector = new ActivityDetector(ptySession, opts.agentType);
+        // Force-ready fallback after 10 seconds
+        const forceReadyTimer = setTimeout(() => {
+            readyDetector.forceReady();
+        }, 10_000);
+        if (typeof forceReadyTimer.unref === "function") {
+            forceReadyTimer.unref();
+        }
+        // 9. Register with daemon (best-effort, non-blocking)
+        const subscriberId = await registerWithDaemon(this._projectRoot, opts.agentType, localSubscriberId, opts.nickname ?? "");
+        // 10. Notify daemon when ready
+        readyDetector.onReady(() => {
+            clearTimeout(forceReadyTimer);
+            const sockPath = daemonSocketPath(this._projectRoot);
+            connectWithRetry(sockPath, 2, 100).then((client) => {
+                if (!client)
+                    return;
+                client.write(JSON.stringify({
+                    type: "agent_ready",
+                    subscriberId,
+                }) + "\n");
+                client.end();
+            }).catch(() => {
+                // Daemon notification failure is non-fatal
+            });
+        });
+        // 11. Build cleanup function
+        let cleaned = false;
+        const cleanup = async () => {
+            if (cleaned)
+                return;
+            cleaned = true;
+            clearTimeout(forceReadyTimer);
+            activityDetector.destroy();
+            readyDetector.destroy();
+            ptySession.destroy();
+        };
+        // 12. Signal handlers (stored for cleanup to prevent accumulation)
+        let signalHandled = false;
+        const handleSignal = (signal) => {
+            if (signalHandled)
+                return;
+            signalHandled = true;
+            const code = signal === "SIGTERM" ? 143 : 130;
+            process.removeListener("SIGTERM", onSigterm);
+            process.removeListener("SIGINT", onSigint);
+            cleanup().finally(() => process.exit(code));
+        };
+        const onSigterm = () => handleSignal("SIGTERM");
+        const onSigint = () => handleSignal("SIGINT");
+        process.on("SIGTERM", onSigterm);
+        process.on("SIGINT", onSigint);
+        return {
+            subscriberId,
+            ptySession,
+            activityDetector,
+            readyDetector,
+            cleanup,
+        };
+    }
+}
+//# sourceMappingURL=launcher.js.map

package/dist/agent/pty-session.d.ts

@@ -0,0 +1,113 @@
+/**
+ * PtySession — merged PTY session manager.
+ *
+ * Combines iterloop's EventEmitter-based PtySession (content/status/idle
+ * classification, ring-buffer prompt detection, transcript management) with
+ * ufoo's PtyWrapper features (JSONL I/O logging, inject socket, monitoring).
+ *
+ * Events emitted:
+ *   "pty-data"  (data: string)   — raw PTY output
+ *   "content"   (line: string)   — meaningful text after classification
+ *   "status"    (text: string)   — status update (thinking, etc.)
+ *   "idle"      ()               — prompt detected, CLI ready for input
+ *   "exit"      (code: number)   — PTY process exited
+ */
+import { EventEmitter } from "node:events";
+export interface PtySessionOptions {
+    cwd?: string;
+    env?: Record<string, string>;
+    cols?: number;
+    rows?: number;
+    /** Engine name used by the output classifier (e.g. "claude", "gemini"). */
+    engine?: string;
+}
+export declare class PtySession extends EventEmitter {
+    private readonly _pty;
+    private _alive;
+    private _lastExitCode;
+    private readonly _engine;
+    private readonly _promptPattern;
+    private _ringBuffer;
+    private _currentLine;
+    private _lastEmittedStatus;
+    private _lastEmittedContent;
+    private _contentLines;
+    private _contentBytes;
+    private _logger;
+    private _loggerBroken;
+    private _injectServer;
+    private _injectSocketPath;
+    private _outputSubscribers;
+    private _outputRingBuffer;
+    private readonly OUTPUT_RING_MAX;
+    constructor(command: string, args: string[], opts?: PtySessionOptions);
+    write(data: string): void;
+    resize(cols: number, rows: number): void;
+    kill(): void;
+    /**
+     * Full cleanup — kills the process, closes logger, tears down inject socket.
+     * Safe to call multiple times.
+     */
+    destroy(): void;
+    get pid(): number;
+    get isAlive(): boolean;
+    /** The exit code of the PTY process (0 if still alive). */
+    get exitCode(): number;
+    /**
+     * Write data followed by a carriage return (convenience for sending commands).
+     */
+    sendLine(line: string): void;
+    /**
+     * Alias for getTranscript() — returns filtered meaningful content.
+     */
+    getCleanOutput(): string;
+    /**
+     * Return accumulated meaningful content, capped at ~50 KB.
+     */
+    getTranscript(): string;
+    /**
+     * Enable JSONL I/O logging to the given directory.
+     * Creates a timestamped `.jsonl` log file.
+     */
+    enableLogging(logDir: string): void;
+    /**
+     * Start a Unix-domain socket server at `socketPath` that accepts
+     * JSON-line commands: inject, raw write, resize, subscribe.
+     */
+    enableInjectSocket(socketPath: string): void;
+    /**
+     * Process a chunk of ANSI-stripped text, splitting into lines and
+     * classifying each as content / status / ignore.
+     */
+    private _processCleanChunk;
+    /** Strip the ⏺ content marker prefix used by Claude CLI. */
+    private _cleanContentLine;
+    /** Strip spinner / status prefixes to extract the status message. */
+    private _extractStatusText;
+    private _logEntry;
+    private _closeLogger;
+    private _handleInjectRequest;
+    private _forwardToSubscribers;
+    private _closeInjectSocket;
+}
+/**
+ * Factory options — alternative object-based signature.
+ */
+export interface CreatePtySessionOptions {
+    cmd: string;
+    args?: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+    engineName?: string;
+    cols?: number;
+    rows?: number;
+    onData?: (data: string) => void;
+    onExit?: (code: number) => void;
+}
+/**
+ * Factory function for creating PtySession instances.
+ * Accepts either positional args or an options object.
+ */
+export declare function createPtySession(opts: CreatePtySessionOptions): PtySession;
+export declare function createPtySession(command: string, args: string[], opts?: PtySessionOptions): PtySession;
+//# sourceMappingURL=pty-session.d.ts.map