@rubytech/create-maxy-code 0.1.388 → 0.1.391

package/dist/__tests__/claude-bin.test.js

@@ -0,0 +1,51 @@
+// acceptance grid for claude-bin.ts (Task 1395 gap 4).
+//
+// Pure resolver: version parse/compare, canonical pick (highest version),
+// and PATH enumeration with injected fs/spawn so no real binary is probed.
+// Runs under node --test alongside the rest of the package.
+import test from "node:test";
+import assert from "node:assert/strict";
+import { pickCanonicalClaude, compareVersions, parseClaudeVersion, enumerateClaudeCandidates, } from "../claude-bin.js";
+test("parseClaudeVersion extracts leading version", () => {
+    assert.equal(parseClaudeVersion("2.1.201 (Claude Code)"), "2.1.201");
+    assert.equal(parseClaudeVersion("  2.1.153 (Claude Code)\n"), "2.1.153");
+    assert.equal(parseClaudeVersion("not installed"), null);
+});
+test("compareVersions orders by numeric parts", () => {
+    assert.ok(compareVersions("2.1.201", "2.1.153") > 0);
+    assert.ok(compareVersions("2.1.153", "2.1.201") < 0);
+    assert.equal(compareVersions("2.1.1", "2.1.1"), 0);
+    assert.ok(compareVersions("2.2.0", "2.1.999") > 0);
+});
+test("pickCanonicalClaude picks highest version (nvm over stale Cask)", () => {
+    const pick = pickCanonicalClaude([
+        { path: "/usr/local/bin/claude", version: "2.1.153" },
+        { path: "/Users/x/.nvm/versions/node/v22/bin/claude", version: "2.1.201" },
+    ]);
+    assert.equal(pick, "/Users/x/.nvm/versions/node/v22/bin/claude");
+});
+test("pickCanonicalClaude: empty -> null, ties -> first", () => {
+    assert.equal(pickCanonicalClaude([]), null);
+    assert.equal(pickCanonicalClaude([
+        { path: "/a/claude", version: "2.1.1" },
+        { path: "/b/claude", version: "2.1.1" },
+    ]), "/a/claude");
+});
+test("enumerateClaudeCandidates dedupes by realpath, skips non-exec/unversioned", () => {
+    const versions = {
+        "/opt/homebrew/bin/claude": "2.1.201 (Claude Code)",
+        "/usr/local/bin/claude": "2.1.153 (Claude Code)",
+    };
+    const deps = {
+        isExecutable: (p) => p === "/opt/homebrew/bin/claude" || p === "/usr/local/bin/claude" || p === "/dup/claude",
+        // /dup/claude is a symlink to the homebrew one -> deduped away
+        realpath: (p) => (p === "/dup/claude" ? "/opt/homebrew/bin/claude" : p),
+        runVersion: (p) => versions[p] ?? null,
+    };
+    const cands = enumerateClaudeCandidates("/opt/homebrew/bin:/usr/local/bin:/dup:/empty", deps);
+    assert.deepEqual(cands, [
+        { path: "/opt/homebrew/bin/claude", version: "2.1.201" },
+        { path: "/usr/local/bin/claude", version: "2.1.153" },
+    ]);
+    assert.equal(pickCanonicalClaude(cands), "/opt/homebrew/bin/claude");
+});

package/dist/__tests__/claude-upgrade-privilege.test.js

@@ -0,0 +1,17 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { decideClaudeUpgradePrivilege } from "../claude-upgrade-privilege.js";
+test("darwin: writable user-owned prefix runs the upgrade without sudo", () => {
+    assert.equal(decideClaudeUpgradePrivilege({ platform: "darwin", prefixWritable: true, canSudo: false }), "run-no-sudo");
+    assert.equal(decideClaudeUpgradePrivilege({ platform: "darwin", prefixWritable: true, canSudo: true }), "run-no-sudo");
+});
+test("darwin: non-writable prefix falls back to sudo when available, else skips", () => {
+    assert.equal(decideClaudeUpgradePrivilege({ platform: "darwin", prefixWritable: false, canSudo: true }), "run-sudo");
+    assert.equal(decideClaudeUpgradePrivilege({ platform: "darwin", prefixWritable: false, canSudo: false }), "skip");
+});
+test("linux: unchanged — sudo when available, skip when not; prefixWritable is ignored", () => {
+    assert.equal(decideClaudeUpgradePrivilege({ platform: "linux", prefixWritable: false, canSudo: true }), "run-sudo");
+    assert.equal(decideClaudeUpgradePrivilege({ platform: "linux", prefixWritable: false, canSudo: false }), "skip");
+    // prefixWritable must not change the Linux decision (root-owned global prefix assumed).
+    assert.equal(decideClaudeUpgradePrivilege({ platform: "linux", prefixWritable: true, canSudo: false }), "skip");
+});

