@ericsanchezok/synergy-util 2.4.5 → 3.0.1

package/dist/plugin-policy.d.ts

@@ -1,64 +1,29 @@
-import { type SynergyCapabilityManifest } from "./capability.js";
 export type PluginSource = "local" | "official" | "npm" | "git" | "url" | "builtin";
-export type RuntimeMode = "in-process" | "worker" | "process";
-export type TrustTier = "declarative" | "trusted-import" | "sandbox";
+export type RuntimeMode = "inProcess" | "process";
+export type TrustTier = "declarative" | "trusted-import";
 export type PolicyRisk = "low" | "medium" | "high";
-export interface PluginPolicyManifest extends SynergyCapabilityManifest {
-    runtime?: {
-        mode?: RuntimeMode;
-        resources?: unknown;
-    };
-    trust?: {
-        requestedTier?: TrustTier;
-    };
-}
-export interface PluginTrustDecision {
-    tier: TrustTier;
-    source: PluginSource;
-    userTrusted: boolean;
-    verifiedIntegrity: boolean;
-    reason: string;
-}
 export interface RuntimeLimits {
     startupTimeoutMs: number;
     toolInvocationTimeoutMs: number;
-    hookInvocationTimeoutMs: number;
-    bridgeRequestTimeoutMs: number;
+    hostServiceRequestTimeoutMs: number;
     taskRunTimeoutMs: number;
     shutdownGraceMs: number;
-    maxConcurrentRequests: number;
-    maxLogBytesPerMinute: number;
-    memoryMb: number;
-    memoryPollIntervalMs: number;
     heartbeatIntervalMs: number;
-    heartbeatMissesBeforeKill: number;
 }
 export type RuntimeLimitOverrides = Partial<RuntimeLimits>;
 export interface PluginRuntimePolicyInput {
-    thirdPartyDefaultMode?: "process" | "worker";
-    highRiskRequiresProcess?: boolean;
-    allowThirdPartyInProcess?: boolean;
-    allowWorkerMode?: boolean;
-    allowLocalInProcess?: boolean;
 }
