mecord-connect 1.0.0

package/runtime/app/apps/local-agent/src/bootstrap-config.js

@@ -0,0 +1,255 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { WindowsDpapiProtector } from '../../../src/core/device-identity.js';
+                                                                                  
+import { OperatorError } from '../../../src/core/errors.js';
+import { readDurableStateText, writeDurableStateText } from '../../../src/core/durable-state.js';
+import { requireLiteralLoopbackBindHost } from '../../../src/core/network-authority.js';
+
+const CONFIG_VERSION = 1         ;
+const MAX_CONFIG_BYTES = 256 * 1024;
+const MAX_ROOTS = 32;
+const DEFAULT_AGENT_PORT = 47_100;
+const DEFAULT_MCP_PORT = 47_200;
+
+                              
+                                 
+                       
+                         
+                                        
+                                      
+                                                                                       
+  
+
+                                          
+                   
+                       
+                         
+                    
+                    
+                  
+                  
+                     
+                        
+ 
+
+export class BootstrapConfigStore {
+  #stateDir        ;
+  #file        ;
+  #protector                       ;
+
+  constructor(stateDir        , protector                       ) {
+    this.#stateDir = path.resolve(stateDir);
+    this.#file = path.join(this.#stateDir, 'bootstrap.json');
+    this.#protector = protector;
+  }
+
+  async configure(rootInput        )                                   {
+    const root = await canonicalDirectory(rootInput);
+    let existing                                 = null;
+    try { existing = await this.load(); }
+    catch (error) {
+      if ((error                         ).code !== 'ENOENT') throw error;
+    }
+
+    const configuredAt = existing?.configuredAt ?? new Date().toISOString();
+    const agentToken = existing?.agentToken ?? randomSecret();
+    const recoveryToken = existing?.recoveryToken ?? randomSecret();
+    const protectedBytes = await this.#protectSecrets(agentToken, recoveryToken);
+    const stored                        = {
+      version: CONFIG_VERSION,
+      configuredAt,
+      allowedRoots: [root],
+      agent: { host: '127.0.0.1', port: existing?.agentPort ?? DEFAULT_AGENT_PORT },
+      mcp: { host: '127.0.0.1', port: existing?.mcpPort ?? DEFAULT_MCP_PORT },
+      secretProtection: { scheme: this.#protector.scheme, ciphertextBase64: protectedBytes.toString('base64') }
+    };
+
+    try {
+      await writeDurableStateText(this.#file, JSON.stringify(stored, null, 2), {
+        maxBytes: MAX_CONFIG_BYTES,
+        errorCode: 'BOOTSTRAP_CONFIG_INVALID',
+        invalidMessage: 'Operator bootstrap configuration is invalid.'
+      });
+    } finally {
+      protectedBytes.fill(0);
+    }
+    return storedToResolved(this.#stateDir, stored, agentToken, recoveryToken);
+  }
+
+  async load()                                   {
+    const text = await readDurableStateText(this.#file, {
+      maxBytes: MAX_CONFIG_BYTES,
+      errorCode: 'BOOTSTRAP_CONFIG_INVALID',
+      invalidMessage: 'Operator bootstrap configuration is invalid.'
+    });
+    let parsed         ;
+    try { parsed = JSON.parse(text); }
+    catch { throw new OperatorError('BOOTSTRAP_CONFIG_INVALID', 'Operator bootstrap configuration is not valid JSON.'); }
+    const stored = validateStored(parsed);
+    const ciphertext = Buffer.from(stored.secretProtection.ciphertextBase64, 'base64');
+    let plaintext                    ;
+    try {
+      plaintext = await this.#protector.unprotect(ciphertext);
+      const secrets = validateSecrets(JSON.parse(plaintext.toString('utf8')));
+      return storedToResolved(this.#stateDir, stored, secrets.agentToken, secrets.recoveryToken);
+    } finally {
+      ciphertext.fill(0);
+      plaintext?.fill(0);
+    }
+  }
+
+  async #protectSecrets(agentToken        , recoveryToken        )                  {
+    const plaintext = Buffer.from(JSON.stringify({ agentToken, recoveryToken }), 'utf8');
+    try { return await this.#protector.protect(plaintext); }
+    finally { plaintext.fill(0); }
+  }
+}
+
+export function defaultOperatorStateDir()         {
+  return path.resolve(process.env.OPERATOR_STATE_DIR ?? path.join(os.homedir(), '.operator'));
+}
+
+export function windowsBootstrapProtector()                        {
+  if (process.platform !== 'win32') {
+    throw new OperatorError('BOOTSTRAP_WINDOWS_REQUIRED', 'One-command protected setup is currently supported by the Windows release.');
+  }
+  const helper = process.env.OPERATOR_WINDOWS_DPAPI_PATH;
+  if (!helper || !path.isAbsolute(helper)) {
+    throw new OperatorError('WINDOWS_DPAPI_HELPER_REQUIRED', 'Packaged Windows DPAPI helper is required for Operator setup.');
+  }
+  return new WindowsDpapiProtector(helper);
+}
+
+export function applyBootstrapEnvironment(config                         )       {
+  process.env.OPERATOR_STATE_DIR = config.stateDir;
+  process.env.OPERATOR_ALLOWED_ROOTS = config.allowedRoots.join(path.delimiter);
+  process.env.OPERATOR_AGENT_TOKEN = config.agentToken;
+  process.env.OPERATOR_RECOVERY_TOKEN = config.recoveryToken;
+  process.env.OPERATOR_AGENT_HOST = config.agentHost;
+  process.env.OPERATOR_AGENT_PORT = String(config.agentPort);
+  process.env.OPERATOR_AGENT_URL = `http://${formatHost(config.agentHost)}:${config.agentPort}`;
+  process.env.OPERATOR_MCP_HOST = config.mcpHost;
+  process.env.OPERATOR_MCP_PORT = String(config.mcpPort);
+}
+
+async function canonicalDirectory(input        )                  {
+  const resolved = path.resolve(input);
+  let stat;
+  try { stat = await fs.stat(resolved); }
+  catch { throw new OperatorError('BOOTSTRAP_ROOT_INVALID', `Authorized root does not exist: ${resolved}`); }
+  if (!stat.isDirectory()) throw new OperatorError('BOOTSTRAP_ROOT_INVALID', `Authorized root is not a directory: ${resolved}`);
+  return await fs.realpath(resolved);
+}
+
+function randomSecret()         {
+  return crypto.randomBytes(32).toString('base64url');
+}
+
+function validPort(input         , label        )         {
+  const value = Number(input);
+  if (!Number.isSafeInteger(value) || value < 1_024 || value > 65_535) {
+    throw new OperatorError('BOOTSTRAP_CONFIG_INVALID', `${label} must be an integer port from 1024 through 65535.`);
+  }
+  return value;
+}
+
+function validConfiguredAt(input         )         {
+  const value = String(input ?? '');
+  const time = Date.parse(value);
+  if (!Number.isFinite(time) || new Date(time).toISOString() !== value) {
+    throw new OperatorError('BOOTSTRAP_CONFIG_INVALID', 'Bootstrap configuredAt must be an ISO timestamp.');
+  }
+  return value;
+}
+
+function validateStored(input         )                        {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) {
+    throw new OperatorError('BOOTSTRAP_CONFIG_INVALID', 'Bootstrap configuration must be a JSON object.');
+  }
+  const value = input                           ;
+  if (value.version !== CONFIG_VERSION) throw new OperatorError('BOOTSTRAP_CONFIG_INVALID', 'Unsupported bootstrap configuration version.');
+  if (!Array.isArray(value.allowedRoots) || value.allowedRoots.length < 1 || value.allowedRoots.length > MAX_ROOTS) {
+    throw new OperatorError('BOOTSTRAP_CONFIG_INVALID', `Bootstrap configuration must contain 1-${MAX_ROOTS} authorized roots.`);
+  }
+  const allowedRoots = value.allowedRoots.map((root) => {
+    const candidate = String(root ?? '');
+    if (!candidate || !path.isAbsolute(candidate)) throw new OperatorError('BOOTSTRAP_CONFIG_INVALID', 'Authorized roots must be absolute paths.');
+    return path.resolve(candidate);
+  });
+  if (new Set(allowedRoots.map((root) => process.platform === 'win32' ? root.toLowerCase() : root)).size !== allowedRoots.length) {
+    throw new OperatorError('BOOTSTRAP_CONFIG_INVALID', 'Authorized roots must be unique.');
+  }
+  const agent = validEndpoint(value.agent, 'Local agent');
+  const mcp = validEndpoint(value.mcp, 'MCP server');
+  const protection = value.secretProtection                                       ;
+  if (!protection || protection.scheme !== 'windows-dpapi-current-user') {
+    throw new OperatorError('BOOTSTRAP_CONFIG_INVALID', 'Bootstrap secrets must use Windows DPAPI CurrentUser protection.');
+  }
+  const ciphertextBase64 = String(protection.ciphertextBase64 ?? '');
+  if (!/^[A-Za-z0-9+/]+={0,2}$/.test(ciphertextBase64) || ciphertextBase64.length > 128 * 1024) {
+    throw new OperatorError('BOOTSTRAP_CONFIG_INVALID', 'Bootstrap secret ciphertext is invalid.');
+  }
+  return {
+    version: CONFIG_VERSION,
+    configuredAt: validConfiguredAt(value.configuredAt),
+    allowedRoots,
+    agent,
+    mcp,
+    secretProtection: { scheme: 'windows-dpapi-current-user', ciphertextBase64 }
+  };
+}
+
+function validEndpoint(input         , label        )                                 {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) {
+    throw new OperatorError('BOOTSTRAP_CONFIG_INVALID', `${label} endpoint is invalid.`);
+  }
+  const value = input                           ;
+  return {
+    host: requireLiteralLoopbackBindHost(String(value.host ?? ''), label),
+    port: validPort(value.port, `${label} port`)
+  };
+}
+
+function validateSecrets(input         )                                                {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) {
+    throw new OperatorError('BOOTSTRAP_SECRET_INVALID', 'Protected bootstrap secret payload is invalid.');
+  }
+  const value = input                           ;
+  const agentToken = validSecret(value.agentToken, 'agent token');
+  const recoveryToken = validSecret(value.recoveryToken, 'recovery token');
+  return { agentToken, recoveryToken };
+}
+
+function validSecret(input         , label        )         {
+  const value = String(input ?? '');
+  if (value.length < 32 || Buffer.byteLength(value, 'utf8') > 4096) {
+    throw new OperatorError('BOOTSTRAP_SECRET_INVALID', `Protected ${label} is invalid.`);
+  }
+  return value;
+}
+
+function storedToResolved(
+  stateDir        ,
+  stored                       ,
+  agentToken        ,
+  recoveryToken        
+)                          {
+  return {
+    stateDir,
+    configuredAt: stored.configuredAt,
+    allowedRoots: [...stored.allowedRoots],
+    agentHost: stored.agent.host,
+    agentPort: stored.agent.port,
+    mcpHost: stored.mcp.host,
+    mcpPort: stored.mcp.port,
+    agentToken,
+    recoveryToken
+  };
+}
+
+function formatHost(host        )         {
+  return host.includes(':') ? `[${host}]` : host;
+}

