@myvillage/cli 1.88.3 → 1.89.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myvillage/cli",
-  "version": "1.88.3",
+  "version": "1.89.1",
   "description": "MyVillageOS CLI for community developers",
   "type": "module",
   "bin": {

package/src/agent-runtime/runner.js

@@ -23,7 +23,7 @@ import fs from 'fs';
 import path from 'path';
 import { getConfig } from '../utils/config.js';
 import { getAccessToken } from '../utils/auth.js';
-import { listLocalAgents, readAgentConfig } from '../utils/local-agent.js';
+import { listLocalAgents, readAgentConfig, getAgentDir, writeAgentConfig } from '../utils/local-agent.js';
 import { startDaemon, stopDaemon, isDaemonRunning, getDaemonInfo } from './daemon.js';
 
 const RUNNER_STATE_FILE = path.join(os.homedir(), '.myvillage', 'runner.json');
@@ -101,6 +101,88 @@ async function request(networkBaseUrl, pathname, method, body, headers) {
   return { status: res.status, ok: res.ok, json };
 }
 
+// ── Config sync (materialise an assigned agent from the control plane) ───────
+
+// Records which published config version this machine last wrote, so we only
+// re-write files when the definition actually changed.
+function syncedVersionPath(agentDir) {
+  return path.join(agentDir, '.config-version');
+}
+
+function readSyncedVersion(agentDir) {
+  try {
+    return Number(fs.readFileSync(syncedVersionPath(agentDir), 'utf8').trim()) || 0;
+  } catch {
+    return 0;
+  }
+}
+
+/**
+ * Write an assigned agent's files from its published definition, creating the
+ * agent directory if this machine has never run it. Returns true when the agent
+ * is ready to start.
+ *
+ * `.env` is never written here: secrets stay per-machine until they can be
+ * envelope-encrypted (see AgentConfig in the schema). An existing local `.env`
+ * is left untouched.
+ */
+async function syncAgentConfig(ctx, assignment) {
+  const { agentProfileId, handle, configVersion } = assignment;
+  const name = handle || agentProfileId;
+  const agentDir = getAgentDir(name);
+  const exists = fs.existsSync(path.join(agentDir, 'agent.config.yaml'));
+
+  // Nothing published: fall back to whatever is already on this machine.
+  if (!configVersion) return exists;
+  // Already current.
+  if (exists && readSyncedVersion(agentDir) === configVersion) return true;
+
+  const res = await ctx.cp(`/agents/${agentProfileId}/config`);
+  if (!res.ok) {
+    log(`could not fetch config for ${name} (${res.status}) — leaving local files alone`);
+    return exists;
+  }
+  const c = res.json.data;
+
+  fs.mkdirSync(agentDir, { recursive: true });
+  if (typeof c.promptMd === 'string' && c.promptMd) {
+    fs.writeFileSync(path.join(agentDir, 'prompt.md'), c.promptMd);
+  }
+  if (typeof c.toolsYaml === 'string' && c.toolsYaml) {
+    fs.writeFileSync(path.join(agentDir, 'tools.yaml'), c.toolsYaml);
+  }
+
+  // Compose agent.config.yaml from server-known identity + published schedule
+  // and brain, preserving anything already set locally that the control plane
+  // does not own.
+  let existingCfg = {};
+  try { existingCfg = readAgentConfig(name) || {}; } catch { /* first sync */ }
+  const cfg = {
+    ...existingCfg,
+    name,
+    display_name: c.displayName || existingCfg.display_name || name,
+    description: c.description ?? existingCfg.description ?? '',
+    man: {
+      ...(existingCfg.man || {}),
+      agent_id: c.agentId,
+      ...(c.villageAgentId ? { village_agent_id: c.villageAgentId } : {}),
+      handle: c.handle || name,
+    },
+    ...(c.schedule ? { schedule: c.schedule } : {}),
+    ...(c.brain ? { brain: c.brain } : {}),
+  };
+  writeAgentConfig(name, cfg);
+
+  // Keep an empty .env so the daemon's loader and 0600 expectations hold, but
+  // never overwrite secrets a person put here.
+  const envPath = path.join(agentDir, '.env');
+  if (!fs.existsSync(envPath)) fs.writeFileSync(envPath, '', { mode: 0o600 });
+
+  fs.writeFileSync(syncedVersionPath(agentDir), String(configVersion));
+  log(`synced ${name} config v${configVersion}${exists ? '' : ' (new on this machine)'}`);
+  return true;
+}
+
 // ── Local agent indexing ─────────────────────────────────────────────────────
 
 // Map control-plane agentProfileId -> local agent { name, config } via the
@@ -238,9 +320,28 @@ async function reconcileOnce(ctx) {
 
   // Start desired-running agents we don't yet own+run here.
   for (const a of desiredRunning) {
-    const entry = local.get(a.agentProfileId);
+    // Materialise (or refresh) the agent from its published definition, so a
+    // machine that has never seen this agent can still run it.
+    let entry = local.get(a.agentProfileId);
+    try {
+      const ready = await syncAgentConfig(ctx, a);
+      if (ready && !entry) {
+        const name = a.handle || a.agentProfileId;
+        entry = { name, config: readAgentConfig(name) };
+        local.set(a.agentProfileId, entry);
+      } else if (ready && entry) {
+        // Pick up an edited prompt/tools on the next start.
+        entry.config = readAgentConfig(entry.name);
+      }
+    } catch (err) {
+      log(`config sync failed for ${a.handle || a.agentProfileId}`, err?.message || err);
+    }
+
     if (!entry) {
-      log(`assigned agent ${a.handle || a.agentProfileId} has no local config on this machine — skipping (provision it first)`);
+      log(
+        `assigned agent ${a.handle || a.agentProfileId} has no config on this machine and none published — ` +
+          `open it in Studio to publish its setup`,
+      );
       continue;
     }
     if (ctx.leases.has(a.agentProfileId) && isDaemonRunning(entry.name)) continue;