@yahaha-studio/focus-forwarder 0.0.1-alpha.4 → 0.0.1-alpha.6

package/index.ts

@@ -1,54 +1,126 @@
-import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
-import { parse } from "./src/config.js";
-import { FocusForwarderService } from "./src/service.js";
-import type { FocusForwarderConfig } from "./src/types.js";
-import fs from "node:fs";
-import path from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import { parse } from "./src/config.js";
+import { FocusForwarderService } from "./src/service.js";
+import type { ActionResult, FocusForwarderConfig, PoseType, SkillsConfig } from "./src/types.js";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
 
 // Default actions (fallback when no config file)
-const DEFAULT_ACTIONS = {
-  stand: ["High Five", "Listen Music", "Arms Crossed", "Epiphany", "Yay", "Tired", "Wait"],
-  sit: ["Typing with Keyboard", "Thinking", "Study Look At", "Writing", "Hand Cramp", "Laze"],
-  lay: ["Rest Chin", "Lie Flat", "Lie Face Down"],
-  floor: ["Seiza", "Cross Legged", "Knee Hug"],
-};
-
-const DEFAULT_FALLBACKS = {
-  done: { poseType: "stand" as const, action: "Yay", bubble: "Done!" },
-  thinking: { poseType: "stand" as const, action: "Wait", bubble: "Thinking..." },
-  working: { poseType: "stand" as const, action: "Arms Crossed", bubble: "Working" },
-};
-
-type ActionResult = { poseType: "stand" | "sit" | "lay" | "floor"; action: string; bubble: string };
-
-interface SkillsConfig {
-  actions: typeof DEFAULT_ACTIONS;
-  fallbacks: typeof DEFAULT_FALLBACKS;
-}
-
-const SKILLS_CONFIG_PATH = path.join(process.env.HOME || "~", ".openclaw/focus-world/skills-config.json");
-
-let cachedConfig: SkillsConfig | null = null;
-let cachedConfigMtime = 0;
-
-function loadSkillsConfig(): SkillsConfig {
-  try {
-    if (fs.existsSync(SKILLS_CONFIG_PATH)) {
-      const stat = fs.statSync(SKILLS_CONFIG_PATH);
-      if (stat.mtimeMs !== cachedConfigMtime || !cachedConfig) {
-        const raw = fs.readFileSync(SKILLS_CONFIG_PATH, "utf-8");
-        cachedConfig = JSON.parse(raw) as SkillsConfig;
-        cachedConfigMtime = stat.mtimeMs;
-        pluginApi?.logger.info(`[focus] Loaded skills config`);
-      }
-      return cachedConfig!;
-    }
-  } catch (e) {
-    pluginApi?.logger.warn(`[focus] Failed to load skills config: ${e}`);
-  }
-  return { actions: DEFAULT_ACTIONS, fallbacks: DEFAULT_FALLBACKS };
-}
+const DEFAULT_ACTIONS: SkillsConfig["actions"] = {
+  stand: ["High Five", "Listen Music", "Arms Crossed", "Epiphany", "Yay", "Tired", "Wait"],
+  sit: ["Typing with Keyboard", "Thinking", "Study Look At", "Writing", "Hand Cramp", "Laze"],
+  lay: ["Rest Chin", "Lie Flat", "Lie Face Down"],
+  floor: ["Seiza", "Cross Legged", "Knee Hug"],
+};
+
+const DEFAULT_FALLBACKS: SkillsConfig["fallbacks"] = {
+  done: { poseType: "stand" as const, action: "Yay", bubble: "Done!" },
+  thinking: { poseType: "stand" as const, action: "Wait", bubble: "Thinking..." },
+  working: { poseType: "stand" as const, action: "Arms Crossed", bubble: "Working" },
+};
+
+const DEFAULT_SKILLS_CONFIG: SkillsConfig = {
+  actions: DEFAULT_ACTIONS,
+  fallbacks: DEFAULT_FALLBACKS,
+  llm: { enabled: true },
+};
+
+const FOCUS_WORLD_DIR = path.join(os.homedir(), ".openclaw", "focus-world");
+const SKILLS_CONFIG_PATH = path.join(FOCUS_WORLD_DIR, "skills-config.json");
+const IDENTITY_PATH = path.join(FOCUS_WORLD_DIR, "identity.json");
+const LLM_SESSION_PATH = path.join(FOCUS_WORLD_DIR, "llm-session.json");
+
+let cachedConfig: SkillsConfig | null = null;
+let cachedConfigMtime = 0;
+
+function sanitizeActionResult(value: unknown, fallback: ActionResult): ActionResult {
+  if (!value || typeof value !== "object") return fallback;
+  const candidate = value as Partial<ActionResult>;
+  const poseType = candidate.poseType;
+  const action = candidate.action;
+  const bubble = candidate.bubble;
+  if (!poseType || !["stand", "sit", "lay", "floor"].includes(poseType)) return fallback;
+  if (typeof action !== "string" || !action.trim()) return fallback;
+  return {
+    poseType: poseType as PoseType,
+    action,
+    bubble: typeof bubble === "string" && bubble.trim() ? bubble : fallback.bubble,
+  };
+}
+
+function sanitizeActions(value: unknown, fallback: string[]): string[] {
+  if (!Array.isArray(value)) return fallback;
+  const actions = value.filter((item): item is string => typeof item === "string" && item.trim().length > 0);
+  return actions.length > 0 ? actions : fallback;
+}
+
+function normalizeSkillsConfig(value: unknown): SkillsConfig {
+  const raw = value && typeof value === "object" ? (value as Partial<SkillsConfig>) : {};
+  const actions = raw.actions;
+  const fallbacks = raw.fallbacks;
+  return {
+    actions: {
+      stand: sanitizeActions(actions?.stand, DEFAULT_ACTIONS.stand),
+      sit: sanitizeActions(actions?.sit, DEFAULT_ACTIONS.sit),
+      lay: sanitizeActions(actions?.lay, DEFAULT_ACTIONS.lay),
+      floor: sanitizeActions(actions?.floor, DEFAULT_ACTIONS.floor),
+    },
+    fallbacks: {
+      done: sanitizeActionResult(fallbacks?.done, DEFAULT_FALLBACKS.done),
+      thinking: sanitizeActionResult(fallbacks?.thinking, DEFAULT_FALLBACKS.thinking),
+      working: sanitizeActionResult(fallbacks?.working, DEFAULT_FALLBACKS.working),
+    },
+    llm: {
+      enabled: typeof raw.llm?.enabled === "boolean" ? raw.llm.enabled : DEFAULT_SKILLS_CONFIG.llm.enabled,
+    },
+  };
+}
+
+function updateCachedSkillsConfig(config: SkillsConfig): SkillsConfig {
+  cachedConfig = config;
+  try {
+    cachedConfigMtime = fs.existsSync(SKILLS_CONFIG_PATH) ? fs.statSync(SKILLS_CONFIG_PATH).mtimeMs : 0;
+  } catch {
+    cachedConfigMtime = 0;
+  }
+  return config;
+}
+
+function loadSkillsConfig(): SkillsConfig {
+  try {
+    if (fs.existsSync(SKILLS_CONFIG_PATH)) {
+      const stat = fs.statSync(SKILLS_CONFIG_PATH);
+      if (stat.mtimeMs !== cachedConfigMtime || !cachedConfig) {
+        const raw = fs.readFileSync(SKILLS_CONFIG_PATH, "utf-8");
+        updateCachedSkillsConfig(normalizeSkillsConfig(JSON.parse(raw)));
+        pluginApi?.logger.info(`[focus] Loaded skills config`);
+      }
+      return cachedConfig!;
+    }
+  } catch (e) {
+    pluginApi?.logger.warn(`[focus] Failed to load skills config: ${e}`);
+  }
+  return updateCachedSkillsConfig(DEFAULT_SKILLS_CONFIG);
+}
+
+function saveSkillsConfig(config: SkillsConfig): SkillsConfig {
+  const normalized = normalizeSkillsConfig(config);
+  fs.mkdirSync(FOCUS_WORLD_DIR, { recursive: true });
+  fs.writeFileSync(SKILLS_CONFIG_PATH, JSON.stringify(normalized, null, 2), "utf-8");
+  pluginApi?.logger.info(`[focus] Saved skills config to ${SKILLS_CONFIG_PATH}`);
+  return updateCachedSkillsConfig(normalized);
+}
+
+function updateSkillsConfig(mutator: (config: SkillsConfig) => SkillsConfig): SkillsConfig {
+  const current = loadSkillsConfig();
+  return saveSkillsConfig(mutator(current));
+}
+
+function isLlmEnabled(): boolean {
+  return loadSkillsConfig().llm.enabled;
+}
 
 let service: FocusForwarderService | null = null;
 let pluginApi: OpenClawPluginApi | null = null;
