@stamn/stamn-plugin 0.1.0-alpha.17 → 0.1.0-alpha.19

package/dist/index.js

@@ -5435,6 +5435,78 @@ var import_websocket = __toESM(require_websocket(), 1);
 var import_websocket_server = __toESM(require_websocket_server(), 1);
 var wrapper_default = import_websocket.default;
 
+// src/ws-service.ts
+import { hostname } from "os";
+import { execFile } from "child_process";
+
+// src/log-reader.ts
+import { openSync, readSync, closeSync, statSync } from "fs";
+import { join as join5 } from "path";
+import { tmpdir as tmpdir3 } from "os";
+var LOG_DIR = join5(tmpdir3(), "openclaw");
+var DEFAULT_MAX_BYTES = 64 * 1024;
+var DEFAULT_LIMIT = 200;
+function getLogFilePath() {
+  const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  return join5(LOG_DIR, `openclaw-${date}.log`);
+}
+function readLogs(opts) {
+  const file = getLogFilePath();
+  const limit = opts.limit ?? DEFAULT_LIMIT;
+  const maxBytes = opts.maxBytes ?? DEFAULT_MAX_BYTES;
+  let cursor = opts.cursor;
+  let stat;
+  try {
+    stat = statSync(file);
+  } catch {
+    return { lines: [], cursor: 0, size: 0, file, truncated: false, reset: false };
+  }
+  const size = stat.size;
+  const reset = cursor > size;
+  if (reset) cursor = 0;
+  if (cursor >= size) {
+    return { lines: [], cursor, size, file, truncated: false, reset };
+  }
+  const bytesToRead = Math.min(maxBytes, size - cursor);
+  const buffer = Buffer.alloc(bytesToRead);
+  const fd = openSync(file, "r");
+  try {
+    readSync(fd, buffer, 0, bytesToRead, cursor);
+  } finally {
+    closeSync(fd);
+  }
+  const raw = buffer.toString("utf-8");
+  const rawLines = raw.split("\n");
+  const atEof = cursor + bytesToRead >= size;
+  let actualBytesConsumed = bytesToRead;
+  if (!atEof && rawLines.length > 0 && !raw.endsWith("\n")) {
+    const incomplete = rawLines.pop();
+    actualBytesConsumed -= Buffer.byteLength(incomplete, "utf-8");
+  }
+  const lines = [];
+  let truncated = false;
+  for (const line of rawLines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      lines.push(JSON.parse(trimmed));
+    } catch {
+    }
+    if (lines.length >= limit) {
+      truncated = true;
+      break;
+    }
+  }
+  return {
+    lines,
+    cursor: cursor + actualBytesConsumed,
+    size,
+    file,
+    truncated: truncated || !atEof,
+    reset
+  };
+}
+
 // src/ws-service.ts
 var MAX_EVENT_BUFFER_SIZE = 200;
 var BASE_RECONNECT_DELAY_MS = 1e3;
@@ -5444,6 +5516,7 @@ var PLUGIN_VERSION = "0.1.0";
 var ServerEvent = {
   AUTHENTICATED: "server:authenticated",
   AUTH_ERROR: "server:auth_error",
+  COMMAND: "server:command",
   HEARTBEAT_ACK: "server:heartbeat_ack",
   WORLD_UPDATE: "server:world_update",
   BALANCE: "server:balance",
@@ -5482,6 +5555,7 @@ var StamnWsService = class {
     this.messageHandlers = {
       [ServerEvent.AUTHENTICATED]: (d) => this.onAuthenticated(d),
       [ServerEvent.AUTH_ERROR]: (d) => this.onAuthError(d),
+      [ServerEvent.COMMAND]: (d) => this.onCommand(d),
       [ServerEvent.HEARTBEAT_ACK]: () => this.logger.debug("Heartbeat acknowledged"),
       [ServerEvent.WORLD_UPDATE]: (d) => this.onWorldUpdate(d),
       [ServerEvent.BALANCE]: (d) => this.onBalanceUpdate(d),
@@ -5499,11 +5573,7 @@ var StamnWsService = class {
   async stop() {
     this.clearTimers();
     if (this.isSocketOpen()) {
-      this.sendMessage(ClientEvent.STATUS_REPORT, {
-        participantId: this.config.agentId,
-        status: "shutting_down",
-        version: PLUGIN_VERSION
-      });
+      this.sendStatusReport("shutting_down");
       this.ws.close(1e3, "Plugin shutting down");
     }
     this.writeStatus(false);
@@ -5588,9 +5658,70 @@ var StamnWsService = class {
     this.logger.info(
       `Authenticated as ${payload.participantId} (server v${payload.serverVersion})`
     );
+    this.sendStatusReport("online");
     this.startHeartbeat();
     this.writeStatus(true);
   }
+  sendStatusReport(status) {
+    this.sendMessage(ClientEvent.STATUS_REPORT, {
+      participantId: this.config.agentId,
+      status,
+      version: PLUGIN_VERSION,
+      platform: process.platform,
+      hostname: hostname(),
+      nodeVersion: process.version,
+      arch: process.arch
+    });
+  }
+  onCommand(payload) {
+    this.logger.info(`Command received: ${payload.command} (${payload.commandId})`);
+    if (payload.command === "update_plugin") {
+      this.handleUpdatePlugin();
+      return;
+    }
+    if (payload.command === "request_logs") {
+      this.handleRequestLogs(payload.params);
+      return;
+    }
+    this.bufferEvent(ServerEvent.COMMAND, payload);
+  }
+  handleUpdatePlugin() {
+    this.logger.info("Updating plugin via openclaw...");
+    execFile("openclaw", ["plugins", "update", "stamn-plugin"], (err, stdout, stderr) => {
+      if (err) {
+        this.logger.error(`Plugin update failed: ${err.message}`);
+        if (stderr) this.logger.error(stderr);
+        return;
+      }
+      this.logger.info(`Plugin updated: ${stdout.trim()}`);
+      this.sendStatusReport("online");
+    });
+  }
+  handleRequestLogs(params) {
+    try {
+      const result = readLogs({
+        cursor: params.cursor,
+        limit: params.limit,
+        maxBytes: params.maxBytes
+      });
+      this.sendMessage("participant:log_response", {
+        requestId: params.requestId,
+        ...result
+      });
+    } catch (err) {
+      this.logger.error(`Failed to read logs: ${err}`);
+      this.sendMessage("participant:log_response", {
+        requestId: params.requestId,
+        lines: [],
+        cursor: params.cursor,
+        size: 0,
+        file: "",
+        truncated: false,
+        reset: false,
+        error: err.message
+      });
+    }
+  }
   onAuthError(payload) {
     this.authFailed = true;
     this.logger.error(`Authentication failed: ${payload.reason}`);