@ericsanchezok/synergy-plugin 2.4.3 → 2.4.5

package/dist/market.js

@@ -0,0 +1,65 @@
+export const OFFICIAL_GITHUB_PLUGIN_MARKETPLACE = {
+    registryRepo: "https://github.com/SII-Holos/synergy-plugins.git",
+    registryGithubRepo: "SII-Holos/synergy-plugins",
+    registryBaseBranch: "main",
+    registryBranchPrefix: "publish",
+};
+function encodeGitHubPath(value) {
+    return value
+        .split("/")
+        .filter((segment) => segment.length > 0)
+        .map(encodeURIComponent)
+        .join("/");
+}
+export function githubReleaseAssetUrl(input) {
+    const normalized = normalizeGitHubRepoUrl(input.repo);
+    if (!normalized)
+        return undefined;
+    return `${normalized}/releases/download/${encodeURIComponent(githubReleaseTag(input.version, input.tagTemplate))}/${encodeURIComponent(input.filename)}`;
+}
+export function githubReleaseTag(version, template = "v{version}") {
+    return template.replaceAll("{version}", version).replaceAll("{tag}", `v${version}`);
+}
+export function normalizeGitHubRepoUrl(input) {
+    if (!input)
+        return undefined;
+    const trimmed = input.trim();
+    const ssh = trimmed.match(/^git@github\.com:([^/]+\/[^/]+?)(?:\.git)?$/);
+    if (ssh)
+        return `https://github.com/${ssh[1]}`;
+    if (/^https:\/\/github\.com\/[^/]+\/[^/]+/.test(trimmed))
+        return trimmed.replace(/\.git$/, "");
+    return undefined;
+}
+export function githubRepoSlug(input) {
+    const normalized = normalizeGitHubRepoUrl(input);
+    const match = normalized?.match(/^https:\/\/github\.com\/([^/]+\/[^/]+?)(?:\/.*)?$/);
+    return match?.[1]?.replace(/\.git$/, "");
+}
+export function githubRawFileUrl(input) {
+    const slug = githubRepoSlug(input.repo);
+    if (!slug)
+        return undefined;
+    return `https://raw.githubusercontent.com/${slug}/${encodeGitHubPath(input.branch)}/${encodeGitHubPath(input.filepath)}`;
+}
+export function githubMarketplaceRegistryUrl(input = OFFICIAL_GITHUB_PLUGIN_MARKETPLACE) {
+    const url = githubRawFileUrl({
+        repo: input.registryRepo,
+        branch: input.registryBaseBranch,
+        filepath: "registry.json",
+    });
+    if (!url)
+        throw new Error(`Invalid GitHub plugin marketplace repo: ${input.registryRepo}`);
+    return url;
+}
+export const OFFICIAL_PLUGIN_REGISTRY_URL = githubMarketplaceRegistryUrl();
+export const DEFAULT_PLUGIN_MARKETPLACE_CONFIG = {
+    enabled: true,
+    registryUrl: OFFICIAL_PLUGIN_REGISTRY_URL,
+    includeLocalRegistry: true,
+    cacheTtlMs: 3_600_000,
+    offlineCache: true,
+    requestTimeoutMs: 10_000,
+    artifactDownloadTimeoutMs: 60_000,
+    cliRequestTimeoutMs: 120_000,
+};

package/dist/paths.d.ts

@@ -0,0 +1,5 @@
+export type SynergyPathEnv = Readonly<Record<string, string | undefined>>;
+export declare function synergyHome(env?: SynergyPathEnv): string;
+export declare function synergyRoot(env?: SynergyPathEnv): string;
+export declare function synergySigningKeysDir(env?: SynergyPathEnv): string;
+export declare function synergySigningKeyFile(env?: SynergyPathEnv): string;

package/dist/paths.js

@@ -0,0 +1,14 @@
+import os from "os";
+import path from "path";
+export function synergyHome(env = process.env) {
+    return env.SYNERGY_HOME || env.SYNERGY_TEST_HOME || os.homedir();
+}
+export function synergyRoot(env = process.env) {
+    return path.join(synergyHome(env), ".synergy");
+}
+export function synergySigningKeysDir(env = process.env) {
+    return path.join(synergyRoot(env), "keys");
+}
+export function synergySigningKeyFile(env = process.env) {
+    return path.join(synergySigningKeysDir(env), "signing-key.json");
+}

