talos-code 0.0.1 → 0.2.0

package/vendor/harness-ui/src/plugin-session.mjs

@@ -0,0 +1,180 @@
+/**
+ * plugin-session.mjs — FASE G del piano `elegant-spinning-dongarra.md`,
+ * esecuzione (29/8): il punto che UNISCE `plugin-registry.mjs` (quali
+ * plugin sono dichiarati e fidati) in quello che una sessione REALE
+ * offre al kernel — `toolPlugin` + `eseguiToolPluginFn`, esattamente
+ * la forma che `talosLavora` accetta (vedi
+ * `AVM-harness/.../talosHarness.mjs`, commit `b9065891`) — più
+ * `hookPlugin`, gli hook dei plugin fidati pronti per fondersi
+ * nell'elenco che `hook-registry.mjs` già produce (vedi la doc su
+ * `costruisciHookFn` in `session-registry.mjs`).
+ *
+ * Mirror di `mcp-session.mjs`, con differenze deliberate:
+ * - EAGER come MCP (i tool devono essere noti PRIMA della prima
+ *   chiamata al modello), ma senza connessione persistente: un tool
+ *   di plugin non è un processo che resta vivo, è un comando lanciato
+ *   ON-DEMAND ad ogni chiamata (spawn, non connect+call) — più vicino
+ *   a come l'attrezzo `shell` del kernel gira un comando, che al
+ *   protocollo MCP.
+ * - Nome esposto SEMPRE prefissato `plugin__<pluginId>__<toolName>`
+ *   (stessa convenzione di `mcp__<serverId>__<toolName>` in
+ *   `mcp-session.mjs`) — due plugin indipendenti possono dichiarare
+ *   un tool con lo stesso nome, e non sanno l'uno dell'altro.
+ * - Solo i plugin FIDATI (`verificaTrustPlugin`, hash sull'INTERO
+ *   manifesto — non per componente, vedi `plugin-registry.mjs`)
+ *   contribuiscono tool E hook. Un plugin mai fidato, o il cui
+ *   manifesto è cambiato da quando è stato fidato, resta interamente
+ *   inerte: zero tool offerti, zero hook nella lista tornata.
+ * - `hookPlugin` porta id GIÀ QUALIFICATI (`plugin:<pluginId>:<hookId>`)
+ *   per non collidere con un hook scritto a mano in
+ *   `.harness-ui-hooks.json` o con l'omonimo di un altro plugin, e
+ *   NON porta un hash da verificare di nuovo altrove: la fiducia è già
+ *   stata accertata QUI (sul plugin intero) — chi fonde questo elenco
+ *   (`costruisciHookFn`) tratta ogni voce di `hookPlugin` come
+ *   già-fidata, mai una seconda verifica nella cartella di trust degli
+ *   hook singoli (namespace di trust diverso, per costruzione: un
+ *   hook standalone è fidato per HASH DEL SUO COMANDO, un hook di
+ *   plugin per HASH DELL'INTERO MANIFESTO — mischiare i due namespace
+ *   sarebbe un bug di sicurezza, non una semplificazione).
+ */
+import {
+  caricaPlugin as caricaPluginReale,
+  verificaTrustPlugin as verificaTrustPluginReale,
+} from './plugin-registry.mjs';
+import { createProcessPolicy, parseProcessCommand } from './process-policy.mjs';
+
+const SEPARATORE = '__';
+const PREFISSO = `plugin${SEPARATORE}`;
+// ⭐ un tool di plugin è un comando singolo, non un giro di test — più di un hook (10s, hook-registry.mjs) ma meno di eseguiProva nel kernel (120s): non è né un controllo rapido né un'intera suite.
+const TIMEOUT_MS = 60_000;
+
+/** Pura: costruisce il nome esposto al modello. Un test la esercita senza spawnare nulla. */
+export function nomeEspostoPlugin(pluginId, nomeTool) {
+  return `${PREFISSO}${pluginId}${SEPARATORE}${nomeTool}`;
+}
+
+/** Pura: l'id qualificato di un hook di plugin, per non collidere con hook standalone o di un altro plugin. */
+export function hookIdQualificato(pluginId, hookId) {
+  return `plugin:${pluginId}:${hookId}`;
+}
+
+/**
+ * Esegue `comando` come sottoprocesso locale (shell, cwd della
+ * sessione), passando gli argomenti della tool-call via una variabile
+ * d'ambiente (`TALOS_PLUGIN_TOOL_ARGS`, JSON — stesso principio già
+ * in uso in `eseguiHook` per `TALOS_HOOK_EVENT`: mai un templating
+ * della stringa comando, che aprirebbe a injection).
+ *
+ * ⭐ Un codice di uscita non-zero è un ESITO del comando, non un
+ * guasto del canale — risolve comunque, con l'output annotato, stesso
+ * principio già in uso per `shell`/`prova` nel kernel: il modello lo
+ * vede e si adatta. Solo un vero guasto di spawn (comando introvabile,
+ * permessi) rigetta la Promise — diventa "plugin tool call failed:
+ * ..." nel kernel, la stessa distinzione già presa per
+ * `chiamaToolMcpFn`.
+ */
+export async function eseguiComandoPlugin({ comando, argomenti, cartella }, deps = {}) {
+  const [executable, ...args] = parseProcessCommand(comando);
+  const envKeys = ['PATH', 'Path', 'PATHEXT', 'SystemRoot', 'WINDIR', 'COMSPEC', 'TALOS_PLUGIN_TOOL_ARGS'];
+  const allowedExecutables = deps.allowedExecutables ?? ['node', 'node.exe', 'echo', 'echo.exe'];
+  const policy = createProcessPolicy({
+    allowedExecutables,
+    capabilities: { plugin: cartella },
+    envAllowlist: envKeys,
+    spawnFn: deps.spawnFn,
+  });
+  const result = await policy.runApprovedProcess({
+    executable,
+    args,
+    cwd: cartella,
+    capability: 'plugin',
+    timeoutMs: TIMEOUT_MS,
+    envKeys,
+    env: { TALOS_PLUGIN_TOOL_ARGS: JSON.stringify(argomenti ?? {}) },
+    captureLimitBytes: 64 * 1024,
+  });
+  const testoFuori = result.stdout.trim();
+  const testoErrori = result.stderr.trim();
+  if (result.code === 0) return testoFuori || '(nessun output)';
+  return [`comando terminato con codice ${result.code}`, testoErrori, testoFuori].filter(Boolean).join('\n');
+}
+
+/**
+ * Carica i plugin del workspace, li filtra a quelli FIDATI, e torna
+ * `{toolPlugin, eseguiToolPluginFn, hookPlugin, falliti}` pronto per
+ * `talosLavora`/`costruisciHookFn`.
+ *
+ * `falliti`: `{pluginId, errore}[]` — mai usata oggi (un plugin fidato
+ * non ha un passo di "connessione" che possa fallire, a differenza di
+ * MCP) ma tornata per SIMMETRIA con `preparaToolMcpPerSessione` e per
+ * non chiudere la porta a un fallimento futuro (es. un `parametri`
+ * malformato scoperto solo qui) — un array vuoto oggi è un fatto
+ * onesto, non un placeholder.
+ */
+export async function preparaToolPluginPerSessione({ cartella, cartellaTrust }, deps = {}) {
+  const caricaPluginFn = deps.caricaPluginFn ?? caricaPluginReale;
+  const verificaTrustPluginFn = deps.verificaTrustPluginFn ?? verificaTrustPluginReale;
+  const eseguiComandoPluginFn = deps.eseguiComandoPluginFn ?? eseguiComandoPlugin;
+
+  let plugin = [];
+  /*
+   * ⛔⛔ A-4 (17/09/2026) — `falliti` MORIVA QUI. Questa funzione dichiara di tornare `falliti` e
+   *   tornava sempre `[]`, perché scartava quello che `caricaPlugin` le dava. Dal secondo giro
+   *   `caricaPlugin` raccoglie i guasti PER PLUGIN (un collegamento, troppi file, un comando che
+   *   esce dalla cartella): buttarli qui significa che un pacchetto guasto sparisce dalla sessione
+   *   senza che niente dica perché — cioè il difetto che quei `falliti` esistono per chiudere.
+   * ⛔ Il commento storico qui sotto («mai usata oggi») non vale più: adesso è piena.
+   */
+  let falliti = [];
+  try {
+    ({ plugin, falliti = [] } = await caricaPluginFn({ cartella }));
+  } catch {
+    // ⭐ stesso principio di hook/MCP: un manifesto malformato non blocca la sessione, degrada a "nessun plugin".
+    return { toolPlugin: [], eseguiToolPluginFn: null, hookPlugin: [], falliti: [] };
+  }
+
+  const toolPlugin = [];
+  const hookPlugin = [];
+  const instradamento = new Map(); // nomeEsposto -> { comando }
+
+  for (const p of plugin) {
+    let fidato = false;
+    try {
+      fidato = await verificaTrustPluginFn({ cartellaTrust, pluginId: p.id, hash: p.hash });
+    } catch {
+      fidato = false; // un registro di trust che non si legge non autorizza in silenzio
+    }
+    if (!fidato) continue; // un plugin non fidato è come se non esistesse — zero tool, zero hook
+
+    for (const t of p.tools) {
+      const nomeEsposto = nomeEspostoPlugin(p.id, t.nome);
+      toolPlugin.push({ nome: nomeEsposto, descrizione: t.descrizione, parametri: t.parametri });
+      /*
+       * ⛔⛔⛔ A-3 (17/09/2026): nella mappa ci va l'id VERO, non lo si ricava dal nome esposto.
+       *   Chi deve riverificare la fiducia prima di eseguire (`agent-service.mjs`) tagliava il
+       *   nome su `__` e ricostruiva l'id: due verità sulla stessa cosa, che il terzo controllo ha
+       *   fatto divergere in due modi (un id `a__b` faceva controllare `a`; un id `_sano` non si
+       *   riconosceva affatto). Qui l'id lo abbiamo in mano: si porta, non si indovina.
+       */
+      instradamento.set(nomeEsposto, { comando: t.comando, pluginId: p.id });
+    }
+    for (const h of p.hooks) {
+      hookPlugin.push({ id: hookIdQualificato(p.id, h.id), eventi: h.eventi, comando: h.comando });
+    }
+  }
+
+  const eseguiToolPluginFn = toolPlugin.length > 0
+    ? async (nomeEsposto, argomenti) => {
+      const voce = instradamento.get(nomeEsposto);
+      if (!voce) throw new Error(`tool di plugin "${nomeEsposto}" non è fra quelli offerti in questa sessione`);
+      return eseguiComandoPluginFn({ comando: voce.comando, argomenti, cartella });
+    }
+    : null;
+
+  /*
+   * ⛔ A-3: `pluginIdDiTool` è la sola strada per sapere DI CHI è un attrezzo. Chi riverifica la
+   *   fiducia prima di eseguirlo (`agent-service.mjs`) la usa al posto di tagliare il nome
+   *   esposto: se l'attrezzo non è in questa mappa, non è di questa sessione e non si esegue.
+   */
+  return { toolPlugin, eseguiToolPluginFn, hookPlugin, falliti, pluginIdDiTool: (n) => instradamento.get(n)?.pluginId ?? null };
+}

