viveworker 0.4.0 → 0.4.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "viveworker",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "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-cli.mjs

@@ -33,8 +33,15 @@ export async function runA2ACli(args) {
   switch (cmd) {
     case "setup":
       return handleSetup(args.slice(1));
+    case "activity":
+      return handleActivity(args.slice(1));
+    case "card":
+      return handleCard(args.slice(1));
     default:
-      console.log("Usage: viveworker a2a setup --user-id <id> [--relay-url <url>] [--timeout <seconds>]");
+      console.log("Commands:");
+      console.log("  viveworker a2a setup    --user-id <id> [--description <text>] [--skills <csv>]");
+      console.log("  viveworker a2a activity [--state-file <path>]");
+      console.log("  viveworker a2a card     [--description <text>] [--skills <csv>] [--avatar <url-or-emoji>]");
       if (cmd && cmd !== "help" && cmd !== "--help") {
         throw new Error(`Unknown command: ${cmd}`);
       }
@@ -50,6 +57,9 @@ async function handleSetup(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"] || "";
+  const avatar = flags["avatar"] || "";
 
   if (!userId) {
     throw new Error("--user-id is required\nUsage: viveworker a2a setup --user-id <id>");
@@ -57,7 +67,11 @@ async function handleSetup(args) {
 
   console.log(`\n🔗 viveworker A2A Relay Setup`);
   console.log(`   Relay:   ${relayUrl}`);
-  console.log(`   User ID: ${userId}\n`);
+  console.log(`   User ID: ${userId}`);
+  if (description) console.log(`   Desc:    ${description}`);
+  if (skillsRaw) console.log(`   Skills:  ${skillsRaw}`);
+  if (avatar) console.log(`   Avatar:  ${avatar}`);
+  console.log();
 
   // Step 1: Create setup session
   console.log("⏳ Creating setup session...");
@@ -122,12 +136,17 @@ async function handleSetup(args) {
     // File may not exist
   }
 
-  const updated = upsertEnvText(currentEnv, {
+  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;
+  if (avatar) envVars.A2A_AVATAR = avatar;
+
+  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 });
@@ -137,6 +156,166 @@ async function handleSetup(args) {
   console.log(`   Your A2A endpoint: ${result.relayUrl}/${result.userId}\n`);
 }
 
+// ---------------------------------------------------------------------------
+// activity command
+// ---------------------------------------------------------------------------
+
+async function handleActivity(args) {
+  const flags = parseFlags(args);
+
+  // Find state file: explicit flag > STATE_FILE env > default locations
+  const candidates = [
+    flags["state-file"] || flags["stateFile"],
+    process.env.STATE_FILE,
+    path.join(os.homedir(), ".viveworker", "state.json"),
+    path.join(process.cwd(), ".viveworker-state.json"),
+  ].filter(Boolean);
+
+  let stateData = null;
+  let usedPath = "";
+  for (const candidate of candidates) {
+    try {
+      const raw = await fs.readFile(candidate, "utf8");
+      stateData = JSON.parse(raw);
+      usedPath = candidate;
+      break;
+    } catch {
+      // try next
+    }
+  }
+
+  if (!stateData) {
+    throw new Error(
+      "Could not find viveworker state file.\n" +
+      "Try: viveworker a2a activity --state-file /path/to/.viveworker-state.json\n" +
+      "Or set STATE_FILE environment variable."
+    );
+  }
+
+  const entries = stateData.recentTimelineEntries || [];
+  if (entries.length === 0) {
+    console.log(JSON.stringify({ totalEntries: 0, providers: {}, threads: [], recentTasks: [] }));
+    return;
+  }
+
+  // Provider usage
+  const providers = {};
+  for (const e of entries) {
+    if (e.provider) providers[e.provider] = (providers[e.provider] || 0) + 1;
+  }
+
+  // Thread topics with activity counts
+  const threadMap = new Map();
+  for (const e of entries) {
+    const label = e.threadLabel || e.title;
+    if (!label || label === "Moltbook") continue;
+    if (!threadMap.has(label)) threadMap.set(label, { count: 0, providers: new Set() });
+    const t = threadMap.get(label);
+    t.count++;
+    if (e.provider) t.providers.add(e.provider);
+  }
+
+  const threads = [...threadMap.entries()]
+    .sort((a, b) => b[1].count - a[1].count)
+    .map(([label, v]) => ({
+      label: label.slice(0, 120),
+      count: v.count,
+      providers: [...v.providers],
+    }));
+
+  // Recent task titles (from assistant_final and user_message kinds)
+  const taskKinds = new Set(["assistant_final", "user_message", "completion"]);
+  const recentTasks = [];
+  const seenTitles = new Set();
+  for (let i = entries.length - 1; i >= 0 && recentTasks.length < 15; i--) {
+    const e = entries[i];
+    if (!taskKinds.has(e.kind)) continue;
+    const title = (e.title || e.threadLabel || "").trim();
+    if (!title || seenTitles.has(title)) continue;
+    seenTitles.add(title);
+    recentTasks.push({
+      title: title.slice(0, 120),
+      provider: e.provider || "",
+      kind: e.kind,
+    });
+  }
+
+  const result = {
+    stateFile: usedPath,
+    totalEntries: entries.length,
+    providers,
+    threads,
+    recentTasks,
+  };
+
+  console.log(JSON.stringify(result, null, 2));
+}
+
+// ---------------------------------------------------------------------------
+// card command
+// ---------------------------------------------------------------------------
+
+async function handleCard(args) {
+  const flags = parseFlags(args);
+  const description = flags["description"] || "";
+  const skillsRaw = flags["skills"] || "";
+  const avatar = flags["avatar"] || "";
+
+  if (!description && !skillsRaw && !avatar) {
+    // No flags — show current values
+    let currentEnv = "";
+    try {
+      currentEnv = await fs.readFile(A2A_ENV_FILE, "utf8");
+    } catch {
+      throw new Error(`No a2a.env found at ${A2A_ENV_FILE}. Run 'viveworker a2a setup' first.`);
+    }
+
+    const currentDesc = envValue(currentEnv, "A2A_DESCRIPTION");
+    const currentSkills = envValue(currentEnv, "A2A_SKILLS");
+    const currentAvatar = envValue(currentEnv, "A2A_AVATAR");
+
+    console.log(`\n📇 Current Agent Card settings (${A2A_ENV_FILE})\n`);
+    console.log(`   Description: ${currentDesc || "(not set)"}`);
+    console.log(`   Skills:      ${currentSkills || "(not set)"}`);
+    console.log(`   Avatar:      ${currentAvatar || "(not set — uses GitHub avatar or 🤖)"}\n`);
+    console.log(`To update: viveworker a2a card --description "..." --skills "..." --avatar "..."`);
+    return;
+  }
+
+  // Update a2a.env
+  let currentEnv = "";
+  try {
+    currentEnv = await fs.readFile(A2A_ENV_FILE, "utf8");
+  } catch {
+    throw new Error(`No a2a.env found at ${A2A_ENV_FILE}. Run 'viveworker a2a setup' first.`);
+  }
+
+  const updates = {};
+  if (description) updates.A2A_DESCRIPTION = description;
+  if (skillsRaw) updates.A2A_SKILLS = skillsRaw;
+  if (avatar) updates.A2A_AVATAR = avatar;
+
+  const updated = upsertEnvText(currentEnv, updates);
+  await fs.writeFile(A2A_ENV_FILE, updated, { mode: 0o600 });
+
+  console.log(`\n✅ Agent Card updated in ${A2A_ENV_FILE}\n`);
+  if (description) console.log(`   Description: ${description}`);
+  if (skillsRaw) console.log(`   Skills:      ${skillsRaw}`);
+  if (avatar) console.log(`   Avatar:      ${avatar}`);
+  console.log(`\n🔄 The bridge will pick up the change within 30 seconds and re-register with the relay.\n`);
+}
+
+function envValue(text, key) {
+  for (const line of text.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("#") || !trimmed) continue;
+    const eq = trimmed.indexOf("=");
+    if (eq === -1) continue;
+    if (trimmed.slice(0, eq) === key) return trimmed.slice(eq + 1);
+  }
+  return "";
+}
+
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------

package/scripts/a2a-handler.mjs

@@ -18,22 +18,22 @@ import crypto from "node:crypto";
 
 export function buildAgentCard(config) {
   const baseUrl = config.a2aPublicUrl || config.publicBaseUrl || `http://localhost:${config.port || 7860}`;
-  return {
-    schemaVersion: "1.0",
-    humanReadableId: "viveworker/viveworker",
-    agentVersion: config.version || "0.3.0",
-    name: "viveworker",
-    description:
-      "LAN-connected AI companion that bridges Codex and Claude Desktop. " +
-      "Can execute coding tasks, file operations, and code reviews with human approval.",
-    url: `${baseUrl.replace(/\/$/u, "")}/a2a`,
-    provider: { name: "viveworker" },
-    capabilities: {
-      a2aVersion: "0.2.3",
-      streaming: false,
-      pushNotifications: false,
-    },
-    skills: [
+
+  // Custom description from A2A_DESCRIPTION env var (set during setup)
+  const description = config.a2aDescription ||
+    "LAN-connected AI companion that bridges Codex and Claude Desktop. " +
+    "Can execute coding tasks, file operations, and code reviews with human approval.";
+
+  // Custom skills from A2A_SKILLS env var (comma-separated tags → skill objects)
+  let skills;
+  if (config.a2aSkills) {
+    skills = config.a2aSkills.split(",").map((s) => s.trim()).filter(Boolean).map((tag) => ({
+      id: tag,
+      name: tag,
+      description: tag,
+    }));
+  } else {
+    skills = [
       {
         id: "code-task",
         name: "Code Task",
@@ -57,9 +57,27 @@ export function buildAgentCard(config) {
           required: ["target"],
         },
       },
-    ],
+    ];
+  }
+
+  const card = {
+    schemaVersion: "1.0",
+    humanReadableId: `viveworker/${config.a2aRelayUserId || "viveworker"}`,
+    agentVersion: config.version || "0.3.0",
+    name: "viveworker",
+    description,
+    url: `${baseUrl.replace(/\/$/u, "")}/a2a`,
+    provider: { name: "viveworker" },
+    capabilities: {
+      a2aVersion: "0.2.3",
+      streaming: false,
+      pushNotifications: false,
+    },
+    skills,
     authSchemes: [{ scheme: "apiKey", in: "header", name: "X-A2A-Key" }],
   };
+  if (config.a2aAvatar) card.avatar = config.a2aAvatar;
+  return card;
 }
 
 // ---------------------------------------------------------------------------

package/scripts/viveworker-bridge.mjs

@@ -13787,6 +13787,9 @@ function buildConfig(cli) {
     moltbookApiKey: cleanText(process.env.MOLTBOOK_API_KEY || readMoltbookEnvKey() || ""),
     a2aApiKey: cleanText(process.env.A2A_API_KEY || readA2AEnvKey() || ""),
     a2aPublicUrl: cleanText(process.env.A2A_PUBLIC_URL || ""),
+    a2aDescription: cleanText(process.env.A2A_DESCRIPTION || ""),
+    a2aSkills: cleanText(process.env.A2A_SKILLS || ""),
+    a2aAvatar: cleanText(process.env.A2A_AVATAR || ""),
     a2aRelayUrl: cleanText(process.env.A2A_RELAY_URL || ""),
     a2aRelayUserId: cleanText(process.env.A2A_RELAY_USER_ID || ""),
     a2aRelaySecret: cleanText(process.env.A2A_RELAY_SECRET || ""),
@@ -15192,31 +15195,52 @@ async function main() {
         console.error(`[scan-error] ${error.message}`);
       }
 
-      // Hot-reload: detect a2a.env changes and auto-start relay
+      // Hot-reload: detect a2a.env changes (new config or updated card)
       const now = Date.now();
-      if (!config.a2aRelayUrl && now - lastA2aEnvCheckAt > A2A_ENV_CHECK_INTERVAL_MS) {
+      if (now - lastA2aEnvCheckAt > A2A_ENV_CHECK_INTERVAL_MS) {
         lastA2aEnvCheckAt = now;
         try {
           loadEnvFile(path.join(os.homedir(), ".viveworker", "a2a.env"));
           const newRelayUrl = cleanText(process.env.A2A_RELAY_URL || "");
           const newRelayUserId = cleanText(process.env.A2A_RELAY_USER_ID || "");
           const newRelayRegisterSecret = cleanText(process.env.A2A_RELAY_REGISTER_SECRET || "");
+          const newDescription = cleanText(process.env.A2A_DESCRIPTION || "");
+          const newSkills = cleanText(process.env.A2A_SKILLS || "");
+          const newAvatar = cleanText(process.env.A2A_AVATAR || "");
+
           if (newRelayUrl && newRelayUserId) {
-            config.a2aRelayUrl = newRelayUrl;
-            config.a2aRelayUserId = newRelayUserId;
-            config.a2aRelayRegisterSecret = newRelayRegisterSecret;
-            config.a2aApiKey = cleanText(process.env.A2A_API_KEY || config.a2aApiKey || "");
-            console.log(`[a2a-relay] Detected new relay config, registering...`);
-            const regResult = await registerWithRelay({ config, buildAgentCard });
-            if (regResult.ok) {
-              startRelayPolling({
-                config,
-                runtime,
-                state,
-                helpers: { recordTimelineEntry, deliverWebPushItem, saveState, historyToken, cleanText },
-              });
-            } else {
-              console.error(`[a2a-relay] Registration failed: ${regResult.error}`);
+            // Check if this is a first-time connect or a card update
+            const isNew = !config.a2aRelayUrl;
+            const cardChanged = config.a2aDescription !== newDescription || config.a2aSkills !== newSkills || config.a2aAvatar !== newAvatar;
+
+            if (isNew || cardChanged) {
+              config.a2aRelayUrl = newRelayUrl;
+              config.a2aRelayUserId = newRelayUserId;
+              config.a2aRelayRegisterSecret = newRelayRegisterSecret;
+              config.a2aApiKey = cleanText(process.env.A2A_API_KEY || config.a2aApiKey || "");
+              config.a2aDescription = newDescription;
+              config.a2aSkills = newSkills;
+              config.a2aAvatar = newAvatar;
+
+              if (isNew) {
+                console.log(`[a2a-relay] Detected new relay config, registering...`);
+              } else {
+                console.log(`[a2a-relay] Agent Card changed, re-registering...`);
+              }
+
+              const regResult = await registerWithRelay({ config, buildAgentCard });
+              if (regResult.ok) {
+                if (isNew) {
+                  startRelayPolling({
+                    config,
+                    runtime,
+                    state,
+                    helpers: { recordTimelineEntry, deliverWebPushItem, saveState, historyToken, cleanText },
+                  });
+                }
+              } else {
+                console.error(`[a2a-relay] Registration failed: ${regResult.error}`);
+              }
             }
           }
         } catch (error) {