package/dist/permissions.d.ts

@@ -0,0 +1,185 @@
+import type { PluginManifest } from "./manifest.js";
+import type { BridgeMethodPolicy, RegistryPermissionItem, SynergyCapabilityCategory, SynergyCapabilityDefinition, SynergyCapabilityPermissionItem, SynergyCapabilityRisk, SynergyCapabilityRiskScope, SynergyCapabilitySeverity } from "@ericsanchezok/synergy-util/capability";
+import { bridgeMethodPolicy as sharedBridgeMethodPolicy, capabilityNonBypassable, hasPublicTools, permissionCategoryForKey, permissionCapability, publicToolNames, stablePluginJson } from "@ericsanchezok/synergy-util/capability";
+export type PluginRisk = SynergyCapabilityRisk;
+export type PluginRiskScope = SynergyCapabilityRiskScope;
+export declare const PLUGIN_PERMISSION_CATEGORIES: readonly ["tools", "files", "network", "data", "ui", "runtime", "hooks", "session", "browser", "identity", "communication", "platform"];
+export type PluginPermissionCategory = SynergyCapabilityCategory;
+export type PluginPermissionSeverity = SynergyCapabilitySeverity;
+export type PluginPermissionItem = SynergyCapabilityPermissionItem;
+export type PluginBridgeMethodPolicy = BridgeMethodPolicy;
+export type { RegistryPermissionItem, SynergyCapabilityDefinition };
+export type ManifestTool = NonNullable<NonNullable<PluginManifest["contributes"]>["tools"]>[number];
+export declare const CAPABILITY_DETAILS: Record<string, SynergyCapabilityDefinition>;
+export declare const 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", "config_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 PERMISSION_CAPABILITY: Record<string, string>;
+export declare const PLUGIN_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 { capabilityNonBypassable, hasPublicTools, permissionCapability, permissionCategoryForKey, publicToolNames, stablePluginJson, };
+export declare const pluginBridgeMethodPolicy: typeof sharedBridgeMethodPolicy;
+export declare function capabilityRisk(capability: string, manifest?: PluginManifest): PluginRisk;
+export declare function baseCapabilities(manifest: PluginManifest): string[];
+export declare function toolCapabilities(manifest: PluginManifest, tool: ManifestTool): string[];
+export declare function publicToolCapabilities(manifest: PluginManifest): string[];
+export declare function computeRisk(capabilities: string[], manifest?: PluginManifest): PluginRisk;
+export declare function capabilitiesForRiskScope(manifest: PluginManifest, scope: PluginRiskScope): string[];
+export declare function pluginRisk(manifest: PluginManifest, input: {
+    scope: PluginRiskScope;
+}): PluginRisk;
+export declare function toolRisk(manifest: PluginManifest, tool: ManifestTool): PluginRisk;
+export declare function permissionItems(manifest: PluginManifest, capabilities: string[]): PluginPermissionItem[];
+export declare function registryPermissionSummary(manifest: PluginManifest, capabilities: string[]): RegistryPermissionItem[];
+export declare function permissionsHashPayload(manifest: PluginManifest, 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[];
+            config?: boolean;
+        };
+        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: PluginManifest): PluginManifest;
+export declare function bridgeCapability(method: string): string | undefined;
+export declare const pluginBridgeMethodCapability: typeof bridgeCapability;

package/dist/permissions.js

