@nonbot/cli 0.10.15 → 0.10.17

package/dist/lib/mcp-account.js

@@ -0,0 +1,232 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { compareVersions, parseSemver } from './update-check.js';
+export function tokenFor(entry, spec, cliAuth) {
+    if (spec) {
+        const auth = Object.entries(spec.headers).find(([k]) => k.toLowerCase() === 'authorization')?.[1];
+        const bearer = auth && /^Bearer\s+(\S+)$/i.exec(auth)?.[1];
+        if (bearer)
+            return { source: 'config', token: bearer };
+        const env = spec.env.NON_BOT_API_TOKEN;
+        if (env)
+            return { source: 'config', token: env };
+    }
+    if (entry.kind === 'remote')
+        return { source: 'none' };
+    return cliAuth?.pat ? { source: 'login', token: cliAuth.pat } : { source: 'none' };
+}
+export function maskToken(token) {
+    const tail = token.slice(-4);
+    return token.startsWith('pat_') ? `pat_…${tail}` : `…${tail}`;
+}
+export function isReadOnly(spec) {
+    if (!spec)
+        return false;
+    if (spec.env.NON_BOT_MCP_READONLY === '1')
+        return true;
+    if (spec.url) {
+        try {
+            return new URL(spec.url).searchParams.get('readonly') === '1';
+        }
+        catch {
+            return false;
+        }
+    }
+    return false;
+}
+export async function checkToken(baseUrl, token, fetchImpl = fetch) {
+    try {
+        const res = await fetchImpl(`${baseUrl}/api/auth/me`, {
+            headers: { Authorization: `Bearer ${token}`, 'X-Requested-With': 'ConradPM-Native' },
+            signal: AbortSignal.timeout(8_000),
+        });
+        if (res.status === 401)
+            return { valid: false, scopes: null };
+        if (!res.ok)
+            return { valid: null, scopes: null };
+        const body = (await res.json());
+        if (!body.authenticated)
+            return { valid: false, scopes: null };
+        const t = body.token;
+        return {
+            valid: true,
+            name: typeof t?.name === 'string' ? t.name : null,
+            scopes: Array.isArray(t?.scopes) ? t.scopes.filter((s) => typeof s === 'string') : null,
+        };
+    }
+    catch {
+        return { valid: null, scopes: null };
+    }
+}
+export function familyOf(tool) {
+    if (tool.startsWith('jobshop_'))
+        return { family: 'jobshop', resources: ['jobshop'] };
+    if (tool.startsWith('radbug_'))
+        return { family: 'radbugs', resources: ['radbugs', 'admin', 'team'] };
+    if (tool.startsWith('run_'))
+        return { family: 'run', resources: ['portfolio', 'runs'] };
+    return { family: 'portfolio', resources: ['portfolio'] };
+}
+export function scopeGaps(scopes, tools) {
+    if (scopes === null || scopes.includes('*'))
+        return { full: true, blocked: [], readOnly: [] };
+    const has = (res) => scopes.some((s) => s.startsWith(`${res}:`));
+    const canWrite = (res) => scopes.some((s) => s === `${res}:write` || (res === 'runs' && /^runs:(fire|control|respond)$/.test(s)));
+    const counts = new Map();
+    for (const t of tools) {
+        const f = familyOf(t.name);
+        const c = counts.get(f.family) ?? { resources: f.resources, n: 0 };
+        c.n++;
+        counts.set(f.family, c);
+    }
+    const blocked = [];
+    const readOnly = [];
+    for (const [family, { resources, n }] of counts) {
+        if (!resources.some(has))
+            blocked.push({ family, tools: n, needs: resources.map((r) => `${r}:*`).join(' or ') });
+        else if (!resources.some(canWrite))
+            readOnly.push({ family, tools: n });
+    }
+    return { full: false, blocked, readOnly };
+}
+export function preApprovals(serverName, dirs, home = homedir(), read = readIfExists) {
+    const files = [join(home, '.claude', 'settings.json'), join(home, '.claude', 'settings.local.json')];
+    for (const d of dirs)
+        files.push(join(d, '.claude', 'settings.json'), join(d, '.claude', 'settings.local.json'));
+    const whole = new Set([`mcp__${serverName}`, `mcp__${serverName}__*`]);
+    const prefix = `mcp__${serverName}__`;
+    const out = { all: false, some: 0, denied: 0, files: [] };
+    const allowed = new Set();
+    const denied = new Set();
+    for (const f of [...new Set(files)]) {
+        let json = null;
+        try {
+            const text = read(f);
+            json = text ? JSON.parse(text) : null;
+        }
+        catch {
+            json = null;
+        }
+        const allow = Array.isArray(json?.permissions?.allow) ? json.permissions.allow : [];
+        const deny = Array.isArray(json?.permissions?.deny) ? json.permissions.deny : [];
+        let said = false;
+        for (const r of allow) {
+            if (typeof r !== 'string')
+                continue;
+            if (whole.has(r)) {
+                out.all = true;
+                said = true;
+            }
+            else if (r.startsWith(prefix)) {
+                allowed.add(r);
+                said = true;
+            }
+        }
+        for (const r of deny) {
+            if (typeof r !== 'string')
+                continue;
+            if (whole.has(r)) {
+                out.denied = 'all';
+                said = true;
+            }
+            else if (r.startsWith(prefix) && out.denied !== 'all') {
+                denied.add(r);
+                said = true;
+            }
+        }
+        if (said)
+            out.files.push(f.startsWith(home) ? '~' + f.slice(home.length) : f);
+    }
+    out.some = allowed.size;
+    if (out.denied !== 'all')
+        out.denied = denied.size;
+    return out;
+}
+function readIfExists(p) {
+    try {
+        return existsSync(p) ? readFileSync(p, 'utf-8') : null;
+    }
+    catch {
+        return null;
+    }
+}
+const RUN_PORTFOLIO_TOOLS = new Set([
+    'portfolio_create_activation',
+    'portfolio_get_activation',
+    'portfolio_update_activation_status',
+    'portfolio_subscribe_to_activations',
+    'portfolio_attach_brief',
+    'portfolio_link_chat_session',
+    'portfolio_mark_run_ready',
+    'portfolio_repo_path',
+]);
+export function appOfTool(tool) {
+    if (tool.startsWith('run_') || RUN_PORTFOLIO_TOOLS.has(tool))
+        return 'run';
+    if (tool.startsWith('jobshop_'))
+        return 'jobshop';
+    return null;
+}
+export async function fetchAppStates(baseUrl, token, fetchImpl = fetch) {
+    try {
+        const res = await fetchImpl(`${baseUrl}/api/feature-flags/me`, {
+            headers: { Authorization: `Bearer ${token}`, 'X-Requested-With': 'ConradPM-Native' },
+            signal: AbortSignal.timeout(8_000),
+        });
+        if (!res.ok)
+            return null;
+        const body = (await res.json());
+        if (!Array.isArray(body.apps))
+            return null;
+        return body.apps
+            .filter((a) => !!a && typeof a.id === 'string')
+            .map((a) => ({ id: a.id, installed: !!a.installed, enabled: !!a.enabled, available: a.available }));
+    }
+    catch {
+        return null;
+    }
+}
+export function appsOff(tools, apps) {
+    const out = [];
+    for (const app of ['run', 'jobshop']) {
+        const n = tools.filter((t) => appOfTool(t.name) === app).length;
+        if (n === 0)
+            continue;
+        const s = apps.find((a) => a.id === app);
+        if (!s)
+            continue;
+        if (s.available === false)
+            out.push({ app, tools: n, state: 'not offered' });
+        else if (!s.installed)
+            out.push({ app, tools: n, state: 'not added' });
+        else if (!s.enabled)
+            out.push({ app, tools: n, state: 'off' });
+    }
+    return out;
+}
+export async function newerReleases(installed, latest, fetchImpl = fetch) {
+    if (!parseSemver(installed) || !parseSemver(latest) || compareVersions(latest, installed) <= 0)
+        return [];
+    try {
+        const res = await fetchImpl('https://registry.npmjs.org/@nonbot/mcp', {
+            headers: { Accept: 'application/json' },
+            signal: AbortSignal.timeout(8_000),
+        });
+        if (!res.ok)
+            return null;
+        const doc = (await res.json());
+        const out = [];
+        for (const [v, t] of Object.entries(doc.time ?? {})) {
+            if (!parseSemver(v) || /-/.test(v))
+                continue;
+            if (compareVersions(v, installed) > 0 && compareVersions(v, latest) <= 0 && typeof t === 'string') {
+                out.push({ version: v, date: t.slice(0, 10) });
+            }
+        }
+        return out.sort((a, b) => compareVersions(a.version, b.version));
+    }
+    catch {
+        return null;
+    }
+}

