Spaces:
Running
Running
File size: 7,864 Bytes
4bd8362 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 | // Nivel 2 dentro del host de extensiones (js/ext/host.js): encender y apagar
// el código de una extensión, leer y guardar sus ficheros al instalarla con su
// código, sus ajustes y su formateador por lenguaje, y el puente con el
// recinto (bridge.js). host.js solo lo importa cuando hace falta: alguna
// extensión con su código encendido, o el usuario pide algo de esto. Quien solo
// usa temas, gramáticas y snippets no baja nada de aquí.
import * as store from '../ext/store.js';
// TODOS los ficheros del paquete bajo extension/, en bytes, para entregarlos al
// recinto al encenderla. Fuera node_modules/** y los *.map, y ninguna ruta que
// salga del paquete. Topes contados sobre lo que sale al descomprimir: 32 MiB
// por fichero y 64 MiB por extensión. La página nunca ejecuta estos bytes.
export const RAW_MAX_ENTRY = 32 << 20, RAW_MAX_TOTAL = 64 << 20;
export async function readVsixRaw(bytes, { maxEntry = RAW_MAX_ENTRY, maxTotal = RAW_MAX_TOTAL } = {}) {
const { openZip } = await import('../ext/unzip.js');
const zip = openZip(bytes, { maxEntry, maxTotal });
const files = new Map();
let total = 0;
for (const name of zip.names) {
if (!name.startsWith('extension/')) continue;
const rel = name.slice('extension/'.length);
if (!rel || /(^|\/)node_modules\//.test(rel) || /\.map$/i.test(rel)) continue;
if (rel.startsWith('/') || rel.split('/').some(s => s === '..' || s === '.' || s === '')) continue;
const data = await zip.read(name);
total += data.length;
files.set(rel, data);
}
return { files, bytes: total };
}
// La entrada `browser` del manifiesto como fichero del paquete
// («./dist/web/extension» → «dist/web/extension.js»), o null si no está.
export function browserEntry(manifest, names) {
if (!manifest || typeof manifest.browser !== 'string') return null;
const base = manifest.browser.replace(/^\.\//, '').replace(/\\/g, '/');
for (const c of [base, base + '.js', base + '/index.js']) if (names.has(c)) return c;
return null;
}
// [[ruta, ArrayBuffer]] del código guardado de una extensión
export async function readCode(rec) {
const paths = Array.isArray(rec?.code?.files) ? rec.code.files : [];
const vals = await store.getFiles(paths.map(p => store.codeKey(rec.id, rec.version, p)));
return paths.map((p, i) => {
const v = vals[i];
if (v === undefined) throw Object.assign(new Error('falta ' + p), { code: 'missing' });
const buf = v instanceof ArrayBuffer ? v.slice(0) : ArrayBuffer.isView(v) ? v.buffer.slice(v.byteOffset, v.byteOffset + v.byteLength) : new TextEncoder().encode(String(v)).buffer;
return [p, buf];
});
}
// Antes de encender el código de una extensión: el diálogo de consentimiento
// del panel (qué verá, que no tiene red, cuánto se baja).
async function confirmaTamano({ runtimeBytes, extensionBytes, name, rec }) {
const { consent } = await import('./manage.js');
return (await consent({ name, publisher: rec?.publisher, version: rec?.version, license: rec?.license, runtime: { bytes: runtimeBytes }, extensionBytes, mode: 'run' })) === 'code';
}
const PARADO = { state: 'stopped', extensions: [], commands: [] };
// h: lo que host.js comparte (ver allí): monaco, exts(), recarga(), emit(),
// paused, sinCodigo, listeners (los del panel) y uiTheme()
const KIND = { vs: 'light', 'hc-black': 'hc', 'hc-light': 'hc-light' };
const kindOf = uiTheme => KIND[uiTheme] || 'dark'; // claro, oscuro o contraste
export function attach(h) {
let puente = null, cargando = null;
const corren = () => (h.paused || h.sinCodigo ? [] : h.exts().filter(e => e.enabled && e.runs));
// Con alguna extensión con su código encendido, el recinto arranca (en
// paralelo: ide.js crea el editor después y el puente lo espera); sin
// ninguna, se desmonta. La lista se lee al sincronizar, no al pedirlo: dos
// cambios seguidos (instalar dos, encender y apagar) no pueden dejar el
// recinto con una lista vieja.
function sync() {
if (!corren().length && !puente && !cargando) return;
(async () => {
cargando ??= import('./bridge.js').then(m => {
m.onChange(() => { for (const f of h.listeners) { try { f(); } catch { /* — */ } } });
return m;
});
puente = await cargando;
puente.setTheme(kindOf(h.uiTheme()));
await puente.sync({ monaco: h.monaco, records: corren(), readCode });
h.emit();
})().catch(e => console.warn('[elffuss-ext] nivel 2:', e?.message || e));
}
// Instalar con su código (el usuario ya aceptó): los bytes del paquete por
// ruta, la entrada `browser`, encendida salvo que estuviera apagada antes, y
// sus ajustes y su formateador si ya los tenía (una actualización).
async function codeFiles(v, bytes, previo) {
if (typeof v.manifest.browser !== 'string') throw Object.assign(new Error('sin código para navegador'), { code: 'nocode' });
const raw = await readVsixRaw(bytes);
const entry = browserEntry(v.manifest, raw.files);
if (!entry) throw Object.assign(new Error('la entrada browser no está en el paquete'), { code: 'noentry' });
const files = new Map();
for (const [p, data] of raw.files) files.set(store.codeKey(v.id, v.version, p), data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength));
return {
files,
fields: {
code: { entry, files: [...raw.files.keys()], bytes: raw.bytes, manifest: v.manifest },
runs: previo?.code ? !!previo.runs : true,
settings: previo?.settings || {}, formatter: previo?.formatter || {},
},
};
}
// Encender el código: la primera vez enseña cuánto se va a bajar ANTES de
// bajar nada; cancelar no cambia nada.
async function setRuns(id, on, { confirm = confirmaTamano } = {}) {
const rec = h.exts().find(e => e.id === id);
if (!rec) throw Object.assign(new Error('no instalada: ' + id), { code: 'missing' });
if (on) {
if (typeof rec.code?.manifest?.browser !== 'string') throw Object.assign(new Error('sin código para navegador'), { code: 'nocode' });
const { runtimeInfo } = await import('./vendor.js');
const info = await runtimeInfo();
if (!info.available) throw Object.assign(new Error('nivel 2 no disponible: ' + info.reason), { code: 'x2-' + info.reason });
if (!info.cached && !(await confirm({ runtimeBytes: info.bytes, extensionBytes: rec.code.bytes || 0, name: rec.displayName || rec.id, id, rec }))) return false;
}
await store.update(id, r => { r.runs = !!on; });
await h.recarga();
return true;
}
// Ajustes (validados por el panel contra lo que la extensión declara) y
// formateador por lenguaje: se aplican sin recargar.
async function setSettings(id, settings) {
if (!settings || typeof settings !== 'object' || Array.isArray(settings)) throw Object.assign(new Error('los ajustes son un objeto JSON'), { code: 'settings' });
await store.update(id, r => { r.settings = structuredClone(settings); }, { mirror: false });
await h.recarga();
}
async function setFormatter(id, lang, choice) {
const rec = h.exts().find(e => e.id === id);
if (!rec || typeof lang !== 'string' || !['extension', 'builtin'].includes(choice)) return;
await store.update(id, r => { r.formatter = { ...(r.formatter || {}), [lang]: choice }; }, { mirror: false });
await h.recarga();
}
// ¿está disponible el nivel 2 aquí? (navegador, sitio, interruptor) y su tamaño
const runtime = async () => (h.paused || h.sinCodigo ? { available: false, reason: 'url' } : (await import('./vendor.js')).runtimeInfo());
return {
sync, codeFiles, setRuns, setSettings, setFormatter, runtime,
setTheme: uiTheme => puente?.setTheme(kindOf(uiTheme)),
state: () => (puente ? puente.state() : PARADO),
commands: () => (puente ? puente.commands() : []),
};
}
|