@miruzero/zero-agent 0.3.5 → 0.3.7

package/src/shared-zero/catalog.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const zero = require('./index');
+const fail = (code, message) => Object.assign(new Error(message), { code });
+
+exports.create = (items = []) => {
+  const canonical = new Map();
+  const aliases = new Map();
+  for (const item of items) {
+    const normalized = zero.descriptor.validate(item);
+    if (canonical.has(normalized.name)) throw fail('DUPLICATE_TOOL_ID', 'duplicate tool id: ' + normalized.name);
+    canonical.set(normalized.name, normalized);
+  }
+  for (const item of canonical.values()) {
+    for (const alias of item.aliases) {
+      if (canonical.has(alias) || aliases.has(alias)) throw fail('DUPLICATE_TOOL_ALIAS', 'duplicate tool alias: ' + alias);
+      aliases.set(alias, item.name);
+    }
+  }
+  const resolve = (name) => {
+    const canonicalName = canonical.has(name) ? name : aliases.get(name);
+    if (!canonicalName) throw fail('UNKNOWN_TOOL', 'unknown Zero tool: ' + name);
+    return canonical.get(canonicalName);
+  };
+  return {
+    resolve,
+    get: (name) => canonical.get(name) || null,
+    list: ({ provider, category } = {}) => [...canonical.values()]
+      .filter((item) => !provider || item.provider === provider)
+      .filter((item) => !category || item.category === category)
+      .sort((a, b) => a.name.localeCompare(b.name))
+  };
+};

package/src/shared-zero/contract.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const VERSION = '1.0.0';
+const versionMajor = (value) => {
+  const match = /^(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/.exec(String(value || ''));
+  return match ? Number(match[1]) : null;
+};
+const mismatch = (actual) => Object.assign(
+  new Error(`Zero contract major mismatch: expected ${VERSION}, got ${actual}`),
+  { code: 'CONTRACT_VERSION_MISMATCH', expected: VERSION, actual }
+);
+
+exports.version = VERSION;
+exports.isCompatible = (other) => versionMajor(other) === versionMajor(VERSION);
+exports.assertCompatible = (other) => {
+  if (!exports.isCompatible(other)) throw mismatch(other);
+  return true;
+};

package/src/shared-zero/descriptor.js

@@ -0,0 +1,25 @@
+'use strict';
+
+const zero = require('./index');
+const EXECUTION = new Set(['core', 'target', 'either']);
+const bad = (code, message) => Object.assign(new Error(message), { code });
+
+exports.validate = (input) => {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) {
+    throw bad('INVALID_TOOL_DESCRIPTOR', 'tool descriptor must be an object');
+  }
+  const identity = zero.toolId.parse(input.name);
+  if (input.execution && !EXECUTION.has(input.execution)) {
+    throw bad('INVALID_TOOL_DESCRIPTOR', 'invalid execution mode: ' + input.execution);
+  }
+  const aliases = input.aliases === undefined ? [] : input.aliases;
+  if (!Array.isArray(aliases) || aliases.some((item) => typeof item !== 'string' || !item.trim())) {
+    throw bad('INVALID_TOOL_DESCRIPTOR', 'aliases must be non-empty strings');
+  }
+  return {
+    ...input,
+    ...identity,
+    aliases: [...new Set(aliases)],
+    inputSchema: input.inputSchema || { type: 'object', properties: {}, additionalProperties: false }
+  };
+};

package/src/shared-zero/errors.js

@@ -0,0 +1,12 @@
+'use strict';
+
+exports.normalize = (error, context = {}) => ({
+  ok: false,
+  error: {
+    code: error?.code || 'ZERO_ERROR',
+    message: error?.message || String(error || 'Zero error'),
+    ...(Number.isInteger(error?.status) ? { status: error.status } : {}),
+    retryable: error?.retryable === true,
+    ...(context.target !== undefined ? { target: context.target } : {})
+  }
+});

package/src/shared-zero/index.js

