@funpixel/tools 0.0.0-stage → 0.1.1

package/dist/commands/setup.js

@@ -0,0 +1,254 @@
+import { spawnSync } from 'node:child_process';
+import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, symlinkSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { EXIT } from "./verify.js";
+import { ui } from "../ui.js";
+import { currentVersion as funtoolsVersion } from "../update.js";
+import { detectHost } from "../doctor/host.js";
+import { languageServers } from "../setup/lsp.js";
+export const HOSTS = ['claude', 'cursor', 'codex', 'kiro', 'robin'];
+const realRun = (cmd, args) => {
+    const r = spawnSync(cmd, args, { encoding: 'utf8', timeout: 180_000 });
+    return { code: r.status ?? (r.error ? 127 : 1), out: `${r.stdout ?? ''}${r.stderr ?? ''}${r.error ? String(r.error.message) : ''}`.trim() };
+};
+const onPath = (run, cmd) => run('/bin/sh', ['-c', `command -v ${cmd}`]).code === 0;
+export function pluginsSource() {
+    const pkg = join(dirname(fileURLToPath(import.meta.url)), '..', '..');
+    for (const p of [join(pkg, 'plugins'), join(pkg, '..', '..', 'gdk', 'dist')])
+        if (existsSync(join(p, 'claude')) && existsSync(join(p, '.claude-plugin', 'marketplace.json')))
+            return p;
+    return null;
+}
+export function hostsFor(o) {
+    if (o.host === 'all')
+        return [...HOSTS];
+    if (o.host)
+        return HOSTS.includes(o.host) ? [o.host] : [];
+    const under = detectHost(o.env);
+    if (under && HOSTS.includes(under.host))
+        return [under.host];
+    const found = [];
+    if (onPath(o.run, 'claude'))
+        found.push('claude');
+    if (existsSync(join(o.home, '.cursor')))
+        found.push('cursor');
+    if (onPath(o.run, 'codex') || existsSync(join(o.home, '.codex')))
+        found.push('codex');
+    if (onPath(o.run, 'kiro-cli') || existsSync(join(o.home, '.kiro')))
+        found.push('kiro');
+    if (existsSync(join(o.applications ?? '/Applications', 'Robin.app')) || existsSync(join(o.home, 'Applications', 'Robin.app')))
+        found.push('robin');
+    return found;
+}
+export function robinLink(home) {
+    return join(home, 'Library', 'Application Support', 'Robin', 'Plugins', 'fp');
+}
+export function staleClaudeInstall(home, source) {
+    const want = source && existsSync(join(source, 'claude', 'skills')) ? new Set(readdirSync(join(source, 'claude', 'skills'))) : null;
+    const out = { stale: [], scopes: [], changed: [] };
+    if (!want)
+        return out;
+    let installs = [];
+    try {
+        installs = JSON.parse(readFileSync(join(home, '.claude', 'plugins', 'installed_plugins.json'), 'utf8'))?.plugins?.['fp@funpixel'] ?? [];
+    }
+    catch {
+        return out;
+    }
+    for (const i of Array.isArray(installs) ? installs : []) {
+        const dir = i.installPath ? join(i.installPath, 'skills') : '';
+        if (!dir || !existsSync(dir))
+            continue;
+        const have = readdirSync(dir);
+        const old = have.filter((n) => !want.has(n));
+        const changed = old.length || have.length !== want.size ? [] : differingFiles(join(source, 'claude'), i.installPath);
+        if (!old.length && have.length === want.size && !changed.length)
+            continue;
+        out.stale.push(...old.filter((n) => !out.stale.includes(n)));
+        out.changed.push(...changed.filter((n) => !out.changed.includes(n)));
+        const scope = i.scope ?? 'user';
+        if (!out.scopes.includes(scope))
+            out.scopes.push(scope);
+    }
+    return out;
+}
+function differingFiles(build, install) {
+    const out = [];
+    const walk = (rel) => {
+        const at = join(build, rel);
+        let names;
+        try {
+            names = readdirSync(at);
+        }
+        catch {
+            return;
+        }
+        for (const n of names) {
+            const r = rel ? join(rel, n) : n;
+            let isDir = false;
+            try {
+                isDir = statSync(join(build, r)).isDirectory();
+            }
+            catch {
+                continue;
+            }
+            if (isDir) {
+                walk(r);
+                continue;
+            }
+            let same = false;
+            try {
+                same = readFileSync(join(build, r)).equals(readFileSync(join(install, r)));
+            }
+            catch {
+                same = false;
+            }
+            if (!same)
+                out.push(r);
+        }
+    };
+    for (const top of ['hooks', 'skills', 'agents', 'commands'])
+        walk(top);
+    return out;
+}
+export function plan(stable, hosts, home, source = null) {
+    const steps = [];
+    for (const h of hosts) {
+        if (h === 'claude') {
+            steps.push({ host: h, does: 'add the Funpixel marketplace to Claude Code', run: `claude plugin marketplace add ${stable}`, ok: null });
+            const old = staleClaudeInstall(home, source);
+            if (old.scopes.includes('user')) {
+                const why = old.stale.length
+                    ? `whose skills are an older set (${old.stale.slice(0, 3).join(', ')}${old.stale.length > 3 ? ', …' : ''}), so the old names do not linger beside the new`
+                    : `whose files differ from this build's (${old.changed.slice(0, 3).join(', ')}${old.changed.length > 3 ? ', …' : ''}): the version did not move, so an install over it would keep the old copy`;
+                steps.push({ host: h, does: `remove the installed GDK plugin, ${why}; its data is kept`, run: 'claude plugin uninstall fp@funpixel --scope user --keep-data', ok: null });
+            }
+            for (const scope of old.scopes.filter((x) => x !== 'user')) {
+                steps.push({ host: h, does: `a ${scope}-scope install of the GDK plugin carries the older skills: in that project run \`claude plugin uninstall fp@funpixel --scope ${scope} --keep-data\`, then install it again`, ok: null });
+            }
+            steps.push({ host: h, does: 'install the GDK plugin (/fp:new, /fp:flow, the skills, the hooks)', run: 'claude plugin install fp@funpixel', ok: null });
+        }
+        else if (h === 'cursor') {
+            steps.push({ host: h, does: `copy the plugin to ${join(home, '.cursor', 'plugins', 'local', 'fp')}`, ok: null });
+        }
+        else if (h === 'kiro') {
+            steps.push({ host: h, does: 'write the Kiro agent that points at the plugin', run: `node ${join(stable, 'kiro', 'install.mjs')}`, ok: null });
+        }
+        else if (h === 'codex') {
+            steps.push({ host: h, does: `in Codex, add the marketplace at ${stable} (its .agents/plugins/marketplace.json) and enable fp; for the hosted tools, bearer_token_env_var = "FUNPIXEL_API_KEY" under [mcp_servers.funpixel] in ~/.codex/config.toml`, ok: null });
+        }
+        else if (h === 'robin') {
+            steps.push({ host: h, does: `link the plugin into Robin (${robinLink(home)} → ${join(stable, 'robin')}): it brings funtools as a local server, and on your Claude subscription the GDK's commands, skills and hooks; reopen Robin, or Settings → Connectors → Refresh Skills`, ok: null });
+        }
+    }
+    return steps;
+}
+export async function setup(opts, io = console) {
+    const u = ui(io, 'setup');
+    const home = opts.home ?? homedir();
+    const env = opts.env ?? process.env;
+    const run = opts.run ?? realRun;
+    if (opts.host && opts.host !== 'all' && !HOSTS.includes(opts.host)) {
+        u.error(`--host ${opts.host}`, `one of ${HOSTS.join(', ')}, or all`);
+        return EXIT.error;
+    }
+    const source = opts.plugins ?? pluginsSource();
+    if (!source) {
+        u.error('this funtools carries no plugin builds', 'reinstall @funpixel/tools, or in the monorepo build them: npm run build in funpixel-mono/gdk');
+        return EXIT.error;
+    }
+    const hosts = hostsFor({ host: opts.host, env, home, run });
+    const stable = join(home, '.funpixel', 'plugins', funtoolsVersion());
+    const steps = plan(stable, hosts, home, source);
+    if (!opts.dryRun && hosts.length) {
+        rmSync(stable, { recursive: true, force: true });
+        mkdirSync(dirname(stable), { recursive: true });
+        cpSync(source, stable, { recursive: true });
+        if (hosts.includes('claude') || hosts.includes('robin')) {
+            const lsp = languageServers(home, env.PATH ?? process.env.PATH ?? '');
+            const wrote = [];
+            for (const dir of [join(stable, 'claude'), join(stable, 'robin', 'claude')]) {
+                if (!existsSync(dir) || !Object.keys(lsp.servers).length)
+                    continue;
+                try {
+                    writeFileSync(join(dir, '.lsp.json'), JSON.stringify(lsp.servers, null, 2) + '\n');
+                    wrote.push(dir);
+                }
+                catch { }
+            }
+            steps.push({ host: hosts.includes('claude') ? 'claude' : 'robin', ok: wrote.length > 0,
+                does: `code sense in Claude Code for ${Object.keys(lsp.servers).join(', ') || 'no language'} (each starts only when a file of its kind is edited)`
+                    + (lsp.missing.length ? `; not on this Mac: ${lsp.missing.map((m) => `${m.id} (${m.install})`).join(', ')}` : '') });
+        }
+        if (hosts.includes('claude') && existsSync(join(stable, 'claude'))) {
+            const mcp = funtoolsMcpEntry();
+            try {
+                writeFileSync(join(stable, 'claude', '.mcp.json'), JSON.stringify({ mcpServers: { funpixel: mcp } }, null, 2) + '\n');
+                steps.push({ host: 'claude', ok: true, does: 'the Funpixel tools in Claude Code through this funtools (`funtools mcp`): its sign-in and API address, no key in the environment' });
+            }
+            catch (e) {
+                steps.push({ host: 'claude', ok: false, does: 'the Funpixel tools through funtools mcp', out: e.message });
+            }
+        }
+        for (const s of steps) {
+            if (s.host === 'robin') {
+                const at = robinLink(home);
+                try {
+                    mkdirSync(dirname(at), { recursive: true });
+                    rmSync(at, { recursive: true, force: true });
+                    symlinkSync(join(stable, 'robin'), at);
+                    s.ok = true;
+                }
+                catch (e) {
+                    s.ok = false;
+                    s.out = e.message;
+                }
+            }
+            else if (s.host === 'cursor') {
+                const to = join(home, '.cursor', 'plugins', 'local', 'fp');
+                try {
+                    rmSync(to, { recursive: true, force: true });
+                    mkdirSync(dirname(to), { recursive: true });
+                    cpSync(join(stable, 'cursor'), to, { recursive: true });
+                    s.ok = true;
+                }
+                catch (e) {
+                    s.ok = false;
+                    s.out = e.message;
+                }
+            }
+            else if (s.run) {
+                const [cmd, ...args] = s.run.split(' ');
+                let r = run(cmd, args);
+                if (r.code !== 0 && /marketplace add/.test(s.run) && /already/i.test(r.out))
+                    r = run('claude', ['plugin', 'marketplace', 'update', 'funpixel']);
+                s.ok = r.code === 0;
+                s.out = r.out.slice(-400);
+            }
+        }
+    }
+    const failed = steps.filter((s) => s.ok === false);
+    if (opts.json) {
+        io.log(JSON.stringify({ source, stable, hosts, dryRun: !!opts.dryRun, steps }, null, 2));
+        return failed.length ? EXIT.fail : EXIT.pass;
+    }
+    u.heading(`setup · ${hosts.length ? hosts.join(', ') : 'no host found'}${opts.dryRun ? ' (dry run: nothing changed)' : ''}`);
+    if (!hosts.length) {
+        u.summary('fail', `no agent found on this machine: name one, funtools setup --host ${HOSTS.join('|')}`);
+        return EXIT.fail;
+    }
+    u.item('note', `the plugins, kept at ${stable}`, `from ${source}`);
+    for (const s of steps)
+        u.item(s.ok === false ? 'fail' : s.ok ? 'pass' : 'note', `${s.host}: ${s.does}`, s.run ? (s.ok === false ? `${s.run}: ${s.out}` : s.run) : undefined);
+    if (opts.dryRun) {
+        u.summary('note', `dry run: ${steps.length} step(s) above would run; nothing was changed. Run it without --dry-run to set up`);
+        return EXIT.pass;
+    }
+    u.summary(failed.length ? 'fail' : 'pass', failed.length ? `${failed.length} step(s) failed` : 'set up. Next: funtools login (your key), then in your agent: /fp:new "<the game in one line>"');
+    return failed.length ? EXIT.fail : EXIT.pass;
+}
+export function funtoolsMcpEntry(execPath = process.execPath, execArgv = process.execArgv, script = process.argv[1] ?? '') {
+    return { command: execPath, args: [...execArgv, resolve(script), 'mcp'] };
+}