package/vendor/harness-ui/src/process-policy.mjs

@@ -0,0 +1,345 @@
+/**
+ * Policy boundary for every host process started by the desktop harness.
+ *
+ * The adapter deliberately keeps the Node child_process API behind a small,
+ * typed surface: callers must name an allowed executable and an explicit
+ * working directory; shell execution is never accepted; environment values
+ * are allowlisted. The underlying spawn/exec implementation remains
+ * injectable so tests never need to start a real process.
+ */
+import { createHash } from 'node:crypto';
+import { execFile, execFileSync, spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { readFile, stat } from 'node:fs/promises';
+import { isAbsolute, relative, resolve, sep } from 'node:path';
+
+const DEFAULT_ENV_ALLOWLIST = Object.freeze([
+  'PATH', 'Path', 'PATHEXT', 'SystemRoot', 'WINDIR', 'COMSPEC',
+  'HOME', 'USERPROFILE', 'TMP', 'TEMP', 'LANG', 'LC_ALL',
+]);
+const DEFAULT_CAPTURE_LIMIT_BYTES = 64 * 1024;
+
+export class ProcessPolicyError extends Error {
+  constructor(message, code = 'PROCESS_POLICY_REJECTED') {
+    super(message);
+    this.name = 'ProcessPolicyError';
+    this.code = code;
+  }
+}
+
+function isInside(root, candidate) {
+  const difference = relative(resolve(root), resolve(candidate));
+  return difference === ''
+    || (difference !== '..' && !difference.startsWith(`..${sep}`) && !isAbsolute(difference));
+}
+
+function executableKey(command) {
+  if (typeof command !== 'string' || command.trim().length === 0 || command.includes('\0')) {
+    throw new ProcessPolicyError('Eseguibile non valido', 'EXECUTABLE_INVALID');
+  }
+  return command.trim().toLowerCase();
+}
+
+function validateArgs(args) {
+  if (!Array.isArray(args) || args.some((arg) => typeof arg !== 'string' || arg.includes('\0'))) {
+    throw new ProcessPolicyError('Argomenti del comando non validi', 'ARGS_INVALID');
+  }
+}
+
+/**
+ * Tokenizza una dichiarazione di comando senza passare da una shell. Le
+ * virgolette servono solo a conservare un argomento (ad esempio il codice di
+ * `node -e`); metacaratteri di shell fuori dalle virgolette sono rifiutati.
+ */
+export function parseProcessCommand(command) {
+  if (typeof command !== 'string' || command.trim() === '' || command.includes('\0')) {
+    throw new ProcessPolicyError('Comando non valido', 'COMMAND_INVALID');
+  }
+  const tokens = [];
+  let token = '';
+  let quoted = false;
+  let escaping = false;
+  for (const char of command.trim()) {
+    if (escaping) { token += char; escaping = false; continue; }
+    if (char === '\\' && quoted) { escaping = true; continue; }
+    if (char === '"') { quoted = !quoted; continue; }
+    if (!quoted && /[&|;<>()]/u.test(char)) {
+      throw new ProcessPolicyError('Il comando non può contenere operatori di shell', 'SHELL_SYNTAX_NOT_ALLOWED');
+    }
+    if (!quoted && /\s/u.test(char)) {
+      if (token) { tokens.push(token); token = ''; }
+      continue;
+    }
+    token += char;
+  }
+  if (escaping) token += '\\';
+  if (quoted) throw new ProcessPolicyError('Virgolette non bilanciate', 'COMMAND_INVALID');
+  if (token) tokens.push(token);
+  if (tokens.length === 0) throw new ProcessPolicyError('Comando non valido', 'COMMAND_INVALID');
+  return tokens;
+}
+
+function validateTimeout(timeout) {
+  if (timeout === undefined) return;
+  if (!Number.isInteger(timeout) || timeout <= 0) {
+    throw new ProcessPolicyError('Durata massima del comando non valida', 'TIMEOUT_INVALID');
+  }
+}
+
+function buildEnvironment(env, allowlist) {
+  if (env !== undefined && (env === null || typeof env !== 'object' || Array.isArray(env))) {
+    throw new ProcessPolicyError('Ambiente del comando non valido', 'ENV_INVALID');
+  }
+  const allowed = new Set(allowlist);
+  const source = { ...process.env, ...(env ?? {}) };
+  return Object.fromEntries(Object.entries(source).filter(([key]) => allowed.has(key)));
+}
+
+function validateCwd(cwd, cwdRoot) {
+  if (typeof cwd !== 'string' || cwd.length === 0 || cwd.includes('\0') || !isAbsolute(cwd)) {
+    throw new ProcessPolicyError('Cartella di lavoro esplicita richiesta', 'CWD_REQUIRED');
+  }
+  const resolved = resolve(cwd);
+  if (cwdRoot && !isInside(cwdRoot, resolved)) {
+    throw new ProcessPolicyError('Cartella di lavoro fuori dall’area autorizzata', 'CWD_NOT_ALLOWED');
+  }
+  return resolved;
+}
+
+function validateCaptureLimit(value) {
+  if (value === undefined) return DEFAULT_CAPTURE_LIMIT_BYTES;
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new ProcessPolicyError('Limite output non valida', 'CAPTURE_LIMIT_INVALID');
+  }
+  return value;
+}
+
+function appendBounded(current, chunk, limit) {
+  const text = Buffer.isBuffer(chunk) ? chunk.toString('utf8') : String(chunk);
+  const remaining = limit - Buffer.byteLength(current, 'utf8');
+  if (remaining <= 0) return { value: current, truncated: true };
+  const bytes = Buffer.from(text, 'utf8');
+  if (bytes.byteLength <= remaining) return { value: current + text, truncated: false };
+  return { value: current + bytes.subarray(0, remaining).toString('utf8'), truncated: true };
+}
+
+function terminateChild(child) {
+  if (!child || typeof child.kill !== 'function') return;
+  try { child.kill('SIGTERM'); } catch { /* il processo può essersi chiuso tra controllo e kill */ }
+}
+
+/**
+ * Risolve un binario configurato soltanto se è un file assoluto realmente
+ * presente. Il digest opzionale rende il pin verificabile senza esporre il
+ * contenuto del file al chiamante.
+ */
+export async function resolveApprovedExecutable({ id, configuredPath, expectedSha256 } = {}, deps = {}) {
+  if (typeof id !== 'string' || id.trim() === '' || typeof configuredPath !== 'string'
+    || !configuredPath.trim() || !isAbsolute(configuredPath) || configuredPath.includes('\0')) {
+    throw new ProcessPolicyError('Percorso dell’eseguibile non valido', 'EXECUTABLE_PATH_INVALID');
+  }
+  if (expectedSha256 !== undefined && !/^[a-f0-9]{64}$/iu.test(expectedSha256)) {
+    throw new ProcessPolicyError('Digest dell’eseguibile non valido', 'EXECUTABLE_DIGEST_INVALID');
+  }
+  const statFn = deps.statFn ?? stat;
+  const readFileFn = deps.readFileFn ?? readFile;
+  const path = resolve(configuredPath);
+  let info;
+  try { info = await statFn(path); } catch { throw new ProcessPolicyError('Eseguibile configurato non trovato', 'EXECUTABLE_NOT_FOUND'); }
+  if (!info?.isFile?.()) throw new ProcessPolicyError('Il percorso configurato non è un file', 'EXECUTABLE_NOT_FILE');
+  let sha256 = null;
+  if (expectedSha256 !== undefined) {
+    const contents = await readFileFn(path);
+    sha256 = createHash('sha256').update(contents).digest('hex');
+    if (sha256.toLowerCase() !== expectedSha256.toLowerCase()) {
+      throw new ProcessPolicyError('Digest dell’eseguibile non corrisponde', 'EXECUTABLE_DIGEST_MISMATCH');
+    }
+  }
+  return Object.freeze({ id: id.trim(), path, sha256 });
+}
+
+/**
+ * @param {{allowedExecutables?:string[], cwdRoot?:string|null, capabilities?:Record<string,string>, envAllowlist?:string[], spawnFn?:typeof spawn, execFileFn?:typeof execFile, execFileSyncFn?:typeof execFileSync}} [options]
+ */
+export function createProcessPolicy({
+  allowedExecutables = [],
+  cwdRoot = null,
+  capabilities = {},
+  envAllowlist = DEFAULT_ENV_ALLOWLIST,
+  spawnFn = spawn,
+  execFileFn = execFile,
+  execFileSyncFn = execFileSync,
+  /*
+   * ⛔ BC-64 (17/09/2026) — `windowsHide: true` NON nasconde solo la console: libuv lo traduce in
+   *   STARTF_USESHOWWINDOW + SW_HIDE, e un programma con finestra che onora quell'avvio nasce INVISIBILE.
+   *   Misurato su questa macchina nei due versi con `explorer.exe /select,<file>`: con `true` la finestra di
+   *   Esplora esiste ma `Visible=False` (l'owner: «non apre nessuna finestra»), con `false` `Visible=True`.
+   *   È lo stesso motivo per cui Node ha revocato il default a `true` (nodejs/node PR #24034, letta il 17/09/2026).
+   * ⇒ Il default resta `true` — un processo di servizio non deve far lampeggiare una console — e chi lancia
+   *   apposta un programma CHE LA PERSONA DEVE VEDERE lo dichiara qui, per nome, alla nascita della politica.
+   */
+  finestreVisibili = false,
+} = {}) {
+  if (typeof finestreVisibili !== 'boolean') throw new ProcessPolicyError('finestreVisibili deve essere un booleano', 'POLICY_INVALID');
+  const approved = new Set(allowedExecutables.map((value) => executableKey(value)));
+  if (cwdRoot !== null && (typeof cwdRoot !== 'string' || !isAbsolute(cwdRoot))) {
+    throw new ProcessPolicyError('Radice delle cartelle di lavoro non valida', 'CWD_ROOT_INVALID');
+  }
+  const environmentKeys = [...new Set(envAllowlist)];
+  if (!capabilities || typeof capabilities !== 'object' || Array.isArray(capabilities)) {
+    throw new ProcessPolicyError('Capability di processo non valide', 'CAPABILITIES_INVALID');
+  }
+  const capabilityRoots = new Map(Object.entries(capabilities).map(([name, root]) => {
+    if (typeof name !== 'string' || !name || typeof root !== 'string' || !isAbsolute(root)) {
+      throw new ProcessPolicyError('Capability di processo non valida', 'CAPABILITIES_INVALID');
+    }
+    return [name, resolve(root)];
+  }));
+
+  function prepare(command, args, options = {}) {
+    const key = executableKey(command);
+    if (!approved.has(key)) throw new ProcessPolicyError('Eseguibile non autorizzato', 'EXECUTABLE_NOT_ALLOWED');
+    validateArgs(args);
+    if (options.shell === true) throw new ProcessPolicyError('I comandi tramite shell non sono consentiti', 'SHELL_NOT_ALLOWED');
+    const cwd = validateCwd(options.cwd, cwdRoot);
+    validateTimeout(options.timeout);
+    return {
+      command,
+      args,
+      options: {
+        ...options,
+        cwd,
+        shell: false,
+        env: buildEnvironment(options.env, environmentKeys),
+        windowsHide: !finestreVisibili,
+      },
+    };
+  }
+
+  function prepareApprovedProcess({ executable, args = [], cwd, envKeys, timeoutMs, signal, capability, captureLimitBytes, env } = {}) {
+    if (typeof capability !== 'string' || capability.trim() === '') {
+      throw new ProcessPolicyError('Capability esplicita richiesta', 'CAPABILITY_REQUIRED');
+    }
+    const capabilityRoot = capabilityRoots.get(capability);
+    if (!capabilityRoot) throw new ProcessPolicyError('Capability non autorizzata', 'CAPABILITY_NOT_ALLOWED');
+    const requestedCwd = validateCwd(cwd, capabilityRoot);
+    if (!existsSync(requestedCwd)) {
+      throw new ProcessPolicyError('Cartella di lavoro non trovata', 'CWD_NOT_FOUND');
+    }
+    const keys = envKeys === undefined ? environmentKeys : envKeys;
+    if (!Array.isArray(keys) || keys.some((key) => typeof key !== 'string')) {
+      throw new ProcessPolicyError('Elenco ambiente non valido', 'ENV_KEYS_INVALID');
+    }
+    const allowedKeys = keys.filter((key) => environmentKeys.includes(key));
+    const options = {
+      cwd: requestedCwd,
+      env: buildEnvironment(env, allowedKeys),
+      timeout: timeoutMs,
+      signal,
+      captureLimitBytes: validateCaptureLimit(captureLimitBytes),
+      shell: false,
+      windowsHide: true,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    };
+    const prepared = prepare(executable, args, options);
+    return { ...prepared, capability };
+  }
+
+  async function runApprovedProcess(request = {}) {
+    const prepared = prepareApprovedProcess(request);
+    const limit = prepared.options.captureLimitBytes;
+    let child;
+    try {
+      child = spawnFn(prepared.command, prepared.args, prepared.options);
+    } catch (error) {
+      throw new ProcessPolicyError(`Impossibile avviare il comando: ${error?.message || 'errore sconosciuto'}`, 'PROCESS_START_FAILED');
+    }
+    if (!child || typeof child.once !== 'function') {
+      throw new ProcessPolicyError('Il processo non ha restituito un canale valido', 'PROCESS_START_FAILED');
+    }
+    return new Promise((resolveResult, rejectResult) => {
+      let stdout = '';
+      let stderr = '';
+      let outputTruncated = false;
+      let timedOut = false;
+      let aborted = false;
+      let settled = false;
+      let spawnError = null;
+      let timer;
+      let onAbort;
+      const cleanup = () => {
+        if (timer) clearTimeout(timer);
+        if (prepared.options.signal && onAbort) prepared.options.signal.removeEventListener('abort', onAbort);
+        child.stdout?.destroy?.();
+        child.stderr?.destroy?.();
+      };
+      const finish = (code = null, signalValue = null) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        resolveResult({ code, signal: signalValue, stdout, stderr, outputTruncated, timedOut, aborted });
+      };
+      const capture = (stream, chunk) => {
+        const next = appendBounded(stream === 'stdout' ? stdout : stderr, chunk, limit);
+        if (stream === 'stdout') stdout = next.value; else stderr = next.value;
+        if (next.truncated) {
+          outputTruncated = true;
+          terminateChild(child);
+        }
+      };
+      child.stdout?.on('data', (chunk) => capture('stdout', chunk));
+      child.stderr?.on('data', (chunk) => capture('stderr', chunk));
+      child.once('close', (code, signalValue) => {
+        if (spawnError && spawnError.code !== 'ENOENT') {
+          if (settled) return;
+          settled = true;
+          cleanup();
+          rejectResult(new ProcessPolicyError(`Processo non disponibile: ${spawnError?.message || 'errore sconosciuto'}`, 'PROCESS_FAILED'));
+          return;
+        }
+        finish(spawnError?.code === 'ENOENT' ? -1 : code, spawnError?.code === 'ENOENT' ? 'ENOENT' : signalValue);
+      });
+      child.once('error', (error) => {
+        if (settled) return;
+        spawnError = error;
+        // Su Windows un avvio fallito può lasciare un handle del job anche
+        // dopo l'evento error; il processo non deve restare orfano mentre
+        // attendiamo il close definitivo.
+        child.unref?.();
+      });
+      if (Number.isInteger(prepared.options.timeout) && prepared.options.timeout > 0) {
+        timer = setTimeout(() => { timedOut = true; terminateChild(child); }, prepared.options.timeout);
+        timer.unref?.();
+      }
+      if (prepared.options.signal) {
+        onAbort = () => { aborted = true; terminateChild(child); };
+        if (prepared.options.signal.aborted) onAbort();
+        else prepared.options.signal.addEventListener('abort', onAbort, { once: true });
+      }
+    });
+  }
+
+  return Object.freeze({
+    spawn(command, args = [], options = {}) {
+      const prepared = prepare(command, args, options);
+      return spawnFn(prepared.command, prepared.args, prepared.options);
+    },
+    execFile(command, args = [], options = {}, callback) {
+      const prepared = prepare(command, args, options);
+      return execFileFn(prepared.command, prepared.args, prepared.options, callback);
+    },
+    execFileSync(command, args = [], options = {}) {
+      const prepared = prepare(command, args, options);
+      return execFileSyncFn(prepared.command, prepared.args, prepared.options);
+    },
+    runApprovedProcess,
+  });
+}
+
+/** Convenience entry point for callers that already own a configured policy. */
+export function runApprovedProcess(request, { policy } = {}) {
+  if (!policy || typeof policy.runApprovedProcess !== 'function') {
+    throw new ProcessPolicyError('Policy di processo richiesta', 'POLICY_REQUIRED');
+  }
+  return policy.runApprovedProcess(request);
+}

