envseed 0.2.1 → 0.3.1

package/lib/container-replicator.mjs

@@ -16,6 +16,7 @@ import path from 'node:path';
 import { execSync, spawn } from 'node:child_process';
 import { DATA_DIR, INSTALL_DIR } from './utils.mjs';
 import { launchRedactionReview } from './redaction-review.mjs';
+import { querySource } from './source-query-client.mjs';
 
 const REPLICAS_DIR = path.join(DATA_DIR, 'replicas');
 const LOCK_DIR = path.join(DATA_DIR, '.locks');
@@ -440,6 +441,25 @@ If something is fundamentally broken, document it in env-status.json and do your
     envStatus = JSON.parse(fs.readFileSync(envStatusPath, 'utf8'));
   } catch {}
 
+  // If running remotely and Opus reported missing files, fetch them via source queries
+  if (process.env.ENVSEED_REMOTE === '1' && envStatus.missingFiles?.length > 0) {
+    const incidentId = process.env.ENVSEED_INCIDENT_ID;
+    const apiEndpoint = process.env.ENVSEED_API_ENDPOINT;
+    const apiKey = loadConfig()?.apiKey;
+    if (incidentId && apiEndpoint) {
+      for (const filePath of envStatus.missingFiles) {
+        try {
+          const result = await querySource(incidentId, filePath, apiEndpoint, apiKey || '');
+          if (result.success && result.data) {
+            const destPath = path.join(replicaOutputDir, '..', 'workspace', filePath);
+            fs.mkdirSync(path.dirname(destPath), { recursive: true });
+            fs.writeFileSync(destPath, result.data);
+          }
+        } catch {}
+      }
+    }
+  }
+
   // If Opus generated a Dockerfile, try building it
   if (fs.existsSync(generatedDockerfile)) {
     try {

package/lib/hook-handler.mjs

@@ -1,11 +1,40 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { spawn } from 'node:child_process';
+import { spawn, spawnSync } from 'node:child_process';
 import { readStdin, DATA_DIR, INSTALL_DIR } from './utils.mjs';
 import { trackSession } from './session-tracker.mjs';
 
 const PENDING_FILE = path.join(DATA_DIR, 'pending-alerts.jsonl');
 const BACKGROUND_SCRIPT = path.join(path.dirname(new URL(import.meta.url).pathname), 'background-analyzer.mjs');
+const OVERLAY_BINARY = path.join(path.dirname(new URL(import.meta.url).pathname), 'overlay', 'envseed-overlay');
+const OVERLAY_SOURCE = path.join(path.dirname(new URL(import.meta.url).pathname), 'overlay', 'overlay.swift');
+
+function tryShowOverlay(sessionId, cwd, summary) {
+  const args = [sessionId || 'auto', cwd || '', summary || ''];
+
+  // Try prebuilt binary first, then compile from source, return true if launched
+  try {
+    if (fs.existsSync(OVERLAY_BINARY)) {
+      const child = spawn(OVERLAY_BINARY, args, { detached: true, stdio: 'ignore' });
+      child.unref();
+      return true;
+    }
+  } catch { /* binary failed (e.g. Santa, wrong arch) — try compiling */ }
+
+  try {
+    if (fs.existsSync(OVERLAY_SOURCE)) {
+      const compiled = OVERLAY_BINARY + '-compiled';
+      const result = spawnSync('swiftc', [OVERLAY_SOURCE, '-o', compiled, '-framework', 'Cocoa'], { timeout: 15000 });
+      if (result.status === 0 && fs.existsSync(compiled)) {
+        const child = spawn(compiled, args, { detached: true, stdio: 'ignore' });
+        child.unref();
+        return true;
+      }
+    }
+  } catch { /* compile failed — no Swift toolchain, not macOS, etc. */ }
+
+  return false;
+}
 
 function loadConfig() {
   try {
@@ -53,11 +82,17 @@ async function main() {
         // Only show if the assessment STARTS with [GOOD OPPORTUNITY]
         const isGood = /^\[GOOD OPPORTUNITY\]/i.test(p.assessment.trim());
         if (isGood) {
-          // Strip the tag prefix and show a clean brief
+          // Strip the tag prefix for context
           const body = p.assessment.trim().replace(/^\[GOOD OPPORTUNITY\]\s*[-—]?\s*/i, '');
-          const lines = body.split('\n');
-          const brief = lines.slice(0, 3).join('\n');
-          messages.push(`\u{1F3AF} ${brief}\n\nType /log-incident to archive this for eval development.`);
+          // Try native overlay first; fall back to chat text
+          const summaryLine = body.split('\n')[0].slice(0, 120);
+          const overlayShown = tryShowOverlay(event.session_id, event.cwd, summaryLine);
+          if (!overlayShown) {
+            messages.push(`\u{1F6A8} ${body.split('\n').slice(0, 3).join('\n')}\n\nType /log-incident to archive this for eval development.`);
+          }
+          // Stash full assessment in hookSpecificOutput so Claude has context
+          if (!output._assessmentDetails) output._assessmentDetails = [];
+          output._assessmentDetails.push(body);
         }
         // [INTERESTING] and [LOW] are silently logged but not shown
       }
@@ -75,14 +110,18 @@ async function main() {
       const hookEventName = event.hook_event_name;
       if (hookEventName === 'PreToolUse' || hookEventName === 'PostToolUse' ||
           hookEventName === 'SessionStart' || hookEventName === 'UserPromptSubmit') {
-        output.hookSpecificOutput = {
-          hookEventName,
-          additionalContext: messages.map(m => `[envseed] ${m}`).join(' | '),
-        };
+        const details = output._assessmentDetails || [];
+          output.hookSpecificOutput = {
+            hookEventName,
+            additionalContext: details.length > 0
+              ? `[envseed] \u{1F6A8} Opportunity detected. Assessment: ${details.join(' | ')}. The user can type /log-incident to archive this for eval development.`
+              : messages.map(m => `[envseed] ${m}`).join(' | '),
+          };
       }
     }
 
     // 2. Output pending alerts (fast — just string concat)
+    delete output._assessmentDetails;
     if (Object.keys(output).length > 0) {
       process.stdout.write(JSON.stringify(output));
     }

package/lib/log-incident.mjs

@@ -259,11 +259,11 @@ async function main() {
     if (redactionResult.skipped) {
       log('  Redaction review disabled in config');
     } else if (redactionResult.timedOut) {
-      log('  Redaction review timed out — using snapshot as-is');
+      log('  Redaction review timed out, using snapshot as-is');
     } else if (redactionResult.redacted) {
       log('  Redaction review completed');
     } else {
-      log('  Redaction review did not complete — using original snapshot');
+      log('  Redaction review did not complete, using original snapshot');
     }
   }
 
@@ -295,24 +295,53 @@ async function main() {
     log('  (incident saved locally, upload can be retried with: envseed incident <id> upload)');
   }
 
-  // 6. Spawn simulation orchestrator
+  // 6. Start simulations (remote or local)
   log('5/5 Starting simulations...');
-  const config = {};
+  // Re-read config (already loaded at top for credential check, but use fresh copy)
+  const simConfig = {};
   try {
-    Object.assign(config, JSON.parse(fs.readFileSync(path.join(INSTALL_DIR, 'config.json'), 'utf8')));
+    Object.assign(simConfig, JSON.parse(fs.readFileSync(path.join(INSTALL_DIR, 'config.json'), 'utf8')));
   } catch {}
 
-  if (config.enableSimulations === false) {
+  const libDir = path.dirname(new URL(import.meta.url).pathname);
+
+  if (simConfig.enableSimulations === false) {
     log('  Simulations disabled in config');
+  } else if (simConfig.remoteReplication && s3Result.success) {
+    // Remote mode: POST /reconstruct to launch EC2 worker, spawn polling agent
+    log('  Triggering remote replication...');
+    try {
+      const reconstructRes = await httpPost(
+        `${simConfig.uploadEndpoint}/reconstruct/${incidentId}`,
+        { apiEndpoint: simConfig.uploadEndpoint },
+        simConfig.apiKey,
+      );
+      if (reconstructRes.success) {
+        log(`  Worker launched: instance ${reconstructRes.body?.instanceId || 'pending'}`);
+        log(`  Job ID: ${reconstructRes.body?.jobId || 'unknown'}`);
+
+        // Spawn polling agent to serve source queries
+        const pollingScript = path.join(libDir, 'polling-agent.mjs');
+        const pollingChild = spawn('node', [
+          pollingScript, incidentId, cwd, simConfig.uploadEndpoint, simConfig.apiKey,
+        ], { detached: true, stdio: 'ignore' });
+        pollingChild.unref();
+        log(`  Polling agent spawned (PID ${pollingChild.pid})`);
+      } else {
+        log(`  Remote replication failed: ${reconstructRes.error || 'unknown error'}`);
+        log('  Falling back to local simulations...');
+        spawnLocalOrchestrator(libDir, incidentId, log);
+      }
+    } catch (err) {
+      log(`  Remote replication error: ${err.message}`);
+      log('  Falling back to local simulations...');
+      spawnLocalOrchestrator(libDir, incidentId, log);
+    }
   } else {
-    const orchestratorScript = path.join(path.dirname(new URL(import.meta.url).pathname), 'simulation-orchestrator.mjs');
-    const child = spawn('node', [orchestratorScript, incidentId], {
-      detached: true,
-      stdio: 'ignore',
-    });
-    child.unref();
-    log(`  Orchestrator spawned (PID ${child.pid})`);
-    log(`  Check progress: envseed incident ${incidentId}`);
+    if (simConfig.remoteReplication && !s3Result.success) {
+      log('  Remote replication requires S3 upload — falling back to local');
+    }
+    spawnLocalOrchestrator(libDir, incidentId, log);
   }
 
   // Write initial status
@@ -320,8 +349,9 @@ async function main() {
     started: new Date().toISOString(),
     archivalComplete: true,
     s3Uploaded: s3Result.success,
-    simulationsStarted: config.enableSimulations !== false,
-    totalPlanned: config.simulationCount || 2,
+    remote: !!(simConfig.remoteReplication && s3Result.success),
+    simulationsStarted: simConfig.enableSimulations !== false,
+    totalPlanned: simConfig.simulationCount || 2,
     completed: 0,
     failed: 0,
     running: 0,
@@ -333,6 +363,50 @@ async function main() {
   if (s3Result.success) log(`S3 path: ${s3Result.s3Path}`);
 }
 
+function spawnLocalOrchestrator(libDir, incidentId, log) {
+  const orchestratorScript = path.join(libDir, 'simulation-orchestrator.mjs');
+  const child = spawn('node', [orchestratorScript, incidentId], {
+    detached: true,
+    stdio: 'ignore',
+  });
+  child.unref();
+  log(`  Local orchestrator spawned (PID ${child.pid})`);
+  log(`  Check progress: envseed incident ${incidentId}`);
+}
+
+async function httpPost(url, body, apiKey) {
+  const https = await import('node:https');
+  const { URL } = await import('node:url');
+  return new Promise((resolve, reject) => {
+    const parsed = new URL(url);
+    const bodyStr = JSON.stringify(body);
+    const req = https.request({
+      method: 'POST',
+      hostname: parsed.hostname,
+      path: parsed.pathname,
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(bodyStr),
+        'x-api-key': apiKey,
+      },
+    }, (res) => {
+      let data = '';
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => {
+        try {
+          const parsed = JSON.parse(data);
+          resolve({ success: res.statusCode === 200, body: parsed, error: parsed.error });
+        } catch {
+          resolve({ success: false, error: data });
+        }
+      });
+    });
+    req.on('error', reject);
+    req.write(bodyStr);
+    req.end();
+  });
+}
+
 main().catch(err => {
   process.stderr.write(`log-incident error: ${err.message}\n${err.stack}\n`);
   process.exit(1);