@openvidstudio/mcp-server 0.1.0 → 1.3.1

package/dist/jobs.d.ts

@@ -0,0 +1,37 @@
+/**
+ * In-memory job tracking for tools whose real work can outlast an MCP client's own request
+ * timeout (Claude Code's MCP_TOOL_TIMEOUT defaults well under the 40+ minutes a full render
+ * can take on a modest machine). A tool that accepts `async: true` starts its real work
+ * without awaiting it in the request handler, records it here, and returns a jobId
+ * immediately; `job_status` (jobStatus.ts) polls this store.
+ *
+ * Deliberately in-memory, not persisted: a job dies with the server process, same as the
+ * render it's tracking would. This process is a long-lived stdio server for the duration of
+ * one MCP connection, so a promise kicked off here and never awaited by its caller keeps
+ * running on the same event loop while later requests (including job_status polls) are
+ * handled -- that's what makes "return now, finish later" work at all.
+ */
+export type JobStatus = "running" | "done" | "error";
+export interface JobProgress {
+    framesRendered: number;
+    totalFrames: number;
+    currentBeat: string | null;
+    /** Most recent lines first isn't the point here; insertion order, capped, is. */
+    logTail: string[];
+}
+export interface JobRecord<T = unknown> {
+    id: string;
+    tool: string;
+    status: JobStatus;
+    startedAt: string;
+    updatedAt: string;
+    progress: JobProgress;
+    result?: T;
+    error?: string;
+}
+export declare function createJob<T>(tool: string, totalFrames?: number): JobRecord<T>;
+export declare function updateJobProgress(jobId: string, patch: Partial<Pick<JobProgress, "framesRendered" | "totalFrames" | "currentBeat">>): void;
+export declare function appendJobLog(jobId: string, line: string): void;
+export declare function completeJob<T>(jobId: string, result: T): void;
+export declare function failJob(jobId: string, error: string): void;
+export declare function getJob(jobId: string): JobRecord | undefined;

package/dist/jobs.js

@@ -0,0 +1,72 @@
+"use strict";
+/**
+ * In-memory job tracking for tools whose real work can outlast an MCP client's own request
+ * timeout (Claude Code's MCP_TOOL_TIMEOUT defaults well under the 40+ minutes a full render
+ * can take on a modest machine). A tool that accepts `async: true` starts its real work
+ * without awaiting it in the request handler, records it here, and returns a jobId
+ * immediately; `job_status` (jobStatus.ts) polls this store.
+ *
+ * Deliberately in-memory, not persisted: a job dies with the server process, same as the
+ * render it's tracking would. This process is a long-lived stdio server for the duration of
+ * one MCP connection, so a promise kicked off here and never awaited by its caller keeps
+ * running on the same event loop while later requests (including job_status polls) are
+ * handled -- that's what makes "return now, finish later" work at all.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createJob = createJob;
+exports.updateJobProgress = updateJobProgress;
+exports.appendJobLog = appendJobLog;
+exports.completeJob = completeJob;
+exports.failJob = failJob;
+exports.getJob = getJob;
+const MAX_LOG_LINES = 20;
+const jobs = new Map();
+function newJobId(tool) {
+    return `${tool}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function createJob(tool, totalFrames = 0) {
+    const now = new Date().toISOString();
+    const record = {
+        id: newJobId(tool),
+        tool,
+        status: "running",
+        startedAt: now,
+        updatedAt: now,
+        progress: { framesRendered: 0, totalFrames, currentBeat: null, logTail: [] },
+    };
+    jobs.set(record.id, record);
+    return record;
+}
+function updateJobProgress(jobId, patch) {
+    const job = jobs.get(jobId);
+    if (!job)
+        return;
+    Object.assign(job.progress, patch);
+    job.updatedAt = new Date().toISOString();
+}
+function appendJobLog(jobId, line) {
+    const job = jobs.get(jobId);
+    if (!job)
+        return;
+    job.progress.logTail = [...job.progress.logTail, line].slice(-MAX_LOG_LINES);
+    job.updatedAt = new Date().toISOString();
+}
+function completeJob(jobId, result) {
+    const job = jobs.get(jobId);
+    if (!job)
+        return;
+    job.status = "done";
+    job.result = result;
+    job.updatedAt = new Date().toISOString();
+}
+function failJob(jobId, error) {
+    const job = jobs.get(jobId);
+    if (!job)
+        return;
+    job.status = "error";
+    job.error = error;
+    job.updatedAt = new Date().toISOString();
+}
+function getJob(jobId) {
+    return jobs.get(jobId);
+}

package/dist/paths.d.ts

@@ -18,3 +18,13 @@ export declare const TEMPLATE_DIR: string;
  * these into a scaffolded project's own docs/ folder (see tools/initProject.ts).
  */
 export declare const DOCS_DIR: string;
