@phnx-labs/agents-cli 1.22.117 → 1.22.119

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

@@ -1,89 +0,0 @@
-import type { CDPClient } from './cdp.js';
-export interface RefOpts {
-    interactive?: boolean;
-    limit?: number;
-    compact?: boolean;
-}
-export interface RefNode {
-    ref: number;
-    role: string;
-    name: string;
-    attrs: string[];
-    backendNodeId?: number;
-    /** Stable selector used by non-CDP DOM backends such as native Arc. */
-    selector?: string;
-    editor?: string;
-}
-/**
- * Stable, navigation-surviving identity for a ref. Unlike {@link RefNode}, this
- * carries no `backendNodeId` (which goes stale the moment the DOM re-renders) —
- * only the accessible descriptor a fresh `getRefs` can be re-matched against.
- * Cached in per-task state so a later `click <ref>` can self-heal when the
- * integer ref has drifted (see {@link healRef}).
- */
-export interface RefDescriptor {
-    ref: number;
-    role: string;
-    name: string;
-    attrs: string[];
-    /**
-     * Best-effort CSS selector captured via DOM. Reserved for future
-     * selector-based healing; matching today is role+name+attrs+position.
-     */
-    selector?: string;
-}
-/**
- * A cached ref listing for one tab: the stable descriptors plus the resolved
- * {@link RefOpts} the listing was built with. A later `click`/`type` MUST
- * rebuild its node map with these same opts, or the integer refs it looks up
- * are numbered against a *different* accessibility filter than the one the
- * user saw in `browser refs` — the drift that makes self-heal silently click
- * the wrong element on the second click.
- */
-export interface RefSnapshot {
-    descriptors: RefDescriptor[];
-    opts: {
-        interactive: boolean;
-        limit: number;
-    };
-}
-/** Snapshot the stable descriptor for every ref in a freshly-built node map. */
-export declare function describeRefs(nodeMap: Map<number, RefNode>): RefDescriptor[];
-/**
- * Re-resolve a stale ref against a freshly-built node map by matching the
- * cached descriptor. Pure — no CDP, no DOM.
- *
- * The integer ref assigned by {@link getRefs} is positional: it shifts whenever
- * the accessibility tree changes (navigation, re-render, or even a different
- * `interactive` filter). The descriptor's (role, name) pair is the coarse
- * identity, but a page can carry duplicate (role, name) elements — two "Submit"
- * buttons, one action button per repeated list row. Matching on (role, name)
- * alone would heal to whichever duplicate the fresh scan happens to hit first,
- * which can be the wrong one. So among (role, name) matches we tie-break, in
- * priority order:
- *
- *   1. **DOM-backed** — a candidate with a `backendNodeId` is resolvable to
- *      coordinates; one without is unclickable, so healing to it is useless.
- *   2. **Attribute similarity** — the cached `attrs` (disabled / checked /
- *      selected / …) disambiguate otherwise-identical twins (the *disabled*
- *      Submit vs the enabled one).
- *   3. **Positional proximity** — the fresh ref closest to the original cached
- *      ref index wins, so a repeated list-row action heals to its nearest
- *      positional twin rather than jumping across the page.
- *
- * Returns the new integer ref, or `null` when no node with the same role+name
- * exists in the fresh map (unhealable — the element is genuinely gone).
- */
-export declare function healRef(descriptor: Pick<RefDescriptor, 'ref' | 'role' | 'name' | 'attrs'>, freshNodeMap: Map<number, RefNode>): number | null;
-export declare function getRefs(cdp: CDPClient, sessionId: string, opts?: RefOpts): Promise<{
-    refs: string;
-    nodeMap: Map<number, RefNode>;
-    opts: {
-        interactive: boolean;
-        limit: number;
-    };
-}>;
-export declare function resolveRefToCoords(cdp: CDPClient, sessionId: string, nodeMap: Map<number, RefNode>, ref: number): Promise<{
-    x: number;
-    y: number;
-}>;

