moshcode 0.62.0 → 0.64.0

package/README.md

@@ -991,10 +991,14 @@ moshcode mcp catalog              # what we know how to run
 moshcode mcp add porkbun          # expands to: npx -y @porkbunllc/mcp-server
 ```
 
-That registers it across every engine that supports MCP (claude, gemini, codex,
-opencode, privacycode) in one go. Kimi is skipped with a reason: it runs MCP
-servers but has no command to register one from a script — add those in-session
-with its own `/mcp-config`, or in `~/.kimi-code/mcp.json`.
+That registers it across every engine that supports MCP (claude, gemini, qwen,
+codex, opencode, privacycode) in one go. Kimi is skipped with a reason: it runs
+MCP servers but has no command to register one from a script — add those
+in-session with its own `/mcp-config`, or in `~/.kimi-code/mcp.json`.
+
+Re-running an install is safe: an engine that already has the server reports
+`already registered` rather than an error, so the summary only goes red when
+something actually went wrong.
 
 The catalog is a convenience, never a gate — an explicit command always wins, so
 `moshcode mcp add porkbun -- node ./my-fork.js` runs your fork.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moshcode",
-  "version": "0.62.0",
+  "version": "0.64.0",
   "type": "module",
   "description": "moshcode — a metal wrapper for coding engines and native UGig/CoinPay workflow CLIs, with OpenPRD and moshscript",
   "repository": {

package/src/dns-system.mjs

@@ -332,8 +332,24 @@ function defaultRunner(command, args) {
  * root to listen on 5354, and requiring it to write a pidfile somewhere
  * privileged would make the whole daemon need privileges it otherwise does not.
  */
-export function pidfilePath() {
-  const base = process.env.XDG_RUNTIME_DIR || join(homedir(), ".moshcode") || tmpdir();
+export function pidfilePath(env = process.env, exists = existsSync) {
+  // `dns enable` escalates, so the run that *starts* the bridge is root and the
+  // runs that later ask about it are not. Under sudo both XDG_RUNTIME_DIR and
+  // HOME belong to root, so the pidfile went to /root/.moshcode — a path the
+  // unprivileged `dns status` and `dns disable` never look at and could not
+  // read if they did. The bridge was reported "not running" for the rest of its
+  // life, and the fix status advised started a second one on top of it.
+  //
+  // So an escalated run records against the invoking user's runtime dir, and
+  // only when that directory is really there: deriving /run/user/<uid> on a
+  // machine without one trades an unreadable path for a nonexistent one. macOS
+  // has no /run/user and falls through unchanged — the escalated paths this
+  // matters for are the systemd-resolved ones.
+  const invoker = env.SUDO_UID ? `/run/user/${env.SUDO_UID}` : null;
+  const base = (invoker && exists(invoker) ? invoker : null)
+    || env.XDG_RUNTIME_DIR
+    || join(homedir(), ".moshcode")
+    || tmpdir();
   return join(base, "moshpit-dns.pid");
 }
 

package/src/dns.mjs

@@ -1742,7 +1742,7 @@ export function parseUdpListeners(text) {
   return out;
 }
 
-const defaultUdpListeners = async () => {
+export const defaultUdpListeners = async () => {
   const { execFile } = await import("node:child_process");
   const text = await new Promise((resolve) => {
     execFile("ss", ["-lnup"], { timeout: 5000 }, (err, stdout) => resolve(err ? "" : String(stdout)));
@@ -1783,6 +1783,89 @@ export function portHolder(listeners, { host = DEFAULT_HOST, port = DEFAULT_PORT
   return null;
 }
 
+/**
+ * What is actually on the bridge's port, rather than what our pidfile claims.
+ *
+ * `status` used to answer this from the pidfile alone, and that file only ever
+ * describes a bridge *this tool* started, in *this* privilege context. Every
+ * other way a bridge reaches 5354 read as "not running": a systemd unit, a
+ * hand-started `dns start`, or — the common one — an `enable` that escalated to
+ * root and therefore wrote its pidfile under root's HOME instead of the
+ * invoking user's runtime dir.
+ *
+ * That is not a cosmetic lie. Status followed it with "routing is in place but
+ * the bridge is not running", and the fix it advised starts a second bridge on
+ * 127.0.0.1 while the working one holds 0.0.0.0. The kernel delivers to the
+ * more specific socket, so the advice shadows the bridge it was meant to
+ * rescue and the machine stops resolving — the outage `portHolder` above
+ * already describes, arrived at this time by following our own instructions.
+ *
+ * So the port gets asked. A bridge nothing here started is still a bridge.
+ * Both questions are put because they fail differently: a resolver that has
+ * stopped answering Moshpit names loses a namespace, and one that has stopped
+ * forwarding takes the machine off the internet.
+ */
+export async function bridgePresence({
+  host = DEFAULT_HOST,
+  port = DEFAULT_PORT,
+  recorded = { running: false, pid: null, stale: false },
+  listeners = defaultUdpListeners,
+  answers = probeResolver,
+  forwards = probeForwarding,
+} = {}) {
+  const [moshpit, clearnet] = await Promise.all([
+    answers({ host, port }).catch(() => false),
+    forwards({ host, port, name: CLEARNET_PROBE }).catch(() => false),
+  ]);
+  const answering = Boolean(moshpit || clearnet);
+
+  // Ours and alive is the ordinary case, and the probe still runs first: a
+  // recorded pid that no longer answers is worth saying out loud rather than
+  // reporting as a healthy bridge on the strength of the file alone.
+  if (recorded.running) {
+    return { kind: "ours", pid: recorded.pid, answering, forwards: clearnet, moshpit };
+  }
+
+  if (!answering) {
+    return recorded.stale
+      ? { kind: "stale", pid: recorded.pid, answering: false, forwards: false, moshpit: false }
+      : { kind: "none", pid: null, answering: false, forwards: false, moshpit: false };
+  }
+
+  // Only asked once something is known to be there, because `ss` is the
+  // expensive half and an unattributable owner is not a reason to call a
+  // demonstrably answering bridge absent.
+  const holder = portHolder(await listeners().catch(() => []), { host, port });
+  return {
+    kind: "foreign",
+    pid: holder?.pid ?? null,
+    process: holder?.process ?? null,
+    answering: true,
+    forwards: clearnet,
+    moshpit,
+  };
+}
+
+/** One line for `status`, kept next to the states it names. */
+export function describeBridge(presence, { host = DEFAULT_HOST, port = DEFAULT_PORT } = {}) {
+  switch (presence.kind) {
+    case "ours":
+      return presence.answering
+        ? `running (pid ${presence.pid})`
+        : `running (pid ${presence.pid}) — but not answering on ${host}:${port}`;
+    case "foreign": {
+      const who = presence.pid
+        ? `pid ${presence.pid}${presence.process ? `, ${presence.process}` : ""}`
+        : "owner not visible";
+      return `answering on ${host}:${port} (${who}) — started by something other than \`dns enable\``;
+    }
+    case "stale":
+      return `NOT running — stale pidfile for ${presence.pid}`;
+    default:
+      return "not running";
+  }
+}
+
 /**
  * Everything that has to be true of the machine before the routing is written.
  *
@@ -2151,7 +2234,7 @@ import { existsSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import {
   applyPlan, daemonStatus, describePlan, detectPlatform, disablePlan, enablePlan,
-  requiredPort, startDaemon, stopDaemon,
+  probeResolver, requiredPort, startDaemon, stopDaemon,
 } from "./dns-system.mjs";
 import { escalateSelf } from "./escalate.mjs";
 
@@ -2230,6 +2313,8 @@ export async function dnsCommand(args = [], out = console.log, deps = {}) {
     applyWith = applyWithRollback,
     verify = verifyResolution,
     bridgeStatus = daemonStatus,
+    presenceImpl = bridgePresence,
+    exists = existsSync,
     startBridge = startDaemon,
     proxyReachableImpl = proxyReachable,
     findLocalProxyImpl = findLocalProxy,
@@ -3009,25 +3094,48 @@ export async function dnsCommand(args = [], out = console.log, deps = {}) {
 
   if (sub === "status") {
     const platform = detectPlatform();
-    const daemon = await daemonStatus();
+    const daemon = await bridgeStatus();
+    const statusPort = requiredPort(platform, port);
+    const presence = await presenceImpl({ port: statusPort, recorded: daemon });
     out(`platform   ${platform || process.platform}`);
-    out(`bridge     ${daemon.running ? `running (pid ${daemon.pid})` : daemon.stale ? `NOT running — stale pidfile for ${daemon.pid}` : "not running"}`);
+    out(`bridge     ${describeBridge(presence, { port: statusPort })}`);
 
     // Routing is read off the filesystem rather than remembered, so a config
     // someone edited or removed by hand is reported as it actually is.
     const marker = platform === "macos" ? "/etc/resolver" : MOSHPIT_DROPIN;
-    const routed = platform === "linux" ? existsSync(marker) : platform === "macos" ? existsSync(marker) : null;
+    // Injected like every other system call this command makes. Read straight
+    // off the filesystem, "is this machine routed" made the status tests depend
+    // on whether the machine running them happened to have Moshpit enabled —
+    // green on a developer's box, red on a clean runner.
+    const routed = platform === "linux" || platform === "macos" ? exists(marker) : null;
     out(`routing    ${routed === null ? "(check NRPT: Get-DnsClientNrptRule)" : routed ? `configured (${marker})` : "not configured"}`);
 
-    // The state worth shouting about: names are pointed at a bridge that is not
-    // there, so every Moshpit name fails instead of falling through.
-    if (routed && !daemon.running) {
+    // The state worth shouting about, and the condition is "nothing answers"
+    // rather than "our pidfile is empty". Those are not the same machine, and
+    // shouting on the second one sent people to start a bridge that shadowed
+    // the working one they already had.
+    //
+    // The advice drops its `sudo` too: the CLI escalates the one step that
+    // needs root, and teaching `sudo moshcode` is how `sudo moshcode update`
+    // ends up reinstalling the whole tool into /root.
+    if (routed && !presence.answering) {
+      out("");
+      out(`! routing is in place but nothing answers on ${DEFAULT_HOST}:${statusPort} — Moshpit names will fail.`);
+      out("  fix with: moshcode dns enable     undo with: moshcode dns disable");
+    }
+
+    // Answering but not forwarding is the dangerous half, and it is invisible
+    // from the Moshpit side: names resolve, and everything else on the machine
+    // stops. Catch-all routing is what makes it total.
+    if (routed && presence.answering && !presence.forwards) {
       out("");
-      out("! routing is in place but the bridge is not running — Moshpit names will fail.");
-      out("  fix with: sudo moshcode dns enable     undo with: sudo moshcode dns disable");
+      out(`! the bridge on ${DEFAULT_HOST}:${statusPort} answers Moshpit names but is not forwarding`);
+      out("  clearnet lookups routed through it will fail. Restart it, or `moshcode dns disable`.");
     }
 
-    const known = await fetchTlds({ registryBase }).catch(() => null);
+    // The injected one, like every other caller. Reaching past it here made
+    // `status` the one subcommand that could not be tested without a network.
+    const known = await fetchTldsImpl({ registryBase }).catch(() => null);
     const probe = known
       ? await resolveName(`probe.${known[0] || "moshpit"}`, { registryBase }).catch(() => null)
       : null;

package/src/engines.mjs

@@ -405,15 +405,37 @@ export function agentLaunchArgs(engine, args = []) {
  * Spawn an arbitrary command with stdio inherited (so its own progress/prompts
  * own the terminal). Resolves { ok, code, signal } on exit. Used by install +
  * upgrade to run engine installers/updaters.
+ *
+ * With `{ capture: true }` the child's stdout/stderr are piped and *echoed
+ * through* rather than inherited, and the combined text comes back as `output`.
+ * The terminal still sees exactly what it saw before — the tee exists so a
+ * caller can read the engine's own words about *why* it exited non-zero, which
+ * a bare exit code cannot tell apart (see `alreadyRegistered` in mcp.mjs).
+ * Inherit stays the default: piping costs a couple of streams, and every other
+ * caller runs installers whose output nobody needs to parse.
+ *
+ * stdin is inherited either way, so a child that prompts still reaches the user.
  */
