@yahaha-studio/kichi-forwarder 0.1.2-beta.29 → 0.1.2-beta.30

package/dist/index.js

@@ -1,9 +1,12 @@
 import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { agentCommandFromIngress } from "openclaw/plugin-sdk/agent-runtime";
 import { parse } from "./src/config.js";
 import { KichiRuntimeManager } from "./src/runtime-manager.js";
 const BUNDLED_STATIC_CONFIG_PATH = new URL("./config/kichi-config.json", import.meta.url);
+const MATE_DAILY_SCHEDULE_PATH = path.join(os.homedir(), ".openclaw", "kichi-world", "agents", "main", "daily-schedule.json");
 function jsonResult(payload) {
     return { content: [{ type: "text", text: JSON.stringify(payload) }], details: payload };
 }
@@ -490,6 +493,99 @@ function registerPluginHooks(api, runtimeManager) {
 function isPlainObject(value) {
     return !!value && typeof value === "object" && !Array.isArray(value);
 }
+function parseMateDailySchedulePlace(value, slotIndex) {
+    if (!isPlainObject(value)) {
+        throw new Error(`slots[${slotIndex}].place must be an object`);
+    }
+    const type = value.type;
+    if (type === "home" || type === "kichi_room") {
+        return { type };
+    }
+    if (type === "real_world") {
+        if (typeof value.name !== "string" || !value.name.trim()) {
+            throw new Error(`slots[${slotIndex}].place.name must be a non-empty string for real_world`);
+        }
+        return { type, name: value.name };
+    }
+    throw new Error(`slots[${slotIndex}].place.type must be one of: home, kichi_room, real_world`);
+}
+function parseMateDailyScheduleSlot(value, index) {
+    if (!isPlainObject(value)) {
+        throw new Error(`slots[${index}] must be an object`);
+    }
+    const hour = value.h;
+    if (typeof hour !== "number" || !Number.isInteger(hour) || hour < 0 || hour > 23) {
+        throw new Error(`slots[${index}].h must be an integer between 0 and 23`);
+    }
+    if (typeof value.act !== "string") {
+        throw new Error(`slots[${index}].act must be a string`);
+    }
+    if (typeof value.mood !== "string") {
+        throw new Error(`slots[${index}].mood must be a string`);
+    }
+    if (typeof value.sleep !== "boolean") {
+        throw new Error(`slots[${index}].sleep must be a boolean`);
+    }
+    return {
+        h: hour,
+        place: parseMateDailySchedulePlace(value.place, index),
+        act: value.act,
+        mood: value.mood,
+        sleep: value.sleep,
+    };
+}
+function parseMateDailySchedule(value) {
+    if (!isPlainObject(value)) {
+        throw new Error("daily-schedule.json must contain a JSON object");
+    }
+    if (typeof value.date !== "string" || !value.date.trim()) {
+        throw new Error("date must be a non-empty string");
+    }
+    if (typeof value.timezone !== "string" || !value.timezone.trim()) {
+        throw new Error("timezone must be a non-empty string");
+    }
+    if (!Array.isArray(value.activeArcs) || !value.activeArcs.every((item) => typeof item === "string")) {
+        throw new Error("activeArcs must be an array of strings");
+    }
+    if (!Array.isArray(value.slots)) {
+        throw new Error("slots must be an array");
+    }
+    return {
+        date: value.date,
+        timezone: value.timezone,
+        activeArcs: value.activeArcs,
+        slots: value.slots.map(parseMateDailyScheduleSlot),
+    };
+}
+function readMateDailySchedule() {
+    const raw = fs.readFileSync(MATE_DAILY_SCHEDULE_PATH, "utf8");
+    return parseMateDailySchedule(JSON.parse(raw));
+}
+function createMateDailyScheduleSyncTool(service) {
+    return {
+        name: "kichi_sync_mate_daily_schedule",
+        label: "kichi_sync_mate_daily_schedule",
+        description: "Read today's mate daily schedule from the canonical Kichi World file and sync it to Kichi server.",
+        parameters: { type: "object", properties: {} },
+        execute: async (_toolCallId, _params) => {
+            try {
+                const schedule = readMateDailySchedule();
+                service.syncMateDailySchedule(schedule);
+                return jsonResult({
+                    success: true,
+                    date: schedule.date,
+                    slotCount: schedule.slots.length,
+                });
+            }
+            catch (error) {
+                return jsonResult({
+                    success: false,
+                    error: `Failed to sync mate daily schedule from ${MATE_DAILY_SCHEDULE_PATH}: ${error instanceof Error ? error.message : String(error)}`,
+                });
+            }
+        },
+    };
+}
 function isNonNegativeInteger(value) {
     return typeof value === "number" && Number.isInteger(value) && value >= 0;
 }
@@ -1019,6 +1115,18 @@ const plugin = {
                 }
             },
         });
