@ericdisero/aurora-cli 0.1.0

package/README.md

@@ -0,0 +1,37 @@
+# @ericdisero/aurora-cli
+
+`aurora` — terminal CLI for **Aurora**, the AI audio workbench. Drive music generation, covers, sample manufacturing, 7-stem separation, and stack export from your shell, or let Claude Code shell out to it instead of loading 27 MCP tool schemas into context.
+
+## Install
+
+```bash
+npm i -g @ericdisero/aurora-cli
+aurora keys --suno-api-key <key> --mvsep-api-key <key>   # once
+aurora status
+```
+
+## Commands
+
+```bash
+aurora run --list                 # every operation + description
+aurora run <op> --key value       # run any operation (same surface as the MCP)
+aurora install-skills [--global]  # bundled agent recipes → .claude/skills/<name>/SKILL.md
+aurora mcp                        # print the MCP client config for this machine
+aurora keys                       # provider key status (masked)
+aurora status                     # userData / database / projects root / keys
+```
+
+## Examples
+
+```bash
+aurora run aurora_create_project --name "Midnight Drive"
+aurora run aurora_sounds --prompt "huge cinematic braam, dark low brass" --soundKey Cm --tempo 140
+aurora run aurora_generate --prompt "dark synthwave, driving bass" --background
+aurora run aurora_get_job_status --jobId gen-xxxx        # streamUrls while cooking
+aurora run aurora_split --assetId <id> --background      # 7 stems, progressive landing
+aurora run aurora_stack_export --projectId <id>          # aligned multi-WAV bundle
+```
+
+Server sibling: `@ericdisero/aurora-mcp-server`. Full docs: [github.com/EricDisero/aurora-mcp](https://github.com/EricDisero/aurora-mcp).
+
+MIT. Copyright Blueprint Online Learning Inc.

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

@@ -0,0 +1,5 @@
+interface InstallSkillsOptions {
+    global?: boolean;
+}
+export declare function runInstallSkills(opts: InstallSkillsOptions): void;
+export {};

package/dist/commands/install-skills.js

@@ -0,0 +1,47 @@
+// Install the bundled skill markdown into Claude Code's skill directories.
+// Claude Code discovers skills as DIRECTORIES: .claude/skills/<name>/SKILL.md —
+// a loose .md dropped into skills/ is silently never loaded (the slates-mcp
+// 6/9 audit lesson, baked in from day one here).
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { existsSync, writeFileSync, mkdirSync } from 'node:fs';
+import { SKILLS } from '@ericdisero/aurora-shared';
+function frontmatterName(markdown, fallback) {
+    if (!markdown.startsWith('---'))
+        return fallback;
+    const end = markdown.indexOf('\n---', 3);
+    if (end === -1)
+        return fallback;
+    const m = markdown.slice(3, end).match(/^name:\s*(.+?)\s*$/m);
+    return m ? m[1].trim() : fallback;
+}
+export function runInstallSkills(opts) {
+    const skillEntries = Object.entries(SKILLS);
+    if (skillEntries.length === 0) {
+        console.error('No bundled skills found in @ericdisero/aurora-shared — broken build?');
+        process.exit(1);
+    }
+    const target = opts.global
+        ? join(homedir(), '.claude', 'skills')
+        : join(process.cwd(), '.claude', 'skills');
+    let fresh = 0;
+    let updated = 0;
+    for (const [key, content] of skillEntries) {
+        const name = frontmatterName(content, key);
+        const dir = join(target, name);
+        const isUpdate = existsSync(dir);
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(join(dir, 'SKILL.md'), content);
+        if (isUpdate) {
+            updated++;
+            console.log(`update  ${name}`);
+        }
+        else {
+            fresh++;
+            console.log(`install ${name}`);
+        }
+    }
+    console.log(`\nInstalled ${fresh + updated} skill(s) (${fresh} new, ${updated} updated) into ${target}`);
+    console.log(`Restart Claude Code, then ask: 'what aurora skills do you have?' to verify.`);
+}
+//# sourceMappingURL=install-skills.js.map

package/dist/commands/keys.d.ts

@@ -0,0 +1,7 @@
+interface KeysOptions {
+    sunoApiKey?: string;
+    kieApiKey?: string;
+    mvsepApiKey?: string;
+}
+export declare function runKeys(opts: KeysOptions): void;
+export {};

package/dist/commands/keys.js

@@ -0,0 +1,33 @@
+// `aurora keys` — provider key configuration (~/.aurora/config.json).
+// No flags = status (masked). Aurora itself has no auth (testing build);
+// these are the dev-direct provider keys.
+import { getConfigPath, getKieKey, getMvsepKey, getSunoKey, writeKeyConfig } from '@ericdisero/aurora-shared';
+function mask(key) {
+    if (!key)
+        return 'NOT SET';
+    if (key.length <= 8)
+        return '****';
+    return `${key.slice(0, 4)}…${key.slice(-4)}`;
+}
+export function runKeys(opts) {
+    const updates = {};
+    if (opts.sunoApiKey)
+        updates.sunoApiKey = opts.sunoApiKey;
+    if (opts.kieApiKey)
+        updates.kieApiKey = opts.kieApiKey;
+    if (opts.mvsepApiKey)
+        updates.mvsepApiKey = opts.mvsepApiKey;
+    if (Object.keys(updates).length > 0) {
+        writeKeyConfig(updates);
+        console.log(`Saved to ${getConfigPath()}`);
+    }
+    console.log('Provider keys (env vars override the config file):');
+    console.log(`  suno  (SUNO_API_KEY):  ${mask(getSunoKey())}  ← PRIMARY (sunoapi.org)`);
+    console.log(`  kie   (KIE_API_KEY):   ${mask(getKieKey())}  ← fallback (api.kie.ai)`);
+    console.log(`  mvsep (MVSEP_API_KEY): ${mask(getMvsepKey())}  ← stem separation`);
+    if (!getSunoKey() && !getKieKey()) {
+        console.log('\nNo Suno provider key — generation/cover/sounds ops will fail.');
+        console.log('Set one: aurora keys --suno-api-key <key>');
+    }
+}
+//# sourceMappingURL=keys.js.map

package/dist/commands/mcp.d.ts

@@ -0,0 +1 @@
+export declare function runMcpConfig(): void;

package/dist/commands/mcp.js

@@ -0,0 +1,41 @@
+// `aurora mcp` — print the MCP client config for this machine, with the key
+// envs inlined when configured (keys in ~/.aurora/config.json are read by the
+// server directly, so the env block is optional in that case).
+import { getKieKey, getMvsepKey, getSunoKey, readKeyConfig } from '@ericdisero/aurora-shared';
+export function runMcpConfig() {
+    const fileConfig = readKeyConfig();
+    const needsEnvBlock = !fileConfig.sunoApiKey && !fileConfig.kieApiKey && !fileConfig.mvsepApiKey;
+    const env = {};
+    if (needsEnvBlock) {
+        if (getSunoKey())
+            env.SUNO_API_KEY = '<your sunoapi.org key>';
+        if (getKieKey())
+            env.KIE_API_KEY = '<your kie.ai key>';
+        if (getMvsepKey())
+            env.MVSEP_API_KEY = '<your mvsep key>';
+        if (Object.keys(env).length === 0) {
+            env.SUNO_API_KEY = '<your sunoapi.org key>';
+            env.MVSEP_API_KEY = '<your mvsep key>';
+        }
+    }
+    const server = {
+        command: 'npx',
+        args: ['-y', '@ericdisero/aurora-mcp-server']
+    };
+    if (Object.keys(env).length > 0)
+        server.env = env;
+    const config = { mcpServers: { aurora: server } };
+    console.log('Add to your MCP config (Claude Desktop: claude_desktop_config.json,');
+    console.log('Claude Code: `claude mcp add-json aurora ...` or .mcp.json, Cursor: mcp.json):\n');
+    console.log(JSON.stringify(config, null, 2));
+    if (!needsEnvBlock) {
+        console.log('\nKeys found in ~/.aurora/config.json — the server reads them directly, no env block needed.');
+    }
+    else {
+        console.log('\nTip: `aurora keys --suno-api-key <key> --mvsep-api-key <key>` stores keys in');
+        console.log('~/.aurora/config.json so the env block becomes unnecessary.');
+    }
+    console.log('\nClaude Code one-liner:');
+    console.log('  claude mcp add aurora -- npx -y @ericdisero/aurora-mcp-server');
+}
+//# sourceMappingURL=mcp.js.map

package/dist/commands/op.d.ts

@@ -0,0 +1,8 @@
+interface RunOpOptions {
+    opId: string;
+    rawArgs: string[];
+    json: boolean;
+}
+export declare function listOps(): void;
+export declare function runOp(opts: RunOpOptions): Promise<void>;
+export {};

package/dist/commands/op.js

@@ -0,0 +1,158 @@
+// `aurora run <op> --key value` dispatcher — port of the slates-mcp CLI's op
+// command, including its best-effort Zod-aware scalar/array/null coercion.
+import { ALL_OPERATIONS } from '@ericdisero/aurora-shared';
+const RUN_COMMAND_FLAGS = new Set(['--json', '--list']);
+export function listOps() {
+    const ops = ALL_OPERATIONS;
+    for (const op of ops) {
+        console.log(`${op.id}\n  ${op.description}\n`);
+    }
+    console.log(`${ops.length} operations. Run one with: aurora run <op> --key value`);
+}
+function parseArgs(rawArgs) {
+    const out = {};
+    for (let i = 0; i < rawArgs.length; i++) {
+        const arg = rawArgs[i];
+        if (!arg.startsWith('--'))
+            continue;
+        if (RUN_COMMAND_FLAGS.has(arg) || RUN_COMMAND_FLAGS.has(arg.split('=')[0])) {
+            const next = rawArgs[i + 1];
+            if (next != null && !next.startsWith('--'))
+                i++;
+            continue;
+        }
+        const eqIdx = arg.indexOf('=');
+        if (eqIdx > 0) {
+            assign(out, arg.slice(2, eqIdx), arg.slice(eqIdx + 1));
+        }
+        else {
+            const key = arg.slice(2);
+            const next = rawArgs[i + 1];
+            if (next == null || next.startsWith('--')) {
+                assign(out, key, true);
+            }
+            else {
+                assign(out, key, next);
+                i++;
+            }
+        }
+    }
+    return out;
+}
+function assign(obj, key, value) {
+    const existing = obj[key];
+    if (existing == null) {
+        obj[key] = value;
+        return;
+    }
+    if (Array.isArray(existing)) {
+        existing.push(value);
+        return;
+    }
+    obj[key] = [existing, value];
+}
+export async function runOp(opts) {
+    const ops = ALL_OPERATIONS;
+    const op = ops.find((o) => o.id === opts.opId);
+    if (!op) {
+        console.error(`Unknown operation: ${opts.opId}`);
+        console.error('Run `aurora run --list` to see all operations.');
+        process.exit(1);
+    }
+    const raw = parseArgs(opts.rawArgs);
+    const coerced = coerceForSchema(op.input, raw);
+    let parsed;
+    try {
+        parsed = op.input.parse(coerced);
+    }
+    catch (err) {
+        console.error('Invalid arguments for', op.id);
+        console.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+    const result = await op.run(parsed);
+    if (opts.json) {
+        process.stdout.write(JSON.stringify({ text: result.text, data: result.data }, null, 2));
+        process.stdout.write('\n');
+        return;
+    }
+    console.log(result.text);
+}
+function coerceForSchema(schema, raw) {
+    const zodObj = schema;
+    if (zodObj?._def?.typeName !== 'ZodObject')
+        return raw;
+    const shape = typeof zodObj._def.shape === 'function' ? zodObj._def.shape() : (zodObj.shape ?? {});
+    const wrappers = new Set([
+        'ZodOptional',
+        'ZodDefault',
+        'ZodNullable',
+        'ZodReadonly',
+        'ZodEffects',
+        'ZodCatch',
+        'ZodBranded'
+    ]);
+    const unwrap = (t) => {
+        let cur = t;
+        let depth = 0;
+        while (cur?._def?.typeName && wrappers.has(cur._def.typeName) && depth < 8) {
+            cur = cur._def.innerType ?? cur._def.schema;
+            depth++;
+        }
+        return cur;
+    };
+    const isNullable = (t) => {
+        let cur = t;
+        let depth = 0;
+        while (cur?._def?.typeName && depth < 8) {
+            if (cur._def.typeName === 'ZodNullable')
+                return true;
+            if (wrappers.has(cur._def.typeName)) {
+                cur = cur._def.innerType ?? cur._def.schema;
+                depth++;
+                continue;
+            }
+            break;
+        }
+        return false;
+    };
+    const coerceScalar = (fieldType, value) => {
+        if (fieldType === 'ZodNumber') {
+            const n = Number(value);
+            return Number.isFinite(n) ? n : value;
+        }
+        if (fieldType === 'ZodBoolean')
+            return value === 'true' || value === '1';
+        return value;
+    };
+    const out = {};
+    for (const [key, value] of Object.entries(raw)) {
+        const declared = shape[key];
+        const leaf = unwrap(declared);
+        const fieldType = (leaf?._def?.typeName ?? '');
+        if (value === 'null' && isNullable(declared)) {
+            out[key] = null;
+            continue;
+        }
+        if (fieldType === 'ZodArray') {
+            const elemType = (leaf?._def?.type?._def?.typeName ?? '');
+            const arr = Array.isArray(value)
+                ? value
+                : typeof value === 'string'
+                    ? value
+                        .split(',')
+                        .map((s) => s.trim())
+                        .filter((s) => s.length > 0)
+                    : [value];
+            out[key] = arr.map((v) => (typeof v === 'string' ? coerceScalar(elemType, v) : v));
+            continue;
+        }
+        if (typeof value === 'string') {
+            out[key] = coerceScalar(fieldType, value);
+            continue;
+        }
+        out[key] = value;
+    }
+    return out;
+}
+//# sourceMappingURL=op.js.map

package/dist/commands/status.d.ts

@@ -0,0 +1 @@
+export declare function runStatus(): Promise<void>;

package/dist/commands/status.js

@@ -0,0 +1,20 @@
+// `aurora status` — where Aurora's data lives + key state, with a clear
+// message when the app has never run on this machine.
+import { existsSync } from 'node:fs';
+import { getDbPath, getKieKey, getMvsepKey, getProjectsDirectory, getSunoKey, getUserDataDir } from '@ericdisero/aurora-shared';
+export async function runStatus() {
+    const userData = getUserDataDir();
+    const dbPath = getDbPath();
+    const dbExists = existsSync(dbPath);
+    console.log(`userData:       ${userData}`);
+    console.log(`database:       ${dbPath} ${dbExists ? '(exists)' : '(MISSING — created on first op)'}`);
+    console.log(`projects root:  ${getProjectsDirectory()}`);
+    console.log(`suno key:       ${getSunoKey() ? 'configured' : getKieKey() ? 'kie fallback configured' : 'NOT SET'}`);
+    console.log(`mvsep key:      ${getMvsepKey() ? 'configured' : 'NOT SET'}`);
+    if (!dbExists) {
+        console.log('\nNo Aurora database yet — either the Aurora app has never run on this machine, or it uses a ' +
+            'different userData dir (set AURORA_USER_DATA to override). The first project/asset op will ' +
+            'create a fresh library here.');
+    }
+}
+//# sourceMappingURL=status.js.map

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { readFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { runOp, listOps } from './commands/op.js';
+import { runInstallSkills } from './commands/install-skills.js';
+import { runKeys } from './commands/keys.js';
+import { runStatus } from './commands/status.js';
+import { runMcpConfig } from './commands/mcp.js';
+const pkg = JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), '..', 'package.json'), 'utf8'));
+const program = new Command();
+program
+    .name('aurora')
+    .description('Aurora AI audio workbench CLI — generation, covers, sounds, 7-stem splits, stack export. ' +
+    'Agent-first: `aurora run <op> --key value` mirrors the MCP tool surface.')
+    .version(pkg.version);
+program
+    .command('run [op]')
+    .description('Run an operation, e.g. `aurora run aurora_create_project --name "Midnight Drive"`')
+    .option('--list', 'List every operation with its description')
+    .option('--json', 'Machine-readable output ({text, data})')
+    .allowUnknownOption(true)
+    .action(async (opId, opts, cmd) => {
+    if (opts.list || !opId) {
+        listOps();
+        return;
+    }
+    await runOp({ opId, rawArgs: cmd.args.slice(1), json: Boolean(opts.json) });
+});
+program
+    .command('install-skills')
+    .description("Install the bundled agent skills into Claude Code's skill directory (.claude/skills/<name>/SKILL.md)")
+    .option('--global', 'Install to ~/.claude/skills instead of ./.claude/skills')
+    .action((opts) => {
+    runInstallSkills({ global: Boolean(opts.global) });
+});
+program
+    .command('keys')
+    .description('Configure provider API keys (~/.aurora/config.json). `aurora keys` shows status.')
+    .option('--suno-api-key <key>', 'sunoapi.org key (PRIMARY Suno provider)')
+    .option('--kie-api-key <key>', 'kie.ai key (fallback Suno provider)')
+    .option('--mvsep-api-key <key>', 'MVSEP key (stem separation)')
+    .action((opts) => {
+    runKeys(opts);
+});
+program
+    .command('status')
+    .description('Show Aurora connection state: userData, database, projects root, key status')
+    .action(async () => {
+    await runStatus();
+});
+program
+    .command('mcp')
+    .description('Print the MCP client config for this machine (Claude Code / Claude Desktop / Cursor)')
+    .action(() => {
+    runMcpConfig();
+});
+program.parseAsync(process.argv).catch((err) => {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@ericdisero/aurora-cli",
+  "version": "0.1.0",
+  "description": "Aurora CLI: drive the Aurora AI audio workbench from your terminal or let Claude Code shell out to it. Music generation, covers, sample manufacturing, 7-stem separation, stack export — plus bundled agent skills and an MCP configurator.",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "aurora": "dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "files": ["dist", "!dist/**/*.map", "README.md"],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/EricDisero/aurora-mcp.git",
+    "directory": "packages/cli"
+  },
+  "keywords": [
+    "aurora",
+    "cli",
+    "mcp",
+    "model-context-protocol",
+    "ai-music",
+    "music-generation",
+    "stem-separation",
+    "suno",
+    "mvsep",
+    "claude",
+    "claude-code",
+    "agent-skills"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@ericdisero/aurora-shared": "0.1.0",
+    "commander": "^12.1.0",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.7.0"
+  }
+}