@orgloop/agentctl 1.2.1 → 1.4.0

package/dist/adapters/claude-code.d.ts

@@ -1,4 +1,4 @@
-import type { AgentAdapter, AgentSession, LaunchOpts, LifecycleEvent, ListOpts, PeekOpts, StopOpts } from "../core/types.js";
+import type { AgentAdapter, AgentSession, DiscoveredSession, LaunchOpts, LifecycleEvent, ListOpts, PeekOpts, StopOpts } from "../core/types.js";
 export interface PidInfo {
     pid: number;
     cwd: string;
@@ -38,6 +38,8 @@ export declare class ClaudeCodeAdapter implements AgentAdapter {
     private readonly getPids;
     private readonly isProcessAlive;
     constructor(opts?: ClaudeCodeAdapterOpts);
+    discover(): Promise<DiscoveredSession[]>;
+    isAlive(sessionId: string): Promise<boolean>;
     list(opts?: ListOpts): Promise<AgentSession[]>;
     peek(sessionId: string, opts?: PeekOpts): Promise<string>;
     status(sessionId: string): Promise<AgentSession>;

package/dist/adapters/claude-code.js

@@ -32,6 +32,57 @@ export class ClaudeCodeAdapter {
         this.getPids = opts?.getPids || getClaudePids;
         this.isProcessAlive = opts?.isProcessAlive || defaultIsProcessAlive;
     }
+    async discover() {
+        const runningPids = await this.getPids();
+        const results = [];
+        let projectDirs;
+        try {
+            projectDirs = await fs.readdir(this.projectsDir);
+        }
+        catch {
+            return [];
+        }
+        for (const projDir of projectDirs) {
+            const projPath = path.join(this.projectsDir, projDir);
+            const stat = await fs.stat(projPath).catch(() => null);
+            if (!stat?.isDirectory())
+                continue;
+            const entries = await this.getEntriesForProject(projPath, projDir);
+            for (const { entry, index } of entries) {
+                if (entry.isSidechain)
+                    continue;
+                const isRunning = await this.isSessionRunning(entry, index, runningPids);
+                const { model, tokens } = await this.parseSessionTail(entry.fullPath);
+                results.push({
+                    id: entry.sessionId,
+                    status: isRunning ? "running" : "stopped",
+                    adapter: this.id,
+                    cwd: index.originalPath || entry.projectPath,
+                    model,
+                    startedAt: new Date(entry.created),
+                    stoppedAt: isRunning ? undefined : new Date(entry.modified),
+                    pid: isRunning
+                        ? await this.findMatchingPid(entry, index, runningPids)
+                        : undefined,
+                    prompt: entry.firstPrompt?.slice(0, 200),
+                    tokens,
+                    nativeMetadata: {
+                        projectDir: index.originalPath || entry.projectPath,
+                        gitBranch: entry.gitBranch,
+                        messageCount: entry.messageCount,
+                    },
+                });
+            }
+        }
+        return results;
+    }
+    async isAlive(sessionId) {
+        const runningPids = await this.getPids();
+        const entry = await this.findIndexEntry(sessionId);
+        if (!entry)
+            return false;
+        return this.isSessionRunning(entry.entry, entry.index, runningPids);
+    }
     async list(opts) {
         const runningPids = await this.getPids();
         const sessions = [];

package/dist/adapters/codex.d.ts

@@ -1,4 +1,4 @@
-import type { AgentAdapter, AgentSession, LaunchOpts, LifecycleEvent, ListOpts, PeekOpts, StopOpts } from "../core/types.js";
+import type { AgentAdapter, AgentSession, DiscoveredSession, LaunchOpts, LifecycleEvent, ListOpts, PeekOpts, StopOpts } from "../core/types.js";
 export interface CodexPidInfo {
     pid: number;
     cwd: string;
@@ -34,6 +34,8 @@ export declare class CodexAdapter implements AgentAdapter {
     private readonly getPids;
     private readonly isProcessAlive;
     constructor(opts?: CodexAdapterOpts);
+    discover(): Promise<DiscoveredSession[]>;
+    isAlive(sessionId: string): Promise<boolean>;
     list(opts?: ListOpts): Promise<AgentSession[]>;
     peek(sessionId: string, opts?: PeekOpts): Promise<string>;
     status(sessionId: string): Promise<AgentSession>;

package/dist/adapters/codex.js

@@ -30,6 +30,41 @@ export class CodexAdapter {
         this.getPids = opts?.getPids || getCodexPids;
         this.isProcessAlive = opts?.isProcessAlive || defaultIsProcessAlive;
     }
+    async discover() {
+        const runningPids = await this.getPids();
+        const sessionInfos = await this.discoverSessions();
+        const results = [];
+        for (const info of sessionInfos) {
+            const isRunning = this.isSessionRunning(info, runningPids);
+            const pid = isRunning
+                ? this.findMatchingPid(info, runningPids)
+                : undefined;
+            results.push({
+                id: info.id,
+                status: isRunning ? "running" : "stopped",
+                adapter: this.id,
+                cwd: info.cwd,
+                model: info.model,
+                startedAt: info.created,
+                stoppedAt: isRunning ? undefined : info.modified,
+                pid,
+                prompt: info.firstPrompt,
+                tokens: info.tokens,
+                nativeMetadata: {
+                    cliVersion: info.cliVersion,
+                    lastMessage: info.lastMessage,
+                },
+            });
+        }
+        return results;
+    }
+    async isAlive(sessionId) {
+        const runningPids = await this.getPids();
+        const info = await this.findSession(sessionId);
+        if (!info)
+            return false;
+        return this.isSessionRunning(info, runningPids);
+    }
     async list(opts) {
         const runningPids = await this.getPids();
         const sessionInfos = await this.discoverSessions();

package/dist/adapters/openclaw.d.ts

@@ -1,4 +1,4 @@
-import type { AgentAdapter, AgentSession, LaunchOpts, LifecycleEvent, ListOpts, PeekOpts, StopOpts } from "../core/types.js";
+import type { AgentAdapter, AgentSession, DiscoveredSession, LaunchOpts, LifecycleEvent, ListOpts, PeekOpts, StopOpts } from "../core/types.js";
 export interface DeviceIdentity {
     deviceId: string;
     publicKeyPem: string;
@@ -122,6 +122,8 @@ export declare class OpenClawAdapter implements AgentAdapter {
     private readonly rpcCall;
     constructor(opts?: OpenClawAdapterOpts);
     private tryLoadDeviceIdentity;
+    discover(): Promise<DiscoveredSession[]>;
+    isAlive(sessionId: string): Promise<boolean>;
     list(opts?: ListOpts): Promise<AgentSession[]>;
     peek(sessionId: string, opts?: PeekOpts): Promise<string>;
     status(sessionId: string): Promise<AgentSession>;

package/dist/adapters/openclaw.js

@@ -197,6 +197,62 @@ export class OpenClawAdapter {
             return null;
         }
     }
+    async discover() {
+        if (!this.authToken)
+            return [];
+        let result;
+        try {
+            result = (await this.rpcCall("sessions.list", {
+                includeDerivedTitles: true,
+                includeLastMessage: true,
+            }));
+        }
+        catch {
+            return [];
+        }
+        return result.sessions.map((row) => {
+            const updatedAt = row.updatedAt ?? 0;
+            const model = row.model || result.defaults.model || undefined;
+            const input = row.inputTokens ?? 0;
+            const output = row.outputTokens ?? 0;
+            // Gateway is the source of truth: if a session is in the list, it's alive.
+            // Don't guess from timestamps — sessions can be idle for hours between messages.
+            return {
+                id: row.sessionId || row.key,
+                status: "running",
+                adapter: this.id,
+                model,
+                startedAt: updatedAt > 0 ? new Date(updatedAt) : new Date(),
+                prompt: row.derivedTitle || row.displayName || row.label,
+                tokens: input || output ? { in: input, out: output } : undefined,
+                nativeMetadata: {
+                    key: row.key,
+                    kind: row.kind,
+                    channel: row.channel,
+                    displayName: row.displayName,
+                    modelProvider: row.modelProvider || result.defaults.modelProvider,
+                    lastMessagePreview: row.lastMessagePreview,
+                },
+            };
+        });
+    }
+    async isAlive(sessionId) {
+        if (!this.authToken)
+            return false;
+        try {
+            const result = (await this.rpcCall("sessions.list", {
+                search: sessionId,
+            }));
+            // Gateway is the source of truth: if a session is in the list, it's alive.
+            return result.sessions.some((s) => s.sessionId === sessionId ||
+                s.key === sessionId ||
+                s.sessionId?.startsWith(sessionId) ||
+                s.key.startsWith(sessionId));
+        }
+        catch {
+            return false;
+        }
+    }
     async list(opts) {
         if (!this.authToken) {
             console.warn("Warning: OPENCLAW_GATEWAY_TOKEN is not set — OpenClaw adapter cannot authenticate. " +
@@ -342,17 +398,18 @@ export class OpenClawAdapter {
     }
     // --- Private helpers ---
     mapRowToSession(row, defaults) {
-        const now = Date.now();
         const updatedAt = row.updatedAt ?? 0;
-        const ageMs = now - updatedAt;
-        const isActive = updatedAt > 0 && ageMs < 5 * 60 * 1000;
+        const ageMs = Date.now() - updatedAt;
+        // Gateway is the source of truth: if a session is in the list, it's alive.
+        // Use "running" for recently active sessions, "idle" for quiet ones.
+        const status = updatedAt > 0 && ageMs < 5 * 60 * 1000 ? "running" : "idle";
         const model = row.model || defaults.model || undefined;
         const input = row.inputTokens ?? 0;
         const output = row.outputTokens ?? 0;
         return {
             id: row.sessionId || row.key,
             adapter: this.id,
-            status: isActive ? "running" : "idle",
+            status,
             startedAt: updatedAt > 0 ? new Date(updatedAt) : new Date(),
             cwd: undefined,
             model,

package/dist/adapters/opencode.d.ts

@@ -1,4 +1,4 @@
-import type { AgentAdapter, AgentSession, LaunchOpts, LifecycleEvent, ListOpts, PeekOpts, StopOpts } from "../core/types.js";
+import type { AgentAdapter, AgentSession, DiscoveredSession, LaunchOpts, LifecycleEvent, ListOpts, PeekOpts, StopOpts } from "../core/types.js";
 export interface PidInfo {
     pid: number;
     cwd: string;
@@ -95,6 +95,8 @@ export declare class OpenCodeAdapter implements AgentAdapter {
     private readonly getPids;
     private readonly isProcessAlive;
     constructor(opts?: OpenCodeAdapterOpts);
+    discover(): Promise<DiscoveredSession[]>;
+    isAlive(sessionId: string): Promise<boolean>;
     list(opts?: ListOpts): Promise<AgentSession[]>;
     peek(sessionId: string, opts?: PeekOpts): Promise<string>;
     status(sessionId: string): Promise<AgentSession>;

package/dist/adapters/opencode.js

@@ -39,6 +39,63 @@ export class OpenCodeAdapter {
         this.getPids = opts?.getPids || getOpenCodePids;
         this.isProcessAlive = opts?.isProcessAlive || defaultIsProcessAlive;
     }
+    async discover() {
+        const runningPids = await this.getPids();
+        const results = [];
+        let projectDirs;
+        try {
+            projectDirs = await fs.readdir(this.sessionDir);
+        }
+        catch {
+            return [];
+        }
+        for (const projHash of projectDirs) {
+            const projPath = path.join(this.sessionDir, projHash);
+            const stat = await fs.stat(projPath).catch(() => null);
+            if (!stat?.isDirectory())
+                continue;
+            const sessionFiles = await this.getSessionFilesForProject(projPath);
+            for (const sessionData of sessionFiles) {
+                const isRunning = await this.isSessionRunning(sessionData, runningPids);
+                const { model, tokens, cost } = await this.aggregateMessageStats(sessionData.id);
+                const createdAt = sessionData.time?.created
+                    ? new Date(sessionData.time.created)
+                    : new Date();
+                const updatedAt = sessionData.time?.updated
+                    ? new Date(sessionData.time.updated)
+                    : undefined;
+                results.push({
+                    id: sessionData.id,
+                    status: isRunning ? "running" : "stopped",
+                    adapter: this.id,
+                    cwd: sessionData.directory,
+                    model,
+                    startedAt: createdAt,
+                    stoppedAt: isRunning ? undefined : updatedAt,
+                    pid: isRunning
+                        ? await this.findMatchingPid(sessionData, runningPids)
+                        : undefined,
+                    prompt: sessionData.title?.slice(0, 200),
+                    tokens,
+                    cost,
+                    nativeMetadata: {
+                        projectID: sessionData.projectID,
+                        slug: sessionData.slug,
+                        summary: sessionData.summary,
+                        version: sessionData.version,
+                    },
+                });
+            }
+        }
+        return results;
+    }
+    async isAlive(sessionId) {
+        const runningPids = await this.getPids();
+        const resolved = await this.resolveSessionId(sessionId);
+        if (!resolved)
+            return false;
+        return this.isSessionRunning(resolved, runningPids);
+    }
     async list(opts) {
         const runningPids = await this.getPids();
         const sessions = [];

package/dist/adapters/pi-rust.d.ts

@@ -1,4 +1,4 @@
-import type { AgentAdapter, AgentSession, LaunchOpts, LifecycleEvent, ListOpts, PeekOpts, StopOpts } from "../core/types.js";
+import type { AgentAdapter, AgentSession, DiscoveredSession, LaunchOpts, LifecycleEvent, ListOpts, PeekOpts, StopOpts } from "../core/types.js";
 export interface PidInfo {
     pid: number;
     cwd: string;
@@ -41,6 +41,8 @@ export declare class PiRustAdapter implements AgentAdapter {
     private readonly getPids;
     private readonly isProcessAlive;
     constructor(opts?: PiRustAdapterOpts);
+    discover(): Promise<DiscoveredSession[]>;
+    isAlive(sessionId: string): Promise<boolean>;
     list(opts?: ListOpts): Promise<AgentSession[]>;
     peek(sessionId: string, opts?: PeekOpts): Promise<string>;
     status(sessionId: string): Promise<AgentSession>;

package/dist/adapters/pi-rust.js

@@ -33,6 +33,80 @@ export class PiRustAdapter {
         this.getPids = opts?.getPids || getPiRustPids;
         this.isProcessAlive = opts?.isProcessAlive || defaultIsProcessAlive;
     }
+    async discover() {
+        const runningPids = await this.getPids();
+        const results = [];
+        let projectDirs;
+        try {
+            const entries = await fs.readdir(this.sessionDir);
+            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 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
+                }
+                results.push({
+                    id: header.id,
+                    status: isRunning ? "running" : "stopped",
+                    adapter: this.id,
+                    cwd: header.cwd || projectCwd,
+                    model: model || header.modelId,
+                    startedAt: new Date(header.timestamp),
+                    stoppedAt: isRunning
+                        ? undefined
+                        : fileStat
+                            ? new Date(Number(fileStat.mtimeMs))
+                            : undefined,
+                    pid: isRunning
+                        ? await this.findMatchingPid(header, projectCwd, runningPids)
+                        : undefined,
+                    prompt: firstPrompt?.slice(0, 200),
+                    tokens,
+                    cost: cost ?? undefined,
+                    nativeMetadata: {
+                        provider: header.provider,
+                        thinkingLevel: header.thinkingLevel,
+                        projectDir: projectCwd,
+                        sessionFile: filePath,
+                    },
+                });
+            }
+        }
+        return results;
+    }
+    async isAlive(sessionId) {
+        const runningPids = await this.getPids();
+        const filePath = await this.findSessionFile(sessionId);
+        if (!filePath)
+            return false;
+        const header = await this.readSessionHeader(filePath);
+        if (!header)
+            return false;
+        const projDir = path.basename(path.dirname(filePath));
+        const projectCwd = decodeProjDir(projDir);
+        return this.isSessionRunning(header, projectCwd, runningPids);
+    }
     async list(opts) {
         const runningPids = await this.getPids();
         const sessions = [];

package/dist/adapters/pi.d.ts

@@ -1,4 +1,4 @@
-import type { AgentAdapter, AgentSession, LaunchOpts, LifecycleEvent, ListOpts, PeekOpts, StopOpts } from "../core/types.js";
+import type { AgentAdapter, AgentSession, DiscoveredSession, LaunchOpts, LifecycleEvent, ListOpts, PeekOpts, StopOpts } from "../core/types.js";
 export interface PidInfo {
     pid: number;
     cwd: string;
@@ -41,6 +41,8 @@ export declare class PiAdapter implements AgentAdapter {
     private readonly getPids;
     private readonly isProcessAlive;
     constructor(opts?: PiAdapterOpts);
+    discover(): Promise<DiscoveredSession[]>;
+    isAlive(sessionId: string): Promise<boolean>;
     list(opts?: ListOpts): Promise<AgentSession[]>;
     peek(sessionId: string, opts?: PeekOpts): Promise<string>;
     /** Extract assistant messages from a JSONL session file */

package/dist/adapters/pi.js

@@ -33,6 +33,44 @@ export class PiAdapter {
         this.getPids = opts?.getPids || getPiPids;
         this.isProcessAlive = opts?.isProcessAlive || defaultIsProcessAlive;
     }
+    async discover() {
+        const runningPids = await this.getPids();
+        const discovered = await this.discoverSessions();
+        const results = [];
+        for (const disc of discovered) {
+            const isRunning = await this.isSessionRunning(disc, runningPids);
+            const { model, tokens, cost } = await this.parseSessionTail(disc.filePath, disc.header);
+            results.push({
+                id: disc.sessionId,
+                status: isRunning ? "running" : "stopped",
+                adapter: this.id,
+                cwd: disc.header.cwd,
+                model,
+                startedAt: disc.created,
+                stoppedAt: isRunning ? undefined : disc.modified,
+                pid: isRunning
+                    ? await this.findMatchingPid(disc, runningPids)
+                    : undefined,
+                prompt: await this.getFirstPrompt(disc.filePath),
+                tokens,
+                cost,
+                nativeMetadata: {
+                    provider: disc.header.provider,
+                    thinkingLevel: disc.header.thinkingLevel,
+                    version: disc.header.version,
+                    cwdSlug: disc.cwdSlug,
+                },
+            });
+        }
+        return results;
+    }
+    async isAlive(sessionId) {
+        const runningPids = await this.getPids();
+        const disc = await this.findSession(sessionId);
+        if (!disc)
+            return false;
+        return this.isSessionRunning(disc, runningPids);
+    }
     async list(opts) {
         const runningPids = await this.getPids();
         const discovered = await this.discoverSessions();