@miruzero/zero-agent 0.3.4 → 0.3.6

package/src/capabilities.js

@@ -1,94 +1,160 @@
-'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 builtInChatGptAuthProvider = () => {
+  const tools = [
+    {
+      name: 'status',
+      description: 'Return redacted ChatGPT auth fixture status from the local zero-agent host.',
+      canonicalName: 'zero.chatgpt.auth.status',
+      category: 'auth',
+      function: 'status',
+      aliases: ['chatgpt.auth.status'],
+      inputSchema: { type: 'object', properties: {}, additionalProperties: false }
+    },
+    {
+      name: 'import',
+      description: 'Write ChatGPT auth fixture input to the local zero-agent host. Returns redacted metadata only.',
+      canonicalName: 'zero.chatgpt.auth.import',
+      category: 'auth',
+      function: 'import',
+      aliases: ['chatgpt.auth.import'],
+      inputSchema: {
+        type: 'object',
+        properties: { input: { type: 'string' } },
+        required: ['input'],
+        additionalProperties: false
+      }
+    }
+  ];
+  return {
+    name: 'chatgpt',
+    type: 'internal',
+    description: 'Built-in ChatGPT auth setup support exposed by zero-agent.',
+    status: 'present',
+    tools,
+    tool_count: tools.length
+  };
+};
+
+const buildCapabilities = (env = process.env) => {
+  const providers = [builtInLocalProvider(), builtInChatGptAuthProvider(), ...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/chatgpt-auth.js

@@ -0,0 +1,121 @@
+'use strict';
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const crypto = require('node:crypto');
+
+const provider = 'chatgpt';
+
+const defaultMcpHome = (env = process.env) => env.ZERO_MCP_HOME || path.join(os.homedir(), '.zero_mcp');
+const defaultAuthFile = (env = process.env) => path.join(defaultMcpHome(env), 'chatgpt', 'auth.json');
+const resolveAuthFile = (env = process.env) => env.ZERO_CHATGPT_AUTH_FILE || defaultAuthFile(env);
+
+const sha256 = (value) => crypto.createHash('sha256').update(String(value)).digest('hex');
+const nowIso = () => new Date().toISOString();
+
+const parseMaybeJson = (text) => {
+  try {
+    return { ok: true, value: JSON.parse(text) };
+  } catch (error) {
+    return { ok: false, error: error.message || String(error) };
+  }
+};
+
+const ensureInput = (input) => {
+  const text = String(input || '').trim();
+  if (!text) {
+    const error = new Error('input is required');
+    error.code = 'BAD_AUTH_INPUT';
+    throw error;
+  }
+  return text;
+};
+const status = ({ env = process.env } = {}) => {
+  const file = resolveAuthFile(env);
+  if (!fs.existsSync(file)) {
+    return {
+      ok: true,
+      provider,
+      auth: { present: false, status: 'missing', redacted: true },
+      file
+    };
+  }
+  const stat = fs.statSync(file);
+  let storedStatus = 'imported-test-fixture';
+  try {
+    const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+    storedStatus = parsed.status || storedStatus;
+  } catch {}
+  return {
+    ok: true,
+    provider,
+    auth: {
+      present: true,
+      status: storedStatus,
+      redacted: true,
+      updated_at: stat.mtime.toISOString(),
+      size: stat.size
+    },
+    file
+  };
+};
+
+const importAuth = ({ input, env = process.env, source = 'zero-agent' } = {}) => {
+  const text = ensureInput(input);
+  const parsed = parseMaybeJson(text);
+  const timestamp = nowIso();
+  const payload = {
+    provider,
+    mode: 'dev-fixture',
+    status: 'imported-test-fixture',
+    source,
+    created_at: timestamp,
+    updated_at: timestamp,
+    validation: {
+      session: 'not-run',
+      sentinel: 'not-run',
+      capability_probe: 'not-run'
+    },
+    security: {
+      raw_secret_return_allowed: false,
+      logs_allowed: false,
+      rotation_required: false
+    },
+    imported: {
+      format: parsed.ok ? 'json' : 'text',
+      parse_error: parsed.ok ? null : parsed.error,
+      sha256: sha256(text),
+      byte_length: Buffer.byteLength(text, 'utf8')
+    },
+    session: parsed.ok ? parsed.value : { raw_text: text }
+  };
+  const file = resolveAuthFile(env);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, JSON.stringify(payload, null, 2) + '\n', { encoding: 'utf8', mode: 0o600 });
+  return {
+    ok: true,
+    provider,
+    file,
+    auth: {
+      present: true,
+      status: payload.status,
+      mode: payload.mode,
+      redacted: true,
+      updated_at: payload.updated_at,
+      input_format: payload.imported.format,
+      input_sha256: payload.imported.sha256,
+      byte_length: payload.imported.byte_length
+    }
+  };
+};
+
+const chatgptAuth = {
+  defaultMcpHome,
+  defaultAuthFile,
+  resolveAuthFile,
+  status,
+  importAuth
+};
+
+Object.assign(exports, chatgptAuth);

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