package/dist/__tests__/joblogic-excluded.test.js

@@ -0,0 +1,39 @@
+// Task 1386: the `joblogic` connector plugin is suspended by exclusion. Its skill
+// triggers on the generic word "jobs" and its tools are all adminAllowlist, so an
+// admin asking about jobs is mis-routed to a connector that ships inert and is used
+// by zero accounts — colliding head-on with SiteDesk's `Job` ontology. Suspension is
+// uniform across every brand: each brand.json must carry "joblogic" in
+// plugins.excluded so the bundler drops it from the payload and it never registers as
+// a native CC plugin. This guard fails loud if any brand drops the exclusion.
+//
+// Runs via Node's built-in test runner (codebase convention). Path resolution mirrors
+// known-brand-hostnames.test.ts.
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readdirSync, readFileSync, existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, resolve, join } from "node:path";
+// dist/__tests__/joblogic-excluded.test.js → maxy-code/brands
+const here = dirname(fileURLToPath(import.meta.url));
+const BRANDS_DIR = resolve(here, "../../../../brands");
+function shippedBrands() {
+    return readdirSync(BRANDS_DIR, { withFileTypes: true })
+        .filter((e) => e.isDirectory())
+        .map((e) => join(BRANDS_DIR, e.name, "brand.json"))
+        .filter((p) => existsSync(p))
+        .map((p) => {
+        const parsed = JSON.parse(readFileSync(p, "utf-8"));
+        return { name: parsed.hostname, excluded: (parsed.plugins?.excluded ?? []) };
+    });
+}
+test("brands/ directory is discoverable and non-empty", () => {
+    assert.ok(existsSync(BRANDS_DIR), `brands dir not found at ${BRANDS_DIR}`);
+    assert.ok(shippedBrands().length > 0, "no shipped brand.json found");
+});
+test("every shipped brand suspends joblogic via plugins.excluded", () => {
+    for (const { name, excluded } of shippedBrands()) {
+        assert.ok(excluded.includes("joblogic"), `brand "${name}" does not list "joblogic" in plugins.excluded; the joblogic ` +
+            `connector would ship in its payload and register as a native CC plugin, ` +
+            `hijacking generic "jobs" queries (Task 1386)`);
+    }
+});

package/dist/__tests__/launchd-plist.test.js

@@ -10,7 +10,7 @@
 // package so `node --test dist/__tests__/*.test.js` picks it up after build.
 import test from "node:test";
 import assert from "node:assert/strict";
-import { renderPlist } from "../launchd-plist.js";
+import { renderPlist, buildSessionManagerWrapper } from "../launchd-plist.js";
 // ---------------------------------------------------------------------------
 // Standard render — every required field present, no escaping needed.
 // ---------------------------------------------------------------------------
@@ -193,3 +193,38 @@ test("renderPlist omits WorkingDirectory key when workingDirectory is absent", (
     assert.match(xml, /<key>KeepAlive<\/key>/);
     assert.match(xml, /<key>RunAtLoad<\/key>/);
 });
