@miruzero/zero-agent 0.3.4 → 0.3.5

package/README.md

@@ -33,7 +33,7 @@ Default state path:
 %APPDATA%\Microsoft\Windows\Start Menu\Programs\Startup\MiruZeroAgent.vbs
 ```
 
-The launcher uses `npx -y @miruzero/zero-agent@<current-version> start` so the user-logon agent does not depend on a stale global install.
+`setup` installs a stable global Zero Agent package by default. The generated launcher records the resolved Node executable and installed Zero Agent entrypoint, while the long-running agent retries transient connection failures instead of exiting.
 
 Device tokens are local secrets and must not be printed or committed.
 

package/package.json

@@ -1,8 +1,12 @@
 {
   "name": "@miruzero/zero-agent",
-  "version": "0.3.4",
+  "version": "0.3.5",
   "description": "MiruZero local worker agent for multi-device tool execution.",
   "type": "commonjs",
+  "main": "src/index.js",
+  "exports": {
+    ".": "./src/index.js"
+  },
   "bin": {
     "zero-agent": "bin/zero-agent.js"
   },
@@ -19,5 +23,8 @@
   "engines": {
     "node": ">=20"
   },
-  "license": "UNLICENSED"
+  "license": "UNLICENSED",
+  "dependencies": {
+    "@miruzero/zero": "0.1.0"
+  }
 }

package/src/agent.js

@@ -1,145 +1,158 @@
-'use strict';
-
-const os = require('node:os');
-const config = require('./config');
-const caps = require('./capabilities');
-const { requestJson } = require('./http');
-const localTools = require('./local-tools');
-
-const nowIso = () => new Date().toISOString();
-
-const serverBase = (server) => String(server || 'https://zero.miru.work').replace(/\/$/, '');
-const trace = (env, event, payload = {}) => {
-  if (env.ZERO_TRACE !== '1') return;
-  console.log(JSON.stringify({ at: nowIso(), event, ...payload }));
-};
-
-const initDevice = ({ name, server }, env = process.env) => {
-  const host = os.hostname();
-  const device = {
-    name: name || host,
-    host,
-    server: server || 'https://zero.miru.work',
-    device_id: null,
-    status: 'initialized',
-    created_at: nowIso(),
-    updated_at: nowIso()
-  };
-  const file = config.saveDevice(device, env);
-  return { file, device: config.redactedDevice(device) };
-};
-
-const pairDevice = async ({ name, server, code }, env = process.env) => {
-  if (!server) throw Object.assign(new Error('server is required'), { exitCode: 64 });
-  if (!code) throw Object.assign(new Error('pairing code is required'), { exitCode: 64 });
-  const host = os.hostname();
-  const payload = { name: name || host, pairing_code: code, host };
-  const result = await requestJson(`${serverBase(server)}/devices/register`, {
-    method: 'POST',
-    body: payload
-  });
-  if (!result.ok) {
-    const error = new Error(`pair failed status=${result.status}`);
-    error.response = result.json;
-    throw error;
-  }
-  const device = {
-    name: payload.name,
-    host,
-    server,
-    device_id: result.json.device_id,
-    device_token: result.json.device_token,
-    status: 'paired',
-    paired_at: nowIso(),
-    updated_at: nowIso()
-  };
-  const file = config.saveDevice(device, env);
-  return { file, device: config.redactedDevice(device) };
-};
-
-const getPairedDevice = (env = process.env) => {
-  const device = config.loadDevice(env);
-  if (!device || !device.device_id || !device.device_token || !device.server) {
-    return null;
-  }
-  return device;
-};
-
-const heartbeatPayload = (device, env = process.env) => {
-  const capability = caps.buildCapabilities(env);
-  return {
-    name: device.name,
-    status: 'online',
-    last_seen: nowIso(),
-    capability_hash: capability.capability_hash,
-    provider_count: capability.providers.length
-  };
-};
-
-const heartbeatOnce = async (env = process.env) => {
-  const device = getPairedDevice(env);
-  if (!device) return { ok: false, code: 'NOT_PAIRED', message: 'run zero-agent pair first' };
-  const url = `${serverBase(device.server)}/devices/${encodeURIComponent(device.device_id)}/heartbeat`;
-  const result = await requestJson(url, {
-    method: 'POST',
-    token: device.device_token,
-    body: heartbeatPayload(device, env)
-  });
-  return { ok: result.ok, status: result.status, body: result.json };
-};
-
-const syncCapabilitiesOnce = async (env = process.env) => {
-  const device = getPairedDevice(env);
-  if (!device) return { ok: false, code: 'NOT_PAIRED' };
-  const url = `${serverBase(device.server)}/devices/${encodeURIComponent(device.device_id)}/capabilities`;
-  const result = await requestJson(url, {
-    method: 'POST',
-    token: device.device_token,
-    body: caps.buildCapabilities(env)
-  });
-  return { ok: result.ok, status: result.status, body: result.json };
-};
-
-
-const pollTaskOnce = async (env = process.env) => {
-  const device = getPairedDevice(env);
-  if (!device) return { ok: false, code: 'NOT_PAIRED' };
-  const nextUrl = serverBase(device.server) + '/devices/' + encodeURIComponent(device.device_id) + '/tasks/next';
-  const next = await requestJson(nextUrl, { method: 'GET', token: device.device_token });
-  if (!next.ok) return { ok: false, status: next.status, body: next.json };
-  const task = next.json?.task || null;
-  if (!task) return { ok: true, task: null };
-  const started = Date.now();
-  trace(env, 'agent.task.received', { task_id: task.task_id, tool: task.tool, args: task.arguments || {} });
-  const resultUrl = serverBase(device.server) + '/devices/' + encodeURIComponent(device.device_id)
-    + '/tasks/' + encodeURIComponent(task.task_id) + '/result';
-  try {
-    const result = localTools.execute(task.tool, task.arguments || {}, env);
-    trace(env, 'agent.task.done', { task_id: task.task_id, ok: true, duration_ms: Date.now() - started });
-    const posted = await requestJson(resultUrl, { method: 'POST', token: device.device_token, body: { ok: true, result } });
-    const finalTask = posted.json?.task || task;
-    return { ok: posted.ok, task: finalTask, result, posted: { status: posted.status, body: posted.json } };
-  } catch (error) {
-    const payload = { ok: false, error: { code: error.code || 'AGENT_EXEC_ERROR', message: error.message || String(error) } };
-    trace(env, 'agent.task.done', { task_id: task.task_id, ok: false, error: payload.error, duration_ms: Date.now() - started });
-    const posted = await requestJson(resultUrl, { method: 'POST', token: device.device_token, body: payload });
-    const finalTask = posted.json?.task || task;
-    return { ok: false, task: finalTask, error: payload.error, posted: { status: posted.status, body: posted.json } };
-  }
-};
-
-const listDevices = async (env = process.env) => {
-  const device = config.loadDevice(env);
-  const result = await requestJson(`${serverBase(device?.server)}/devices`);
-  return { ok: result.ok, status: result.status, body: result.json };
-};
-module.exports = {
-  initDevice,
-  pairDevice,
-  heartbeatPayload,
-  heartbeatOnce,
-  syncCapabilitiesOnce,
-  pollTaskOnce,
-  listDevices,
-  getPairedDevice
-};
+'use strict';
+
+const os = require('node:os');
+const config = require('./config');
+const caps = require('./capabilities');
+const http = require('./http');
+const localTools = require('./local-tools');
+const command = require('./command');
+const zero = require('./zero-runtime');
+
+const nowIso = () => new Date().toISOString();
+
+const serverBase = (server) => String(server || 'https://zero.miru.work').replace(/\/$/, '');
+const trace = (env, event, payload = {}) => {
+  if (env.ZERO_TRACE !== '1') return;
+  console.log(JSON.stringify({ at: nowIso(), event, ...payload }));
+};
+
+const initDevice = ({ name, server }, env = process.env) => {
+  const host = os.hostname();
+  const device = {
+    name: name || host,
+    host,
+    server: server || 'https://zero.miru.work',
+    device_id: null,
+    status: 'initialized',
+    created_at: nowIso(),
+    updated_at: nowIso()
+  };
+  const file = config.saveDevice(device, env);
+  return { file, device: config.redactedDevice(device) };
+};
+
+const pairDevice = async ({ name, server, code }, env = process.env) => {
+  if (!server) throw Object.assign(new Error('server is required'), { exitCode: 64 });
+  if (!code) throw Object.assign(new Error('pairing code is required'), { exitCode: 64 });
+  const host = os.hostname();
+  const payload = { name: name || host, pairing_code: code, host };
+  const result = await http.requestJson(`${serverBase(server)}/devices/register`, {
+    method: 'POST',
+    body: payload
+  });
+  if (!result.ok) {
+    const error = new Error(`pair failed status=${result.status}`);
+    error.response = result.json;
+    throw error;
+  }
+  const device = {
+    name: payload.name,
+    host,
+    server,
+    device_id: result.json.device_id,
+    device_token: result.json.device_token,
+    status: 'paired',
+    paired_at: nowIso(),
+    updated_at: nowIso()
+  };
+  const file = config.saveDevice(device, env);
+  return { file, device: config.redactedDevice(device) };
+};
+
+const getPairedDevice = (env = process.env) => {
+  const device = config.loadDevice(env);
+  if (!device || !device.device_id || !device.device_token || !device.server) {
+    return null;
+  }
+  return device;
+};
+
+const heartbeatPayload = (device, env = process.env) => {
+  const capability = caps.buildCapabilities(env);
+  return {
+    name: device.name,
+    status: 'online',
+    last_seen: nowIso(),
+    capability_hash: capability.capability_hash,
+    provider_count: capability.providers.length
+  };
+};
+
+const heartbeatOnce = async (env = process.env) => {
+  const device = getPairedDevice(env);
+  if (!device) return { ok: false, code: 'NOT_PAIRED', message: 'run zero-agent pair first' };
+  const url = `${serverBase(device.server)}/devices/${encodeURIComponent(device.device_id)}/heartbeat`;
+  const result = await http.requestJson(url, {
+    method: 'POST',
+    token: device.device_token,
+    body: heartbeatPayload(device, env)
+  });
+  return { ok: result.ok, status: result.status, body: result.json };
+};
+
+const syncCapabilitiesOnce = async (env = process.env) => {
+  const device = getPairedDevice(env);
+  if (!device) return { ok: false, code: 'NOT_PAIRED' };
+  const url = `${serverBase(device.server)}/devices/${encodeURIComponent(device.device_id)}/capabilities`;
+  const result = await http.requestJson(url, {
+    method: 'POST',
+    token: device.device_token,
+    body: caps.buildCapabilities(env)
+  });
+  return { ok: result.ok, status: result.status, body: result.json };
+};
+
+
+const executeTask = (task = {}, env = process.env) => {
+  if (task.contractVersion) zero.contract.assertCompatible(task.contractVersion);
+  if (task.deadline && Date.parse(task.deadline) <= Date.now()) {
+    throw Object.assign(new Error('task deadline exceeded'), { code: 'TASK_DEADLINE_EXCEEDED', retryable: false });
+  }
+  const tool = String(task.tool || '');
+  if (tool.startsWith('zero.command.') || tool === 'readFile' || tool === 'command.readFile') {
+    try { return command.callTool(tool, task.arguments || {}, { env }); }
+    catch (error) {
+      if (error.code !== 'UNKNOWN_TOOL') throw error;
+    }
+  }
+  return localTools.execute(tool, task.arguments || {}, env);
+};
+
+const pollTaskOnce = async (env = process.env) => {
+  const device = getPairedDevice(env);
+  if (!device) return { ok: false, code: 'NOT_PAIRED' };
+  const nextUrl = serverBase(device.server) + '/devices/' + encodeURIComponent(device.device_id) + '/tasks/next';
+  const next = await http.requestJson(nextUrl, { method: 'GET', token: device.device_token });
+  if (!next.ok) return { ok: false, status: next.status, body: next.json };
+  const task = next.json?.task || null;
+  if (!task) return { ok: true, task: null };
+  const started = Date.now();
+  trace(env, 'agent.task.received', { task_id: task.task_id, tool: task.tool, args: task.arguments || {} });
+  const resultUrl = serverBase(device.server) + '/devices/' + encodeURIComponent(device.device_id)
+    + '/tasks/' + encodeURIComponent(task.task_id) + '/result';
+  try {
+    const result = executeTask(task, env);
+    trace(env, 'agent.task.done', { task_id: task.task_id, ok: true, duration_ms: Date.now() - started });
+    const posted = await http.requestJson(resultUrl, { method: 'POST', token: device.device_token, body: { ok: true, result } });
+    const finalTask = posted.json?.task || task;
+    return { ok: posted.ok, task: finalTask, result, posted: { status: posted.status, body: posted.json } };
+  } catch (error) {
+    const payload = { ok: false, error: { code: error.code || 'AGENT_EXEC_ERROR', message: error.message || String(error) } };
+    trace(env, 'agent.task.done', { task_id: task.task_id, ok: false, error: payload.error, duration_ms: Date.now() - started });
+    const posted = await http.requestJson(resultUrl, { method: 'POST', token: device.device_token, body: payload });
+    const finalTask = posted.json?.task || task;
+    return { ok: false, task: finalTask, error: payload.error, posted: { status: posted.status, body: posted.json } };
+  }
+};
+
+const listDevices = async (env = process.env) => {
+  const device = config.loadDevice(env);
+  const result = await http.requestJson(`${serverBase(device?.server)}/devices`);
+  return { ok: result.ok, status: result.status, body: result.json };
+};
+const agent = {
+  initDevice, pairDevice, heartbeatPayload, heartbeatOnce, syncCapabilitiesOnce,
+  executeTask, pollTaskOnce, listDevices, getPairedDevice
+};
+
+Object.assign(exports, agent);

package/src/autostart.js

@@ -1,12 +1,13 @@
 'use strict';
 
+const childProcess = require('node:child_process');
 const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
 const config = require('./config');
 const pkg = require('../package.json');
 
-const DEFAULT_INTERVAL = 30000;
+const DEFAULT_INTERVAL = 5000;
 
 const q = (value) => '"' + String(value).replace(/"/g, '""') + '"';
 const winPath = (value) => String(value).replace(/\//g, '\\');
@@ -35,23 +36,52 @@ const paths = (env = process.env) => {
 };
 
 const packageSpec = () => pkg.name + '@' + pkg.version;
-const packageBin = () => path.join(__dirname, '..', 'bin', 'zero-agent.js');
+const localPackageBin = () => path.join(__dirname, '..', 'bin', 'zero-agent.js');
 
-const launcherContent = ({ interval = DEFAULT_INTERVAL, roots, logFile }, env = process.env) => {
+const globalRoot = (env = process.env) => {
+  if (env.ZERO_AGENT_GLOBAL_ROOT) return path.resolve(env.ZERO_AGENT_GLOBAL_ROOT);
+  const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+  const result = childProcess.spawnSync(npmCmd, ['root', '-g'], {
+    env,
+    encoding: 'utf8',
+    windowsHide: true
+  });
+  if (result.status !== 0) return null;
+  const value = String(result.stdout || '').trim();
+  return value ? path.resolve(value) : null;
+};
+
+const packageBin = (env = process.env) => {
+  if (env.ZERO_AGENT_BIN) return path.resolve(env.ZERO_AGENT_BIN);
+  if (env.ZERO_AGENT_SKIP_GLOBAL_INSTALL !== '1') {
+    const root = globalRoot(env);
+    const candidate = root
+      ? path.join(root, '@miruzero', 'zero-agent', 'bin', 'zero-agent.js')
+      : null;
+    if (candidate && fs.existsSync(candidate)) return candidate;
+  }
+  return localPackageBin();
+};
+
+const nodeBin = (env = process.env) => path.resolve(env.ZERO_AGENT_NODE || process.execPath);
+
+const launcherContent = ({ interval = DEFAULT_INTERVAL, roots, logFile, binFile, nodeFile }, env = process.env) => {
   const home = config.agentHome(env);
   const spec = packageSpec();
-  const bin = packageBin();
+  const bin = binFile || packageBin(env);
+  const node = nodeFile || nodeBin(env);
   return [
     '@echo off',
     'setlocal',
     'set "ZERO_TRACE=1"',
     'set "ZERO_AGENT_HOME=' + winPath(home) + '"',
     'set "ZERO_AGENT_ROOTS=' + winPath(roots) + '"',
+    ...(env.ZERO_MCP_ROOT ? ['set "ZERO_MCP_ROOT=' + winPath(env.ZERO_MCP_ROOT) + '"'] : []),
     'set "ZERO_AGENT_INTERVAL=' + Number(interval || DEFAULT_INTERVAL) + '"',
     'rem interval=' + Number(interval || DEFAULT_INTERVAL) + 'ms',
     'if not exist ' + q(winPath(path.dirname(logFile))) + ' mkdir ' + q(winPath(path.dirname(logFile))),
     'echo [%date% %time%] starting ' + spec + ' >> ' + q(winPath(logFile)),
-    'node ' + q(winPath(bin)) + ' start --interval %ZERO_AGENT_INTERVAL% >> ' + q(winPath(logFile)) + ' 2>&1',
+    q(winPath(node)) + ' ' + q(winPath(bin)) + ' start --interval %ZERO_AGENT_INTERVAL% >> ' + q(winPath(logFile)) + ' 2>&1',
     ''
   ].join('\r\n');
 };
@@ -67,12 +97,25 @@ const prepare = (options = {}, env = process.env) => {
   const p = paths(env);
   const interval = Number(options.interval || env.ZERO_AGENT_INTERVAL || DEFAULT_INTERVAL);
   const roots = options.roots || defaultRoots(env);
+  const binFile = packageBin(env);
+  const nodeFile = nodeBin(env);
   fs.mkdirSync(path.dirname(p.launcherFile), { recursive: true });
   fs.mkdirSync(path.dirname(p.startupFile), { recursive: true });
   fs.mkdirSync(path.dirname(p.logFile), { recursive: true });
-  fs.writeFileSync(p.launcherFile, launcherContent({ interval, roots, logFile: p.logFile }, env), 'utf8');
+  fs.writeFileSync(p.launcherFile, launcherContent({
+    interval,
+    roots,
+    logFile: p.logFile,
+    binFile,
+    nodeFile
+  }, env), 'utf8');
   fs.writeFileSync(p.startupFile, vbsContent(p.launcherFile), 'utf8');
-  return { ok: true, interval, roots, ...p };
+  return { ok: true, interval, roots, binFile, nodeFile, ...p };
+};
+
+const isPrepared = (env = process.env) => {
+  const p = paths(env);
+  return fs.existsSync(p.launcherFile) && fs.existsSync(p.startupFile);
 };
 
 const autostart = {
@@ -80,6 +123,9 @@ const autostart = {
   defaultRoots,
   paths,
   prepare,
+  isPrepared,
+  packageBin,
+  nodeBin,
   launcherContent
 };