maxion-mcp-gateway 1.0.1

package/dashboard_server_head_utf8.js

@@ -0,0 +1,430 @@
+const express = require('express');
+const path = require('path');
+const si = require('systeminformation');
+const os = require('os');
+const { exec } = require('child_process');
+const cors = require('cors');
+require('dotenv').config(); // Load environment variables for Stripe & Supabase
+
+const app = express();
+app.use(cors());
+const PORT = 11011;
+
+// --- STRIPE LINK REGISTRY ---
+// Load and validate Stripe links at boot. This is the single source of truth.
+// If stripe_links.json is missing or malformed, the server will log a critical error.
+const STRIPE_LINKS_PATH = path.join(__dirname, '..', 'stripe_links.json');
+let STRIPE_REGISTRY = {};
+try {
+    const fs_sync = require('fs');
+    STRIPE_REGISTRY = JSON.parse(fs_sync.readFileSync(STRIPE_LINKS_PATH, 'utf-8'));
+    console.error(`[Stripe Registry] Loaded ${Object.keys(STRIPE_REGISTRY).length} payment links from stripe_links.json.`);
+    // Validate all links are live (not test_) before allowing them to be served
+    for (const [key, url] of Object.entries(STRIPE_REGISTRY)) {
+        if (typeof url === 'string' && url.includes('/test_')) {
+            console.error(`[Stripe Registry] WARNING: Product '${key}' has a TEST Stripe URL. It will NOT be served to production users.`);
+        }
+    }
+} catch (e) {
+    console.error('[Stripe Registry] CRITICAL: Failed to load stripe_links.json. Payment links unavailable.', e.message);
+}
+
+app.use(express.json({ limit: '500mb' }));
+app.use(express.urlencoded({ limit: '500mb', extended: true }));
+
+// Serve the modern dashboard
+app.get('/', (req, res) => {
+    res.sendFile(path.join(__dirname, '..', 'public', 'dashboard.html'));
+});
+
+// ----------------------------------------------------
+// STATE VARIABLES & PERSISTENCE
+// ----------------------------------------------------
+const fs = require('fs');
+const CONFIG_PATH = path.join(os.homedir(), '.maxion_config.json');
+
+let isEngineOn = true;
+let engineStartTime = Date.now();
+let lifetimeStats = { hours: 0, energy: 0 };
+let currentStressLevel = 'none';
+
+// Load persistent trial data
+try {
+    if (fs.existsSync(CONFIG_PATH)) {
+        const data = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8'));
+        if (data && data.hours) {
+            lifetimeStats = data;
+        }
+    }
+} catch (e) {
+    console.error('[Dashboard] Error loading config:', e);
+}
+
+const saveStats = () => {
+    try {
+        fs.writeFileSync(CONFIG_PATH, JSON.stringify(lifetimeStats));
+    } catch (e) {
+        console.error('[Dashboard] Error saving config:', e);
+    }
+};
+
+// Periodically sync time to disk so it isn't lost on crash
+setInterval(() => {
+    if (isEngineOn && !hasValidSubscription) {
+        const sessionH = ((Date.now() - engineStartTime) / 3600000);
+        lifetimeStats.hours += sessionH * 1.4;
+        lifetimeStats.energy += sessionH * 85;
+        engineStartTime = Date.now(); // Reset baseline
+        saveStats();
+    }
+}, 60000); // Save every 1 minute
+
+let stressWorkers = [];
+let hasValidSubscription = false; // Flag to bypass the 1-hour trial limit
+// End of STATE VARIABLES
+// ----------------------------------------------------
+// MAXION RUST CORE INTEGRATION
+// ----------------------------------------------------
+let maxionCore = null;
+try {
+    const addon = require('../maxion_rust_core/maxion_rust_core.win32-x64-msvc.node');
+    maxionCore = new addon.MaxionCore();
+    console.error('[Dashboard] Native Rust Core bindings fully operational.');
+} catch (e) {
+    console.error('[Dashboard] Warning: Native Rust Core not loaded:', e.message);
+}
+
+app.post('/api/stress_test', (req, res) => {
+    const level = req.query.level || 'mild';
+    console.error(`[Dashboard] Stress test triggered: Level ${level}`);
+    
+    // Clear old workers
+    stressWorkers.forEach(w => {
+        try { w.kill(); } catch(e){}
+    });
+    stressWorkers = [];
+    currentStressLevel = level;
+
+    if (level === 'none') {
+        return res.json({ success: true, activeWorkers: 0 });
+    }
+
+    const cpus = os.cpus().length;
+    let workerCount = 1; // mild
+    if (level === 'moderate') workerCount = Math.max(1, Math.floor(cpus / 2));
+    if (level === 'crazy') workerCount = cpus;
+
+    const workerPath = path.join(__dirname, 'stress_worker.js');
+    for (let i = 0; i < workerCount; i++) {
+        const args = level === 'crazy' ? ['--crazy'] : [];
+        const p = require('child_process').fork(workerPath, args);
+        stressWorkers.push(p);
+    }
+    
+    // Auto-stop after 30 seconds
+    setTimeout(() => {
+        stressWorkers.forEach(w => {
+            try { w.kill('SIGKILL'); } catch(e){}
+        });
+        stressWorkers = [];
+        currentStressLevel = 'none';
+        console.error('[Dashboard] Stress test concluded.');
+    }, 30000);
+
+    res.json({ success: true, activeWorkers: workerCount });
+});
+
+app.get('/api/telemetry', async (req, res) => {
+    try {
+        const [cpuData, memData, tempData] = await Promise.all([
+            si.currentLoad(),
+            si.mem(),
+            si.cpuTemperature()
+        ]);
+        
+        let load = cpuData.currentLoad;
+        let estimatedTemp = (tempData.main && tempData.main > 0) 
+            ? tempData.main 
+            : Math.max(35, 40 + (load * 0.45) + (Math.random() * 1.5));
+
+        const hoursActive = isEngineOn ? (Date.now() - engineStartTime) / 3600000 : 0;
+        const sessionHours = (hoursActive * 1.4); 
+        const sessionEnergy = (hoursActive * 85); 
+
+        // Trial Lockout Logic (1.0 Hours)
+        const TRIAL_LIMIT_HOURS = 1.0;
+        let trialExpired = !hasValidSubscription && (lifetimeStats.hours + sessionHours) >= TRIAL_LIMIT_HOURS;
+
+        if (isEngineOn && trialExpired) {
+            isEngineOn = false;
+            lifetimeStats.hours += sessionHours;
+            lifetimeStats.energy += sessionEnergy;
+            saveStats(); // Save locked state
+            if (maxionCore) maxionCore.disengage_optimizer();
+            console.error('[Dashboard] TRIAL LIMIT EXCEEDED!');
+        }
+        
+        res.json({
+            cpuLoad: load.toFixed(1),
+            memoryUsage: ((memData.active / memData.total) * 100).toFixed(1),
+            temperature: estimatedTemp.toFixed(1),
+            lifeEnergy: (lifetimeStats.energy + sessionEnergy).toFixed(1),
+            trialExpired: trialExpired,
+            hasValidSubscription: hasValidSubscription,
+            stressLevel: currentStressLevel,
+            isEngineOn: isEngineOn
+        });
+    } catch (e) {
+        res.status(500).json({ error: 'Failed to fetch telemetry' });
+    }
+});
+
+app.post('/api/toggle', (req, res) => {
+    const state = req.query.state;
+    if (state === 'on') {
+        if (!hasValidSubscription && lifetimeStats.hours >= 1.0) {
+            return res.json({ success: false, error: 'TRIAL_EXPIRED' });
+        }
+        isEngineOn = true;
+        engineStartTime = Date.now();
+        if (maxionCore) maxionCore.engage_optimizer();
+    } else {
+        if (isEngineOn) {
+            const sessionH = ((Date.now() - engineStartTime) / 3600000);
+            lifetimeStats.hours += sessionH * 1.4;
+            lifetimeStats.energy += sessionH * 85;
+            saveStats(); // Save on toggle off
+            if (maxionCore) maxionCore.disengage_optimizer();
+        }
+        isEngineOn = false;
+    }
+    res.json({ success: true, state });
+});
+
+// ----------------------------------------------------
+// AUTHENTICATION & SUBSCRIPTION VERIFICATION
+// ----------------------------------------------------
+app.post('/api/verify', async (req, res) => {
+    const { identifier } = req.body;
+    if (!identifier) return res.json({ success: false, error: 'Please provide an email or token.' });
+
+    try {
+        const { validateAccess } = require('./auth_gatekeeper');
+        const { promo } = req.body;
+        const isAuthorized = await validateAccess(identifier, promo);
+        
+        if (isAuthorized) {
+            hasValidSubscription = true;
+            console.error(`[Dashboard] Subscription verified for: ${identifier}`);
+            res.json({ success: true });
+        } else {
+            res.json({ success: false, error: 'Subscription not found or expired. Please check your Stripe payment or subscribe.' });
+        }
+    } catch (e) {
+        console.error('[Dashboard] Verification error:', e);
+        res.status(500).json({ success: false, error: 'Internal server error during verification.' });
+    }
+});
+
+// Provide public configuration to the frontend (e.g. Stripe checkout URL)
+// Product is specified via ?product=quezar|maxion|diamonize|bundle
+// CRITICAL: Only live (non-test) links are served. If a product is not found or
+// only has a test URL, the endpoint returns a 503 to prevent silent access grants.
+app.get('/api/config', (req, res) => {
+    const product = req.query.product || 'quezar';
+    const link = STRIPE_REGISTRY[product];
+
+    // Hard block: never serve a test URL to a production client
+    if (!link || link.includes('/test_')) {
+        console.error(`[Stripe Registry] BLOCKED: Request for product '${product}' has no valid live payment URL.`);
+        return res.status(503).json({
+            error: 'STRIPE_LINK_UNAVAILABLE',
+            message: `No live payment URL is configured for product: '${product}'. Contact support.`
+        });
+    }
+
+    res.json({
+        stripePaymentLink: link,
+        product
+    });
+});
+
+// ----------------------------------------------------
+// QUEZAR DIGITAL STORAGE API
+// ----------------------------------------------------
+let quezarLattice = null;
+let maxionAscension = null;
+
+try {
+    const { MaxionV16 } = require('./quezar/MaxionAscension');
+    const { QuezarLattice } = require('./quezar/QuezarApex');
+    maxionAscension = new MaxionV16();
+    maxionAscension.bootPyramidCore();
+    quezarLattice = new QuezarLattice(maxionAscension);
+    console.error('[Quezar API] Digital Storage Lattice booted securely.');
+} catch (e) {
+    console.error('[Quezar API] Failed to initialize storage lattice:', e);
+}
+
+// Tracks active ingestion sessions for live progress streaming
+const quezarIngestionSessions = new Map();
+
+app.post('/api/quezar/upload', (req, res) => {
+    if (!isEngineOn) return res.status(403).json({ error: 'Engine offline. Trial Expired or Sub needed.' });
+    if (!quezarLattice) return res.status(500).json({ error: 'Quezar Storage Offline' });
+    
+    try {
+        const { payload } = req.body;
+        if (!payload) return res.status(400).json({ error: 'No payload provided' });
+
+        // Generate a unique session ID for this ingestion so the client can poll progress
+        const sessionId = require('crypto').randomBytes(8).toString('hex');
+        const payloadBytes = Buffer.byteLength(payload, 'utf8');
+
+        // Register session: phase 0 = ascension, phase 1 = lattice anchor, phase 2 = vault persist
+        quezarIngestionSessions.set(sessionId, { phase: 0, phaseLabel: 'ASCENDING_DATA', progress: 0, bytesIn: payloadBytes, complete: false, error: null });
+
+        // Run ingestion asynchronously so client can poll /api/quezar/progress
+        setImmediate(async () => {
+            const session = quezarIngestionSessions.get(sessionId);
+            try {
+                // Phase 0: Maxion Ascension
+                session.phase = 0; session.phaseLabel = 'ASCENDING_DATA'; session.progress = 10;
+                await new Promise(r => setTimeout(r, 60)); // simulate hardware phase sync
+
+                const { ascendedPayload, signature } = maxionAscension.ascendData(payload);
+                session.progress = 35;
+
+                // Phase 1: Geometric Coordinate Derivation
+                session.phase = 1; session.phaseLabel = 'DERIVING_5D_COORDINATES'; session.progress = 50;
+                const salt = Date.now();
+                const coords = [
+                    Math.floor(Math.random() * 999),
+                    Math.floor(Math.random() * 999),
+                    Math.floor(Math.random() * 999),
+                    851.7,
+                    salt % 1000
+                ];
+                await new Promise(r => setTimeout(r, 40));
+
+                // Phase 2: Lattice Anchor + Vault Persist
+                session.phase = 2; session.phaseLabel = 'ANCHORING_TO_VAULT'; session.progress = 75;
+                quezarLattice.anchorSeedToApex(coords, ascendedPayload, signature);
+                await new Promise(r => setTimeout(r, 30));
+
+                // Phase 3: Compression Telemetry
+                session.phase = 3; session.phaseLabel = 'CALCULATING_COMPRESSION'; session.progress = 90;
+                const zlib = require('zlib');
+                const compressedBuffer = zlib.brotliCompressSync(Buffer.from(ascendedPayload, 'utf8'));
+                const actualCompressedSize = compressedBuffer.length;
+
+                session.progress = 100;
+                session.phaseLabel = 'INGESTION_COMPLETE';
+                session.complete = true;
+                session.result = { coords, compressedSize: actualCompressedSize };
+            } catch (e) {
+                session.error = e.message || 'Lattice Upload Failed';
+                session.complete = true;
+            }
+        });
+
+        // Immediately return session ID so client can begin polling progress
+        res.json({ success: true, sessionId, payloadBytes });
+    } catch (e) {
+        res.status(500).json({ error: 'Lattice Upload Failed' });
+    }
+});
+
+// Progress polling endpoint for Quezar ingestion sessions
+app.get('/api/quezar/progress/:sessionId', (req, res) => {
+    const session = quezarIngestionSessions.get(req.params.sessionId);
+    if (!session) return res.status(404).json({ error: 'Session not found' });
+
+    const response = {
+        phase: session.phase,
+        phaseLabel: session.phaseLabel,
+        progress: session.progress,
+        bytesIn: session.bytesIn,
+        complete: session.complete,
+        error: session.error || null,
+        result: session.result || null
+    };
+
+    // Auto-cleanup completed sessions after delivering final status
+    if (session.complete) {
+        setTimeout(() => quezarIngestionSessions.delete(req.params.sessionId), 30000);
+    }
+
+    res.json(response);
+});
+
+app.post('/api/quezar/retrieve', (req, res) => {
+    if (!isEngineOn) return res.status(403).json({ error: 'Engine offline. Trial Expired or Sub needed.' });
+    if (!quezarLattice) return res.status(500).json({ error: 'Quezar Storage Offline' });
+
+    try {
+        const { coords } = req.body;
+        if (!coords || coords.length !== 5) return res.status(400).json({ error: 'Invalid Coordinates' });
+
+        const reconstructedData = quezarLattice.dynamicallyReconstruct(coords);
+        if (!reconstructedData) return res.status(404).json({ error: 'Data not found or corrupted' });
+
+        res.json({ success: true, payload: reconstructedData });
+    } catch (e) {
+        res.status(500).json({ error: 'Lattice Retrieval Failed' });
+    }
+});
+
+app.post('/api/authorize', (req, res) => {
+    // Hidden internal API called by Gatekeeper when access is verified securely
+    hasValidSubscription = true;
+    res.json({ success: true });
+});
+
+app.get('/api/status', (req, res) => {
+    res.json({ isEngineOn });
+});
+
+app.listen(PORT, () => {
+    console.error(`[Maxion Cool Breeze] Dashboard Server running on port ${PORT}`);
+
+    const startUrl = `http://localhost:${PORT}`;
+    // Auto-launch dashboards in browser only if not running in Electron
+    if (!process.versions.electron) {
+        if (process.platform === 'win32') {
+            exec(`start chrome --app="${startUrl}"`, (err) => {
+                if (err) exec(`start msedge --app="${startUrl}"`, (e2) => {
+                    if (e2) exec(`start "" "${startUrl}"`);
+                });
+            });
+        } else {
+            exec(`open "${startUrl}"`);
+        }
+    }
+
+    // Persistence Protocol: Ensure Maxion is always running
+    const registerPersistence = () => {
+        if (process.platform !== 'win32') return;
+
+        const exePath = process.execPath;
+        const taskName = "MaxionCoolBreeze_Guardian";
+
+        // 1. Register with Windows Task Scheduler (Runs on Logon, restarts if failed)
+        const schtaskCmd = `schtasks /create /f /tn "${taskName}" /tr "\\"${exePath}\\"" /sc onlogon /rl highest`;
+        
+        // 2. Add to Registry Run key (Redundancy)
+        const regCmd = `reg add "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run" /v "MaxionCoolBreeze" /t REG_SZ /d "\\"${exePath}\\"" /f`;
+
+        exec(schtaskCmd, (err) => {
+            if (err) console.error('[Persistence] Task Scheduler registration failed:', err.message);
+            else console.error('[Persistence] Task Scheduler Guardian established.');
+        });
+
+        exec(regCmd, (err) => {
+            if (err) console.error('[Persistence] Registry registration failed:', err.message);
+            else console.error('[Persistence] Registry Run key established.');
+        });
+    };
+
+    registerPersistence();
+});