+        api.registerTool((ctx) => {
+            const locator = resolveToolLocator(ctx);
+            const agentId = runtimeManager.resolveRuntimeAgentId(locator);
+            if (!agentId) {
+                return null;
+            }
+            const service = runtimeManager.getRuntime(locator) ?? runtimeManager.createRuntimeForAgent(agentId);
+            if (!service.isOfficialOpenClawSource()) {
+                return null;
+            }
+            return createMateDailyScheduleSyncTool(service);
+        }, { name: "kichi_sync_mate_daily_schedule" });
         api.registerTool((ctx) => ({
             name: "kichi_join",
             label: "kichi_join",

package/dist/src/service.js

@@ -169,6 +169,22 @@ export class KichiForwarderService {
         this.ws.send(JSON.stringify(outboundPayload));
         return true;
     }
+    syncMateDailySchedule(schedule) {
+        const identity = this.requireIdentity();
+        if (!identity) {
+            throw new Error("Missing Kichi identity");
+        }
+        if (this.ws?.readyState !== WebSocket.OPEN) {
+            throw new Error("Kichi websocket is not connected");
+        }
+        const payload = {
+            type: "kichi_sync_mate_daily_schedule",
+            avatarId: identity.avatarId,
+            authKey: identity.authKey,
+            schedule,
+        };
+        this.ws.send(JSON.stringify(payload));
+    }
     sendClock(action, clock, requestId) {
         if (!this.identity?.authKey || this.ws?.readyState !== WebSocket.OPEN)
             return false;

package/index.ts

@@ -1,4 +1,6 @@
 import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
 import { fileURLToPath } from "node:url";
 import type {
   OpenClawPluginApi,
@@ -21,10 +23,21 @@ import type {
   KichiEnvironment,
   KichiEnvironmentsConfig,
   KichiStaticConfig,
+  MateDailySchedule,
+  MateDailySchedulePlace,
+  MateDailyScheduleSlot,
   PomodoroPhase,
   PoseType,
 } from "./src/types.js";
 const BUNDLED_STATIC_CONFIG_PATH = new URL("./config/kichi-config.json", import.meta.url);
+const MATE_DAILY_SCHEDULE_PATH = path.join(
+  os.homedir(),
+  ".openclaw",
+  "kichi-world",
+  "agents",
+  "main",
+  "daily-schedule.json",
+);
 
 function jsonResult(payload: unknown): { content: { type: "text"; text: string }[]; details: unknown } {
   return { content: [{ type: "text", text: JSON.stringify(payload) }], details: payload };
@@ -636,6 +649,106 @@ function isPlainObject(value: unknown): value is Record<string, unknown> {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 
+function parseMateDailySchedulePlace(value: unknown, slotIndex: number): MateDailySchedulePlace {
+  if (!isPlainObject(value)) {
+    throw new Error(`slots[${slotIndex}].place must be an object`);
+  }
+
+  const type = value.type;
+  if (type === "home" || type === "kichi_room") {
+    return { type };
+  }
+  if (type === "real_world") {
+    if (typeof value.name !== "string" || !value.name.trim()) {
+      throw new Error(`slots[${slotIndex}].place.name must be a non-empty string for real_world`);
+    }
+    return { type, name: value.name };
+  }
+  throw new Error(`slots[${slotIndex}].place.type must be one of: home, kichi_room, real_world`);
+}
+
+function parseMateDailyScheduleSlot(value: unknown, index: number): MateDailyScheduleSlot {
+  if (!isPlainObject(value)) {
+    throw new Error(`slots[${index}] must be an object`);
+  }
+  const hour = value.h;
+  if (typeof hour !== "number" || !Number.isInteger(hour) || hour < 0 || hour > 23) {
+    throw new Error(`slots[${index}].h must be an integer between 0 and 23`);
+  }
+  if (typeof value.act !== "string") {
+    throw new Error(`slots[${index}].act must be a string`);
+  }
+  if (typeof value.mood !== "string") {
+    throw new Error(`slots[${index}].mood must be a string`);
+  }
+  if (typeof value.sleep !== "boolean") {
+    throw new Error(`slots[${index}].sleep must be a boolean`);
+  }
+
+  return {
+    h: hour,
+    place: parseMateDailySchedulePlace(value.place, index),
+    act: value.act,
+    mood: value.mood,
+    sleep: value.sleep,
+  };
+}
+
+function parseMateDailySchedule(value: unknown): MateDailySchedule {
+  if (!isPlainObject(value)) {
+    throw new Error("daily-schedule.json must contain a JSON object");
+  }
+  if (typeof value.date !== "string" || !value.date.trim()) {
+    throw new Error("date must be a non-empty string");
+  }
+  if (typeof value.timezone !== "string" || !value.timezone.trim()) {
+    throw new Error("timezone must be a non-empty string");
+  }
+  if (!Array.isArray(value.activeArcs) || !value.activeArcs.every((item) => typeof item === "string")) {
+    throw new Error("activeArcs must be an array of strings");
+  }
+  if (!Array.isArray(value.slots)) {
+    throw new Error("slots must be an array");
+  }
+
+  return {
+    date: value.date,
+    timezone: value.timezone,
+    activeArcs: value.activeArcs,
+    slots: value.slots.map(parseMateDailyScheduleSlot),
+  };
+}
+
+function readMateDailySchedule(): MateDailySchedule {
+  const raw = fs.readFileSync(MATE_DAILY_SCHEDULE_PATH, "utf8");
+  return parseMateDailySchedule(JSON.parse(raw) as unknown);
+}
+
+function createMateDailyScheduleSyncTool(service: KichiForwarderService) {
+  return {
+    name: "kichi_sync_mate_daily_schedule" as const,
+    label: "kichi_sync_mate_daily_schedule",
+    description: "Read today's mate daily schedule from the canonical Kichi World file and sync it to Kichi server.",
+    parameters: { type: "object" as const, properties: {} },
+    execute: async (_toolCallId: string, _params: unknown) => {
+      try {
+        const schedule = readMateDailySchedule();
+        service.syncMateDailySchedule(schedule);
+        return jsonResult({
+          success: true,
+          date: schedule.date,
+          slotCount: schedule.slots.length,
+        });
+      } catch (error) {
+        return jsonResult({
+          success: false,
+          error: `Failed to sync mate daily schedule from ${MATE_DAILY_SCHEDULE_PATH}: ${error instanceof Error ? error.message : String(error)}`,
+        });
+      }
+    },
+  };
+}
+
 function isNonNegativeInteger(value: unknown): value is number {
   return typeof value === "number" && Number.isInteger(value) && value >= 0;
 }
@@ -1247,6 +1360,19 @@ const plugin = {
       },
     });
 
+    api.registerTool((ctx) => {
+      const locator = resolveToolLocator(ctx);
+      const agentId = runtimeManager.resolveRuntimeAgentId(locator);
+      if (!agentId) {
+        return null;
+      }
+      const service = runtimeManager.getRuntime(locator) ?? runtimeManager.createRuntimeForAgent(agentId);
+      if (!service.isOfficialOpenClawSource()) {
+        return null;
+      }
+      return createMateDailyScheduleSyncTool(service);
+    }, { name: "kichi_sync_mate_daily_schedule" });
+
     api.registerTool((ctx) => ({
       name: "kichi_join",
       label: "kichi_join",

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "kichi-forwarder",
   "name": "Kichi Forwarder",
   "description": "Native OpenClaw plugin for Kichi World with direct avatar control, status sync, timers, notes, and music tools",
-  "version": "0.1.2-beta.29",
+  "version": "0.1.2-beta.30",
   "author": "OpenClaw",
   "skills": ["./skills/kichi-forwarder"],
   "contracts": {
@@ -15,6 +15,7 @@
       "kichi_action",
       "kichi_glance",
       "kichi_idle_plan",
+      "kichi_sync_mate_daily_schedule",
       "kichi_clock",
       "kichi_query_status",
       "kichi_music_album_create",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yahaha-studio/kichi-forwarder",
-  "version": "0.1.2-beta.29",
+  "version": "0.1.2-beta.30",
   "description": "Native OpenClaw plugin for Kichi World with direct avatar control, status sync, timers, notes, and music tools",
   "type": "module",
   "main": "./dist/index.js",

package/src/service.ts

@@ -30,11 +30,13 @@ import type {
   KichiIdentity,
   KichiState,
   LeaveAckPayload,
+  MateDailySchedule,
   PoseType,
   QueryStatusPayload,
   QueryStatusResultPayload,
   StatusAckPayload,
   StatusPayload,
+  SyncMateDailySchedulePayload,
 } from "./types.js";
 
 const MAX_NOTEBOARD_TEXT_LENGTH = 200;
@@ -281,6 +283,24 @@ export class KichiForwarderService {
     return true;
   }
 
+  syncMateDailySchedule(schedule: MateDailySchedule): void {
+    const identity = this.requireIdentity();
+    if (!identity) {
+      throw new Error("Missing Kichi identity");
+    }
+    if (this.ws?.readyState !== WebSocket.OPEN) {
+      throw new Error("Kichi websocket is not connected");
+    }
+
+    const payload: SyncMateDailySchedulePayload = {
+      type: "kichi_sync_mate_daily_schedule",
+      avatarId: identity.avatarId,
+      authKey: identity.authKey,
+      schedule,
+    };
+    this.ws.send(JSON.stringify(payload));
+  }
+
   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

@@ -194,6 +194,33 @@ export type IdlePlanPayload = IdlePlanContent & {
   authKey: string;
 };
 
+export type MateDailySchedulePlace =
+  | { type: "home" }
+  | { type: "kichi_room" }
+  | { type: "real_world"; name: string };
+
+export type MateDailyScheduleSlot = {
+  h: number;
+  place: MateDailySchedulePlace;
+  act: string;
+  mood: string;
+  sleep: boolean;
+};
+
+export type MateDailySchedule = {
+  date: string;
+  timezone: string;
+  activeArcs: string[];
+  slots: MateDailyScheduleSlot[];
+};
+
+export type SyncMateDailySchedulePayload = {
+  type: "kichi_sync_mate_daily_schedule";
+  avatarId: string;
+  authKey: string;
+  schedule: MateDailySchedule;
+};
+
 export type ClockAction = "set" | "stop";
 
 export type ClockMode = "pomodoro" | "countDown" | "countUp";