viveworker 0.2.1 → 0.4.0

package/scripts/a2a-relay-client.mjs

@@ -0,0 +1,394 @@
+/**
+ * a2a-relay-client.mjs — Bridge-side polling client for the viveworker A2A relay.
+ *
+ * Connects the local viveworker bridge to the Cloudflare Worker relay:
+ *   - Registers the bridge with the relay on first startup
+ *   - Polls the relay every 20 seconds for pending A2A tasks
+ *   - Posts task results (completion/failure/rejection) back to the relay
+ *
+ * Designed to be imported and used from viveworker-bridge.mjs.
+ */
+
+import crypto from "node:crypto";
+import os from "node:os";
+import path from "node:path";
+import { promises as fs, readFileSync } from "node:fs";
+import { upsertEnvText } from "./lib/pairing.mjs";
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+const POLL_INTERVAL_MS = 20_000;     // 20 seconds
+const REQUEST_TIMEOUT_MS = 15_000;   // 15 seconds per HTTP request
+const A2A_ENV_FILE = path.join(os.homedir(), ".viveworker", "a2a.env");
+
+// ---------------------------------------------------------------------------
+// Module state
+// ---------------------------------------------------------------------------
+
+let pollTimer = null;
+let isPolling = false;
+
+// ---------------------------------------------------------------------------
+// Registration
+// ---------------------------------------------------------------------------
+
+/**
+ * Register this bridge with the A2A relay. On first registration, generates
+ * a bridgeSecret and writes it back to ~/.viveworker/a2a.env.
+ *
+ * @param {object} params
+ * @param {object} params.config - Bridge config (must have a2aRelayUrl, a2aRelayUserId, a2aApiKey)
+ * @param {Function} params.buildAgentCard - Function to build the local agent card
+ * @returns {Promise<{ ok: boolean, relayUrl?: string, error?: string }>}
+ */
+export async function registerWithRelay({ config, buildAgentCard }) {
+  const relayUrl = config.a2aRelayUrl;
+  const userId = config.a2aRelayUserId;
+
+  if (!relayUrl || !userId) {
+    return { ok: false, error: "A2A_RELAY_URL or A2A_RELAY_USER_ID not configured" };
+  }
+
+  // Generate or reuse bridgeSecret
+  let bridgeSecret = config.a2aRelaySecret || "";
+  const isNewSecret = !bridgeSecret;
+  if (isNewSecret) {
+    bridgeSecret = crypto.randomBytes(32).toString("hex");
+  }
+
+  const agentCard = typeof buildAgentCard === "function"
+    ? buildAgentCard(config)
+    : {};
+
+  const body = {
+    userId,
+    bridgeSecret,
+    a2aApiKey: config.a2aApiKey || "",
+    agentCard,
+    ...(config.a2aRelayRegisterSecret ? { registerSecret: config.a2aRelayRegisterSecret } : {}),
+  };
+
+  const headers = {
+    "content-type": "application/json",
+  };
+  // Re-registration requires the current bridgeSecret
+  if (!isNewSecret) {
+    headers["authorization"] = `Bearer ${bridgeSecret}`;
+  }
+
+  try {
+    const res = await fetchWithTimeout(`${relayUrl}/internal/register`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body),
+    });
+
+    const data = await res.json();
+
+    if (!res.ok) {
+      return { ok: false, error: data.error || `HTTP ${res.status}` };
+    }
+
+    // On success, write bridgeSecret back to a2a.env if new
+    if (isNewSecret) {
+      await persistRelaySecret(bridgeSecret);
+      // Update config in-place so subsequent calls use the secret
+      config.a2aRelaySecret = bridgeSecret;
+    }
+
+    console.log(`[a2a-relay] Registered as ${userId} → ${data.relayUrl || relayUrl}`);
+    return { ok: true, relayUrl: data.relayUrl };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Polling
+// ---------------------------------------------------------------------------
+
+/**
+ * Start polling the relay for pending A2A tasks. Tasks are ingested into
+ * the local runtime just like locally-received A2A tasks.
+ *
+ * @param {object} params
+ * @param {object} params.config       - Bridge config
+ * @param {object} params.runtime      - Bridge runtime state
+ * @param {object} params.state        - Persistent state
+ * @param {object} params.helpers      - { recordTimelineEntry, deliverWebPushItem, saveState, historyToken, cleanText }
+ */
+export function startRelayPolling({ config, runtime, state, helpers }) {
+  if (pollTimer) {
+    console.warn("[a2a-relay] Polling already started, skipping duplicate start");
+    return;
+  }
+
+  const relayUrl = config.a2aRelayUrl;
+  const userId = config.a2aRelayUserId;
+  const secret = config.a2aRelaySecret;
+
+  if (!relayUrl || !userId || !secret) {
+    console.warn("[a2a-relay] Cannot start polling — missing relay config");
+    return;
+  }
+
+  console.log(`[a2a-relay] Starting poll loop (every ${POLL_INTERVAL_MS / 1000}s) for user ${userId}`);
+
+  // Do an initial poll immediately, then schedule interval
+  pollOnce({ config, runtime, state, helpers }).catch((err) => {
+    console.error(`[a2a-relay] Initial poll error: ${err.message}`);
+  });
+
+  pollTimer = setInterval(() => {
+    if (isPolling || runtime.stopping) return;
+    pollOnce({ config, runtime, state, helpers }).catch((err) => {
+      console.error(`[a2a-relay] Poll error: ${err.message}`);
+    });
+  }, POLL_INTERVAL_MS);
+
+  // Allow Node to exit even if timer is running
+  if (pollTimer.unref) pollTimer.unref();
+}
+
+/**
+ * Stop relay polling. Call on bridge shutdown.
+ */
+export function stopRelayPolling() {
+  if (pollTimer) {
+    clearInterval(pollTimer);
+    pollTimer = null;
+  }
+  isPolling = false;
+  console.log("[a2a-relay] Polling stopped");
+}
+
+/**
+ * Single poll cycle: fetch pending tasks from the relay and ingest them.
+ */
+async function pollOnce({ config, runtime, state, helpers }) {
+  if (runtime.stopping) return;
+  isPolling = true;
+
+  try {
+    const relayUrl = config.a2aRelayUrl;
+    const userId = config.a2aRelayUserId;
+    const secret = config.a2aRelaySecret;
+
+    const res = await fetchWithTimeout(`${relayUrl}/internal/poll/${userId}`, {
+      method: "GET",
+      headers: {
+        authorization: `Bearer ${secret}`,
+      },
+    });
+
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      console.error(`[a2a-relay] Poll failed: HTTP ${res.status} ${text.slice(0, 200)}`);
+      return;
+    }
+
+    const data = await res.json();
+    const tasks = data.tasks || [];
+
+    if (tasks.length === 0) return;
+
+    console.log(`[a2a-relay] Received ${tasks.length} task(s) from relay`);
+
+    for (const relayTask of tasks) {
+      await ingestRelayTask({ relayTask, config, runtime, state, helpers });
+    }
+  } finally {
+    isPolling = false;
+  }
+}
+
+/**
+ * Ingest a single relay task into local runtime. Creates the same structure
+ * as a locally-received A2A task, tagged with relayTaskId for result posting.
+ */
+async function ingestRelayTask({ relayTask, config, runtime, state, helpers }) {
+  const { recordTimelineEntry, deliverWebPushItem, saveState, historyToken, cleanText } = helpers;
+
+  // Skip if we already have this task (deduplicate)
+  for (const existing of runtime.a2aTasksByToken.values()) {
+    if (existing.relayTaskId === relayTask.id) {
+      return; // already ingested
+    }
+  }
+
+  const token = historyToken(`a2a_task:${relayTask.id}`);
+  const instruction = cleanText(relayTask.instruction || "");
+  const now = Date.now();
+
+  const task = {
+    id: relayTask.id,
+    token,
+    contextId: relayTask.contextId || crypto.randomUUID(),
+    status: "submitted",
+    statusMessage: "",
+    messages: relayTask.messages || [],
+    artifacts: [],
+    instruction,
+    callerInfo: relayTask.callerInfo || {},
+    createdAtMs: relayTask.createdAtMs || now,
+    updatedAtMs: now,
+    decisionWaiters: [],
+    decision: null,
+    // Mark as relay-originated so we know to post results back
+    relayTaskId: relayTask.id,
+    relayUserId: config.a2aRelayUserId,
+  };
+
+  runtime.a2aTasksByToken.set(token, task);
+
+  // Record timeline entry (same as local A2A handler)
+  try {
+    recordTimelineEntry({
+      config,
+      runtime,
+      state,
+      entry: {
+        stableId: `a2a_task:${relayTask.id}`,
+        token,
+        kind: "a2a_task",
+        threadId: "a2a",
+        threadLabel: "A2A",
+        title: `A2A: ${instruction.slice(0, 80)}`,
+        summary: instruction.slice(0, 160),
+        messageText: instruction,
+        createdAtMs: relayTask.createdAtMs || now,
+        readOnly: false,
+        provider: "a2a",
+      },
+    });
+    await saveState(config.stateFile, state);
+  } catch (err) {
+    console.error(`[a2a-relay] Timeline save error: ${err.message}`);
+  }
+
+  // Send Web Push notification
+  try {
+    await deliverWebPushItem({
+      config,
+      state,
+      kind: "a2a_task",
+      token,
+      stableId: `a2a_task:${relayTask.id}`,
+      title: "A2A Task Request",
+      body: instruction.slice(0, 160),
+      buildLocalizedContent: ({ locale }) => {
+        const lang = locale?.startsWith("ja") ? "ja" : "en";
+        return {
+          title: lang === "ja" ? "\u{1F91D} A2Aリレー経由のタスク依頼" : "\u{1F91D} A2A task via relay",
+          body: instruction.slice(0, 160),
+        };
+      },
+    });
+  } catch (err) {
+    console.error(`[a2a-relay] Push notification error: ${err.message}`);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Result posting
+// ---------------------------------------------------------------------------
+
+/**
+ * Post a task result back to the relay. Called after task completion,
+ * failure, or rejection.
+ *
+ * @param {object} params
+ * @param {object} params.config - Bridge config (a2aRelayUrl, a2aRelayUserId, a2aRelaySecret)
+ * @param {object} params.task   - A2A task object with relayTaskId
+ * @returns {Promise<{ ok: boolean, error?: string }>}
+ */
+export async function postRelayResult({ config, task }) {
+  if (!task.relayTaskId) {
+    return { ok: false, error: "Not a relay task" };
+  }
+
+  const relayUrl = config.a2aRelayUrl;
+  const userId = task.relayUserId || config.a2aRelayUserId;
+  const secret = config.a2aRelaySecret;
+
+  if (!relayUrl || !userId || !secret) {
+    return { ok: false, error: "Relay not configured" };
+  }
+
+  const body = {
+    status: task.status,
+    statusMessage: task.statusMessage || "",
+    updatedAtMs: task.updatedAtMs || Date.now(),
+    artifacts: task.artifacts || [],
+  };
+
+  try {
+    const res = await fetchWithTimeout(
+      `${relayUrl}/internal/result/${userId}/${task.relayTaskId}`,
+      {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          authorization: `Bearer ${secret}`,
+        },
+        body: JSON.stringify(body),
+      }
+    );
+
+    const data = await res.json();
+
+    if (!res.ok) {
+      console.error(`[a2a-relay] Result post failed: HTTP ${res.status} ${data.error || ""}`);
+      return { ok: false, error: data.error || `HTTP ${res.status}` };
+    }
+
+    console.log(`[a2a-relay] Result posted for task ${task.relayTaskId} → ${data.status}`);
+    return { ok: true };
+  } catch (err) {
+    console.error(`[a2a-relay] Result post error: ${err.message}`);
+    return { ok: false, error: err.message };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Write A2A_RELAY_SECRET back to ~/.viveworker/a2a.env.
+ */
+async function persistRelaySecret(secret) {
+  try {
+    let current = "";
+    try {
+      current = await fs.readFile(A2A_ENV_FILE, "utf8");
+    } catch {
+      // File may not exist yet
+    }
+
+    const updated = upsertEnvText(current, {
+      A2A_RELAY_SECRET: secret,
+    });
+
+    await fs.mkdir(path.dirname(A2A_ENV_FILE), { recursive: true, mode: 0o700 });
+    await fs.writeFile(A2A_ENV_FILE, updated, { mode: 0o600 });
+    console.log(`[a2a-relay] Wrote A2A_RELAY_SECRET to ${A2A_ENV_FILE}`);
+  } catch (err) {
+    console.error(`[a2a-relay] Failed to write relay secret: ${err.message}`);
+  }
+}
+
+/**
+ * fetch() with a timeout via AbortSignal.
+ */
+async function fetchWithTimeout(url, options = {}, timeoutMs = REQUEST_TIMEOUT_MS) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetch(url, { ...options, signal: controller.signal });
+  } finally {
+    clearTimeout(timer);
+  }
+}

package/scripts/com.viveworker.moltbook-scout.plist.sample

@@ -0,0 +1,58 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<!--
+  SAMPLE launchd agent for the Moltbook scouting loop.
+
+  This is provider-neutral: the cron command invokes whichever agent CLI
+  you use. Customize the inner command to call `codex exec`, `claude -p`,
+  a small Anthropic SDK script, or whatever produces drafts for you.
+
+  Install:
+    1. Copy this file to ~/Library/LaunchAgents/com.viveworker.moltbook-scout.plist
+    2. Replace the placeholders (PATH/TO/VIVEWORKER, your agent CLI line)
+    3. Make sure ~/.viveworker/moltbook.env is populated (same file the
+       watcher uses) and that VIVEWORKER_HOOK_SECRET matches the bridge.
+    4. launchctl load ~/Library/LaunchAgents/com.viveworker.moltbook-scout.plist
+-->
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>com.viveworker.moltbook-scout</string>
+
+  <key>ProgramArguments</key>
+  <array>
+    <string>/bin/bash</string>
+    <string>-lc</string>
+    <!--
+      Example for a Codex Desktop user with `codex exec`:
+
+        set -a; . "$HOME/.viveworker/moltbook.env"; set +a;
+        cd "$HOME/path/to/viveworker";
+        codex exec "Run scripts/moltbook-scout-run.sh. If it prints a
+        candidate (status: 'candidate'), draft a 2-3 paragraph reply in
+        viveworker voice (informal lowercase, technically substantive,
+        no signature) and run: node scripts/viveworker.mjs moltbook
+        propose <postId> --text \"<your draft>\" --timeout 900. If
+        scout prints anything else, exit quietly."
+
+      Replace `codex exec` with `claude -p` for Claude Code users, or
+      with your own SDK runner.
+    -->
+    <string>set -a; . "$HOME/.viveworker/moltbook.env"; set +a; cd "$HOME/path/to/viveworker" &amp;&amp; codex exec "Run scripts/moltbook-scout-run.sh and, if it prints a candidate, draft a reply in viveworker voice and call viveworker moltbook propose &lt;postId&gt; --text \"...\" --timeout 900."</string>
+  </array>
+
+  <key>StartInterval</key>
+  <integer>120</integer>
+
+  <key>RunAtLoad</key>
+  <false/>
+
+  <key>StandardOutPath</key>
+  <string>/tmp/viveworker-moltbook-scout.out.log</string>
+  <key>StandardErrorPath</key>
+  <string>/tmp/viveworker-moltbook-scout.err.log</string>
+
+  <key>ProcessType</key>
+  <string>Background</string>
+</dict>
+</plist>

package/scripts/moltbook-api.mjs

@@ -0,0 +1,206 @@
+// Shared Moltbook API helpers used by the watcher and the CLI.
+// Keeps credential loading + request plumbing in one place.
+
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+export const API_BASE = "https://www.moltbook.com/api/v1";
+
+export const DEFAULT_ENV_FILE = path.join(os.homedir(), ".viveworker", "moltbook.env");
+export const DEFAULT_INBOX_DIR = path.join(os.homedir(), ".viveworker", "moltbook-inbox");
+export const DEFAULT_SCOUT_STATE_FILE = path.join(os.homedir(), ".viveworker", "moltbook-scout-state.json");
+
+export async function loadMoltbookEnv(envFile = DEFAULT_ENV_FILE) {
+  const env = {};
+  try {
+    const raw = await fs.readFile(envFile, "utf8");
+    for (const line of raw.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+      const eq = trimmed.indexOf("=");
+      if (eq === -1) continue;
+      env[trimmed.slice(0, eq).trim()] = trimmed.slice(eq + 1).trim();
+    }
+  } catch {
+    // Missing env file is fine — caller will validate required keys.
+  }
+  // Fall back to process.env for anything not in the file.
+  for (const key of ["MOLTBOOK_API_KEY", "MOLTBOOK_AGENT_ID", "VIVEWORKER_HOOK_SECRET", "VIVEWORKER_BASE_URL"]) {
+    if (!env[key] && process.env[key]) env[key] = process.env[key];
+  }
+  return env;
+}
+
+export function createMoltbookClient(apiKey) {
+  if (!apiKey) {
+    throw new Error("MOLTBOOK_API_KEY is required");
+  }
+  return async function mb(pathname, init = {}) {
+    const res = await fetch(`${API_BASE}${pathname}`, {
+      ...init,
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${apiKey}`,
+        ...(init.headers || {}),
+      },
+    });
+    const text = await res.text().catch(() => "");
+    if (!res.ok) {
+      throw new Error(`moltbook ${res.status} ${pathname}: ${text}`);
+    }
+    try {
+      return JSON.parse(text);
+    } catch {
+      return text;
+    }
+  };
+}
+
+export function extractNotifications(payload) {
+  const list = [];
+  const candidates = [
+    payload?.notifications,
+    payload?.data?.notifications,
+    payload?.unread_notifications,
+    payload?.activity,
+  ];
+  for (const arr of candidates) {
+    if (Array.isArray(arr)) list.push(...arr);
+  }
+  return list;
+}
+
+export function isCommentNotification(n) {
+  const type = String(n?.type || n?.kind || "").toLowerCase();
+  return type.includes("comment") || type.includes("reply") || type.includes("mention");
+}
+
+export async function ensureInboxDir(dir = DEFAULT_INBOX_DIR) {
+  await fs.mkdir(dir, { recursive: true });
+  return dir;
+}
+
+export function inboxPathFor(commentId, dir = DEFAULT_INBOX_DIR) {
+  return path.join(dir, `${commentId}.json`);
+}
+
+export async function writeInboxItem(item, dir = DEFAULT_INBOX_DIR) {
+  await ensureInboxDir(dir);
+  await fs.writeFile(inboxPathFor(item.commentId, dir), JSON.stringify(item, null, 2) + "\n", "utf8");
+}
+
+export async function readInboxItem(commentId, dir = DEFAULT_INBOX_DIR) {
+  try {
+    const raw = await fs.readFile(inboxPathFor(commentId, dir), "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+export async function updateInboxStatus(commentId, status, extra = {}, dir = DEFAULT_INBOX_DIR) {
+  const existing = await readInboxItem(commentId, dir);
+  if (!existing) return null;
+  const updated = { ...existing, ...extra, status, updatedAt: new Date().toISOString() };
+  await writeInboxItem(updated, dir);
+  return updated;
+}
+
+// ---------- Scout state ----------
+//
+// Tracks per-day usage of the Moltbook scouting loop so we can enforce a
+// simple daily quota and avoid re-proposing drafts against the same post.
+
+export async function readScoutState(file = DEFAULT_SCOUT_STATE_FILE) {
+  try {
+    const raw = await fs.readFile(file, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") return defaultScoutState();
+    return {
+      day: String(parsed.day || ""),
+      sentToday: Number(parsed.sentToday) || 0,
+      seenPostIds: parsed.seenPostIds && typeof parsed.seenPostIds === "object" ? parsed.seenPostIds : {},
+      batch: parsed.batch && typeof parsed.batch === "object" ? parsed.batch : null,
+      lastComposeDay: String(parsed.lastComposeDay || ""),
+      composedToday: Number(parsed.composedToday) || 0,
+      composeSlotsAttempted: Array.isArray(parsed.composeSlotsAttempted) ? parsed.composeSlotsAttempted : [],
+      recentComposeTitles: Array.isArray(parsed.recentComposeTitles) ? parsed.recentComposeTitles : [],
+    };
+  } catch {
+    return defaultScoutState();
+  }
+}
+
+export async function writeScoutState(state, file = DEFAULT_SCOUT_STATE_FILE) {
+  await fs.mkdir(path.dirname(file), { recursive: true });
+  await fs.writeFile(file, JSON.stringify(state, null, 2) + "\n", "utf8");
+}
+
+export function defaultScoutState() {
+  return { day: todayKey(), sentToday: 0, seenPostIds: {}, batch: null, lastComposeDay: "", composedToday: 0, composeSlotsAttempted: [], recentComposeTitles: [] };
+}
+
+export function todayKey() {
+  // Use local timezone with AM 5:00 as the day boundary — hours before 5am
+  // count as the previous day so late-night work doesn't consume the next
+  // day's quota.
+  const d = new Date(Date.now() - 5 * 60 * 60 * 1000);
+  const y = d.getFullYear();
+  const m = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  return `${y}-${m}-${day}`;
+}
+
+export function rollScoutDayIfNeeded(state) {
+  const today = todayKey();
+  if (state.day !== today) {
+    state.day = today;
+    state.sentToday = 0;
+    state.composedToday = 0;
+    state.composeSlotsAttempted = [];
+  }
+  // Evict seenPostIds entries older than 30 days to keep the file small.
+  const cutoff = Date.now() - 30 * 24 * 60 * 60 * 1000;
+  for (const [id, entry] of Object.entries(state.seenPostIds)) {
+    // Support both legacy (bare timestamp) and new ({ ts, outcome }) formats.
+    const ts = typeof entry === "number" ? entry : (entry?.ts ?? 0);
+    if (!Number.isFinite(ts) || ts < cutoff) delete state.seenPostIds[id];
+  }
+  return state;
+}
+
+export function recordComposeAttempt(state, title, postId) {
+  state.composedToday = (state.composedToday || 0) + 1;
+  state.lastComposeDay = todayKey();
+  if (!Array.isArray(state.recentComposeTitles)) state.recentComposeTitles = [];
+  state.recentComposeTitles.unshift(
+    postId ? { title: String(title || ""), postId: String(postId) } : String(title || "")
+  );
+  if (state.recentComposeTitles.length > 10) state.recentComposeTitles.length = 10;
+  return state;
+}
+
+export function markPostSeen(state, postId, outcome = "seen") {
+  state.seenPostIds[String(postId)] = { ts: Date.now(), outcome };
+  return state;
+}
+
+export async function listInboxItems(dir = DEFAULT_INBOX_DIR) {
+  try {
+    const files = await fs.readdir(dir);
+    const items = [];
+    for (const file of files) {
+      if (!file.endsWith(".json")) continue;
+      try {
+        const raw = await fs.readFile(path.join(dir, file), "utf8");
+        items.push(JSON.parse(raw));
+      } catch {
+        // skip bad file
+      }
+    }
+    return items.sort((a, b) => String(b.createdAt || "").localeCompare(String(a.createdAt || "")));
+  } catch {
+    return [];
+  }
+}