@miruzero/zero-agent 0.3.5 → 0.3.7

package/README.md

@@ -1,6 +1,8 @@
 # Zero Agent
 
-Local worker agent for Zero MCP multi-device execution.
+`zero-agent` is the machine-local execution worker for Miruko Zero OS. It owns target-side execution, local identity/state, filesystem/path policy, capability reporting, and task completion back to Zero Core.
+
+It does not own the public MCP endpoint or global device registry authority. The package includes only the machine-local ChatGPT auth/session runtime required by its login flow.
 
 ## Quick start
 
@@ -8,14 +10,11 @@ Local worker agent for Zero MCP multi-device execution.
 npx @miruzero/zero-agent@latest start --once
 ```
 
-On first run, `start` creates local config, a launcher, and a Windows user-logon autostart file automatically.
-
-## Commands
+Commands exposed by the package include:
 
-```powershell
-zero-agent setup --name TON --code ZERO-XXXX
-zero-agent start --once
-zero-agent start
+```text
+zero-agent setup
+zero-agent start [--once]
 zero-agent status
 zero-agent doctor
 zero-agent providers
@@ -23,23 +22,33 @@ zero-agent tools
 zero-agent capabilities
 ```
 
-## Autostart
-
-Default state path:
+For source validation:
 
-```text
-%USERPROFILE%\.zero-agent\device.json
-%USERPROFILE%\.zero-agent\start-zero-agent.cmd
-%APPDATA%\Microsoft\Windows\Start Menu\Programs\Startup\MiruZeroAgent.vbs
+```powershell
+Set-Location M:\Zero_HOME\source\agent\zero-agent
+npm test
+npm run doctor
+npm pack --dry-run
 ```
+## Runtime ownership
 
-`setup` installs a stable global Zero Agent package by default. The generated launcher records the resolved Node executable and installed Zero Agent entrypoint, while the long-running agent retries transient connection failures instead of exiting.
+Zero Agent owns the machine-local capability boundary. It reports capabilities to Core and executes work only inside local policy/identity constraints.
 
-Device tokens are local secrets and must not be printed or committed.
+Shared Zero capabilities should be reached through the module’s Zero root rather than rebuilding dependency ownership in every file. Public capability paths stay stable while implementations may change behind them.
 
-## Package checks
+## ChatGPT boundary
 
-```powershell
-npm test
-npm pack --dry-run
-```
+Zero Agent owns the ChatGPT auth/session capability required by HOME under `src/chatgpt/`. `src/chatgpt-runtime.js` resolves this package-local implementation only; sibling ChatGPT projects are Supplier / R&D references, never runtime dependencies.
+
+The owner can reuse a valid HOME auth context or acquire one from the current machine's local ChatGPT session state. The machine-local handoff reads Chrome Local Storage as input, selects the active personal workspace when available, performs the HOME-owned direct session exchange, persists canonical state under the Agent home, and returns only redacted readiness to Core.
+
+There is no Puppeteer/Playwright/CDP browser launcher and no runtime require/import of `M:\Zero_ChatGPT`.
+
+## Local instance ownership
+
+A current Agent instance acquires local ownership before polling. Replacement/takeover behavior exists to prevent duplicate pollers for the same paired identity. Inspect current tests/source before relying on old PID/process notes.
+
+## Secrets
+
+Device tokens, machine auth material, ChatGPT session data, cookies and setup tickets are local secrets. Never print, commit, or return them in ordinary diagnostics. Report only redacted status/evidence.
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miruzero/zero-agent",
-  "version": "0.3.5",
+  "version": "0.3.7",
   "description": "MiruZero local worker agent for multi-device tool execution.",
   "type": "commonjs",
   "main": "src/index.js",
@@ -11,7 +11,7 @@
     "zero-agent": "bin/zero-agent.js"
   },
   "scripts": {
-    "test": "node --test",
+    "test": "node --test && node ../../ownership/verify.js",
     "start": "node bin/zero-agent.js start",
     "doctor": "node bin/zero-agent.js doctor"
   },
@@ -25,6 +25,9 @@
   },
   "license": "UNLICENSED",
   "dependencies": {
-    "@miruzero/zero": "0.1.0"
+    "classic-level": "^3.0.0"
+  },
+  "allowScripts": {
+    "classic-level@3.0.0": true
   }
 }

package/src/agent.js

@@ -1,158 +1,193 @@
-'use strict';
-
-const os = require('node:os');
-const config = require('./config');
-const caps = require('./capabilities');
-const http = require('./http');
-const localTools = require('./local-tools');
-const command = require('./command');
-const zero = require('./zero-runtime');
-
-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();
-  const device = {
-    name: name || host,
-    host,
-    server: server || 'https://zero.miru.work',
-    device_id: null,
-    status: 'initialized',
-    created_at: nowIso(),
-    updated_at: nowIso()
-  };
-  const file = config.saveDevice(device, env);
-  return { file, device: config.redactedDevice(device) };
-};
-
-const pairDevice = async ({ name, server, code }, env = process.env) => {
-  if (!server) throw Object.assign(new Error('server is required'), { exitCode: 64 });
-  if (!code) throw Object.assign(new Error('pairing code is required'), { exitCode: 64 });
-  const host = os.hostname();
-  const payload = { name: name || host, pairing_code: code, host };
-  const result = await http.requestJson(`${serverBase(server)}/devices/register`, {
-    method: 'POST',
-    body: payload
-  });
-  if (!result.ok) {
-    const error = new Error(`pair failed status=${result.status}`);
-    error.response = result.json;
-    throw error;
-  }
-  const device = {
-    name: payload.name,
-    host,
-    server,
-    device_id: result.json.device_id,
-    device_token: result.json.device_token,
-    status: 'paired',
-    paired_at: nowIso(),
-    updated_at: nowIso()
-  };
-  const file = config.saveDevice(device, env);
-  return { file, device: config.redactedDevice(device) };
-};
-
-const getPairedDevice = (env = process.env) => {
-  const device = config.loadDevice(env);
-  if (!device || !device.device_id || !device.device_token || !device.server) {
-    return null;
-  }
-  return device;
-};
-
-const heartbeatPayload = (device, env = process.env) => {
-  const capability = caps.buildCapabilities(env);
-  return {
-    name: device.name,
-    status: 'online',
-    last_seen: nowIso(),
-    capability_hash: capability.capability_hash,
-    provider_count: capability.providers.length
-  };
-};
-
-const heartbeatOnce = async (env = process.env) => {
-  const device = getPairedDevice(env);
-  if (!device) return { ok: false, code: 'NOT_PAIRED', message: 'run zero-agent pair first' };
-  const url = `${serverBase(device.server)}/devices/${encodeURIComponent(device.device_id)}/heartbeat`;
-  const result = await http.requestJson(url, {
-    method: 'POST',
-    token: device.device_token,
-    body: heartbeatPayload(device, env)
-  });
-  return { ok: result.ok, status: result.status, body: result.json };
-};
-
-const syncCapabilitiesOnce = async (env = process.env) => {
-  const device = getPairedDevice(env);
-  if (!device) return { ok: false, code: 'NOT_PAIRED' };
-  const url = `${serverBase(device.server)}/devices/${encodeURIComponent(device.device_id)}/capabilities`;
-  const result = await http.requestJson(url, {
-    method: 'POST',
-    token: device.device_token,
-    body: caps.buildCapabilities(env)
-  });
-  return { ok: result.ok, status: result.status, body: result.json };
-};
-
-
-const executeTask = (task = {}, env = process.env) => {
-  if (task.contractVersion) zero.contract.assertCompatible(task.contractVersion);
-  if (task.deadline && Date.parse(task.deadline) <= Date.now()) {
-    throw Object.assign(new Error('task deadline exceeded'), { code: 'TASK_DEADLINE_EXCEEDED', retryable: false });
-  }
-  const tool = String(task.tool || '');
-  if (tool.startsWith('zero.command.') || tool === 'readFile' || tool === 'command.readFile') {
-    try { return command.callTool(tool, task.arguments || {}, { env }); }
-    catch (error) {
-      if (error.code !== 'UNKNOWN_TOOL') throw error;
-    }
-  }
-  return localTools.execute(tool, task.arguments || {}, env);
-};
-
-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 http.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 = executeTask(task, env);
-    trace(env, 'agent.task.done', { task_id: task.task_id, ok: true, duration_ms: Date.now() - started });
-    const posted = await http.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 http.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 http.requestJson(`${serverBase(device?.server)}/devices`);
-  return { ok: result.ok, status: result.status, body: result.json };
-};
-const agent = {
-  initDevice, pairDevice, heartbeatPayload, heartbeatOnce, syncCapabilitiesOnce,
-  executeTask, pollTaskOnce, listDevices, getPairedDevice
-};
-
-Object.assign(exports, agent);
+'use strict';
+
+const zero = require('./zero');
+
+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 }));
+};
+
+exports.initDevice = ({ name, server }, env = process.env) => {
+  const host = zero.os.hostname();
+  const device = {
+    name: name || host,
+    host,
+    server: server || 'https://zero.miru.work',
+    device_id: null,
+    status: 'initialized',
+    created_at: nowIso(),
+    updated_at: nowIso()
+  };
+  const file = zero.config.saveDevice(device, env);
+  return { file, device: zero.config.redactedDevice(device) };
+};
+
+exports.pairDevice = async ({ name, server, code }, env = process.env) => {
+  if (!server) throw Object.assign(new Error('server is required'), { exitCode: 64 });
+  if (!code) throw Object.assign(new Error('pairing code is required'), { exitCode: 64 });
+  const host = zero.os.hostname();
+  const payload = { name: name || host, pairing_code: code, host };
+  const result = await zero.http.requestJson(`${serverBase(server)}/devices/register`, {
+    method: 'POST',
+    body: payload
+  });
+  if (!result.ok) {
+    const error = new Error(`pair failed status=${result.status}`);
+    error.response = result.json;
+    throw error;
+  }
+  const device = {
+    name: payload.name,
+    host,
+    server,
+    device_id: result.json.device_id,
+    device_token: result.json.device_token,
+    status: 'paired',
+    paired_at: nowIso(),
+    updated_at: nowIso()
+  };
+  const file = zero.config.saveDevice(device, env);
+  return { file, device: zero.config.redactedDevice(device) };
+};
+
+exports.getPairedDevice = (env = process.env) => {
+  const device = zero.config.loadDevice(env);
+  if (!device || !device.device_id || !device.device_token || !device.server) {
+    return null;
+  }
+  return device;
+};
+
+exports.heartbeatPayload = (device, env = process.env) => {
+  const capability = zero.capabilities.buildCapabilities(env);
+  return {
+    name: device.name,
+    status: 'online',
+    last_seen: nowIso(),
+    agentVersion: zero.pkg.version,
+    contractVersion: zero.contract.version,
+    platform: process.platform,
+    architecture: process.arch,
+    capability_hash: capability.capability_hash,
+    provider_count: capability.providers.length
+  };
+};
+
+exports.heartbeatOnce = async (env = process.env) => {
+  const device = exports.getPairedDevice(env);
+  if (!device) return { ok: false, code: 'NOT_PAIRED', message: 'run zero-agent pair first' };
+  const url = `${serverBase(device.server)}/devices/${encodeURIComponent(device.device_id)}/heartbeat`;
+  const result = await zero.http.requestJson(url, {
+    method: 'POST',
+    token: device.device_token,
+    body: exports.heartbeatPayload(device, env)
+  });
+  return { ok: result.ok, status: result.status, body: result.json };
+};
+
+exports.syncCapabilitiesOnce = async (env = process.env) => {
+  const device = exports.getPairedDevice(env);
+  if (!device) return { ok: false, code: 'NOT_PAIRED' };
+  const url = `${serverBase(device.server)}/devices/${encodeURIComponent(device.device_id)}/capabilities`;
+  const result = await zero.http.requestJson(url, {
+    method: 'POST',
+    token: device.device_token,
+    body: zero.capabilities.buildCapabilities(env)
+  });
+  return { ok: result.ok, status: result.status, body: result.json };
+};
+
+
+exports.executeTask = (task = {}, env = process.env) => {
+  if (task.contractVersion) zero.contract.assertCompatible(task.contractVersion);
+  if (task.deadline && Date.parse(task.deadline) <= Date.now()) {
+    throw Object.assign(new Error('task deadline exceeded'), { code: 'TASK_DEADLINE_EXCEEDED', retryable: false });
+  }
+  const tool = String(task.tool || '');
+  if (tool === 'zero.chatgpt.auth.check') {
+    const status = zero.chatgptAuth.status({ env }).auth || {};
+    const auth = ['valid', 'expired', 'missing', 'invalid'].includes(status.status) ? status.status : 'invalid';
+    return {
+      state: auth === 'valid' ? 'auth_valid' : 'auth_required',
+      runtime: 'ready',
+      auth,
+      redacted: true
+    };
+  }
+  if (tool === 'zero.device.paths.setAllowedRoots') {
+    return zero.devicePaths.saveAllowedRoots(task.arguments?.roots || [], env);
+  }
+  if (tool.startsWith('zero.command.') || tool === 'readFile' || tool === 'command.readFile') {
+    try { return zero.command.callTool(tool, task.arguments || {}, { env }); }
+    catch (error) {
+      if (error.code !== 'UNKNOWN_TOOL') throw error;
+    }
+  }
+  return zero.localTools.execute(tool, task.arguments || {}, env);
+};
+
+exports.executeTaskAsync = async (task = {}, env = process.env) => {
+  if (String(task.tool || '') !== 'zero.chatgpt.auth.ensure') return exports.executeTask(task, env);
+  if (task.contractVersion) zero.contract.assertCompatible(task.contractVersion);
+  if (task.deadline && Date.parse(task.deadline) <= Date.now()) {
+    throw Object.assign(new Error('task deadline exceeded'), { code: 'TASK_DEADLINE_EXCEEDED', retryable: false });
+  }
+  try {
+    await zero.chatgptAuth.ensure({ env });
+    return { state: 'auth_valid', runtime: 'ready', auth: 'valid', redacted: true };
+  } catch (error) {
+    const recoverable = new Set([
+      'AUTH_REQUIRED', 'CHATGPT_LOCAL_SESSION_NOT_FOUND', 'CHATGPT_LOCAL_SESSION_AMBIGUOUS',
+      'CHATGPT_SESSION_MARKER_MISSING', 'CHATGPT_SESSION_NOT_AUTHENTICATED',
+      'CHATGPT_SESSION_FETCH_FAILED', 'CHATGPT_SESSION_BOOTSTRAP_FAILED',
+      'CHATGPT_SESSION_BOOTSTRAP_COOKIE_MISSING', 'CHATGPT_SESSION_EXCHANGE_FAILED'
+    ]);
+    if (!recoverable.has(error?.code)) throw error;
+    const status = zero.chatgptAuth.status({ env }).auth || {};
+    const auth = ['expired', 'missing', 'invalid'].includes(status.status) ? status.status : 'missing';
+    return { state: 'auth_required', runtime: 'ready', auth, redacted: true };
+  }
+};
+exports.executeAndPostTask = async (task, device, env = process.env) => {
+  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 = await exports.executeTaskAsync(task, env);
+    trace(env, 'agent.task.done', { task_id: task.task_id, ok: true, duration_ms: Date.now() - started });
+    const posted = await zero.http.requestJson(resultUrl, { method: 'POST', token: device.device_token, body: { ok: true, result } });
+    return { ok: posted.ok, task: posted.json?.task || task, 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 zero.http.requestJson(resultUrl, { method: 'POST', token: device.device_token, body: payload });
+    return { ok: false, task: posted.json?.task || task, error: payload.error, posted: { status: posted.status, body: posted.json } };
+  }
+};
+
+exports.listenTaskStreamOnce = async (env = process.env, { signal } = {}) => {
+  const device = exports.getPairedDevice(env);
+  if (!device) return { ok: false, code: 'NOT_PAIRED' };
+  const streamUrl = serverBase(device.server) + '/devices/' + encodeURIComponent(device.device_id) + '/tasks/stream';
+  let lastTask = null;
+  const stream = await zero.http.consumeEventStream(streamUrl, {
+    token: device.device_token,
+    signal,
+    onEvent: async ({ event, data }) => {
+      if (event !== 'task') return;
+      const task = JSON.parse(data);
+      lastTask = await exports.executeAndPostTask(task, device, env);
+    }
+  });
+  return { ...stream, task: lastTask?.task || null, result: lastTask?.result || null };
+};
+
+exports.listDevices = async (env = process.env) => {
+  const device = zero.config.loadDevice(env);
+  const result = await zero.http.requestJson(`${serverBase(device?.server)}/devices`);
+  return { ok: result.ok, status: result.status, body: result.json };
+};

package/src/args.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const parseArgs = (argv = []) => {
+exports.parseArgs = (argv = []) => {
   const out = { _: [] };
   for (let index = 0; index < argv.length; index += 1) {
     const item = argv[index];
@@ -24,5 +24,3 @@ const parseArgs = (argv = []) => {
   }
   return out;
 };
-
-module.exports = { parseArgs };