@phnx-labs/agents-cli 1.14.7 → 1.15.0

package/dist/lib/browser/drivers/ssh.js

@@ -9,7 +9,7 @@ export async function connectSSH(endpoint, profile) {
     }
     const user = url.username || process.env.USER || 'root';
     const host = url.hostname;
-    const remotePort = parseInt(url.searchParams.get('port') || '9222', 10);
+    const remotePort = url.port ? parseInt(url.port, 10) : 9222;
     const localPort = allocatePort();
     try {
         await ensureRemoteBrowser(user, host, profile.browser, remotePort, profile.binary);
@@ -17,7 +17,7 @@ export async function connectSSH(endpoint, profile) {
     catch {
         // Browser may already be running, continue
     }
-    const tunnel = await startSSHTunnel(user, host, localPort, remotePort);
+    let tunnel = await startSSHTunnel(user, host, localPort, remotePort);
     try {
         await waitForPort(localPort, 8000);
     }
@@ -133,6 +133,27 @@ async function ensureRemoteBrowser(user, host, browserType, port, customBinary)
         }, 2000);
     });
 }
+export async function restartRemoteBrowser(user, host, browserType, port, customBinary) {
+    // Kill any process using the remote debugging port
+    const killCmd = `lsof -ti :${port} | xargs kill -9 2>/dev/null || true`;
+    await runSSHCommand(user, host, killCmd);
+    await sleep(500);
+    await ensureRemoteBrowser(user, host, browserType, port, customBinary);
+    await sleep(1500);
+}
+function runSSHCommand(user, host, cmd) {
+    return new Promise((resolve) => {
+        const child = spawn('ssh', [`${user}@${host}`, '-o', 'BatchMode=yes', cmd], {
+            stdio: 'ignore',
+        });
+        child.on('close', () => resolve());
+        child.on('error', () => resolve());
+        setTimeout(() => {
+            child.kill();
+            resolve();
+        }, 3000);
+    });
+}
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }

package/dist/lib/browser/ipc.js

