fix: allow global commands from the user home directory

Closes #58

Author: Honguan

lib/cli.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { lstat, readFile, realpath } from "node:fs/promises";
-import { dirname, relative, resolve } from "node:path";
+import { dirname, join, relative, resolve } from "node:path";
 import {
   inspectInstallation as inspectBaseInstallation,
   reasoningWarnings,
@@ -131,11 +131,39 @@ async function semanticCrossScope(options) {
   return entries;
 }
 
+function flagPresent(argv, name) {
+  return argv.some((token) => token === name || token.startsWith(`${name}=`));
+}
+
 function isStatus(argv) {
   if (argv[0] === "v2") return ["status", "doctor"].includes(argv[1]);
   return ["status", "doctor"].includes(argv[0]);
 }
 
+function isOperational(argv) {
+  if (argv[0] === "v2") {
+    return ["enable", "disable", "status", "install", "uninstall", "doctor"].includes(argv[1]);
+  }
+  return ["enable", "disable", "status", "install", "uninstall", "doctor", "adopt", "repair"].includes(argv[0]);
+}
+
+function samePath(left, right) {
+  if (process.platform === "win32") return left.toLowerCase() === right.toLowerCase();
+  return left === right;
+}
+
+function scopeAwareOptions(argv, normalized) {
+  if (!flagPresent(argv, "--global")) return normalized;
+
+  // Global commands select only the user-level installation. Give the enhanced
+  // diagnostics a non-overlapping synthetic project view so a cwd that happens
+  // to be the user home cannot block the explicitly selected global scope.
+  return {
+    ...normalized,
+    cwd: join(normalized.home, ".codex-model-router-global-command")
+  };
+}
+
 export { reasoningWarnings };
 
 export async function resolveLocations(options = {}, global = false) {
@@ -144,27 +172,38 @@ export async function resolveLocations(options = {}, global = false) {
 
 export async function inspectInstallation(options = {}, global = false) {
   const normalized = await canonicalOptions(options);
-  const report = await inspectBaseInstallation(normalized, global);
-  report.cross_scope = await semanticCrossScope(normalized);
+  const scoped = global ? scopeAwareOptions(["status", "--global"], normalized) : normalized;
+  const report = await inspectBaseInstallation(scoped, global);
+  report.roots.project = normalized.cwd;
+  report.cross_scope = await semanticCrossScope(scoped);
   return report;
 }
 
 export async function runCli(argv, options = {}) {
   const normalized = await canonicalOptions(options);
-  if (!isStatus(argv)) return runEnhancedCli(argv, normalized);
-
   const output = normalized.output ?? console.log;
-  const json = argv.some((token) => token === "--json" || token.startsWith("--json="));
+  const global = flagPresent(argv, "--global");
+
+  if (isOperational(argv) && !global && samePath(normalized.cwd, normalized.home)) {
+    output("fail: project scope cannot use the user home as its project root; use --global or change to an actual project directory");
+    return 1;
+  }
+
+  const scoped = scopeAwareOptions(argv, normalized);
+  if (!isStatus(argv)) return runEnhancedCli(argv, scoped);
+
+  const json = flagPresent(argv, "--json");
   const captured = [];
   const baseExit = await runEnhancedCli(argv, {
-    ...normalized,
+    ...scoped,
     output: json ? (line) => captured.push(String(line)) : output
   });
-  const crossScope = await semanticCrossScope(normalized);
+  const crossScope = await semanticCrossScope(scoped);
   const conflict = crossScope.some((entry) => entry.status === "conflict");
 
   if (json) {
     const report = JSON.parse(captured.join("\n"));
+    report.roots.project = normalized.cwd;
     report.cross_scope = crossScope;
     output(JSON.stringify(report, null, 2));
   } else {

test/enhanced-cli.test.js

@@ -34,11 +34,11 @@ test("default reasoning is warning-free and weak profiles use stable warning cod
   );
 });
 
-test("overlapping project and global Codex roots are rejected before writes", async () => {
+test("overlapping project and global Codex roots are rejected before project writes", async () => {
   const dir = await fixture();
   try {
     const lines = [];
-    const result = await runCli(["enable", "--global", "--dry-run"], {
+    const result = await runCli(["enable", "--dry-run"], {
       cwd: dir.project,
       home: dir.home,
       env: { CODEX_HOME: join(dir.project, ".codex") },

test/global-home-scope.test.js

@@ -0,0 +1,55 @@
+import assert from "node:assert/strict";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { runCli } from "../lib/cli.js";
+
+const quiet = () => {};
+const codexAvailable = () => ({ status: 0, stdout: "codex-cli 9.9.9\n", stderr: "" });
+
+async function fixture() {
+  const home = await mkdtemp(join(tmpdir(), "codex-model-router-global-home-"));
+  return {
+    home,
+    cleanup: () => rm(home, { recursive: true, force: true })
+  };
+}
+
+test("explicit global lifecycle commands work when cwd equals home", async () => {
+  const dir = await fixture();
+  try {
+    const options = {
+      cwd: dir.home,
+      home: dir.home,
+      output: quiet,
+      spawnSync: codexAvailable
+    };
+
+    assert.equal(await runCli(["enable", "--global"], options), 0);
+    assert.equal(await runCli(["status", "--global"], options), 0);
+    assert.equal(await runCli(["repair", "--global"], options), 0);
+    assert.equal(await runCli(["v2", "status", "--global"], options), 0);
+    assert.equal(await runCli(["disable", "--global"], options), 0);
+  } finally {
+    await dir.cleanup();
+  }
+});
+
+test("project lifecycle commands reject the user home with an actionable message", async () => {
+  const dir = await fixture();
+  try {
+    const lines = [];
+    const result = await runCli(["enable"], {
+      cwd: dir.home,
+      home: dir.home,
+      output: (line) => lines.push(String(line)),
+      spawnSync: codexAvailable
+    });
+
+    assert.equal(result, 1);
+    assert.ok(lines.some((line) => line.includes("use --global or change to an actual project directory")));
+  } finally {
+    await dir.cleanup();
+  }
+});