@unblocklabs/unblock-memory 0.3.4 → 0.3.6

package/dist/src/people-tools.js

@@ -2,24 +2,43 @@ import { jsonResult } from "openclaw/plugin-sdk/agent-runtime";
 import { Type } from "typebox";
 import { Value } from "typebox/value";
 import { renderPeopleWhisper } from "./people-hooks.js";
-import { openClawSlackDirectory, syncSlackDirectory, } from "./slack-directory.js";
+import { createOpenClawSlackDirectory, syncSlackDirectory, } from "./slack-directory.js";
 const nonEmpty = Type.String({ pattern: "\\S", maxLength: 1000 });
-const personSelector = Type.Union([
-    Type.Object({ view: Type.Literal("person"), personId: nonEmpty }, { additionalProperties: false }),
+const inspectParameters = Type.Union([
+    Type.Object({
+        view: Type.Literal("person"),
+        personId: Type.String({
+            pattern: "\\S",
+            maxLength: 1000,
+            description: "PeopleSQL person ID. Use identity when only Slack IDs are known.",
+        }),
+    }, { additionalProperties: false }),
     Type.Object({
         view: Type.Literal("person"),
         identity: Type.Object({
             provider: Type.Literal("slack"),
-            accountScope: nonEmpty,
-            externalId: nonEmpty,
-        }, { additionalProperties: false }),
+            accountScope: Type.String({
+                pattern: "\\S",
+                maxLength: 1000,
+                description: "Configured Slack account ID, for example default.",
+            }),
+            externalId: Type.String({
+                pattern: "\\S",
+                maxLength: 1000,
+                description: "Exact Slack user ID.",
+            }),
+        }, {
+            additionalProperties: false,
+            description: "Exact Slack identity for the person to inspect.",
+        }),
     }, { additionalProperties: false }),
-]);
-const inspectParameters = Type.Union([
-    personSelector,
     Type.Object({
         view: Type.Literal("todos"),
-        limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 100 })),
+        limit: Type.Optional(Type.Integer({
+            minimum: 1,
+            maximum: 100,
+            description: "Maximum actionable todos to return.",
+        })),
     }, { additionalProperties: false }),
 ]);
 const updateParameters = Type.Union([
@@ -85,7 +104,7 @@ function createInspectTool(stores, config, ctx) {
     return {
         name: "memory_people_inspect",
         label: "Inspect People Memory",
-        description: "Inspect one exact person or bounded actionable people todos.",
+        description: "Inspect one person by PeopleSQL personId or exact Slack identity, or list bounded actionable people todos.",
         parameters: inspectParameters,
         async execute(_toolCallId, raw) {
             const input = Value.Parse(inspectParameters, raw);
@@ -174,7 +193,7 @@ function createSyncTool(stores, reader, ctx) {
         },
     };
 }
-export function registerPeopleTools(api, stores, config, directoryReader = openClawSlackDirectory) {
+export function registerPeopleTools(api, stores, config, directoryReader) {
     api.registerTool((ctx) => createInspectTool(stores, config, ctx), {
         names: ["memory_people_inspect"],
         optional: true,
@@ -183,7 +202,10 @@ export function registerPeopleTools(api, stores, config, directoryReader = openC
         names: ["memory_people_update"],
         optional: true,
     });
-    api.registerTool((ctx) => createSyncTool(stores, directoryReader, ctx), {
+    api.registerTool((ctx) => createSyncTool(stores, directoryReader ??
+        createOpenClawSlackDirectory({
+            getConfig: () => ctx.getRuntimeConfig?.() ?? ctx.runtimeConfig ?? ctx.config,
+        }), ctx), {
         names: ["memory_people_sync"],
         optional: true,
     });

package/dist/src/slack-directory.d.ts

@@ -1,3 +1,4 @@
+import type { OpenClawConfig } from "openclaw/plugin-sdk/plugin-entry";
 import type { PeopleStore } from "./people-store.js";
 type SlackDirectoryEntry = {
     id: string;
@@ -11,13 +12,22 @@ export type SlackDirectoryReader = {
         limit: number;
     }): Promise<readonly SlackDirectoryEntry[]>;
 };
-type DirectoryCommand = (executable: string, args: readonly string[], options: {
-    maxBuffer: number;
-}) => Promise<{
-    stdout: string;
-}>;
-export declare function createOpenClawSlackDirectory(run?: DirectoryCommand): SlackDirectoryReader;
-export declare const openClawSlackDirectory: SlackDirectoryReader;
+type SlackAccountInspector = (params: {
+    channelId: "slack";
+    cfg: OpenClawConfig;
+    accountId: string;
+}) => Promise<Record<string, unknown> | null>;
+type SlackRequest = (input: string | URL, init: {
+    headers: {
+        authorization: string;
+    };
+    signal: AbortSignal;
+}) => Promise<Pick<Response, "json" | "ok" | "status">>;
+export declare function createOpenClawSlackDirectory(params: {
+    getConfig: () => OpenClawConfig | undefined;
+    inspectAccount?: SlackAccountInspector;
+    request?: SlackRequest;
+}): SlackDirectoryReader;
 export declare function syncSlackDirectory(params: {
     store: PeopleStore;
     reader: SlackDirectoryReader;

package/dist/src/slack-directory.js

@@ -1,55 +1,83 @@
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-const execFileAsync = promisify(execFile);
+import { inspectReadOnlyChannelAccount } from "openclaw/plugin-sdk/directory-runtime";
 function text(value, maxLength) {
     return typeof value === "string" && value.trim() ? value.trim().slice(0, maxLength) : undefined;
 }
-export function createOpenClawSlackDirectory(run = async (executable, args, options) => {
-    const result = await execFileAsync(executable, args, options);
-    return { stdout: result.stdout };
-}) {
+function record(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function slackToken(account) {
+    return text(account.userToken, 10_000) ?? text(account.botToken, 10_000);
+}
+function slackEntry(value) {
+    const member = record(value);
+    const id = text(member?.id, 200);
+    if (!id)
+        return undefined;
+    const profile = record(member?.profile);
+    return {
+        id,
+        name: text(profile?.display_name, 500) ??
+            text(profile?.real_name, 500) ??
+            text(member?.real_name, 500) ??
+            text(member?.name, 500),
+        handle: text(member?.name, 200),
+        avatarUrl: text(profile?.image_512, 2_000) ??
+            text(profile?.image_192, 2_000) ??
+            text(profile?.image_72, 2_000),
+    };
+}
+export function createOpenClawSlackDirectory(params) {
+    const inspectAccount = params.inspectAccount ?? inspectReadOnlyChannelAccount;
+    const request = params.request ?? fetch;
     return {
         async listUsers({ accountId, limit }) {
-            const { stdout } = await run("openclaw", [
-                "directory",
-                "peers",
-                "list",
-                "--channel",
-                "slack",
-                "--account",
-                accountId,
-                "--limit",
-                String(limit),
-                "--json",
-            ], { maxBuffer: 1024 * 1024 });
-            const parsed = JSON.parse(stdout);
-            if (!Array.isArray(parsed))
-                throw new Error("OpenClaw Slack directory returned an invalid response");
-            return parsed.flatMap((value) => {
-                if (!value || typeof value !== "object" || Array.isArray(value))
-                    return [];
-                const entry = value;
-                if (entry.kind !== "user")
-                    return [];
-                const prefixedId = text(entry.id, 200);
-                if (!prefixedId?.startsWith("user:"))
-                    return [];
-                const id = text(prefixedId.slice("user:".length), 200);
-                const handle = text(entry.handle, 200);
-                return id
-                    ? [
-                        {
-                            id,
-                            name: text(entry.name, 500),
-                            handle: text(handle?.startsWith("@") ? handle.slice(1) : handle, 200),
-                        },
-                    ]
-                    : [];
-            });
+            const cfg = params.getConfig();
+            if (!cfg)
+                throw new Error("OpenClaw runtime config is unavailable");
+            const account = await inspectAccount({ channelId: "slack", cfg, accountId });
+            const token = account ? slackToken(account) : undefined;
+            if (!token) {
+                throw new Error(`Slack credentials for account "${accountId}" are unavailable in the active runtime snapshot`);
+            }
+            const entries = [];
+            const cursors = new Set();
+            let cursor;
+            while (entries.length < limit) {
+                const url = new URL("https://slack.com/api/users.list");
+                url.searchParams.set("limit", String(Math.min(limit, 200)));
+                if (cursor)
+                    url.searchParams.set("cursor", cursor);
+                const response = await request(url, {
+                    headers: { authorization: `Bearer ${token}` },
+                    signal: AbortSignal.timeout(30_000),
+                });
+                const payload = record(await response.json());
+                if (!response.ok || payload?.ok !== true) {
+                    const detail = text(payload?.error, 200) ?? `HTTP ${response.status}`;
+                    throw new Error(`Slack directory request failed: ${detail}`);
+                }
+                const members = Array.isArray(payload.members) ? payload.members : [];
+                for (const member of members) {
+                    const entry = slackEntry(member);
+                    if (entry)
+                        entries.push(entry);
+                    if (entries.length === limit)
+                        break;
+                }
+                const next = text(record(payload.response_metadata)?.next_cursor, 2_000);
+                if (!next)
+                    break;
+                if (cursors.has(next))
+                    throw new Error("Slack directory returned a repeated cursor");
+                cursors.add(next);
+                cursor = next;
+            }
+            return entries;
         },
     };
 }
-export const openClawSlackDirectory = createOpenClawSlackDirectory();
 export async function syncSlackDirectory(params) {
     const entries = await params.reader.listUsers({
         accountId: params.accountId,

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "unblock-memory",
   "name": "Unblock Memory",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "description": "Indexes, retrieves, and analyzes configured workspace memory with existing QMD vectors.",
   "kind": "memory",
   "activation": { "onStartup": false },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unblocklabs/unblock-memory",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "description": "Workspace-native memory for OpenClaw, powered by QMD",
   "type": "module",
   "license": "MIT",
@@ -41,6 +41,7 @@
     "typebox": "1.3.6"
   },
   "devDependencies": {
+    "@openclaw/ai": "2026.8.1-beta.3",
     "@openclaw/plugin-inspector": "^0.3.10",
     "@types/node": "^24.6.0",
     "@types/picomatch": "^4.0.2",