npm - letfixit - Versions diffs - 0.1.0 - Mend

letfixit 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (46) hide show

package/.env.example +33 -0
package/README.md +226 -0
package/adapters/android/build.gradle +28 -0
package/adapters/android/src/main/kotlin/dev/perfanalyzer/ChoreographerAdapter.kt +43 -0
package/adapters/android/src/main/kotlin/dev/perfanalyzer/LogcatReader.kt +64 -0
package/adapters/android/src/main/kotlin/dev/perfanalyzer/MemoryObserver.kt +46 -0
package/adapters/android/src/main/kotlin/dev/perfanalyzer/OkHttpInterceptor.kt +53 -0
package/adapters/android/src/main/kotlin/dev/perfanalyzer/PerfAnalyzer.kt +100 -0
package/adapters/flutter/lib/perf_analyzer.dart +73 -0
package/adapters/flutter/lib/src/frame_observer.dart +45 -0
package/adapters/flutter/lib/src/network_observer.dart +72 -0
package/adapters/flutter/lib/src/rebuild_observer.dart +57 -0
package/adapters/flutter/lib/src/universal_event.dart +50 -0
package/adapters/flutter/lib/src/vm_service_adapter.dart +81 -0
package/adapters/flutter/pubspec.lock +184 -0
package/adapters/flutter/pubspec.yaml +13 -0
package/config/model.manifest.example.json +108 -0
package/config/model.manifest.json +108 -0
package/core/schema/universal_event.dart +63 -0
package/dashboard/dist/assets/index-D5TCSsvB.js +107 -0
package/dashboard/dist/index.html +118 -0
package/package.json +62 -0
package/scripts/encrypt-model.js +86 -0
package/scripts/fill-manifest.js +67 -0
package/scripts/load-env.js +20 -0
package/scripts/model_crypto.js +14 -0
package/scripts/setup-model.js +269 -0
package/server/adb_bridge.js +201 -0
package/server/adb_score.js +77 -0
package/server/ai_proxy.js +373 -0
package/server/analysis_engine.js +222 -0
package/server/android_bridge.js +124 -0
package/server/android_live.js +167 -0
package/server/data/device_gpu_db.json +465 -0
package/server/device_db.js +94 -0
package/server/device_review.js +146 -0
package/server/finding_generator.js +56 -0
package/server/flutter_bridge.js +414 -0
package/server/index.js +619 -0
package/server/ios_bridge.js +181 -0
package/server/model_config.js +54 -0
package/server/report_template.js +169 -0
package/server/session_manager.js +370 -0
package/server/widget_gpu_classifier.js +77 -0
package/server/widget_triage.js +78 -0
package/setup.sh +160 -0

package/dashboard/dist/index.html ADDED Viewed

