@miruzero/zero-agent 0.2.0 → 0.3.1

package/README.md

@@ -1,12 +1,34 @@
-# Zero Agent
+# Zero Agent
 
 Local worker agent for Zero MCP multi-device execution.
 
+## One-command start
+
+For a normal user, start with npm/npx and let the agent create local files automatically:
+
+```powershell
+npx @miruzero/zero-agent@latest start --name TON --code ZERO-XXXX
+```
+
+Or inside this package:
+
+```powershell
+npm start
+```
+
+On first start, the agent creates:
+
+```text
+%USERPROFILE%\.zero-agent\device.json
+%USERPROFILE%\.zero-agent\start-zero-agent.cmd
+%APPDATA%\Microsoft\Windows\Start Menu\Programs\Startup\MiruZeroAgent.vbs
+%USERPROFILE%\.zero-agent\logs\zero-agent.log
+```
+
 ## Commands
 
 ```powershell
-zero-agent init --server https://zero.miru.work
-zero-agent pair --server https://zero.miru.work --code ZERO-XXXX
+zero-agent setup --server https://zero.miru.work --name TON --code ZERO-XXXX
 zero-agent start --once
 zero-agent start
 zero-agent status
@@ -33,4 +55,4 @@ Device tokens are local secrets and must not be printed or committed.
 ```powershell
 npm test
 npm pack --dry-run