-export function runCmd(cmd, args = []) {
+export function runCmd(cmd, args = [], { capture = false } = {}) {
   return new Promise((resolve) => {
     let child;
     const spec = spawnSpec(cmd, args);
-    try { child = spawn(spec.cmd, spec.args, { stdio: "inherit" }); }
+    const stdio = capture ? ["inherit", "pipe", "pipe"] : "inherit";
+    try { child = spawn(spec.cmd, spec.args, { stdio }); }
     catch (e) { resolve({ ok: false, error: e }); return; }
-    child.on("error", (e) => resolve({ ok: false, error: e }));
-    child.on("exit", (code, signal) => resolve({ ok: true, code, signal }));
+    let output = "";
+    if (capture) {
+      for (const [stream, sink] of [[child.stdout, process.stdout], [child.stderr, process.stderr]]) {
+        stream?.on("data", (chunk) => { output += chunk.toString(); sink.write(chunk); });
+      }
+    }
+    child.on("error", (e) => resolve({ ok: false, error: e, output }));
+    // "exit" fires as soon as the process is gone, which with pipes can leave
+    // the last chunk still queued — the one line we are trying to read. "close"
+    // waits for the streams too. With stdio inherited there are no streams, so
+    // the two are the same moment and existing callers are unaffected; the
+    // distinction is kept explicit so neither branch changes by accident.
+    child.on(capture ? "close" : "exit", (code, signal) => resolve({ ok: true, code, signal, output }));
   });
 }
 

package/src/integrations.mjs

@@ -105,6 +105,22 @@ export function parseMcp(tokens) {
     };
   }
 
