openzoo 0.50.48 → 0.50.49

package/lib/cursorbackend.js

@@ -40,6 +40,8 @@ import { encodeAvailableModels, encodeForMethod, encodeEnsureSandBox, encodeGetG
 import {
   accountPodPath, accountAgentsPath, rosterForAccount, rosterForEvent,
   readHouseRoster, houseAgentsPath, shapeAgent, agentBrief, briefFromName,
+  readWakeups, writeWakeups, shapeWakeup, parseWakeupEvery, wantsWakeupCron,
+  DEFAULT_WAKEUP_PROMPT,
 } from './grokbotAccount.js';
 import { formatSpendFooter, mergeTurnProof } from './spendProof.js';
 import { prefixVisitorRichText } from './grokbotweb.js';
@@ -1181,10 +1183,130 @@ export function createZooTurnQueue() {
       inflight.delete(id);
       return 1;
     },
+    busy(agentId) {
+      return inflight.has(String(agentId || ''));
+    },
   };
 }
 const zooTurns = createZooTurnQueue();
 
+const wakeupTimers = new Map();
+let wakeupLog = () => {};
+let wakeupsRestored = false;
+
+function persistWakeups(map) {
+  try { writeWakeups(HOME, map); } catch (e) {
+    wakeupLog(`cursor-backend:      wakeups save failed: ${e.message}`);
+  }
+}
+
+export function listAgentWakeups() {
+  return readWakeups(HOME);
+}
+
+export function cancelAgentWakeup(agentId) {
+  const id = String(agentId || '');
+  const t = wakeupTimers.get(id);
+  if (t) {
+    clearTimeout(t);
+    wakeupTimers.delete(id);
+  }
+  const map = readWakeups(HOME);
+  if (!map[id]) return { ok: true, cancelled: false };
+  delete map[id];
+  persistWakeups(map);
+  return { ok: true, cancelled: true, id };
+}
+
+function armWakeup(rec) {
+  const id = rec.agentId;
+  const prev = wakeupTimers.get(id);
+  if (prev) clearTimeout(prev);
+  const delay = Math.max(1000, Number(rec.nextAt) - Date.now());
+  const t = setTimeout(() => {
+    fireAgentWakeup(id).catch((e) => wakeupLog(`cursor-backend:      wakeup fire ${id}: ${e.message}`));
+  }, delay);
+  wakeupTimers.set(id, t);
+}
+
+export function scheduleAgentWakeup(agentId, opts = {}) {
+  const id = String(agentId || '').trim();
+  if (!id) return { ok: false, error: 'no agent' };
+  const now = Date.now();
+  const every = opts.every ?? opts.everySec;
+  const rec = shapeWakeup(id, {
+    every,
+    prompt: opts.prompt,
+    lastAt: 0,
+    nextAt: now + parseWakeupEvery(every) * 1000,
+  }, now);
+  const map = readWakeups(HOME);
+  map[id] = rec;
+  persistWakeups(map);
+  armWakeup(rec);
+  wakeupLog(`cursor-backend:      wakeup every ${rec.everySec}s agent=${id}`);
+  return { ok: true, ...rec };
+}
+
+async function fireAgentWakeup(agentId) {
+  const id = String(agentId || '');
+  const map = readWakeups(HOME);
+  const rec = map[id];
+  if (!rec) {
+    wakeupTimers.delete(id);
+    return;
+  }
+  rec.lastAt = Date.now();
+  rec.nextAt = rec.lastAt + rec.everySec * 1000;
+  persistWakeups(map);
+  armWakeup(rec);
+  if (zooTurns.busy(id)) {
+    wakeupLog(`cursor-backend:      wakeup skip busy agent=${id}`);
+    return;
+  }
+  const nonce = `oz-wakeup-${id}-${rec.lastAt}`;
+  const prompt = rec.prompt || DEFAULT_WAKEUP_PROMPT;
+  const turn = zooTurns.begin(id, nonce);
+  const userLine = fanoutLine(id, 'user', `[wakeup]\n${prompt}`, { clientNonce: nonce, requestId: nonce });
+  ssePush('transcript', { ...gatewayEntry(userLine), agentId: id });
+  bumpAgent(id, { preview: '[wakeup]', notify: false });
+  wakeupLog(`cursor-backend:      wakeup start agent=${id}`);
+  try {
+    const z = await zooComplete(prompt, wakeupLog, id, {}, {
+      signal: turn.signal,
+      onProgress: (note) => {
+        if (!zooTurns.isCurrent(id, nonce)) return;
+        paintChatUpdate(id, note, { clientNonce: nonce, requestId: nonce });
+      },
+    });
+    if (!zooTurns.isCurrent(id, nonce)) return;
+    const line = fanoutLine(id, 'assistant', z.text, { clientNonce: nonce, requestId: nonce });
+    ssePush('transcript', { ...gatewayEntry(line), agentId: id });
+    bumpAgent(id, { preview: z.text, notify: true });
+    wakeupLog(`cursor-backend:      wakeup done agent=${id} seq=${line.seq}`);
+  } catch (e) {
+    if (!isSupersededError(e)) wakeupLog(`cursor-backend:      wakeup failed agent=${id}: ${e.message}`);
+  } finally {
+    zooTurns.end(id, nonce);
+  }
+}
+
+export function restoreAgentWakeups(log = () => {}) {
+  wakeupLog = log;
+  if (wakeupsRestored) return 0;
+  wakeupsRestored = true;
+  const map = readWakeups(HOME);
+  const ids = Object.keys(map);
+  const now = Date.now();
+  ids.forEach((id, i) => {
+    map[id].nextAt = now + 5000 + i * 2000;
+  });
+  if (ids.length) persistWakeups(map);
+  for (const id of ids) armWakeup(map[id]);
+  if (ids.length) log(`cursor-backend:      wakeups restored ${ids.length}`);
+  return ids.length;
+}
+
 export function formatZooProgress({ step, maxSteps, names, command } = {}) {
   const tools = Array.isArray(names) ? names.filter(Boolean).join(', ') : String(names || 'tools');
   const cmd = command ? ` ${JSON.stringify(String(command).slice(0, 80))}` : '';
@@ -1195,7 +1317,7 @@ export function formatZooProgress({ step, maxSteps, names, command } = {}) {
  *  bubble is still silence. Keep it short; the model history skips ephemeral. */
 export function formatZooToolLine({ name, args = {}, result } = {}) {
   const detail = args.command || args.path || args.name || args.window
-    || args.query || args.url || args.key || args.app
+    || args.query || args.url || args.key || args.app || args.every
     || (args.x != null && args.y != null ? `${args.x},${args.y}` : '')
     || (args.text != null ? String(args.text).slice(0, 80) : '');
   const head = detail
@@ -2003,6 +2125,34 @@ const LOCAL_TOOLS = [
       },
     },
   },
+  {
+    type: 'function',
+    function: {
+      name: 'schedule_wakeup',
+      description: 'Host timer that keeps this bot working with no human message. "never stop" / cron. Default every 5m. Min 60s. Does not spawn bots.',
+      parameters: {
+        type: 'object',
+        properties: {
+          every: { type: 'string', description: '5m, 1h, 90s. Default 5m. Floor 60s.' },
+          prompt: { type: 'string', description: 'What to do on each tick.' },
+          agent: { type: 'string', description: 'Name or id. Default: this bot.' },
+        },
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'cancel_wakeup',
+      description: 'Stop the host wakeup timer for this bot (or agent).',
+      parameters: {
+        type: 'object',
+        properties: {
+          agent: { type: 'string' },
+        },
+      },
+    },
+  },
 ];
 
 export const LOCAL_TOOL_NAMES = LOCAL_TOOLS.map((t) => t.function.name);
@@ -2151,8 +2301,12 @@ async function runLocalTool(name, args, log, ctx = {}) {
       const agent = mintLocalAgent({ name, brief });
       pushCreatedAgent(agent, { select: args.select !== false });
       seedBriefOnCanvas(agent);
+      const n = (cachedAgentList() || []).length;
       log(`cursor-backend:      create_agent tool id=${agent.id} name=${JSON.stringify(agent.name)} brief=${brief ? brief.length : 0}c`);
-      return JSON.stringify({ ok: true, id: agent.id, name: agent.name, brief: agent.brief || '' });
+      const warning = n >= 8
+        ? `Mac already has ${n} bots. Prefer schedule_wakeup over spawning. Only mint a NEW named role.`
+        : undefined;
+      return JSON.stringify({ ok: true, id: agent.id, name: agent.name, brief: agent.brief || '', warning });
     }
     if (name === 'set_brief') {
       const who = findAgent(args.agent || args.id || args.name) || findAgent(ctx.agentId);
@@ -2162,10 +2316,12 @@ async function runLocalTool(name, args, log, ctx = {}) {
     }
     if (name === 'list_agents') {
       const list = cachedAgentList() || [];
+      const wakes = readWakeups(HOME);
       return JSON.stringify(list.map((a) => ({
         id: a.id,
         name: a.name,
         brief: String(a.brief || '').slice(0, 120),
+        wakeup: wakes[a.id] ? { everySec: wakes[a.id].everySec, nextAt: wakes[a.id].nextAt } : null,
       })));
     }
     if (name === 'message_agent') {
@@ -2177,6 +2333,17 @@ async function runLocalTool(name, args, log, ctx = {}) {
         log,
       });
     }
+    if (name === 'schedule_wakeup') {
+      const who = findAgent(args.agent || args.id || args.name) || findAgent(ctx.agentId);
+      if (!who) return 'ERROR no such agent';
+      const got = scheduleAgentWakeup(who.id, { every: args.every, prompt: args.prompt });
+      return JSON.stringify(got);
+    }
+    if (name === 'cancel_wakeup') {
+      const who = findAgent(args.agent || args.id || args.name) || findAgent(ctx.agentId);
+      if (!who) return 'ERROR no such agent';
+      return JSON.stringify(cancelAgentWakeup(who.id));
+    }
     return `unknown tool ${name}`;
   } catch (e) {
     return `ERROR ${e.message}`;
@@ -2273,8 +2440,9 @@ async function zooComplete(prompt, log, agentId, parsed = {}, opts = {}) {
             return brief ? `${who} Standing brief (persisted): ${brief}` : who;
           })(),
           `You HAVE local tools on the user's computer via ${via}.`,