@@ -0,0 +1,51 @@
+import { SYNERGY_CAPABILITY_CATEGORIES, SYNERGY_CAPABILITY_DETAILS, SYNERGY_PERMISSION_CAPABILITY, SYNERGY_PROFILE_CAPABILITIES, baseCapabilities as sharedBaseCapabilities, bridgeCapability as sharedBridgeCapability, bridgeMethodPolicy as sharedBridgeMethodPolicy, capabilitiesForRiskScope as sharedCapabilitiesForRiskScope, capabilityNonBypassable, capabilityRisk as sharedCapabilityRisk, computeRisk as sharedComputeRisk, hasPublicTools, manifestHashPayload as sharedManifestHashPayload, permissionCategoryForKey, permissionCapability, permissionItems as sharedPermissionItems, permissionsHashPayload as sharedPermissionsHashPayload, pluginRisk as sharedPluginRisk, publicToolCapabilities as sharedPublicToolCapabilities, publicToolNames, registryPermissionSummary as sharedRegistryPermissionSummary, stablePluginJson, toolCapabilities as sharedToolCapabilities, toolRisk as sharedToolRisk, SYNERGY_BRIDGE_METHOD_POLICY, } from "@ericsanchezok/synergy-util/capability";
+export const PLUGIN_PERMISSION_CATEGORIES = SYNERGY_CAPABILITY_CATEGORIES;
+export const CAPABILITY_DETAILS = SYNERGY_CAPABILITY_DETAILS;
+export const PROFILE_CAPABILITIES = SYNERGY_PROFILE_CAPABILITIES;
+export const PERMISSION_CAPABILITY = SYNERGY_PERMISSION_CAPABILITY;
+export const PLUGIN_BRIDGE_METHOD_POLICY = SYNERGY_BRIDGE_METHOD_POLICY;
+export { capabilityNonBypassable, hasPublicTools, permissionCapability, permissionCategoryForKey, publicToolNames, stablePluginJson, };
+export const pluginBridgeMethodPolicy = sharedBridgeMethodPolicy;
+function asCapabilityManifest(manifest) {
+    return manifest;
+}
+export function capabilityRisk(capability, manifest) {
+    return sharedCapabilityRisk(capability, manifest ? asCapabilityManifest(manifest) : undefined);
+}
+export function baseCapabilities(manifest) {
+    return sharedBaseCapabilities(asCapabilityManifest(manifest));
+}
+export function toolCapabilities(manifest, tool) {
+    return sharedToolCapabilities(asCapabilityManifest(manifest), tool);
+}
+export function publicToolCapabilities(manifest) {
+    return sharedPublicToolCapabilities(asCapabilityManifest(manifest));
+}
+export function computeRisk(capabilities, manifest) {
+    return sharedComputeRisk(capabilities, manifest ? asCapabilityManifest(manifest) : undefined);
+}
+export function capabilitiesForRiskScope(manifest, scope) {
+    return sharedCapabilitiesForRiskScope(asCapabilityManifest(manifest), scope);
+}
+export function pluginRisk(manifest, input) {
+    return sharedPluginRisk(asCapabilityManifest(manifest), input);
+}
+export function toolRisk(manifest, tool) {
+    return sharedToolRisk(asCapabilityManifest(manifest), tool);
+}
+export function permissionItems(manifest, capabilities) {
+    return sharedPermissionItems(asCapabilityManifest(manifest), capabilities);
+}
+export function registryPermissionSummary(manifest, capabilities) {
+    return sharedRegistryPermissionSummary(asCapabilityManifest(manifest), capabilities);
+}
+export function permissionsHashPayload(manifest, capabilities) {
+    return sharedPermissionsHashPayload(asCapabilityManifest(manifest), capabilities);
+}
+export function manifestHashPayload(manifest) {
+    return sharedManifestHashPayload(asCapabilityManifest(manifest));
+}
+export function bridgeCapability(method) {
+    return sharedBridgeCapability(method);
+}
+export const pluginBridgeMethodCapability = bridgeCapability;

package/dist/policy.d.ts

@@ -0,0 +1 @@
+export * from "@ericsanchezok/synergy-util/plugin-policy";

package/dist/policy.js

@@ -0,0 +1 @@
+export * from "@ericsanchezok/synergy-util/plugin-policy";

package/dist/spec.d.ts

@@ -0,0 +1,3 @@
+import type { PluginManifest } from "./manifest.js";
+export declare function entryCandidatesFromPluginDir(pluginDir: string, manifest: PluginManifest): string[];
+export declare function resolveEntryFromPluginDir(pluginDir: string, manifest: PluginManifest): string;

package/dist/spec.js

