@workclaw/openclaw-workclaw 1.0.18 → 1.0.19

package/dist/src/gateway/config-writer.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Config Writer - handles writing account config to openclaw.json
+ *
+ * NOTE: Only agent creation/initialization writes to openclaw.json via writeConfigFile.
+ * Runtime dynamic data (openConversationId) is stored in a separate state file
+ * to avoid triggering openclaw's config watcher, which would re-parse env vars
+ * and potentially overwrite already-resolved values like ${MODEL_API_KEY}.
+ */
+type ConfigLogger = {
+    info?: (msg: string) => void;
+    error?: (msg: string) => void;
+};
+/**
+ * Write a new config to the openclaw.json file.
+ */
+export declare function writeConfigFile(newConfig: any, cfg: any, log?: ConfigLogger): Promise<void>;
+/**
+ * Load openConversationId from the separate state file.
+ *
+ * Key format: accountId:userId
+ *
+ * Called at runtime to restore openConversationId after process restart,
+ * since cfg is reloaded from openclaw.json which does not contain this value.
+ */
+export declare function loadOpenConversationId(accountId: string, userId: string): string | null;
+/**
+ * Save openConversationId to a separate state file (with write throttling).
+ *
+ * Key format: accountId:userId
+ * Throttling: if called multiple times within 1 second, only the last value is saved.
+ * This avoids excessive disk writes from high-frequency messages.
+ *
+ * Stored in ~/.openclaw/workclaw-state/conversations.json (separate from openclaw.json)
+ * to avoid triggering openclaw's config watcher which would re-parse env vars.
+ */
+export declare function saveOpenConversationId(accountId: string, userId: string, openConversationId: string, cfg: any, log?: ConfigLogger): Promise<void>;
+/**
+ * Initialize workclaw agent config in one shot (hardware device init).
+ *
+ * Sets apiKey, agentId, userId and persists to openclaw.json in a single write.
+ *
+ * NOTE: If apiKey already contains a SecretRef (type: "env"|"file"|"exec"),
+ * it is preserved and NOT overwritten, since OpenClaw handles SecretRef resolution.
+ */
+export declare function initWorkclawAgent(params: {
+    apiKey?: string;
+    agentId?: string;
+    userId?: string;
+    accountId?: string;
+}, cfg: any, log?: ConfigLogger): Promise<void>;
+/**
+ * Save userId to cfg memory and persist to openclaw.json.
+ *
+ * Used during hardware device initialization to persist the default userId.
+ */
+export declare function saveWorkClawUserId(accountId: string, userId: string | number, cfg: any, log?: ConfigLogger): Promise<void>;
+/**
+ * Save agentId to cfg memory and persist to openclaw.json.
+ *
+ * Used during hardware device initialization to persist the default agentId.
+ */
+export declare function saveWorkClawAgentId(accountId: string, agentId: string | number, cfg: any, log?: ConfigLogger): Promise<void>;
+/**
+ * Save apiKey to cfg memory only.
+ *
+ * Does NOT write to openclaw.json to avoid triggering openclaw's config watcher,
+ * which would re-parse env vars (e.g. ${MODEL_API_KEY}) and potentially
+ * overwrite resolved values in the runtime cfg.
+ */
+export declare function saveWorkClawApiKey(apiKey: string, cfg: any, log?: ConfigLogger): Promise<void>;
+export {};

package/dist/src/gateway/config-writer.js