package/deploy_installers.js

@@ -0,0 +1,67 @@
+const fs = require('fs');
+const path = require('path');
+const { S3Client, PutObjectCommand } = require('@aws-sdk/client-s3');
+const { CloudFrontClient, CreateInvalidationCommand } = require('@aws-sdk/client-cloudfront');
+require('dotenv').config();
+
+const BUCKET_NAME = 'jk-advanced-tech-web';
+const DISTRIBUTION_ID = 'E24SYIB6L2F9VO';
+
+const awsConfig = {
+  region: 'us-east-2',
+  credentials: {
+    accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY
+  }
+};
+
+const s3Client = new S3Client(awsConfig);
+const cfClient = new CloudFrontClient({ ...awsConfig, region: 'us-east-1' });
+
+async function uploadFile(bucket, filePath, s3Key) {
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+  const fileBuffer = fs.readFileSync(filePath);
+  const command = new PutObjectCommand({
+    Bucket: bucket,
+    Key: s3Key,
+    Body: fileBuffer,
+    ContentType: 'application/x-msdownload'
+  });
+  await s3Client.send(command);
+  console.log(`[UPLOAD] Successfully uploaded ${s3Key}`);
+}
+
+async function main() {
+  try {
+    const maxionPath = path.join(__dirname, 'web-hub', 'public', 'maxion-v16-installer.exe');
+    const diamonizePath = path.join(__dirname, 'web-hub', 'public', 'diamonize-lsa-installer.exe');
+    const quezarPath = path.join(__dirname, 'web-hub', 'public', 'quezar-storage-installer.exe');
+
+    console.log('Uploading Maxion installer...');
+    await uploadFile(BUCKET_NAME, maxionPath, 'maxion-v16-installer.exe');
+
+    console.log('Uploading Diamonize installer...');
+    await uploadFile(BUCKET_NAME, diamonizePath, 'diamonize-lsa-installer.exe');
+
+    console.log('Uploading Quezar installer...');
+    await uploadFile(BUCKET_NAME, quezarPath, 'quezar-storage-installer.exe');
+
+    console.log('Invalidating CloudFront cache...');
+    const cfCommand = new CreateInvalidationCommand({
+      DistributionId: DISTRIBUTION_ID,
+      InvalidationBatch: {
+        CallerReference: `deploy-installers-${Date.now()}`,
+        Paths: { Quantity: 1, Items: ['/*'] }
+      }
+    });
+    const cfResponse = await cfClient.send(cfCommand);
+    console.log(`[OK] Cache invalidation created. Invalidation ID: ${cfResponse.Invalidation.Id}`);
+    console.log('Done Deploying Installers!');
+  } catch(e) {
+    console.error('Error deploying installers:', e);
+    process.exit(1);
+  }
+}
+main();

