@orgloop/agentctl 1.1.0 → 1.2.1

package/dist/cli.js

@@ -9,21 +9,34 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { Command } from "commander";
 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 { DaemonClient } from "./client/daemon-client.js";
 import { runHook } from "./hooks.js";
+import { orchestrateLaunch, parseAdapterSlots, } from "./launch-orchestrator.js";
+import { expandMatrix, parseMatrixFile } from "./matrix-parser.js";
 import { mergeSession } from "./merge.js";
 import { createWorktree } from "./worktree.js";
 const adapters = {
     "claude-code": new ClaudeCodeAdapter(),
+    codex: new CodexAdapter(),
     openclaw: new OpenClawAdapter(),
+    opencode: new OpenCodeAdapter(),
+    pi: new PiAdapter(),
+    "pi-rust": new PiRustAdapter(),
 };
 const client = new DaemonClient();
 /**
  * Ensure the daemon is running. Auto-starts it if not.
  * Returns true if daemon is available after the call.
+ * Set AGENTCTL_NO_DAEMON=1 to skip daemon and use direct adapter mode.
  */
 async function ensureDaemon() {
+    if (process.env.AGENTCTL_NO_DAEMON === "1")
+        return false;
     if (await client.isRunning())
         return true;
     // Auto-start daemon in background
@@ -67,27 +80,35 @@ function getAllAdapters() {
     return Object.values(adapters);
 }
 // --- Formatters ---
-function formatSession(s) {
-    return {
+function formatSession(s, showGroup) {
+    const row = {
         ID: s.id.slice(0, 8),
         Status: s.status,
+        Adapter: s.adapter || "-",
         Model: s.model || "-",
-        CWD: s.cwd ? shortenPath(s.cwd) : "-",
-        PID: s.pid?.toString() || "-",
-        Started: timeAgo(s.startedAt),
-        Prompt: (s.prompt || "-").slice(0, 60),
     };
+    if (showGroup)
+        row.Group = s.group || "-";
+    row.CWD = s.cwd ? shortenPath(s.cwd) : "-";
+    row.PID = s.pid?.toString() || "-";
+    row.Started = timeAgo(s.startedAt);
+    row.Prompt = (s.prompt || "-").slice(0, 60);
+    return row;
 }
-function formatRecord(s) {
-    return {
+function formatRecord(s, showGroup) {
+    const row = {
         ID: s.id.slice(0, 8),
         Status: s.status,
+        Adapter: s.adapter || "-",
         Model: s.model || "-",
-        CWD: s.cwd ? shortenPath(s.cwd) : "-",
-        PID: s.pid?.toString() || "-",
-        Started: timeAgo(new Date(s.startedAt)),
-        Prompt: (s.prompt || "-").slice(0, 60),
     };
+    if (showGroup)
+        row.Group = s.group || "-";
+    row.CWD = s.cwd ? shortenPath(s.cwd) : "-";
+    row.PID = s.pid?.toString() || "-";
+    row.Started = timeAgo(new Date(s.startedAt));
+    row.Prompt = (s.prompt || "-").slice(0, 60);
+    return row;
 }
 function shortenPath(p) {
     const home = process.env.HOME || "";
@@ -153,6 +174,7 @@ function sessionToJson(s) {
         tokens: s.tokens,
         cost: s.cost,
         pid: s.pid,
+        group: s.group,
         meta: s.meta,
     };
 }
@@ -168,20 +190,27 @@ program
     .description("List agent sessions")
     .option("--adapter <name>", "Filter by adapter")
     .option("--status <status>", "Filter by status (running|stopped|idle|error)")
+    .option("--group <id>", "Filter by launch group (e.g. g-a1b2c3)")
     .option("-a, --all", "Include stopped sessions (last 7 days)")
     .option("--json", "Output as JSON")
     .action(async (opts) => {
     const daemonRunning = await ensureDaemon();
     if (daemonRunning) {
-        const sessions = await client.call("session.list", {
+        let sessions = await client.call("session.list", {
             status: opts.status,
             all: opts.all,
+            adapter: opts.adapter,
+            group: opts.group,
         });
+        if (opts.adapter) {
+            sessions = sessions.filter((s) => s.adapter === opts.adapter);
+        }
         if (opts.json) {
             printJson(sessions);
         }
         else {
-            printTable(sessions.map(formatRecord));
+            const hasGroups = sessions.some((s) => s.group);
+            printTable(sessions.map((s) => formatRecord(s, hasGroups)));
         }
         return;
     }
@@ -202,7 +231,8 @@ program
         printJson(sessions.map(sessionToJson));
     }
     else {
-        printTable(sessions.map(formatSession));
+        const hasGroups = sessions.some((s) => s.group);
+        printTable(sessions.map((s) => formatSession(s, hasGroups)));
     }
 });
 // status
@@ -222,7 +252,7 @@ program
                 printJson(session);
             }
             else {
-                const fmt = formatRecord(session);
+                const fmt = formatRecord(session, !!session.group);
                 for (const [k, v] of Object.entries(fmt)) {
                     console.log(`${k.padEnd(10)} ${v}`);
                 }
@@ -232,32 +262,37 @@ program
             }
             return;
         }
-        catch (err) {
-            console.error(err.message);
-            process.exit(1);
+        catch {
+            // Daemon failed — fall through to direct adapter lookup
         }
     }
-    // Direct fallback
-    const adapter = getAdapter(opts.adapter);
-    try {
-        const session = await adapter.status(id);
-        if (opts.json) {
-            printJson(sessionToJson(session));
-        }
-        else {
-            const fmt = formatSession(session);
-            for (const [k, v] of Object.entries(fmt)) {
-                console.log(`${k.padEnd(10)} ${v}`);
+    // Direct fallback: try specified adapter, or search all adapters
+    const statusAdapters = opts.adapter
+        ? [getAdapter(opts.adapter)]
+        : getAllAdapters();
+    for (const adapter of statusAdapters) {
+        try {
+            const session = await adapter.status(id);
+            if (opts.json) {
+                printJson(sessionToJson(session));
             }
-            if (session.tokens) {
-                console.log(`Tokens     in: ${session.tokens.in}, out: ${session.tokens.out}`);
+            else {
+                const fmt = formatSession(session, !!session.group);
+                for (const [k, v] of Object.entries(fmt)) {
+                    console.log(`${k.padEnd(10)} ${v}`);
+                }
+                if (session.tokens) {
+                    console.log(`Tokens     in: ${session.tokens.in}, out: ${session.tokens.out}`);
+                }
             }
+            return;
+        }
+        catch {
+            // Try next adapter
         }
     }
-    catch (err) {
-        console.error(err.message);
-        process.exit(1);
-    }
+    console.error(`Session not found: ${id}`);
+    process.exit(1);
 });
 // peek
 program
@@ -276,22 +311,39 @@ program
             console.log(output);
             return;
         }
+        catch {
+            // Daemon failed — fall through to direct adapter lookup
+        }
+    }
+    // Direct fallback: try specified adapter, or search all adapters
+    if (opts.adapter) {
+        const adapter = getAdapter(opts.adapter);
+        try {
+            const output = await adapter.peek(id, {
+                lines: Number.parseInt(opts.lines, 10),
+            });
+            console.log(output);
+            return;
+        }
         catch (err) {
             console.error(err.message);
             process.exit(1);
         }
     }
-    const adapter = getAdapter(opts.adapter);
-    try {
-        const output = await adapter.peek(id, {
-            lines: Number.parseInt(opts.lines, 10),
-        });
-        console.log(output);
-    }
-    catch (err) {
-        console.error(err.message);
-        process.exit(1);
+    for (const adapter of getAllAdapters()) {
+        try {
+            const output = await adapter.peek(id, {
+                lines: Number.parseInt(opts.lines, 10),
+            });
+            console.log(output);
+            return;
+        }
+        catch {
+            // Try next adapter
+        }
     }
+    console.error(`Session not found: ${id}`);
+    process.exit(1);
 });
 // stop
 program
@@ -356,7 +408,7 @@ program
 // launch
 program
     .command("launch [adapter]")
-    .description("Launch a new agent session")
+    .description("Launch a new agent session (or multiple with --adapter flags)")
     .requiredOption("-p, --prompt <text>", "Prompt to send")
     .option("--spec <path>", "Spec file path")
     .option("--cwd <dir>", "Working directory")
@@ -364,13 +416,108 @@ program
     .option("--force", "Override directory locks")
     .option("--worktree <repo>", "Auto-create git worktree from this repo before launch")
     .option("--branch <name>", "Branch name for --worktree")
+    .option("--adapter <name>", "Adapter to launch (repeatable for parallel launch)", collectAdapter, [])
+    .option("--matrix <file>", "YAML matrix file for advanced sweep launch")
     .option("--on-create <script>", "Hook: run after session is created")
     .option("--on-complete <script>", "Hook: run after session completes")
     .option("--pre-merge <script>", "Hook: run before merge")
     .option("--post-merge <script>", "Hook: run after merge")
+    .allowUnknownOption() // Allow interleaved --adapter/--model for parseAdapterSlots
     .action(async (adapterName, opts) => {
     let cwd = opts.cwd ? path.resolve(opts.cwd) : process.cwd();
-    const name = adapterName || "claude-code";
+    // Collect hooks
+    const hooks = opts.onCreate || opts.onComplete || opts.preMerge || opts.postMerge
+        ? {
+            onCreate: opts.onCreate,
+            onComplete: opts.onComplete,
+            preMerge: opts.preMerge,
+            postMerge: opts.postMerge,
+        }
+        : undefined;
+    // --- Multi-adapter / matrix detection ---
+    let slots = [];
+    if (opts.matrix) {
+        // Matrix file mode
+        try {
+            const matrixFile = await parseMatrixFile(opts.matrix);
+            slots = expandMatrix(matrixFile);
+            // Matrix can override cwd and prompt
+            if (matrixFile.cwd)
+                cwd = path.resolve(matrixFile.cwd);
+        }
+        catch (err) {
+            console.error(`Failed to parse matrix file: ${err.message}`);
+            process.exit(1);
+        }
+    }
+    else {
+        // Check for multi-adapter via raw argv parsing
+        // We need raw argv because commander can't handle interleaved
+        // --adapter A --model M1 --adapter B --model M2
+        const rawArgs = process.argv.slice(2);
+        const adapterCount = rawArgs.filter((a) => a === "--adapter" || a === "-A").length;
+        if (adapterCount > 1) {
+            // Multi-adapter mode: parse from raw args
+            slots = parseAdapterSlots(rawArgs);
+        }
+        else if (adapterCount === 1 && opts.adapter?.length === 1) {
+            // Single --adapter flag — could still be multi if model is specified
+            // but this is the normal single-adapter path via --adapter flag
+        }
+    }
+    // --- Parallel launch path ---
+    if (slots.length > 1) {
+        const daemonRunning = await ensureDaemon();
+        try {
+            let groupId = "";
+            const result = await orchestrateLaunch({
+                slots,
+                prompt: opts.prompt,
+                spec: opts.spec,
+                cwd,
+                hooks,
+                adapters,
+                onSessionLaunched: (slotResult) => {
+                    // Track in daemon if available
+                    if (daemonRunning && !slotResult.error) {
+                        client
+                            .call("session.launch.track", {
+                            id: slotResult.sessionId,
+                            adapter: slotResult.slot.adapter,
+                            cwd: slotResult.cwd,
+                            group: groupId,
+                        })
+                            .catch(() => {
+                            // Best effort — session will be picked up by poll
+                        });
+                    }
+                },
+                onGroupCreated: (id) => {
+                    groupId = id;
+                },
+            });
+            console.log(`\nLaunched ${result.results.length} sessions (group: ${result.groupId}):`);
+            for (const r of result.results) {
+                const label = r.slot.model
+                    ? `${r.slot.adapter} (${r.slot.model})`
+                    : r.slot.adapter;
+                if (r.error) {
+                    console.log(`  ✗ ${label} — ${r.error}`);
+                }
+                else {
+                    console.log(`  ${label}  → ${shortenPath(r.cwd)}  (${r.sessionId.slice(0, 8)})`);
+                }
+            }
+        }
+        catch (err) {
+            console.error(`Parallel launch failed: ${err.message}`);
+            process.exit(1);
+        }
+        return;
+    }
+    // --- Single adapter launch path (original behavior) ---
+    const name = slots.length === 1 ? slots[0].adapter : adapterName || "claude-code";
+    const model = slots.length === 1 && slots[0].model ? slots[0].model : opts.model;
     // FEAT-1: Worktree lifecycle
     let worktreeInfo;
     if (opts.worktree) {
@@ -391,15 +538,6 @@ program
             process.exit(1);
         }
     }
-    // Collect hooks
-    const hooks = opts.onCreate || opts.onComplete || opts.preMerge || opts.postMerge
-        ? {
-            onCreate: opts.onCreate,
-            onComplete: opts.onComplete,
-            preMerge: opts.preMerge,
-            postMerge: opts.postMerge,
-        }
-        : undefined;
     const daemonRunning = await ensureDaemon();
     if (daemonRunning) {
         try {
@@ -408,7 +546,7 @@ program
                 prompt: opts.prompt,
                 cwd,
                 spec: opts.spec,
-                model: opts.model,
+                model,
                 force: opts.force,
                 worktree: worktreeInfo
                     ? { repo: worktreeInfo.repo, branch: worktreeInfo.branch }
@@ -443,7 +581,7 @@ program
             prompt: opts.prompt,
             spec: opts.spec,
             cwd,
-            model: opts.model,
+            model,
             hooks,
         });
         console.log(`Launched session ${session.id.slice(0, 8)} (PID: ${session.pid})`);
@@ -462,6 +600,10 @@ program
         process.exit(1);
     }
 });
+/** Commander collect callback for repeatable --adapter */
+function collectAdapter(value, previous) {
+    return previous.concat([value]);
+}
 // events
 program
     .command("events")
@@ -560,6 +702,84 @@ program
         });
     }
 });
