@phnx-labs/agents-cli 1.18.2 → 1.18.4

package/dist/commands/plugins.js

@@ -149,7 +149,19 @@ Examples:
         if (plugin.skills.length > 0) {
             console.log(chalk.bold('\n  Skills'));
             for (const skill of plugin.skills) {
-                console.log(`    ${chalk.cyan(`${plugin.name}:${skill}`)}`);
+                console.log(`    ${chalk.cyan(`/${plugin.name}:${skill}`)}`);
+            }
+        }
+        if (plugin.commands.length > 0) {
+            console.log(chalk.bold('\n  Commands'));
+            for (const cmd of plugin.commands) {
+                console.log(`    ${chalk.cyan(`/${plugin.name}:${cmd}`)}`);
+            }
+        }
+        if (plugin.agentDefs.length > 0) {
+            console.log(chalk.bold('\n  Subagents'));
+            for (const a of plugin.agentDefs) {
+                console.log(`    ${chalk.magenta(a)}`);
             }
         }
         if (plugin.hooks.length > 0) {
@@ -158,12 +170,40 @@ Examples:
                 console.log(`    ${chalk.yellow(hook)}`);
             }
         }
+        if (plugin.mcpServers.length > 0) {
+            console.log(chalk.bold('\n  MCP Servers'));
+            for (const s of plugin.mcpServers) {
+                console.log(`    ${chalk.green(s)}`);
+            }
+        }
+        if (plugin.lspServers.length > 0) {
+            console.log(chalk.bold('\n  LSP Servers'));
+            for (const s of plugin.lspServers) {
+                console.log(`    ${chalk.green(s)}`);
+            }
+        }
+        if (plugin.monitors.length > 0) {
+            console.log(chalk.bold('\n  Monitors'));
+            for (const m of plugin.monitors) {
+                console.log(`    ${chalk.blue(m)}`);
+            }
+        }
+        if (plugin.bin.length > 0) {
+            console.log(chalk.bold('\n  Bin'));
+            for (const b of plugin.bin) {
+                console.log(`    ${chalk.white(b)}`);
+            }
+        }
         if (plugin.scripts.length > 0) {
             console.log(chalk.bold('\n  Scripts'));
             for (const script of plugin.scripts) {
                 console.log(`    ${chalk.gray(script)}`);
             }
         }
+        if (plugin.hasSettings) {
+            console.log(chalk.bold('\n  Settings'));
+            console.log(`    ${chalk.gray('settings.json')}`);
+        }
         // Show installation status per agent version
         console.log(chalk.bold('\n  Installation Status'));
         let anyInstalled = false;
@@ -572,20 +612,24 @@ function formatPluginDetail(plugin, targets) {
         lines.push('  ' + chalk.gray('Supports: ') + supported.join(chalk.gray(' · ')));
     }
     lines.push('  ' + chalk.gray(formatPath(plugin.root)));
-    if (plugin.skills.length > 0) {
-        lines.push('');
-        lines.push(chalk.bold('  Skills'));
-        lines.push('  ' + plugin.skills.map((s) => chalk.cyan(s)).join(chalk.gray(', ')));
-    }
-    if (plugin.hooks.length > 0) {
-        lines.push('');
-        lines.push(chalk.bold('  Hooks'));
-        lines.push('  ' + plugin.hooks.map((h) => chalk.yellow(h)).join(chalk.gray(', ')));
-    }
-    if (plugin.scripts.length > 0) {
+    const section = (label, items, colorFn) => {
+        if (items.length === 0)
+            return;
         lines.push('');
-        lines.push(chalk.bold('  Scripts'));
-        lines.push('  ' + plugin.scripts.map((s) => chalk.white(s)).join(chalk.gray(', ')));
+        lines.push(chalk.bold(`  ${label}`));
+        lines.push('  ' + items.map(colorFn).join(chalk.gray(', ')));
+    };
+    section('Skills', plugin.skills.map((s) => `/${plugin.name}:${s}`), chalk.cyan);
+    section('Commands', plugin.commands.map((c) => `/${plugin.name}:${c}`), chalk.cyan);
+    section('Subagents', plugin.agentDefs, chalk.magenta);
+    section('Hooks', plugin.hooks, chalk.yellow);
+    section('MCP Servers', plugin.mcpServers, chalk.green);
+    section('LSP Servers', plugin.lspServers, chalk.green);
+    section('Monitors', plugin.monitors, chalk.blue);
+    section('Bin', plugin.bin, chalk.white);
+    section('Scripts', plugin.scripts, chalk.white);
+    if (plugin.hasSettings) {
+        section('Settings', ['settings.json'], chalk.gray);
     }
     if (targets.length > 0) {
         lines.push('');

package/dist/commands/view.js

@@ -604,19 +604,28 @@ async function showAgentResources(agentId, requestedVersion) {
             const versionStr = agentData.version ? ` (${agentData.version})` : '';
             const agentHeader = home ? termLink(agentData.agentName, home) : agentData.agentName;
             console.log(`  ${chalk.bold(agentHeader)}${chalk.gray(versionStr)}:`);
+            const pluralize = (n, singular) => `${n} ${singular}${n === 1 ? '' : 's'}`;
             for (const p of plugins) {
                 const linkedName = termLink(p.name, linkTarget(p.root));
                 const parts = [];
                 if (p.skills.length > 0)
-                    parts.push(`${p.skills.length} skill${p.skills.length === 1 ? '' : 's'}`);
+                    parts.push(pluralize(p.skills.length, 'skill'));
                 if (p.commands.length > 0)
-                    parts.push(`${p.commands.length} command${p.commands.length === 1 ? '' : 's'}`);
-                if (p.hooks.length > 0)
-                    parts.push(`${p.hooks.length} hook${p.hooks.length === 1 ? '' : 's'}`);
+                    parts.push(pluralize(p.commands.length, 'command'));
                 if (p.agentDefs.length > 0)
-                    parts.push(`${p.agentDefs.length} subagent${p.agentDefs.length === 1 ? '' : 's'}`);
-                if (p.hasMcp)
-                    parts.push('mcp');
+                    parts.push(pluralize(p.agentDefs.length, 'subagent'));
+                if (p.hooks.length > 0)
+                    parts.push(pluralize(p.hooks.length, 'hook'));
+                if (p.mcpServers.length > 0)
+                    parts.push(`${p.mcpServers.length} MCP`);
+                if (p.lspServers.length > 0)
+                    parts.push(`${p.lspServers.length} LSP`);
+                if (p.monitors.length > 0)
+                    parts.push(pluralize(p.monitors.length, 'monitor'));
+                if (p.bin.length > 0)
+                    parts.push(pluralize(p.bin.length, 'bin'));
+                if (p.hasSettings)
+                    parts.push('settings');
                 const contents = parts.length > 0 ? chalk.gray(` (${parts.join(', ')})`) : '';
                 console.log(`    ${chalk.cyan(linkedName)}${contents} ${chalk.cyan('[user]')}`);
             }

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;