TC$mC$ ratkaistaan rakentamalla verkkoon Asynkroninen OOB-Silta
(Store-and-Forward Proxy).
Koska meidC$n Mesh-verkkomme ydin perustuu jo valmiiksi tC$ysin asynkroniseen
viestinvC$litykseen (MeshRPC:n reqId ja pendingRequests -kartta) ja
JSON-paketteihin, verkon ei tarvitse tietC$C$, siirtyykC6 paketti TCP-sokettia
pitkin mikrosekunnissa vai kuljetetaanko se USB-tikulla fyysisen ilmaraon yli
kerran pC$ivC$ssC$.
TC$ssC$ on arkkitehtuuri ja toteutusmalli sille, miten airgap-laitteet ja
tuntemattomat protokollat integroidaan osaksi olemassa olevaa verkkoa.
1. Ydinkonsepti: OMEGA-tyylinen Virtuaalireititys
Airgap-laitteella ei ole dynaamista verkko-osoitetta. Siksi osoitteistus
ratkaistaan Virtuaalisilla Target ID:illC$.
 * Annat airgap-laitteelle staattisen nimen, esim. targetId: "airgap-vault-1".
 * Mesh-verkossa (esim. AlphaGatewaylla) pyC6rii uusi vC$lityspalvelin, OOB
Bridge Node.
 * Silta ilmoittaa verkolle reitityssC$C$nnC6n: "MinC$ otan vastaan kaikki
viestit, joiden kohde on airgap-vault-1."
 * Kun silta saa viestin, se katkaisee normaalin verkkoprotokollan,
sarjallistaa JSON-paketin ja siirtC$C$ sen fyysiseen tai loogiseen
In/Out-postilaatikkoon.
2. Prototyyppi: In/Out Mailbox Silta (TiedostojC$rjestelmC$)
Jos ilmaraon ylitys tapahtuu jaetun kansion, virtuaalisen tiedostojC$rjestelmC$
n (esim. MeshFS-tyyppisen ratkaisun) tai verkkolevyn kautta, silta on
C$C$rimmC$isen yksinkertainen.
TC$ssC$ on konseptuaalinen oob_bridge.js, joka liittC$C$ hakemistopohjaisen
postilaatikon suoraan meidC$n HybridMeshNode -runkoon:
import fs from 'fs';
import path from 'path';
import { HybridMeshNode } from './mesh.js';

const INBOX_DIR = path.resolve('./airgap_inbox');   // Airgap-koneen
kirjoittamat vastaukset
const OUTBOX_DIR = path.resolve('./airgap_outbox'); // MeshistC$ Airgapille
lC$htevC$t pyynnC6t

/ Varmistetaan hakemistot
[INBOX_DIR, OUTBOX_DIR].forEach(d => { if (!fs.existsSync(d)) fs.mkdirSync(d,
{ recursive: true }); });

const bridgeNode = new HybridMeshNode("OOB_File_Bridge");

async function main() {
    await bridgeNode.start();
    console.log("[OOB Bridge] KC$ynnissC$. Tarkkaillaan postilaatikoita...");

    // 1. MESH -> AIRGAP (Kuunnellaan Mesh-verkkoa)
    for await (const msg of bridgeNode.inbox) {
        // Otetaan kiinni vain ne viestit, jotka on osoitettu
airgap-laitteille
        if (msg.targetId === "airgap-vault-1") {
            const fileName = `msg_${msg.msgId}_${Date.now()}.json`;
            const filePath = path.join(OUTBOX_DIR, fileName);
            
            // Kirjoitetaan raaka Mesh-viestitaulukko tiedostoksi
postilaatikkoon
            fs.writeFileSync(filePath, JSON.stringify([
                msg.version, msg.type, msg.msgId, msg.senderId, msg.targetId,
msg.ttl, msg.tags, msg.payload
            ]));
            console.log(`[OOB Bridge] Viesti reititetty Outboxiin:
${fileName}`);
        }
    }
}

