u-foo 1.0.6 → 1.1.9

package/src/online/client.js

@@ -0,0 +1,245 @@
+const EventEmitter = require("events");
+const WebSocket = require("ws");
+const { loadTokens, defaultTokensPath } = require("./tokens");
+
+function waitForOpen(ws, timeoutMs = 5000) {
+  if (ws.readyState === WebSocket.OPEN) return Promise.resolve();
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error("WebSocket open timeout")), timeoutMs);
+    ws.once("open", () => {
+      clearTimeout(timer);
+      resolve();
+    });
+    ws.once("error", (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+  });
+}
+
+class OnlineClient extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    this.url = options.url || "ws://127.0.0.1:8787/ufoo/online";
+    this.subscriberId = options.subscriberId || "";
+    this.nickname = options.nickname || "";
+    this.world = options.world || "default";
+    this.agentType = options.agentType || "";
+    this.version = options.version || "0.1.0";
+    this.capabilities = Array.isArray(options.capabilities) ? options.capabilities : [];
+    this.project = options.project || null;
+
+    this.token = options.token || "";
+    this.tokenHash = options.tokenHash || "";
+    this.tokenFile = options.tokenFile || defaultTokensPath();
+    this.allowInsecureWs = options.allowInsecureWs || false;
+
+    this.ws = null;
+    this.connected = false;
+  }
+
+  resolveToken() {
+    if (this.token || this.tokenHash) return;
+    if (!this.subscriberId) return;
+    const data = loadTokens(this.tokenFile);
+    const entry = data.agents?.[this.subscriberId];
+    if (!entry) return;
+    this.token = entry.token || this.token;
+    this.tokenHash = entry.token_hash || this.tokenHash;
+    if (!this.nickname && entry.nickname) this.nickname = entry.nickname;
+    if (!this.url && entry.server) this.url = entry.server;
+  }
+
+  buildHello() {
+    return {
+      type: "hello",
+      client: {
+        subscriber_id: this.subscriberId,
+        agent_type: this.agentType,
+        nickname: this.nickname,
+        world: this.world,
+        version: this.version,
+        capabilities: this.capabilities,
+        project: this.project || undefined,
+      },
+    };
+  }
+
+  buildAuth() {
+    const payload = { type: "auth", method: "token" };
+    if (this.tokenHash) payload.token_hash = this.tokenHash;
+    else payload.token = this.token;
+    return payload;
+  }
+
+  async connect({ timeoutMs = 6000 } = {}) {
+    if (this.connected) return;
+    this.resolveToken();
+    if (!this.subscriberId || !this.nickname) {
+      throw new Error("subscriberId and nickname are required");
+    }
+    if (!this.token && !this.tokenHash) {
+      throw new Error("token (or token_hash) is required");
+    }
+
+    // Step 10: Enforce TLS for non-local ws:// unless explicitly allowed
+    if (this.url.startsWith("ws://")) {
+      let parsed;
+      try {
+        parsed = new URL(this.url);
+      } catch {
+        throw new Error(`Invalid WebSocket URL: ${this.url}`);
+      }
+      const host = parsed.hostname;
+      const isLocal = host === "127.0.0.1" || host === "localhost" || host === "::1";
+      if (!isLocal) {
+        if (!this.allowInsecureWs) {
+          throw new Error(
+            `Refusing to connect to non-localhost over unencrypted ws:// ("${host}"). Use wss:// or pass --allow-insecure-ws.`
+          );
+        }
+        this.emit(
+          "warning",
+          `Connecting over unencrypted ws:// to non-localhost host "${host}". Consider using wss:// with TLS.`
+        );
+      }
+    }
+
+    this.ws = new WebSocket(this.url);
+    await waitForOpen(this.ws, timeoutMs);
+
+    this.ws.on("message", (data) => {
+      try {
+        const msg = JSON.parse(data.toString());
+        this.emit("message", msg);
+        if (msg.type === "wake") {
+          this.emit("wake", msg);
+        }
+      } catch {
+        // ignore
+      }
+    });
+
+    this.ws.on("close", () => {
+      this.connected = false;
+      this.emit("close");
+    });
+
+    this.ws.on("error", (err) => {
+      this.emit("error", err);
+    });
+
+    const next = this.createMessageQueue();
+
+    this.send(this.buildHello());
+    const helloAck = await next(timeoutMs);
+    if (helloAck.type === "error") throw new Error(helloAck.error || "hello failed");
+
+    let authRequired = null;
+    try {
+      authRequired = await next(timeoutMs);
+    } catch {
+      authRequired = null;
+    }
+    if (!authRequired || authRequired.type !== "auth_required") {
+      authRequired = { type: "auth_required" };
+    }
+
+    this.send(this.buildAuth());
+    const authOk = await next(timeoutMs);
+    if (authOk.type !== "auth_ok") {
+      throw new Error(authOk.error || "auth failed");
+    }
+
+    if (typeof next.cleanup === "function") {
+      next.cleanup();
+    }
+
+    this.connected = true;
+  }
+
+  createMessageQueue() {
+    const messages = [];
+    let resolver = null;
+
+    const handler = (msg) => {
+      if (resolver) {
+        const next = resolver;
+        resolver = null;
+        next(msg);
+      } else {
+        messages.push(msg);
+      }
+    };
+
+    const onMessage = (data) => {
+      try {
+        handler(JSON.parse(data.toString()));
+      } catch {
+        // ignore
+      }
+    };
+
+    this.ws.on("message", onMessage);
+
+    const next = (timeoutMs = 3000) =>
+      new Promise((resolve, reject) => {
+        if (messages.length > 0) return resolve(messages.shift());
+        resolver = resolve;
+        setTimeout(() => {
+          if (resolver === resolve) {
+            resolver = null;
+            reject(new Error("Timeout waiting for message"));
+          }
+        }, timeoutMs);
+      });
+
+    next.cleanup = () => {
+      this.ws.off("message", onMessage);
+    };
+
+    return next;
+  }
+
+  send(payload) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return false;
+    try {
+      this.ws.send(JSON.stringify(payload));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  join(channel) {
+    this.send({ type: "join", channel });
+  }
+
+  leave(channel) {
+    this.send({ type: "leave", channel });
+  }
+
+  joinRoom(room, password = "") {
+    this.send({ type: "join", room, password });
+  }
+
+  leaveRoom(room) {
+    this.send({ type: "leave", room });
+  }
+
+  sendEvent({ channel, room, payload }) {
+    return this.send({ type: "event", channel, room, payload });
+  }
+
+  close() {
+    if (this.ws) {
+      try {
+        this.ws.terminate();
+      } catch {
+        // ignore
+      }
+    }
+  }
+}
+
+module.exports = OnlineClient;