+// --- Worktree subcommand ---
+const worktreeCmd = new Command("worktree").description("Manage agentctl-created worktrees");
+worktreeCmd
+    .command("list")
+    .description("List git worktrees for a repo")
+    .argument("<repo>", "Path to the main repo")
+    .option("--json", "Output as JSON")
+    .action(async (repo, opts) => {
+    const { listWorktrees } = await import("./worktree.js");
+    try {
+        const entries = await listWorktrees(repo);
+        // Filter to only non-bare worktrees (exclude the main worktree)
+        const worktrees = entries.filter((e) => !e.bare);
+        if (opts.json) {
+            printJson(worktrees);
+            return;
+        }
+        if (worktrees.length === 0) {
+            console.log("No worktrees found.");
+            return;
+        }
+        printTable(worktrees.map((e) => ({
+            Path: shortenPath(e.path),
+            Branch: e.branch || "-",
+            HEAD: e.head?.slice(0, 8) || "-",
+        })));
+    }
+    catch (err) {
+        console.error(err.message);
+        process.exit(1);
+    }
+});
+worktreeCmd
+    .command("clean")
+    .description("Remove a worktree and optionally its branch")
+    .argument("<path>", "Path to the worktree to remove")
+    .option("--repo <path>", "Main repo path (auto-detected if omitted)")
+    .option("--delete-branch", "Also delete the worktree's branch")
+    .action(async (worktreePath, opts) => {
+    const { cleanWorktree } = await import("./worktree.js");
+    const absPath = path.resolve(worktreePath);
+    let repo = opts.repo;
+    // Auto-detect repo from the worktree's .git file
+    if (!repo) {
+        try {
+            const gitFile = await fs.readFile(path.join(absPath, ".git"), "utf-8");
+            // .git file contains: gitdir: /path/to/repo/.git/worktrees/<name>
+            const match = gitFile.match(/gitdir:\s*(.+)/);
+            if (match) {
+                const gitDir = match[1].trim();
+                // Navigate up from .git/worktrees/<name> to the repo root
+                repo = path.resolve(gitDir, "..", "..", "..");
+            }
+        }
+        catch {
+            console.error("Cannot auto-detect repo. Use --repo to specify the main repository.");
+            process.exit(1);
+        }
+    }
+    if (!repo) {
+        console.error("Cannot determine repo path. Use --repo.");
+        process.exit(1);
+    }
+    try {
+        const result = await cleanWorktree(repo, absPath, {
+            deleteBranch: opts.deleteBranch,
+        });
+        console.log(`Removed worktree: ${shortenPath(result.removedPath)}`);
+        if (result.deletedBranch) {
+            console.log(`Deleted branch: ${result.deletedBranch}`);
+        }
+    }
+    catch (err) {
+        console.error(err.message);
+        process.exit(1);
+    }
+});
+program.addCommand(worktreeCmd);
 // --- Lock commands ---
 program
     .command("lock <directory>")
