@ericdisero/aurora-shared 0.1.0

package/dist/operations/index.js

@@ -0,0 +1,848 @@
+// Operations layer — the ONE place every Aurora agent tool is defined. Both the
+// MCP server and the CLI register these as their tool / command surface
+// (slates-mcp's single-registry rule, carried over). Every operation:
+//   - has a stable string id (= the MCP tool name)
+//   - has a Zod input schema (MCP tool definition AND CLI argument parsing)
+//   - works directly against Aurora's userData DB + project folders (standalone
+//     v1 — no running app required; renderer-bound mastering ops are deferred
+//     to the app-integration follow-up)
+import { join, extname, basename, dirname } from 'node:path';
+import { existsSync } from 'node:fs';
+import { z } from 'zod';
+import { v4 as uuidv4 } from 'uuid';
+import { getDbPath, getProjectsDirectory, getUserDataDir } from '../paths.js';
+import { getMvsepKey, getSunoKey, getKieKey } from '../config.js';
+import { createCover, createGeneration, createSoundsGeneration, createWavConversion, downloadTo, getRemainingCredits, host, pollWavConversion, uploadAudioFile } from '../providers/suno.js';
+import { getMvsepUserInfo } from '../providers/mvsep.js';
+import { createProject, deleteProject, getProject, getProjectDirectory, listProjects, renameProject } from '../storage/projects.js';
+import { addFileAsset, deleteAsset, getAsset, insertAsset, listAssets, updateAssetPath } from '../storage/assets.js';
+import { getProjectStems, getStems } from '../storage/stems.js';
+import { advanceJob, listJobs, loadJob, newJobManifest, saveJob } from '../jobs.js';
+import { createSplitJobs, prepareSplit } from '../split.js';
+import { probeDurationSeconds, standardizeToWav, convertToMp3, pitchShift } from '../audio/ffmpeg.js';
+import { runRipMidi, runRvcUpscale } from '../sidecars.js';
+import { addLane, exportStackBundle, laneNameFromPath, loadStack, removeLane, updateLane } from '../stack.js';
+import { SKILLS } from '../skills/content.js';
+function ok(data, text) {
+    return { text: text ?? JSON.stringify(data, null, 2), data };
+}
+// Latest Suno model (wire enum verified vs the sunoapi.org OpenAPI spec
+// 2026-06-10: V4 | V4_5 | V4_5PLUS | V4_5ALL | V5 | V5_5). Sounds stays
+// locked to V5 by its own docs.
+const DEFAULT_GEN_MODEL = 'V5_5';
+const MAX_COVER_REFERENCE_SECONDS = 8 * 60;
+const BACKGROUND_DESCRIBE = 'Submit and return immediately with a jobId instead of blocking. Poll aurora_get_job_status ' +
+    'every 10-20s. Status includes streamUrls you can hand the user to LISTEN mid-generation, ' +
+    'before files land. Jobs survive process restarts (provider-side state).';
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/** Blocking wrapper: advance the job every 5s up to ~12 min, then degrade
+ *  gracefully to "still running" instead of erroring (MCP clients can time out
+ *  long tool calls — the job itself is provider-side and loses nothing). */
+async function awaitJob(m) {
+    const MAX_WAIT_MS = 12 * 60 * 1000;
+    const start = Date.now();
+    let current = m;
+    while (current.status === 'running' && Date.now() - start < MAX_WAIT_MS) {
+        await sleep(5000);
+        current = await advanceJob(current);
+    }
+    return current;
+}
+function jobSummary(m) {
+    return {
+        jobId: m.jobId,
+        kind: m.kind,
+        status: m.status,
+        stage: m.stage,
+        error: m.error,
+        projectId: m.projectId,
+        assetIds: m.assetIds,
+        stems: m.stems,
+        streamUrls: m.streamUrls && m.streamUrls.length > 0 ? m.streamUrls : undefined,
+        lastProviderStatus: m.lastStatus,
+        createdAt: m.createdAt,
+        updatedAt: m.updatedAt
+    };
+}
+function jobText(m) {
+    if (m.status === 'done') {
+        const assets = m.assetIds.length > 0 ? ` ${m.assetIds.length} asset(s): ${m.assetIds.join(', ')}.` : '';
+        const stems = m.stems.length > 0 ? ` ${m.stems.length} stem(s) landed.` : '';
+        return `Job ${m.jobId} complete.${assets}${stems} Files are on disk in the project folder.`;
+    }
+    if (m.status === 'error')
+        return `Job ${m.jobId} FAILED: ${m.error}`;
+    const stream = m.streamUrls && m.streamUrls.length > 0
+        ? ` Stream preview available NOW (play these URLs for the user before files land): ${m.streamUrls.join(' , ')}`
+        : '';
+    return `Job ${m.jobId} still running — ${m.stage}.${stream} Poll aurora_get_job_status again in 10-20s.`;
+}
+async function resolveProjectOrCreate(projectId, fallbackName) {
+    if (projectId) {
+        const p = getProject(projectId);
+        if (!p)
+            throw new Error(`Project not found: ${projectId}. Use aurora_list_projects.`);
+        return p.id;
+    }
+    const created = await createProject(fallbackName);
+    return created.id;
+}
+function sanitizeFileName(name) {
+    return name.replace(/[\\/:*?"<>|]/g, '_').trim() || 'track';
+}
+/** Resolve an op input that may be an assetId or a raw file path. */
+function resolveAudioInput(input) {
+    if (input.assetId) {
+        const asset = getAsset(input.assetId);
+        if (!asset)
+            throw new Error(`Asset not found: ${input.assetId}. Use aurora_list_assets.`);
+        if (!existsSync(asset.path))
+            throw new Error(`Asset audio file is missing on disk: ${asset.path}`);
+        return { path: asset.path, asset };
+    }
+    if (input.path) {
+        if (!existsSync(input.path))
+            throw new Error(`File not found: ${input.path}`);
+        return { path: input.path, asset: null };
+    }
+    throw new Error('Provide either assetId or path.');
+}
+// ── Identity / workspace ────────────────────────────────────────
+const getCredits = {
+    id: 'aurora_get_credits',
+    description: 'Cloud balances: Suno provider credits (sunoapi.org/kie.ai) and MVSEP premium minutes. ' +
+        'FREE call — run it before any paid generation or split, and after, to log real spend.',
+    input: z.object({}).strict(),
+    async run() {
+        const result = {};
+        try {
+            result.sunoCredits = await getRemainingCredits();
+            result.sunoProvider = host();
+        }
+        catch (err) {
+            result.sunoError = err instanceof Error ? err.message : String(err);
+        }
+        if (getMvsepKey()) {
+            try {
+                const info = await getMvsepUserInfo();
+                result.mvsepPremiumMinutes = info.premiumMinutes;
+                result.mvsepPremiumEnabled = info.premiumEnabled;
+            }
+            catch (err) {
+                result.mvsepError = err instanceof Error ? err.message : String(err);
+            }
+        }
+        else {
+            result.mvsepError = 'MVSEP_API_KEY not configured';
+        }
+        return ok(result);
+    }
+};
+const getWorkspaceState = {
+    id: 'aurora_get_workspace_state',
+    description: "Snapshot of the user's Aurora workspace: userData location, projects root, key status, " +
+        'projects list, optional per-project assets+stems. Call once at the start of a session.',
+    input: z.object({ projectId: z.string().optional() }),
+    async run(input) {
+        const projects = listProjects();
+        let activeProject;
+        if (input.projectId) {
+            const p = getProject(input.projectId);
+            if (!p)
+                throw new Error(`Project not found: ${input.projectId}`);
+            activeProject = {
+                ...p,
+                directory: getProjectDirectory(p.id),
+                assets: listAssets(p.id),
+                stems: getProjectStems(p.id)
+            };
+        }
+        return ok({
+            userData: getUserDataDir(),
+            database: getDbPath(),
+            projectsRoot: getProjectsDirectory(),
+            keys: {
+                suno: Boolean(getSunoKey() || getKieKey()),
+                mvsep: Boolean(getMvsepKey())
+            },
+            projects,
+            activeProject
+        });
+    }
+};
+// ── Projects ────────────────────────────────────────────────────
+const createProjectOp = {
+    id: 'aurora_create_project',
+    description: 'Create a new Aurora project (a container of audio assets, with a human-readable folder on disk).',
+    input: z.object({ name: z.string().min(1).describe('Project name, e.g. "Midnight Drive"') }),
+    async run(input) {
+        const project = await createProject(input.name);
+        return ok({ project, directory: getProjectDirectory(project.id) });
+    }
+};
+const listProjectsOp = {
+    id: 'aurora_list_projects',
+    description: 'List every Aurora project (id, name, folder name, timestamps), newest first.',
+    input: z.object({}).strict(),
+    async run() {
+        return ok({ projects: listProjects(), projectsRoot: getProjectsDirectory() });
+    }
+};
+const renameProjectOp = {
+    id: 'aurora_rename_project',
+    description: 'Rename a project (display name only — the on-disk folder keeps its name).',
+    input: z.object({ projectId: z.string(), name: z.string().min(1) }),
+    async run(input) {
+        return ok({ project: renameProject(input.projectId, input.name) });
+    }
+};
+const deleteProjectOp = {
+    id: 'aurora_delete_project',
+    description: 'DELETE a project: its DB rows AND its entire folder on disk (all audio files). Irreversible. ' +
+        'Requires confirm:true — ask the user first.',
+    input: z.object({
+        projectId: z.string(),
+        confirm: z.boolean().optional().describe('Must be true. Confirm with the user before calling.')
+    }),
+    async run(input) {
+        const project = getProject(input.projectId);
+        if (!project)
+            throw new Error(`Project not found: ${input.projectId}`);
+        if (!input.confirm) {
+            return ok({ wouldDelete: { project, directory: getProjectDirectory(project.id) } }, `NOT deleted. This would remove project "${project.name}" and its entire folder ` +
+                `${getProjectDirectory(project.id)} from disk. Re-call with confirm:true after the user agrees.`);
+        }
+        await deleteProject(input.projectId);
+        return ok({ deleted: project.id }, `Deleted project "${project.name}" and its folder.`);
+    }
+};
+const listAssetsOp = {
+    id: 'aurora_list_assets',
+    description: 'All assets in a project (generations, covers, imports, references, masters) with their on-disk ' +
+        'paths, plus every split stem grouped by source asset.',
+    input: z.object({ projectId: z.string() }),
+    async run(input) {
+        const project = getProject(input.projectId);
+        if (!project)
+            throw new Error(`Project not found: ${input.projectId}`);
+        const assets = listAssets(input.projectId);
+        const stems = getProjectStems(input.projectId);
+        const stemsByAsset = {};
+        for (const s of stems) {
+            ;
+            (stemsByAsset[s.assetId] ??= []).push(s);
+        }
+        return ok({
+            project,
+            directory: getProjectDirectory(project.id),
+            assets: assets.map((a) => ({ ...a, stems: stemsByAsset[a.id] ?? [] }))
+        });
+    }
+};
+// ── Asset management ────────────────────────────────────────────
+const importFileOp = {
+    id: 'aurora_import_file',
+    description: "Copy an external audio file into a project as an 'import' asset (lands in <project>/imports/). " +
+        'Any asset can then be split, covered, stacked, or pitch-shifted.',
+    input: z.object({
+        projectId: z.string(),
+        filePath: z.string().describe('Absolute path to the audio file to import')
+    }),
+    async run(input) {
+        if (!existsSync(input.filePath))
+            throw new Error(`File not found: ${input.filePath}`);
+        const asset = await addFileAsset({ projectId: input.projectId, kind: 'import', filePath: input.filePath });
+        return ok({ asset });
+    }
+};
+const addReferenceOp = {
+    id: 'aurora_add_reference',
+    description: "Copy an audio file into a project as a 'reference' asset (lands in <project>/references/ and " +
+        "registers in the global reference library the mastering flow keys off). References can be split too.",
+    input: z.object({
+        projectId: z.string(),
+        filePath: z.string().describe('Absolute path to the reference audio file')
+    }),
+    async run(input) {
+        if (!existsSync(input.filePath))
+            throw new Error(`File not found: ${input.filePath}`);
+        const asset = await addFileAsset({ projectId: input.projectId, kind: 'reference', filePath: input.filePath });
+        return ok({ asset });
+    }
+};
+const deleteAssetOp = {
+    id: 'aurora_delete_asset',
+    description: 'DELETE an asset: its DB row, its audio file on disk, its stems folder, and any linked reference ' +
+        'row. Irreversible. Requires confirm:true — ask the user first.',
+    input: z.object({
+        assetId: z.string(),
+        confirm: z.boolean().optional().describe('Must be true. Confirm with the user before calling.')
+    }),
+    async run(input) {
+        const asset = getAsset(input.assetId);
+        if (!asset)
+            throw new Error(`Asset not found: ${input.assetId}`);
+        if (!input.confirm) {
+            return ok({ wouldDelete: asset }, `NOT deleted. This would remove "${asset.name}" (${asset.path}) and its stems from disk. ` +
+                'Re-call with confirm:true after the user agrees.');
+        }
+        await deleteAsset(input.assetId);
+        return ok({ deleted: asset.id }, `Deleted asset "${asset.name}".`);
+    }
+};
+const fetchWavOp = {
+    id: 'aurora_fetch_wav',
+    description: 'Upgrade a generation/cover asset from MP3 to provider WAV (uses the taskId+audioId stored at ' +
+        'generation time; ~0.4 Suno credits per conversion). The asset re-points at the WAV; the MP3 stays on disk.',
+    input: z.object({ assetId: z.string() }),
+    async run(input) {
+        const asset = getAsset(input.assetId);
+        if (!asset)
+            throw new Error(`Asset not found: ${input.assetId}`);
+        const origin = (asset.origin ?? {});
+        if (!origin.taskId || !origin.audioId) {
+            throw new Error('This asset has no provider taskId/audioId in its origin metadata (probably an import, or a ' +
+                'legacy generation) — the provider WAV conversion needs both. Use aurora_convert for a local ffmpeg WAV instead.');
+        }
+        const wavTaskId = await createWavConversion(origin.taskId, origin.audioId);
+        const wavUrl = await pollWavConversion(wavTaskId);
+        const wavPath = join(dirname(asset.path), `${basename(asset.path, extname(asset.path))}.wav`);
+        await downloadTo(wavUrl, wavPath);
+        const updated = updateAssetPath(asset.id, wavPath);
+        return ok({ asset: updated }, `WAV fetched: ${wavPath} (asset re-pointed; MP3 kept on disk).`);
+    }
+};
+// ── Generation (long ops — background-capable) ──────────────────
+const generateOp = {
+    id: 'aurora_generate',
+    description: 'Generate a full music track via Suno (2 variations land as project assets, MP3 + WAV-upgradeable). ' +
+        'Takes 1-3 minutes. PAID (Suno credits) — check aurora_get_credits first. ' +
+        BACKGROUND_DESCRIBE,
+    input: z.object({
+        prompt: z.string().describe('Lyrics in custom mode (style/title set), else a track description'),
+        style: z.string().optional().describe('Music style (implies custom mode)'),
+        title: z.string().optional().describe('Track title (implies custom mode)'),
+        instrumental: z.boolean().optional().describe('Generate without vocals (default false)'),
+        model: z.string().optional().describe(`Suno model id (default ${DEFAULT_GEN_MODEL})`),
+        vocalGender: z.enum(['male', 'female']).optional(),
+        negativeTags: z.string().optional().describe('Styles to exclude, ONE comma-separated string'),
+        projectId: z.string().optional().describe('Target project (auto-created from the title/prompt when omitted)'),
+        background: z.boolean().optional().describe('Return a jobId immediately instead of waiting')
+    }),
+    async run(input) {
+        const customMode = Boolean(input.style || input.title);
+        const model = (input.model ?? DEFAULT_GEN_MODEL).replace(/\./g, '_');
+        const baseName = input.title?.trim() || input.prompt.slice(0, 60).trim() || 'Generated track';
+        const projectId = await resolveProjectOrCreate(input.projectId, baseName);
+        const taskId = await createGeneration({
+            prompt: input.prompt,
+            style: input.style,
+            title: input.title,
+            instrumental: input.instrumental ?? false,
+            customMode,
+            model,
+            vocalGender: input.vocalGender,
+            negativeTags: input.negativeTags
+        });
+        const manifest = newJobManifest('generate', `gen-${uuidv4().slice(0, 8)}`, projectId, baseName, {
+            prompt: input.prompt,
+            style: input.style,
+            title: input.title,
+            instrumental: input.instrumental ?? false,
+            model,
+            vocalGender: input.vocalGender ?? null,
+            negativeTags: input.negativeTags
+        }, { taskId });
+        await saveJob(manifest);
+        if (input.background) {
+            return ok(jobSummary(manifest), jobText(manifest));
+        }
+        const finished = await awaitJob(manifest);
+        return ok(jobSummary(finished), jobText(finished));
+    }
+};
+const soundsOp = {
+    id: 'aurora_sounds',
+    description: 'Generate a sample / one-shot / loop via Suno Sounds (key + tempo lockable; 2 variations land as ' +
+        'project assets). Fast (~20-30s) and cheap (~2.5 Suno credits). sunoapi.org only. ' +
+        BACKGROUND_DESCRIBE,
+    input: z.object({
+        prompt: z.string().max(500).describe('Sound description, e.g. "huge cinematic braam, dark low brass"'),
+        soundKey: z.string().optional().describe('Pitch lock, e.g. C, Cm, F#, F#m (default Any)'),
+        tempo: z.number().int().min(1).max(300).optional().describe('BPM lock; omit for auto'),
+        loop: z.boolean().optional().describe('Generate as a loopable sound'),
+        projectId: z.string().optional(),
+        background: z.boolean().optional()
+    }),
+    async run(input) {
+        const baseName = input.prompt.slice(0, 60).trim() || 'Sound';
+        const projectId = await resolveProjectOrCreate(input.projectId, baseName);
+        const taskId = await createSoundsGeneration({
+            prompt: input.prompt,
+            soundKey: input.soundKey,
+            soundTempo: input.tempo,
+            soundLoop: input.loop
+        });
+        const manifest = newJobManifest('sounds', `snd-${uuidv4().slice(0, 8)}`, projectId, baseName, {
+            prompt: input.prompt,
+            instrumental: true,
+            model: 'V5',
+            soundKey: input.soundKey,
+            soundTempo: input.tempo,
+            soundLoop: input.loop ?? false
+        }, { taskId });
+        await saveJob(manifest);
+        if (input.background) {
+            return ok(jobSummary(manifest), jobText(manifest));
+        }
+        const finished = await awaitJob(manifest);
+        return ok(jobSummary(finished), jobText(finished));
+    }
+};
+const coverOp = {
+    id: 'aurora_cover',
+    description: 'Cover a track (Suno upload-and-cover style transform): same musical content, new style. Source is a ' +
+        'project asset or an external file (max 8 minutes). 2 variations land as cover assets linked to the ' +
+        'source. PAID (~12 Suno credits + ~0.4/WAV) — check aurora_get_credits first. ' +
+        BACKGROUND_DESCRIBE,
+    input: z.object({
+        sourceAssetId: z.string().optional().describe('Project asset to transform'),
+        sourcePath: z.string().optional().describe('OR an external audio file path'),
+        prompt: z.string().describe('What the cover should sound like'),
+        style: z.string().optional().describe('Target style (custom mode needs BOTH style and title)'),
+        title: z.string().optional(),
+        instrumental: z.boolean().optional(),
+        model: z.string().optional().describe(`Suno model id (default ${DEFAULT_GEN_MODEL})`),
+        vocalGender: z.enum(['male', 'female']).optional(),
+        negativeTags: z.string().optional().describe('Styles to exclude, ONE comma-separated string'),
+        audioWeight: z.number().min(0).max(1).optional().describe('0..1 — 0 = new style dominates, 1 = stay close to the source'),
+        projectId: z.string().optional(),
+        background: z.boolean().optional(),
+        fetchWav: z
+            .boolean()
+            .optional()
+            .describe('Blocking mode only: also fetch the provider WAV per variation (default true; ~0.4 credits each)')
+    }),
+    async run(input) {
+        const sourceAsset = input.sourceAssetId ? getAsset(input.sourceAssetId) : null;
+        if (input.sourceAssetId && !sourceAsset)
+            throw new Error(`Asset not found: ${input.sourceAssetId}`);
+        const sourcePath = sourceAsset?.path ?? input.sourcePath;
+        if (!sourcePath || !existsSync(sourcePath)) {
+            throw new Error('Cover source not found — pass sourceAssetId (a project asset) or sourcePath (a file).');
+        }
+        const customMode = Boolean(input.style || input.title);
+        if (customMode && (!input.style || !input.title)) {
+            throw new Error('Custom mode needs BOTH a style and a title (you set only one).');
+        }
+        const model = (input.model ?? DEFAULT_GEN_MODEL).replace(/\./g, '_');
+        // 8-minute reference cap (pre-checked; the provider enforces it too).
+        const duration = await probeDurationSeconds(sourcePath);
+        if (duration !== null && duration > MAX_COVER_REFERENCE_SECONDS) {
+            throw new Error(`Reference audio is ${Math.round(duration)}s — covers cap the input at 8 minutes. Export a shorter section.`);
+        }
+        const baseName = input.title?.trim() || `${basename(sourcePath, extname(sourcePath))} cover`.trim();
+        const projectId = input.projectId
+            ? (getProject(input.projectId)?.id ??
+                (() => {
+                    throw new Error(`Project not found: ${input.projectId}`);
+                })())
+            : (sourceAsset?.projectId ?? (await createProject(baseName)).id);
+        // AIFF/FLAC → standardized WAV for upload (undocumented containers). The
+        // temp file is disposable the moment the upload returns — clean it on every
+        // path (the leak here was a fresh-eyes review finding).
+        let uploadUrl;
+        let tempUpload = null;
+        try {
+            let uploadSource = sourcePath;
+            const ext = extname(sourcePath).toLowerCase();
+            if (ext !== '.wav' && ext !== '.mp3') {
+                const { tmpdir } = await import('node:os');
+                tempUpload = join(tmpdir(), `aurora-cover-upload-${Date.now()}.wav`);
+                await standardizeToWav(sourcePath, tempUpload);
+                uploadSource = tempUpload;
+            }
+            uploadUrl = await uploadAudioFile(uploadSource);
+        }
+        finally {
+            if (tempUpload) {
+                const { rm } = await import('node:fs/promises');
+                await rm(tempUpload, { force: true }).catch(() => { });
+            }
+        }
+        const taskId = await createCover({
+            uploadUrl,
+            prompt: input.prompt,
+            style: input.style,
+            title: input.title,
+            instrumental: input.instrumental ?? false,
+            customMode,
+            model,
+            vocalGender: input.vocalGender,
+            negativeTags: input.negativeTags,
+            audioWeight: input.audioWeight
+        });
+        const manifest = newJobManifest('cover', `cov-${uuidv4().slice(0, 8)}`, projectId, baseName, {
+            prompt: input.prompt,
+            style: input.style,
+            title: input.title,
+            instrumental: input.instrumental ?? false,
+            model,
+            vocalGender: input.vocalGender ?? null,
+            negativeTags: input.negativeTags,
+            audioWeight: input.audioWeight
+        }, { taskId, sourceAssetId: sourceAsset?.id ?? null });
+        await saveJob(manifest);
+        if (input.background) {
+            return ok(jobSummary(manifest), jobText(manifest));
+        }
+        const finished = await awaitJob(manifest);
+        // Blocking-mode WAV stage (mirrors the app's runCover best-effort WAVs).
+        const wavNotes = [];
+        if (finished.status === 'done' && (input.fetchWav ?? true)) {
+            for (const assetId of finished.assetIds) {
+                try {
+                    await fetchWavOp.run({ assetId });
+                    wavNotes.push(`${assetId}: WAV fetched`);
+                }
+                catch (err) {
+                    wavNotes.push(`${assetId}: WAV failed (${err instanceof Error ? err.message : err}) — MP3 kept; retry with aurora_fetch_wav`);
+                }
+            }
+        }
+        const summary = jobSummary(finished);
+        if (wavNotes.length > 0)
+            summary.wavStage = wavNotes;
+        return ok(summary, `${jobText(finished)}${wavNotes.length > 0 ? ` WAV stage: ${wavNotes.join('; ')}` : ''}`);
+    }
+};
+const splitOp = {
+    id: 'aurora_split',
+    description: 'Split ANY project asset into 7 stems (vocals, kick, snare, toms, hats, bass, everything-else) via ' +
+        '3 MVSEP jobs + local phase-cancellation. Takes 3-5+ minutes. PAID (REAL MVSEP credits — do not ' +
+        're-split an asset that already has stems; check aurora_list_assets first). Stems land ' +
+        'PROGRESSIVELY as each MVSEP job finishes. ' +
+        BACKGROUND_DESCRIBE,
+    input: z.object({
+        assetId: z.string().describe('The asset to split (generation, cover, import, or reference)'),
+        background: z.boolean().optional().describe('Strongly recommended — splits often exceed blocking-call ceilings')
+    }),
+    async run(input) {
+        const existing = getStems(input.assetId);
+        if (existing.length >= 7) {
+            return ok({ stems: existing }, 'This asset ALREADY has a full 7-stem split — returning the existing stems instead of spending ' +
+                'MVSEP credits again. Delete the stems first if you really want a re-split.');
+        }
+        const prep = await prepareSplit(input.assetId);
+        const hashes = await createSplitJobs(prep.audioBytes);
+        const manifest = newJobManifest('split', `spl-${uuidv4().slice(0, 8)}`, prep.asset.projectId, prep.asset.name, { assetId: input.assetId }, { assetId: input.assetId, stemsDir: prep.stemsDir, hashes });
+        manifest.stage = 'separating (0/3 jobs landed)';
+        await saveJob(manifest);
+        if (input.background) {
+            return ok(jobSummary(manifest), jobText(manifest));
+        }
+        const finished = await awaitJob(manifest);
+        return ok(jobSummary(finished), jobText(finished));
+    }
+};
+const getJobStatusOp = {
+    id: 'aurora_get_job_status',
+    description: 'Poll a background job (generate / sounds / cover / split). Advances the job: downloads and ' +
+        'registers whatever the provider has finished since the last poll (split stems land progressively). ' +
+        'Returns streamUrls for in-progress generations — playable immediately.',
+    input: z.object({ jobId: z.string() }),
+    async run(input) {
+        const manifest = await loadJob(input.jobId);
+        if (!manifest)
+            throw new Error(`Job not found: ${input.jobId}. Use aurora_list_jobs.`);
+        const advanced = manifest.status === 'running' ? await advanceJob(manifest) : manifest;
+        return ok(jobSummary(advanced), jobText(advanced));
+    }
+};
+const listJobsOp = {
+    id: 'aurora_list_jobs',
+    description: 'List all background jobs (newest first) with status and landed outputs.',
+    input: z.object({}).strict(),
+    async run() {
+        const jobs = await listJobs();
+        return ok({ jobs: jobs.map(jobSummary) });
+    }
+};
+// ── Audio utilities (local ffmpeg — free) ───────────────────────
+const pitchShiftOp = {
+    id: 'aurora_pitch_shift',
+    description: 'Pitch-shift an asset or audio file by +/- semitones (local ffmpeg, FREE, output locked to 44.1kHz). ' +
+        'Default varispeed (tempo shifts with pitch); preserveTempo keeps tempo constant. If the input was a ' +
+        'project asset, the result registers as a new import asset in the same project.',
+    input: z.object({
+        assetId: z.string().optional(),
+        path: z.string().optional().describe('OR an absolute file path'),
+        semitones: z.number().describe('e.g. 3, -2, 0.5'),
+        preserveTempo: z.boolean().optional(),
+        format: z.enum(['wav', 'mp3']).optional().describe('Output format (default wav)')
+    }),
+    async run(input) {
+        const { path, asset } = resolveAudioInput(input);
+        const format = input.format ?? 'wav';
+        const stem = basename(path, extname(path));
+        const sign = input.semitones >= 0 ? '+' : '';
+        const outPath = join(dirname(path), `${stem}${sign}${input.semitones}st.${format}`);
+        const engine = await pitchShift(path, outPath, input.semitones, input.preserveTempo ?? false, format);
+        let newAsset = null;
+        if (asset) {
+            newAsset = insertAsset({
+                projectId: asset.projectId,
+                kind: 'import',
+                name: basename(outPath, extname(outPath)),
+                path: outPath,
+                origin: { tool: 'pitch_shift', semitones: input.semitones, engine, sourceAssetId: asset.id },
+                sourceAssetId: asset.id
+            });
+        }
+        return ok({ outputPath: outPath, engine, asset: newAsset });
+    }
+};
+const convertOp = {
+    id: 'aurora_convert',
+    description: 'Convert an asset or audio file to WAV (44.1kHz stereo float32) or MP3 (320k CBR) via local ffmpeg ' +
+        '(FREE). If the input was a project asset, the result registers as a new import asset.',
+    input: z.object({
+        assetId: z.string().optional(),
+        path: z.string().optional(),
+        to: z.enum(['wav', 'mp3'])
+    }),
+    async run(input) {
+        const { path, asset } = resolveAudioInput(input);
+        const stem = basename(path, extname(path));
+        const sameExt = extname(path).toLowerCase() === `.${input.to}`;
+        const outPath = join(dirname(path), `${stem}${sameExt ? '-converted' : ''}.${input.to}`);
+        if (input.to === 'wav')
+            await standardizeToWav(path, outPath);
+        else
+            await convertToMp3(path, outPath);
+        let newAsset = null;
+        if (asset) {
+            newAsset = insertAsset({
+                projectId: asset.projectId,
+                kind: 'import',
+                name: basename(outPath, extname(outPath)),
+                path: outPath,
+                origin: { tool: 'convert', to: input.to, sourceAssetId: asset.id },
+                sourceAssetId: asset.id
+            });
+        }
+        return ok({ outputPath: outPath, asset: newAsset });
+    }
+};
+// ── Sidecars (local Python — free, require the aurora repo) ─────
+const rvcUpscaleOp = {
+    id: 'aurora_rvc_upscale',
+    description: "RVC vocal upscale (local Python sidecar — FREE, but needs the aurora repo + sidecar deps; set the " +
+        'AURORA_REPO env var). Input: a vocals stem (assetId + stemType "vocals") or any WAV path. Output ' +
+        'lands next to the input as <name>_upscaled.wav.',
+    input: z.object({
+        assetId: z.string().optional().describe('Asset whose vocals stem to upscale'),
+        stemType: z.string().optional().describe('Stem to pick from the asset (default "vocals")'),
+        path: z.string().optional().describe('OR a direct WAV path'),
+        model: z.string().optional().describe("'jb' (default) or 'purposeaudacity'"),
+        f0UpKey: z.number().optional().describe('Pitch shift in semitones (default 0)')
+    }),
+    async run(input) {
+        let inputPath = input.path;
+        if (input.assetId) {
+            const stems = getStems(input.assetId);
+            const want = input.stemType ?? 'vocals';
+            const stem = stems.find((s) => s.stemType === want);
+            if (!stem) {
+                throw new Error(`Asset ${input.assetId} has no "${want}" stem. Split it first (aurora_split) or pass a direct path.`);
+            }
+            inputPath = stem.path;
+        }
+        if (!inputPath)
+            throw new Error('Provide assetId (+stemType) or path.');
+        const outPath = join(dirname(inputPath), `${basename(inputPath, extname(inputPath))}_upscaled.wav`);
+        await runRvcUpscale({ inputPath, outputPath: outPath, model: input.model, f0UpKey: input.f0UpKey });
+        return ok({ outputPath: outPath });
+    }
+};
+const ripMidiOp = {
+    id: 'aurora_rip_midi',
+    description: 'Rip MIDI from an audio stem or file (local Python sidecar — FREE, but needs the aurora repo + ' +
+        'sidecar deps; set AURORA_REPO). drums→onset detection, mono→CREPE, poly→Basic Pitch. Output: <name>.mid ' +
+        'next to the input.',
+    input: z.object({
+        assetId: z.string().optional(),
+        stemType: z.string().optional().describe('Which stem of the asset (e.g. "bass", "kick")'),
+        path: z.string().optional(),
+        mode: z.enum(['poly', 'mono', 'auto']).optional().describe('Transcription path (default auto)'),
+        instrument: z.string().optional().describe('Instrument hint for auto-routing, e.g. "bass", "kick"')
+    }),
+    async run(input) {
+        let inputPath = input.path;
+        let instrument = input.instrument;
+        if (input.assetId) {
+            const stems = getStems(input.assetId);
+            if (!input.stemType)
+                throw new Error('Pass stemType with assetId (e.g. "bass", "kick").');
+            const stem = stems.find((s) => s.stemType === input.stemType);
+            if (!stem)
+                throw new Error(`Asset ${input.assetId} has no "${input.stemType}" stem.`);
+            inputPath = stem.path;
+            instrument ??= input.stemType;
+        }
+        if (!inputPath)
+            throw new Error('Provide assetId+stemType or path.');
+        const outPath = join(dirname(inputPath), `${basename(inputPath, extname(inputPath))}.mid`);
+        await runRipMidi({ inputPath, outputPath: outPath, mode: input.mode ?? 'auto', instrument });
+        return ok({ outputPath: outPath });
+    }
+};
+// ── Stack (minimal layer view) ──────────────────────────────────
+const stackListOp = {
+    id: 'aurora_stack_list',
+    description: "A project's stack lanes (the minimal layer view: name, path, offset, gain, mute/solo).",
+    input: z.object({ projectId: z.string() }),
+    async run(input) {
+        return ok({ lanes: await loadStack(input.projectId) });
+    }
+};
+const stackAddLaneOp = {
+    id: 'aurora_stack_add_lane',
+    description: 'Add a lane to the project stack from an asset, a stem (assetId + stemType), or a raw path. The app ' +
+        'shows the same stack live (stack.json in the project folder).',
+    input: z.object({
+        projectId: z.string(),
+        assetId: z.string().optional(),
+        stemType: z.string().optional().describe('With assetId: pick that stem instead of the asset audio'),
+        path: z.string().optional(),
+        name: z.string().optional(),
+        offsetSec: z.number().min(0).optional().describe('Clip start offset from timeline zero (default 0)'),
+        gainDb: z.number().optional().describe('Lane gain in dB (default 0)')
+    }),
+    async run(input) {
+        let path = input.path;
+        let sourceId;
+        let name = input.name;
+        if (input.assetId) {
+            if (input.stemType) {
+                const stem = getStems(input.assetId).find((s) => s.stemType === input.stemType);
+                if (!stem)
+                    throw new Error(`Asset ${input.assetId} has no "${input.stemType}" stem.`);
+                path = stem.path;
+                sourceId = stem.id;
+                name ??= input.stemType;
+            }
+            else {
+                const asset = getAsset(input.assetId);
+                if (!asset)
+                    throw new Error(`Asset not found: ${input.assetId}`);
+                path = asset.path;
+                sourceId = asset.id;
+                name ??= asset.name;
+            }
+        }
+        if (!path)
+            throw new Error('Provide assetId (optionally with stemType) or path.');
+        name ??= laneNameFromPath(path);
+        const lane = await addLane(input.projectId, {
+            name,
+            path,
+            sourceId,
+            offsetSec: input.offsetSec,
+            gainDb: input.gainDb
+        });
+        return ok({ lane });
+    }
+};
+const stackUpdateLaneOp = {
+    id: 'aurora_stack_update_lane',
+    description: "Update a stack lane's offset, gain, mute, solo, or name.",
+    input: z.object({
+        projectId: z.string(),
+        laneId: z.string(),
+        offsetSec: z.number().min(0).optional(),
+        gainDb: z.number().optional(),
+        mute: z.boolean().optional(),
+        solo: z.boolean().optional(),
+        name: z.string().optional()
+    }),
+    async run(input) {
+        const { projectId, laneId, ...patch } = input;
+        const lane = await updateLane(projectId, laneId, patch);
+        return ok({ lane });
+    }
+};
+const stackRemoveLaneOp = {
+    id: 'aurora_stack_remove_lane',
+    description: 'Remove a lane from the project stack.',
+    input: z.object({ projectId: z.string(), laneId: z.string() }),
+    async run(input) {
+        await removeLane(input.projectId, input.laneId);
+        return ok({ removed: input.laneId });
+    }
+};
+const stackExportOp = {
+    id: 'aurora_stack_export',
+    description: 'Export the stack as an aligned multi-WAV bundle: one 32-bit float WAV per audible lane, padded ' +
+        'with leading silence to common timeline zero — drop them all at time zero in any DAW and ' +
+        'everything lines up sample-accurately. Lands in <project>/stack-export/.',
+    input: z.object({ projectId: z.string() }),
+    async run(input) {
+        const paths = await exportStackBundle(input.projectId);
+        return ok({ paths }, `Exported ${paths.length} aligned WAV(s):\n${paths.join('\n')}`);
+    }
+};
+// ── Skills delivery (MCP-only clients) ──────────────────────────
+const getPromptingGuideOp = {
+    id: 'aurora_get_prompting_guide',
+    description: 'Read a bundled Aurora skill/guide (workflow recipes, Suno prompting, cost discipline, stems). ' +
+        'Call with no topic to list available guides. CLI users: `aurora install-skills` installs these ' +
+        'into .claude/skills/ instead.',
+    input: z.object({
+        topic: z.string().optional().describe('Guide name (from the no-topic listing) or a keyword')
+    }),
+    async run(input) {
+        const names = Object.keys(SKILLS);
+        if (!input.topic) {
+            return ok({ guides: names }, `Available guides:\n${names.join('\n')}\nCall again with topic:<name>.`);
+        }
+        const exact = SKILLS[input.topic];
+        if (exact)
+            return ok({ name: input.topic, content: exact }, exact);
+        const fuzzy = names.find((n) => n.includes(input.topic.toLowerCase()));
+        if (fuzzy)
+            return ok({ name: fuzzy, content: SKILLS[fuzzy] }, SKILLS[fuzzy]);
+        throw new Error(`No guide matching "${input.topic}". Available: ${names.join(', ')}`);
+    }
+};
+// ── Registry ────────────────────────────────────────────────────
+export const ALL_OPERATIONS = [
+    getCredits,
+    getWorkspaceState,
+    createProjectOp,
+    listProjectsOp,
+    renameProjectOp,
+    deleteProjectOp,
+    listAssetsOp,
+    importFileOp,
+    addReferenceOp,
+    deleteAssetOp,
+    fetchWavOp,
+    generateOp,
+    soundsOp,
+    coverOp,
+    splitOp,
+    getJobStatusOp,
+    listJobsOp,
+    pitchShiftOp,
+    convertOp,
+    rvcUpscaleOp,
+    ripMidiOp,
+    stackListOp,
+    stackAddLaneOp,
+    stackUpdateLaneOp,
+    stackRemoveLaneOp,
+    stackExportOp,
+    getPromptingGuideOp
+];
+//# sourceMappingURL=index.js.map