rol-websocket-channel 1.1.3 → 1.1.4

package/index.ts

@@ -536,6 +536,7 @@ async function handleCustomMessageType(
   accountId: string,
   mqttTopic: string,
 ): Promise<void> {
+  const isSkillInstallFlow = msgType === "skillsInstallFromClawHub" || msgType === "skillsUpdateFromClawHub";
   const response: any = {
     type: "receiver",
     trace_id: traceId,
@@ -543,6 +544,12 @@ async function handleCustomMessageType(
     timestamp: Date.now(),
   };
 
+  if (isSkillInstallFlow) {
+    console.log(
+      `[rol-websocket-channel] custom message start: type=${msgType}, traceId=${traceId}, slug=${innerData?.slug ?? ""}, accountId=${accountId}, topic=${mqttTopic}`,
+    );
+  }
+
   const handlerMethod = (messageHandler as any)[msgType];
   if (typeof handlerMethod === "function") {
     try {
@@ -561,15 +568,34 @@ async function handleCustomMessageType(
         response.data = methodResult.result;
         if (!methodResult.ok) {
           response.error = methodResult.error?.message || "Unknown error";
+          if (isSkillInstallFlow) {
+            console.error(
+              `[rol-websocket-channel] custom message failed: type=${msgType}, traceId=${traceId}, slug=${innerData?.slug ?? ""}, error=${response.error}, detail=${JSON.stringify(methodResult.error?.data ?? {})}`,
+            );
+          }
+        } else if (isSkillInstallFlow) {
+          console.log(
+            `[rol-websocket-channel] custom message success: type=${msgType}, traceId=${traceId}, slug=${innerData?.slug ?? ""}`,
+          );
         }
       } else {
         // 旧格式：直接返回数据
         response.success = true;
         response.data = methodResult;
+        if (isSkillInstallFlow) {
+          console.log(
+            `[rol-websocket-channel] custom message success: type=${msgType}, traceId=${traceId}, slug=${innerData?.slug ?? ""}`,
+          );
+        }
       }
     } catch (handlerErr: any) {
       response.success = false;
       response.error = handlerErr.message;
+      if (isSkillInstallFlow) {
+        console.error(
+          `[rol-websocket-channel] custom message threw: type=${msgType}, traceId=${traceId}, slug=${innerData?.slug ?? ""}, error=${handlerErr?.message ?? String(handlerErr)}`,
+        );
+      }
     }
   } else {
     response.success = false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rol-websocket-channel",
-  "version": "1.1.3",
+  "version": "1.1.4",
   "description": "Unified OpenClaw plugin: MQTT Channel + Admin Bridge for remote management",
   "license": "MIT",
   "author": "nixgnehc",

package/src/admin/methods/sessions-extended.ts

@@ -21,6 +21,9 @@ export const getSession: MethodHandler = async (
   context
 ): Promise<JsonValue> => {
   const objectParams = isObject(params) ? params : {};
+  const agentId = typeof objectParams.agentId === 'string' && objectParams.agentId.trim()
+    ? objectParams.agentId.trim()
+    : undefined;
   const sessionId = typeof objectParams.sessionId === 'string' ? objectParams.sessionId : null;
   const requestedLimit = typeof objectParams.limit === 'number' ? objectParams.limit : MAX_SESSION_MESSAGES;
   const requestedOffset = typeof objectParams.offset === 'number' ? objectParams.offset : 0;
@@ -34,11 +37,11 @@ export const getSession: MethodHandler = async (
     );
   }
 
-  const session = await findSessionRecord(context, sessionId);
+  const session = await findSessionRecord(context, sessionId, agentId);
   if (!session) {
     throw new JsonRpcException(
       JSON_RPC_ERRORS.invalidParams,
-      `Session not found: ${sessionId}`
+      agentId ? `Session not found: ${sessionId} for agent ${agentId}` : `Session not found: ${sessionId}`
     );
   }
 
@@ -52,6 +55,7 @@ export const getSession: MethodHandler = async (
   const messages = await readSessionMessages(sessionFile, limit, offset);
 
   return {
+    agentId: session.agentId,
     agentName: session.agentName,
     sessionId: session.sessionId ?? sessionId,
     sessionKey: session.sessionKey,
@@ -76,6 +80,9 @@ export const prepareMessage: MethodHandler = async (
   context
 ): Promise<JsonValue> => {
   const objectParams = isObject(params) ? params : {};
+  const agentId = typeof objectParams.agentId === 'string' && objectParams.agentId.trim()
+    ? objectParams.agentId.trim()
+    : undefined;
   const sessionId = typeof objectParams.sessionId === 'string' ? objectParams.sessionId : null;
   const message = typeof objectParams.message === 'string' ? objectParams.message : null;
   const attachedSkills = Array.isArray(objectParams.attachedSkills) ? objectParams.attachedSkills : [];
@@ -94,15 +101,16 @@ export const prepareMessage: MethodHandler = async (
     );
   }
 
-  const session = await findSessionRecord(context, sessionId);
+  const session = await findSessionRecord(context, sessionId, agentId);
   if (!session) {
     throw new JsonRpcException(
       JSON_RPC_ERRORS.invalidParams,
-      `Session not found: ${sessionId}`
+      agentId ? `Session not found: ${sessionId} for agent ${agentId}` : `Session not found: ${sessionId}`
     );
   }
 
   const messageData: any = {
+    agentId: session.agentId,
     agentName: session.agentName,
     sessionId: session.sessionId ?? sessionId,
     sessionKey: session.sessionKey,

package/src/admin/methods/sessions.ts

@@ -26,6 +26,7 @@ interface SessionsIndexEntry {
 type SessionsIndex = Record<string, SessionsIndexEntry>;
 
 export interface AgentSessionRecord {
+  agentId: string;
   agentName: string;
   sessionKey: string;
   sessionId: string | null;
@@ -41,17 +42,24 @@ export interface AgentSessionRecord {
 }
 
 export const listSessions: MethodHandler = async (
-  _params,
+  params,
   context
 ): Promise<JsonValue> => {
-  const items = await listAllAgentSessions(context);
+  const objectParams = isObject(params) ? params : {};
+  const agentId = typeof objectParams.agentId === 'string' && objectParams.agentId.trim()
+    ? objectParams.agentId.trim()
+    : undefined;
+  const items = await listAllAgentSessions(context, agentId);
   return {
     count: items.length,
     items
   };
 };
 
-export async function listAllAgentSessions(context: MethodContext): Promise<AgentSessionRecord[]> {
+export async function listAllAgentSessions(
+  context: MethodContext,
+  agentId?: string
+): Promise<AgentSessionRecord[]> {
   const agentsRoot = path.join(context.openclawRoot, 'agents');
   if (!(await pathExists(agentsRoot))) {
     return [];
@@ -66,6 +74,10 @@ export async function listAllAgentSessions(context: MethodContext): Promise<Agen
     }
 
     const agentName = agentEntry.name;
+    if (agentId && agentName !== agentId) {
+      continue;
+    }
+
     const sessionsPath = path.join(agentsRoot, agentName, 'sessions', 'sessions.json');
     if (!(await pathExists(sessionsPath))) {
       continue;
@@ -75,6 +87,7 @@ export async function listAllAgentSessions(context: MethodContext): Promise<Agen
     for (const [sessionKey, entry] of Object.entries(sessions)) {
       const sessionId = entry.sessionId ?? extractSessionIdFromFile(entry.sessionFile) ?? null;
       items.push({
+        agentId: agentName,
         agentName,
         sessionKey,
         sessionId,
@@ -98,20 +111,26 @@ export async function listAllAgentSessions(context: MethodContext): Promise<Agen
 
 export async function findSessionRecord(
   context: MethodContext,
-  sessionIdOrKey: string
+  sessionIdOrKey: string,
+  agentId?: string
 ): Promise<AgentSessionRecord | null> {
-  const sessions = await listAllAgentSessions(context);
+  const sessions = await listAllAgentSessions(context, agentId);
   return sessions.find((item) => item.sessionId === sessionIdOrKey || item.sessionKey === sessionIdOrKey) ?? null;
 }
 
 export async function resolveSessionFile(
   context: MethodContext,
-  sessionIdOrKey: string
+  sessionIdOrKey: string,
+  agentId?: string
 ): Promise<string | null> {
-  const session = await findSessionRecord(context, sessionIdOrKey);
+  const session = await findSessionRecord(context, sessionIdOrKey, agentId);
   return session?.sessionFilePath ?? null;
 }
 
+function isObject(value: JsonValue | undefined): value is Record<string, JsonValue> {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
 function extractSessionIdFromFile(sessionFile: string | undefined): string | null {
   if (!sessionFile) {
     return null;

package/src/admin/methods/skills.ts

@@ -143,7 +143,7 @@ export const searchClawHubSkills: MethodHandler = async (params, context): Promi
   const objectParams = isObject(params) ? params : {};
   const query = typeof objectParams.query === 'string' ? objectParams.query.trim() : '';
   const args = query ? ['skills', 'search', query, '--json'] : ['skills', 'search', '--json'];
-  const result = await runOpenClawSkillCommand(args, context.projectRoot);
+  const result = await runOpenClawSkillCommand(args, context.openclawRoot, context.openclawRoot);
 
   return {
     ok: true,
@@ -155,7 +155,7 @@ export const searchClawHubSkills: MethodHandler = async (params, context): Promi
 export const installSkillFromClawHub: MethodHandler = async (params, context): Promise<JsonValue> => {
   const objectParams = expectObject(params) as unknown as ClawHubSkillParams;
   const slug = expectString(objectParams.slug, 'slug');
-  const result = await runOpenClawSkillCommand(['skills', 'install', slug], context.projectRoot);
+  const result = await runOpenClawSkillCommand(['skills', 'install', slug], context.openclawRoot, context.openclawRoot);
 
   return {
     ok: true,
@@ -167,7 +167,7 @@ export const installSkillFromClawHub: MethodHandler = async (params, context): P
 export const updateSkillFromClawHub: MethodHandler = async (params, context): Promise<JsonValue> => {
   const objectParams = expectObject(params) as unknown as ClawHubSkillParams;
   const slug = expectString(objectParams.slug, 'slug');
-  const result = await runOpenClawSkillCommand(['skills', 'update', slug], context.projectRoot);
+  const result = await runOpenClawSkillCommand(['skills', 'update', slug], context.openclawRoot, context.openclawRoot);
 
   return {
     ok: true,
@@ -233,27 +233,42 @@ async function npmPack(packageSpec: string, cwd: string): Promise<string> {
 
 async function runOpenClawSkillCommand(
   args: string[],
-  cwd: string
+  cwd: string,
+  openclawRoot?: string
 ): Promise<{ stdout: string; stderr: string; parsed: JsonValue | null }> {
   const command = process.env.OPENCLAW_BIN || 'openclaw';
-  const options = buildOpenClawExecOptions(cwd);
+  const options = buildOpenClawExecOptions(cwd, openclawRoot);
+  const openclawBin = process.env.OPENCLAW_BIN || '';
+  const openclawHome = options.env?.OPENCLAW_HOME || '';
+
+  console.log(
+    `[skills] exec start: command=${command}, args=${JSON.stringify(args)}, cwd=${cwd}, OPENCLAW_BIN=${openclawBin}, OPENCLAW_HOME=${openclawHome}`
+  );
 
   try {
     const { stdout, stderr } = await execFileAsync(command, args, options);
+    console.log(
+      `[skills] exec success: command=${command}, args=${JSON.stringify(args)}, stdoutLength=${stdout.length}, stderrLength=${stderr.length}`
+    );
     return {
       stdout,
       stderr,
       parsed: parseJsonOutput(stdout)
     };
   } catch (err: any) {
+    const stdout = typeof err?.stdout === 'string' ? err.stdout : '';
+    const stderr = typeof err?.stderr === 'string' ? err.stderr : '';
+    console.error(
+      `[skills] exec failed: command=${command}, args=${JSON.stringify(args)}, cwd=${cwd}, OPENCLAW_BIN=${openclawBin}, OPENCLAW_HOME=${openclawHome}, stdout=${JSON.stringify(stdout)}, stderr=${JSON.stringify(stderr)}`
+    );
     throw new JsonRpcException(
       JSON_RPC_ERRORS.internalError,
       `OpenClaw skill command failed: ${err instanceof Error ? err.message : String(err)}`,
       {
         command,
         args,
-        stdout: typeof err?.stdout === 'string' ? err.stdout : '',
-        stderr: typeof err?.stderr === 'string' ? err.stderr : ''
+        stdout,
+        stderr
       }
     );
   }
@@ -274,7 +289,7 @@ function parseJsonOutput(stdout: string): JsonValue | null {
 
 async function queryOpenClawSkills(context: MethodContext): Promise<unknown[]> {
   const command = process.env.OPENCLAW_BIN || 'openclaw';
-  const options = buildOpenClawExecOptions(context.projectRoot);
+  const options = buildOpenClawExecOptions(context.openclawRoot, context.openclawRoot);
 
   try {
     const { stdout } = await execFileAsync(command, ['skills', 'list', '--json'], options);
@@ -300,15 +315,38 @@ async function queryOpenClawSkills(context: MethodContext): Promise<unknown[]> {
   }
 }
 
-function buildOpenClawExecOptions(cwd: string): { cwd: string; shell?: boolean } {
+function buildOpenClawExecOptions(
+  cwd: string,
+  openclawRoot?: string
+): { cwd: string; shell?: boolean; env: NodeJS.ProcessEnv } {
+  const env: NodeJS.ProcessEnv = { ...process.env };
+  const openclawHome = resolveOpenClawHomeForCli(openclawRoot);
+  if (openclawHome) {
+    env.OPENCLAW_HOME = openclawHome;
+  }
+
   if (process.platform === 'win32') {
     return {
       cwd,
-      shell: true
+      shell: true,
+      env
     };
   }
 
-  return { cwd };
+  return { cwd, env };
+}
+
+function resolveOpenClawHomeForCli(openclawRoot?: string): string | undefined {
+  if (!openclawRoot) {
+    return process.env.OPENCLAW_HOME;
+  }
+
+  const resolvedRoot = path.resolve(openclawRoot);
+  if (path.basename(resolvedRoot) === '.openclaw') {
+    return path.dirname(resolvedRoot);
+  }
+
+  return process.env.OPENCLAW_HOME;
 }
 
 function normalizeCliSkill(