@ericsanchezok/synergy-util 2.4.4

package/dist/binary.d.ts

@@ -0,0 +1,7 @@
+export declare namespace Binary {
+    function search<T>(array: T[], id: string, compare: (item: T) => string): {
+        found: boolean;
+        index: number;
+    };
+    function insert<T>(array: T[], item: T, compare: (item: T) => string): T[];
+}

package/dist/binary.js

@@ -0,0 +1,40 @@
+export var Binary;
+(function (Binary) {
+    function search(array, id, compare) {
+        let left = 0;
+        let right = array.length - 1;
+        while (left <= right) {
+            const mid = Math.floor((left + right) / 2);
+            const midId = compare(array[mid]);
+            if (midId === id) {
+                return { found: true, index: mid };
+            }
+            else if (midId < id) {
+                left = mid + 1;
+            }
+            else {
+                right = mid - 1;
+            }
+        }
+        return { found: false, index: left };
+    }
+    Binary.search = search;
+    function insert(array, item, compare) {
+        const id = compare(item);
+        let left = 0;
+        let right = array.length;
+        while (left < right) {
+            const mid = Math.floor((left + right) / 2);
+            const midId = compare(array[mid]);
+            if (midId < id) {
+                left = mid + 1;
+            }
+            else {
+                right = mid;
+            }
+        }
+        array.splice(left, 0, item);
+        return array;
+    }
+    Binary.insert = insert;
+})(Binary || (Binary = {}));

package/dist/browser-protocol.d.ts

@@ -0,0 +1,97 @@
+export declare const BROWSER_PROTOCOL_VERSION = 1;
+export declare const BrowserPresentationKinds: readonly ["native", "webrtc"];
+export type BrowserPresentationKind = (typeof BrowserPresentationKinds)[number];
+export type BrowserPresentationPreference = "auto" | BrowserPresentationKind;
+export declare function parseBrowserPresentationPreference(value: string | null | undefined): BrowserPresentationPreference;
+export declare function normalizeBrowserURL(input: string, base?: string): string;
+export interface BrowserPresentationCapabilities {
+    native: boolean;
+    webrtc: boolean;
+}
+export interface BrowserPresentationSelection {
+    protocolVersion: typeof BROWSER_PROTOCOL_VERSION;
+    kind: BrowserPresentationKind;
+    capabilities: BrowserPresentationCapabilities;
+    reason: "desktop-local" | "remote-client" | "requested";
+}
+export interface BrowserPresentationEnvironment {
+    desktop: boolean;
+    sameHost: boolean;
+    remote: boolean;
+    requested?: BrowserPresentationPreference;
+    capabilities?: Partial<BrowserPresentationCapabilities>;
+}
+export interface BrowserPage {
+    id: string;
+    url: string;
+    title: string;
+    isLoading: boolean;
+    lastActiveAt?: number | null;
+}
+export interface BrowserSession {
+    page: BrowserPage | null;
+}
+export interface BrowserPresentation {
+    selection: BrowserPresentationSelection;
+}
+export interface BrowserControl {
+    navigate(input: {
+        pageId?: string;
+        url: string;
+    }): Promise<{
+        url: string;
+        title: string;
+    }>;
+    reload(input?: {
+        pageId?: string;
+    }): Promise<void>;
+    stop(input?: {
+        pageId?: string;
+    }): Promise<void>;
+    setViewport(input: {
+        pageId?: string;
+        width: number;
+        height: number;
+    }): Promise<void>;
+    snapshot(input?: {
+        pageId?: string;
+    }): Promise<unknown>;
+    screenshot(input?: {
+        pageId?: string;
+    }): Promise<{
+        dataUrl: string;
+        width: number;
+        height: number;
+    }>;
+}
+export interface BrowserHost {
+    protocolVersion: typeof BROWSER_PROTOCOL_VERSION;
+    capabilities(): Promise<BrowserPresentationCapabilities> | BrowserPresentationCapabilities;
+    presentation(input: BrowserPresentationEnvironment): BrowserPresentationSelection;
+    session(input: {
+        ownerKey: string;
+    }): Promise<BrowserSession>;
+    control(input: {
+        ownerKey: string;
+    }): Promise<BrowserControl>;
+}
+export declare function selectBrowserPresentation(input: BrowserPresentationEnvironment): BrowserPresentationSelection;
+export type BrowserWebRTCSignalMessage = {
+    type: "webrtc.offer";
+    pageId: string;
+    sdp: string;
+    traceId?: string;
+} | {
+    type: "webrtc.answer";
+    pageId: string;
+    sdp: string;
+} | {
+    type: "webrtc.ice";
+    pageId: string;
+    candidate: unknown;
+    traceId?: string;
+} | {
+    type: "webrtc.close";
+    pageId: string;
+    traceId?: string;
+};

