@kehto/services 0.7.0 → 0.9.1

package/dist/index.js

@@ -231,156 +231,6 @@ function createNotificationService(options) {
 
 // src/identity-service.ts
 var IDENTITY_SERVICE_VERSION = "1.0.0";
-var DECRYPT_ERROR_CODES = [
-  "class-forbidden",
-  "signer-denied",
-  "signer-unavailable",
-  "decrypt-failed",
-  "malformed-wrap",
-  "impersonation",
-  "unsupported-encryption",
-  "policy-denied"
-];
-var DECRYPT_ERROR_CODE_SET = new Set(DECRYPT_ERROR_CODES);
-function isDecryptErrorCode(value) {
-  return typeof value === "string" && DECRYPT_ERROR_CODE_SET.has(value);
-}
-function normalizeDecryptError(error) {
-  if (isDecryptErrorCode(error)) return error;
-  if (typeof error === "object" && error !== null) {
-    const candidate = error;
-    if (isDecryptErrorCode(candidate.code)) return candidate.code;
-    if (isDecryptErrorCode(candidate.error)) return candidate.error;
-    if (isDecryptErrorCode(candidate.message)) return candidate.message;
-  }
-  return "decrypt-failed";
-}
-function sendDecryptError(id, error, send) {
-  const result = {
-    type: "identity.decrypt.error",
-    id,
-    error
-  };
-  send(result);
-}
-function isStringArrayArray(value) {
-  return Array.isArray(value) && value.every(
-    (tag) => Array.isArray(tag) && tag.every((part) => typeof part === "string")
-  );
-}
-function isNostrEvent(value) {
-  const event = value;
-  return typeof event === "object" && event !== null && typeof event.id === "string" && typeof event.pubkey === "string" && typeof event.created_at === "number" && typeof event.kind === "number" && isStringArrayArray(event.tags) && typeof event.content === "string" && typeof event.sig === "string";
-}
-function isRumor(value) {
-  const rumor = value;
-  return typeof rumor === "object" && rumor !== null && typeof rumor.id === "string" && typeof rumor.pubkey === "string" && typeof rumor.created_at === "number" && typeof rumor.kind === "number" && isStringArrayArray(rumor.tags) && typeof rumor.content === "string";
-}
-function isGiftWrapDecryptResult(value) {
-  const result = value;
-  return typeof result === "object" && result !== null && isNostrEvent(result.seal) && isRumor(result.rumor);
-}
-function firstDecodedByte(content) {
-  const trimmed = content.trim();
-  if (trimmed.length === 0) return null;
-  const normalized = trimmed.replace(/-/g, "+").replace(/_/g, "/");
-  const padded = normalized.padEnd(Math.ceil(normalized.length / 4) * 4, "=");
-  try {
-    const decoded = atob(padded);
-    return decoded.length > 0 ? decoded.charCodeAt(0) : null;
-  } catch {
-    return null;
-  }
-}
-function detectEncryptionMode(event) {
-  if (event.kind === 4) return "nip04";
-  if (event.kind === 1059) return "nip17";
-  if (event.kind === 14 || firstDecodedByte(event.content) === 2) {
-    return "nip44-direct";
-  }
-  return null;
-}
-function rumorFromSignedEvent(event, content) {
-  return {
-    id: event.id,
-    pubkey: event.pubkey,
-    kind: event.kind,
-    tags: event.tags,
-    created_at: event.created_at,
-    content
-  };
-}
-async function handleDecrypt(id, message, send, options) {
-  const event = message.event;
-  if (!isNostrEvent(event)) {
-    sendDecryptError(id, "malformed-wrap", send);
-    return;
-  }
-  const verifyEvent = options.verifyEvent ?? (() => true);
-  let verified;
-  try {
-    verified = await Promise.resolve(verifyEvent(event));
-  } catch {
-    sendDecryptError(id, "malformed-wrap", send);
-    return;
-  }
-  if (!verified) {
-    sendDecryptError(id, "malformed-wrap", send);
-    return;
-  }
-  const mode = detectEncryptionMode(event);
-  if (!mode) {
-    sendDecryptError(id, "unsupported-encryption", send);
-    return;
-  }
-  const decryptor = options.getDecryptor?.() ?? null;
-  if (!decryptor) {
-    sendDecryptError(id, "signer-unavailable", send);
-    return;
-  }
-  try {
-    if (mode === "nip04") {
-      const plaintext = await decryptor.nip04Decrypt(event.pubkey, event.content);
-      const result2 = {
-        type: "identity.decrypt.result",
-        id,
-        rumor: rumorFromSignedEvent(event, plaintext),
-        sender: event.pubkey
-      };
-      send(result2);
-      return;
-    }
-    if (mode === "nip44-direct") {
-      const plaintext = await decryptor.nip44Decrypt(event.pubkey, event.content);
-      const result2 = {
-        type: "identity.decrypt.result",
-        id,
-        rumor: rumorFromSignedEvent(event, plaintext),
-        sender: event.pubkey
-      };
-      send(result2);
-      return;
-    }
-    const unwrapped = await decryptor.unwrapGiftWrap(event);
-    if (!isGiftWrapDecryptResult(unwrapped)) {
-      sendDecryptError(id, "malformed-wrap", send);
-      return;
-    }
-    if (unwrapped.seal.pubkey !== unwrapped.rumor.pubkey) {
-      sendDecryptError(id, "impersonation", send);
-      return;
-    }
-    const result = {
-      type: "identity.decrypt.result",
-      id,
-      rumor: unwrapped.rumor,
-      sender: unwrapped.seal.pubkey
-    };
-    send(result);
-  } catch (error) {
-    sendDecryptError(id, normalizeDecryptError(error), send);
-  }
-}
 function createIdentityService(options) {
   return {
     descriptor: {
@@ -496,10 +346,6 @@ function createIdentityService(options) {
           send(result);
           return;
         }
-        case "identity.decrypt": {
-          void handleDecrypt(id, message, send, options);
-          return;
-        }
         default:
           sendError(message.type, `Unknown identity method: ${message.type}`);
       }
@@ -2550,6 +2396,227 @@ function toErrorMessage3(err) {
   return "upload failed";
 }
 
+// src/intent-service.ts
+var INTENT_SERVICE_VERSION = "1.0.0";
+var INTENT_DESCRIPTOR = {
+  name: "intent",
+  version: INTENT_SERVICE_VERSION,
+  description: "NAP-INTENT archetype intent dispatch \u2014 invoke/available/handlers"
+};
+function toErrorMessage4(err) {
+  if (err instanceof Error) return err.message;
+  if (typeof err === "string") return err;
+  return "intent request failed";
+}
+function createIntentService(options) {
+  if (!options || typeof options.resolver !== "object" || options.resolver === null) {
+    throw new Error("createIntentService: options.resolver is required");
+  }
+  const { resolver } = options;
+  const windows = /* @__PURE__ */ new Map();
+  resolver.onChanged?.((availability) => {
+    for (const send of windows.values()) {
+      send({ type: "intent.changed", availability });
+    }
+  });
+  function settle(call, send, resultType, id, onValue) {
+    let pending;
+    try {
+      pending = Promise.resolve(call());
+    } catch (err) {
+      send({ type: resultType, id, error: toErrorMessage4(err) });
+      return;
+    }
+    pending.then((value) => send(onValue(value))).catch((err) => send({ type: resultType, id, error: toErrorMessage4(err) }));
+  }
+  function handleInvoke(windowId, msg, send) {
+    const m = msg;
+    const id = m.id ?? "";
+    const request = m.request;
+    if (!request || typeof request !== "object" || typeof request.archetype !== "string" || request.archetype.length === 0) {
+      send({ type: "intent.invoke.result", id, error: "invalid request" });
+      return;
+    }
+    settle(
+      () => resolver.invoke(request, { windowId }),
+      send,
+      "intent.invoke.result",
+      id,
+      (result) => ({ type: "intent.invoke.result", id, result })
+    );
+  }
+  function handleAvailable(msg, send) {
+    const m = msg;
+    const id = m.id ?? "";
+    if (typeof m.archetype !== "string" || m.archetype.length === 0) {
+      send({ type: "intent.available.result", id, error: "invalid archetype" });
+      return;
+    }
+    const archetype = m.archetype;
+    settle(
+      () => resolver.available(archetype),
+      send,
+      "intent.available.result",
+      id,
+      (availability) => ({ type: "intent.available.result", id, availability })
+    );
+  }
+  function handleHandlers(msg, send) {
+    const m = msg;
+    const id = m.id ?? "";
+    settle(
+      () => resolver.handlers(),
+      send,
+      "intent.handlers.result",
+      id,
+      (handlers) => ({ type: "intent.handlers.result", id, handlers })
+    );
+  }
+  return {
+    descriptor: INTENT_DESCRIPTOR,
+    handleMessage(windowId, message, send) {
+      windows.set(windowId, send);
+      switch (message.type) {
+        case "intent.invoke":
+          handleInvoke(windowId, message, send);
+          return;
+        case "intent.available":
+          handleAvailable(message, send);
+          return;
+        case "intent.handlers":
+          handleHandlers(message, send);
+          return;
+        default:
+          return;
+      }
+    },
+    onWindowDestroyed(windowId) {
+      windows.delete(windowId);
+    }
+  };
+}
+
+// src/catalog-intent-resolver.ts
+function candidatesFor(catalog, archetype, defaultHandler) {
+  const candidates = [];
+  for (const entry of catalog) {
+    const support = entry.archetypes[archetype];
+    if (!support) continue;
+    candidates.push({
+      dTag: entry.dTag,
+      ...entry.title === void 0 ? {} : { title: entry.title },
+      actions: support.actions,
+      protocols: support.protocols,
+      ...entry.dTag === defaultHandler ? { isDefault: true } : {}
+    });
+  }
+  return candidates;
+}
+function fail(archetype, action, error) {
+  return { ok: false, archetype, action, handled: false, error };
+}
+function createCatalogIntentResolver(options) {
+  if (!options || typeof options.loadCatalog !== "function") {
+    throw new Error("createCatalogIntentResolver: options.loadCatalog is required");
+  }
+  if (!options.windows || typeof options.windows.open !== "function") {
+    throw new Error("createCatalogIntentResolver: options.windows is required");
+  }
+  const { loadCatalog, windows, getDefaultHandler, chooseHandler, defaultProtocol } = options;
+  const listeners = /* @__PURE__ */ new Set();
+  async function availabilityFor(archetype) {
+    const catalog = await loadCatalog();
+    const def = getDefaultHandler?.(archetype);
+    const candidates = candidatesFor(catalog, archetype, def);
+    return {
+      archetype,
+      available: candidates.length > 0,
+      candidates,
+      hasDefault: def !== void 0 && candidates.some((c) => c.dTag === def)
+    };
+  }
+  async function pickHandler(archetype, candidates, preference, callerWindowId) {
+    if (typeof preference === "string" && preference !== "default" && preference !== "choose") {
+      return preference;
+    }
+    if (preference === "choose") {
+      const picked = await chooseHandler?.(archetype, candidates, callerWindowId);
+      return picked ?? null;
+    }
+    const def = getDefaultHandler?.(archetype);
+    if (def !== void 0 && candidates.some((c) => c.dTag === def)) return def;
+    if (candidates.length === 1) return candidates[0].dTag;
+    if (chooseHandler) {
+      const picked = await chooseHandler(archetype, candidates, callerWindowId);
+      return picked ?? null;
+    }
+    return candidates[0].dTag;
+  }
+  async function invoke(request, context) {
+    const archetype = request.archetype;
+    const action = request.action ?? "open";
+    const catalog = await loadCatalog();
+    const candidates = candidatesFor(catalog, archetype, getDefaultHandler?.(archetype));
+    if (candidates.length === 0) return fail(archetype, action, "no handler");
+    const pickedDTag = await pickHandler(archetype, candidates, request.handler, context.windowId);
+    if (pickedDTag === null) return fail(archetype, action, "user cancelled");
+    const handler = candidates.find((c) => c.dTag === pickedDTag);
+    if (!handler) return fail(archetype, action, "no handler");
+    if (!handler.actions.includes(action)) return fail(archetype, action, "unsupported action");
+    const protocol = request.protocol ?? defaultProtocol?.(archetype) ?? handler.protocols[0];
+    if (protocol !== void 0 && handler.protocols.length > 0 && !handler.protocols.includes(protocol)) {
+      return fail(archetype, action, "unsupported protocol");
+    }
+    let windowId;
+    try {
+      const opened = await windows.open({
+        dTag: handler.dTag,
+        archetype,
+        action,
+        ...protocol === void 0 ? {} : { protocol },
+        ...request.payload === void 0 ? {} : { payload: request.payload },
+        ...request.behavior === void 0 ? {} : { behavior: request.behavior },
+        callerWindowId: context.windowId
+      });
+      windowId = opened.windowId;
+    } catch {
+      return fail(archetype, action, "invoke failed");
+    }
+    return {
+      ok: true,
+      archetype,
+      action,
+      handled: true,
+      handler: handler.dTag,
+      windowId,
+      ...protocol === void 0 ? {} : { protocol }
+    };
+  }
+  async function handlers() {
+    const catalog = await loadCatalog();
+    const archetypes = /* @__PURE__ */ new Set();
+    for (const entry of catalog) {
+      for (const slug of Object.keys(entry.archetypes)) archetypes.add(slug);
+    }
+    return Promise.all([...archetypes].map((a) => availabilityFor(a)));
+  }
+  return {
+    invoke,
+    available: availabilityFor,
+    handlers,
+    onChanged(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    notifyChanged(archetype) {
+      if (listeners.size === 0) return;
+      void availabilityFor(archetype).then((availability) => {
+        for (const listener of listeners) listener(availability);
+      });
+    }
+  };
+}
+
 // src/cvm-service.ts
 var CVM_SERVICE_VERSION = "1.0.0";
 var CVM_DESCRIPTOR = {
@@ -2592,7 +2659,7 @@ function createCvmService(options) {
     const m = msg;
     const id = m.id ?? "";
     void transport.discover(m.query).then((servers) => send({ type: "cvm.discover.result", id, servers })).catch(
-      (err) => send({ type: "cvm.discover.result", id, servers: [], error: toErrorMessage4(err) })
+      (err) => send({ type: "cvm.discover.result", id, servers: [], error: toErrorMessage5(err) })
     );
   }
   function handleRequest(windowId, msg, send) {
@@ -2608,7 +2675,7 @@ function createCvmService(options) {
     }
     openSession(windowId, m.server, send);
     void transport.request(m.server, m.message, m.options).then((message) => send({ type: "cvm.request.result", id, message })).catch(
-      (err) => send({ type: "cvm.request.result", id, error: toErrorMessage4(err) })
+      (err) => send({ type: "cvm.request.result", id, error: toErrorMessage5(err) })
     );
   }
   function handleClose(windowId, msg, send) {
@@ -2619,7 +2686,7 @@ function createCvmService(options) {
       return;
     }
     closeSession(windowId, m.server.pubkey);
-    void transport.close(m.server).then(() => send({ type: "cvm.close.result", id })).catch((err) => send({ type: "cvm.close.result", id, error: toErrorMessage4(err) }));
+    void transport.close(m.server).then(() => send({ type: "cvm.close.result", id })).catch((err) => send({ type: "cvm.close.result", id, error: toErrorMessage5(err) }));
   }
   return {
     descriptor: CVM_DESCRIPTOR,
@@ -2650,7 +2717,7 @@ function createCvmService(options) {
     }
   };
 }
-function toErrorMessage4(err) {
+function toErrorMessage5(err) {
   if (err instanceof Error) return err.message;
   if (typeof err === "string") return err;
   return "cvm request failed";
@@ -2659,11 +2726,13 @@ export {
   createAudioService,
   createBrowserMediaBridge,
   createCacheService,
+  createCatalogIntentResolver,
   createConfigService,
   createCoordinatedRelay,
   createCvmService,
   createHttpUploader,
   createIdentityService,
+  createIntentService,
   createKeysService,
   createMediaService,
   createNotificationService,