@orgloop/agentctl 1.0.0

package/dist/daemon/server.js

@@ -0,0 +1,283 @@
+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 { ClaudeCodeAdapter } from "../adapters/claude-code.js";
+import { OpenClawAdapter } from "../adapters/openclaw.js";
+import { migrateLocks } from "../migration/migrate-locks.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 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");
+    await fs.rm(sockPath, { force: true });
+    // 3. Run migration (idempotent)
+    await migrateLocks(configDir).catch((err) => console.error("Migration warning:", err.message));
+    // 4. Load persisted state
+    const state = await StateManager.load(configDir);
+    // 5. Initialize subsystems
+    const adapters = opts.adapters || {
+        "claude-code": new ClaudeCodeAdapter(),
+        openclaw: new OpenClawAdapter(),
+    };
+    const lockManager = new LockManager(state);
+    const emitter = new EventEmitter();
+    const fuseEngine = new FuseEngine(state, {
+        defaultDurationMs: 10 * 60 * 1000,
+        emitter,
+    });
+    const sessionTracker = new SessionTracker(state, { adapters });
+    const metrics = new MetricsRegistry(sessionTracker, lockManager, fuseEngine);
+    // Wire up events
+    emitter.on("fuse.fired", () => {
+        metrics.recordFuseFired();
+    });
+    // 6. Resume fuse timers
+    fuseEngine.resumeTimers();
+    // 7. Start session polling
+    sessionTracker.startPolling();
+    // 8. Create request handler
+    const handleRequest = createRequestHandler({
+        sessionTracker,
+        lockManager,
+        fuseEngine,
+        metrics,
+        adapters,
+        state,
+        configDir,
+        sockPath,
+    });
+    // 9. Start Unix socket server
+    const socketServer = net.createServer((conn) => {
+        let buffer = "";
+        conn.on("data", (chunk) => {
+            buffer += chunk.toString();
+            const lines = buffer.split("\n");
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const req = JSON.parse(line);
+                    handleRequest(req).then((result) => {
+                        const resp = { id: req.id, result };
+                        conn.write(`${JSON.stringify(resp)}\n`);
+                    }, (err) => {
+                        const resp = {
+                            id: req.id,
+                            error: {
+                                code: "ERR",
+                                message: err.message,
+                            },
+                        };
+                        conn.write(`${JSON.stringify(resp)}\n`);
+                    });
+                }
+                catch {
+                    // Malformed JSON — ignore
+                }
+            }
+        });
+    });
+    await new Promise((resolve, reject) => {
+        socketServer.listen(sockPath, () => resolve());
+        socketServer.on("error", reject);
+    });
+    // 10. Start HTTP metrics server
+    const metricsPort = opts.metricsPort ?? 9200;
+    const httpServer = http.createServer((req, res) => {
+        if (req.url === "/metrics" && req.method === "GET") {
+            res.writeHead(200, {
+                "Content-Type": "text/plain; version=0.0.4",
+            });
+            res.end(metrics.generateMetrics());
+        }
+        else {
+            res.writeHead(404);
+            res.end("Not Found\n");
+        }
+    });
+    await new Promise((resolve, reject) => {
+        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();
+        fuseEngine.shutdown();
+        state.flush();
+        await state.persist();
+        socketServer.close();
+        httpServer.close();
+        await fs.rm(sockPath, { force: true });
+        await fs.rm(pidFilePath, { force: true });
+    };
+    // 12. Signal handlers
+    for (const sig of ["SIGTERM", "SIGINT"]) {
+        process.on(sig, async () => {
+            console.log(`Received ${sig}, shutting down...`);
+            await shutdown();
+            process.exit(0);
+        });
+    }
+    console.log(`agentctl daemon started (PID ${process.pid})`);
+    console.log(`  Socket: ${sockPath}`);
+    console.log(`  Metrics: http://localhost:${metricsPort}/metrics`);
+    return { socketServer, httpServer, shutdown };
+}
+function createRequestHandler(ctx) {
+    return async (req) => {
+        const params = (req.params || {});
+        switch (req.method) {
+            case "session.list":
+                return ctx.sessionTracker.listSessions({
+                    status: params.status,
+                    all: params.all,
+                });
+            case "session.status": {
+                const session = ctx.sessionTracker.getSession(params.id);
+                if (!session)
+                    throw new Error(`Session not found: ${params.id}`);
+                return session;
+            }
+            case "session.peek": {
+                const adapterName = params.adapter || "claude-code";
+                const adapter = ctx.adapters[adapterName];
+                if (!adapter)
+                    throw new Error(`Unknown adapter: ${adapterName}`);
+                return adapter.peek(params.id, {
+                    lines: params.lines,
+                });
+            }
+            case "session.launch": {
+                const cwd = params.cwd;
+                // Check locks
+                const lock = ctx.lockManager.check(cwd);
+                if (lock && !params.force) {
+                    if (lock.type === "manual") {
+                        throw new Error(`Directory locked by ${lock.lockedBy}: ${lock.reason}. Use --force to override.`);
+                    }
+                    throw new Error(`Directory in use by session ${lock.sessionId?.slice(0, 8)}. Use --force to override.`);
+                }
+                // Cancel any pending fuse
+                if (cwd) {
+                    ctx.fuseEngine.cancelFuse(cwd);
+                }
+                // Launch via adapter
+                const adapterName = params.adapter || "claude-code";
+                const adapter = ctx.adapters[adapterName];
+                if (!adapter)
+                    throw new Error(`Unknown adapter: ${adapterName}`);
+                const session = await adapter.launch({
+                    adapter: adapterName,
+                    prompt: params.prompt,
+                    cwd,
+                    spec: params.spec,
+                    model: params.model,
+                    env: params.env,
+                    adapterOpts: params.adapterOpts,
+                });
+                const record = ctx.sessionTracker.track(session, adapterName);
+                // Auto-lock
+                if (cwd) {
+                    ctx.lockManager.autoLock(cwd, session.id);
+                }
+                return record;
+            }
+            case "session.stop": {
+                const session = ctx.sessionTracker.getSession(params.id);
+                if (!session)
+                    throw new Error(`Session not found: ${params.id}`);
+                const adapter = ctx.adapters[session.adapter];
+                if (!adapter)
+                    throw new Error(`Unknown adapter: ${session.adapter}`);
+                await adapter.stop(session.id, {
+                    force: params.force,
+                });
+                // Remove auto-lock
+                ctx.lockManager.autoUnlock(session.id);
+                // Mark stopped and start fuse if applicable
+                const stopped = ctx.sessionTracker.onSessionExit(session.id);
+                if (stopped) {
+                    ctx.fuseEngine.onSessionExit(stopped);
+                    ctx.metrics.recordSessionStopped();
+                }
+                return null;
+            }
+            case "session.resume": {
+                const session = ctx.sessionTracker.getSession(params.id);
+                if (!session)
+                    throw new Error(`Session not found: ${params.id}`);
+                const adapter = ctx.adapters[session.adapter];
+                if (!adapter)
+                    throw new Error(`Unknown adapter: ${session.adapter}`);
+                await adapter.resume(session.id, params.message);
+                return null;
+            }
+            case "lock.list":
+                return ctx.lockManager.listAll();
+            case "lock.acquire":
+                return ctx.lockManager.manualLock(params.directory, params.by, params.reason);
+            case "lock.release":
+                ctx.lockManager.manualUnlock(params.directory);
+                return null;
+            case "fuse.list":
+                return ctx.fuseEngine.listActive();
+            case "fuse.cancel":
+                ctx.fuseEngine.cancelFuse(params.directory);
+                return null;
+            case "daemon.status":
+                return {
+                    pid: process.pid,
+                    uptime: Date.now() - startTime,
+                    sessions: ctx.sessionTracker.activeCount(),
+                    locks: ctx.lockManager.listAll().length,
+                    fuses: ctx.fuseEngine.listActive().length,
+                };
+            case "daemon.shutdown":
+                // Graceful shutdown — defer so response can be sent first
+                setTimeout(async () => {
+                    await ctx.state.persist();
+                    process.exit(0);
+                }, 100);
+                return null;
+            default:
+                throw new Error(`Unknown method: ${req.method}`);
+        }
+    };
+}
+// --- Helpers ---
+async function readPidFile(pidFilePath) {
+    try {
+        const raw = await fs.readFile(pidFilePath, "utf-8");
+        return Number.parseInt(raw.trim(), 10);
+    }
+    catch {
+        return null;
+    }
+}
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

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

