@workclaw/openclaw-workclaw 1.0.18 → 1.0.19

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

@@ -0,0 +1,130 @@
+import { normalizeAccountId } from "../accounts.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");
+}
+async function loadRuntimeConfig(api) {
+    const runtimeConfig = api.runtime?.config;
+    if (runtimeConfig?.loadConfig) {
+        return runtimeConfig.loadConfig();
+    }
+    return api.config;
+}
+async function writeRuntimeConfig(api, config) {
+    const runtimeConfig = api.runtime?.config;
+    if (runtimeConfig?.writeConfigFile) {
+        await runtimeConfig.writeConfigFile(config);
+        return;
+    }
+    throw new Error("Config write not supported");
+}
+function getAccountMap(config) {
+    const channels = config?.channels && typeof config.channels === "object" ? config.channels : {};
+    const openclawWorkclaw = channels['openclaw-workclaw'] && typeof channels['openclaw-workclaw'] === "object" ? channels['openclaw-workclaw'] : {};
+    const accounts = openclawWorkclaw.accounts && typeof openclawWorkclaw.accounts === "object" ? openclawWorkclaw.accounts : {};
+    return { ...accounts };
+}
+function withAccounts(config, accounts) {
+    const channels = config?.channels && typeof config.channels === "object" ? config.channels : {};
+    const openclawWorkclaw = channels['openclaw-workclaw'] && typeof channels['openclaw-workclaw'] === "object" ? channels['openclaw-workclaw'] : {};
+    return {
+        ...config,
+        channels: {
+            ...channels,
+            'openclaw-workclaw': {
+                ...openclawWorkclaw,
+                accounts,
+            },
+        },
+    };
+}
+export function createAccountsApiHandler(api) {
+    return async (req, res) => {
+        const method = String(req.method ?? "GET").toUpperCase();
+        const url = new URL(req.url ?? "", "http://localhost");
+        const idRaw = url.searchParams.get("id") ?? url.searchParams.get("accountId");
+        const accountId = idRaw ? normalizeAccountId(idRaw) : null;
+        if (method === "GET") {
+            const cfg = await loadRuntimeConfig(api);
+            const accounts = getAccountMap(cfg);
+            if (accountId) {
+                const account = accounts[accountId];
+                if (!account) {
+                    sendJson(res, 404, { ok: false, error: "Not Found" });
+                    return;
+                }
+                sendJson(res, 200, { ok: true, accountId, config: account });
+                return;
+            }
+            const entries = Object.entries(accounts).map(([id, config]) => ({
+                accountId: id,
+                config,
+            }));
+            sendJson(res, 200, { ok: true, accounts: entries });
+            return;
+        }
+        if (method === "POST" || method === "PUT") {
+            const raw = await readRequestBody(req);
+            let input = {};
+            try {
+                input = raw ? JSON.parse(raw) : {};
+            }
+            catch {
+                sendJson(res, 400, { ok: false, error: "Invalid JSON" });
+                return;
+            }
+            const inputId = input?.accountId ?? input?.id;
+            const normalizedId = inputId ? normalizeAccountId(String(inputId)) : "";
+            const patch = input?.config;
+            if (!normalizedId || !patch || typeof patch !== "object") {
+                sendJson(res, 400, { ok: false, error: "Missing accountId or config" });
+                return;
+            }
+            const cfg = await loadRuntimeConfig(api);
+            const accounts = getAccountMap(cfg);
+            if (method === "POST" && accounts[normalizedId]) {
+                sendJson(res, 409, { ok: false, error: "Account already exists" });
+                return;
+            }
+            if (method === "PUT" && !accounts[normalizedId]) {
+                sendJson(res, 404, { ok: false, error: "Not Found" });
+                return;
+            }
+            const next = method === "PUT" ? { ...accounts[normalizedId], ...patch } : patch;
+            const updated = withAccounts(cfg, { ...accounts, [normalizedId]: next });
+            await writeRuntimeConfig(api, updated);
+            sendJson(res, 200, { ok: true, accountId: normalizedId });
+            return;
+        }
+        if (method === "DELETE") {
+            if (!accountId) {
+                sendJson(res, 400, { ok: false, error: "Missing accountId" });
+                return;
+            }
+            const cfg = await loadRuntimeConfig(api);
+            const accounts = getAccountMap(cfg);
+            if (!accounts[accountId]) {
+                sendJson(res, 404, { ok: false, error: "Not Found" });
+                return;
+            }
+            const { [accountId]: _ignored, ...rest } = accounts;
+            const updated = withAccounts(cfg, rest);
+            await writeRuntimeConfig(api, updated);
+            sendJson(res, 200, { ok: true, accountId, deleted: true });
+            return;
+        }
+        sendJson(res, 405, { ok: false, error: "Method Not Allowed" });
+    };
+}

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

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

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

