openclaw-app 1.1.5 → 1.1.7

package/index.ts

@@ -563,8 +563,9 @@ function cleanupRelay(state: RelayState) {
         state.ws = null;
     }
     state.e2eSessions.clear();
-    state.prevE2eSessions.clear();
-    state.pendingFlushQueue.clear();
+    // prevE2eSessions is intentionally kept across reconnects so that
+    // offline-buffered messages can still be re-encrypted after a plugin
+    // reconnect. pendingFlushQueue is also kept for the same reason.
 }
 
 function connectRelay(ctx: any, account: ResolvedAccount) {
@@ -929,12 +930,51 @@ async function handleRpc(ctx: any, accountId: string, msg: any): Promise<boolean
                 agentsSample: Array.isArray(agentsList) ? agentsList.slice(0, 3) : agentsList,
             });
         } else if (method === "runtime.inspect.deep") {
-            // Inspect sub-objects to find agents.create capability
-            const systemKeys = runtime?.system ? Object.keys(runtime.system) : [];
-            const toolsKeys = runtime?.tools ? Object.keys(runtime.tools) : [];
-            const stateKeys = runtime?.state ? Object.keys(runtime.state) : [];
-            const agentsApiKeys = runtime?.agents ? Object.keys(runtime.agents) : [];
-            await sendRpcReply({ systemKeys, toolsKeys, stateKeys, agentsApiKeys });
+            // Deep inspection to discover skills API surface
+            const allRuntimeKeys = runtime ? Object.keys(runtime) : [];
+
+            // Walk every top-level key and record its type + sub-keys (if object/function)
+            const runtimeShape: Record<string, any> = {};
+            for (const k of allRuntimeKeys) {
+                try {
+                    const v = runtime[k];
+                    const t = typeof v;
+                    if (t === 'function') {
+                        runtimeShape[k] = 'function';
+                    } else if (v && t === 'object') {
+                        runtimeShape[k] = Object.keys(v).slice(0, 20);
+                    } else {
+                        runtimeShape[k] = t;
+                    }
+                } catch (_) {
+                    runtimeShape[k] = 'error';
+                }
+            }
+
+            // Specifically probe skills-related paths
+            const skillsProbe: Record<string, any> = {};
+            const candidates = ['skills', 'skillManager', 'skillLoader', 'skillRegistry', 'pluginSkills'];
+            for (const c of candidates) {
+                if (runtime?.[c]) {
+                    skillsProbe[c] = typeof runtime[c] === 'object'
+                        ? Object.keys(runtime[c])
+                        : typeof runtime[c];
+                }
+            }
+
+            // Also probe config.skills
+            let cfgSkills: any = null;
+            try {
+                const cfg = runtime.config.loadConfig();
+                cfgSkills = {
+                    topKeys: Object.keys(cfg?.skills ?? {}),
+                    entriesKeys: Object.keys(cfg?.skills?.entries ?? {}),
+                    entriesSample: Object.entries(cfg?.skills?.entries ?? {}).slice(0, 5)
+                        .map(([k, v]: [string, any]) => ({ name: k, enabled: v?.enabled })),
+                };
+            } catch (_) {}
+
+            await sendRpcReply({ runtimeShape, skillsProbe, cfgSkills });
         } else if (method === "agents.list") {
             const cfg = runtime.config.loadConfig();
             // cfg.agents structure: { defaults: {...}, list: [{id, name, workspace, ...}], ... }
@@ -957,9 +997,10 @@ async function handleRpc(ctx: any, accountId: string, msg: any): Promise<boolean
             })).filter((a: any) => a.id);
             await sendRpcReply({ agents: list });
         } else if (method === "sessions.list") {
-            const cfg = runtime.config.loadConfig();
-            const sessions = runtime.session?.listSessions?.({ cfg, accountId }) ?? [];
-            await sendRpcReply({ sessions });
+            // Sessions are stored locally in the mobile app's Drift DB.
+            // The Gateway/CLI has no sessions API we can call reliably.
+            // Return empty — session_provider.dart falls back to local DB which is the source of truth.
+            await sendRpcReply({ sessions: [] });
         } else if (method === "agents.create") {
             // Use CLI: openclaw agents add <name> --workspace <path> [--model <model>]
             const name = params.name as string | undefined;
@@ -979,6 +1020,119 @@ async function handleRpc(ctx: any, accountId: string, msg: any): Promise<boolean
                     await sendRpcReply({ name, workspace, output: result.stdout ?? '' });
                 }
             }
