@yahaha-studio/kichi-forwarder 0.0.1-alpha.44 → 0.0.1-alpha.46

package/index.ts

@@ -71,6 +71,21 @@ const MAX_NOTEBOARD_TEXT_LENGTH = 200;
 const MAX_MESSAGE_RECEIVED_PREVIEW_WIDTH = 20;
 const MESSAGE_RECEIVED_ELLIPSIS = "...";
 const BUNDLED_ALBUM_CONFIG_PATH = new URL("./config/album-config.json", import.meta.url);
+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 cachedConfig: KichiRuntimeConfig | null = null;
 let cachedConfigMtime = 0;
 let cachedConfigPath = "";
@@ -78,6 +93,173 @@ let cachedAlbumConfig: Album | null = null;
 let cachedAlbumConfigMtime = 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") {
@@ -297,6 +479,16 @@ async function handleMessageReceivedHook(content: string): Promise<void> {
   }
   const trimmed = truncateByDisplayWidth(content, MAX_MESSAGE_RECEIVED_PREVIEW_WIDTH);
   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 {
@@ -304,10 +496,30 @@ function handleMessageSentHook(): void {
     return;
   }
   service.sendHookNotify("before_send_message", pickRandomAction(MESSAGE_SENT_BUBBLES));
+  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;
     }
@@ -320,13 +532,65 @@ function registerPluginHooks(api: OpenClawPluginApi): void {
     };
   });
 
-  api.on("before_tool_call", () => {
+  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}`,
+    );
     if (!isLlmRuntimeEnabled()) {
       syncFixedStatus(FIXED_HOOK_STATUSES.beforeToolCall);
     }
   });
 
-  api.on("message_received", async (event) => {
+  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;
     await handleMessageReceivedHook(event.content);
   });
 
@@ -335,6 +599,16 @@ function registerPluginHooks(api: OpenClawPluginApi): void {
   });
 
   api.on("agent_end", (event) => {
+    updateWorkspace(
+      {
+        mode: event.success ? "idle" : "error",
+        phase: event.success ? "run complete" : "run failed",
+        currentFocus: event.success ? "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" : "agent run failed",
+    );
     if (isLlmRuntimeEnabled()) {
       return;
     }
@@ -596,6 +870,13 @@ 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(),
@@ -656,6 +937,7 @@ const plugin = {
           return { success: false, error: "Kichi service is not initialized" };
         }
         if (result.success) {
+          scheduleWorkspacePush();
           return { success: true, authKey: result.authKey };
         }
         return {

package/package.json

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

package/src/service.ts

@@ -22,6 +22,7 @@ import type {
   QueryStatusPayload,
   QueryStatusResultPayload,
   StatusPayload,
+  WorkspaceScreenPayload,
 } from "./types.js";
 
 const IDENTITY_DIR = path.join(os.homedir(), ".openclaw", "kichi-world");
@@ -110,7 +111,6 @@ export class KichiForwarderService {
     this.ws = new WebSocket(this.config.wsUrl);
     this.ws.on("open", () => {
       this.logger.info(`Connected to ${this.config.wsUrl}`);
-      // Automatically send rejoin when a valid identity is available.
       this.sendRejoinPayload();
     });
     this.ws.on("message", (data) => this.handleMessage(data.toString()));
@@ -150,7 +150,6 @@ export class KichiForwarderService {
         this.joinResolve?.({ success: true, authKey: joinAck.authKey });
         this.joinResolve = null;
       } else if (msg.type === "rejoin_failed" || msg.type === "auth_error") {
-        // AuthKey invalid/expired, clear it
         this.logger.warn(`Auth failed: ${msg.reason || "unknown"}`);
         this.clearAuthKey();
       } else if (msg.type === "leave_ack") {
@@ -335,6 +334,20 @@ 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;

package/src/types.ts

@@ -105,6 +105,14 @@ 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";