fauxnix-cli 0.9.3 → 0.12.0

package/dist/commands/text-filters.d.ts

@@ -1,3 +1,4 @@
 import { CommandSpec, Handler } from '../registry.js';
 export declare const specs: CommandSpec[];
+/** sed/awk stay unspec'd (custom script parsers). egrep injects -E and stays its own handler. */
 export declare const handlers: Record<string, Handler>;

package/dist/commands/text-filters.js

@@ -3,7 +3,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { FauxnixParseError, wordToString } from '../ast.js';
 import { parseWords, psStr } from '../registry.js';
-import { argListExpr, exprOfWord, literalOfWord, operandExpr } from '../translator.js';
+import { argListExpr, exprOfWord, literalOfWord, operandExpr, PURE_SED_FILE_MESSAGE, } from '../translator.js';
 /* ------------------------------------------------------------------ */
 /* Shared PS snippets (same shape as files.ts)                         */
 /* ------------------------------------------------------------------ */
@@ -981,7 +981,7 @@ function parseSedScript(src, isEre) {
     }
     return out;
 }
-const sed = (args) => {
+const sed = (args, ctx) => {
     // custom argv parse: -i takes an ATTACHED suffix; -e/-f take attached or next
     const raw = args.map((w) => wordToString(w));
     let noPrint = false;
@@ -1030,6 +1030,9 @@ const sed = (args) => {
                         throw new FauxnixParseError('fauxnix: sed -' + ch + ' requires an argument');
                     }
                     if (ch === 'f') {
+                        if (ctx.translationMode === 'pure') {
+                            throw new FauxnixParseError(PURE_SED_FILE_MESSAGE);
+                        }
                         try {
                             val = readFileSync(nodePathOf(val), 'utf8');
                         }
@@ -1775,20 +1778,42 @@ const awk = (args) => {
     const { values, operandWords } = parseWords(args, ['F', 'v']);
     // -v may repeat; collect all of them
     const vvars = [];
+    const addVVar = (nv) => {
+        const eq = nv.indexOf('=');
+        if (eq < 1) {
+            throw new FauxnixParseError("fauxnix: awk invalid -v assignment '" + nv + "'");
+        }
+        const name = nv.slice(0, eq);
+        if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) {
+            throw new FauxnixParseError("fauxnix: awk invalid variable name '" + name + "'");
+        }
+        vvars.push([name, nv.slice(eq + 1)]);
+    };
+    let onlyOperands = false;
     for (let i = 0; i < args.length; i++) {
         const t = wordToString(args[i]);
-        if (t === '-v' && i + 1 < args.length) {
-            const nv = wordToString(args[i + 1]);
-            const eq = nv.indexOf('=');
-            if (eq > 0)
-                vvars.push([nv.slice(0, eq), nv.slice(eq + 1)]);
+        if (t === '--') {
+            onlyOperands = true;
+            continue;
+        }
+        if (onlyOperands)
+            continue;
+        if (t === '-F') {
+            if (i + 1 < args.length)
+                i++;
+            continue;
+        }
+        if (t.startsWith('-F') && t.length > 2)
+            continue;
+        if (t === '-v') {
+            if (i + 1 >= args.length) {
+                throw new FauxnixParseError('fauxnix: awk -v requires an argument');
+            }
+            addVVar(wordToString(args[i + 1]));
             i++;
         }
         else if (t.startsWith('-v') && t.length > 2) {
-            const nv = t.slice(2);
-            const eq = nv.indexOf('=');
-            if (eq > 0)
-                vvars.push([nv.slice(0, eq), nv.slice(eq + 1)]);
+            addVVar(t.slice(2));
         }
     }
     if (operandWords.length === 0) {
@@ -2289,8 +2314,9 @@ function parseCutList(list) {
 const cut = (args) => {
     const { flags, longs, values, operandWords } = parseWords(args, ['d', 'f', 'c', 'b'], []);
     const complement = longs.has('--complement');
-    const charsMode = flags.has('c') || flags.has('b');
-    const fieldsMode = flags.has('f');
+    // -f/-c/-b are value-taking; parseWords records them in `values`, not `flags`.
+    const charsMode = values.has('-c') || values.has('-b');
+    const fieldsMode = values.has('-f');
     const suppress = flags.has('s');
     if (charsMode && fieldsMode) {
         throw new FauxnixParseError('fauxnix: cut only one type of list may be specified');
@@ -2527,7 +2553,67 @@ export const specs = [
         usageExit: 2,
         handler: grep,
     },
+    {
+        names: ['sort'],
+        options: [
+            { short: 'r', long: '--reverse', support: 'implemented' },
+            { short: 'n', long: '--numeric-sort', support: 'implemented' },
+            { short: 'u', long: '--unique', support: 'implemented' },
+            { short: 'f', long: '--ignore-case', support: 'implemented' },
+            { short: 'b', long: '--ignore-leading-blanks', support: 'implemented' },
+            { short: 't', takesValue: true, support: 'implemented' },
+            { short: 'k', takesValue: true, support: 'implemented' },
+            { short: 'z', long: '--zero-terminated', support: 'unsupported', reason: 'NUL-terminated records' },
+        ],
+        effects: ['read'],
+        platform: 'windows-ps51',
+        dispatch: 'translated',
+        usageExit: 2,
+        handler: sort,
+    },
+    {
+        names: ['uniq'],
+        options: [
+            { short: 'c', support: 'implemented' },
+            { short: 'd', support: 'implemented' },
+            { short: 'u', support: 'implemented' },
+            { short: 'i', support: 'implemented' },
+        ],
+        effects: ['read'],
+        platform: 'windows-ps51',
+        dispatch: 'translated',
+        handler: uniq,
+    },
+    {
+        names: ['cut'],
+        options: [
+            { short: 'd', takesValue: true, support: 'implemented' },
+            { short: 'f', takesValue: true, support: 'implemented' },
+            { short: 'c', takesValue: true, support: 'implemented' },
+            { short: 'b', takesValue: true, support: 'implemented' },
+            { short: 's', support: 'implemented' },
+            { long: '--complement', support: 'implemented' },
+        ],
+        effects: ['read'],
+        platform: 'windows-ps51',
+        dispatch: 'translated',
+        handler: cut,
+    },
+    {
+        names: ['tr'],
+        options: [
+            { short: 'd', support: 'implemented' },
+            { short: 's', support: 'implemented' },
+            { short: 'c', long: '--complement', support: 'unsupported', reason: 'complement' },
+            { short: 'C', support: 'unsupported', reason: 'complement' },
+        ],
+        effects: ['read'],
+        platform: 'windows-ps51',
+        dispatch: 'translated',
+        handler: tr,
+    },
 ];
+/** sed/awk stay unspec'd (custom script parsers). egrep injects -E and stays its own handler. */
 export const handlers = {
     egrep: (args, ctx) => grep([[{ kind: 'Text', text: '-E' }], ...args], ctx), // egrep = grep -E
     sed,

package/dist/commands/text-io.js

@@ -523,6 +523,20 @@ const head = (args, ctx) => {
 /* ------------------------------------------------------------------ */
 /* tail                                                                */
 /* ------------------------------------------------------------------ */
+/** A count embedded in generated PS must be a canonical Int32 literal. */
+function tailCountLiteral(raw) {
+    if (!/^[+-]?\d+$/.test(raw))
+        return null;
+    try {
+        const n = BigInt(raw.replace(/^[+-]/, ''));
+        if (n > 2147483647n)
+            return null;
+        return n.toString();
+    }
+    catch {
+        return null;
+    }
+}
 const tail = (args, ctx) => {
     const pre = parseWords(args);
     if (pre.flags.has('f') || pre.flags.has('F')) {
@@ -533,9 +547,35 @@ const tail = (args, ctx) => {
     let nLines = null;
     let fromLine = null;
     let nBytes = null;
+    let fromByte = false;
     const operandWords = [];
     let quiet = false;
     let verbose = false;
+    const setCount = (kind, raw) => {
+        const literal = tailCountLiteral(raw);
+        if (literal === null) {
+            return psErrExpr(psStr("tail: invalid number of " + kind + ": '" + raw + "'"));
+        }
+        if (kind === 'bytes') {
+            nBytes = literal;
+            fromByte = raw.startsWith('+');
+            nLines = null;
+            fromLine = null;
+        }
+        else {
+            nBytes = null;
+            fromByte = false;
+            if (raw.startsWith('+')) {
+                fromLine = literal;
+                nLines = null;
+            }
+            else {
+                nLines = literal;
+                fromLine = null;
+            }
+        }
+        return null;
+    };
     {
         let i = 0;
         let onlyOps = false;
@@ -567,12 +607,9 @@ const tail = (args, ctx) => {
                     else {
                         i++;
                     }
-                    if (name === '--bytes')
-                        nBytes = val;
-                    else if (val.startsWith('+'))
-                        fromLine = val.slice(1);
-                    else
-                        nLines = val.replace(/^-/, '');
+                    const err = setCount(name === '--bytes' ? 'bytes' : 'lines', val);
+                    if (err !== null)
+                        return err;
                     continue;
                 }
                 if (name === '--quiet' || name === '--silent') {
@@ -589,49 +626,45 @@ const tail = (args, ctx) => {
                 continue;
             }
             let m;
-            if (t === '-n' || t === '-c') {
-                const val = i + 1 < args.length ? wordToString(args[i + 1]) : null;
-                if (val === null) {
-                    return psErrExpr(psStr('tail: option requires an argument -- ' + t.slice(1)));
-                }
-                if (t === '-c')
-                    nBytes = val;
-                else if (val.startsWith('+'))
-                    fromLine = val.slice(1);
-                else
-                    nLines = val.replace(/^-/, ''); // -n -N ≡ -n N (last N)
-                i += 2;
-                continue;
-            }
-            if ((m = t.match(/^-[nc](.*)$/)) !== null) {
-                const val = m[1];
-                if (t[1] === 'c')
-                    nBytes = val;
-                else if (val.startsWith('+'))
-                    fromLine = val.slice(1);
-                else
-                    nLines = val.replace(/^-/, '');
-                i++;
-                continue;
-            }
             if ((m = t.match(/^-(\d+)$/)) !== null) {
-                nLines = m[1];
+                const err = setCount('lines', t);
+                if (err !== null)
+                    return err;
                 i++;
                 continue;
             }
             if ((m = t.match(/^\+(\d+)$/)) !== null) {
-                fromLine = m[1];
+                const err = setCount('lines', t);
+                if (err !== null)
+                    return err;
                 i++;
                 continue;
             }
             if (t.startsWith('-') && t.length > 1) {
-                for (const ch of t.slice(1)) {
+                const body = t.slice(1);
+                let usedNext = false;
+                for (let c = 0; c < body.length; c++) {
+                    const ch = body[c];
                     if (ch === 'q')
                         quiet = true;
                     else if (ch === 'v')
                         verbose = true;
+                    else if (ch === 'n' || ch === 'c') {
+                        let val = body.slice(c + 1);
+                        if (val === '') {
+                            if (i + 1 >= args.length) {
+                                return psErrExpr(psStr('tail: option requires an argument -- ' + ch));
+                            }
+                            val = wordToString(args[i + 1]);
+                            usedNext = true;
+                        }
+                        const err = setCount(ch === 'c' ? 'bytes' : 'lines', val);
+                        if (err !== null)
+                            return err;
+                        break;
+                    }
                 }
-                i++;
+                i += usedNext ? 2 : 1;
                 continue;
             }
             operandWords.push(args[i]);
@@ -639,13 +672,7 @@ const tail = (args, ctx) => {
         }
     }
     const bytesMode = nBytes !== null;
-    const countLit = bytesMode
-        ? nBytes
-        : fromLine !== null
-            ? fromLine
-            : nLines !== null
-                ? nLines
-                : '10';
+    const countLit = bytesMode ? nBytes : fromLine ?? nLines ?? '10';
     const lines = [
         PS_GLOB_FN,
         PS_READTEXT_FN,
@@ -659,7 +686,9 @@ const tail = (args, ctx) => {
         lines.push(STDIN_INLINES);
     lines.push(...psCollectFiles(operandWords, (g) => qErr('tail', g, 'No such file or directory'), (g) => qErr('tail', g, 'Is a directory', 'error reading ')), '$fx_count = [int](' + countLit + ')', '$fx_from = ' + pb(fromLine !== null && !bytesMode), '$fx_hdr = ((($fx_srcs.Count -gt 1) -and ' + pb(!quiet) + ') -or ' + pb(verbose) + ')', '$fx_first = $true');
     if (bytesMode) {
-        lines.push('$fx_out = New-Object System.Text.StringBuilder', 'for ($fx_k = 0; $fx_k -lt $fx_srcs.Count; $fx_k++) {', '  $fx_g = $fx_srcs[$fx_k]', "  if ($fx_g -eq '-') { $fx_txt = (fx-stdinraw $fx_items); $fx_disp = 'standard input' }", '  else { $fx_txt = fx-read $fx_g; $fx_disp = $fx_names[$fx_k] }', '  if ($fx_hdr) {', '    if (-not $fx_first) { [void]$fx_out.Append([string][char]10) }', "    [void]$fx_out.Append('==> ' + $fx_disp + ' <==' + [string][char]10)", '  }', '  $fx_first = $false', '  $fx_st = $fx_txt.Length - $fx_count', '  if ($fx_st -lt 0) { $fx_st = 0 }', '  if ($fx_st -lt $fx_txt.Length) { [void]$fx_out.Append($fx_txt.Substring($fx_st)) }', '}', 'fx-write $fx_out.ToString() $fx_term');
+        lines.push('$fx_out = New-Object System.Text.StringBuilder', 'for ($fx_k = 0; $fx_k -lt $fx_srcs.Count; $fx_k++) {', '  $fx_g = $fx_srcs[$fx_k]', "  if ($fx_g -eq '-') { $fx_txt = (fx-stdinraw $fx_items); $fx_disp = 'standard input' }", '  else { $fx_txt = fx-read $fx_g; $fx_disp = $fx_names[$fx_k] }', '  if ($fx_hdr) {', '    if (-not $fx_first) { [void]$fx_out.Append([string][char]10) }', "    [void]$fx_out.Append('==> ' + $fx_disp + ' <==' + [string][char]10)", '  }', '  $fx_first = $false', fromByte
+            ? '  $fx_st = $fx_count - 1'
+            : '  $fx_st = $fx_txt.Length - $fx_count', '  if ($fx_st -lt 0) { $fx_st = 0 }', '  if ($fx_st -lt $fx_txt.Length) { [void]$fx_out.Append($fx_txt.Substring($fx_st)) }', '}', 'fx-write $fx_out.ToString() $fx_term');
     }
     else {
         lines.push('for ($fx_k = 0; $fx_k -lt $fx_srcs.Count; $fx_k++) {', '  $fx_g = $fx_srcs[$fx_k]', "  if ($fx_g -eq '-') { $fx_ls = @($fx_in); $fx_disp = 'standard input' }", '  else { $fx_ls = @(fx-splitlines (fx-read $fx_g)); $fx_disp = $fx_names[$fx_k] }', '  if ($fx_hdr) {', "    if (-not $fx_first) { '' }", "    '==> ' + $fx_disp + ' <=='", '  }', '  $fx_first = $false', '  if ($fx_from) {', '    $fx_st = $fx_count - 1', '    if ($fx_st -lt 0) { $fx_st = 0 }', '  } else {', '    $fx_st = $fx_ls.Count - $fx_count', '    if ($fx_st -lt 0) { $fx_st = 0 }', '  }', '  for ($fx_i = $fx_st; $fx_i -lt $fx_ls.Count; $fx_i++) { $fx_ls[$fx_i] }', '}');

package/dist/doctor.d.ts

@@ -0,0 +1,21 @@
+export type DoctorOptions = {
+    home?: string;
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    nodeVersion?: string;
+    /** Injected MCP-module loader. Default: dynamic import of ./mcp.js (does not start the server). */
+    loadMcp?: () => Promise<unknown>;
+};
+export type DoctorReport = {
+    lines: string[];
+    ok: boolean;
+};
+export declare function collectDoctorReport(opts?: DoctorOptions): Promise<DoctorReport>;
+export declare function claudeUserConfigPath(home: string, env: NodeJS.ProcessEnv): string;
+export declare function codexConfigPath(home: string, env: NodeJS.ProcessEnv): string;
+export declare function openCodeConfigPath(home: string, env: NodeJS.ProcessEnv): string;
+export declare function hasCodexFauxnix(text: string): boolean;
+export declare function hasOpenCodeFauxnix(data: unknown): boolean;
+export declare function isServerMap(value: unknown): boolean;
+export declare function serverMapHasFauxnix(value: unknown): boolean;
+export declare function fauxnixServerNames(value: unknown): string[];

package/dist/doctor.js

@@ -0,0 +1,292 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { resolveQwenLaunchTuple, sameQwenLaunchTuple } from './qwen-launch.js';
+const VALUE_INDENT = '             ';
+export async function collectDoctorReport(opts = {}) {
+    const home = opts.home ?? homedir();
+    const cwd = opts.cwd ?? process.cwd();
+    const env = opts.env ?? process.env;
+    const nodeVersion = opts.nodeVersion ?? process.version;
+    const lines = [''];
+    lines.push(...encodingLines(env));
+    lines.push('');
+    lines.push(field('claude', detectClaude(home, cwd, env)));
+    lines.push(field('codex', detectCodex(home, env)));
+    lines.push(field('opencode', detectOpenCode(home, env)));
+    lines.push(field('qwen', detectQwen(home)));
+    lines.push('');
+    const mcp = await mcpLines(nodeVersion, opts.loadMcp);
+    lines.push(...mcp.lines);
+    return { lines, ok: mcp.ok };
+}
+function field(label, value) {
+    return `${label.padEnd(10)} : ${value}`;
+}
+function encodingLines(env) {
+    const raw = env.FAUXNIX_NATIVE_ENCODING;
+    const current = raw === undefined || raw === ''
+        ? 'unset → utf8 (default)'
+        : raw === 'ansi'
+            ? 'ansi → GBK-native admin tools'
+            : `${raw} → utf8 (only ansi selects GBK)`;
+    return [
+        field('encoding', 'UTF-8 default for native-tool pipelines'),
+        VALUE_INDENT + `current FAUXNIX_NATIVE_ENCODING=${current}`,
+        VALUE_INDENT + 'set FAUXNIX_NATIVE_ENCODING=ansi for GBK-native admin tools (ipconfig, tasklist)',
+    ];
+}
+function detectClaude(home, cwd, env) {
+    const userPath = claudeUserConfigPath(home, env);
+    const projectPath = join(cwd, '.mcp.json');
+    const userExists = existsSync(userPath);
+    const projectExists = existsSync(projectPath);
+    let user;
+    let project;
+    if (userExists)
+        user = inspectClaudeJson(userPath);
+    if (projectExists) {
+        const inspected = inspectClaudeJson(projectPath);
+        // Project-scope Claude MCP is always a top-level mcpServers object.
+        if (!inspected.parseError && inspected.hasTopLevelMcpServers)
+            project = inspected;
+    }
+    if (!userExists && !project)
+        return 'not detected — see README';
+    if (user?.hasFauxnix)
+        return `fauxnix MCP configured (${userPath})`;
+    if (project?.hasFauxnix)
+        return `fauxnix MCP configured (${projectPath})`;
+    if (userExists && user?.parseError) {
+        return `found ${userPath} (unreadable JSON) — see README`;
+    }
+    if (userExists) {
+        return `found ${userPath}, fauxnix MCP not listed — run: claude mcp add fauxnix -- fauxnix mcp`;
+    }
+    return `found ${projectPath}, fauxnix MCP not listed — see README`;
+}
+export function claudeUserConfigPath(home, env) {
+    const dir = env.CLAUDE_CONFIG_DIR?.trim();
+    if (dir)
+        return join(dir, '.claude.json');
+    return join(home, '.claude.json');
+}
+export function codexConfigPath(home, env) {
+    const codexHome = env.CODEX_HOME?.trim() || join(home, '.codex');
+    return join(codexHome, 'config.toml');
+}
+export function openCodeConfigPath(home, env) {
+    const xdg = env.XDG_CONFIG_HOME?.trim() || join(home, '.config');
+    return join(xdg, 'opencode', 'opencode.json');
+}
+function inspectClaudeJson(path) {
+    const text = readText(path);
+    if (text === undefined) {
+        return { parseError: true, hasTopLevelMcpServers: false, hasFauxnix: false };
+    }
+    let data;
+    try {
+        data = JSON.parse(stripBom(text));
+    }
+    catch {
+        return { parseError: true, hasTopLevelMcpServers: false, hasFauxnix: false };
+    }
+    if (!data || typeof data !== 'object' || Array.isArray(data)) {
+        return { parseError: true, hasTopLevelMcpServers: false, hasFauxnix: false };
+    }
+    const rec = data;
+    const hasTopLevelMcpServers = isServerMap(rec.mcpServers);
+    let hasFauxnix = hasTopLevelMcpServers && serverMapHasFauxnix(rec.mcpServers);
+    const projects = rec.projects;
+    if (projects && typeof projects === 'object' && !Array.isArray(projects)) {
+        for (const proj of Object.values(projects)) {
+            if (!proj || typeof proj !== 'object' || Array.isArray(proj))
+                continue;
+            const servers = proj.mcpServers;
+            if (isServerMap(servers) && serverMapHasFauxnix(servers))
+                hasFauxnix = true;
+        }
+    }
+    return { parseError: false, hasTopLevelMcpServers, hasFauxnix };
+}
+function detectCodex(home, env) {
+    const path = codexConfigPath(home, env);
+    if (!existsSync(path))
+        return 'not detected — see README';
+    const text = readText(path);
+    if (text === undefined)
+        return `found ${path} (unreadable) — see README`;
+    if (hasCodexFauxnix(stripBom(text)))
+        return `fauxnix MCP configured (${path})`;
+    return `found ${path}, fauxnix MCP not listed — run: codex mcp add fauxnix -- fauxnix mcp`;
+}
+export function hasCodexFauxnix(text) {
+    if (/^\s*\[mcp_servers\.(?:fauxnix|"fauxnix"|'fauxnix')\]/im.test(text))
+        return true;
+    const tables = text.split(/^\s*\[/m);
+    for (const table of tables) {
+        if (!/^mcp_servers\./i.test(table))
+            continue;
+        const header = (table.split(/[\]\r\n]/, 1)[0] ?? '').trim();
+        if (/^mcp_servers\.(?:fauxnix|"fauxnix"|'fauxnix')$/i.test(header))
+            return true;
+        const cmd = /^\s*command\s*=\s*(?:"([^"]*)"|'([^']*)')/im.exec(table);
+        const command = cmd?.[1] ?? cmd?.[2];
+        if (command && isFauxnixExecutable(command))
+            return true;
+        const args = /^\s*args\s*=\s*\[([^\]]*)\]/im.exec(table);
+        if (args) {
+            const items = [...args[1].matchAll(/"([^"]*)"|'([^']*)'/g)].map((m) => m[1] ?? m[2] ?? '');
+            if (items.some(isFauxnixExecutable))
+                return true;
+        }
+    }
+    return false;
+}
+function detectOpenCode(home, env) {
+    const path = openCodeConfigPath(home, env);
+    if (!existsSync(path))
+        return 'not detected — see README';
+    const text = readText(path);
+    if (text === undefined)
+        return `found ${path} (unreadable) — see README`;
+    let data;
+    try {
+        data = JSON.parse(stripBom(text));
+    }
+    catch {
+        return `found ${path} (unreadable JSON) — see README`;
+    }
+    if (hasOpenCodeFauxnix(data))
+        return `fauxnix MCP configured (${path})`;
+    return `found ${path}, fauxnix MCP not listed — add mcp.fauxnix (see README)`;
+}
+function detectQwen(home) {
+    const path = join(home, '.qwen', 'settings.json');
+    if (!existsSync(path))
+        return 'not detected — see README';
+    const text = readText(path);
+    if (text === undefined)
+        return `found ${path} (unreadable) — see README`;
+    let data;
+    try {
+        data = JSON.parse(stripBom(text));
+    }
+    catch {
+        return `found ${path} (unreadable JSON) — see README`;
+    }
+    if (!data || typeof data !== 'object' || Array.isArray(data)) {
+        return `found ${path} (not a JSON object) — see README`;
+    }
+    const servers = data.mcpServers;
+    if (!isServerMap(servers)) {
+        return `found ${path}, fauxnix MCP not listed — run: fauxnix install --qwen`;
+    }
+    const extraNames = fauxnixServerNames(servers).filter((name) => name !== 'fauxnix');
+    if (extraNames.length) {
+        return `found ${path}, additional fauxnix MCP entries (${extraNames.join(', ')}) — remove them, then run: fauxnix install --qwen`;
+    }
+    const config = servers.fauxnix;
+    const expected = resolveQwenLaunchTuple();
+    if (expected.ok && sameQwenLaunchTuple(config, expected.value)) {
+        return `fauxnix MCP configured with an absolute launcher (${path})`;
+    }
+    if (config != null || serverMapHasFauxnix(servers)) {
+        return `found ${path}, fauxnix MCP launcher does not match this installation — run: fauxnix install --qwen`;
+    }
+    return `found ${path}, fauxnix MCP not listed — run: fauxnix install --qwen`;
+}
+export function hasOpenCodeFauxnix(data) {
+    if (!data || typeof data !== 'object' || Array.isArray(data))
+        return false;
+    const mcp = data.mcp;
+    if (!isServerMap(mcp))
+        return false;
+    if (serverMapHasFauxnix(mcp))
+        return true;
+    const nested = mcp.servers;
+    return isServerMap(nested) && serverMapHasFauxnix(nested);
+}
+export function isServerMap(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+export function serverMapHasFauxnix(value) {
+    return fauxnixServerNames(value).length > 0;
+}
+export function fauxnixServerNames(value) {
+    if (!isServerMap(value))
+        return [];
+    const names = [];
+    for (const [name, cfg] of Object.entries(value)) {
+        if (name === 'servers')
+            continue;
+        if (looksLikeFauxnixServer(name, cfg))
+            names.push(name);
+    }
+    return names;
+}
+function looksLikeFauxnixServer(name, cfg) {
+    if (/^fauxnix(-cli)?$/i.test(name))
+        return true;
+    if (!cfg || typeof cfg !== 'object' || Array.isArray(cfg))
+        return false;
+    const rec = cfg;
+    const chunks = [];
+    if (typeof rec.command === 'string')
+        chunks.push(rec.command);
+    if (Array.isArray(rec.command)) {
+        for (const part of rec.command)
+            if (typeof part === 'string')
+                chunks.push(part);
+    }
+    if (Array.isArray(rec.args)) {
+        for (const part of rec.args)
+            if (typeof part === 'string')
+                chunks.push(part);
+    }
+    return chunks.some(isFauxnixExecutable);
+}
+function isFauxnixExecutable(s) {
+    const base = s.replace(/\\/g, '/').split('/').pop()?.trim() ?? '';
+    return /^fauxnix(-cli)?(\.cmd|\.exe)?$/i.test(base);
+}
+async function mcpLines(nodeVersion, loadMcp) {
+    const major = nodeMajor(nodeVersion);
+    const nodeOk = major >= 18;
+    let moduleOk = false;
+    let moduleDetail = '';
+    try {
+        const mod = await (loadMcp ?? defaultLoadMcp)();
+        moduleOk =
+            !!mod && typeof mod.startMcpServer === 'function';
+        if (!moduleOk)
+            moduleDetail = 'startMcpServer export missing';
+    }
+    catch (e) {
+        moduleDetail = e instanceof Error ? e.message : String(e);
+    }
+    const lines = [
+        field('node', `${nodeVersion.startsWith('v') ? nodeVersion : 'v' + nodeVersion}${nodeOk ? ' (>=18 required)' : '  FAILED (requires >=18)'}`),
+        field('mcp', moduleOk ? 'module loads' : `FAILED to load${moduleDetail ? ': ' + moduleDetail : ''}`),
+        VALUE_INDENT + 'start with: fauxnix mcp',
+    ];
+    return { lines, ok: nodeOk && moduleOk };
+}
+async function defaultLoadMcp() {
+    return import('./mcp.js');
+}
+function nodeMajor(version) {
+    const m = /^v?(\d+)/.exec(version);
+    return m ? Number(m[1]) : 0;
+}
+function stripBom(text) {
+    return text.charCodeAt(0) === 0xfeff ? text.slice(1) : text;
+}
+function readText(path) {
+    try {
+        return readFileSync(path, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+}