@peers-app/peers-ui 0.22.0 → 0.23.0

package/src/screens/tools/tool-access-ipc.ts

@@ -0,0 +1,88 @@
+import {
+  createContractConsumer,
+  getHostContractTransport,
+  getToolAccessControlContractDefinition,
+  type IContractTransport,
+  type IToolAccessControlConsumer,
+  subscribeHostContractTransport,
+  waitForHostContractTransport,
+} from "@peers-app/peers-sdk";
+
+const HOST_TRANSPORT_TIMEOUT_MS = 10_000;
+
+type CachedConsumer = {
+  transport: IContractTransport;
+  consumer: IToolAccessControlConsumer;
+};
+
+const cachedByContext = new Map<string, CachedConsumer>();
+const pendingByContext = new Map<string, Promise<IToolAccessControlConsumer>>();
+
+function disposeCachedConsumers(): void {
+  for (const cached of cachedByContext.values()) {
+    cached.consumer.dispose();
+  }
+  cachedByContext.clear();
+}
+
+subscribeHostContractTransport(
+  (transport) => {
+    if ([...cachedByContext.values()].some((cached) => cached.transport !== transport)) {
+      disposeCachedConsumers();
+      pendingByContext.clear();
+    }
+  },
+  { emitCurrent: false },
+);
+
+async function loadConsumer(
+  transport: IContractTransport,
+  dataContextId: string,
+): Promise<IToolAccessControlConsumer> {
+  cachedByContext.get(dataContextId)?.consumer.dispose();
+  cachedByContext.delete(dataContextId);
+  const consumer = createContractConsumer(getToolAccessControlContractDefinition(), transport, {
+    dataContextId,
+  }) as unknown as IToolAccessControlConsumer;
+  try {
+    await consumer.loadingPromise;
+    if (getHostContractTransport() !== transport) {
+      consumer.dispose();
+      pendingByContext.delete(dataContextId);
+      return getToolAccessControlConsumer(dataContextId);
+    }
+    cachedByContext.set(dataContextId, { transport, consumer });
+    return consumer;
+  } catch (error) {
+    consumer.dispose();
+    throw error;
+  }
+}
+
+/**
+ * Return a typed local-host consumer for Tool Access Control in `dataContextId`.
+ */
+export async function getToolAccessControlConsumer(
+  dataContextId: string,
+): Promise<IToolAccessControlConsumer> {
+  const transport =
+    getHostContractTransport() ??
+    (await waitForHostContractTransport({ timeoutMs: HOST_TRANSPORT_TIMEOUT_MS }));
+  const cached = cachedByContext.get(dataContextId);
+  if (cached?.transport === transport) {
+    return cached.consumer;
+  }
+  const pending = pendingByContext.get(dataContextId);
+  if (pending) {
+    return pending;
+  }
+  const loadPromise = loadConsumer(transport, dataContextId);
+  pendingByContext.set(dataContextId, loadPromise);
+  try {
+    return await loadPromise;
+  } finally {
+    if (pendingByContext.get(dataContextId) === loadPromise) {
+      pendingByContext.delete(dataContextId);
+    }
+  }
+}

package/src/screens/tools/tool-info.tsx

@@ -1,9 +1,11 @@
 import { type IDoc, type ITool, observable } from "@peers-app/peers-sdk";
 import { useEffect, useState } from "react";
+import { AccessLevelField } from "../../components/access-level-field";
 import { Checkbox } from "../../components/checkbox";
 import { Input } from "../../components/input";
 import { MarkdownEditorInline } from "../../components/markdown-editor/editor-inline";
 
+/** Info tab for a tool, including its required access level. */
 export const ToolInfo = (props: { tool: IDoc<ITool> }) => {
   const { tool } = props;
 
@@ -40,6 +42,8 @@ export const ToolInfo = (props: { tool: IDoc<ITool> }) => {
         title="Tool name"
       />
 
+      <AccessLevelField value={tool.qs.accessLevel} />
+
       <div>
         <label className="form-label small mt-2 me-2">Is Assistant Runner:</label>
         <Checkbox className="form-check-input mt-2" checked={tool.qs.isAssistantRunner} />