@occum-net/occumclaw 0.5.0 → 0.6.0

package/index.ts

@@ -327,12 +327,85 @@ function listAccountIds(cfg: any): string[] {
   return [];
 }
 
+// ─── Directory Helpers ───────────────────────────────────────────────────────
+
+interface DirectoryEntry {
+  kind: "user" | "group" | "channel";
+  id: string;
+  name?: string;
+  handle?: string;
+  avatarUrl?: string;
+  rank?: number;
+}
+
+/** Case-insensitive substring filter on id, name, and handle. */
+function filterEntries(entries: DirectoryEntry[], query?: string | null, limit?: number | null): DirectoryEntry[] {
+  if (query) {
+    const q = query.trim().toLowerCase();
+    entries = entries.filter(
+      (e) =>
+        e.id.toLowerCase().includes(q) ||
+        e.name?.toLowerCase().includes(q) ||
+        e.handle?.toLowerCase().includes(q),
+    );
+  }
+  if (limit && limit > 0) entries = entries.slice(0, limit);
+  return entries;
+}
+
+/** Convert an occum.net channel member to a directory entry. */
+function memberToEntry(m: any): DirectoryEntry {
+  return {
+    kind: "user",
+    id: m.memberType === "agent" ? m.agentId : m.userId,
+    name: m.displayName ?? m.invitedName ?? undefined,
+    handle: m.memberType === "agent" ? m.agentId : undefined,
+    avatarUrl: m.avatarUrl ?? undefined,
+  };
+}
+
+/** Convert an occum.net channel to a directory group entry. */
+function channelToEntry(ch: any): DirectoryEntry {
+  return {
+    kind: "group",
+    id: ch.id,
+    name: ch.name ?? undefined,
+  };
+}
+
+/**
+ * Build a ToolConfig from either the gateway closure or from the cfg param.
+ * The gateway sets cachedConfig/controlChannelId at startup; the CLI resolver
+ * only has cfg, so we fall back to resolveAccount + /agents/me.
+ */
+async function resolveDirectoryContext(
+  cachedConfig: ToolConfig | null,
+  controlChannelId: string | null,
+  cfg?: any,
+): Promise<{ config: ToolConfig; controlChannelId: string } | null> {
+  if (cachedConfig && controlChannelId) {
+    return { config: cachedConfig, controlChannelId };
+  }
+  // Fallback: build config from cfg param (used by CLI commands)
+  const account = resolveAccount(cfg ?? {});
+  if (!account.agentToken) return null;
+  const config: ToolConfig = { agentToken: account.agentToken, apiUrl: account.apiUrl };
+  try {
+    const me = await apiRequest(config, "/agents/me");
+    if (!me.controlChannelId) return null;
+    return { config, controlChannelId: me.controlChannelId };
+  } catch {
+    return null;
+  }
+}
+
 // ─── Channel Plugin ─────────────────────────────────────────────────────────
 
 function createOccumChannelPlugin(logger: PluginLogger) {
-  // Shared state: set by startAccount, read by resolveTarget/sendText.
+  // Shared state: set by startAccount, read by resolveTarget/sendText/directory.
   // All outbound delivery routes to the agent's control channel.
   let controlChannelId: string | null = null;
+  let cachedConfig: ToolConfig | null = null;
 
   return {
     id: "occum" as const,
@@ -353,6 +426,132 @@ function createOccumChannelPlugin(logger: PluginLogger) {
       resolveToolPolicy: resolveOccumToolPolicy,
     },
 
+    directory: {
+      async self(params: { cfg?: any }) {
+        const ctx = await resolveDirectoryContext(cachedConfig, controlChannelId, params.cfg);
+        if (!ctx) return null;
+        try {
+          const me = await apiRequest(ctx.config, "/agents/me");
+          return { kind: "user" as const, id: me.id, name: me.name ?? undefined };
+        } catch {
+          return null;
+        }
+      },
+
+      async listPeers(params: { cfg?: any; query?: string | null; limit?: number | null; accountId?: string | null }) {
+        const ctx = await resolveDirectoryContext(cachedConfig, controlChannelId, params.cfg);
+        if (!ctx) return [];
+        try {
+          const members: any[] = await apiRequest(ctx.config, `/channels/${ctx.controlChannelId}/members`);
+          const entries = members.map(memberToEntry).filter((e) => !!e.id);
+          return filterEntries(entries, params.query, params.limit);
+        } catch {
+          return [];
+        }
+      },
+
+      async listPeersLive(params: { cfg?: any; query?: string | null; limit?: number | null; accountId?: string | null }) {
+        const ctx = await resolveDirectoryContext(cachedConfig, controlChannelId, params.cfg);
+        if (!ctx) return [];
+        try {
+          const members: any[] = await apiRequest(ctx.config, `/channels/${ctx.controlChannelId}/members`);
+          const entries = members.map(memberToEntry).filter((e) => !!e.id);
+          return filterEntries(entries, params.query, params.limit);
+        } catch {
+          return [];
+        }
+      },
+
+      async listGroups(params: { cfg?: any; query?: string | null; limit?: number | null; accountId?: string | null }) {
+        const ctx = await resolveDirectoryContext(cachedConfig, controlChannelId, params.cfg);
+        if (!ctx) return [];
+        try {
+          const channels: any[] = await apiRequest(ctx.config, "/channels");
+          const entries = channels.map(channelToEntry);
+          return filterEntries(entries, params.query, params.limit);
+        } catch {
+          return [];
+        }
+      },
+
+      async listGroupsLive(params: { cfg?: any; query?: string | null; limit?: number | null; accountId?: string | null }) {
+        const ctx = await resolveDirectoryContext(cachedConfig, controlChannelId, params.cfg);
+        if (!ctx) return [];
+        try {
+          const channels: any[] = await apiRequest(ctx.config, "/channels");
+          const entries = channels.map(channelToEntry);
+          return filterEntries(entries, params.query, params.limit);
+        } catch {
+          return [];
+        }
+      },
+
+      async listGroupMembers(params: { cfg?: any; groupId: string; limit?: number | null; accountId?: string | null }) {
+        const ctx = await resolveDirectoryContext(cachedConfig, controlChannelId, params.cfg);
+        if (!ctx) return [];
+        try {
+          const members: any[] = await apiRequest(ctx.config, `/channels/${params.groupId}/members`);
+          const entries = members.map(memberToEntry).filter((e) => !!e.id);
+          return params.limit && params.limit > 0 ? entries.slice(0, params.limit) : entries;
+        } catch {
+          return [];
+        }
+      },
+    },
+
+    resolver: {
+      async resolveTargets(params: {
+        cfg?: any;
+        accountId?: string | null;
+        inputs: string[];
+        kind: "user" | "group";
+      }) {
+        const ctx = await resolveDirectoryContext(cachedConfig, controlChannelId, params.cfg);
+        if (!ctx) {
+          return params.inputs.map((input) => ({ input, resolved: false, note: "Not configured" }));
+        }
+        if (params.kind === "group") {
+          try {
+            const channels: any[] = await apiRequest(ctx.config, "/channels");
+            return params.inputs.map((input) => {
+              const q = input.trim().toLowerCase();
+              const match = channels.find(
+                (ch) => ch.id === input || ch.name?.toLowerCase().includes(q),
+              );
+              return match
+                ? { input, resolved: true, id: match.id, name: match.name ?? undefined }
+                : { input, resolved: false };
+            });
+          } catch {
+            return params.inputs.map((input) => ({ input, resolved: false }));
+          }
+        }
+        // kind === "user"
+        try {
+          const members: any[] = await apiRequest(ctx.config, `/channels/${ctx.controlChannelId}/members`);
+          return params.inputs.map((input) => {
+            const q = input.trim().toLowerCase();
+            const match = members.find(
+              (m) =>
+                m.userId === input ||
+                m.agentId === input ||
+                m.displayName?.toLowerCase().includes(q) ||
+                m.invitedName?.toLowerCase().includes(q),
+            );
+            if (!match) return { input, resolved: false };
+            return {
+              input,
+              resolved: true,
+              id: match.memberType === "agent" ? match.agentId : match.userId,
+              name: match.displayName ?? match.invitedName ?? undefined,
+            };
+          });
+        } catch {
+          return params.inputs.map((input) => ({ input, resolved: false }));
+        }
+      },
+    },
+
     config: {
       listAccountIds: (cfg: any) => listAccountIds(cfg),
       resolveAccount: (cfg: any, accountId?: string | null) => resolveAccount(cfg, accountId),
@@ -422,6 +621,7 @@ function createOccumChannelPlugin(logger: PluginLogger) {
 
         const channelRuntime = ctx.channelRuntime;
         const config: ToolConfig = { agentToken: account.agentToken, apiUrl: account.apiUrl };
+        cachedConfig = config;
 
         // Discover agent identity
         let agentId: string | null = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@occum-net/occumclaw",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "publishConfig": {
     "access": "public"
   },