viveworker 0.3.0 → 0.4.1

package/README.md

@@ -200,6 +200,7 @@ npx viveworker doctor
 ### What it does
 
 - **Incoming replies**: detects when other agents comment on your posts and notifies your phone so you can draft a reply
+- **Draft approval on phone**: reply drafts and original post drafts appear in `Tasks` and `Timeline`, where you can approve, deny, or edit them from your phone
 - **Auto-scout replies**: every 2 minutes, scans the Moltbook feed, scores posts against your agent's persona (0–100), batches candidates over a 30-minute window, picks the best match, drafts a reply via LLM, and proposes it for your approval
 - **Original post drafts**: based on your daily coding activity, composes new posts in your agent's voice and proposes them at natural intervals — morning (yesterday recap), noon (morning progress), and evening (full-day summary). Up to 3 per day; deny any slot you don't want
 
@@ -207,31 +208,44 @@ npx viveworker doctor
 
 1. Define your agent's persona in `~/.viveworker/moltbook-persona.md` — voice, expertise, interests, topics to avoid
 2. The system filters all content through this persona: only activities and posts that match your agent's expertise are surfaced
-3. Drafts arrive as phone notifications with an editable title, body, and one-tap approve/deny
-4. On approve, `viveworker` posts to Moltbook and solves the verification puzzle automatically
+3. The Moltbook watcher pushes incoming replies and draft proposals into `Tasks` and `Timeline`
+4. On your phone, you can approve, deny, or edit the draft body before sending
+5. The Moltbook CLI long-polls for that decision, then posts to Moltbook and solves the verification puzzle automatically
 
 ### Setup
 
 ```bash
-# Add your Moltbook API key
-cat > ~/.viveworker/moltbook.env << 'EOF'
-MOLTBOOK_API_KEY=your-api-key
-MOLTBOOK_AGENT_ID=your-agent-id
-EOF
-
-# Initialize your agent's persona
+# Install the Moltbook watcher and auto-scout alongside viveworker
+npx viveworker setup \
+  --moltbook \
+  --moltbook-api-key your-api-key \
+  --moltbook-agent-id your-agent-id \
+  --moltbook-agent-name "your-agent-name" \
+  --auto-scout
+
+# Describe your agent's voice and expertise
 npx viveworker moltbook persona init
 
-# The watcher and scout start automatically with viveworker
+# After setup, use start/stop as usual
 npx viveworker start
 ```
 
+`setup --moltbook` writes `~/.viveworker/moltbook.env` and installs the Moltbook watcher.
+`--auto-scout` installs the scheduled scout job. After that, `npx viveworker start` is your normal restart command for the main app.
+
+Open `Settings > Moltbook` in the phone app to see the current auto-scout posting quota, current batch, and recent compose status.
+
 ### Key commands
 
 - `npx viveworker moltbook list` — show pending comment notifications
+- `npx viveworker moltbook poll` — manually refresh Moltbook notifications once
+- `npx viveworker moltbook reconcile` — resolve inbox items that were already replied to elsewhere
 - `npx viveworker moltbook scout` — manually pick a feed candidate
-- `npx viveworker moltbook compose` — check today's activity for post material
+- `npx viveworker moltbook propose <postId> --text "..."` — submit a reply draft for phone approval
+- `npx viveworker moltbook compose` — inspect today's activity for original-post material
+- `npx viveworker moltbook compose-propose --title "..." --content "..."` — submit an original-post draft for phone approval
 - `npx viveworker moltbook persona show` — view your agent's persona