@@ -0,0 +1,9 @@
+'use strict';
+
+exports.contract = require('./contract');
+exports.toolId = require('./tool-id');
+exports.descriptor = require('./descriptor');
+exports.catalog = require('./catalog');
+exports.errors = require('./errors');
+exports.runtime = require('./runtime');
+exports.target = require('./target');

package/src/shared-zero/runtime.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const bad = (message) => Object.assign(new Error(message), { code: 'INVALID_RUNTIME' });
+
+exports.create = ({ catalog, invoke } = {}) => {
+  if (!catalog || typeof catalog.list !== 'function' || typeof catalog.resolve !== 'function') {
+    throw bad('runtime requires a catalog');
+  }
+  if (typeof invoke !== 'function') throw bad('runtime requires invoke(descriptor,args,context)');
+  return {
+    list: (filter = {}) => catalog.list(filter),
+    call: (name, args = {}, context = {}) => invoke(catalog.resolve(name), args, context)
+  };
+};

package/src/shared-zero/target.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const invalid = () => Object.assign(new Error('invalid Zero target'), { code: 'INVALID_TARGET' });
+
+exports.normalize = (value) => {
+  if (value === undefined || value === null || value === '' || value === 'local' || value === 'core') {
+    return { kind: 'local', name: 'local' };
+  }
+  if (typeof value === 'string') return { kind: 'device', name: value };
+  if (!value || typeof value !== 'object' || Array.isArray(value)) throw invalid();
+  if (value.kind === 'local') return { kind: 'local', name: 'local' };
+  if (value.device_id) return { kind: 'device', device_id: String(value.device_id) };
+  if (value.name) {
+    if (value.name === 'local' || value.name === 'core') return { kind: 'local', name: 'local' };
+    return { kind: 'device', name: String(value.name) };
+  }
+  throw invalid();
+};
+exports.isRemote = (value) => exports.normalize(value).kind === 'device';

package/src/shared-zero/tool-id.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const SEGMENT = /^[A-Za-z][A-Za-z0-9_-]*$/;
+const invalid = (value) => Object.assign(
+  new Error('invalid Zero tool id: ' + String(value)),
+  { code: 'INVALID_TOOL_ID' }
+);
+const assertSegment = (value) => {
+  if (!SEGMENT.test(String(value || ''))) throw invalid(value);
+  return String(value);
+};
+
+exports.format = ({ provider, category, function: functionName } = {}) => {
+  const p = assertSegment(provider);
+  const c = assertSegment(category);
+  const f = assertSegment(functionName);
+  return `zero.${p}.${c}.${f}`;
+};
+exports.parse = (name) => {
+  const parts = String(name || '').split('.');
+  if (parts.length !== 4 || parts[0] !== 'zero') throw invalid(name);
+  const provider = assertSegment(parts[1]);
+  const category = assertSegment(parts[2]);
+  const functionName = assertSegment(parts[3]);
+  return { provider, category, function: functionName, name: `zero.${provider}.${category}.${functionName}` };
+};

package/src/storage-roots.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const zero = require('./zero');
+
+
+exports.discover = (system = {}) => {
+    const platform = system.platform || process.platform;
+    const exists = system.exists || zero.fs.existsSync;
+    const candidates = platform === 'win32'
+      ? Array.from({ length: 26 }, (_, index) => String.fromCharCode(65 + index) + ':\\')
+      : ['/'];
+
+    return candidates.filter((item) => {
+      try {
+        return exists(item);
+      } catch {
+        return false;
+      }
+    });
+};
+

package/src/zero-runtime.js

@@ -1,13 +1,3 @@
 'use strict';
 
-const load = () => {
-  try {
-    return require('@miruzero/zero');
-  } catch (error) {
-    if (error?.code !== 'MODULE_NOT_FOUND' || !String(error.message).includes('@miruzero/zero')) throw error;
-    return require('../../../packages/zero');
-  }
-};
-
-const zero = load();
-Object.assign(exports, zero);
+module.exports = require('./zero');

package/src/zero.js

