talos-code 0.0.1 → 0.2.0

package/vendor/harness-ui/src/harness-receipt-keypair.mjs

@@ -0,0 +1,207 @@
+/**
+ * harness-receipt-keypair.mjs — la chiave Ed25519 che firma le ricevute del
+ * kernel (`talosHarness.mjs`, `creaRicevutaOperazione`/`firma`).
+ *
+ * ⭐⭐⭐ 29/8, FASE D — il pezzo dichiarato aperto fin dal primo incremento
+ * della firma: "decidere dove vivono le chiavi e chi verifica: una
+ * decisione separata, non presa qui". Presa qui, ora.
+ *
+ * ⛔ Stesso disegno di `control-plane/scripts/browser-action-keypair.mjs`
+ * (AVM, letto prima di scrivere questo file — REGOLA ZERO, cercato nel
+ * proprio codebase prima di inventare un pattern nuovo): provisioning
+ * persistito su un file `.env`, PEM codificato in base64, tre variabili
+ * (privata/pubblica/id). NON lo stesso algoritmo — quello è EC P-256 per
+ * un token JWT con scadenza; questo è Ed25519 per una ricevuta d'audit
+ * permanente, lo stesso RFC 8032 già usato da `generaChiaviFirmaRicevute()`
+ * nel kernel — e NON lo stesso file: due concetti diversi (una capability
+ * che autorizza un'azione PRIMA che avvenga, contro una ricevuta che
+ * attesta un'azione GIÀ avvenuta) restano due file, come `TalosDisco`/
+ * `discoNode.ts`/`discoCapacitor.ts` restano tre file per lo stesso
+ * concetto su runtime diversi — non una libreria condivisa forzata.
+ *
+ * ⛔ Perché una chiave PERSISTITA e non una generata a ogni avvio (come fa
+ * `control-plane/scripts/dev-stack.mjs` per il suo token JWT effimero):
+ * una ricevuta d'audit deve restare verificabile MOLTO dopo che il
+ * processo che l'ha firmata è morto — un riavvio del server non deve
+ * invalidare ogni firma emessa prima. Il token JWT del dev-stack vive
+ * solo per la durata di una sessione locale fra due processi che
+ * ripartono insieme; questa chiave no.
+ */
+import {
+  createPrivateKey,
+  createPublicKey,
+  generateKeyPairSync,
+  randomUUID,
+  timingSafeEqual,
+} from 'node:crypto';
+import { chmod, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const PRIVATE_KEY_ENV = 'TALOS_HARNESS_RECEIPT_PRIVATE_KEY_B64';
+const PUBLIC_KEY_ENV = 'TALOS_HARNESS_RECEIPT_PUBLIC_KEY_B64';
+const KEY_ID_ENV = 'TALOS_HARNESS_RECEIPT_KEY_ID';
+const RECEIPT_KEY_ENV_NAMES = [PRIVATE_KEY_ENV, PUBLIC_KEY_ENV, KEY_ID_ENV];
+const KEY_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
+
+export function generateHarnessReceiptKeypair() {
+  const { privateKey, publicKey } = generateKeyPairSync('ed25519', {
+    privateKeyEncoding: { format: 'pem', type: 'pkcs8' },
+    publicKeyEncoding: { format: 'pem', type: 'spki' },
+  });
+  const keypair = {
+    keyId: `talos-harness-receipt-${randomUUID()}`,
+    privateKeyBase64: Buffer.from(privateKey, 'utf8').toString('base64'),
+    publicKeyBase64: Buffer.from(publicKey, 'utf8').toString('base64'),
+  };
+
+  assertValidHarnessReceiptKeypair(keypair);
+
+  return keypair;
+}
+
+export async function ensureHarnessReceiptKeypairEnvFile(envFile) {
+  const absolutePath = path.resolve(envFile);
+  const contents = await readFile(absolutePath, 'utf8').catch((error) => {
+    if (error?.code === 'ENOENT') return '';
+    throw error;
+  });
+  const parsed = parseEnv(contents);
+  const configured = {
+    keyId: parsed.get(KEY_ID_ENV)?.trim() ?? '',
+    privateKeyBase64: parsed.get(PRIVATE_KEY_ENV)?.trim() ?? '',
+    publicKeyBase64: parsed.get(PUBLIC_KEY_ENV)?.trim() ?? '',
+  };
+  const presentCount = Object.values(configured).filter((value) => value !== '').length;
+
+  if (presentCount > 0 && presentCount < 3) {
+    throw new Error('Refusing partial TALOS harness receipt keypair configuration.');
+  }
+  if (presentCount === 3) {
+    assertValidHarnessReceiptKeypair(configured);
+    await chmod(absolutePath, 0o600).catch((error) => {
+      if (process.platform !== 'win32') throw error;
+    });
+
+    return { created: false, keypair: configured };
+  }
+
+  const keypair = generateHarnessReceiptKeypair();
+  const updated = setEnvValues(contents, new Map([
+    [PRIVATE_KEY_ENV, keypair.privateKeyBase64],
+    [PUBLIC_KEY_ENV, keypair.publicKeyBase64],
+    [KEY_ID_ENV, keypair.keyId],
+  ]));
+  const temporaryPath = `${absolutePath}.tmp-${process.pid}-${randomUUID()}`;
+
+  try {
+    await writeFile(temporaryPath, updated, { encoding: 'utf8', flag: 'wx', mode: 0o600 });
+    await rename(temporaryPath, absolutePath);
+    await chmod(absolutePath, 0o600).catch((error) => {
+      if (process.platform !== 'win32') throw error;
+    });
+  } catch (error) {
+    await rm(temporaryPath, { force: true }).catch(() => {});
+    throw error;
+  }
+
+  return { created: true, keypair };
+}
+
+function assertValidHarnessReceiptKeypair(keypair) {
+  if (!KEY_ID_PATTERN.test(keypair.keyId)) throw configurationError();
+
+  const privatePem = decodeCanonicalBase64(keypair.privateKeyBase64);
+  const publicPem = decodeCanonicalBase64(keypair.publicKeyBase64);
+  if (!privatePem.startsWith('-----BEGIN PRIVATE KEY-----\n')
+    || !privatePem.trimEnd().endsWith('-----END PRIVATE KEY-----')
+    || !publicPem.startsWith('-----BEGIN PUBLIC KEY-----\n')
+    || !publicPem.trimEnd().endsWith('-----END PUBLIC KEY-----')) {
+    throw configurationError();
+  }
+
+  try {
+    const privateKey = createPrivateKey(privatePem);
+    const publicKey = createPublicKey(publicPem);
+    if (privateKey.asymmetricKeyType !== 'ed25519' || publicKey.asymmetricKeyType !== 'ed25519') {
+      throw configurationError();
+    }
+
+    const expectedPublic = createPublicKey(privateKey).export({ format: 'der', type: 'spki' });
+    const suppliedPublic = publicKey.export({ format: 'der', type: 'spki' });
+    if (expectedPublic.length !== suppliedPublic.length
+      || !timingSafeEqual(expectedPublic, suppliedPublic)) {
+      throw configurationError();
+    }
+  } catch {
+    throw configurationError();
+  }
+}
+
+function decodeCanonicalBase64(value) {
+  if (typeof value !== 'string'
+    || value === ''
+    || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/u.test(value)) {
+    throw configurationError();
+  }
+  const decoded = Buffer.from(value, 'base64');
+  if (decoded.toString('base64') !== value) throw configurationError();
+
+  return decoded.toString('utf8');
+}
+
+function parseEnv(contents) {
+  const values = new Map();
+  const occurrences = new Map();
+  for (const line of contents.split(/\r?\n/u)) {
+    const match = /^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/u.exec(line);
+    if (!match) continue;
+    const [, name, value] = match;
+    occurrences.set(name, (occurrences.get(name) ?? 0) + 1);
+    values.set(name, value);
+  }
+  for (const name of RECEIPT_KEY_ENV_NAMES) {
+    if ((occurrences.get(name) ?? 0) > 1) {
+      throw new Error(`Refusing duplicate ${name} entries in the environment file.`);
+    }
+  }
+
+  return values;
+}
+
+function setEnvValues(contents, values) {
+  const eol = contents.includes('\r\n') ? '\r\n' : '\n';
+  const lines = contents === '' ? [] : contents.split(/\r?\n/u);
+  if (lines.at(-1) === '') lines.pop();
+
+  for (const [name, value] of values) {
+    const index = lines.findIndex((line) => line.startsWith(`${name}=`));
+    const replacement = `${name}=${value}`;
+    if (index >= 0) lines[index] = replacement;
+    else lines.push(replacement);
+  }
+
+  return `${lines.join(eol)}${eol}`;
+}
+
+function configurationError() {
+  return new Error('TALOS harness receipt keypair must be a matching Ed25519 PKCS8/SPKI pair with a valid key id.');
+}
+
+async function runCli() {
+  const [, , flag, target, ...rest] = process.argv;
+  if (flag !== '--env-file' || typeof target !== 'string' || target.trim() === '' || rest.length > 0) {
+    throw new Error('Usage: node src/harness-receipt-keypair.mjs --env-file <path>');
+  }
+
+  const result = await ensureHarnessReceiptKeypairEnvFile(target);
+  process.stdout.write(`Harness receipt keypair is ready (${result.created ? 'created' : 'existing'}).\n`);
+}
+
+const invokedPath = process.argv[1] ? path.resolve(process.argv[1]) : '';
+if (invokedPath === fileURLToPath(import.meta.url)) {
+  runCli().catch((error) => {
+    process.stderr.write(`${error instanceof Error ? error.message : 'Harness receipt keypair provisioning failed.'}\n`);
+    process.exitCode = 1;
+  });
+}

package/vendor/harness-ui/src/hf-direct-transfer.mjs

@@ -0,0 +1,170 @@
+import { createHash } from 'node:crypto';
+import { createWriteStream } from 'node:fs';
+import { once } from 'node:events';
+import { mkdir, stat, rm } from 'node:fs/promises';
+import { basename, isAbsolute, join, relative, resolve } from 'node:path';
+
+const HOST_OK = (host) => host === 'huggingface.co' || host.endsWith('.huggingface.co') || host.endsWith('.hf.co');
+
+export class HfDirectTransferError extends Error {
+  constructor(message, code = 'HF_TRANSFER_FAILED') { super(message); this.name = 'HfDirectTransferError'; this.code = code; }
+}
+
+function fail(message, code = 'HF_TRANSFER_INVALID') { throw new HfDirectTransferError(message, code); }
+const LOCAL_ID = /^[a-z0-9][a-z0-9._-]{0,127}$/iu;
+const LOCAL_NAME = /^.{1,160}$/su;
+const MAX_LOCAL_IMPORT_BYTES_DEFAULT = 64 * 1024 ** 3;
+function inside(root, value) { const absolute = resolve(root, value); const rel = relative(resolve(root), absolute); if (rel === '..' || rel.startsWith(`..${'\\'}`) || isAbsolute(rel)) fail('model path escapes root', 'HF_PATH_REJECTED'); return absolute; }
+function validateManifest(value) {
+  if (!value || typeof value !== 'object' || typeof value.id !== 'string' || typeof value.repo !== 'string' || typeof value.revision !== 'string' || !/^[a-f0-9]{40,64}$/iu.test(value.revision) || !Array.isArray(value.files) || value.files.length === 0 || !Number.isSafeInteger(value.bytes) || value.bytes <= 0 || typeof value.path !== 'string' || isAbsolute(value.path)) fail('download manifest is invalid');
+  const files = value.files.map((file) => {
+    if (!file || typeof file.path !== 'string' || !file.path || file.path.startsWith('/') || file.path.split('/').some((part) => !part || part === '.' || part === '..') || !Number.isSafeInteger(file.bytes) || file.bytes <= 0 || !/^[a-f0-9]{64}$/iu.test(file.sha256)) fail('download file is invalid');
+    return { path: file.path, bytes: file.bytes, sha256: file.sha256.toLowerCase() };
+  });
+  if (files.reduce((sum, file) => sum + file.bytes, 0) !== value.bytes) fail('download byte total is invalid');
+  return { ...value, files, sha256: typeof value.sha256 === 'string' ? value.sha256.toLowerCase() : files[0].sha256, state: 'incomplete' };
+}
+
+async function digest(path) { const hash = createHash('sha256'); let bytes = 0; const stream = (await import('node:fs')).createReadStream(path); for await (const chunk of stream) { hash.update(chunk); bytes += chunk.length; } return { bytes, sha256: hash.digest('hex') }; }
+
+export function createHfDirectTransfer({ rootDir, modelStore, hubClient, fetchImpl = fetch, now = () => new Date(), maxConcurrent = 2, maxImportBytes = MAX_LOCAL_IMPORT_BYTES_DEFAULT } = {}) {
+  if (typeof rootDir !== 'string' || !isAbsolute(rootDir) || !modelStore || typeof modelStore.inspect !== 'function' || typeof modelStore.register !== 'function' || typeof modelStore.setState !== 'function' || !hubClient || typeof hubClient.resolveDownload !== 'function') fail('direct transfer dependencies are invalid', 'HF_TRANSFER_MISCONFIGURED');
+  const records = new Map(); const queue = []; let active = 0;
+  if (!Number.isSafeInteger(maxImportBytes) || maxImportBytes <= 0) fail('local import limit is invalid', 'HF_TRANSFER_MISCONFIGURED');
+  async function verify(request) {
+    for (const file of request.files) {
+      const target = inside(rootDir, join(request.path, file.path));
+      let actual; try { actual = await digest(target); } catch { fail(`cannot read ${file.path}`, 'MODEL_FILE_UNREADABLE'); }
+      if (actual.bytes !== file.bytes || actual.sha256 !== file.sha256) fail(`checksum mismatch for ${file.path}`, 'CHECKSUM_MISMATCH');
+    }
+    return modelStore.setState(request.id, 'ready');
+  }
+  async function download(record) {
+    const { request } = record;
+    for (const file of request.files) {
+      if (record.abort.signal.aborted) throw new HfDirectTransferError('download cancelled', 'CANCELLED_BY_OWNER');
+      const target = inside(rootDir, join(request.path, file.path)); await mkdir(resolve(target, '..'), { recursive: true });
+      let offset = 0; try { offset = (await stat(`${target}.partial`)).size; } catch {}
+      const signed = await hubClient.resolveDownload(request.repo, request.revision, file.path);
+      const parsed = new URL(signed.url); if (parsed.protocol !== 'https:' || !HOST_OK(parsed.hostname)) fail('download host is not official', 'HF_REDIRECT_HOST_REJECTED');
+      const headers = offset > 0 && offset < file.bytes ? { Range: `bytes=${offset}-` } : {};
+      if (offset >= file.bytes) offset = 0;
+      const response = await fetchImpl(signed.url, { headers, signal: record.abort.signal });
+      if (!response.ok || !response.body) fail(`Hugging Face download HTTP ${response.status}`, 'HF_DOWNLOAD_FAILED');
+      if (offset > 0 && response.status !== 206) { await rm(`${target}.partial`, { force: true }); offset = 0; }
+      const output = createWriteStream(`${target}.partial`, { flags: offset > 0 ? 'a' : 'w' });
+      let received = offset; const reader = response.body.getReader ? response.body.getReader() : null;
+      try {
+        if (reader) { while (true) { const { value, done } = await reader.read(); if (done) break; if (value) { if (!output.write(Buffer.from(value))) await new Promise((resolveWrite) => output.once('drain', resolveWrite)); received += value.byteLength; record.bytes = record.baseBytes + received; record.progress = Math.min(99, Math.round((record.bytes / request.bytes) * 100)); } } } else { for await (const chunk of response.body) { if (!output.write(Buffer.from(chunk))) await new Promise((resolveWrite) => output.once('drain', resolveWrite)); received += chunk.length; record.bytes = record.baseBytes + received; record.progress = Math.min(99, Math.round((record.bytes / request.bytes) * 100)); } }
+        await new Promise((resolveClose, rejectClose) => { output.once('close', resolveClose); output.once('error', rejectClose); output.end(); });
+      } catch (error) {
+        output.destroy();
+        throw error;
+      }
+      await (await import('node:fs/promises')).rename(`${target}.partial`, target); record.baseBytes += file.bytes;
+    }
+    record.state = 'verifying'; await verify(request); record.state = 'ready'; record.progress = 100; record.bytes = request.bytes; record.finishedAt = now().toISOString();
+  }
+  function pump() { while (active < maxConcurrent && queue.length) { const record = queue.shift(); active += 1; if (record.state === 'queued') record.state = 'running'; download(record).catch((error) => { if (!['paused', 'cancelled'].includes(record.state)) { record.state = 'failed'; record.reason = error.code || 'HF_DOWNLOAD_FAILED'; } }).finally(() => { active -= 1; pump(); }); } }
+  async function start(value) {
+    const request = validateManifest(value); const existing = await modelStore.inspect(request.id); if (existing && (existing.repo !== request.repo || existing.revision !== request.revision)) fail('existing transfer has different revision', 'HF_TRANSFER_COLLISION');
+    if (existing?.state === 'ready') {
+      const ready = { id: request.id, request: existing, state: 'ready', progress: 100, bytes: existing.bytes, baseBytes: existing.bytes, reason: null, startedAt: existing.updatedAt, abort: new AbortController() };
+      records.set(request.id, ready);
+      return status(request.id);
+    }
+    if (!existing) await modelStore.register({ ...request, state: 'incomplete', updatedAt: now().toISOString() });
+    const previous = records.get(request.id); if (previous && ['queued', 'running', 'verifying'].includes(previous.state)) return status(request.id);
+    const record = { id: request.id, request, state: 'queued', progress: 0, bytes: 0, baseBytes: 0, reason: null, startedAt: now().toISOString(), abort: new AbortController() }; records.set(request.id, record); queue.push(record); pump();
+    return status(request.id);
+  }
+  // 06/09 B6.10: la coda a schermo dice il FILE e il repository, non l'id interno (`repo`, `file`, `name`, `finishedAt`)
+  function status(id) { const record = records.get(id); return record ? { id: record.id, state: record.state, progress: record.progress, bytes: record.bytes, totalBytes: record.request.bytes, reason: record.reason, startedAt: record.startedAt, repo: record.request.repo ?? null, file: record.request.files?.[0]?.path ?? null, name: record.request.name ?? null, finishedAt: record.finishedAt ?? (record.state === 'ready' ? record.request.updatedAt ?? null : null) } : null; }
+  async function pause(id) { const record = records.get(id); if (!record || !['queued', 'running'].includes(record.state)) return false; record.state = 'paused'; record.reason = 'PAUSED_BY_OWNER'; record.abort.abort(); return true; }
+  async function resume(id) {
+    const record = records.get(id);
+    if (!record) {
+      const manifest = await modelStore.inspect(id);
+      if (!manifest || manifest.state === 'ready') return false;
+      return start(manifest);
+    }
+    if (!['paused', 'failed'].includes(record.state)) return false;
+    return start(record.request);
+  }
+  async function cancel(id) {
+    const record = records.get(id); if (!record || ['ready', 'failed', 'cancelled'].includes(record.state)) return false;
+    record.state = 'cancelled'; record.reason = 'CANCELLED_BY_OWNER'; record.abort.abort();
+    await Promise.all(record.request.files.map((file) => rm(`${inside(rootDir, join(record.request.path, file.path))}.partial`, { force: true })));
+    await modelStore.remove(record.id).catch(() => {});
+    return true;
+  }
+  async function verifyById(id) { const record = records.get(id); const manifest = record?.request || await modelStore.inspect(id); if (!manifest) fail('model manifest not found', 'MODEL_NOT_FOUND'); return verify(manifest); }
+  function validateImportMetadata(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value) || typeof value.id !== 'string' || !LOCAL_ID.test(value.id)) fail('local model id is invalid', 'LOCAL_IMPORT_INVALID');
+    if (typeof value.filename !== 'string' || value.filename.trim() === '' || value.filename.length > 240 || basename(value.filename) !== value.filename || value.filename.includes('\\') || value.filename.includes('/') || !/\.gguf$/iu.test(value.filename)) fail('local model filename is invalid', 'LOCAL_IMPORT_INVALID');
+    if (value.expectedBytes !== undefined && (!Number.isSafeInteger(value.expectedBytes) || value.expectedBytes <= 0)) fail('local model size is invalid', 'LOCAL_IMPORT_INVALID');
+    if (value.expectedBytes !== undefined && value.expectedBytes > maxImportBytes) fail('local model is too large', 'LOCAL_IMPORT_TOO_LARGE');
+    if (value.name !== undefined && (typeof value.name !== 'string' || !LOCAL_NAME.test(value.name.trim()))) fail('local model name is invalid', 'LOCAL_IMPORT_INVALID');
+    return { id: value.id, filename: value.filename, expectedBytes: value.expectedBytes ?? null, name: value.name?.trim() || null };
+  }
+  async function importStream(readable, metadata) {
+    if (!readable || typeof readable[Symbol.asyncIterator] !== 'function') fail('local import stream is invalid', 'LOCAL_IMPORT_INVALID');
+    const request = validateImportMetadata(metadata);
+    if (await modelStore.inspect(request.id)) fail(`model ${request.id} already exists`, 'HF_TRANSFER_COLLISION');
+    const target = inside(rootDir, join(request.id, request.filename));
+    await mkdir(resolve(target, '..'), { recursive: true });
+    const temporary = `${target}.partial-upload-${process.pid}-${Date.now()}`;
+    const output = createWriteStream(temporary, { flags: 'wx' });
+    const hash = createHash('sha256');
+    let total = 0;
+    let prefix = Buffer.alloc(0);
+    let registered = false;
+    try {
+      for await (const chunk of readable) {
+        const value = Buffer.from(chunk);
+        if (!value.length) continue;
+        total += value.length;
+        if (total > maxImportBytes) fail('local model is too large', 'LOCAL_IMPORT_TOO_LARGE');
+        if (request.expectedBytes !== null && total > request.expectedBytes) fail('local model size does not match', 'LOCAL_IMPORT_SIZE_MISMATCH');
+        if (prefix.length < 4) prefix = Buffer.concat([prefix, value.subarray(0, 4 - prefix.length)]);
+        hash.update(value);
+        if (!output.write(value)) await once(output, 'drain');
+      }
+      await new Promise((resolveClose, rejectClose) => output.end((error) => error ? rejectClose(error) : resolveClose()));
+      if (total === 0) fail('local model is empty', 'LOCAL_IMPORT_EMPTY');
+      if (request.expectedBytes !== null && total !== request.expectedBytes) fail('local model size does not match', 'LOCAL_IMPORT_SIZE_MISMATCH');
+      if (prefix.toString('ascii') !== 'GGUF') fail('local file is not a GGUF model', 'LOCAL_IMPORT_NOT_GGUF');
+      const sha256 = hash.digest('hex');
+      await (await import('node:fs/promises')).rename(temporary, target);
+      const manifest = { id: request.id, repo: 'local-upload', revision: sha256, files: [{ path: request.filename, bytes: total, sha256 }], bytes: total, sha256, license: 'unknown', path: request.id, state: 'ready', updatedAt: now().toISOString() };
+      try {
+        await modelStore.register(manifest);
+        registered = true;
+        if (request.name && typeof modelStore.rename === 'function') await modelStore.rename(request.id, request.name);
+      } catch (error) {
+        await rm(target, { force: true }).catch(() => {});
+        if (registered) await modelStore.remove?.(request.id).catch?.(() => {});
+        throw error;
+      }
+      return (await modelStore.inspect(request.id)) || manifest;
+    } catch (error) {
+      output.destroy();
+      await rm(temporary, { force: true }).catch(() => {});
+      throw error;
+    }
+  }
+  async function listStatuses() {
+    for (const manifest of await modelStore.list()) {
+      if (records.has(manifest.id)) continue;
+      if (manifest.state === 'ready') {
+        records.set(manifest.id, { id: manifest.id, request: manifest, state: 'ready', progress: 100, bytes: manifest.bytes, baseBytes: manifest.bytes, reason: null, startedAt: manifest.updatedAt, abort: new AbortController() });
+      } else {
+        let bytes = 0;
+        for (const file of manifest.files) { try { bytes += (await stat(`${inside(rootDir, join(manifest.path, file.path))}.partial`)).size; } catch {} }
+        records.set(manifest.id, { id: manifest.id, request: manifest, state: 'paused', progress: Math.min(99, Math.round((bytes / manifest.bytes) * 100)), bytes, baseBytes: 0, reason: 'RECOVERED_AFTER_RESTART', startedAt: manifest.updatedAt, abort: new AbortController() });
+      }
+    }
+    return [...records.keys()].map((id) => status(id)).filter(Boolean);
+  }
+  return Object.freeze({ start, status, listStatuses, pause, resume, cancel, verify: verifyById, importStream });
+}

