nubase_cli 0.1.4 → 0.1.7

package/README.md

@@ -16,7 +16,9 @@ Installing skills starts a one-time browser authorization session and prints an
 npx -y nubase_cli@latest install-skills
 ```
 
-Open the printed URL, sign in to Studio, choose a project, and approve. The URL includes a per-session UUID and points back to the temporary localhost callback started by the install command. After approval, the CLI writes `~/.nubase/config.json` and closes the localhost callback server.
+This installs the bundled Claude/Codex skills into your user skill directories, writes a local project MCP bridge under `.nubase/mcp-bridge`, writes project MCP config for Claude Code, and starts browser authorization. Open the printed URL, sign in to Studio, choose a project, and approve. The URL includes a per-session UUID and points back to the temporary localhost callback started by the install command. After approval, the CLI writes project-local `.nubase/config.json` and closes the localhost callback server.
+
+Restart Claude Code in the project after installing, then run `/mcp` and confirm `nubase` is connected.
 
 For automation, skip the prompt:
 
@@ -24,6 +26,18 @@ For automation, skip the prompt:
 npx -y nubase_cli@latest install-skills --no-authorize
 ```
 
+To install project-local skill files instead of user-level skill files:
+
+```bash
+npx -y nubase_cli@latest install-skills --skills-scope project
+```
+
+To skip MCP config registration:
+
+```bash
+npx -y nubase_cli@latest install-skills --no-mcp
+```
+
 You can also start a standalone authorization session:
 
 ```bash
@@ -55,10 +69,12 @@ node packages/mcp-bridge/dist/src/index.js
 {
   "mcpServers": {
     "nubase": {
-      "command": "npx",
-      "args": ["-y", "nubase_cli@latest"],
+      "type": "stdio",
+      "command": "node",
+      "args": ["/absolute/project/path/.nubase/mcp-bridge/dist/src/index.js"],
       "env": {
-        "NUBASE_AGENT_ID": "claude-code"
+        "NUBASE_AGENT_ID": "claude-code",
+        "NUBASE_CONFIG": "/absolute/project/path/.nubase/config.json"
       }
     }
   }
@@ -69,7 +85,7 @@ You may still set `NUBASE_URL` and `NUBASE_PROJECT_KEY` explicitly. Environment
 
 ## Install Agent Skills
 
-Install the bundled Nubase skills into a repository:
+Install the bundled Nubase skills and project MCP config:
 
 ```bash
 npx -y nubase_cli@latest install-skills
@@ -77,9 +93,31 @@ npx -y nubase_cli@latest install-skills
 
 Targets:
 
-- `claude`: writes `.claude/skills/nubase/**`
-- `codex`: writes `.codex/skills/nubase/**`
-- `both`: writes both
+- `claude`: installs `~/.claude/skills/nubase/**`
+- `codex`: installs `~/.codex/skills/nubase/**`
+- `both`: installs both
+
+Use `--skills-scope project` to write `.claude/skills/nubase/**` and `.codex/skills/nubase/**` in the current project instead.
+
+By default, when the target includes `claude`, the command also copies the local MCP bridge to `.nubase/mcp-bridge` and creates or merges project `.mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "nubase": {
+      "type": "stdio",
+      "command": "node",
+      "args": ["/absolute/project/path/.nubase/mcp-bridge/dist/src/index.js"],
+      "env": {
+        "NUBASE_AGENT_ID": "claude-code",
+        "NUBASE_CONFIG": "/absolute/project/path/.nubase/config.json"
+      }
+    }
+  }
+}
+```
+
+Use `--mcp both` to also write project `.codex/config.toml` for Codex. Use `--no-mcp` to skip MCP config.
 
 Installed structure:
 
