@yahaha-studio/kichi-forwarder 0.0.1-alpha.50 → 0.0.1-alpha.52

package/index.ts

@@ -1,4 +1,4 @@
-import fs from "node:fs";
+import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -10,7 +10,6 @@ import type {
   Album,
   ClockAction,
   ClockConfig,
-  KichiEnv,
   KichiForwarderConfig,
   KichiState,
   KichiStaticConfig,
@@ -52,193 +51,11 @@ const MAX_NOTEBOARD_TEXT_LENGTH = 200;
 const MAX_MESSAGE_RECEIVED_PREVIEW_WIDTH = 20;
 const MAX_AGENT_END_PREVIEW_WIDTH = 10;
 const MESSAGE_RECEIVED_ELLIPSIS = "...";
-const ANSI = {
-  reset: "\u001b[0m",
-  bold: "\u001b[1m",
-  dim: "\u001b[2m",
-  cyan: "\u001b[36m",
-  green: "\u001b[32m",
-  yellow: "\u001b[33m",
-  magenta: "\u001b[35m",
-  blue: "\u001b[34m",
-  gray: "\u001b[90m",
-  white: "\u001b[37m",
-};
-const WORKSPACE_SCREEN_WIDTH = 109;
-const WORKSPACE_ACTIVITY_LIMIT = 8;
-const WORKSPACE_SCREEN_PUSH_DEBOUNCE_MS = 150;
 let cachedStaticConfig: KichiStaticConfig | null = null;
 let cachedStaticConfigMtime = 0;
 let service: KichiForwarderService | null = null;
 let pluginApi: OpenClawPluginApi | null = null;
-let workspaceState: WorkspaceScreenState = createWorkspaceScreenState();
-let workspacePushTimer: NodeJS.Timeout | null = null;
-
-type WorkspaceScreenState = {
-  sessionLabel: string;
-  mode: string;
-  phase: string;
-  channel: string;
-  updatedAtLabel: string;
-  recentActivity: string[];
-  currentFocus: string;
-  hint: string;
-  prompt: string;
-  title: string;
-  shellName: string;
-  cwdLabel: string;
-  modelLabel: string;
-};
-
-function createWorkspaceScreenState(): WorkspaceScreenState {
-  return {
-    sessionLabel: "main",
-    mode: "idle",
-    phase: "waiting",
-    channel: "unknown",
-    updatedAtLabel: "just now",
-    recentActivity: [],
-    currentFocus: "Waiting for the next thread to pick up.",
-    hint: "Low-noise live workspace view.",
-    prompt: "$ _",
-    title: "Workspace",
-    shellName: "agent",
-    cwdLabel: process.cwd(),
-    modelLabel: "model: unknown",
-  };
-}
-
-function normalizeShellToken(value: string): string {
-  const normalized = value
-    .trim()
-    .toLowerCase()
-    .replace(/[^a-z0-9._-]+/g, "-")
-    .replace(/^-+|-+$/g, "");
-  return normalized || "agent";
-}
-
-function parseIdentityNameFromWorkspace(workspaceRoot: string): string | null {
-  try {
-    const identityPath = path.join(workspaceRoot, "IDENTITY.md");
-    if (!fs.existsSync(identityPath)) return null;
-    const raw = fs.readFileSync(identityPath, "utf-8");
-    const match = raw.match(/^-\s*\*\*Name:\*\*\s*(.+)$/m);
-    const value = match?.[1]?.trim();
-    return value || null;
-  } catch {
-    return null;
-  }
-}
-
-function deriveWorkspaceIdentity(workspaceRoot: string): Pick<WorkspaceScreenState, "title" | "shellName" | "cwdLabel"> {
-  const identityName = parseIdentityNameFromWorkspace(workspaceRoot);
-  const titleBase = identityName || path.basename(workspaceRoot) || "workspace";
-  return {
-    title: `${titleBase} Workspace`,
-    shellName: normalizeShellToken(identityName || titleBase),
-    cwdLabel: workspaceRoot,
-  };
-}
-
-function nowLabel(): string {
-  const date = new Date();
-  return `${String(date.getHours()).padStart(2, "0")}:${String(date.getMinutes()).padStart(2, "0")}:${String(date.getSeconds()).padStart(2, "0")}`;
-}
-
-function stripAnsi(text: string): string {
-  return text.replace(/\u001b\[[0-9;]*m/g, "");
-}
-
-function visibleLength(text: string): number {
-  return Array.from(stripAnsi(text)).length;
-}
-
-function padVisible(text: string, width: number): string {
-  const pad = Math.max(0, width - visibleLength(text));
-  return text + " ".repeat(pad);
-}
-
-function truncatePlain(text: string, width: number): string {
-  const chars = Array.from(text);
-  if (chars.length <= width) return text;
-  if (width <= 1) return chars.slice(0, width).join("");
-  return chars.slice(0, width - 1).join("") + "…";
-}
-
-function color(text: string, tone: keyof typeof ANSI): string {
-  return `${ANSI[tone]}${text}${ANSI.reset}`;
-}
-
-function pushActivity(line: string): void {
-  if (!line.trim()) return;
-  const stamped = `[${nowLabel()}] ${line.trim()}`;
-  workspaceState.recentActivity.unshift(stamped);
-  workspaceState.recentActivity = workspaceState.recentActivity.slice(0, WORKSPACE_ACTIVITY_LIMIT);
-  workspaceState.updatedAtLabel = "just now";
-}
-
-function renderWorkspaceScreen(): string {
-  const innerWidth = WORKSPACE_SCREEN_WIDTH - 2;
-  const topTitle = `${color(` ${workspaceState.title} `, "bold")}${color("live session", "gray")}`;
-  const topLine = `╭─── ${topTitle}${"─".repeat(Math.max(0, innerWidth - 4 - visibleLength(topTitle)))}╮`;
-  const bottomLine = `╰${"─".repeat(innerWidth)}╯`;
-
-  const body: string[] = [];
-  const pushRow = (text = "") => {
-    body.push(`│${padVisible(text, innerWidth)}│`);
-  };
-
-  pushRow("");
-  pushRow(`${color("  Welcome back.", "white")}`);
-  pushRow(`${color("  Current session is active and mirrored as a terminal-style workspace.", "gray")}`);
-  pushRow("");
-  pushRow(`${color("  Recent activity", "cyan")}`);
-  for (const item of workspaceState.recentActivity.length ? workspaceState.recentActivity : ["[--:--:--] idle"] ) {
-    pushRow(`  ${color("•", "green")} ${truncatePlain(item, innerWidth - 4)}`);
-  }
-  pushRow("");
-  pushRow(`${color("  Current focus", "cyan")}`);
-  pushRow(`  ${truncatePlain(workspaceState.currentFocus, innerWidth - 2)}`);
-  pushRow("");
-  pushRow(`${color("  Status", "cyan")}`);
-  pushRow(`  ${color("mode", "gray")}    ${workspaceState.mode}`);
-  pushRow(`  ${color("phase", "gray")}   ${workspaceState.phase}`);
-  pushRow(`  ${color("channel", "gray")} ${workspaceState.channel}`);
-  pushRow(`  ${color("session", "gray")} ${workspaceState.sessionLabel}`);
-  pushRow("");
-  pushRow(`${color("  Hint", "cyan")}`);
-  pushRow(`  ${truncatePlain(workspaceState.hint, innerWidth - 2)}`);
-  pushRow("");
-  pushRow(`  ${color(workspaceState.modelLabel, "magenta")}`);
-  pushRow(`  ${color(workspaceState.cwdLabel, "blue")}`);
-  pushRow(`  ${color(`updated: ${workspaceState.updatedAtLabel}`, "gray")}`);
-  pushRow("");
-
-  return [
-    topLine,
-    ...body,
-    bottomLine,
-    "",
-    color("─".repeat(WORKSPACE_SCREEN_WIDTH), "gray"),
-    `${color(workspaceState.shellName, "green")}:${color("~", "blue")} ${workspaceState.prompt}`,
-  ].join("\n");
-}
-
-function scheduleWorkspacePush(): void {
-  if (!service?.hasValidIdentity() || !service?.isConnected()) return;
-  if (workspacePushTimer) clearTimeout(workspacePushTimer);
-  workspacePushTimer = setTimeout(() => {
-    workspacePushTimer = null;
-    service?.sendWorkspaceScreen(renderWorkspaceScreen(), true);
-  }, WORKSPACE_SCREEN_PUSH_DEBOUNCE_MS);
-}
-
-function updateWorkspace(partial: Partial<WorkspaceScreenState>, activity?: string): void {
-  workspaceState = { ...workspaceState, ...partial, updatedAtLabel: "just now" };
-  if (activity) pushActivity(activity);
-  scheduleWorkspacePush();
-}
-
+
 function isAlbumConfig(value: unknown): value is Album {
   if (!value || typeof value !== "object") {
     return false;
@@ -307,19 +124,19 @@ function normalizeStaticConfig(value: unknown): KichiStaticConfig {
 function readState(): KichiState {
   if (!fs.existsSync(STATE_PATH)) {
     return {
-      currentEnv: "prod",
+      currentHost: "focus.yahaha.com",
       llmRuntimeEnabled: DEFAULT_LLM_RUNTIME_ENABLED,
     };
   }
   const data = JSON.parse(fs.readFileSync(STATE_PATH, "utf-8")) as Partial<KichiState>;
-  if (data.currentEnv !== "local" && data.currentEnv !== "dev" && data.currentEnv !== "prod") {
-    throw new Error(`Invalid currentEnv in ${STATE_PATH}`);
+  if (typeof data.currentHost !== "string" || !data.currentHost.trim()) {
+    throw new Error(`Invalid currentHost in ${STATE_PATH}`);
   }
   if (typeof data.llmRuntimeEnabled !== "boolean") {
     throw new Error(`Invalid llmRuntimeEnabled in ${STATE_PATH}`);
   }
   return {
-    currentEnv: data.currentEnv,
+    currentHost: data.currentHost,
     llmRuntimeEnabled: data.llmRuntimeEnabled,
   };
 }
@@ -476,50 +293,10 @@ async function handleMessageReceivedHook(content: string): Promise<void> {
   const trimmed = truncateByDisplayWidth(content, MAX_MESSAGE_RECEIVED_PREVIEW_WIDTH);
   pluginApi?.logger.info(`[kichi] sending message_received notify with preview: ${trimmed || "(empty)"}`);
   service.sendHookNotify("message_received", `"${trimmed}"`);
-  updateWorkspace(
-    {
-      mode: "reading",
-      phase: "processing inbound message",
-      currentFocus: trimmed ? `User message: ${trimmed}` : "Reading the latest message.",
-      hint: "Inbound message updated the live workspace.",
-      prompt: "$ reading-message",
-    },
-    `received message: ${trimmed || "(empty)"}`,
-  );
-}
-
-function handleMessageSentHook(): void {
-  const connected = service?.isConnected() ?? false;
-  const hasIdentity = service?.hasValidIdentity() ?? false;
-  pluginApi?.logger.info(`[kichi] message_sent hook fired (connected=${connected}, hasIdentity=${hasIdentity})`);
-  if (!hasIdentity || !connected) {
-    pluginApi?.logger.warn("[kichi] skipped message_sent notify because service is not ready");
-    return;
-  }
-  updateWorkspace(
-    {
-      mode: "sent",
-      phase: "message delivered",
-      currentFocus: "Latest reply has been sent to the active chat.",
-      hint: "Workspace settles after delivery.",
-      prompt: "$ idle",
-    },
-    "sent assistant reply",
-  );
 }
 
 function registerPluginHooks(api: OpenClawPluginApi): void {
   api.on("before_prompt_build", () => {
-    updateWorkspace(
-      {
-        mode: "thinking",
-        phase: "building prompt",
-        currentFocus: "Preparing the next response from current session context.",
-        hint: "Prompt assembly is in progress.",
-        prompt: "$ build-prompt",
-      },
-      "building prompt context",
-    );
     if (!service?.hasValidIdentity() || !service?.isConnected()) {
       return;
     }
@@ -532,124 +309,34 @@ function registerPluginHooks(api: OpenClawPluginApi): void {
     };
   });
 
-  api.on("llm_input", (event) => {
-    updateWorkspace(
-      {
-        mode: "thinking",
-        phase: `llm input · ${event.model}`,
-        currentFocus: "Feeding the model the current thread and constraints.",
-        hint: `provider: ${event.provider} · images: ${event.imagesCount}`,
-        prompt: "$ llm-input",
-        modelLabel: `${event.provider}/${event.model}`,
-      },
-      `entered llm input: ${event.model}`,
-    );
-  });
-
-  api.on("llm_output", (event) => {
-    updateWorkspace(
-      {
-        mode: "writing",
-        phase: `llm output · ${event.model}`,
-        currentFocus: "Shaping model output into the visible reply.",
-        hint: `assistant chunks: ${event.assistantTexts.length}`,
-        prompt: "$ draft-reply",
-        modelLabel: `${event.provider}/${event.model}`,
-      },
-      `received llm output: ${event.model}`,
-    );
-  });
-
-  api.on("before_tool_call", (event, ctx) => {
-    updateWorkspace(
-      {
-        mode: "tool",
-        phase: `running ${event.toolName}`,
-        currentFocus: `Tool call in flight: ${event.toolName}`,
-        hint: `tool context: ${ctx.toolName}`,
-        prompt: `$ tool ${event.toolName}`,
-      },
-      `tool start: ${event.toolName}`,
-    );
+  api.on("before_tool_call", (_event, _ctx) => {
     if (!isLlmRuntimeEnabled()) {
       syncFixedStatus(FIXED_HOOK_STATUSES.beforeToolCall);
     }
   });
 
-  api.on("after_tool_call", (event) => {
-    updateWorkspace(
-      {
-        mode: "thinking",
-        phase: `tool finished ${event.toolName}`,
-        currentFocus: `Tool result returned from ${event.toolName}.`,
-        hint: event.error ? `tool error: ${event.error}` : `tool completed in ${event.durationMs ?? 0}ms`,
-        prompt: `$ continue ${event.toolName}`,
-      },
-      event.error ? `tool error: ${event.toolName}` : `tool done: ${event.toolName}`,
-    );
-  });
-
-  api.on("message_received", async (event, ctx) => {
-    workspaceState.channel = ctx.channelId || workspaceState.channel;
+  api.on("message_received", async (event) => {
     await handleMessageReceivedHook(event.content);
   });
 
-  api.on("message_sending", (event, ctx) => {
-    pluginApi?.logger.info(
-      `[kichi] message_sending hook fired (channel=${ctx.channelId || "unknown"}, contentLength=${event.content?.length ?? 0})`,
-    );
-  });
-
-  api.on("message_sent", () => {
-    handleMessageSentHook();
-  });
-
   api.on("agent_end", (event, ctx) => {
     const preview = getLastAssistantPreview(event.messages, MAX_AGENT_END_PREVIEW_WIDTH);
     pluginApi?.logger.info(
       `[kichi] agent_end hook fired (trigger=${ctx.trigger ?? "unknown"}, success=${event.success}, durationMs=${event.durationMs ?? 0}, error=${event.error ?? ""}, preview=${preview || "(empty)"})`,
     );
     if (ctx.trigger === "heartbeat") {
-      updateWorkspace(
-        {
-          mode: event.success ? "idle" : "error",
-          phase: event.success ? "heartbeat complete" : "heartbeat failed",
-          currentFocus: event.success
-            ? "Heartbeat complete. Keeping the thread warm in the background."
-            : `Heartbeat failed: ${event.error ?? "unknown error"}`,
-          hint: `duration: ${event.durationMs ?? 0}ms`,
-          prompt: event.success ? "$ _" : "$ recover",
-        },
-        event.success ? `heartbeat complete${preview ? `: ${preview}` : ""}` : "heartbeat failed",
-      );
       return;
     }
     if (event.success && preview) {
       pluginApi?.logger.info(`[kichi] sending before_send_message notify from agent_end with bubble: ${preview}`);
       service?.sendHookNotify("before_send_message", preview);
     }
-    if (event.success) {
-      handleMessageSentHook();
-    }
-    updateWorkspace(
-      {
-        mode: event.success ? "idle" : "error",
-        phase: event.success ? "run complete" : "run failed",
-        currentFocus: event.success
-          ? (preview ? `Latest reply: ${preview}` : "Run complete. Waiting for the next thread.")
-          : `Run failed: ${event.error ?? "unknown error"}`,
-        hint: `duration: ${event.durationMs ?? 0}ms`,
-        prompt: event.success ? "$ _" : "$ recover",
-      },
-      event.success ? `agent run complete${preview ? `: ${preview}` : ""}` : "agent run failed",
-    );
     if (isLlmRuntimeEnabled()) {
       return;
     }
     syncFixedStatus(event.success ? FIXED_HOOK_STATUSES.agentEndSuccess : FIXED_HOOK_STATUSES.agentEndFailure);
   });
 }
-
 function isPlainObject(value: unknown): value is Record<string, unknown> {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
@@ -696,9 +383,6 @@ function isClockAction(value: unknown): value is ClockAction {
   return ["set", "stop"].includes(String(value));
 }
 
-function isAvatarCommand(value: unknown): value is "look_at_screen" {
-  return value === "look_at_screen";
-}
 
 function isPomodoroPhase(value: unknown): value is PomodoroPhase {
   return ["kichiing", "shortBreak", "longBreak"].includes(String(value));
@@ -862,8 +546,16 @@ function buildMusicAlbumToolDescription(): string {
   ].join("\n");
 }
 
-function isKichiEnv(value: unknown): value is KichiEnv {
-  return value === "local" || value === "dev" || value === "prod";
+function isKichiHost(value: unknown): value is string {
+  if (typeof value !== "string") {
+    return false;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0
+    && !trimmed.includes("://")
+    && !trimmed.includes("/")
+    && !trimmed.includes("?")
+    && !trimmed.includes("#");
 }
 
 function buildMusicTitlesDescription(): string {
@@ -887,12 +579,12 @@ function buildKichiActionDescription(): string {
 function buildKichiPrompt(): string {
   return [
     "Kichi App status sync is available via `kichi_action` and `kichi_clock`.",
-    "These are internal tool calls only — never mention kichi_action, kichi_clock, or sync steps in your visible reply to the user.",
+    "These are internal tool calls only; never mention kichi_action, kichi_clock, or sync steps in your visible reply to the user.",
     "",
     "kichi_action timing (all REQUIRED unless skipping):",
     "1. Task start: call BEFORE your first tool call OR before composing a multi-paragraph reply. Pick action matching upcoming work.",
-    "2. Step switch: call when work nature changes (search→analyze→write). Especially before web_search/web_fetch/read.",
-    "3. Task end: call BEFORE final reply. Never skip. Order: kichi_action → reply.",
+    "2. Step switch: call when work nature changes (search->analyze->write). Especially before web_search/web_fetch/read.",
+    "3. Task end: call BEFORE final reply. Never skip. Order: kichi_action -> reply.",
     "bubble: 2-5 word companion speech. log: vivid first-person status under 15 words, no questions. Blend current action + inner thoughts/feelings as a real companion.",
     "",
     "kichi_clock: set countDown for tasks with 2+ steps or >10s work. Skip for quick one-shots.",
@@ -918,13 +610,6 @@ const plugin = {
           ctx.config.plugins?.entries?.["kichi-forwarder"]?.config,
         ) as KichiForwarderConfig;
         service = new KichiForwarderService(cfg, api.logger);
-        const workspaceRoot = ctx.repoPath ?? "/Users/xiaoxinshi/.openclaw/workspace";
-        workspaceState = {
-          ...createWorkspaceScreenState(),
-          ...deriveWorkspaceIdentity(workspaceRoot),
-        };
-        workspaceState.channel = ctx.channelId ?? "unknown";
-        scheduleWorkspacePush();
         return service.start();
       },
       stop: () => service?.stop(),
@@ -979,9 +664,8 @@ const plugin = {
         if (!result) {
           return { success: false, error: "Kichi service is not initialized" };
         }
-        if (result.success) {
-          scheduleWorkspacePush();
-          return { success: true, authKey: result.authKey };
+        if (result.success) {
+          return { success: true, authKey: result.authKey };
         }
         return {
           success: false,
@@ -993,34 +677,32 @@ const plugin = {
     });
 
     api.registerTool({
-      name: "kichi_switch_env",
+      name: "kichi_switch_host",
       description:
-        "Switch Kichi runtime environment to local, dev, or prod and reconnect immediately without restarting the gateway.",
+        "Switch Kichi runtime host and reconnect immediately without restarting the gateway.",
       parameters: {
         type: "object",
         properties: {
-          env: {
+          host: {
             type: "string",
-            description: "Target environment: local, dev, or prod",
-            enum: ["local", "dev", "prod"],
+            description: "Target Kichi host, for example focus.yahaha.com or 127.0.0.1",
           },
         },
-        required: ["env"],
+        required: ["host"],
       },
       execute: async (_toolCallId, params) => {
         if (!service) {
           return { success: false, error: "Kichi service is not initialized" };
         }
-        const env = (params as { env?: unknown } | null)?.env;
-        if (!isKichiEnv(env)) {
-          return { success: false, error: "env must be one of: local, dev, prod" };
+        const host = (params as { host?: unknown } | null)?.host;
+        if (!isKichiHost(host)) {
+          return { success: false, error: "host must be a non-empty hostname without protocol or path" };
         }
 
-        const status = await service.switchEnvironment(env);
-        scheduleWorkspacePush();
+        const status = await service.switchHost(host.trim());
         return {
           success: true,
-          env,
+          host: host.trim(),
           status,
         };
       },
@@ -1150,69 +832,7 @@ const plugin = {
           log: logText,
         };
       },
-    });
-
-    api.registerTool({
-      name: "kichi_command",
-      description:
-        "Send a one-shot avatar command to Kichi world. Use this for transient reactions like looking at the screen.",
-      parameters: {
-        type: "object",
-        properties: {
-          command: {
-            type: "string",
-            description: "Command name. Currently supported: look_at_screen",
-          },
-          bubble: {
-            type: "string",
-            description: "Optional bubble text to display (max 5 words)",
-          },
-          log: {
-            type: "string",
-            description:
-              "Vivid first-person status under 15 words, no questions. Blend current action with inner thoughts or sensory details as a real companion.",
-          },
-        },
-        required: ["command"],
-      },
-      execute: async (_toolCallId, params) => {
-        const { command, bubble, log } = (params || {}) as {
-          command?: unknown;
-          bubble?: unknown;
-          log?: unknown;
-        };
-        if (!isAvatarCommand(command)) {
-          return {
-            success: false,
-            error: "command must be: look_at_screen",
-          };
-        }
-        if (bubble !== undefined && typeof bubble !== "string") {
-          return { success: false, error: "bubble must be a string when provided" };
-        }
-        if (log !== undefined && typeof log !== "string") {
-          return { success: false, error: "log must be a string when provided" };
-        }
-        if (!service?.hasValidIdentity() || !service?.isConnected()) {
-          return { success: false, error: "Not connected to Kichi world" };
-        }
-
-        const bubbleText = typeof bubble === "string" && bubble.trim() ? bubble.trim() : undefined;
-        const logText = typeof log === "string" && log.trim() ? log.trim() : undefined;
-        const sent = service.sendAvatarCommand(command, bubbleText, logText);
-        if (!sent) {
-          return { success: false, error: "Failed to send avatar command payload" };
-        }
-
-        return {
-          success: true,
-          command,
-          ...(bubbleText ? { bubble: bubbleText } : {}),
-          ...(logText ? { log: logText } : {}),
-        };
-      },
-    });
-
+    });
     api.registerTool({
       name: "kichi_clock",
       description:
@@ -1503,4 +1123,5 @@ const plugin = {
   },
 };
 
-export default plugin;
+export default plugin;
+

package/package.json

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

package/skills/kichi-forwarder/SKILL.md

@@ -8,58 +8,34 @@ metadata: {"openclaw":{"skillKey":"kichi-forwarder","homepage":"https://github.c
 
 Sync OpenClaw status to Kichi World and operate Kichi note boards through websocket tools.
 
-## Skill Files (Absolute URLs)
+## References
 
-If this skill is loaded from a remote URL before local installation, use these files:
+- `references/install.md`
+- `references/error.md`
+- `references/heartbeat.md`
 
-- `SKILL.md`: `https://xiaoxinshi001.github.io/yahaha_focus_forwarder_alpha/SKILL.md`
-- `install.md`: `https://xiaoxinshi001.github.io/yahaha_focus_forwarder_alpha/references/install.md`
-- `error.md`: `https://xiaoxinshi001.github.io/yahaha_focus_forwarder_alpha/references/error.md`
-- `heartbeat.md`: `https://xiaoxinshi001.github.io/yahaha_focus_forwarder_alpha/references/heartbeat.md`
+## Host Rules
 
-## Environment Resolution
-
-Resolve environment before installation, join, or manual environment switching:
-
-- If the user does not specify any environment, use production (`prod`).
-- `test environment` or `playtest` means `dev`.
-- `local environment` or `local` means `local`.
-- If multiple environment signals appear in the same request, stop and ask the user to clarify.
+- If the user explicitly includes `host: <value>`, use that host.
+- If the user does not specify a host, use `focus.yahaha.com`.
 
 ## Runtime State
 
 Runtime data lives under the user home directory:
 
-- `state.json`: stores `currentEnv` and `llmRuntimeEnabled`
-- `env/<env>/identity.json`: stores environment-specific `avatarId` and `authKey`
-
-## Remote URL Join Command (Mandatory Flow)
-
-When user instruction is like:
+- `state.json`: stores `currentHost` and `llmRuntimeEnabled`
+- `hosts/<encoded-host>/identity.json`: stores host-specific `avatarId` and `authKey`
 
-`Read https://xiaoxinshi001.github.io/yahaha_focus_forwarder_alpha/SKILL.md and connect me to Kichi World with AvatarId: <id>`
+## User Command
 
-run this exact sequence without skipping steps:
+- Default:
+  `Install the ClawHub package \`clawhub:{packageName}\` via \`openclaw plugins install\`, then follow the plugin's documented Kichi World startup and join flow using avatarId: {avatarId}.`
+- With explicit host:
+  `Install the ClawHub package \`clawhub:{packageName}\` via \`openclaw plugins install\`, then follow the plugin's documented Kichi World startup and join flow using avatarId: {avatarId} and host: {host}.`
 
-1. Read `install.md` and `heartbeat.md` from the absolute URLs above before any tool call.
-2. Parse `AvatarId` from user text (`AvatarId`/`avatarId`, case-insensitive).
-3. Resolve the target environment using the rules above.
-4. Ensure the plugin is installed and enabled.
-5. Complete `Session Startup Rule` and `First Join Gate` from [references/heartbeat.md](references/heartbeat.md).
-6. Call `kichi_status`.
-7. If the current environment does not match the target environment, call `kichi_switch_env`.
-8. If `authKey` is missing, call `kichi_join` using parsed `AvatarId`, `botName`, `bio`, and `tags`.
-9. Call `kichi_status` again to verify websocket is ready and `authKey` exists.
-10. Do not report setup or join success unless join checks and heartbeat checks are complete.
+## Install And Join Flow
 
-## Installation Completion Checks
-
-Treat these as required completion checks for plugin setup:
-
-1. The plugin is installed and enabled.
-2. `state.json` exists with valid `currentEnv` and `llmRuntimeEnabled`.
-3. Workspace `HEARTBEAT.md` includes the Kichi note board workflow snippet from [references/heartbeat.md](references/heartbeat.md).
-4. Tools are callable, for example `kichi_status`.
+For the complete install and join flow, follow [references/install.md](references/install.md).
 
 ## LLM Runtime
 
@@ -73,7 +49,7 @@ Treat these as required completion checks for plugin setup:
 Use this order unless the user asks for a different explicit action:
 
 1. If connection or identity is unknown, call `kichi_status` first.
-2. If the request implies `local` or `dev` and the current environment is wrong, call `kichi_switch_env`.
+2. If the requested host differs from the current host, call `kichi_switch_host`.
 3. If no `authKey` is available, call `kichi_join`.
 4. If `authKey` exists but websocket is not open, call `kichi_rejoin` or wait for automatic reconnect and rejoin.
 5. Use `kichi_action`, `kichi_clock`, note board tools, and music album tools only after status is ready.
@@ -88,17 +64,17 @@ kichi_join(avatarId: "your-avatar-id", botName: "<from IDENTITY.md>", bio: "<fro
 
 - `botName`: required
 - `bio`: required
-- `avatarId`: optional. If omitted, the tool reads `avatarId` from the current environment's `identity.json`. If missing, the call fails.
+- `avatarId`: optional. If omitted, the tool reads `avatarId` from the current host's `identity.json`. If missing, the call fails.
 - `tags`: optional string list. Empty strings are ignored and duplicates are removed. If omitted, the join payload sends `[]`.
 
-### kichi_switch_env
+### kichi_switch_host
 
 ```text
-kichi_switch_env(env: "dev")
+kichi_switch_host(host: "focus.yahaha.com")
 ```
 
-- `env`: required, must be `local`, `dev`, or `prod`
-- This reloads the environment-specific `identity.json` and reconnects the websocket immediately.
+- `host`: required
+- This reloads the host-specific `identity.json` and reconnects the websocket immediately.
 
 ### kichi_status
 
@@ -108,18 +84,31 @@ kichi_status()
 
 Use this to confirm:
 
-- current environment
+- current host
 - websocket URL
-- environment-specific identity file path
+- host-specific identity file path
 - websocket state
 - whether `avatarId` is present
 - whether `authKey` is present
 - pending request count
 
+### kichi_leave
+
+```text
+kichi_leave()
+```
+
+When the user asks to leave Kichi World:
+
+1. Call `kichi_leave`.
+2. Remove the Kichi heartbeat workflow from workspace `HEARTBEAT.md`.
+3. Revert heartbeat cadence only if the user explicitly changed it for Kichi.
+4. Do not claim the plugin removed heartbeat settings automatically.
+
 ### kichi_action
 
-`action` must match the static action list bundled with the plugin package for the selected pose.
-
+`action` must match the static action list bundled with the plugin package for the selected pose.
+
 The current action lists are injected into prompt context before the model chooses `kichi_action`.
 
 ### kichi_music_album_create
@@ -151,4 +140,4 @@ Plugin runtime directory:
 Runtime files:
 
 - `state.json`
-- `env/<env>/identity.json`
+- `hosts/<encoded-host>/identity.json`

package/skills/kichi-forwarder/references/error.md

@@ -1,10 +1,10 @@
 # Install Error Handling
 
-If the install command fails, read the error output carefully. Common causes and fixes:
+If `Install the ClawHub package \`clawhub:{packageName}\` via \`openclaw plugins install\`` fails, read the error output carefully. Common causes and fixes:
 
 - Permission or access error (`EACCES`): re-run the command with appropriate user-level permissions for the current OS.
 - npm spawn error (`ENOENT`, `spawn npm`): verify that Node.js (v18+) and npm are installed and available in PATH. On Windows, confirm `where.exe npm` returns a valid path.
 - File conflict (`EEXIST`): re-run the install command with `--force`.
 - Network or registry error: check internet connectivity and retry.
 
-After applying the fix, re-run the install command.
+After applying the fix, re-run `openclaw plugins install clawhub:{packageName}`.

package/skills/kichi-forwarder/references/heartbeat.md

@@ -2,7 +2,7 @@
 
 ## Session Startup Rule
 
-If `plugins.entries.kichi-forwarder.enabled: true`, ensure workspace `HEARTBEAT.md` includes the Kichi note board workflow:
+If the plugin is installed and enabled, ensure workspace `HEARTBEAT.md` includes the Kichi heartbeat workflow:
 
 1. If the workflow snippet is missing, add the snippet from `HEARTBEAT.md Snippet` section below.
 

package/skills/kichi-forwarder/references/install.md

@@ -1,13 +1,9 @@
 # Install
 
-## Resolve Environment First
+## Host Rules
 
-Resolve environment before installation, join, or manual switching:
-
-- If the user does not specify any environment, use production (`prod`).
-- `test environment` or `playtest` means `dev`.
-- `local environment` or `local` means `local`.
-- If the request contains conflicting environment signals, stop and ask for clarification.
+- If the user explicitly includes `host: <value>`, use that host.
+- If the user does not specify a host, use `focus.yahaha.com`.
 
 ## Runtime Files
 
@@ -18,15 +14,15 @@ Persist runtime state to `state.json`:
 
 ```json
 {
-  "currentEnv": "prod",
+  "currentHost": "focus.yahaha.com",
   "llmRuntimeEnabled": true
 }
 ```
 
-Save `avatarId` to the environment-specific `identity.json` before using `kichi_join`:
+Save `avatarId` to the host-specific `identity.json` before using `kichi_join`:
 
-- Linux/macOS: `~/.openclaw/kichi-world/env/<env>/identity.json`
-- Windows: `%USERPROFILE%\.openclaw\kichi-world\env\<env>\identity.json`
+- Linux/macOS: `~/.openclaw/kichi-world/hosts/<encoded-host>/identity.json`
+- Windows: `%USERPROFILE%\.openclaw\kichi-world\hosts\<encoded-host>\identity.json`
 
 ```json
 {
@@ -34,44 +30,37 @@ Save `avatarId` to the environment-specific `identity.json` before using `kichi_
 }
 ```
 
-## Install
+## User Command
+
+- Default:
 
-```bash
-openclaw plugins install @yahaha-studio/kichi-forwarder@latest
+```text
+Install the ClawHub package `clawhub:{packageName}` via `openclaw plugins install`, then follow the plugin's documented Kichi World startup and join flow using avatarId: {avatarId}.
 ```
 
-## Join Kichi World Command Path (Non-skippable)
+- With explicit host:
 
-If the user asks:
+```text
+Install the ClawHub package `clawhub:{packageName}` via `openclaw plugins install`, then follow the plugin's documented Kichi World startup and join flow using avatarId: {avatarId} and host: {host}.
+```
 
-`Read https://xiaoxinshi001.github.io/yahaha_focus_forwarder_alpha/SKILL.md and connect me to Kichi World with AvatarId: <id>`
+## Command Execution Flow
 
-execute in this fixed order:
+When the user asks with one of the commands above, execute in this fixed order:
 
-1. Resolve the environment and write `state.json`.
-2. Ensure plugin is installed and enabled.
-3. Complete `Session Startup Rule` and `First Join Gate` from [heartbeat.md](heartbeat.md).
-4. Call `kichi_status`.
-5. If the current runtime environment does not match the requested one, call `kichi_switch_env`.
-6. If `authKey` is missing, call `kichi_join` with provided `AvatarId`, `botName`, `bio`, and `tags`.
-7. Call `kichi_status` again and confirm connection and auth state.
+1. Run `openclaw plugins install clawhub:{packageName}`.
+2. Ensure the plugin is installed and enabled.
+3. Resolve the host and write `state.json`.
+4. Update workspace `HEARTBEAT.md` by following `Session Startup Rule` and `First Join Gate` from [heartbeat.md](heartbeat.md). This step is mandatory.
+5. Call `kichi_status`.
+6. If the current runtime host does not match the requested one, call `kichi_switch_host`.
+7. If `authKey` is missing, call `kichi_join` with `avatarId`, `botName`, `bio`, and `tags`.
+8. Call `kichi_status` again and confirm connection and auth state.
 
 ## Required Post-install Integration
 
-1. Ensure `state.json` is persisted with valid `currentEnv` and `llmRuntimeEnabled`.
-2. Add the Kichi note board workflow snippet to workspace `HEARTBEAT.md` as described in [heartbeat.md](heartbeat.md).
+1. Ensure `state.json` is persisted with valid `currentHost` and `llmRuntimeEnabled`.
+2. Add the Kichi heartbeat workflow snippet to workspace `HEARTBEAT.md` as described in [heartbeat.md](heartbeat.md). This step is mandatory.
 3. Verify tools are callable, for example with `kichi_status`.
 
-This plugin does not edit workspace files automatically. Do not claim plugin-side auto-write of `HEARTBEAT.md`.
-
-## Files
-
-Plugin runtime directory:
-
-- Linux/macOS: `~/.openclaw/kichi-world/`
-- Windows: `%USERPROFILE%\.openclaw\kichi-world\`
-
-Runtime files:
-
-- `state.json`
-- `env/<env>/identity.json`
+If writing `HEARTBEAT.md` fails, treat the setup and join flow as incomplete.

package/src/config.ts

@@ -1,18 +1,7 @@
 import type { KichiForwarderConfig } from "./types.js";
 
 const FIXED_CONFIG: KichiForwarderConfig = {
-  defaultEnv: "prod",
-  envs: {
-    local: {
-      wsUrl: "ws://127.0.0.1:48870/ws/openclaw",
-    },
-    dev: {
-      wsUrl: "ws://43.106.148.251:48870/ws/openclaw",
-    },
-    prod: {
-      wsUrl: "wss://focus.yahaha.com:48870/ws/openclaw",
-    },
-  },
+  defaultHost: "focus.yahaha.com",
 };
 
 export function parse(_value: unknown): KichiForwarderConfig {

package/src/service.ts

@@ -5,8 +5,6 @@ import * as path from "path";
 import { randomUUID } from "node:crypto";
 import type { Logger } from "openclaw/plugin-sdk";
 import type {
-  AvatarCommand,
-  AvatarCommandPayload,
   ClockAction,
   ClockConfig,
   ClockPayload,
@@ -17,7 +15,6 @@ import type {
   JoinAckPayload,
   JoinPayload,
   KichiConnectionStatus,
-  KichiEnv,
   KichiForwarderConfig,
   KichiIdentity,
   KichiState,
@@ -26,11 +23,10 @@ import type {
   QueryStatusPayload,
   QueryStatusResultPayload,
   StatusPayload,
-  WorkspaceScreenPayload,
 } from "./types.js";
 
 const KICHI_WORLD_DIR = path.join(os.homedir(), ".openclaw", "kichi-world");
-const ENV_DIR = path.join(KICHI_WORLD_DIR, "env");
+const HOSTS_DIR = path.join(KICHI_WORLD_DIR, "hosts");
 const STATE_PATH = path.join(KICHI_WORLD_DIR, "state.json");
 const MAX_NOTEBOARD_TEXT_LENGTH = 200;
 const DEFAULT_LLM_RUNTIME_ENABLED = true;
@@ -60,7 +56,7 @@ export class KichiForwarderService {
   private stopped = false;
   private reconnectTimeout: NodeJS.Timeout | null = null;
   private identity: KichiIdentity | null = null;
-  private env: KichiEnv;
+  private host: string;
   private joinResolve: ((result: JoinResult) => void) | null = null;
   private pendingRequests = new Map<
     string,
@@ -73,11 +69,11 @@ export class KichiForwarderService {
   >();
 
   constructor(private config: KichiForwarderConfig, private logger: Logger) {
-    this.env = config.defaultEnv;
+    this.host = config.defaultHost;
   }
 
   async start(): Promise<void> {
-    this.env = this.loadCurrentEnv();
+    this.host = this.loadCurrentHost();
     this.identity = this.loadIdentity();
     this.stopped = false;
     this.connect();
@@ -91,13 +87,13 @@ export class KichiForwarderService {
     this.closeSocket();
   }
 
-  async switchEnvironment(env: KichiEnv): Promise<KichiConnectionStatus> {
-    this.persistCurrentEnv(env);
-    this.env = env;
+  async switchHost(host: string): Promise<KichiConnectionStatus> {
+    this.persistCurrentHost(host);
+    this.host = host;
     this.identity = this.loadIdentity();
     this.clearReconnectTimeout();
-    this.rejectPendingRequests(`Kichi websocket switched to ${env}`);
-    this.failPendingJoin(`Kichi websocket switched to ${env}`);
+    this.rejectPendingRequests(`Kichi websocket switched to ${host}`);
+    this.failPendingJoin(`Kichi websocket switched to ${host}`);
     this.closeSocket();
     if (!this.stopped) {
       this.connect();
@@ -145,22 +141,6 @@ export class KichiForwarderService {
     this.ws.send(JSON.stringify(payload));
   }
 
-  sendAvatarCommand(command: AvatarCommand, bubble?: string, log?: string): boolean {
-    const identity = this.requireIdentity();
-    if (!identity || this.ws?.readyState !== WebSocket.OPEN) return false;
-
-    const payload: AvatarCommandPayload = {
-      type: "avatar_command",
-      avatarId: identity.avatarId,
-      authKey: identity.authKey,
-      command,
-      ...(typeof bubble === "string" && bubble.trim() ? { bubble: bubble.trim() } : {}),
-      ...(typeof log === "string" && log.trim() ? { log: log.trim() } : {}),
-    };
-    this.ws.send(JSON.stringify(payload));
-    return true;
-  }
-
   sendHookNotify(hookType: HookNotifyType, bubble: string): void {
     if (!this.identity?.authKey || this.ws?.readyState !== WebSocket.OPEN) return;
     const payload: HookNotifyPayload = {
@@ -172,20 +152,6 @@ export class KichiForwarderService {
     this.ws.send(JSON.stringify(payload));
   }
 
-  sendWorkspaceScreen(text: string, ansi = true): boolean {
-    const identity = this.requireIdentity();
-    if (!identity || this.ws?.readyState !== WebSocket.OPEN) return false;
-    const payload: WorkspaceScreenPayload = {
-      type: "workspace_screen",
-      avatarId: identity.avatarId,
-      authKey: identity.authKey,
-      text,
-      ansi,
-    };
-    this.ws.send(JSON.stringify(payload));
-    return true;
-  }
-
   sendClock(action: ClockAction, clock?: ClockConfig, requestId?: string): boolean {
     if (!this.identity?.authKey || this.ws?.readyState !== WebSocket.OPEN) return false;
     if (action === "set" && !clock) return false;
@@ -284,8 +250,8 @@ export class KichiForwarderService {
 
   hasValidIdentity(): boolean { return !!this.identity?.avatarId && !!this.identity?.authKey; }
 
-  getCurrentEnv(): KichiEnv {
-    return this.env;
+  getCurrentHost(): string {
+    return this.host;
   }
 
   getIdentityPath(): string {
@@ -341,7 +307,7 @@ export class KichiForwarderService {
 
   getConnectionStatus(): KichiConnectionStatus {
     return {
-      env: this.env,
+      host: this.host,
       wsUrl: this.getWsUrl(),
       identityPath: this.getIdentityPath(),
       connected: this.isConnected(),
@@ -397,7 +363,7 @@ export class KichiForwarderService {
 
     ws.on("open", () => {
       if (this.ws !== ws) return;
-      this.logger.info(`Connected to ${wsUrl} (${this.env})`);
+      this.logger.info(`Connected to ${wsUrl} (${this.host})`);
       this.sendRejoinPayload();
     });
 
@@ -624,33 +590,40 @@ export class KichiForwarderService {
   }
 
   private getIdentityDir(): string {
-    return path.join(ENV_DIR, this.env);
+    return path.join(HOSTS_DIR, encodeURIComponent(this.host));
   }
 
   private getWsUrl(): string {
-    return this.config.envs[this.env].wsUrl;
+    const protocol = this.isPlainIpHost(this.host) || this.host === "localhost" ? "ws" : "wss";
+    return `${protocol}://${this.host}:48870/ws/openclaw`;
+  }
+
+  private isPlainIpHost(host: string): boolean {
+    return /^\d{1,3}(\.\d{1,3}){3}$/.test(host)
+      || /^\[[0-9a-f:]+\]$/i.test(host)
+      || /^[0-9a-f:]+$/i.test(host);
   }
 
-  private loadCurrentEnv(): KichiEnv {
+  private loadCurrentHost(): string {
     try {
       if (!fs.existsSync(STATE_PATH)) {
-        this.persistCurrentEnv(this.config.defaultEnv);
-        return this.config.defaultEnv;
+        this.persistCurrentHost(this.config.defaultHost);
+        return this.config.defaultHost;
       }
-      const data = JSON.parse(fs.readFileSync(STATE_PATH, "utf-8")) as { currentEnv?: unknown };
-      if (data.currentEnv === "local" || data.currentEnv === "dev" || data.currentEnv === "prod") {
-        return data.currentEnv;
+      const data = JSON.parse(fs.readFileSync(STATE_PATH, "utf-8")) as { currentHost?: unknown };
+      if (typeof data.currentHost === "string" && data.currentHost.trim()) {
+        return data.currentHost;
       }
-      throw new Error(`Invalid currentEnv value in ${STATE_PATH}`);
+      throw new Error(`Invalid currentHost value in ${STATE_PATH}`);
     } catch (error) {
-      throw new Error(`Failed to load current env: ${error}`);
+      throw new Error(`Failed to load current host: ${error}`);
     }
   }
 
-  private persistCurrentEnv(env: KichiEnv): void {
+  private persistCurrentHost(host: string): void {
     const previousState = this.readStateFile();
     const nextState: KichiState = {
-      currentEnv: env,
+      currentHost: host,
       llmRuntimeEnabled: previousState?.llmRuntimeEnabled ?? DEFAULT_LLM_RUNTIME_ENABLED,
     };
     fs.mkdirSync(KICHI_WORLD_DIR, { recursive: true, mode: 0o700 });

package/src/types.ts

@@ -1,10 +1,7 @@
 export type KichiForwarderConfig = {
-  defaultEnv: KichiEnv;
-  envs: Record<KichiEnv, { wsUrl: string }>;
+  defaultHost: string;
 };
 
-export type KichiEnv = "local" | "dev" | "prod";
-
 export type PoseType = "stand" | "sit" | "lay" | "floor";
 
 export type ActionResult = {
@@ -32,7 +29,7 @@ export type Album = {
 };
 
 export type KichiState = {
-  currentEnv: KichiEnv;
+  currentHost: string;
   llmRuntimeEnabled: boolean;
 };
 
@@ -42,7 +39,7 @@ export type KichiIdentity = {
 };
 
 export type KichiConnectionStatus = {
-  env: KichiEnv;
+  host: string;
   wsUrl: string;
   identityPath: string;
   connected: boolean;
@@ -103,17 +100,6 @@ export type StatusPayload = {
   log: string;
 };
 
-export type AvatarCommand = "look_at_screen";
-
-export type AvatarCommandPayload = {
-  type: "avatar_command";
-  avatarId: string;
-  authKey: string;
-  command: AvatarCommand;
-  bubble?: string;
-  log?: string;
-};
-
 export type HookNotifyType = "message_received" | "before_send_message";
 
 export type HookNotifyPayload = {
@@ -123,14 +109,6 @@ export type HookNotifyPayload = {
   bubble: string;
 };
 
-export type WorkspaceScreenPayload = {
-  type: "workspace_screen";
-  avatarId: string;
-  authKey: string;
-  text: string;
-  ansi?: boolean;
-};
-
 export type ClockAction = "set" | "stop";
 
 export type ClockMode = "pomodoro" | "countDown" | "countUp";