+  // A remote server is a URL and nothing else — every engine's builder pushes
+  // the target alone and discards `args`. So a leftover token here is not a
+  // command line, it is something the user typed that this command will silently
+  // throw away. `mcp install <url> --dry-run` is the case that matters: the flag
+  // does not exist, it lands here, and the install goes ahead and writes to
+  // every engine's config — the exact opposite of what the person typing it
+  // expected. Say so instead of dropping it on the floor.
+  if (!cmdParts && target && isRemoteTarget(target) && args.length) {
+    const extra = args[0];
+    return {
+      error: extra.startsWith("-")
+        ? `unknown mcp flag "${extra}" — mcp takes --name, -t/--transport, -e/--env, and -H/--header, and has no --dry-run`
+        : `unexpected argument "${extra}" after a remote server URL — a URL server takes no command arguments`,
+    };
+  }
+
   if (verb === "install" && !name) {
     if (target && isRemoteTarget(target)) name = deriveName(target);
     else return { error: "a stdio command server needs an explicit --name" };
@@ -185,6 +201,9 @@ export function printSkillTargets(json = false) {
 function summarize(results) {
   for (const r of results) {
     if (r.status === "added" || r.status === "installed" || r.status === "removed") console.log(line(r.key, ok(r.status)));
+    // Nothing to do and nothing wrong: grey, like the other "we didn't act"
+    // rows, rather than the green of a change we actually made.
+    else if (r.status === "already") console.log(line(r.key, ash("already registered")));
     else if (r.status === "failed") console.log(line(r.key, err(`failed${r.code != null ? ` (code ${r.code})` : r.signal ? ` (${r.signal})` : ""}`)));
     else if (r.status === "not-installed") console.log(line(r.key, ash("not installed — /install " + r.key)));
     else console.log(line(r.key, ash(`skipped — ${r.reason}`)));

package/src/mcp.mjs

@@ -5,7 +5,7 @@ import { ENGINES, isInstalled, ranOk, runCmd } from "./engines.mjs";
 import { isIP } from "node:net";
 
 // Coding engines that can register MCP servers. Aider has no MCP support.
-export const MCP_ENGINES = ["claude", "gemini", "codex", "opencode", "privacycode"];
+export const MCP_ENGINES = ["claude", "gemini", "qwen", "codex", "opencode", "privacycode"];
 
 /** Is this target a remote server URL (vs a local stdio command)? */
 export function isRemoteTarget(target) {
@@ -71,7 +71,11 @@ export function mcpAddArgs(key, spec) {
       else argv.push("--", target, ...args);
       return { argv };
     }
-    case "gemini": {
+    // Qwen Code is a Gemini CLI fork and kept the whole `mcp add` surface —
+    // same `-s/-t/-e/-H` flags, same "URL or command" positional. It shares the
+    // builder rather than getting a copy, so the two can only drift on purpose.
+    case "gemini":
+    case "qwen": {
       const argv = ["mcp", "add", "-s", "user"];
       if (remote) argv.push("-t", transport);
       for (const [k, v] of env) argv.push("-e", `${k}=${v}`);
@@ -138,9 +142,27 @@ export function planMcpAdd(spec, { installedSet } = {}) {
   });
 }
 
+/**
+ * Did this engine exit non-zero only because the server was already there?
+ *
+ * Registering the same server twice is the normal way to re-run `mcp install`,
+ * and it is not a failure — but Claude Code and Gemini/Qwen exit 1 on it, so the
+ * fan-out summary painted `claude ✗ failed (code 1)` next to opencode's cheerful
+ * green box. Read from a box where four engines already had the server, that
+ * says "moshcode cannot register with Claude Code" — which is exactly the wrong
+ * conclusion, and the reason this function exists rather than a nicer exit code.
+ *
+ * Matched against the engine's own words, so it stays honest: an engine that
+ * fails for any *other* reason still comes back failed.
+ */
+const ALREADY_RE = /already (?:exists|configured|registered|added)|exists in (?:user|global|project) config/i;
+export function alreadyRegistered(r) {
+  return ALREADY_RE.test(String(r?.output ?? ""));
+}
+
 /**
  * Execute a plan: run each installed, non-skipped engine's `mcp add`. Returns
- * results [{ key, status: "added"|"skipped"|"failed"|"not-installed", reason? }].
+ * results [{ key, status: "added"|"already"|"skipped"|"failed"|"not-installed", reason? }].
  * `run` is injectable for tests; defaults to the real spawner.
  */
 export async function runMcpAdd(plan, { run = runCmd } = {}) {
@@ -148,8 +170,11 @@ export async function runMcpAdd(plan, { run = runCmd } = {}) {
   for (const item of plan) {
     if (item.skip) { results.push({ key: item.key, status: "skipped", reason: item.skip }); continue; }
     if (!item.installed) { results.push({ key: item.key, status: "not-installed" }); continue; }
-    const r = await run(item.bin, item.argv);
-    results.push({ key: item.key, status: ranOk(r) ? "added" : "failed", code: r.code, signal: r.signal ?? null });
+    // capture so a non-zero exit can be read for "already exists" rather than
+    // reported as a failure; the child's output still reaches the terminal.
+    const r = await run(item.bin, item.argv, { capture: true });
+    const status = ranOk(r) ? "added" : alreadyRegistered(r) ? "already" : "failed";
+    results.push({ key: item.key, status, code: r.code, signal: r.signal ?? null });
   }
   return results;
 }