@myvillage/cli 2.14.0 → 2.16.0

package/package.json

@@ -1,11 +1,14 @@
 {
   "name": "@myvillage/cli",
-  "version": "2.14.0",
+  "version": "2.16.0",
   "description": "MyVillageOS CLI for community developers",
   "type": "module",
   "bin": {
     "myvillage": "./bin/myvillage.js"
   },
+  "scripts": {
+    "test": "node --test test/*.test.js"
+  },
   "engines": {
     "node": ">=22.0.0"
   },

package/src/agent-runtime/context.js

@@ -14,13 +14,26 @@
 import { listDatasets } from '../utils/dataset-workspace.js';
 import { listModels } from '../utils/model-workspace.js';
 import { readAgentModels, describeAgentModel } from '../utils/agent-models.js';
+import { fetchAgentMemories, formatMemorySection, readEnvSecrets } from './memory-context.js';
 
-export async function gatherContext(agentConfig, lastCheckIn, recentActions = [], agentName = agentConfig?.name) {
+// `opts.agentDir` lets saved notes be checked against the agent's .env so a
+// secret never reaches the context; `opts.listMemory` swaps the memory fetch
+// (tests).
+export async function gatherContext(agentConfig, lastCheckIn, recentActions = [], agentName = agentConfig?.name, opts = {}) {
   const parts = [];
 
   parts.push(`Current time: ${new Date().toISOString()}`);
   parts.push(`Last check-in: ${lastCheckIn || 'never'}`);
 
+  // What the agent saved in earlier runs. Read by the runtime every loop, not
+  // left to the model to look up. Empty (and silent) if it can't be fetched.
+  const memories = await fetchAgentMemories(
+    agentConfig?.man?.agent_id,
+    opts.listMemory ? { list: opts.listMemory } : undefined,
+  );
+  const memorySection = formatMemorySection(memories, { secrets: readEnvSecrets(opts.agentDir) });
+  if (memorySection) parts.push(memorySection);
+
   // Include recent actions so the agent knows what it already did
   if (recentActions.length > 0) {
     parts.push('\nYour recent actions:');
@@ -76,5 +89,5 @@ export async function gatherContext(agentConfig, lastCheckIn, recentActions = []
   parts.push('You may post, comment, vote, read files, run your tools, or do nothing if appropriate.');
   parts.push('Be thoughtful — quality over quantity. Avoid repeating yourself.');
 
-  return { text: parts.join('\n') };
+  return { text: parts.join('\n'), memoryCount: memories.length };
 }

package/src/agent-runtime/loop.js

@@ -12,6 +12,7 @@ import { getMCPTools, cleanupMCPClients } from './mcp-client.js';
 import { getBuiltinTools } from './builtin-tools.js';
 import { readAgentModels } from '../utils/agent-models.js';
 import { gatherContext } from './context.js';
+import { RUN_NOTES_INSTRUCTION } from './memory-context.js';
 import { isWithinActiveHours, getNextCheckInMs } from './scheduler.js';
 import { parse as parseYaml } from 'yaml';
 import { postAgentHeartbeat, listAgentTasks, claimAgentTask, completeAgentTask, refreshAccessToken } from '../utils/api.js';
@@ -308,6 +309,10 @@ export async function agentLoop(agentName, { signal }) {
         logActivity(agentDir, { type: 'wisdom_loaded', count: wisdom.length, names: wisdom.map(w => w.name) });
       }
 
+      // Ask the agent to leave notes for its next run. Only when it can
+      // actually save them; the notes come back in the context every loop.
+      if (tools.agent_memory_set) systemPrompt = `${systemPrompt}\n\n${RUN_NOTES_INSTRUCTION}`;
+
       // Try to pull an assigned task first. Tasks take priority over ambient
       // feed-monitoring. If nothing is queued, fall through to the default.
       if (resuming) {
@@ -320,7 +325,7 @@ export async function agentLoop(agentName, { signal }) {
       // no longer auto-fetched here — the agent pulls them on demand via its
       // tools — so these activity counters stay at 0 unless a future signal
       // repopulates them.
-      const contextResult = await gatherContext(config, lastCheckIn, recentActions, agentName);
+      const contextResult = await gatherContext(config, lastCheckIn, recentActions, agentName, { agentDir });
       let context = contextResult.text;
       const eventsFound = 0;
 
@@ -360,6 +365,7 @@ Guidelines:
         feedItems: feedItemsRead,
         mentions: mentionsFound,
         events: eventsFound,
+        memories: contextResult.memoryCount,
       });
 
       const conversation = resuming

package/src/agent-runtime/mcp-client.js

@@ -167,7 +167,10 @@ export async function getMCPTools(agentDir, agentConfig) {
       // withhold everything else this server offers (e.g. grant `network_feed`
       // but not `wallet_send`). Absent/empty → all tools, the backward-compatible
       // default.
-      const tools = applyToolAllowlist(await client.tools(), server.allowed_tools, name);
+      const tools = withSecretPlaceholders(
+        applyToolAllowlist(await client.tools(), server.allowed_tools, name),
+        server.secrets,
+      );
       const toolNames = Object.keys(tools);
       Object.assign(allTools, tools);
       servers.push({
@@ -216,6 +219,76 @@ export function applyToolAllowlist(tools, allowed, serverName) {
   return filtered;
 }
 
+/**
+ * Let an agent use a secret without ever seeing it.
+ *
+ * `secrets` is a server's list of `.env` names from tools.yaml (e.g.
+ * `[SCHOOL_USERNAME, SCHOOL_PASSWORD]`). The agent writes `${SCHOOL_PASSWORD}`
+ * in a tool call, say as the value for `puppeteer_fill`, and the real value is
+ * swapped in right before the tool runs. Anything the tool sends back has the
+ * value turned back into its placeholder, so the secret never reaches the
+ * model, its context, or the activity log.
+ *
+ * Only the names listed are swapped, per server, so an agent cannot ask for
+ * `${MYVILLAGE_ACCESS_TOKEN}` or any other variable it wasn't given. Unknown or
+ * unset names are left as written.
+ */
+export function withSecretPlaceholders(tools, secretNames, env = process.env) {
+  if (!Array.isArray(secretNames) || secretNames.length === 0) return tools;
+  const allowed = new Set(secretNames.filter((n) => typeof n === 'string' && /^\w+$/.test(n)));
+  if (allowed.size === 0) return tools;
+
+  const fill = (v) => {
+    if (typeof v === 'string') {
+      return v.replace(/\$\{(\w+)\}/g, (m, n) => (allowed.has(n) && env[n] ? env[n] : m));
+    }
+    if (Array.isArray(v)) return v.map(fill);
+    if (v && typeof v === 'object') {
+      return Object.fromEntries(Object.entries(v).map(([k, x]) => [k, fill(x)]));
+    }
+    return v;
+  };
+
+  // Longest first, so a value that contains another is replaced whole. Very
+  // short values are skipped: blanking every "a" in a page would wreck it.
+  const values = [...allowed]
+    .map((n) => [n, env[n]])
+    .filter(([, v]) => typeof v === 'string' && v.length >= 3)
+    .sort((a, b) => b[1].length - a[1].length);
+  const redact = (v) => {
+    if (typeof v === 'string') {
+      let out = v;
+      for (const [n, secret] of values) out = out.split(secret).join(`\${${n}}`);
+      return out;
+    }
+    if (Array.isArray(v)) return v.map(redact);
+    if (v && typeof v === 'object') {
+      return Object.fromEntries(Object.entries(v).map(([k, x]) => [k, redact(x)]));
+    }
+    return v;
+  };
+
+  const wrapped = {};
+  for (const [name, tool] of Object.entries(tools)) {
+    if (typeof tool?.execute !== 'function') {
+      wrapped[name] = tool;
+      continue;
+    }
+    wrapped[name] = {
+      ...tool,
+      execute: async (args, options) => {
+        try {
+          return redact(await tool.execute(fill(args), options));
+        } catch (err) {
+          if (err && typeof err.message === 'string') err.message = redact(err.message);
+          throw err;
+        }
+      },
+    };
+  }
+  return wrapped;
+}
+
 export async function cleanupMCPClients() {
   for (const client of activeClients) {
     try { await client.close(); } catch { /* ignore */ }

package/src/agent-runtime/memory-context.js

@@ -0,0 +1,136 @@
+// ── Memory Context ──────────────────────────────────────
+// Every loop starts a fresh conversation, so an agent forgets what it worked
+// out last run (a login selector that worked, an id it looked up) unless the
+// model happens to call agent_memory_list. Relying on that choice failed in
+// practice: an agent found the right selectors in run 1, never re-read them,
+// and spent run 2 guessing again.
+//
+// So the runtime reads the agent's saved memories itself, at the start of
+// every loop, and puts a compact "what you remember" section into the context.
+// It reads the same store the hosted agent_memory_* MCP tools use
+// (GET /api/network/agents/{agentProfileId}/memory), straight from the
+// platform API, so it works whether or not the agent was granted those tools.
+//
+// Notes saved under RUN_NOTES_CATEGORY are shown first: that is the category
+// the agent is asked to use for "things my next run should know".
+
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { listAgentMemory } from '../utils/api.js';
+
+export const RUN_NOTES_CATEGORY = 'run_notes';
+
+const DEFAULT_MAX_ENTRIES = 30;
+const DEFAULT_MAX_CHARS = 4000;
+const MAX_VALUE_CHARS = 500;
+const FETCH_TIMEOUT_MS = 8000;
+
+// Shown in the system prompt when the agent can call agent_memory_set. Kept
+// constant so it doesn't break the cached system-prompt prefix.
+export const RUN_NOTES_INSTRUCTION =
+  '## Notes for your next run\n' +
+  'Each run starts fresh: the only things you carry over are the notes you save. ' +
+  'Before you finish, if you worked something out that would save time next run (a selector, button or URL that worked, ' +
+  'an id you looked up, a step that failed and why), save it with agent_memory_set using ' +
+  `category "${RUN_NOTES_CATEGORY}" and a short descriptive key (e.g. "login_selectors"). ` +
+  'Update the same key rather than adding near-duplicates. ' +
+  'Never save a password or secret value; write its ${NAME} placeholder instead.';
+
+/**
+ * Fetch this agent's saved memories, newest first. Never throws: any failure
+ * (no agent id yet, offline, signed out, slow server) returns [] so the loop
+ * runs exactly as it did before.
+ */
+export async function fetchAgentMemories(agentId, { list = listAgentMemory, timeoutMs = FETCH_TIMEOUT_MS } = {}) {
+  if (!agentId) return [];
+  let timer;
+  try {
+    const res = await Promise.race([
+      list(agentId),
+      new Promise((resolve) => { timer = setTimeout(() => resolve(null), timeoutMs); }),
+    ]);
+    const entries = Array.isArray(res?.data) ? res.data : Array.isArray(res) ? res : [];
+    return entries.filter((e) => e && typeof e.key === 'string');
+  } catch {
+    return [];
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/**
+ * Values from the agent's .env, so a secret the agent mistakenly saved to
+ * memory is shown back as its ${NAME} placeholder instead of the real value.
+ */
+export function readEnvSecrets(agentDir) {
+  const out = [];
+  const path = agentDir && join(agentDir, '.env');
+  if (!path || !existsSync(path)) return out;
+  let text;
+  try { text = readFileSync(path, 'utf-8'); } catch { return out; }
+  for (const raw of text.split('\n')) {
+    const line = raw.trim();
+    if (!line || line.startsWith('#')) continue;
+    const eq = line.indexOf('=');
+    if (eq <= 0) continue;
+    const name = line.slice(0, eq).trim().replace(/^export\s+/, '');
+    let value = line.slice(eq + 1).trim();
+    if (value.length >= 2 && (value[0] === '"' || value[0] === "'") && value.endsWith(value[0])) {
+      value = value.slice(1, -1);
+    }
+    if (/^\w+$/.test(name) && value.length >= 3) out.push([name, value]);
+  }
+  // Longest first, so a value that contains another is replaced whole.
+  return out.sort((a, b) => b[1].length - a[1].length);
+}
+
+function redact(text, secrets) {
+  let out = text;
+  for (const [name, value] of secrets) out = out.split(value).join(`\${${name}}`);
+  return out;
+}
+
+function oneLine(value) {
+  const s = (typeof value === 'string' ? value : JSON.stringify(value) ?? '').replace(/\s+/g, ' ').trim();
+  return s.length > MAX_VALUE_CHARS ? `${s.slice(0, MAX_VALUE_CHARS)}…` : s;
+}
+
+function updatedTime(e) {
+  const t = Date.parse(e.updatedAt || e.createdAt || '');
+  return Number.isNaN(t) ? 0 : t;
+}
+
+/**
+ * Render memories as a compact context section, or '' when there are none.
+ * Run notes come first, then everything else; newest first within each, capped
+ * at `maxEntries` lines and roughly `maxChars` characters.
+ */
+export function formatMemorySection(
+  entries,
+  { maxEntries = DEFAULT_MAX_ENTRIES, maxChars = DEFAULT_MAX_CHARS, secrets = [] } = {},
+) {
+  if (!Array.isArray(entries) || entries.length === 0) return '';
+  const byNewest = [...entries].sort((a, b) => updatedTime(b) - updatedTime(a));
+  const ordered = [
+    ...byNewest.filter((e) => e.category === RUN_NOTES_CATEGORY),
+    ...byNewest.filter((e) => e.category !== RUN_NOTES_CATEGORY),
+  ];
+
+  const header = [
+    '\nWhat you remember from earlier runs (your own saved notes, newest first; use them instead of working things out again):',
+  ];
+  const lines = [];
+  let used = header[0].length;
+  for (const e of ordered) {
+    if (lines.length >= maxEntries) break;
+    const date = e.updatedAt ? ` (saved ${String(e.updatedAt).slice(0, 10)})` : '';
+    const cat = e.category && e.category !== RUN_NOTES_CATEGORY ? ` [${e.category}]` : '';
+    const line = redact(`- ${e.key}${cat}: ${oneLine(e.value)}${date}`, secrets);
+    if (lines.length > 0 && used + line.length + 1 > maxChars) break;
+    lines.push(line);
+    used += line.length + 1;
+  }
+  const hidden = ordered.length - lines.length;
+  if (hidden > 0) lines.push(`(${hidden} older note${hidden === 1 ? '' : 's'} not shown; agent_memory_list has them all.)`);
+  return [...header, ...lines].join('\n');
+}