@soyeht/soyeht 0.2.6 → 0.2.8

package/openclaw.plugin.json

@@ -5,7 +5,7 @@
   ],
   "name": "Soyeht",
   "description": "Channel plugin for the Soyeht Flutter mobile app",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soyeht/soyeht",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "description": "OpenClaw channel plugin for the Soyeht Flutter mobile app",
   "type": "module",
   "main": "src/index.ts",

package/src/http.ts

@@ -1,7 +1,8 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
-import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import type { OpenClawPluginApi, PluginRuntimeChannel } from "openclaw/plugin-sdk";
 import { normalizeAccountId, resolveSoyehtAccount } from "./config.js";
-import { decryptEnvelopeV2, validateEnvelopeV2, type EnvelopeV2 } from "./envelope-v2.js";
+import { decryptEnvelopeV2, encryptEnvelopeV2, validateEnvelopeV2, type EnvelopeV2 } from "./envelope-v2.js";
+import { buildOutboundEnvelope } from "./outbound.js";
 import { cloneRatchetSession, zeroBuffer, type RatchetState } from "./ratchet.js";
 import type { SecurityV2Deps } from "./service.js";
 import { PLUGIN_VERSION } from "./version.js";
@@ -236,15 +237,38 @@ export function inboundHandler(
         return;
       }
 
-      // TODO: Push decrypted message to OpenClaw agent pipeline.
-      // The exact API depends on the OpenClaw runtime (e.g. api.channel.pushInbound()).
-      // For now the message is decrypted and the session is updated;
-      // wiring to the agent conversation will be done when the runtime API is known.
-      api.logger.info("[soyeht] Inbound message received (direct mode)", {
-        accountId: result.accountId,
-      });
+      const { plaintext, accountId } = result;
+
+      // Parse the decrypted message (EnvelopeV2 plaintext is JSON with contentType/text)
+      let messageText: string;
+      try {
+        const parsed = JSON.parse(plaintext);
+        messageText = parsed.text ?? parsed.body ?? plaintext;
+      } catch {
+        messageText = plaintext;
+      }
 
-      sendJson(res, 200, { ok: true, received: true, accountId: result.accountId });
+      api.logger.info("[soyeht] Inbound message received (direct mode)", { accountId });
+
+      // Respond 200 immediately — agent dispatch happens in background
+      sendJson(res, 200, { ok: true, received: true, accountId });
+
+      // Fire-and-forget: dispatch to agent pipeline
+      const channelRuntime = (api.runtime as Record<string, unknown>).channel as
+        | PluginRuntimeChannel
+        | undefined;
+      if (channelRuntime?.routing && channelRuntime?.reply) {
+        dispatchToAgent(api, v2deps, channelRuntime, accountId, messageText).catch((err) => {
+          api.logger.error("[soyeht] Agent dispatch failed", {
+            accountId,
+            error: err instanceof Error ? err.message : String(err),
+          });
+        });
+      } else {
+        api.logger.warn(
+          "[soyeht] channelRuntime not available — message decrypted but not delivered to agent",
+        );
+      }
     } catch (err) {
       const message = err instanceof Error ? err.message : "unknown_error";
       sendJson(res, 400, { ok: false, error: message });
@@ -252,6 +276,119 @@ export function inboundHandler(
   };
 }
 
