viveworker 0.4.6 → 0.4.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "viveworker",
-  "version": "0.4.6",
+  "version": "0.4.8",
   "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",

package/scripts/a2a-executor.mjs

@@ -1,20 +1,95 @@
 /**
- * a2a-executor.mjs — Execute approved A2A tasks via Codex CLI.
+ * a2a-executor.mjs — Execute approved A2A tasks via Codex or Claude 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.
+ * `codex exec` or `claude -p` to perform the work, captures the output,
+ * and updates the task status to completed/failed.
  */
 
-import { spawn } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
 import path from "node:path";
 import os from "node:os";
 import { completeA2ATask, failA2ATask } from "./a2a-handler.mjs";
 
+const APP_BUNDLE_PATH = "/Applications/Codex.app/Contents/Resources/codex";
+
+/**
+ * Try to find the claude binary by walking well-known locations.
+ * Returns the absolute path if found, or null.
+ */
+function findClaudeBin() {
+  // 1. `which` works if PATH is set (interactive shell, etc.)
+  const which = spawnSync("which", ["claude"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+  if (which.status === 0 && which.stdout) return which.stdout.trim();
+
+  // 2. ~/.claude/local/claude (official standalone install)
+  const standalone = path.join(os.homedir(), ".claude", "local", "claude");
+  if (existsSync(standalone)) return standalone;
+
+  // 3. nvm-managed global install — scan version dirs
+  const nvmBase = path.join(os.homedir(), ".nvm", "versions", "node");
+  if (existsSync(nvmBase)) {
+    const ls = spawnSync("ls", [nvmBase], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+    if (ls.status === 0 && ls.stdout) {
+      const versions = ls.stdout.trim().split("\n").filter(Boolean).reverse();
+      for (const v of versions) {
+        const candidate = path.join(nvmBase, v, "bin", "claude");
+        if (existsSync(candidate)) return candidate;
+      }
+    }
+  }
+
+  // 4. Homebrew / common paths
+  for (const p of ["/usr/local/bin/claude", "/opt/homebrew/bin/claude"]) {
+    if (existsSync(p)) return p;
+  }
+
+  return null;
+}
+
+/**
+ * Detect which executor CLIs are available on this machine.
+ * Returns { codex: boolean, claude: boolean, claudeBin?: string, codexBin?: string }.
+ */
+export function detectAvailableExecutors() {
+  const codexWhich = spawnSync("which", ["codex"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+  const codexBin = codexWhich.status === 0 && codexWhich.stdout
+    ? codexWhich.stdout.trim()
+    : existsSync(APP_BUNDLE_PATH) ? APP_BUNDLE_PATH : null;
+
+  const claudeBin = findClaudeBin();
+
+  return {
+    codex: !!codexBin,
+    claude: !!claudeBin,
+    codexBin: codexBin || undefined,
+    claudeBin: claudeBin || undefined,
+  };
+}
+
+/**
+ * Resolve the codex binary path.
+ */
+function resolveCodexBin(config) {
+  if (config.codexBin) return config.codexBin;
+  const which = spawnSync("which", ["codex"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+  if (which.status === 0 && which.stdout) return which.stdout.trim();
+  if (existsSync(APP_BUNDLE_PATH)) return APP_BUNDLE_PATH;
+  return "codex";
+}
+
+/**
+ * Resolve the claude binary path.
+ */
+function resolveClaudeBin() {
+  return findClaudeBin() || "claude";
+}
+
 const EXEC_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes
 
 /**
- * Execute an A2A task by spawning `codex exec`.
+ * Execute an A2A task by spawning the chosen executor.
  *
  * @param {object}   task                  - A2A task object
  * @param {object}   config                - Bridge config
@@ -23,23 +98,32 @@ const EXEC_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes
  * @param {object}   helpers
  * @param {Function} helpers.recordTimelineEntry
  * @param {Function} helpers.saveState
+ * @param {string}   [executor]            - "codex" or "claude" (auto-detect if omitted)
  */
-export async function executeA2ATask(task, config, runtime, state, { recordTimelineEntry, saveState }) {
+export async function executeA2ATask(task, config, runtime, state, { recordTimelineEntry, saveState }, executor) {
   const instruction = task.instruction || "";
   if (!instruction) {
     failA2ATask(task, "No instruction provided");
     return;
   }
 
-  console.log(`[a2a-exec] Starting task ${task.id}: ${instruction.slice(0, 80)}`);
+  // Resolve executor if not specified.
+  if (!executor) {
+    const available = detectAvailableExecutors();
+    executor = available.codex ? "codex" : available.claude ? "claude" : "codex";
+  }
+
+  console.log(`[a2a-exec] Starting task ${task.id} via ${executor}: ${instruction.slice(0, 80)}`);
 
   try {
-    const result = await runCodexExec(instruction, config);
+    const result = executor === "claude"
+      ? await runClaudeExec(instruction)
+      : await runCodexExec(instruction, config);
     completeA2ATask(task, result);
-    console.log(`[a2a-exec] Task ${task.id} completed (${result.length} chars)`);
+    console.log(`[a2a-exec] Task ${task.id} completed via ${executor} (${result.length} chars)`);
   } catch (error) {
     failA2ATask(task, error.message);
-    console.error(`[a2a-exec] Task ${task.id} failed: ${error.message}`);
+    console.error(`[a2a-exec] Task ${task.id} failed via ${executor}: ${error.message}`);
   }
 
   // Record completion in timeline
@@ -51,13 +135,16 @@ export async function executeA2ATask(task, config, runtime, state, { recordTimel
       entry: {
         stableId: `a2a_task_result:${task.id}`,
         token: task.token,
-        kind: "a2a_task",
+        kind: "a2a_task_result",
         threadId: "a2a",
-        threadLabel: "A2A",
+        threadLabel: instruction.slice(0, 80),
         title: task.status === "completed"
           ? `A2A ✅: ${instruction.slice(0, 60)}`
           : `A2A ❌: ${instruction.slice(0, 60)}`,
-        summary: task.statusMessage || "",
+        summary: task.status === "completed"
+          ? (task.artifacts?.[0]?.parts?.[0]?.text || "").slice(0, 160)
+          : task.statusMessage || "Failed",
+        instruction,
         messageText: task.status === "completed"
           ? (task.artifacts?.[0]?.parts?.[0]?.text || "").slice(0, 500)
           : task.statusMessage || "Failed",
@@ -78,23 +165,24 @@ export async function executeA2ATask(task, config, runtime, state, { recordTimel
  */
 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 codexBin = resolveCodexBin(config);
+    const args = ["exec", "--full-auto", "--skip-git-repo-check", instruction];
+    const cwd = config.workspaceRoot || os.tmpdir();
 
     const child = spawn(codexBin, args, {
       cwd,
-      stdio: ["ignore", "pipe", "pipe"],
+      stdio: ["pipe", "pipe", "pipe"],
       env: { ...process.env, CODEX_HOME: config.codexHome || path.join(os.homedir(), ".codex") },
       timeout: EXEC_TIMEOUT_MS,
     });
 
+    child.stdin.end();
+
     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");
       }
@@ -117,10 +205,60 @@ function runCodexExec(instruction, config) {
       }
     });
 
-    // Timeout fallback
     setTimeout(() => {
       try { child.kill("SIGTERM"); } catch { /* ignore */ }
       reject(new Error("codex exec timed out (10 minutes)"));
     }, EXEC_TIMEOUT_MS).unref?.();
   });
 }
+
+/**
+ * Spawn `claude -p` and capture stdout+stderr.
+ */
+function runClaudeExec(instruction) {
+  return new Promise((resolve, reject) => {
+    const claudeBin = resolveClaudeBin();
+    const args = ["-p", instruction, "--output-format", "text"];
+
+    const child = spawn(claudeBin, args, {
+      cwd: os.tmpdir(),
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env },
+      timeout: EXEC_TIMEOUT_MS,
+    });
+
+    child.stdin.end();
+
+    let stdout = "";
+    let stderr = "";
+
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+      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 claude: ${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(`claude exec failed: ${errorDetail.slice(0, 500)}`));
+      }
+    });
+
+    setTimeout(() => {
+      try { child.kill("SIGTERM"); } catch { /* ignore */ }
+      reject(new Error("claude exec timed out (10 minutes)"));
+    }, EXEC_TIMEOUT_MS).unref?.();
+  });
+}

package/scripts/a2a-handler.mjs

@@ -302,9 +302,10 @@ async function handleMessageSend({
         token,
         kind: "a2a_task",
         threadId: "a2a",
-        threadLabel: "A2A",
+        threadLabel: cleanText(instruction).slice(0, 80),
         title: `A2A: ${cleanText(instruction).slice(0, 80)}`,
         summary: cleanText(instruction).slice(0, 160),
+        instruction,
         messageText: instruction,
         createdAtMs: now,
         readOnly: false,

package/scripts/a2a-relay-client.mjs

@@ -68,6 +68,7 @@ export async function registerWithRelay({ config, buildAgentCard }) {
     userId,
     bridgeSecret,
     a2aApiKey: config.a2aApiKey || "",
+    acceptPublicTasks: config.a2aAcceptPublicTasks || false,
     agentCard,
     ...(config.a2aRelayRegisterSecret ? { registerSecret: config.a2aRelayRegisterSecret } : {}),
   };
@@ -166,6 +167,14 @@ export function stopRelayPolling() {
   console.log("[a2a-relay] Polling stopped");
 }
 
+/**
+ * Update the acceptPublicTasks flag on the relay via re-registration.
+ */
+export async function updatePublicTasksFlag({ config, buildAgentCard, acceptPublicTasks }) {
+  config.a2aAcceptPublicTasks = acceptPublicTasks;
+  return registerWithRelay({ config, buildAgentCard });
+}
+
 /**
  * Return current relay connection status for the settings UI.
  */

package/scripts/moltbook-api.mjs

@@ -4,12 +4,14 @@
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
+import { spawn } from "node:child_process";
 
 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 const DEFAULT_DRAFTS_DIR = path.join(os.homedir(), ".viveworker", "moltbook-drafts");
 
 export async function loadMoltbookEnv(envFile = DEFAULT_ENV_FILE) {
   const env = {};
@@ -204,3 +206,210 @@ export async function listInboxItems(dir = DEFAULT_INBOX_DIR) {
     return [];
   }
 }
+
+// ---------- Draft persistence ----------
+//
+// Pending Moltbook drafts (reply proposals and original-post proposals) are
+// written to disk so they survive bridge restarts.  One JSON file per draft,
+// keyed by its bridge-assigned token.
+
+export async function ensureDraftsDir(dir = DEFAULT_DRAFTS_DIR) {
+  await fs.mkdir(dir, { recursive: true });
+  return dir;
+}
+
+function draftPathFor(token, dir = DEFAULT_DRAFTS_DIR) {
+  // Token may contain colons — encode for safe filenames.
+  const safe = encodeURIComponent(token);
+  return path.join(dir, `${safe}.json`);
+}
+
+export async function writeDraft(draft, dir = DEFAULT_DRAFTS_DIR) {
+  await ensureDraftsDir(dir);
+  // Exclude runtime-only fields (decisionWaiters is an array of callbacks).
+  const { decisionWaiters, ...serializable } = draft;
+  await fs.writeFile(draftPathFor(draft.token, dir), JSON.stringify(serializable, null, 2) + "\n", "utf8");
+}
+
+export async function readDraft(token, dir = DEFAULT_DRAFTS_DIR) {
+  try {
+    const raw = await fs.readFile(draftPathFor(token, dir), "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+export async function deleteDraft(token, dir = DEFAULT_DRAFTS_DIR) {
+  try {
+    await fs.unlink(draftPathFor(token, dir));
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+}
+
+export async function listPendingDrafts(dir = DEFAULT_DRAFTS_DIR) {
+  try {
+    const files = await fs.readdir(dir);
+    const drafts = [];
+    for (const file of files) {
+      if (!file.endsWith(".json")) continue;
+      try {
+        const raw = await fs.readFile(path.join(dir, file), "utf8");
+        const draft = JSON.parse(raw);
+        if (draft && !draft.decision) drafts.push(draft);
+      } catch {
+        // skip bad file
+      }
+    }
+    return drafts;
+  } catch {
+    return [];
+  }
+}
+
+// ---------- Verification puzzle solvers ----------
+//
+// Shared by the CLI (for manual `reply` flow) and the bridge (for fire-and-
+// forget draft posting on approval).
+
+// Naive verification-puzzle solver. Handles the obfuscated two-number
+// arithmetic Moltbook currently uses (add / subtract / multiply). Returns
+// `null` if it can't confidently solve — caller falls back to LLM or manual.
+export function solveVerificationPuzzle(challengeText) {
+  if (!challengeText) return null;
+  const cleaned = String(challengeText)
+    .replace(/[^a-zA-Z0-9\s]/g, " ")
+    .toLowerCase();
+  const numberWords = {
+    zero: 0, one: 1, two: 2, three: 3, four: 4, five: 5, six: 6, seven: 7, eight: 8, nine: 9,
+    ten: 10, eleven: 11, twelve: 12, thirteen: 13, fourteen: 14, fifteen: 15, sixteen: 16,
+    seventeen: 17, eighteen: 18, nineteen: 19, twenty: 20, thirty: 30, forty: 40, fifty: 50,
+    sixty: 60, seventy: 70, eighty: 80, ninety: 90, hundred: 100,
+  };
+  const collapseRuns = (w) => w.replace(/([a-z])\1+/g, "$1");
+  const rawTokens = cleaned
+    .replace(/[^a-z0-9\s]/g, " ")
+    .split(/\s+/)
+    .filter(Boolean);
+  const operationWords = new Set([
+    "total", "combined", "force", "velocity", "speed", "gains", "plus", "and",
+    "subtract", "minus", "less", "difference", "decreased", "loses", "lost", "slower", "slows", "slowed",
+    "multiply", "times", "product", "multiplied",
+    "divide", "divided", "ratio",
+    "how", "much", "what", "exerts", "new",
+  ]);
+  const isKnown = (w) => numberWords[w] != null || numberWords[collapseRuns(w)] != null || operationWords.has(w) || operationWords.has(collapseRuns(w));
+  const merged = [];
+  let ti = 0;
+  while (ti < rawTokens.length) {
+    let best = rawTokens[ti];
+    let bestLen = 1;
+    let candidate = rawTokens[ti];
+    for (let span = 2; span <= Math.min(4, rawTokens.length - ti); span++) {
+      candidate += rawTokens[ti + span - 1];
+      if (isKnown(candidate) || isKnown(collapseRuns(candidate))) {
+        best = candidate;
+        bestLen = span;
+      }
+    }
+    merged.push(best);
+    ti += bestLen;
+  }
+  const words = merged.map((w) => {
+    if (/^\d+$/.test(w)) return w;
+    if (numberWords[w] != null) return w;
+    const collapsed = collapseRuns(w);
+    if (numberWords[collapsed] != null) return collapsed;
+    return collapsed;
+  });
+  const numbers = [];
+  let i = 0;
+  while (i < words.length) {
+    const w = words[i];
+    if (/^\d+$/.test(w)) {
+      numbers.push(Number(w));
+      i += 1;
+      continue;
+    }
+    if (numberWords[w] != null) {
+      let total = numberWords[w];
+      i += 1;
+      while (i < words.length && numberWords[words[i]] != null) {
+        const next = numberWords[words[i]];
+        if (next === 100) total *= 100;
+        else if (next < 100 && total < 100) total += next;
+        else break;
+        i += 1;
+      }
+      numbers.push(total);
+      continue;
+    }
+    i += 1;
+  }
+  if (numbers.length < 2) return null;
+  const a = numbers[0];
+  const b = numbers[1];
+  const hasWord = (w) => words.includes(w);
+  const hasAny = (...ws) => ws.some(hasWord);
+  let result;
+  if (hasAny("subtract", "minus", "less", "difference", "decreased", "loses", "lost", "slower", "slows", "slowed")) {
+    result = a - b;
+  } else if (hasAny("multiply", "times", "product", "multiplied")) {
+    result = a * b;
+  } else if (hasAny("divide", "divided", "ratio")) {
+    result = b !== 0 ? a / b : a;
+  } else {
+    result = a + b;
+  }
+  return result.toFixed(2);
+}
+
+// LLM-based verification puzzle solver. Shells out to claude or codex CLI.
+// Returns the answer as "XX.XX" string, or null if unavailable.
+export async function solvePuzzleWithLLM(challengeText) {
+  if (!challengeText) return null;
+  const prompt =
+    `The following text is an obfuscated arithmetic word problem from Moltbook (an AI social network). ` +
+    `The text has random capitalization, doubled letters, and stray punctuation — ignore all of that. ` +
+    `CRITICAL: ALL symbols (/, *, ^, ~, [, ], etc.) are NOISE, NOT arithmetic operators. ` +
+    `The operation is ALWAYS expressed in natural language words only. ` +
+    `Extract the numbers (written as words like "thirty five" = 35), determine the operation from WORDS ONLY ` +
+    `(addition: "total", "combined", "and", "plus", "gains", "new velocity"; ` +
+    `subtraction: "difference", "minus", "less", "loses"; ` +
+    `multiplication: "times", "product", "multiplied"; ` +
+    `division: "divided by", "ratio", "per"). ` +
+    `If no operation word is found, default to addition. ` +
+    `Compute the result and output ONLY the number with exactly 2 decimal places (e.g. "58.00"). No other text.\n\n` +
+    `Puzzle: ${challengeText}`;
+  for (const cmd of ["claude", "codex"]) {
+    let bin;
+    try {
+      bin = await new Promise((resolve) => {
+        const p = spawn("command", ["-v", cmd], { shell: "/bin/bash", stdio: ["ignore", "pipe", "ignore"] });
+        let out = "";
+        p.stdout.on("data", (d) => (out += d.toString()));
+        p.on("exit", (code) => resolve(code === 0 ? out.trim() : ""));
+        p.on("error", () => resolve(""));
+      });
+    } catch { bin = ""; }
+    if (!bin) continue;
+    const args = cmd === "claude" ? ["-p", prompt, "--output-format", "text"] : ["exec", prompt];
+    try {
+      const result = await new Promise((resolve, reject) => {
+        const p = spawn(bin, args, { stdio: ["ignore", "pipe", "pipe"], timeout: 30000 });
+        let out = "";
+        p.stdout.on("data", (d) => (out += d.toString()));
+        p.on("exit", (code) => (code === 0 ? resolve(out.trim()) : reject(new Error(`exit ${code}`))));
+        p.on("error", reject);
+      });
+      const match = result.match(/(\d+\.\d{2})/);
+      if (match) return match[1];
+      const intMatch = result.match(/^(\d+)$/m);
+      if (intMatch) return `${intMatch[1]}.00`;
+    } catch {
+      // try next
+    }
+  }
+  return null;
+}