/ 2. AIRGAP -> MESH (Pollaataan Inboxia vastausten varalta)
setInterval(() => {
    const files = fs.readdirSync(INBOX_DIR);
    for (const file of files) {
        if (file.endsWith('.json')) {
            const filePath = path.join(INBOX_DIR, file);
            try {
                const rawData = fs.readFileSync(filePath, 'utf8');
                
                // SyC6tetC$C$n airgap-laitteen kirjoittama vastaus takaisin
Mesh-verkon ytimeen!
                // TC$mC$ triggerC6i normaalin Flooding/Gossip -reitityksen
takaisin alkuperC$iselle kysyjC$lle.
                bridgeNode._handleIncoming(rawData, null, 'OOB');
                
                // Arkistoidaan tai poistetaan kC$sitelty viesti
                fs.unlinkSync(filePath);
                console.log(`[OOB Bridge] Vastaus luettu Inboxista ja
injektoitu Meshiin: ${file}`);
            } catch (err) {
                console.error(`Virhe luettaessa OOB-tiedostoa ${file}:`,
err.message);
            }
        }
    }
}, 5000); // PollausvC$li 5 sekuntia

main();

3. Airgap-Noden logiikka (Tuntemattoman rajan takana)
Airgap-koneessa pyC6rivC$ ohjelmisto ei tarvitse TCP/UDP-soketteja eikC$
mesh.js -verkkokerrosta lainkaan. Sille riittC$C$ pelkkC$ liiketoimintalogiikka
 ja kyky lukea/kirjoittaa JSON-tiedostoja.
Sen tyC6kierto on:
 * Skannaa airgap_outbox -kansiota (joka on sille Inbox).
 * Kun uusi tiedosto ilmestyy, pura JSON.
 * Jos tags sisC$ltC$C$ ["api"] ja endpoint on tunnettu, suorita rutiini
(esim. lue salainen tiedosto, tee kryptografinen allekirjoitus).
 * Kirjoita tulos airgap_inbox -kansioon alkuperC$isellC$ msgId:llC$ ja
["api-res"] -tagilla varustettuna.
 * Poista alkuperC$inen pyyntC6tiedosto.
Laajennettavuus muihin OOB-protokolliin
TC$mC$ sama Proxy/Router-prototyyppi mukautuu triviaalisti mihin tahansa
siirtotiehen ilman, ettC$ Mesh-verkon muiden solmujen koodia tarvitsee muuttaa
tavuakaan:
 * Yksisuuntaiset sarjakaapelit (Unidirectional Serial): Jos rakennat
serial-to-IRC -tyyppisen sillan, OOB Bridge avaa /dev/ttyUSB0 portin.
fs.writeFileSync korvautuu serialPort.write(JSON) -kutsulla. Airgap-kone lukee
sarjaportin puskuria.
 * SC$hkC6posti / IRC-kanavat: Bridge-node voi kC$yttC$C$ IRC-bottia tai
IMAP-sC$hkC6postilaatikkoa transporttina. Base64-koodattu Mesh-paketti
lC$hetetC$C$n yksityisviestinC$ kanavalle, josta airgap-verkon puolella oleva
vastaanotin lukee sen.
 * Irrotettavat mediat (USB Dead Drops): Bridge-node havaitsee, kun /media/usb
liitetC$C$n (mount). Se siirtC$C$ kaikki jonossa olevat Mesh-viestit tikulle
ja lukee tikulla olevat vastaukset sisC$C$n. Tikun siirto fyysisesti
airgap-koneeseen on verkon nC$kC6kulmasta vain "verkkolatenssia", jota MeshRPC
sietC$C$ loistavasti, kunhan selaimen tai backendin asettama timeout on
konfiguroitu riittC$vC$n pitkC$ksi (esim. 24 tuntia).
Mesh-arkkitehtuurisi "viestin id ja asynkroninen kuitti" -malli tekee tC$stC$
saumatonta. LC$hettC$jC$ vain kutsuu meshFetch("airgap-vault-1/get_keys"), ja
Promise resolvaa joko millisekuntien, minuuttien tai pC$ivien kuluttua
riippuen siitC$, milloin In/Out-postilaatikko synkronoidaan.