@spzhongwin/skill-logger-plugin 1.0.18 → 1.0.20

package/src/ws-client.test.ts

@@ -5,6 +5,7 @@ import os from "node:os";
 import path from "node:path";
 import { DatabaseSync } from "node:sqlite";
 import {
+  GatewayWsClient,
   normalizeAssistantUserId,
   normalizeCommandCode,
   enabledAgentIdsFromAccounts,
@@ -17,6 +18,151 @@ import {
   isGatewaySkillCommand,
 } from "./ws-client.ts";
 
+async function handleClientMessage(
+  client: GatewayWsClient,
+  message: Record<string, unknown>,
+): Promise<void> {
+  await (client as unknown as { handleMessage(value: Record<string, unknown>): Promise<void> }).handleMessage(message);
+}
+
+function createReplyingClient(gatewayId: string): { client: GatewayWsClient; replies: Record<string, unknown>[] } {
+  const replies: Record<string, unknown>[] = [];
+  const client = new GatewayWsClient({
+    serverUrl: "ws://localhost:1",
+    gatewayId,
+    updater: {} as never,
+  });
+  const socket = {
+    readyState: 1,
+    send(payload: string, callback?: (error?: Error) => void) {
+      replies.push(JSON.parse(payload) as Record<string, unknown>);
+      callback?.();
+    },
+  };
+  Object.assign(client as object, { ws: socket });
+  return { client, replies };
+}
+
+describe("LIST_FREE_SKILLS", () => {
+  it("通过 action 分发扫描当前 workspace，并返回来源明确的路径字段", async () => {
+    const workspace = fs.mkdtempSync(path.join(os.tmpdir(), "free-skill-ws-client-"));
+    try {
+      const skillPath = path.join(workspace, ".xg-platform", "demo");
+      fs.mkdirSync(skillPath, { recursive: true });
+      fs.writeFileSync(
+        path.join(skillPath, "SKILL.md"),
+        "---\nname: Demo\ndescription: local demo\nversion: 1.2.3\n---\n",
+      );
+
+      const { client, replies } = createReplyingClient("gateway-local-1");
+      Object.assign(client as object, {
+        resolveRegularSkillContext: async () => ({
+          skillsDir: path.join(workspace, "skills"),
+          localAgentId: "sales-agent",
+          workspace,
+        }),
+      });
+      await handleClientMessage(client, {
+        action: "LIST_FREE_SKILLS",
+        userId: "12345",
+        agentId: "injected-agent-must-be-ignored",
+        workspace: path.join(workspace, "..", "external-workspace"),
+        replyId: "free-1",
+      });
+
+      const hostSkillFilePath = fs.realpathSync(path.join(skillPath, "SKILL.md"));
+      assert.deepEqual(replies, [{
+        type: "REPLY",
+        replyId: "free-1",
+        success: true,
+        action: "LIST_FREE_SKILLS",
+        data: {
+          gatewayId: "gateway-local-1",
+          agentId: "sales-agent",
+          directoryPath: fs.realpathSync(path.join(workspace, ".xg-platform")),
+          skills: [{
+            code: "demo",
+            name: "Demo",
+            description: "local demo",
+            version: "1.2.3",
+            workspaceRelativePath: path.join(".xg-platform", "demo"),
+            skillFilePath: path.join(".xg-platform", "demo", "SKILL.md"),
+            hostSkillFilePath,
+          }],
+        },
+      }]);
+    } finally {
+      fs.rmSync(workspace, { recursive: true, force: true });
+    }
+  });
+
+  it("忽略请求注入的外部 workspace 和 agentId，只使用解析出的 Agent workspace", async () => {
+    const workspace = fs.mkdtempSync(path.join(os.tmpdir(), "free-skill-resolved-ws-"));
+    const externalWorkspace = fs.mkdtempSync(path.join(os.tmpdir(), "free-skill-injected-ws-"));
+    try {
+      const safeSkillPath = path.join(workspace, ".xg-platform", "safe");
+      fs.mkdirSync(safeSkillPath, { recursive: true });
+      fs.writeFileSync(path.join(safeSkillPath, "SKILL.md"), "---\nname: Safe\n---\n");
+
+      const externalSkillPath = path.join(externalWorkspace, ".xg-platform", "outside");
+      fs.mkdirSync(externalSkillPath, { recursive: true });
+      fs.writeFileSync(path.join(externalSkillPath, "SKILL.md"), "---\nname: Outside\n---\n");
+
+      const { client, replies } = createReplyingClient("gateway-local-2");
+      Object.assign(client as object, {
+        resolveRegularSkillContext: async () => ({
+          skillsDir: path.join(workspace, "skills"),
+          localAgentId: "resolved-agent",
+          workspace,
+        }),
+      });
+      await handleClientMessage(client, {
+        action: "LIST_FREE_SKILLS",
+        userId: "12345",
+        agentId: "injected-agent",
+        workspace: externalWorkspace,
+        workspacePath: externalWorkspace,
+        agentWorkspace: externalWorkspace,
+        replyId: "free-isolated",
+      });
+
+      const response = replies[0] as { data: Record<string, unknown> };
+      assert.equal(response.data.agentId, "resolved-agent");
+      assert.equal(response.data.directoryPath, fs.realpathSync(path.join(workspace, ".xg-platform")));
+      assert.deepEqual(response.data.skills, [{
+        code: "safe",
+        name: "Safe",
+        description: "",
+        version: "",
+        workspaceRelativePath: path.join(".xg-platform", "safe"),
+        skillFilePath: path.join(".xg-platform", "safe", "SKILL.md"),
+        hostSkillFilePath: fs.realpathSync(path.join(safeSkillPath, "SKILL.md")),
+      }]);
+    } finally {
+      fs.rmSync(workspace, { recursive: true, force: true });
+      fs.rmSync(externalWorkspace, { recursive: true, force: true });
+    }
+  });
+
+  it("缺少 userId 时返回明确错误，不静默丢弃新 action", async () => {
+    const { client, replies } = createReplyingClient("gateway-local-1");
+
+    await handleClientMessage(client, {
+      action: "LIST_FREE_SKILLS",
+      replyId: "free-missing-user",
+    });
+
+    assert.deepEqual(replies, [{
+      type: "REPLY",
+      replyId: "free-missing-user",
+      success: false,
+      error: "INVALID_REQUEST",
+      message: "Missing userId parameter",
+      action: "LIST_FREE_SKILLS",
+    }]);
+  });
+});
+
 describe("command code boundary", () => {
   it("只接受单一路径段，不静默改写路径穿越输入", () => {
     assert.equal(normalizeCommandCode("demo-skill"), "demo-skill");

package/src/ws-client.ts

@@ -5,6 +5,7 @@ import { DatabaseSync } from "node:sqlite";
 import { SkillUpdater } from "./updater.ts";
 import { openclawHome } from "./paths.ts";
 import { readSkillVersion } from "./skill-version.ts";
+import { scanFreeSkillDirectory, type FreeSkill } from "./free-skill-directory.ts";
 
 const HEARTBEAT_INTERVAL_MS = 30_000;
 const HEARTBEAT_ACK_TIMEOUT_MS = 75_000;
@@ -184,6 +185,73 @@ export function readCronJobsByAgentId(
   }
 }
 
+export type FreeSkillDirectorySkill = Pick<FreeSkill, "code" | "name" | "description" | "version"> & {
+  workspaceRelativePath: string;
+  skillFilePath: string;
+  hostSkillFilePath: string;
+};
+
+export type FreeSkillDirectoryResponse = {
+  gatewayId: string;
+  agentId: string;
+  directoryPath: string;
+  skills: FreeSkillDirectorySkill[];
+};
+
+function isWithinPath(parent: string, candidate: string): boolean {
+  const relative = path.relative(parent, candidate);
+  return relative === "" || (relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative));
+}
+
+function relativeWorkspacePath(workspace: string, target: string): string {
+  const relative = path.relative(workspace, target);
+  return isWithinPath(workspace, target) ? relative : "";
+}
+
+async function resolveRealWorkspace(workspace: string): Promise<string> {
+  const resolved = path.resolve(workspace);
+  try {
+    return await fs.realpath(resolved);
+  } catch {
+    return resolved;
+  }
+}
+
+async function resolveFreeSkillDirectoryPath(workspace: string): Promise<string> {
+  const workspacePath = await resolveRealWorkspace(workspace);
+  const candidate = path.resolve(workspacePath, ".xg-platform");
+  try {
+    const directoryPath = await fs.realpath(candidate);
+    const stat = await fs.stat(directoryPath);
+    return stat.isDirectory() && isWithinPath(workspacePath, directoryPath) ? directoryPath : "";
+  } catch {
+    return "";
+  }
+}
+
+function buildFreeSkillDirectoryResponse(
+  gatewayId: string,
+  agentId: string,
+  workspacePath: string,
+  directoryPath: string,
+  skills: FreeSkill[],
+): FreeSkillDirectoryResponse {
+  return {
+    gatewayId,
+    agentId,
+    directoryPath,
+    skills: skills.map((skill) => ({
+      code: skill.code,
+      name: skill.name,
+      description: skill.description,
+      version: skill.version,
+      workspaceRelativePath: relativeWorkspacePath(workspacePath, skill.skillPath),
+      skillFilePath: relativeWorkspacePath(workspacePath, skill.skillFilePath),
+      hostSkillFilePath: skill.skillFilePath,
+    })),
+  };
+}
+
 export interface WsClientOptions {
   serverUrl: string;       // 例如: wss://api.aishuo.co/gateway/ws
   authToken?: string;      // 用于网关鉴权
@@ -239,16 +307,28 @@ export class GatewayWsClient {
     };
   }
 
-  /** 普通 Skill 的所有读写操作共用这一个配置驱动的寻址入口。 */
-  private async resolveRegularSkillTarget(userId: string): Promise<string> {
+  private async readOpenclawConfig(): Promise<unknown> {
     const configPath = path.join(openclawHome(), "openclaw.json");
-    let config: unknown;
     try {
-      config = JSON.parse(await fs.readFile(configPath, "utf-8"));
+      return JSON.parse(await fs.readFile(configPath, "utf-8"));
     } catch (err: any) {
       throw new Error(`无法读取 openclaw.json: ${err?.message || String(err)}`);
     }
-    return resolveSkillInstallTarget(config, userId).skillsDir;
+  }
+
+  private async resolveRegularSkillContext(userId: string): Promise<SkillInstallTarget & { workspace: string }> {
+    const target = resolveSkillInstallTarget(await this.readOpenclawConfig(), userId);
+    return { ...target, workspace: path.dirname(target.skillsDir) };
+  }
+
+  /** 普通 Skill 的所有读写操作共用这一个配置驱动的寻址入口。 */
+  private async resolveRegularSkillTarget(userId: string): Promise<string> {
+    return (await this.resolveRegularSkillContext(userId)).skillsDir;
+  }
+
+  private async resolveFreeSkillRequestContext(userId: string): Promise<{ workspace: string; agentId: string }> {
+    const target = await this.resolveRegularSkillContext(userId);
+    return { workspace: target.workspace, agentId: target.localAgentId };
   }
 
   constructor(options: WsClientOptions) {
@@ -588,6 +668,14 @@ export class GatewayWsClient {
 
     if (!userId) {
       this.appendLogToFile("WARN", "Command", `Message dropped: missing userId`, msg);
+      if (action === "LIST_FREE_SKILLS") {
+        this.reply(replyId, {
+          success: false,
+          error: "INVALID_REQUEST",
+          message: "Missing userId parameter",
+          action,
+        });
+      }
       return;
     }
 
@@ -640,6 +728,21 @@ export class GatewayWsClient {
           data: {code: safeCode, installScope: gatewaySkillCommand ? "gateway" : "agent", removed: true},
         });
 
+      } else if (action === "LIST_FREE_SKILLS") {
+        const context = await this.resolveFreeSkillRequestContext(userId);
+        const workspacePath = await resolveRealWorkspace(context.workspace);
+        const scannedSkills = await scanFreeSkillDirectory(context.workspace);
+        const directoryPath = scannedSkills[0]?.directoryPath
+          || await resolveFreeSkillDirectoryPath(context.workspace);
+        const data = buildFreeSkillDirectoryResponse(
+          this.options.gatewayId,
+          context.agentId,
+          workspacePath,
+          directoryPath,
+          scannedSkills,
+        );
+        this.reply(replyId, { success: true, data, action });
+
       } else if (action === "LIST_SKILLS") {
         const regularTargetDir = await this.resolveRegularSkillTarget(userId);
 
@@ -899,7 +1002,17 @@ export class GatewayWsClient {
       } else {
         console.warn(`[skill-logger-plugin][WS] Unknown action: ${action}`);
         this.appendLogToFile("WARN", "Command", `Unknown action: ${action}`);
-        this.reply(replyId, { success: false, message: `Unknown action: ${action}`, action });
+        if (action === "LIST_FREE_SKILLS") {
+          this.reply(replyId, {
+            success: false,
+            unsupported: true,
+            error: "UNSUPPORTED_ACTION",
+            message: "LIST_FREE_SKILLS unsupported by this plugin",
+            action,
+          });
+        } else {
+          this.reply(replyId, { success: false, message: `Unknown action: ${action}`, action });
+        }
       }
     } catch (err: any) {
       this.appendLogToFile("ERROR", "Command", `Error executing action ${action}`, err);