@phnx-labs/agents-cli 1.18.3 → 1.18.4

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

@@ -1,4 +1,15 @@
 import type { DeviceDescriptor } from './types.js';
+/**
+ * Default viewport for newly-created profiles. Matches Safari's logical
+ * resolution on a 14-inch MacBook Pro (M1/M2/M3 Pro/Max) — the most common
+ * shape this CLI sees in practice. Shared with the `MacBook Pro` device
+ * preset below so both surfaces agree.
+ */
+export declare const DEFAULT_VIEWPORT: {
+    readonly width: 1512;
+    readonly height: 982;
+    readonly deviceScaleFactor: 2;
+};
 export declare const DEVICES: Record<string, DeviceDescriptor>;
 export declare function getDevice(name: string): DeviceDescriptor | undefined;
 export declare function listDevices(): string[];

package/dist/lib/browser/devices.js

@@ -1,3 +1,14 @@
+/**
+ * Default viewport for newly-created profiles. Matches Safari's logical
+ * resolution on a 14-inch MacBook Pro (M1/M2/M3 Pro/Max) — the most common
+ * shape this CLI sees in practice. Shared with the `MacBook Pro` device
+ * preset below so both surfaces agree.
+ */
+export const DEFAULT_VIEWPORT = {
+    width: 1512,
+    height: 982,
+    deviceScaleFactor: 2,
+};
 export const DEVICES = {
     'iPhone 14': {
         width: 390,
@@ -12,9 +23,9 @@ export const DEVICES = {
         mobile: true,
     },
     'MacBook Pro': {
-        width: 1440,
-        height: 900,
-        deviceScaleFactor: 2,
+        width: DEFAULT_VIEWPORT.width,
+        height: DEFAULT_VIEWPORT.height,
+        deviceScaleFactor: DEFAULT_VIEWPORT.deviceScaleFactor,
         mobile: false,
     },
 };

package/dist/lib/browser/ipc.js

@@ -70,6 +70,7 @@ export class BrowserIPCServer {
                 const result = await this.service.start(request.profile, {
                     taskName: request.taskName,
                     url: request.url,
+                    endpointName: request.endpoint,
                 });
                 return {
                     ok: true,
@@ -78,13 +79,6 @@ export class BrowserIPCServer {
                     windowTargetId: result.windowId,
                 };
             }
-            case 'launch-profile': {
-                if (!request.profile) {
-                    return { ok: false, error: 'Profile required' };
-                }
-                const result = await this.service.launchProfile(request.profile);
-                return { ok: true, port: result.port, pid: result.pid };
-            }
             case 'done': {
                 if (!request.task) {
                     return { ok: false, error: 'Task required' };
@@ -153,12 +147,38 @@ export class BrowserIPCServer {
                 const result = await this.service.evaluate(request.task, request.tabId, request.expr);
                 return { ok: true, result };
             }
+            case 'record-start': {
+                if (!request.task)
+                    return { ok: false, error: 'Task required' };
+                try {
+                    const r = await this.service.recordStart(request.task, request.tabId, {
+                        fps: request.fps,
+                        duration: request.duration,
+                        maxMb: request.maxMb,
+                    });
+                    return { ok: true, path: r.path, fps: r.fps, durationCapSec: r.durationCapSec, maxMb: r.maxMb };
+                }
+                catch (err) {
+                    return { ok: false, error: err instanceof Error ? err.message : String(err) };
+                }
+            }
+            case 'record-stop': {
+                if (!request.task)
+                    return { ok: false, error: 'Task required' };
+                try {
+                    const r = await this.service.recordStop(request.task);
+                    return { ok: true, path: r.path, bytes: r.bytes, durationMs: r.durationMs, stopReason: r.reason };
+                }
+                catch (err) {
+                    return { ok: false, error: err instanceof Error ? err.message : String(err) };
+                }
+            }
             case 'screenshot': {
                 if (!request.task) {
                     return { ok: false, error: 'Task required' };
                 }
-                const resultPath = await this.service.screenshot(request.task, request.tabId, request.path);
-                return { ok: true, path: resultPath };
+                const shot = await this.service.screenshot(request.task, request.tabId, request.path, request.quality);
+                return { ok: true, path: shot.path, bytes: shot.bytes, width: shot.width, height: shot.height };
             }
             case 'refs': {
                 if (!request.task) {

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

@@ -13,7 +13,29 @@ export declare function createProfile(profile: BrowserProfile): Promise<void>;
 export declare function updateProfile(profile: BrowserProfile): Promise<void>;
 export declare function deleteProfile(name: string): Promise<void>;
 /**
- * Extract the port intended by the profile's first endpoint.
+ * Resolve a profile's endpoint presets into a normalized map regardless of
+ * whether the YAML uses the legacy `string[]` shape or the new map shape.
+ * The legacy entries get auto-named `endpoint-0`, `endpoint-1`, ... .
+ */
+export declare function getEndpointPresets(profile: BrowserProfile): Record<string, import('./types.js').EndpointPreset>;
+/**
+ * Pick the endpoint preset to use. Order:
+ *   1. Explicit name passed in (errors if unknown)
+ *   2. `profile.defaultEndpoint` if set
+ *   3. First entry (preserves legacy string[] behavior)
+ *
+ * Returns the resolved name + the preset (with per-endpoint overrides
+ * already applied to binary / targetFilter), so callers don't have to
+ * remember the precedence rules.
+ */
+export declare function resolveEndpoint(profile: BrowserProfile, endpointName?: string): {
+    name: string;
+    target: string;
+    binary?: string;
+    targetFilter?: string;
+};
+/**
+ * Extract the port intended by the profile's default endpoint.
  * Returns undefined for endpoint shapes that don't carry a port (e.g. ws:// without one).
  */
 export declare function extractConfiguredPort(profile: BrowserProfile): number | undefined;

package/dist/lib/browser/profiles.js

@@ -17,6 +17,7 @@ function configToProfile(name, config) {
         electron: config.electron,
         targetFilter: config.targetFilter,
         endpoints: config.endpoints,
+        defaultEndpoint: config.defaultEndpoint,
         chrome: config.chrome,
         secrets: config.secrets,
         viewport: config.viewport,
@@ -35,6 +36,8 @@ function profileToConfig(profile) {
         config.electron = profile.electron;
     if (profile.targetFilter)
         config.targetFilter = profile.targetFilter;
+    if (profile.defaultEndpoint)
+        config.defaultEndpoint = profile.defaultEndpoint;
     if (profile.chrome)
         config.chrome = profile.chrome;
     if (profile.secrets)
@@ -125,13 +128,70 @@ export async function deleteProfile(name) {
     writeMeta(meta);
 }
 /**
- * Extract the port intended by the profile's first endpoint.
+ * Resolve a profile's endpoint presets into a normalized map regardless of
+ * whether the YAML uses the legacy `string[]` shape or the new map shape.
+ * The legacy entries get auto-named `endpoint-0`, `endpoint-1`, ... .
+ */
+export function getEndpointPresets(profile) {
+    if (Array.isArray(profile.endpoints)) {
+        const out = {};
+        profile.endpoints.forEach((target, i) => {
+            out[`endpoint-${i}`] = { target };
+        });
+        return out;
+    }
+    return profile.endpoints;
+}
+/**
+ * Pick the endpoint preset to use. Order:
+ *   1. Explicit name passed in (errors if unknown)
+ *   2. `profile.defaultEndpoint` if set
+ *   3. First entry (preserves legacy string[] behavior)
+ *
+ * Returns the resolved name + the preset (with per-endpoint overrides
+ * already applied to binary / targetFilter), so callers don't have to
+ * remember the precedence rules.
+ */
+export function resolveEndpoint(profile, endpointName) {
+    const presets = getEndpointPresets(profile);
+    const names = Object.keys(presets);
+    if (names.length === 0) {
+        throw new Error(`Profile "${profile.name}" has no endpoints configured`);
+    }
+    let chosenName;
+    if (endpointName) {
+        if (!presets[endpointName]) {
+            throw new Error(`Endpoint "${endpointName}" not found on profile "${profile.name}". ` +
+                `Available: ${names.join(', ')}`);
+        }
+        chosenName = endpointName;
+    }
+    else if (profile.defaultEndpoint && presets[profile.defaultEndpoint]) {
+        chosenName = profile.defaultEndpoint;
+    }
+    else {
+        chosenName = names[0];
+    }
+    const preset = presets[chosenName];
+    return {
+        name: chosenName,
+        target: preset.target,
+        binary: preset.binary ?? profile.binary,
+        targetFilter: preset.targetFilter ?? profile.targetFilter,
+    };
+}
+/**
+ * Extract the port intended by the profile's default endpoint.
  * Returns undefined for endpoint shapes that don't carry a port (e.g. ws:// without one).
  */
 export function extractConfiguredPort(profile) {
-    const endpoint = profile.endpoints[0];
-    if (!endpoint)
+    const presets = getEndpointPresets(profile);
+    const firstName = profile.defaultEndpoint && presets[profile.defaultEndpoint]
+        ? profile.defaultEndpoint
+        : Object.keys(presets)[0];
+    if (!firstName)
         return undefined;
+    const endpoint = presets[firstName].target;
     let url;
     try {
         url = new URL(endpoint);

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

@@ -45,20 +45,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 +86,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;
@@ -152,10 +172,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;