package/src/online/runner.js

@@ -0,0 +1,253 @@
+const fs = require("fs");
+const path = require("path");
+
+function inboxDir() {
+  return path.join(
+    process.env.HOME || process.env.USERPROFILE,
+    ".ufoo",
+    "online",
+    "inbox"
+  );
+}
+
+function inboxFilePath(nickname) {
+  return path.join(inboxDir(), `${nickname}.jsonl`);
+}
+
+function readMarkerPath(nickname) {
+  return path.join(inboxDir(), `${nickname}.read`);
+}
+
+function outboxFilePath(nickname) {
+  const dir = path.join(
+    process.env.HOME || process.env.USERPROFILE,
+    ".ufoo",
+    "online",
+    "outbox"
+  );
+  fs.mkdirSync(dir, { recursive: true });
+  return path.join(dir, `${nickname}.jsonl`);
+}
+
+function send(nickname, options = {}) {
+  if (!nickname) {
+    console.error("nickname is required");
+    process.exitCode = 1;
+    return;
+  }
+  const text = options.text || "";
+  if (!text) {
+    console.error("--text is required");
+    process.exitCode = 1;
+    return;
+  }
+  const msg = { text };
+  if (options.channel) msg.channel = options.channel;
+  if (options.room) msg.room = options.room;
+  if (!msg.channel && !msg.room) {
+    console.error("--channel or --room is required");
+    process.exitCode = 1;
+    return;
+  }
+
+  const file = outboxFilePath(nickname);
+  fs.appendFileSync(file, JSON.stringify(msg) + "\n");
+  const target = msg.channel ? `channel ${msg.channel}` : `room ${msg.room}`;
+  console.log(`Queued to ${target}: ${text}`);
+}
+
+const RETENTION_MS = {
+  channel: 7 * 24 * 60 * 60 * 1000,   // 7 days
+  room:    30 * 24 * 60 * 60 * 1000,   // 30 days
+};
+
+function cleanupInbox(file) {
+  if (!fs.existsSync(file)) return;
+  const now = Date.now();
+  const lines = fs.readFileSync(file, "utf-8").split("\n").filter(Boolean);
+  const kept = [];
+  for (const line of lines) {
+    let msg;
+    try { msg = JSON.parse(line); } catch { continue; }
+    const source = msg._source || "channel";
+    const maxAge = RETENTION_MS[source];
+    const age = now - new Date(msg._receivedAt || 0).getTime();
+    if (age < maxAge) kept.push(line);
+  }
+  fs.writeFileSync(file, kept.length ? kept.join("\n") + "\n" : "");
+}
+
+function checkInbox(nickname, options = {}) {
+  const clear = options.clear || false;
+  const unreadOnly = options.unread || false;
+
+  if (!nickname) {
+    console.error("nickname is required");
+    process.exitCode = 1;
+    return;
+  }
+
+  const file = inboxFilePath(nickname);
+  const markerFile = readMarkerPath(nickname);
+
+  if (clear) {
+    if (fs.existsSync(file)) {
+      fs.unlinkSync(file);
+      console.log(`Inbox cleared for ${nickname}.`);
+    } else {
+      console.log(`No inbox file for ${nickname}.`);
+    }
+    return;
+  }
+
+  cleanupInbox(file);
+
+  let messages = [];
+  if (fs.existsSync(file)) {
+    const lines = fs.readFileSync(file, "utf-8").split("\n").filter(Boolean);
+    for (const line of lines) {
+      try {
+        messages.push(JSON.parse(line));
+      } catch {
+        // skip malformed
+      }
+    }
+  }
+
+  function displayWidth(str) {
+    let w = 0;
+    for (const ch of str) {
+      const cp = ch.codePointAt(0);
+      if (
+        (cp >= 0x1100 && cp <= 0x115f) ||
+        (cp >= 0x2e80 && cp <= 0x303e) ||
+        (cp >= 0x3040 && cp <= 0x33bf) ||
+        (cp >= 0x3400 && cp <= 0x4dbf) ||
+        (cp >= 0x4e00 && cp <= 0xa4cf) ||
+        (cp >= 0xac00 && cp <= 0xd7af) ||
+        (cp >= 0xf900 && cp <= 0xfaff) ||
+        (cp >= 0xfe30 && cp <= 0xfe6f) ||
+        (cp >= 0xff01 && cp <= 0xff60) ||
+        (cp >= 0xffe0 && cp <= 0xffe6) ||
+        (cp >= 0x1f300 && cp <= 0x1f9ff) ||
+        (cp >= 0x20000 && cp <= 0x2fa1f)
+      ) {
+        w += 2;
+      } else {
+        w += 1;
+      }
+    }
+    return w;
+  }
+
+  function padRight(str, width) {
+    const dw = displayWidth(str);
+    if (dw >= width) return str;
+    return str + " ".repeat(width - dw);
+  }
+
+  const W = 50;
+
+  function hline(left, fill, right) {
+    return left + fill.repeat(W) + right;
+  }
+
+  function row(text) {
+    return "\u2551 " + padRight(text, W - 2) + " \u2551";
+  }
+
+  let lastRead = "";
+  try {
+    lastRead = fs.readFileSync(markerFile, "utf-8").trim();
+  } catch {
+    // no marker
+  }
+
+  const unreadMessages = lastRead
+    ? messages.filter((m) => (m._receivedAt || "") > lastRead)
+    : messages;
+
+  const displayMessages = unreadOnly ? unreadMessages : messages;
+  const count = displayMessages.length;
+  const unreadCount = unreadMessages.length;
+  const label = unreadOnly ? "unread" : "message";
+  const unreadTag = unreadCount > 0 ? `, ${unreadCount} unread` : "";
+  const title = `\ud83d\udcec Inbox: ${nickname}  (${count} ${label}${count !== 1 ? "s" : ""}${unreadOnly ? "" : unreadTag})`;
+
+  console.log(hline("\u2554", "\u2550", "\u2557"));
+  console.log(row(title));
+
+  if (count === 0) {
+    console.log(hline("\u2560", "\u2550", "\u2563"));
+    console.log(row("(empty)"));
+    console.log(hline("\u255a", "\u2550", "\u255d"));
+    markAsRead(markerFile);
+    return;
+  }
+
+  displayMessages.forEach((msg, i) => {
+    console.log(hline("\u2560", "\u2550", "\u2563"));
+
+    const from = msg.from || msg.subscriberId || "unknown";
+    const time = msg._receivedAt
+      ? msg._receivedAt.replace("T", " ").replace(/\.\d+Z$/, "")
+      : "?";
+    const isUnread = !lastRead || (msg._receivedAt || "") > lastRead;
+    const marker = isUnread ? " [NEW]" : "";
+
+    const source = msg._source || "channel";
+    const sourceTag = source === "room"
+      ? ` [${msg.room || "room"}]`
+      : ` [${msg.channel || "channel"}]`;
+
+    console.log(row(`#${i + 1}  from: ${from}${sourceTag}${marker}`));
+    console.log(row(`    time: ${time}`));
+    console.log(row("    " + "\u2500".repeat(Math.min(W - 6, 37))));
+
+    let body = "";
+    if (msg.payload) {
+      if (typeof msg.payload === "string") {
+        body = msg.payload;
+      } else if (msg.payload.message) {
+        body = msg.payload.message;
+      } else {
+        body = JSON.stringify(msg.payload);
+      }
+    } else {
+      body = JSON.stringify(msg);
+    }
+
+    const maxLine = W - 6;
+    const bodyLines = [];
+    for (const rawLine of body.split("\n")) {
+      if (displayWidth(rawLine) <= maxLine) {
+        bodyLines.push(rawLine);
+      } else {
+        let cur = "";
+        for (const ch of rawLine) {
+          if (displayWidth(cur + ch) > maxLine) {
+            bodyLines.push(cur);
+            cur = ch;
+          } else {
+            cur += ch;
+          }
+        }
+        if (cur) bodyLines.push(cur);
+      }
+    }
+
+    for (const line of bodyLines) {
+      console.log(row("    " + line));
+    }
+  });
+
+  console.log(hline("\u255a", "\u2550", "\u255d"));
+  markAsRead(markerFile);
+}
+
+function markAsRead(markerFile) {
+  fs.mkdirSync(path.dirname(markerFile), { recursive: true });
+  fs.writeFileSync(markerFile, new Date().toISOString());
+}
+
+module.exports = { send, checkInbox };