Skip to content

armgit / SOMA

Public Imported from GitHub
0

Desktop app for designing parametric 3D models in CadQuery together with the coding agent of your choice

App: Protokoll der App in logs/soma.log

Kai-Jungsthoefelaae032e1d8e3
diff --git a/app/src/main/about.ts b/app/src/main/about.ts
index 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<Abo
paths: [
{ 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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
index 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, renameEntr
import { 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, isProje
if (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 Anlegen
app.whenReady().then(async () => {
+ logIpcFailures();
// Dunkel wie die Oberfläche: unter Windows sonst eine weiße Titelleiste, ebenso die Dialoge zum Öffnen und Speichern
nativeTheme.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.ts
index 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}-sk
export 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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[] }