@orgloop/agentctl 1.1.0 → 1.2.1

package/dist/daemon/server.js

@@ -1,38 +1,57 @@
+import { execFile } from "node:child_process";
 import { EventEmitter } from "node:events";
 import fs from "node:fs/promises";
 import http from "node:http";
 import net from "node:net";
 import os from "node:os";
 import path from "node:path";
+import { promisify } from "node:util";
 import { ClaudeCodeAdapter } from "../adapters/claude-code.js";
+import { CodexAdapter } from "../adapters/codex.js";
 import { OpenClawAdapter } from "../adapters/openclaw.js";
+import { OpenCodeAdapter } from "../adapters/opencode.js";
+import { PiAdapter } from "../adapters/pi.js";
+import { PiRustAdapter } from "../adapters/pi-rust.js";
 import { migrateLocks } from "../migration/migrate-locks.js";
+import { saveEnvironment } from "../utils/daemon-env.js";
+import { clearBinaryCache } from "../utils/resolve-binary.js";
 import { FuseEngine } from "./fuse-engine.js";
 import { LockManager } from "./lock-manager.js";
 import { MetricsRegistry } from "./metrics.js";
 import { SessionTracker } from "./session-tracker.js";
 import { StateManager } from "./state.js";
+const execFileAsync = promisify(execFile);
 const startTime = Date.now();
 export async function startDaemon(opts = {}) {
     const configDir = opts.configDir || path.join(os.homedir(), ".agentctl");
     await fs.mkdir(configDir, { recursive: true });
-    // 1. Check for existing daemon
     const pidFilePath = path.join(configDir, "agentctl.pid");
-    const existingPid = await readPidFile(pidFilePath);
-    if (existingPid && isProcessAlive(existingPid)) {
-        throw new Error(`Daemon already running (PID ${existingPid})`);
-    }
-    // 2. Clean stale socket
     const sockPath = path.join(configDir, "agentctl.sock");
+    // 1. Kill stale daemon/supervisor processes before anything else (#39)
+    await killStaleDaemons(configDir);
+    // 2. Verify no daemon is actually running by trying to connect to socket
+    const socketAlive = await isSocketAlive(sockPath);
+    if (socketAlive) {
+        throw new Error("Daemon already running (socket responsive)");
+    }
+    // 3. Clean stale socket file
     await fs.rm(sockPath, { force: true });
-    // 3. Run migration (idempotent)
+    // 4. Save shell environment for subprocess spawning (#42)
+    await saveEnvironment(configDir);
+    // 5. Clear binary cache on restart (#41 — pick up moved/updated binaries)
+    clearBinaryCache();
+    // 6. Run migration (idempotent)
     await migrateLocks(configDir).catch((err) => console.error("Migration warning:", err.message));
-    // 4. Load persisted state
+    // 7. Load persisted state
     const state = await StateManager.load(configDir);
-    // 5. Initialize subsystems
+    // 8. Initialize subsystems
     const adapters = opts.adapters || {
         "claude-code": new ClaudeCodeAdapter(),
+        codex: new CodexAdapter(),
         openclaw: new OpenClawAdapter(),
+        opencode: new OpenCodeAdapter(),
+        pi: new PiAdapter(),
+        "pi-rust": new PiRustAdapter(),
     };
     const lockManager = new LockManager(state);
     const emitter = new EventEmitter();
@@ -46,11 +65,13 @@ export async function startDaemon(opts = {}) {
     emitter.on("fuse.fired", () => {
         metrics.recordFuseFired();
     });
-    // 6. Resume fuse timers
+    // 9. Validate all sessions on startup — mark dead ones as stopped (#40)
+    sessionTracker.validateAllSessions();
+    // 10. Resume fuse timers
     fuseEngine.resumeTimers();
-    // 7. Start session polling
+    // 11. Start session polling
     sessionTracker.startPolling();
-    // 8. Create request handler
+    // 12. Create request handler
     const handleRequest = createRequestHandler({
         sessionTracker,
         lockManager,
@@ -61,7 +82,7 @@ export async function startDaemon(opts = {}) {
         configDir,
         sockPath,
     });
-    // 9. Start Unix socket server
+    // 13. Start Unix socket server
     const socketServer = net.createServer((conn) => {
         let buffer = "";
         conn.on("data", (chunk) => {
@@ -97,7 +118,9 @@ export async function startDaemon(opts = {}) {
         socketServer.listen(sockPath, () => resolve());
         socketServer.on("error", reject);
     });
-    // 10. Start HTTP metrics server
+    // 14. Write PID file (after socket is listening — acts as "lock acquired")
+    await fs.writeFile(pidFilePath, String(process.pid));
+    // 15. Start HTTP metrics server
     const metricsPort = opts.metricsPort ?? 9200;
     const httpServer = http.createServer((req, res) => {
         if (req.url === "/metrics" && req.method === "GET") {
@@ -115,8 +138,6 @@ export async function startDaemon(opts = {}) {
         httpServer.listen(metricsPort, "127.0.0.1", () => resolve());
         httpServer.on("error", reject);
     });
-    // 11. Write PID file
-    await fs.writeFile(pidFilePath, String(process.pid));
     // Shutdown function
     const shutdown = async () => {
         sessionTracker.stopPolling();
@@ -128,7 +149,7 @@ export async function startDaemon(opts = {}) {
         await fs.rm(sockPath, { force: true });
         await fs.rm(pidFilePath, { force: true });
     };
-    // 12. Signal handlers
+    // 16. Signal handlers
     for (const sig of ["SIGTERM", "SIGINT"]) {
         process.on(sig, async () => {
             console.log(`Received ${sig}, shutting down...`);
@@ -141,15 +162,100 @@ export async function startDaemon(opts = {}) {
     console.log(`  Metrics: http://localhost:${metricsPort}/metrics`);
     return { socketServer, httpServer, shutdown };
 }
+// --- Stale daemon cleanup (#39) ---
+/**
+ * Find and kill ALL stale agentctl daemon/supervisor processes.
+ * This ensures singleton enforcement even after unclean shutdowns.
+ */
+async function killStaleDaemons(configDir) {
+    // 1. Kill processes recorded in PID files
+    for (const pidFile of ["agentctl.pid", "supervisor.pid"]) {
+        const p = path.join(configDir, pidFile);
+        const pid = await readPidFile(p);
+        if (pid && pid !== process.pid && isProcessAlive(pid)) {
+            try {
+                process.kill(pid, "SIGTERM");
+                // Wait briefly for clean shutdown
+                await sleep(500);
+                if (isProcessAlive(pid)) {
+                    process.kill(pid, "SIGKILL");
+                }
+            }
+            catch {
+                // Already gone
+            }
+        }
+        // Clean up stale PID file
+        await fs.rm(p, { force: true }).catch(() => { });
+    }
+    // 2. Scan ps for any remaining agentctl daemon processes
+    try {
+        const { stdout } = await execFileAsync("ps", ["aux"]);
+        for (const line of stdout.split("\n")) {
+            if (!line.includes("agentctl") || !line.includes("daemon"))
+                continue;
+            if (line.includes("grep"))
+                continue;
+            const fields = line.trim().split(/\s+/);
+            if (fields.length < 2)
+                continue;
+            const pid = Number.parseInt(fields[1], 10);
+            if (Number.isNaN(pid) || pid === process.pid)
+                continue;
+            // Also skip our parent process (supervisor)
+            if (pid === process.ppid)
+                continue;
+            try {
+                process.kill(pid, "SIGTERM");
+                await sleep(200);
+                if (isProcessAlive(pid)) {
+                    process.kill(pid, "SIGKILL");
+                }
+            }
+            catch {
+                // Already gone
+            }
+        }
+    }
+    catch {
+        // ps failed — best effort
+    }
+}
+/**
+ * Check if a Unix socket is actually responsive (not just a stale file).
+ */
+async function isSocketAlive(sockPath) {
+    return new Promise((resolve) => {
+        const socket = net.createConnection(sockPath);
+        const timeout = setTimeout(() => {
+            socket.destroy();
+            resolve(false);
+        }, 1000);
+        socket.on("connect", () => {
+            clearTimeout(timeout);
+            socket.destroy();
+            resolve(true);
+        });
+        socket.on("error", () => {
+            clearTimeout(timeout);
+            resolve(false);
+        });
+    });
+}
 function createRequestHandler(ctx) {
     return async (req) => {
         const params = (req.params || {});
         switch (req.method) {
-            case "session.list":
-                return ctx.sessionTracker.listSessions({
+            case "session.list": {
+                let sessions = ctx.sessionTracker.listSessions({
                     status: params.status,
                     all: params.all,
                 });
+                if (params.group) {
+                    sessions = sessions.filter((s) => s.group === params.group);
+                }
+                return sessions;
+            }
             case "session.status": {
                 const session = ctx.sessionTracker.getSession(params.id);
                 if (!session)
@@ -157,11 +263,15 @@ function createRequestHandler(ctx) {
                 return session;
             }
             case "session.peek": {
-                const adapterName = params.adapter || "claude-code";
+                // Auto-detect adapter from tracked session, fall back to param or claude-code
+                const tracked = ctx.sessionTracker.getSession(params.id);
+                const adapterName = params.adapter || tracked?.adapter || "claude-code";
                 const adapter = ctx.adapters[adapterName];
                 if (!adapter)
                     throw new Error(`Unknown adapter: ${adapterName}`);
-                return adapter.peek(params.id, {
+                // Use the full session ID if we resolved it from the tracker
+                const peekId = tracked?.id || params.id;
+                return adapter.peek(peekId, {
                     lines: params.lines,
                 });
             }
@@ -193,6 +303,10 @@ function createRequestHandler(ctx) {
                     env: params.env,
                     adapterOpts: params.adapterOpts,
                 });
+                // Propagate group tag if provided
+                if (params.group) {
+                    session.group = params.group;
+                }
                 const record = ctx.sessionTracker.track(session, adapterName);
                 // Auto-lock
                 if (cwd) {
@@ -204,6 +318,15 @@ function createRequestHandler(ctx) {
                 const session = ctx.sessionTracker.getSession(params.id);
                 if (!session)
                     throw new Error(`Session not found: ${params.id}`);
+                // Ghost pending entry with dead PID: remove from state with --force
+                if (session.id.startsWith("pending-") &&
+                    params.force &&
+                    session.pid &&
+                    !isProcessAlive(session.pid)) {
+                    ctx.lockManager.autoUnlock(session.id);
+                    ctx.sessionTracker.removeSession(session.id);
+                    return null;
+                }
                 const adapter = ctx.adapters[session.adapter];
                 if (!adapter)
                     throw new Error(`Unknown adapter: ${session.adapter}`);
@@ -230,6 +353,11 @@ function createRequestHandler(ctx) {
                 await adapter.resume(session.id, params.message);
                 return null;
             }
+            // --- Prune command (#40) ---
+            case "session.prune": {
+                const pruned = ctx.sessionTracker.pruneDeadSessions();
+                return { pruned };
+            }
             case "lock.list":
                 return ctx.lockManager.listAll();
             case "lock.acquire":
@@ -281,3 +409,6 @@ function isProcessAlive(pid) {
         return false;
     }
 }
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/daemon/session-tracker.d.ts

@@ -11,9 +11,12 @@ export declare class SessionTracker {
     private adapters;
     private pollIntervalMs;
     private pollHandle;
+    private polling;
     private readonly isProcessAlive;
     constructor(state: StateManager, opts: SessionTrackerOpts);
     startPolling(): void;
+    /** Run poll() with a guard to skip if the previous cycle is still running */
+    private guardedPoll;
     stopPolling(): void;
     private poll;
     /**
@@ -22,6 +25,24 @@ export declare class SessionTracker {
      * - Any "running"/"idle" session in state whose PID is dead → mark stopped
      */
     private reapStaleEntries;
+    /**
+     * Validate all sessions on daemon startup (#40).
+     * Any session marked as "running" or "idle" whose PID is dead gets
+     * immediately marked as "stopped". This prevents unbounded growth of
+     * ghost sessions across daemon restarts.
+     */
+    validateAllSessions(): void;
+    /**
+     * Aggressively prune all clearly-dead sessions (#40).
+     * Returns the number of sessions pruned.
+     * Called via `agentctl prune` command.
+     */
+    pruneDeadSessions(): number;
+    /**
+     * Remove stopped sessions from state that have been stopped for more than 7 days.
+     * This reduces overhead from accumulating hundreds of historical sessions.
+     */
+    private pruneOldSessions;
     /** Track a newly launched session */
     track(session: AgentSession, adapterName: string): SessionRecord;
     /** Get session record by id (exact or prefix) */
@@ -30,8 +51,11 @@ export declare class SessionTracker {
     listSessions(opts?: {
         status?: string;
         all?: boolean;
+        adapter?: string;
     }): SessionRecord[];
     activeCount(): number;
+    /** Remove a session from state entirely (used for ghost cleanup) */
+    removeSession(sessionId: string): void;
     /** Called when a session stops — returns the cwd for fuse/lock processing */
     onSessionExit(sessionId: string): SessionRecord | undefined;
 }

package/dist/daemon/session-tracker.js

@@ -1,8 +1,11 @@
+/** Max age for stopped sessions in state before pruning (7 days) */
+const STOPPED_SESSION_PRUNE_AGE_MS = 7 * 24 * 60 * 60 * 1000;
 export class SessionTracker {
     state;
     adapters;
     pollIntervalMs;
     pollHandle = null;
+    polling = false;
     isProcessAlive;
     constructor(state, opts) {
         this.state = state;
@@ -13,12 +16,25 @@ export class SessionTracker {
     startPolling() {
         if (this.pollHandle)
             return;
+        // Prune old stopped sessions on startup
+        this.pruneOldSessions();
         // Initial poll
-        this.poll().catch((err) => console.error("Poll error:", err));
+        this.guardedPoll();
         this.pollHandle = setInterval(() => {
-            this.poll().catch((err) => console.error("Poll error:", err));
+            this.guardedPoll();
         }, this.pollIntervalMs);
     }
+    /** Run poll() with a guard to skip if the previous cycle is still running */
+    guardedPoll() {
+        if (this.polling)
+            return;
+        this.polling = true;
+        this.poll()
+            .catch((err) => console.error("Poll error:", err))
+            .finally(() => {
+            this.polling = false;
+        });
+    }
     stopPolling() {
         if (this.pollHandle) {
             clearInterval(this.pollHandle);
@@ -40,14 +56,17 @@ export class SessionTracker {
                     if (!existing) {
                         this.state.setSession(session.id, record);
                     }
-                    else if (existing.status !== record.status) {
-                        // Status changed — update
+                    else if (existing.status !== record.status ||
+                        (!existing.model && record.model)) {
+                        // Status changed or model resolved — update
                         this.state.setSession(session.id, {
                             ...existing,
                             status: record.status,
                             stoppedAt: record.stoppedAt,
+                            model: record.model || existing.model,
                             tokens: record.tokens,
                             cost: record.cost,
+                            prompt: record.prompt || existing.prompt,
                         });
                     }
                 }
@@ -94,9 +113,117 @@ export class SessionTracker {
             }
         }
     }
+    /**
+     * Validate all sessions on daemon startup (#40).
+     * Any session marked as "running" or "idle" whose PID is dead gets
+     * immediately marked as "stopped". This prevents unbounded growth of
+     * ghost sessions across daemon restarts.
+     */
+    validateAllSessions() {
+        const sessions = this.state.getSessions();
+        let cleaned = 0;
+        for (const [id, record] of Object.entries(sessions)) {
+            if (record.status !== "running" && record.status !== "idle")
+                continue;
+            if (record.pid) {
+                if (!this.isProcessAlive(record.pid)) {
+                    this.state.setSession(id, {
+                        ...record,
+                        status: "stopped",
+                        stoppedAt: new Date().toISOString(),
+                    });
+                    cleaned++;
+                }
+            }
+            else {
+                // No PID recorded — can't verify, mark as stopped
+                this.state.setSession(id, {
+                    ...record,
+                    status: "stopped",
+                    stoppedAt: new Date().toISOString(),
+                });
+                cleaned++;
+            }
+        }
+        if (cleaned > 0) {
+            console.error(`Validated sessions on startup: marked ${cleaned} dead sessions as stopped`);
+        }
+    }
+    /**
+     * Aggressively prune all clearly-dead sessions (#40).
+     * Returns the number of sessions pruned.
+     * Called via `agentctl prune` command.
+     */
+    pruneDeadSessions() {
+        const sessions = this.state.getSessions();
+        let pruned = 0;
+        for (const [id, record] of Object.entries(sessions)) {
+            // Remove stopped/completed/failed sessions older than 24h
+            if (record.status === "stopped" ||
+                record.status === "completed" ||
+                record.status === "failed") {
+                const stoppedAt = record.stoppedAt
+                    ? new Date(record.stoppedAt).getTime()
+                    : new Date(record.startedAt).getTime();
+                const age = Date.now() - stoppedAt;
+                if (age > 24 * 60 * 60 * 1000) {
+                    this.state.removeSession(id);
+                    pruned++;
+                }
+                continue;
+            }
+            // Remove running/idle sessions whose PID is dead
+            if (record.status === "running" || record.status === "idle") {
+                if (record.pid && !this.isProcessAlive(record.pid)) {
+                    this.state.removeSession(id);
+                    pruned++;
+                }
+                else if (!record.pid) {
+                    this.state.removeSession(id);
+                    pruned++;
+                }
+            }
+        }
+        return pruned;
+    }
+    /**
+     * Remove stopped sessions from state that have been stopped for more than 7 days.
+     * This reduces overhead from accumulating hundreds of historical sessions.
+     */
+    pruneOldSessions() {
+        const sessions = this.state.getSessions();
+        const now = Date.now();
+        let pruned = 0;
+        for (const [id, record] of Object.entries(sessions)) {
+            if (record.status !== "stopped" &&
+                record.status !== "completed" &&
+                record.status !== "failed") {
+                continue;
+            }
+            const stoppedAt = record.stoppedAt
+                ? new Date(record.stoppedAt).getTime()
+                : new Date(record.startedAt).getTime();
+            if (now - stoppedAt > STOPPED_SESSION_PRUNE_AGE_MS) {
+                this.state.removeSession(id);
+                pruned++;
+            }
+        }
+        if (pruned > 0) {
+            console.error(`Pruned ${pruned} sessions stopped >7 days ago from state`);
+        }
+    }
     /** Track a newly launched session */
     track(session, adapterName) {
         const record = sessionToRecord(session, adapterName);
+        // Pending→UUID reconciliation: if this is a real session (not pending),
+        // remove any pending-PID placeholder with the same PID
+        if (!session.id.startsWith("pending-") && session.pid) {
+            for (const [id, existing] of Object.entries(this.state.getSessions())) {
+                if (id.startsWith("pending-") && existing.pid === session.pid) {
+                    this.state.removeSession(id);
+                }
+            }
+        }
         this.state.setSession(session.id, record);
         return record;
     }
@@ -116,7 +243,20 @@ export class SessionTracker {
     /** List all tracked sessions */
     listSessions(opts) {
         const sessions = Object.values(this.state.getSessions());
+        // Liveness check: mark sessions with dead PIDs as stopped
+        for (const s of sessions) {
+            if ((s.status === "running" || s.status === "idle") && s.pid) {
+                if (!this.isProcessAlive(s.pid)) {
+                    s.status = "stopped";
+                    s.stoppedAt = new Date().toISOString();
+                    this.state.setSession(s.id, s);
+                }
+            }
+        }
         let filtered = sessions;
+        if (opts?.adapter) {
+            filtered = filtered.filter((s) => s.adapter === opts.adapter);
+        }
         if (opts?.status) {
             filtered = filtered.filter((s) => s.status === opts.status);
         }
@@ -137,6 +277,10 @@ export class SessionTracker {
     activeCount() {
         return Object.values(this.state.getSessions()).filter((s) => s.status === "running" || s.status === "idle").length;
     }
+    /** Remove a session from state entirely (used for ghost cleanup) */
+    removeSession(sessionId) {
+        this.state.removeSession(sessionId);
+    }
     /** Called when a session stops — returns the cwd for fuse/lock processing */
     onSessionExit(sessionId) {
         const session = this.state.getSession(sessionId);
@@ -190,6 +334,7 @@ function sessionToRecord(session, adapterName) {
         tokens: session.tokens,
         cost: session.cost,
         pid: session.pid,
+        group: session.group,
         meta: session.meta,
     };
 }

package/dist/daemon/state.d.ts

@@ -15,6 +15,7 @@ export interface SessionRecord {
     cost?: number;
     pid?: number;
     exitCode?: number;
+    group?: string;
     meta: Record<string, unknown>;
 }
 export interface Lock {

package/dist/hooks.d.ts

@@ -6,6 +6,8 @@ export interface HookContext {
     adapter: string;
     branch?: string;
     exitCode?: number;
+    group?: string;
+    model?: string;
 }
 /**
  * Run a lifecycle hook script if defined.

package/dist/hooks.js

@@ -23,6 +23,10 @@ export async function runHook(hooks, phase, ctx) {
         env.AGENTCTL_BRANCH = ctx.branch;
     if (ctx.exitCode != null)
         env.AGENTCTL_EXIT_CODE = String(ctx.exitCode);
+    if (ctx.group)
+        env.AGENTCTL_GROUP = ctx.group;
+    if (ctx.model)
+        env.AGENTCTL_MODEL = ctx.model;
     try {
         const result = await execAsync(script, {
             cwd: ctx.cwd,

package/dist/launch-orchestrator.d.ts

@@ -0,0 +1,60 @@
+import type { AgentAdapter, LifecycleHooks } from "./core/types.js";
+/** A single adapter+model slot parsed from CLI flags */
+export interface AdapterSlot {
+    adapter: string;
+    model?: string;
+}
+/** Result of launching one slot within a group */
+export interface SlotLaunchResult {
+    slot: AdapterSlot;
+    sessionId: string;
+    pid?: number;
+    cwd: string;
+    branch: string;
+    error?: string;
+}
+/** Result of the full orchestrated launch */
+export interface OrchestratedLaunchResult {
+    groupId: string;
+    results: SlotLaunchResult[];
+}
+export interface OrchestrateOpts {
+    slots: AdapterSlot[];
+    prompt: string;
+    spec?: string;
+    cwd: string;
+    hooks?: LifecycleHooks;
+    adapters: Record<string, AgentAdapter>;
+    /** Optional: callback when daemon is available for lock/track */
+    onSessionLaunched?: (result: SlotLaunchResult) => void;
+    /** Optional: callback when group ID is generated (before launches) */
+    onGroupCreated?: (groupId: string) => void;
+}
+/** Generate a short group ID like "g-a1b2c3" */
+export declare function generateGroupId(): string;
+/**
+ * Generate a short suffix for a slot, used in worktree/branch naming.
+ * When an adapter appears multiple times, disambiguate using the model short name.
+ */
+export declare function slotSuffix(slot: AdapterSlot, allSlots: AdapterSlot[]): string;
+/** Build worktree path: <repo>-<groupId>-<suffix> */
+export declare function worktreePath(repo: string, groupId: string, suffix: string): string;
+/** Build branch name: try/<groupId>/<suffix> */
+export declare function branchName(groupId: string, suffix: string): string;
+/**
+ * Orchestrate a parallel multi-adapter launch.
+ *
+ * 1. Generate group ID
+ * 2. For each slot: create worktree, run on_worktree_create hook, launch adapter
+ * 3. Return all results (successes and failures)
+ */
+export declare function orchestrateLaunch(opts: OrchestrateOpts): Promise<OrchestratedLaunchResult>;
+/**
+ * Parse positional adapter slots from raw argv.
+ *
+ * Multiple --adapter flags, each optionally followed by --model:
+ *   --adapter claude-code --model opus --adapter codex
+ *
+ * Returns AdapterSlot[] representing each launch slot.
+ */
+export declare function parseAdapterSlots(rawArgs: string[]): AdapterSlot[];