@@ -99,6 +137,7 @@ The bridge injects user and session context from environment variables:
 ```bash
 NUBASE_URL=https://nubase.ai
 NUBASE_PROJECT_KEY=YOUR_NUBASE_PROJECT_KEY
+NUBASE_CONFIG=.nubase/config.json
 NUBASE_USER_JWT=USER_ACCESS_TOKEN
 NUBASE_USER_ID=USER_UUID
 NUBASE_AGENT_ID=codex

package/dist/src/auth-config.d.ts

@@ -8,6 +8,8 @@ export interface StoredAuthConfig {
     savedAt: string;
 }
 export declare function defaultConfigPath(env?: NodeJS.ProcessEnv): string;
+export declare function projectConfigPath(projectDir?: string): string;
+export declare function legacyConfigPath(): string;
 export declare function loadStoredAuthConfig(configPath?: string): Promise<{
     nubaseUrl: string;
     projectKey: string;

package/dist/src/auth-config.js

@@ -4,6 +4,12 @@ import path from 'node:path';
 export function defaultConfigPath(env = process.env) {
     if (env.NUBASE_CONFIG)
         return env.NUBASE_CONFIG;
+    return projectConfigPath();
+}
+export function projectConfigPath(projectDir = process.cwd()) {
+    return path.join(projectDir, '.nubase', 'config.json');
+}
+export function legacyConfigPath() {
     return path.join(os.homedir(), '.nubase', 'config.json');
 }
 export async function loadStoredAuthConfig(configPath = defaultConfigPath()) {

package/dist/src/authorize.d.ts

@@ -6,6 +6,7 @@ export interface AuthorizeOptions {
     openBrowser: boolean;
     timeoutMs: number;
     promptOnly: boolean;
+    configPath: string;
 }
 export declare function parseAuthorizeArgs(argv: string[], env?: NodeJS.ProcessEnv): AuthorizeOptions;
 export declare function authorize(options: AuthorizeOptions): Promise<StoredAuthConfig>;

package/dist/src/authorize.js

@@ -1,7 +1,7 @@
 import { spawn } from 'node:child_process';
 import crypto from 'node:crypto';
 import http from 'node:http';
-import { saveStoredAuthConfig } from './auth-config.js';
+import { defaultConfigPath, saveStoredAuthConfig } from './auth-config.js';
 import { DEFAULT_NUBASE_URL } from './config.js';
 const DEFAULT_STUDIO_URL = 'https://nubase.ai/studio';
 export function parseAuthorizeArgs(argv, env = process.env) {
@@ -12,6 +12,7 @@ export function parseAuthorizeArgs(argv, env = process.env) {
         openBrowser: true,
         timeoutMs: 5 * 60 * 1000,
         promptOnly: false,
+        configPath: defaultConfigPath(env),
     };
     for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
@@ -24,6 +25,9 @@ export function parseAuthorizeArgs(argv, env = process.env) {
         else if (arg === '--agent-id') {
             options.agentId = requiredValue(argv, ++i, arg);
         }
+        else if (arg === '--config') {
+            options.configPath = requiredValue(argv, ++i, arg);
+        }
         else if (arg === '--timeout-seconds') {
             const seconds = Number(requiredValue(argv, ++i, arg));
             if (!Number.isFinite(seconds) || seconds <= 0) {
@@ -93,7 +97,7 @@ async function startAuthorization(options) {
                 if (req.method === 'POST' && req.url === '/callback') {
                     const payload = await readJson(req);
                     const config = validateCallbackPayload(payload, state, options.nubaseUrl);
-                    const saved = await saveStoredAuthConfig(config);
+                    const saved = await saveStoredAuthConfig(config, options.configPath);
                     sendJson(res, 200, { ok: true });
                     cleanup();
                     resolve(saved);
@@ -175,6 +179,7 @@ function corsHeaders() {
         'Access-Control-Allow-Origin': '*',
         'Access-Control-Allow-Methods': 'GET,POST,OPTIONS',
         'Access-Control-Allow-Headers': 'Content-Type',
+        'Access-Control-Allow-Private-Network': 'true',
         'Access-Control-Max-Age': '600',
     };
 }

package/dist/src/config.js

@@ -1,4 +1,4 @@
-import { defaultConfigPath, loadStoredAuthConfig } from './auth-config.js';
+import { defaultConfigPath, legacyConfigPath, loadStoredAuthConfig } from './auth-config.js';
 export const DEFAULT_NUBASE_URL = 'https://nubase.ai';
 export function loadConfig(env = process.env) {
     const nubaseUrl = stripTrailingSlash(env.NUBASE_URL || DEFAULT_NUBASE_URL);
@@ -21,7 +21,7 @@ export async function loadConfigAsync(env = process.env) {
     const config = loadConfig(env);
     if (config.projectKey)
         return config;
-    const stored = await loadStoredAuthConfig(defaultConfigPath(env));
+    const stored = await loadStoredAuthConfig(defaultConfigPath(env)) ?? (env.NUBASE_CONFIG ? null : await loadStoredAuthConfig(legacyConfigPath()));
     if (!stored)
         return config;
     return {

package/dist/src/index.js

@@ -6,12 +6,26 @@ import { installSkills, parseInstallArgs } from './install-skills.js';
 import { McpStdioServer } from './mcp-stdio.js';
 import { NubaseClient } from './nubase-client.js';
 import { callTool, TOOLS } from './tools.js';
-const CLI_VERSION = '0.1.4';
+const CLI_VERSION = '0.1.7';
 if (process.argv[2] === 'install-skills') {
     const options = parseInstallArgs(process.argv.slice(3));
     const installed = await installSkills(options);
     for (const file of installed) {
-        console.error(`Installed Nubase skill: ${file}`);
+        if (file.endsWith('.mcp.json')) {
+            console.error(`Registered Nubase MCP server config: ${file}`);
+        }
+        else if (file.endsWith('.codex/config.toml')) {
+            console.error(`Registered Nubase Codex MCP config: ${file}`);
+        }
+        else if (file.endsWith('.gitignore')) {
+            console.error(`Ensured Nubase local config is ignored by git: ${file}`);
+        }
+        else if (file.includes(`${defaultPathSep()}.nubase${defaultPathSep()}mcp-bridge${defaultPathSep()}`)) {
+            console.error(`Installed Nubase local MCP bridge: ${file}`);
+        }
+        else {
+            console.error(`Installed Nubase skill: ${file}`);
+        }
     }
     if (options.authorize) {
         console.error('');
@@ -69,3 +83,6 @@ const server = new McpStdioServer(async (request) => {
     }
 });
 server.start();
+function defaultPathSep() {
+    return process.platform === 'win32' ? '\\' : '/';
+}

package/dist/src/install-skills.d.ts

@@ -1,9 +1,16 @@
 export type SkillTarget = 'claude' | 'codex' | 'both';
+export type SkillInstallScope = 'user' | 'project';
+export type McpInstallTarget = 'none' | 'claude' | 'codex' | 'both';
 export interface InstallSkillsOptions {
     target: SkillTarget;
     projectDir: string;
     authorize?: boolean;
     authArgs?: string[];
+    skills?: boolean;
+    skillsScope?: SkillInstallScope;
+    mcp?: McpInstallTarget;
+    configPath?: string;
+    homeDir?: string;
 }
 export declare function installSkills(options: InstallSkillsOptions): Promise<string[]>;
 export declare function parseInstallArgs(argv: string[]): {
@@ -11,4 +18,8 @@ export declare function parseInstallArgs(argv: string[]): {
     projectDir: string;
     authorize: boolean;
     authArgs: string[];
+    skills: boolean;
+    skillsScope: SkillInstallScope;
+    mcp: McpInstallTarget;
+    configPath: string;
 };

package/dist/src/install-skills.js

@@ -1,24 +1,46 @@
-import { cp, mkdir } from 'node:fs/promises';
+import { cp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { projectConfigPath } from './auth-config.js';
 export async function installSkills(options) {
     const skillDir = bundledSkillDir();
     const targets = options.target === 'both' ? ['claude', 'codex'] : [options.target];
     const installed = [];
-    for (const target of targets) {
-        const destDir = target === 'claude'
-            ? path.join(options.projectDir, '.claude', 'skills', 'nubase')
-            : path.join(options.projectDir, '.codex', 'skills', 'nubase');
-        await mkdir(path.dirname(destDir), { recursive: true });
-        await cp(skillDir, destDir, { recursive: true, force: true });
-        installed.push(path.join(destDir, 'SKILL.md'));
+    const skillsScope = options.skillsScope ?? 'user';
+    const configPath = path.resolve(options.configPath ?? projectConfigPath(options.projectDir));
+    const homeDir = options.homeDir ?? os.homedir();
+    if (options.skills !== false) {
+        for (const target of targets) {
+            const destDir = skillDestDir(target, skillsScope, options.projectDir, homeDir);
+            await mkdir(path.dirname(destDir), { recursive: true });
+            await cp(skillDir, destDir, { recursive: true, force: true });
+            installed.push(path.join(destDir, 'SKILL.md'));
+        }
+    }
+    const mcpTargets = resolveMcpTargets(options.mcp ?? 'claude', targets);
+    let mcpCommand = null;
+    if (mcpTargets.length > 0) {
+        mcpCommand = await installProjectMcpBridge(options.projectDir);
+        installed.push(mcpCommand.entrypoint);
+    }
+    if (mcpTargets.includes('claude')) {
+        installed.push(await installClaudeMcpConfig(options.projectDir, configPath, mcpCommand));
     }
+    if (mcpTargets.includes('codex')) {
+        installed.push(await installCodexMcpConfig(options.projectDir, configPath, mcpCommand));
+    }
+    installed.push(await ensureProjectGitignore(options.projectDir));
     return installed;
 }
 export function parseInstallArgs(argv) {
     let target = 'both';
     let projectDir = process.cwd();
     let authorize = true;
+    let skills = true;
+    let skillsScope = 'user';
+    let mcp = 'claude';
+    let configPath;
     const authArgs = ['--prompt-only'];
     for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
@@ -38,17 +60,180 @@ export function parseInstallArgs(argv) {
         else if (arg === '--no-authorize') {
             authorize = false;
         }
+        else if (arg === '--no-skills') {
+            skills = false;
+        }
+        else if (arg === '--no-mcp-config') {
+            mcp = 'none';
+        }
+        else if (arg === '--no-mcp') {
+            mcp = 'none';
+        }
+        else if (arg === '--mcp') {
+            const value = argv[++i];
+            if (value !== 'none' && value !== 'claude' && value !== 'codex' && value !== 'both') {
+                throw new Error('--mcp must be none, claude, codex, or both');
+            }
+            mcp = value;
+        }
+        else if (arg === '--skills-scope') {
+            const value = argv[++i];
+            if (value !== 'user' && value !== 'project') {
+                throw new Error('--skills-scope must be user or project');
+            }
+            skillsScope = value;
+        }
+        else if (arg === '--config') {
+            const value = argv[++i];
+            if (!value)
+                throw new Error('--config requires a value');
+            configPath = path.resolve(projectDir, value);
+        }
         else if (arg === '--studio-url' || arg === '--nubase-url' || arg === '--agent-id' || arg === '--timeout-seconds') {
             const value = argv[++i];
             if (!value)
                 throw new Error(`${arg} requires a value`);
             authArgs.push(arg, value);
         }
+        else {
+            throw new Error(`Unknown install-skills option: ${arg}`);
+        }
     }
-    return { target, projectDir, authorize, authArgs };
+    configPath = configPath ?? projectConfigPath(projectDir);
+    authArgs.push('--config', configPath);
+    return { target, projectDir, authorize, authArgs, skills, skillsScope, mcp, configPath };
 }
 function bundledSkillDir() {
+    return path.join(bundledPackageRoot(), 'skills', 'nubase');
+}
+function bundledPackageRoot() {
     const here = path.dirname(fileURLToPath(import.meta.url));
-    const packageRoot = path.resolve(here, '..', '..');
-    return path.join(packageRoot, 'skills', 'nubase');
+    return path.resolve(here, '..', '..');
+}
+function skillDestDir(target, scope, projectDir, homeDir) {
+    if (scope === 'project') {
+        return target === 'claude'
+            ? path.join(projectDir, '.claude', 'skills', 'nubase')
+            : path.join(projectDir, '.codex', 'skills', 'nubase');
+    }
+    return target === 'claude'
+        ? path.join(homeDir, '.claude', 'skills', 'nubase')
+        : path.join(homeDir, '.codex', 'skills', 'nubase');
+}
+function resolveMcpTargets(mcp, skillTargets) {
+    if (mcp === 'none')
+        return [];
+    const requested = mcp === 'both' ? ['claude', 'codex'] : [mcp];
+    return requested.filter((target) => skillTargets.includes(target));
+}
+async function installProjectMcpBridge(projectDir) {
+    const packageRoot = bundledPackageRoot();
+    const destRoot = path.join(projectDir, '.nubase', 'mcp-bridge');
+    await rm(destRoot, { recursive: true, force: true });
+    await mkdir(destRoot, { recursive: true, mode: 0o700 });
+    await cp(path.join(packageRoot, 'dist', 'src'), path.join(destRoot, 'dist', 'src'), { recursive: true, force: true });
+    await cp(path.join(packageRoot, 'skills'), path.join(destRoot, 'skills'), { recursive: true, force: true });
+    await cp(path.join(packageRoot, 'package.json'), path.join(destRoot, 'package.json'), { force: true });
+    const entrypoint = path.join(destRoot, 'dist', 'src', 'index.js');
+    return {
+        command: 'node',
+        args: [entrypoint],
+        entrypoint,
+    };
+}
+async function installClaudeMcpConfig(projectDir, nubaseConfigPath, mcpCommand) {
+    const mcpConfigPath = path.join(projectDir, '.mcp.json');
+    const config = await readProjectMcpConfig(mcpConfigPath);
+    config.mcpServers = {
+        ...(config.mcpServers ?? {}),
+        nubase: {
+            type: 'stdio',
+            command: mcpCommand?.command ?? 'npx',
+            args: mcpCommand?.args ?? ['-y', 'nubase_cli@latest'],
+            env: {
+                NUBASE_AGENT_ID: 'claude-code',
+                NUBASE_CONFIG: nubaseConfigPath,
+            },
+        },
+    };
+    await writeFile(mcpConfigPath, `${JSON.stringify(config, null, 2)}\n`, 'utf8');
+    return mcpConfigPath;
+}
+async function installCodexMcpConfig(projectDir, nubaseConfigPath, mcpCommand) {
+    const configPath = path.join(projectDir, '.codex', 'config.toml');
+    await mkdir(path.dirname(configPath), { recursive: true });
+    const existing = await readTextIfExists(configPath);
+    const block = codexMcpBlock(nubaseConfigPath, mcpCommand);
+    const next = upsertCodexMcpBlock(existing, block);
+    await writeFile(configPath, next, 'utf8');
+    return configPath;
+}
+async function ensureProjectGitignore(projectDir) {
+    const gitignorePath = path.join(projectDir, '.gitignore');
+    const existing = await readTextIfExists(gitignorePath);
+    const lines = existing.split(/\r?\n/);
+    if (!lines.includes('.nubase/')) {
+        const next = `${existing.trimEnd()}${existing.trimEnd() ? '\n' : ''}.nubase/\n`;
+        await writeFile(gitignorePath, next, 'utf8');
+    }
+    return gitignorePath;
+}
+async function readTextIfExists(filePath) {
+    try {
+        return await readFile(filePath, 'utf8');
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return '';
+        throw err;
+    }
+}
+function codexMcpBlock(configPath, mcpCommand) {
+    const command = mcpCommand?.command ?? 'npx';
+    const args = mcpCommand?.args ?? ['-y', 'nubase_cli@latest'];
+    return [
+        '[mcp_servers.nubase]',
+        'type = "stdio"',
+        `command = "${escapeTomlString(command)}"`,
+        `args = [${args.map((arg) => `"${escapeTomlString(arg)}"`).join(', ')}]`,
+        'startup_timeout_sec = 30',
+        '',
+        '[mcp_servers.nubase.env]',
+        'NUBASE_AGENT_ID = "codex"',
+        `NUBASE_CONFIG = "${escapeTomlString(configPath)}"`,
+        '',
+    ].join('\n');
+}
+function upsertCodexMcpBlock(existing, block) {
+    const pattern = /(?:^|\n)\[mcp_servers\.nubase\][\s\S]*?(?=\n\[mcp_servers\.(?!nubase(?:\.env)?\b)|\n\[[^\]]+\]|\s*$)/;
+    const trimmedBlock = `\n${block.trimEnd()}\n`;
+    if (pattern.test(existing)) {
+        return existing.replace(pattern, trimmedBlock).replace(/^\n/, '');
+    }
+    const prefix = existing.trimEnd();
+    return `${prefix}${prefix ? '\n\n' : ''}${block}`;
+}
+function escapeTomlString(value) {
+    return value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+async function readProjectMcpConfig(configPath) {
+    try {
+        const raw = await readFile(configPath, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            throw new Error('.mcp.json must contain a JSON object');
+        }
+        if (parsed.mcpServers !== undefined && (!parsed.mcpServers || typeof parsed.mcpServers !== 'object' || Array.isArray(parsed.mcpServers))) {
+            throw new Error('.mcp.json mcpServers must be a JSON object');
+        }
+        return parsed;
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return {};
+        if (err instanceof SyntaxError) {
+            throw new Error(`Could not parse ${configPath}: ${err.message}`);
+        }
+        throw err;
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nubase_cli",
-  "version": "0.1.4",
+  "version": "0.1.7",
   "private": false,
   "type": "module",
   "bin": {

package/skills/nubase/SKILL.md

@@ -56,28 +56,46 @@ If a tool is unavailable, continue with REST/API guidance and tell the user what
 
 ## Setup
 
-Install MCP bridge:
+Install the Nubase skills and project MCP config:
+
+```bash
+npx -y nubase_cli@latest install-skills
+```
+
+By default this writes:
+
+- `~/.claude/skills/nubase/**`
+- `~/.codex/skills/nubase/**`
+- project `.mcp.json` with a `nubase` stdio MCP server for Claude Code
+- project `.nubase/mcp-bridge/**` local MCP bridge runtime, so agent startup does not depend on `npx @latest`
+- project `.nubase/config.json` after browser authorization
+
+After installing, restart Claude Code in the project and run `/mcp`. The `nubase` server must be connected before this skill can call `nubase_overview`, `memory_context`, or other MCP tools.
+
+Expected `.mcp.json` shape:
 
 ```json
 {
   "mcpServers": {
     "nubase": {
-      "command": "npx",
-      "args": ["nubase_cli"],
+      "type": "stdio",
+      "command": "node",
+      "args": ["/absolute/project/path/.nubase/mcp-bridge/dist/src/index.js"],
       "env": {
-        "NUBASE_URL": "http://localhost:9999",
-        "NUBASE_PROJECT_KEY": "YOUR_NUBASE_PROJECT_KEY",
-        "NUBASE_AGENT_ID": "codex"
+        "NUBASE_AGENT_ID": "claude-code",
+        "NUBASE_CONFIG": "/absolute/project/path/.nubase/config.json"
       }
     }
   }
 }
 ```
 
-Install skills:
+If `NUBASE_PROJECT_KEY` is not set, `nubase_cli` reads the browser authorization saved at the project `NUBASE_CONFIG` path.
+
+To install project-local skill files instead of user-level skill files:
 
 ```bash
-npx nubase_cli install-skills --target both --project-dir .
+npx -y nubase_cli@latest install-skills --skills-scope project
 ```
 
 This installs one Nubase skill directory containing: