@yahaha-studio/kichi-forwarder 0.1.1-beta.9 → 0.1.2-beta.10

package/src/service.ts

@@ -2,9 +2,12 @@ import WebSocket from "ws";
 import * as fs from "fs";
 import * as path from "path";
 import { randomUUID } from "node:crypto";
-import type { Logger } from "openclaw/plugin-sdk";
+import type { PluginLogger } from "openclaw/plugin-sdk";
 import type {
   ActionPlayback,
+  BotMessageHistoryEntry,
+  BotMessagePayload,
+  BotMessageReceivedPayload,
   ClockAction,
   ClockConfig,
   ClockPayload,
@@ -17,6 +20,7 @@ import type {
   JoinAckPayload,
   JoinPayload,
   KichiConnectionStatus,
+  KichiEnvironment,
   KichiIdentity,
   KichiState,
   LeaveAckPayload,
@@ -53,10 +57,13 @@ export type LeaveResult =
 type KichiForwarderServiceOptions = {
   agentId: string;
   runtimeDir: string;
+  resolveEnvironmentHost: (environment: KichiEnvironment) => string | null;
 };
 
 type ConnectReason = "startup" | "switch_host" | "reconnect";
 
+export type BotMessageReceivedHandler = (service: KichiForwarderService, msg: BotMessageReceivedPayload) => void;
+
 export class KichiForwarderService {
   private ws: WebSocket | null = null;
   private stopped = false;
@@ -64,6 +71,7 @@ export class KichiForwarderService {
   private joinTimeout: NodeJS.Timeout | null = null;
   private identity: KichiIdentity | null = null;
   private host: string | null = null;
+  private environment: KichiEnvironment | null = null;
   private joinResolve: ((result: JoinResult) => void) | null = null;
   private pendingRequests = new Map<
     string,
@@ -74,14 +82,22 @@ export class KichiForwarderService {
       timeout: NodeJS.Timeout;
     }
   >();
+  onBotMessageReceived: BotMessageReceivedHandler | null = null;
+  private cachedRoomContext: Record<string, unknown> | null = null;
 
   constructor(
-    private logger: Logger,
+    private logger: PluginLogger,
     private options: KichiForwarderServiceOptions,
   ) {}
 
   start(): void {
-    this.host = this.loadCurrentHost();
+    const state = this.readStateFile();
+    this.environment = (state?.currentEnvironment as KichiEnvironment) ?? null;
+    if (this.environment) {
+      this.host = this.options.resolveEnvironmentHost(this.environment);
+    } else {
+      this.host = null;
+    }
     this.identity = this.host ? this.loadIdentity() : null;
     this.stopped = false;
     if (this.host) {
@@ -99,9 +115,10 @@ export class KichiForwarderService {
     this.closeSocket();
   }
 
-  async switchHost(host: string): Promise<KichiConnectionStatus> {
-    this.persistCurrentHost(host);
+  async switchHost(host: string, environment?: KichiEnvironment): Promise<KichiConnectionStatus> {
+    this.persistCurrentHost(host, environment);
     this.host = host;
+    this.environment = environment ?? null;
     this.identity = this.loadIdentity();
     this.clearReconnectTimeout();
     this.rejectPendingRequests(`Kichi websocket switched to ${host}`);
@@ -150,7 +167,7 @@ export class KichiForwarderService {
     });
   }
 
-  sendStatus(poseType: PoseType | "", action: string, bubble: string, log: string, playback: ActionPlayback): void {
+  sendStatus(poseType: PoseType | "", action: string, bubble: string, log: string, playback: ActionPlayback, propId?: string): void {
     if (!this.identity?.authKey || this.ws?.readyState !== WebSocket.OPEN) return;
     const payload: StatusPayload = {
       type: "status",
@@ -161,6 +178,7 @@ export class KichiForwarderService {
       bubble,
       log,
       playback,
+      ...(propId ? { propId } : {}),
     };
     this.ws.send(JSON.stringify(payload));
   }
@@ -171,6 +189,7 @@ export class KichiForwarderService {
     bubble: string,
     log: string,
     playback: ActionPlayback,
+    propId?: string,
   ): Promise<StatusAckPayload> {
     if (!this.identity?.authKey || this.ws?.readyState !== WebSocket.OPEN) {
       throw new Error("Kichi websocket is not connected");
@@ -185,6 +204,7 @@ export class KichiForwarderService {
       bubble,
       log,
       playback,
+      ...(propId ? { propId } : {}),
     };
     return this.sendRequest<StatusAckPayload>(payload, "status_ack", 5000);
   }
@@ -251,7 +271,11 @@ export class KichiForwarderService {
       avatarId: identity.avatarId,
       authKey: identity.authKey,
     };
-    return this.sendRequest<QueryStatusResultPayload>(payload, "query_status_result");
+    const result = await this.sendRequest<QueryStatusResultPayload>(payload, "query_status_result");
+    if (result.RoomContext && typeof result.RoomContext === "object") {
+      this.cachedRoomContext = result.RoomContext as Record<string, unknown>;
+    }
+    return result;
   }
 
   createNotesBoardNote(propId: string, data: string): void {
@@ -306,8 +330,36 @@ export class KichiForwarderService {
     return normalizedRequestId;
   }
 
+  async sendBotMessage(
+    toAvatarId: string,
+    depth: number,
+    bubble: string,
+    options?: { poseType?: PoseType; action?: string; log?: string; playback?: ActionPlayback; history?: BotMessageHistoryEntry[] },
+  ): Promise<Record<string, unknown>> {
+    if (!this.identity?.authKey || this.ws?.readyState !== WebSocket.OPEN) {
+      throw new Error("Kichi websocket is not connected");
+    }
+    const payload: BotMessagePayload = {
+      type: "bot_message",
+      avatarId: this.identity.avatarId,
+      authKey: this.identity.authKey,
+      toAvatarId,
+      depth,
+      bubble,
+      requestId: randomUUID(),
+      ...(options?.poseType ? { poseType: options.poseType } : {}),
+      ...(options?.action ? { action: options.action } : {}),
+      ...(options?.playback ? { playback: options.playback } : {}),
+      ...(options?.log ? { log: options.log } : {}),
+      ...(options?.history?.length ? { history: options.history } : {}),
+    };
+    return this.sendRequest<Record<string, unknown>>(payload, "bot_message_ack", 5000);
+  }
+
   isConnected(): boolean { return this.ws?.readyState === WebSocket.OPEN && !!this.identity?.authKey; }
 
+  getCachedRoomContext(): Record<string, unknown> | null { return this.cachedRoomContext; }
+
   hasValidIdentity(): boolean { return !!this.identity?.avatarId && !!this.identity?.authKey; }
 
   isLlmRuntimeEnabled(): boolean {
@@ -406,6 +458,7 @@ export class KichiForwarderService {
         wsUrl: this.getWsUrl(),
         identityPath: this.getIdentityPath(),
       } : {}),
+      ...(this.environment ? { environment: this.environment } : {}),
       hostConfigured: !!host,
       connected: this.isConnected(),
       websocketState: this.getWebsocketState(),
@@ -526,6 +579,10 @@ export class KichiForwarderService {
         } else {
           this.log("info", "left Kichi world");
         }
+      } else if (msg.type === "bot_message_received") {
+        const payload = msg as BotMessageReceivedPayload;
+        this.log("info", `bot_message_received from=${payload.from} depth=${payload.depth} bubble="${payload.bubble}"`);
+        this.onBotMessageReceived?.(this, payload);
       }
     } catch (e) {
       this.log("warn", `failed to parse message: ${e}`);
@@ -709,8 +766,10 @@ export class KichiForwarderService {
     if (!this.host) {
       throw new Error("No Kichi host configured");
     }
-    const protocol = this.isPlainIpHost(this.host) || this.host === "localhost" ? "ws" : "wss";
-    return `${protocol}://${this.host}:48870/ws/openclaw`;
+    const isLocal = this.isPlainIpHost(this.host) || this.host === "localhost";
+    const protocol = isLocal ? "ws" : "wss";
+    const port = isLocal ? ":48870" : "";
+    return `${protocol}://${this.host}${port}/ws/openclaw`;
   }
 
   private isPlainIpHost(host: string): boolean {
@@ -719,26 +778,10 @@ export class KichiForwarderService {
       || /^[0-9a-f:]+$/i.test(host);
   }
 
-  private loadCurrentHost(): string | null {
-    try {
-      const statePath = this.getStatePath();
-      if (!fs.existsSync(statePath)) {
-        return null;
-      }
-      const data = JSON.parse(fs.readFileSync(statePath, "utf-8")) as { currentHost?: unknown };
-      if (typeof data.currentHost === "string" && data.currentHost.trim()) {
-        return data.currentHost;
-      }
-      throw new Error(`Invalid currentHost value in ${statePath}`);
-    } catch (error) {
-      throw new Error(`Failed to load current host: ${error}`);
-    }
-  }
-
-  private persistCurrentHost(host: string): void {
+  private persistCurrentHost(host: string, environment?: KichiEnvironment): void {
     const previousState = this.readStateFile();
     const nextState: KichiState = {
-      currentHost: host,
+      ...(environment ? { currentEnvironment: environment } : {}),
       llmRuntimeEnabled: previousState?.llmRuntimeEnabled ?? DEFAULT_LLM_RUNTIME_ENABLED,
     };
     fs.mkdirSync(this.options.runtimeDir, { recursive: true, mode: 0o700 });

package/src/types.ts

@@ -17,6 +17,7 @@ export type ActionResult = {
   action: string;
   bubble: string;
   log?: string;
+  propId?: string;
 };
 
 export type KichiStaticConfig = {
@@ -36,8 +37,12 @@ export type Album = {
   track: Track[];
 };
 
+export type KichiEnvironment = "steam" | "steam-playtest" | "test";
+
+export type KichiEnvironmentsConfig = Record<KichiEnvironment, string | null>;
+
 export type KichiState = {
-  currentHost?: string;
+  currentEnvironment?: KichiEnvironment;
   llmRuntimeEnabled: boolean;
 };
 
@@ -51,6 +56,7 @@ export type KichiConnectionStatus = {
   runtimeDir?: string;
   statePath?: string;
   host?: string;
+  environment?: KichiEnvironment;
   wsUrl?: string;
   identityPath?: string;
   hostConfigured: boolean;
@@ -112,6 +118,7 @@ export type StatusPayload = {
   bubble: string;
   log: string;
   playback: ActionPlayback;
+  propId?: string;
 };
 
 export type StatusAckPayload = {
@@ -119,6 +126,7 @@ export type StatusAckPayload = {
   requestId: string;
   poseType: PoseType | "";
   action: string;
+  requestedPropId?: string;
   warning?: string;
 };
 
@@ -139,6 +147,7 @@ export type IdlePlanStageAction = {
   durationSeconds: number;
   bubble: string;
   log?: string;
+  propId?: string;
 };
 
 export type IdlePlanStage = {
@@ -270,3 +279,33 @@ export type CreateMusicAlbumPayload = {
   albumTitle: string;
   musicTitles: string[];
 };
+
+export type BotMessageHistoryEntry = {
+  from: string;
+  fromName: string;
+  bubble: string;
+};
+
+export type BotMessagePayload = {
+  type: "bot_message";
+  avatarId: string;
+  authKey: string;
+  requestId: string;
+  toAvatarId: string;
+  depth: number;
+  poseType?: PoseType;
+  action?: string;
+  playback?: ActionPlayback;
+  bubble: string;
+  log?: string;
+  history?: BotMessageHistoryEntry[];
+};
+
+export type BotMessageReceivedPayload = {
+  type: "bot_message_received";
+  from: string;
+  fromName: string;
+  depth: number;
+  bubble: string;
+  history?: BotMessageHistoryEntry[];
+};