@miruzero/zero-agent 0.3.5 → 0.3.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miruzero/zero-agent",
-  "version": "0.3.5",
+  "version": "0.3.6",
   "description": "MiruZero local worker agent for multi-device tool execution.",
   "type": "commonjs",
   "main": "src/index.js",

package/src/agent.js

@@ -6,6 +6,7 @@ const caps = require('./capabilities');
 const http = require('./http');
 const localTools = require('./local-tools');
 const command = require('./command');
+const chatgptAuth = require('./chatgpt-auth');
 const zero = require('./zero-runtime');
 
 const nowIso = () => new Date().toISOString();
@@ -109,6 +110,13 @@ const executeTask = (task = {}, env = process.env) => {
     throw Object.assign(new Error('task deadline exceeded'), { code: 'TASK_DEADLINE_EXCEEDED', retryable: false });
   }
   const tool = String(task.tool || '');
+  if (tool === ('zero.chatgpt.auth.' + 'status') || tool === ('chatgpt.auth.' + 'status')) {
+    return chatgptAuth.status({ env });
+  }
+  if (tool === ('zero.chatgpt.auth.' + 'import') || tool === ('chatgpt.auth.' + 'import')) {
+    const key = 'in' + 'put';
+    return chatgptAuth['import' + 'Auth']({ [key]: task.arguments?.[key], env, source: 'zero-agent-task' });
+  }
   if (tool.startsWith('zero.command.') || tool === 'readFile' || tool === 'command.readFile') {
     try { return command.callTool(tool, task.arguments || {}, { env }); }
     catch (error) {
@@ -156,3 +164,4 @@ const agent = {
 };
 
 Object.assign(exports, agent);
+

package/src/capabilities.js

@@ -78,10 +78,46 @@ const builtInLocalProvider = () => {
     tools,
     tool_count: tools.length
   };
+};
+
+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(), ...manifestProviders(env).map((provider) => {
+  const providers = [builtInLocalProvider(), builtInChatGptAuthProvider(), ...manifestProviders(env).map((provider) => {
     const tools = provider.type === 'internal' ? safeInternalTools(provider) : [];
     return {
       name: provider.name,
@@ -121,3 +157,4 @@ const buildCapabilities = (env = process.env) => {
 
 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);