@@ -0,0 +1,31 @@
+import fs from "fs";
+import path from "path";
+function resolvePackageEntry(pluginDir) {
+    const pkgPath = path.join(pluginDir, "package.json");
+    if (!fs.existsSync(pkgPath))
+        return path.join(pluginDir, "index.ts");
+    try {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+        const exported = typeof pkg.exports === "string" ? pkg.exports : (pkg.exports?.["."]?.bun ?? pkg.exports?.["."]?.import);
+        const entry = exported ?? pkg.main ?? "index.ts";
+        return path.resolve(pluginDir, entry);
+    }
+    catch {
+        return path.join(pluginDir, "index.ts");
+    }
+}
+export function entryCandidatesFromPluginDir(pluginDir, manifest) {
+    return [
+        manifest.main ? path.resolve(pluginDir, manifest.main) : undefined,
+        path.join(pluginDir, "dist", "runtime", "index.js"),
+        path.join(pluginDir, "runtime", "index.js"),
+        resolvePackageEntry(pluginDir),
+        path.join(pluginDir, "src", "index.ts"),
+        path.join(pluginDir, "index.ts"),
+        path.join(pluginDir, "index.js"),
+    ].filter(Boolean);
+}
+export function resolveEntryFromPluginDir(pluginDir, manifest) {
+    const candidates = entryCandidatesFromPluginDir(pluginDir, manifest);
+    return candidates.find((candidate) => fs.existsSync(candidate)) ?? candidates[0];
+}

package/dist/tool.d.ts

@@ -1,6 +1,7 @@
 import { z } from "zod";
-import type { ToolDisplay } from "./display";
-export type { ToolDisplay, ToolMediaDisplay } from "./display";
+import type { ToolDisplay } from "./display.js";
+import type { BunShell } from "./shell.js";
+export type { ToolDisplay, ToolMediaDisplay } from "./display.js";
 export type ToolContext = {
     sessionID: string;
     messageID: string;
@@ -13,6 +14,8 @@ export type ToolContext = {
         patterns: string[];
         metadata?: Record<string, any>;
     }): Promise<void>;
+    /** Run shell commands through Synergy's current workspace shell boundary. */
+    $?: BunShell;
     /** Run a Synergy delegated subagent task from inside this tool. */
     task?: ToolTaskService;
     /** Invoke another visible/explicitly-allowed Synergy tool from inside this tool. */
