@miruzero/zero-agent 0.3.3 → 0.3.5

package/src/capabilities.js

@@ -1,94 +1,123 @@
-'use strict';
-
-const crypto = require('node:crypto');
-const fs = require('node:fs');
-const path = require('node:path');
-const localTools = require('./local-tools');
-
-const defaultMcpRoot = () => path.resolve(__dirname, '../..');
-const mcpRoot = (env = process.env) => path.resolve(env.ZERO_MCP_ROOT || defaultMcpRoot());
-const providersDir = (env = process.env) => path.join(mcpRoot(env), 'providers');
-
-const readManifest = (file) => {
-  try {
-    return JSON.parse(fs.readFileSync(file, 'utf8'));
-  } catch (error) {
-    return { error: error.message };
-  }
-};
-
-const manifestProviders = (env = process.env) => {
-  const dir = providersDir(env);
-  if (!fs.existsSync(dir)) return [];
-  return fs.readdirSync(dir, { withFileTypes: true })
-    .filter((item) => item.isDirectory())
-    .map((item) => {
-      const root = path.join(dir, item.name);
-      const manifestFile = path.join(root, 'provider.json');
-      const manifest = fs.existsSync(manifestFile) ? readManifest(manifestFile) : {};
-      return {
-        name: item.name,
-        type: manifest.type || 'unknown',
-        description: manifest.description || '',
-        providerRoot: root,
-        manifestFile,
-        manifestError: manifest.error || null,
-        module: manifest.module || null,
-        command: manifest.command || null,
-        args: manifest.args || []
-      };
-    });
-};
-
-const safeInternalTools = (provider) => {
-  if (!provider.module) return [];
-  const modulePath = provider.module.replaceAll('{providerRoot}', provider.providerRoot.replace(/\\/g, '/'));
-  const resolved = path.resolve(modulePath);
-  try {
-    const runtime = require(resolved);
-    if (typeof runtime.listTools !== 'function') return [];
-    return runtime.listTools({}).map((tool) => ({
-      name: tool.name,
-      description: tool.description || '',
-      inputSchema: tool.inputSchema || null
-    }));
-  } catch (error) {
-    return [{ name: '__scan_error__', description: error.message, inputSchema: null }];
-  }
-};
-const builtInLocalProvider = () => ({
-  name: 'zero-agent-local',
-  type: 'internal',
-  description: 'Built-in safe local filesystem tools exposed by zero-agent.',
-  status: 'present',
-  tools: localTools.listTools(),
-  tool_count: localTools.listTools().length
+'use strict';
+
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const path = require('node:path');
+const localTools = require('./local-tools');
+const command = require('./command');
+const zero = require('./zero-runtime');
+
+const defaultMcpRoot = () => path.resolve(__dirname, '../..');
+const mcpRoot = (env = process.env) => path.resolve(env.ZERO_MCP_ROOT || defaultMcpRoot());
+const providersDir = (env = process.env) => path.join(mcpRoot(env), 'providers');
+
+const readManifest = (file) => {
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch (error) {
+    return { error: error.message };
+  }
+};
+
+const manifestProviders = (env = process.env) => {
+  const dir = providersDir(env);
+  if (!fs.existsSync(dir)) return [];
+  return fs.readdirSync(dir, { withFileTypes: true })
+    .filter((item) => item.isDirectory())
+    .map((item) => {
+      const root = path.join(dir, item.name);
+      const manifestFile = path.join(root, 'provider.json');
+      const manifest = fs.existsSync(manifestFile) ? readManifest(manifestFile) : {};
+      return {
+        name: item.name,
+        type: manifest.type || 'unknown',
+        description: manifest.description || '',
+        providerRoot: root,
+        manifestFile,
+        manifestError: manifest.error || null,
+        module: manifest.module || null,
+        command: manifest.command || null,
+        args: manifest.args || []
+      };
+    });
+};
+
+const safeInternalTools = (provider) => {
+  if (!provider.module) return [];
+  const modulePath = provider.module.replaceAll('{providerRoot}', provider.providerRoot.replace(/\\/g, '/'));
+  const resolved = path.resolve(modulePath);
+  try {
+    const runtime = require(resolved);
+    if (typeof runtime.listTools !== 'function') return [];
+    return runtime.listTools({}).map((tool) => ({
+      name: tool.name,
+      description: tool.description || '',
+      inputSchema: tool.inputSchema || null
+    }));
+  } catch (error) {
+    return [{ name: '__scan_error__', description: error.message, inputSchema: null }];
+  }
+};
+const publicCommandTool = (tool) => ({
+  name: tool.name,
+  description: tool.description || '',
+  canonicalName: tool.name,
+  category: tool.category,
+  function: tool.function,
+  aliases: tool.aliases || [],
+  inputSchema: tool.inputSchema || null
 });
 
-const buildCapabilities = (env = process.env) => {
-  const providers = [builtInLocalProvider(), ...manifestProviders(env).map((provider) => {
-    const tools = provider.type === 'internal' ? safeInternalTools(provider) : [];
-    return {
-      name: provider.name,
-      type: provider.type,
-      description: provider.description,
-      status: provider.manifestError ? 'invalid' : 'present',
-      tools,
-      tool_count: tools.length,
-      mcp_stdio_live_scan: provider.type === 'mcp-stdio' ? false : undefined
-    };
-  })];
-  const payload = {
-    agent_version: require('../package.json').version,
-    mcp_root: mcpRoot(env),
-    providers
+const builtInLocalProvider = () => {
+  const tools = command.listTools().map(publicCommandTool);
+  return {
+    name: 'zero-agent-command',
+    type: 'internal',
+    description: 'Built-in safe command tools exposed by zero-agent.',
+    status: 'present',
+    tools,
+    tool_count: tools.length
   };
-  payload.capability_hash = crypto
-    .createHash('sha256')
-    .update(JSON.stringify(payload.providers))
-    .digest('hex');
-  return payload;
-};
-
-const capabilities = { mcpRoot, providersDir, manifestProviders, buildCapabilities };
-Object.assign(exports, capabilities);
+};
+
+const buildCapabilities = (env = process.env) => {
+  const providers = [builtInLocalProvider(), ...manifestProviders(env).map((provider) => {
+    const tools = provider.type === 'internal' ? safeInternalTools(provider) : [];
+    return {
+      name: provider.name,
+      type: provider.type,
+      description: provider.description,
+      status: provider.manifestError ? 'invalid' : 'present',
+      tools,
+      tool_count: tools.length,
+      mcp_stdio_live_scan: provider.type === 'mcp-stdio' ? false : undefined
+    };
+  })];
+  const agentVersion = require('../package.json').version;
+  const categories = Array.from(new Set(command.listTools().map((tool) => `${tool.provider}.${tool.category}`))).sort();
+  const adapters = ['native'];
+  const payload = {
+    agentVersion,
+    agent_version: agentVersion,
+    contractVersion: zero.contract.version,
+    platform: process.platform,
+    architecture: process.arch,
+    categories,
+    adapters,
+    mcp_root: mcpRoot(env),
+    providers
+  };
+  const fingerprint = {
+    contractVersion: payload.contractVersion,
+    platform: payload.platform,
+    architecture: payload.architecture,
+    categories: payload.categories,
+    adapters: payload.adapters,
+    providers: payload.providers
+  };
+  payload.capability_hash = crypto.createHash('sha256').update(JSON.stringify(fingerprint)).digest('hex');
+  return payload;
+};
+
+const capabilities = { mcpRoot, providersDir, manifestProviders, buildCapabilities };
+Object.assign(exports, capabilities);

package/src/cli.js

@@ -51,8 +51,10 @@ const ensureLocalBootstrap = async (parsed, 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);
+  const prepared = autostart.isPrepared(env)
+    ? { ...autostart.paths(env), ok: true, reused: true }
+    : autostart.prepare({ interval: autostartInterval(parsed) }, env);
+  console.log('autoSetup=' + (prepared.reused ? 'REUSED' : 'OK') + ' launcher=' + prepared.launcherFile);
   if (parsed.code && (!device || !device.device_id)) {
     const paired = await agent.pairDevice({
       name: parsed.name || device?.name,
@@ -87,7 +89,11 @@ const runSetup = async (parsed, env) => {
   console.log('Zero Agent Setup');
   console.log('server=' + server);
   console.log('name=' + (name || os.hostname()));
-  runGlobalInstall(parsed, env);
+  const installed = runGlobalInstall(parsed, env);
+  if (!installed.skipped && !installed.ok) {
+    console.error('setup=FAILED global installation did not complete');
+    return 70;
+  }
   const init = agent.initDevice({ name, server }, env);
   console.log('init=OK file=' + init.file);
   const prepared = autostart.prepare({ interval: autostartInterval(parsed) }, env);
@@ -136,6 +142,21 @@ const runStartOnce = async (env) => {
   return { heartbeat, capability, task };
 };
 
+const runSafeStartCycle = async (env, runOnce = runStartOnce) => {
+  try {
+    return { ok: true, result: await runOnce(env) };
+  } catch (error) {
+    return {
+      ok: false,
+      reconnect: true,
+      error: {
+        code: error.code || error.cause?.code || 'AGENT_CONNECTION_ERROR',
+        message: error.message || String(error)
+      }
+    };
+  }
+};
+
 const printStartBanner = (env) => {
   const device = config.loadDevice(env);
   console.log('🚀 Starting Zero Agent...');
@@ -145,26 +166,38 @@ const printStartBanner = (env) => {
   console.log('🌐 Server: ' + (device?.server || 'https://zero.miru.work'));
 };
 
-const printLoopResult = (result) => {
+const loopResultEvent = (result) => {
   if (!result || result.code === 'NOT_PAIRED') {
-    console.log('❌ Device not paired: run zero-agent pair first');
-    return;
+    return { level: 'error', text: '❌ Device not paired: run zero-agent pair first' };
   }
   const hb = result.heartbeat || {};
   const cap = result.capability || {};
+  const task = result.task?.task || null;
+  const healthy = Boolean(hb.ok) && Boolean(cap.ok);
+  if (healthy && !task) return null;
+
   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)),
-    capabilities: okMark(Boolean(cap.ok)),
-    status: device?.status || null,
-    name: device?.name || null,
-    host: device?.host || null,
-    providers: device?.provider_count ?? null,
-    last_seen: device?.last_seen || null,
-    task: taskState
-  }));
+  return {
+    level: healthy ? 'info' : 'error',
+    text: JSON.stringify({
+      at: new Date().toISOString(),
+      heartbeat: okMark(Boolean(hb.ok)),
+      capabilities: okMark(Boolean(cap.ok)),
+      status: device?.status || null,
+      name: device?.name || null,
+      host: device?.host || null,
+      providers: device?.provider_count ?? null,
+      last_seen: device?.last_seen || null,
+      task: task ? (task.task_id + ':' + (task.status || 'done')) : 'none'
+    })
+  };
+};
+
+const printLoopResult = (result) => {
+  const event = loopResultEvent(result);
+  if (!event) return;
+  if (event.level === 'error') console.error(event.text);
+  else console.log(event.text);
 };
 
 async function run(argv = [], env = process.env) {
@@ -225,8 +258,17 @@ async function run(argv = [], env = process.env) {
     console.log('⏱️  Heartbeat interval: ' + interval + 'ms');
     console.log('🟢 Device ready; press Ctrl+C to stop');
     while (true) {
-      const result = await runStartOnce(env);
-      printLoopResult(result);
+      const cycle = await runSafeStartCycle(env);
+      if (cycle.ok) {
+        printLoopResult(cycle.result);
+      } else {
+        console.error(JSON.stringify({
+          at: new Date().toISOString(),
+          heartbeat: 'FAIL',
+          reconnect: 'WAIT',
+          error: cycle.error
+        }));
+      }
       await new Promise((resolve) => setTimeout(resolve, interval));
     }
   }
@@ -235,4 +277,4 @@ async function run(argv = [], env = process.env) {
   return 64;
 }
 
-module.exports = { run, usage, status, doctor };
+module.exports = { run, usage, status, doctor, runSafeStartCycle, loopResultEvent };

package/src/command/filesystem/append-file.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const zero = require('../../zero-runtime');
+const pathPolicy = require('./path-policy');
+
+const descriptor = zero.descriptor.validate({
+  name: 'zero.command.filesystem.appendFile',
+  aliases: ['zero.command.appendFile'],
+  description: 'Append UTF-8 text content to a file inside allowed roots.',
+  capability: 'filesystem.write',
+  risk: 'write',
+  execution: 'target',
+  adapters: ['native'],
+  inputSchema: {
+    type: 'object',
+    properties: { path: { type: 'string' }, content: { type: 'string' } },
+    required: ['path', 'content'],
+    additionalProperties: false
+  }
+});
+
+const appendFile = (args = {}, context = {}) => {
+  const file = pathPolicy.resolveAllowed(args.path, context);
+  const data = String(args.content ?? '');
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.appendFileSync(file, data, 'utf8');
+  return { ok: true, path: file, mode: 'append', bytes: Buffer.byteLength(data) };
+};
+
+const appendFileModule = { descriptor, appendFile };
+Object.assign(exports, appendFileModule);

package/src/command/filesystem/copy-directory.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const fs = require('node:fs');
+const zero = require('../../zero-runtime');
+const pathPolicy = require('./path-policy');
+
+const descriptor = zero.descriptor.validate({
+  name: 'zero.command.filesystem.copyDirectory',
+  aliases: ['zero.command.copyDirectory'],
+  description: 'Copy a directory recursively inside allowed roots.',
+  capability: 'filesystem.write',
+  risk: 'write',
+  execution: 'target',
+  adapters: ['native'],
+  inputSchema: {
+    type: 'object',
+    properties: { source: { type: 'string' }, destination: { type: 'string' }, overwrite: { type: 'boolean', default: false } },
+    required: ['source', 'destination'],
+    additionalProperties: false
+  }
+});
+
+const fail = (code, message) => Object.assign(new Error(message), { code });
+const copyDirectory = (args = {}, context = {}) => {
+  const source = pathPolicy.resolveAllowed(args.source, context);
+  const destination = pathPolicy.resolveAllowed(args.destination, context);
+  if (!fs.statSync(source).isDirectory()) throw fail('NOT_A_DIRECTORY', 'source is not a directory');
+  fs.cpSync(source, destination, { recursive: true, force: args.overwrite === true, errorOnExist: args.overwrite !== true });
+  return { ok: true, source, destination };
+};
+
+const copyDirectoryModule = { descriptor, copyDirectory };
+Object.assign(exports, copyDirectoryModule);

package/src/command/filesystem/copy-file.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const zero = require('../../zero-runtime');
+const pathPolicy = require('./path-policy');
+
+const descriptor = zero.descriptor.validate({
+  name: 'zero.command.filesystem.copyFile',
+  aliases: ['zero.command.copyFile'],
+  description: 'Copy one file inside allowed roots.',
+  capability: 'filesystem.write',
+  risk: 'write',
+  execution: 'target',
+  adapters: ['native'],
+  inputSchema: {
+    type: 'object',
+    properties: { source: { type: 'string' }, destination: { type: 'string' } },
+    required: ['source', 'destination'],
+    additionalProperties: false
+  }
+});
+
+const copyFile = (args = {}, context = {}) => {
+  const source = pathPolicy.resolveAllowed(args.source, context);
+  const destination = pathPolicy.resolveAllowed(args.destination, context);
+  fs.mkdirSync(path.dirname(destination), { recursive: true });
+  fs.copyFileSync(source, destination);
+  return { ok: true, source, destination };
+};
+
+const copyFileModule = { descriptor, copyFile };
+Object.assign(exports, copyFileModule);

package/src/command/filesystem/create-directory.js

@@ -0,0 +1,30 @@
+'use strict';
+
+const fs = require('node:fs');
+const zero = require('../../zero-runtime');
+const pathPolicy = require('./path-policy');
+
+const descriptor = zero.descriptor.validate({
+  name: 'zero.command.filesystem.createDirectory',
+  aliases: ['zero.command.createDirectory'],
+  description: 'Create a directory recursively inside allowed roots.',
+  capability: 'filesystem.write',
+  risk: 'write',
+  execution: 'target',
+  adapters: ['native'],
+  inputSchema: {
+    type: 'object',
+    properties: { path: { type: 'string' } },
+    required: ['path'],
+    additionalProperties: false
+  }
+});
+
+const createDirectory = (args = {}, context = {}) => {
+  const dir = pathPolicy.resolveAllowed(args.path, context);
+  fs.mkdirSync(dir, { recursive: true });
+  return { ok: true, path: dir, created: fs.existsSync(dir) && fs.statSync(dir).isDirectory() };
+};
+
+const createDirectoryModule = { descriptor, createDirectory };
+Object.assign(exports, createDirectoryModule);

package/src/command/filesystem/create-file.js

@@ -0,0 +1,35 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const zero = require('../../zero-runtime');
+const pathPolicy = require('./path-policy');
+
+const descriptor = zero.descriptor.validate({
+  name: 'zero.command.filesystem.createFile',
+  aliases: ['zero.command.createFile'],
+  description: 'Create a UTF-8 text file inside allowed roots.',
+  capability: 'filesystem.write',
+  risk: 'write',
+  execution: 'target',
+  adapters: ['native'],
+  inputSchema: {
+    type: 'object',
+    properties: { path: { type: 'string' }, content: { type: 'string', default: '' }, overwrite: { type: 'boolean', default: false } },
+    required: ['path'],
+    additionalProperties: false
+  }
+});
+
+const fail = (code, message) => Object.assign(new Error(message), { code });
+const createFile = (args = {}, context = {}) => {
+  const file = pathPolicy.resolveAllowed(args.path, context);
+  if (fs.existsSync(file) && args.overwrite !== true) throw fail('FILE_EXISTS', 'file already exists');
+  const data = String(args.content ?? '');
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, data, 'utf8');
+  return { ok: true, path: file, created: true, bytes: Buffer.byteLength(data) };
+};
+
+const createFileModule = { descriptor, createFile };
+Object.assign(exports, createFileModule);

package/src/command/filesystem/delete-directory.js

@@ -0,0 +1,27 @@
+'use strict';
+
+const fs = require('node:fs');
+const zero = require('../../zero-runtime');
+const pathPolicy = require('./path-policy');
+
+const descriptor = zero.descriptor.validate({
+  name: 'zero.command.filesystem.deleteDirectory',
+  aliases: ['zero.command.deleteDirectory'],
+  description: 'Delete a directory inside allowed roots.',
+  capability: 'filesystem.write',
+  risk: 'write',
+  execution: 'target',
+  adapters: ['native'],
+  inputSchema: { type: 'object', properties: { path: { type: 'string' }, recursive: { type: 'boolean', default: false } }, required: ['path'], additionalProperties: false }
+});
+
+const fail = (code, message) => Object.assign(new Error(message), { code });
+const deleteDirectory = (args = {}, context = {}) => {
+  const dir = pathPolicy.resolveAllowed(args.path, context);
+  if (!fs.statSync(dir).isDirectory()) throw fail('NOT_A_DIRECTORY', 'path is not a directory');
+  fs.rmSync(dir, { recursive: args.recursive === true, force: false });
+  return { ok: true, path: dir, deleted: true };
+};
+
+const deleteDirectoryModule = { descriptor, deleteDirectory };
+Object.assign(exports, deleteDirectoryModule);

package/src/command/filesystem/delete-file.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const fs = require('node:fs');
+const zero = require('../../zero-runtime');
+const pathPolicy = require('./path-policy');
+
+const descriptor = zero.descriptor.validate({
+  name: 'zero.command.filesystem.deleteFile',
+  aliases: ['zero.command.deleteFile'],
+  description: 'Delete one file inside allowed roots. Directories are rejected.',
+  capability: 'filesystem.write',
+  risk: 'write',
+  execution: 'target',
+  adapters: ['native'],
+  inputSchema: {
+    type: 'object',
+    properties: { path: { type: 'string' } },
+    required: ['path'],
+    additionalProperties: false
+  }
+});
+
+const fail = (code, message) => Object.assign(new Error(message), { code });
+const deleteFile = (args = {}, context = {}) => {
+  const file = pathPolicy.resolveAllowed(args.path, context);
+  if (!fs.existsSync(file)) throw fail('FILE_NOT_FOUND', 'file does not exist');
+  if (!fs.statSync(file).isFile()) throw fail('NOT_A_FILE', 'deleteFile supports files only');
+  fs.unlinkSync(file);
+  return { ok: true, path: file, deleted: true };
+};
+
+const deleteFileModule = { descriptor, deleteFile };
+Object.assign(exports, deleteFileModule);

package/src/command/filesystem/exists.js

@@ -0,0 +1,29 @@
+'use strict';
+
+const fs = require('node:fs');
+const zero = require('../../zero-runtime');
+const pathPolicy = require('./path-policy');
+
+const descriptor = zero.descriptor.validate({
+  name: 'zero.command.filesystem.exists',
+  aliases: ['zero.command.exists'],
+  description: 'Check whether a path exists inside allowed roots.',
+  capability: 'filesystem.read',
+  risk: 'read',
+  execution: 'target',
+  adapters: ['native'],
+  inputSchema: {
+    type: 'object',
+    properties: { path: { type: 'string' } },
+    required: ['path'],
+    additionalProperties: false
+  }
+});
+
+const exists = (args = {}, context = {}) => {
+  const pathValue = pathPolicy.resolveAllowed(args.path, context);
+  return { ok: true, path: pathValue, exists: fs.existsSync(pathValue) };
+};
+
+const existsModule = { descriptor, exists };
+Object.assign(exports, existsModule);

package/src/command/filesystem/get-file-info.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const fs = require('node:fs');
+const zero = require('../../zero-runtime');
+const pathPolicy = require('./path-policy');
+const text = require('./text');
+
+const descriptor = zero.descriptor.validate({
+  name: 'zero.command.filesystem.getFileInfo',
+  aliases: ['zero.command.getFileInfo'],
+  description: 'Get metadata for a file or directory inside allowed roots.',
+  capability: 'filesystem.read',
+  risk: 'read',
+  execution: 'target',
+  adapters: ['native'],
+  inputSchema: {
+    type: 'object',
+    properties: { path: { type: 'string' } },
+    required: ['path'],
+    additionalProperties: false
+  }
+});
+
+const getFileInfo = (args = {}, context = {}) => {
+  const target = pathPolicy.resolveAllowed(args.path, context);
+  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() ? text.readUtf8(target).split(/\r?\n/).length : null
+  };
+};
+
+const getFileInfoModule = { descriptor, getFileInfo };
+Object.assign(exports, getFileInfoModule);