groove-dev 0.27.93 → 0.27.96

package/node_modules/moe-training/client/parsers/codex.js

@@ -0,0 +1,80 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+export class CodexParser {
+  constructor() {
+    this._sessionId = null;
+  }
+
+  parseEvent(jsonEvent) {
+    if (!jsonEvent || !jsonEvent.type) return null;
+
+    switch (jsonEvent.type) {
+      case 'thread.started': {
+        this._sessionId = jsonEvent.thread_id || null;
+        return null;
+      }
+
+      case 'item.started': {
+        const item = jsonEvent.item || {};
+        if (item.type === 'agent_message') {
+          return { type: 'thought', content: item.text || '' };
+        }
+        if (item.type === 'command_execution') {
+          return { type: 'action', tool: 'command_execution', arguments: { command: item.command }, content: `Executing: ${item.command || ''}` };
+        }
+        if (item.type === 'file_edit' || item.type === 'file_write') {
+          return { type: 'action', tool: item.type, arguments: { path: item.path || item.file || '' }, content: `${item.type}: ${item.path || item.file || ''}` };
+        }
+        if (item.type === 'file_read') {
+          return { type: 'action', tool: 'file_read', arguments: { path: item.path || item.file || '' }, content: `Reading: ${item.path || item.file || ''}` };
+        }
+        return null;
+      }
+
+      case 'item.completed': {
+        const item = jsonEvent.item || {};
+        if (item.type === 'agent_message') {
+          return { type: 'thought', content: item.text || '' };
+        }
+        if (item.type === 'command_execution') {
+          const output = (item.aggregated_output || '').slice(0, 2000);
+          if (item.exit_code !== 0) {
+            return { type: 'error', content: output || `Exit code: ${item.exit_code}` };
+          }
+          return { type: 'observation', content: output };
+        }
+        if (item.type === 'file_edit' || item.type === 'file_write' || item.type === 'file_read') {
+          const output = (item.output || item.content || '').slice(0, 2000);
+          return { type: 'observation', content: output };
+        }
+        return null;
+      }
+
+      case 'turn.completed': {
+        return { type: 'resolution', content: '' };
+      }
+
+      default:
+        return null;
+    }
+  }
+
+  extractTokens(jsonEvent) {
+    if (!jsonEvent) return null;
+    const usage = jsonEvent.usage || jsonEvent.item?.usage;
+    if (!usage) return null;
+    return {
+      input: usage.input_tokens || 0,
+      output: usage.output_tokens || 0,
+      cacheRead: 0,
+      cacheCreation: 0,
+    };
+  }
+
+  extractSessionId(jsonEvent) {
+    if (jsonEvent?.type === 'thread.started') {
+      return jsonEvent.thread_id || null;
+    }
+    return null;
+  }
+}

package/node_modules/moe-training/client/parsers/gemini.js

@@ -0,0 +1,80 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+export class GeminiParser {
+  constructor() {
+    this._sessionId = null;
+  }
+
+  parseEvent(jsonEvent) {
+    if (!jsonEvent || !jsonEvent.type) return null;
+
+    switch (jsonEvent.type) {
+      case 'agent_start': {
+        this._sessionId = jsonEvent.streamId || null;
+        return null;
+      }
+
+      case 'message': {
+        if (jsonEvent.role === 'user') return null;
+        const raw = jsonEvent.content;
+        const parts = Array.isArray(raw) ? raw : (typeof raw === 'string' ? [{ text: raw }] : raw ? [raw] : []);
+
+        for (const part of parts) {
+          if (part.type === 'thought') {
+            return { type: 'thought', content: part.thought || part.text || '' };
+          }
+        }
+
+        const text = parts.map((p) => p.text || '').filter(Boolean).join('\n');
+        if (text) {
+          return { type: 'thought', content: text };
+        }
+        return null;
+      }
+
+      case 'tool_request': {
+        return {
+          type: 'action',
+          tool: jsonEvent.name || 'Tool',
+          arguments: jsonEvent.args || {},
+          content: `Using ${jsonEvent.name || 'Tool'}`,
+        };
+      }
+
+      case 'tool_response': {
+        const rawContent = jsonEvent.content;
+        const contentParts = Array.isArray(rawContent) ? rawContent : (typeof rawContent === 'string' ? [{ text: rawContent }] : rawContent ? [rawContent] : []);
+        const content = contentParts.map((p) => p.text || '').join('').slice(0, 2000);
+        return { type: 'observation', content };
+      }
+
+      case 'error': {
+        return { type: 'error', content: jsonEvent.message || 'Unknown error' };
+      }
+
+      case 'agent_end': {
+        return { type: 'resolution', content: '' };
+      }
+
+      default:
+        return null;
+    }
+  }
+
+  extractTokens(jsonEvent) {
+    if (!jsonEvent || jsonEvent.type !== 'usage') return null;
+    return {
+      input: jsonEvent.inputTokens || 0,
+      output: jsonEvent.outputTokens || 0,
+      cacheRead: jsonEvent.cachedTokens || 0,
+      cacheCreation: 0,
+    };
+  }
+
+  extractSessionId(jsonEvent) {
+    if (jsonEvent?.type === 'agent_start') {
+      return jsonEvent.streamId || null;
+    }
+    return null;
+  }
+}

