@ericdisero/aurora-shared 0.1.0

package/dist/jobs.js

@@ -0,0 +1,220 @@
+// Background-job model. Long ops (generate / sounds / cover / split) can submit
+// and return immediately; the job's provider handles (taskId / MVSEP hashes)
+// persist to userData/agent-jobs/<jobId>.json, so status survives process
+// restarts — aurora_get_job_status re-polls the PROVIDER, not in-process state,
+// and finishes downloads/DB-landing the moment results are ready (per-stem
+// progressive for splits). Mirrors the bridge's job.json manifest discipline.
+import { join, extname } from 'node:path';
+import { mkdir, readFile, readdir, writeFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { getJobsDir } from './paths.js';
+import { downloadTo, fetchGenerationRecord, isGenerationFailure } from './providers/suno.js';
+import { fetchSeparationStatus, resolveSeparationStatus } from './providers/mvsep.js';
+import { ensureKindDir, getAsset, insertAsset, uniqueDestPath } from './storage/assets.js';
+import { landSplitJob, finalizeSplit } from './split.js';
+function jobPath(jobId) {
+    return join(getJobsDir(), `${jobId}.json`);
+}
+export async function saveJob(m) {
+    m.updatedAt = new Date().toISOString();
+    await mkdir(getJobsDir(), { recursive: true });
+    await writeFile(jobPath(m.jobId), JSON.stringify(m, null, 2));
+}
+export async function loadJob(jobId) {
+    const p = jobPath(jobId);
+    if (!existsSync(p))
+        return null;
+    try {
+        return JSON.parse(await readFile(p, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+export async function listJobs() {
+    const dir = getJobsDir();
+    if (!existsSync(dir))
+        return [];
+    const files = (await readdir(dir)).filter((f) => f.endsWith('.json'));
+    const jobs = [];
+    for (const f of files) {
+        try {
+            jobs.push(JSON.parse(await readFile(join(dir, f), 'utf-8')));
+        }
+        catch {
+            // skip unreadable manifests
+        }
+    }
+    return jobs.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+}
+export function newJobManifest(kind, jobId, projectId, baseName, params, provider) {
+    const now = new Date().toISOString();
+    return {
+        jobId,
+        kind,
+        status: 'running',
+        createdAt: now,
+        updatedAt: now,
+        projectId,
+        baseName,
+        params,
+        provider,
+        landed: {},
+        assetIds: [],
+        stems: [],
+        stage: 'submitted'
+    };
+}
+function sanitizeFileName(name) {
+    return name.replace(/[\\/:*?"<>|]/g, '_').trim() || 'track';
+}
+/** Land finished generation/sounds/cover variations as project assets —
+ *  mirrors the app's generation:generate landing (MP3 + audioId in origin;
+ *  the app's or MCP's fetch-WAV upgrades on demand). */
+async function landGenerationAssets(m, variations) {
+    const kind = m.kind === 'cover' ? 'cover' : 'generation';
+    const outputDir = await ensureKindDir(m.projectId, kind);
+    for (let i = 0; i < variations.length; i++) {
+        const v = variations[i];
+        if (!v.audioUrl)
+            continue;
+        const variantName = variations.length > 1 ? `${m.baseName} v${i + 1}` : m.baseName;
+        const ext = extname(new URL(v.audioUrl).pathname) || '.mp3';
+        const dest = uniqueDestPath(outputDir, `${sanitizeFileName(variantName)}${ext}`);
+        await downloadTo(v.audioUrl, dest);
+        const asset = insertAsset({
+            projectId: m.projectId,
+            kind,
+            name: sanitizeFileName(variantName),
+            path: dest,
+            origin: {
+                provider: 'sunoapi',
+                ...m.params,
+                taskId: m.provider.taskId,
+                audioId: v.id ?? null
+            },
+            sourceAssetId: m.provider.sourceAssetId ?? null
+        });
+        m.assetIds.push(asset.id);
+    }
+}
+// Per-job serialization: two concurrent status polls advancing the same job
+// would double-land assets (both read landed=false, both download + insert).
+// Within this process, the second caller awaits the first and gets its result.
+// (Cross-process races — CLI + MCP simultaneously — are narrowed by the fresh
+// manifest re-read below, not fully eliminated; acceptable for v1 dogfood.)
+const advanceLocks = new Map();
+/** Advance a running job by ONE provider poll, landing whatever is ready.
+ *  Idempotent and serialized per jobId — the status op can hit it repeatedly. */
+export async function advanceJob(m) {
+    if (m.status !== 'running')
+        return m;
+    const inFlight = advanceLocks.get(m.jobId);
+    if (inFlight)
+        return inFlight;
+    const run = (async () => {
+        // Re-read disk state so a concurrent process's landing isn't repeated.
+        const fresh = (await loadJob(m.jobId)) ?? m;
+        if (fresh.status !== 'running')
+            return fresh;
+        try {
+            if (fresh.kind === 'split') {
+                await advanceSplit(fresh);
+            }
+            else {
+                await advanceGeneration(fresh);
+            }
+        }
+        catch (err) {
+            fresh.status = 'error';
+            fresh.error = err instanceof Error ? err.message : String(err);
+            fresh.stage = 'error';
+        }
+        await saveJob(fresh);
+        return fresh;
+    })();
+    advanceLocks.set(m.jobId, run);
+    try {
+        return await run;
+    }
+    finally {
+        advanceLocks.delete(m.jobId);
+    }
+}
+async function advanceGeneration(m) {
+    const taskId = m.provider.taskId;
+    if (!taskId)
+        throw new Error('Job manifest has no provider taskId');
+    const record = await fetchGenerationRecord(taskId);
+    m.lastStatus = record.status;
+    // Monotonic grow only — providers can drop streamAudioUrl from later
+    // responses; never shrink a previously-seen preview list.
+    const streams = record.variations
+        .map((v) => v.streamAudioUrl)
+        .filter((u) => Boolean(u));
+    if (streams.length > (m.streamUrls?.length ?? 0))
+        m.streamUrls = streams;
+    if (record.status === 'SUCCESS' || record.status === 'CALLBACK_EXCEPTION') {
+        const ready = record.variations.filter((v) => v.audioUrl);
+        if (ready.length === 0) {
+            if (record.status === 'SUCCESS') {
+                throw new Error('Provider reported SUCCESS but returned no audio URLs');
+            }
+            m.stage = 'finishing (callback grace window)';
+            return;
+        }
+        if (!m.landed.assets) {
+            m.stage = 'downloading variations';
+            await landGenerationAssets(m, ready);
+            m.landed.assets = true;
+        }
+        m.status = 'done';
+        m.stage = 'complete';
+        return;
+    }
+    if (isGenerationFailure(record.status)) {
+        throw new Error(`Generation failed with status: ${record.status}`);
+    }
+    m.stage =
+        (m.streamUrls?.length ?? 0) > 0
+            ? `generating (${record.status}) — stream preview available`
+            : `generating (${record.status})`;
+}
+async function advanceSplit(m) {
+    const { hashes, assetId, stemsDir } = m.provider;
+    if (!hashes || !assetId || !stemsDir)
+        throw new Error('Split job manifest is incomplete');
+    const asset = getAsset(assetId);
+    if (!asset)
+        throw new Error(`Split source asset no longer exists: ${assetId}`);
+    const jobNames = ['vocals', 'drumsep', 'bass'];
+    const pendingStates = [];
+    // Poll the pending hashes in parallel — one status round-trip per poll, not three.
+    const pending = jobNames.filter((j) => !m.landed[j]);
+    const statuses = await Promise.all(pending.map((j) => fetchSeparationStatus(hashes[j])));
+    for (let i = 0; i < pending.length; i++) {
+        const job = pending[i];
+        const files = resolveSeparationStatus(hashes[job], statuses[i]);
+        if (files) {
+            const rows = await landSplitJob(job, files, asset, stemsDir);
+            m.stems.push(...rows.map((r) => ({ stemType: r.stemType, path: r.path })));
+            m.landed[job] = true;
+        }
+        else {
+            pendingStates.push(`${job}: ${statuses[i].status}`);
+        }
+    }
+    if (jobNames.every((j) => m.landed[j])) {
+        if (!m.landed.ee) {
+            const row = await finalizeSplit(asset, stemsDir);
+            m.stems.push({ stemType: row.stemType, path: row.path });
+            m.landed.ee = true;
+        }
+        m.status = 'done';
+        m.stage = 'complete — 7 stems landed';
+        return;
+    }
+    const landedCount = jobNames.filter((j) => m.landed[j]).length;
+    m.stage = `separating (${landedCount}/3 jobs landed; ${pendingStates.join(', ')})`;
+}
+//# sourceMappingURL=jobs.js.map

package/dist/operations/index.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+export interface OperationResult {
+    text: string;
+    data?: unknown;
+}
+export interface Operation<I> {
+    id: string;
+    description: string;
+    input: z.ZodType<I>;
+    run: (input: I) => Promise<OperationResult>;
+}
+export declare const ALL_OPERATIONS: ReadonlyArray<Operation<unknown>>;