package/vendor/harness-ui/src/prompt-enhancer-provider.mjs

@@ -0,0 +1,94 @@
+import { risolviDestinazioneModello } from './model-destination.mjs';
+import { nativeProviderResponse } from './native-provider-adapter.mjs';
+
+function erroreApi(message, code) {
+  return Object.assign(new Error(message), { code });
+}
+
+function mappaErroreDestinazione(errore) {
+  if (errore?.code === 'PROVIDER_KEY_MISSING') {
+    return erroreApi('Manca la credenziale del provider usato da questa chat. Collegala in Impostazioni → Provider, poi riprova.', 'PROVIDER_KEY_REQUIRED');
+  }
+  if (errore?.code === 'MODEL_DESTINATION_INVALID' || errore?.code === 'MODEL_DESTINATION_MISCONFIGURED') {
+    return erroreApi('Il modello di questa chat non ha una destinazione valida.', 'PROVIDER_RUNTIME_UNAVAILABLE');
+  }
+  if (typeof errore?.code === 'string' && errore.code.startsWith('PROVIDER_')) {
+    return erroreApi('Il provider di questa chat non è disponibile per la riscrittura.', 'PROVIDER_RUNTIME_UNAVAILABLE');
+  }
+  return errore;
+}
+
+/**
+ * Invia Prompt Enhance allo stesso provider scelto dalla sessione.
+ *
+ * La rotta HTTP possiede sessione e contratto API; questo modulo possiede solo
+ * l'instradamento del trasporto, riusando la stessa fonte di verità della chat.
+ */
+export async function chiediMiglioramentoAlProvider({ modello, messaggi, providerStore, fetchFn = globalThis.fetch } = {}) {
+  if (typeof modello !== 'string' || modello.trim() === '') {
+    throw erroreApi('Questa sessione non dichiara un modello.', 'SESSION_NOT_READY');
+  }
+  if (!providerStore || typeof providerStore.getKey !== 'function' || typeof providerStore.getRuntime !== 'function') {
+    throw erroreApi('Il portachiavi dei provider non è configurato.', 'PROVIDER_STORE_UNAVAILABLE');
+  }
+  if (typeof fetchFn !== 'function') {
+    throw erroreApi('Il trasporto del provider non è configurato.', 'PROVIDER_RUNTIME_UNAVAILABLE');
+  }
+
+  let destinazione;
+  try {
+    destinazione = risolviDestinazioneModello(modello, {
+      leggiChiave: (provider) => providerStore.getKey(provider),
+      leggiRuntime: (provider) => providerStore.getRuntime(provider),
+      localePronto: () => false,
+    });
+  } catch (errore) {
+    throw mappaErroreDestinazione(errore);
+  }
+
+  if (destinazione.locale || destinazione.esterno) {
+    throw erroreApi('Il provider di questa chat non è disponibile per la riscrittura.', 'PROVIDER_RUNTIME_UNAVAILABLE');
+  }
+
+  const body = {
+    model: destinazione.modelloRemoto,
+    messages: messaggi,
+    stream: false,
+    max_tokens: 2048,
+  };
+
+  let risposta;
+  try {
+    if (destinazione.native) {
+      risposta = await nativeProviderResponse({
+        provider: destinazione.fonte,
+        model: destinazione.modelloRemoto,
+        apiKey: destinazione.apiKey,
+        baseURL: destinazione.baseURL,
+        body,
+        fetchFn,
+      });
+    } else {
+      risposta = await fetchFn(destinazione.url, {
+        method: 'POST',
+        headers: { Accept: 'application/json', ...destinazione.headers },
+        body: JSON.stringify(body),
+      });
+    }
+  } catch {
+    throw erroreApi('Il provider di questa chat non ha risposto.', 'PROVIDER_RUNTIME_UNAVAILABLE');
+  }
+
+  if (!risposta?.ok) {
+    throw erroreApi(`Il provider di questa chat ha risposto ${risposta?.status ?? '?'}.`, 'PROVIDER_RUNTIME_UNAVAILABLE');
+  }
+
+  let letto;
+  try { letto = await risposta.json(); } catch { letto = null; }
+  const contenuto = typeof letto?.choices?.[0]?.message?.content === 'string' ? letto.choices[0].message.content : '';
+  return {
+    contenuto,
+    modelloUsato: modello,
+    fornitoreUsato: destinazione.fonte,
+  };
+}