+        } else if (method === "tools.list") {
+            // Use `openclaw skills list --json` CLI — most reliable source for loaded skills.
+            // Falls back to fs scan of ~/.openclaw/skills if CLI is unavailable.
+            let tools: any[] = [];
+
+            try {
+                // Try object form first; fall back to string form (same as agents.create)
+                let cliResult: any;
+                try {
+                    cliResult = await runtime.system.runCommandWithTimeout(
+                        { cmd: 'openclaw', args: ['skills', 'list', '--json'] },
+                        10000
+                    );
+                } catch (_) {
+                    cliResult = await runtime.system.runCommandWithTimeout(
+                        'openclaw skills list --json',
+                        10000
+                    );
+                }
+                if (cliResult.exitCode === 0 && cliResult.stdout?.trim()) {
+                    const parsed = JSON.parse(cliResult.stdout.trim());
+                    const raw: any[] = Array.isArray(parsed) ? parsed
+                        : Array.isArray(parsed?.skills) ? parsed.skills
+                        : parsed?.data ?? [];
+                    tools = raw
+                        .filter((s: any) => s['user-invocable'] !== false && s['user-invocable'] !== 'false')
+                        .map((s: any) => ({
+                            name: s.name ?? s.id ?? '',
+                            description: s.description ?? s.desc ?? '',
+                            category: s.category ?? '',
+                            userInvocable: true,
+                        }))
+                        .filter((t: any) => t.name);
+                }
+            } catch (_) {}
+
+            // Fallback: scan ~/.openclaw for all skills/ subdirs, deduplicated
+            if (tools.length === 0) {
+                try {
+                    // eslint-disable-next-line @typescript-eslint/no-var-requires
+                    const fs = (globalThis as any).require?.('fs') ?? require('fs');
+                    // eslint-disable-next-line @typescript-eslint/no-var-requires
+                    const path = (globalThis as any).require?.('path') ?? require('path');
+                    const cfg = runtime.config.loadConfig();
+                    const proc = (globalThis as any).process;
+                    const home = proc?.env?.HOME ?? proc?.env?.USERPROFILE ?? '~';
+                    const ocRoot = `${home}/.openclaw`;
+
+                    // Collect all skills/ directories under ~/.openclaw recursively (depth 2)
+                    const skillDirs: string[] = [];
+                    const addSkillsDir = (dir: string) => {
+                        try {
+                            if (fs.existsSync(dir)) skillDirs.push(dir);
+                        } catch (_) {}
+                    };
+
+                    // ~/.openclaw/skills
+                    addSkillsDir(`${ocRoot}/skills`);
+
+                    // ~/.openclaw/*/skills  (workspace dirs one level deep)
+                    try {
+                        for (const entry of fs.readdirSync(ocRoot)) {
+                            const sub = path.join(ocRoot, entry, 'skills');
+                            addSkillsDir(sub);
+                        }
+                    } catch (_) {}
+
+                    // Extra dirs from config
+                    for (const d of (cfg?.skills?.load?.extraDirs ?? [])) addSkillsDir(d);
+
+                    const seen = new Set<string>();
+                    for (const dir of skillDirs) {
+                        let entries: string[];
+                        try { entries = fs.readdirSync(dir); } catch (_) { continue; }
+                        for (const entry of entries) {
+                            const skillFile = path.join(dir, entry, 'SKILL.md');
+                            let content: string;
+                            try { content = fs.readFileSync(skillFile, 'utf8'); } catch (_) { continue; }
+                            const fm = _parseSkillFrontmatter(content);
+                            const name: string = fm.name ?? entry;
+                            if (!name || seen.has(name)) continue;
+                            seen.add(name);
+                            if (fm['user-invocable'] === false || fm['user-invocable'] === 'false') continue;
+                            if (cfg?.skills?.entries?.[name]?.enabled === false) continue;
+                            tools.push({ name, description: fm.description ?? '', category: '', userInvocable: true });
+                        }
+                    }
+                } catch (_) {}
+            }
+
+            await sendRpcReply({ tools });
+        } else if (method === "tools.invoke") {
+            // Invoke a skill by injecting a /skill <name> command into the chat session
+            const toolName = params.name as string | undefined;
+            const input = (params.params?.input ?? params.input ?? '') as string;
+            if (!toolName) {
+                await sendRpcReply(null, "tools.invoke: missing required param 'name'");
+            } else {
+                try {
+                    // Send /skill <name> [input] as a chat message to the current session
+                    const cmd = input ? `/skill ${toolName} ${input}` : `/skill ${toolName}`;
+                    const wireSessionKey = replySessionKey ?? 'rpc';
+                    await handleInbound(ctx, accountId, {
+                        type: 'message',
+                        content: cmd,
+                        sessionKey: wireSessionKey,
+                        chatSessionKey: wireSessionKey,
+                    });
+                    await sendRpcReply({ dispatched: true, command: cmd });
+                } catch (e: any) {
+                    await sendRpcReply(null, `tools.invoke '${toolName}' error: ${e}`);
+                }
+            }
         } else {
             await sendRpcReply(null, `Unknown RPC method: ${method}`);
         }