package/dist/lib/browser/refs.js

@@ -1,191 +0,0 @@
-import { truncate } from '../format.js';
-/** Snapshot the stable descriptor for every ref in a freshly-built node map. */
-export function describeRefs(nodeMap) {
-    return Array.from(nodeMap.values()).map((n) => ({
-        ref: n.ref,
-        role: n.role,
-        name: n.name,
-        attrs: n.attrs.slice(),
-        selector: n.selector,
-    }));
-}
-/**
- * Re-resolve a stale ref against a freshly-built node map by matching the
- * cached descriptor. Pure — no CDP, no DOM.
- *
- * The integer ref assigned by {@link getRefs} is positional: it shifts whenever
- * the accessibility tree changes (navigation, re-render, or even a different
- * `interactive` filter). The descriptor's (role, name) pair is the coarse
- * identity, but a page can carry duplicate (role, name) elements — two "Submit"
- * buttons, one action button per repeated list row. Matching on (role, name)
- * alone would heal to whichever duplicate the fresh scan happens to hit first,
- * which can be the wrong one. So among (role, name) matches we tie-break, in
- * priority order:
- *
- *   1. **DOM-backed** — a candidate with a `backendNodeId` is resolvable to
- *      coordinates; one without is unclickable, so healing to it is useless.
- *   2. **Attribute similarity** — the cached `attrs` (disabled / checked /
- *      selected / …) disambiguate otherwise-identical twins (the *disabled*
- *      Submit vs the enabled one).
- *   3. **Positional proximity** — the fresh ref closest to the original cached
- *      ref index wins, so a repeated list-row action heals to its nearest
- *      positional twin rather than jumping across the page.
- *
- * Returns the new integer ref, or `null` when no node with the same role+name
- * exists in the fresh map (unhealable — the element is genuinely gone).
- */
-export function healRef(descriptor, freshNodeMap) {
-    const { ref, role, name, attrs } = descriptor;
-    const cachedAttrs = new Set(attrs);
-    // How well a candidate's attribute set matches the cached one: reward shared
-    // attrs, penalize both extras the candidate carries and cached attrs it is
-    // missing. Exact set equality scores highest; an all-attrs-empty comparison
-    // scores 0 for every candidate (so the tie-break falls through to proximity).
-    const attrScore = (node) => {
-        let shared = 0;
-        for (const a of node.attrs)
-            if (cachedAttrs.has(a))
-                shared += 1;
-        const extra = node.attrs.length - shared;
-        const missing = cachedAttrs.size - shared;
-        return shared * 2 - extra - missing;
-    };
-    let best = null;
-    let bestKey = null;
-    for (const node of freshNodeMap.values()) {
-        if (node.role !== role || node.name !== name)
-            continue;
-        // Lexicographic key, all "higher is better":
-        //   [ DOM-backed, attribute similarity, -distance-to-original-ref ].
-        const key = [
-            node.backendNodeId !== undefined || node.selector !== undefined ? 1 : 0,
-            attrScore(node),
-            -Math.abs(node.ref - ref),
-        ];
-        if (bestKey === null ||
-            key[0] > bestKey[0] ||
-            (key[0] === bestKey[0] && key[1] > bestKey[1]) ||
-            (key[0] === bestKey[0] && key[1] === bestKey[1] && key[2] > bestKey[2])) {
-            best = node;
-            bestKey = key;
-        }
-    }
-    return best ? best.ref : null;
-}
-const EDITOR_DETECT_FN = `(function() {
-  let el = this;
-  for (let i = 0; i < 5; i++) {
-    if (!el || el === document.documentElement) break;
-    if (el.hasAttribute && el.hasAttribute('data-lexical-editor')) return 'lexical';
-    if (el.classList && el.classList.contains('ProseMirror')) return 'prosemirror';
-    if (el.hasAttribute && el.hasAttribute('data-slate-editor')) return 'slate';
-    if (el.classList && Array.from(el.classList).some(function(c) { return /^DraftEditor-/.test(c); })) return 'draft';
-    if (el.classList && el.classList.contains('ql-editor')) return 'quill';
-    if (el.classList && el.classList.contains('ck-editor__editable')) return 'ckeditor5';
-    if (el.tagName === 'TRIX-EDITOR') return 'trix';
-    el = el.parentElement;
-  }
-  return null;
-})`;
-async function detectEditorForNode(cdp, sessionId, backendNodeId) {
-    const { object } = await cdp.send('DOM.resolveNode', { backendNodeId }, sessionId);
-    if (!object.objectId)
-        return undefined;
-    const objectId = object.objectId;
-    try {
-        const { result } = await cdp.send('Runtime.callFunctionOn', { objectId, functionDeclaration: EDITOR_DETECT_FN, returnByValue: true }, sessionId);
-        return result.value ?? undefined;
-    }
-    finally {
-        await cdp.send('Runtime.releaseObject', { objectId }, sessionId);
-    }
-}
-const INTERACTIVE_ROLES = new Set([
-    'button',
-    'link',
-    'textbox',
-    'checkbox',
-    'radio',
-    'combobox',
-    'listbox',
-    'option',
-    'menuitem',
-    'tab',
-    'slider',
-    'spinbutton',
-    'searchbox',
-    'switch',
-    'menuitemcheckbox',
-    'menuitemradio',
-    'treeitem',
-]);
-export async function getRefs(cdp, sessionId, opts = {}) {
-    const { interactive = true, limit = 500, compact = false } = opts;
-    const { nodes } = (await cdp.send('Accessibility.getFullAXTree', {}, sessionId));
-    const nodeMap = new Map();
-    const lines = [];
-    let refCounter = 1;
-    for (const node of nodes) {
-        if (refCounter > limit)
-            break;
-        const role = node.role?.value?.toLowerCase() || '';
-        if (!role || role === 'none' || role === 'generic')
-            continue;
-        if (interactive && !INTERACTIVE_ROLES.has(role))
-            continue;
-        const name = node.name?.value || '';
-        const attrs = [];
-        for (const prop of node.properties || []) {
-            const propName = prop.name;
-            const propValue = prop.value?.value;
-            if (propName === 'disabled' && propValue === true)
-                attrs.push('disabled');
-            if (propName === 'checked' && propValue === true)
-                attrs.push('checked');
-            if (propName === 'selected' && propValue === true)
-                attrs.push('selected');
-            if (propName === 'expanded' && propValue === true)
-                attrs.push('expanded');
-            if (propName === 'required' && propValue === true)
-                attrs.push('required');
-            if (propName === 'readonly' && propValue === true)
-                attrs.push('readonly');
-            if (propName === 'invalid' && propValue === true)
-                attrs.push('invalid');
-        }
-        const ref = refCounter++;
-        const refNode = {
-            ref,
-            role,
-            name,
-            attrs,
-            backendNodeId: node.backendDOMNodeId,
-        };
-        if (role === 'textbox' && node.backendDOMNodeId) {
-            const editor = await detectEditorForNode(cdp, sessionId, node.backendDOMNodeId);
-            if (editor)
-                refNode.editor = editor;
-        }
-        nodeMap.set(ref, refNode);
-        const attrStr = attrs.length > 0 ? ` [${attrs.join('] [')}]` : '';
-        const editorStr = refNode.editor ? ` [editor=${refNode.editor}]` : '';
-        const nameStr = name ? ` "${truncate(name, 50)}"` : '';
-        const line = compact
-            ? `${role}${nameStr} [ref=${ref}]${attrStr}${editorStr}`
-            : `- ${role}${nameStr} [ref=${ref}]${attrStr}${editorStr}`;
-        lines.push(line);
-    }
-    return { refs: lines.join('\n'), nodeMap, opts: { interactive, limit } };
-}
-export async function resolveRefToCoords(cdp, sessionId, nodeMap, ref) {
-    const node = nodeMap.get(ref);
-    if (!node)
-        throw new Error(`Ref ${ref} not found`);
-    if (!node.backendNodeId)
-        throw new Error(`Ref ${ref} has no DOM node`);
-    const { model } = (await cdp.send('DOM.getBoxModel', { backendNodeId: node.backendNodeId }, sessionId));
-    const [x1, y1, x2, y2, x3, y3, x4, y4] = model.content;
-    const centerX = (x1 + x2 + x3 + x4) / 4;
-    const centerY = (y1 + y2 + y3 + y4) / 4;
-    return { x: centerX, y: centerY };
-}

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