-```
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miruzero/zero-agent",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "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/autostart.js

@@ -0,0 +1,81 @@
+'use strict';
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const config = require('./config');
+
+const DEFAULT_INTERVAL = 30000;
+
+const q = (value) => '"' + String(value).replace(/"/g, '""') + '"';
+const winPath = (value) => String(value).replace(/\//g, '\\');
+
+const defaultRoots = (env = process.env) => {
+  if (env.ZERO_AGENT_ROOTS) return env.ZERO_AGENT_ROOTS;
+  const home = env.USERPROFILE || os.homedir();
+  return [
+    path.join(home, 'Desktop', 'zero'),
+    path.join(home, 'Downloads')
+  ].join(path.delimiter);
+};
+
+const startupDir = (env = process.env) => {
+  const appData = env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming');
+  return path.join(appData, 'Microsoft', 'Windows', 'Start Menu', 'Programs', 'Startup');
+};
+
+const paths = (env = process.env) => {
+  const home = config.agentHome(env);
+  return {
+    home,
+    launcherFile: path.join(home, 'start-zero-agent.cmd'),
+    startupFile: path.join(startupDir(env), 'MiruZeroAgent.vbs'),
+    logFile: path.join(config.logDir(env), 'zero-agent.log')
+  };
+};
+
+const launcherContent = ({ interval = DEFAULT_INTERVAL, roots, logFile }, env = process.env) => {
+  const home = config.agentHome(env);
+  return [
+    '@echo off',
+    'setlocal',
+    'set "ZERO_TRACE=1"',
+    'set "ZERO_AGENT_HOME=' + winPath(home) + '"',
+    'set "ZERO_AGENT_ROOTS=' + winPath(roots) + '"',
+    '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 zero-agent >> ' + q(winPath(logFile)),
+    'zero-agent start --interval %ZERO_AGENT_INTERVAL% >> ' + q(winPath(logFile)) + ' 2>&1',
+    ''
+  ].join('\r\n');
+};
+
+const vbsContent = (launcherFile) => [
+  'Set WshShell = CreateObject("WScript.Shell")',
+  'WshShell.Run Chr(34) & "' + winPath(launcherFile).replace(/"/g, '""') + '" & Chr(34), 0, False',
+  ''
+].join('\r\n');
+
+const prepare = (options = {}, env = process.env) => {
+  config.ensureDirs(env);
+  const p = paths(env);
+  const interval = Number(options.interval || env.ZERO_AGENT_INTERVAL || DEFAULT_INTERVAL);
+  const roots = options.roots || defaultRoots(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.startupFile, vbsContent(p.launcherFile), 'utf8');
+  return { ok: true, interval, roots, ...p };
+};
+
+const autostart = {
+  DEFAULT_INTERVAL,
+  defaultRoots,
+  paths,
+  prepare
+};
+
+Object.assign(exports, autostart);
+

package/src/cli.js

@@ -4,6 +4,7 @@ const childProcess = require('node:child_process');
 const os = require('node:os');
 const pkg = require('../package.json');
 const config = require('./config');
+const autostart = require('./autostart');
 const caps = require('./capabilities');
 const agent = require('./agent');
 const { parseArgs } = require('./args');
@@ -14,7 +15,7 @@ Usage:
   zero-agent setup [--server <url>] [--name <device>] [--code <pairing-code>] [--no-global]
   zero-agent init --server <url> [--name <device>]
   zero-agent pair --server <url> --code <pairing-code> [--name <device>]
-  zero-agent start [--once] [--interval <ms>]
+  zero-agent start [--once] [--interval <ms>] [--code <pairing-code>] [--name <device>]
   zero-agent status
   zero-agent devices
   zero-agent doctor
@@ -27,6 +28,42 @@ const printJson = (value) => console.log(JSON.stringify(value, null, 2));
 const okMark = (ok) => ok ? 'OK' : 'FAIL';
 const DEFAULT_SERVER = 'https://zero.miru.work';
 
+const autostartInterval = (parsed) => Number(parsed.interval || autostart.DEFAULT_INTERVAL);
+
+const printAutostartInfo = (prepared) => {
+  console.log('Autostart file');
+  console.log(prepared.startupFile);
+  console.log('ตัวนี้จะรันตอน user logon และเปิด:');
+  console.log(prepared.launcherFile);
+  console.log('Launcher');
+  console.log(prepared.launcherFile);
+  console.log('ตั้งค่า:');
+  console.log('ZERO_TRACE=1');
+  console.log('ZERO_AGENT_ROOTS=' + prepared.roots);
+  console.log('interval=' + prepared.interval + 'ms');
+  console.log('log=' + prepared.logFile);
+};
+
+const ensureLocalBootstrap = async (parsed, env) => {
+  let device = config.loadDevice(env);
+  if (!device) {
+    const init = agent.initDevice({ name: parsed.name, server: parsed.server || DEFAULT_SERVER }, env);
+    console.log('autoInit=OK file=' + init.file);
+    device = config.loadDevice(env);
+  }
+  const prepared = autostart.prepare({ interval: autostartInterval(parsed) }, env);
+  console.log('autoSetup=OK launcher=' + prepared.launcherFile);
+  if (parsed.code && (!device || !device.device_id)) {
+    const paired = await agent.pairDevice({
+      name: parsed.name || device?.name,
+      server: parsed.server || device?.server || DEFAULT_SERVER,
+      code: parsed.code
+    }, env);
+    console.log('autoPair=OK file=' + paired.file);
+  }
+  return prepared;
+};
+
 const runGlobalInstall = (parsed, env) => {
   if (parsed['no-global'] || env.ZERO_AGENT_SKIP_GLOBAL_INSTALL === '1') {
     console.log('globalInstall=SKIPPED');
@@ -53,6 +90,8 @@ const runSetup = async (parsed, env) => {
   runGlobalInstall(parsed, env);
   const init = agent.initDevice({ name, server }, env);
   console.log('init=OK file=' + init.file);
+  const prepared = autostart.prepare({ interval: autostartInterval(parsed) }, env);
+  printAutostartInfo(prepared);
   if (!parsed.code) {
     console.log('pairing=NEEDS_CODE');
     console.log('Next: zero-agent pair --server ' + server + ' --code ZERO-XXXXXX --name ' + init.device.name);
@@ -93,7 +132,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 +153,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)),
@@ -120,8 +161,9 @@ const printLoopResult = (result) => {
     status: device?.status || null,
     name: device?.name || null,
     host: device?.host || null,
-    providers: device?.provider_count || null,
-    last_seen: device?.last_seen || null
+    providers: device?.provider_count ?? null,
+    last_seen: device?.last_seen || null,
+    task: taskState
   }));
 };
 
@@ -173,11 +215,12 @@ async function run(argv = [], env = process.env) {
     return 0;
   }
   if (command === 'start') {
+    await ensureLocalBootstrap(parsed, env);
     if (parsed.once) {
       printJson(await runStartOnce(env));
       return 0;
     }
-    const interval = Number(parsed.interval || 10000);
+    const interval = Number(parsed.interval || autostart.DEFAULT_INTERVAL);
     printStartBanner(env);
     console.log('⏱️  Heartbeat interval: ' + interval + 'ms');
     console.log('🟢 Device ready; press Ctrl+C to stop');

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 };