package/node_modules/moe-training/client/parsers/grok.js

@@ -0,0 +1,16 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+export class GrokParser {
+  // TODO: Grok agentic CLI not yet available. Wire up when headless CLI is built.
+  parseEvent(_jsonEvent) {
+    return null;
+  }
+
+  extractTokens(_jsonEvent) {
+    return null;
+  }
+
+  extractSessionId(_jsonEvent) {
+    return null;
+  }
+}

package/node_modules/moe-training/client/parsers/index.js

@@ -0,0 +1,20 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { SUPPORTED_PROVIDERS } from '../../shared/constants.js';
+import { ClaudeCodeParser } from './claude-code.js';
+import { CodexParser } from './codex.js';
+import { GeminiParser } from './gemini.js';
+import { GrokParser } from './grok.js';
+
+const constructors = {
+  'claude-code': ClaudeCodeParser,
+  'codex': CodexParser,
+  'gemini': GeminiParser,
+  'grok': GrokParser,
+};
+
+export function getParser(providerName) {
+  if (!SUPPORTED_PROVIDERS.includes(providerName)) return null;
+  const Ctor = constructors[providerName];
+  return Ctor ? new Ctor() : null;
+}

package/node_modules/moe-training/client/scrubber.js

@@ -0,0 +1,128 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+function luhnCheck(digits) {
+  let sum = 0;
+  let alt = false;
+  for (let i = digits.length - 1; i >= 0; i--) {
+    let n = parseInt(digits[i], 10);
+    if (alt) {
+      n *= 2;
+      if (n > 9) n -= 9;
+    }
+    sum += n;
+    alt = !alt;
+  }
+  return sum % 10 === 0;
+}
+
+export class PIIScrubber {
+  constructor() {
+    this._patterns = [
+      {
+        name: 'pem_private_key',
+        regex: /-----BEGIN[A-Z ]*PRIVATE KEY-----[\s\S]*?-----END[A-Z ]*PRIVATE KEY-----/g,
+        replacement: '[PRIVATE_KEY]',
+      },
+      {
+        name: 'aws_key',
+        regex: /AKIA[0-9A-Z]{16}/g,
+        replacement: '[AWS_KEY]',
+      },
+      {
+        name: 'jwt_token',
+        regex: /eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/g,
+        replacement: '[API_KEY]',
+      },
+      {
+        name: 'bearer_token',
+        regex: /Bearer\s+[A-Za-z0-9._~+/\-]+=*/g,
+        replacement: '[API_KEY]',
+      },
+      {
+        name: 'sk_pk_key',
+        regex: /(?:sk|pk)_[a-zA-Z0-9_]{20,}/g,
+        replacement: '[API_KEY]',
+      },
+      {
+        name: 'credit_card',
+        regex: /\b(\d{4})[- ]?(\d{4})[- ]?(\d{4})[- ]?(\d{4})\b/g,
+        replacement: null, // handled in scrub() with Luhn
+      },
+      {
+        name: 'ssn',
+        regex: /\b\d{3}-\d{2}-\d{4}\b/g,
+        replacement: '[SSN]',
+      },
+      {
+        name: 'email',
+        regex: /[a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{2,}/g,
+        replacement: '[EMAIL]',
+      },
+      {
+        name: 'email_urlencoded',
+        regex: /[a-zA-Z0-9._%+-]+%40[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g,
+        replacement: '[EMAIL]',
+      },
+      {
+        name: 'ipv6',
+        regex: /(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|(?:[0-9a-fA-F]{1,4}:){1,7}:|(?:[0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|::(?:[fF]{4}:)?(?:\d{1,3}\.){3}\d{1,3}|::1?\b/g,
+        replacement: '[IP]',
+      },
+      {
+        name: 'ipv4',
+        regex: /\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/g,
+        replacement: '[IP]',
+      },
+      {
+        name: 'intl_phone',
+        regex: /\+\d{1,3}[\s.-]?\(?\d{1,4}\)?[\s.-]?\d{2,4}[\s.-]?\d{2,4}(?:[\s.-]?\d{1,4})?/g,
+        replacement: '[PHONE]',
+      },
+      {
+        name: 'phone',
+        regex: /(?:\+?1[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}\b/g,
+        replacement: '[PHONE]',
+      },
+      {
+        name: 'url_with_secret',
+        regex: /https?:\/\/[^\s]*[?&](?:token|key|secret|password|api_key|apikey|access_token|auth)=[^\s&]*/gi,
+        replacement: '[REDACTED_URL]',
+      },
+      {
+        name: 'long_hex',
+        regex: /\b[0-9a-fA-F]{40,}\b/g,
+        replacement: '[API_KEY]',
+      },
+      {
+        name: 'home_path',
+        regex: /(?:\/Users\/[^\/\s]+|\/home\/[^\/\s]+|C:\\Users\\[^\\\s]+)([\/\\][^\s]*)?/g,
+        replacement: null,
+      },
+      {
+        name: 'base64_secret',
+        regex: /(?<![A-Za-z0-9+/])[A-Za-z0-9+/]{40,}={0,2}(?![A-Za-z0-9+/])/g,
+        replacement: '[API_KEY]',
+      },
+    ];
+  }
+
+  scrub(text) {
+    if (!text || typeof text !== 'string') return text;
+    let result = text;
+
+    for (const pattern of this._patterns) {
+      if (pattern.name === 'credit_card') {
+        result = result.replace(pattern.regex, (match, g1, g2, g3, g4) => {
+          const digits = (g1 + g2 + g3 + g4);
+          return luhnCheck(digits) ? '[CREDIT_CARD]' : match;
+        });
+      } else if (pattern.name === 'home_path') {
+        result = result.replace(pattern.regex, (_match, relPath) => '~' + (relPath || ''));
+      } else {
+        result = result.replace(pattern.regex, pattern.replacement);
+      }
+    }
+
+    return result;
+  }
+}

package/node_modules/moe-training/client/session-attestation.js

@@ -0,0 +1,115 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { platform, arch, cpus, totalmem, hostname, release, endianness } from 'node:os';
+import { createHash } from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+import { generateECDHKeypair, deriveSharedSecret, signEnvelope, computeAppHash } from '../shared/crypto.js';
+
+export class SessionAttestation {
+  constructor(centralCommandUrl) {
+    this._centralCommandUrl = centralCommandUrl;
+    this._sessions = new Map();
+  }
+
+  async openSession(sessionId, metadata) {
+    const keypair = generateECDHKeypair();
+    let appVersionHash = '';
+    try {
+      appVersionHash = computeAppHash(fileURLToPath(import.meta.url));
+    } catch {
+      appVersionHash = 'unknown';
+    }
+
+    const body = {
+      session_id: sessionId,
+      public_key: keypair.publicKey,
+      app_version_hash: appVersionHash,
+      provider: metadata.provider,
+      model: metadata.model_engine,
+      machine_fingerprint: SessionAttestation.getMachineFingerprint(),
+      groove_version: metadata.groove_version,
+    };
+
+    try {
+      const res = await fetch(`${this._centralCommandUrl}/v1/sessions/open`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(10_000),
+      });
+
+      if (!res.ok) {
+        this._sessions.set(sessionId, { keypair, sharedSecret: null, sequence: 0, appVersionHash, offline: true });
+        return false;
+      }
+
+      const data = await res.json();
+      const sharedSecret = deriveSharedSecret(keypair.privateKey, data.server_public_key);
+      this._sessions.set(sessionId, { keypair, sharedSecret, sequence: 0, appVersionHash, offline: false });
+      return true;
+    } catch {
+      this._sessions.set(sessionId, { keypair, sharedSecret: null, sequence: 0, appVersionHash, offline: true });
+      return false;
+    }
+  }
+
+  signEnvelope(sessionId, envelope) {
+    const session = this._sessions.get(sessionId);
+    if (!session) return envelope;
+
+    if (session.offline || !session.sharedSecret) {
+      envelope.attestation = {
+        session_hmac: 'OFFLINE',
+        sequence: session.sequence++,
+        app_version_hash: session.appVersionHash,
+      };
+      return envelope;
+    }
+
+    const forSigning = { ...envelope };
+    delete forSigning.attestation;
+    const envelopeBytes = JSON.stringify(forSigning);
+    const hmac = signEnvelope(session.sharedSecret, envelopeBytes, session.sequence);
+    envelope.attestation = {
+      session_hmac: hmac,
+      sequence: session.sequence++,
+      app_version_hash: session.appVersionHash,
+    };
+    return envelope;
+  }
+
+  async closeSession(sessionId) {
+    const session = this._sessions.get(sessionId);
+    if (!session || session.offline) {
+      this._sessions.delete(sessionId);
+      return;
+    }
+
+    try {
+      await fetch(`${this._centralCommandUrl}/v1/sessions/close`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ session_id: sessionId }),
+        signal: AbortSignal.timeout(10_000),
+      });
+    } catch {
+      // fail silent
+    }
+
+    this._sessions.delete(sessionId);
+  }
+
+  static getMachineFingerprint() {
+    const signals = [
+      platform(),
+      arch(),
+      cpus()[0]?.model || '',
+      String(totalmem()),
+      hostname(),
+      String(cpus().length),
+      release(),
+      endianness(),
+    ];
+    return createHash('sha256').update(signals.join('|')).digest('hex');
+  }
+}

package/node_modules/moe-training/client/step-classifier.js

@@ -0,0 +1,68 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+const ERROR_SIGNAL_RE = /\b(?:error|Error|ERROR|exception|Exception|EXCEPTION|failed|FAILED|exit code [1-9]|ENOENT|EACCES|EPERM|TypeError|ReferenceError|SyntaxError|Cannot find|Module not found|Command failed|non-zero exit)\b/;
+const FIX_SIGNAL_RE = /\b(?:fix|correcting|I see the issue|let me fix|the (?:issue|problem|bug) (?:is|was)|instead I should|my mistake)\b/i;
+
+export class StepClassifier {
+  constructor() {
+    this.hasAgentActed = false;
+    this._lastStepType = null;
+  }
+
+  classifyUserMessage(text) {
+    if (!this.hasAgentActed) {
+      return null;
+    }
+    return {
+      type: 'correction',
+      content: text,
+      source: 'user',
+    };
+  }
+
+  classifyCoordinationEvent(event) {
+    return {
+      type: 'coordination',
+      coordination_id: event.coordination_id || event.id || '',
+      direction: event.direction || (event.source ? 'inbound' : 'outbound'),
+      target_agent: event.target_agent || event.targetAgent || '',
+      protocol: event.protocol || 'knock',
+      content: event.content || event.message || '',
+    };
+  }
+
+  onStep(step) {
+    if (step.type === 'action') {
+      this.hasAgentActed = true;
+    }
+
+    const content = step.content || '';
+
+    if ((step.type === 'action' || step.type === 'observation') && ERROR_SIGNAL_RE.test(content)) {
+      step.type = 'error';
+    }
+
+    if (step.type === 'thought' && this._lastStepType === 'correction' && FIX_SIGNAL_RE.test(content)) {
+      step.correction_context = true;
+    }
+
+    this._lastStepType = step.type;
+    return step;
+  }
+
+  static detectErrorRecovery(steps) {
+    for (let i = 0; i < steps.length - 1; i++) {
+      if (steps[i].type === 'error') {
+        for (let j = i + 1; j < steps.length; j++) {
+          if (steps[j].type === 'resolution') return true;
+          if (steps[j].type === 'error') break;
+        }
+      }
+    }
+    return false;
+  }
+
+  static countUserInterventions(steps) {
+    return steps.filter((s) => s.type === 'correction').length;
+  }
+}