@vivipilot/cli 0.1.0 → 0.1.4

package/src/mcp.ts

@@ -1,438 +0,0 @@
-import { mkdir, writeFile } from "node:fs/promises";
-import { dirname } from "node:path";
-import { createInterface } from "node:readline";
-import { randomUUID } from "node:crypto";
-import { VivipilotApiClient, type EstimateRequest } from "./api.js";
-import { type CliConfig, type Env, resolveApiUrl } from "./config.js";
-
-type StdioLike = {
-  stdin: NodeJS.ReadableStream;
-  stdout: NodeJS.WritableStream;
-  stderr: NodeJS.WritableStream;
-};
-
-type JsonRpcId = string | number | null;
-type JsonRpcRequest = {
-  jsonrpc: "2.0";
-  id?: JsonRpcId;
-  method?: string;
-  params?: unknown;
-};
-
-type ToolResult = {
-  content: Array<{ type: "text"; text: string }>;
-  structuredContent?: Record<string, unknown>;
-  isError?: boolean;
-};
-
-export type McpServerOptions = {
-  config: CliConfig;
-  env?: Env;
-} & StdioLike;
-
-const PROTOCOL_VERSION = "2025-06-18";
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function optionalNumber(args: Record<string, unknown>, key: string): number | undefined {
-  const value = args[key];
-  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
-}
-
-function optionalString(args: Record<string, unknown>, key: string): string | undefined {
-  const value = args[key];
-  return typeof value === "string" && value.trim() ? value.trim() : undefined;
-}
-
-function estimateRequestFromToolArgs(args: Record<string, unknown>): EstimateRequest {
-  const prompt = optionalString(args, "prompt");
-  if (!prompt) throw new Error("prompt is required");
-  const engine = optionalString(args, "engine");
-  const enginePreference = engine === "pixi" || engine === "three" || engine === "auto" ? engine : undefined;
-  const width = optionalNumber(args, "width");
-  const height = optionalNumber(args, "height");
-  const fps = optionalNumber(args, "fps");
-  const durationSeconds = optionalNumber(args, "durationSeconds") ?? optionalNumber(args, "duration");
-
-  return {
-    prompt,
-    ...(width || height || fps ? { canvas: { width, height, fps } } : {}),
-    ...(durationSeconds ? { durationSeconds } : {}),
-    ...(enginePreference ? { enginePreference } : {}),
-  };
-}
-
-function jsonToolResult(value: Record<string, unknown>, isError = false): ToolResult {
-  return {
-    content: [{ type: "text", text: JSON.stringify(value, null, 2) }],
-    structuredContent: value,
-    isError,
-  };
-}
-
-function toolError(error: unknown): ToolResult {
-  const message = error instanceof Error ? error.message : String(error);
-  return jsonToolResult({ ok: false, error: message }, true);
-}
-
-async function writeJsonFile(path: string, value: unknown): Promise<void> {
-  await mkdir(dirname(path), { recursive: true });
-  await writeFile(path, `${JSON.stringify(value, null, 2)}\n`, "utf8");
-}
-
-async function verifyLocalManifest(manifestPath: string, config: CliConfig, env: Env) {
-  const { verifyManifestFile } = await import("./manifest.js");
-  return verifyManifestFile(manifestPath, config, env);
-}
-
-function tools() {
-  return [
-    {
-      name: "vivipilot_get_balance",
-      title: "Get Vivipilot paid credit balance",
-      description: "Returns Vivipilot account balance and paid top-up balance. CLI/MCP generation is paid-only and never grants trial credits.",
-      inputSchema: { type: "object", properties: {}, additionalProperties: false },
-    },
-    {
-      name: "vivipilot_estimate_motion_layout",
-      title: "Estimate Vivipilot motion layout credits",
-      description: "Estimates paid credits for a cloud layout generation. This does not burn credits.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          prompt: { type: "string" },
-          width: { type: "number" },
-          height: { type: "number" },
-          fps: { type: "number" },
-          durationSeconds: { type: "number" },
-          engine: { type: "string", enum: ["pixi", "three", "auto"] },
-        },
-        required: ["prompt"],
-        additionalProperties: false,
-      },
-    },
-    {
-      name: "vivipilot_generate_motion_layout",
-      title: "Generate signed Vivipilot render manifest",
-      description: "Paid-only cloud generation. Burns paid credits only after cloud orchestration is wired; local rendering uses the client's hardware.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          prompt: { type: "string" },
-          out: { type: "string" },
-          idempotencyKey: { type: "string" },
-          width: { type: "number" },
-          height: { type: "number" },
-          fps: { type: "number" },
-          durationSeconds: { type: "number" },
-          engine: { type: "string", enum: ["pixi", "three", "auto"] },
-        },
-        required: ["prompt"],
-        additionalProperties: false,
-      },
-    },
-    {
-      name: "vivipilot_verify_manifest",
-      title: "Verify Vivipilot render manifest",
-      description: "Verifies a signed Vivipilot manifest locally using public keys. This does not burn credits.",
-      inputSchema: {
-        type: "object",
-        properties: { manifestPath: { type: "string" } },
-        required: ["manifestPath"],
-        additionalProperties: false,
-      },
-    },
-    {
-      name: "vivipilot_render_video",
-      title: "Render Vivipilot video locally",
-      description: "Renders a signed manifest on local hardware after signature verification. No cloud rendering is used.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          manifestPath: { type: "string" },
-          out: { type: "string" },
-          verifyOnly: { type: "boolean" },
-        },
-        required: ["manifestPath"],
-        additionalProperties: false,
-      },
-    },
-    {
-      name: "vivipilot_get_generation_status",
-      title: "Get Vivipilot generation status",
-      description: "Checks cloud status for a Vivipilot layout generation. This does not burn credits.",
-      inputSchema: {
-        type: "object",
-        properties: { generationId: { type: "string" } },
-        required: ["generationId"],
-        additionalProperties: false,
-      },
-    },
-  ];
-}
-
-async function callTool(name: string, args: unknown, client: VivipilotApiClient, config: CliConfig, env: Env): Promise<ToolResult> {
-  const toolArgs = isRecord(args) ? args : {};
-  try {
-    switch (name) {
-      case "vivipilot_get_balance": {
-        const balance = await client.balance() as Record<string, unknown>;
-        const paidBalance = typeof balance.paidBalance === "number" ? balance.paidBalance : 0;
-        const nextActions = paidBalance > 0
-          ? [
-            { tool: "vivipilot_estimate_motion_layout", reason: "Estimate credits for a generation before spending." },
-            { tool: "vivipilot_generate_motion_layout", reason: "Generate a signed manifest (paid credits will be burned)." },
-          ]
-          : [
-            { action: "topup", reason: `Buy credits at ${resolveApiUrl(config, env)}/edit?billing=topup before generating. CLI/MCP generation is paid-only.` },
-          ];
-        return jsonToolResult({ ok: true, ...balance, nextActions });
-      }
-      case "vivipilot_estimate_motion_layout": {
-        const estimate = await client.estimate(estimateRequestFromToolArgs(toolArgs)) as Record<string, unknown>;
-        const estimatedCredits = typeof estimate.estimatedCredits === "number" ? estimate.estimatedCredits : 0;
-        return jsonToolResult({
-          ok: true,
-          ...estimate,
-          nextActions: [
-            { tool: "vivipilot_generate_motion_layout", reason: `Generate now for ~${estimatedCredits} credits (paid-only).` },
-            { tool: "vivipilot_get_balance", reason: "Check balance before generating." },
-          ],
-        });
-      }
-      case "vivipilot_generate_motion_layout": {
-        const out = optionalString(toolArgs, "out") ?? "scene.vivi.json";
-        const idempotencyKey = optionalString(toolArgs, "idempotencyKey") ?? `mcp_${randomUUID()}`;
-        const request = estimateRequestFromToolArgs(toolArgs);
-
-        // Use async start + poll for progress visibility
-        const startResult = await client.startGenerate(
-          { ...request, outputFormat: "manifest" },
-          idempotencyKey,
-        );
-        const generationId = startResult.generationId;
-
-        // If already completed (idempotent replay), fetch manifest
-        if (startResult.idempotentReplay && startResult.status === "completed") {
-          const status = await client.generationProgress(generationId);
-          if (status.manifestData) {
-            await writeJsonFile(out, status.manifestData);
-            return jsonToolResult({
-              ok: true,
-              generationId,
-              manifestPath: out,
-              creditsCharged: status.creditsCharged ?? null,
-              status: "completed",
-              nextActions: [
-                { tool: "vivipilot_verify_manifest", args: { manifestPath: out }, reason: "Verify the signed manifest locally before rendering." },
-                { tool: "vivipilot_render_video", args: { manifestPath: out }, reason: "Render the manifest to video on local hardware." },
-              ],
-            });
-          }
-        }
-
-        // Poll until terminal
-        const maxWaitMs = 300_000;
-        const pollInterval = 2000;
-        const startTime = Date.now();
-        let lastProgress = "";
-
-        while (Date.now() - startTime < maxWaitMs) {
-          await new Promise((r) => setTimeout(r, pollInterval));
-          let status;
-          try {
-            status = await client.generationProgress(generationId);
-          } catch {
-            continue;
-          }
-
-          if (status.progressMessage && status.progressMessage !== lastProgress) {
-            lastProgress = status.progressMessage;
-          }
-
-          if (status.status === "completed" && status.manifestData) {
-            await writeJsonFile(out, status.manifestData);
-            return jsonToolResult({
-              ok: true,
-              generationId,
-              manifestPath: out,
-              creditsCharged: status.creditsCharged ?? null,
-              engine: status.engine,
-              status: "completed",
-              progressLog: lastProgress,
-              nextActions: [
-                { tool: "vivipilot_verify_manifest", args: { manifestPath: out }, reason: "Verify the signed manifest locally before rendering." },
-                { tool: "vivipilot_render_video", args: { manifestPath: out }, reason: "Render the manifest to video on local hardware." },
-              ],
-            });
-          }
-
-          if (status.status === "failed") {
-            return jsonToolResult({
-              ok: false,
-              generationId,
-              error: status.error ?? "Generation failed.",
-              progressLog: lastProgress,
-              nextActions: [
-                { tool: "vivipilot_generate_motion_layout", reason: "Retry with a new prompt or idempotency key." },
-                { tool: "vivipilot_get_balance", reason: "Check balance before retrying." },
-              ],
-            }, true);
-          }
-        }
-
-        return jsonToolResult({
-          ok: false,
-          generationId,
-          error: "Generation timed out after 5 minutes.",
-          nextActions: [
-            { tool: "vivipilot_get_generation_status", args: { generationId }, reason: "Check if generation completed after timeout." },
-          ],
-        }, true);
-      }
-      case "vivipilot_verify_manifest": {
-        const manifestPath = optionalString(toolArgs, "manifestPath");
-        if (!manifestPath) throw new Error("manifestPath is required");
-        const result = await verifyLocalManifest(manifestPath, config, env);
-        if (!result.ok) throw new Error(result.message);
-        return jsonToolResult({
-          ok: true,
-          manifestId: result.manifest.manifestId,
-          generationId: result.manifest.generationId,
-          canonicalPayloadHash: result.canonicalPayloadHash,
-          nextActions: [
-            { tool: "vivipilot_render_video", args: { manifestPath }, reason: "Render the verified manifest to video." },
-          ],
-        });
-      }
-      case "vivipilot_render_video": {
-        const manifestPath = optionalString(toolArgs, "manifestPath");
-        if (!manifestPath) throw new Error("manifestPath is required");
-        const out = optionalString(toolArgs, "out") ?? "video.mp4";
-        const format = optionalString(toolArgs, "format") as "mp4" | "webm" | "gif" | "mov" | undefined;
-        const scale = optionalNumber(toolArgs, "scale");
-        const fps = optionalNumber(toolArgs, "fps");
-        const transparent = toolArgs.transparent === true;
-        const verifyOnly = toolArgs.verifyOnly === true;
-
-        const { renderManifest } = await import("./render.js");
-        const result = await renderManifest(
-          {
-            manifestPath,
-            outPath: out,
-            ...(format ? { format } : {}),
-            ...(scale ? { scale } : {}),
-            ...(fps ? { fps } : {}),
-            ...(transparent ? { transparent } : {}),
-            verifyOnly,
-          },
-          config,
-          env,
-        );
-
-        return jsonToolResult({
-          ok: true,
-          manifestId: result.manifestId,
-          out: result.outPath,
-          size: result.size,
-          nextActions: [
-            { action: "file_ready", reason: `Video written to ${result.outPath} (${(result.size / 1024 / 1024).toFixed(2)} MB).` },
-          ],
-        });
-      }
-      case "vivipilot_get_generation_status": {
-        const generationId = optionalString(toolArgs, "generationId");
-        if (!generationId) throw new Error("generationId is required");
-        const status = await client.generationProgress(generationId) as Record<string, unknown>;
-        const nextActions: Array<{ tool: string; args?: Record<string, unknown>; reason: string }> = [];
-        if (status.status === "completed" && status.manifest) {
-          nextActions.push({ tool: "vivipilot_verify_manifest", reason: "Verify the completed manifest." });
-          nextActions.push({ tool: "vivipilot_render_video", reason: "Render the completed manifest to video." });
-        } else if (status.status === "failed") {
-          nextActions.push({ tool: "vivipilot_generate_motion_layout", reason: "Retry with a new idempotency key." });
-          nextActions.push({ tool: "vivipilot_get_balance", reason: "Check balance before retrying." });
-        } else {
-          nextActions.push({ tool: "vivipilot_get_generation_status", args: { generationId }, reason: "Poll again — generation still in progress." });
-        }
-        return jsonToolResult({ ok: true, ...status, nextActions });
-      }
-      default:
-        throw new Error(`Unknown tool: ${name}`);
-    }
-  } catch (error) {
-    return toolError(error);
-  }
-}
-
-function send(stdout: NodeJS.WritableStream, message: Record<string, unknown>): void {
-  stdout.write(`${JSON.stringify(message)}\n`);
-}
-
-function sendResult(stdout: NodeJS.WritableStream, id: JsonRpcId, result: unknown): void {
-  send(stdout, { jsonrpc: "2.0", id, result });
-}
-
-function sendError(stdout: NodeJS.WritableStream, id: JsonRpcId | undefined, code: number, message: string): void {
-  send(stdout, { jsonrpc: "2.0", id: id ?? null, error: { code, message } });
-}
-
-export async function startMcpServer(options: McpServerOptions): Promise<void> {
-  const env = options.env ?? process.env;
-  const client = new VivipilotApiClient({ config: options.config, env });
-  const lines = createInterface({ input: options.stdin });
-
-  for await (const line of lines) {
-    const trimmed = line.trim();
-    if (!trimmed) continue;
-
-    let message: JsonRpcRequest;
-    try {
-      message = JSON.parse(trimmed) as JsonRpcRequest;
-    } catch {
-      sendError(options.stdout, null, -32700, "Parse error");
-      continue;
-    }
-
-    const id = message.id;
-    try {
-      switch (message.method) {
-        case "initialize":
-          sendResult(options.stdout, id ?? null, {
-            protocolVersion: PROTOCOL_VERSION,
-            capabilities: { tools: { listChanged: false } },
-            serverInfo: {
-              name: "vivipilot",
-              title: "Vivipilot MCP",
-              version: "0.1.0",
-            },
-            instructions: "Vivipilot generation tools are paid-only and require VIVIPILOT_API_KEY or `vivipilot login` configuration. Local render tools use the client's hardware.",
-          });
-          break;
-        case "notifications/initialized":
-          break;
-        case "ping":
-          sendResult(options.stdout, id ?? null, {});
-          break;
-        case "tools/list":
-          sendResult(options.stdout, id ?? null, { tools: tools() });
-          break;
-        case "tools/call": {
-          if (!isRecord(message.params) || typeof message.params.name !== "string") {
-            sendError(options.stdout, id, -32602, "tools/call requires params.name");
-            break;
-          }
-          const result = await callTool(message.params.name, message.params.arguments, client, options.config, env);
-          sendResult(options.stdout, id ?? null, result);
-          break;
-        }
-        default:
-          if (id !== undefined) sendError(options.stdout, id, -32601, `Method not found: ${message.method ?? ""}`);
-      }
-    } catch (error) {
-      const messageText = error instanceof Error ? error.message : String(error);
-      if (id !== undefined) sendError(options.stdout, id, -32603, messageText);
-    }
-  }
-}