@@ -0,0 +1,118 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>ParityFix — AI Realtime Performance Analyzer</title>
+    <style>
+      /* ── ParityFix design tokens ─────────────────────────────────────────
+         Brand palette: #ffffff #474554 #aca7cb #ff00e9 #ff00d5            */
+      :root {
+        --pf-bg:          #18171f;
+        --pf-surface:     #201f2a;
+        --pf-surface-2:   #2a2836;
+        --pf-surface-3:   #474554;
+        --pf-ink:         #474554;
+        --pf-border:      #3a3848;
+        --pf-border-soft: #2d2b38;
+        --pf-text-hi:     #ffffff;
+        --pf-text:        #aca7cb;
+        --pf-text-2:      #c6c2de;
+        --pf-muted:       #8b86a6;
+        --pf-faint:       #615d76;
+        --pf-accent:      #ff00e9;   /* brand magenta — primary accent */
+        --pf-accent-2:    #ff00d5;   /* brand magenta — hover partner  */
+        --pf-teal:        #ff00e9;   /* alias: primary accent          */
+        --pf-sage:        #46d6a0;   /* good / success  */
+        --pf-warn:        #f2c14e;   /* medium          */
+        --pf-high:        #ff9457;   /* high            */
+        --pf-danger:      #ff4d6d;   /* critical        */
+        --pf-font: -apple-system, BlinkMacSystemFont, 'Segoe UI', Inter, Roboto, sans-serif;
+        --pf-mono: 'SF Mono', ui-monospace, 'Fira Code', Menlo, monospace;
+        --pf-radius: 10px;
+        --pf-shadow: 0 1px 2px rgba(0,0,0,.3), 0 4px 18px rgba(0,0,0,.22);
+      }
+      *, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+      html, body, #root { height: 100%; }
+      body {
+        background: var(--pf-bg);
+        color: var(--pf-text);
+        font-family: var(--pf-font);
+        -webkit-font-smoothing: antialiased;
+        font-size: 14px;
+      }
+      code, pre, .num { font-family: var(--pf-mono); }
+      ::-webkit-scrollbar { width: 8px; height: 8px; }
+      ::-webkit-scrollbar-track { background: transparent; }
+      ::-webkit-scrollbar-thumb { background: var(--pf-ink); border-radius: 4px; }
+      ::-webkit-scrollbar-thumb:hover { background: var(--pf-muted); }
+      button { font-family: inherit; }
+      button:focus-visible, input:focus-visible { outline: 2px solid var(--pf-teal); outline-offset: 1px; }
+      input::placeholder { color: var(--pf-faint); }
+      /* ── Shared component classes ─────────────────────────────────────── */
+      .pf-panel {
+        background: var(--pf-surface);
+        border: 1px solid var(--pf-border-soft);
+        border-radius: var(--pf-radius);
+        box-shadow: var(--pf-shadow);
+      }
+      .pf-panel-title {
+        font-size: 11px; font-weight: 700; letter-spacing: .08em;
+        text-transform: uppercase; color: var(--pf-text-2);
+      }
+      .pf-badge {
+        display: inline-flex; align-items: center; gap: 4px;
+        font-size: 10px; font-weight: 700; letter-spacing: .04em;
+        padding: 2px 8px; border-radius: 999px; text-transform: uppercase;
+        white-space: nowrap;
+      }
+      .pf-btn {
+        border-radius: 8px; border: 1px solid var(--pf-border);
+        background: var(--pf-surface-2); color: var(--pf-text);
+        font-size: 13px; font-weight: 600; padding: 7px 14px; cursor: pointer;
+        transition: background .15s, border-color .15s, color .15s;
+      }
+      .pf-btn:hover:not(:disabled) { background: var(--pf-surface-3); border-color: var(--pf-ink); }
+      .pf-btn:disabled { opacity: .45; cursor: default; }
+      .pf-btn-primary {
+        background: var(--pf-accent); border-color: var(--pf-accent); color: #ffffff; font-weight: 700;
+      }
+      .pf-btn-primary:hover:not(:disabled) { background: var(--pf-accent-2); border-color: var(--pf-accent-2); }
+      .pf-input {
+        width: 100%; background: var(--pf-bg); border: 1px solid var(--pf-border);
+        border-radius: 8px; padding: 9px 12px; color: var(--pf-text-hi);
+        font-size: 14px; font-family: inherit;
+      }
+      .pf-input:focus { border-color: var(--pf-teal); outline: none; }
+      .pf-chip {
+        border: 1px solid var(--pf-border); background: transparent;
+        color: var(--pf-text-2); font-size: 11px; font-weight: 600;
+        padding: 4px 11px; border-radius: 999px; cursor: pointer;
+        transition: all .15s;
+      }
+      .pf-chip:hover { border-color: var(--pf-muted); color: var(--pf-text-hi); }
+      .pf-chip.on { background: var(--pf-ink); border-color: var(--pf-muted); color: var(--pf-text-hi); }
+      .pf-empty {
+        padding: 26px 16px; text-align: center;
+        color: var(--pf-faint); font-size: 12.5px;
+      }
+      @keyframes pf-pulse { 0%,100% { opacity: 1 } 50% { opacity: .45 } }
+      @keyframes pf-blink { 0%,100% { opacity: 1 } 50% { opacity: .3 } }
+      .pf-pulse { animation: pf-pulse 1.6s ease-in-out infinite; }
+    </style>
+    <script type="module" crossorigin src="/assets/index-D5TCSsvB.js"></script>
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>

package/package.json ADDED Viewed