@@ -76,14 +79,13 @@ export interface ToolInvokeService {
 }
 export type ToolResultMetadata = Record<string, any> & {
     display?: ToolDisplay;
-    primaryAttachmentIds?: string[];
 };
 export interface ToolResult {
     title?: string;
     output: string;
     metadata?: ToolResultMetadata;
     attachments?: Array<{
-        type: "file";
+        type: "attachment";
         id: string;
         sessionID: string;
         messageID: string;
@@ -91,6 +93,25 @@ export interface ToolResult {
         filename?: string;
         url: string;
         localPath?: string;
+        presentation?: {
+            hidden?: boolean;
+            renderer?: "image" | "video" | "audio" | "thumbnail" | "file";
+            size?: "original" | "small" | "medium" | "large";
+            crop?: boolean;
+        };
+        model?: {
+            mode: "summary";
+            summary?: string;
+        } | {
+            mode: "content";
+            text?: string;
+        } | {
+            mode: "provider-file";
+            summary?: string;
+        } | {
+            mode: "none";
+        };
+        metadata?: Record<string, any>;
     }>;
 }
 export type ToolExposure = {

package/dist/ui.d.ts

@@ -23,21 +23,32 @@ export interface PluginPanelProps {
     panelId: string;
     scopeId?: string;
 }
-export type PluginWorkspacePanel = Component<PluginPanelProps>;
-export type PluginGlobalPanel = Component<PluginPanelProps>;
+export interface PluginWorkbenchPanelTab {
+    id: string;
+    panelId: string;
+    resourceId?: string;
+    title?: string;
+    source?: string;
+}
+export interface PluginWorkbenchPanelProps extends PluginPanelProps {
+    tab: PluginWorkbenchPanelTab;
+    onRequestClose?: () => void;
+}
+export type PluginWorkbenchPanel = Component<PluginWorkbenchPanelProps>;
+export type PluginAppPanel = Component<PluginPanelProps>;
 export interface PluginSettingsProps {
     pluginId: string;
     values: Record<string, unknown>;
     onChange(values: Record<string, unknown>): void;
 }
 export type PluginSettingsSection = Component<PluginSettingsProps>;
-export type PluginChatSlot = "before-tools" | "after-tools" | "before-reasoning" | "after-reasoning";
-export interface PluginChatComponentProps {
-    slot: PluginChatSlot;
+export type PluginMessageSlotName = "before-tools" | "after-tools" | "before-reasoning" | "after-reasoning";
+export interface PluginMessageSlotProps {
+    slot: PluginMessageSlotName;
     sessionId?: string;
     messageId?: string;
 }
-export type PluginChatComponent = Component<PluginChatComponentProps>;
+export type PluginMessageSlot = Component<PluginMessageSlotProps>;
 export interface PluginCommandContext {
     pluginId: string;
     serverUrl: string;

package/dist/version.d.ts

@@ -0,0 +1,2 @@
+export declare const PLUGIN_PROTOCOL_MIN_SYNERGY_VERSION = "2.4.3";
+export declare const PLUGIN_PROTOCOL_MIN_SYNERGY_RANGE = ">=2.4.3";

package/dist/version.js

@@ -0,0 +1,2 @@
+export const PLUGIN_PROTOCOL_MIN_SYNERGY_VERSION = "2.4.3";
+export const PLUGIN_PROTOCOL_MIN_SYNERGY_RANGE = `>=${PLUGIN_PROTOCOL_MIN_SYNERGY_VERSION}`;

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@ericsanchezok/synergy-plugin",
-  "version": "2.4.3",
+  "version": "2.4.5",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -14,38 +14,73 @@
   },
   "scripts": {
     "typecheck": "tsgo --noEmit",
-    "build": "tsc"
+    "build": "bun run --cwd ../util build && rm -rf dist && tsc -p tsconfig.build.json"
   },
   "exports": {
     ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
     },
     "./tool": {
-      "import": "./dist/tool.js",
-      "types": "./dist/tool.d.ts"
+      "types": "./dist/tool.d.ts",
+      "import": "./dist/tool.js"
     },
     "./display": {
-      "import": "./dist/display.js",
-      "types": "./dist/display.d.ts"
+      "types": "./dist/display.d.ts",
+      "import": "./dist/display.js"
     },
     "./hooks": {
-      "import": "./dist/hooks.js",
-      "types": "./dist/hooks.d.ts"
+      "types": "./dist/hooks.d.ts",
+      "import": "./dist/hooks.js"
+    },
+    "./permissions": {
+      "types": "./dist/permissions.d.ts",
+      "import": "./dist/permissions.js"
+    },
+    "./ids": {
+      "types": "./dist/ids.d.ts",
+      "import": "./dist/ids.js"
+    },
+    "./policy": {
+      "types": "./dist/policy.d.ts",
+      "import": "./dist/policy.js"
+    },
+    "./paths": {
+      "types": "./dist/paths.d.ts",
+      "import": "./dist/paths.js"
+    },
+    "./artifact": {
+      "types": "./dist/artifact.d.ts",
+      "import": "./dist/artifact.js"
+    },
+    "./market": {
+      "types": "./dist/market.d.ts",
+      "import": "./dist/market.js"
+    },
+    "./spec": {
+      "types": "./dist/spec.d.ts",
+      "import": "./dist/spec.js"
+    },
+    "./version": {
+      "types": "./dist/version.d.ts",
+      "import": "./dist/version.js"
     },
     "./shell": {
-      "import": "./dist/shell.js",
-      "types": "./dist/shell.d.ts"
+      "types": "./dist/shell.d.ts",
+      "import": "./dist/shell.js"
     },
     "./ui": {
-      "import": "./dist/ui.js",
-      "types": "./dist/ui.d.ts"
+      "types": "./dist/ui.d.ts",
+      "import": "./dist/ui.js"
     }
   },
   "files": [
     "dist"
   ],
-  "dependencies": {},
+  "dependencies": {
+    "@ericsanchezok/synergy-sdk": "2.4.5",
+    "@ericsanchezok/synergy-util": "2.4.5"
+  },
   "peerDependencies": {
     "zod": ">=4.0.0"
   }