@workclaw/openclaw-workclaw 1.0.18 → 1.0.20

package/dist/src/api/session-api.js

@@ -0,0 +1,207 @@
+import { getWorkclawRuntime } from "../runtime.js";
+function sendJson(res, statusCode, payload) {
+    res.statusCode = statusCode;
+    res.setHeader("Content-Type", "application/json");
+    res.end(JSON.stringify(payload));
+}
+async function readRequestBody(req) {
+    const chunks = [];
+    await new Promise((resolve, reject) => {
+        req.on("data", (chunk) => {
+            chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        });
+        req.on("end", () => resolve());
+        req.on("error", (err) => reject(err));
+    });
+    return Buffer.concat(chunks).toString("utf-8");
+}
+/**
+ * 构建会话 key
+ * 格式: openclaw-workclaw:{accountId}:{userId}
+ */
+function buildSessionKey(accountId, userId) {
+    return `openclaw-workclaw:${accountId}:${userId}`;
+}
+/**
+ * 解析会话 key
+ */
+function parseSessionKey(sessionKey) {
+    const parts = sessionKey.split(":");
+    if (parts.length !== 3 || parts[0] !== "openclaw-workclaw") {
+        return null;
+    }
+    return {
+        channel: parts[0],
+        accountId: parts[1],
+        userId: parts[2],
+    };
+}
+/**
+ * 重置/开启新会话
+ * 通过发送系统事件 /new 到指定会话
+ */
+async function resetSession(sessionKey, log) {
+    try {
+        const runtime = getWorkclawRuntime();
+        // 使用 system.enqueueSystemEvent 发送 /new 命令
+        runtime.system.enqueueSystemEvent("/new", {
+            sessionKey,
+            contextKey: null,
+        });
+        log?.info?.(`[SessionAPI] Sent /new command to session: ${sessionKey}`);
+        return {
+            success: true,
+            message: `Session reset command sent to ${sessionKey}`,
+        };
+    }
+    catch (err) {
+        const errorMsg = `Failed to reset session: ${String(err)}`;
+        log?.error?.(`[SessionAPI] ${errorMsg}`);
+        return { success: false, message: errorMsg };
+    }
+}
+/**
+ * 获取会话存储路径
+ */
+function getSessionStorePath(agentId, log) {
+    try {
+        const runtime = getWorkclawRuntime();
+        const storePath = runtime.channel.session.resolveStorePath(undefined, {
+            agentId,
+        });
+        return storePath;
+    }
+    catch (err) {
+        log?.error?.(`[SessionAPI] Failed to resolve store path: ${String(err)}`);
+        return null;
+    }
+}
+/**
+ * 读取会话最后更新时间
+ */
+async function getSessionLastUpdated(sessionKey, log) {
+    try {
+        const runtime = getWorkclawRuntime();
+        const storePath = runtime.channel.session.resolveStorePath();
+        const updatedAt = runtime.channel.session.readSessionUpdatedAt({
+            storePath,
+            sessionKey,
+        });
+        return updatedAt ?? null;
+    }
+    catch (err) {
+        log?.error?.(`[SessionAPI] Failed to read session updated at: ${String(err)}`);
+        return null;
+    }
+}
+export function createSessionApiHandler(api) {
+    return async (req, res) => {
+        const method = String(req.method ?? "GET").toUpperCase();
+        const url = new URL(req.url ?? "", "http://localhost");
+        // 移除尾部斜杠并获取路径部分
+        const fullPath = url.pathname.replace(/\/+$/, "");
+        // 提取子路径（去掉 /openclaw-workclaw/sessions 前缀）
+        const subPath = fullPath.replace(/^\/openclaw-workclaw\/sessions/, "").replace(/^\//, "") || "/";
+        const log = {
+            info: (msg) => api.logger?.info?.(`[SessionAPI] ${msg}`),
+            error: (msg) => api.logger?.error?.(`[SessionAPI] ${msg}`),
+        };
+        log?.info?.(`[SessionAPI] ${method} ${fullPath} (subPath: ${subPath})`);
+        // GET /sessions 或 /sessions/ - 列出会话信息
+        if (method === "GET" && (subPath === "/" || subPath === "")) {
+            const sessionKey = url.searchParams.get("sessionKey");
+            if (sessionKey) {
+                // 获取特定会话信息
+                const parsed = parseSessionKey(sessionKey);
+                const updatedAt = await getSessionLastUpdated(sessionKey, log);
+                sendJson(res, 200, {
+                    ok: true,
+                    session: {
+                        sessionKey,
+                        parsed,
+                        lastUpdatedAt: updatedAt,
+                        lastUpdatedAtFormatted: updatedAt
+                            ? new Date(updatedAt).toISOString()
+                            : null,
+                    },
+                });
+                return;
+            }
+            // 返回 API 信息
+            sendJson(res, 200, {
+                ok: true,
+                message: "Session Management API",
+                endpoints: {
+                    "GET /sessions": "获取会话信息 (可选参数: sessionKey)",
+                    "POST /sessions/reset": "重置/开启新会话 (参数: accountId + userId 或直接提供 sessionKey)",
+                    "GET /sessions/store-path": "获取会话存储路径 (可选参数: agentId)",
+                },
+            });
+            return;
+        }
+        // POST /sessions/reset - 重置会话
+        if (method === "POST" && subPath === "reset") {
+            const raw = await readRequestBody(req);
+            let input = {};
+            try {
+                input = raw ? JSON.parse(raw) : {};
+            }
+            catch {
+                sendJson(res, 400, { ok: false, error: "Invalid JSON" });
+                return;
+            }
+            const { accountId, userId, sessionKey: directSessionKey } = input;
+            let sessionKey;
+            if (directSessionKey) {
+                sessionKey = directSessionKey;
+            }
+            else if (accountId && userId) {
+                sessionKey = buildSessionKey(accountId, userId);
+            }
+            else {
+                sendJson(res, 400, {
+                    ok: false,
+                    error: "Missing required fields: either provide 'sessionKey' or both 'accountId' and 'userId'",
+                });
+                return;
+            }
+            const result = await resetSession(sessionKey, log);
+            if (result.success) {
+                sendJson(res, 200, {
+                    ok: true,
+                    message: result.message,
+                    sessionKey,
+                });
+            }
+            else {
+                sendJson(res, 500, {
+                    ok: false,
+                    error: result.message,
+                    sessionKey,
+                });
+            }
+            return;
+        }
+        // GET /sessions/store-path - 获取会话存储路径
+        if (method === "GET" && subPath === "store-path") {
+            const agentId = url.searchParams.get("agentId") ?? undefined;
+            const storePath = getSessionStorePath(agentId, log);
+            if (storePath) {
+                sendJson(res, 200, {
+                    ok: true,
+                    storePath,
+                    agentId: agentId ?? "default",
+                });
+            }
+            else {
+                sendJson(res, 500, {
+                    ok: false,
+                    error: "Failed to resolve session store path",
+                });
+            }
+            return;
+        }
+        // 404
+        sendJson(res, 404, { ok: false, error: "Not Found" });
+    };
+}

package/dist/src/api/skills-api.d.ts

@@ -0,0 +1,2 @@
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+export declare function createSkillsApiHandler(api: OpenClawPluginApi): (req: any, res: any) => Promise<void>;

package/dist/src/api/skills-api.js

@@ -0,0 +1,64 @@
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+const execAsync = promisify(exec);
+function sendJson(res, statusCode, payload) {
+    res.statusCode = statusCode;
+    res.setHeader("Content-Type", "application/json");
+    res.end(JSON.stringify(payload));
+}
+export function createSkillsApiHandler(api) {
+    return async (req, res) => {
+        const method = String(req.method ?? "GET").toUpperCase();
+        if (method === "GET") {
+            try {
+                // 调用 openclaw skills list 命令
+                const { stdout, stderr } = await execAsync("openclaw skills list --json", {
+                    timeout: 10000, // 10秒超时
+                });
+                if (stderr && !stdout) {
+                    api.logger.error(`Skills list error: ${stderr}`);
+                    sendJson(res, 500, { ok: false, error: "Failed to list skills" });
+                    return;
+                }
+                // 尝试解析JSON输出
+                let skillsData;
+                try {
+                    skillsData = JSON.parse(stdout);
+                }
+                catch {
+                    // 如果不支持--json输出，尝试解析文本输出
+                    const lines = stdout.split('\n');
+                    const skills = lines
+                        .filter((line) => line.trim() && !line.includes('Skills'))
+                        .map((line) => {
+                        const parts = line.split(/\s{2,}/).map((p) => p.trim());
+                        if (parts.length >= 3) {
+                            return {
+                                status: parts[0]?.includes('✓') ? 'ready' : 'missing',
+                                name: parts[1],
+                                description: parts[2],
+                                source: parts[3] || 'openclaw-bundled'
+                            };
+                        }
+                        return null;
+                    })
+                        .filter((s) => s !== null);
+                    skillsData = {
+                        total: skills.length,
+                        ready: skills.filter((s) => s.status === 'ready').length,
+                        missing: skills.filter((s) => s.status === 'missing').length,
+                        skills
+                    };
+                }
+                sendJson(res, 200, { ok: true, ...skillsData });
+                return;
+            }
+            catch (error) {
+                api.logger.error(`Skills API error: ${error.message}`);
+                sendJson(res, 500, { ok: false, error: error.message });
+                return;
+            }
+        }
+        sendJson(res, 405, { ok: false, error: "Method Not Allowed" });
+    };
+}

package/dist/src/api/workspace.d.ts

@@ -0,0 +1,3 @@
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+export declare function resolveWorkspaceDir(api: OpenClawPluginApi): string;
+export declare function isDefaultWorkspace(api: OpenClawPluginApi): boolean;

package/dist/src/api/workspace.js

@@ -0,0 +1,30 @@
+import os from "node:os";
+import path from "node:path";
+import { getWorkclawLogger } from "../runtime.js";
+export function resolveWorkspaceDir(api) {
+    const agents = api.config.agents?.list ?? [];
+    const defaultAgent = agents.find((agent) => agent?.default === true) ??
+        agents.find((agent) => String(agent?.id ?? "").toLowerCase() === "main");
+    const workspaceRaw = (typeof defaultAgent?.workspace === "string" && defaultAgent.workspace.trim()) ||
+        (typeof api.config.agents?.defaults?.workspace === "string" &&
+            api.config.agents.defaults.workspace.trim());
+    getWorkclawLogger().info(`workspaceRaw: ${workspaceRaw}`);
+    if (workspaceRaw) {
+        return api.resolvePath(workspaceRaw);
+    }
+    const profile = process.env.OPENCLAW_PROFILE?.trim();
+    const suffix = profile && profile.toLowerCase() !== "default" ? `workspace-${profile}` : "workspace";
+    return path.join(os.homedir(), ".openclaw", suffix);
+}
+export function isDefaultWorkspace(api) {
+    const agents = api.config.agents?.list ?? [];
+    const defaultAgent = agents.find((agent) => agent?.default === true) ??
+        agents.find((agent) => String(agent?.id ?? "").toLowerCase() === "main");
+    const workspaceRaw = (typeof defaultAgent?.workspace === "string" && defaultAgent.workspace.trim()) ||
+        (typeof api.config.agents?.defaults?.workspace === "string" &&
+            api.config.agents.defaults.workspace.trim());
+    if (workspaceRaw)
+        return false;
+    const profile = process.env.OPENCLAW_PROFILE?.trim();
+    return !profile || profile.toLowerCase() === "default";
+}

package/dist/src/channel.d.ts

@@ -0,0 +1,11 @@
+import type { ChannelPlugin } from "openclaw/plugin-sdk";
+import type { ResolvedWorkclawAccount } from "./types.js";
+export declare const workclawDock: {
+    id: string;
+    capabilities: {
+        chatTypes: string[];
+        media: boolean;
+        blockStreaming: boolean;
+    };
+};
+export declare const workclawPlugin: ChannelPlugin<ResolvedWorkclawAccount>;