@phnx-labs/agents-cli 1.20.28 → 1.20.29

package/dist/lib/session/db.js

@@ -290,9 +290,9 @@ export function getDBPath() {
 export function getScanStampByPath(filePath) {
     const db = getDB();
     const row = db
-        .prepare(`SELECT file_mtime_ms, file_size FROM scan_ledger WHERE file_path = ? LIMIT 1`)
+        .prepare(`SELECT file_mtime_ms, file_size, scanned_at FROM scan_ledger WHERE file_path = ? LIMIT 1`)
         .get(canonicalLedgerKey(filePath));
-    return row ? { fileMtimeMs: row.file_mtime_ms, fileSize: row.file_size } : null;
+    return row ? { fileMtimeMs: row.file_mtime_ms, fileSize: row.file_size, scannedAt: row.scanned_at } : null;
 }
 /**
  * Bulk-load the stamp ledger for a set of file paths in a single SQL query.
@@ -324,13 +324,13 @@ export function getScanStampsForPaths(filePaths) {
         const placeholders = chunk.map(() => '?').join(',');
         const rows = db
             .prepare(`
-        SELECT file_path, file_mtime_ms, file_size
+        SELECT file_path, file_mtime_ms, file_size, scanned_at
         FROM scan_ledger
         WHERE file_path IN (${placeholders})
       `)
             .all(...chunk);
         for (const row of rows) {
-            const stamp = { fileMtimeMs: row.file_mtime_ms, fileSize: row.file_size };
+            const stamp = { fileMtimeMs: row.file_mtime_ms, fileSize: row.file_size, scannedAt: row.scanned_at };
             for (const original of canonicalToOriginals.get(row.file_path) || []) {
                 result.set(original, stamp);
             }

package/dist/lib/session/discover.d.ts

@@ -7,6 +7,7 @@
  * subsequent queries are served entirely from the cache.
  */
 import type { SessionAgentId, SessionMeta } from './types.js';
+import { type ScanStamp } from './db.js';
 /** Options controlling which sessions to discover and how to report progress. */
 export interface DiscoverOptions {
     agent?: SessionAgentId;
@@ -85,6 +86,7 @@ export declare function resolveSessionById(sessions: SessionMeta[], idQuery: str
  * preserving the existing SessionMeta[] contract so sessions.ts is unchanged.
  */
 export declare function searchContentIndex(sessions: SessionMeta[], query: string): Map<string, SessionMeta>;
+export declare function shouldDeferRecentAppend(prev: ScanStamp, current: ScanStamp, nowMs: number, debounceMs?: number): boolean;
 /**
  * Collect all directories to scan for an agent's sessions. Deduplicates by
  * realpath to avoid double-counting symlinked version homes.

package/dist/lib/session/discover.js

@@ -34,6 +34,7 @@ const RUSH_SESSIONS_DIR = path.join(HOME, '.rush', 'sessions');
 const HERMES_SESSIONS_DIR = path.join(HOME, '.hermes', 'sessions');
 /** How long OpenClaw channel/cron snapshots stay valid before we re-shell-out. */
 const OPENCLAW_TTL_MS = 60_000;
+const ACTIVE_APPEND_RESCAN_DEBOUNCE_MS = 5_000;
 let cachedOpenClawWorkspaces = null;
 const cachedAgentVersions = new Map();
 /**
@@ -63,6 +64,7 @@ export async function discoverSessions(options) {
                     case 'rush': return scanRushIncremental(onProgress);
                     case 'hermes': return scanHermesIncremental(onProgress);
                     case 'kimi': return scanKimiIncremental(onProgress);
+                    case 'droid': return scanDroidIncremental(onProgress);
                 }
             }));
         }
@@ -164,10 +166,16 @@ export function searchContentIndex(sessions, query) {
 /**
  * For a list of files, stat each, compare to the DB ledger, and return only
  * the ones that need rescanning. One bulk DB query for the whole list.
+ *
+ * Actively running agents append to their JSONL every few seconds. Without a
+ * small debounce, repeated `agents sessions` invocations stream-parse the same
+ * growing transcript over and over. The cached row is good enough for a few
+ * seconds; once writes settle or the debounce expires, the file is parsed once.
  */
 function filterChangedFiles(filePaths) {
     const ledger = getScanStampsForPaths(filePaths);
     const out = [];
+    const now = Date.now();
     for (const filePath of filePaths) {
         const stat = safeStatSync(filePath);
         if (!stat)
@@ -180,10 +188,22 @@ function filterChangedFiles(filePaths) {
         if (prev && prev.fileMtimeMs === scan.fileMtimeMs && prev.fileSize === scan.fileSize) {
             continue;
         }
+        if (prev && shouldDeferRecentAppend(prev, scan, now)) {
+            continue;
+        }
         out.push({ filePath, scan });
     }
     return out;
 }
+export function shouldDeferRecentAppend(prev, current, nowMs, debounceMs = ACTIVE_APPEND_RESCAN_DEBOUNCE_MS) {
+    if (prev.scannedAt === undefined)
+        return false;
+    if (current.fileSize <= prev.fileSize)
+        return false;
+    if (current.fileMtimeMs < prev.fileMtimeMs)
+        return false;
+    return nowMs - prev.scannedAt < debounceMs;
+}
 // ---------------------------------------------------------------------------
 // Multi-version directory scanning
 // ---------------------------------------------------------------------------
@@ -1291,6 +1311,214 @@ function extractHermesMessageText(content) {
         .join('\n')
         .trim();
 }
+/**
+ * Incrementally re-scan changed Droid (Factory) session files and upsert into
+ * the DB. Droid writes one `<uuid>.jsonl` transcript plus a sibling
+ * `<uuid>.settings.json` (model + token usage) under
+ * `~/.factory/sessions/<encoded-cwd>/`.
+ */
+async function scanDroidIncremental(onProgress) {
+    const currentVersion = await getCurrentAgentVersion('droid');
+    const filePaths = [];
+    for (const sessionsDir of getAgentSessionDirs('droid', 'sessions')) {
+        // High limit: we only stat files here, parsing is gated by ledger match.
+        for (const fp of walkForFiles(sessionsDir, '.jsonl', 100_000)) {
+            filePaths.push(fp);
+        }
+    }
+    const changed = filterChangedFiles(filePaths);
+    if (changed.length === 0)
+        return;
+    onProgress?.({ agent: 'droid', parsed: 0, total: changed.length });
+    const entries = [];
+    const touched = [];
+    const seen = new Set();
+    let parsed = 0;
+    for (const { filePath, scan } of changed) {
+        try {
+            const result = await readDroidMeta(filePath, currentVersion);
+            if (result && !seen.has(result.meta.id)) {
+                seen.add(result.meta.id);
+                entries.push({ meta: result.meta, content: result.content, scan });
+            }
+            else {
+                touched.push({ filePath, scan });
+            }
+        }
+        catch {
+            touched.push({ filePath, scan });
+        }
+        parsed++;
+        onProgress?.({ agent: 'droid', parsed, total: changed.length });
+    }
+    upsertSessionsBatch(entries);
+    recordScans(touched);
+}
+/** Stream-parse a single Droid JSONL file (+ sibling settings) into session metadata. */
+async function readDroidMeta(filePath, currentVersion) {
+    const scan = await scanDroidSession(filePath);
+    // The filename is the canonical session id; fall back to the session_start id.
+    const sessionId = path.basename(filePath).replace(/\.jsonl$/, '') || scan.sessionId || '';
+    if (!sessionId)
+        return null;
+    // Token usage and cost live only in the sibling `<uuid>.settings.json`.
+    const settings = readDroidSettings(filePath.replace(/\.jsonl$/, '.settings.json'));
+    const model = settings.model || scan.model;
+    const tokenCount = settings.tokenCount;
+    const costUsd = model && settings.usage
+        ? costOfUsage({
+            model,
+            inputTokens: settings.usage.inputTokens,
+            outputTokens: settings.usage.outputTokens,
+            cacheReadTokens: settings.usage.cacheReadTokens,
+            cacheCreationTokens: settings.usage.cacheCreationTokens,
+        })
+        : 0;
+    const stat = safeStatSync(filePath);
+    const cwd = normalizeCwd(scan.cwd || '');
+    const meta = {
+        id: sessionId,
+        shortId: sessionId.slice(0, 8),
+        agent: 'droid',
+        timestamp: scan.timestamp || (stat ? stat.mtime.toISOString() : new Date().toISOString()),
+        project: cwd ? path.basename(cwd) : undefined,
+        cwd,
+        filePath,
+        version: resolveSessionVersion('droid', filePath, undefined, currentVersion),
+        topic: scan.topic,
+        messageCount: scan.messageCount,
+        tokenCount,
+        costUsd: costUsd > 0 ? costUsd : undefined,
+        durationMs: scan.durationMs,
+    };
+    return { meta, content: scan.contentText || '' };
+}
+/** Read model + token usage from a Droid `<uuid>.settings.json` sidecar. */
+function readDroidSettings(settingsPath) {
+    try {
+        const data = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+        const model = typeof data.model === 'string' ? data.model : undefined;
+        const u = data.tokenUsage;
+        if (!u || typeof u !== 'object')
+            return { model };
+        const usage = {
+            inputTokens: u.inputTokens,
+            outputTokens: u.outputTokens,
+            cacheReadTokens: u.cacheReadTokens,
+            cacheCreationTokens: u.cacheCreationTokens,
+        };
+        const tokenCount = sumKnownNumbers([
+            u.inputTokens,
+            u.outputTokens,
+            u.cacheCreationTokens,
+            u.cacheReadTokens,
+        ]) ?? undefined;
+        return { model, tokenCount, usage };
+    }
+    catch {
+        return {};
+    }
+}
+/** Stream a Droid JSONL file and extract scan-level metadata (id, cwd, topic, model, duration). */
+async function scanDroidSession(filePath) {
+    const stream = fs.createReadStream(filePath, { encoding: 'utf-8' });
+    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+    let sessionId;
+    let timestamp;
+    let cwd;
+    let title;
+    let sessionTitle;
+    let firstUserTopic;
+    let model;
+    let messageCount = 0;
+    let firstTsMs;
+    let lastTsMs;
+    const userTexts = [];
+    try {
+        for await (const line of rl) {
+            if (!line.trim())
+                continue;
+            let parsed;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (parsed.type === 'session_start') {
+                sessionId = typeof parsed.id === 'string' ? parsed.id : sessionId;
+                cwd = typeof parsed.cwd === 'string' ? parsed.cwd : cwd;
+                // Droid auto-generates `sessionTitle`; `title` is the raw first prompt.
+                if (typeof parsed.sessionTitle === 'string' && parsed.sessionTitle.trim()) {
+                    sessionTitle = parsed.sessionTitle.trim();
+                }
+                if (typeof parsed.title === 'string' && parsed.title.trim()) {
+                    title = parsed.title.trim();
+                }
+                continue;
+            }
+            if (parsed.type !== 'message')
+                continue;
+            // Track duration across every timestamped message.
+            if (typeof parsed.timestamp === 'string') {
+                const ms = new Date(parsed.timestamp).getTime();
+                if (!Number.isNaN(ms)) {
+                    if (firstTsMs === undefined || ms < firstTsMs)
+                        firstTsMs = ms;
+                    if (lastTsMs === undefined || ms > lastTsMs)
+                        lastTsMs = ms;
+                }
+            }
+            if (!timestamp && typeof parsed.timestamp === 'string')
+                timestamp = parsed.timestamp;
+            const msg = parsed.message || {};
+            if (typeof msg.modelId === 'string')
+                model = msg.modelId;
+            const text = extractDroidMessageText(msg.content);
+            if (!text)
+                continue;
+            messageCount++;
+            if (msg.role === 'user') {
+                userTexts.push(text);
+                if (!firstUserTopic)
+                    firstUserTopic = extractSessionTopic(text);
+            }
+        }
+    }
+    finally {
+        rl.close();
+        stream.destroy();
+    }
+    const durationMs = firstTsMs !== undefined && lastTsMs !== undefined && lastTsMs > firstTsMs
+        ? lastTsMs - firstTsMs
+        : undefined;
+    return {
+        sessionId,
+        timestamp,
+        cwd,
+        // Prefer Droid's auto-title, then the raw first-prompt title, then the
+        // derived first-user-message topic.
+        topic: sessionTitle || title || firstUserTopic,
+        model,
+        messageCount,
+        durationMs,
+        contentText: userTexts.length > 0 ? userTexts.join('\n') : undefined,
+    };
+}
+/** Extract plain text from a Droid message content field (Anthropic-shaped blocks). */
+function extractDroidMessageText(content) {
+    if (typeof content === 'string')
+        return content.trim();
+    if (!Array.isArray(content))
+        return '';
+    return content
+        .map((part) => (typeof part?.text === 'string' && part.type === 'text' ? part.text : ''))
+        // Droid front-loads injected context (date, skills list) as <system-reminder>
+        // text blocks on the first user turn — drop them so topic/content stay clean.
+        .filter((text) => text.trim() && !text.trim().startsWith('<system-reminder>'))
+        .join('\n')
+        .trim();
+}
 /** Stream a Claude JSONL file and extract scan-level metadata (timestamp, cwd, topic, tokens). */
 export async function scanClaudeSession(filePath) {
     const stream = fs.createReadStream(filePath, { encoding: 'utf-8' });

package/dist/lib/session/parse.d.ts

@@ -51,3 +51,10 @@ export declare function parseRush(filePath: string): SessionEvent[];
 export declare function parseHermes(filePath: string): SessionEvent[];
 /** Parse a Kimi session state.json file by reading its agents/main/wire.jsonl. */
 export declare function parseKimi(filePath: string): SessionEvent[];
+/**
+ * Parse a Droid (Factory) JSONL session file into normalized events. Droid
+ * wraps each turn in a `{type:'message', message:{role, content, modelId}}`
+ * envelope; the content blocks are Anthropic-shaped (text/thinking/tool_use/
+ * tool_result), so block handling mirrors the Claude parser.
+ */
+export declare function parseDroid(filePath: string): SessionEvent[];

package/dist/lib/session/parse.js

@@ -109,6 +109,9 @@ export function parseSession(filePath, agent) {
         case 'kimi':
             events = parseKimi(filePath);
             break;
+        case 'droid':
+            events = parseDroid(filePath);
+            break;
     }
     // Chokepoint: every string field that originated in an untrusted session
     // file gets stripped of terminal escapes here, so renderers downstream can
@@ -133,6 +136,8 @@ export function detectAgent(filePath) {
         return 'hermes';
     if (filePath.includes('/.kimi-code/') || filePath.includes('\\.kimi-code\\'))
         return 'kimi';
+    if (filePath.includes('/.factory/') || filePath.includes('\\.factory\\'))
+        return 'droid';
     // Cloud convention: cloud-sessions/<id>/session.<format>.jsonl
     const cloudMatch = filePath.match(/session\.(claude|codex|rush)\.jsonl(?:$|[?#])/);
     if (cloudMatch)
@@ -1124,3 +1129,108 @@ export function parseKimi(filePath) {
     }
     return events;
 }
+// ---------------------------------------------------------------------------
+// Droid (Factory) parser
+// ---------------------------------------------------------------------------
+/**
+ * Parse a Droid (Factory) JSONL session file into normalized events. Droid
+ * wraps each turn in a `{type:'message', message:{role, content, modelId}}`
+ * envelope; the content blocks are Anthropic-shaped (text/thinking/tool_use/
+ * tool_result), so block handling mirrors the Claude parser.
+ */
+export function parseDroid(filePath) {
+    const content = safeReadSessionFile(filePath);
+    const lines = content.split('\n').filter(l => l.trim());
+    const events = [];
+    // Map tool_use id -> {tool, args} for correlating with tool_result.
+    const toolUseMap = new Map();
+    for (const line of lines) {
+        let raw;
+        try {
+            raw = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (raw.type !== 'message')
+            continue;
+        const message = raw.message || {};
+        const role = message.role === 'user' ? 'user' : 'assistant';
+        const timestamp = raw.timestamp || new Date().toISOString();
+        const blocks = message.content;
+        // Plain-string content (rare) renders as a single message.
+        if (typeof blocks === 'string') {
+            const text = blocks.trim();
+            if (text)
+                events.push({ type: 'message', agent: 'droid', timestamp, role, content: text });
+            continue;
+        }
+        if (!Array.isArray(blocks))
+            continue;
+        for (const block of blocks) {
+            if (block.type === 'text') {
+                const text = (block.text || '').trim();
+                // Skip injected context blocks (date, skills list) on the first user turn.
+                if (text && !(role === 'user' && text.startsWith('<system-reminder>'))) {
+                    events.push({ type: 'message', agent: 'droid', timestamp, role, content: text });
+                }
+            }
+            else if (block.type === 'thinking') {
+                const thinkingText = (block.thinking || '').trim();
+                if (thinkingText)
+                    events.push({ type: 'thinking', agent: 'droid', timestamp, content: thinkingText });
+            }
+            else if (block.type === 'tool_use') {
+                const toolName = block.name || 'unknown';
+                const toolInput = block.input || {};
+                if (block.id)
+                    toolUseMap.set(block.id, { tool: toolName, args: toolInput });
+                events.push({
+                    type: 'tool_use',
+                    agent: 'droid',
+                    timestamp,
+                    tool: toolName,
+                    args: toolInput,
+                    path: toolInput.file_path || toolInput.path || undefined,
+                    command: toolName === 'Bash' ? toolInput.command : undefined,
+                });
+            }
+            else if (block.type === 'tool_result') {
+                const toolId = block.tool_use_id;
+                const toolInfo = toolId ? toolUseMap.get(toolId) : undefined;
+                const isError = block.is_error === true;
+                let output = '';
+                if (typeof block.content === 'string') {
+                    output = block.content;
+                }
+                else if (Array.isArray(block.content)) {
+                    output = block.content
+                        .filter((c) => c.type === 'text')
+                        .map((c) => c.text || '')
+                        .join('\n');
+                }
+                if (isError) {
+                    events.push({ type: 'error', agent: 'droid', timestamp, tool: toolInfo?.tool, content: output || 'Tool execution failed' });
+                }
+                else {
+                    events.push({
+                        type: 'tool_result',
+                        agent: 'droid',
+                        timestamp,
+                        tool: toolInfo?.tool,
+                        success: true,
+                        output: output.length > 500 ? output.slice(0, 497) + '...' : output,
+                    });
+                }
+                if (toolId)
+                    toolUseMap.delete(toolId);
+            }
+            else if (block.type === 'image') {
+                const source = block.source || {};
+                const sizeBytes = source.type === 'base64' ? Math.ceil((source.data?.length || 0) * 0.75) : 0;
+                events.push({ type: 'attachment', agent: 'droid', timestamp, mediaType: source.media_type || 'image/png', sizeBytes });
+            }
+        }
+    }
+    return events;
+}

package/dist/lib/session/types.d.ts

@@ -7,7 +7,7 @@
  * speaks these types.
  */
 /** Agents that store session data on disk and can be discovered by `agents sessions`. */
-export type SessionAgentId = 'claude' | 'codex' | 'gemini' | 'opencode' | 'openclaw' | 'rush' | 'hermes' | 'grok' | 'kimi';
+export type SessionAgentId = 'claude' | 'codex' | 'gemini' | 'opencode' | 'openclaw' | 'rush' | 'hermes' | 'grok' | 'kimi' | 'droid';
 /** All agents with session discovery support, in display order. */
 export declare const SESSION_AGENTS: SessionAgentId[];
 /** A single normalized event within a session (message, tool call, thinking, etc.). */

package/dist/lib/session/types.js

@@ -7,4 +7,4 @@
  * speaks these types.
  */
 /** All agents with session discovery support, in display order. */
-export const SESSION_AGENTS = ['claude', 'codex', 'gemini', 'opencode', 'openclaw', 'rush', 'hermes', 'grok', 'kimi'];
+export const SESSION_AGENTS = ['claude', 'codex', 'gemini', 'opencode', 'openclaw', 'rush', 'hermes', 'grok', 'kimi', 'droid'];

package/dist/lib/startup/command-registry.d.ts

@@ -68,6 +68,7 @@ export declare const loadTmux: ModuleLoader;
 export declare const loadBrowser: ModuleLoader;
 export declare const loadComputer: ModuleLoader;
 export declare const loadHosts: ModuleLoader;
+export declare const loadSsh: ModuleLoader;
 export declare const loadPull: ModuleLoader;
 export declare const loadPush: ModuleLoader;
 export declare const loadRepo: ModuleLoader;

package/dist/lib/startup/command-registry.js

@@ -46,6 +46,7 @@ export const loadTmux = async () => (await import('../../commands/tmux.js')).reg
 export const loadBrowser = async () => (await import('../../commands/browser.js')).registerBrowserCommand;
 export const loadComputer = async () => (await import('../../commands/computer.js')).registerComputerCommand;
 export const loadHosts = async () => (await import('../../commands/hosts.js')).registerHostsCommand;
+export const loadSsh = async () => (await import('../../commands/ssh.js')).registerSshCommands;
 export const loadPull = async () => (await import('../../commands/pull.js')).registerPullCommand;
 export const loadPush = async () => (await import('../../commands/push.js')).registerPushCommand;
 export const loadRepo = async () => (await import('../../commands/repo.js')).registerRepoCommands;
@@ -128,6 +129,8 @@ export const COMMAND_LOADERS = {
     browser: [loadBrowser],
     computer: [loadComputer],
     hosts: [loadHosts],
+    ssh: [loadSsh],
+    devices: [loadSsh],
     pull: [loadPull],
     push: [loadPush],
     repo: [loadRepo],

package/dist/lib/state.d.ts

@@ -152,6 +152,8 @@ export declare function getTeamsDir(): string;
 export declare function getTeamsAgentsDir(): string;
 /** Path to the team registry — list of named teams with timestamps. Durable runtime, per-machine. */
 export declare function getTeamsRegistryPath(): string;
+/** Path to the device registry — SSH device profiles with platform/auth metadata. Durable runtime, per-machine (host list + addresses are NOT pulled by `agents repo push`). */
+export declare function getDevicesRegistryPath(): string;
 /** Path to cloud dispatch cache (~/.agents/.cache/cloud/). */
 export declare function getCloudDir(): string;
 /** Path to terminal session metadata (~/.agents/.cache/terminals/). */

package/dist/lib/state.js

@@ -334,6 +334,8 @@ export function getTeamsDir() { return TEAMS_DIR; }
 export function getTeamsAgentsDir() { return TEAMS_AGENTS_DIR; }
 /** Path to the team registry — list of named teams with timestamps. Durable runtime, per-machine. */
 export function getTeamsRegistryPath() { return path.join(HISTORY_DIR, 'teams', 'registry.json'); }
+/** Path to the device registry — SSH device profiles with platform/auth metadata. Durable runtime, per-machine (host list + addresses are NOT pulled by `agents repo push`). */
+export function getDevicesRegistryPath() { return path.join(HISTORY_DIR, 'devices', 'registry.json'); }
 /** Path to cloud dispatch cache (~/.agents/.cache/cloud/). */
 export function getCloudDir() { return CLOUD_DIR; }
 /** Path to terminal session metadata (~/.agents/.cache/terminals/). */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phnx-labs/agents-cli",
-  "version": "1.20.28",
+  "version": "1.20.29",
   "description": "One CLI for all your AI coding agents - versions, config, cloud dispatch, sessions, and teams (now with first-class Grok Build CLI support)",
   "type": "module",
   "main": "dist/index.js",