nexus-agents 2.61.0 → 2.62.0

package/dist/{chunk-KNAPTURC.js → chunk-OJBW4II4.js}

@@ -8,7 +8,7 @@ import {
   checkSqlite,
   defaultConfig,
   initDataDirectories
-} from "./chunk-NB6IYTMN.js";
+} from "./chunk-V7AFOKWC.js";
 import {
   BUILT_IN_EXPERTS
 } from "./chunk-GJVHRJO2.js";
@@ -1933,4 +1933,4 @@ export {
   setupCommand,
   setupCommandAsync
 };
-//# sourceMappingURL=chunk-KNAPTURC.js.map
+//# sourceMappingURL=chunk-OJBW4II4.js.map

package/dist/{chunk-NB6IYTMN.js → chunk-V7AFOKWC.js}

@@ -38,7 +38,7 @@ import {
 } from "./chunk-CLYZ7FWP.js";
 
 // src/version.ts
-var VERSION = true ? "2.61.0" : "dev";
+var VERSION = true ? "2.62.0" : "dev";
 
 // src/config/schemas-core.ts
 import { z } from "zod";
@@ -2025,7 +2025,7 @@ async function runDoctorFix(result) {
   writeLine2("\u2500".repeat(40));
   let fixCount = 0;
   if (!result.dataDirectory.rootExists || result.dataDirectory.subdirectories.some((d) => !d.exists || !d.writable)) {
-    const { runSetup } = await import("./setup-command-QJGB34JY.js");
+    const { runSetup } = await import("./setup-command-FC67SJSP.js");
     const setupResult = runSetup({
       skipMcp: true,
       skipRules: true,
@@ -2135,4 +2135,4 @@ export {
   startStdioServer,
   closeServer
 };
-//# sourceMappingURL=chunk-NB6IYTMN.js.map
+//# sourceMappingURL=chunk-V7AFOKWC.js.map

package/dist/{chunk-TRWIEUI2.js → chunk-X5WDX7L3.js}

@@ -68,7 +68,7 @@ import {
   clampTaskTtl,
   getAvailabilityCache,
   resolveFallback
-} from "./chunk-NB6IYTMN.js";
+} from "./chunk-V7AFOKWC.js";
 import {
   DEFAULTS
 } from "./chunk-H43PABG4.js";
@@ -53661,4 +53661,4 @@ export {
   detectBackend,
   createTaskTracker
 };
-//# sourceMappingURL=chunk-TRWIEUI2.js.map
+//# sourceMappingURL=chunk-X5WDX7L3.js.map

package/dist/cli.d.ts

@@ -108,6 +108,7 @@ interface ParsedCliArgs {
         source?: string;
         portable?: boolean;
         gitignore?: boolean;
+        mcpConfig?: boolean;
     };
     positionals: string[];
 }

package/dist/cli.js

@@ -16,7 +16,7 @@ import "./chunk-6QU4DJYW.js";
 import {
   setupCommandAsync,
   verifyCommand
-} from "./chunk-KNAPTURC.js";
+} from "./chunk-OJBW4II4.js";
 import "./chunk-QGZBCD2A.js";
 import {
   AuthHandler,
@@ -142,7 +142,7 @@ import {
   validateCommand,
   validateWorkflow,
   wrapInMarkdownFence
-} from "./chunk-TRWIEUI2.js";
+} from "./chunk-X5WDX7L3.js";
 import "./chunk-ED6VQWNG.js";
 import {
   resolveToken
@@ -201,7 +201,7 @@ import {
   loadConfig,
   runDoctor,
   validateNexusEnv
-} from "./chunk-NB6IYTMN.js";
+} from "./chunk-V7AFOKWC.js";
 import {
   DEFAULTS
 } from "./chunk-H43PABG4.js";
@@ -17663,6 +17663,11 @@ var PARSE_ARGS_CONFIG = {
     gitignore: {
       type: "boolean",
       default: false
+    },
+    // init --portable --mcp-config flag (#2308)
+    "mcp-config": {
+      type: "boolean",
+      default: false
     }
   },
   allowPositionals: true,
@@ -17721,18 +17726,135 @@ function isValidCommand(value) {
 }
 
 // src/cli-commands-handlers.ts
-import { existsSync as existsSync19 } from "fs";
+import { existsSync as existsSync20 } from "fs";
 
 // src/cli/init-portable.ts
 import {
-  existsSync as existsSync17,
+  existsSync as existsSync18,
   mkdirSync as mkdirSync3,
   readdirSync as readdirSync2,
   statSync as statSync3,
-  appendFileSync,
-  readFileSync as readFileSync10
+  appendFileSync as appendFileSync2,
+  readFileSync as readFileSync11
 } from "fs";
-import { resolve as resolve11, join as join13, isAbsolute as isAbsolute2 } from "path";
+import { resolve as resolve11, join as join14, isAbsolute as isAbsolute2 } from "path";
+
+// src/cli/mcp-config-emitter.ts
+import { existsSync as existsSync17, readFileSync as readFileSync10, writeFileSync as writeFileSync5, appendFileSync } from "fs";
+import { join as join13 } from "path";
+var MCP_CONFIG_FILENAME = ".mcp.json";
+var NEXUS_SERVER_KEY = "nexus-agents";
+function buildNexusServerEntry(dataDir) {
+  return {
+    command: "nexus-agents",
+    args: ["--mode=server"],
+    env: { NEXUS_DATA_DIR: dataDir }
+  };
+}
+function entriesEqual(a, b) {
+  if (a.command !== b.command) return false;
+  if (a.args.length !== b.args.length) return false;
+  for (let i = 0; i < a.args.length; i++) if (a.args[i] !== b.args[i]) return false;
+  const aEnv = a.env ?? {};
+  const bEnv = b.env ?? {};
+  const aKeys = Object.keys(aEnv);
+  const bKeys = Object.keys(bEnv);
+  if (aKeys.length !== bKeys.length) return false;
+  for (const k of aKeys) if (aEnv[k] !== bEnv[k]) return false;
+  return true;
+}
+function loadExistingConfig(path23) {
+  if (!existsSync17(path23)) return { ok: true, value: void 0 };
+  let raw;
+  try {
+    raw = readFileSync10(path23, "utf-8");
+  } catch (e) {
+    return { ok: false, error: e instanceof Error ? e.message : String(e) };
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null) {
+      return { ok: false, error: `${path23}: top-level JSON must be an object` };
+    }
+    return { ok: true, value: parsed };
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return { ok: false, error: `${path23}: invalid JSON \u2014 ${msg}` };
+  }
+}
+function decideEmission(existing, desired, force) {
+  if (existing === void 0) {
+    return { kind: "write", nextConfig: { mcpServers: { [NEXUS_SERVER_KEY]: desired } } };
+  }
+  const servers = existing.mcpServers ?? {};
+  const current = servers[NEXUS_SERVER_KEY];
+  if (current !== void 0 && entriesEqual(current, desired)) {
+    return { kind: "noop" };
+  }
+  if (current !== void 0 && !force) {
+    return {
+      kind: "refuse",
+      reason: `existing ${NEXUS_SERVER_KEY} entry differs; pass --force to overwrite`
+    };
+  }
+  const nextServers = { ...servers, [NEXUS_SERVER_KEY]: desired };
+  return { kind: "write", nextConfig: { ...existing, mcpServers: nextServers } };
+}
+function autoGitignoreMcpConfig(workspaceDir, dryRun) {
+  const gitDir = join13(workspaceDir, ".git");
+  if (!existsSync17(gitDir)) return false;
+  const gitignorePath = join13(workspaceDir, ".gitignore");
+  let existing = "";
+  if (existsSync17(gitignorePath)) {
+    existing = readFileSync10(gitignorePath, "utf-8");
+    const already = existing.split("\n").some((l) => l.trim() === MCP_CONFIG_FILENAME || l.trim() === `/${MCP_CONFIG_FILENAME}`);
+    if (already) return false;
+  }
+  if (!dryRun) {
+    const sep3 = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
+    appendFileSync(gitignorePath, `${sep3}${MCP_CONFIG_FILENAME}
+`, "utf-8");
+  }
+  return true;
+}
+function emitMcpConfig(options) {
+  const mcpConfigPath = join13(options.workspaceDir, MCP_CONFIG_FILENAME);
+  const dryRun = options.dryRun === true;
+  const force = options.force === true;
+  const desired = buildNexusServerEntry(options.dataDir);
+  const loaded = loadExistingConfig(mcpConfigPath);
+  if (!loaded.ok) return makeFailure(mcpConfigPath, loaded.error);
+  const decision = decideEmission(loaded.value, desired, force);
+  if (decision.kind === "refuse") return makeFailure(mcpConfigPath, decision.reason);
+  if (decision.kind === "noop") {
+    return makeSuccess({
+      mcpConfigPath,
+      written: false,
+      alreadyMatched: true,
+      gitignoreUpdated: false
+    });
+  }
+  if (!dryRun) {
+    writeFileSync5(mcpConfigPath, JSON.stringify(decision.nextConfig, null, 2) + "\n", "utf-8");
+  }
+  const gitignoreUpdated = autoGitignoreMcpConfig(options.workspaceDir, dryRun);
+  return makeSuccess({ mcpConfigPath, written: true, alreadyMatched: false, gitignoreUpdated });
+}
+function makeSuccess(opts) {
+  return { success: true, error: null, ...opts };
+}
+function makeFailure(mcpConfigPath, error) {
+  return {
+    success: false,
+    mcpConfigPath,
+    written: false,
+    alreadyMatched: false,
+    gitignoreUpdated: false,
+    error
+  };
+}
+
+// src/cli/init-portable.ts
 var DEFAULT_PORTABLE_DIRNAME = ".nexus-agents";
 var RESTRICTED_SUBDIRS = /* @__PURE__ */ new Set(["auth"]);
 function resolveTargetPath(rawPath) {
@@ -17742,13 +17864,13 @@ function resolveTargetPath(rawPath) {
   return isAbsolute2(rawPath) ? rawPath : resolve11(process.cwd(), rawPath);
 }
 function isNonEmpty(dir) {
-  if (!existsSync17(dir)) return false;
+  if (!existsSync18(dir)) return false;
   const stat2 = statSync3(dir);
   if (!stat2.isDirectory()) return true;
   return readdirSync2(dir).length > 0;
 }
 function ensureDir(path23, dryRun, created, alreadyExisted, mode) {
-  if (existsSync17(path23)) {
+  if (existsSync18(path23)) {
     alreadyExisted.push(path23);
     return;
   }
@@ -17758,37 +17880,37 @@ function ensureDir(path23, dryRun, created, alreadyExisted, mode) {
   created.push(path23);
 }
 function maybeUpdateGitignore(workspaceDir, portableDirName, dryRun) {
-  const gitDir = join13(workspaceDir, ".git");
-  if (!existsSync17(gitDir)) return false;
-  const gitignorePath = join13(workspaceDir, ".gitignore");
+  const gitDir = join14(workspaceDir, ".git");
+  if (!existsSync18(gitDir)) return false;
+  const gitignorePath = join14(workspaceDir, ".gitignore");
   const entry = `${portableDirName}/`;
   let existing = "";
-  if (existsSync17(gitignorePath)) {
-    existing = readFileSync10(gitignorePath, "utf-8");
+  if (existsSync18(gitignorePath)) {
+    existing = readFileSync11(gitignorePath, "utf-8");
     if (existing.split("\n").some((l) => l.trim() === entry || l.trim() === portableDirName)) {
       return false;
     }
   }
   if (!dryRun) {
     const sep3 = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
-    appendFileSync(gitignorePath, `${sep3}${entry}
+    appendFileSync2(gitignorePath, `${sep3}${entry}
 `, "utf-8");
   }
   return true;
 }
 function inspectTarget(target) {
-  const exists = existsSync17(target);
+  const exists = existsSync18(target);
   if (!exists) return { exists: false, nonEmpty: false, isExistingNexusDir: false };
   const nonEmpty = isNonEmpty(target);
   const stat2 = statSync3(target);
-  const isExistingNexusDir = stat2.isDirectory() && existsSync17(join13(target, "audit"));
+  const isExistingNexusDir = stat2.isDirectory() && existsSync18(join14(target, "audit"));
   return { exists, nonEmpty, isExistingNexusDir };
 }
 function createDataLayout(target, dryRun, created, alreadyExisted) {
   ensureDir(target, dryRun, created, alreadyExisted);
   for (const subdir of DATA_SUBDIRECTORIES) {
     const mode = RESTRICTED_SUBDIRS.has(subdir) ? 448 : void 0;
-    ensureDir(join13(target, subdir), dryRun, created, alreadyExisted, mode);
+    ensureDir(join14(target, subdir), dryRun, created, alreadyExisted, mode);
   }
 }
 function makeResult(opts) {
@@ -17799,6 +17921,7 @@ function makeResult(opts) {
     alreadyExisted: opts.alreadyExisted,
     skipped: opts.skipped ?? false,
     gitignoreUpdated: opts.gitignoreUpdated ?? false,
+    ...opts.mcpConfig !== void 0 ? { mcpConfig: opts.mcpConfig } : {},
     error: opts.error ?? null
   };
 }
@@ -17808,6 +17931,25 @@ function applyGitignoreOption(target, options, dryRun) {
   const portableName = target.slice(workspaceDir.length + 1);
   return maybeUpdateGitignore(workspaceDir, portableName, dryRun);
 }
+function applyMcpConfigOption(target, options, dryRun) {
+  if (options.mcpConfig !== true) return void 0;
+  const workspaceDir = resolve11(target, "..");
+  return emitMcpConfig({
+    workspaceDir,
+    dataDir: target,
+    force: options.force === true,
+    dryRun
+  });
+}
+function buildSuccessResult(base, flags, mcpConfig) {
+  if (mcpConfig === void 0) {
+    return makeResult({ ...base, ...flags, success: true });
+  }
+  if (mcpConfig.success) {
+    return makeResult({ ...base, ...flags, success: true, mcpConfig });
+  }
+  return makeResult({ ...base, ...flags, success: false, mcpConfig, error: mcpConfig.error });
+}
 function initPortable(options = {}) {
   const created = [];
   const alreadyExisted = [];
@@ -17819,7 +17961,11 @@ function initPortable(options = {}) {
     const state = inspectTarget(target);
     if (state.isExistingNexusDir && !force) {
       createDataLayout(target, dryRun, created, alreadyExisted);
-      return makeResult({ ...base, success: true, skipped: true });
+      return buildSuccessResult(
+        base,
+        { skipped: true },
+        applyMcpConfigOption(target, options, dryRun)
+      );
     }
     if (state.nonEmpty && !state.isExistingNexusDir && !force) {
       const error = `target ${target} already exists and is not empty; pass --force to use anyway`;
@@ -17827,37 +17973,62 @@ function initPortable(options = {}) {
     }
     createDataLayout(target, dryRun, created, alreadyExisted);
     const gitignoreUpdated = applyGitignoreOption(target, options, dryRun);
-    return makeResult({ ...base, success: true, gitignoreUpdated });
+    return buildSuccessResult(
+      base,
+      { gitignoreUpdated },
+      applyMcpConfigOption(target, options, dryRun)
+    );
   } catch (error) {
     const msg = error instanceof Error ? error.message : String(error);
     return makeResult({ ...base, success: false, error: msg });
   }
 }
+function renderMcpConfigLines(mcpConfig) {
+  const lines = [];
+  if (mcpConfig.alreadyMatched) {
+    lines.push(`\u2713 .mcp.json already up to date: ${mcpConfig.mcpConfigPath}`);
+  } else if (mcpConfig.written) {
+    lines.push(`\u2713 Wrote MCP config: ${mcpConfig.mcpConfigPath}`);
+  }
+  if (mcpConfig.gitignoreUpdated) {
+    lines.push(`\u2713 Added .mcp.json to .gitignore (per-machine; do not commit)`);
+  }
+  return lines;
+}
+function renderMcpConfigCaveat(mcpConfig) {
+  if (mcpConfig?.written !== true) return [];
+  return [
+    "",
+    "Note: .mcp.json contains an absolute path to your local data dir.",
+    "It is per-machine and should NOT be committed \u2014 collaborators should",
+    "run `nexus-agents init --portable --mcp-config` themselves."
+  ];
+}
 function formatInitPortableMessage(result, dryRun) {
   if (!result.success) {
     return `init --portable failed: ${result.error ?? "unknown error"}
 `;
   }
-  const lines = [];
   if (dryRun) {
-    lines.push(`(dry-run) would create ${String(result.created.length)} entries under:`);
-    lines.push(`  ${result.absolutePath}`);
-    return lines.join("\n") + "\n";
-  }
-  if (result.skipped) {
-    lines.push(`\u2713 Already initialized: ${result.absolutePath}`);
-  } else {
-    lines.push(`\u2713 Created: ${result.absolutePath}`);
-  }
-  if (result.gitignoreUpdated) {
-    lines.push(`\u2713 Added entry to .gitignore`);
+    const lines2 = [
+      `(dry-run) would create ${String(result.created.length)} entries under:`,
+      `  ${result.absolutePath}`
+    ];
+    return lines2.join("\n") + "\n";
   }
+  const lines = [];
+  lines.push(
+    result.skipped ? `\u2713 Already initialized: ${result.absolutePath}` : `\u2713 Created: ${result.absolutePath}`
+  );
+  if (result.gitignoreUpdated) lines.push(`\u2713 Added entry to .gitignore`);
+  if (result.mcpConfig !== void 0) lines.push(...renderMcpConfigLines(result.mcpConfig));
   lines.push("");
   lines.push("Activate by exporting:");
   lines.push(`  export NEXUS_DATA_DIR=${result.absolutePath}`);
   lines.push("");
   lines.push("Or one-off:");
   lines.push(`  NEXUS_DATA_DIR=${result.absolutePath} nexus-agents <cmd>`);
+  lines.push(...renderMcpConfigCaveat(result.mcpConfig));
   return lines.join("\n") + "\n";
 }
 
@@ -20672,8 +20843,8 @@ function printFirstRunHint() {
   const isTTY = process.stderr.isTTY;
   if (!isTTY) return;
   const dataDir = getNexusDataDir();
-  const hasConfig = existsSync19("./nexus-agents.yaml") || existsSync19("./nexus-agents.yml");
-  if (existsSync19(dataDir) || hasConfig) return;
+  const hasConfig = existsSync20("./nexus-agents.yaml") || existsSync20("./nexus-agents.yml");
+  if (existsSync20(dataDir) || hasConfig) return;
   process.stderr.write(
     "\n\x1B[36mnexus-agents\x1B[0m: First time? Run \x1B[1mnexus-agents setup\x1B[0m to configure.\n\n"
   );
@@ -20851,7 +21022,8 @@ function handleInitCommand(args) {
     ...targetPath !== void 0 && targetPath !== "" ? { path: targetPath } : {},
     force: args.options.force,
     dryRun: args.options.dryRun,
-    gitignore: args.options.gitignore ?? false
+    gitignore: args.options.gitignore ?? false,
+    mcpConfig: args.options.mcpConfig ?? false
   });
   process.stdout.write(formatInitPortableMessage(result, args.options.dryRun));
   process.exit(result.success ? EXIT_CODES.SUCCESS : EXIT_CODES.SERVER_START_FAILED);
@@ -22329,7 +22501,7 @@ function handleStatusCommand2(args) {
 
 // src/cli/scenario-command.ts
 import { readdir as readdir4 } from "fs/promises";
-import { join as join15, resolve as resolve14 } from "path";
+import { join as join16, resolve as resolve14 } from "path";
 
 // src/testing/e2e/scenario-runner.ts
 import { readFile as readFile7 } from "fs/promises";
@@ -22699,7 +22871,7 @@ async function handleRun(args) {
     process.exit(EXIT_CODES.SERVER_START_FAILED);
   }
   const runner = createScenarioRunner();
-  const fixturePath = join15(FIXTURES_DIR, `${name}${SCENARIO_SUFFIX}`);
+  const fixturePath = join16(FIXTURES_DIR, `${name}${SCENARIO_SUFFIX}`);
   try {
     const fixture = await runner.loadFixture(fixturePath);
     const result = await runner.run(fixture);
@@ -23410,7 +23582,15 @@ function buildOptions(values) {
     ...buildSweBenchOptions(values),
     ...buildAtbenchOptions(values),
     ...buildLearningMetricsOptions(values),
-    ...buildSetupOptions(values)
+    ...buildSetupOptions(values),
+    ...buildInitOptions(values)
+  };
+}
+function buildInitOptions(values) {
+  return {
+    portable: values.portable,
+    gitignore: values.gitignore,
+    mcpConfig: values["mcp-config"]
   };
 }
 function parseCliArgs(args = process.argv.slice(2)) {