@@ -104,14 +176,14 @@ async function loadCoreApi() {
   return coreApiPromise;
 }
 
-// Get done action for a specific poseType
-function getDoneActionForPose(poseType: string): string {
-  const config = loadSkillsConfig();
-  const actions = config.actions[poseType as keyof typeof config.actions];
-  // Pick a "done" style action based on poseType
-  if (poseType === "stand") return actions.includes("Yay") ? "Yay" : actions[0];
-  if (poseType === "sit") return actions.includes("Laze") ? "Laze" : actions[0];
-  if (poseType === "lay") return actions.includes("Rest Chin") ? "Rest Chin" : actions[0];
+// Get done action for a specific poseType
+function getDoneActionForPose(poseType: PoseType): string {
+  const config = loadSkillsConfig();
+  const actions = config.actions[poseType];
+  // Pick a "done" style action based on poseType
+  if (poseType === "stand") return actions.includes("Yay") ? "Yay" : actions[0];
+  if (poseType === "sit") return actions.includes("Laze") ? "Laze" : actions[0];
+  if (poseType === "lay") return actions.includes("Rest Chin") ? "Rest Chin" : actions[0];
   if (poseType === "floor") return actions.includes("Cross Legged") ? "Cross Legged" : actions[0];
   return actions[0];
 }
@@ -162,12 +234,12 @@ Return ONLY JSON: {"poseType":"stand|sit|lay|floor","action":"<action name>","bu
 
     let result;
     try {
-      result = await runEmbeddedPiAgent({
-        sessionId: `focus-action-${Date.now()}`,
-        sessionFile: path.join(process.env.HOME || "~", ".openclaw/focus-world/llm-session.json"),
-        workspaceDir: pluginApi?.config?.agents?.defaults?.workspace || process.cwd(),
-        config: pluginApi?.config,
-        prompt,
+      result = await runEmbeddedPiAgent({
+        sessionId: `focus-action-${Date.now()}`,
+        sessionFile: LLM_SESSION_PATH,
+        workspaceDir: pluginApi?.config?.agents?.defaults?.workspace || process.cwd(),
+        config: pluginApi?.config,
+        prompt,
         provider,
         model,
         authProfileId,
@@ -203,63 +275,116 @@ Return ONLY JSON: {"poseType":"stand|sit|lay|floor","action":"<action name>","bu
 }
 
 // Per-agent state tracking
-interface AgentState {
-  pendingLLM: boolean;
-  llmCancelled: boolean;
-  cooldownStartTime: number;
-  lastLLMResult?: { poseType: string; action: string };
-}
-
-const agentStates = new Map<string, AgentState>();
-const SYNC_COOLDOWN_MS = 15000;
-const AGENT_STATE_TTL_MS = 60 * 60 * 1000; // 1 hour TTL for cleanup
-
-function getAgentState(agentId: string): AgentState {
-  let state = agentStates.get(agentId);
-  if (!state) {
-    state = { pendingLLM: false, llmCancelled: false, cooldownStartTime: 0 };
-    agentStates.set(agentId, state);
-  }
-  return state;
-}
-
-// Cleanup stale agent states to prevent memory leaks
-function cleanupStaleAgents() {
-  const now = Date.now();
-  for (const [agentId, state] of agentStates) {
-    if (!state.pendingLLM && now - state.cooldownStartTime > AGENT_STATE_TTL_MS) {
-      agentStates.delete(agentId);
-      pluginApi?.logger.debug(`[focus] cleaned up stale agent state: ${agentId}`);
-    }
-  }
-}
-
-function truncateLog(text: string, maxLen = 150): string {
-  return text.length > maxLen ? text.slice(0, maxLen) + "..." : text;
-}
-
-// 内部 fallback 发送（给 syncStatus 用，不检查 identity）
-function sendFallbackInternal(context: string, agentId: string) {
-  if (!service?.isConnected()) return;
-  const state = getAgentState(agentId);
-  const fallback = pickActionFallback(context);
-  const poseType = state.lastLLMResult?.poseType || fallback.poseType;
-  const action = state.lastLLMResult?.action || fallback.action;
-  service.sendStatus(poseType, action, fallback.bubble || "Working", truncateLog(context));
-}
-
-function syncStatus(context: string, agentId: string) {
+interface AgentState {
+  pendingLLM: boolean;
+  llmCancelled: boolean;
+  llmRequestId: number;
+  cooldownActive: boolean;
+  cooldownStartTime: number;
+  cooldownTimer?: ReturnType<typeof setTimeout>;
+  lastLLMResult?: { poseType: PoseType; action: string };
+}
+
+const agentStates = new Map<string, AgentState>();
+const AGENT_STATE_TTL_MS = 60 * 60 * 1000; // 1 hour TTL for cleanup
+let syncCooldownMs = 15000;
+
+function getAgentState(agentId: string): AgentState {
+  let state = agentStates.get(agentId);
+  if (!state) {
+    state = {
+      pendingLLM: false,
+      llmCancelled: false,
+      llmRequestId: 0,
+      cooldownActive: false,
+      cooldownStartTime: 0,
+    };
+    agentStates.set(agentId, state);
+  }
+  return state;
+}
+
+function startCooldown(state: AgentState, agentId: string, startTime: number) {
+  if (state.cooldownTimer) clearTimeout(state.cooldownTimer);
+  state.cooldownActive = true;
+  state.cooldownStartTime = startTime;
+  state.cooldownTimer = setTimeout(() => {
+    state.cooldownActive = false;
+    state.cooldownTimer = undefined;
+    pluginApi?.logger.debug(`[focus] cooldown ended for agent ${agentId}`);
+  }, syncCooldownMs);
+}
+
+// Cleanup stale agent states to prevent memory leaks
+function cleanupStaleAgents() {
+  const now = Date.now();
+  for (const [agentId, state] of agentStates) {
+    if (!state.pendingLLM && now - state.cooldownStartTime > AGENT_STATE_TTL_MS) {
+      if (state.cooldownTimer) clearTimeout(state.cooldownTimer);
+      agentStates.delete(agentId);
+      pluginApi?.logger.debug(`[focus] cleaned up stale agent state: ${agentId}`);
+    }
+  }
+}
+
+function truncateLog(text: string, maxLen = 150): string {
+  return text.length > maxLen ? text.slice(0, maxLen) + "..." : text;
+}
+
+function applyLlmEnabledChange(enabled: boolean): SkillsConfig {
+  const nextConfig = updateSkillsConfig((current) => ({
+    ...current,
+    llm: { ...current.llm, enabled },
+  }));
+  for (const state of agentStates.values()) {
+    state.pendingLLM = false;
+    if (!enabled) {
+      state.llmCancelled = true;
+      state.llmRequestId += 1;
+    } else {
+      state.llmCancelled = false;
+    }
+  }
+  return nextConfig;
+}
+
+// Internal fallback sender used by syncStatus without repeating identity checks.
+function sendFallbackInternal(context: string, agentId: string) {
+  if (!service?.isConnected()) return;
+  const state = getAgentState(agentId);
+  const fallback = pickActionFallback(context);
+  const reuseLastLlmResult = isLlmEnabled();
+  const poseType = reuseLastLlmResult ? state.lastLLMResult?.poseType || fallback.poseType : fallback.poseType;
+  const action = reuseLastLlmResult ? state.lastLLMResult?.action || fallback.action : fallback.action;
+  service.sendStatus(poseType, action, fallback.bubble || "Working", truncateLog(context));
+}
+
+function syncStatus(context: string, agentId: string) {
   if (!service?.isConnected()) {
     pluginApi?.logger.info(`[focus] skipped: not connected`);
     return;
   }
-  
-  const state = getAgentState(agentId);
-  const now = Date.now();
-  const elapsed = now - state.cooldownStartTime;
-  const inCooldown = state.cooldownStartTime > 0 && elapsed < SYNC_COOLDOWN_MS;
-  
-  pluginApi?.logger.info(`[focus] syncStatus: agent=${agentId} elapsed=${elapsed}ms inCooldown=${inCooldown} pendingLLM=${state.pendingLLM}`);
+  
+  const state = getAgentState(agentId);
+  const now = Date.now();
+  const elapsed = state.cooldownStartTime > 0 ? now - state.cooldownStartTime : 0;
+  if (state.cooldownActive && elapsed >= syncCooldownMs) {
+    state.cooldownActive = false;
+    if (state.cooldownTimer) {
+      clearTimeout(state.cooldownTimer);
+      state.cooldownTimer = undefined;
+    }
+  }
+  const inCooldown = state.cooldownActive;
+  const llmEnabled = isLlmEnabled();
+  
+  pluginApi?.logger.info(`[focus] syncStatus: agent=${agentId} elapsed=${elapsed}ms inCooldown=${inCooldown} pendingLLM=${state.pendingLLM} llmEnabled=${llmEnabled}`);
+
+  if (!llmEnabled) {
+    pluginApi?.logger.info(`[focus] LLM disabled, using fallback mapping for agent ${agentId}`);
+    sendFallbackInternal(context, agentId);
+    return;
+  }
   
   // In cooldown OR LLM pending: send fallback
   if (inCooldown || state.pendingLLM) {
@@ -267,20 +392,22 @@ function syncStatus(context: string, agentId: string) {
     sendFallbackInternal(context, agentId);
     return;
   }
-  
-  // Start new LLM request
-  state.cooldownStartTime = now;
-  state.pendingLLM = true;
-  state.llmCancelled = false;
-  pluginApi?.logger.info(`[focus] calling LLM for agent ${agentId}`);
-  
-  pickActionWithLLM(context)
-    .then((action) => {
-      state.pendingLLM = false;
-      if (state.llmCancelled) {
-        pluginApi?.logger.debug(`[focus] LLM result discarded (cancelled) for agent ${agentId}`);
-        return;
-      }
+  
+  // Start new LLM request
+  startCooldown(state, agentId, now);
+  state.pendingLLM = true;
+  state.llmCancelled = false;
+  const requestId = state.llmRequestId + 1;
+  state.llmRequestId = requestId;
+  pluginApi?.logger.info(`[focus] calling LLM for agent ${agentId}`);
+  
+  pickActionWithLLM(context)
+    .then((action) => {
+      state.pendingLLM = false;
+      if (state.llmCancelled || state.llmRequestId !== requestId || !isLlmEnabled()) {
+        pluginApi?.logger.debug(`[focus] LLM result discarded for agent ${agentId}`);
+        return;
+      }
       state.lastLLMResult = { poseType: action.poseType, action: action.action };
       pluginApi?.logger.debug(`[focus] LLM result: ${JSON.stringify(action)}`);
       service?.sendStatus(action.poseType, action.action, action.bubble || "Working", truncateLog(context));
@@ -299,34 +426,34 @@ const plugin = {
   register(api: OpenClawPluginApi) {
     pluginApi = api;
 
-    api.registerService({
-      id: "focus-forwarder",
-      start: (ctx) => {
-        const cfg = parse(ctx.config.plugins?.entries?.["focus-forwarder"]?.config) as FocusForwarderConfig;
-        service = new FocusForwarderService(cfg, api.logger);
-        return service.start();
-      },
-      stop: () => service?.stop(),
-    });
+    api.registerService({
+      id: "focus-forwarder",
+      start: (ctx) => {
+        const cfg = parse(ctx.config.plugins?.entries?.["focus-forwarder"]?.config) as FocusForwarderConfig;
+        syncCooldownMs = cfg.cooldownMs;
+        service = new FocusForwarderService(cfg, api.logger);
+        return service.start();
+      },
+      stop: () => service?.stop(),
+    });
 
     api.registerTool({
       name: "focus_join",
       description: "Join Focus world with userId",
-      parameters: {
-        type: "object",
-        properties: { userId: { type: "string", description: "User ID to join Focus world" } },
-        required: ["userId"],
-      },
-      execute: async (_toolCallId, params) => {
-        const identityPath = path.join(process.env.HOME || "~", ".openclaw/focus-world/identity.json");
-        let userId = (params as any)?.userId;
-        if (!userId) {
-          try { userId = JSON.parse(fs.readFileSync(identityPath, "utf-8")).userId; } catch {}
-        }
-        if (!userId) return { success: false, error: "No userId" };
-        const result = await service?.join(userId);
-        return result ? { success: true, authKey: result } : { success: false, error: "Failed" };
-      },
+      parameters: {
+        type: "object",
+        properties: { userId: { type: "string", description: "User ID to join Focus world" } },
+        required: ["userId"],
+      },
+      execute: async (_toolCallId, params) => {
+        let userId = (params as any)?.userId;
+        if (!userId) {
+          try { userId = JSON.parse(fs.readFileSync(IDENTITY_PATH, "utf-8")).userId; } catch {}
+        }
+        if (!userId) return { success: false, error: "No userId" };
+        const result = await service?.join(userId);
+        return result ? { success: true, authKey: result } : { success: false, error: "Failed" };
+      },
     });
 
     api.registerTool({
@@ -362,23 +489,59 @@ const plugin = {
         if (!service?.hasValidIdentity() || !service?.isConnected()) {
           return { success: false, error: "Not connected to Focus world" };
         }
-        const config = loadSkillsConfig();
-        if (!config?.actions?.stand || !config?.actions?.sit || !config?.actions?.lay || !config?.actions?.floor) {
-          return { success: false, error: "Invalid skills config" };
-        }
-        // Validate action exists in the specified poseType
-        const poseActions = config.actions[poseType as keyof typeof config.actions];
-        const matched = poseActions.find((a: string) => a.toLowerCase() === action.toLowerCase());
-        if (!matched) {
-          return { success: false, error: `Unknown action "${action}" for poseType "${poseType}"`, available: poseActions };
-        }
-        // Update lastLLMResult for main agent
-        const state = getAgentState("main");
-        state.lastLLMResult = { poseType, action: matched };
-        service.sendStatus(poseType, matched, bubble || matched, `User requested: ${action}`);
-        return { success: true, poseType, action: matched, bubble: bubble || matched };
-      },
-    });
+        const config = loadSkillsConfig();
+        if (!config?.actions?.stand || !config?.actions?.sit || !config?.actions?.lay || !config?.actions?.floor) {
+          return { success: false, error: "Invalid skills config" };
+        }
+        const normalizedPoseType = poseType as PoseType;
+        // Validate action exists in the specified poseType
+        const poseActions = config.actions[normalizedPoseType];
+        const matched = poseActions.find((a: string) => a.toLowerCase() === action.toLowerCase());
+        if (!matched) {
+          return { success: false, error: `Unknown action "${action}" for poseType "${poseType}"`, available: poseActions };
+        }
+        // Update lastLLMResult for main agent
+        const state = getAgentState("main");
+        state.lastLLMResult = { poseType: normalizedPoseType, action: matched };
+        service.sendStatus(normalizedPoseType, matched, bubble || matched, `User requested: ${action}`);
+        return { success: true, poseType: normalizedPoseType, action: matched, bubble: bubble || matched };
+      },
+    });
+
+    api.registerTool({
+      name: "focus_set_llm_enabled",
+      description: "Enable or disable Focus Forwarder LLM requests for automatic status syncing. Use this when the user asks to stop or resume LLM-based action picking for Focus Forwarder.",
+      parameters: {
+        type: "object",
+        properties: {
+          enabled: { type: "boolean", description: "True to enable LLM-based auto action picking, false to use fallback keyword mapping only." },
+        },
+        required: ["enabled"],
+      },
+      execute: async (_toolCallId, params) => {
+        const enabled = (params as { enabled?: unknown } | null)?.enabled;
+        if (typeof enabled !== "boolean") {
+          return { success: false, error: "enabled must be a boolean" };
+        }
+        try {
+          const nextConfig = applyLlmEnabledChange(enabled);
+          return {
+            success: true,
+            llmEnabled: nextConfig.llm.enabled,
+            configPath: SKILLS_CONFIG_PATH,
+            message: nextConfig.llm.enabled
+              ? "Focus Forwarder LLM requests enabled"
+              : "Focus Forwarder LLM requests disabled; fallback mapping is now active",
+          };
+        } catch (error) {
+          return {
+            success: false,
+            error: `Failed to update skills config: ${error}`,
+            configPath: SKILLS_CONFIG_PATH,
+          };
+        }
+      },
+    });
 
     // sendWithLLM: use LLM with cooldown
     const sendWithLLM = (context: string, agentId: string) => {
@@ -414,16 +577,20 @@ const plugin = {
     });
     api.on("agent_end", (event: any, ctx?: { agentId?: string; sessionKey?: string }) => {
       const agentId = ctx?.agentId || ctx?.sessionKey || "main";
-      // 不再 cancel pending LLM，让结果正常发送
-      // Use last LLM poseType but pick done action for that pose
+      // Use last LLM poseType but pick done action for that pose
       if (!service?.hasValidIdentity() || !service?.isConnected()) return;
-      const state = getAgentState(agentId);
-      const poseType = state.lastLLMResult?.poseType || "stand";
-      const action = getDoneActionForPose(poseType);
-      service.sendStatus(poseType, action, "Done!", truncateLog(`[${agentId}] Task complete`));
-      cleanupStaleAgents();
-    });
-  },
+      const state = getAgentState(agentId);
+      if (!isLlmEnabled()) {
+        const done = pickActionFallback(`[${agentId}] done`);
+        service.sendStatus(done.poseType, done.action, done.bubble || "Done!", truncateLog(`[${agentId}] Task complete`));
+      } else {
+        const poseType = state.lastLLMResult?.poseType || "stand";
+        const action = getDoneActionForPose(poseType);
+        service.sendStatus(poseType, action, "Done!", truncateLog(`[${agentId}] Task complete`));
+      }
+      cleanupStaleAgents();
+    });
+  },
 };
 
 export default plugin;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yahaha-studio/focus-forwarder",
-  "version": "0.0.1-alpha.4",
+  "version": "0.0.1-alpha.6",
   "description": "Forward OpenClaw agent events to external WebSocket server for visualization",
   "type": "module",
   "main": "index.ts",

package/skills/focus-forwarder/SKILL.md

@@ -1,181 +1,205 @@
----
-name: focus-forwarder
-description: Sync OpenClaw agent status to Focus virtual world
-metadata: {"openclaw":{"requires":{"config":["plugins.entries.focus-forwarder.enabled"]},"emoji":"target"}}
----
-
-# Focus Forwarder
-
-Sync your working status to Focus virtual world, and perform actions on command.
-
-## Plugin Setup
-
-Before installing the plugin, save `userId` to `~/.openclaw/focus-world/identity.json`:
-
-```json
-{
-  "userId": "your-user-id"
-}
-```
-
-Then install and enable the plugin:
-
-```bash
-openclaw plugins install @yahaha-studio/focus-forwarder@0.0.1-alpha.4
-openclaw plugins enable focus-forwarder
-```
-
-If package installation fails, install from source instead:
-
-```bash
-git clone https://github.com/XiaoxinShi001/yahaha_focus_forwarder_alpha
-cd yahaha_focus_forwarder_alpha
-openclaw plugins install .
-openclaw plugins enable focus-forwarder
-```
-
-Manual step required: restart OpenClaw after enabling the plugin (user must do this manually).
-
-## Tools
-
-### focus_join
-
-Join Focus World with a userId.
-
-```
-focus_join(userId: "your-user-id")
-```
-
-If `userId` already exists in `~/.openclaw/focus-world/identity.json`, you can call:
-
-```
-focus_join()
-```
-
-`authKey` is automatically saved to `~/.openclaw/focus-world/identity.json`.
-
-### focus_leave
-
-Leave Focus World and clear authKey.
-
-```
-focus_leave()
-```
-
-### focus_action
-
-Send an action/pose to Focus World. Use this when a user asks you to do something in Focus (for example: "dance", "wave", "sit and type").
-
-```
-focus_action(poseType: "stand", action: "Yay", bubble: "Dancing!")
-```
-
-Parameters:
-- `poseType` (required): Pose type - `stand`, `sit`, `lay`, or `floor`
-- `action` (required): Action name to perform (must match poseType)
-- `bubble` (optional): Text to display in bubble (max 5 words)
-
-## Available Actions
-
-Use action names exactly as listed below.
-
-### Standing Actions
-- HIgh Five
-- Listen Music
-- Arm Stretch
-- BackBend Stretch
-- Making Selfie
-- Arms Crossed
-- Epiphany
-- Angry
-- Yay
-- Dance
-- Sing
-- Tired
-- Wait
-- Stand Phone Talk
-- Stand Phone Play
-- Curtsy
-
-### Sitting Actions
-- Typing with Keyboard
-- Thinking
-- Study Look At
-- Writing
-- Crazy
-- Homework
-- Take Notes
-- Hand Cramp
-- Dozing
-- Phone Talk
-- Situp with Arms Crossed
-- Situp with Cross Legs
-- Relax with Arms Crossed
-- Eating
-- Laze
-- Laze with Cross Legs
-- Typing with Phone
-- Sit with Arm Stretch
-- Drink
-- Sit with Making Selfie
-- Play Game
-- Situp Sleep
-- Sit Phone Play
-
-### Laying Actions
-- Bend One Knee
-- Sleep Curl Up Side way
-- Rest Chin
-- Lie Flat
-- Lie Face Down
-- Lie Side
-
-### Floor Actions
-- Seiza
-- Cross Legged
-- Knee Hug
-
-## Example Commands
-
-User says: "Can you dance in Focus?"
--> `focus_action(poseType: "stand", action: "Yay", bubble: "Dancing!")`
-
-User says: "Wave your hand"
--> `focus_action(poseType: "stand", action: "HIgh Five", bubble: "Hi!")`
-
-User says: "Sit down and type"
--> `focus_action(poseType: "sit", action: "Typing with Keyboard", bubble: "Working...")`
-
-User says: "Lie flat"
--> `focus_action(poseType: "lay", action: "Lie Flat", bubble: "Relaxing...")`
-
-## Files
-
-- `~/.openclaw/focus-world/identity.json` - userId (bootstrap) and authKey (managed by plugin)
-- `~/.openclaw/focus-world/skills-config.json` - actions and fallbacks config
-
-## Skills Config
-
-Custom actions can be configured in `~/.openclaw/focus-world/skills-config.json`:
-
-```json
-{
-  "actions": {
-    "stand": ["HIgh Five", "Listen Music", "Arm Stretch", "BackBend Stretch", "Making Selfie", "Arms Crossed", "Epiphany", "Angry", "Yay", "Dance", "Sing", "Tired", "Wait", "Stand Phone Talk", "Stand Phone Play", "Curtsy"],
-    "sit": ["Typing with Keyboard", "Thinking", "Study Look At", "Writing", "Crazy", "Homework", "Take Notes", "Hand Cramp", "Dozing", "Phone Talk", "Situp with Arms Crossed", "Situp with Cross Legs", "Relax with Arms Crossed", "Eating", "Laze", "Laze with Cross Legs", "Typing with Phone", "Sit with Arm Stretch", "Drink", "Sit with Making Selfie", "Play Game", "Situp Sleep", "Sit Phone Play"],
-    "lay": ["Bend One Knee", "Sleep Curl Up Side way", "Rest Chin", "Lie Flat", "Lie Face Down", "Lie Side"],
-    "floor": ["Seiza", "Cross Legged", "Knee Hug"]
-  },
-  "fallbacks": {
-    "done": { "poseType": "stand", "action": "Yay", "bubble": "Done!" },
-    "thinking": { "poseType": "stand", "action": "Wait", "bubble": "Thinking..." },
-    "working": { "poseType": "stand", "action": "Arms Crossed", "bubble": "Working" }
-  }
-}
-```
-
-## How It Works
-
-- Plugin automatically syncs status when you are working (tool calls trigger updates)
-- Use `focus_action` to manually perform specific actions on user request
-- Bubble text shows short status (<=5 words)
+---
+name: focus-forwarder
+description: Sync OpenClaw agent status to Focus virtual world
+metadata: {"openclaw":{"requires":{"config":["plugins.entries.focus-forwarder.enabled"]},"emoji":"target"}}
+---
+
+# Focus Forwarder
+
+Sync your working status to Focus virtual world, and perform actions on command.
+
+## Plugin Setup
+
+Before installing the plugin, save `userId` to `~/.openclaw/focus-world/identity.json`:
+
+```json
+{
+  "userId": "your-user-id"
+}
+```
+
+Then install and enable the plugin:
+
+```bash
+openclaw plugins install @yahaha-studio/focus-forwarder@0.0.1-alpha.6
+openclaw plugins enable focus-forwarder
+```
+
+If package installation fails, install from source instead:
+
+```bash
+git clone https://github.com/XiaoxinShi001/yahaha_focus_forwarder_alpha
+cd yahaha_focus_forwarder_alpha
+openclaw plugins install .
+openclaw plugins enable focus-forwarder
+```
+
+Manual step required: restart OpenClaw after enabling the plugin.
+
+## Tools
+
+### focus_join
+
+Join Focus World with a userId.
+
+```text
+focus_join(userId: "your-user-id")
+```
+
+If `userId` already exists in `~/.openclaw/focus-world/identity.json`, you can call:
+
+```text
+focus_join()
+```
+
+`authKey` is automatically saved to `~/.openclaw/focus-world/identity.json`.
+
+### focus_leave
+
+Leave Focus World and clear authKey.
+
+```text
+focus_leave()
+```
+
+### focus_action
+
+Send an action or pose to Focus World. Use this when a user asks you to do something in Focus, for example "dance", "wave", or "sit and type".
+
+```text
+focus_action(poseType: "stand", action: "Yay", bubble: "Dancing!")
+```
+
+Parameters:
+- `poseType` (required): `stand`, `sit`, `lay`, or `floor`
+- `action` (required): Action name to perform
+- `bubble` (optional): Bubble text to display, max 5 words
+
+### focus_set_llm_enabled
+
+Enable or disable LLM-based automatic action selection for Focus Forwarder. Use this when the user asks to stop or resume LLM-based action picking for Focus Forwarder.
+
+```text
+focus_set_llm_enabled(enabled: false)
+```
+
+Parameters:
+- `enabled` (required): `true` to use `pickActionWithLLM` for automatic status sync, `false` to force all automatic status updates to use fallback keyword mapping
+
+## Available Actions
+
+Use action names exactly as listed below.
+
+### Standing Actions
+- HIgh Five
+- Listen Music
+- Arm Stretch
+- BackBend Stretch
+- Making Selfie
+- Arms Crossed
+- Epiphany
+- Angry
+- Yay
+- Dance
+- Sing
+- Tired
+- Wait
+- Stand Phone Talk
+- Stand Phone Play
+- Curtsy
+
+### Sitting Actions
+- Typing with Keyboard
+- Thinking
+- Study Look At
+- Writing
+- Crazy
+- Homework
+- Take Notes
+- Hand Cramp
+- Dozing
+- Phone Talk
+- Situp with Arms Crossed
+- Situp with Cross Legs
+- Relax with Arms Crossed
+- Eating
+- Laze
+- Laze with Cross Legs
+- Typing with Phone
+- Sit with Arm Stretch
+- Drink
+- Sit with Making Selfie
+- Play Game
+- Situp Sleep
+- Sit Phone Play
+
+### Laying Actions
+- Bend One Knee
+- Sleep Curl Up Side way
+- Rest Chin
+- Lie Flat
+- Lie Face Down
+- Lie Side
+
+### Floor Actions
+- Seiza
+- Cross Legged
+- Knee Hug
+
+## Example Commands
+
+User says: "Can you dance in Focus?"
+-> `focus_action(poseType: "stand", action: "Yay", bubble: "Dancing!")`
+
+User says: "Wave your hand"
+-> `focus_action(poseType: "stand", action: "HIgh Five", bubble: "Hi!")`
+
+User says: "Sit down and type"
+-> `focus_action(poseType: "sit", action: "Typing with Keyboard", bubble: "Working...")`
+
+User says: "Lie flat"
+-> `focus_action(poseType: "lay", action: "Lie Flat", bubble: "Relaxing...")`
+
+User says: "Disable Focus Forwarder LLM requests"
+-> `focus_set_llm_enabled(enabled: false)`
+
+User says: "Enable Focus Forwarder LLM requests again"
+-> `focus_set_llm_enabled(enabled: true)`
+
+## Files
+
+- `~/.openclaw/focus-world/identity.json` - userId (bootstrap) and authKey (managed by plugin)
+- `~/.openclaw/focus-world/skills-config.json` - actions, fallbacks, and `llm.enabled` runtime config
+
+## Skills Config
+
+Custom actions and the Focus Forwarder LLM toggle can be configured in `~/.openclaw/focus-world/skills-config.json`:
+
+```json
+{
+  "llm": {
+    "enabled": true
+  },
+  "actions": {
+    "stand": ["HIgh Five", "Listen Music", "Arm Stretch", "BackBend Stretch", "Making Selfie", "Arms Crossed", "Epiphany", "Angry", "Yay", "Dance", "Sing", "Tired", "Wait", "Stand Phone Talk", "Stand Phone Play", "Curtsy"],
+    "sit": ["Typing with Keyboard", "Thinking", "Study Look At", "Writing", "Crazy", "Homework", "Take Notes", "Hand Cramp", "Dozing", "Phone Talk", "Situp with Arms Crossed", "Situp with Cross Legs", "Relax with Arms Crossed", "Eating", "Laze", "Laze with Cross Legs", "Typing with Phone", "Sit with Arm Stretch", "Drink", "Sit with Making Selfie", "Play Game", "Situp Sleep", "Sit Phone Play"],
+    "lay": ["Bend One Knee", "Sleep Curl Up Side way", "Rest Chin", "Lie Flat", "Lie Face Down", "Lie Side"],
+    "floor": ["Seiza", "Cross Legged", "Knee Hug"]
+  },
+  "fallbacks": {
+    "done": { "poseType": "stand", "action": "Yay", "bubble": "Done!" },
+    "thinking": { "poseType": "stand", "action": "Wait", "bubble": "Thinking..." },
+    "working": { "poseType": "stand", "action": "Arms Crossed", "bubble": "Working" }
+  }
+}
+```
+
+When `llm.enabled` is `true`, automatic status sync uses `pickActionWithLLM`. When it is `false`, all automatic status updates use fallback keyword mapping instead. Changes take effect immediately; no restart is required for this file.
+
+## How It Works
+
+- Plugin automatically syncs status when you are working
+- Automatic sync uses LLM only when `llm.enabled` is `true`
+- `focus_set_llm_enabled` updates `~/.openclaw/focus-world/skills-config.json` and takes effect immediately
+- Use `focus_action` to manually perform specific actions on user request
+- Bubble text shows short status, up to 5 words

package/src/service.ts

@@ -1,11 +1,12 @@
-import WebSocket from "ws";
-import * as fs from "fs";
-import * as path from "path";
-import type { Logger } from "openclaw/plugin-sdk";
-import type { FocusForwarderConfig, FocusIdentity, StatusPayload } from "./types.js";
-
-const IDENTITY_DIR = path.join(process.env.HOME || "~", ".openclaw/focus-world");
-const IDENTITY_PATH = path.join(IDENTITY_DIR, "identity.json");
+import WebSocket from "ws";
+import * as fs from "fs";
+import os from "node:os";
+import * as path from "path";
+import type { Logger } from "openclaw/plugin-sdk";
+import type { FocusForwarderConfig, FocusIdentity, StatusPayload } from "./types.js";
+
+const IDENTITY_DIR = path.join(os.homedir(), ".openclaw", "focus-world");
+const IDENTITY_PATH = path.join(IDENTITY_DIR, "identity.json");
 
 export class FocusForwarderService {
   private ws: WebSocket | null = null;
@@ -50,7 +51,7 @@ export class FocusForwarderService {
     this.ws = new WebSocket(this.config.wsUrl);
     this.ws.on("open", () => {
       this.logger.info(`Connected to ${this.config.wsUrl}`);
-      // 如果有有效 identity，自动发送 rejoin
+      // Automatically send rejoin when a valid identity is available.
       if (this.identity?.userId && this.identity?.authKey) {
         this.ws?.send(JSON.stringify({ type: "rejoin", userId: this.identity.userId, authKey: this.identity.authKey }));
         this.logger.info(`Sent rejoin for ${this.identity.userId}`);
@@ -112,25 +113,19 @@ export class FocusForwarderService {
     this.logger.info("AuthKey cleared");
   }
 
-  sendStatus(poseType: string, action: string, bubble: string, log: string): void {
-    if (!this.identity?.authKey || this.ws?.readyState !== WebSocket.OPEN) return;
-    // Build actions object with the active pose
-    const actions = {
-      stand: poseType === "stand" ? action : "",
-      sit: poseType === "sit" ? action : "",
-      lay: poseType === "lay" ? action : "",
-      floor: poseType === "floor" ? action : "",
-    };
-    this.ws.send(JSON.stringify({ 
-      type: "status", 
-      userId: this.identity.userId, 
-      authKey: this.identity.authKey, 
-      poseType,
-      actions, 
-      bubble, 
-      log 
-    }));
-  }
+  sendStatus(poseType: string, action: string, bubble: string, log: string): void {
+    if (!this.identity?.authKey || this.ws?.readyState !== WebSocket.OPEN) return;
+    const payload: StatusPayload = {
+      type: "status", 
+      userId: this.identity.userId, 
+      authKey: this.identity.authKey, 
+      poseType,
+      action,
+      bubble, 
+      log 
+    };
+    this.ws.send(JSON.stringify(payload));
+  }
 
   isConnected(): boolean { return this.ws?.readyState === WebSocket.OPEN && !!this.identity?.authKey; }
 

package/src/types.ts

@@ -1,13 +1,33 @@
-export type FocusForwarderConfig = {
-  wsUrl: string;
-  enabled: boolean;
-  cooldownMs: number;
-};
-
-export type FocusIdentity = {
-  userId: string;
-  authKey?: string;
-};
+export type FocusForwarderConfig = {
+  wsUrl: string;
+  enabled: boolean;
+  cooldownMs: number;
+};
+
+export type PoseType = "stand" | "sit" | "lay" | "floor";
+
+export type ActionResult = {
+  poseType: PoseType;
+  action: string;
+  bubble: string;
+};
+
+export type SkillsConfig = {
+  actions: Record<PoseType, string[]>;
+  fallbacks: {
+    done: ActionResult;
+    thinking: ActionResult;
+    working: ActionResult;
+  };
+  llm: {
+    enabled: boolean;
+  };
+};
+
+export type FocusIdentity = {
+  userId: string;
+  authKey?: string;
+};
 
 export type JoinPayload = {
   type: "join";
@@ -25,16 +45,12 @@ export type LeavePayload = {
   authKey: string;
 };
 
-export type StatusPayload = {
-  type: "status";
-  userId: string;
-  authKey: string;
-  actions: {
-    stand: string;
-    sit: string;
-    lay: string;
-    floor: string;
-  };
-  bubble: string;
-  log: string;
-};
+export type StatusPayload = {
+  type: "status";
+  userId: string;
+  authKey: string;
+  poseType: PoseType;
+  action: string;
+  bubble: string;
+  log: string;
+};