+/**
+ * Bundled copy of packages/mcp-server/py/*.py, produced by this package's own build
+ * step (the directory is listed in package.json's "files", no separate copy script
+ * needed since it is already inside the package root) and shipped inside the
+ * published npm package. Same __dirname-relative reasoning as TEMPLATE_DIR and
+ * DOCS_DIR above: resolves to <package root>/py at runtime, whether this package is
+ * installed standalone or run from inside this monorepo. compose_score
+ * (tools/composeScore.ts) spawns packages/mcp-server/py/compose-score.py from here.
+ */
+export declare const PY_DIR: string;

package/dist/paths.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DOCS_DIR = exports.TEMPLATE_DIR = void 0;
+exports.PY_DIR = exports.DOCS_DIR = exports.TEMPLATE_DIR = void 0;
 const path = __importStar(require("node:path"));
 /**
  * Bundled copy of templates/default, produced by scripts/copy-template.mjs at build
@@ -55,3 +55,13 @@ exports.TEMPLATE_DIR = path.join(__dirname, "..", "templates", "default");
  * these into a scaffolded project's own docs/ folder (see tools/initProject.ts).
  */
 exports.DOCS_DIR = path.join(__dirname, "..", "docs");
+/**
+ * Bundled copy of packages/mcp-server/py/*.py, produced by this package's own build
+ * step (the directory is listed in package.json's "files", no separate copy script
+ * needed since it is already inside the package root) and shipped inside the
+ * published npm package. Same __dirname-relative reasoning as TEMPLATE_DIR and
+ * DOCS_DIR above: resolves to <package root>/py at runtime, whether this package is
+ * installed standalone or run from inside this monorepo. compose_score
+ * (tools/composeScore.ts) spawns packages/mcp-server/py/compose-score.py from here.
+ */
+exports.PY_DIR = path.join(__dirname, "..", "py");

package/dist/primitives/registry.d.ts

@@ -0,0 +1,43 @@
+/**
+ * The motion primitives catalog.
+ *
+ * scaffold_scene's 10 templates are whole scenes. Below that level there was nothing: a
+ * scene that wants a count-up number, a fanned card stack, or a typewriter line had to have
+ * that animation hand-written from motion.ts's tween/pop/spring primitives every single
+ * time (the "stat" template's own counter is a literal hardcoded "0" for exactly this
+ * reason -- it never got an animation because writing one inline wasn't worth it for one
+ * template). A small, tested, searchable set of these -- catalog_motion_primitives to find
+ * one, add_motion_primitive to drop its real source into the project -- means composing a
+ * scene from proven pieces instead of re-deriving the tween math each time.
+ *
+ * Local and bundled on purpose: a hosted registry/account is not what makes this useful, a
+ * first working batch is. Each entry's `source` is a real, self-contained .tsx component
+ * using only "react", "remotion" and "@openvidstudio/core" -- the same constraint
+ * scaffold_scene's own templates follow -- so it drops into any scene unmodified.
+ */
+export interface MotionPrimitive {
+    /** kebab-case id, e.g. "count-up-stat". Stable: add_motion_primitive looks up by this. */
+    name: string;
+    title: string;
+    description: string;
+    /** Extra terms a query might use that the title/description don't already contain. */
+    keywords: string[];
+    /** The component's exported name inside `source`. */
+    componentName: string;
+    /** Self-contained .tsx source, ready to write to disk as-is. */
+    source: string;
+}
+export declare const MOTION_PRIMITIVES: MotionPrimitive[];
+export interface PrimitiveMatch {
+    primitive: MotionPrimitive;
+    score: number;
+}
+/**
+ * Ranks the catalog against a free-text query: every query token found in the primitive's
+ * name/title/description/keywords adds a point, an exact or prefix match on `name` adds a
+ * strong bonus (so searching the id itself always wins), and an empty query returns every
+ * primitive in catalog order rather than nothing -- mirroring find_music_bed's "no query
+ * means browse everything" behaviour.
+ */
+export declare function searchMotionPrimitives(query: string | undefined, limit?: number): PrimitiveMatch[];
+export declare function findMotionPrimitive(name: string): MotionPrimitive | undefined;