package/vendor/harness-ui/src/hf-hub-client.mjs

@@ -0,0 +1,106 @@
+const REVISION = /^[a-f0-9]{40,64}$/iu;
+const REPO = /^[A-Za-z0-9][A-Za-z0-9._-]{0,95}\/[A-Za-z0-9][A-Za-z0-9._-]{0,95}$/u;
+const OFFICIAL_HOSTS = new Set(['huggingface.co']);
+
+export class HfHubError extends Error {
+  constructor(message, code = 'HF_HUB_ERROR') { super(message); this.name = 'HfHubError'; this.code = code; }
+}
+
+function invalid(message) { throw new HfHubError(message, 'HF_HUB_INVALID'); }
+function ensureRepo(repo) { if (typeof repo !== 'string' || !REPO.test(repo)) invalid('repository id is invalid'); return repo; }
+function ensureRevision(revision) { if (typeof revision !== 'string' || !REVISION.test(revision)) invalid('revision is invalid'); return revision; }
+function ensurePath(path) { if (typeof path !== 'string' || path.trim() === '' || path.startsWith('/') || path.split('/').some((part) => !part || part === '.' || part === '..')) invalid('file path is invalid'); return path; }
+
+function extractModelCardImages(readme, { repo, revision }) {
+  const images = [];
+  let cleaned = String(readme ?? '');
+  const resolve = (raw) => {
+    try {
+      const parsed = new URL(raw, `https://huggingface.co/${repo}/resolve/${encodeURIComponent(revision)}/`);
+      if (parsed.protocol !== 'https:' || parsed.username || parsed.password) return null;
+      return parsed.toString();
+    } catch { return null; }
+  };
+  cleaned = cleaned.replace(/<img\b[^>]*>/giu, (tag) => {
+    const source = /\bsrc\s*=\s*["']([^"']+)["']/iu.exec(tag)?.[1];
+    const alt = /\balt\s*=\s*["']([^"']*)["']/iu.exec(tag)?.[1] ?? '';
+    const url = source ? resolve(source) : null;
+    if (url) images.push({ alt, url });
+    return '';
+  });
+  cleaned = cleaned.replace(/!\[([^\]]*)\]\(([^)\s]+)(?:\s+["'][^)]*["'])?\)/gu, (_match, alt, source) => {
+    const url = resolve(source);
+    if (url) images.push({ alt, url });
+    return '';
+  });
+  return { readme: cleaned.replace(/\n{3,}/gu, '\n\n').trim(), images };
+}
+
+function officialDownloadUrl(value) {
+  let parsed;
+  try { parsed = new URL(value); } catch { throw new HfHubError('Hugging Face redirect is invalid', 'HF_REDIRECT_INVALID'); }
+  if (parsed.protocol !== 'https:' || ![...OFFICIAL_HOSTS].some((host) => parsed.hostname === host || parsed.hostname.endsWith(`.${host}`)) && !parsed.hostname.endsWith('.hf.co')) {
+    throw new HfHubError('Hugging Face download host is not official', 'HF_REDIRECT_HOST_REJECTED');
+  }
+  return parsed;
+}
+
+export function createHfHubClient({ fetchImpl = fetch, token, baseUrl = 'https://huggingface.co' } = {}) {
+  if (typeof fetchImpl !== 'function') throw new HfHubError('fetch implementation is required', 'HF_HUB_MISCONFIGURED');
+  const root = new URL(baseUrl);
+  if (root.protocol !== 'https:') throw new HfHubError('Hub base URL must use HTTPS', 'HF_HUB_MISCONFIGURED');
+  const headers = () => ({ Accept: 'application/json', ...(typeof token === 'string' && token.trim() ? { Authorization: `Bearer ${token.trim()}` } : {}) });
+  async function request(path, options = {}) {
+    const response = await fetchImpl(new URL(path, root), { ...options, headers: { ...headers(), ...(options.headers || {}) } });
+    if (response.ok || (options.redirect === 'manual' && response.status >= 300 && response.status < 400)) return response;
+    if (response.status === 401 || response.status === 403) throw new HfHubError('Repository Hugging Face gated o non autorizzato', 'HF_REPOSITORY_GATED');
+    if (response.status === 429) throw new HfHubError('Limite richieste Hugging Face raggiunto', 'HF_RATE_LIMITED');
+    throw new HfHubError(`Hugging Face HTTP ${response.status}`, 'HF_HUB_UPSTREAM');
+  }
+  async function searchModels({ query = '', limit = 20, cursor = null, sort = 'downloads', direction = '-1', author = null, filters = [] } = {}) {
+    const allowedSort = new Set(['downloads', 'likes', 'created', 'lastModified']);
+    const allowedDirection = new Set(['-1', '1']);
+    if (typeof query !== 'string' || query.length > 200 || !Number.isInteger(limit) || limit < 1 || limit > 50 || !allowedSort.has(sort) || !allowedDirection.has(String(direction)) || (author !== null && (typeof author !== 'string' || author.length > 100)) || !Array.isArray(filters) || filters.some((filter) => typeof filter !== 'string' || filter.length === 0 || filter.length > 80)) invalid('search parameters are invalid');
+    const params = new URLSearchParams({ sort, direction: String(direction), limit: String(limit) });
+    params.append('filter', 'gguf');
+    for (const filter of filters) params.append('filter', filter);
+    if (author?.trim()) params.set('author', author.trim());
+    for (const field of ['sha', 'gguf', 'downloads', 'downloadsAllTime', 'likes', 'pipeline_tag', 'tags', 'siblings', 'cardData']) params.append('expand[]', field);
+    if (query.trim()) params.set('search', query.trim());
+    if (cursor) params.set('cursor', String(cursor));
+    const response = await request(`/api/models?${params}`);
+    const rows = await response.json();
+    const payload = Array.isArray(rows) ? rows : (Array.isArray(rows?.items) ? rows.items : (Array.isArray(rows?.data) ? rows.data : []));
+    const items = payload.map((row) => ({ repo: row.id, revision: /^[a-f0-9]{40,64}$/iu.test(row.sha || '') ? row.sha : null, downloads: Number.isFinite(row.downloads) ? row.downloads : null, likes: Number.isFinite(row.likes) ? row.likes : null, gated: row.gated === true, pipelineTag: row.pipeline_tag || null, license: row.cardData?.license || row.license || null, tags: Array.isArray(row.tags) ? row.tags.slice(0, 40) : [] }));
+    const nextCursor = rows?.next ?? rows?.next_cursor ?? rows?.nextCursor ?? response.headers.get('x-next-cursor') ?? null;
+    return { items, nextCursor: typeof nextCursor === 'string' && nextCursor ? nextCursor : null };
+  }
+  async function describeModel(repo, revision = 'main') {
+    ensureRepo(repo); const rev = revision === 'main' ? revision : ensureRevision(revision);
+    const [meta, readme] = await Promise.all([request(`/api/models/${repo}`).then((r) => r.json()), request(`/${repo}/raw/${encodeURIComponent(rev)}/README.md`, { headers: { Accept: 'text/plain' } }).then((r) => r.text()).catch((error) => error.code === 'HF_HUB_UPSTREAM' ? '' : Promise.reject(error))]);
+    const revisionResolved = /^[a-f0-9]{40,64}$/iu.test(meta.sha || '') ? meta.sha : rev;
+    const card = extractModelCardImages(readme, { repo, revision: revisionResolved });
+    return { repo, revision: revisionResolved, gated: meta.gated === true, license: meta.cardData?.license || meta.license || null, readme: card.readme, images: card.images, downloads: meta.downloads ?? null, likes: meta.likes ?? null, pipelineTag: meta.pipeline_tag || null };
+  }
+  async function listGgufFiles(repo, revision) {
+    ensureRepo(repo); ensureRevision(revision);
+    const rows = await (await request(`/api/models/${repo}/tree/${encodeURIComponent(revision)}?recursive=true`)).json();
+    return (Array.isArray(rows) ? rows : []).filter((row) => row.type === 'file' && typeof row.path === 'string' && row.path.toLowerCase().endsWith('.gguf')).map((row) => ({ path: row.path, sizeBytes: Number(row.size), sha256: row.lfs?.oid || row.oid || null, security: row.security?.status || null }));
+  }
+  async function pathsInfo(repo, revision, paths) {
+    ensureRepo(repo); ensureRevision(revision); if (!Array.isArray(paths) || paths.length === 0 || paths.length > 200 || !paths.every((path) => typeof path === 'string')) invalid('paths are invalid');
+    const response = await request(`/api/models/${repo}/paths-info/${encodeURIComponent(revision)}`, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ paths, expand: true }) });
+    const body = await response.json(); const rows = Array.isArray(body) ? body : body.files;
+    if (!Array.isArray(rows)) throw new HfHubError('paths-info response is invalid', 'HF_HUB_RESPONSE_INVALID');
+    return rows.map((row) => ({ path: row.path, sizeBytes: Number(row.size), sha256: row.lfs?.oid || row.oid || null, security: row.security?.status || null })).filter((row) => Number.isSafeInteger(row.sizeBytes) && row.sizeBytes > 0);
+  }
+  async function resolveDownload(repo, revision, path) {
+    ensureRepo(repo); ensureRevision(revision); ensurePath(path);
+    const response = await request(`/${repo}/resolve/${encodeURIComponent(revision)}/${path.split('/').map(encodeURIComponent).join('/')}`, { redirect: 'manual' });
+    const location = response.headers.get('location');
+    if (!location) throw new HfHubError('Hugging Face did not return a signed download URL', 'HF_RESOLVE_INVALID');
+    const url = officialDownloadUrl(location);
+    return { url: url.toString(), expiresAt: url.searchParams.get('Expires') ? Number(url.searchParams.get('Expires')) * 1000 : null };
+  }
+  return Object.freeze({ searchModels, describeModel, listGgufFiles, pathsInfo, resolveDownload });
+}