package/dist/commands/sim.js

@@ -0,0 +1,179 @@
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { EXIT } from "./verify.js";
+import { fingerprint } from "../verify/fingerprint.js";
+import { invalid, judge, perMinute, playFloor, statedLength } from "../sim/judge.js";
+import { curveRows, judgeCurve, judgeReach } from "../sim/curve.js";
+import { designDoc } from "../gdd/doc.js";
+import { contentList, contentTotals } from "../gdd/size.js";
+import { ui } from "../ui.js";
+import { autoLog } from "../feedback/auto.js";
+import { idleLine } from "../frame/idle.js";
+import { UNWIRED } from "../sim/skeleton.js";
+import { lengthFromRooms } from "../spec/rooms.js";
+export const SIM_RECORD = join('.funtools', 'sim.json');
+export const SIM_SCRIPT = join('test', 'probes.ts');
+export const SIM_TIMEOUT_S = 300;
+const HOOK = `export async function resolve(s, c, next) {
+  try { return await next(s, c); } catch (e) {
+    if (!/^\\.{1,2}\\//.test(s) || /\\.[cm]?[jt]sx?$/.test(s)) throw e;
+    for (const x of ['.ts', '.js', '/index.ts']) { try { return await next(s + x, c); } catch {} }
+    throw e;
+  }
+}`;
+const SYNC_HOOK = `{ resolve(s, c, next) {
+  try { return next(s, c); } catch (e) {
+    if (!/^\\.{1,2}\\//.test(s) || /\\.[cm]?[jt]sx?$/.test(s)) throw e;
+    for (const x of ['.ts', '.js', '/index.ts']) { try { return next(s + x, c); } catch {} }
+    throw e;
+  }
+} }`;
+export const TS_RESOLVE = `data:text/javascript,${encodeURIComponent(`import * as m from 'node:module'; if (typeof m.registerHooks === 'function') m.registerHooks(${SYNC_HOOK}); else m.register(${JSON.stringify(`data:text/javascript,${encodeURIComponent(HOOK)}`)});`)}`;
+export function crashLine(stderr) {
+    const lines = stderr.trim().split('\n');
+    const named = lines.find((l) => /^\w*Error\b.*:/.test(l.trim()));
+    return named?.trim() ?? lines.slice(-3).join(' ');
+}
+export const nodeScript = (dir, script, timeoutMs = SIM_TIMEOUT_S * 1000) => new Promise((done) => {
+    const env = { ...process.env };
+    delete env.NODE_TEST_CONTEXT;
+    const child = spawn(process.execPath, ['--import', TS_RESOLVE, script], { cwd: dir, env, stdio: ['ignore', 'pipe', 'pipe'] });
+    let stdout = '', stderr = '', timedOut = false;
+    child.stdout.on('data', (b) => { stdout += b; });
+    child.stderr.on('data', (b) => { stderr += b; });
+    const timer = setTimeout(() => { timedOut = true; child.kill('SIGKILL'); }, timeoutMs);
+    child.on('error', (e) => { clearTimeout(timer); done({ code: 127, stdout, stderr: String(e) }); });
+    child.on('close', (code) => { clearTimeout(timer); done({ code: code ?? 1, stdout, stderr, timedOut }); });
+});
+const EXAMPLE = /does not provide an export named '(bestStep|hop|inReach|move|newRun|phase|SLOTS|TELL_SECONDS|tick|GOAL)'/;
+export function unwired(stderr) {
+    const m = new RegExp(`^\\s*(?:\\w*Error: )[^\\n]*probes\\.ts ${UNWIRED}: ([^\\n]+?)(?: \\(skill funpixel-game-logic[^\\n]*)?$`, 'm').exec(stderr);
+    return m ? m[1].trim() : null;
+}
+export function whyFailed(script, res, timeoutS) {
+    if (res.timedOut)
+        return [`${script} ran past ${timeoutS} s and was stopped`, `a campaign probe can take minutes: --timeout ${timeoutS * 2}, or fewer seeds while tuning`];
+    const example = EXAMPLE.exec(res.stderr);
+    if (example)
+        return [`${script} still plays the scaffold's example: it imports ${example[1]}, which your rules no longer export`, 'rewrite its game (newRun, step, outcome, progress) and the five policies on your own rules; src/probe-kit.ts does the rest (skill funpixel-game-logic, references/probes.md)'];
+    return [`${script} exited ${res.code}: ${crashLine(res.stderr)}`, `run it yourself: node ${script}`];
+}
+export const stderrLines = (stderr, max = 12) => stderr.split('\n').map((l) => l.trimEnd()).filter((l) => l.trim()).slice(-max);
+export function parseProbe(stdout) {
+    try {
+        return JSON.parse(stdout.trim());
+    }
+    catch { }
+    for (const line of stdout.trim().split('\n').reverse()) {
+        if (!line.trim().startsWith('{'))
+            continue;
+        try {
+            return JSON.parse(line);
+        }
+        catch { }
+    }
+    return null;
+}
+const MARK = { warn: 'warn', note: 'note', ok: 'pass', 'not measured': 'not_observed' };
+export async function sim(opts, io = console, run = nodeScript) {
+    const dir = resolve(opts.target ?? '.');
+    const u = ui(io, 'sim');
+    const script = opts.script ?? SIM_SCRIPT;
+    if (!existsSync(join(dir, script))) {
+        if (opts.json)
+            io.log(JSON.stringify({ tool: 'funtools', command: 'sim', exit: EXIT.not_observed, script, findings: [] }, null, 2));
+        else {
+            const parked = existsSync(join(dir, `${script}.funtools-new`));
+            u.summary('not_observed', parked
+                ? `no ${script}: a probe for your rules waits at ${script}.funtools-new (upgrade parked it) — copy it to ${script}, fill its five marked places with your rules, and src/probe-kit.ts does the rest (skill funpixel-game-logic, references/probes.md)`
+                : `no ${script}: the bots never played the rules — write it over your rules and src/probe-kit.ts (an idle, a naive and a skilled policy at least; shape and worked examples: skill funpixel-game-logic, references/probes.md)`);
+        }
+        return EXIT.not_observed;
+    }
+    const fp = (await fingerprint(dir)).fingerprint;
+    const timeoutS = opts.timeout && opts.timeout > 0 ? opts.timeout : SIM_TIMEOUT_S;
+    const res = await run(dir, script, timeoutS * 1000);
+    const said = stderrLines(res.stderr);
+    const todo = unwired(res.stderr);
+    if (todo && !res.timedOut) {
+        const says = `the bots never played the rules: ${script} is the skeleton, not wired to this game's rules (${todo})`;
+        const next = `fill its TODO places over your rules (newRun, step, outcome, progress; a naive policy that loses, a skilled one that wins some), then \`npx @funpixel/tools sim\` (skill funpixel-game-logic, references/probes.md)`;
+        const findings = [{ id: 'unwired', state: 'warn', says, next }];
+        const record = { tool: 'funtools', command: 'sim', script, exit: EXIT.fail, fingerprint: fp, at: new Date().toISOString(), findings, cohorts: [] };
+        await mkdir(dirname(join(dir, SIM_RECORD)), { recursive: true });
+        await writeFile(join(dir, SIM_RECORD), JSON.stringify(record, null, 2) + '\n');
+        if (opts.json)
+            io.log(JSON.stringify(record, null, 2));
+        else {
+            u.item('fail', says, next);
+            u.summary('fail', `the bots never played the rules (${SIM_RECORD})`);
+        }
+        return EXIT.fail;
+    }
+    if (res.code !== 0 || res.timedOut) {
+        const [why, next] = whyFailed(script, res, timeoutS);
+        if (!opts.json)
+            for (const l of said)
+                u.line(`stderr: ${l}`, 2);
+        u.error(why, next);
+        return EXIT.error;
+    }
+    const out = parseProbe(res.stdout);
+    const why = invalid(out);
+    if (why) {
+        for (const l of said)
+            u.line(`stderr: ${l}`, 2);
+        u.error(why, `run it yourself: node ${script}`);
+        return EXIT.error;
+    }
+    const probe = out;
+    const doc = designDoc(dir);
+    const stated = doc ? statedLength(doc.text, doc.rel) : null;
+    const rows = doc ? contentList(doc.text) : null;
+    const reach = judgeReach(probe.cohorts, rows ? contentTotals(rows).areas : null, doc?.rel);
+    const floor = playFloor(dir);
+    const byRooms = lengthFromRooms(dir, fp, floor);
+    const findings = [...judge(probe, undefined, stated, floor), ...judgeCurve(probe.cohorts), ...(reach ? [reach] : [])]
+        .map((f) => (f.id === 'length' && byRooms ? { id: 'length', state: byRooms.state, says: byRooms.says, ...(byRooms.next ? { next: byRooms.next } : {}) } : f));
+    const curve = curveRows(probe.cohorts);
+    const measured = findings.some((f) => f.state !== 'not measured');
+    const exit = measured ? EXIT.pass : EXIT.not_observed;
+    const record = { tool: 'funtools', command: 'sim', script, exit, fingerprint: fp, at: new Date().toISOString(), findings, cohorts: probe.cohorts, ...(curve.length ? { curve } : {}), moments: probe.moments ?? [], ...(stated ? { stated_length: stated } : {}), play_floor: floor, ...(said.length ? { stderr: said } : {}) };
+    await mkdir(dirname(join(dir, SIM_RECORD)), { recursive: true });
+    await writeFile(join(dir, SIM_RECORD), JSON.stringify(record, null, 2) + '\n');
+    autoLog(dir, 'sim', 'naive bot runs lost', probe.cohorts.find((c) => c.role === 'naive')?.lost, 'runs', SIM_RECORD);
+    autoLog(dir, 'sim', 'warnings', findings.filter((f) => f.state === 'warn').length, '', SIM_RECORD);
+    if (opts.json) {
+        io.log(JSON.stringify(record, null, 2));
+        return exit;
+    }
+    u.heading(`policies (${probe.cohorts[0]?.seeds ?? 0} seeds each)`);
+    for (const c of probe.cohorts) {
+        u.line(`${c.policy} — ${c.says}`);
+        u.line(`won ${c.won} · lost ${c.lost} · open ${c.open} · progress ${c.progress.mean} (${c.progress.min}–${c.progress.max}) · ${c.meanSeconds} s${c.spread ? ` (${c.spread.min}–${c.spread.max}, median ${c.spread.median})` : ''} · ${perMinute(c)}/min${c.firstSuccess === null ? '' : ` · first success ${c.firstSuccess}`}`, 2);
+        if (c.ended !== undefined)
+            u.line(c.ended ? `ending reached on ${c.ended}/${c.seeds} seeds, at ${c.endedAt} s` : `no ending reached in ${c.seconds} s`, 2);
+        if (c.levels?.length)
+            u.line(`levels ${c.levels.map((l) => `${l.level}: ${l.reached} seeds at ${l.meanAt} s`).join(' · ')}`, 2);
+    }
+    if (curve.length) {
+        u.heading('the curve, per level');
+        for (const l of curve)
+            u.line(l, 2);
+    }
+    if (said.length) {
+        u.heading('the probe said (stderr)');
+        for (const l of said)
+            u.line(l, 2);
+    }
+    u.heading('findings');
+    for (const f of findings)
+        u.item(MARK[f.state], f.says, f.next);
+    u.item('note', idleLine(dir));
+    const count = (s) => findings.filter((f) => f.state === s).length;
+    const tally = [`${count('warn')} warn`, `${count('note')} note`, `${count('ok')} ok`, `${count('not measured')} not measured`].join(' · ');
+    u.summary(count('warn') ? 'warn' : measured ? 'note' : 'not_observed', `${tally} — a mirror: own each warn and note in the design note, or change the rules (${SIM_RECORD})`);
+    return exit;
+}