@@ -0,0 +1,103 @@
+import { mkdir, readFile, stat, unlink, writeFile } from "node:fs/promises";
+import { resolveWorkspaceDir } from "./workspace.js";
+const promptNames = ["SOUL.md", "USER.md"];
+function normalizePromptName(raw) {
+    const name = String(raw ?? "").trim().toUpperCase();
+    if (name === "SOUL" || name === "SOUL.MD")
+        return "SOUL.md";
+    if (name === "USER" || name === "USER.MD")
+        return "USER.md";
+    return null;
+}
+import path from "node:path";
+function resolvePromptPath(api, name) {
+    return path.join(resolveWorkspaceDir(api), name);
+}
+function sendJson(res, statusCode, payload) {
+    res.statusCode = statusCode;
+    res.setHeader("Content-Type", "application/json");
+    res.end(JSON.stringify(payload));
+}
+export function createPromptsApiHandler(api) {
+    return async (req, res) => {
+        const method = String(req.method ?? "GET").toUpperCase();
+        const url = new URL(req.url ?? "", "http://localhost");
+        const name = normalizePromptName(url.searchParams.get("name"));
+        if (method === "GET") {
+            if (name) {
+                const filePath = resolvePromptPath(api, name);
+                try {
+                    const content = await readFile(filePath, "utf-8");
+                    sendJson(res, 200, { ok: true, name, content });
+                    return;
+                }
+                catch (error) {
+                    sendJson(res, 404, { ok: false, error: "Not Found" });
+                    return;
+                }
+            }
+            const entries = await Promise.all(promptNames.map(async (promptName) => {
+                const filePath = resolvePromptPath(api, promptName);
+                try {
+                    const info = await stat(filePath);
+                    return { name: promptName, exists: true, bytes: info.size };
+                }
+                catch {
+                    return { name: promptName, exists: false, bytes: 0 };
+                }
+            }));
+            sendJson(res, 200, { ok: true, entries });
+            return;
+        }
+        if (method === "PUT" || method === "POST") {
+            const raw = await readRequestBody(req);
+            let input = {};
+            try {
+                input = raw ? JSON.parse(raw) : {};
+            }
+            catch {
+                sendJson(res, 400, { ok: false, error: "Invalid JSON" });
+                return;
+            }
+            const targetName = normalizePromptName(input?.name);
+            const content = typeof input?.content === "string" ? input.content : null;
+            if (!targetName || content === null) {
+                sendJson(res, 400, { ok: false, error: "Missing name or content" });
+                return;
+            }
+            const workspaceDir = resolveWorkspaceDir(api);
+            await mkdir(workspaceDir, { recursive: true });
+            await writeFile(resolvePromptPath(api, targetName), content, { encoding: "utf-8" });
+            sendJson(res, 200, { ok: true, name: targetName });
+            return;
+        }
+        if (method === "DELETE") {
+            if (!name) {
+                sendJson(res, 400, { ok: false, error: "Missing name" });
+                return;
+            }
+            const filePath = resolvePromptPath(api, name);
+            try {
+                await unlink(filePath);
+                sendJson(res, 200, { ok: true, name, deleted: true });
+                return;
+            }
+            catch {
+                sendJson(res, 200, { ok: true, name, deleted: false });
+                return;
+            }
+        }
+        sendJson(res, 405, { ok: false, error: "Method Not Allowed" });
+    };
+}
+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");
+}

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

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

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,28 @@
+import os from "node:os";
+import path from "node:path";
+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());
+    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>;