package/vendor/harness-ui/src/hf-image-proxy.mjs

@@ -0,0 +1,105 @@
+import { lookup } from 'node:dns/promises';
+import { isIP } from 'node:net';
+
+const ALLOWED_SUFFIXES = Object.freeze(['huggingface.co', 'hf.co']);
+const ALLOWED_MIME = new Set(['image/png', 'image/jpeg', 'image/webp', 'image/gif', 'image/avif']);
+
+export class HfImageProxyError extends Error {
+  constructor(message, code) { super(message); this.name = 'HfImageProxyError'; this.code = code; }
+}
+
+function fail(message, code) { throw new HfImageProxyError(message, code); }
+
+function isAllowedHost(hostname) {
+  const host = hostname.toLowerCase().replace(/\.$/u, '');
+  return ALLOWED_SUFFIXES.some((suffix) => host === suffix || host.endsWith(`.${suffix}`));
+}
+
+function privateAddress(address) {
+  const normalized = String(address).toLowerCase().replace(/^\[|\]$/gu, '');
+  if (isIP(normalized) === 4) {
+    const parts = normalized.split('.').map(Number);
+    const [a, b] = parts;
+    return a === 0 || a === 10 || a === 127 || (a === 100 && b >= 64 && b <= 127)
+      || (a === 169 && b === 254) || (a === 172 && b >= 16 && b <= 31)
+      || (a === 192 && (b === 168 || b === 0)) || (a === 198 && b >= 18 && b <= 19)
+      || a >= 224;
+  }
+  if (isIP(normalized) === 6) {
+    const first = Number.parseInt(normalized.split(':')[0] || '0', 16);
+    return normalized === '::' || normalized === '::1' || normalized.startsWith('fe80:')
+      || (first >= 0xfc00 && first <= 0xfdff) || normalized.startsWith('::ffff:') && privateAddress(normalized.slice(7));
+  }
+  return true;
+}
+
+async function validateRemoteUrl(value, { redirect = false, lookupFn }) {
+  let url;
+  try { url = value instanceof URL ? new URL(value) : new URL(String(value)); } catch { fail('Hugging Face image URL is invalid', redirect ? 'HF_IMAGE_REDIRECT_REJECTED' : 'HF_IMAGE_URL_INVALID'); }
+  if (url.protocol !== 'https:' || url.username || url.password || !isAllowedHost(url.hostname)) {
+    fail('Hugging Face image host is not allowed', redirect ? 'HF_IMAGE_REDIRECT_REJECTED' : 'HF_IMAGE_HOST_REJECTED');
+  }
+  let records;
+  try { records = await lookupFn(url.hostname, { all: true, verbatim: true }); } catch { fail('Hugging Face image host could not be resolved', 'HF_IMAGE_DNS_FAILED'); }
+  const addresses = Array.isArray(records) ? records : [records];
+  if (!addresses.length || addresses.some((record) => privateAddress(record?.address ?? record))) fail('Hugging Face image host resolves to a private address', redirect ? 'HF_IMAGE_REDIRECT_REJECTED' : 'HF_IMAGE_PRIVATE_ADDRESS');
+  return url;
+}
+
+function combinedSignal(timeoutMs, externalSignal) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort('timeout'), timeoutMs);
+  timer.unref?.();
+  const onAbort = () => controller.abort(externalSignal.reason);
+  if (externalSignal?.aborted) onAbort();
+  else externalSignal?.addEventListener?.('abort', onAbort, { once: true });
+  return { signal: typeof AbortSignal.any === 'function' && externalSignal ? AbortSignal.any([controller.signal, externalSignal]) : controller.signal, close: () => { clearTimeout(timer); externalSignal?.removeEventListener?.('abort', onAbort); } };
+}
+
+async function readLimited(response, maxBytes) {
+  const advertised = Number(response.headers?.get?.('content-length'));
+  if (Number.isFinite(advertised) && advertised > maxBytes) fail('Hugging Face image is too large', 'HF_IMAGE_TOO_LARGE');
+  if (response.body?.getReader) {
+    const reader = response.body.getReader();
+    const chunks = []; let total = 0;
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      total += value?.byteLength ?? 0;
+      if (total > maxBytes) { await reader.cancel?.(); fail('Hugging Face image is too large', 'HF_IMAGE_TOO_LARGE'); }
+      chunks.push(Buffer.from(value));
+    }
+    return Buffer.concat(chunks, total);
+  }
+  const bytes = Buffer.from(await response.arrayBuffer());
+  if (bytes.byteLength > maxBytes) fail('Hugging Face image is too large', 'HF_IMAGE_TOO_LARGE');
+  return bytes;
+}
+
+export async function fetchAllowedHfImage(value, { fetchImpl = fetch, lookupFn = lookup, maxBytes = 4 * 1024 * 1024, timeoutMs = 15_000, signal = null } = {}) {
+  if (typeof fetchImpl !== 'function' || !Number.isSafeInteger(maxBytes) || maxBytes < 1 || !Number.isSafeInteger(timeoutMs) || timeoutMs < 1) fail('Hugging Face image proxy configuration is invalid', 'HF_IMAGE_CONFIG_INVALID');
+  let url = await validateRemoteUrl(value, { lookupFn, redirect: false });
+  const lifecycle = combinedSignal(timeoutMs, signal);
+  try {
+    for (let redirects = 0; redirects <= 3; redirects += 1) {
+      let response;
+      try { response = await fetchImpl(url, { redirect: 'manual', signal: lifecycle.signal, headers: { Accept: 'image/*' } }); }
+      catch (error) { if (lifecycle.signal.aborted) fail('Hugging Face image request timed out or was cancelled', 'HF_IMAGE_ABORTED'); fail('Hugging Face image could not be downloaded', 'HF_IMAGE_UNREACHABLE'); }
+      if (response.status >= 300 && response.status < 400) {
+        if (redirects === 3) fail('Hugging Face image redirected too many times', 'HF_IMAGE_REDIRECT_REJECTED');
+        const location = response.headers?.get?.('location');
+        if (!location) fail('Hugging Face image redirect is missing its destination', 'HF_IMAGE_REDIRECT_REJECTED');
+        let next;
+        try { next = new URL(location, url); } catch { fail('Hugging Face image redirect is invalid', 'HF_IMAGE_REDIRECT_REJECTED'); }
+        url = await validateRemoteUrl(next, { lookupFn, redirect: true });
+        continue;
+      }
+      if (!response.ok) fail('Hugging Face image service returned an error', 'HF_IMAGE_UPSTREAM');
+      const mimeType = String(response.headers?.get?.('content-type') || '').split(';', 1)[0].trim().toLowerCase();
+      if (!ALLOWED_MIME.has(mimeType)) fail('Hugging Face response is not a safe image format', 'HF_IMAGE_MIME_REJECTED');
+      const bytes = await readLimited(response, maxBytes);
+      return Object.freeze({ bytes, mimeType, sourceUrl: url.toString() });
+    }
+  } finally { lifecycle.close(); }
+  fail('Hugging Face image redirect is invalid', 'HF_IMAGE_REDIRECT_REJECTED');
+}