Desktop app for designing parametric 3D models in CadQuery together with the coding agent of your choice
TypeScript 3d-modeling3d-printing3d-printing-toolsagentagentic-aiai-cadcadcadqueryclaude-codecodexelectronfemllmmacdmakeropencodeparametric-designpythonsteptext-to-cad
App: Protokoll der App in logs/soma.log
Kai-Jungsthoefelaae032e1d8e3
diff --git a/app/src/main/about.ts b/app/src/main/about.tsindex 5f28b08..de85eb3 100644--- a/app/src/main/about.ts+++ b/app/src/main/about.ts@@ -6,7 +6,8 @@ import { app } from 'electron';import { exec } from 'dugite';import type { AboutInfo, AgentInfo, ComponentInfo } from '../shared/types';import { SOMA_VERSION } from '../shared/version';-import { pythonExe, userDataDir, userSkillsDir, warmDir } from './paths';+import { logTail } from './log';+import { logsDir, pythonExe, userDataDir, userSkillsDir, warmDir } from './paths';/*** Angaben für „About“ in den Einstellungen (E81): Versionen, Komponenten mit Lizenz, gefundene Agenten, Pfade. Alles wird@@ -102,7 +103,7 @@ async function gitVersion(): Promise<string | null> {} catch { return null; }}-function osName(): string {+export function osName(): string {const rel = os.release();if (process.platform === 'win32') {// Windows 11 meldet sich weiter als 10.0, erst die Build-Nummer ab 22000 unterscheidet@@ -122,6 +123,7 @@ export async function aboutInfo(agents: () => Promise<AgentInfo[]>): Promise<Abopaths: [{ label: 'App data', path: userDataDir() },{ label: 'Your skills', path: userSkillsDir() },+ { label: 'Logs', path: logsDir() },{ label: 'Python', path: python.exe },{ label: 'Program', path: app.getAppPath() },],@@ -141,5 +143,8 @@ export function aboutText(a: AboutInfo): string {...a.paths.map((p) => `${p.label}: ${p.path}`),];if (a.python.error) lines.push(`Python problem: ${a.python.error}`);+ // Das Ende des Protokolls (log.ts): Mit dem Bericht kommt gleich, was zuletzt schiefging+ const tail = logTail(40);+ if (tail) lines.push('', 'Recent log (logs/soma.log):', tail);return lines.join('\n');}diff --git a/app/src/main/agents.ts b/app/src/main/agents.tsindex 61bbd84..dbc4879 100644--- a/app/src/main/agents.ts+++ b/app/src/main/agents.ts@@ -20,3 +20,31 @@ const isOnPath = (command: string, env: NodeJS.ProcessEnv) =>export async function detectAgents(env: NodeJS.ProcessEnv): Promise<AgentInfo[]> {return Promise.all(KNOWN.map(async (a) => ({ ...a, found: await isOnPath(a.command, env) })));}++/** Bekannter Agent zu einer Befehlszeile (erstes Wort, ohne Pfad und .cmd/.exe), sonst undefined. */+export function agentFor(line: string): (typeof KNOWN)[number] | undefined {+ const first = line.trim().split(/\s+/)[0] ?? '';+ const name = first.replace(/^.*[\\/]/, '').replace(/\.(cmd|exe|ps1|bat)$/i, '').toLowerCase();+ return KNOWN.find((a) => a.command === name);+}++/** Je Sitzung nur einmal nach der Version fragen: Ein Agent startet in einer Sitzung oft mehrmals. */+const versionAsked = new Set<string>();++/**+ * Für das Protokoll (log.ts): welcher Agent gestartet wurde, und einmal je Sitzung seine Version. Bei Problemen mit einem+ * Agenten hängt viel an seiner Version. `how`: per Knopf oder im Terminal getippt. Nur Name und Version, nie die+ * Befehlszeile (sie kann Schlüssel oder Text des Nutzers enthalten).+ */+export function logAgentStart(line: string, how: 'button' | 'typed', env: NodeJS.ProcessEnv): void {+ const a = agentFor(line);+ if (!a) return;+ console.log(`[agent] ${a.label} started (${how === 'button' ? 'start button' : 'typed in a terminal'})`);+ if (versionAsked.has(a.id) || process.env.SOMA_TEST === '1') return;+ versionAsked.add(a.id);+ // Unter Windows sind die Agenten meist .cmd-Dateien von npm, die gehen nur über die Shell. Der Befehl ist fest (KNOWN).+ execFile(a.command, ['--version'], { env, windowsHide: true, timeout: 15000, shell: process.platform === 'win32' }, (err, stdout, stderr) => {+ const v = (stdout || stderr || '').trim().split(/\r?\n/)[0]?.slice(0, 200);+ console.log(`[agent] ${a.label} version: ${err && !v ? `unknown (${err.message.split('\n')[0]})` : v || 'unknown'}`);+ });+}diff --git a/app/src/main/build.ts b/app/src/main/build.tsindex 3b07f9c..0a0bfb0 100644--- a/app/src/main/build.ts+++ b/app/src/main/build.ts@@ -4,6 +4,7 @@ import path from 'node:path';import { EventEmitter } from 'node:events';import { affectsBuild } from '../shared/editable';import type { BuildResult, BuildStatus, ParamInfo } from '../shared/types';+import { log } from './log';import { pythonExe, warmDir } from './paths';import { IGNORED_TOP } from './watcher';@@ -116,6 +117,7 @@ export class BuildManager extends EventEmitter {clearTimeout(timeout);this.proc = null;if (this.disposed) return;+ logBuild(result, (Date.now() - startedAt) / 1000, reason);this.takeParams(result);if (result.status === 'ok') this.shown = mapBuildId(this.dir);this.setStatus({ state: result.status === 'ok' ? 'ok' : 'error', result, seconds: (Date.now() - startedAt) / 1000, builtAt: Date.now() });@@ -184,6 +186,7 @@ export class BuildManager extends EventEmitter {let error: string | null;try { error = await install(); } catch (e) { error = e instanceof Error ? e.message : String(e); }this.installing = null;+ if (error) log('ERROR', `[packages] Could not install ${names.join(', ')}: ${error}`);if (this.disposed) return;this.packageError = error;const { queued: _q, ...rest } = this.status;@@ -316,6 +319,21 @@ function emitLine(w: WarmProcess, line: string): void {else w.lines.push(l);}+/** Fehler im Ablauf statt im Code des Modells: Python startet nicht, Zeitlimit, kein Ergebnis. */+const PIPELINE_ERRORS = new Set(['PythonStart', 'Timeout', 'NoResult']);++/**+ * Build ins Protokoll (log.ts). Fehler im Code des Modells sind Alltag beim Modellieren und stehen nur mit Art und erster+ * Zeile drin, Fehler im Ablauf mit der ganzen Meldung (darin das Ende von stderr).+ */+function logBuild(r: BuildResult, seconds: number, reason: string): void {+ const s = `${seconds.toFixed(1)} s, ${reason}`;+ if (r.status === 'ok') { log('INFO', `[build] ok, ${r.parts?.length ?? 0} parts, ${s}`); return; }+ const e = r.error;+ if (e && PIPELINE_ERRORS.has(e.kind)) log('ERROR', `[build] ${e.kind} (${s}): ${e.message}`);+ else log('INFO', `[build] error in the model, ${e?.kind ?? 'unknown'} (${s}): ${(e?.message ?? '').split('\n')[0].slice(0, 300)}`);+}+function errorResult(kind: string, message: string): BuildResult {return { status: 'error', error: { kind, message, file: null, line: null, traceback: '' } };}diff --git a/app/src/main/log.ts b/app/src/main/log.tsnew file mode 100644index 0000000..60785cb--- /dev/null+++ b/app/src/main/log.ts@@ -0,0 +1,102 @@+import fs from 'node:fs';+import os from 'node:os';+import path from 'node:path';+import util from 'node:util';++/**+ * Protokoll der App in den App-Daten (`logs/soma.log`), damit sich Probleme bei Nutzern nachvollziehen lassen. Die+ * installierte App hat keine Konsole: Was über console.* lief, war bisher verloren. initLog() leitet console.log/warn/error+ * zusätzlich in die Datei, die bestehenden Meldungen landen so ohne Umbau darin. Nichts wird hochgeladen, der Nutzer gibt+ * die Datei selbst weiter (sie enthält Pfade, also den Benutzernamen).+ *+ * Rotation beim Start und während des Laufs: über MAX_BYTES wird soma.log zu soma.1.log (bis KEEP alte Dateien).+ * Schreiben ist synchron (wenige Zeilen, und nach einem Absturz soll das Letzte drinstehen). Scheitert es, bleibt nur die+ * Konsole: Das Protokoll darf die App nie stören.+ */++const MAX_BYTES = 2 * 1024 * 1024;+const KEEP = 3;+/** Längere Meldungen (stderr eines Builds, Tracebacks) werden gekürzt, das Ende bleibt (dort steht meist der Grund). */+const MAX_LINE = 4000;++let file: string | null = null;+let size = 0;++export type LogLevel = 'INFO' | 'WARN' | 'ERROR';++export const logFile = (): string | null => file;++function rotate(): void {+ if (!file) return;+ try {+ for (let i = KEEP - 1; i >= 1; i--) {+ const from = file.replace(/\.log$/, `.${i}.log`);+ if (fs.existsSync(from)) fs.renameSync(from, file.replace(/\.log$/, `.${i + 1}.log`));+ }+ if (fs.existsSync(file)) fs.renameSync(file, file.replace(/\.log$/, '.1.log'));+ size = 0;+ } catch { /* Datei gesperrt (zweite Instanz): weiter anhängen */ }+}++function write(level: LogLevel, text: string): void {+ if (!file) return;+ let t = text.replace(/\r\n?/g, '\n').trimEnd();+ if (t.length > MAX_LINE) t = `… ${t.slice(-MAX_LINE)}`;+ // Folgezeilen eingerückt: Ein Eintrag bleibt als Block erkennbar+ const line = `${new Date().toISOString()} ${level.padEnd(5)} ${t.replace(/\n/g, '\n ')}\n`;+ try {+ if (size + line.length > MAX_BYTES) rotate();+ fs.appendFileSync(file, line, 'utf8');+ size += Buffer.byteLength(line);+ } catch { /* Platte voll, Ordner weg: nur Konsole */ }+}++/** Ein Eintrag ins Protokoll, ohne Ausgabe auf der Konsole. */+export function log(level: LogLevel, ...args: unknown[]): void {+ write(level, util.format(...args));+}++/**+ * Protokoll einrichten und console.* anzapfen. Einmal beim Start, sobald die App-Daten feststehen. `header`: Zeilen für+ * den Beginn der Sitzung (Version, System …).+ */+export function initLog(dir: string, header: Record<string, string | null | undefined>): void {+ if (file) return;+ try {+ fs.mkdirSync(dir, { recursive: true });+ file = path.join(dir, 'soma.log');+ try { size = fs.statSync(file).size; } catch { size = 0; }+ if (size > MAX_BYTES) rotate();+ } catch { file = null; return; }++ const orig = { log: console.log, warn: console.warn, error: console.error };+ console.log = (...a: unknown[]) => { orig.log(...a); write('INFO', util.format(...a)); };+ console.warn = (...a: unknown[]) => { orig.warn(...a); write('WARN', util.format(...a)); };+ console.error = (...a: unknown[]) => { orig.error(...a); write('ERROR', util.format(...a)); };++ // Nur mitschreiben: uncaughtExceptionMonitor ändert nichts am Verhalten von Electron (Fehlerdialog)+ process.on('uncaughtExceptionMonitor', (e) => write('ERROR', `[main] Uncaught exception: ${e instanceof Error ? e.stack ?? e.message : String(e)}`));+ process.on('unhandledRejection', (e) => write('ERROR', `[main] Unhandled promise rejection: ${e instanceof Error ? e.stack ?? e.message : String(e)}`));++ write('INFO', `---- SOMA started (pid ${process.pid}) ----\n${Object.entries(header).map(([k, v]) => `${k}: ${v ?? '–'}`).join('\n')}`);+}++/** Systemname für den Kopf, ohne Electron (auch in reinen Node-Tests nutzbar). */+export const osText = (): string => `${os.type()} ${os.release()} (${process.arch})`;++/** Die letzten `n` Zeilen des Protokolls, für „Copy system info“. Leer, wenn es keins gibt. */+export function logTail(n: number): string {+ if (!file) return '';+ try {+ const fd = fs.openSync(file, 'r');+ try {+ const len = fs.fstatSync(fd).size;+ const take = Math.min(len, 64 * 1024);+ const buf = Buffer.alloc(take);+ fs.readSync(fd, buf, 0, take, len - take);+ const lines = buf.toString('utf8').split('\n');+ if (take < len) lines.shift(); // angeschnittene erste Zeile+ return lines.filter((l, i) => l || i < lines.length - 1).slice(-n).join('\n');+ } finally { fs.closeSync(fd); }+ } catch { return ''; }+}diff --git a/app/src/main/main.ts b/app/src/main/main.tsindex 910b9c8..c93da29 100644--- a/app/src/main/main.ts+++ b/app/src/main/main.ts@@ -1,7 +1,7 @@import { app, BrowserWindow, clipboard, dialog, ipcMain, nativeTheme, shell, type WebContents } from 'electron';import fs from 'node:fs';import path from 'node:path';-import { aboutInfo, aboutText } from './about';+import { aboutInfo, aboutText, osName } from './about';import { detectAgents } from './agents';import { bridgeEnv, startBridge, stopBridge } from './bridge';import { stopWarm, warmUp } from './build';@@ -11,7 +11,9 @@ import { backupText, createEntry, entryPath, importInputs, listFiles, renameEntrimport { ProjectController } from './projects';import { terminalEnv } from './terminals';import { readHelp, readHelpImage } from './help';-import { adoptLoginShellPath, appIcon, editBackupsDir, helpDir, libraryBackupsDir, skillDirs, skillsDir, thumbnailsDir, userSkillsDir } from './paths';+import { initLog, log } from './log';+import { adoptLoginShellPath, appIcon, editBackupsDir, helpDir, libraryBackupsDir, logsDir, pythonExe, skillDirs, skillsDir, thumbnailsDir, userDataDir, userSkillsDir } from './paths';+import { SOMA_VERSION } from '../shared/version';import { readSettings, writeSettings } from './settings';import { checkUpdate } from './updates';import { areaDir, clearPreviews, isStorageArea, storageStats } from './storage';@@ -26,6 +28,12 @@ import { createProject, getLastProject, getSkillBases, getSkillDefaults, isProjeif (process.env.SOMA_USER_DATA) app.setPath('userData', process.env.SOMA_USER_DATA);else if (process.platform === 'win32' && process.env.LOCALAPPDATA) app.setPath('userData', path.join(process.env.LOCALAPPDATA, 'soma'));+// Protokoll (log.ts) so früh wie möglich: Auch Fehler beim Start sollen drinstehen+initLog(logsDir(), {+ version: SOMA_VERSION, system: `${osName()} ${process.arch}`, electron: process.versions.electron,+ packaged: app.isPackaged ? 'yes' : 'no (development)', python: pythonExe(), appData: userDataDir(),+});+/*** Linux ohne nutzbaren Grafiktreiber (VM, Remote-Desktop, xvfb): Chromium sperrt WebGL auf dem Software-Renderer llvmpipe,* ohne WebGL gibt es keinen Viewer. Bekommt der Viewer keinen Kontext, meldet das Fenster es (gpu:webglFailed), die App@@ -42,6 +50,22 @@ let controller: ProjectController | null = null;/** Im Testmodus landet Kopiertes hier statt in der echten Zwischenablage des Nutzers. */let testClipboard = '';+/**+ * Anfragen des Renderers mit der Antwort `{ ok: false, error }` ins Protokoll (log.ts), abgebrochene Rückfragen nicht.+ * Sonst sähe nur der Nutzer die Meldung, im Protokoll fehlte sie. Ein Wrapper um ipcMain.handle statt an jedem der vielen+ * Handler. Ausnahmen protokolliert Electron selbst über console.error („Error occurred in handler for …“, mit Stack), die+ * landen so schon im Protokoll.+ */+function logIpcFailures(): void {+ const handle = ipcMain.handle.bind(ipcMain);+ ipcMain.handle = (channel, fn) => handle(channel, async (e, ...args) => {+ const r: unknown = await fn(e, ...args);+ const o = r as { ok?: unknown; error?: unknown; canceled?: unknown } | null;+ if (o && typeof o === 'object' && o.ok === false && o.error && !o.canceled) log('WARN', `[${channel}] ${String(o.error)}`);+ return r;+ });+}+function registerIpc(ctl: ProjectController): void {const dir = () => ctl.need().dir;@@ -422,6 +446,7 @@ function hostDialogs(wc: WebContents): void {// Erst die Verbindung für `soma render` (E58), dann das Fenster: Die Terminals bekommen Adresse und Schlüssel beim Anlegenapp.whenReady().then(async () => {+ logIpcFailures();// Dunkel wie die Oberfläche: unter Windows sonst eine weiße Titelleiste, ebenso die Dialoge zum Öffnen und SpeichernnativeTheme.themeSource = 'dark';adoptLoginShellPath(); // macOS und Linux: PATH wie im Terminal, sonst fehlen die Agenten@@ -436,4 +461,4 @@ app.whenReady().then(async () => {});createWindow();});-app.on('window-all-closed', () => { stopBridge(); stopWarm(); app.quit(); });+app.on('window-all-closed', () => { console.log('[soma] quit'); stopBridge(); stopWarm(); app.quit(); });diff --git a/app/src/main/paths.ts b/app/src/main/paths.tsindex d590925..de8c7bf 100644--- a/app/src/main/paths.ts+++ b/app/src/main/paths.ts@@ -25,6 +25,8 @@ export const skillBackupsDir = (id: string) => path.join(backupsDir(), `${id}-skexport const previewsDir = () => path.join(userDataDir(), 'previews');/** Vorschaubilder für die Startseite (vom Viewer nach dem Laden des Modells, jederzeit neu erzeugbar). */export const thumbnailsDir = () => path.join(userDataDir(), 'thumbnails');+/** Protokoll der App (log.ts), für die Fehlersuche bei Nutzern. */+export const logsDir = () => path.join(userDataDir(), 'logs');/*** Leerer Startordner der vorgewärmten Python-Prozesse (build.ts). Python setzt ihn vorn in den Suchpfad, also darf dort* nichts liegen, was Module überdeckt. Ein Projektordner geht nicht: Windows hielte ihn als aktuelles Verzeichnis fest.diff --git a/app/src/main/projects.ts b/app/src/main/projects.tsindex b09db37..e9bdfeb 100644--- a/app/src/main/projects.ts+++ b/app/src/main/projects.ts@@ -153,6 +153,7 @@ export class ProjectController {if (st.state === 'ok' && !st.stale) void this.cachePreview(session);});setLastProject(id);+ console.log(`[project] opened ${id}`);// Gilt der letzte Build noch (seit seinem Start nichts geändert), zeigt der Viewer ihn gleich, statt neu zu bauen. Sonst// erster Build direkt beim Öffnen, damit der Viewer nicht leer ist (der Nutzer kann Auto-Build danach abschalten).const last = currentBuild(dir);diff --git a/app/src/main/storage.ts b/app/src/main/storage.tsindex 8c28834..552b3ea 100644--- a/app/src/main/storage.ts+++ b/app/src/main/storage.ts@@ -1,7 +1,7 @@import fs from 'node:fs';import path from 'node:path';import type { StorageArea, StorageEntry, StorageStats } from '../shared/types';-import { backupsDir, previewsDir, thumbnailsDir, userDataDir, userSkillsDir, workspacesDir } from './paths';+import { backupsDir, logsDir, previewsDir, thumbnailsDir, userDataDir, userSkillsDir, workspacesDir } from './paths';/*** Speicherplatz in den App-Daten (E81): Größe je Bereich für die Einstellungen. Was dort liegt, legt die App selbst an.@@ -18,9 +18,10 @@ export function areaDir(area: StorageArea): string {case 'previews': return previewsDir();case 'thumbnails': return thumbnailsDir();case 'skills': return userSkillsDir();+ case 'logs': return logsDir();}}-export const isStorageArea = (a: unknown): a is StorageArea => ['appdata', 'workspaces', 'backups', 'previews', 'thumbnails', 'skills'].includes(a as string);+export const isStorageArea = (a: unknown): a is StorageArea => ['appdata', 'workspaces', 'backups', 'previews', 'thumbnails', 'skills', 'logs'].includes(a as string);/*** Größe eines Ordners mit allem darin. Verknüpfungen zählen nicht (sie könnten aus den App-Daten hinaus oder im Kreis@@ -48,7 +49,7 @@ const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;/** Größe der App-Daten je Bereich. „other“: alles Übrige (Caches von Chromium, state.json, settings.json …). */export async function storageStats(): Promise<StorageStats> {const dir = userDataDir();- const ids: StorageArea[] = ['workspaces', 'backups', 'previews', 'thumbnails', 'skills'];+ const ids: StorageArea[] = ['workspaces', 'backups', 'previews', 'thumbnails', 'skills', 'logs'];const [total, ...sizes] = await Promise.all([folderSize(dir), ...ids.map((a) => folderSize(areaDir(a)))]);let models = 0;try { models = fs.readdirSync(workspacesDir()).filter((n) => UUID.test(n)).length; } catch { /* noch keins */ }diff --git a/app/src/main/terminals.ts b/app/src/main/terminals.tsindex 02e3ac4..f772268 100644--- a/app/src/main/terminals.ts+++ b/app/src/main/terminals.ts@@ -1,6 +1,7 @@import path from 'node:path';import type { WebContents } from 'electron';import * as pty from 'node-pty';+import { logAgentStart } from './agents';import { bridgeEnv } from './bridge';import { envPaths } from './packages';import { gitCmdDir, pythonBinDirs } from './paths';@@ -34,6 +35,8 @@ let nextId = 1;/** Verwaltet die Terminals eines Projekts. Jedes ist eine normale Shell im Projektordner (E19). */export class TerminalManager {private terms = new Map<number, pty.IPty>();+ /** Getippte Zeile je Terminal, nur um einen von Hand gestarteten Agenten zu protokollieren (track). null: unzuverlässig. */+ private typed = new Map<number, string | null>();constructor(private readonly wc: WebContents, private readonly dir: string) {}@@ -51,9 +54,11 @@ export class TerminalManager {}const id = nextId++;this.terms.set(id, p);+ if (opts.command) logAgentStart(opts.command, 'button', terminalEnv(this.dir));p.onData((d) => { if (!this.wc.isDestroyed()) this.wc.send('term:data', id, d); });p.onExit(({ exitCode }) => {this.terms.delete(id);+ this.typed.delete(id);if (!this.wc.isDestroyed()) this.wc.send('term:exit', id, exitCode);});// Ein Startbefehl (z. B. der Agent) wird sichtbar in die Shell getippt. Endet er, bleibt die Shell offen.@@ -61,11 +66,39 @@ export class TerminalManager {return id;}- write(id: number, data: string): void { this.terms.get(id)?.write(data); }+ write(id: number, data: string): void {+ const p = this.terms.get(id);+ if (!p) return;+ p.write(data);+ this.track(id, data);+ }++ /**+ * Erkennt, wenn der Nutzer einen bekannten Agenten selbst in die Shell tippt, für das Protokoll. Nur grob: Pfeiltasten,+ * Verlauf, Tab-Ergänzung oder Einfügen machen die Zeile unzuverlässig, sie zählt dann nicht. Als Agentenstart gilt nur+ * der Befehl allein oder mit Optionen (`claude`, `codex --resume`), damit Text an einen laufenden Agenten, der zufällig+ * mit seinem Namen beginnt, nicht mitzählt. Getippter Text selbst kommt nie ins Protokoll.+ */+ private track(id: number, data: string): void {+ let line = this.typed.get(id) ?? '';+ let ok = this.typed.get(id) !== null;+ for (const ch of data) {+ if (ch === '\r' || ch === '\n') {+ const t = line.trim();+ if (ok && t && /^\S+(\s+-.*)?$/.test(t)) logAgentStart(t, 'typed', terminalEnv(this.dir));+ line = ''; ok = true;+ } else if (ch === '\x7f' || ch === '\b') line = line.slice(0, -1);+ else if (ch === '\x03') { line = ''; ok = true; }+ else if (ch === '\x1b' || ch === '\t') ok = false;+ else if (ch >= ' ' && line.length < 200) line += ch;+ }+ this.typed.set(id, ok ? line : null);+ }+resize(id: number, cols: number, rows: number): void {if (cols > 0 && rows > 0) { try { this.terms.get(id)?.resize(cols, rows); } catch { /* Terminal schon beendet */ } }}- kill(id: number): void { try { this.terms.get(id)?.kill(); } catch { /* schon beendet */ } this.terms.delete(id); }+ kill(id: number): void { try { this.terms.get(id)?.kill(); } catch { /* schon beendet */ } this.terms.delete(id); this.typed.delete(id); }killAll(): void { for (const id of [...this.terms.keys()]) this.kill(id); }/**diff --git a/app/src/shared/types.ts b/app/src/shared/types.tsindex d604df6..2f0dcc5 100644--- a/app/src/shared/types.ts+++ b/app/src/shared/types.ts@@ -240,7 +240,7 @@ export interface LibraryResult {library: LibraryState;}/** Bereich der App-Daten in den Einstellungen (E81). Der Renderer nennt nur die Kennung, den Ordner kennt der Hauptprozess. */-export type StorageArea = 'appdata' | 'workspaces' | 'backups' | 'previews' | 'thumbnails' | 'skills';+export type StorageArea = 'appdata' | 'workspaces' | 'backups' | 'previews' | 'thumbnails' | 'skills' | 'logs';/** Größe eines Bereichs. `other`: alles Übrige in den App-Daten. `models`: Zahl der Arbeitsordner. */export interface StorageEntry { id: StorageArea | 'other'; path: string | null; bytes: number; files: number; models?: number }export interface StorageStats { dir: string; total: number; areas: StorageEntry[] }