+- `npx viveworker setup --auto-scout-uninstall` — remove the scheduled auto-scout job
 
 ## Roadmap
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "viveworker",
-  "version": "0.3.0",
-  "description": "Local mobile companion for Codex Desktop and Claude Desktop approvals, questions, completions, and code review on your LAN.",
+  "version": "0.4.1",
+  "description": "Local mobile companion for Codex Desktop and Claude Desktop — approvals, code review, Moltbook drafts, and A2A (Agent-to-Agent) task relay on your LAN.",
   "author": "Yuta Hoshino <hoshino.lireneo@gmail.com>",
   "license": "MIT",
   "keywords": [
@@ -19,6 +19,10 @@
     "approvals",
     "questions",
     "code-review",
+    "moltbook",
+    "ai-agents",
+    "a2a",
+    "agent-to-agent",
     "lan",
     "companion-app",
     "vivecoding"
@@ -37,7 +41,12 @@
     "scripts/moltbook-cli.mjs",
     "scripts/moltbook-watcher.mjs",
     "scripts/moltbook-scout-run.sh",
+    "scripts/moltbook-scout-auto.sh",
     "scripts/com.viveworker.moltbook-scout.plist.sample",
+    "scripts/a2a-cli.mjs",
+    "scripts/a2a-handler.mjs",
+    "scripts/a2a-executor.mjs",
+    "scripts/a2a-relay-client.mjs",
     "scripts/lib",
     "web",
     "README.md",

package/scripts/a2a-cli.mjs

@@ -0,0 +1,198 @@
+/**
+ * a2a-cli.mjs — CLI for viveworker A2A relay operations.
+ *
+ * Usage:
+ *   viveworker a2a setup --user-id <id> [--relay-url <url>] [--timeout <seconds>]
+ *
+ * The `setup` command:
+ *   1. Creates a setup session on the relay
+ *   2. Opens the GitHub OAuth URL in the user's browser
+ *   3. Polls for completion (user approves in browser)
+ *   4. Writes credentials to ~/.viveworker/a2a.env
+ *   5. Bridge can then be restarted to auto-connect
+ */
+
+import { promises as fs } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { execSync } from "node:child_process";
+import { upsertEnvText } from "./lib/pairing.mjs";
+
+const A2A_ENV_FILE = path.join(os.homedir(), ".viveworker", "a2a.env");
+const DEFAULT_RELAY_URL = "https://a2a.viveworker.com";
+const DEFAULT_TIMEOUT = 300; // 5 minutes
+const POLL_INTERVAL = 3000;  // 3 seconds
+
+// ---------------------------------------------------------------------------
+// CLI entry point
+// ---------------------------------------------------------------------------
+
+export async function runA2ACli(args) {
+  const cmd = args[0];
+
+  switch (cmd) {
+    case "setup":
+      return handleSetup(args.slice(1));
+    default:
+      console.log("Usage: viveworker a2a setup --user-id <id> [--description <text>] [--skills <csv>] [--relay-url <url>] [--timeout <seconds>]");
+      if (cmd && cmd !== "help" && cmd !== "--help") {
+        throw new Error(`Unknown command: ${cmd}`);
+      }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// setup command
+// ---------------------------------------------------------------------------
+
+async function handleSetup(args) {
+  const flags = parseFlags(args);
+  const userId = flags["user-id"] || flags["userId"];
+  const relayUrl = (flags["relay-url"] || flags["relayUrl"] || DEFAULT_RELAY_URL).replace(/\/$/u, "");
+  const timeout = Number(flags["timeout"]) || DEFAULT_TIMEOUT;
+  const description = flags["description"] || "";
+  const skillsRaw = flags["skills"] || "";
+
+  if (!userId) {
+    throw new Error("--user-id is required\nUsage: viveworker a2a setup --user-id <id>");
+  }
+
+  console.log(`\n🔗 viveworker A2A Relay Setup`);
+  console.log(`   Relay:   ${relayUrl}`);
+  console.log(`   User ID: ${userId}`);
+  if (description) console.log(`   Desc:    ${description}`);
+  if (skillsRaw) console.log(`   Skills:  ${skillsRaw}`);
+  console.log();
+
+  // Step 1: Create setup session
+  console.log("⏳ Creating setup session...");
+  const sessionRes = await fetchJson(`${relayUrl}/auth/setup`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ userId }),
+  });
+
+  if (sessionRes.error) {
+    throw new Error(`Setup session failed: ${sessionRes.error}`);
+  }
+
+  const { token, authUrl } = sessionRes;
+  console.log(`✅ Session created\n`);
+
+  // Step 2: Open browser
+  console.log(`🌐 Opening browser for GitHub authorization...`);
+  console.log(`   ${authUrl}\n`);
+  openBrowser(authUrl);
+
+  console.log(`⏳ Waiting for GitHub authorization (timeout: ${timeout}s)...`);
+
+  // Step 3: Poll for completion
+  const deadline = Date.now() + timeout * 1000;
+  let result = null;
+
+  while (Date.now() < deadline) {
+    await sleep(POLL_INTERVAL);
+
+    const pollRes = await fetchJson(`${relayUrl}/auth/setup/${token}`);
+
+    if (pollRes.status === "completed") {
+      result = pollRes.credentials;
+      break;
+    }
+
+    if (pollRes.status === "error") {
+      throw new Error(`Registration failed: ${pollRes.error}`);
+    }
+
+    if (pollRes.error) {
+      throw new Error(`Poll error: ${pollRes.error}`);
+    }
+
+    // Still pending — continue polling
+  }
+
+  if (!result) {
+    throw new Error("Timeout waiting for GitHub authorization. Please try again.");
+  }
+
+  console.log(`\n✅ GitHub authorization complete (@${result.githubLogin})\n`);
+
+  // Step 4: Write to a2a.env
+  console.log(`📝 Writing credentials to ${A2A_ENV_FILE}...`);
+
+  let currentEnv = "";
+  try {
+    currentEnv = await fs.readFile(A2A_ENV_FILE, "utf8");
+  } catch {
+    // File may not exist
+  }
+
+  const envVars = {
+    A2A_API_KEY: result.a2aApiKey,
+    A2A_RELAY_URL: result.relayUrl,
+    A2A_RELAY_USER_ID: result.userId,
+    A2A_RELAY_REGISTER_SECRET: result.registerSecret,
+  };
+  if (description) envVars.A2A_DESCRIPTION = description;
+  if (skillsRaw) envVars.A2A_SKILLS = skillsRaw;
+
+  const updated = upsertEnvText(currentEnv, envVars);
+
+  await fs.mkdir(path.dirname(A2A_ENV_FILE), { recursive: true, mode: 0o700 });
+  await fs.writeFile(A2A_ENV_FILE, updated, { mode: 0o600 });
+
+  console.log(`✅ Credentials saved\n`);
+  console.log(`🚀 Setup complete! Restart your viveworker bridge to connect.`);
+  console.log(`   Your A2A endpoint: ${result.relayUrl}/${result.userId}\n`);
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function parseFlags(args) {
+  const flags = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      const eqIdx = arg.indexOf("=");
+      if (eqIdx !== -1) {
+        flags[arg.slice(2, eqIdx)] = arg.slice(eqIdx + 1);
+      } else if (i + 1 < args.length && !args[i + 1].startsWith("--")) {
+        flags[arg.slice(2)] = args[++i];
+      } else {
+        flags[arg.slice(2)] = true;
+      }
+    }
+  }
+  return flags;
+}
+
+async function fetchJson(url, options = {}) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), 15000);
+  try {
+    const res = await fetch(url, { ...options, signal: controller.signal });
+    return await res.json();
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+function openBrowser(url) {
+  try {
+    if (process.platform === "darwin") {
+      execSync(`open "${url}"`, { stdio: "ignore" });
+    } else if (process.platform === "linux") {
+      execSync(`xdg-open "${url}"`, { stdio: "ignore" });
+    } else if (process.platform === "win32") {
+      execSync(`start "" "${url}"`, { stdio: "ignore" });
+    }
+  } catch {
+    // Browser open failed — URL is already printed for manual use
+  }
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/scripts/a2a-executor.mjs

@@ -0,0 +1,126 @@
+/**
+ * a2a-executor.mjs — Execute approved A2A tasks via Codex CLI.
+ *
+ * After the user approves an A2A task in the PWA, this module spawns
+ * `codex exec` to perform the work, captures the output, and updates
+ * the task status to completed/failed.
+ */
+
+import { spawn } from "node:child_process";
+import path from "node:path";
+import os from "node:os";
+import { completeA2ATask, failA2ATask } from "./a2a-handler.mjs";
+
+const EXEC_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes
+
+/**
+ * Execute an A2A task by spawning `codex exec`.
+ *
+ * @param {object}   task                  - A2A task object
+ * @param {object}   config                - Bridge config
+ * @param {object}   runtime               - Bridge runtime
+ * @param {object}   state                 - Persistent state
+ * @param {object}   helpers
+ * @param {Function} helpers.recordTimelineEntry
+ * @param {Function} helpers.saveState
+ */
+export async function executeA2ATask(task, config, runtime, state, { recordTimelineEntry, saveState }) {
+  const instruction = task.instruction || "";
+  if (!instruction) {
+    failA2ATask(task, "No instruction provided");
+    return;
+  }
+
+  console.log(`[a2a-exec] Starting task ${task.id}: ${instruction.slice(0, 80)}`);
+
+  try {
+    const result = await runCodexExec(instruction, config);
+    completeA2ATask(task, result);
+    console.log(`[a2a-exec] Task ${task.id} completed (${result.length} chars)`);
+  } catch (error) {
+    failA2ATask(task, error.message);
+    console.error(`[a2a-exec] Task ${task.id} failed: ${error.message}`);
+  }
+
+  // Record completion in timeline
+  try {
+    recordTimelineEntry({
+      config,
+      runtime,
+      state,
+      entry: {
+        stableId: `a2a_task_result:${task.id}`,
+        token: task.token,
+        kind: "a2a_task",
+        threadId: "a2a",
+        threadLabel: "A2A",
+        title: task.status === "completed"
+          ? `A2A ✅: ${instruction.slice(0, 60)}`
+          : `A2A ❌: ${instruction.slice(0, 60)}`,
+        summary: task.statusMessage || "",
+        messageText: task.status === "completed"
+          ? (task.artifacts?.[0]?.parts?.[0]?.text || "").slice(0, 500)
+          : task.statusMessage || "Failed",
+        taskStatus: task.status,
+        createdAtMs: task.updatedAtMs || Date.now(),
+        readOnly: true,
+        provider: "a2a",
+      },
+    });
+    await saveState(config.stateFile, state);
+  } catch (error) {
+    console.error(`[a2a-exec-timeline] ${error.message}`);
+  }
+}
+
+/**
+ * Spawn `codex exec` and capture stdout+stderr.
+ */
+function runCodexExec(instruction, config) {
+  return new Promise((resolve, reject) => {
+    const codexBin = config.codexBin || "codex";
+    const args = ["exec", "--prompt", instruction, "--approval-mode", "full-auto"];
+    const cwd = config.workspaceRoot || process.cwd();
+
+    const child = spawn(codexBin, args, {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...process.env, CODEX_HOME: config.codexHome || path.join(os.homedir(), ".codex") },
+      timeout: EXEC_TIMEOUT_MS,
+    });
+
+    let stdout = "";
+    let stderr = "";
+
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+      // Cap output at 100KB
+      if (stdout.length > 100_000) {
+        child.kill("SIGTERM");
+      }
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+      if (stderr.length > 50_000) stderr = stderr.slice(-50_000);
+    });
+
+    child.on("error", (error) => {
+      reject(new Error(`Failed to spawn codex: ${error.message}`));
+    });
+
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve(stdout.trim() || "(completed with no output)");
+      } else {
+        const errorDetail = stderr.trim() || stdout.trim() || `exit code ${code}`;
+        reject(new Error(`codex exec failed: ${errorDetail.slice(0, 500)}`));
+      }
+    });
+
+    // Timeout fallback
+    setTimeout(() => {
+      try { child.kill("SIGTERM"); } catch { /* ignore */ }
+      reject(new Error("codex exec timed out (10 minutes)"));
+    }, EXEC_TIMEOUT_MS).unref?.();
+  });
+}