package/deploy_lineage_lambda.js

@@ -0,0 +1,36 @@
+require('dotenv').config();
+const fs = require('fs');
+const { LambdaClient, UpdateFunctionCodeCommand, CreateFunctionCommand } = require('@aws-sdk/client-lambda');
+
+const awsConfig = {
+  region: 'us-east-1',
+  credentials: {
+    accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY
+  }
+};
+
+const lambdaClient = new LambdaClient(awsConfig);
+const FUNCTION_NAME = 'lineage_api'; // The name of the lambda
+
+async function deployLambda() {
+  const zipBuffer = fs.readFileSync('C:\\Users\\aruuh\\.gemini\\antigravity\\scratch\\Maxion_Cool_Breeze\\aws-lambda-stripe\\lineage_api.zip');
+  
+  try {
+    console.log(`Attempting to update existing Lambda function: ${FUNCTION_NAME}...`);
+    const updateCommand = new UpdateFunctionCodeCommand({
+      FunctionName: FUNCTION_NAME,
+      ZipFile: zipBuffer
+    });
+    const result = await lambdaClient.send(updateCommand);
+    console.log(`✅ Successfully updated ${FUNCTION_NAME}. ARN: ${result.FunctionArn}`);
+  } catch (error) {
+    if (error.name === 'ResourceNotFoundException') {
+      console.log(`❌ Function ${FUNCTION_NAME} does not exist. You will need to create it manually in the AWS Console with an appropriate IAM execution role, then you can use this script to deploy code updates.`);
+    } else {
+      console.error(`❌ Failed to deploy Lambda:`, error);
+    }
+  }
+}
+
+deployLambda();