package/dist/commands/simulator.js

@@ -0,0 +1,154 @@
+import { mkdir } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { listProcs, machineDir, ownerPid, sessionOf } from "../machine/procs.js";
+import { DEFAULT_DEVICE, gc, lease, list, readLease, release, writeLease } from "../simulator/lease.js";
+import { Refused, realSimctl } from "../simulator/simctl.js";
+import { findTapTool, readPlist, runTool, shot, sipsRotate, stand, tap } from "../simulator/screen.js";
+import { EXIT } from "./verify.js";
+import { ui } from "../ui.js";
+export const SIM_VERBS = ['lease', 'release', 'list', 'gc', 'shot', 'tap'];
+export const isSimVerb = (w) => !!w && SIM_VERBS.includes(w);
+export async function realSimulatorDeps(io, owner, tool, env = process.env) {
+    const procs = await listProcs();
+    const pid = owner ?? ownerPid(procs, env);
+    return {
+        root: join(machineDir(env), 'sim-leases'), simctl: realSimctl, procs: listProcs, now: Date.now, ownerPid: pid,
+        session: sessionOf(env, pid), cwd: process.cwd(), log: (l) => io.error(`funtools sim: ${l}`),
+        plist: readPlist, rotate: sipsRotate, tool: findTapTool(env, tool), run: runTool,
+    };
+}
+export async function simulator(o, io, given) {
+    const u = ui(io, `sim ${o.verb}`);
+    if (process.platform !== 'darwin' && !given) {
+        u.error('the iOS Simulator runs only on macOS');
+        return EXIT.not_observed;
+    }
+    const d = given ?? await realSimulatorDeps(io, o.owner, o.tool);
+    const out = (v) => io.log(JSON.stringify(v, null, 2));
+    try {
+        switch (o.verb) {
+            case 'lease': {
+                const r = await lease({ device: o.device, runtime: o.runtime, boot: o.boot }, d);
+                if (!r.ok) {
+                    u.error(r.message);
+                    return EXIT.error;
+                }
+                if (o.json) {
+                    out({ ...r.lease, booted: r.booted });
+                    return 0;
+                }
+                const err = ui({ log: io.error, error: io.error }, 'sim lease');
+                err.summary('pass', `${r.lease.name} · ${r.lease.device} · ${r.lease.runtime}${r.booted ? ' · booted' : ''} · owner pid ${r.lease.owner_pid}`);
+                io.log(r.lease.udid);
+                err.line(`release it when done: funtools sim release ${r.lease.udid}`, 0);
+                return 0;
+            }
+            case 'release': {
+                const udid = o.args[0];
+                if (!udid) {
+                    u.error('which lease?', 'funtools sim release <udid> (funtools sim list)');
+                    return EXIT.error;
+                }
+                const r = await release(udid, { force: o.force }, d);
+                if (!r.ok) {
+                    u.error(r.message);
+                    return EXIT.error;
+                }
+                if (o.json) {
+                    out({ released: r.lease, note: r.note ?? null });
+                    return 0;
+                }
+                u.summary('pass', `${r.lease?.name ?? udid} shut down and deleted${r.note ? ` (${r.note})` : ''}`);
+                return 0;
+            }
+            case 'list': {
+                const rows = await list(d);
+                if (o.json) {
+                    out(rows);
+                    return 0;
+                }
+                u.heading(`sim leases · ${d.root}`);
+                if (!rows.length)
+                    u.line(`none — funtools sim lease [--device "${DEFAULT_DEVICE}"]`);
+                for (const r of rows) {
+                    if (r.orphan) {
+                        u.item('warn', `${r.device.name} ${r.device.udid}`, `${r.device.state}; no lease record (funtools sim gc deletes it once shut down)`);
+                        continue;
+                    }
+                    const l = r.lease;
+                    u.item(r.owner_alive ? 'pass' : 'warn', `${l.name} ${l.udid} · ${l.device} · ${r.device?.state ?? 'gone'}`, `session ${l.session}, owner pid ${l.owner_pid}${r.owner_alive ? '' : ' (gone: funtools sim gc releases it)'}, since ${l.created}`);
+                }
+                return 0;
+            }
+            case 'gc': {
+                const r = await gc({ dryRun: o.dryRun }, d);
+                if (o.json) {
+                    out(r);
+                    return 0;
+                }
+                u.heading(`sim gc${r.dry_run ? ' · dry run' : ''} · ft-lease-* devices only`);
+                for (const l of r.released)
+                    u.item(r.dry_run ? 'todo' : 'pass', `${r.dry_run ? 'would release' : 'released'} ${l.name} ${l.udid}`, `owner pid ${l.owner_pid} is gone`);
+                for (const x of r.deleted_orphans)
+                    u.item(r.dry_run ? 'todo' : 'pass', `${r.dry_run ? 'would delete' : 'deleted'} ${x.name} ${x.udid}`, 'ft-lease-* with no record, shut down');
+                for (const k of r.kept)
+                    u.item('skip', k.name, k.why);
+                if (!r.released.length && !r.deleted_orphans.length)
+                    u.line('nothing to clean up');
+                return 0;
+            }
+            case 'shot':
+            case 'tap': {
+                const udid = o.args[0];
+                if (!udid) {
+                    u.error('which simulator?', `funtools sim ${o.verb} <udid>${o.verb === 'tap' ? ' x y' : ''}`);
+                    return EXIT.error;
+                }
+                const l = await readLease(d.root, udid);
+                const st = await stand(udid, { orientation: o.orientation, app: o.app, remembered: l?.orientation }, d.simctl, d.plist);
+                if ('error' in st) {
+                    u.error(st.error);
+                    return EXIT.error;
+                }
+                if (o.verb === 'shot') {
+                    const file = resolve(o.out ?? join('.funtools', 'sim', `shot-${udid.slice(0, 8)}-${Date.now()}.png`));
+                    await mkdir(dirname(file), { recursive: true });
+                    const r = await shot(udid, file, st, d);
+                    if (l && l.orientation !== st.orientation)
+                        await writeLease(d.root, { ...l, orientation: st.orientation });
+                    if (o.json) {
+                        out(r);
+                        return 0;
+                    }
+                    u.summary('pass', `${r.file} · ${r.orientation}${r.rotated ? ` (turned ${r.rotated}°)` : ''}${r.size ? ` · ${r.size.width}x${r.size.height} px` : ''} · from ${r.from}`);
+                    return 0;
+                }
+                if (!l) {
+                    u.error(`${udid} is not a funtools lease — a tap on another agent's simulator lands in its run`, 'funtools sim lease gives you one');
+                    return EXIT.error;
+                }
+                const [xs, ys] = o.args.slice(1);
+                const x = Number(xs), y = Number(ys);
+                if (xs === undefined || ys === undefined || !Number.isFinite(x) || !Number.isFinite(y)) {
+                    u.error('tap needs x and y', 'funtools sim tap <udid> x y (pixels of the upright shot; --points for points)');
+                    return EXIT.error;
+                }
+                const r = await tap(udid, x, y, { points: o.points, stand: st }, d);
+                if ('error' in r) {
+                    u.error(o.tool && !d.tool ? `${o.tool} is not installed` : r.error);
+                    return d.tool ? EXIT.error : EXIT.not_observed;
+                }
+                if (o.json) {
+                    out(r);
+                    return 0;
+                }
+                u.summary('pass', `tapped (${x}, ${y}) ${o.points ? 'pt' : 'px'} of the ${r.orientation} game → device (${r.device_points.x}, ${r.device_points.y}) pt via ${r.tool} · from ${r.from}`);
+                return 0;
+            }
+        }
+    }
+    catch (e) {
+        u.error(e instanceof Refused ? e.message : `failed: ${e.message}`);
+        return EXIT.error;
+    }
+}