@@ -0,0 +1,28 @@
+import type { AgentAdapter, AgentSession } from "../core/types.js";
+import type { SessionRecord, StateManager } from "./state.js";
+export interface SessionTrackerOpts {
+    adapters: Record<string, AgentAdapter>;
+    pollIntervalMs?: number;
+}
+export declare class SessionTracker {
+    private state;
+    private adapters;
+    private pollIntervalMs;
+    private pollHandle;
+    constructor(state: StateManager, opts: SessionTrackerOpts);
+    startPolling(): void;
+    stopPolling(): void;
+    private poll;
+    /** Track a newly launched session */
+    track(session: AgentSession, adapterName: string): SessionRecord;
+    /** Get session record by id (exact or prefix) */
+    getSession(id: string): SessionRecord | undefined;
+    /** List all tracked sessions */
+    listSessions(opts?: {
+        status?: string;
+        all?: boolean;
+    }): SessionRecord[];
+    activeCount(): number;
+    /** Called when a session stops — returns the cwd for fuse/lock processing */
+    onSessionExit(sessionId: string): SessionRecord | undefined;
+}

package/dist/daemon/session-tracker.js

@@ -0,0 +1,121 @@
+export class SessionTracker {
+    state;
+    adapters;
+    pollIntervalMs;
+    pollHandle = null;
+    constructor(state, opts) {
+        this.state = state;
+        this.adapters = opts.adapters;
+        this.pollIntervalMs = opts.pollIntervalMs ?? 5000;
+    }
+    startPolling() {
+        if (this.pollHandle)
+            return;
+        // Initial poll
+        this.poll().catch((err) => console.error("Poll error:", err));
+        this.pollHandle = setInterval(() => {
+            this.poll().catch((err) => console.error("Poll error:", err));
+        }, this.pollIntervalMs);
+    }
+    stopPolling() {
+        if (this.pollHandle) {
+            clearInterval(this.pollHandle);
+            this.pollHandle = null;
+        }
+    }
+    async poll() {
+        for (const [adapterName, adapter] of Object.entries(this.adapters)) {
+            try {
+                const sessions = await adapter.list({ all: true });
+                for (const session of sessions) {
+                    const existing = this.state.getSession(session.id);
+                    const record = sessionToRecord(session, adapterName);
+                    if (!existing) {
+                        this.state.setSession(session.id, record);
+                    }
+                    else if (existing.status !== record.status) {
+                        // Status changed — update
+                        this.state.setSession(session.id, {
+                            ...existing,
+                            status: record.status,
+                            stoppedAt: record.stoppedAt,
+                            tokens: record.tokens,
+                            cost: record.cost,
+                        });
+                    }
+                }
+            }
+            catch {
+                // Adapter unavailable — skip
+            }
+        }
+    }
+    /** Track a newly launched session */
+    track(session, adapterName) {
+        const record = sessionToRecord(session, adapterName);
+        this.state.setSession(session.id, record);
+        return record;
+    }
+    /** Get session record by id (exact or prefix) */
+    getSession(id) {
+        // Exact match
+        const exact = this.state.getSession(id);
+        if (exact)
+            return exact;
+        // Prefix match
+        const sessions = this.state.getSessions();
+        const matches = Object.entries(sessions).filter(([key]) => key.startsWith(id));
+        if (matches.length === 1)
+            return matches[0][1];
+        return undefined;
+    }
+    /** List all tracked sessions */
+    listSessions(opts) {
+        const sessions = Object.values(this.state.getSessions());
+        let filtered = sessions;
+        if (opts?.status) {
+            filtered = filtered.filter((s) => s.status === opts.status);
+        }
+        else if (!opts?.all) {
+            filtered = filtered.filter((s) => s.status === "running" || s.status === "idle");
+        }
+        return filtered.sort((a, b) => {
+            // Running first, then by recency
+            if (a.status === "running" && b.status !== "running")
+                return -1;
+            if (b.status === "running" && a.status !== "running")
+                return 1;
+            return new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime();
+        });
+    }
+    activeCount() {
+        return Object.values(this.state.getSessions()).filter((s) => s.status === "running" || s.status === "idle").length;
+    }
+    /** Called when a session stops — returns the cwd for fuse/lock processing */
+    onSessionExit(sessionId) {
+        const session = this.state.getSession(sessionId);
+        if (session) {
+            session.status = "stopped";
+            session.stoppedAt = new Date().toISOString();
+            this.state.setSession(sessionId, session);
+        }
+        return session;
+    }
+}
+function sessionToRecord(session, adapterName) {
+    return {
+        id: session.id,
+        adapter: adapterName,
+        status: session.status,
+        startedAt: session.startedAt.toISOString(),
+        stoppedAt: session.stoppedAt?.toISOString(),
+        cwd: session.cwd,
+        spec: session.spec,
+        model: session.model,
+        prompt: session.prompt,
+        tokens: session.tokens,
+        cost: session.cost,
+        pid: session.pid,
+        meta: session.meta,
+    };
+}

