@kehto/services 0.6.0 → 0.8.0

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}`);
       }
@@ -2278,6 +2124,278 @@ function normalizePublishResult(res, relayUrls) {
   return out;
 }
 
+// src/upload-service.ts
+var UPLOAD_SERVICE_VERSION = "1.0.0";
+var UPLOAD_DESCRIPTOR = {
+  name: "upload",
+  version: UPLOAD_SERVICE_VERSION,
+  description: "NAP-UPLOAD shell-mediated file/blob upload \u2014 upload/status with progress pushes"
+};
+function createUploadService(options) {
+  if (!options || typeof options.uploader !== "object" || options.uploader === null) {
+    throw new Error("createUploadService: options.uploader is required");
+  }
+  const { uploader } = options;
+  const generateId2 = options.generateId ?? (() => crypto.randomUUID());
+  const now = options.now ?? (() => Date.now());
+  const entries = /* @__PURE__ */ new Map();
+  function handleUpload(windowId, msg, send) {
+    const m = msg;
+    const id = m.id ?? "";
+    const request = m.request;
+    if (!request || typeof request !== "object" || request.data == null) {
+      send({ type: "upload.upload.result", id, error: "invalid request" });
+      return;
+    }
+    const uploadId = generateId2();
+    const key = `${windowId}:${uploadId}`;
+    entries.set(key, { uploadId });
+    const ctx = {
+      uploadId,
+      windowId,
+      onStatus: (status) => {
+        const stamped = { ...status, uploadId, updatedAt: status.updatedAt || now() };
+        const entry = entries.get(key);
+        if (entry) entry.status = stamped;
+        send({ type: "upload.status.changed", status: stamped });
+      }
+    };
+    void uploader.upload(request, ctx).then((result) => {
+      const stamped = { ...result, uploadId };
+      const entry = entries.get(key);
+      if (entry) entry.status = { ...stamped, updatedAt: now() };
+      send({ type: "upload.upload.result", id, result: stamped });
+    }).catch((err) => {
+      entries.delete(key);
+      send({ type: "upload.upload.result", id, error: toErrorMessage2(err) });
+    });
+  }
+  function handleStatus(windowId, msg, send) {
+    const m = msg;
+    const id = m.id ?? "";
+    const uploadId = m.uploadId;
+    if (typeof uploadId !== "string" || uploadId.length === 0) {
+      send({ type: "upload.status.result", id, error: "invalid uploadId" });
+      return;
+    }
+    const tracked = entries.get(`${windowId}:${uploadId}`)?.status;
+    if (tracked) {
+      send({ type: "upload.status.result", id, status: tracked });
+      return;
+    }
+    if (uploader.status) {
+      void uploader.status(uploadId).then(
+        (status) => send(
+          status ? { type: "upload.status.result", id, status } : { type: "upload.status.result", id, error: "unknown upload" }
+        )
+      ).catch(
+        (err) => send({ type: "upload.status.result", id, error: toErrorMessage2(err) })
+      );
+      return;
+    }
+    send({ type: "upload.status.result", id, error: "unknown upload" });
+  }
+  return {
+    descriptor: UPLOAD_DESCRIPTOR,
+    handleMessage(windowId, message, send) {
+      switch (message.type) {
+        case "upload.upload":
+          handleUpload(windowId, message, send);
+          return;
+        case "upload.status":
+          handleStatus(windowId, message, send);
+          return;
+        default:
+          return;
+      }
+    },
+    onWindowDestroyed(windowId) {
+      const prefix = `${windowId}:`;
+      for (const [key, entry] of entries) {
+        if (key.startsWith(prefix)) {
+          uploader.cancel?.(entry.uploadId);
+          entries.delete(key);
+        }
+      }
+    }
+  };
+}
+function toErrorMessage2(err) {
+  if (err instanceof Error) return err.message;
+  if (typeof err === "string") return err;
+  return "upload request failed";
+}
+
+// src/http-uploader.ts
+var KIND_NIP98 = 27235;
+var KIND_BLOSSOM_AUTH = 24242;
+var BLOSSOM_AUTH_TTL_S = 3600;
+function createHttpUploader(options) {
+  if (!options || typeof options.signEvent !== "function") {
+    throw new Error("createHttpUploader: options.signEvent is required");
+  }
+  const rails = options.rails ?? {};
+  const signEvent = options.signEvent;
+  const fetchFn = options.fetch ?? fetch;
+  const digest = options.digestSha256 ?? defaultDigestSha256;
+  const nowS = options.now ?? (() => Math.floor(Date.now() / 1e3));
+  const defaultRail = options.defaultRail ?? firstConfiguredRail(rails);
+  async function upload(request, ctx) {
+    const rail = request.rail ?? defaultRail;
+    const config = rail === "nip96" ? rails.nip96 : rail === "blossom" ? rails.blossom : void 0;
+    if (rail !== "nip96" && rail !== "blossom") {
+      return failed(ctx.uploadId, rail ?? "unknown", "unsupported rail");
+    }
+    const server = config?.servers?.[0];
+    if (!server) {
+      return failed(ctx.uploadId, rail, "no server configured");
+    }
+    const bytes = await toBytes(request.data);
+    const sha256 = await digest(bytes);
+    try {
+      return rail === "nip96" ? await uploadNip96({ request, ctx, server, bytes, sha256, signEvent, fetchFn, nowS }) : await uploadBlossom({ request, ctx, server, bytes, sha256, signEvent, fetchFn, nowS });
+    } catch (err) {
+      return failed(ctx.uploadId, rail, toErrorMessage3(err), sha256);
+    }
+  }
+  return { upload };
+}
+async function uploadNip96(args) {
+  const { request, ctx, server, bytes, sha256, signEvent, fetchFn, nowS } = args;
+  const auth = await signEvent({
+    kind: KIND_NIP98,
+    created_at: nowS(),
+    content: "",
+    tags: [
+      ["u", server],
+      ["method", "POST"],
+      ["payload", sha256]
+    ]
+  });
+  const form = new FormData();
+  form.append("file", new Blob([bytesToArrayBuffer(bytes)], { type: request.mimeType }), request.filename ?? "file");
+  if (request.caption !== void 0) form.append("caption", request.caption);
+  if (request.mimeType !== void 0) form.append("content_type", request.mimeType);
+  if (request.noTransform) form.append("no_transform", "true");
+  const res = await fetchFn(server, {
+    method: "POST",
+    headers: { Authorization: nostrAuthHeader(auth) },
+    body: form
+  });
+  if (!res.ok) {
+    return failed(ctx.uploadId, "nip96", `server rejected (HTTP ${res.status})`, sha256);
+  }
+  const body = await res.json();
+  if (body.status === "error") {
+    return failed(ctx.uploadId, "nip96", body.message ?? "upload failed", sha256);
+  }
+  const tags = body.nip94_event?.tags ?? [];
+  return fromNip94Tags(ctx.uploadId, "nip96", tags, bytes.byteLength, sha256);
+}
+function fromNip94Tags(uploadId, rail, tags, fallbackSize, fallbackSha) {
+  const get = (name) => tags.find((t) => t[0] === name)?.[1];
+  const url = get("url");
+  const result = {
+    ok: Boolean(url),
+    uploadId,
+    status: url ? "complete" : "failed",
+    rail,
+    sha256: get("x") ?? fallbackSha,
+    nip94: tags
+  };
+  if (url) result.url = url;
+  const ox = get("ox");
+  if (ox) result.originalSha256 = ox;
+  const size = get("size");
+  result.size = size ? Number(size) : fallbackSize;
+  const m = get("m");
+  if (m) result.mimeType = m;
+  const dim = parseDimensions(get("dim"));
+  if (dim) result.dimensions = dim;
+  const blurhash = get("blurhash");
+  if (blurhash) result.blurhash = blurhash;
+  if (!url) result.error = "server returned no url";
+  return result;
+}
+async function uploadBlossom(args) {
+  const { request, ctx, server, bytes, sha256, signEvent, fetchFn, nowS } = args;
+  const auth = await signEvent({
+    kind: KIND_BLOSSOM_AUTH,
+    created_at: nowS(),
+    content: `Upload ${request.filename ?? "file"}`,
+    tags: [
+      ["t", "upload"],
+      ["x", sha256],
+      ["expiration", String(nowS() + BLOSSOM_AUTH_TTL_S)]
+    ]
+  });
+  const endpoint = `${trimTrailingSlash(server)}/upload`;
+  const headers = { Authorization: nostrAuthHeader(auth) };
+  if (request.mimeType) headers["Content-Type"] = request.mimeType;
+  const res = await fetchFn(endpoint, {
+    method: "PUT",
+    headers,
+    body: bytesToArrayBuffer(bytes)
+  });
+  if (!res.ok) {
+    return failed(ctx.uploadId, "blossom", `server rejected (HTTP ${res.status})`, sha256);
+  }
+  const blob = await res.json();
+  if (!blob.url) {
+    return failed(ctx.uploadId, "blossom", "server returned no url", sha256);
+  }
+  const result = {
+    ok: true,
+    uploadId: ctx.uploadId,
+    status: "complete",
+    rail: "blossom",
+    url: blob.url,
+    sha256: blob.sha256 ?? sha256,
+    size: blob.size ?? bytes.byteLength
+  };
+  if (blob.type) result.mimeType = blob.type;
+  return result;
+}
+function failed(uploadId, rail, error, sha256) {
+  return { ok: false, uploadId, status: "failed", rail, error, ...sha256 ? { sha256 } : {} };
+}
+function firstConfiguredRail(rails) {
+  if (rails.nip96?.servers?.length) return "nip96";
+  if (rails.blossom?.servers?.length) return "blossom";
+  return void 0;
+}
+function nostrAuthHeader(event) {
+  return `Nostr ${base64Utf8(JSON.stringify(event))}`;
+}
+function base64Utf8(s) {
+  return btoa(String.fromCharCode(...new TextEncoder().encode(s)));
+}
+function parseDimensions(dim) {
+  if (!dim) return void 0;
+  const m = /^(\d+)x(\d+)$/.exec(dim);
+  if (!m) return void 0;
+  return { width: Number(m[1]), height: Number(m[2]) };
+}
+async function toBytes(data) {
+  if (data instanceof ArrayBuffer) return new Uint8Array(data);
+  return new Uint8Array(await data.arrayBuffer());
+}
+function bytesToArrayBuffer(bytes) {
+  return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+}
+function trimTrailingSlash(url) {
+  return url.endsWith("/") ? url.slice(0, -1) : url;
+}
+async function defaultDigestSha256(bytes) {
+  const buf = await crypto.subtle.digest("SHA-256", bytesToArrayBuffer(bytes));
+  return Array.from(new Uint8Array(buf)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function toErrorMessage3(err) {
+  if (err instanceof Error) return err.message;
+  if (typeof err === "string") return err;
+  return "upload failed";
+}
+
 // src/cvm-service.ts
 var CVM_SERVICE_VERSION = "1.0.0";
 var CVM_DESCRIPTOR = {
@@ -2320,7 +2438,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: toErrorMessage2(err) })
+      (err) => send({ type: "cvm.discover.result", id, servers: [], error: toErrorMessage4(err) })
     );
   }
   function handleRequest(windowId, msg, send) {
@@ -2336,7 +2454,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: toErrorMessage2(err) })
+      (err) => send({ type: "cvm.request.result", id, error: toErrorMessage4(err) })
     );
   }
   function handleClose(windowId, msg, send) {
@@ -2347,7 +2465,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: toErrorMessage2(err) }));
+    void transport.close(m.server).then(() => send({ type: "cvm.close.result", id })).catch((err) => send({ type: "cvm.close.result", id, error: toErrorMessage4(err) }));
   }
   return {
     descriptor: CVM_DESCRIPTOR,
@@ -2378,7 +2496,7 @@ function createCvmService(options) {
     }
   };
 }
-function toErrorMessage2(err) {
+function toErrorMessage4(err) {
   if (err instanceof Error) return err.message;
   if (typeof err === "string") return err;
   return "cvm request failed";
@@ -2390,6 +2508,7 @@ export {
   createConfigService,
   createCoordinatedRelay,
   createCvmService,
+  createHttpUploader,
   createIdentityService,
   createKeysService,
   createMediaService,
@@ -2399,6 +2518,7 @@ export {
   createRelayPoolOutboxRouter,
   createRelayPoolService,
   createResourceService,
-  createThemeService
+  createThemeService,
+  createUploadService
 };
 //# sourceMappingURL=index.js.map