@prismer/sdk 1.7.3 → 1.8.0

package/dist/index.js

@@ -30,9 +30,11 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  AIPIdentity: () => import_aip_sdk.AIPIdentity,
   AccountClient: () => AccountClient,
   AttachmentQueue: () => AttachmentQueue,
   BindingsClient: () => BindingsClient,
+  CommunityHub: () => CommunityHub,
   ContactsClient: () => ContactsClient,
   ConversationsClient: () => ConversationsClient,
   CreditsClient: () => CreditsClient,
@@ -48,6 +50,7 @@ __export(index_exports, {
   IMRealtimeClient: () => IMRealtimeClient,
   IdentityClient: () => IdentityClient,
   IndexedDBStorage: () => IndexedDBStorage,
+  KnowledgeLinkClient: () => KnowledgeLinkClient,
   MemoryClient: () => MemoryClient,
   MemoryStorage: () => MemoryStorage,
   MessagesClient: () => MessagesClient,
@@ -70,7 +73,9 @@ __export(index_exports, {
   encryptContext: () => encryptContext,
   encryptFile: () => encryptFile,
   encryptForSend: () => encryptForSend,
-  extractSignals: () => extractSignals
+  extractSignals: () => extractSignals,
+  guessMimeType: () => guessMimeType,
+  safeSlug: () => safeSlug
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -542,7 +547,11 @@ var WRITE_PATTERNS = [
   { method: "POST", pattern: /\/api\/im\/(messages|direct|groups)\//, opType: "message.send" },
   { method: "PATCH", pattern: /\/api\/im\/messages\//, opType: "message.edit" },
   { method: "DELETE", pattern: /\/api\/im\/messages\//, opType: "message.delete" },
-  { method: "POST", pattern: /\/api\/im\/conversations\/[^/]+\/read/, opType: "conversation.read" }
+  { method: "POST", pattern: /\/api\/im\/conversations\/[^/]+\/read/, opType: "conversation.read" },
+  // v1.8.0 Community — queued when offline-first IM is enabled
+  { method: "POST", pattern: /\/api\/im\/community\/posts$/, opType: "community_post" },
+  { method: "POST", pattern: /\/api\/im\/community\/posts\/[^/]+\/comments$/, opType: "community_comment" },
+  { method: "POST", pattern: /\/api\/im\/community\/vote$/, opType: "community_vote" }
 ];
 function matchWriteOp(method, path) {
   for (const { method: m, pattern, opType } of WRITE_PATTERNS) {
@@ -1274,6 +1283,277 @@ var AttachmentQueue = class {
   }
 };
 
+// src/community-hub.ts
+var CommunityHub = class {
+  constructor(_r, config) {
+    this._r = _r;
+    this.feedCache = /* @__PURE__ */ new Map();
+    this.statsCache = null;
+    this.notifCountCache = null;
+    this.notifCountTTL = 15e3;
+    this.wsUnsubs = [];
+    this.feedTTL = config?.feedTTLMs ?? 3e5;
+    this.statsTTL = config?.statsTTLMs ?? 6e5;
+  }
+  /** Invalidate cached feeds/stats (e.g. after you posted). */
+  invalidateCache(boardId) {
+    if (boardId) this.feedCache.delete(boardId);
+    else this.feedCache.clear();
+    this.statsCache = null;
+    this.notifCountCache = null;
+  }
+  /**
+   * Subscribe to community.* WebSocket events; updates local notification count hint and invalidates feed.
+   */
+  attachRealtime(ws) {
+    const onReply = () => {
+      this.notifCountCache = null;
+      this.feedCache.clear();
+    };
+    const types = [
+      "community.reply",
+      "community.vote",
+      "community.answer.accepted",
+      "community.mention"
+    ];
+    for (const t of types) {
+      ws.on(t, onReply);
+      this.wsUnsubs.push(() => ws.off(t, onReply));
+    }
+  }
+  detachRealtime() {
+    for (const u of this.wsUnsubs) u();
+    this.wsUnsubs = [];
+  }
+  // ─── Intent (cached reads) ─────────────────────────────────
+  async feed(opts) {
+    const key = opts?.boardId ?? "__all__";
+    const hit = this.feedCache.get(key);
+    if (hit && Date.now() - hit.at < this.feedTTL) {
+      return { ok: true, data: hit.payload };
+    }
+    const res = await this.listPosts({
+      boardId: opts?.boardId,
+      limit: opts?.limit ?? 20,
+      sort: "hot"
+    });
+    if (res.ok && res.data != null) {
+      this.feedCache.set(key, { at: Date.now(), payload: res.data });
+    }
+    return res;
+  }
+  async aggregatedContext(opts) {
+    const [feed, stats, unreadNotifications] = await Promise.all([
+      this.feed({ boardId: opts?.boardId, limit: opts?.feedLimit ?? 15 }),
+      this.statsCached(),
+      this.unreadCountCached()
+    ]);
+    return { feed, stats, unreadNotifications };
+  }
+  async statsCached() {
+    if (this.statsCache && Date.now() - this.statsCache.at < this.statsTTL) {
+      return { ok: true, data: this.statsCache.data };
+    }
+    const res = await this.getStats();
+    if (res.ok && res.data != null) {
+      this.statsCache = { at: Date.now(), data: res.data };
+    }
+    return res;
+  }
+  async unreadCountCached() {
+    if (this.notifCountCache && Date.now() - this.notifCountCache.at < this.notifCountTTL) {
+      return { ok: true, data: { unread: this.notifCountCache.count } };
+    }
+    const res = await this.getNotificationCount();
+    const n = res.data?.unread;
+    if (res.ok && typeof n === "number") {
+      this.notifCountCache = { at: Date.now(), count: n };
+    }
+    return res;
+  }
+  /** Helpdesk question shortcut */
+  async ask(title, content, tags) {
+    const res = await this.createPost({
+      boardId: "helpdesk",
+      title,
+      content,
+      postType: "question",
+      tags
+    });
+    if (res.ok) this.invalidateCache("helpdesk");
+    return res;
+  }
+  /** Showcase battle report shortcut */
+  async reportBattle(input) {
+    const res = await this.createPost({
+      boardId: "showcase",
+      title: input.title,
+      content: input.content,
+      postType: "battleReport",
+      tags: input.tags,
+      linkedGeneIds: input.linkedGeneIds,
+      linkedAgentId: input.linkedAgentId
+    });
+    if (res.ok) this.invalidateCache("showcase");
+    return res;
+  }
+  // ─── Notifications & profile (auth) ────────────────────────
+  async getNotifications(opts) {
+    const q = {};
+    if (opts?.unread) q.unread = "true";
+    if (opts?.limit != null) q.limit = String(opts.limit);
+    if (opts?.offset != null) q.offset = String(opts.offset);
+    return this._r("GET", "/api/im/community/notifications", void 0, q);
+  }
+  async markNotificationsRead(notificationId) {
+    const body = notificationId ? { notificationId } : {};
+    return this._r("POST", "/api/im/community/notifications/read", body);
+  }
+  async getNotificationCount() {
+    return this._r("GET", "/api/im/community/notifications/count");
+  }
+  async listBookmarks(opts) {
+    const q = {};
+    if (opts?.cursor) q.cursor = opts.cursor;
+    if (opts?.limit != null) q.limit = String(opts.limit);
+    return this._r("GET", "/api/im/community/bookmarks", void 0, q);
+  }
+  async followToggle(followingId, followingType) {
+    return this._r("POST", "/api/im/community/follow", { followingId, followingType });
+  }
+  async listFollowing(type) {
+    const q = {};
+    if (type) q.type = type;
+    return this._r("GET", "/api/im/community/following", void 0, q);
+  }
+  async listFollowers(userId) {
+    return this._r("GET", `/api/im/community/followers/${encodeURIComponent(userId)}`);
+  }
+  async getProfile(userId) {
+    return this._r("GET", `/api/im/community/profile/${encodeURIComponent(userId)}`);
+  }
+  // ─── REST (same surface as former CommunityClient) ─────────
+  async createPost(input) {
+    return this._r("POST", "/api/im/community/posts", input);
+  }
+  async listPosts(opts) {
+    const query = {};
+    if (opts?.boardId) query.boardId = opts.boardId;
+    if (opts?.sort) query.sort = opts.sort;
+    if (opts?.period) query.period = opts.period;
+    if (opts?.authorType) query.authorType = opts.authorType;
+    if (opts?.cursor) query.cursor = opts.cursor;
+    if (opts?.limit != null) query.limit = String(opts.limit);
+    return this._r("GET", "/api/im/community/posts", void 0, query);
+  }
+  async getPost(postId) {
+    return this._r("GET", `/api/im/community/posts/${encodeURIComponent(postId)}`);
+  }
+  async updatePost(postId, input) {
+    return this._r("PUT", `/api/im/community/posts/${encodeURIComponent(postId)}`, input);
+  }
+  async deletePost(postId) {
+    return this._r("DELETE", `/api/im/community/posts/${encodeURIComponent(postId)}`);
+  }
+  async createComment(postId, input) {
+    return this._r("POST", `/api/im/community/posts/${encodeURIComponent(postId)}/comments`, input);
+  }
+  async listComments(postId, opts) {
+    const query = {};
+    if (opts?.sort) query.sort = opts.sort;
+    if (opts?.cursor) query.cursor = opts.cursor;
+    if (opts?.limit != null) query.limit = String(opts.limit);
+    return this._r("GET", `/api/im/community/posts/${encodeURIComponent(postId)}/comments`, void 0, query);
+  }
+  async markBestAnswer(commentId) {
+    return this._r("POST", `/api/im/community/comments/${encodeURIComponent(commentId)}/best-answer`);
+  }
+  async vote(targetType, targetId, value) {
+    return this._r("POST", "/api/im/community/vote", { targetType, targetId, value });
+  }
+  async bookmark(postId) {
+    return this._r("POST", "/api/im/community/bookmark", { postId });
+  }
+  async search(query, opts) {
+    const q = { q: query };
+    if (opts?.boardId) q.boardId = opts.boardId;
+    if (opts?.sort) q.sort = opts.sort;
+    if (opts?.limit != null) q.limit = String(opts.limit);
+    return this._r("GET", "/api/im/community/search", void 0, q);
+  }
+  async updateComment(commentId, input) {
+    return this._r("PUT", `/api/im/community/comments/${encodeURIComponent(commentId)}`, input);
+  }
+  async deleteComment(commentId) {
+    return this._r("DELETE", `/api/im/community/comments/${encodeURIComponent(commentId)}`);
+  }
+  async getStats() {
+    return this._r("GET", "/api/im/community/stats");
+  }
+  async getTrendingTags(limit) {
+    const query = {};
+    if (limit != null) query.limit = String(limit);
+    return this._r("GET", "/api/im/community/tags/trending", void 0, query);
+  }
+  async getHotPosts(opts) {
+    const query = {};
+    if (opts?.limit != null) query.limit = String(opts.limit);
+    if (opts?.period) query.period = opts.period;
+    return this._r("GET", "/api/im/community/hot", void 0, query);
+  }
+  async searchSuggest(q) {
+    return this._r("GET", "/api/im/community/search/suggest", void 0, { q });
+  }
+  async autocompleteGenes(q, limit) {
+    const query = { q };
+    if (limit != null) query.limit = String(limit);
+    return this._r("GET", "/api/im/community/autocomplete/genes", void 0, query);
+  }
+  async autocompleteSkills(q, limit) {
+    const query = { q };
+    if (limit != null) query.limit = String(limit);
+    return this._r("GET", "/api/im/community/autocomplete/skills", void 0, query);
+  }
+  async createBattleReport(input) {
+    return this.createPost({
+      boardId: "showcase",
+      title: `Battle Report: ${input.agentId}`,
+      content: input.narrative || "Auto-generated battle report",
+      postType: "battleReport",
+      linkedGeneIds: input.geneIds,
+      linkedAgentId: input.agentId
+    });
+  }
+  async createMilestone(input) {
+    return this.createPost({
+      boardId: "showcase",
+      title: input.title,
+      content: input.content,
+      postType: "milestone",
+      linkedGeneIds: input.geneIds,
+      linkedAgentId: input.agentId,
+      tags: input.tags
+    });
+  }
+  async createGeneRelease(input) {
+    return this.createPost({
+      boardId: "showcase",
+      title: input.title,
+      content: input.content,
+      postType: "geneRelease",
+      linkedGeneIds: [input.geneId],
+      tags: input.tags
+    });
+  }
+};
+
+// src/aip.ts
+var import_aip_sdk = require("@prismer/aip-sdk");
+var import_aip_sdk2 = require("@prismer/aip-sdk");
+var import_aip_sdk3 = require("@prismer/aip-sdk");
+var import_aip_sdk4 = require("@prismer/aip-sdk");
+var import_aip_sdk5 = require("@prismer/aip-sdk");
+
 // src/types.ts
 var ENVIRONMENTS = {
   production: "https://prismer.cloud"
@@ -2163,20 +2443,27 @@ var PBKDF2_ITERATIONS = 1e5;
 var SALT_LENGTH = 16;
 var IV_LENGTH = 12;
 var KEY_LENGTH = 256;
-var E2EEncryption = class {
+var _E2EEncryption = class _E2EEncryption {
   constructor() {
     this.masterKey = null;
     this.keyPair = null;
     this.sessionKeys = /* @__PURE__ */ new Map();
     // conversationId → AES key
     this.salt = null;
+    // ─── Pipeline Functions ──────────────────────────────────
+    this.messageCount = 0;
+    this.lastRotation = Date.now();
   }
   /**
    * Initialize encryption with user passphrase.
    * Derives a master key via PBKDF2 and generates an ECDH key pair.
+   *
+   * @param passphrase - User passphrase for master key derivation
+   * @param salt - Optional Base64-encoded salt. If omitted, a random 16-byte salt is generated.
+   *               Store the salt (via exportSalt()) so you can re-derive the same master key later.
    */
-  async init(passphrase) {
-    this.salt = getRandomValues(new Uint8Array(SALT_LENGTH));
+  async init(passphrase, salt) {
+    this.salt = salt ? new Uint8Array(base64ToArrayBuffer(salt)) : getRandomValues(new Uint8Array(SALT_LENGTH));
     const passphraseKey = await subtle().importKey(
       "raw",
       new TextEncoder().encode(passphrase),
@@ -2187,7 +2474,7 @@ var E2EEncryption = class {
     this.masterKey = await subtle().deriveKey(
       {
         name: "PBKDF2",
-        salt: this.salt,
+        salt: new Uint8Array(this.salt.buffer, this.salt.byteOffset, this.salt.byteLength).buffer,
         iterations: PBKDF2_ITERATIONS,
         hash: "SHA-256"
       },
@@ -2202,6 +2489,14 @@ var E2EEncryption = class {
       ["deriveKey"]
     );
   }
+  /**
+   * Export the salt as Base64 string for persistent storage.
+   * You must store this and pass it back to init() to re-derive the same master key.
+   */
+  exportSalt() {
+    if (!this.salt) throw new Error("E2E not initialized. Call init() first.");
+    return arrayBufferToBase64(this.salt.buffer);
+  }
   /**
    * Export public key for sharing with conversation peers.
    */
@@ -2314,8 +2609,93 @@ var E2EEncryption = class {
     this.keyPair = null;
     this.sessionKeys.clear();
     this.salt = null;
+    this.messageCount = 0;
+  }
+  /**
+   * High-level encrypt-for-send pipeline.
+   * Encrypts content, builds metadata, and handles key rotation.
+   *
+   * Returns { encryptedContent, metadata } ready to send.
+   */
+  async encryptForSend(conversationId, content) {
+    if (!this.hasSessionKey(conversationId)) {
+      throw new Error("No session key for this conversation. Call deriveSessionKey() first.");
+    }
+    const needsRotation = this.shouldRotateKey();
+    const encryptedContent = await this.encrypt(conversationId, content);
+    this.messageCount++;
+    return {
+      encryptedContent,
+      metadata: {
+        encrypted: true,
+        encryptionVersion: 1,
+        ...needsRotation && { keyRotationRequested: true }
+      }
+    };
+  }
+  /**
+   * High-level decrypt-on-receive pipeline.
+   * Decrypts content and validates metadata.
+   */
+  async decryptOnReceive(conversationId, encryptedContent, metadata) {
+    if (!this.hasSessionKey(conversationId)) {
+      throw new Error("No session key for this conversation. Call deriveSessionKey() first.");
+    }
+    return this.decrypt(conversationId, encryptedContent);
+  }
+  /**
+   * High-level file encryption pipeline.
+   */
+  async encryptFile(conversationId, fileData) {
+    const base64Data = arrayBufferToBase64(fileData);
+    const encryptedData = await this.encrypt(conversationId, base64Data);
+    return {
+      encryptedData,
+      metadata: {
+        encrypted: true,
+        encryptionVersion: 1,
+        fileEncrypted: true
+      }
+    };
+  }
+  /**
+   * High-level file decryption pipeline.
+   */
+  async decryptFile(conversationId, encryptedData) {
+    const base64Data = await this.decrypt(conversationId, encryptedData);
+    return base64ToArrayBuffer(base64Data);
+  }
+  /**
+   * Check if key rotation is needed (1000 messages or 24 hours).
+   */
+  shouldRotateKey() {
+    if (this.messageCount >= _E2EEncryption.KEY_ROTATION_THRESHOLD) {
+      return true;
+    }
+    if (Date.now() - this.lastRotation >= _E2EEncryption.KEY_ROTATION_INTERVAL_MS) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Perform key rotation: generate new ECDH keypair and reset counters.
+   * The caller is responsible for re-exchanging keys with peers.
+   */
+  async rotateKeys() {
+    this.keyPair = await subtle().generateKey(
+      { name: "ECDH", namedCurve: "P-256" },
+      false,
+      ["deriveKey"]
+    );
+    this.messageCount = 0;
+    this.lastRotation = Date.now();
+    this.sessionKeys.clear();
+    return this.exportPublicKey();
   }
 };
+_E2EEncryption.KEY_ROTATION_THRESHOLD = 1e3;
+_E2EEncryption.KEY_ROTATION_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var E2EEncryption = _E2EEncryption;
 function arrayBufferToBase64(buffer) {
   if (typeof btoa !== "undefined") {
     const bytes = new Uint8Array(buffer);
@@ -2883,6 +3263,53 @@ var EvolutionRuntime = class {
 };
 
 // src/index.ts
+var _fs = null;
+var _os = null;
+var _path = null;
+try {
+  _fs = require("fs");
+  _os = require("os");
+  _path = require("path");
+} catch {
+}
+function resolveApiKey(explicit) {
+  if (explicit) return explicit;
+  try {
+    if (typeof process !== "undefined" && process.env?.PRISMER_API_KEY) {
+      return process.env.PRISMER_API_KEY;
+    }
+  } catch {
+  }
+  if (_fs && _os && _path) {
+    try {
+      const configPath = _path.join(_os.homedir(), ".prismer", "config.toml");
+      const raw = _fs.readFileSync(configPath, "utf-8");
+      const match = raw.match(/^api_key\s*=\s*'([^']+)'/m) || raw.match(/^api_key\s*=\s*"([^"]+)"/m);
+      if (match?.[1]) return match[1];
+    } catch {
+    }
+  }
+  return "";
+}
+function resolveBaseUrl(explicit) {
+  if (explicit) return explicit;
+  try {
+    if (typeof process !== "undefined" && process.env?.PRISMER_BASE_URL) {
+      return process.env.PRISMER_BASE_URL;
+    }
+  } catch {
+  }
+  if (_fs && _os && _path) {
+    try {
+      const configPath = _path.join(_os.homedir(), ".prismer", "config.toml");
+      const raw = _fs.readFileSync(configPath, "utf-8");
+      const match = raw.match(/^base_url\s*=\s*'([^']+)'/m) || raw.match(/^base_url\s*=\s*"([^"]+)"/m);
+      if (match?.[1]) return match[1];
+    } catch {
+    }
+  }
+  return void 0;
+}
 var AccountClient = class {
   constructor(_r) {
     this._r = _r;
@@ -2895,6 +3322,10 @@ var AccountClient = class {
   async me() {
     return this._r("GET", "/api/im/me");
   }
+  /** Update own profile */
+  async updateProfile(options) {
+    return this._r("PATCH", "/api/im/me", options);
+  }
   /** Refresh JWT token */
   async refreshToken() {
     return this._r("POST", "/api/im/token/refresh");
@@ -2985,6 +3416,30 @@ var ConversationsClient = class {
   async markAsRead(conversationId) {
     return this._r("POST", `/api/im/conversations/${conversationId}/read`);
   }
+  /** Archive a conversation */
+  async archive(conversationId) {
+    return this._r("POST", `/api/im/conversations/${conversationId}/archive`);
+  }
+  /** Unarchive a conversation */
+  async unarchive(conversationId) {
+    return this._r("POST", `/api/im/conversations/${conversationId}/unarchive`);
+  }
+  /** Update conversation metadata */
+  async update(conversationId, options) {
+    return this._r("PATCH", `/api/im/conversations/${conversationId}`, options);
+  }
+  /** Pin or unpin a conversation */
+  async pin(conversationId, pinned) {
+    return this._r("PATCH", `/api/im/conversations/${conversationId}/pin`, { pinned });
+  }
+  /** Mute or unmute a conversation */
+  async mute(conversationId, muted) {
+    return this._r("PATCH", `/api/im/conversations/${conversationId}/mute`, { muted });
+  }
+  /** Delete a conversation */
+  async delete(conversationId) {
+    return this._r("DELETE", `/api/im/conversations/${conversationId}`);
+  }
 };
 var MessagesClient = class {
   constructor(_r) {
@@ -3014,6 +3469,10 @@ var MessagesClient = class {
   async delete(conversationId, messageId) {
     return this._r("DELETE", `/api/im/messages/${conversationId}/${messageId}`);
   }
+  /** Mark messages as delivered */
+  async markDelivered(conversationId, messageIds) {
+    return this._r("POST", "/api/im/messages/delivered", { conversationId, messageIds });
+  }
 };
 var ContactsClient = class {
   constructor(_r) {
@@ -3023,6 +3482,18 @@ var ContactsClient = class {
   async list() {
     return this._r("GET", "/api/im/contacts");
   }
+  /** Search users/agents by query */
+  async search(query, options) {
+    const params = { q: query };
+    if (options?.type && options.type !== "all") params.type = options.type;
+    if (options?.limit) params.limit = String(options.limit);
+    if (options?.offset) params.offset = String(options.offset);
+    return this._r("GET", "/api/im/discover", void 0, params);
+  }
+  /** Get a user's public profile */
+  async getProfile(userId) {
+    return this._r("GET", `/api/im/users/${userId}`);
+  }
   /** Discover agents by capability or type */
   async discover(options) {
     const query = {};
@@ -3030,6 +3501,67 @@ var ContactsClient = class {
     if (options?.capability) query.capability = options.capability;
     return this._r("GET", "/api/im/discover", void 0, query);
   }
+  // ─── Friend System (v1.8.0 P9) ─────────────────────────
+  /** Send a friend request */
+  async request(userId, opts) {
+    return this._r("POST", "/api/im/contacts/request", { userId, ...opts });
+  }
+  /** List pending friend requests received */
+  async pendingReceived(opts) {
+    const params = {};
+    if (opts?.limit) params.limit = String(opts.limit);
+    if (opts?.offset) params.offset = String(opts.offset);
+    return this._r("GET", "/api/im/contacts/requests/received", void 0, params);
+  }
+  /** List pending friend requests sent */
+  async pendingSent(opts) {
+    const params = {};
+    if (opts?.limit) params.limit = String(opts.limit);
+    if (opts?.offset) params.offset = String(opts.offset);
+    return this._r("GET", "/api/im/contacts/requests/sent", void 0, params);
+  }
+  /** Accept a friend request */
+  async accept(requestId) {
+    return this._r("POST", `/api/im/contacts/requests/${requestId}/accept`);
+  }
+  /** Reject a friend request */
+  async reject(requestId) {
+    return this._r("POST", `/api/im/contacts/requests/${requestId}/reject`);
+  }
+  /** List friends */
+  async friends(opts) {
+    const params = {};
+    if (opts?.limit) params.limit = String(opts.limit);
+    if (opts?.offset) params.offset = String(opts.offset);
+    return this._r("GET", "/api/im/contacts/friends", void 0, params);
+  }
+  /** Remove a friend */
+  async remove(userId) {
+    return this._r("DELETE", `/api/im/contacts/${userId}/remove`);
+  }
+  /** Set a remark/alias for a contact */
+  async setRemark(userId, remark) {
+    return this._r("PATCH", `/api/im/contacts/${userId}/remark`, { remark });
+  }
+  /** Block a user */
+  async block(userId) {
+    return this._r("POST", `/api/im/contacts/${userId}/block`, {});
+  }
+  /** Unblock a user */
+  async unblock(userId) {
+    return this._r("DELETE", `/api/im/contacts/${userId}/block`);
+  }
+  /** List blocked users */
+  async blocklist(opts) {
+    const params = {};
+    if (opts?.limit) params.limit = String(opts.limit);
+    if (opts?.offset) params.offset = String(opts.offset);
+    return this._r("GET", "/api/im/contacts/blocked", void 0, params);
+  }
+  /** Get presence status for multiple users */
+  async getPresence(userIds) {
+    return this._r("POST", "/api/im/presence/batch", { userIds });
+  }
 };
 var BindingsClient = class {
   constructor(_r) {
@@ -3181,6 +3713,23 @@ var MemoryClient = class {
     if (scope) query.scope = scope;
     return this._r("GET", "/api/im/memory/load", void 0, query);
   }
+  /** Get memory-gene knowledge links for the authenticated user's memory files (v1.8.0) */
+  async getKnowledgeLinks() {
+    return this._r("GET", "/api/im/memory/links");
+  }
+};
+var KnowledgeLinkClient = class {
+  constructor(_r) {
+    this._r = _r;
+  }
+  /**
+   * Get all knowledge links for a given entity.
+   * @param entityType - One of: memory, gene, capsule, signal
+   * @param entityId   - The entity ID
+   */
+  async getLinks(entityType, entityId) {
+    return this._r("GET", "/api/im/knowledge/links", void 0, { entityType, entityId });
+  }
 };
 var IdentityClient = class {
   constructor(_r) {
@@ -3283,6 +3832,62 @@ var EvolutionClient = class {
     if (limit != null) query.limit = String(limit);
     return this._r("GET", "/api/im/evolution/public/feed", void 0, query);
   }
+  // ── Leaderboard V2 (public, no auth required) ──
+  /** Get hero section global stats (total agents, genes, capsules, savings) */
+  async getLeaderboardHero() {
+    return this._r("GET", "/api/im/evolution/leaderboard/hero");
+  }
+  /** Get rising stars leaderboard */
+  async getLeaderboardRising(period, limit) {
+    const query = {};
+    if (period) query.period = period;
+    if (limit != null) query.limit = String(limit);
+    return this._r("GET", "/api/im/evolution/leaderboard/rising", void 0, query);
+  }
+  /** Get leaderboard summary stats (totalAgentsEvolving, totalGenesCreated, etc.) */
+  async getLeaderboardStats() {
+    return this._r("GET", "/api/im/evolution/leaderboard/stats");
+  }
+  /** Get agent improvement board */
+  async getLeaderboardAgents(period, domain) {
+    const query = {};
+    if (period) query.period = period;
+    if (domain) query.domain = domain;
+    return this._r("GET", "/api/im/evolution/leaderboard/agents", void 0, query);
+  }
+  /** Get gene impact board */
+  async getLeaderboardGenes(period, sort) {
+    const query = {};
+    if (period) query.period = period;
+    if (sort) query.sort = sort;
+    return this._r("GET", "/api/im/evolution/leaderboard/genes", void 0, query);
+  }
+  /** Get contributor board */
+  async getLeaderboardContributors(period) {
+    const query = {};
+    if (period) query.period = period;
+    return this._r("GET", "/api/im/evolution/leaderboard/contributors", void 0, query);
+  }
+  /** Get cross-environment comparison data */
+  async getLeaderboardComparison() {
+    return this._r("GET", "/api/im/evolution/leaderboard/comparison");
+  }
+  /** Get public profile page data for an agent or owner */
+  async getPublicProfile(entityId) {
+    return this._r("GET", `/api/im/evolution/profile/${encodeURIComponent(entityId)}`);
+  }
+  /** Render agent/creator card as PNG */
+  async renderCard(input) {
+    return this._r("POST", "/api/im/evolution/card/render", input);
+  }
+  /** Get benchmark data for profile FOMO section */
+  async getBenchmark() {
+    return this._r("GET", "/api/im/evolution/benchmark");
+  }
+  /** Get gene highlight capsules for profile page */
+  async getHighlights(geneId) {
+    return this._r("GET", `/api/im/evolution/highlights/${encodeURIComponent(geneId)}`);
+  }
   // ── Authenticated endpoints ──
   /** Analyze signals and get gene recommendation */
   async analyze(options) {
@@ -3364,11 +3969,11 @@ var EvolutionClient = class {
   }
   /** Delete a gene */
   async deleteGene(geneId) {
-    return this._r("DELETE", `/api/im/evolution/genes/${geneId}`);
+    return this._r("DELETE", `/api/im/evolution/genes/${encodeURIComponent(geneId)}`);
   }
   /** Publish a gene. Pass skipCanary=true to bypass canary validation (MVP/admin). */
   async publishGene(geneId, options) {
-    return this._r("POST", `/api/im/evolution/genes/${geneId}/publish`, options?.skipCanary ? { skipCanary: true } : void 0);
+    return this._r("POST", `/api/im/evolution/genes/${encodeURIComponent(geneId)}/publish`, options?.skipCanary ? { skipCanary: true } : void 0);
   }
   /** Import a published gene */
   async importGene(geneId) {
@@ -3439,8 +4044,8 @@ var EvolutionClient = class {
     return this._r("GET", "/api/im/skills/stats");
   }
   /** Install a skill — creates Gene + returns content + install guide */
-  async installSkill(slugOrId) {
-    return this._r("POST", `/api/im/skills/${encodeURIComponent(slugOrId)}/install`);
+  async installSkill(slugOrId, scope) {
+    return this._r("POST", `/api/im/skills/${encodeURIComponent(slugOrId)}/install`, scope ? { scope } : void 0);
   }
   /** Uninstall a skill */
   async uninstallSkill(slugOrId) {
@@ -3454,6 +4059,14 @@ var EvolutionClient = class {
   async getSkillContent(slugOrId) {
     return this._r("GET", `/api/im/skills/${encodeURIComponent(slugOrId)}/content`);
   }
+  /** Create/submit a community skill */
+  async createSkill(input) {
+    return this._r("POST", "/api/im/skills", input);
+  }
+  /** Star a skill (increment community rating) */
+  async starSkill(skillId) {
+    return this._r("POST", `/api/im/skills/${encodeURIComponent(skillId)}/star`);
+  }
   /**
    * Install a skill and write SKILL.md to local filesystem.
    * Combines cloud install + local file sync for Claude Code / OpenClaw / OpenCode.
@@ -3516,8 +4129,8 @@ var EvolutionClient = class {
   async uninstallSkillLocal(slugOrId) {
     const result = await this.uninstallSkill(slugOrId);
     const removedPaths = [];
-    const safeSlug = slugOrId.replace(/[\/\\]/g, "").replace(/\.\./g, "");
-    if (!safeSlug) return { ...result, data: { uninstalled: result.data?.uninstalled ?? false, removedPaths } };
+    const slug = safeSlug(slugOrId);
+    if (!slug) return { ...result, data: { uninstalled: result.data?.uninstalled ?? false, removedPaths } };
     try {
       const fs = await import("fs");
       const path = await import("path");
@@ -3525,10 +4138,10 @@ var EvolutionClient = class {
       const home = os.homedir();
       const pluginBase = process.env.PRISMER_PLUGIN_DIR || path.join(home, ".claude", "plugins", "prismer");
       const dirs = [
-        path.join(home, ".claude", "skills", safeSlug),
-        path.join(home, ".openclaw", "skills", safeSlug),
-        path.join(home, ".config", "opencode", "skills", safeSlug),
-        path.join(pluginBase, "skills", safeSlug)
+        path.join(home, ".claude", "skills", slug),
+        path.join(home, ".openclaw", "skills", slug),
+        path.join(home, ".config", "opencode", "skills", slug),
+        path.join(pluginBase, "skills", slug)
       ];
       for (const dir of dirs) {
         try {
@@ -3638,6 +4251,9 @@ var EvolutionClient = class {
     return this._r("POST", "/api/im/evolution/sync", body);
   }
 };
+function safeSlug(input) {
+  return input.replace(/[\/\\]/g, "").replace(/\.\./g, "").replace(/\0/g, "");
+}
 function guessMimeType(fileName) {
   const ext = fileName.split(".").pop()?.toLowerCase() || "";
   const map = {
@@ -3866,7 +4482,7 @@ var IMRealtimeClient = class {
   }
 };
 var IMClient = class {
-  constructor(request, wsBase, fetchFn, getAuthHeaders, offlineManager) {
+  constructor(request, wsBase, fetchFn, getAuthHeaders, offlineManager, communityHubConfig) {
     this.account = new AccountClient(request);
     this.direct = new DirectClient(request);
     this.groups = new GroupsClient(request);
@@ -3878,9 +4494,11 @@ var IMClient = class {
     this.workspace = new WorkspaceClient(request);
     this.tasks = new TasksClient(request);
     this.memory = new MemoryClient(request);
+    this.knowledge = new KnowledgeLinkClient(request);
     this.identity = new IdentityClient(request);
     this.security = new SecurityClient(request);
     this.evolution = new EvolutionClient(request);
+    this.community = new CommunityHub(request, communityHubConfig ?? void 0);
     this.files = new FilesClient(request, wsBase, fetchFn, getAuthHeaders);
     this.realtime = new IMRealtimeClient(wsBase);
     this.offline = offlineManager ?? null;
@@ -3889,19 +4507,43 @@ var IMClient = class {
   async health() {
     return this.account["_r"]("GET", "/api/im/health");
   }
+  /** Get workspace superset view with slot filtering */
+  async getWorkspace(scope, slots, includeContent) {
+    const params = new URLSearchParams();
+    if (scope) params.set("scope", scope);
+    if (slots?.length) params.set("slots", slots.join(","));
+    if (includeContent) params.set("includeContent", "true");
+    return this.workspace["_r"]("GET", `/api/im/workspace/view?${params}`);
+  }
 };
 var PrismerClient = class {
   constructor(config = {}) {
     this._offlineManager = null;
-    if (config.apiKey && !config.apiKey.startsWith("sk-prismer-") && !config.apiKey.startsWith("eyJ")) {
+    /** AIP identity for auto-signing (v1.8.0 S1) */
+    this._identity = null;
+    this._identityReady = null;
+    const resolvedApiKey = resolveApiKey(config.apiKey);
+    if (resolvedApiKey && !resolvedApiKey.startsWith("sk-prismer-") && !resolvedApiKey.startsWith("eyJ")) {
       console.warn('Warning: API key should start with "sk-prismer-" (or "eyJ" for IM JWT)');
     }
-    this.apiKey = config.apiKey || "";
+    this.apiKey = resolvedApiKey;
     const envUrl = ENVIRONMENTS[config.environment || "production"];
-    this.baseUrl = (config.baseUrl || envUrl).replace(/\/$/, "");
+    this.baseUrl = (resolveBaseUrl(config.baseUrl) || envUrl).replace(/\/$/, "");
     this.timeout = config.timeout || 3e4;
     this.fetchFn = config.fetch || fetch;
     this.imAgent = config.imAgent;
+    if (config.identity) {
+      if (config.identity === "auto" && this.apiKey) {
+        this._identityReady = import_aip_sdk.AIPIdentity.fromApiKey(this.apiKey).then((id) => {
+          this._identity = id;
+        }).catch((err) => console.warn("[PrismerSDK] Identity init failed:", err));
+      } else if (typeof config.identity === "object" && config.identity.privateKey) {
+        const keyBytes = typeof Buffer !== "undefined" ? new Uint8Array(Buffer.from(config.identity.privateKey, "base64")) : new Uint8Array(atob(config.identity.privateKey).split("").map((c) => c.charCodeAt(0)));
+        this._identityReady = import_aip_sdk.AIPIdentity.fromPrivateKey(keyBytes).then((id) => {
+          this._identity = id;
+        }).catch((err) => console.warn("[PrismerSDK] Identity init failed:", err));
+      }
+    }
     if (config.offline) {
       this._offlineManager = new OfflineManager(
         config.offline.storage,
@@ -3912,14 +4554,60 @@ var PrismerClient = class {
         (err) => console.warn("[PrismerSDK] Offline storage init failed:", err)
       );
     }
-    const imRequest = this._offlineManager ? (m, p, b, q) => this._offlineManager.dispatch(m, p, b, q) : (m, p, b, q) => this._request(m, p, b, q);
+    let imRequest = this._offlineManager ? (m, p, b, q) => this._offlineManager.dispatch(m, p, b, q) : (m, p, b, q) => this._request(m, p, b, q);
+    if (config.identity) {
+      const baseRequest = imRequest;
+      imRequest = (method, path, body, query) => {
+        if (method === "POST" && path.includes("/messages") && body) {
+          const b = body;
+          if (!b.signature && !b.skipSigning) {
+            const ready = this._identityReady || Promise.resolve();
+            return ready.then(() => {
+              if (this._identity) {
+                return this._signAndSend(baseRequest, method, path, b, query);
+              }
+              return baseRequest(method, path, body, query);
+            });
+          }
+        }
+        return baseRequest(method, path, body, query);
+      };
+    }
     this.im = new IMClient(
       imRequest,
       this.baseUrl,
       this.fetchFn,
       () => this._getAuthHeaders(),
-      this._offlineManager
+      this._offlineManager,
+      config.community ?? null
+    );
+  }
+  /** Wait for identity to be ready (useful for tests or explicit await) */
+  async ensureIdentity() {
+    if (this._identityReady) await this._identityReady;
+    return this._identity;
+  }
+  /** Auto-sign a message body and send (v1.8.0 S1) */
+  async _signAndSend(baseRequest, method, path, body, query) {
+    if (this._identityReady) await this._identityReady;
+    if (!this._identity) return baseRequest(method, path, body, query);
+    const content = body.content || "";
+    const contentHashBytes = new Uint8Array(
+      await crypto.subtle.digest("SHA-256", new TextEncoder().encode(content))
     );
+    const contentHash = Array.from(contentHashBytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+    const timestamp = Date.now();
+    const payload = `1|${this._identity.did}|${body.type || "text"}|${timestamp}|${contentHash}`;
+    const payloadBytes = new TextEncoder().encode(payload);
+    const signature = await this._identity.sign(payloadBytes);
+    return baseRequest(method, path, {
+      ...body,
+      secVersion: 1,
+      senderDid: this._identity.did,
+      contentHash,
+      signature,
+      signedAt: timestamp
+    }, query);
   }
   /** Build auth headers for raw HTTP requests (used by file upload) */
   _getAuthHeaders() {
@@ -4055,9 +4743,11 @@ function createClient(config) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AIPIdentity,
   AccountClient,
   AttachmentQueue,
   BindingsClient,
+  CommunityHub,
   ContactsClient,
   ConversationsClient,
   CreditsClient,
@@ -4073,6 +4763,7 @@ function createClient(config) {
   IMRealtimeClient,
   IdentityClient,
   IndexedDBStorage,
+  KnowledgeLinkClient,
   MemoryClient,
   MemoryStorage,
   MessagesClient,
@@ -4094,5 +4785,7 @@ function createClient(config) {
   encryptContext,
   encryptFile,
   encryptForSend,
-  extractSignals
+  extractSignals,
+  guessMimeType,
+  safeSlug
 });