+// ---------------------------------------------------------------------------
+// Dispatch inbound message to OpenClaw agent pipeline (fire-and-forget)
+// ---------------------------------------------------------------------------
+
+async function dispatchToAgent(
+  api: OpenClawPluginApi,
+  v2deps: SecurityV2Deps,
+  channelRuntime: PluginRuntimeChannel,
+  accountId: string,
+  messageText: string,
+): Promise<void> {
+  const cfg = await api.runtime.config.loadConfig();
+  const account = resolveSoyehtAccount(cfg, accountId);
+
+  const route = channelRuntime.routing.resolveAgentRoute({
+    cfg,
+    channel: "soyeht",
+    accountId: account.accountId,
+    peer: { kind: "direct", id: accountId },
+  });
+
+  const sessionCfg = (cfg as Record<string, unknown>).session as
+    | Record<string, unknown>
+    | undefined;
+  const storePath = channelRuntime.session.resolveStorePath(
+    sessionCfg?.store as string | undefined,
+    { agentId: route.agentId },
+  );
+
+  const envelopeOptions = channelRuntime.reply.resolveEnvelopeFormatOptions(cfg);
+  const previousTimestamp = channelRuntime.session.readSessionUpdatedAt({
+    storePath,
+    sessionKey: route.sessionKey,
+  });
+
+  const body = channelRuntime.reply.formatAgentEnvelope({
+    channel: "Soyeht",
+    from: `soyeht:${accountId}`,
+    timestamp: Date.now(),
+    previousTimestamp,
+    envelope: envelopeOptions,
+    body: messageText,
+  });
+
+  const ctxPayload = channelRuntime.reply.finalizeInboundContext({
+    Body: body,
+    BodyForAgent: messageText,
+    RawBody: messageText,
+    From: `soyeht:${accountId}`,
+    To: `soyeht:${accountId}`,
+    SessionKey: route.sessionKey,
+    AccountId: route.accountId,
+    ChatType: "direct",
+    ConversationLabel: `soyeht:${accountId}`,
+    SenderName: accountId,
+    SenderId: accountId,
+    CommandAuthorized: true,
+    Provider: "soyeht",
+    Surface: "soyeht",
+    OriginatingChannel: "soyeht",
+    OriginatingTo: `soyeht:${accountId}`,
+  });
+
+  await channelRuntime.session.recordInboundSession({
+    storePath,
+    sessionKey: (ctxPayload as Record<string, unknown>).SessionKey as string ?? route.sessionKey,
+    ctx: ctxPayload,
+    onRecordError: (err: unknown) => {
+      api.logger.error("[soyeht] Failed updating session meta", { error: String(err) });
+    },
+  });
+
+  await channelRuntime.reply.dispatchReplyWithBufferedBlockDispatcher({
+    ctx: ctxPayload,
+    cfg,
+    dispatcherOptions: {
+      deliver: async (payload: { text?: string; mediaUrl?: string }) => {
+        const text = payload.text;
+        if (!text) return;
+
+        const ratchetSession = v2deps.sessions.get(accountId);
+        if (!ratchetSession) {
+          api.logger.warn("[soyeht] No ratchet session for reply delivery", { accountId });
+          return;
+        }
+
+        const envelope = buildOutboundEnvelope(accountId, accountId, {
+          contentType: "text",
+          text,
+        });
+
+        const { envelope: v2env, updatedSession } = encryptEnvelopeV2({
+          session: ratchetSession,
+          accountId,
+          plaintext: JSON.stringify(envelope),
+          dhRatchetCfg: {
+            intervalMessages: account.security.dhRatchetIntervalMessages,
+            intervalMs: account.security.dhRatchetIntervalMs,
+          },
+        });
+        v2deps.sessions.set(accountId, updatedSession);
+        v2deps.outboundQueue.enqueue(accountId, v2env);
+      },
+      onError: (err: unknown, info: { kind: string }) => {
+        api.logger.error(`[soyeht] ${info.kind} reply failed`, {
+          accountId,
+          error: err instanceof Error ? err.message : String(err),
+        });
+      },
+    },
+  });
+}
+
 // ---------------------------------------------------------------------------
 // GET /soyeht/events/:accountId (SSE — plugin → app outbound stream)
 // ---------------------------------------------------------------------------

package/src/openclaw-plugin-sdk.d.ts

@@ -140,6 +140,105 @@ declare module "openclaw/plugin-sdk" {
     sampleRate?: number;
   };
 
