@miruzero/zero-agent 0.3.6 → 0.3.8

package/src/cli.js

@@ -1,15 +1,9 @@
 'use strict';
 
-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');
+const zero = require('./zero');
 
-const usage = () => `Zero Agent
+
+exports.usage = () => `Zero Agent
 
 Usage:
   zero-agent setup [--server <url>] [--name <device>] [--code <pairing-code>] [--no-global]
@@ -28,7 +22,7 @@ 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 autostartInterval = (parsed) => Number(parsed.interval || zero.autostart.DEFAULT_INTERVAL);
 
 const printAutostartInfo = (prepared) => {
   console.log('Autostart file');
@@ -39,24 +33,24 @@ const printAutostartInfo = (prepared) => {
   console.log(prepared.launcherFile);
   console.log('ตั้งค่า:');
   console.log('ZERO_TRACE=1');
-  console.log('ZERO_AGENT_ROOTS=' + prepared.roots);
+  console.log(prepared.roots ? ('ZERO_AGENT_ROOTS=' + prepared.roots) : 'storageRoots=auto');
   console.log('interval=' + prepared.interval + 'ms');
   console.log('log=' + prepared.logFile);
 };
 
 const ensureLocalBootstrap = async (parsed, env) => {
-  let device = config.loadDevice(env);
+  let device = zero.config.loadDevice(env);
   if (!device) {
-    const init = agent.initDevice({ name: parsed.name, server: parsed.server || DEFAULT_SERVER }, env);
+    const init = zero.agent.initDevice({ name: parsed.name, server: parsed.server || DEFAULT_SERVER }, env);
     console.log('autoInit=OK file=' + init.file);
-    device = config.loadDevice(env);
+    device = zero.config.loadDevice(env);
   }
-  const prepared = autostart.isPrepared(env)
-    ? { ...autostart.paths(env), ok: true, reused: true }
-    : autostart.prepare({ interval: autostartInterval(parsed) }, env);
+  const prepared = zero.autostart.isPrepared(env)
+    ? { ...zero.autostart.paths(env), ok: true, reused: true }
+    : zero.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({
+    const paired = await zero.agent.pairDevice({
       name: parsed.name || device?.name,
       server: parsed.server || device?.server || DEFAULT_SERVER,
       code: parsed.code
@@ -71,10 +65,10 @@ const runGlobalInstall = (parsed, env) => {
     console.log('globalInstall=SKIPPED');
     return { skipped: true };
   }
-  const spec = parsed.package || (pkg.name + '@' + pkg.version);
+  const spec = parsed.package || (zero.pkg.name + '@' + zero.pkg.version);
   const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
   console.log('globalInstall=START ' + spec);
-  const result = childProcess.spawnSync(npmCmd, ['install', '-g', spec], { stdio: 'inherit', env });
+  const result = zero.childProcess.spawnSync(npmCmd, ['install', '-g', spec], { stdio: 'inherit', env });
   if (result.status === 0) {
     console.log('globalInstall=OK');
     return { ok: true };
@@ -88,23 +82,23 @@ const runSetup = async (parsed, env) => {
   const name = parsed.name || undefined;
   console.log('Zero Agent Setup');
   console.log('server=' + server);
-  console.log('name=' + (name || os.hostname()));
+  console.log('name=' + (name || zero.os.hostname()));
   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);
+  const init = zero.agent.initDevice({ name, server }, env);
   console.log('init=OK file=' + init.file);
-  const prepared = autostart.prepare({ interval: autostartInterval(parsed) }, env);
+  const prepared = zero.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);
-    console.log('Or:   npx ' + pkg.name + '@latest setup --server ' + server + ' --name ' + init.device.name + ' --code ZERO-XXXXXX');
+    console.log('Or:   npx ' + zero.pkg.name + '@latest setup --server ' + server + ' --name ' + init.device.name + ' --code ZERO-XXXXXX');
     return 0;
   }
-  const paired = await agent.pairDevice({ name: init.device.name, server, code: parsed.code }, env);
+  const paired = await zero.agent.pairDevice({ name: init.device.name, server, code: parsed.code }, env);
   console.log('pair=OK file=' + paired.file);
   printJson(paired.device);
   const heartbeat = await runStartOnce(env);
@@ -115,19 +109,19 @@ const runSetup = async (parsed, env) => {
 };
 
 
-const status = (env) => {
-  const device = config.loadDevice(env);
-  if (!device) return { paired: false, home: config.agentHome(env) };
-  return { paired: Boolean(device.device_id), home: config.agentHome(env), device: config.redactedDevice(device) };
+exports.status = (env) => {
+  const device = zero.config.loadDevice(env);
+  if (!device) return { paired: false, home: zero.config.agentHome(env) };
+  return { paired: Boolean(device.device_id), home: zero.config.agentHome(env), device: zero.config.redactedDevice(device) };
 };
 
-const doctor = (env) => {
-  const capability = caps.buildCapabilities(env);
+exports.doctor = (env) => {
+  const capability = zero.capabilities.buildCapabilities(env);
   return {
     ok: true,
     node: process.version,
     platform: process.platform,
-    agent_home: config.agentHome(env),
+    agent_home: zero.config.agentHome(env),
     mcp_root: capability.mcp_root,
     providers: capability.providers.length,
     capability_hash: capability.capability_hash
@@ -135,14 +129,13 @@ const doctor = (env) => {
 };
 
 const runStartOnce = async (env) => {
-  const heartbeat = await agent.heartbeatOnce(env);
+  const heartbeat = await zero.agent.heartbeatOnce(env);
   if (!heartbeat.ok && heartbeat.code === 'NOT_PAIRED') return heartbeat;
-  const capability = await agent.syncCapabilitiesOnce(env);
-  const task = await agent.pollTaskOnce(env);
-  return { heartbeat, capability, task };
+  const capability = await zero.agent.syncCapabilitiesOnce(env);
+  return { heartbeat, capability };
 };
 
-const runSafeStartCycle = async (env, runOnce = runStartOnce) => {
+exports.runSafeStartCycle = async (env, runOnce = runStartOnce) => {
   try {
     return { ok: true, result: await runOnce(env) };
   } catch (error) {
@@ -158,15 +151,18 @@ const runSafeStartCycle = async (env, runOnce = runStartOnce) => {
 };
 
 const printStartBanner = (env) => {
-  const device = config.loadDevice(env);
+  const device = zero.config.loadDevice(env);
+  let chatgptAuth = 'unknown';
+  try { chatgptAuth = zero.chatgptAuth.status({ env }).auth?.status || 'unknown'; } catch {}
   console.log('🚀 Starting Zero Agent...');
-  console.log('🔁 Session restored: ' + (device?.device_id ? 'yes' : 'no'));
+  console.log('🔁 Device pairing restored: ' + (device?.device_id ? 'yes' : 'no'));
+  console.log('🔐 ChatGPT Auth: ' + chatgptAuth);
   console.log('👤 Device Name: ' + (device?.name || '(unpaired)'));
   console.log('🆔 Device ID: ' + (device?.device_id || '(not paired)'));
   console.log('🌐 Server: ' + (device?.server || 'https://zero.miru.work'));
 };
 
-const loopResultEvent = (result) => {
+exports.loopResultEvent = (result) => {
   if (!result || result.code === 'NOT_PAIRED') {
     return { level: 'error', text: '❌ Device not paired: run zero-agent pair first' };
   }
@@ -183,6 +179,10 @@ const loopResultEvent = (result) => {
       at: new Date().toISOString(),
       heartbeat: okMark(Boolean(hb.ok)),
       capabilities: okMark(Boolean(cap.ok)),
+      heartbeat_http_status: hb.status ?? null,
+      heartbeat_error_code: hb.body?.error?.code || hb.code || null,
+      capabilities_http_status: cap.status ?? null,
+      capabilities_error_code: cap.body?.error?.code || cap.code || null,
       status: device?.status || null,
       name: device?.name || null,
       host: device?.host || null,
@@ -194,48 +194,76 @@ const loopResultEvent = (result) => {
 };
 
 const printLoopResult = (result) => {
-  const event = loopResultEvent(result);
+  const event = exports.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) {
-  const parsed = parseArgs(argv);
+exports.connectionTransition = (previous = 'connecting', cycle = {}, env = process.env) => {
+  const result = cycle.result || {};
+  const hb = result.heartbeat || {};
+  const cap = result.capability || {};
+  const healthy = Boolean(cycle.ok) && Boolean(hb.ok) && Boolean(cap.ok);
+  const device = cap.body?.device || hb.body?.device || zero.config.loadDevice(env) || {};
+  const lastSeen = hb.body?.device?.last_seen || cap.body?.device?.last_seen || null;
+  const server = zero.config.loadDevice(env)?.server || env.ZERO_SERVER_URL || DEFAULT_SERVER;
+
+  if (healthy) {
+    if (previous === 'connected') return { state: 'connected', level: 'info', text: null };
+    const verb = previous === 'disconnected' ? 'Reconnected' : 'Connected';
+    return {
+      state: 'connected',
+      level: 'info',
+      text: `✅ ${verb} to Zero Core\n   Status: Online\n   Device: ${device.name || device.host || '(unnamed)'}\n   Core: ${server}\n   Heartbeat: OK (HTTP ${hb.status ?? 'OK'})\n   Capabilities: Synced (HTTP ${cap.status ?? 'OK'})\n   Last seen: ${lastSeen || 'now'}\n   Agent version: ${zero.pkg.version}\n   Contract: ${cap.body?.device?.contract_version || hb.body?.device?.contract_version || zero.contract.version}\n   Compatibility: ${String(cap.body?.device?.compatibility?.status || hb.body?.device?.compatibility?.status || 'unknown').toUpperCase()}`
+    };
+  }
+
+  if (previous === 'disconnected') return { state: 'disconnected', level: 'error', text: null };
+  const status = hb.status != null ? `heartbeat HTTP ${hb.status}` : cap.status != null ? `capabilities HTTP ${cap.status}` : (cycle.error?.code || 'connection error');
+  return {
+    state: 'disconnected',
+    level: 'error',
+    text: `🔴 Disconnected from Zero Core — ${server}\n↻ Reconnecting automatically (${status})`
+  };
+};
+
+exports.run = async (argv = [], env = process.env) => {
+  const parsed = zero.args.parseArgs(argv);
   const command = parsed._[0] || 'help';
   if (command === 'help' || parsed.help) {
-    console.log(usage());
+    console.log(exports.usage());
     return 0;
   }
   if (command === 'setup') {
     return runSetup(parsed, env);
   }
   if (command === 'init') {
-    const result = agent.initDevice({ name: parsed.name, server: parsed.server }, env);
+    const result = zero.agent.initDevice({ name: parsed.name, server: parsed.server }, env);
     console.log(`init=OK file=${result.file}`);
     printJson(result.device);
     return 0;
   }
   if (command === 'pair') {
-    const result = await agent.pairDevice({ name: parsed.name, server: parsed.server, code: parsed.code }, env);
+    const result = await zero.agent.pairDevice({ name: parsed.name, server: parsed.server, code: parsed.code }, env);
     console.log(`pair=OK file=${result.file}`);
     printJson(result.device);
     return 0;
   }
   if (command === 'status') {
-    printJson(status(env));
+    printJson(exports.status(env));
     return 0;
   }
   if (command === 'devices') {
-    printJson(await agent.listDevices(env));
+    printJson(await zero.agent.listDevices(env));
     return 0;
   }
   if (command === 'doctor') {
-    printJson(doctor(env));
+    printJson(exports.doctor(env));
     return 0;
   }
   if (command === 'providers') {
-    printJson(caps.manifestProviders(env).map((item) => ({
+    printJson(zero.capabilities.manifestProviders(env).map((item) => ({
       name: item.name,
       type: item.type,
       description: item.description,
@@ -244,37 +272,46 @@ async function run(argv = [], env = process.env) {
     return 0;
   }
   if (command === 'tools' || command === 'capabilities') {
-    printJson(caps.buildCapabilities(env));
+    printJson(zero.capabilities.buildCapabilities(env));
     return 0;
   }
   if (command === 'start') {
     await ensureLocalBootstrap(parsed, env);
+    const ownership = await zero.instance.acquire(env);
+    console.log(JSON.stringify({ event: 'zero.agent.zero.instance.active', pid: ownership.pid, replaced_pid: ownership.replaced_pid }));
+    const local = await zero.localServer.startLocalServer({ env });
+    console.log(JSON.stringify({ event: 'zero.agent.local.ready', host: '127.0.0.1', port: local.port }));
     if (parsed.once) {
-      printJson(await runStartOnce(env));
+      try { printJson(await runStartOnce(env)); }
+      finally {
+        await new Promise((resolve) => local.server.close(resolve));
+        ownership.release();
+      }
       return 0;
     }
-    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');
-    while (true) {
-      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
-        }));
+    console.log('🔌 Connecting to Zero Core...');
+    const cycle = await exports.runSafeStartCycle(env);
+    const transition = exports.connectionTransition('connecting', cycle, env);
+    if (transition.text) {
+      if (transition.level === 'error') console.error(transition.text);
+      else console.log(transition.text);
+    }
+    if (transition.state !== 'connected') return 69;
+    console.log('📡 Task channel: listening for Core events');
+    for (;;) {
+      try {
+        const stream = await zero.agent.listenTaskStreamOnce(env);
+        if (!stream.ok) throw Object.assign(new Error('task stream unavailable'), { code: `HTTP_${stream.status || 0}` });
+        console.error('🔴 Task channel closed by Zero Core');
+      } catch (error) {
+        console.error(`🔴 Task channel disconnected (${error.code || error.message || 'connection error'})`);
       }
-      await new Promise((resolve) => setTimeout(resolve, interval));
+      console.log('↻ Reconnecting task channel after disconnect event...');
+      await new Promise((resolve) => setTimeout(resolve, 1000));
     }
   }
   console.error('unknown command: ' + command);
-  console.error(usage());
+  console.error(exports.usage());
   return 64;
-}
-
-module.exports = { run, usage, status, doctor, runSafeStartCycle, loopResultEvent };
+};

package/src/command/exec.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const zero = require('../zero');
+
+
+exports.execDescriptor = zero.descriptor.validate({
+  name: 'zero.command.exec.run',
+  aliases: ['zero.command.exec'],
+  description: 'Execute an allowed local command through the agent process adapter.',
+  capability: 'process.execute',
+  risk: 'execute',
+  execution: 'target',
+  adapters: ['native'],
+  inputSchema: {
+    type: 'object',
+    properties: {
+      command: { type: 'string' },
+      args: { type: 'array', items: { type: 'string' } }
+    },
+    required: ['command'],
+    additionalProperties: false
+  }
+});
+
+exports.exec = async (input = {}) => new Promise((resolve, reject) => {
+  zero.childProcess.execFile(input.command, Array.isArray(input.args) ? input.args : [], { shell: false }, (error, stdout, stderr) => {
+    if (error) {
+      reject(error);
+      return;
+    }
+    resolve({ ok: true, stdout, stderr });
+  });
+});
+

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

@@ -1,11 +1,9 @@
 'use strict';
 
-const fs = require('node:fs');
-const path = require('node:path');
-const zero = require('../../zero-runtime');
-const pathPolicy = require('./path-policy');
+const zero = require('../../zero');
 
-const descriptor = zero.descriptor.validate({
+
+exports.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.',
@@ -21,13 +19,10 @@ const descriptor = zero.descriptor.validate({
   }
 });
 
-const appendFile = (args = {}, context = {}) => {
-  const file = pathPolicy.resolveAllowed(args.path, context);
+exports.appendFile = (args = {}, context = {}) => {
+  const file = zero.pathPolicy.resolveAllowed(args.path, context);
   const data = String(args.content ?? '');
-  fs.mkdirSync(path.dirname(file), { recursive: true });
-  fs.appendFileSync(file, data, 'utf8');
+  zero.fs.mkdirSync(zero.path.dirname(file), { recursive: true });
+  zero.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

@@ -1,10 +1,9 @@
 'use strict';
 
-const fs = require('node:fs');
-const zero = require('../../zero-runtime');
-const pathPolicy = require('./path-policy');
+const zero = require('../../zero');
 
-const descriptor = zero.descriptor.validate({
+
+exports.descriptor = zero.descriptor.validate({
   name: 'zero.command.filesystem.copyDirectory',
   aliases: ['zero.command.copyDirectory'],
   description: 'Copy a directory recursively inside allowed roots.',
@@ -21,13 +20,10 @@ const descriptor = zero.descriptor.validate({
 });
 
 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 });
+exports.copyDirectory = (args = {}, context = {}) => {
+  const source = zero.pathPolicy.resolveAllowed(args.source, context);
+  const destination = zero.pathPolicy.resolveAllowed(args.destination, context);
+  if (!zero.fs.statSync(source).isDirectory()) throw fail('NOT_A_DIRECTORY', 'source is not a directory');
+  zero.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

@@ -1,11 +1,9 @@
 'use strict';
 
-const fs = require('node:fs');
-const path = require('node:path');
-const zero = require('../../zero-runtime');
-const pathPolicy = require('./path-policy');
+const zero = require('../../zero');
 
-const descriptor = zero.descriptor.validate({
+
+exports.descriptor = zero.descriptor.validate({
   name: 'zero.command.filesystem.copyFile',
   aliases: ['zero.command.copyFile'],
   description: 'Copy one file inside allowed roots.',
@@ -21,13 +19,10 @@ const descriptor = zero.descriptor.validate({
   }
 });
 
-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);
+exports.copyFile = (args = {}, context = {}) => {
+  const source = zero.pathPolicy.resolveAllowed(args.source, context);
+  const destination = zero.pathPolicy.resolveAllowed(args.destination, context);
+  zero.fs.mkdirSync(zero.path.dirname(destination), { recursive: true });
+  zero.fs.copyFileSync(source, destination);
   return { ok: true, source, destination };
 };
-
-const copyFileModule = { descriptor, copyFile };
-Object.assign(exports, copyFileModule);

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

@@ -1,10 +1,9 @@
 'use strict';
 
-const fs = require('node:fs');
-const zero = require('../../zero-runtime');
-const pathPolicy = require('./path-policy');
+const zero = require('../../zero');
 
-const descriptor = zero.descriptor.validate({
+
+exports.descriptor = zero.descriptor.validate({
   name: 'zero.command.filesystem.createDirectory',
   aliases: ['zero.command.createDirectory'],
   description: 'Create a directory recursively inside allowed roots.',
@@ -20,11 +19,8 @@ const descriptor = zero.descriptor.validate({
   }
 });
 
-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() };
+exports.createDirectory = (args = {}, context = {}) => {
+  const dir = zero.pathPolicy.resolveAllowed(args.path, context);
+  zero.fs.mkdirSync(dir, { recursive: true });
+  return { ok: true, path: dir, created: zero.fs.existsSync(dir) && zero.fs.statSync(dir).isDirectory() };
 };
-
-const createDirectoryModule = { descriptor, createDirectory };
-Object.assign(exports, createDirectoryModule);

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

@@ -1,11 +1,9 @@
 'use strict';
 
-const fs = require('node:fs');
-const path = require('node:path');
-const zero = require('../../zero-runtime');
-const pathPolicy = require('./path-policy');
+const zero = require('../../zero');
 
-const descriptor = zero.descriptor.validate({
+
+exports.descriptor = zero.descriptor.validate({
   name: 'zero.command.filesystem.createFile',
   aliases: ['zero.command.createFile'],
   description: 'Create a UTF-8 text file inside allowed roots.',
@@ -22,14 +20,11 @@ const descriptor = zero.descriptor.validate({
 });
 
 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');
+exports.createFile = (args = {}, context = {}) => {
+  const file = zero.pathPolicy.resolveAllowed(args.path, context);
+  if (zero.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');
+  zero.fs.mkdirSync(zero.path.dirname(file), { recursive: true });
+  zero.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

@@ -1,10 +1,9 @@
 'use strict';
 
-const fs = require('node:fs');
-const zero = require('../../zero-runtime');
-const pathPolicy = require('./path-policy');
+const zero = require('../../zero');
 
-const descriptor = zero.descriptor.validate({
+
+exports.descriptor = zero.descriptor.validate({
   name: 'zero.command.filesystem.deleteDirectory',
   aliases: ['zero.command.deleteDirectory'],
   description: 'Delete a directory inside allowed roots.',
@@ -16,12 +15,9 @@ const descriptor = zero.descriptor.validate({
 });
 
 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 });
+exports.deleteDirectory = (args = {}, context = {}) => {
+  const dir = zero.pathPolicy.resolveAllowed(args.path, context);
+  if (!zero.fs.statSync(dir).isDirectory()) throw fail('NOT_A_DIRECTORY', 'path is not a directory');
+  zero.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

@@ -1,10 +1,9 @@
 'use strict';
 
-const fs = require('node:fs');
-const zero = require('../../zero-runtime');
-const pathPolicy = require('./path-policy');
+const zero = require('../../zero');
 
-const descriptor = zero.descriptor.validate({
+
+exports.descriptor = zero.descriptor.validate({
   name: 'zero.command.filesystem.deleteFile',
   aliases: ['zero.command.deleteFile'],
   description: 'Delete one file inside allowed roots. Directories are rejected.',
@@ -21,13 +20,10 @@ const descriptor = zero.descriptor.validate({
 });
 
 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);
+exports.deleteFile = (args = {}, context = {}) => {
+  const file = zero.pathPolicy.resolveAllowed(args.path, context);
+  if (!zero.fs.existsSync(file)) throw fail('FILE_NOT_FOUND', 'file does not exist');
+  if (!zero.fs.statSync(file).isFile()) throw fail('NOT_A_FILE', 'deleteFile supports files only');
+  zero.fs.unlinkSync(file);
   return { ok: true, path: file, deleted: true };
 };
-
-const deleteFileModule = { descriptor, deleteFile };
-Object.assign(exports, deleteFileModule);

package/src/command/filesystem/exists.js

@@ -1,10 +1,9 @@
 'use strict';
 
-const fs = require('node:fs');
-const zero = require('../../zero-runtime');
-const pathPolicy = require('./path-policy');
+const zero = require('../../zero');
 
-const descriptor = zero.descriptor.validate({
+
+exports.descriptor = zero.descriptor.validate({
   name: 'zero.command.filesystem.exists',
   aliases: ['zero.command.exists'],
   description: 'Check whether a path exists inside allowed roots.',
@@ -20,10 +19,7 @@ const descriptor = zero.descriptor.validate({
   }
 });
 
-const exists = (args = {}, context = {}) => {
-  const pathValue = pathPolicy.resolveAllowed(args.path, context);
-  return { ok: true, path: pathValue, exists: fs.existsSync(pathValue) };
+exports.exists = (args = {}, context = {}) => {
+  const pathValue = zero.pathPolicy.resolveAllowed(args.path, context);
+  return { ok: true, path: pathValue, exists: zero.fs.existsSync(pathValue) };
 };
-
-const existsModule = { descriptor, exists };
-Object.assign(exports, existsModule);