-          'Tools: read_file, write_file, exec, list_dir, screenshot, click, type_text, key, ui_tree, focus_app, open_url, create_agent, set_brief, list_agents, message_agent.',
+          'Tools: read_file, write_file, exec, list_dir, screenshot, click, type_text, key, ui_tree, focus_app, open_url, create_agent, set_brief, list_agents, message_agent, schedule_wakeup, cancel_wakeup.',
           'create_agent mints a sidebar bot. ALWAYS pass brief so they keep the job across restart. set_brief updates it. list_agents + message_agent talk to other bots (one hop). Do not tell the human to copy-paste between canvases.',
+          'NEVER STOP / cron / keep working between human messages: call schedule_wakeup every="5m". That is a host timer. There is no crontab. Do not spawn more bots for persistence. Do not re-read SITREP-NOW.md or STANDING-ORDERS.md every turn — do the next file or click. exec sysctl/uptime is not the job. If the tray already has named workers, answer "no" to spawning more.',
           'You CAN click the Mac and fill/submit browser forms. That is required when the user asks. Do not write a markdown briefing instead of clicking. Do not tell the user to click.',
           'Form loop: focus_app Brave Browser → screenshot → click the field (query or x,y) → type_text → screenshot to confirm → click Submit / key enter. screenshot.screen is click coordinate space. Prefer click query="Submit".',
           'screenshot captures the display and attaches the image. For any on-screen form, dashboard, or click target, screenshot first this turn. Do not guess at UI you have not seen.',
