@phnx-labs/agents-cli 1.14.7 → 1.16.0

package/dist/lib/browser/profiles.js

@@ -1,61 +1,101 @@
-import * as fs from 'fs';
 import * as path from 'path';
-import * as os from 'os';
-import * as yaml from 'yaml';
-import { getUserAgentsDir } from '../state.js';
-export function getBrowserProfilesDir() {
-    return path.join(getUserAgentsDir(), 'browser', 'profiles');
-}
+import { getBrowserRuntimeDir as getBrowserRuntimeDirRoot, readMeta, writeMeta, } from '../state.js';
 export function getBrowserRuntimeDir() {
-    const agentsDir = path.join(os.homedir(), '.agents');
-    return path.join(agentsDir, 'browser');
-}
-export function getProfilePath(name) {
-    return path.join(getBrowserProfilesDir(), `${name}.yaml`);
+    return getBrowserRuntimeDirRoot();
 }
 export function getProfileRuntimeDir(name) {
     return path.join(getBrowserRuntimeDir(), name);
 }
+function configToProfile(name, config) {
+    return {
+        name,
+        description: config.description,
+        browser: config.browser,
+        binary: config.binary,
+        electron: config.electron,
+        endpoints: config.endpoints,
+        chrome: config.chrome,
+        secrets: config.secrets,
+        viewport: config.viewport,
+    };
+}
+function profileToConfig(profile) {
+    const config = {
+        browser: profile.browser,
+        endpoints: profile.endpoints,
+    };
+    if (profile.description)
+        config.description = profile.description;
+    if (profile.binary)
+        config.binary = profile.binary;
+    if (profile.electron)
+        config.electron = profile.electron;
+    if (profile.chrome)
+        config.chrome = profile.chrome;
+    if (profile.secrets)
+        config.secrets = profile.secrets;
+    if (profile.viewport)
+        config.viewport = profile.viewport;
+    return config;
+}
 export async function listProfiles() {
-    const dir = getBrowserProfilesDir();
-    if (!fs.existsSync(dir))
+    const meta = readMeta();
+    if (!meta.browser)
         return [];
-    const files = fs.readdirSync(dir).filter((f) => f.endsWith('.yaml'));
-    const profiles = [];
-    for (const file of files) {
-        const content = fs.readFileSync(path.join(dir, file), 'utf-8');
-        const profile = yaml.parse(content);
-        profiles.push(profile);
-    }
-    return profiles;
+    return Object.entries(meta.browser).map(([name, config]) => configToProfile(name, config));
 }
 export async function getProfile(name) {
-    const filePath = getProfilePath(name);
-    if (!fs.existsSync(filePath))
+    const meta = readMeta();
+    const config = meta.browser?.[name];
+    if (!config)
         return null;
-    const content = fs.readFileSync(filePath, 'utf-8');
-    return yaml.parse(content);
+    return configToProfile(name, config);
 }
 export async function createProfile(profile) {
-    const dir = getBrowserProfilesDir();
-    fs.mkdirSync(dir, { recursive: true });
-    const filePath = getProfilePath(profile.name);
-    if (fs.existsSync(filePath)) {
+    const meta = readMeta();
+    if (meta.browser?.[profile.name]) {
         throw new Error(`Profile "${profile.name}" already exists`);
     }
-    fs.writeFileSync(filePath, yaml.stringify(profile), 'utf-8');
+    meta.browser = meta.browser ?? {};
+    meta.browser[profile.name] = profileToConfig(profile);
+    writeMeta(meta);
 }
 export async function updateProfile(profile) {
-    const filePath = getProfilePath(profile.name);
-    if (!fs.existsSync(filePath)) {
+    const meta = readMeta();
+    if (!meta.browser?.[profile.name]) {
         throw new Error(`Profile "${profile.name}" does not exist`);
     }
-    fs.writeFileSync(filePath, yaml.stringify(profile), 'utf-8');
+    meta.browser[profile.name] = profileToConfig(profile);
+    writeMeta(meta);
 }
 export async function deleteProfile(name) {
-    const filePath = getProfilePath(name);
-    if (!fs.existsSync(filePath)) {
+    const meta = readMeta();
+    if (!meta.browser?.[name]) {
         throw new Error(`Profile "${name}" does not exist`);
     }
-    fs.unlinkSync(filePath);
+    delete meta.browser[name];
+    writeMeta(meta);
+}
+/**
+ * Extract the port intended by the profile's first 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)
+        return undefined;
+    let url;
+    try {
+        url = new URL(endpoint);
+    }
+    catch {
+        return undefined;
+    }
+    if (url.port)
+        return parseInt(url.port, 10);
+    if (url.protocol === 'cdp:')
+        return 9222;
+    if (url.protocol === 'ssh:')
+        return 9222;
+    return undefined;
 }

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

@@ -1,12 +1,27 @@
-import { type TabInfo, type ProfileStatus } from './types.js';
+import { type TabInfo, type ProfileStatus, type HistoricalTask } from './types.js';
 import { type RefOpts, type RefNode } from './refs.js';
 export declare class BrowserService {
     private connections;
-    start(profileName: string, taskId?: string): Promise<{
+    private forkingProfiles;
+    private consoleLogs;
+    private pageErrors;
+    private networkRequests;
+    private pendingDownloads;
+    private enabledSessions;
+    start(profileName: string, opts?: {
+        taskName?: string;
+        url?: string;
+    }): Promise<{
         task: string;
-        windowTargetId?: string;
+        name: string;
+        tabId?: string;
+        windowId?: string;
     }>;
-    stop(taskId: string): Promise<{
+    stop(taskName: string): Promise<{
+        ok: boolean;
+        profile?: string;
+    }>;
+    done(taskName: string): Promise<{
         ok: boolean;
         profile?: string;
     }>;
@@ -14,26 +29,80 @@ export declare class BrowserService {
     navigate(taskId: string, url: string, profileName?: string): Promise<{
         tabId: string;
         url: string;
+        created: boolean;
     }>;
+    tabAdd(taskId: string, url: string, profileName?: string): Promise<{
+        tabId: string;
+        url: string;
+    }>;
+    tabFocus(taskId: string, tabHint: string): Promise<{
+        tabId: string;
+    }>;
+    tabList(taskId: string): Promise<Array<{
+        id: string;
+        url: string;
+        title: string;
+        current: boolean;
+    }>>;
+    private resolveTabHint;
+    private resolveCurrentTab;
+    private getCdpTargetId;
     tabs(taskId?: string, profileName?: string): Promise<TabInfo[]>;
-    close(taskId: string, tabId?: string): Promise<void>;
-    evaluate(taskId: string, tabId: string, expression: string): Promise<unknown>;
-    screenshot(taskId: string, tabId?: string, outputPath?: string): Promise<string>;
+    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>;
     private refsCache;
-    refs(taskId: string, tabId?: string, opts?: RefOpts): Promise<{
+    refs(taskId: string, tabHint?: string, opts?: RefOpts): Promise<{
         refs: string;
         nodeMap: Map<number, RefNode>;
     }>;
-    click(taskId: string, tabId: string, ref: number): Promise<void>;
-    type(taskId: string, tabId: string, ref: number, text: string): Promise<void>;
-    press(taskId: string, tabId: string, key: string): Promise<void>;
-    hover(taskId: string, tabId: string, ref: number): Promise<void>;
+    click(taskId: string, ref: number, tabHint?: string): Promise<void>;
+    type(taskId: string, ref: number, text: string, tabHint?: string): Promise<void>;
+    press(taskId: string, key: string, tabHint?: string): Promise<void>;
+    hover(taskId: string, ref: number, tabHint?: string): Promise<void>;
     status(profileName?: string): Promise<ProfileStatus[]>;
+    private reconcileFromDisk;
+    setViewport(taskId: string, width: number, height: number, options?: {
+        mobile?: boolean;
+        deviceScaleFactor?: number;
+        tabHint?: string;
+    }): Promise<void>;
+    setDevice(taskId: string, deviceName: string, tabHint?: string): Promise<void>;
+    private enableRuntimeForSession;
+    getConsoleLogs(taskId: string, options?: {
+        level?: string;
+        clear?: boolean;
+        tabHint?: string;
+    }): Promise<import('./types.js').ConsoleEntry[]>;
+    getErrors(taskId: string, options?: {
+        clear?: boolean;
+        tabHint?: string;
+    }): Promise<import('./types.js').ErrorEntry[]>;
+    private enableNetworkForSession;
+    getNetworkRequests(taskId: string, options?: {
+        filter?: string;
+        clear?: boolean;
+        tabHint?: string;
+    }): Promise<import('./types.js').NetworkRequest[]>;
+    getResponseBody(taskId: string, urlPattern: string, options?: {
+        timeout?: number;
+        maxChars?: number;
+        tabHint?: string;
+    }): Promise<string>;
+    wait(taskId: string, type: 'time' | 'selector' | 'url' | 'function' | 'load', value: string | number, options?: {
+        timeout?: number;
+        tabHint?: string;
+    }): Promise<void>;
+    setDownloadPath(taskId: string, downloadPath: string, tabHint?: string): Promise<void>;
+    waitForDownload(taskId: string, timeout?: number): Promise<string>;
+    private findTaskBySession;
     shutdown(): Promise<void>;
+    private findAvailableFork;
+    private forkElectronProfile;
     private connectProfile;
     private connectEndpoint;
     private enableDomains;
-    private createTaskWindow;
+    private getOrCreateWindow;
     private findTask;
     private getTabsForTask;
     private getProfileStatus;
@@ -42,4 +111,6 @@ export declare class BrowserService {
     private invalidateTargetCache;
     private saveTaskState;
     private loadTaskState;
+    private saveToHistory;
+    getHistory(limit?: number): Promise<HistoricalTask[]>;
 }