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() : []),
  };
}