@@ -0,0 +1,62 @@
+{
+  "name": "letfixit",
+  "version": "0.1.0",
+  "description": "LetFixIt — AI-based realtime performance analysis & suggestions for Flutter, Android & iOS, powered by the local Ultron n0-beta model.",
+  "keywords": ["flutter", "android", "ios", "performance", "profiler", "devtools", "observability", "llm", "local-ai"],
+  "license": "MIT",
+  "author": "JahidDev24",
+  "main": "server/index.js",
+  "bin": {
+    "letfixit": "server/index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/JahidDev24/ultron-LLM-Coder.git"
+  },
+  "homepage": "https://github.com/JahidDev24/ultron-LLM-Coder#readme",
+  "bugs": {
+    "url": "https://github.com/JahidDev24/ultron-LLM-Coder/issues"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "files": [
+    "server/*.js",
+    "server/data/**",
+    "scripts/*.js",
+    "dashboard/dist/**",
+    "adapters/android/**/*.kt",
+    "adapters/android/**/*.gradle",
+    "adapters/flutter/lib/**/*.dart",
+    "adapters/flutter/pubspec.yaml",
+    "adapters/flutter/pubspec.lock",
+    "core/**/*.dart",
+    "config/model.manifest.json",
+    "config/model.manifest.example.json",
+    "setup.sh",
+    ".env.example",
+    "README.md"
+  ],
+  "scripts": {
+    "start": "node server/index.js",
+    "dev": "concurrently \"node server/index.js\" \"cd dashboard && npm run dev\"",
+    "build": "cd dashboard && npm run build",
+    "setup": "node scripts/setup-model.js",
+    "setup:force": "node scripts/setup-model.js --force",
+    "encrypt-model": "node scripts/encrypt-model.js",
+    "fill-manifest": "node scripts/fill-manifest.js",
+    "postinstall": "node scripts/setup-model.js",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "dotenv": "^16.3.1",
+    "express": "^4.18.2",
+    "node-fetch": "^2.7.0",
+    "uuid": "^9.0.0",
+    "ws": "^8.14.2"
+  }
+}

package/scripts/encrypt-model.js ADDED Viewed

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+// ── Maintainer tool: split + encrypt a model into 3 chunks ────────────────────
+// Produces the encrypted chunks + a manifest for release. You then upload the
+// chunk files (Drive / GitHub Release / any CDN), paste their URLs into the
+// manifest, and ship the manifest — but NEVER the key. The key stays in your
+// environment (and in GitHub Actions secrets for CI releases).
+//
+//   PARITYFIX_MODEL_KEY=<passphrase> node scripts/encrypt-model.js <source.gguf> [outDir]
+//
+// Output (default outDir = dist/model-chunks/):
+//   chunk.0.enc chunk.1.enc chunk.2.enc   ← upload these
+//   model.manifest.json                   ← fill in each chunk's `url`, then copy to config/
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { pipeline } = require('stream/promises');
+require('./load-env')();   // pull PARITYFIX_MODEL_KEY etc. from .env (root has no dotenv)
+const mc = require('../server/model_config');
+const { ALGO, deriveKey } = require('./model_crypto');
+async function sha256File(p) {
+  const h = crypto.createHash('sha256');
+  await pipeline(fs.createReadStream(p), async function* (src) { for await (const d of src) h.update(d); yield; });
+  return h.digest('hex');
+}
+async function main() {
+  const src = process.argv[2];
+  const outDir = path.resolve(process.argv[3] || 'dist/model-chunks');
+  const key = process.env.PARITYFIX_MODEL_KEY;
+  if (!src || !fs.existsSync(src)) { console.error('usage: PARITYFIX_MODEL_KEY=… node scripts/encrypt-model.js <source.gguf> [outDir]'); process.exit(1); }
+  if (!key) { console.error('❌ PARITYFIX_MODEL_KEY is not set (the decryption passphrase). Never commit it.'); process.exit(1); }
+  fs.mkdirSync(outDir, { recursive: true });
+  const total = fs.statSync(src).size;
+  // Size-based: as many chunks as needed so each is ≤ CHUNK_MAX_BYTES, then made
+  // equal — base size each with the remainder spread one byte at a time, so all
+  // parts differ by at most 1 byte and every part stays under the cap.
+  const n = Math.max(1, Math.ceil(total / mc.CHUNK_MAX_BYTES));
+  const base = Math.floor(total / n);
+  const rem = total % n;
+  const salt = crypto.randomBytes(16).toString('hex');
+  const derivedKey = deriveKey(key, salt);
+  console.log(`\n  Encrypting ${path.basename(src)} (${(total / 1024 ** 3).toFixed(2)} GB) → ${n} chunks of ~${(base / 1048576).toFixed(0)} MB (cap ${(mc.CHUNK_MAX_BYTES / 1048576).toFixed(0)} MB) in ${outDir}\n`);
+  const chunks = [];
+  let start = 0;
+  for (let i = 0; i < n; i++) {
+    const size = base + (i < rem ? 1 : 0);
+    const end = start + size - 1; // inclusive range for createReadStream
+    if (start > end) break;
+    const iv = crypto.randomBytes(12);
+    const cipher = crypto.createCipheriv(ALGO, derivedKey, iv);
+    const encFile = path.join(outDir, `chunk.${String(i).padStart(2, '0')}.enc`);
+    await pipeline(fs.createReadStream(src, { start, end }), cipher, fs.createWriteStream(encFile));
+    const authTag = cipher.getAuthTag().toString('hex');
+    const sha = await sha256File(encFile);
+    chunks.push({
+      index: i,
+      file: path.basename(encFile),
+      url: `REPLACE_WITH_DOWNLOAD_URL_FOR_${path.basename(encFile)}`,
+      mirrors: [],                       // optional extra sources for this chunk
+      iv: iv.toString('hex'),
+      authTag,
+      sha256: sha,
+      bytes: end - start + 1,
+    });
+    console.log(`  ✓ chunk ${i}: ${((end - start + 1) / 1048576).toFixed(1)} MB → ${encFile}`);
+    start = end + 1;
+  }
+  const manifest = { name: mc.MODEL_NAME, algorithm: ALGO, salt, sha256: await sha256File(src), chunks };
+  const manifestPath = path.join(outDir, 'model.manifest.json');
+  fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+  console.log(`\n  ✅ Wrote ${manifestPath}  (${chunks.length} chunks)`);
+  console.log('  Next:');
+  console.log('    1) Upload the chunk.*.enc files — ideally SPREAD across sources (GitHub Release + a CDN/bucket).');
+  console.log('    2) Put each direct-download URL into the manifest\'s `url`; add extra hosts to `mirrors` for redundancy.');
+  console.log('    3) Prefer hosts that support HTTP range requests so installs resume after a dropped connection.');
+  console.log('    4) Copy the manifest to config/model.manifest.json (git-ignored).');
+  console.log('    5) Store PARITYFIX_MODEL_KEY as a GitHub Actions secret — never commit it.\n');
+}
+main().catch((e) => { console.error('❌', e.message); process.exit(1); });

package/scripts/fill-manifest.js ADDED Viewed

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+// ── Manifest assembler ────────────────────────────────────────────────────────
+// Turns the generated dist/model-chunks/model.manifest.json into a ready-to-ship
+// config/model.manifest.json by filling in each chunk's download `url` from your
+// GitHub Release assets. Chunks below --split go to the part-1 tag, the rest to
+// part-2 (matching the two-release, multi-source layout).
+//
+//   node scripts/fill-manifest.js \
+//     --owner <you> --repo <repo> \
+//     --part1-tag model-v0-part1 --part2-tag model-v0-part2 [--split 5]
+//
+// Single-release variant: pass only --part1-tag (all chunks use it).
+const fs = require('fs');
+const path = require('path');
+const ROOT = path.join(__dirname, '..');
+const SRC = path.join(ROOT, 'dist', 'model-chunks', 'model.manifest.json');
+const OUT = path.join(ROOT, 'config', 'model.manifest.json');
+function arg(name, def) {
+  const i = process.argv.indexOf(`--${name}`);
+  return i >= 0 && process.argv[i + 1] ? process.argv[i + 1] : def;
+}
+const owner = arg('owner');
+const repo = arg('repo');
+const part1 = arg('part1-tag');
+const part2 = arg('part2-tag', part1);          // default: one release for all
+const split = parseInt(arg('split', '5'), 10);  // chunks < split → part1
+if (!owner || !repo || !part1) {
+  console.error('usage: node scripts/fill-manifest.js --owner <you> --repo <repo> --part1-tag <tag> [--part2-tag <tag>] [--split N]');
+  process.exit(1);
+}
+if (!fs.existsSync(SRC)) {
+  console.error(`❌ ${path.relative(ROOT, SRC)} not found. Run \`npm run encrypt-model -- <model.gguf>\` first.`);
+  process.exit(1);
+}
+const src = JSON.parse(fs.readFileSync(SRC, 'utf8'));
+const assetUrl = (tag, file) => `https://github.com/${owner}/${repo}/releases/download/${tag}/${file}`;
+const chunks = src.chunks
+  .slice()
+  .sort((a, b) => a.index - b.index)
+  .map((ch) => {
+    const tag = ch.index < split ? part1 : part2;
+    return {
+      index: ch.index,
+      url: assetUrl(tag, ch.file),
+      mirrors: ch.mirrors && ch.mirrors.length ? ch.mirrors : [],
+      iv: ch.iv,
+      authTag: ch.authTag,
+      sha256: ch.sha256,
+      bytes: ch.bytes,
+    };
+  });
+const out = { name: src.name, algorithm: src.algorithm, salt: src.salt, sha256: src.sha256, chunks };
+fs.mkdirSync(path.dirname(OUT), { recursive: true });
+fs.writeFileSync(OUT, JSON.stringify(out, null, 2) + '\n');
+console.log(`✅ Wrote ${path.relative(ROOT, OUT)}  (${chunks.length} chunks)`);
+const p1 = chunks.filter((c) => c.index < split).length;
+console.log(`   chunks 0–${split - 1} → ${part1}  (${p1})`);
+if (part2 !== part1) console.log(`   chunks ${split}–${chunks.length - 1} → ${part2}  (${chunks.length - p1})`);
+console.log('   Verify the assets are reachable, then commit is NOT needed — this file is git-ignored.');

package/scripts/load-env.js ADDED Viewed

@@ -0,0 +1,20 @@
+// Minimal, dependency-free .env loader for the root scripts (root has no
+// node_modules, so we can't rely on the `dotenv` package here). Real environment
+// variables and CI secrets always win — we only fill in what isn't already set.
+const fs = require('fs');
+const path = require('path');
+module.exports = function loadEnv() {
+  const p = path.join(__dirname, '..', '.env');
+  if (!fs.existsSync(p)) return;
+  for (const raw of fs.readFileSync(p, 'utf8').split('\n')) {
+    const line = raw.trim();
+    if (!line || line.startsWith('#')) continue;
+    const eq = line.indexOf('=');
+    if (eq < 0) continue;
+    const key = line.slice(0, eq).trim();
+    let val = line.slice(eq + 1).trim();
+    if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) val = val.slice(1, -1);
+    if (process.env[key] === undefined) process.env[key] = val;
+  }
+};