@@ -0,0 +1,312 @@
+/**
+ * Config Writer - handles writing account config to openclaw.json
+ *
+ * NOTE: Only agent creation/initialization writes to openclaw.json via writeConfigFile.
+ * Runtime dynamic data (openConversationId) is stored in a separate state file
+ * to avoid triggering openclaw's config watcher, which would re-parse env vars
+ * and potentially overwrite already-resolved values like ${MODEL_API_KEY}.
+ */
+import { writeFile, readFile, mkdir, rename } from "fs/promises";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { execSync } from "child_process";
+import { getWorkclawRuntime } from "../runtime.js";
+/** 修复目录所有权（仅非 Windows 环境） */
+function fixOwner(dir) {
+    if (process.platform === 'win32')
+        return;
+    try {
+        execSync(`chown -R node:node "${dir}"`, { stdio: 'ignore' });
+    }
+    catch { }
+}
+const STATE_DIR = "workclaw-state";
+// 写入节流时间（避免频繁写入）
+const SAVE_THROTTLE_MS = 1000;
+// 每个账户的上次写入时间，key 格式: accountId:userId
+const lastSaveTimeMap = new Map();
+/**
+ * Find the actual openclaw.json config path.
+ */
+function findConfigPath() {
+    // Prefer homedir config over cwd, since cwd might be the project directory
+    // which could have a stale or unrelated openclaw.json
+    const configPaths = [
+        join(homedir(), ".openclaw", "openclaw.json"),
+        join(homedir(), ".openclaw", "config.json"),
+        join(process.cwd(), "openclaw.json"),
+        join(process.cwd(), "config.json"),
+    ];
+    const found = configPaths.find((p) => existsSync(p));
+    return found ?? join(homedir(), ".openclaw", "openclaw.json");
+}
+/**
+ * Get the state directory for workclaw runtime data.
+ */
+function findStateDir() {
+    const configPath = findConfigPath();
+    const openclawDir = join(configPath, "..", "..");
+    return join(openclawDir, STATE_DIR);
+}
+function getStateFilePath() {
+    return join(findStateDir(), "conversations.json");
+}
+/**
+ * Write a new config to the openclaw.json file.
+ */
+export async function writeConfigFile(newConfig, cfg, log) {
+    try {
+        const runtime = getWorkclawRuntime();
+        const configApi = runtime.config;
+        await configApi.writeConfigFile(newConfig);
+        log?.info?.(`[WriteConfig] Config written via runtime.config.writeConfigFile`);
+        Object.assign(cfg, newConfig);
+    }
+    catch (err) {
+        log?.error?.(`[WriteConfig] Failed to write config: ${String(err)}`);
+        throw err;
+    }
+}
+/**
+ * Load openConversationId from the separate state file.
+ *
+ * Key format: accountId:userId
+ *
+ * Called at runtime to restore openConversationId after process restart,
+ * since cfg is reloaded from openclaw.json which does not contain this value.
+ */
+export function loadOpenConversationId(accountId, userId) {
+    const statePath = getStateFilePath();
+    const key = `${accountId}:${userId}`;
+    try {
+        if (!existsSync(statePath))
+            return null;
+        const content = readFileSync(statePath, "utf-8");
+        const state = JSON.parse(content);
+        return state[key]?.openConversationId ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Save openConversationId to a separate state file (with write throttling).
+ *
+ * Key format: accountId:userId
+ * Throttling: if called multiple times within 1 second, only the last value is saved.
+ * This avoids excessive disk writes from high-frequency messages.
+ *
+ * Stored in ~/.openclaw/workclaw-state/conversations.json (separate from openclaw.json)
+ * to avoid triggering openclaw's config watcher which would re-parse env vars.
+ */
+export async function saveOpenConversationId(accountId, userId, openConversationId, cfg, log) {
+    const key = `${accountId}:${userId}`;
+    // Also update cfg memory immediately
+    const workclawCfg = cfg?.channels?.['openclaw-workclaw'];
+    if (workclawCfg?.accounts?.[accountId]) {
+        workclawCfg.accounts[accountId].openConversationId = openConversationId;
+    }
+    // Throttle: skip if written recently
+    const lastSaveTime = lastSaveTimeMap.get(key) ?? 0;
+    const now = Date.now();
+    if (now - lastSaveTime < SAVE_THROTTLE_MS) {
+        return;
+    }
+    // Write immediately — never lose a pending value on crash
+    await doSaveOpenConversationId(key, openConversationId, log);
+    lastSaveTimeMap.set(key, now);
+}
+async function doSaveOpenConversationId(key, openConversationId, log) {
+    try {
+        const statePath = getStateFilePath();
+        let state = {};
+        if (existsSync(statePath)) {
+            try {
+                const content = await readFile(statePath, "utf-8");
+                state = JSON.parse(content);
+            }
+            catch (parseErr) {
+                log?.error?.(`SaveConversation: Failed to parse state file: ${String(parseErr)}`);
+            }
+        }
+        if (!state[key])
+            state[key] = {};
+        // Skip write only when the value is the same (and not empty/null)
+        const existing = state[key].openConversationId;
+        if (existing === openConversationId && existing != null && existing !== "") {
+            return;
+        }
+        state[key].openConversationId = openConversationId;
+        // Ensure state dir exists
+        const stateDir = findStateDir();
+        if (!existsSync(stateDir)) {
+            try {
+                await mkdir(stateDir, { recursive: true, mode: 0o755 });
+            }
+            catch (mkdirErr) {
+                if (mkdirErr.code === 'EACCES' || mkdirErr.code === 'EPERM') {
+                    // Docker/non-root: retry with loose permissions
+                    await mkdir(stateDir, { recursive: true, mode: 0o777 });
+                }
+                else {
+                    throw mkdirErr;
+                }
+            }
+            // 修复权限（目录可能已存在但权限不对）
+            fixOwner(stateDir);
+        }
+        // Atomic write: write to tmp file then rename
+        const tmpPath = statePath + ".tmp";
+        await writeFile(tmpPath, JSON.stringify(state, null, 2), "utf-8");
+        await rename(tmpPath, statePath);
+        log?.info?.(`SaveConversation: Saved openConversationId for key ${key}`);
+    }
+    catch (err) {
+        log?.error?.(`SaveConversation: Failed to write state file: ${String(err)}`);
+    }
+}
+/**
+ * Initialize workclaw agent config in one shot (hardware device init).
+ *
+ * Sets apiKey, agentId, userId and persists to openclaw.json in a single write.
+ *
+ * NOTE: If apiKey already contains a SecretRef (type: "env"|"file"|"exec"),
+ * it is preserved and NOT overwritten, since OpenClaw handles SecretRef resolution.
+ */
+export async function initWorkclawAgent(params, cfg, log) {
+    try {
+        const workclawCfg = cfg?.channels?.['openclaw-workclaw'];
+        if (!workclawCfg)
+            return;
+        if (params.apiKey) {
+            // Check if existing value is a SecretRef object - if so, skip to preserve it
+            const existingApiKey = cfg.models?.providers?.["sophnet-minimax"]?.apiKey;
+            if (existingApiKey && typeof existingApiKey === "object" && existingApiKey.type) {
+                log?.info?.(`initWorkclawAgent: apiKey is SecretRef (type=${existingApiKey.type}), skipping overwrite`);
+            }
+            else {
+                if (!cfg.models)
+                    cfg.models = {};
+                if (!cfg.models.providers)
+                    cfg.models.providers = {};
+                if (!cfg.models.providers["sophnet-minimax"])
+                    cfg.models.providers["sophnet-minimax"] = {};
+                cfg.models.providers["sophnet-minimax"].apiKey = params.apiKey;
+                log?.info?.(`initWorkclawAgent: apiKey set (plain value)`);
+            }
+        }
+        if (params.agentId) {
+            if (!cfg.models)
+                cfg.models = {};
+            if (!cfg.models.providers)
+                cfg.models.providers = {};
+            if (!cfg.models.providers["sophnet-minimax"])
+                cfg.models.providers["sophnet-minimax"] = {};
+            cfg.models.providers["sophnet-minimax"].apiKey = params.apiKey;
+            log?.info?.(`initWorkclawAgent: apiKey set`);
+        }
+        if (params.agentId) {
+            const accountId = params.accountId || "default";
+            const accounts = workclawCfg.accounts ?? {};
+            workclawCfg.accounts = accounts;
+            if (!accounts[accountId])
+                accounts[accountId] = {};
+            accounts[accountId].agentId = params.agentId;
+            log?.info?.(`initWorkclawAgent: agentId=${params.agentId} set for ${accountId}`);
+        }
+        if (params.userId) {
+            workclawCfg.userId = params.userId;
+            log?.info?.(`initWorkclawAgent: userId=${params.userId} set`);
+        }
+        // Single write to persist all
+        await writeConfigFile(cfg, cfg, log);
+        log?.info?.(`initWorkclawAgent: all config persisted`);
+    }
+    catch (err) {
+        log?.error?.(`initWorkclawAgent: failed: ${String(err)}`);
+        throw err;
+    }
+}
+/**
+ * Save userId to cfg memory and persist to openclaw.json.
+ *
+ * Used during hardware device initialization to persist the default userId.
+ */
+export async function saveWorkClawUserId(accountId, userId, cfg, log) {
+    try {
+        const workclawCfg = cfg?.channels?.['openclaw-workclaw'];
+        if (!workclawCfg)
+            return;
+        workclawCfg.userId = userId;
+        log?.info?.(`SaveUserId: Saved userId ${userId} for account ${accountId}`);
+        // Persist to openclaw.json via framework API
+        await writeConfigFile(cfg, cfg, log);
+    }
+    catch (err) {
+        log?.error?.(`SaveUserId: Failed to update cfg: ${String(err)}`);
+        throw err;
+    }
+}
+/**
+ * Save agentId to cfg memory and persist to openclaw.json.
+ *
+ * Used during hardware device initialization to persist the default agentId.
+ */
+export async function saveWorkClawAgentId(accountId, agentId, cfg, log) {
+    try {
+        const workclawCfg = cfg?.channels?.['openclaw-workclaw'];
+        if (!workclawCfg)
+            return;
+        const accounts = workclawCfg.accounts;
+        let savedToAccount = null;
+        if (accounts?.[accountId]) {
+            accounts[accountId].agentId = agentId;
+            savedToAccount = accountId;
+        }
+        else if (accounts?.["default"]) {
+            if (!accounts["default"].agentId) {
+                accounts["default"].agentId = agentId;
+                savedToAccount = "default";
+                log?.info?.(`SaveAgentId: Saved agentId ${agentId} to default account`);
+            }
+        }
+        else {
+            log?.info?.(`SaveAgentId: Account ${accountId} not found, default account also missing`);
+        }
+        if (savedToAccount) {
+            log?.info?.(`SaveAgentId: Saved agentId ${agentId} for account ${savedToAccount}`);
+        }
+        // Persist to openclaw.json via framework API
+        await writeConfigFile(cfg, cfg, log);
+    }
+    catch (err) {
+        log?.error?.(`SaveAgentId: Failed to update cfg: ${String(err)}`);
+        throw err;
+    }
+}
+/**
+ * Save apiKey to cfg memory only.
+ *
+ * Does NOT write to openclaw.json to avoid triggering openclaw's config watcher,
+ * which would re-parse env vars (e.g. ${MODEL_API_KEY}) and potentially
+ * overwrite resolved values in the runtime cfg.
+ */
+export async function saveWorkClawApiKey(apiKey, cfg, log) {
+    try {
+        if (!cfg.models)
+            cfg.models = {};
+        if (!cfg.models.providers)
+            cfg.models.providers = {};
+        if (!cfg.models.providers["sophnet-minimax"])
+            cfg.models.providers["sophnet-minimax"] = {};
+        cfg.models.providers["sophnet-minimax"].apiKey = apiKey;
+        log?.info?.(`SaveApiKey: Saved apiKey to cfg`);
+        // Persist to openclaw.json via framework API
+        await writeConfigFile(cfg, cfg, log);
+    }
+    catch (err) {
+        log?.error?.(`SaveApiKey: Failed to update cfg: ${String(err)}`);
+        throw err;
+    }
+}

package/dist/src/gateway/message-context.d.ts

@@ -0,0 +1,76 @@
+import type { PluginRuntime } from "openclaw/plugin-sdk";
+export interface Attachment {
+    url: string;
+    fileId: string;
+    type: 'image' | 'file';
+    name?: string;
+}
+/** Channel/plugin name constant */
+export declare const OPENCLAW_WORKCLAW_CHANNEL = "openclaw-workclaw";
+export interface InboundMessage {
+    text: string;
+    to: string;
+    from: string;
+    chatType: "dm" | "group";
+    messageId: string;
+    rawPayload: string;
+    timestamp: number;
+    attachments?: Attachment[];
+}
+export interface InboundContextPayload {
+    [key: string]: unknown;
+    Body: string;
+    BodyForAgent: string;
+    RawBody: string;
+    From: string;
+    To: string;
+    ChatType: "dm" | "group";
+    Provider: string;
+    Surface: string;
+    Timestamp: number;
+    AccountId: string;
+    AgentId?: string;
+    MessageSid?: string;
+    OriginatingChannel: string;
+    OriginatingTo: string;
+}
+export type WorkClawMessageType = "agent_message" | "ping" | "disconnect" | "agent_created" | "agent_updated" | "agent_deleted" | "tools_list" | "skills_list" | "skills_event" | "init_agent" | "ignored";
+export interface ParseWorkClawResult {
+    type: WorkClawMessageType;
+    message?: {
+        text: string;
+        userId: string;
+        openConversationId: string;
+        messageId: string;
+        agentId?: string | number;
+        attachments?: Attachment[];
+    };
+    pongData?: any;
+    eventData?: any;
+}
+export declare function parseInboundMessage(data: string, allowRawJsonPayload?: boolean): Partial<InboundMessage>;
+export declare function parseWorkClawMessage(data: string, log?: {
+    info?: (msg: string) => void;
+    warn?: (msg: string) => void;
+    error?: (msg: string) => void;
+}): ParseWorkClawResult | null;
+/**
+ * Build inbound context for WorkClaw channel.
+ *
+ * When pluginRuntime is provided, performs full session handling:
+ * - resolveStorePath, readSessionUpdatedAt, formatInboundEnvelope
+ * - finalizeInboundContext, recordInboundSession
+ *
+ * @param message - The inbound message
+ * @param accountId - Account ID
+ * @param config - Account config (WorkclawConfig)
+ * @param agentId - Target agent ID (optional)
+ * @param pluginRuntime - OpenClaw plugin runtime (optional, enables full session handling)
+ * @param recordSession - Whether to record session (default true)
+ * @param log - Optional logger
+ */
+export declare function buildInboundContext(message: InboundMessage, accountId: string, config: any, agentId?: string, pluginRuntime?: PluginRuntime, recordSession?: boolean, log?: {
+    info?: (msg: string) => void;
+    warn?: (msg: string) => void;
+    error?: (msg: string) => void;
+}): Promise<InboundContextPayload>;