Skip to content

The all-in-one local AI studio for your desktop: chat, image and video generation and a coding agent in one free, open source app. Windows and Linux. No Docker, no terminal, no cloud required.

16.1 KB
Raw Blame
/**
 * Zusicherungen ÜBER `vite.config.ts` selbst — die Klammer zwischen den
 * herausgelösten Modulen und der Datei, die sie benutzen soll.
 *
 * Warum statisch: die Middlewares hängen an einem echten `ViteDevServer` mit
 * laufendem ComfyUI-Starter, Ollama-Spawn und Whisper-Prozess; sie im Test zu
 * instanziieren hiesse, den halben Rechner zu starten. Was hier geprüft wird,
 * ist deshalb nicht das Verhalten, sondern dass die FORM der Fehler, die in
 * `src/dev/` behoben sind, nicht in `vite.config.ts` zurückkommt. Das Verhalten
 * selbst steht in http-body.test.ts, ssrf-policy.test.ts und
 * model-paths.test.ts — diese Datei sagt nur: die Datei benutzt sie auch.
 *
 * Dieselbe Technik benutzt schon `src/lib/__tests__/app-identity.test.ts` auf
 * derselben Datei.
 *
 * NEGATIVE CONTROL (von Hand geprüft): einen der verbotenen Ausdrücke in
 * vite.config.ts wieder einsetzen (z. B. `const x = JSON.parse(body)`) → der
 * zugehörige Fall wird rot.
 *
 * Run: npx vitest run src/dev/__tests__/dev-server-shape.test.ts
 */
import { describe, expect, it } from 'vitest'
import { readFileSync } from 'node:fs'
import { resolve } from 'node:path'

/**
 * Der Quelltext des ausgelieferten Dev-Servers, ohne reine Kommentarzeilen.
 *
 * Bis ZB-7 war das `vite.config.ts` allein — der Dev-Server WAR die
 * Build-Konfiguration. Er liegt jetzt in `dev-server/`; die Zusicherungen
 * unten sind unverändert, nur ihre Quelle ist es nicht mehr. `vite.config.ts`
 * bleibt in der Liste, weil dieselben Fehlerformen auch dort nicht
 * zurückkommen dürfen.
 *
 * Die REIHENFOLGE ist die Einhäng-Reihenfolge aus dev-server/index.ts, denn
 * `ausschnitt` unten schneidet „bis zum nächsten Endpunkt".
 *
 * Die Kommentare der Dateien ZITIEREN die alten Fehlerformen, um zu erklären,
 * warum es die Module in `src/dev/` gibt — ein Grep über den Rohtext würde also
 * genau die Erklärung als Verstoss lesen. Nur ganze Kommentarzeilen fallen weg;
 * ein Verstoss im Code steht nie auf einer solchen Zeile.
 */
const DEV_SERVER_QUELLEN = [
  'dev-server/guard.ts',
  'dev-server/ssrf.ts',
  'dev-server/http.ts',
  'dev-server/proxy-routes.ts',
  'dev-server/remote-stubs.ts',
  'dev-server/comfy.ts',
  'dev-server/downloads.ts',
  'dev-server/exec-routes.ts',
  'dev-server/fs-routes.ts',
  'dev-server/system-routes.ts',
  'dev-server/web-search.ts',
  'dev-server/whisper.ts',
  'dev-server/index.ts',
  'vite.config.ts',
]

const viteConfigRoh = DEV_SERVER_QUELLEN
  .map((datei) => readFileSync(resolve(process.cwd(), datei), 'utf8'))
  .join('\n')
const viteConfig = viteConfigRoh
  .split('\n')
  .filter((line) => {
    const t = line.trim()
    return !(t.startsWith('//') || t.startsWith('*') || t.startsWith('/*'))
  })
  .join('\n')

/**
 * Der Textausschnitt EINES Handlers.
 *
 * Ein Grep über die ganze Datei beantwortet „steht der Wächter irgendwo" —
 * die Frage ist aber „steht er in DIESEM Handler". `bis` ist die nächste
 * Marke; ohne Angabe endet der Ausschnitt an der nächsten Middleware.
 */
function ausschnitt(von: string, bis?: string | null): string {
  const start = viteConfig.indexOf(von)
  expect(start, `nicht gefunden: ${von}`).toBeGreaterThanOrEqual(0)
  const rest = viteConfig.slice(start + von.length)
  const marke = bis ?? "routes.use('/local-api/"
  const ende = rest.indexOf(marke)
  return ende < 0 ? rest : rest.slice(0, ende)
}

describe('der Request-Körper', () => {
  it('wird nirgends mehr chunkweise zu einem String addiert', () => {
    // `body += chunk` dekodiert jeden Chunk einzeln; ein Zeichen auf der
    // Chunk-Grenze zerfällt. Siehe http-body.test.ts.
    expect(viteConfig).not.toMatch(/body \+= c\b/)
    expect(viteConfig.match(/=> \{ body \+= /g)).toBeNull()
  })

  it('wird nirgends mehr ungeschützt geparst', () => {
    // `JSON.parse(body)` in einem `end`-Handler: der Wurf kommt an, wenn die
    // Middleware längst zurückgekehrt ist, niemand fängt ihn, und der ganze
    // `npm run dev`-Prozess endet. Drei Endpunkte hatten genau das.
    expect(viteConfig).not.toContain('JSON.parse(body)')
  })

  it('geht durch den einen geprüften Leser', () => {
    // Ein Einstieg für alle POST-Handler. Sinkt diese Zahl, wurde entweder
    // wieder von Hand gepuffert — oder ein Handler ist absichtlich gegangen.
    // Von zwanzig auf achtzehn: `/local-api/file-read` und `/file-write` sind
    // entfernt (siehe „die beiden alten file-Endpunkte" weiter unten). Wer die
    // Zahl das nächste Mal senkt, muss denselben Nachweis mitbringen.
    const stellen = viteConfig.match(/withJsonBody\(req, res, \(body\) =>/g) ?? []
    expect(stellen.length).toBeGreaterThanOrEqual(18)
  })
})

describe('Pfade aus dem Request', () => {
  it('bauen den ComfyUI-Zielpfad nicht mehr von Hand zusammen', () => {
    // `join(comfyPath, 'models', subfolder)` mit `subfolder: '../../..'` schrieb
    // ausserhalb der Installation. Siehe model-paths.test.ts.
    expect(viteConfig).not.toContain("join(comfyPath, 'models', subfolder")
    expect(viteConfig).not.toContain("join(comfyPath, 'models', subfolder, id)")
    expect(viteConfig).not.toContain('join(destDir, filename)')
    expect(viteConfig).not.toContain('join(customNodesDir, node_name')
  })

  it('gehen durch den Käfig', () => {
    expect(viteConfig).toContain('comfyDestPath(')
    expect(viteConfig).toContain('downloadToPathDest(')
    expect(viteConfig).toContain('customNodeDir(')
  })
})

describe('Prozessaufrufe aus dem Request', () => {
  it('bauen keine Shell-Zeile mehr aus fremden Werten', () => {
    // `execSync(\`git clone "${repo_url}" "${targetDir}"\`)`: die
    // doppelten Anführungszeichen sind keine Grenze, `x"; …; echo "` war ein
    // zweites Kommando.
    expect(viteConfig).not.toContain('git clone "${')
    expect(viteConfig).not.toContain('pip install -r "${')
    expect(viteConfig).toContain("execFileSync('git', ['clone'")
  })
})

describe('der SSRF-Wächter', () => {
  it('entscheidet nicht mehr auf der Schreibweise der Adresse', () => {
    // Die alten Präfix-/Regex-Prüfungen sahen `0:0:0:0:0:ffff:127.0.0.1` nicht.
    // Siehe ssrf-policy.test.ts.
    expect(viteConfig).not.toContain("lc.startsWith('fe80')")
    expect(viteConfig).not.toContain("lc.startsWith('64:ff9b:')")
    expect(viteConfig).toContain('createSsrfPolicy(')
  })

  it('lässt net.isIP das Orakel bleiben, statt es nachzubauen', () => {
    expect(viteConfig).toContain('net.isIP(value)')
  })

  it('hängt auch am Model-Download, nicht nur an den beiden Proxies', () => {
    // DER BEFUND: `downloadFile` holte jede URL, die der Aufrufer angab, und
    // schrieb die Antwort auf die Platte — `http://169.254.169.254/…`
    // eingeschlossen, zwei Bildschirmseiten unter `proxy-image` /
    // `proxy-download`, die genau dagegen geschützt sind. Der gepackte Build
    // hat an derselben Stelle `proxy::validate_public_url(url)?`
    // (download.rs::download_with_progress).
    const downloadFile = ausschnitt('function downloadFile(', 'routes.use(\'/local-api/download-model\'')
    expect(downloadFile).toContain('await assertPublicUrl(requestUrl)')
  })

  it('prüft JEDEN Weiterleitungs-Hop, nicht nur den ersten', () => {
    // Der klassische Bypass: eine öffentliche URL antwortet mit 302 auf
    // 169.254.169.254. Rust benutzt dafür `ssrf_safe_redirect_policy`; hier
    // muss die Weiterleitung zurück durch `doRequest` — und damit durch den
    // Wächter — statt an ihm vorbei.
    const downloadFile = ausschnitt('function downloadFile(', 'routes.use(\'/local-api/download-model\'')
    // Der Wächter steht VOR dem ersten `proto.get`, nicht dahinter.
    const wächter = downloadFile.indexOf('await assertPublicUrl(requestUrl)')
    expect(wächter).toBeGreaterThanOrEqual(0)
    expect(wächter).toBeLessThan(downloadFile.indexOf('proto.get('))
    // Und die Weiterleitung geht durch dieselbe Funktion.
    expect(downloadFile).toMatch(/doRequest\(next, redirectCount \+ 1\)/)
    expect(downloadFile).not.toMatch(/doRequest\(response\.headers\.location/)
  })

  it('verbindet auf die GEPRÜFTE Adresse, nicht noch einmal auf den Namen', () => {
    // DER BEFUND (Rebind-Fenster): `assertPublicUrl` löste den Namen auf, prüfte
    // die Adressen und warf sie weg — der `http.get` daneben löste denselben
    // Namen ERNEUT auf. Ein Resolver, der der Prüfung eine öffentliche Adresse
    // und dem Verbindungsaufbau 127.0.0.1 gibt, kam durch. Rust pinnt an
    // derselben Stelle (`pinned_client` / `resolve_to_addrs`, proxy.rs:290).
    // Das Verhalten steht in ssrf-fetch.test.ts; hier steht nur, dass die drei
    // Holstellen dieser Datei es auch benutzen.
    expect(viteConfig).toContain('checkPublicUrl(urlStr, ssrfDeps)')
    const downloadFile = ausschnitt('function downloadFile(', "routes.use('/local-api/download-model'")
    expect(downloadFile).toContain('createPinnedLookup(target.addresses, ssrfDeps.ipFamily)')
    expect(downloadFile).toContain('proto.get(requestUrl, { headers, lookup: pinned }')
  })

  it('hat die drei handgeschriebenen Weiterleitungsschleifen auf EINE reduziert', () => {
    // `proxy-image` folgte GENAU EINEM Sprung (der zweite hätte auf
    // 169.254.169.254 zeigen dürfen), `proxy-download` und `downloadFile` je
    // fünf — drei Kopien derselben Sicherheitslogik. Die geprüfte Schleife liegt
    // jetzt in src/dev/ssrf-fetch.ts, wo ein Test sie gegen echte Server fährt.
    for (const endpunkt of ['proxy-image', 'proxy-download']) {
      const handler = ausschnitt(`routes.use('/local-api/${endpunkt}'`)
      expect(handler, endpunkt).toContain('ssrfSafeGet(')
      // Kein von Hand ausgeschriebener Hop mehr in diesen beiden Handlern.
      expect(handler, endpunkt).not.toMatch(/statusCode >= 300/)
      expect(handler, endpunkt).not.toContain('headers.location')
    }
  })
})

/**
 * `src/api/backend.ts` ohne reine Kommentarzeilen — dieselbe Behandlung wie
 * `viteConfig` oben, aus demselben Grund: die Registry ERKLÄRT in einem
 * Kommentar, warum `file_read` dort nicht mehr steht, und ein Grep über den
 * Rohtext läse genau die Erklärung als Verstoss.
 */
const backendTs = readFileSync(resolve(process.cwd(), 'src/api/backend.ts'), 'utf8')
  .split('\n')
  .filter((line) => {
    const t = line.trim()
    return !(t.startsWith('//') || t.startsWith('*') || t.startsWith('/*'))
  })
  .join('\n')

/** Der Rohtext derselben Datei, für die Zusicherungen ÜBER die Kommentare. */
const backendTsRoh = readFileSync(resolve(process.cwd(), 'src/api/backend.ts'), 'utf8')

describe('die beiden alten file-Endpunkte', () => {
  // DER BEFUND: `/local-api/file-read` und `/local-api/file-write` bedienten die
  // älteren Befehle `file_read` / `file_write` und hatten keinen Aufrufer mehr —
  // die gleichnamigen MODELL-WERKZEUGE (builtin-tools.ts) führen über
  // `fs_read` / `fs_write` aus. Übrig blieb eine DRITTE Pfadregel neben den
  // beiden anderen: Wurzel ohne Chat-Slug, `includes('..')` statt des Käfigs,
  // absolute Pfade stillschweigend eingefaltet — und damit eine Abweichung von
  // `resolve_agent_path` auf der Rust-Seite, die niemand benutzte.
  //
  // Diese Zusicherungen halten fest, dass sie WEG BLEIBEN. Wer sie beim
  // nächsten Aufräumen als „fehlt ja" wieder anlegt, wird hier rot.

  it('sind aus dem Dev-Server verschwunden', () => {
    expect(viteConfig).not.toContain("routes.use('/local-api/file-read'")
    expect(viteConfig).not.toContain("routes.use('/local-api/file-write'")
    expect(viteConfig).not.toContain("'/local-api/file-read'")
    expect(viteConfig).not.toContain("'/local-api/file-write'")
  })

  it('stehen auch nicht mehr in der Befehls-Registry', () => {
    // Der Grund, warum die Registry MIT muss und nicht nur der Handler: ein
    // Eintrag ohne Endpunkt macht aus einem sprechenden
    // "Unknown backend command: file_read" einen nackten HTTP 404.
    expect(backendTs).not.toMatch(/\bfile_read:\s*\{/)
    expect(backendTs).not.toMatch(/\bfile_write:\s*\{/)
    expect(backendTs).not.toContain('/local-api/file-read')
    expect(backendTs).not.toContain('/local-api/file-write')
  })

  it('sagen an beiden Stellen, wohin der Weg stattdessen führt', () => {
    // Ohne diesen Hinweis ist ein gelöschter Endpunkt nur eine Lücke, und die
    // nächste Person legt ihn wieder an.
    expect(viteConfigRoh).toContain('ENTFERNT: /local-api/file-read')
    expect(viteConfigRoh).toMatch(/fs-read und[\s\S]{0,40}fs-write/)
    expect(backendTsRoh).toMatch(/file_read \/ file_write: ABSICHTLICH NICHT HIER/)
    expect(backendTsRoh).toMatch(/fs_read \/ fs_write/)
  })

  it('haben in fs_read / fs_write einen Nachfolger, der wirklich da ist', () => {
    // Eine Zusicherung, die nur Abwesenheit prüft, wäre auch grün, wenn der
    // Ersatzweg mitverschwunden wäre.
    expect(backendTs).toMatch(/\bfs_read:\s*\{/)
    expect(backendTs).toMatch(/\bfs_write:\s*\{/)
    expect(viteConfig).toContain("routes.use('/local-api/fs-read'")
    expect(viteConfig).toContain("routes.use('/local-api/fs-write'")
  })
})

describe('die fünf fs-Endpunkte', () => {
  // DER BEFUND: `fs-read`, `fs-write`, `fs-list`, `fs-search` und `fs-info`
  // prüften den Pfad nicht. `{"path":"../../.ssh/id_rsa"}` verliess den
  // Arbeitsordner, und `fs-write` schrieb auf jeden absoluten Pfad. Die Regel
  // selbst steht in src/lib/dev-fs-jail.ts (Port von `resolve_path` in
  // src-tauri/src/commands/filesystem.rs), der Weg dorthin in
  // src/dev/fs-request-path.ts — siehe fs-request-path.test.ts.

  it('bauen den Pfad nicht mehr selbst zusammen', () => {
    // Der Ausdruck, der in allen fünf Handlern stand.
    expect(viteConfig).not.toMatch(/isAbsolute\([A-Za-z]+\)\s*\?/)
    expect(viteConfig).not.toContain("join(os.homedir(), AGENT_WORKSPACE_DIR, filePath)")
    expect(viteConfig).not.toContain("join(os.homedir(), AGENT_WORKSPACE_DIR, dirPath)")
  })

  it('gehen alle fünf durch den Käfig', () => {
    const stellen = viteConfig.match(/resolveFsRequestPath\(body, os\.homedir\(\), devJail\)/g) ?? []
    expect(stellen.length).toBe(5)
    for (const endpunkt of ['fs-read', 'fs-write', 'fs-list', 'fs-search', 'fs-info']) {
      const bis = endpunkt === 'fs-info' ? "routes.use('/local-api/system-info'" : null
      const handler = ausschnitt(`routes.use('/local-api/${endpunkt}'`, bis)
      expect(handler, endpunkt).toContain('resolveFsRequestPath(body, os.homedir(), devJail)')
    }
  })

  it('reichen dem Käfig den Symlink-Auflöser mit', () => {
    // DER BEFUND: der Käfig prüfte rein lexikalisch, also glaubte er dem
    // Pfad-STRING. `ln -s /etc <ws>/out` und dann `{"path":"out/hosts"}` gab am
    // laufenden Dev-Server den Inhalt von /etc/hosts zurück. Der Käfig ist rein
    // (kein node:fs), der Auflöser kommt deshalb von hier — und OHNE IHN fällt
    // er still auf die lexikalische Prüfung zurück, also auf genau den alten
    // Zustand. Die sechste Tür (fs-read-bytes) ruft den Käfig direkt auf.
    expect(viteConfig).toMatch(/const devJail: DevJailOptions = \{/)
    expect(viteConfig).toContain('realPath: (p) => realpathSync(p)')
    expect(viteConfig).toContain('systemDrive: process.env.SystemDrive')
    const bytes = ausschnitt("routes.use('/local-api/fs-write'", null)
    expect(bytes).not.toContain('devResolveWithinJail')
    const leser = ausschnitt("routes.use('/local-api/fs-read-bytes'", null)
    expect(leser).toContain('devResolveWithinJail({')
    expect(leser).toContain('...devJail,')
  })

  it('lösen den Pfad VOR dem try auf, damit ein Ausbruch kein 200 wird', () => {
    // fs-list und fs-search antworten in ihrem catch mit 200 und leerer
    // Liste; läge der Käfig darin, sähe ein Ausbruchsversuch aus wie ein
    // leeres Verzeichnis statt wie ein 403.
    for (const endpunkt of ['fs-read', 'fs-write', 'fs-list', 'fs-search', 'fs-info']) {
      const bis = endpunkt === 'fs-info' ? "routes.use('/local-api/system-info'" : null
      const handler = ausschnitt(`routes.use('/local-api/${endpunkt}'`, bis)
      expect(handler.indexOf('resolveFsRequestPath('), endpunkt).toBeLessThan(handler.indexOf('try {'))
    }
  })

  it('lassen JailEscapeError als 403 heraus', () => {
    // `withJsonBody` fängt, was der Handler wirft, und `failRequest` ist der
    // Weg für die Handler, die selbst fangen.
    expect(viteConfig).toContain("err instanceof JailEscapeError ? 403 : 400")
  })
})