@funpixel/tools 0.0.0-stage → 0.1.1

package/dist/unity/editor.js

@@ -0,0 +1,471 @@
+import { readdir, readFile, stat, copyFile, mkdir, writeFile } from 'node:fs/promises';
+import { dirname, isAbsolute, join, relative } from 'node:path';
+import { isBatch, isUnityEditor, projectOfProc, unityOn } from "../machine/procs.js";
+import { acquire, newJobId, projectNames, queueHolds } from "./queue.js";
+import { findUnity, logErrors, NOT_RUN, unityRun } from "./run.js";
+import { BRIDGE_TOOLS, BRIDGE_URL, BRIDGE_VERSION, RESOURCE_EDITOR_STATE, RESOURCE_PROJECT_INFO, STDIO_BOOT, dropOpened, readManifest, readMark, readOpened, writeMark, writeOpened, } from "./bridge.js";
+import { payload, refusal } from "./mcp-stdio.js";
+export const DONE = 0;
+export const FAILED = 1;
+export const NOT_OBSERVED = 2;
+export const REFUSED = 3;
+export const ACTIONS = ['console', 'compile', 'play', 'stop', 'shot', 'menu', 'call', 'hierarchy', 'add', 'save', 'open', 'close'];
+export const NEEDS_EDITOR = new Set(['play', 'stop', 'shot', 'hierarchy', 'add', 'save']);
+const same = (a, b) => a.replace(/\/+$/, '').toLowerCase() === b.replace(/\/+$/, '').toLowerCase();
+const onProject = (project, p) => !!p && projectNames(project).some((n) => same(n, p));
+export function ownsLive(rec, procs) {
+    const p = procs.find((x) => x.pid === rec.pid);
+    return !!p && isUnityEditor(p.args) && onProject(rec.project, projectOfProc(p));
+}
+export async function situation(project, d) {
+    const procs = await d.run.procs();
+    const on = unityOn(procs, projectNames(project));
+    const m = await readManifest(project);
+    const rec = await readOpened(d.editors, project);
+    return {
+        project,
+        manifestError: 'error' in m ? m.error : null,
+        installed: 'error' in m ? null : m.entry,
+        editors: on.filter((p) => !isBatch(p.args)),
+        batch: on.filter((p) => isBatch(p.args)),
+        bridge: await d.reach(project),
+        opened: rec && ownsLive(rec, procs) ? rec : null,
+        queue: await queueHolds(d.run.root, project, procs, d.run.now(), d.queue.staleMs),
+    };
+}
+const pids = (ps) => ps.map((p) => p.pid).join(', ');
+export function decide(action, s, o) {
+    if (action === 'open' || action === 'close')
+        return { kind: 'refuse', why: 'open and close are not routed' };
+    if (s.editors.length) {
+        const who = `the Unity Editor (pid ${pids(s.editors)}) that has ${s.project} open`;
+        if (s.bridge.reachable)
+            return { kind: 'bridge' };
+        if (s.installed) {
+            return { kind: 'refuse', why: `${who} has MCP for Unity in its manifest, but its bridge does not answer over stdio: ${s.bridge.why}. It may still be importing or compiling, be behind a dialog, or run the HTTP transport; in that Editor, Window > MCP for Unity, choose stdio and start the session. funtools never relaunches or quits an Editor it did not open` };
+        }
+        return { kind: 'refuse', why: `${who} has no MCP for Unity, and batch mode cannot open a project an Editor holds. Add the bridge in that Editor (Package Manager > Add package from git URL: ${BRIDGE_URL}), or after it is closed with funtools unity bridge install. funtools never quits it` };
+    }
+    if (o.open) {
+        if (!s.installed)
+            return { kind: 'refuse', why: `--open opens the Editor with the bridge, and ${s.project} does not have it: funtools unity bridge install --project ${s.project} first` };
+        return { kind: 'open', then: 'bridge' };
+    }
+    const open = `add --open to open an Editor on it with the bridge (funtools unity editor close ends that one)${s.installed ? '' : `, after funtools unity bridge install --project ${s.project}`}`;
+    if (NEEDS_EDITOR.has(action))
+        return { kind: 'needs_editor', why: `${action} needs an open Editor, and none has ${s.project} open — ${open}` };
+    if (action === 'console')
+        return { kind: 'log', why: `no Editor has ${s.project} open, so this is the newest funtools log of the project, not a live console` };
+    return { kind: 'batch', why: `no Editor has ${s.project} open: fell back to a queued batch run (30–90 s; ${open})` };
+}
+const RECORDED = new Set(BRIDGE_TOOLS);
+export async function route(c, status, project) {
+    const call = async (tool, args, timeoutMs) => {
+        if (!RECORDED.has(tool))
+            throw new Error(`${tool} is not a tool of MCP for Unity ${BRIDGE_VERSION}`);
+        return c.call(tool, args, timeoutMs);
+    };
+    if (!c.tools.includes('set_active_instance'))
+        throw new Error(`the MCP server lists no set_active_instance (it lists ${c.tools.slice(0, 12).join(', ') || 'nothing'}): not the pinned MCP for Unity server, so nothing was sent`);
+    const r = await call('set_active_instance', { instance: status.id });
+    const no = refusal(r);
+    if (no)
+        throw new Error(`MCP for Unity would not route to ${status.id}: ${no}. Nothing was sent to any Editor`);
+    const echoed = payload(r).data?.instance;
+    if (echoed !== status.id)
+        throw new Error(`MCP for Unity routed to ${echoed ?? 'an unnamed Editor'}, not ${status.id}. Nothing was sent`);
+    const info = (await c.read(RESOURCE_PROJECT_INFO));
+    const root = typeof info === 'object' ? info.data?.projectRoot ?? info.projectRoot : undefined;
+    if (!onProject(project, root ?? null))
+        throw new Error(`the routed Editor's project is ${root ?? '(not said)'}, not ${project}. Nothing was sent`);
+    return {
+        call,
+        read: async (uri) => { const v = await c.read(uri); return (v && typeof v === 'object' ? v : { text: v }); },
+        tools: c.tools,
+    };
+}
+async function consoleFrom(b, cursor, types) {
+    const entries = [];
+    let at = cursor;
+    for (let pages = 0; pages < 20; pages++) {
+        const r = await b.call('read_console', { action: 'get', types, format: 'json', include_stacktrace: false, page_size: 500, cursor: at });
+        const no = refusal(r);
+        if (no)
+            throw new Error(`read_console: ${no}`);
+        const data = (payload(r).data ?? {});
+        const items = data.items ?? [];
+        entries.push(...items);
+        at += items.length;
+        if (!data.truncated || !items.length)
+            break;
+    }
+    return { entries, end: at };
+}
+const entryLine = (e) => `${e.message?.split('\n')[0] ?? ''}${e.file ? ` (${e.file}${e.line ? `:${e.line}` : ''})` : ''}`;
+const isError = (e) => /error|exception|assert/i.test(e.type ?? '');
+const isWarning = (e) => /warning/i.test(e.type ?? '');
+export async function bridgeConsole(b, project, d, o) {
+    const items = [];
+    let from = 0;
+    if (o.since === 'last')
+        from = (await readMark(d.editors, project)) ?? 0;
+    else if (typeof o.since === 'number')
+        from = o.since;
+    let got = await consoleFrom(b, from, ['error', 'warning', 'log']);
+    if (from > 0 && !got.entries.length) {
+        const all = await consoleFrom(b, 0, ['error', 'warning', 'log']);
+        if (all.end < from) {
+            items.push({ s: 'note', text: `the console has ${all.end} entries now, fewer than mark ${from}: it was cleared since, so this is all of it` });
+            got = all;
+        }
+    }
+    await writeMark(d.editors, project, got.end);
+    const shown = typeof o.since === 'undefined' ? got.entries.slice(-o.count) : got.entries.slice(0, o.count);
+    const errors = got.entries.filter(isError).length;
+    const warnings = got.entries.filter(isWarning).length;
+    const lines = shown.map((e) => `${(e.type ?? 'Log').padEnd(9)} ${entryLine(e)}`);
+    items.push({ s: errors ? 'warn' : 'pass', text: `${got.entries.length} entr${got.entries.length === 1 ? 'y' : 'ies'}${o.since !== undefined ? ` since mark ${from}` : ''}: ${errors} error(s), ${warnings} warning(s)`, detail: `next: --since ${got.end} (or --since last)` });
+    if (shown.length < got.entries.length)
+        items.push({ s: 'note', text: `showing ${shown.length} (--count ${o.count})` });
+    return { code: DONE, items, lines, data: { from, mark: got.end, errors, warnings, entries: shown } };
+}
+const CS_ERROR = /error CS\d{4}/;
+export async function bridgeCompile(b) {
+    const items = [];
+    const r = await b.call('refresh_unity', { mode: 'force', scope: 'scripts', compile: 'request', wait_for_ready: true }, 240_000);
+    const no = refusal(r);
+    if (no)
+        items.push({ s: 'note', text: `refresh_unity: ${no}` });
+    const state = (await b.read(RESOURCE_EDITOR_STATE));
+    const compiling = state.data?.compilation?.is_compiling === true;
+    const { entries } = await consoleFrom(b, 0, ['error']);
+    const errors = [...new Set(entries.filter((e) => CS_ERROR.test(e.message ?? '')).map(entryLine))];
+    if (compiling) {
+        items.push({ s: 'not_observed', text: 'still compiling after the refresh', detail: (state.data?.advice?.blocking_reasons ?? []).join(', ') || 'ask again in a moment' });
+        return { code: NOT_OBSERVED, items, data: { compiling, errors } };
+    }
+    if (errors.length) {
+        items.push({ s: 'fail', text: `${errors.length} compile error(s)` });
+        return { code: FAILED, items, lines: errors.slice(0, 40), data: { compiling, errors } };
+    }
+    items.push({ s: 'pass', text: 'scripts compiled, no compile errors in the console' });
+    return { code: DONE, items, data: { compiling, errors } };
+}
+async function playState(b) {
+    try {
+        const s = (await b.read(RESOURCE_EDITOR_STATE));
+        return s.data?.editor?.play_mode?.is_playing ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function bridgePlay(b, want, d) {
+    const r = await b.call('manage_editor', { action: want ? 'play' : 'stop' }, 60_000);
+    const no = refusal(r);
+    if (no)
+        return { code: FAILED, items: [{ s: 'fail', text: `manage_editor ${want ? 'play' : 'stop'}: ${no}` }] };
+    for (let i = 0; i < 30; i++) {
+        if ((await playState(b)) === want)
+            return { code: DONE, items: [{ s: 'pass', text: want ? 'in Play mode' : 'out of Play mode' }], data: { playing: want } };
+        await d.run.sleep(1000);
+    }
+    return { code: NOT_OBSERVED, items: [{ s: 'not_observed', text: `asked to ${want ? 'play' : 'stop'}; the Editor did not report ${want ? 'playing' : 'stopped'} within 30 s` }] };
+}
+export function pngSize(buf) {
+    if (buf.length < 24 || buf.readUInt32BE(0) !== 0x89504e47)
+        return null;
+    return { width: buf.readUInt32BE(16), height: buf.readUInt32BE(20) };
+}
+export async function bridgeShot(b, project, o) {
+    const r = await b.call('manage_camera', {
+        action: 'screenshot', include_image: true, max_resolution: 1280,
+        capture_source: o.view === 'scene' ? 'scene_view' : 'game_view',
+        output_folder: 'Temp/funtools-shots',
+    }, 120_000);
+    const no = refusal(r);
+    if (no)
+        return { code: FAILED, items: [{ s: 'fail', text: `manage_camera screenshot: ${no}` }] };
+    await mkdir(dirname(o.out), { recursive: true });
+    const img = r.content?.find((c) => c.type === 'image' && c.data);
+    const data = (payload(r).data ?? {});
+    let bytes = null;
+    if (img?.data)
+        bytes = Buffer.from(img.data, 'base64');
+    else if (data.imageBase64)
+        bytes = Buffer.from(data.imageBase64, 'base64');
+    if (bytes)
+        await writeFile(o.out, bytes);
+    else {
+        const p = data.fullPath ?? data.path ?? data.screenshots?.[0]?.path;
+        if (!p)
+            return { code: FAILED, items: [{ s: 'fail', text: 'the screenshot came back with no picture and no path' }], data: payload(r) };
+        await copyFile(isAbsolute(p) ? p : join(project, p), o.out);
+        bytes = await readFile(o.out);
+    }
+    const size = pngSize(bytes);
+    return { code: DONE, items: [{ s: 'pass', text: `${o.view} view → ${o.out}`, detail: size ? `${size.width}×${size.height}` : `${bytes.length} bytes` }], data: { out: o.out, ...size } };
+}
+export async function bridgeMenu(b, menu) {
+    const r = await b.call('execute_menu_item', { menu_path: menu }, 300_000);
+    const no = refusal(r);
+    if (no)
+        return { code: FAILED, items: [{ s: 'fail', text: `${menu}: ${no}` }] };
+    const p = payload(r);
+    return { code: DONE, items: [{ s: 'pass', text: `ran ${menu}`, detail: String(p.message ?? '') || undefined }], data: p };
+}
+export const METHOD = /^[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)+$/;
+export async function bridgeCall(b, method) {
+    const g = await b.call('manage_tools', { action: 'activate', group: 'scripting_ext' });
+    const gp = payload(g);
+    if (refusal(g) || gp.error)
+        return { code: FAILED, items: [{ s: 'fail', text: `could not turn on execute_code: ${refusal(g) ?? gp.error}` }] };
+    const r = await b.call('execute_code', { action: 'execute', code: `${method}();`, safety_checks: true }, 300_000);
+    const no = refusal(r);
+    if (no)
+        return { code: FAILED, items: [{ s: 'fail', text: `${method}: ${no}` }] };
+    const p = payload(r);
+    return { code: DONE, items: [{ s: 'pass', text: `called ${method}`, detail: String(p.message ?? '') || undefined }], data: p };
+}
+export async function bridgeHierarchy(b, o) {
+    const lines = [];
+    const tree = [];
+    let total = 0;
+    const level = async (parent, depth) => {
+        const args = { action: 'get_hierarchy', page_size: 200, include_transform: false };
+        if (parent !== null)
+            args.parent = parent;
+        const r = await b.call('manage_scene', args);
+        const no = refusal(r);
+        if (no)
+            return no;
+        const data = (payload(r).data ?? {});
+        for (const n of data.items ?? []) {
+            if (total >= o.max)
+                return null;
+            total++;
+            tree.push({ ...n, depth });
+            const comps = (n.componentTypes ?? []).filter((c) => c !== 'Transform');
+            lines.push(`${'  '.repeat(depth)}${n.name}${n.activeSelf === false ? ' (off)' : ''}${comps.length ? `  [${comps.join(', ')}]` : ''}${n.childCount && depth + 1 >= o.depth ? `  +${n.childCount} child(ren)` : ''}`);
+            if (n.childCount && depth + 1 < o.depth && n.instanceID !== undefined) {
+                const no2 = await level(n.instanceID, depth + 1);
+                if (no2)
+                    return no2;
+            }
+        }
+        if (data.truncated)
+            lines.push(`${'  '.repeat(depth)}… ${(data.total ?? 0) - (data.items?.length ?? 0)} more`);
+        return null;
+    };
+    const no = await level(null, 0);
+    if (no)
+        return { code: FAILED, items: [{ s: 'fail', text: `manage_scene get_hierarchy: ${no}` }] };
+    return { code: DONE, items: [{ s: 'pass', text: `${total} object(s) read${total >= o.max ? ` (stopped at ${o.max})` : ''}, ${o.depth} level(s) deep` }], lines, data: tree };
+}
+export const PRIMITIVES = ['cube', 'sphere', 'capsule', 'cylinder', 'plane', 'quad'];
+export async function bridgeAdd(b, o) {
+    const shape = o.shape.toLowerCase();
+    const type = shape[0].toUpperCase() + shape.slice(1);
+    const r = await b.call('manage_gameobject', { action: 'create', primitive_type: type, name: o.name ?? type, position: o.at });
+    const no = refusal(r);
+    if (no)
+        return { code: FAILED, items: [{ s: 'fail', text: `manage_gameobject create: ${no}` }] };
+    return { code: DONE, items: [{ s: 'pass', text: `added ${o.name ?? type} (${type}) at ${o.at.join(', ')}`, detail: 'unsaved: funtools unity editor save' }], data: payload(r) };
+}
+export async function bridgeSave(b) {
+    const r = await b.call('manage_scene', { action: 'save' });
+    const no = refusal(r);
+    if (no)
+        return { code: FAILED, items: [{ s: 'fail', text: `manage_scene save: ${no}` }] };
+    const p = payload(r);
+    return { code: DONE, items: [{ s: 'pass', text: 'saved the open scene', detail: String(p.message ?? '') || undefined }], data: p };
+}
+const SKIP_DIRS = new Set(['Library', 'Temp', 'Logs', 'obj', 'Build', 'Builds', 'UserSettings', 'node_modules', '.git']);
+async function csFiles(dir, out, cap = 20_000) {
+    let ents;
+    try {
+        ents = await readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const e of ents) {
+        if (out.length >= cap)
+            return;
+        if (e.isDirectory()) {
+            if (!SKIP_DIRS.has(e.name) && !e.name.startsWith('.'))
+                await csFiles(join(dir, e.name), out, cap);
+        }
+        else if (e.name.endsWith('.cs'))
+            out.push(join(dir, e.name));
+    }
+}
+export async function resolveMenuItem(project, menu) {
+    const files = [];
+    await csFiles(join(project, 'Assets'), files);
+    await csFiles(join(project, 'Packages'), files);
+    const esc = menu.replace(/[.*+?^${}()|[\]\\]/g, '\\$&').replace(/"/g, '\\\\?"');
+    const attr = new RegExp(`\\[\\s*(?:UnityEditor\\.)?MenuItem\\s*\\(\\s*"${esc}(?:\\s+[%#&_][^"]*)?"`);
+    for (const f of files) {
+        let text;
+        try {
+            text = await readFile(f, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        const m = attr.exec(text);
+        if (!m)
+            continue;
+        const after = text.slice(m.index);
+        const fn = /\bstatic\s+(?:async\s+)?[\w<>\[\],.\s]+?\s+(\w+)\s*\(\s*\)/.exec(after);
+        if (!fn)
+            continue;
+        const before = text.slice(0, m.index);
+        const cls = [...before.matchAll(/\bclass\s+(\w+)/g)].at(-1)?.[1];
+        const ns = [...before.matchAll(/\bnamespace\s+([\w.]+)/g)].at(-1)?.[1];
+        if (!cls)
+            continue;
+        return { method: [ns, cls, fn[1]].filter(Boolean).join('.'), file: relative(project, f) };
+    }
+    return null;
+}
+export function batchOutcome(r, what, csOnly = false) {
+    const items = [];
+    if (r.code === NOT_RUN)
+        return { code: REFUSED, items: [{ s: 'fail', text: r.message ?? 'the batch run did not start' }], data: r };
+    const errors = (r.errors ?? []).filter((e) => !csOnly || CS_ERROR.test(e));
+    const cs = (r.errors ?? []).filter((e) => CS_ERROR.test(e));
+    if (r.code === 0 && !cs.length)
+        items.push({ s: 'pass', text: `${what}: Unity exit 0`, detail: r.log ?? undefined });
+    else
+        items.push({ s: 'fail', text: `${what}: Unity exit ${r.code}${cs.length ? `, ${cs.length} compile error(s)` : ''}`, detail: r.log ?? undefined });
+    return { code: r.code === 0 && !cs.length ? DONE : FAILED, items, lines: errors.slice(0, 40), data: { exit: r.code, log: r.log, errors } };
+}
+export async function batchRun(project, unityArgs, d, o) {
+    return unityRun({ unityArgs, project, unity: o.unity, cwd: o.cwd, queue: d.queue }, d.run);
+}
+export async function logConsole(project, count) {
+    const dir = join(project, 'Logs');
+    let names = [];
+    try {
+        names = (await readdir(dir)).filter((n) => /^funtools-.*\.log$/.test(n));
+    }
+    catch { }
+    let newest = null;
+    for (const n of names) {
+        try {
+            const s = await stat(join(dir, n));
+            if (!newest || s.mtimeMs > newest.mtime)
+                newest = { file: join(dir, n), mtime: s.mtimeMs };
+        }
+        catch { }
+    }
+    if (!newest)
+        return { code: NOT_OBSERVED, items: [{ s: 'not_observed', text: `no funtools log in ${dir} yet: nothing has run here through funtools`, detail: 'funtools unity editor compile runs one' }] };
+    const text = await readFile(newest.file, 'utf8');
+    const errors = logErrors(text, 400);
+    const warnings = text.split('\n').filter((l) => /warning CS\d{4}|\bwarning\b/i.test(l) && !/^\s*at /.test(l)).length;
+    return {
+        code: DONE,
+        items: [{ s: errors.length ? 'warn' : 'pass', text: `${errors.length} error line(s), ${warnings} warning line(s) in ${relative(project, newest.file)}`, detail: `written ${new Date(newest.mtime).toISOString()}` }],
+        lines: errors.slice(-count),
+        data: { log: newest.file, written: new Date(newest.mtime).toISOString(), errors: errors.slice(-count), warnings },
+    };
+}
+export async function openEditor(s, d, o) {
+    const project = s.project;
+    if (s.editors.length)
+        return { code: DONE, rec: s.opened ?? undefined, items: [{ s: 'note', text: `an Editor (pid ${pids(s.editors)}) already has ${project} open${s.opened ? ', the one funtools opened' : ''}` }] };
+    if (!s.installed)
+        return { code: REFUSED, items: [{ s: 'fail', text: `${project} has no MCP for Unity: funtools unity bridge install --project ${project} first` }] };
+    const found = findUnity(project, o.unity, d.run.env);
+    if ('error' in found)
+        return { code: REFUSED, items: [{ s: 'fail', text: found.error }] };
+    const log = join(project, 'Logs', `funtools-editor-${o.stamp}.log`);
+    const rec = {
+        id: newJobId(), project, pid: d.run.self, session: d.run.session, cwd: o.cwd,
+        command: 'unity editor --open (an interactive Editor with the bridge)', since: new Date(d.run.now()).toISOString(), log,
+    };
+    const got = await acquire(rec, d.queue, d.run);
+    if (!got.ok)
+        return { code: REFUSED, items: [{ s: 'fail', text: got.message }] };
+    let opened;
+    try {
+        await mkdir(dirname(log), { recursive: true });
+        const env = { ...d.run.env, UNITY_MCP_DISABLE_TELEMETRY: 'true' };
+        const child = d.spawnEditor(found.bin, ['-projectPath', project, '-logFile', log, '-executeMethod', STDIO_BOOT], env);
+        if (!(child.pid > 0))
+            return { code: REFUSED, items: [{ s: 'fail', text: `could not start ${found.bin}` }] };
+        opened = { pid: child.pid, project, bin: found.bin, log, session: d.run.session, opened_at: new Date(d.run.now()).toISOString() };
+        await writeOpened(d.editors, opened);
+    }
+    finally {
+        await got.held.release();
+    }
+    d.run.log(`opened the Editor on ${project} (pid ${opened.pid}, log ${log}); waiting for its bridge (up to ${Math.round(o.waitMs / 1000)} s; a first open imports the project)`);
+    const start = d.run.now();
+    let said = start;
+    for (;;) {
+        const r = await d.reach(project);
+        if (r.reachable)
+            return { code: DONE, rec: opened, items: [{ s: 'pass', text: `opened the Editor on ${project} (pid ${opened.pid}); its bridge ${r.why}`, detail: `funtools unity editor close --project ${project} ends it` }] };
+        const procs = await d.run.procs();
+        if (!ownsLive(opened, procs)) {
+            let tail = [];
+            try {
+                tail = logErrors(await readFile(log, 'utf8'), 12);
+            }
+            catch { }
+            await dropOpened(d.editors, project);
+            return { code: FAILED, items: [{ s: 'fail', text: `the Editor (pid ${opened.pid}) ended before its bridge answered`, detail: `log ${log}${tail.length ? `: ${tail.join(' | ')}` : ''}` }] };
+        }
+        if (d.run.now() - start >= o.waitMs) {
+            return { code: NOT_OBSERVED, rec: opened, items: [{ s: 'not_observed', text: `the Editor (pid ${opened.pid}) is up, and its bridge did not answer within ${Math.round(o.waitMs / 1000)} s: ${r.why}`, detail: `a licence or sign-in prompt, a Safe Mode dialog or a long import holds it; read ${log}. It stays open; funtools unity editor close ends it` }] };
+        }
+        if (d.run.now() - said >= 30_000) {
+            d.run.log(`still waiting for the bridge on ${project}: ${r.why}`);
+            said = d.run.now();
+        }
+        await d.run.sleep(2000);
+    }
+}
+export async function closeEditor(project, d, o) {
+    const rec = await readOpened(d.editors, project);
+    let procs = await d.run.procs();
+    const others = unityOn(procs, projectNames(project)).filter((p) => p.pid !== rec?.pid && !isBatch(p.args));
+    const leftAlone = others.map((p) => ({ s: 'skip', text: `Editor pid ${p.pid} on ${project} was not opened by funtools: left alone` }));
+    if (!rec) {
+        if (others.length)
+            return { code: REFUSED, items: [{ s: 'fail', text: `funtools opened no Editor on ${project}, and closes only the ones it opened` }, ...leftAlone] };
+        return { code: DONE, items: [{ s: 'note', text: `no Editor is open on ${project}; nothing to close` }] };
+    }
+    if (!ownsLive(rec, procs)) {
+        await dropOpened(d.editors, project);
+        return { code: DONE, items: [{ s: 'note', text: `the Editor funtools opened (pid ${rec.pid}) has already ended`, detail: 'its record is cleared' }, ...leftAlone] };
+    }
+    d.signal(rec.pid, 'SIGTERM');
+    const gone = async (ms) => {
+        const until = d.run.now() + ms;
+        for (;;) {
+            procs = await d.run.procs();
+            if (!ownsLive(rec, procs))
+                return true;
+            if (d.run.now() >= until)
+                return false;
+            await d.run.sleep(1000);
+        }
+    };
+    if (await gone(o.waitMs)) {
+        await dropOpened(d.editors, project);
+        return { code: DONE, items: [{ s: 'pass', text: `closed the Editor funtools opened on ${project} (pid ${rec.pid})` }, ...leftAlone] };
+    }
+    if (!o.force)
+        return { code: FAILED, items: [{ s: 'warn', text: `asked the Editor (pid ${rec.pid}) to quit; it is still up after ${Math.round(o.waitMs / 1000)} s`, detail: 'a dialog may hold it; --force ends that pid' }, ...leftAlone] };
+    d.signal(rec.pid, 'SIGKILL');
+    if (await gone(10_000)) {
+        await dropOpened(d.editors, project);
+        return { code: DONE, items: [{ s: 'pass', text: `ended the Editor funtools opened (pid ${rec.pid}) with --force` }, ...leftAlone] };
+    }
+    return { code: FAILED, items: [{ s: 'fail', text: `pid ${rec.pid} is still running after SIGKILL` }, ...leftAlone] };
+}

package/dist/unity/gc.js

@@ -0,0 +1,140 @@
+import { execFile } from 'node:child_process';
+import { lstat, readdir, rm } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { unityOn } from "../machine/procs.js";
+import { projectNames, queueHolds } from "./queue.js";
+import { isUnityProject } from "./run.js";
+export const GC_FOLDERS = ['Library', 'Builds', 'Temp', 'Logs'];
+export const GC_DAYS = 14;
+export const GC_DEPTH = 4;
+const SKIP_DIRS = new Set(['node_modules', 'Library', 'Builds', 'Temp', 'Logs', 'Packages', 'Assets', 'obj', 'DerivedData', 'Pods']);
+export async function findProjects(roots, depth = GC_DEPTH) {
+    const out = [];
+    const walk = async (dir, left) => {
+        if (isUnityProject(dir)) {
+            out.push(dir);
+            return;
+        }
+        if (left <= 0)
+            return;
+        let entries;
+        try {
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries)
+            if (e.isDirectory() && !e.name.startsWith('.') && !SKIP_DIRS.has(e.name))
+                await walk(join(dir, e.name), left - 1);
+    };
+    for (const r of roots)
+        await walk(resolve(r), depth);
+    return [...new Set(out)].sort();
+}
+export async function newestMtime(dir, after) {
+    let newest = 0;
+    const walk = async (d) => {
+        let s;
+        try {
+            s = await lstat(d);
+        }
+        catch {
+            return false;
+        }
+        newest = Math.max(newest, s.mtimeMs);
+        if (newest > after)
+            return true;
+        if (!s.isDirectory())
+            return false;
+        let names;
+        try {
+            names = await readdir(d);
+        }
+        catch {
+            return false;
+        }
+        for (const n of names)
+            if (await walk(join(d, n)))
+                return true;
+        return false;
+    };
+    await walk(dir);
+    return newest;
+}
+export const du = (dir) => new Promise((ok) => {
+    execFile('du', ['-sk', dir], { timeout: 300_000, maxBuffer: 4 * 1024 * 1024 }, (err, stdout) => ok(err && !stdout ? 0 : Number(/^(\d+)/.exec(String(stdout))?.[1] ?? 0) * 1024));
+});
+export async function holdOf(project, d, procs) {
+    const ps = procs ?? await d.procs();
+    const open = unityOn(ps, projectNames(project));
+    if (open.length)
+        return `Unity has it open (pid ${open.map((p) => p.pid).join(', ')})`;
+    const q = await queueHolds(d.root, project, ps, d.now(), d.staleMs);
+    if (q)
+        return q;
+    try {
+        const lf = await lstat(join(project, 'Temp', 'UnityLockfile'));
+        if (d.now() - lf.mtimeMs < 24 * 3600_000)
+            return 'Temp/UnityLockfile is fresh (an Editor may have it open)';
+    }
+    catch { }
+    return null;
+}
+export async function gcPlan(roots, days, d) {
+    const cutoff = d.now() - days * 86400_000;
+    const procs = await d.procs();
+    const plan = { folders: [], skipped: [], recent: 0, bytes: 0 };
+    for (const project of await findProjects(roots)) {
+        const why = await holdOf(project, d, procs);
+        if (why) {
+            plan.skipped.push({ project, why });
+            continue;
+        }
+        for (const folder of GC_FOLDERS) {
+            const path = join(project, folder);
+            let s;
+            try {
+                s = await lstat(path);
+            }
+            catch {
+                continue;
+            }
+            if (!s.isDirectory() || s.isSymbolicLink())
+                continue;
+            const newest = await newestMtime(path, cutoff);
+            if (newest > cutoff) {
+                plan.recent++;
+                continue;
+            }
+            const bytes = await d.du(path);
+            plan.folders.push({ project, folder, path, bytes, touched: new Date(newest).toISOString() });
+            plan.bytes += bytes;
+        }
+    }
+    plan.folders.sort((a, b) => b.bytes - a.bytes);
+    return plan;
+}
+export async function gcApply(plan, d) {
+    const removed = [];
+    const kept = [];
+    const byProject = new Map();
+    for (const f of plan.folders)
+        byProject.set(f.project, [...(byProject.get(f.project) ?? []), f]);
+    for (const [project, folders] of byProject) {
+        const why = await holdOf(project, d);
+        if (why) {
+            kept.push({ project, why: `${why} (checked again before deleting)` });
+            continue;
+        }
+        for (const f of folders) {
+            const s = await lstat(f.path).catch(() => null);
+            if (!s || !s.isDirectory() || s.isSymbolicLink())
+                continue;
+            await rm(f.path, { recursive: true, force: true });
+            removed.push(f);
+        }
+    }
+    return { removed, kept };
+}
+export const human = (b) => b >= 1024 ** 3 ? `${(b / 1024 ** 3).toFixed(1)} GB` : b >= 1024 ** 2 ? `${Math.round(b / 1024 ** 2)} MB` : `${Math.round(b / 1024)} KB`;