-export interface PluginPolicyDecision {
+export declare const DEFAULT_PLUGIN_RUNTIME_POLICY: {};
+export declare const DEFAULT_PLUGIN_RUNTIME_LIMITS: RuntimeLimits;
+export interface PluginTrustDecision {
+    tier: TrustTier;
     source: PluginSource;
-    capabilities: string[];
-    risk: PolicyRisk;
-    trust: PluginTrustDecision;
-    runtimeMode: RuntimeMode;
+    userTrusted: boolean;
+    verifiedIntegrity: boolean;
+    reason: string;
 }
-export declare const DEFAULT_PLUGIN_RUNTIME_POLICY: Required<PluginRuntimePolicyInput>;
-export declare const DEFAULT_PLUGIN_RUNTIME_LIMITS: RuntimeLimits;
-export declare function isTrustedPluginSource(source: PluginSource): boolean;
 export interface ResolveRuntimeModeInput {
     source: PluginSource;
-    manifestMode?: RuntimeMode;
-    devMode?: boolean;
-    userTrusted?: boolean;
-    risk?: PolicyRisk;
-    forceProcess?: boolean;
-    policy?: PluginRuntimePolicyInput;
 }
 export interface PolicyCheckResult {
     type: "pass" | "warn" | "error";
@@ -66,6 +31,7 @@ export interface PolicyCheckResult {
 }
 export declare function resolveRuntimeMode(input: ResolveRuntimeModeInput): RuntimeMode;
 export declare function resolveRuntimeLimits(...overrides: Array<RuntimeLimitOverrides | undefined>): RuntimeLimits;
+export declare function isTrustedPluginSource(source: PluginSource): source is "local" | "official" | "builtin";
 export declare function decideTrust(input: {
     source: PluginSource;
     userTrusted: boolean;
@@ -78,23 +44,27 @@ export declare function defaultPluginTrustDecision(input: {
     verifiedIntegrity?: boolean;
     devMode?: boolean;
 }): PluginTrustDecision;
+interface FlatManifest {
+    capabilities?: Array<{
+        id: string;
+    }>;
+}
+export interface PluginPolicyDecision {
+    source: PluginSource;
+    capabilities: string[];
+    risk: PolicyRisk;
+    trust: PluginTrustDecision;
+    runtimeMode: RuntimeMode;
+}
 export declare function resolvePluginPolicyDecision(input: {
-    manifest: PluginPolicyManifest;
+    manifest: FlatManifest;
     source: PluginSource;
     userTrusted?: boolean;
     verifiedIntegrity?: boolean;
     devMode?: boolean;
-    policy?: PluginRuntimePolicyInput;
-    forceProcess?: boolean;
     risk?: PolicyRisk;
 }): PluginPolicyDecision;
 export declare function trustReason(decision: PluginTrustDecision): string;
 export declare function trustSummary(decision: PluginTrustDecision): string;
-export declare function validateRuntimePolicy(input: {
-    manifest: PluginPolicyManifest;
-    source: PluginSource;
-    trustTier: TrustTier;
-    risk: PolicyRisk;
-    userTrusted?: boolean;
-    policy?: PluginRuntimePolicyInput;
-}): PolicyCheckResult[];
+export declare function validateRuntimePolicy(): PolicyCheckResult[];
+export {};

package/dist/plugin-policy.js

@@ -1,123 +1,37 @@
-import { baseCapabilities, pluginRisk } from "./capability.js";
-export const DEFAULT_PLUGIN_RUNTIME_POLICY = {
-    thirdPartyDefaultMode: "process",
-    highRiskRequiresProcess: true,
-    allowThirdPartyInProcess: false,
-    allowWorkerMode: true,
-    allowLocalInProcess: true,
-};
+export const DEFAULT_PLUGIN_RUNTIME_POLICY = {};
 export const DEFAULT_PLUGIN_RUNTIME_LIMITS = {
     startupTimeoutMs: 5_000,
     toolInvocationTimeoutMs: 120_000,
-    hookInvocationTimeoutMs: 120_000,
-    bridgeRequestTimeoutMs: 120_000,
+    hostServiceRequestTimeoutMs: 120_000,
     taskRunTimeoutMs: 120_000,
     shutdownGraceMs: 1_500,
-    maxConcurrentRequests: 8,
-    maxLogBytesPerMinute: 128_000,
-    memoryMb: 256,
-    memoryPollIntervalMs: 10_000,
     heartbeatIntervalMs: 5_000,
-    heartbeatMissesBeforeKill: 3,
 };
-const TRUSTED_SOURCES = new Set(["builtin", "official", "local"]);
-const THIRD_PARTY_SOURCES = new Set(["npm", "git", "url"]);
-export function isTrustedPluginSource(source) {
-    return TRUSTED_SOURCES.has(source);
-}
-function runtimePolicy(input) {
-    return { ...DEFAULT_PLUGIN_RUNTIME_POLICY, ...(input ?? {}) };
-}
 export function resolveRuntimeMode(input) {
-    const policy = runtimePolicy(input.policy);
-    const source = input.source;
-    const manifestMode = input.manifestMode;
-    const userTrusted = input.userTrusted ?? false;
-    const risk = input.risk ?? "low";
-    if (input.forceProcess)
-        return "process";
-    if (policy.highRiskRequiresProcess && risk === "high")
-        return "process";
-    if (manifestMode === "process")
-        return "process";
-    if (manifestMode === "worker") {
-        if (policy.allowWorkerMode && userTrusted)
-            return "worker";
-        return THIRD_PARTY_SOURCES.has(source) ? "process" : defaultTrustedMode(source, policy);
-    }
-    if (manifestMode === "in-process") {
-        if (TRUSTED_SOURCES.has(source))
-            return defaultTrustedMode(source, policy);
-        return policy.allowThirdPartyInProcess ? "in-process" : "process";
-    }
-    if (THIRD_PARTY_SOURCES.has(source)) {
-        if (policy.thirdPartyDefaultMode === "worker" && policy.allowWorkerMode && userTrusted)
-            return "worker";
-        return "process";
-    }
-    return defaultTrustedMode(source, policy);
+    return input.source === "builtin" ? "inProcess" : "process";
 }
 export function resolveRuntimeLimits(...overrides) {
-    const resolved = { ...DEFAULT_PLUGIN_RUNTIME_LIMITS };
+    const result = { ...DEFAULT_PLUGIN_RUNTIME_LIMITS };
     for (const override of overrides) {
-        if (!override)
-            continue;
-        for (const [key, value] of Object.entries(override)) {
-            if (typeof value !== "number" || !Number.isFinite(value) || value <= 0)
-                continue;
-            resolved[key] = Math.round(value);
+        for (const [key, value] of Object.entries(override ?? {})) {
+            if (typeof value === "number" && Number.isFinite(value) && value > 0)
+                result[key] = Math.round(value);
         }
     }
-    return resolved;
+    return result;
+}
+export function isTrustedPluginSource(source) {
+    return source === "builtin" || source === "official" || source === "local";
 }
 export function decideTrust(input) {
-    const { source, userTrusted, verifiedIntegrity, devMode } = input;
-    let tier;
-    let reason;
-    switch (source) {
-        case "builtin":
-            tier = "trusted-import";
-            reason = "builtin plugin is always trusted";
-            break;
-        case "official":
-            tier = "trusted-import";
-            reason = "official registry plugin is trusted";
-            break;
-        case "local":
-            tier = "trusted-import";
-            reason = devMode ? "local plugin in dev mode" : "local plugin";
-            break;
-        case "npm":
-            if (userTrusted && verifiedIntegrity) {
-                tier = "trusted-import";
-                reason = "user-trusted npm plugin with verified integrity";
-            }
-            else {
-                tier = "sandbox";
-                reason = "npm plugin requires explicit user trust and verified integrity";
-            }
-            break;
-        case "git":
-            if (userTrusted) {
-                tier = "trusted-import";
-                reason = "user-trusted git plugin";
-            }
-            else {
-                tier = "sandbox";
-                reason = "git plugin requires explicit user trust";
-            }
-            break;
-        case "url":
-            tier = "sandbox";
-            reason = "URL-sourced plugins always run in sandbox";
-            break;
-    }
     return {
-        tier,
-        source,
-        userTrusted,
-        verifiedIntegrity,
-        reason,
+        source: input.source,
+        userTrusted: input.userTrusted,
+        verifiedIntegrity: input.verifiedIntegrity,
+        tier: input.userTrusted || input.source === "builtin" ? "trusted-import" : "declarative",
+        reason: input.userTrusted
+            ? "plugin UI was explicitly trusted"
+            : "plugin contributes declarations only until trusted",
     };
 }
 export function defaultPluginTrustDecision(input) {
@@ -129,112 +43,29 @@ export function defaultPluginTrustDecision(input) {
     });
 }
 export function resolvePluginPolicyDecision(input) {
-    const userTrusted = input.userTrusted ?? isTrustedPluginSource(input.source);
-    const verifiedIntegrity = input.verifiedIntegrity ?? input.source === "official";
-    const capabilities = baseCapabilities(input.manifest);
-    const risk = input.risk ?? pluginRisk(input.manifest, { scope: "install" });
-    const trust = decideTrust({
-        source: input.source,
-        userTrusted,
-        verifiedIntegrity,
-        devMode: input.devMode ?? false,
-    });
-    const runtimeMode = resolveRuntimeMode({
-        source: input.source,
-        manifestMode: input.manifest.runtime?.mode,
-        devMode: input.devMode,
-        userTrusted,
-        risk,
-        forceProcess: input.forceProcess,
-        policy: input.policy,
-    });
+    const capabilities = input.manifest.capabilities?.map((item) => item.id) ?? [];
+    const risk = input.risk ??
+        (capabilities.some((item) => ["workspace.write", "secrets", "task.delegate", "blueprint.delegate", "lightloop.delegate"].includes(item))
+            ? "high"
+            : capabilities.length
+                ? "medium"
+                : "low");
     return {
         source: input.source,
         capabilities,
         risk,
-        trust,
-        runtimeMode,
+        trust: defaultPluginTrustDecision(input),
+        runtimeMode: resolveRuntimeMode({ source: input.source }),
     };
 }
 export function trustReason(decision) {
-    const factors = [];
-    if (decision.userTrusted)
-        factors.push("user-trusted");
-    if (decision.verifiedIntegrity)
-        factors.push("integrity verified");
-    const factorText = factors.length > 0 ? ` (${factors.join(", ")})` : "";
-    return `${decision.reason} -> ${decision.tier}${factorText}`;
+    return decision.reason;
 }
 export function trustSummary(decision) {
-    const metadata = [];
-    if (decision.userTrusted)
-        metadata.push("trusted");
-    if (decision.verifiedIntegrity)
-        metadata.push("verified");
-    const meta = metadata.length > 0 ? ` [${metadata.join(", ")}]` : "";
-    return `${decision.source} -> ${decision.tier}${meta}`;
+    return `${decision.tier}: ${decision.reason}`;
 }
-function defaultTrustedMode(source, policy) {
-    if (source === "local" && !policy.allowLocalInProcess)
-        return "process";
-    return "in-process";
-}
-export function validateRuntimePolicy(input) {
-    const results = [];
-    const requestedMode = input.manifest.runtime?.mode;
-    const effectiveMode = resolveRuntimeMode({
-        source: input.source,
-        manifestMode: requestedMode,
-        userTrusted: input.userTrusted,
-        risk: input.risk,
-        policy: input.policy,
-    });
-    if (requestedMode && requestedMode !== effectiveMode) {
-        results.push({
-            type: "warn",
-            message: `Plugin requested runtime mode "${requestedMode}" but Synergy will use "${effectiveMode}" for source=${input.source} and risk=${input.risk}.`,
-        });
-    }
-    const requestedTier = input.manifest.trust?.requestedTier;
-    if (input.trustTier === "sandbox" && requestedTier !== "sandbox") {
-        results.push({
-            type: "warn",
-            message: `Plugin has sandbox trust tier; effective runtime mode is "${effectiveMode}". Use process mode with explicit resource limits for strongest isolation.`,
-        });
-    }
-    if (requestedTier !== undefined && requestedTier !== input.trustTier) {
-        results.push({
-            type: "warn",
-            message: `Plugin requested trust tier "${requestedTier}" but was assigned "${input.trustTier}" (source=${input.source}). Runtime mode is "${effectiveMode}".`,
-        });
-    }
-    if (effectiveMode === "worker") {
-        const tools = input.manifest.permissions?.tools;
-        const hasShell = tools?.shell ?? false;
-        const hasFileWrite = tools?.filesystem === "write";
-        const hasMcpSpawn = tools?.mcp === "spawn";
-        const contributedTools = input.manifest.contributes?.tools ?? [];
-        const toolShell = contributedTools.some((tool) => tool.capabilities?.shell);
-        const toolFileWrite = contributedTools.some((tool) => tool.capabilities?.filesystem === "write");
-        if (hasShell || toolShell || hasFileWrite || toolFileWrite || hasMcpSpawn) {
-            const unsupported = [];
-            if (hasShell || toolShell)
-                unsupported.push("shell");
-            if (hasFileWrite || toolFileWrite)
-                unsupported.push("file_write");
-            if (hasMcpSpawn)
-                unsupported.push("mcp_spawn");
-            results.push({
-                type: "warn",
-                message: `Worker mode does not fully support: ${unsupported.join(", ")}. Use process mode for these capabilities.`,
-            });
-        }
-    }
-    if (effectiveMode === "process" && !input.manifest.runtime?.resources) {
-        results.push({
-            type: "warn",
-            message: "Process mode used without resource limits. Specify runtime.resources to prevent resource exhaustion.",
-        });
-    }
-    return results;
+export function validateRuntimePolicy() {
+    return [
+        { type: "pass", message: "External plugins use the process runtime; built-ins may use the inProcess runtime." },
+    ];
 }

package/dist/uuid.d.ts

@@ -0,0 +1,10 @@
+export interface UUIDCrypto {
+    randomUUID?: () => string;
+    getRandomValues?: (array: Uint8Array) => Uint8Array;
+}
+export interface UUIDEnvironment {
+    crypto?: UUIDCrypto;
+    now?: () => number;
+    random?: () => number;
+}
+export declare function generateUUID(environment?: UUIDEnvironment): string;

package/dist/uuid.js

@@ -0,0 +1,30 @@
+let fallbackCounter = 0;
+export function generateUUID(environment) {
+    const webCrypto = environment ? environment.crypto : globalThis.crypto;
+    try {
+        if (typeof webCrypto?.randomUUID === "function")
+            return webCrypto.randomUUID();
+    }
+    catch {
+        // randomUUID may be exposed but blocked outside a secure context.
+    }
+    try {
+        if (typeof webCrypto?.getRandomValues === "function") {
+            const bytes = webCrypto.getRandomValues(new Uint8Array(16));
+            bytes[6] = (bytes[6] & 0x0f) | 0x40;
+            bytes[8] = (bytes[8] & 0x3f) | 0x80;
+            return formatUUID(bytes);
+        }
+    }
+    catch {
+        // Fall through for runtimes without a usable Web Crypto implementation.
+    }
+    fallbackCounter += 1;
+    const now = environment?.now?.() ?? Date.now();
+    const random = environment?.random?.() ?? Math.random();
+    return `${now.toString(36)}-${fallbackCounter.toString(36)}-${random.toString(36).slice(2)}`;
+}
+function formatUUID(bytes) {
+    const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+    return [hex.slice(0, 8), hex.slice(8, 12), hex.slice(12, 16), hex.slice(16, 20), hex.slice(20)].join("-");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ericsanchezok/synergy-util",
-  "version": "2.4.5",
+  "version": "3.0.1",
   "type": "module",
   "license": "MIT",
   "exports": {

package/dist/browser-protocol.d.ts

@@ -1,97 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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" };
-}