package/runtime/app/apps/local-agent/src/cli.js

@@ -0,0 +1,237 @@
+import { spawn } from 'node:child_process';
+import http from 'node:http';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { DeviceIdentityStore } from '../../../src/core/device-identity.js';
+import { OperatorError } from '../../../src/core/errors.js';
+import { safeChildEnvironment } from '../../../src/core/child-environment.js';
+import { PRODUCT_NAME } from '../../../src/core/product-identity.js';
+import {
+  BootstrapConfigStore,
+  applyBootstrapEnvironment,
+  defaultOperatorStateDir,
+  windowsBootstrapProtector
+} from './bootstrap-config.js';
+
+const args = process.argv.slice(2);
+const command = args[0] ?? 'run';
+
+try {
+  if (command === 'setup') await setup(args.slice(1));
+  else if (command === 'verify') await verify(args.slice(1));
+  else if (command === 'run' && args.length === 1) await run();
+  else if (command === '--help' || command === '-h' || command === 'help') printHelp();
+  else if (args.length === 0) await run();
+  else throw new OperatorError('CLI_ARGUMENT_INVALID', `Unknown Operator command: ${command}`);
+} catch (error) {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`[operator] ${message}`);
+  process.exitCode = 1;
+}
+
+async function setup(rest          )                {
+  const { root, startRuntime } = parseSetupArgs(rest);
+  const stateDir = defaultOperatorStateDir();
+  const store = new BootstrapConfigStore(stateDir, windowsBootstrapProtector());
+  const config = await store.configure(root);
+  applyBootstrapEnvironment(config);
+
+  const identity = await new DeviceIdentityStore(stateDir).loadOrCreate();
+  await verifyConfiguredState(stateDir, config);
+  if (startRuntime) await ensureRuntimeReady(config);
+  console.log('Operator setup: PASS');
+  console.log(`Authorized root: ${config.allowedRoots[0]}`);
+  console.log(`Device: ${identity.deviceName} (${identity.deviceId})`);
+  console.log('Secrets: protected with Windows DPAPI CurrentUser');
+  console.log('Verification: PASS');
+  console.log(`Runtime: ${startRuntime ? 'running' : 'not started (--no-start)'}`);
+  console.log(startRuntime ? 'Ready: connect Operator in ChatGPT.' : 'Ready: run operator when you want to start the runtime.');
+}
+
+async function verify(rest          )                {
+  if (rest.length > 0) throw new OperatorError('CLI_ARGUMENT_INVALID', 'Operator verify does not accept arguments.');
+  const stateDir = defaultOperatorStateDir();
+  const store = new BootstrapConfigStore(stateDir, windowsBootstrapProtector());
+  const config = await store.load();
+  applyBootstrapEnvironment(config);
+
+  await verifyConfiguredState(stateDir, config);
+
+  console.log('Operator verify: PASS');
+  console.log(`Authorized roots: ${config.allowedRoots.length}`);
+  console.log(`Local agent: ${config.agentHost}:${config.agentPort}`);
+  console.log(`Local MCP: ${config.mcpHost}:${config.mcpPort}/mcp`);
+  console.log('Device identity: unlocked and signature verified');
+  console.log('Secrets: DPAPI protected; no plaintext bootstrap secrets detected');
+  console.log('Ready: run operator');
+}
+
+async function run()                {
+  const stateDir = defaultOperatorStateDir();
+  const store = new BootstrapConfigStore(stateDir, windowsBootstrapProtector());
+  let config;
+  try { config = await store.load(); }
+  catch (error) {
+    if ((error                         ).code === 'ENOENT') {
+      throw new OperatorError('BOOTSTRAP_REQUIRED', 'Operator is not configured. Run "operator setup" once.');
+    }
+    throw error;
+  }
+  applyBootstrapEnvironment(config);
+  await import('./main.js');
+  await import('../../mcp-server/src/server.js');
+}
+
+function parseSetupArgs(rest          )                                          {
+  let root = process.env.OPERATOR_INVOKE_CWD ?? process.cwd();
+  let startRuntime = true;
+  for (let index = 0; index < rest.length; index += 1) {
+    const arg = rest[index];
+    if (arg === '--no-start') { startRuntime = false; continue; }
+    if (arg === '--root' && rest[index + 1]) { root = rest[index + 1] ; index += 1; continue; }
+    throw new OperatorError('CLI_ARGUMENT_INVALID', 'Usage: operator setup [--root <authorized-folder>] [--no-start]');
+  }
+  return { root, startRuntime };
+}
+
+async function ensureRuntimeReady(config                                                   )                {
+  if (await runtimeHealthy(config)) return;
+  const dpapi = process.env.OPERATOR_WINDOWS_DPAPI_PATH;
+  const uia = process.env.OPERATOR_WINDOWS_UIA_PATH;
+  const pathLease = process.env.OPERATOR_WINDOWS_PATH_LEASE_PATH;
+  if (
+    !dpapi || !path.isAbsolute(dpapi)
+    || !uia || !path.isAbsolute(uia)
+    || !pathLease || !path.isAbsolute(pathLease)
+  ) {
+    throw new OperatorError('BOOTSTRAP_RUNTIME_START_FAILED', 'Packaged native helpers are required to start Operator automatically.');
+  }
+  const child = spawn(process.execPath, ['--experimental-strip-types', import.meta.filename, 'run'], {
+    cwd: config.allowedRoots[0],
+    detached: true,
+    env: {
+      ...safeChildEnvironment('desktop'),
+      OPERATOR_STATE_DIR: config.stateDir,
+      OPERATOR_WINDOWS_DPAPI_PATH: dpapi,
+      OPERATOR_WINDOWS_UIA_PATH: uia,
+      OPERATOR_WINDOWS_PATH_LEASE_PATH: pathLease
+    },
+    shell: false,
+    stdio: 'ignore',
+    windowsHide: true
+  });
+  child.unref();
+  for (let attempt = 0; attempt < 40; attempt += 1) {
+    await new Promise((resolve) => setTimeout(resolve, 250));
+    if (await runtimeHealthy(config)) return;
+  }
+  throw new OperatorError('BOOTSTRAP_RUNTIME_START_FAILED', 'Operator runtime did not become healthy after setup. Run "operator verify" for diagnostics.');
+}
+
+async function runtimeHealthy(config                                                   )                   {
+  const agentBase = `http://${formatHost(config.agentHost)}:${config.agentPort}`;
+  const mcpBase = `http://${formatHost(config.mcpHost)}:${config.mcpPort}`;
+  try {
+    const agent = await readHealthJson(`${agentBase}/v1/settings`, {
+      authorization: `Bearer ${config.agentToken}`
+    });
+    if (agent.status !== 200 || (agent.body                    ).ok !== true) return false;
+    const mcp = await readHealthJson(`${mcpBase}/health`);
+    const body = mcp.body                                       ;
+    return mcp.status === 200 && body.ok === true && body.service === PRODUCT_NAME;
+  } catch {
+    return false;
+  }
+}
+
+async function readHealthJson(url        , headers                         = {})                                             {
+  return await new Promise((resolve, reject) => {
+    const req = http.get(url, {
+      agent: false,
+      headers: { ...headers, connection: 'close' }
+    }, (res) => {
+      const chunks           = [];
+      let bytes = 0;
+      res.on('data', (chunk        ) => {
+        bytes += chunk.byteLength;
+        if (bytes > 16 * 1024) {
+          req.destroy(new Error('Operator readiness response exceeded 16 KiB.'));
+          return;
+        }
+        chunks.push(chunk);
+      });
+      res.on('end', () => {
+        try {
+          resolve({ status: res.statusCode ?? 0, body: JSON.parse(Buffer.concat(chunks).toString('utf8')) });
+        } catch (error) {
+          reject(error);
+        }
+      });
+    });
+    req.setTimeout(750, () => req.destroy(new Error('Operator readiness probe timed out.')));
+    req.once('error', reject);
+  });
+}
+
+function formatHost(host        )         {
+  return host.includes(':') ? `[${host}]` : host;
+}
+
+async function verifyConfiguredState(stateDir        , config                                                   )                {
+  for (const root of config.allowedRoots) {
+    const stat = await fs.stat(root);
+    if (!stat.isDirectory()) throw new OperatorError('BOOTSTRAP_ROOT_INVALID', `Authorized root is no longer a directory: ${root}`);
+  }
+  if (config.agentPort === config.mcpPort) {
+    throw new OperatorError('BOOTSTRAP_CONFIG_INVALID', 'Local agent and MCP server ports must be distinct.');
+  }
+  await verifyDeviceIdentity(stateDir);
+  await verifyMcpRuntime();
+  await verifySecretsAreNotPlaintext(stateDir, config.agentToken, config.recoveryToken);
+}
+
+async function verifyDeviceIdentity(stateDir        )                {
+  const store = new DeviceIdentityStore(stateDir);
+  const existing = await store.loadExisting();
+  if (!existing) throw new OperatorError('DEVICE_IDENTITY_MISSING', 'Operator device identity is absent. Run Operator to begin fresh device enrollment.');
+  const probe = Buffer.from('operator-one-command-verify-v1', 'utf8');
+  const signature = await store.sign(probe);
+  if (!(await store.verify(probe, signature))) {
+    throw new OperatorError('DEVICE_IDENTITY_VERIFY_FAILED', 'Device identity signature round trip failed.');
+  }
+}
+
+async function verifyMcpRuntime()                {
+  const root = path.resolve(import.meta.dirname, '../../mcp-server');
+  const required = [
+    'src/server.js',
+    'src/local-agent-client.js',
+    'node_modules/fastify/package.json',
+    'node_modules/zod/package.json',
+    'node_modules/@modelcontextprotocol/server/package.json',
+    'node_modules/@modelcontextprotocol/fastify/package.json'
+  ];
+  for (const relative of required) {
+    try { await fs.access(path.join(root, relative)); }
+    catch { throw new OperatorError('MCP_RUNTIME_MISSING', `Packaged MCP runtime is incomplete: ${relative}`); }
+  }
+}
+
+async function verifySecretsAreNotPlaintext(stateDir        , ...secrets          )                {
+  const text = await fs.readFile(path.join(stateDir, 'bootstrap.json'), 'utf8');
+  for (const secret of secrets) {
+    if (text.includes(secret)) throw new OperatorError('BOOTSTRAP_SECRET_EXPOSED', 'Bootstrap configuration contains a plaintext secret.');
+  }
+}
+
+function printHelp()       {
+  console.log([
+    'Operator',
+    '',
+    '  operator setup [--root <folder>]      Configure, verify, and start Operator once.',
+    '  operator verify                       Re-run protected config/runtime verification.',
+    '  operator                              Start the local agent and MCP server.',
+    '',
+    'Setup never prints or stores plaintext bearer/recovery secrets.'
+  ].join('\n'));
+}