@@ -195,6 +195,7 @@ export async function sendIPCRequest(request) {
         if (!fs.existsSync(socketPath)) {
             throw new Error('Failed to start browser daemon');
         }
+        await new Promise((r) => setTimeout(r, 300));
     }
     return new Promise((resolve, reject) => {
         const socket = net.createConnection(socketPath);

package/dist/lib/browser/service.d.ts

@@ -2,6 +2,7 @@ import { type TabInfo, type ProfileStatus } from './types.js';
 import { type RefOpts, type RefNode } from './refs.js';
 export declare class BrowserService {
     private connections;
+    private forkingProfiles;
     start(profileName: string, taskId?: string): Promise<{
         task: string;
         windowTargetId?: string;
@@ -30,6 +31,8 @@ export declare class BrowserService {
     hover(taskId: string, tabId: string, ref: number): Promise<void>;
     status(profileName?: string): Promise<ProfileStatus[]>;
     shutdown(): Promise<void>;
+    private findAvailableFork;
+    private forkElectronProfile;
     private connectProfile;
     private connectEndpoint;
     private enableDomains;

package/dist/lib/browser/service.js

@@ -2,7 +2,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { CDPClient, discoverBrowserWsUrl } from './cdp.js';
 import { getProfile, getProfileRuntimeDir, getBrowserRuntimeDir } from './profiles.js';
-import { killChrome, getRunningChromeInfo } from './chrome.js';
+import { killChrome, getRunningChromeInfo, launchBrowser, allocatePort } from './chrome.js';
 import { connectLocal } from './drivers/local.js';
 import { connectSSH } from './drivers/ssh.js';
 import { generateTaskId, isValidTaskId, } from './types.js';
@@ -11,6 +11,7 @@ import { clickAtCoords, hoverAtCoords, typeText, pressKey, focusNode } from './i
 import { emit } from '../events.js';
 export class BrowserService {
     connections = new Map();
+    forkingProfiles = new Set();
     async start(profileName, taskId) {
         const profile = await getProfile(profileName);
         if (!profile) {
@@ -21,7 +22,34 @@ export class BrowserService {
             throw new Error(`Invalid task ID "${finalTaskId}". Must be lowercase alphanumeric with hyphens.`);
         }
         let conn = this.connections.get(profileName);
-        if (!conn) {
+        let effectiveProfileName = profileName;
+        if (conn && conn.electron && conn.tasks.size > 0) {
+            if (this.forkingProfiles.has(profileName)) {
+                while (this.forkingProfiles.has(profileName)) {
+                    await new Promise((r) => setTimeout(r, 50));
+                }
+                const existingFork = this.findAvailableFork(profileName);
+                if (existingFork) {
+                    conn = existingFork.conn;
+                    effectiveProfileName = existingFork.name;
+                }
+                else {
+                    throw new Error(`Fork in progress but no available fork found for "${profileName}"`);
+                }
+            }
+            else {
+                this.forkingProfiles.add(profileName);
+                try {
+                    const { forkName, connection } = await this.forkElectronProfile(profile);
+                    conn = connection;
+                    effectiveProfileName = forkName;
+                }
+                finally {
+                    this.forkingProfiles.delete(profileName);
+                }
+            }
+        }
+        else if (!conn) {
             conn = await this.connectProfile(profile);
             this.connections.set(profileName, conn);
         }
@@ -32,15 +60,15 @@ export class BrowserService {
         const { windowTargetId } = await this.createTaskWindow(conn, finalTaskId);
         const task = {
             id: finalTaskId,
-            profile: profileName,
+            profile: effectiveProfileName,
             windowTargetId,
-            tabIds: [],
+            tabIds: conn.electron && windowTargetId ? [windowTargetId] : [],
             createdAt: Date.now(),
             pid: conn.pid,
         };
         conn.tasks.set(finalTaskId, task);
-        await this.saveTaskState(profileName, conn.tasks);
-        emit('browser.launch', { profile: profileName, task: finalTaskId, pid: conn.pid });
+        await this.saveTaskState(effectiveProfileName, conn.tasks);
+        emit('browser.launch', { profile: effectiveProfileName, task: finalTaskId, pid: conn.pid });
         return { task: finalTaskId, windowTargetId };
     }
     async stop(taskId) {
@@ -65,6 +93,11 @@ export class BrowserService {
                 conn.tasks.delete(taskId);
                 await this.saveTaskState(profileName, conn.tasks);
                 emit('browser.close', { profile: profileName, task: taskId });
+                if (conn.forkedFrom && conn.tasks.size === 0) {
+                    conn.cdp.close();
+                    killChrome(conn.pid);
+                    this.connections.delete(profileName);
+                }
                 return { ok: true, profile: profileName };
             }
         }
@@ -259,6 +292,37 @@ export class BrowserService {
         }
         this.connections.clear();
     }
+    findAvailableFork(profileName) {
+        for (const [name, conn] of this.connections) {
+            if (conn.forkedFrom === profileName && conn.tasks.size === 0) {
+                return { name, conn };
+            }
+        }
+        return null;
+    }
+    async forkElectronProfile(profile) {
+        let forkNum = 2;
+        while (this.connections.has(`${profile.name}.${forkNum}`)) {
+            forkNum++;
+        }
+        const forkName = `${profile.name}.${forkNum}`;
+        const port = allocatePort();
+        const { pid, wsUrl } = await launchBrowser(forkName, profile.browser, port, profile.chrome, profile.secrets, profile.binary);
+        const cdp = new CDPClient();
+        await cdp.connect(wsUrl);
+        await this.enableDomains(cdp);
+        const connection = {
+            cdp,
+            port,
+            pid,
+            electron: true,
+            forkedFrom: profile.name,
+            tasks: new Map(),
+            sessionCache: new Map(),
+        };
+        this.connections.set(forkName, connection);
+        return { forkName, connection };
+    }
     async connectProfile(profile) {
         const existingInfo = getRunningChromeInfo(profile.name);
         if (existingInfo) {
@@ -351,7 +415,20 @@ export class BrowserService {
         if (conn.electron) {
             const { targetInfos } = (await conn.cdp.send('Target.getTargets'));
             const pageTarget = targetInfos.find((t) => t.type === 'page');
-            return { windowTargetId: pageTarget?.targetId };
+            if (pageTarget) {
+                return { windowTargetId: pageTarget.targetId };
+            }
+            // No existing page - try to create one (works on some Electron apps)
+            try {
+                const result = (await conn.cdp.send('Target.createTarget', {
+                    url: 'about:blank',
+                    newWindow: true,
+                }));
+                return { windowTargetId: result.targetId };
+            }
+            catch {
+                throw new Error('No page targets found and unable to create new window');
+            }
         }
         const result = (await conn.cdp.send('Target.createTarget', {
             url: 'about:blank',

package/dist/lib/daemon.js

@@ -6,7 +6,7 @@
  * (macOS), systemd (Linux), or as a plain detached process. PID tracking,
  * log output, reload (SIGHUP), and graceful shutdown are handled here.
  */
-import { spawn, execSync } from 'child_process';
+import { spawn, execSync, execFileSync } from 'child_process';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
@@ -297,10 +297,10 @@ function startDaemonLocked() {
             }
             fs.writeFileSync(plistPath, generateLaunchdPlist(), 'utf-8');
             try {
-                execSync(`launchctl unload "${plistPath}" 2>/dev/null`, { encoding: 'utf-8' });
+                execFileSync('launchctl', ['unload', plistPath], { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] });
             }
             catch { /* not loaded, expected */ }
-            execSync(`launchctl load "${plistPath}"`, { encoding: 'utf-8' });
+            execFileSync('launchctl', ['load', plistPath], { encoding: 'utf-8' });
             const pid = waitForPid(3000);
             return { pid, method: 'launchd' };
         }
@@ -358,7 +358,7 @@ export function stopDaemon() {
         const plistPath = getLaunchdPlistPath();
         if (fs.existsSync(plistPath)) {
             try {
-                execSync(`launchctl unload "${plistPath}"`, { encoding: 'utf-8' });
+                execFileSync('launchctl', ['unload', plistPath], { encoding: 'utf-8' });
                 fs.unlinkSync(plistPath);
             }
             catch (err) {

package/dist/lib/events.d.ts

@@ -3,8 +3,15 @@
  *
  * Structured JSONL logs at ~/.agents/logs/events-YYYY-MM-DD.jsonl
  * with automatic daily rotation and rich metadata for debugging/auditing.
+ *
+ * Features:
+ * - Rich metadata: hostname, platform, arch, pid, timezone
+ * - Timing helpers: measure operation duration automatically
+ * - Truncation: long inputs/outputs are trimmed with ellipsis
+ * - Permissions: logs dir is 0700, files are 0600 (owner-only)
+ * - Performance tracking: withTiming() wrapper for any async function
  */
-export type EventType = 'agent.run.start' | 'agent.run.end' | 'version.install' | 'version.switch' | 'version.remove' | 'skill.install' | 'skill.remove' | 'browser.launch' | 'browser.close' | 'secrets.get' | 'secrets.set' | 'secrets.delete' | 'cloud.dispatch' | 'cloud.complete' | 'teams.create' | 'teams.start' | 'teams.complete' | 'hook.fire' | 'hook.error' | 'resource.sync' | 'error' | 'warn' | 'info';
+export type EventType = 'agent.run.start' | 'agent.run.end' | 'agent.spawn.start' | 'agent.spawn.end' | 'version.install' | 'version.switch' | 'version.remove' | 'skill.install' | 'skill.remove' | 'browser.launch' | 'browser.close' | 'browser.navigate' | 'browser.screenshot' | 'secrets.get' | 'secrets.set' | 'secrets.delete' | 'cloud.dispatch' | 'cloud.complete' | 'teams.create' | 'teams.add' | 'teams.start' | 'teams.complete' | 'hook.fire' | 'hook.complete' | 'hook.error' | 'resource.sync' | 'command.start' | 'command.end' | 'perf.timing' | 'session.start' | 'session.end' | 'error' | 'warn' | 'info' | 'debug';
 export interface EventMeta {
     ts: string;
     tz: string;
@@ -13,17 +20,33 @@ export interface EventMeta {
     platform: NodeJS.Platform;
     arch: string;
     pid: number;
+    ppid: number;
     event: EventType;
 }
 export interface EventPayload {
     agent?: string;
     version?: string;
+    sessionId?: string;
     cwd?: string;
+    command?: string;
+    args?: string[];
+    input?: string;
+    output?: string;
+    prompt?: string;
     durationMs?: number;
+    startupMs?: number;
+    exitCode?: number;
+    status?: string;
     error?: string;
+    errorStack?: string;
     [key: string]: unknown;
 }
 export type EventRecord = EventMeta & EventPayload;
+/**
+ * Truncate a string to maxLength, adding ellipsis if truncated.
+ * Returns undefined for null/undefined input.
+ */
+export declare function truncate(str: string | null | undefined, maxLength?: number): string | undefined;
 /**
  * Emit a structured event to the daily log file.
  *
@@ -41,6 +64,62 @@ export declare function emit(event: EventType, payload?: EventPayload): void;
  * done({ exitCode: 0 }); // emits agent.run.end with durationMs
  */
 export declare function emitStart(startEvent: EventType, payload?: EventPayload): (endPayload?: EventPayload) => void;
+/**
+ * Measure execution time of a synchronous function.
+ * Emits a perf.timing event with the duration.
+ *
+ * @example
+ * const result = time('parse-config', () => parseConfig(path));
+ */
+export declare function time<T>(label: string, fn: () => T, payload?: EventPayload): T;
+/**
+ * Measure execution time of an async function.
+ * Emits a perf.timing event with the duration.
+ *
+ * @example
+ * const result = await timeAsync('fetch-data', () => fetchData(url));
+ */
+export declare function timeAsync<T>(label: string, fn: () => Promise<T>, payload?: EventPayload): Promise<T>;
+/**
+ * Create a timing context for measuring multiple phases of an operation.
+ * Useful for tracking startup time vs execution time.
+ *
+ * @example
+ * const timer = createTimer('agent.run', { agent: 'claude' });
+ * // ... setup work ...
+ * timer.mark('startup'); // records startup time
+ * // ... main work ...
+ * timer.end({ exitCode: 0 }); // records total time and emits event
+ */
+export declare function createTimer(label: string, payload?: EventPayload): {
+    mark: (phase: string) => number;
+    end: (endPayload?: EventPayload) => void;
+    elapsed: () => number;
+};
+/**
+ * Higher-order function that wraps an async function with timing.
+ * The wrapper emits start/end events automatically.
+ *
+ * @example
+ * const timedFetch = withTiming('fetch', fetchData, { service: 'api' });
+ * const result = await timedFetch(url);
+ */
+export declare function withTiming<Args extends unknown[], R>(label: string, fn: (...args: Args) => Promise<R>, basePayload?: EventPayload): (...args: Args) => Promise<R>;
+/**
+ * Emit a command.start event with CLI args.
+ * Returns a done() function to emit command.end with duration.
+ *
+ * @example
+ * // At CLI entry point:
+ * const done = emitCommand('run', process.argv.slice(2));
+ * // ... execute command ...
+ * done({ exitCode: 0 });
+ */
+export declare function emitCommand(command: string, args?: string[], payload?: EventPayload): (endPayload?: EventPayload) => void;
+/**
+ * Emit an error event with full details.
+ */
+export declare function emitError(err: Error | string, payload?: EventPayload): void;
 /**
  * Remove log files older than the retention period.
  * Called lazily on emit or explicitly via CLI.
@@ -61,6 +140,20 @@ export declare function query(options: {
     endDate?: Date;
     eventTypes?: EventType[];
     agent?: string;
+    command?: string;
     limit?: number;
 }): EventRecord[];
+/**
+ * Get performance stats for a specific label.
+ */
+export declare function getTimingStats(label: string, options?: {
+    days?: number;
+}): {
+    count: number;
+    avgMs: number;
+    minMs: number;
+    maxMs: number;
+    p50Ms: number;
+    p95Ms: number;
+} | null;
 export declare const LOGS_PATH: string;