@@ -0,0 +1,78 @@
+'use strict';
+
+const loadShared = () => require('./shared-zero');
+
+const mount = (name, loader) => Object.defineProperty(exports, name, {
+  enumerable: true,
+  configurable: true,
+  get() {
+    const value = loader();
+    Object.defineProperty(exports, name, { enumerable: true, configurable: false, value });
+    return value;
+  }
+});
+
+const shared = loadShared();
+exports.contract = shared.contract;
+exports.toolId = shared.toolId;
+exports.descriptor = shared.descriptor;
+exports.catalog = shared.catalog;
+exports.errors = shared.errors;
+exports.runtime = shared.runtime;
+exports.target = shared.target;
+exports.fs = require('node:fs');
+exports.path = require('node:path');
+exports.os = require('node:os');
+exports.crypto = require('node:crypto');
+exports.net = require('node:net');
+exports.nodeHttp = require('node:http');
+exports.childProcess = require('node:child_process');
+exports.pkg = require('../package.json');
+
+mount('classicLevel', () => require('classic-level'));
+mount('args', () => require('./args'));
+mount('config', () => require('./config'));
+mount('autostart', () => require('./autostart'));
+mount('capabilities', () => require('./capabilities'));
+mount('agent', () => require('./agent'));
+mount('instance', () => require('./instance'));
+mount('localServer', () => require('./local-server'));
+mount('http', () => require('./http'));
+mount('localTools', () => require('./local-tools'));
+mount('command', () => require('./command'));
+mount('chatgptAuth', () => require('./chatgpt-auth'));
+mount('chatgptSession', () => require('./chatgpt-session'));
+mount('chatgptSessionExchange', () => require('./chatgpt-session-exchange'));
+mount('devicePaths', () => require('./device-paths'));
+mount('identityState', () => require('./identity-state'));
+mount('storageRoots', () => require('./storage-roots'));
+mount('enrollmentClient', () => require('./enrollment-client'));
+mount('commandFilesystem', () => require('./command/filesystem'));
+mount('commandPath', () => require('./command/path'));
+mount('commandExec', () => require('./command/exec'));
+mount('pathPolicy', () => require('./command/filesystem/path-policy'));
+mount('commandText', () => require('./command/filesystem/text'));
+mount('commandWalk', () => require('./command/filesystem/walk'));
+mount('readFileTool', () => require('./command/filesystem/read-file'));
+mount('moveFileTool', () => require('./command/filesystem/move-file'));
+
+mount('appendFileTool', () => require('./command/filesystem/append-file'));
+mount('copyDirectoryTool', () => require('./command/filesystem/copy-directory'));
+mount('copyFileTool', () => require('./command/filesystem/copy-file'));
+mount('createDirectoryTool', () => require('./command/filesystem/create-directory'));
+mount('createFileTool', () => require('./command/filesystem/create-file'));
+mount('deleteDirectoryTool', () => require('./command/filesystem/delete-directory'));
+mount('deleteFileTool', () => require('./command/filesystem/delete-file'));
+mount('existsTool', () => require('./command/filesystem/exists'));
+mount('getFileInfoTool', () => require('./command/filesystem/get-file-info'));
+mount('globFilesTool', () => require('./command/filesystem/glob-files'));
+mount('grepFilesTool', () => require('./command/filesystem/grep-files'));
+mount('hashFileTool', () => require('./command/filesystem/hash-file'));
+mount('listDirectoryTool', () => require('./command/filesystem/list-directory'));
+mount('moveDirectoryTool', () => require('./command/filesystem/move-directory'));
+mount('readFilesTool', () => require('./command/filesystem/read-files'));
+mount('renameFileTool', () => require('./command/filesystem/rename-file'));
+mount('replaceFileTool', () => require('./command/filesystem/replace-file'));
+mount('touchFileTool', () => require('./command/filesystem/touch-file'));
+mount('truncateFileTool', () => require('./command/filesystem/truncate-file'));
+mount('writeFileTool', () => require('./command/filesystem/write-file'));