+// ---------------------------------------------------------------------------
+// buildSessionManagerWrapper — Task 1395 gap 2
+// ---------------------------------------------------------------------------
+test("buildSessionManagerWrapper sources .env and execs the manager", () => {
+    const w = buildSessionManagerWrapper({
+        envPath: "/Users/x/.maxy/.env",
+        installDir: "/Users/x/maxy-code",
+        nodeBin: "/usr/local/bin/node",
+        persistDir: "/Users/x/.maxy",
+        brandPort: 19200,
+    });
+    assert.match(w, /^#!\/bin\/bash\n/);
+    assert.match(w, /set -a; \[ -f "\/Users\/x\/\.maxy\/\.env" \] && \. "\/Users\/x\/\.maxy\/\.env"; set \+a/);
+    assert.match(w, /export CLAUDE_SESSION_MANAGER_PERSIST_DIR="\/Users\/x\/\.maxy"/);
+    assert.match(w, /export PLATFORM_ROOT="\/Users\/x\/maxy-code\/platform"/);
+    assert.match(w, /export MAXY_BRAND_PORT="19200"/);
+    assert.match(w, /export PLATFORM_PORT="19200"/);
+    assert.match(w, /cd "\/Users\/x\/maxy-code\/platform\/services\/claude-session-manager"/);
+    assert.match(w, /exec \/usr\/local\/bin\/node dist\/index\.js\n$/);
+});
+test("session-manager plist renders bash wrapper as sole ProgramArguments", () => {
+    const xml = renderPlist({
+        label: "com.rubytech.maxy-code-claude-session-manager",
+        programArguments: ["/bin/bash", "/Users/x/.maxy/claude-session-manager-wrapper.sh"],
+        stdoutPath: "/Users/x/.maxy/logs/server.log",
+        stderrPath: "/Users/x/.maxy/logs/server.log",
+        keepAlive: true,
+        runAtLoad: true,
+        workingDirectory: "/Users/x/maxy-code/platform/services/claude-session-manager",
+    });
+    assert.match(xml, /<string>com\.rubytech\.maxy-code-claude-session-manager<\/string>/);
+    assert.match(xml, /<string>\/bin\/bash<\/string>\s*<string>\/Users\/x\/\.maxy\/claude-session-manager-wrapper\.sh<\/string>/);
+    assert.match(xml, /<key>KeepAlive<\/key>\s*<true\/>/);
+    assert.match(xml, /<key>RunAtLoad<\/key>\s*<true\/>/);
+});

package/dist/__tests__/macos-darwin-branch.test.js

@@ -81,3 +81,21 @@ test("uninstall darwin path bootsout the LaunchAgent and removes the plist", ()
     // brand-keyed — install + uninstall both depend on the same label shape.
     assert.match(SRC, /function launchdLabel\(\):\s*string\s*\{\s*return\s*`com\.rubytech\.\$\{BRAND\.hostname\}`/);
 });
+test("resetNeo4jAuth has a darwin branch that uses brew services and no sudo", () => {
+    // On darwin Neo4j runs under a user launchd agent (brew services) and its
+    // datadir is user-owned — no systemctl, no sudo. Task 1394. Static-grep, not
+    // behaviour: resetNeo4jAuth spawns brew/neo4j-admin and can't run headless.
+    const fn = SRC.slice(SRC.indexOf("function resetNeo4jAuth"), SRC.indexOf("function redactInstallLogs"));
+    assert.match(fn, /platform === "darwin"/, "resetNeo4jAuth must branch on darwin");
+    assert.match(fn, /brew["']?,\s*\[["']services["']\s*,\s*["']stop["']/, "darwin branch stops neo4j via brew services");
+    assert.match(fn, /brew["']?,\s*\[["']services["']\s*,\s*["']start["']/, "darwin branch starts neo4j via brew services");
+    assert.match(fn, /neo4j-darwin-auth-reset/, "darwin branch emits the reset observability marker");
+    // The darwin branch must NOT shell out to systemctl or sudo (that path is
+    // Linux-only). Match invocation shapes — quoted command literals and the
+    // `sudo: true` option — not prose, so the branch's own explanatory comment
+    // ("no systemctl, no sudo") does not defeat the assertion.
+    const darwinBranch = fn.slice(fn.indexOf('platform === "darwin"'), fn.indexOf("} else {"));
+    assert.ok(!/["']systemctl["']/.test(darwinBranch), "darwin branch must not invoke systemctl");
+    assert.ok(!/["']sudo["']/.test(darwinBranch), "darwin branch must not spawn sudo");
+    assert.ok(!/sudo:\s*true/.test(darwinBranch), "darwin branch must not pass { sudo: true } on the user-owned datadir");
+});

package/dist/__tests__/neo4j-datadir.test.js

@@ -0,0 +1,14 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { resolveNeo4jDataDir } from "../neo4j-datadir.js";
+test("darwin resolves the Homebrew datadir under the brew prefix (Intel + Apple Silicon)", () => {
+    assert.equal(resolveNeo4jDataDir({ platform: "darwin", brewPrefix: "/usr/local", dedicated: false, hostname: "maxy-code" }), "/usr/local/var/neo4j");
+    assert.equal(resolveNeo4jDataDir({ platform: "darwin", brewPrefix: "/opt/homebrew", dedicated: false, hostname: "maxy-code" }), "/opt/homebrew/var/neo4j");
+});
+test("darwin ignores dedicated — only the shared Homebrew instance exists on darwin", () => {
+    assert.equal(resolveNeo4jDataDir({ platform: "darwin", brewPrefix: "/usr/local", dedicated: true, hostname: "realagent-code" }), "/usr/local/var/neo4j");
+});
+test("linux shared and dedicated datadirs are unchanged", () => {
+    assert.equal(resolveNeo4jDataDir({ platform: "linux", brewPrefix: "", dedicated: false, hostname: "maxy-code" }), "/var/lib/neo4j");
+    assert.equal(resolveNeo4jDataDir({ platform: "linux", brewPrefix: "", dedicated: true, hostname: "realagent" }), "/var/lib/neo4j-realagent");
+});

package/dist/claude-bin.js

@@ -0,0 +1,78 @@
+// Task 1395 gap 4 — resolve one canonical `claude` binary.
+//
+// A Mac can carry more than one `claude` on PATH at different versions — e.g.
+// an npm-global (nvm/Homebrew node) claude AND a Homebrew Cask `claude-code` at
+// /usr/local/bin/claude. Whichever the runtime PATH hits first wins, which
+// during the Task 1393 migration was the STALE Cask (2.1.153) rather than the
+// logged-in nvm binary (2.1.201). The installer resolves a single canonical
+// path and persists it as CLAUDE_BIN in `.env`; every runtime spawn then uses
+// that exact binary instead of a PATH lottery.
+//
+// Canonical = highest version. This is deterministic and picks the newest
+// claude, which is the defensible choice when two are present. All fs/spawn I/O
+// is injected so the resolver stays pure and unit-testable.
+import { join } from "node:path";
+/** Extract the leading dotted-numeric version from `claude --version` output,
+ *  e.g. "2.1.201 (Claude Code)" -> "2.1.201". Returns null when absent. */
+export function parseClaudeVersion(raw) {
+    const m = raw.trim().match(/(\d+(?:\.\d+)+)/);
+    return m ? m[1] : null;
+}
+function toParts(v) {
+    const m = v.trim().match(/^(\d+(?:\.\d+)*)/);
+    return m ? m[1].split(".").map((n) => parseInt(n, 10)) : [];
+}
+/** Numeric dotted-version compare (a<b -> <0, a>b -> >0). Missing parts = 0. */
+export function compareVersions(a, b) {
+    const pa = toParts(a);
+    const pb = toParts(b);
+    const len = Math.max(pa.length, pb.length);
+    for (let i = 0; i < len; i++) {
+        const d = (pa[i] ?? 0) - (pb[i] ?? 0);
+        if (d !== 0)
+            return d;
+    }
+    return 0;
+}
+/** Pick the highest-version candidate's path; first-wins on ties. Null when the
+ *  list is empty. */
+export function pickCanonicalClaude(candidates) {
+    if (candidates.length === 0)
+        return null;
+    let best = candidates[0];
+    for (let i = 1; i < candidates.length; i++) {
+        if (compareVersions(candidates[i].version, best.version) > 0)
+            best = candidates[i];
+    }
+    return best.path;
+}
+/** Enumerate every distinct `claude` reachable from `pathEnv` (colon-separated
+ *  PATH), deduped by realpath, each probed for its version. Non-executable
+ *  entries, symlink duplicates, and version-probe failures are skipped. */
+export function enumerateClaudeCandidates(pathEnv, deps) {
+    const seen = new Set();
+    const out = [];
+    for (const dir of pathEnv.split(":").filter(Boolean)) {
+        const cand = join(dir, "claude");
+        if (!deps.isExecutable(cand))
+            continue;
+        let real;
+        try {
+            real = deps.realpath(cand);
+        }
+        catch {
+            real = cand;
+        }
+        if (seen.has(real))
+            continue;
+        seen.add(real);
+        const raw = deps.runVersion(cand);
+        if (!raw)
+            continue;
+        const version = parseClaudeVersion(raw);
+        if (!version)
+            continue;
+        out.push({ path: cand, version });
+    }
+    return out;
+}

package/dist/claude-upgrade-privilege.js

@@ -0,0 +1,21 @@
+// Pure decision for whether the phase-3 `npm install -g @anthropic-ai/claude-code`
+// upgrade runs under sudo, runs unprivileged, or is skipped. Peer of
+// apt-resolve.ts / brew-resolve.ts: no spawnSync, no fs — the caller injects the
+// probed inputs and applies the result.
+//
+// Root cause this encodes: on darwin the npm global prefix (nvm or Homebrew) is
+// user-owned, so `npm install -g` needs no sudo; wrapping it in sudo forces a
+// non-interactive password prompt that hard-fails. On Linux the global prefix is
+// root-owned by default, so the existing sudo-or-skip behaviour is preserved
+// unchanged (prefixWritable is not consulted on Linux).
+export function decideClaudeUpgradePrivilege(input) {
+    if (input.platform === "darwin") {
+        if (input.prefixWritable)
+            return "run-no-sudo";
+        if (input.canSudo)
+            return "run-sudo";
+        return "skip";
+    }
+    // linux: unchanged from the historical `isLinux() && !canSudo()` skip.
+    return input.canSudo ? "run-sudo" : "skip";
+}