@rubytech/create-maxy-code 0.1.223 → 0.1.225

package/dist/__tests__/installer-settings-permissions.test.js

@@ -0,0 +1,112 @@
+// Task 583 — Installer must seed permissions.defaultMode=bypassPermissions
+// and permissions.allow=["*"] into the brand-scoped settings.json so
+// claude.ai/code sessions never fall through to the Anthropic remote
+// auto-classifier. Existing top-level keys must be preserved; an
+// already-correct file must be a true no-op (mtime unchanged).
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, readFileSync, writeFileSync, statSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { seedBypassPermissionsSettings, assertBypassPermissionsSeed, BYPASS_PERMISSIONS_BLOCK } from "../permissions-seed.js";
+function freshDir() {
+    return mkdtempSync(join(tmpdir(), "t583-"));
+}
+test("empty target: creates settings.json with the permissions block", () => {
+    const dir = freshDir();
+    try {
+        const result = seedBypassPermissionsSettings(dir);
+        assert.equal(result.action, "seeded");
+        assert.equal(result.path, join(dir, "settings.json"));
+        const parsed = JSON.parse(readFileSync(result.path, "utf-8"));
+        assert.deepEqual(parsed, { permissions: { defaultMode: "bypassPermissions", allow: ["*"], deny: [] } });
+        assert.equal(assertBypassPermissionsSeed(dir).status, "ok");
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+test("existing keys preserved verbatim; permissions added", () => {
+    const dir = freshDir();
+    try {
+        const settingsPath = join(dir, "settings.json");
+        const existing = {
+            enabledPlugins: { "memory@claude-plugins-official": true },
+            extraKnownMarketplaces: { "claude-plugins-official": { source: { source: "github", repo: "anthropics/claude-plugins-official" } } },
+            inputNeededNotifEnabled: false,
+            agentPushNotifEnabled: false,
+            model: "opus",
+        };
+        writeFileSync(settingsPath, JSON.stringify(existing, null, 2));
+        const result = seedBypassPermissionsSettings(dir);
+        assert.equal(result.action, "seeded");
+        const parsed = JSON.parse(readFileSync(settingsPath, "utf-8"));
+        assert.deepEqual(parsed.enabledPlugins, existing.enabledPlugins);
+        assert.deepEqual(parsed.extraKnownMarketplaces, existing.extraKnownMarketplaces);
+        assert.equal(parsed.inputNeededNotifEnabled, false);
+        assert.equal(parsed.agentPushNotifEnabled, false);
+        assert.equal(parsed.model, "opus");
+        assert.deepEqual(parsed.permissions, { defaultMode: "bypassPermissions", allow: ["*"], deny: [] });
+        assert.equal(assertBypassPermissionsSeed(dir).status, "ok");
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+test("idempotent: already-correct block triggers no write", () => {
+    const dir = freshDir();
+    try {
+        const settingsPath = join(dir, "settings.json");
+        writeFileSync(settingsPath, JSON.stringify({ model: "opus", permissions: { defaultMode: "bypassPermissions", allow: ["*"], deny: [] } }, null, 2));
+        const before = statSync(settingsPath).mtimeMs;
+        // Small busy-wait so a same-millisecond write would be detectable on
+        // filesystems with millisecond mtime granularity.
+        const target = Date.now() + 15;
+        while (Date.now() < target) { /* spin */ }
+        const result = seedBypassPermissionsSettings(dir);
+        assert.equal(result.action, "noop");
+        const after = statSync(settingsPath).mtimeMs;
+        assert.equal(after, before, "mtime must not change on noop");
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+test("malformed JSON: overwrites with the seeded block", () => {
+    const dir = freshDir();
+    try {
+        const settingsPath = join(dir, "settings.json");
+        writeFileSync(settingsPath, "{ not json");
+        const result = seedBypassPermissionsSettings(dir);
+        assert.equal(result.action, "seeded");
+        assert.equal(assertBypassPermissionsSeed(dir).status, "ok");
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+test("assert: missing file reports missing", () => {
+    const dir = freshDir();
+    try {
+        assert.equal(assertBypassPermissionsSeed(dir).status, "missing");
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+test("assert: partial block (no wildcard) reports missing", () => {
+    const dir = freshDir();
+    try {
+        writeFileSync(join(dir, "settings.json"), JSON.stringify({ permissions: { defaultMode: "default", allow: [], deny: [] } }));
+        assert.equal(assertBypassPermissionsSeed(dir).status, "missing");
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+test("BYPASS_PERMISSIONS_BLOCK frozen literal matches expected shape", () => {
+    assert.equal(BYPASS_PERMISSIONS_BLOCK.defaultMode, "bypassPermissions");
+    assert.deepEqual([...BYPASS_PERMISSIONS_BLOCK.allow], ["*"]);
+    assert.deepEqual([...BYPASS_PERMISSIONS_BLOCK.deny], []);
+    assert.ok(Object.isFrozen(BYPASS_PERMISSIONS_BLOCK));
+});

package/dist/index.js

@@ -2,6 +2,7 @@
 import { execFileSync, spawn, spawnSync } from "node:child_process";
 import { existsSync, mkdirSync, writeFileSync, cpSync, readFileSync, rmSync, readdirSync, appendFileSync, openSync, closeSync, chmodSync, statSync, realpathSync } from "node:fs";
 import { registerSpecialistAgentsAt, SpecialistSymlinkCollision } from "./specialist-registration.js";
+import { seedBypassPermissionsSettings, assertBypassPermissionsSeed } from "./permissions-seed.js";
 import { resolve, join, dirname } from "node:path";
 import { randomBytes } from "node:crypto";
 import { resolveInstallPortFromFs, buildMaxyUnitFile, buildClaudeSessionManagerUnitFile, buildClaudePtysSliceUnitFile } from "./port-resolution.js";
@@ -953,6 +954,12 @@ function installClaudeCode() {
     // pre-create the per-brand CLAUDE_CONFIG_DIR so the first
     // `claude plugin marketplace add` has a directory to write into.
     mkdirSync(CLAUDE_CONFIG_DIR, { recursive: true });
+    // Task 583 — seed the brand-scoped permissions block so claude.ai/code
+    // sessions short-circuit Stage 1 of the local matcher and never fall
+    // through to the Anthropic remote auto-classifier (which routes Agent
+    // dispatch to `ask` and surfaces a prompt no unattended operator clicks).
+    const permissionsSeed = seedBypassPermissionsSettings(CLAUDE_CONFIG_DIR);
+    logFile(`[install-permissions] action=${permissionsSeed.action} path=${permissionsSeed.path}`);
     const marketplaceList = spawnSync("claude", ["plugin", "marketplace", "list"], { stdio: "pipe", encoding: "utf-8", env: claudePluginEnv() });
     if (marketplaceList.stderr)
         process.stderr.write(marketplaceList.stderr);
@@ -2053,6 +2060,12 @@ function registerLocalAndExternalPlugins() {
         throw new Error(`Plugin registration incomplete: expected marketplaces ${JSON.stringify([...expectedMarketplaces])} but \`claude plugin marketplace list\` returned ${JSON.stringify(actualMarketplaces)}. Missing: ${JSON.stringify(missing)}. Check setup.log for [plugin-marketplace] ERROR lines.`);
     }
     logFile(`[plugin-marketplace] assertion-source=claude-plugin-marketplace-list count=${actualMarketplaces.length} marketplaces=${JSON.stringify(actualMarketplaces)} CLAUDE_CONFIG_DIR=${CLAUDE_CONFIG_DIR}`);
+    // Task 583 — post-install assertion that the brand-scoped permissions
+    // block survived install. Warn-only: a missing block does not abort the
+    // install (consistent with the marketplace ERROR path that logs and
+    // continues per-entry), but surfaces in setup.log for diagnosis.
+    const permissionsAssert = assertBypassPermissionsSeed(CLAUDE_CONFIG_DIR);
+    logFile(`[install-permissions] brand-settings=${permissionsAssert.status} path=${permissionsAssert.path}`);
 }
 function buildPlatform() {
     log("9", TOTAL, "Installing dependencies and building...");

package/dist/permissions-seed.js

@@ -0,0 +1,76 @@
+// Task 583 — Seed Claude Code's two-stage permission classifier with a
+// wildcard allow so claude.ai/code sessions never fall through to the
+// Anthropic remote auto-classifier. The classifier routes `Agent`/`Task`
+// to `ask`, which surfaces as a permission prompt that an unattended
+// operator never clicks — observed as 4-minute dead-air hangs on
+// realagent-code.
+//
+// This module is the single writer for the brand-scoped settings.json
+// permissions block. Account-scoped settings.json is written by
+// platform/scripts/setup-account.sh in lockstep with the same shape.
+import { readFileSync, writeFileSync, renameSync, existsSync, mkdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+export const BYPASS_PERMISSIONS_BLOCK = Object.freeze({
+    defaultMode: "bypassPermissions",
+    allow: ["*"],
+    deny: [],
+});
+function isAlreadyCorrect(permissions) {
+    if (!permissions || typeof permissions !== "object")
+        return false;
+    const p = permissions;
+    if (p.defaultMode !== "bypassPermissions")
+        return false;
+    if (!Array.isArray(p.allow) || !p.allow.includes("*"))
+        return false;
+    if (!Array.isArray(p.deny) || p.deny.length !== 0)
+        return false;
+    return true;
+}
+export function seedBypassPermissionsSettings(configDir) {
+    const settingsPath = join(configDir, "settings.json");
+    let existing = {};
+    if (existsSync(settingsPath)) {
+        const text = readFileSync(settingsPath, "utf-8");
+        if (text.trim().length > 0) {
+            try {
+                const parsed = JSON.parse(text);
+                if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                    existing = parsed;
+                }
+            }
+            catch {
+                // Malformed JSON: treat as empty and overwrite with a well-formed
+                // file containing only the permissions block. Any keys the prior
+                // file carried are unrecoverable from invalid JSON anyway.
+            }
+        }
+    }
+    if (isAlreadyCorrect(existing.permissions)) {
+        return { action: "noop", path: settingsPath };
+    }
+    mkdirSync(dirname(settingsPath), { recursive: true });
+    const merged = { ...existing, permissions: { ...BYPASS_PERMISSIONS_BLOCK, allow: [...BYPASS_PERMISSIONS_BLOCK.allow], deny: [] } };
+    const tmpPath = `${settingsPath}.task583.tmp`;
+    writeFileSync(tmpPath, JSON.stringify(merged, null, 2) + "\n");
+    renameSync(tmpPath, settingsPath);
+    return { action: "seeded", path: settingsPath };
+}
+export function assertBypassPermissionsSeed(configDir) {
+    const settingsPath = join(configDir, "settings.json");
+    if (!existsSync(settingsPath))
+        return { status: "missing", path: settingsPath };
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(settingsPath, "utf-8"));
+    }
+    catch {
+        return { status: "missing", path: settingsPath };
+    }
+    if (!parsed || typeof parsed !== "object")
+        return { status: "missing", path: settingsPath };
+    const permissions = parsed.permissions;
+    return isAlreadyCorrect(permissions)
+        ? { status: "ok", path: settingsPath }
+        : { status: "missing", path: settingsPath };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rubytech/create-maxy-code",
-  "version": "0.1.223",
+  "version": "0.1.225",
   "description": "Install Maxy — AI for Productive People",
   "bin": {
     "create-maxy-code": "./dist/index.js"

package/payload/platform/plugins/admin/mcp/dist/index.js

@@ -1969,7 +1969,7 @@ eagerTool(server, "skill-load", "Load a plugin skill's SKILL.md body by skill na
 // sentinel that read like a successful render to the agent while the
 // chat surface saw nothing. Admin flows now use plain markdown for
 // reviewable artefacts and the `file-presentation` skill for downloadable
-// artefacts (delivered via `SendUserFile`, the native Claude Code surface).
+// artefacts (written under output/ and delivered by stating their location).
 // The :Component / :KnowledgeDocument
 // persistence pipeline is preserved for historical conversations that
 // already carry the rows; no new conversations write to it.