@miruzero/zero-agent 0.2.0 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miruzero/zero-agent",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "MiruZero local worker agent for multi-device tool execution.",
   "type": "commonjs",
   "bin": {

package/src/agent.js

@@ -4,10 +4,15 @@ 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();
@@ -95,6 +100,34 @@ const syncCapabilitiesOnce = async (env = process.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`);
@@ -106,6 +139,7 @@ module.exports = {
   heartbeatPayload,
   heartbeatOnce,
   syncCapabilitiesOnce,
+  pollTaskOnce,
   listDevices,
   getPairedDevice
 };

package/src/cli.js

@@ -93,7 +93,8 @@ const runStartOnce = async (env) => {
   const heartbeat = await agent.heartbeatOnce(env);
   if (!heartbeat.ok && heartbeat.code === 'NOT_PAIRED') return heartbeat;
   const capability = await agent.syncCapabilitiesOnce(env);
-  return { heartbeat, capability };
+  const task = await agent.pollTaskOnce(env);
+  return { heartbeat, capability, task };
 };
 
 const printStartBanner = (env) => {
@@ -113,6 +114,7 @@ const printLoopResult = (result) => {
   const hb = result.heartbeat || {};
   const cap = result.capability || {};
   const device = cap.body?.device || hb.body?.device || null;
+  const taskState = result.task?.task ? (result.task.task.task_id + ':' + (result.task.task.status || 'done')) : 'none';
   console.log(JSON.stringify({
     at: new Date().toISOString(),
     heartbeat: okMark(Boolean(hb.ok)),
@@ -121,7 +123,8 @@ const printLoopResult = (result) => {
     name: device?.name || null,
     host: device?.host || null,
     providers: device?.provider_count || null,
-    last_seen: device?.last_seen || null
+    last_seen: device?.last_seen || null,
+    task: taskState
   }));
 };
 

package/src/local-tools.js

@@ -0,0 +1,145 @@
+'use strict';
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const textDecoder = new TextDecoder('utf-8', { fatal: false });
+const err = (code, message) => Object.assign(new Error(message), { code });
+const normalize = (value) => path.resolve(String(value)).toLowerCase();
+
+const rootsFor = (env = process.env) => {
+  const configured = String(env.ZERO_AGENT_ROOTS || '')
+    .split(';')
+    .map((item) => item.trim())
+    .filter(Boolean);
+  const roots = configured.length ? configured : [os.homedir(), process.cwd()];
+  return roots.map((item) => path.resolve(item));
+};
+
+const resolveAllowed = (inputPath, env = process.env) => {
+  if (!inputPath || typeof inputPath !== 'string') throw err('INVALID_PATH', 'path is required');
+  const roots = rootsFor(env);
+  const target = path.resolve(inputPath);
+  const targetNorm = normalize(target);
+  const ok = roots.some((root) => {
+    const rootNorm = normalize(root);
+    return targetNorm === rootNorm || targetNorm.startsWith(rootNorm + path.sep.toLowerCase());
+  });
+  if (!ok) throw err('PATH_NOT_ALLOWED', 'path is outside agent allowed roots');
+  return target;
+};
+
+const readUtf8 = (file) => {
+  const data = fs.readFileSync(file);
+  if (data.includes(0)) throw err('BINARY_FILE', 'binary file is not supported');
+  return textDecoder.decode(data);
+};
+
+const entry = (fullPath, root) => {
+  const stat = fs.statSync(fullPath);
+  return {
+    path: fullPath,
+    relativePath: path.relative(root, fullPath).replace(/\\/g, '/'),
+    type: stat.isDirectory() ? 'directory' : 'file',
+    size: stat.size
+  };
+};
+
+const walk = (root, options = {}) => {
+  const depth = options.depth ?? Infinity;
+  const filesOnly = options.filesOnly === true;
+  const out = [];
+  const visit = (dir, level) => {
+    if (level > depth) return;
+    for (const name of fs.readdirSync(dir)) {
+      const full = path.join(dir, name);
+      const item = entry(full, root);
+      if (!filesOnly || item.type === 'file') out.push(item);
+      if (item.type === 'directory') visit(full, level + 1);
+    }
+  };
+  visit(root, 1);
+  return out;
+};
+
+const wildcard = (pattern) => new RegExp('^' + String(pattern)
+  .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+  .replace(/\*/g, '.*').replace(/\?/g, '.') + '$', 'i');
+
+const numbered = (lines, startIndex) => lines
+  .map((line, index) => String(startIndex + index + 1).padStart(4, ' ') + '\t' + line)
+  .join('\n');
+
+const listDirectory = (args, env) => {
+  const root = resolveAllowed(args.path, env);
+  const depth = Math.max(1, Math.min(args.depth || 2, 5));
+  return { ok: true, path: root, depth, entries: walk(root, { depth }) };
+};
+
+const getFileInfo = (args, env) => {
+  const target = resolveAllowed(args.path, env);
+  const stat = fs.statSync(target);
+  return {
+    ok: true,
+    path: target,
+    type: stat.isDirectory() ? 'directory' : 'file',
+    size: stat.size,
+    createdAt: stat.birthtime.toISOString(),
+    modifiedAt: stat.mtime.toISOString(),
+    lineCount: stat.isFile() ? readUtf8(target).split(/\r?\n/).length : null
+  };
+};
+
+const readFile = (args, env) => {
+  const file = resolveAllowed(args.path, env);
+  const lines = readUtf8(file).split(/\r?\n/);
+  const offset = Number.isInteger(args.offset) ? args.offset : 0;
+  const length = Number.isInteger(args.length) ? args.length : 200;
+  const start = offset < 0 ? Math.max(lines.length + offset, 0) : Math.max(offset, 0);
+  const slice = lines.slice(start, start + length);
+  return { ok: true, path: file, totalLines: lines.length, offset: start, length: slice.length, content: numbered(slice, start) };
+};
+
+const globFiles = (args, env) => {
+  const root = resolveAllowed(args.path, env);
+  const rx = wildcard(args.pattern || '*');
+  const max = Math.max(1, Math.min(args.maxResults || 200, 1000));
+  const files = walk(root, { filesOnly: true })
+    .filter((item) => rx.test(path.basename(item.path)) || rx.test(item.relativePath))
+    .slice(0, max);
+  return { ok: true, path: root, pattern: args.pattern, files };
+};
+
+const grepFiles = (args, env) => {
+  const root = resolveAllowed(args.path, env);
+  const max = Math.max(1, Math.min(args.maxResults || 200, 1000));
+  const rx = args.literal ? null : new RegExp(String(args.pattern), 'i');
+  const fileRx = args.filePattern ? wildcard(args.filePattern) : null;
+  const matches = [];
+  for (const file of walk(root, { filesOnly: true })) {
+    if (fileRx && !fileRx.test(path.basename(file.path)) && !fileRx.test(file.relativePath)) continue;
+    let text;
+    try { text = readUtf8(file.path); } catch { continue; }
+    const lines = text.split(/\r?\n/);
+    for (let index = 0; index < lines.length; index += 1) {
+      const line = lines[index];
+      const hit = args.literal ? line.includes(String(args.pattern)) : rx.test(line);
+      if (!hit) continue;
+      matches.push({ path: file.path, relativePath: file.relativePath, line: index + 1, text: line });
+      if (matches.length >= max) return { ok: true, path: root, pattern: args.pattern, matches };
+    }
+  }
+  return { ok: true, path: root, pattern: args.pattern, matches };
+};
+
+const handlers = { listDirectory, getFileInfo, readFile, globFiles, grepFiles };
+
+exports.execute = (tool, args = {}, env = process.env) => {
+  const cleanTool = String(tool || '').replace(/^command\./, '');
+  const handler = handlers[cleanTool];
+  if (!handler) throw err('UNKNOWN_AGENT_TOOL', 'unknown or unsafe agent tool: ' + tool);
+  return handler(args, env);
+};
+
+exports._private = { rootsFor, resolveAllowed, wildcard };