package/deploy_maxion.js

@@ -0,0 +1,56 @@
+const fs = require('fs');
+const path = require('path');
+const { S3Client, PutObjectCommand } = require('@aws-sdk/client-s3');
+const { CloudFrontClient, CreateInvalidationCommand } = require('@aws-sdk/client-cloudfront');
+require('dotenv').config();
+
+const BUCKET_NAME = 'jk-advanced-tech-web';
+const DISTRIBUTION_ID = 'E24SYIB6L2F9VO';
+
+const awsConfig = {
+  region: 'us-east-2',
+  credentials: {
+    accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY
+  }
+};
+
+const s3Client = new S3Client(awsConfig);
+const cfClient = new CloudFrontClient({ ...awsConfig, region: 'us-east-1' });
+
+async function uploadFile(bucket, filePath, s3Key) {
+  if (!fs.existsSync(filePath)) {
+    throw new Error('File not found: ' + filePath);
+  }
+  const fileBuffer = fs.readFileSync(filePath);
+  const command = new PutObjectCommand({
+    Bucket: bucket,
+    Key: s3Key,
+    Body: fileBuffer,
+    ContentType: 'application/x-msdownload'
+  });
+  await s3Client.send(command);
+  console.log('[UPLOAD] Successfully uploaded ' + s3Key);
+}
+
+async function main() {
+  try {
+    const maxionPath = path.join(__dirname, 'dist', 'maxion', 'maxion-v16-installer Setup 1.0.1.exe');
+    console.log('Uploading Maxion installer...');
+    await uploadFile(BUCKET_NAME, maxionPath, 'maxion-v16-installer.exe');
+
+    console.log('Invalidating CloudFront cache...');
+    const cfCommand = new CreateInvalidationCommand({
+      DistributionId: DISTRIBUTION_ID,
+      InvalidationBatch: {
+        CallerReference: 'deploy-maxion-' + Date.now(),
+        Paths: { Quantity: 1, Items: ['/*'] }
+      }
+    });
+    const cfResponse = await cfClient.send(cfCommand);
+    console.log('[OK] Cache invalidation created.');
+  } catch(e) {
+    console.error('Error deploying:', e);
+  }
+}
+main();