package/dist/browser-protocol.js

@@ -0,0 +1,51 @@
+export const BROWSER_PROTOCOL_VERSION = 1;
+export const BrowserPresentationKinds = ["native", "webrtc"];
+export function parseBrowserPresentationPreference(value) {
+    if (value === "native" || value === "webrtc")
+        return value;
+    return "auto";
+}
+export function normalizeBrowserURL(input, base) {
+    const raw = input.trim();
+    if (!raw)
+        throw new Error("URL is required");
+    if (/^(localhost|127\.0\.0\.1|\[::1\]|::1)(:\d+)?(\/.*)?$/i.test(raw)) {
+        return `http://${raw}`;
+    }
+    if (/^[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}(:\d+)?(\/.*)?$/.test(raw)) {
+        return `https://${raw}`;
+    }
+    if (base || /^[a-zA-Z][a-zA-Z\d+.-]*:/.test(raw)) {
+        try {
+            return new URL(raw, base).toString();
+        }
+        catch {
+            // Continue to search fallback below.
+        }
+    }
+    return `https://www.google.com/search?q=${encodeURIComponent(raw)}`;
+}
+const defaultCapabilities = {
+    native: true,
+    webrtc: true,
+};
+function capabilities(input) {
+    return {
+        native: input?.native ?? defaultCapabilities.native,
+        webrtc: input?.webrtc ?? defaultCapabilities.webrtc,
+    };
+}
+export function selectBrowserPresentation(input) {
+    const caps = capabilities(input.capabilities);
+    const requested = input.requested ?? "auto";
+    if (requested === "native" && caps.native) {
+        return { protocolVersion: BROWSER_PROTOCOL_VERSION, kind: "native", capabilities: caps, reason: "requested" };
+    }
+    if (requested === "webrtc" && caps.webrtc) {
+        return { protocolVersion: BROWSER_PROTOCOL_VERSION, kind: "webrtc", capabilities: caps, reason: "requested" };
+    }
+    if (caps.native && input.desktop && input.sameHost && !input.remote) {
+        return { protocolVersion: BROWSER_PROTOCOL_VERSION, kind: "native", capabilities: caps, reason: "desktop-local" };
+    }
+    return { protocolVersion: BROWSER_PROTOCOL_VERSION, kind: "webrtc", capabilities: caps, reason: "remote-client" };
+}

package/dist/capability.d.ts