@@ -1025,13 +1179,17 @@ async function handleInbound(ctx: any, accountId: string, msg: any) {
         });
 
         // Derive an isolated Gateway session for each mobile conversation.
-        // If the app provides an agentId, route to that agent's session:
-        //   agent:<agentId>:mobile-<appSessionKey>
-        // Otherwise fall back to the default main agent route.
-        let sessionKey: string;
+        //
+        // chatSessionKey format from app: "agent:<agentId>:<uuid1>-<uuid2>"
+        // We use this as the stable per-conversation identity on the Gateway side.
+        // appSessionKey is the wire-level connection ID — used for E2E reply routing.
         const appSessionKey = msg.sessionKey ? String(msg.sessionKey) : null;
         const msgAgentId = msg.agentId ? String(msg.agentId) : null;
-        if (appSessionKey) {
+        let sessionKey: string;
+        if (chatSessionKey) {
+            // chatSessionKey from app: "agent:<agentId>:<uuid>" — use as-is for Gateway routing
+            sessionKey = chatSessionKey;
+        } else if (appSessionKey) {
             const agentId = msgAgentId || 'main';
             sessionKey = `agent:${agentId}:mobile-${appSessionKey}`;
         } else {
@@ -1204,3 +1362,28 @@ export default function register(api: any) {
 
     api.logger?.info?.("[openclaw-app] Plugin registered");
 }
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+/**
+ * Parse YAML frontmatter from a SKILL.md string.
+ * Returns a flat key→value map for simple scalar fields.
+ * Handles: name, description, user-invocable, disable-model-invocation, command-dispatch.
+ */
+function _parseSkillFrontmatter(content: string): Record<string, any> {
+    const result: Record<string, any> = {};
+    const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (!match) return result;
+    for (const line of match[1].split('\n')) {
+        const colon = line.indexOf(':');
+        if (colon === -1) continue;
+        const key = line.slice(0, colon).trim();
+        const val = line.slice(colon + 1).trim();
+        if (!key) continue;
+        // Parse booleans
+        if (val === 'true') result[key] = true;
+        else if (val === 'false') result[key] = false;
+        else result[key] = val;
+    }
+    return result;
+}

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
     "id": "openclaw-app",
     "name": "OpenClaw App",
-    "version": "1.1.5",
+    "version": "1.1.7",
     "description": "Mobile app channel for OpenClaw — chat via the OpenClaw App app through a Cloudflare Worker relay.",
     "channels": [
         "openclaw-app"

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "openclaw-app",
-    "version": "1.1.5",
+    "version": "1.1.7",
     "description": "OpenClaw App channel plugin — relay bridge for the OpenClaw App app",
     "main": "index.ts",
     "type": "module",