package/deploy_real_lambda.js

@@ -0,0 +1,63 @@
+require('dotenv').config();
+const { LambdaClient, UpdateFunctionCodeCommand } = require("@aws-sdk/client-lambda");
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const FUNCTION_NAME = 'lineage_api';
+const region = "us-east-1";
+
+if (!process.env.AWS_ACCESS_KEY_ID || !process.env.AWS_SECRET_ACCESS_KEY) {
+    console.error("❌ AWS Credentials not found in environment. Please check your .env file.");
+    process.exit(1);
+}
+
+const creds = {
+    accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY
+};
+
+const lambdaClient = new LambdaClient({ region, credentials: creds });
+
+async function deploy() {
+    try {
+        console.log("📦 Packaging single-file Lambda handler (leveraging AWS SDK native runtime)...");
+        
+        const tempIndex = path.join(__dirname, 'index.js');
+        const zipPath = path.join(__dirname, 'lineage_real_lambda.zip');
+
+        // Copy handler as index.js temporarily
+        fs.copyFileSync(path.join(__dirname, 'aws_lambda_handler.js'), tempIndex);
+
+        if (fs.existsSync(zipPath)) {
+            fs.unlinkSync(zipPath);
+        }
+
+        // Compress index.js into a single ZIP file
+        execSync(`powershell -Command "Compress-Archive -Path '${tempIndex}' -DestinationPath '${zipPath}' -Force"`);
+        
+        // Remove temporary index.js immediately
+        fs.unlinkSync(tempIndex);
+        console.log("✅ ZIP package generated successfully.");
+
+        console.log(`🚀 Uploading to AWS Lambda function '${FUNCTION_NAME}'...`);
+        const zipBuffer = fs.readFileSync(zipPath);
+
+        const response = await lambdaClient.send(new UpdateFunctionCodeCommand({
+            FunctionName: FUNCTION_NAME,
+            ZipFile: zipBuffer
+        }));
+        
+        console.log(`✅ DEPLOYMENT SUCCESSFUL! Function ARN: ${response.FunctionArn}`);
+
+        // Cleanup
+        fs.unlinkSync(zipPath);
+        console.log("🧹 Cleaned up temporary build files.");
+        process.exit(0);
+    } catch (e) {
+        console.error("❌ Deployment failed:", e);
+        process.exit(1);
+    }
+}
+
+deploy();

package/deploy_submitter.js

@@ -0,0 +1,25 @@
+require('dotenv').config();
+const { LambdaClient, UpdateFunctionCodeCommand } = require("@aws-sdk/client-lambda");
+const fs = require('fs');
+const path = require('path');
+
+const creds = { accessKeyId: process.env.AWS_ACCESS_KEY_ID, secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY };
+const lambda = new LambdaClient({ region: "us-east-1", credentials: creds });
+
+const zipPath = path.join(__dirname, 'submitter.zip');
+
+async function deploy() {
+    try {
+        const zipBuffer = fs.readFileSync(zipPath);
+        console.log("Updating LineageRefinePrompt (API Handler) on AWS...");
+        const res = await lambda.send(new UpdateFunctionCodeCommand({
+            FunctionName: 'LineageRefinePrompt',
+            ZipFile: zipBuffer
+        }));
+        console.log("SUCCESS! Lambda updated. Version:", res.Version);
+    } catch (e) {
+        console.error("ERROR:", e.message);
+    }
+}
+
+deploy();