@phnx-labs/agents-cli 1.18.3 → 1.18.5

package/dist/lib/browser/runtime-state.js

@@ -0,0 +1,259 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+import { getProfileRuntimeDir, getBrowserRuntimeDir } from './profiles.js';
+const PID_FILE = 'pid';
+const PORT_FILE = 'port';
+const COMMAND_FILE = 'command';
+const META_FILE = 'meta.json';
+function readNumberFile(p) {
+    try {
+        const n = parseInt(fs.readFileSync(p, 'utf-8').trim(), 10);
+        return Number.isFinite(n) ? n : null;
+    }
+    catch {
+        return null;
+    }
+}
+function readStringFile(p) {
+    try {
+        return fs.readFileSync(p, 'utf-8').trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Save the runtime record atomically. We write the legacy one-value-per-
+ * file fields plus a JSON meta blob so future code can read either.
+ * The cache directory may not exist yet (first launch); we create it.
+ */
+export function writeProfileRuntime(profileName, runtime) {
+    const dir = getProfileRuntimeDir(profileName);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, PID_FILE), String(runtime.pid));
+    fs.writeFileSync(path.join(dir, PORT_FILE), String(runtime.port));
+    if (runtime.command) {
+        fs.writeFileSync(path.join(dir, COMMAND_FILE), runtime.command);
+    }
+    const meta = {
+        ...runtime,
+        daemonPid: runtime.daemonPid ?? process.pid,
+        spawnedAt: runtime.spawnedAt ?? Date.now(),
+    };
+    fs.writeFileSync(path.join(dir, META_FILE), JSON.stringify(meta));
+}
+/** Read just the JSON meta record. Returns null when absent or malformed. */
+export function readProfileRuntimeMeta(profileName) {
+    const dir = getProfileRuntimeDir(profileName);
+    try {
+        const raw = fs.readFileSync(path.join(dir, META_FILE), 'utf-8');
+        const obj = JSON.parse(raw);
+        if (typeof obj !== 'object' || obj === null)
+            return null;
+        return obj;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Read the runtime triple. Returns null when the files are missing OR when
+ * the recorded pid no longer points at the same process we launched —
+ * stale data is auto-cleaned to keep the next caller from acting on it.
+ */
+export function readProfileRuntime(profileName) {
+    const dir = getProfileRuntimeDir(profileName);
+    const pid = readNumberFile(path.join(dir, PID_FILE));
+    const port = readNumberFile(path.join(dir, PORT_FILE));
+    const command = readStringFile(path.join(dir, COMMAND_FILE)) ?? undefined;
+    if (pid === null || port === null)
+        return null;
+    if (!isProcessAlive(pid, command)) {
+        clearProfileRuntime(profileName);
+        return null;
+    }
+    return { pid, port, command };
+}
+/** Remove the pid/port/command/meta files. Leaves chrome-data + tasks.json intact. */
+export function clearProfileRuntime(profileName) {
+    const dir = getProfileRuntimeDir(profileName);
+    for (const f of [PID_FILE, PORT_FILE, COMMAND_FILE, META_FILE]) {
+        try {
+            fs.unlinkSync(path.join(dir, f));
+        }
+        catch { /* not present */ }
+    }
+}
+/**
+ * Recursively remove the whole profile cache (chrome-data, tasks.json,
+ * everything). Used by `profiles delete` so an old profile name doesn't
+ * leak its history into a freshly-recreated one.
+ */
+export function removeProfileCache(profileName) {
+    const dir = getProfileRuntimeDir(profileName);
+    try {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+    catch { /* gone */ }
+}
+/**
+ * Find every cache directory belonging to a given profile. The composite
+ * naming (`<name>@<endpoint>`) means a single agents-cli profile can have
+ * multiple runtime dirs side by side; this finds them all plus the legacy
+ * non-composite dir from older builds.
+ */
+export function listProfileCacheDirs(profileName) {
+    const root = getBrowserRuntimeDir();
+    if (!fs.existsSync(root))
+        return [];
+    const matches = [];
+    for (const entry of fs.readdirSync(root)) {
+        if (entry === profileName)
+            matches.push(path.join(root, entry));
+        else if (entry.startsWith(`${profileName}@`))
+            matches.push(path.join(root, entry));
+    }
+    return matches;
+}
+/**
+ * `process.kill(pid, 0)` answers "is a process with this id alive?" — but
+ * pid reuse is real on long-uptime machines, and a stale cache pointing
+ * at a since-reassigned pid would happily call the imposter ours.
+ *
+ * Strategy: if we recorded the executable basename when we launched, ask
+ * `ps` what command the live pid is running and compare. No command on
+ * record means we fall back to the existence check (older cache entries
+ * or `pid:0` for "attached to an externally-launched browser").
+ */
+export function isProcessAlive(pid, expectedCommand) {
+    if (pid === 0)
+        return true;
+    try {
+        process.kill(pid, 0);
+    }
+    catch (err) {
+        if (err && err.code === 'EPERM') {
+            // exists but we can't signal it — count it as alive
+            return !expectedCommand || matchesCommand(pid, expectedCommand);
+        }
+        return false;
+    }
+    if (!expectedCommand)
+        return true;
+    return matchesCommand(pid, expectedCommand);
+}
+/**
+ * Read every profile cache directory and produce a structured snapshot.
+ * Works without the daemon — `agents browser ps` uses this to render a
+ * complete state view even when the IPC server is down. The caller can
+ * post-process to detect conflicts (e.g. two profiles with the same port,
+ * or a port someone else is listening on).
+ */
+export function listAllProfileSnapshots() {
+    const root = getBrowserRuntimeDir();
+    if (!fs.existsSync(root))
+        return [];
+    const out = [];
+    for (const name of fs.readdirSync(root).sort()) {
+        const dir = path.join(root, name);
+        let stat;
+        try {
+            stat = fs.statSync(dir);
+        }
+        catch {
+            continue;
+        }
+        if (!stat.isDirectory())
+            continue;
+        const meta = readProfileRuntimeMeta(name);
+        const taskCount = readTaskCount(dir);
+        const pidAlive = meta ? isProcessAlive(meta.pid, meta.command) : false;
+        const tunnelAlive = meta?.tunnelPid ? isProcessAlive(meta.tunnelPid, 'ssh') : false;
+        const daemonAlive = meta?.daemonPid ? isProcessAlive(meta.daemonPid) : false;
+        out.push({ name, dir, meta, pidAlive, tunnelAlive, daemonAlive, taskCount });
+    }
+    return out;
+}
+function readTaskCount(dir) {
+    try {
+        const raw = fs.readFileSync(path.join(dir, 'tasks.json'), 'utf-8');
+        const obj = JSON.parse(raw);
+        if (Array.isArray(obj))
+            return obj.length;
+        if (obj && typeof obj === 'object')
+            return Object.keys(obj).length;
+        return 0;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * Reap browser + tunnel processes spawned by daemons that no longer exist.
+ * Call once on daemon startup. The idea: every process we spawn records
+ * its daemonPid in meta.json. If that daemon is dead (crashed, SIGKILL),
+ * its children were left rootless — kill them now so they don't hijack
+ * the next session's local ports.
+ *
+ * We're conservative: a record with no daemonPid (older builds) is left
+ * alone — we'd rather leak than wrongly kill a user-owned process that
+ * happens to share metadata.
+ */
+export function reapOrphanedProcesses() {
+    const root = getBrowserRuntimeDir();
+    if (!fs.existsSync(root))
+        return { reaped: 0, details: [] };
+    let reaped = 0;
+    const details = [];
+    for (const profileName of fs.readdirSync(root)) {
+        const meta = readProfileRuntimeMeta(profileName);
+        if (!meta)
+            continue;
+        if (!meta.daemonPid)
+            continue;
+        if (meta.daemonPid === process.pid)
+            continue;
+        // Owning daemon still alive — leave its kids alone.
+        if (isProcessAlive(meta.daemonPid))
+            continue;
+        // Kill what the dead daemon left behind. Best-effort.
+        const kill = (pid, label) => {
+            if (!pid || pid === 0)
+                return;
+            // Only kill if it matches the recorded command — guards against
+            // pid reuse handing us an unrelated process to murder.
+            if (meta.command && !matchesCommand(pid, meta.command) &&
+                !matchesCommand(pid, 'ssh'))
+                return;
+            try {
+                process.kill(pid, 'SIGTERM');
+                reaped++;
+                details.push(`reaped ${label ?? 'pid'} ${pid} (profile ${profileName})`);
+            }
+            catch { /* already gone */ }
+        };
+        kill(meta.pid, 'browser');
+        kill(meta.tunnelPid, 'tunnel');
+        clearProfileRuntime(profileName);
+    }
+    return { reaped, details };
+}
+function matchesCommand(pid, expectedCommand) {
+    try {
+        const out = execSync(`ps -p ${pid} -o comm=`, {
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim();
+        if (!out)
+            return false;
+        // Match on the basename only — `/Applications/Comet.app/Contents/MacOS/Comet`
+        // vs the recorded `Comet`, vs `Google\ Chrome`. Case-insensitive.
+        const live = path.basename(out).toLowerCase();
+        const want = path.basename(expectedCommand).toLowerCase();
+        return live === want || live.startsWith(want) || want.startsWith(live);
+    }
+    catch {
+        return false;
+    }
+}

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

@@ -34,7 +34,14 @@ export declare function pickWindowTarget<T extends {
     url?: string;
     title?: string;
 }>(targets: T[], filter: string | undefined): T | undefined;
+/**
+ * Parse a `--since`/`--until` value. Accepts ISO-8601 absolute timestamps
+ * or relative offsets like `30s`, `5m`, `2h`, `1d`.
+ */
+export declare function parseSinceUntil(s: string): Date;
+export declare function readNewestMatchingFile(dir: string, prefix: string, tailLines: number): string;
 export declare class BrowserService {
+    private static readonly SOURCE_PREFIX;
     private connections;
     private forkingProfiles;
     private consoleLogs;
@@ -45,20 +52,13 @@ export declare class BrowserService {
     start(profileName: string, opts?: {
         taskName?: string;
         url?: string;
+        endpointName?: string;
     }): Promise<{
         task: string;
         name: string;
         tabId?: string;
         windowId?: string;
-    }>;
-    /**
-     * Launch (or attach to) the profile's browser without creating a task. Used by
-     * `agents browser profiles launch <name>` so users can warm up the browser —
-     * including the first-run onboarding flow — before any automation starts.
-     */
-    launchProfile(profileName: string): Promise<{
-        port: number;
-        pid: number;
+        profile: string;
     }>;
     stop(taskName: string): Promise<{
         ok: boolean;
@@ -93,7 +93,34 @@ export declare class BrowserService {
     tabs(taskId?: string, profileName?: string): Promise<TabInfo[]>;
     tabClose(taskId: string, tabHint?: string): Promise<void>;
     evaluate(taskId: string, tabHint: string | undefined, expression: string): Promise<unknown>;
-    screenshot(taskId: string, tabHint?: string, outputPath?: string): Promise<string>;
+    screenshot(taskId: string, tabHint?: string, outputPath?: string, quality?: 'compressed' | 'raw'): Promise<{
+        path: string;
+        bytes: number;
+        width: number;
+        height: number;
+    }>;
+    private recordings;
+    recordStart(taskId: string, tabHint?: string, opts?: {
+        fps?: number;
+        duration?: number;
+        maxMb?: number;
+    }): Promise<{
+        path: string;
+        fps: number;
+        durationCapSec: number;
+        maxMb: number;
+    }>;
+    recordStop(taskId: string, reason?: 'manual' | 'duration-cap' | 'size-cap'): Promise<{
+        path: string;
+        bytes: number;
+        durationMs: number;
+        reason: string;
+    }>;
+    recordStatus(taskId: string): Promise<{
+        recording: boolean;
+        path?: string;
+        elapsedMs?: number;
+    }>;
     private refsCache;
     refs(taskId: string, tabHint?: string, opts?: RefOpts): Promise<{
         refs: string;
@@ -142,6 +169,15 @@ export declare class BrowserService {
         maxChars?: number;
         tabHint?: string;
     }): Promise<string>;
+    getAppLogs(taskId: string, opts: {
+        lines?: number;
+        level?: string;
+        filter?: string;
+        message?: string;
+        source?: string;
+        since?: string;
+        until?: string;
+    }): Promise<any[]>;
     wait(taskId: string, type: 'time' | 'selector' | 'url' | 'function' | 'load', value: string | number, options?: {
         timeout?: number;
         tabHint?: string;
@@ -152,10 +188,21 @@ export declare class BrowserService {
     shutdown(): Promise<void>;
     private findAvailableFork;
     private forkElectronProfile;
+    /**
+     * Connect to a profile at a specific endpoint preset. The caller has
+     * already resolved the endpoint and built the `effectiveProfile` with
+     * the per-endpoint binary/targetFilter overrides applied; we just use it.
+     *
+     * `effectiveProfile.name` is the composite identifier (`<profile>@<endpoint>`)
+     * so per-endpoint pid/port files don't collide when the same app runs
+     * locally and remotely at the same time.
+     */
     private connectProfile;
     private connectEndpoint;
     private enableDomains;
     private getOrCreateWindow;
+    private hasTaskNamed;
+    private generateUniqueTaskName;
     private findTask;
     private getTabsForTask;
     private getProfileStatus;