package/scripts/model_crypto.js ADDED Viewed

@@ -0,0 +1,14 @@
+// Shared crypto for the model chunk pipeline. AES-256-GCM with a scrypt-derived
+// key. The passphrase (PARITYFIX_MODEL_KEY) is NEVER committed — it lives in an
+// env var locally and in GitHub Actions secrets at release time. The salt is not
+// secret and travels in the manifest.
+const crypto = require('crypto');
+const ALGO = 'aes-256-gcm';
+function deriveKey(passphrase, saltHex) {
+  if (!passphrase) throw new Error('PARITYFIX_MODEL_KEY is not set');
+  return crypto.scryptSync(String(passphrase), Buffer.from(saltHex, 'hex'), 32);
+}
+module.exports = { ALGO, deriveKey };

package/scripts/setup-model.js ADDED Viewed

@@ -0,0 +1,269 @@
+#!/usr/bin/env node
+// ── Ultron n0-beta installer ──────────────────────────────────────────────────
+// Downloads the 3 encrypted model chunks (interactive progress) → verifies →
+// AES-GCM decrypts → merges → finalizes as bin/ultron/ultron-n0-beta.gguf →
+// prints a friendly success + model disclaimer.
+//
+// Runs from `npm run setup` or as a postinstall step. It is NON-FATAL: if the
+// chunk manifest or decryption key isn't configured, it prints instructions and
+// exits cleanly so `npm install` never breaks.
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const https = require('https');
+const http = require('http');
+const { fileURLToPath } = require('url');
+require('./load-env')();   // pull PARITYFIX_MODEL_KEY etc. from .env (root has no dotenv)
+const mc = require('../server/model_config');
+const { ALGO, deriveKey } = require('./model_crypto');
+const C = { reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m', mag: '\x1b[95m', grn: '\x1b[92m', yel: '\x1b[93m', red: '\x1b[91m', cyan: '\x1b[96m' };
+const c = (col, s) => `${col}${s}${C.reset}`;
+const isPostinstall = process.env.npm_lifecycle_event === 'postinstall';
+const FORCE = process.argv.includes('--force');
+const TMP = path.join(mc.MODEL_DIR, '.tmp');
+const mb = (n) => (n / 1048576).toFixed(1);
+// ── Interactive progress bar ────────────────────────────────────────────────
+function drawBar(label, done, total) {
+  const width = 26;
+  const pct = total ? Math.min(1, done / total) : 0;
+  const filled = Math.round(pct * width);
+  const bar = c(C.mag, '█'.repeat(filled)) + c(C.dim, '░'.repeat(width - filled));
+  const size = total ? `${mb(done)}/${mb(total)} MB` : `${mb(done)} MB`;
+  process.stdout.write(`\r  ${label} [${bar}] ${String(Math.round(pct * 100)).padStart(3)}%  ${size}   `);
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+// ── Resumable download ────────────────────────────────────────────────────────
+// Streams `urlStr` into `dest.part`, resuming via an HTTP Range request if a
+// partial file already exists, then renames to `dest`. On mid-stream failure the
+// `.part` is left in place so the next attempt continues from where it stopped.
+// Supports http(s) (with redirects + Drive confirm) and file:// (for testing).
+function download(urlStr, dest, label) {
+  const partPath = dest + '.part';
+  return new Promise((resolve, reject) => {
+    if (urlStr.startsWith('file://')) {
+      const src = fileURLToPath(urlStr);
+      const total = fs.statSync(src).size;
+      let done = 0;
+      const rs = fs.createReadStream(src);
+      const ws = fs.createWriteStream(partPath);
+      rs.on('data', (ch) => { done += ch.length; drawBar(label, done, total); });
+      rs.on('error', reject); ws.on('error', reject);
+      ws.on('finish', () => { process.stdout.write('\n'); fs.renameSync(partPath, dest); resolve(); });
+      rs.pipe(ws);
+      return;
+    }
+    const startAt = fs.existsSync(partPath) ? fs.statSync(partPath).size : 0;
+    const go = (u, redirects, cookie) => {
+      if (redirects > 6) return reject(new Error('too many redirects'));
+      const lib = u.startsWith('https') ? https : http;
+      const headers = {};
+      if (cookie) headers.cookie = cookie;
+      if (startAt > 0) headers.Range = `bytes=${startAt}-`; // resume
+      const req = lib.get(u, { headers }, (res) => {
+        const setCookie = res.headers['set-cookie']?.join('; ') || cookie;
+        if ([301, 302, 303, 307, 308].includes(res.statusCode)) {
+          res.resume();
+          return go(new URL(res.headers.location, u).toString(), redirects + 1, setCookie);
+        }
+        // Google Drive large-file interstitial: HTML page with a confirm token.
+        if ((res.headers['content-type'] || '').includes('text/html') && /google\.com|googleusercontent/.test(u)) {
+          let body = '';
+          res.on('data', (d) => (body += d));
+          res.on('end', () => {
+            const action = (body.match(/action="([^"]+download[^"]*)"/) || [])[1];
+            const tok = (body.match(/confirm=([0-9A-Za-z_-]+)/) || [])[1];
+            if (action) return go(action.replace(/&amp;/g, '&'), redirects + 1, setCookie);
+            if (tok) { const sep = u.includes('?') ? '&' : '?'; return go(`${u}${sep}confirm=${tok}`, redirects + 1, setCookie); }
+            reject(new Error('Google Drive returned HTML (quota/private?). Use a GitHub Release/CDN URL that supports range requests.'));
+          });
+          return;
+        }
+        if (![200, 206].includes(res.statusCode)) { res.resume(); return reject(new Error(`HTTP ${res.statusCode}`)); }
+        // 206 → server honored resume (append). 200 → full body (restart).
+        const resuming = res.statusCode === 206;
+        let done = resuming ? startAt : 0;
+        const len = parseInt(res.headers['content-length'] || '0', 10);
+        const total = resuming ? startAt + len : len;
+        const ws = fs.createWriteStream(partPath, { flags: resuming ? 'a' : 'w' });
+        res.on('data', (ch) => { done += ch.length; drawBar(label, done, total); });
+        res.on('error', reject); ws.on('error', reject);
+        ws.on('finish', () => { process.stdout.write('\n'); fs.renameSync(partPath, dest); resolve(); });
+        res.pipe(ws);
+      });
+      req.on('error', reject);
+    };
+    go(urlStr, 0, null);
+  });
+}
+// Fetch one chunk, trying its url then each mirror, retrying (and resuming) on
+// failure, and verifying the checksum before accepting it.
+async function fetchChunk(ch, encPath, baseLabel) {
+  const sources = [ch.url, ...(ch.mirrors || [])].filter((u) => u && !/^REPLACE/.test(u));
+  if (!sources.length) throw new Error(`chunk ${ch.index} has no valid download URL in the manifest`);
+  let lastErr;
+  for (let s = 0; s < sources.length; s++) {
+    const label = sources.length > 1 ? `${baseLabel} ${c(C.dim, `(src ${s + 1}/${sources.length})`)}` : baseLabel;
+    for (let attempt = 1; attempt <= 3; attempt++) {
+      try {
+        await download(sources[s], encPath, label);
+        if (ch.sha256) {
+          const got = await sha256File(encPath);
+          if (got !== ch.sha256) { fs.rmSync(encPath, { force: true }); throw new Error('checksum mismatch (corrupt download)'); }
+        }
+        return; // success
+      } catch (e) {
+        lastErr = e;
+        const resumable = fs.existsSync(encPath + '.part');
+        console.log('\n  ' + c(C.yel, `⚠ ${baseLabel} attempt ${attempt} failed: ${e.message}`) + c(C.dim, resumable ? ' — resuming…' : ' — retrying…'));
+        await sleep(1000 * attempt);
+      }
+    }
+  }
+  throw lastErr || new Error(`chunk ${ch.index} download failed`);
+}
+function sha256File(p) {
+  return new Promise((resolve, reject) => {
+    const h = crypto.createHash('sha256');
+    fs.createReadStream(p).on('data', (d) => h.update(d)).on('error', reject).on('end', () => resolve(h.digest('hex')));
+  });
+}
+function decryptChunk(encPath, outPath, key, ivHex, authTagHex) {
+  return new Promise((resolve, reject) => {
+    const decipher = crypto.createDecipheriv(ALGO, key, Buffer.from(ivHex, 'hex'));
+    if (authTagHex) decipher.setAuthTag(Buffer.from(authTagHex, 'hex'));
+    const rs = fs.createReadStream(encPath);
+    const ws = fs.createWriteStream(outPath);
+    rs.on('error', reject); ws.on('error', reject); decipher.on('error', reject);
+    ws.on('finish', resolve);
+    rs.pipe(decipher).pipe(ws);
+  });
+}
+function mergeInto(parts, dest) {
+  return new Promise((resolve, reject) => {
+    const ws = fs.createWriteStream(dest);
+    ws.on('error', reject);
+    const next = (i) => {
+      if (i >= parts.length) return ws.end(resolve);
+      const rs = fs.createReadStream(parts[i]);
+      rs.on('error', reject);
+      rs.on('end', () => next(i + 1));
+      rs.pipe(ws, { end: false });
+    };
+    next(0);
+  });
+}
+function box(lines) {
+  const w = Math.max(...lines.map((l) => stripAnsi(l).length));
+  const top = '  ╔' + '═'.repeat(w + 2) + '╗';
+  const bot = '  ╚' + '═'.repeat(w + 2) + '╝';
+  console.log(c(C.mag, top));
+  for (const l of lines) console.log(c(C.mag, '  ║ ') + l + ' '.repeat(w - stripAnsi(l).length) + c(C.mag, ' ║'));
+  console.log(c(C.mag, bot));
+}
+const stripAnsi = (s) => s.replace(/\x1b\[[0-9;]*m/g, '');
+// ── Main ─────────────────────────────────────────────────────────────────────
+async function setup() {
+  console.log(`\n  ${c(C.bold + C.mag, '✦ Ultron n0-beta')} — local model setup\n`);
+  if (mc.isReady() && !FORCE) {
+    console.log(c(C.grn, `  ✅ ${mc.MODEL_NAME} already installed (${mc.sizeGB()} GB). Use --force to reinstall.\n`));
+    return;
+  }
+  const manifest = mc.loadManifest();
+  const key = process.env.PARITYFIX_MODEL_KEY;
+  if (!manifest || !key) {
+    console.log(c(C.yel, '  ⚠️  Model chunks not configured — skipping automatic download.\n'));
+    if (!manifest) console.log(`     • No chunk manifest found. Copy ${c(C.cyan, 'config/model.manifest.example.json')} → ${c(C.cyan, 'config/model.manifest.json')} and fill in the chunk URLs.`);
+    if (!key)      console.log(`     • Set ${c(C.cyan, 'PARITYFIX_MODEL_KEY')} (the decryption passphrase) in your environment.`);
+    console.log(`\n     Then run ${c(C.cyan, 'npm run setup')} again. (You can also use the legacy ${c(C.cyan, './setup.sh')} to pull from HuggingFace.)\n`);
+    return; // non-fatal
+  }
+  const chunks = [...manifest.chunks].sort((a, b) => a.index - b.index);
+  console.log(c(C.dim, `  ${chunks.length} chunk(s) to fetch — resumable, mirror-aware.\n`));
+  fs.mkdirSync(TMP, { recursive: true });
+  const derivedKey = deriveKey(key, manifest.salt);
+  const decParts = [];
+  for (const ch of chunks) {
+    const label = c(C.cyan, `Chunk ${ch.index + 1}/${chunks.length}`);
+    const encPath = path.join(TMP, `chunk.${String(ch.index).padStart(2, '0')}.enc`);
+    const decPath = path.join(TMP, `chunk.${String(ch.index).padStart(2, '0')}.dec`);
+    // Skip already-fetched-and-verified chunks (idempotent re-runs).
+    let haveValid = false;
+    if (fs.existsSync(encPath) && ch.sha256) haveValid = (await sha256File(encPath)) === ch.sha256;
+    if (!haveValid) await fetchChunk(ch, encPath, label);
+    process.stdout.write(`  ${c(C.dim, `↳ decrypting chunk ${ch.index + 1}…`)}\r`);
+    await decryptChunk(encPath, decPath, derivedKey, ch.iv, ch.authTag);
+    process.stdout.write(' '.repeat(40) + '\r');
+    decParts.push(decPath);
+  }
+  console.log(c(C.dim, '  ↳ merging chunks…'));
+  fs.mkdirSync(mc.MODEL_DIR, { recursive: true });
+  await mergeInto(decParts, mc.MODEL_PATH);
+  const size = fs.statSync(mc.MODEL_PATH).size;
+  if (size < mc.MIN_BYTES) throw new Error(`merged model is only ${mb(size)}MB — expected the full weights`);
+  if (manifest.sha256) {
+    const got = await sha256File(mc.MODEL_PATH);
+    if (got !== manifest.sha256) throw new Error('merged model checksum mismatch');
+  }
+  try { fs.chmodSync(mc.MODEL_PATH, 0o755); } catch (_) {}
+  fs.rmSync(TMP, { recursive: true, force: true });
+  console.log('');
+  box([
+    c(C.bold + C.grn, `✅  ${mc.MODEL_NAME} is ready`),
+    '',
+    c(C.reset, `Local model   ${c(C.cyan, path.relative(process.cwd(), mc.MODEL_PATH))}`),
+    c(C.reset, `Size          ${c(C.cyan, mc.sizeGB() + ' GB')}`),
+    c(C.reset, `Runs          ${c(C.cyan, '100% on-device — private, no cloud needed')}`),
+  ]);
+  console.log('');
+  console.log('  ' + c(C.dim, wrap(mc.DISCLAIMER, 76, '  ')));
+  console.log('');
+  console.log(`  ${c(C.mag, '▸')} Start it with ${c(C.cyan, 'npm start')}\n`);
+}
+// Wrap long text to a width, indenting continuation lines.
+function wrap(text, width, indent) {
+  const words = text.split(' ');
+  const lines = [];
+  let line = '';
+  for (const w of words) {
+    if ((line + ' ' + w).trim().length > width) { lines.push(line.trim()); line = w; }
+    else line += ' ' + w;
+  }
+  if (line.trim()) lines.push(line.trim());
+  return lines.join('\n' + indent);
+}
+if (require.main === module) {
+  setup().catch((err) => {
+    console.log('\n' + c(C.red, `  ❌ Model setup failed: ${err.message}`));
+    console.log(c(C.dim, '     You can retry with `npm run setup`, or use ./setup.sh for the HuggingFace source.\n'));
+    process.exit(isPostinstall ? 0 : 1); // never break `npm install`
+  });
+}
+module.exports = { download, fetchChunk, decryptChunk, mergeInto, sha256File, setup };