+  // ---- Channel runtime types (subset used by soyeht inbound dispatch) ----
+
+  export type ResolvedAgentRoute = {
+    agentId: string;
+    channel: string;
+    accountId: string;
+    sessionKey: string;
+    mainSessionKey: string;
+    lastRoutePolicy: "main" | "session";
+    matchedBy: string;
+  };
+
+  export type EnvelopeFormatOptions = {
+    timezone?: string;
+    includeTimestamp?: boolean;
+    includeElapsed?: boolean;
+    userTimezone?: string;
+  };
+
+  export type ReplyPayload = {
+    text?: string;
+    mediaUrl?: string;
+    mediaUrls?: string[];
+    isError?: boolean;
+    isReasoning?: boolean;
+    [key: string]: unknown;
+  };
+
+  export type ReplyDispatchKind = "tool" | "block" | "final";
+
+  export type PluginRuntimeChannel = {
+    routing: {
+      resolveAgentRoute: (params: {
+        cfg: OpenClawConfig;
+        channel: string;
+        accountId?: string | null;
+        peer?: { kind: ChatType; id: string } | null;
+        parentPeer?: { kind: ChatType; id: string } | null;
+        guildId?: string | null;
+        teamId?: string | null;
+        memberRoleIds?: string[];
+      }) => ResolvedAgentRoute;
+      buildAgentSessionKey: (...args: unknown[]) => string;
+    };
+    reply: {
+      finalizeInboundContext: <T extends Record<string, unknown>>(
+        ctx: T,
+        opts?: Record<string, unknown>,
+      ) => T;
+      formatAgentEnvelope: (params: {
+        channel: string;
+        from?: string;
+        timestamp?: number | Date;
+        previousTimestamp?: number | Date;
+        envelope?: EnvelopeFormatOptions;
+        body: string;
+        host?: string;
+        ip?: string;
+      }) => string;
+      resolveEnvelopeFormatOptions: (cfg?: OpenClawConfig) => EnvelopeFormatOptions;
+      dispatchReplyWithBufferedBlockDispatcher: (params: {
+        ctx: Record<string, unknown>;
+        cfg: OpenClawConfig;
+        dispatcherOptions: {
+          deliver: (
+            payload: ReplyPayload,
+            info?: { kind: ReplyDispatchKind },
+          ) => Promise<void>;
+          onError?: (err: unknown, info: { kind: string }) => void;
+          [key: string]: unknown;
+        };
+        replyOptions?: Record<string, unknown>;
+      }) => Promise<unknown>;
+      dispatchReplyFromConfig: (...args: unknown[]) => Promise<unknown>;
+      [key: string]: unknown;
+    };
+    session: {
+      resolveStorePath: (store?: string, opts?: { agentId?: string }) => string;
+      readSessionUpdatedAt: (params: {
+        storePath: string;
+        sessionKey: string;
+      }) => number | undefined;
+      recordInboundSession: (params: {
+        storePath: string;
+        sessionKey: string;
+        ctx: Record<string, unknown>;
+        onRecordError: (err: unknown) => void;
+        [key: string]: unknown;
+      }) => Promise<void>;
+      [key: string]: unknown;
+    };
+    activity: {
+      record: (...args: unknown[]) => void;
+      [key: string]: unknown;
+    };
+    text: { [key: string]: unknown };
+    [key: string]: unknown;
+  };
+
   export type PluginRuntime = {
     config: {
       loadConfig: () => Promise<OpenClawConfig>;
@@ -160,6 +259,7 @@ declare module "openclaw/plugin-sdk" {
         prefsPath?: string;
       }) => Promise<TtsTelephonyResult>;
     };
+    channel?: PluginRuntimeChannel;
     [key: string]: unknown;
   };
 

package/src/service.ts

@@ -78,15 +78,20 @@ const DEFAULT_GATEWAY_PORT = 18789;
 
 function detectLanIp(): string | null {
   const nets = networkInterfaces();
+  const candidates: string[] = [];
   for (const ifaces of Object.values(nets)) {
     if (!ifaces) continue;
     for (const iface of ifaces) {
-      // Skip loopback and internal, only IPv4
       if (iface.internal || iface.family !== "IPv4") continue;
-      return iface.address;
+      candidates.push(iface.address);
     }
   }
-  return null;
+  if (candidates.length === 0) return null;
+  // Prefer typical LAN ranges over VPN/container ranges
+  const preferred = candidates.find((ip) => ip.startsWith("192.168."))
+    ?? candidates.find((ip) => ip.startsWith("10."))
+    ?? candidates[0];
+  return preferred;
 }
 
 function detectGatewayPort(cfg: Record<string, unknown>): number {

package/src/version.ts

@@ -1 +1 @@
-export const PLUGIN_VERSION = "0.2.6";
+export const PLUGIN_VERSION = "0.2.8";