@orgloop/agentctl 1.1.0 → 1.2.1

package/dist/adapters/pi-rust.js

@@ -0,0 +1,753 @@
+import { execFile, spawn } from "node:child_process";
+import crypto from "node:crypto";
+import { watch } from "node:fs";
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { promisify } from "node:util";
+import { buildSpawnEnv } from "../utils/daemon-env.js";
+import { resolveBinaryPath } from "../utils/resolve-binary.js";
+const execFileAsync = promisify(execFile);
+const DEFAULT_SESSION_DIR = path.join(os.homedir(), ".pi", "agent", "sessions");
+// Default: only show stopped sessions from the last 7 days
+const STOPPED_SESSION_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
+/**
+ * Pi Rust adapter — reads session data directly from ~/.pi/agent/sessions/
+ * and cross-references with running PIDs. NEVER maintains its own registry.
+ *
+ * Pi Rust (pi-rust / pi_agent_rust) stores sessions as JSONL files organized
+ * by project directory. It also maintains a SQLite index for fast lookups,
+ * but we read JSONL directly for simplicity and testability.
+ */
+export class PiRustAdapter {
+    id = "pi-rust";
+    sessionDir;
+    sessionsMetaDir;
+    getPids;
+    isProcessAlive;
+    constructor(opts) {
+        this.sessionDir = opts?.sessionDir || DEFAULT_SESSION_DIR;
+        this.sessionsMetaDir =
+            opts?.sessionsMetaDir ||
+                path.join(os.homedir(), ".pi", "agentctl", "sessions");
+        this.getPids = opts?.getPids || getPiRustPids;
+        this.isProcessAlive = opts?.isProcessAlive || defaultIsProcessAlive;
+    }
+    async list(opts) {
+        const runningPids = await this.getPids();
+        const sessions = [];
+        let projectDirs;
+        try {
+            const entries = await fs.readdir(this.sessionDir);
+            // Project dirs start with "--" (encoded paths)
+            projectDirs = entries.filter((e) => e.startsWith("--"));
+        }
+        catch {
+            return [];
+        }
+        for (const projDir of projectDirs) {
+            const projPath = path.join(this.sessionDir, projDir);
+            const stat = await fs.stat(projPath).catch(() => null);
+            if (!stat?.isDirectory())
+                continue;
+            const projectCwd = decodeProjDir(projDir);
+            const sessionFiles = await this.getSessionFiles(projPath);
+            for (const file of sessionFiles) {
+                const filePath = path.join(projPath, file);
+                const header = await this.readSessionHeader(filePath);
+                if (!header)
+                    continue;
+                const session = await this.buildSession(header, filePath, projectCwd, runningPids);
+                // Filter by status
+                if (opts?.status && session.status !== opts.status)
+                    continue;
+                // If not --all, skip old stopped sessions
+                if (!opts?.all && session.status === "stopped") {
+                    const age = Date.now() - session.startedAt.getTime();
+                    if (age > STOPPED_SESSION_MAX_AGE_MS)
+                        continue;
+                }
+                // Default: only show running sessions unless --all
+                if (!opts?.all &&
+                    !opts?.status &&
+                    session.status !== "running" &&
+                    session.status !== "idle") {
+                    continue;
+                }
+                sessions.push(session);
+            }
+        }
+        // Sort: running first, then by most recent
+        sessions.sort((a, b) => {
+            if (a.status === "running" && b.status !== "running")
+                return -1;
+            if (b.status === "running" && a.status !== "running")
+                return 1;
+            return b.startedAt.getTime() - a.startedAt.getTime();
+        });
+        return sessions;
+    }
+    async peek(sessionId, opts) {
+        const lines = opts?.lines ?? 20;
+        const filePath = await this.findSessionFile(sessionId);
+        if (!filePath)
+            throw new Error(`Session not found: ${sessionId}`);
+        const content = await fs.readFile(filePath, "utf-8");
+        const jsonlLines = content.trim().split("\n");
+        const assistantMessages = [];
+        for (const line of jsonlLines) {
+            try {
+                const msg = JSON.parse(line);
+                if (msg.type === "message" &&
+                    msg.message?.role === "assistant" &&
+                    msg.message?.content) {
+                    const text = extractTextContent(msg.message.content);
+                    if (text)
+                        assistantMessages.push(text);
+                }
+            }
+            catch {
+                // skip malformed lines
+            }
+        }
+        // Take last N messages
+        const recent = assistantMessages.slice(-lines);
+        return recent.join("\n---\n");
+    }
+    async status(sessionId) {
+        const runningPids = await this.getPids();
+        const filePath = await this.findSessionFile(sessionId);
+        if (!filePath)
+            throw new Error(`Session not found: ${sessionId}`);
+        const header = await this.readSessionHeader(filePath);
+        if (!header)
+            throw new Error(`Session not found: ${sessionId}`);
+        const projDir = path.basename(path.dirname(filePath));
+        const projectCwd = decodeProjDir(projDir);
+        return this.buildSession(header, filePath, projectCwd, runningPids);
+    }
+    async launch(opts) {
+        const args = ["--print", "--mode", "json", opts.prompt];
+        if (opts.model) {
+            args.unshift("--model", opts.model);
+        }
+        const env = buildSpawnEnv(undefined, opts.env);
+        const cwd = opts.cwd || process.cwd();
+        // Write stdout to a log file so we can extract the session ID
+        await fs.mkdir(this.sessionsMetaDir, { recursive: true });
+        const logPath = path.join(this.sessionsMetaDir, `launch-${Date.now()}.log`);
+        const logFd = await fs.open(logPath, "w");
+        const piRustPath = await resolveBinaryPath("pi-rust");
+        const child = spawn(piRustPath, args, {
+            cwd,
+            env,
+            stdio: ["ignore", logFd.fd, "ignore"],
+            detached: true,
+        });
+        child.on("error", (err) => {
+            console.error(`[pi-rust] spawn error: ${err.message}`);
+        });
+        child.unref();
+        const pid = child.pid;
+        const now = new Date();
+        await logFd.close();
+        // Try to extract the real session ID from the JSONL output
+        let resolvedSessionId;
+        if (pid) {
+            resolvedSessionId = await this.pollForSessionId(logPath, pid, 5000);
+        }
+        const sessionId = resolvedSessionId || (pid ? `pending-${pid}` : crypto.randomUUID());
+        // Persist session metadata so status checks work after wrapper exits
+        if (pid) {
+            await this.writeSessionMeta({
+                sessionId,
+                pid,
+                wrapperPid: process.pid,
+                cwd,
+                model: opts.model,
+                prompt: opts.prompt.slice(0, 200),
+                launchedAt: now.toISOString(),
+            });
+        }
+        const session = {
+            id: sessionId,
+            adapter: this.id,
+            status: "running",
+            startedAt: now,
+            cwd,
+            model: opts.model,
+            prompt: opts.prompt.slice(0, 200),
+            pid,
+            meta: {
+                adapterOpts: opts.adapterOpts,
+                spec: opts.spec,
+                logPath,
+            },
+        };
+        return session;
+    }
+    /**
+     * Poll the launch log file for up to `timeoutMs` to extract the real session ID.
+     * Pi Rust's JSONL output includes the session ID in the first line (type: "session").
+     */
+    async pollForSessionId(logPath, pid, timeoutMs) {
+        const deadline = Date.now() + timeoutMs;
+        while (Date.now() < deadline) {
+            try {
+                const content = await fs.readFile(logPath, "utf-8");
+                for (const line of content.split("\n")) {
+                    if (!line.trim())
+                        continue;
+                    try {
+                        const msg = JSON.parse(line);
+                        if (msg.type === "session" &&
+                            msg.id &&
+                            typeof msg.id === "string") {
+                            return msg.id;
+                        }
+                    }
+                    catch {
+                        // Not valid JSON yet
+                    }
+                }
+            }
+            catch {
+                // File may not exist yet
+            }
+            // Check if process is still alive
+            try {
+                process.kill(pid, 0);
+            }
+            catch {
+                break; // Process died
+            }
+            await sleep(200);
+        }
+        return undefined;
+    }
+    async stop(sessionId, opts) {
+        const pid = await this.findPidForSession(sessionId);
+        if (!pid)
+            throw new Error(`No running process for session: ${sessionId}`);
+        if (opts?.force) {
+            process.kill(pid, "SIGINT");
+            await sleep(5000);
+            try {
+                process.kill(pid, "SIGKILL");
+            }
+            catch {
+                // Already dead
+            }
+        }
+        else {
+            process.kill(pid, "SIGTERM");
+        }
+    }
+    async resume(sessionId, message) {
+        const filePath = await this.findSessionFile(sessionId);
+        const session = filePath
+            ? await this.status(sessionId).catch(() => null)
+            : null;
+        const cwd = session?.cwd || process.cwd();
+        // pi-rust --continue resumes the previous session, --session <path> for a specific one
+        const args = ["--print", "-p", message];
+        if (filePath) {
+            args.unshift("--session", filePath);
+        }
+        else {
+            args.unshift("--continue");
+        }
+        const piRustPath = await resolveBinaryPath("pi-rust");
+        const child = spawn(piRustPath, args, {
+            cwd,
+            stdio: ["pipe", "pipe", "pipe"],
+            detached: true,
+        });
+        child.on("error", (err) => {
+            console.error(`[pi-rust] resume spawn error: ${err.message}`);
+        });
+        child.unref();
+    }
+    async *events() {
+        let knownSessions = new Map();
+        const initial = await this.list({ all: true });
+        for (const s of initial) {
+            knownSessions.set(s.id, s);
+        }
+        const watcher = watch(this.sessionDir, { recursive: true });
+        try {
+            while (true) {
+                await sleep(5000);
+                const current = await this.list({ all: true });
+                const currentMap = new Map(current.map((s) => [s.id, s]));
+                for (const [id, session] of currentMap) {
+                    const prev = knownSessions.get(id);
+                    if (!prev) {
+                        yield {
+                            type: "session.started",
+                            adapter: this.id,
+                            sessionId: id,
+                            session,
+                            timestamp: new Date(),
+                        };
+                    }
+                    else if (prev.status === "running" &&
+                        session.status === "stopped") {
+                        yield {
+                            type: "session.stopped",
+                            adapter: this.id,
+                            sessionId: id,
+                            session,
+                            timestamp: new Date(),
+                        };
+                    }
+                    else if (prev.status === "running" && session.status === "idle") {
+                        yield {
+                            type: "session.idle",
+                            adapter: this.id,
+                            sessionId: id,
+                            session,
+                            timestamp: new Date(),
+                        };
+                    }
+                }
+                knownSessions = currentMap;
+            }
+        }
+        finally {
+            watcher.close();
+        }
+    }
+    // --- Private helpers ---
+    /** List .jsonl session files in a project directory */
+    async getSessionFiles(projPath) {
+        try {
+            const entries = await fs.readdir(projPath);
+            return entries.filter((e) => e.endsWith(".jsonl"));
+        }
+        catch {
+            return [];
+        }
+    }
+    /** Read and parse the session header (first line) from a JSONL file */
+    async readSessionHeader(filePath) {
+        try {
+            const content = await fs.readFile(filePath, "utf-8");
+            const firstLine = content.split("\n")[0];
+            if (!firstLine?.trim())
+                return null;
+            const parsed = JSON.parse(firstLine);
+            if (parsed.type !== "session")
+                return null;
+            return parsed;
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Extract the session ID from a JSONL filename (e.g., "2026-02-22T16-29-54.096Z_feb70071.jsonl" → "feb70071") */
+    extractShortId(filename) {
+        // Format: {timestamp}_{shortId}.jsonl
+        const base = filename.replace(".jsonl", "");
+        const parts = base.split("_");
+        return parts[parts.length - 1];
+    }
+    async buildSession(header, filePath, projectCwd, runningPids) {
+        const isRunning = await this.isSessionRunning(header, projectCwd, runningPids);
+        const { model, tokens, cost } = await this.parseSessionTail(filePath);
+        const firstPrompt = await this.readFirstPrompt(filePath);
+        let fileStat;
+        try {
+            fileStat = await fs.stat(filePath);
+        }
+        catch {
+            // ignore
+        }
+        return {
+            id: header.id,
+            adapter: this.id,
+            status: isRunning ? "running" : "stopped",
+            startedAt: new Date(header.timestamp),
+            stoppedAt: isRunning
+                ? undefined
+                : fileStat
+                    ? new Date(Number(fileStat.mtimeMs))
+                    : undefined,
+            cwd: header.cwd || projectCwd,
+            model: model || header.modelId,
+            prompt: firstPrompt?.slice(0, 200),
+            tokens,
+            cost: cost ?? undefined,
+            pid: isRunning
+                ? await this.findMatchingPid(header, projectCwd, runningPids)
+                : undefined,
+            meta: {
+                provider: header.provider,
+                thinkingLevel: header.thinkingLevel,
+                projectDir: projectCwd,
+                sessionFile: filePath,
+            },
+        };
+    }
+    async isSessionRunning(header, projectCwd, runningPids) {
+        const sessionCreated = new Date(header.timestamp).getTime();
+        // 1. Check running PIDs discovered via `ps aux`
+        for (const [, info] of runningPids) {
+            if (info.args.includes(header.id)) {
+                if (this.processStartedAfterSession(info, sessionCreated))
+                    return true;
+                continue;
+            }
+            if (info.cwd === projectCwd) {
+                if (this.processStartedAfterSession(info, sessionCreated))
+                    return true;
+            }
+        }
+        // 2. Check persisted session metadata
+        const meta = await this.readSessionMeta(header.id);
+        if (meta?.pid) {
+            if (this.isProcessAlive(meta.pid)) {
+                const pidInfo = runningPids.get(meta.pid);
+                if (pidInfo?.startTime && meta.startTime) {
+                    const currentStartMs = new Date(pidInfo.startTime).getTime();
+                    const recordedStartMs = new Date(meta.startTime).getTime();
+                    if (!Number.isNaN(currentStartMs) &&
+                        !Number.isNaN(recordedStartMs) &&
+                        Math.abs(currentStartMs - recordedStartMs) > 5000) {
+                        await this.deleteSessionMeta(header.id);
+                        return false;
+                    }
+                }
+                if (meta.startTime) {
+                    const metaStartMs = new Date(meta.startTime).getTime();
+                    const sessionMs = new Date(meta.launchedAt).getTime();
+                    if (!Number.isNaN(metaStartMs) && metaStartMs >= sessionMs - 5000) {
+                        return true;
+                    }
+                    await this.deleteSessionMeta(header.id);
+                    return false;
+                }
+                return true;
+            }
+            await this.deleteSessionMeta(header.id);
+        }
+        return false;
+    }
+    processStartedAfterSession(info, sessionCreatedMs) {
+        if (!info.startTime)
+            return false;
+        const processStartMs = new Date(info.startTime).getTime();
+        if (Number.isNaN(processStartMs))
+            return false;
+        return processStartMs >= sessionCreatedMs - 5000;
+    }
+    async findMatchingPid(header, projectCwd, runningPids) {
+        const sessionCreated = new Date(header.timestamp).getTime();
+        for (const [pid, info] of runningPids) {
+            if (info.args.includes(header.id)) {
+                if (this.processStartedAfterSession(info, sessionCreated))
+                    return pid;
+                continue;
+            }
+            if (info.cwd === projectCwd) {
+                if (this.processStartedAfterSession(info, sessionCreated))
+                    return pid;
+            }
+        }
+        const meta = await this.readSessionMeta(header.id);
+        if (meta?.pid && this.isProcessAlive(meta.pid)) {
+            return meta.pid;
+        }
+        return undefined;
+    }
+    async parseSessionTail(filePath) {
+        try {
+            const content = await fs.readFile(filePath, "utf-8");
+            const lines = content.trim().split("\n");
+            let model;
+            let totalIn = 0;
+            let totalOut = 0;
+            let totalCost = 0;
+            const tail = lines.slice(-100);
+            for (const line of tail) {
+                try {
+                    const msg = JSON.parse(line);
+                    if (msg.type === "message" && msg.message?.role === "assistant") {
+                        if (msg.message.model)
+                            model = msg.message.model;
+                        if (msg.message.usage) {
+                            totalIn += msg.message.usage.input || 0;
+                            totalOut += msg.message.usage.output || 0;
+                            if (msg.message.usage.cost?.total) {
+                                totalCost += msg.message.usage.cost.total;
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // skip
+                }
+            }
+            if (!model) {
+                const head = lines.slice(0, 20);
+                for (const line of head) {
+                    try {
+                        const msg = JSON.parse(line);
+                        if (msg.type === "message" &&
+                            msg.message?.role === "assistant" &&
+                            msg.message?.model) {
+                            model = msg.message.model;
+                            break;
+                        }
+                        // Also check session header for modelId
+                        if (msg.type === "session" &&
+                            msg.modelId) {
+                            model = msg.modelId;
+                        }
+                    }
+                    catch {
+                        // skip
+                    }
+                }
+            }
+            return {
+                model,
+                tokens: totalIn || totalOut ? { in: totalIn, out: totalOut } : undefined,
+                cost: totalCost || undefined,
+            };
+        }
+        catch {
+            return {};
+        }
+    }
+    /** Read the first user prompt from a JSONL session file */
+    async readFirstPrompt(filePath) {
+        try {
+            const content = await fs.readFile(filePath, "utf-8");
+            for (const line of content.split("\n").slice(0, 20)) {
+                try {
+                    const msg = JSON.parse(line);
+                    if (msg.type === "message" &&
+                        msg.message?.role === "user" &&
+                        msg.message?.content) {
+                        return extractTextContent(msg.message.content);
+                    }
+                }
+                catch {
+                    // skip
+                }
+            }
+        }
+        catch {
+            // skip
+        }
+        return undefined;
+    }
+    /** Find a session JSONL file by session ID (full or prefix match) */
+    async findSessionFile(sessionId) {
+        let projectDirs;
+        try {
+            const entries = await fs.readdir(this.sessionDir);
+            projectDirs = entries.filter((e) => e.startsWith("--"));
+        }
+        catch {
+            return null;
+        }
+        for (const projDir of projectDirs) {
+            const projPath = path.join(this.sessionDir, projDir);
+            const stat = await fs.stat(projPath).catch(() => null);
+            if (!stat?.isDirectory())
+                continue;
+            const files = await this.getSessionFiles(projPath);
+            for (const file of files) {
+                const filePath = path.join(projPath, file);
+                const header = await this.readSessionHeader(filePath);
+                if (!header)
+                    continue;
+                // Full match or prefix match
+                if (header.id === sessionId || header.id.startsWith(sessionId)) {
+                    return filePath;
+                }
+                // Also check if the short ID in the filename matches
+                const shortId = this.extractShortId(file);
+                if (shortId === sessionId || sessionId.startsWith(shortId)) {
+                    return filePath;
+                }
+            }
+        }
+        return null;
+    }
+    async findPidForSession(sessionId) {
+        const session = await this.status(sessionId);
+        return session.pid ?? null;
+    }
+    // --- Session metadata persistence ---
+    async writeSessionMeta(meta) {
+        await fs.mkdir(this.sessionsMetaDir, { recursive: true });
+        let startTime;
+        try {
+            const { stdout } = await execFileAsync("ps", [
+                "-p",
+                meta.pid.toString(),
+                "-o",
+                "lstart=",
+            ]);
+            startTime = stdout.trim() || undefined;
+        }
+        catch {
+            // Process may have already exited or ps failed
+        }
+        const fullMeta = { ...meta, startTime };
+        const metaPath = path.join(this.sessionsMetaDir, `${meta.sessionId}.json`);
+        await fs.writeFile(metaPath, JSON.stringify(fullMeta, null, 2));
+    }
+    async readSessionMeta(sessionId) {
+        const metaPath = path.join(this.sessionsMetaDir, `${sessionId}.json`);
+        try {
+            const raw = await fs.readFile(metaPath, "utf-8");
+            return JSON.parse(raw);
+        }
+        catch {
+            // File doesn't exist or is unreadable
+        }
+        try {
+            const files = await fs.readdir(this.sessionsMetaDir);
+            for (const file of files) {
+                if (!file.endsWith(".json"))
+                    continue;
+                try {
+                    const raw = await fs.readFile(path.join(this.sessionsMetaDir, file), "utf-8");
+                    const meta = JSON.parse(raw);
+                    if (meta.sessionId === sessionId)
+                        return meta;
+                }
+                catch {
+                    // skip
+                }
+            }
+        }
+        catch {
+            // Dir doesn't exist
+        }
+        return null;
+    }
+    async deleteSessionMeta(sessionId) {
+        for (const id of [sessionId, `pending-${sessionId}`]) {
+            const metaPath = path.join(this.sessionsMetaDir, `${id}.json`);
+            try {
+                await fs.unlink(metaPath);
+            }
+            catch {
+                // File doesn't exist
+            }
+        }
+    }
+}
+// --- Utility functions ---
+/**
+ * Decode a Pi Rust project directory name back to the original path.
+ * Pi Rust encodes paths: "/" → "-", wrapped in "--".
+ * E.g., "--private-tmp-test-pi-rust--" → "/private/tmp/test-pi-rust"
+ *
+ * Note: This is a lossy encoding — hyphens in the original path are
+ * indistinguishable from path separators. We do our best to reconstruct.
+ */
+export function decodeProjDir(dirName) {
+    // Strip leading/trailing "--"
+    let inner = dirName;
+    if (inner.startsWith("--"))
+        inner = inner.slice(2);
+    if (inner.endsWith("--"))
+        inner = inner.slice(0, -2);
+    // Replace "-" with "/"
+    return `/${inner.replace(/-/g, "/")}`;
+}
+/**
+ * Encode a path as a Pi Rust project directory name.
+ * E.g., "/private/tmp/test-pi-rust" → "--private-tmp-test-pi-rust--"
+ */
+export function encodeProjDir(cwdPath) {
+    // Strip leading "/" and replace remaining "/" and "-" with "-"
+    const stripped = cwdPath.startsWith("/") ? cwdPath.slice(1) : cwdPath;
+    const encoded = stripped.replace(/\//g, "-");
+    return `--${encoded}--`;
+}
+function defaultIsProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function getPiRustPids() {
+    const pids = new Map();
+    try {
+        const { stdout } = await execFileAsync("ps", ["aux"]);
+        for (const line of stdout.split("\n")) {
+            if (!line.includes("pi-rust") || line.includes("grep"))
+                continue;
+            const fields = line.trim().split(/\s+/);
+            if (fields.length < 11)
+                continue;
+            const pid = parseInt(fields[1], 10);
+            const command = fields.slice(10).join(" ");
+            // Match pi-rust processes (the binary, not wrappers)
+            if (!command.includes("pi-rust"))
+                continue;
+            if (pid === process.pid)
+                continue;
+            let cwd = "";
+            try {
+                const { stdout: lsofOut } = await execFileAsync("/usr/sbin/lsof", [
+                    "-p",
+                    pid.toString(),
+                    "-Fn",
+                ]);
+                const lsofLines = lsofOut.split("\n");
+                for (let i = 0; i < lsofLines.length; i++) {
+                    if (lsofLines[i] === "fcwd" && lsofLines[i + 1]?.startsWith("n")) {
+                        cwd = lsofLines[i + 1].slice(1);
+                        break;
+                    }
+                }
+            }
+            catch {
+                // lsof might fail
+            }
+            let startTime;
+            try {
+                const { stdout: lstart } = await execFileAsync("ps", [
+                    "-p",
+                    pid.toString(),
+                    "-o",
+                    "lstart=",
+                ]);
+                startTime = lstart.trim() || undefined;
+            }
+            catch {
+                // ps might fail
+            }
+            pids.set(pid, { pid, cwd, args: command, startTime });
+        }
+    }
+    catch {
+        // ps failed — return empty
+    }
+    return pids;
+}
+function extractTextContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .filter((b) => b.type === "text" && b.text)
+            .map((b) => b.text)
+            .join("\n");
+    }
+    return "";
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}