@@ -0,0 +1,289 @@
+export type SynergyCapabilityRisk = "low" | "medium" | "high";
+export type SynergyCapabilityRiskScope = "install" | "agent";
+export declare const SYNERGY_CAPABILITY_CATEGORIES: readonly ["tools", "files", "network", "data", "ui", "runtime", "hooks", "session", "browser", "identity", "communication", "platform"];
+export type SynergyCapabilityCategory = (typeof SYNERGY_CAPABILITY_CATEGORIES)[number];
+export type SynergyCapabilitySeverity = SynergyCapabilityRisk;
+export interface SynergyCapabilityPermissionItem {
+    key: string;
+    category: SynergyCapabilityCategory;
+    severity: SynergyCapabilitySeverity;
+    title: string;
+    description: string;
+    technical?: string;
+}
+export interface RegistryPermissionItem {
+    key: string;
+    description: string;
+    risk: SynergyCapabilityRisk;
+}
+export type ManifestTool = NonNullable<NonNullable<SynergyCapabilityManifest["contributes"]>["tools"]>[number];
+export interface SynergyCapabilityManifestTool {
+    id?: string;
+    name: string;
+    exposure?: {
+        mode?: string;
+    };
+    capabilities?: {
+        filesystem?: "none" | "read" | "write";
+        shell?: boolean;
+        network?: boolean;
+        session?: "none" | "metadata" | "read";
+        workspace?: "none" | "metadata" | "read";
+        config?: "none" | "plugin" | "global";
+    };
+}
+export interface SynergyCapabilityManifest {
+    permissions?: {
+        tools?: {
+            filesystem?: "none" | "read" | "write";
+            shell?: boolean;
+            network?: boolean;
+            mcp?: "none" | "invoke" | "spawn";
+            task?: unknown;
+        };
+        data?: {
+            session?: "none" | "metadata" | "read";
+            workspace?: "none" | "metadata" | "read";
+            config?: "none" | "plugin" | "global";
+            secrets?: "none" | "own";
+        };
+        ui?: {
+            toolRenderers?: boolean;
+            partRenderers?: boolean;
+            workbenchPanels?: boolean;
+            appPanels?: boolean;
+            settings?: boolean;
+            messageSlots?: boolean;
+            themes?: boolean;
+            icons?: boolean;
+            appRoutes?: boolean;
+            commands?: boolean;
+            trustedImport?: boolean;
+            sandboxIframe?: boolean;
+        };
+        hooks?: {
+            promptTransform?: boolean;
+            compactionTransform?: boolean;
+            toolExecute?: "none" | "own" | "declared" | "all";
+            permissionAsk?: "none" | "own" | "all";
+            events?: "none" | "selected" | "all";
+            eventNames?: string[];
+        };
+        network?: {
+            connectDomains?: string[];
+        };
+    };
+    contributes?: {
+        permissions?: unknown;
+        tools?: SynergyCapabilityManifestTool[];
+        agents?: Array<{
+            name?: string;
+            mode?: string;
+            hidden?: boolean;
+            model?: unknown;
+            modelRole?: unknown;
+            permission?: unknown;
+        }>;
+        mcp?: unknown;
+        ui?: {
+            toolRenderers?: unknown[];
+            partRenderers?: unknown[];
+            workbenchPanels?: unknown[];
+            appPanels?: unknown[];
+            settings?: unknown[];
+            messageSlots?: unknown[];
+            themes?: unknown[];
+            icons?: unknown[];
+            appRoutes?: unknown[];
+            commands?: unknown[];
+        };
+    };
+    lifecycle?: unknown;
+}
+export interface SynergyCapabilityDefinition extends Omit<SynergyCapabilityPermissionItem, "key"> {
+    nonBypassable?: boolean;
+}
+export declare function publicToolNames(manifest: SynergyCapabilityManifest): string[];
+export declare function hasPublicTools(manifest: SynergyCapabilityManifest): boolean;
+export declare const SYNERGY_CAPABILITY_DETAILS: Record<string, SynergyCapabilityDefinition>;
+export declare const SYNERGY_PROFILE_CAPABILITIES: readonly ["file_read", "file_write", "shell_read", "shell", "shell_remote_write", "shell_remote_publish", "shell_destructive", "shell_hardline", "file_external_read", "file_external_write", "network_read", "network_request", "mcp_invoke", "mcp_spawn", "session_data", "workspace_data", "config:read", "config:write", "secrets", "task", "prompt_transform", "compaction_transform", "tool_execution_hook", "permission_hook", "event_hook", "identity_act", "communication_email", "channel_outbound", "platform_control", "protected_op", "session_state", "browser_interact", "browser_inspect", "browser_eval_readonly", "browser_eval_trusted", "browser_clipboard", "browser_download", "browser_viewport"];
+export declare const SYNERGY_PERMISSION_CAPABILITY: Record<string, string>;
+export declare function permissionCapability(permission: string): string;
+export declare function capabilityNonBypassable(capability: string): boolean;
+export declare function capabilityRisk(capability: string, manifest?: SynergyCapabilityManifest): SynergyCapabilityRisk;
+export declare function baseCapabilities(manifest: SynergyCapabilityManifest): string[];
+export declare function toolCapabilities(manifest: SynergyCapabilityManifest, tool: ManifestTool): string[];
+export declare function publicToolCapabilities(manifest: SynergyCapabilityManifest): string[];
+export declare function computeRisk(capabilities: string[], manifest?: SynergyCapabilityManifest): SynergyCapabilityRisk;
+export declare function capabilitiesForRiskScope(manifest: SynergyCapabilityManifest, scope: SynergyCapabilityRiskScope): string[];
+export declare function pluginRisk(manifest: SynergyCapabilityManifest, input: {
+    scope: SynergyCapabilityRiskScope;
+}): SynergyCapabilityRisk;
+export declare function toolRisk(manifest: SynergyCapabilityManifest, tool: ManifestTool): SynergyCapabilityRisk;
+export declare function permissionItems(manifest: SynergyCapabilityManifest, capabilities: string[]): SynergyCapabilityPermissionItem[];
+export declare function registryPermissionSummary(manifest: SynergyCapabilityManifest, capabilities: string[]): RegistryPermissionItem[];
+export declare function permissionCategoryForKey(key: string): SynergyCapabilityCategory;
+export declare function permissionsHashPayload(manifest: SynergyCapabilityManifest, capabilities: string[]): {
+    capabilities: string[];
+    permissions: {
+        tools?: {
+            filesystem?: "none" | "read" | "write";
+            shell?: boolean;
+            network?: boolean;
+            mcp?: "none" | "invoke" | "spawn";
+            task?: unknown;
+        };
+        data?: {
+            session?: "none" | "metadata" | "read";
+            workspace?: "none" | "metadata" | "read";
+            config?: "none" | "plugin" | "global";
+            secrets?: "none" | "own";
+        };
+        ui?: {
+            toolRenderers?: boolean;
+            partRenderers?: boolean;
+            workbenchPanels?: boolean;
+            appPanels?: boolean;
+            settings?: boolean;
+            messageSlots?: boolean;
+            themes?: boolean;
+            icons?: boolean;
+            appRoutes?: boolean;
+            commands?: boolean;
+            trustedImport?: boolean;
+            sandboxIframe?: boolean;
+        };
+        hooks?: {
+            promptTransform?: boolean;
+            compactionTransform?: boolean;
+            toolExecute?: "none" | "own" | "declared" | "all";
+            permissionAsk?: "none" | "own" | "all";
+            events?: "none" | "selected" | "all";
+            eventNames?: string[];
+        };
+        network?: {
+            connectDomains?: string[];
+        };
+    };
+    contributes: {
+        ui?: {
+            toolRenderers: boolean;
+            partRenderers: boolean;
+            workbenchPanels: boolean;
+            appPanels: boolean;
+            settings: boolean;
+            messageSlots: boolean;
+            themes: boolean;
+            icons: boolean;
+            appRoutes: boolean;
+            commands: boolean;
+        } | undefined;
+        mcp?: {} | undefined;
+        agents?: {
+            name: string | undefined;
+            mode: string | undefined;
+            hidden: boolean | undefined;
+            model: unknown;
+            modelRole: unknown;
+            permission: unknown;
+        }[] | undefined;
+        tools?: {
+            id: string | undefined;
+            name: string;
+            exposure: {
+                mode?: string;
+            } | undefined;
+            capabilities: {
+                filesystem?: "none" | "read" | "write";
+                shell?: boolean;
+                network?: boolean;
+                session?: "none" | "metadata" | "read";
+                workspace?: "none" | "metadata" | "read";
+                config?: "none" | "plugin" | "global";
+            } | undefined;
+        }[] | undefined;
+        permissions?: {} | undefined;
+    } | undefined;
+    lifecycle: {};
+};
+export declare function manifestHashPayload(manifest: SynergyCapabilityManifest): SynergyCapabilityManifest;
+export declare function stablePluginJson(value: unknown): string;
+export type BridgeMethodPolicy = {
+    type: "capability";
+    capability: string;
+} | {
+    type: "unprivileged";
+} | {
+    type: "unknown";
+};
+export declare const SYNERGY_BRIDGE_METHOD_POLICY: {
+    readonly "config.get": {
+        readonly type: "capability";
+        readonly capability: "config:read";
+    };
+    readonly "config.set": {
+        readonly type: "capability";
+        readonly capability: "config:write";
+    };
+    readonly "config.replace": {
+        readonly type: "capability";
+        readonly capability: "config:write";
+    };
+    readonly "secret.get": {
+        readonly type: "capability";
+        readonly capability: "secrets";
+    };
+    readonly "secret.set": {
+        readonly type: "capability";
+        readonly capability: "secrets";
+    };
+    readonly "secret.delete": {
+        readonly type: "capability";
+        readonly capability: "secrets";
+    };
+    readonly "cache.get": {
+        readonly type: "unprivileged";
+    };
+    readonly "cache.set": {
+        readonly type: "unprivileged";
+    };
+    readonly "cache.delete": {
+        readonly type: "unprivileged";
+    };
+    readonly "file.read": {
+        readonly type: "capability";
+        readonly capability: "file_read";
+    };
+    readonly "file.write": {
+        readonly type: "capability";
+        readonly capability: "file_write";
+    };
+    readonly "network.fetch": {
+        readonly type: "capability";
+        readonly capability: "network_request";
+    };
+    readonly "shell.run": {
+        readonly type: "capability";
+        readonly capability: "shell";
+    };
+    readonly "session.getMetadata": {
+        readonly type: "capability";
+        readonly capability: "session_data";
+    };
+    readonly "workspace.getMetadata": {
+        readonly type: "capability";
+        readonly capability: "workspace_data";
+    };
+    readonly "task.run": {
+        readonly type: "capability";
+        readonly capability: "task";
+    };
+    readonly "tool.invoke": {
+        readonly type: "unprivileged";
+    };
+    readonly "permission.request": {
+        readonly type: "unprivileged";
+    };
+};
+export declare function bridgeMethodPolicy(method: string): BridgeMethodPolicy;
+export declare function bridgeCapability(method: string): string | undefined;