package/dist/daemon/state.d.ts

@@ -0,0 +1,61 @@
+export interface SessionRecord {
+    id: string;
+    adapter: string;
+    status: "running" | "idle" | "stopped" | "error" | "completed" | "failed" | "pending";
+    startedAt: string;
+    stoppedAt?: string;
+    cwd?: string;
+    spec?: string;
+    model?: string;
+    prompt?: string;
+    tokens?: {
+        in: number;
+        out: number;
+    };
+    cost?: number;
+    pid?: number;
+    exitCode?: number;
+    meta: Record<string, unknown>;
+}
+export interface Lock {
+    directory: string;
+    type: "auto" | "manual";
+    sessionId?: string;
+    lockedBy?: string;
+    reason?: string;
+    lockedAt: string;
+}
+export interface FuseTimer {
+    directory: string;
+    clusterName: string;
+    branch: string;
+    expiresAt: string;
+    sessionId: string;
+}
+export interface PersistedState {
+    sessions: Record<string, SessionRecord>;
+    locks: Lock[];
+    fuses: FuseTimer[];
+    version: number;
+}
+export declare class StateManager {
+    private state;
+    private configDir;
+    private persistTimer;
+    constructor(configDir: string, state?: PersistedState);
+    static load(configDir: string): Promise<StateManager>;
+    persist(): Promise<void>;
+    markDirty(): void;
+    getSessions(): Record<string, SessionRecord>;
+    getSession(id: string): SessionRecord | undefined;
+    setSession(id: string, session: SessionRecord): void;
+    removeSession(id: string): void;
+    getLocks(): Lock[];
+    addLock(lock: Lock): void;
+    removeLocks(predicate: (lock: Lock) => boolean): void;
+    getFuses(): FuseTimer[];
+    addFuse(fuse: FuseTimer): void;
+    removeFuse(directory: string): void;
+    /** Flush pending timer (for clean shutdown) */
+    flush(): void;
+}

package/dist/daemon/state.js

@@ -0,0 +1,126 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+const SCHEMA_VERSION = 1;
+export class StateManager {
+    state;
+    configDir;
+    persistTimer = null;
+    constructor(configDir, state) {
+        this.configDir = configDir;
+        this.state = state || {
+            sessions: {},
+            locks: [],
+            fuses: [],
+            version: SCHEMA_VERSION,
+        };
+    }
+    static async load(configDir) {
+        await fs.mkdir(configDir, { recursive: true });
+        const state = {
+            sessions: {},
+            locks: [],
+            fuses: [],
+            version: SCHEMA_VERSION,
+        };
+        // Load state.json
+        try {
+            const raw = await fs.readFile(path.join(configDir, "state.json"), "utf-8");
+            const parsed = JSON.parse(raw);
+            if (parsed.sessions)
+                state.sessions = parsed.sessions;
+            if (parsed.version)
+                state.version = parsed.version;
+        }
+        catch {
+            // First run or missing file
+        }
+        // Load locks.json
+        try {
+            const raw = await fs.readFile(path.join(configDir, "locks.json"), "utf-8");
+            state.locks = JSON.parse(raw);
+        }
+        catch {
+            // First run or missing file
+        }
+        // Load fuses.json
+        try {
+            const raw = await fs.readFile(path.join(configDir, "fuses.json"), "utf-8");
+            state.fuses = JSON.parse(raw);
+        }
+        catch {
+            // First run or missing file
+        }
+        return new StateManager(configDir, state);
+    }
+    async persist() {
+        if (this.persistTimer) {
+            clearTimeout(this.persistTimer);
+            this.persistTimer = null;
+        }
+        await fs.mkdir(this.configDir, { recursive: true });
+        // Atomic writes via write-to-tmp + rename
+        await atomicWrite(path.join(this.configDir, "state.json"), JSON.stringify({ sessions: this.state.sessions, version: this.state.version }, null, 2));
+        await atomicWrite(path.join(this.configDir, "locks.json"), JSON.stringify(this.state.locks, null, 2));
+        await atomicWrite(path.join(this.configDir, "fuses.json"), JSON.stringify(this.state.fuses, null, 2));
+    }
+    markDirty() {
+        if (!this.persistTimer) {
+            this.persistTimer = setTimeout(() => {
+                this.persist().catch((err) => console.error("Failed to persist state:", err));
+            }, 1000);
+        }
+    }
+    // --- Session accessors ---
+    getSessions() {
+        return this.state.sessions;
+    }
+    getSession(id) {
+        return this.state.sessions[id];
+    }
+    setSession(id, session) {
+        this.state.sessions[id] = session;
+        this.markDirty();
+    }
+    removeSession(id) {
+        delete this.state.sessions[id];
+        this.markDirty();
+    }
+    // --- Lock accessors ---
+    getLocks() {
+        return [...this.state.locks];
+    }
+    addLock(lock) {
+        this.state.locks.push(lock);
+        this.markDirty();
+    }
+    removeLocks(predicate) {
+        this.state.locks = this.state.locks.filter((l) => !predicate(l));
+        this.markDirty();
+    }
+    // --- Fuse accessors ---
+    getFuses() {
+        return [...this.state.fuses];
+    }
+    addFuse(fuse) {
+        // Remove existing fuse for same directory first
+        this.state.fuses = this.state.fuses.filter((f) => f.directory !== fuse.directory);
+        this.state.fuses.push(fuse);
+        this.markDirty();
+    }
+    removeFuse(directory) {
+        this.state.fuses = this.state.fuses.filter((f) => f.directory !== directory);
+        this.markDirty();
+    }
+    /** Flush pending timer (for clean shutdown) */
+    flush() {
+        if (this.persistTimer) {
+            clearTimeout(this.persistTimer);
+            this.persistTimer = null;
+        }
+    }
+}
+async function atomicWrite(filePath, data) {
+    const tmpPath = `${filePath}.tmp`;
+    await fs.writeFile(tmpPath, data, "utf-8");
+    await fs.rename(tmpPath, filePath);
+}

package/dist/daemon/supervisor.d.ts

@@ -0,0 +1,24 @@
+export interface SupervisorOpts {
+    /** Path to Node.js executable */
+    nodePath: string;
+    /** Path to the CLI entry point */
+    cliPath: string;
+    /** Metrics port */
+    metricsPort: number;
+    /** Config directory (~/.agentctl) */
+    configDir: string;
+    /** Minimum backoff delay in ms (default: 1000) */
+    minBackoffMs?: number;
+    /** Maximum backoff delay in ms (default: 300000 = 5min) */
+    maxBackoffMs?: number;
+    /** Reset backoff after this many ms of uptime (default: 60000 = 1min) */
+    stableUptimeMs?: number;
+}
+/**
+ * Daemon supervisor — launches the daemon in foreground mode and
+ * restarts it on crash with exponential backoff (1s, 2s, 4s... cap 5min).
+ * Resets backoff after stable uptime.
+ */
+export declare function runSupervisor(opts: SupervisorOpts): Promise<void>;
+/** Read the supervisor PID from disk and check if it's alive */
+export declare function getSupervisorPid(configDir?: string): Promise<number | null>;