package/dist/lib/mcp-config.js

@@ -1,6 +1,68 @@
-import { existsSync, readFileSync } from 'node:fs';
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { basename, dirname, join, resolve, isAbsolute } from 'node:path';
+export const LEGACY_MCP_NAMES = ['portfolio-mcp', 'context-graph', 'jobshop-mcp'];
+const LAUNCH = new WeakMap();
+export function launchSpecOf(entry) {
+    return LAUNCH.get(entry);
+}
+export function isNonbotRemoteUrl(value) {
+    if (!value)
+        return false;
+    try {
+        const u = new URL(value);
+        return u.protocol === 'https:' && u.hostname.toLowerCase().replace(/\.$/, '') === 'mcp.non.bot';
+    }
+    catch {
+        return false;
+    }
+}
+export function projectServerApproved(name, dir, claudeJson, home, read) {
+    const enabled = new Set();
+    const disabled = new Set();
+    let all = false;
+    const takeFrom = (o, mayApprove) => {
+        if (!o || typeof o !== 'object')
+            return;
+        const r = o;
+        if (Array.isArray(r.disabledMcpjsonServers))
+            for (const n of r.disabledMcpjsonServers)
+                if (typeof n === 'string')
+                    disabled.add(n);
+        if (!mayApprove)
+            return;
+        if (Array.isArray(r.enabledMcpjsonServers))
+            for (const n of r.enabledMcpjsonServers)
+                if (typeof n === 'string')
+                    enabled.add(n);
+        if (r.enableAllProjectMcpServers === true)
+            all = true;
+    };
+    let real = dir;
+    try {
+        real = realpathSync(dir);
+    }
+    catch {
+    }
+    takeFrom(claudeJson?.projects?.[dir], true);
+    if (real !== dir)
+        takeFrom(claudeJson?.projects?.[real], true);
+    takeFrom(parse(read(join(home, '.claude', 'settings.json'))), true);
+    takeFrom(parse(read(join(dir, '.claude', 'settings.json'))), false);
+    takeFrom(parse(read(join(dir, '.claude', 'settings.local.json'))), false);
+    if (disabled.has(name))
+        return false;
+    return enabled.has(name) || all;
+}
+function stringMap(v) {
+    const out = {};
+    if (v && typeof v === 'object') {
+        for (const [k, val] of Object.entries(v))
+            if (typeof val === 'string')
+                out[k] = val;
+    }
+    return out;
+}
 function defaultReadFile(path) {
     try {
         return existsSync(path) ? readFileSync(path, 'utf-8') : null;
@@ -16,7 +78,7 @@ export function classifyServer(name, server, baseDir) {
     const args = Array.isArray(server.args) ? server.args.filter((a) => typeof a === 'string') : [];
     const command = typeof server.command === 'string' ? server.command : '';
     const url = typeof server.url === 'string' ? server.url : '';
-    if (/(^|\/\/|\.)mcp\.non\.bot\b/.test(url) || args.some((a) => /mcp\.non\.bot/.test(a))) {
+    if (isNonbotRemoteUrl(url) || args.some(isNonbotRemoteUrl)) {
         return { kind: 'remote' };
     }
     const spec = args.find((a) => /^@nonbot\/mcp(@[^\s]+)?$/.test(a));
@@ -61,25 +123,38 @@ export function scanMcpConfigs(deps = {}) {
     const names = new Set();
     const where = new Map();
     const nonbot = [];
+    const locations = [];
     const seenFiles = new Set();
-    const take = (source, json, baseDir) => {
+    const take = (source, json, baseDir, scope, file, dir) => {
         for (const [name, server] of serversIn(json)) {
             names.add(name);
             if (!where.has(name))
                 where.set(name, source);
+            locations.push({ name, source, scope, file, ...(dir ? { dir } : {}) });
             const c = classifyServer(name, server, baseDir);
-            if (c)
-                nonbot.push({ source, name, ...c });
+            if (c) {
+                const approved = scope !== 'project' || (!!dir && projectServerApproved(name, dir, claudeJson, home, read));
+                const entry = { source, name, ...c, scope, ...(dir ? { dir } : {}), approved };
+                nonbot.push(entry);
+                LAUNCH.set(entry, {
+                    command: typeof server.command === 'string' ? server.command : undefined,
+                    args: Array.isArray(server.args) ? server.args.filter((a) => typeof a === 'string') : [],
+                    env: stringMap(server.env),
+                    url: typeof server.url === 'string' ? server.url : undefined,
+                    headers: stringMap(server.headers),
+                    cwd: baseDir,
+                });
+            }
         }
     };
     const claudeJsonPath = join(home, '.claude.json');
     const claudeJson = parse(read(claudeJsonPath));
     const projectDirs = [];
     if (claudeJson) {
-        take('~/.claude.json', claudeJson, home);
+        take('~/.claude.json', claudeJson, home, 'user', claudeJsonPath);
         if (claudeJson.projects && typeof claudeJson.projects === 'object') {
             for (const [dir, proj] of Object.entries(claudeJson.projects)) {
-                take(`~/.claude.json (${tilde(dir, home)})`, proj, dir);
+                take(`~/.claude.json (${tilde(dir, home)})`, proj, dir, 'local', claudeJsonPath, dir);
                 projectDirs.push(dir);
             }
         }
@@ -98,15 +173,18 @@ export function scanMcpConfigs(deps = {}) {
         seenFiles.add(file);
         const json = parse(read(file));
         if (json)
-            take(tilde(file, home), json, dir);
+            take(tilde(file, home), json, dir, 'project', file, dir);
     }
     if (platform === 'darwin') {
-        const desktop = join(home, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+        const desktop = desktopConfigPath(home);
         const json = parse(read(desktop));
         if (json)
-            take('Claude Desktop', json, home);
+            take('Claude Desktop', json, home, 'desktop', desktop);
     }
-    return { names, where, nonbot };
+    return { names, where, nonbot, locations };
+}
+export function desktopConfigPath(home = homedir()) {
+    return join(home, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
 }
 export function describeNonbotMcp(e, home = homedir()) {
     switch (e.kind) {

package/dist/lib/mcp-probe.js

@@ -0,0 +1,226 @@
+import { spawn as nodeSpawn } from 'node:child_process';
+import { VERSION } from '../version.js';
+import { isNonbotRemoteUrl } from './mcp-config.js';
+export const MCP_PROTOCOL_VERSION = '2025-06-18';
+const INIT_PARAMS = {
+    protocolVersion: MCP_PROTOCOL_VERSION,
+    capabilities: {},
+    clientInfo: { name: 'nonbot-cli', version: VERSION },
+};
+const LOADER_ENV = /^(NODE_OPTIONS|NODE_PATH|BASH_ENV|ENV|PROMPT_COMMAND|DYLD_.*|LD_.*)$/i;
+export function safeConfigEnv(env) {
+    const out = {};
+    for (const [k, v] of Object.entries(env))
+        if (!LOADER_ENV.test(k))
+            out[k] = v;
+    return out;
+}
+function toolsFrom(result) {
+    const r = (result ?? {});
+    const tools = Array.isArray(r.tools) ? r.tools.filter((t) => t && typeof t === 'object') : [];
+    return { tools, next: typeof r.nextCursor === 'string' && r.nextCursor ? r.nextCursor : undefined };
+}
+function serverInfo(result) {
+    const info = (result ?? {}).serverInfo ?? {};
+    return {
+        name: typeof info.name === 'string' ? info.name.slice(0, 80) : undefined,
+        version: typeof info.version === 'string' ? info.version.slice(0, 40) : undefined,
+    };
+}
+function finish(started, now, parts) {
+    return { ok: false, ms: now() - started, tools: [], toolBytes: 0, ...parts };
+}
+export async function probeStdio(spec, deps = {}) {
+    const now = deps.now ?? (() => Date.now());
+    const started = now();
+    if (!spec.command)
+        return finish(started, now, { error: 'no command in the config' });
+    const spawnImpl = deps.spawnImpl ?? ((cmd, args, opts) => nodeSpawn(cmd, args, { ...opts, stdio: ['pipe', 'pipe', 'ignore'], shell: process.platform === 'win32' }));
+    const timeoutMs = deps.timeoutMs ?? 45_000;
+    let child;
+    try {
+        child = spawnImpl(spec.command, spec.args, { cwd: spec.cwd, env: { ...process.env, ...safeConfigEnv(spec.env) } });
+    }
+    catch {
+        return finish(started, now, { error: `could not start "${spec.command}"` });
+    }
+    return new Promise((resolve) => {
+        let done = false;
+        let buf = '';
+        let nextId = 1;
+        const waiting = new Map();
+        const end = (r) => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timer);
+            try {
+                child.stdin?.end();
+            }
+            catch { }
+            try {
+                child.kill('SIGTERM');
+            }
+            catch { }
+            resolve(r);
+        };
+        const timer = setTimeout(() => end(finish(started, now, { error: `no answer within ${Math.round(timeoutMs / 1000)}s` })), timeoutMs);
+        child.on('error', () => end(finish(started, now, { error: `could not start "${spec.command}"` })));
+        child.on('exit', (code) => end(finish(started, now, { error: `it exited (code ${code ?? '?'}) before answering` })));
+        child.stdout?.setEncoding('utf-8');
+        child.stdout?.on('data', (chunk) => {
+            buf += chunk;
+            if (buf.length > 8_000_000)
+                return end(finish(started, now, { error: 'answer too large' }));
+            let nl;
+            while ((nl = buf.indexOf('\n')) >= 0) {
+                const line = buf.slice(0, nl).trim();
+                buf = buf.slice(nl + 1);
+                if (!line)
+                    continue;
+                let msg;
+                try {
+                    msg = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                if (typeof msg.id === 'number' && waiting.has(msg.id)) {
+                    const cb = waiting.get(msg.id);
+                    waiting.delete(msg.id);
+                    cb(msg);
+                }
+            }
+        });
+        const send = (method, params) => new Promise((res) => {
+            const id = nextId++;
+            waiting.set(id, res);
+            child.stdin?.write(JSON.stringify({ jsonrpc: '2.0', id, method, ...(params ? { params } : {}) }) + '\n');
+        });
+        const notify = (method) => child.stdin?.write(JSON.stringify({ jsonrpc: '2.0', method }) + '\n');
+        (async () => {
+            const init = await send('initialize', INIT_PARAMS);
+            if (init.error)
+                return end(finish(started, now, { error: 'it refused the handshake' }));
+            const info = serverInfo(init.result);
+            notify('notifications/initialized');
+            const all = [];
+            let cursor;
+            for (let page = 0; page < 20; page++) {
+                const res = await send('tools/list', cursor ? { cursor } : undefined);
+                if (res.error)
+                    return end(finish(started, now, { serverName: info.name, serverVersion: info.version, error: 'tools/list failed' }));
+                const { tools, next } = toolsFrom(res.result);
+                all.push(...tools);
+                if (!next)
+                    break;
+                cursor = next;
+            }
+            end({
+                ok: true,
+                ms: now() - started,
+                serverName: info.name,
+                serverVersion: info.version,
+                tools: all.map((t) => ({ name: String(t.name ?? '') })).filter((t) => t.name),
+                toolBytes: Buffer.byteLength(JSON.stringify({ tools: all })),
+            });
+        })().catch(() => end(finish(started, now, { error: 'unexpected answer' })));
+    });
+}
+export async function probeRemote(spec, deps = {}) {
+    const now = deps.now ?? (() => Date.now());
+    const fetchImpl = deps.fetchImpl ?? fetch;
+    const started = now();
+    if (!spec.url)
+        return finish(started, now, { error: 'no url in the config' });
+    const headers = {
+        'Content-Type': 'application/json',
+        Accept: 'application/json, text/event-stream',
+        ...spec.headers,
+    };
+    if (!Object.keys(headers).some((k) => k.toLowerCase() === 'authorization') && deps.fallbackBearer && isNonbotRemoteUrl(spec.url)) {
+        headers.Authorization = `Bearer ${deps.fallbackBearer}`;
+    }
+    let nextId = 1;
+    const call = async (method, params, isNotification = false) => {
+        const body = isNotification
+            ? { jsonrpc: '2.0', method }
+            : { jsonrpc: '2.0', id: nextId++, method, ...(params ? { params } : {}) };
+        const res = await fetchImpl(spec.url, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(body),
+            redirect: 'manual',
+            signal: AbortSignal.timeout(deps.timeoutMs ?? 15_000),
+        });
+        const session = res.headers.get('mcp-session-id');
+        if (session)
+            headers['Mcp-Session-Id'] = session;
+        if (isNotification)
+            return null;
+        if (res.status === 401 || res.status === 403)
+            throw new Error(`auth ${res.status}`);
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status}`);
+        const text = await res.text();
+        if ((res.headers.get('content-type') ?? '').includes('text/event-stream')) {
+            for (const line of text.split('\n')) {
+                if (!line.startsWith('data:'))
+                    continue;
+                try {
+                    const msg = JSON.parse(line.slice(5).trim());
+                    if (msg.result !== undefined || msg.error)
+                        return msg;
+                }
+                catch { }
+            }
+            return { error: { message: 'no result' } };
+        }
+        return JSON.parse(text);
+    };
+    try {
+        const init = await call('initialize', INIT_PARAMS);
+        if (!init || init.error)
+            return finish(started, now, { error: 'it refused the handshake' });
+        const info = serverInfo(init.result);
+        await call('notifications/initialized', undefined, true).catch(() => null);
+        const all = [];
+        let cursor;
+        for (let page = 0; page < 20; page++) {
+            const res = await call('tools/list', cursor ? { cursor } : undefined);
+            if (!res || res.error)
+                return finish(started, now, { serverName: info.name, serverVersion: info.version, error: 'tools/list failed' });
+            const { tools, next } = toolsFrom(res.result);
+            all.push(...tools);
+            if (!next)
+                break;
+            cursor = next;
+        }
+        return {
+            ok: true,
+            ms: now() - started,
+            serverName: info.name,
+            serverVersion: info.version,
+            tools: all.map((t) => ({ name: String(t.name ?? '') })).filter((t) => t.name),
+            toolBytes: Buffer.byteLength(JSON.stringify({ tools: all })),
+        };
+    }
+    catch (e) {
+        const m = e.message;
+        return finish(started, now, { error: /^auth/.test(m) ? 'the server refused the token' : /^HTTP/.test(m) ? `the server answered ${m}` : 'could not reach it' });
+    }
+}
+export function probeMcp(spec, deps = {}) {
+    return spec.url && !spec.command ? probeRemote(spec, deps) : probeStdio(spec, deps);
+}
+export function toolGroups(tools) {
+    const counts = new Map();
+    for (const t of tools) {
+        const g = t.name.includes('_') ? t.name.slice(0, t.name.indexOf('_')) : t.name;
+        counts.set(g, (counts.get(g) ?? 0) + 1);
+    }
+    return [...counts.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
+}
+export function estimateTokens(bytes) {
+    return Math.round(bytes / 4);
+}

package/dist/lib/mcp-trust.js

@@ -0,0 +1,63 @@
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, realpathSync, renameSync, writeFileSync, chmodSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+function configDir() {
+    const override = process.env.NONBOT_CONFIG_DIR;
+    return override && override.length > 0 ? override : join(homedir(), '.config', 'nonbot');
+}
+export function trustFilePath(dir = configDir()) {
+    return join(dir, 'mcp-trust.json');
+}
+function realDir(dir) {
+    try {
+        return realpathSync(dir);
+    }
+    catch {
+        return dir;
+    }
+}
+export function launchFingerprint(spec) {
+    const env = Object.keys(spec.env).sort().map((k) => [k, spec.env[k]]);
+    const payload = JSON.stringify({ command: spec.command ?? null, args: spec.args, url: spec.url ?? null, env, cwd: realDir(spec.cwd) });
+    return createHash('sha256').update(payload).digest('hex');
+}
+function readRecords(file) {
+    try {
+        if (!existsSync(file))
+            return [];
+        const json = JSON.parse(readFileSync(file, 'utf-8'));
+        return Array.isArray(json.approved)
+            ? json.approved.filter((r) => r && typeof r === 'object' && typeof r.fingerprint === 'string')
+            : [];
+    }
+    catch {
+        return [];
+    }
+}
+export function isRememberedTrust(entry, spec, file = trustFilePath()) {
+    if (!entry.dir)
+        return false;
+    const dir = realDir(entry.dir);
+    const fp = launchFingerprint(spec);
+    return readRecords(file).some((r) => r.dir === dir && r.name === entry.name && r.fingerprint === fp);
+}
+export function mayStartEntry(entry, spec, isRemembered = (e, s) => isRememberedTrust(e, s)) {
+    if (entry.approved !== false)
+        return true;
+    return isRemembered(entry, spec);
+}
+export function rememberTrust(entry, spec, file = trustFilePath(), now = new Date()) {
+    if (!entry.dir)
+        return;
+    const dir = realDir(entry.dir);
+    const records = readRecords(file).filter((r) => !(r.dir === dir && r.name === entry.name));
+    records.push({ dir, name: entry.name, fingerprint: launchFingerprint(spec), approvedAt: now.toISOString() });
+    const parent = join(file, '..');
+    mkdirSync(parent, { recursive: true, mode: 0o700 });
+    const tmp = `${file}.tmp`;
+    writeFileSync(tmp, JSON.stringify({ approved: records.slice(-200) }, null, 2) + '\n', { mode: 0o600 });
+    chmodSync(tmp, 0o600);
+    renameSync(tmp, file);
+    chmodSync(file, 0o600);
+}