@@ -1,70 +0,0 @@
-import type { BrowserProfileConfig } from '../types.js';
-export interface ProfileDeclaration {
-    device: string;
-    config: BrowserProfileConfig;
-}
-/**
- * The leftover central `browser:` tombstone from before per-device declarations.
- * Empty when none remain — and `agents sync` now drains it automatically via
- * {@link autoEvictCentralBrowserProfiles}, so on a synced box this is empty and
- * {@link profileRegistry} is the single source of truth. It survives only to
- * fold in migration and to explain an as-yet-unclaimed profile in a resolve
- * error (a profile hostable on a peer that has not synced yet), never as a
- * parallel store callers read for resolution.
- */
-export declare function centralBrowserProfiles(): Record<string, BrowserProfileConfig>;
-interface CentralClaimResult {
-    claimed: string[];
-    skipped: string[];
-}
-/**
- * Fold leftover central `browser:` entries into THIS device's declaration file.
- *
- * The EXPLICIT operator action (`agents browser profiles claim`), run on the
- * machine that actually owns the browser. It is never called implicitly from a
- * read, and that is the point: every device can read the central map, so an
- * implicit claim races — whichever box reads first claims the name, {@link
- * profileKind} then reports it `identity`, and the daemon tunnels to that box,
- * which for a fleet-wide `cdp://localhost:*` profile is a logged-out headless
- * browser wearing a credentialed browser's name. {@link autoEvictCentralBrowserProfiles}
- * closes that race for the automatic path (host-gated + non-throwing on sync);
- * this one is the manual, throw-on-conflict counterpart.
- *
- * `canHostHere` is supplied by the command layer so this module stays a leaf —
- * it must not import `isProfileLaunchableHere` (that would cycle through
- * chrome.ts → profiles.ts). Only profiles this machine can host are claimed; the
- * rest stay central, undeclared, and fail loudly on resolve.
- */
-export declare function migrateCentralBrowserProfiles(canHostHere: (config: BrowserProfileConfig) => boolean, name?: string): CentralClaimResult;
-/**
- * Automatic, self-draining counterpart to {@link migrateCentralBrowserProfiles}:
- * fold every lingering central `browser:` profile THIS machine can host into its
- * device doc and clear it from central, so the tombstone drains itself on
- * `agents sync` with no manual `agents browser profiles claim`.
- *
- * Safe to call implicitly, unlike a claim at registry-read time (which races —
- * see the `profileRegistry does not claim central declarations` guard), but the
- * CALLER owns one ordering invariant: invoke it AFTER the sync's repo pull. Two
- * boxes can both host the same profile (`canHostHere` is launchability, not
- * ownership), so a box acting on a PRE-pull view of central could re-claim a
- * profile a peer already drained and pushed — both writes land in different
- * device files with no git conflict, and the profile flips identity->fungible.
- * Running post-pull means central already reflects peers' drains, so the tombstone
- * is gone locally before this box looks. The selection is also computed INSIDE
- * the meta lock, and the path never throws — an unhostable profile or one that
- * conflicts with an existing local declaration is left central for an explicit
- * claim rather than wedging the sync. After it runs, {@link profileRegistry} is
- * the single source of truth: a claimed profile lives in the device doc alone,
- * never double-counted across the two stores.
- */
-export declare function autoEvictCentralBrowserProfiles(canHostHere: (config: BrowserProfileConfig) => boolean): CentralClaimResult;
-/**
- * Every profile any device declares, keyed by name to all declaring devices.
- * Reads every `devices/<name>/agents.yaml`; declarations never overwrite.
- */
-export declare function profileRegistry(): Map<string, ProfileDeclaration[]>;
-/** Devices declaring `name`, empty when nobody does. */
-export declare function declaringDevices(name: string): string[];
-/** Exactly one declaring device is identity-bearing; several are fungible. */
-export declare function profileKind(name: string): 'identity' | 'fungible' | null;
-export {};