@@ -2805,6 +2973,10 @@ async function handleHijackedPodHttp(req, res, full, body, log) {
     log(`cursor-backend:      >> sendPrompt agent=${agentId} keys=${Object.keys(parsed).join(',')} attachments=${attN}${visitor ? ` visitor=${visitor.shortname}` : ''} prompt=${JSON.stringify((prompt || '').slice(0, 80))}`);
     lastSendEchoId = String(nonce);
     jsonSend(res, { accepted: true });
+    if (!visitor && wantsWakeupCron(prompt)) {
+      const cron = scheduleAgentWakeup(agentId, { every: '5m' });
+      log(`cursor-backend:      never-stop cron agent=${agentId} every=${cron.everySec}s`);
+    }
     const turn = zooTurns.begin(agentId, nonce);
     const userLine = fanoutLine(agentId, 'user', uiText, {
       clientNonce: nonce,
@@ -3013,6 +3185,7 @@ function respond(req, res, method, models) {
  * unprivileged). Returns { server, port }.
  */
 export function startCursorBackend({ port = 8443, models, log = () => {} } = {}) {
+  restoreAgentWakeups(log);
   const { cert, key } = ensureCert(log);
   const certPem = fs.readFileSync(cert);
   const keyPem = fs.readFileSync(key);

package/lib/grokbotAccount.js

@@ -184,6 +184,72 @@ export function rosterForEvent(list, activity) {
   });
 }
 
+export const WAKEUP_MIN_SEC = 60;
+export const WAKEUP_MAX_SEC = 6 * 3600;
+export const WAKEUP_DEFAULT_SEC = 5 * 60;
+export const DEFAULT_WAKEUP_PROMPT = 'Wakeup. Continue your brief. Do the next real action (write a file, click, or message a worker). Do not only re-read sitrep. Do not spawn more bots. Do not exec sysctl/uptime.';
+
+export function wakeupsPath(home) {
+  return path.join(home, '.openzoo', 'grokbot-wakeups.json');
+}
+
+/** "5m" / "1h" / "90" / "30s". Floor 60s so a never-stop cron cannot storm. */
+export function parseWakeupEvery(raw) {
+  const s = String(raw ?? '').trim().toLowerCase();
+  if (!s) return WAKEUP_DEFAULT_SEC;
+  const m = s.match(/^(\d+(?:\.\d+)?)\s*(s|sec|secs|seconds?|m|min|mins|minutes?|h|hr|hrs|hours?)?$/);
+  if (!m) return WAKEUP_DEFAULT_SEC;
+  const n = Number(m[1]);
+  if (!Number.isFinite(n) || n <= 0) return WAKEUP_DEFAULT_SEC;
+  const u = m[2] || 's';
+  let sec = n;
+  if (/^m/.test(u)) sec = n * 60;
+  else if (/^h/.test(u)) sec = n * 3600;
+  return Math.min(WAKEUP_MAX_SEC, Math.max(WAKEUP_MIN_SEC, Math.round(sec)));
+}
+
+export function wantsWakeupCron(prompt) {
+  const s = String(prompt || '');
+  if (/\bcron\b.{0,48}\bwakeups?\b/i.test(s)) return true;
+  if (/\bwakeups?\b.{0,48}\bcron\b/i.test(s)) return true;
+  if (/\bnever stop\b/i.test(s)) return true;
+  if (/\bschedule\b.{0,24}\bwakeups?\b/i.test(s)) return true;
+  return false;
+}
+
+export function shapeWakeup(agentId, rec = {}, now = Date.now()) {
+  const everySec = parseWakeupEvery(rec.everySec ?? rec.every ?? rec.interval);
+  const prompt = String(rec.prompt || DEFAULT_WAKEUP_PROMPT).trim().slice(0, 2000)
+    || DEFAULT_WAKEUP_PROMPT;
+  const lastAt = Number(rec.lastAt) || 0;
+  let nextAt = Number(rec.nextAt) || 0;
+  if (!Number.isFinite(nextAt) || nextAt <= 0) nextAt = now + everySec * 1000;
+  return {
+    agentId: String(agentId || rec.agentId || ''),
+    everySec,
+    prompt,
+    lastAt,
+    nextAt,
+  };
+}
+
+export function readWakeups(home) {
+  const raw = readJsonFile(wakeupsPath(home));
+  const src = raw && typeof raw === 'object' && !Array.isArray(raw) ? raw : {};
+  const out = {};
+  for (const [id, rec] of Object.entries(src)) {
+    const w = shapeWakeup(id, rec);
+    if (w.agentId) out[w.agentId] = w;
+  }
+  return out;
+}
+
+export function writeWakeups(home, map) {
+  const dir = path.dirname(wakeupsPath(home));
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(wakeupsPath(home), JSON.stringify(map || {}, null, 2));
+}
+
 export function callerKeyFromAuth(authorization) {
   const a = String(authorization || '').trim();
   if (!a) return '';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openzoo",
-  "version": "0.50.48",
+  "version": "0.50.49",
   "description": "Local x402-paying proxy + MCP server for openzoo.fun — point any OpenAI-compatible harness (Cursor, Claude Code, aider, SDKs) at localhost and it pays per call from a local burner wallet. Solana and Base rails live; Robinhood experimental.",
   "license": "MIT",
   "type": "module",