@@ -650,6 +870,25 @@ program
         process.exit(1);
     }
 });
+// --- Prune command (#40) ---
+program
+    .command("prune")
+    .description("Remove dead and stale sessions from daemon state")
+    .action(async () => {
+    const daemonRunning = await ensureDaemon();
+    if (!daemonRunning) {
+        console.error("Daemon not running. Start with: agentctl daemon start");
+        process.exit(1);
+    }
+    try {
+        const result = await client.call("session.prune");
+        console.log(`Pruned ${result.pruned} dead/stale sessions`);
+    }
+    catch (err) {
+        console.error(err.message);
+        process.exit(1);
+    }
+});
 // --- Daemon subcommand ---
 const daemonCmd = new Command("daemon").description("Manage the agentctl daemon");
 daemonCmd
@@ -727,8 +966,9 @@ daemonCmd
 });
 daemonCmd
     .command("status")
-    .description("Show daemon status")
+    .description("Show daemon status and all daemon-related processes")
     .action(async () => {
+    // Show daemon status
     try {
         const status = await client.call("daemon.status");
         console.log(`Daemon running (PID ${status.pid})`);
@@ -740,6 +980,38 @@ daemonCmd
     catch {
         console.log("Daemon not running");
     }
+    // Show all daemon-related processes (#39)
+    const configDir = path.join(os.homedir(), ".agentctl");
+    const { getSupervisorPid } = await import("./daemon/supervisor.js");
+    const supPid = await getSupervisorPid();
+    let daemonPid = null;
+    try {
+        const raw = await fs.readFile(path.join(configDir, "agentctl.pid"), "utf-8");
+        const pid = Number.parseInt(raw.trim(), 10);
+        try {
+            process.kill(pid, 0);
+            daemonPid = pid;
+        }
+        catch {
+            // PID file is stale
+        }
+    }
+    catch {
+        // No PID file
+    }
+    console.log("\nDaemon-related processes:");
+    if (supPid) {
+        console.log(`  Supervisor: PID ${supPid} (alive)`);
+    }
+    else {
+        console.log("  Supervisor: not running");
+    }
+    if (daemonPid) {
+        console.log(`  Daemon: PID ${daemonPid} (alive)`);
+    }
+    else {
+        console.log("  Daemon: not running");
+    }
 });
 daemonCmd
     .command("restart")

package/dist/core/types.d.ts

@@ -24,6 +24,7 @@ export interface AgentSession {
     };
     cost?: number;
     pid?: number;
+    group?: string;
     meta: Record<string, unknown>;
 }
 export interface LifecycleEvent {