memax-cli 0.1.0-alpha.5 → 0.1.0-alpha.50

package/dist/commands/setup.js

@@ -1,11 +1,29 @@
 import chalk from "chalk";
-import { readFileSync, writeFileSync, mkdirSync, existsSync, chmodSync, } from "node:fs";
-import { join, dirname } from "node:path";
-import { homedir, platform } from "node:os";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
 import { execSync } from "node:child_process";
+import { createInterface } from "node:readline";
+import { commandExists, resolveMemaxBin, } from "./setup-types.js";
+import { ensureApiKey, ensureLocalAgentKey, setupMcpRemote, setupMcpOAuth, setupMcp, printMcpConfigs, removeMcpJson, removeMcpToml, } from "./setup-mcp.js";
+import { setupHooks, removeHooks } from "./setup-hooks.js";
+import { injectInstructions, removeInstructions, installSkills, removeSkills, } from "./setup-instructions.js";
+// --- Agent definitions ---
 function getAgents() {
     const home = homedir();
-    const isWin = platform() === "win32";
+    const cwd = process.cwd();
+    // Helper: standard { type: "url", url, headers? } shape used by Cursor, Windsurf, OpenClaw
+    const stdUrlEntry = (url, headers) => ({
+        type: "url",
+        url,
+        ...(headers ? { headers } : {}),
+    });
+    // Helper: { type: "http", url, headers? } shape used by VS Code, Copilot CLI
+    const httpEntry = (url, headers) => ({
+        type: "http",
+        url,
+        ...(headers ? { headers } : {}),
+    });
     return [
         {
             name: "Claude Code",
@@ -14,7 +32,10 @@ function getAgents() {
             format: "json-mcpServers",
             mcpKey: "mcpServers",
             hasHooks: true,
+            globalInstructionFile: join(home, ".claude", "CLAUDE.md"),
             detect: () => existsSync(join(home, ".claude")) || commandExists("claude"),
+            // Claude Code uses `claude mcp add` CLI, not JSON config — this is a fallback
+            remoteEntry: stdUrlEntry,
         },
         {
             name: "Cursor",
@@ -23,7 +44,9 @@ function getAgents() {
             format: "json-mcpServers",
             mcpKey: "mcpServers",
             hasHooks: false,
+            globalInstructionFile: null,
             detect: () => existsSync(join(home, ".cursor")) || commandExists("cursor"),
+            remoteEntry: stdUrlEntry,
         },
         {
             name: "Windsurf",
@@ -32,8 +55,10 @@ function getAgents() {
             format: "json-mcpServers",
             mcpKey: "mcpServers",
             hasHooks: false,
+            globalInstructionFile: null,
             detect: () => existsSync(join(home, ".codeium", "windsurf")) ||
                 commandExists("windsurf"),
+            remoteEntry: stdUrlEntry,
         },
         {
             name: "Gemini CLI",
@@ -42,7 +67,13 @@ function getAgents() {
             format: "json-mcpServers",
             mcpKey: "mcpServers",
             hasHooks: true,
+            globalInstructionFile: join(home, ".gemini", "GEMINI.md"),
             detect: () => existsSync(join(home, ".gemini")) || commandExists("gemini"),
+            // Gemini CLI uses httpUrl for streamable HTTP; url is its SSE field
+            remoteEntry: (url, headers) => ({
+                httpUrl: url,
+                ...(headers ? { headers } : {}),
+            }),
         },
         {
             name: "GitHub Copilot CLI",
@@ -51,16 +82,32 @@ function getAgents() {
             format: "json-mcpServers",
             mcpKey: "mcpServers",
             hasHooks: false,
+            globalInstructionFile: null,
             detect: () => existsSync(join(home, ".copilot")) || commandExists("gh copilot"),
+            // Copilot CLI requires type + url + tools for both remote and local servers
+            remoteEntry: (url, headers) => ({
+                type: "http",
+                url,
+                tools: [{ type: "function" }],
+                ...(headers ? { headers } : {}),
+            }),
+            localEntry: (command, args) => ({
+                command,
+                args,
+                tools: [{ type: "function" }],
+            }),
         },
         {
             name: "Copilot (VS Code)",
             id: "vscode",
-            configPath: join(".vscode", "mcp.json"), // project-level
+            configPath: join(".vscode", "mcp.json"),
             format: "json-servers",
             mcpKey: "servers",
             hasHooks: false,
+            globalInstructionFile: null,
             detect: () => existsSync(".vscode") || commandExists("code"),
+            // VS Code uses type: "http" for remote MCP servers
+            remoteEntry: httpEntry,
         },
         {
             name: "Codex CLI",
@@ -69,23 +116,106 @@ function getAgents() {
             format: "toml",
             mcpKey: "mcp_servers",
             hasHooks: false,
+            globalInstructionFile: join(home, ".codex", "AGENTS.md"),
             detect: () => existsSync(join(home, ".codex")) || commandExists("codex"),
+            // Codex TOML is handled separately; this is for JSON fallback reference
+            remoteEntry: stdUrlEntry,
+        },
+        {
+            name: "OpenClaw",
+            id: "openclaw",
+            configPath: join(home, ".openclaw", "openclaw.json"),
+            format: "json-mcpServers",
+            mcpKey: "mcp.servers",
+            hasHooks: false,
+            globalInstructionFile: null,
+            detect: () => existsSync(join(home, ".openclaw")) || commandExists("openclaw"),
+            remoteEntry: stdUrlEntry,
+        },
+        {
+            name: "OpenCode",
+            id: "opencode",
+            configPath: join(cwd, ".opencode", "opencode.jsonc"),
+            format: "json-mcpServers",
+            mcpKey: "mcp",
+            hasHooks: false,
+            globalInstructionFile: null,
+            detect: () => existsSync(join(cwd, ".opencode")) || commandExists("opencode"),
+            // OpenCode uses type: "remote" for remote, type: "local" for local
+            remoteEntry: (url, headers) => ({
+                type: "remote",
+                url,
+                ...(headers ? { headers } : {}),
+            }),
+            localEntry: (command, args) => ({
+                type: "local",
+                command,
+                args,
+            }),
         },
     ];
 }
 export async function setupCommand(options) {
     const enableMcp = options.all || options.mcp;
     const enableHooks = options.all || options.hooks;
-    if (!enableMcp && !enableHooks) {
+    const enableInstructions = options.all || options.instructions;
+    if (!enableMcp && !enableHooks && !enableInstructions && !options.print) {
         printUsage();
         return;
     }
-    // Resolve memax binary
-    const memaxBin = resolveMemaxBin();
-    if (!memaxBin) {
-        console.error(chalk.red("\n  Could not find memax binary.\n  Install globally: npm install -g memax-cli@alpha\n"));
+    if (options.hub && options.agentSync) {
+        console.error(chalk.red("\n  --agent-sync cannot be combined with --hub because hub-scoped MCP keys are restricted to that hub only.\n"));
+        process.exit(1);
+    }
+    // Hub scoping requires API key mode — OAuth grants are configured during
+    // the consent screen, not at setup time.
+    if (options.hub && !options.apiKey) {
+        console.error(chalk.red("\n  --hub requires --api-key because hub scoping is configured per API key.\n  Use: memax setup --mcp --api-key --hub <id>\n"));
+        process.exit(1);
+    }
+    // Permission flags only apply to remote API key mode — reject in OAuth and local mode
+    const permissionFlags = [
+        options.readOnly && "--read-only",
+        options.allowDelete && "--allow-delete",
+        options.allowOrganize && "--allow-organize",
+        options.agentSync && "--agent-sync",
+    ].filter(Boolean);
+    if (permissionFlags.length > 0 && (!options.apiKey || options.local)) {
+        console.error(chalk.red(`\n  ${permissionFlags.join(", ")} only apply to remote API key mode.\n  Use: memax setup --mcp --api-key ${permissionFlags.join(" ")}\n`));
+        process.exit(1);
+    }
+    // --api-key is meaningless with --local
+    if (options.apiKey && options.local) {
+        console.error(chalk.red("\n  --api-key and --local are mutually exclusive.\n  Use --api-key for remote API key mode, or --local for local CLI mode.\n"));
         process.exit(1);
     }
+    // --print: just output config JSON for manual copy/paste
+    if (options.print) {
+        await printMcpConfigs({
+            local: options.local ?? false,
+            apiKey: options.apiKey ?? false,
+            hub: options.hub,
+            readOnly: options.readOnly,
+            allowDelete: options.allowDelete,
+            allowOrganize: options.allowOrganize,
+            agentSync: options.agentSync,
+        });
+        return;
+    }
+    // Remote mode (default): OAuth auto-discovery (no API key in config)
+    // --api-key: use per-agent API keys (legacy mode, for CI/CD or agents without OAuth)
+    // --local: use local CLI binary (memax mcp serve)
+    const useRemote = !options.local;
+    const useApiKey = options.apiKey ?? false;
+    // Local mode: need memax binary
+    let memaxBin = null;
+    if (!useRemote || enableHooks) {
+        memaxBin = resolveMemaxBin();
+        if (!memaxBin && !useRemote) {
+            console.error(chalk.red("\n  Could not find memax binary.\n  Install globally: npm install -g memax-cli@alpha\n"));
+            process.exit(1);
+        }
+    }
     // Filter agents
     const allAgents = getAgents();
     const onlySet = options.only
@@ -111,21 +241,57 @@ export async function setupCommand(options) {
         return;
     }
     console.log(chalk.bold("\n  Memax Setup\n"));
+    if (useRemote && useApiKey) {
+        console.log(chalk.gray("  Mode: remote server (API key)\n"));
+    }
+    else if (useRemote) {
+        console.log(chalk.gray("  Mode: remote server (OAuth)\n"));
+    }
+    else {
+        console.log(chalk.gray("  Mode: local CLI\n"));
+    }
     const results = [];
     for (const agent of agents) {
         const changes = [];
-        // MCP setup
+        // MCP setup — OAuth (default), API key (--api-key), or local (--local)
         if (enableMcp) {
             try {
-                setupMcp(agent, memaxBin);
-                changes.push("MCP server");
+                if (useRemote && useApiKey) {
+                    // Legacy API key mode — creates per-agent key with agent_name
+                    const agentKey = await ensureApiKey(options.hub, agent.id, {
+                        readOnly: options.readOnly,
+                        allowDelete: options.allowDelete,
+                        allowOrganize: options.allowOrganize,
+                        agentSync: options.agentSync,
+                    });
+                    if (!agentKey) {
+                        console.error(chalk.red(`  ✗ ${agent.name}: Could not create API key. Run: memax login`));
+                        continue;
+                    }
+                    setupMcpRemote(agent, agentKey);
+                    changes.push("MCP server (API key)");
+                }
+                else if (useRemote) {
+                    // OAuth mode (default) — no API key in config, agent auto-discovers auth
+                    setupMcpOAuth(agent);
+                    changes.push("MCP server (OAuth)");
+                }
+                else {
+                    const localAgentKey = await ensureLocalAgentKey(agent.id);
+                    if (!localAgentKey) {
+                        console.error(chalk.red(`  ✗ ${agent.name}: Could not provision local agent key. Run: memax login`));
+                        continue;
+                    }
+                    setupMcp(agent, memaxBin);
+                    changes.push("MCP server (local agent auth)");
+                }
             }
             catch (err) {
                 console.log(chalk.red(`  ✗ ${agent.name}: MCP setup failed — ${err.message}`));
             }
         }
-        // Hook setup (only for agents that support it)
-        if (enableHooks && agent.hasHooks) {
+        // Hook setup (only for agents that support it — needs local binary)
+        if (enableHooks && agent.hasHooks && memaxBin) {
             try {
                 setupHooks(agent, memaxBin);
                 changes.push("Context injection hook");
@@ -134,6 +300,26 @@ export async function setupCommand(options) {
                 console.log(chalk.red(`  ✗ ${agent.name}: Hook setup failed — ${err.message}`));
             }
         }
+        // Inject memax instructions into agent's global instruction file
+        if (enableInstructions && agent.globalInstructionFile) {
+            try {
+                injectInstructions(agent.globalInstructionFile);
+                changes.push("Instructions injected");
+            }
+            catch (err) {
+                console.log(chalk.red(`  ✗ ${agent.name}: Instruction injection failed — ${err.message}`));
+            }
+            // Install memax skills for agents that support skill directories
+            try {
+                const skillCount = await installSkills(agent);
+                if (skillCount > 0) {
+                    changes.push(`${skillCount} skill${skillCount > 1 ? "s" : ""} installed`);
+                }
+            }
+            catch (err) {
+                console.log(chalk.red(`  ✗ ${agent.name}: Skill install failed — ${err.message}`));
+            }
+        }
         if (changes.length > 0) {
             results.push({ agent: agent.name, changes });
         }
@@ -153,8 +339,8 @@ export async function setupCommand(options) {
     console.log(chalk.gray("\n  MCP tools available to all configured agents:"));
     console.log(chalk.gray("    • memax_recall — semantic search your knowledge"));
     console.log(chalk.gray("    • memax_push   — save knowledge from sessions"));
-    console.log(chalk.gray("    • memax_get    — read full note by ID"));
-    console.log(chalk.gray("    • memax_search — browse notes by category"));
+    console.log(chalk.gray("    • memax_get    — read full memory by ID"));
+    console.log(chalk.gray("    • memax_list   — browse memories"));
     if (enableHooks) {
         const hookAgents = results.filter((r) => r.changes.includes("Context injection hook"));
         if (hookAgents.length > 0) {
@@ -162,8 +348,32 @@ export async function setupCommand(options) {
             console.log(chalk.gray("  Every prompt gets relevant context injected automatically."));
         }
     }
-    console.log(chalk.gray("\n  Restart your agents for changes to take effect.\n"));
+    console.log(chalk.gray("\n  Restart your agents for changes to take effect."));
+    // Offer to restore configs from cloud if this looks like a new device
+    if (enableInstructions || options.all) {
+        try {
+            const { syncAgentMemoryCommand } = await import("./sync.js");
+            const rl = createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            const restore = await new Promise((resolve) => {
+                rl.question(chalk.gray("\n  Restore agent configs from Memax cloud? [Y/n] "), (answer) => {
+                    rl.close();
+                    resolve(answer.trim().toLowerCase() !== "n");
+                });
+            });
+            if (restore) {
+                await syncAgentMemoryCommand({ skipConflicts: true });
+            }
+        }
+        catch {
+            // Sync not available (not logged in, etc.) — skip silently
+        }
+    }
+    console.log();
 }
+// --- Teardown command ---
 export async function teardownCommand(options) {
     const allAgents = getAgents();
     const onlySet = options.only
@@ -178,19 +388,30 @@ export async function teardownCommand(options) {
             // Claude Code uses its own CLI
             if (agent.id === "claude-code") {
                 if (commandExists("claude")) {
-                    try {
-                        execSync("claude mcp remove memax", { stdio: "pipe" });
-                        console.log(chalk.gray(`  Removed MCP from ${agent.name}`));
-                        removed = true;
-                    }
-                    catch {
-                        // Not installed
+                    // Remove from both user and project scope to clean up old
+                    // (pre-scope) and new (user-scoped) installs
+                    for (const scope of ["--scope user", ""]) {
+                        try {
+                            execSync(`claude mcp remove memax ${scope}`.trim(), {
+                                stdio: "pipe",
+                            });
+                            console.log(chalk.gray(`  Removed MCP from ${agent.name}${scope ? " (user scope)" : " (project scope)"}`));
+                            removed = true;
+                        }
+                        catch {
+                            // Not installed in this scope
+                        }
                     }
                 }
                 if (agent.hasHooks && existsSync(agent.configPath)) {
                     if (removeHooks(agent))
                         removed = true;
                 }
+                if (agent.globalInstructionFile &&
+                    removeInstructions(agent.globalInstructionFile)) {
+                    console.log(chalk.gray(`  Removed instructions from ${agent.name}`));
+                    removed = true;
+                }
                 continue;
             }
             if (!existsSync(agent.configPath))
@@ -205,6 +426,15 @@ export async function teardownCommand(options) {
             }
             if (agent.hasHooks && removeHooks(agent))
                 removed = true;
+            if (agent.globalInstructionFile &&
+                removeInstructions(agent.globalInstructionFile)) {
+                console.log(chalk.gray(`  Removed instructions from ${agent.name}`));
+                removed = true;
+            }
+            if (removeSkills(agent)) {
+                console.log(chalk.gray(`  Removed skills from ${agent.name}`));
+                removed = true;
+            }
         }
         catch {
             // Skip agents we can't clean up
@@ -216,270 +446,7 @@ export async function teardownCommand(options) {
     }
     console.log(chalk.green("\n  Memax integrations removed.\n  Restart your agents for changes to take effect.\n"));
 }
-// --- MCP setup per agent ---
-function setupMcp(agent, bin) {
-    // Claude Code has its own CLI for MCP management
-    if (agent.id === "claude-code") {
-        setupMcpClaudeCode(bin);
-        return;
-    }
-    mkdirSync(dirname(agent.configPath), { recursive: true });
-    if (agent.format === "toml") {
-        setupMcpToml(agent, bin);
-        return;
-    }
-    // JSON-based agents
-    let config = {};
-    if (existsSync(agent.configPath)) {
-        try {
-            config = JSON.parse(readFileSync(agent.configPath, "utf-8"));
-        }
-        catch {
-            // Start fresh
-        }
-    }
-    const servers = (config[agent.mcpKey] ?? {});
-    servers.memax = {
-        command: bin.command,
-        args: [...bin.args, "mcp", "serve"],
-    };
-    config[agent.mcpKey] = servers;
-    writeFileSync(agent.configPath, JSON.stringify(config, null, 2) + "\n");
-}
-function setupMcpClaudeCode(bin) {
-    // Claude Code uses its own CLI for MCP — settings.json mcpServers is ignored
-    if (!commandExists("claude")) {
-        throw new Error("claude CLI not found in PATH");
-    }
-    // Remove existing first (idempotent)
-    try {
-        execSync("claude mcp remove memax", { stdio: "pipe" });
-    }
-    catch {
-        // Not installed yet — fine
-    }
-    // claude mcp add <name> -- <command> [args...]
-    const allArgs = [...bin.args, "mcp", "serve"];
-    const cmd = `claude mcp add memax -- ${bin.command} ${allArgs.join(" ")}`;
-    try {
-        execSync(cmd, { stdio: "pipe" });
-    }
-    catch (err) {
-        throw new Error(`claude mcp add failed: ${err.message}`);
-    }
-}
-function setupMcpToml(agent, bin) {
-    // Codex uses TOML — append or update the memax section
-    let content = "";
-    if (existsSync(agent.configPath)) {
-        content = readFileSync(agent.configPath, "utf-8");
-    }
-    // Remove existing memax section if present
-    content = content.replace(/\[mcp_servers\.memax\][\s\S]*?(?=\n\[|$)/, "");
-    const args = [...bin.args, "mcp", "serve"].map((a) => `"${a}"`).join(", ");
-    content = content.trim();
-    if (content)
-        content += "\n\n";
-    content += `[mcp_servers.memax]\ncommand = "${bin.command}"\nargs = [${args}]\n`;
-    writeFileSync(agent.configPath, content);
-}
-// --- Hook setup ---
-function setupHooks(agent, bin) {
-    if (agent.id === "claude-code") {
-        setupClaudeCodeHooks(agent, bin);
-    }
-    else if (agent.id === "gemini") {
-        setupGeminiHooks(agent, bin);
-    }
-}
-function setupClaudeCodeHooks(agent, bin) {
-    const hookScript = writeHookScript(bin);
-    let config = {};
-    if (existsSync(agent.configPath)) {
-        try {
-            config = JSON.parse(readFileSync(agent.configPath, "utf-8"));
-        }
-        catch {
-            // Start fresh
-        }
-    }
-    const hooks = (config.hooks ?? {});
-    // Remove existing memax hooks
-    if (hooks["UserPromptSubmit"]) {
-        hooks["UserPromptSubmit"] = hooks["UserPromptSubmit"].filter((h) => !h.hooks?.some((hh) => hh.command?.includes("memax")));
-    }
-    hooks["UserPromptSubmit"] = [
-        ...(hooks["UserPromptSubmit"] ?? []),
-        {
-            matcher: "",
-            hooks: [{ type: "command", command: hookScript, timeout: 30 }],
-        },
-    ];
-    config.hooks = hooks;
-    writeFileSync(agent.configPath, JSON.stringify(config, null, 2) + "\n");
-}
-function setupGeminiHooks(agent, bin) {
-    const hookScript = writeHookScript(bin);
-    let config = {};
-    if (existsSync(agent.configPath)) {
-        try {
-            config = JSON.parse(readFileSync(agent.configPath, "utf-8"));
-        }
-        catch {
-            // Start fresh
-        }
-    }
-    const hooks = (config.hooks ?? {});
-    // Remove existing memax hooks from both old ("Startup") and correct event
-    for (const event of ["Startup", "BeforeAgent"]) {
-        if (hooks[event]) {
-            hooks[event] = hooks[event].filter((h) => !h.hooks?.some((hh) => hh.command?.includes("memax")));
-            if (hooks[event].length === 0)
-                delete hooks[event];
-        }
-    }
-    // BeforeAgent fires after user submits a prompt — equivalent to Claude Code's PrePromptSubmit
-    hooks["BeforeAgent"] = [
-        ...(hooks["BeforeAgent"] ?? []),
-        {
-            matcher: "",
-            hooks: [{ type: "command", command: hookScript, timeout: 30 }],
-        },
-    ];
-    config.hooks = hooks;
-    writeFileSync(agent.configPath, JSON.stringify(config, null, 2) + "\n");
-}
-// --- Teardown helpers ---
-function removeMcpJson(agent) {
-    if (!existsSync(agent.configPath))
-        return false;
-    try {
-        const config = JSON.parse(readFileSync(agent.configPath, "utf-8"));
-        const servers = config[agent.mcpKey];
-        if (!servers?.memax)
-            return false;
-        delete servers.memax;
-        if (Object.keys(servers).length === 0)
-            delete config[agent.mcpKey];
-        writeFileSync(agent.configPath, JSON.stringify(config, null, 2) + "\n");
-        console.log(chalk.gray(`  Removed MCP from ${agent.name}`));
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function removeMcpToml(agent) {
-    if (!existsSync(agent.configPath))
-        return false;
-    let content = readFileSync(agent.configPath, "utf-8");
-    const before = content;
-    content = content.replace(/\[mcp_servers\.memax\][\s\S]*?(?=\n\[|$)/, "");
-    if (content === before)
-        return false;
-    writeFileSync(agent.configPath, content.trim() + "\n");
-    console.log(chalk.gray(`  Removed MCP from ${agent.name}`));
-    return true;
-}
-function removeHooks(agent) {
-    if (!existsSync(agent.configPath))
-        return false;
-    try {
-        const config = JSON.parse(readFileSync(agent.configPath, "utf-8"));
-        const hooks = config.hooks;
-        if (!hooks)
-            return false;
-        let removed = false;
-        for (const event of Object.keys(hooks)) {
-            const before = hooks[event].length;
-            hooks[event] = hooks[event].filter((h) => !h.command?.includes("memax") &&
-                !h.hooks?.some((hh) => hh.command?.includes("memax")));
-            if (hooks[event].length < before)
-                removed = true;
-            if (hooks[event].length === 0)
-                delete hooks[event];
-        }
-        if (Object.keys(hooks).length === 0)
-            delete config.hooks;
-        if (removed) {
-            writeFileSync(agent.configPath, JSON.stringify(config, null, 2) + "\n");
-            console.log(chalk.gray(`  Removed hooks from ${agent.name}`));
-        }
-        return removed;
-    }
-    catch {
-        return false;
-    }
-}
-function resolveMemaxBin() {
-    // 1. Global install — use absolute path so agents find it without shell PATH
-    if (commandExists("memax")) {
-        try {
-            const which = platform() === "win32" ? "where memax" : "which memax";
-            const absPath = execSync(which, { encoding: "utf-8", stdio: "pipe" })
-                .trim()
-                .split("\n")[0];
-            if (absPath) {
-                return { command: absPath, args: [], shell: absPath };
-            }
-        }
-        catch {
-            // fall through
-        }
-        return { command: "memax", args: [], shell: "memax" };
-    }
-    // 2. Local repo build (faster than npx, always up-to-date during dev)
-    const localBuild = join(process.cwd(), "packages", "cli", "dist", "index.js");
-    if (existsSync(localBuild)) {
-        return {
-            command: "node",
-            args: [localBuild],
-            shell: `node ${localBuild}`,
-        };
-    }
-    // 3. npx as last resort (slow startup — agents may timeout on first run)
-    try {
-        execSync("npx --yes memax-cli --version", {
-            encoding: "utf-8",
-            timeout: 15000,
-            stdio: "pipe",
-        });
-        return {
-            command: "npx",
-            args: ["-y", "memax-cli"],
-            shell: "npx -y memax-cli",
-        };
-    }
-    catch {
-        // npx failed
-    }
-    return null;
-}
-function commandExists(cmd) {
-    try {
-        const which = platform() === "win32" ? "where" : "which";
-        execSync(`${which} ${cmd}`, { stdio: "pipe" });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function writeHookScript(bin) {
-    const hooksDir = join(homedir(), ".memax", "hooks");
-    mkdirSync(hooksDir, { recursive: true });
-    const isWindows = platform() === "win32";
-    const scriptName = isWindows ? "context-inject.cmd" : "context-inject.sh";
-    const scriptPath = join(hooksDir, scriptName);
-    if (isWindows) {
-        writeFileSync(scriptPath, WIN_HOOK.replace(/\$MEMAX/g, bin.shell));
-    }
-    else {
-        writeFileSync(scriptPath, UNIX_HOOK.replace(/\$MEMAX/g, bin.shell));
-        chmodSync(scriptPath, 0o755);
-    }
-    return scriptPath;
-}
+// --- Usage ---
 function printUsage() {
     const agents = getAgents();
     const detected = agents.filter((a) => a.detect());
@@ -493,10 +460,15 @@ function printUsage() {
         console.log();
     }
     console.log(chalk.gray("  Usage:\n"));
-    console.log(chalk.gray("    memax setup --mcp          MCP tools for all detected agents"));
-    console.log(chalk.gray("    memax setup --all          MCP + hooks (where supported)"));
+    console.log(chalk.gray("    memax setup --mcp               Remote MCP server for all detected agents"));
+    console.log(chalk.gray("    memax setup --instructions      Inject memax usage instructions into agent configs"));
+    console.log(chalk.gray("    memax setup --all               MCP + hooks + instructions"));
+    console.log(chalk.gray("    memax setup --mcp --local       Use local CLI instead of remote server"));
+    console.log(chalk.gray("    memax setup --mcp --api-key     Use API keys instead of OAuth (CI/CD)"));
+    console.log(chalk.gray("    memax setup --print        Print MCP config to copy/paste"));
     console.log(chalk.gray("    memax setup --mcp --only claude-code,cursor"));
-    console.log(chalk.gray("    memax setup --all --skip codex"));
+    console.log(chalk.gray("    memax setup --mcp --read-only"));
+    console.log(chalk.gray("    memax setup --mcp --hub memax-team --allow-organize"));
     console.log(chalk.gray("    memax teardown             Remove all integrations\n"));
     console.log(chalk.gray("  Supported agents:"));
     for (const a of agents) {
@@ -507,25 +479,29 @@ function printUsage() {
     }
     console.log();
 }
-const UNIX_HOOK = `#!/bin/bash
-# Memax context injection — installed by: memax setup --hooks
-set -e
-INPUT=$(cat)
-PROMPT=$(echo "$INPUT" | jq -r '.prompt // empty')
-CWD=$(echo "$INPUT" | jq -r '.cwd // empty')
-if [ -z "$PROMPT" ] || [ \${#PROMPT} -lt 10 ]; then exit 0; fi
-case "$PROMPT" in [Yy]|[Yy]es|[Nn]|[Nn]o|ok|OK|sure|Sure|thanks|Thanks|y|n) exit 0 ;; esac
-if [ -n "$CWD" ]; then cd "$CWD" 2>/dev/null || true; fi
-CONTEXT=$($MEMAX recall "$PROMPT" --hook --limit 5 --max-tokens 3000 2>/dev/null) || exit 0
-if [ -n "$CONTEXT" ] && [ "$CONTEXT" != "<memax-context>" ]; then echo "$CONTEXT"; fi
-exit 0
-`;
-const WIN_HOOK = `@echo off
-REM Memax context injection — installed by: memax setup --hooks
-set /p INPUT=
-for /f "tokens=*" %%a in ('echo %INPUT% ^| jq -r ".prompt // empty"') do set PROMPT=%%a
-if "%PROMPT%"=="" exit /b 0
-$MEMAX recall "%PROMPT%" --hook --limit 5 --max-tokens 3000 2>nul
-exit /b 0
-`;
+export function registerSetupCommands(program) {
+    program
+        .command("setup")
+        .description("Set up AI agent integrations (auto-detects installed agents)")
+        .option("--mcp", "Enable MCP server (agent tools)")
+        .option("--hooks", "Enable context injection hooks")
+        .option("--instructions", "Inject memax instructions into agent config files")
+        .option("--all", "Enable MCP + hooks + instructions")
+        .option("--local", "Use local stdio MCP instead of remote server")
+        .option("--api-key", "Use per-agent API keys instead of OAuth (for CI/CD or agents without OAuth support)")
+        .option("--print", "Print MCP config JSON to copy/paste (no changes made)")
+        .option("--only <agents>", "Only configure these agents (comma-separated)")
+        .option("--skip <agents>", "Skip these agents (comma-separated)")
+        .option("--hub <id>", "Scope MCP key to a specific hub")
+        .option("--read-only", "Create remote MCP keys without write access")
+        .option("--allow-delete", "Allow remote MCP keys to delete memories")
+        .option("--allow-organize", "Allow remote MCP keys to organize topics and run dreams")
+        .option("--agent-sync", "Allow remote MCP keys to sync agent configs and sessions")
+        .action(setupCommand);
+    program
+        .command("teardown")
+        .description("Remove Memax integrations from agents")
+        .option("--only <agents>", "Only remove from these agents (comma-separated)")
+        .action(teardownCommand);
+}
 //# sourceMappingURL=setup.js.map