clawrelay 0.3.2 → 0.3.4

package/README.md

@@ -24,6 +24,12 @@ Or install from a local path during development:
 openclaw plugins install ./packages/relay-channel
 ```
 
+Update to the latest version:
+
+```bash
+openclaw plugins update clawrelay
+```
+
 Or install from a tarball:
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawrelay",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "Channel relay plugin for OpenClaw — receives messages from an always-on relay proxy",
   "main": "src/index.ts",
   "type": "module",

package/src/gateway-handler.ts

@@ -23,7 +23,7 @@ export function createRelayInboundHandler(api: any) {
     respond: (ok: boolean, payload?: unknown, error?: unknown) => void;
     context: any;
   }) => {
-    const { params, respond } = opts;
+    const { params, client, respond } = opts;
 
     const message = params.message as RelayInboundMessage | undefined;
     if (!message || !message.messageId || !message.content) {
@@ -36,7 +36,7 @@ export function createRelayInboundHandler(api: any) {
 
     // Resolve the account — use accountId from params or fall back to default
     const accountId = (params.accountId as string) ?? 'default';
-    const config = api.runtime.config.load();
+    const config = api.config;
     const accounts = config.channels?.relay?.accounts ?? {};
     const accountData = accounts[accountId] ?? config.channels?.relay;
 
@@ -62,26 +62,69 @@ export function createRelayInboundHandler(api: any) {
       return;
     }
 
-    try {
-      const responseContent = await processRelayMessage({
-        message,
-        account,
-        config,
-        log: logger,
-      });
-
-      respond(true, {
-        messageId: message.messageId,
-        content: responseContent,
-        replyToMessageId: message.messageId,
-      });
-    } catch (err) {
-      const errMsg = err instanceof Error ? err.message : String(err);
-      logger.error(`[clawrelay] Failed to process inbound: ${errMsg}`);
-      respond(false, undefined, {
-        code: 'INTERNAL_ERROR',
-        message: `Error processing message: ${errMsg}`,
-      });
+    const streaming = params.streaming === true;
+
+    if (streaming) {
+      // Streaming mode: ack immediately, then send deltas via events
+      respond(true, { messageId: message.messageId, streaming: true });
+
+      const streamCallback = (text: string) => {
+        try {
+          client.sendEvent('relay.stream.delta', {
+            messageId: message.messageId,
+            text,
+            kind: 'deliver',
+          });
+        } catch (err) {
+          logger.debug(`[clawrelay] Failed to send stream delta: ${err}`);
+        }
+      };
+
+      try {
+        const responseContent = await processRelayMessage({
+          message,
+          account,
+          config,
+          log: logger,
+          streamCallback,
+        });
+
+        client.sendEvent('relay.stream.done', {
+          messageId: message.messageId,
+          text: responseContent,
+        });
+      } catch (err) {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        logger.error(`[clawrelay] Failed to process inbound (streaming): ${errMsg}`);
+        client.sendEvent('relay.stream.done', {
+          messageId: message.messageId,
+          text: '',
+          error: `Error processing message: ${errMsg}`,
+        });
+      }
+    } else {
+      // Non-streaming: buffered response as before
+      try {
+        const responseContent = await processRelayMessage({
+          message,
+          account,
+          config,
+          log: logger,
+        });
+
+        respond(true, {
+          messageId: message.messageId,
+          content: responseContent,
+          replyToMessageId: message.messageId,
+        });
+      } catch (err) {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        logger.error(`[clawrelay] Failed to process inbound: ${errMsg}`);
+        respond(false, undefined, {
+          code: 'INTERNAL_ERROR',
+          message: `Error processing message: ${errMsg}`,
+        });
+      }
     }
   };
 }
@@ -108,8 +151,9 @@ async function processRelayMessage(params: {
   account: RelayAccount;
   config: any;
   log: any;
+  streamCallback?: (text: string) => void;
 }): Promise<string> {
-  const { message, account, config, log } = params;
+  const { message, account, config, log, streamCallback } = params;
 
   const core = getRelayRuntime();
   const peerId = resolvePeerId(message);
@@ -190,6 +234,7 @@ async function processRelayMessage(params: {
         const text = payload.text ?? '';
         if (text.trim()) {
           parts.push(text);
+          streamCallback?.(text);
         }
       },
       onError: (err: unknown, info: { kind: string }) => {

package/src/onboarding.ts

@@ -9,9 +9,104 @@ import {
   promptAccountId,
 } from "openclaw/plugin-sdk";
 import crypto from "node:crypto";
+import { execSync } from "node:child_process";
+import path from "node:path";
 
 const channel = "relay" as const;
 
+const SPRITE_ENV_BIN = "/.sprite/bin/sprite-env";
+const DEFAULT_GATEWAY_PORT = 18789;
+const GATEWAY_SERVICE_NAME = "openclaw-gateway";
+
+function isOnSprite(): boolean {
+  try {
+    execSync(`test -x ${SPRITE_ENV_BIN}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function getExistingGatewayService(): Record<string, unknown> | undefined {
+  try {
+    const out = execSync(`${SPRITE_ENV_BIN} services list`, {
+      encoding: "utf-8",
+      timeout: 5000,
+    }).trim();
+    const services: Record<string, unknown>[] = JSON.parse(out);
+    return services.find(
+      (s) => (s as any).name === GATEWAY_SERVICE_NAME,
+    );
+  } catch {
+    return undefined;
+  }
+}
+
+function findOpenclawBinary(): string | undefined {
+  const binDir = path.dirname(process.execPath);
+  const candidate = path.join(binDir, "openclaw");
+  try {
+    execSync(`test -x "${candidate}"`, { stdio: "ignore" });
+    return candidate;
+  } catch {
+    return undefined;
+  }
+}
+
+async function ensureSpriteGatewayService(
+  cfg: OpenClawConfig,
+  prompter: WizardPrompter,
+): Promise<void> {
+  if (!isOnSprite()) return;
+
+  const existing = getExistingGatewayService();
+  if (existing) {
+    await prompter.note(
+      `Sprite gateway service already exists (${GATEWAY_SERVICE_NAME}).`,
+      "Sprite",
+    );
+    return;
+  }
+
+  const openclawBin = findOpenclawBinary();
+  if (!openclawBin) {
+    await prompter.note(
+      "Could not locate the openclaw binary to create the gateway service. You may need to create it manually:\n" +
+        `  sprite-env services create ${GATEWAY_SERVICE_NAME} --cmd openclaw --args "gateway,--port,${DEFAULT_GATEWAY_PORT}" --http-port ${DEFAULT_GATEWAY_PORT}`,
+      "Sprite",
+    );
+    return;
+  }
+
+  const gwCfg = (cfg as any).gateway;
+  const port = gwCfg?.port ?? DEFAULT_GATEWAY_PORT;
+
+  const shouldCreate = await prompter.confirm({
+    message: `Create sprite gateway service (${GATEWAY_SERVICE_NAME} on port ${port})?`,
+    initialValue: true,
+  });
+
+  if (!shouldCreate) return;
+
+  try {
+    execSync(
+      `${SPRITE_ENV_BIN} services create ${GATEWAY_SERVICE_NAME} --cmd "${openclawBin}" --args "gateway,--port,${port}" --http-port ${port}`,
+      { encoding: "utf-8", timeout: 10000 },
+    );
+    await prompter.note(
+      `Gateway service created: ${GATEWAY_SERVICE_NAME} → ${openclawBin} gateway --port ${port}`,
+      "Sprite",
+    );
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    await prompter.note(
+      `Failed to create gateway service: ${msg}\n\nYou can create it manually:\n` +
+        `  sprite-env services create ${GATEWAY_SERVICE_NAME} --cmd "${openclawBin}" --args "gateway,--port,${port}" --http-port ${port}`,
+      "Sprite",
+    );
+  }
+}
+
 function generateAuthToken(): string {
   const bytes = crypto.randomBytes(24);
   return `crly_${bytes.toString("base64url")}`;
@@ -168,6 +263,9 @@ export const relayOnboardingAdapter: ChannelOnboardingAdapter = {
       authToken,
     });
 
+    // --- Sprite gateway service ---
+    await ensureSpriteGatewayService(next, prompter);
+
     await prompter.note(
       `Relay channel configured (token: ${authToken.slice(0, 12)}...). Select Finished below, then deploy the relay service.`,
       "Relay",