package/dist/lib/browser/registry.js

@@ -1,252 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { isDeepStrictEqual } from 'node:util';
-import * as yaml from 'yaml';
-import { commitCentralConfigAfterWrite, getUserAgentsDir, readMeta, updateMeta, withMetaLock, writeMetaUnlocked } from '../state.js';
-function isRecord(value) {
-    return !!value && typeof value === 'object' && !Array.isArray(value);
-}
-/**
- * The leftover central `browser:` tombstone from before per-device declarations.
- * Empty when none remain — and `agents sync` now drains it automatically via
- * {@link autoEvictCentralBrowserProfiles}, so on a synced box this is empty and
- * {@link profileRegistry} is the single source of truth. It survives only to
- * fold in migration and to explain an as-yet-unclaimed profile in a resolve
- * error (a profile hostable on a peer that has not synced yet), never as a
- * parallel store callers read for resolution.
- */
-export function centralBrowserProfiles() {
-    const central = readMeta().browser;
-    if (!central || Object.keys(central).length === 0)
-        return {};
-    return { ...central };
-}
-/**
- * Pick the central `browser:` entries this machine may fold into its device doc.
- *
- * A profile is claimable only when `canHostHere` accepts it — the endpoint or
- * binary resolves to THIS machine — so a `cdp://localhost:*` profile owned by a
- * peer is never claimed here (the logged-out-headless-browser bug this module
- * exists to prevent). A name already declared locally with an IDENTICAL config
- * is folded too, which just drops the redundant central copy. A name declared
- * locally with a DIFFERENT config is a genuine conflict: `onConflict: 'throw'`
- * (the explicit `claim` command) surfaces it; `onConflict: 'skip'` (automatic
- * eviction on sync) leaves it central so a stray duplicate can never wedge a
- * sync — an operator resolves it with an explicit claim.
- */
-function selectClaimableCentral(central, local, canHostHere, opts) {
-    const toClaim = {};
-    const skipped = [];
-    for (const [profileName, config] of Object.entries(central)) {
-        if (opts.name && profileName !== opts.name)
-            continue;
-        if (!canHostHere(config)) {
-            skipped.push(profileName);
-            continue;
-        }
-        const existing = local[profileName];
-        if (existing && !isDeepStrictEqual(existing, config)) {
-            if (opts.onConflict === 'throw') {
-                throw new Error(`Cannot migrate browser profile "${profileName}": central agents.yaml and this device's ` +
-                    `agents.yaml declare different configurations. Resolve the duplicate before retrying.`);
-            }
-            skipped.push(profileName);
-            continue;
-        }
-        toClaim[profileName] = config;
-    }
-    return { toClaim, skipped };
-}
-/**
- * Return `current` with `toClaim` moved out of the central `browser:` map and
- * into this device's `deviceBrowser` doc. The central key is dropped entirely
- * once drained, so the tombstone disappears rather than lingering as an empty
- * map. Pure — the caller applies it under the meta lock.
- */
-function buildEvictedMeta(current, toClaim) {
-    const legacy = current;
-    const remaining = {};
-    for (const [profileName, config] of Object.entries(legacy.browser ?? {})) {
-        if (!(profileName in toClaim))
-            remaining[profileName] = config;
-    }
-    const { browser: _removed, ...withoutCentralBrowser } = legacy;
-    return {
-        ...withoutCentralBrowser,
-        ...(Object.keys(remaining).length > 0 ? { browser: remaining } : {}),
-        deviceBrowser: { ...current.deviceBrowser, ...toClaim },
-    };
-}
-/**
- * Commit a claim computed by the EXPLICIT path (`migrateCentralBrowserProfiles`).
- * `toClaim` was selected from an unlocked snapshot — acceptable for that manual,
- * deliberate command; the automatic path instead selects INSIDE the lock (see
- * {@link autoEvictCentralBrowserProfiles}) so an unrelated concurrent write can
- * never be clobbered by a stale selection.
- */
-function commitCentralClaim(toClaim) {
-    updateMeta((current) => buildEvictedMeta(current, toClaim));
-}
-/**
- * Fold leftover central `browser:` entries into THIS device's declaration file.
- *
- * The EXPLICIT operator action (`agents browser profiles claim`), run on the
- * machine that actually owns the browser. It is never called implicitly from a
- * read, and that is the point: every device can read the central map, so an
- * implicit claim races — whichever box reads first claims the name, {@link
- * profileKind} then reports it `identity`, and the daemon tunnels to that box,
- * which for a fleet-wide `cdp://localhost:*` profile is a logged-out headless
- * browser wearing a credentialed browser's name. {@link autoEvictCentralBrowserProfiles}
- * closes that race for the automatic path (host-gated + non-throwing on sync);
- * this one is the manual, throw-on-conflict counterpart.
- *
- * `canHostHere` is supplied by the command layer so this module stays a leaf —
- * it must not import `isProfileLaunchableHere` (that would cycle through
- * chrome.ts → profiles.ts). Only profiles this machine can host are claimed; the
- * rest stay central, undeclared, and fail loudly on resolve.
- */
-export function migrateCentralBrowserProfiles(canHostHere, name) {
-    const meta = readMeta();
-    const central = meta.browser;
-    if (!central || Object.keys(central).length === 0) {
-        if (name) {
-            throw new Error(`No leftover central browser profile named "${name}".`);
-        }
-        return { claimed: [], skipped: [] };
-    }
-    const local = meta.deviceBrowser ?? {};
-    if (name) {
-        const config = central[name];
-        if (!config) {
-            throw new Error(local[name]
-                ? `Browser profile "${name}" is already declared on this device.`
-                : `No leftover central browser profile named "${name}".`);
-        }
-        if (!canHostHere(config)) {
-            throw new Error(`Cannot claim browser profile "${name}": this machine cannot host it ` +
-                `(its browser/binary isn't installed here). Run this command on the machine that has that browser.`);
-        }
-    }
-    const { toClaim, skipped } = selectClaimableCentral(central, local, canHostHere, {
-        name,
-        onConflict: 'throw',
-    });
-    const claimed = Object.keys(toClaim).sort();
-    skipped.sort();
-    if (claimed.length === 0)
-        return { claimed, skipped };
-    commitCentralClaim(toClaim);
-    return { claimed, skipped };
-}
-/**
- * Automatic, self-draining counterpart to {@link migrateCentralBrowserProfiles}:
- * fold every lingering central `browser:` profile THIS machine can host into its
- * device doc and clear it from central, so the tombstone drains itself on
- * `agents sync` with no manual `agents browser profiles claim`.
- *
- * Safe to call implicitly, unlike a claim at registry-read time (which races —
- * see the `profileRegistry does not claim central declarations` guard), but the
- * CALLER owns one ordering invariant: invoke it AFTER the sync's repo pull. Two
- * boxes can both host the same profile (`canHostHere` is launchability, not
- * ownership), so a box acting on a PRE-pull view of central could re-claim a
- * profile a peer already drained and pushed — both writes land in different
- * device files with no git conflict, and the profile flips identity->fungible.
- * Running post-pull means central already reflects peers' drains, so the tombstone
- * is gone locally before this box looks. The selection is also computed INSIDE
- * the meta lock, and the path never throws — an unhostable profile or one that
- * conflicts with an existing local declaration is left central for an explicit
- * claim rather than wedging the sync. After it runs, {@link profileRegistry} is
- * the single source of truth: a claimed profile lives in the device doc alone,
- * never double-counted across the two stores.
- */
-export function autoEvictCentralBrowserProfiles(canHostHere) {
-    // Read fresh, select, and commit inside ONE meta-lock acquisition. Reading
-    // central before the lock and committing after (the manual path's shape) leaves
-    // a window where a concurrent write on THIS machine changes central/deviceBrowser
-    // between snapshot and commit, so the stale selection would be merged over the
-    // fresher value. Selecting from the state the lock just handed us closes that
-    // window. We write ONLY when something is claimed, so a no-op sync never touches
-    // any doc (writeMetaUnlocked would otherwise re-serialize the device doc every
-    // run). This mirrors updateMeta's own body, minus the unconditional write.
-    let centralChanged = false;
-    const result = withMetaLock(() => {
-        const meta = readMeta();
-        const central = meta.browser;
-        if (!central || Object.keys(central).length === 0)
-            return { claimed: [], skipped: [] };
-        const local = meta.deviceBrowser ?? {};
-        const { toClaim, skipped } = selectClaimableCentral(central, local, canHostHere, {
-            onConflict: 'skip',
-        });
-        const claimed = Object.keys(toClaim).sort();
-        skipped.sort();
-        if (claimed.length === 0)
-            return { claimed, skipped };
-        centralChanged = writeMetaUnlocked(buildEvictedMeta(meta, toClaim));
-        return { claimed, skipped };
-    });
-    // Commit the central eviction AFTER the meta lock releases (the invariant:
-    // every non-daemon central write commits after the lock, so agents.yaml is
-    // never left dirty at rest to re-open the pull-trip window). Gated inside the
-    // helper on centralChanged && !isDaemonProcess().
-    commitCentralConfigAfterWrite(centralChanged);
-    return result;
-}
-/**
- * Every profile any device declares, keyed by name to all declaring devices.
- * Reads every `devices/<name>/agents.yaml`; declarations never overwrite.
- */
-export function profileRegistry() {
-    const registry = new Map();
-    const devicesDir = path.join(getUserAgentsDir(), 'devices');
-    if (!fs.existsSync(devicesDir))
-        return registry;
-    const devices = fs
-        .readdirSync(devicesDir, { withFileTypes: true })
-        .filter((entry) => entry.isDirectory())
-        .map((entry) => entry.name)
-        .sort();
-    for (const device of devices) {
-        const file = path.join(devicesDir, device, 'agents.yaml');
-        if (!fs.existsSync(file))
-            continue;
-        let parsed;
-        try {
-            parsed = yaml.parse(fs.readFileSync(file, 'utf8'));
-        }
-        catch (error) {
-            throw new Error(`Cannot read browser declarations from ${file}: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        if (parsed == null)
-            continue;
-        if (!isRecord(parsed)) {
-            throw new Error(`Cannot read browser declarations from ${file}: document root must be a map.`);
-        }
-        const browser = parsed.browser;
-        if (browser == null)
-            continue;
-        if (!isRecord(browser)) {
-            throw new Error(`Cannot read browser declarations from ${file}: browser must be a map.`);
-        }
-        for (const [name, config] of Object.entries(browser)) {
-            if (!isRecord(config)) {
-                throw new Error(`Cannot read browser declaration "${name}" from ${file}: profile must be a map.`);
-            }
-            const declarations = registry.get(name) ?? [];
-            declarations.push({ device, config: config });
-            registry.set(name, declarations);
-        }
-    }
-    return registry;
-}
-/** Devices declaring `name`, empty when nobody does. */
-export function declaringDevices(name) {
-    return (profileRegistry().get(name) ?? []).map((declaration) => declaration.device);
-}
-/** Exactly one declaring device is identity-bearing; several are fungible. */
-export function profileKind(name) {
-    const count = profileRegistry().get(name)?.length ?? 0;
-    if (count === 0)
-        return null;
-    return count === 1 ? 'identity' : 'fungible';
-}

package/dist/lib/browser/remote-control.d.ts

@@ -1,59 +0,0 @@
-/**
- * Consent gate for driving THIS machine's browser from another fleet machine.
- *
- * `browser --device <device>` routes a browser command to `<device>` over SSH (the
- * fleet passthrough) and runs `agents browser ...` there. `agents ssh <device>
- * agents browser …` is the same remote drive through the ssh wrapper. Every such
- * remote invocation carries the {@link FLEET_REMOTE_ENV} marker, set at the fleet
- * dispatch site (`maybeRunOnHost` / `streamAgentsOnHost`) and on the ssh wrapper
- * (`buildSshInvocation` via `markFleetRemote`). A machine only accepts being driven
- * when its owner has opted in via `agents browser remote-control on` (the
- * device-scope `browser.remote-control` config key, never synced).
- *
- * Local invocations (no marker) are never gated — this only governs cross-machine
- * drives. Read-only queries are not gated.
- *
- * The authoritative gate is {@link assertRemoteControlAllowedForRequest}, called
- * inside the browser daemon at the top of `resolveOrCreateTask` — the one
- * chokepoint every task-scoped verb resolves through — plus `BrowserService.start`
- * for the task-less `browser start` command and `BrowserService.stopProfile` for
- * the task-less `browser stop --profile` command. It has to live there because ~18
- * page verbs (`navigate`, `click`, `screenshot`, `tab-add`, …) launch OR attach
- * to a browser implicitly, and gating only the `browser start` command left every
- * one of them ungated; gating only the create branch of `resolveOrCreateTask` left
- * the attach paths ungated (RUSH-3064); `stop --profile` is handled by `bindTask`'s
- * early return before `resolveOrCreateTask` ever runs, so it needed its own gate
- * call too (PHNX-3317). {@link assertRemoteControlAllowed} remains as a fast-fail
- * CLI-side check so a refused `start` never auto-creates a profile.
- */
-/** Env marker set on every remote `agents` invocation by `buildRemoteAgentsInvocation` and `markFleetRemote`. */
-export declare const FLEET_REMOTE_ENV = "AGENTS_FLEET_REMOTE";
-/** True when this process was dispatched to this machine by a fleet `--device` or `agents ssh … agents browser` run. */
-export declare function isFleetRemoteInvocation(env?: NodeJS.ProcessEnv): boolean;
-/**
- * Guard the browser-drive entry point. A fleet-remote invocation may only drive
- * this machine's browser when the owner opted in; otherwise throw a clear,
- * actionable error. A local invocation is never gated.
- *
- * `env` and `enabled` are injectable so the decision is unit-testable without a
- * real remote hop or a real config store.
- */
-export declare function assertRemoteControlAllowed(opts?: {
-    env?: NodeJS.ProcessEnv;
-    enabled?: boolean;
-}): void;
-/**
- * The daemon-side consent gate.
- *
- * Reads ONLY the per-request marker, never `process.env`: the browser daemon is
- * shared and long-lived, and it may have been auto-started by a fleet-remote CLI
- * that leaked `AGENTS_FLEET_REMOTE=1` into its environment permanently. Reading
- * the daemon's env would then refuse every subsequent LOCAL drive on this
- * machine until the daemon restarted.
- *
- * `actor` is likewise the caller's forwarded identity, not the daemon's.
- */
-export declare function assertRemoteControlAllowedForRequest(fleetRemote: boolean | undefined, opts?: {
-    actor?: string;
-    enabled?: boolean;
-}): void;