vidjutsu 1.2.0 → 1.3.0

package/README.md

@@ -26,14 +26,14 @@ import { createClient } from "vidjutsu";
 
 const vj = createClient();
 
-// Watch — AI analyzes a video and answers your prompt (10 credits)
+// Watch — AI analyzes a video and answers your prompt (50/day)
 const { data: watch } = await vj.watchMedia({
   mediaUrl: "https://cdn.example.com/video.mp4",
   prompt: "Is the hook strong enough for fitness TikTok?",
 });
 console.log(watch.response);
 
-// Extract — pull frames, audio, and metadata (5 credits)
+// Extract — pull frames, audio, and metadata (100/day)
 const { data: extract } = await vj.extractMedia({
   mediaUrl: "https://cdn.example.com/video.mp4",
   frames: "auto",
@@ -41,13 +41,13 @@ const { data: extract } = await vj.extractMedia({
 });
 console.log(extract.frames, extract.metadata);
 
-// Transcribe — speech-to-text with word-level timing (10 credits)
+// Transcribe — speech-to-text with word-level timing (30/day)
 const { data: transcript } = await vj.transcribeMedia({
   mediaUrl: "https://cdn.example.com/video.mp4",
 });
 console.log(transcript.transcript, transcript.words);
 
-// Overlay — burn text onto video (5 credits)
+// Overlay — burn text onto video (50/day)
 const { data: overlay } = await vj.createOverlay({
   videoUrl: "https://cdn.example.com/video.mp4",
   text: "Follow for more tips",
@@ -77,17 +77,19 @@ const vj = createClient({ baseUrl: "https://staging.api.vidjutsu.ai" });
 
 ## All methods
 
-### Video intelligence (paid)
+### Video intelligence (metered)
 
-| Method | Credits | Description |
-|--------|---------|-------------|
-| `watchMedia(body)` | 10 | AI watches a video/image and answers your prompt |
-| `extractMedia(body)` | 5 | Extract frames, audio, and metadata from video |
-| `transcribeMedia(body)` | 10 | Speech-to-text with word-level timing |
-| `checkSpec(body)` | 5 | Validate a VidLang spec against rules |
-| `createOverlay(body)` | 5 | Burn text overlay onto video |
+Requires an active subscription. Each endpoint has its own daily rate limit (fixed window, resets 00:00 UTC). Hitting a limit returns HTTP 429 with a `retryAfter` hint.
 
-### Resources (free)
+| Method | Daily limit | Description |
+|--------|-------------|-------------|
+| `watchMedia(body)` | 50 / day | AI watches a video/image and answers your prompt |
+| `extractMedia(body)` | 100 / day | Extract frames, audio, and metadata from video |
+| `transcribeMedia(body)` | 30 / day | Speech-to-text with word-level timing |
+| `checkSpec(body)` | 100 / day | Validate a VidLang spec against rules |
+| `createOverlay(body)` | 50 / day | Burn text overlay onto video |
+
+### Resources (unmetered)
 
 | Method | Description |
 |--------|-------------|
@@ -96,7 +98,6 @@ const vj = createClient({ baseUrl: "https://staging.api.vidjutsu.ai" });
 | `createAsset(body)` / `updateAsset(body, query)` / `listOrGetAssets(query)` / `deleteAsset(query)` | Manage assets |
 | `createReference(body)` / `updateReference(body, query)` / `listOrGetReferences(query)` / `deleteReference(query)` | Manage references |
 | `uploadFile(body)` / `uploadFromUrl(body)` | Upload media to CDN |
-| `getBalance()` | Check credit balance |
 
 ### Utilities (free)
 
@@ -115,17 +116,18 @@ const vj = createClient({ baseUrl: "https://staging.api.vidjutsu.ai" });
 Every method returns the `openapi-fetch` response shape: `{ data, error, response }`. For endpoints not covered by convenience methods, use the raw client:
 
 ```ts
-const { data, error } = await vj.api.GET("/v1/balance");
+const { data, error } = await vj.api.GET("/v1/usage");
 const { data, error } = await vj.api.POST("/v1/watch", {
   body: { mediaUrl: "...", prompt: "..." },
 });
 ```
 
-## Credits & billing
+## Pricing & billing
 
-- **$99/month** — 1,000 credits included
-- **Extra credits** — $0.10 each
-- No overage charges — API returns 402 when credits run out
+- **$99/month flat** — full API access via Stripe, billed monthly, cancel anytime.
+- **No credits, no metered billing, no top-ups** — usage is governed by per-endpoint daily rate limits (reset 00:00 UTC), not a credit balance.
+- Hitting a daily limit returns **HTTP 429** with a `retryAfter` hint. Check remaining capacity with `getUsage()` or `GET /v1/usage`.
+- `GET /v1/pricing` is the single source of truth for current price and limits.
 
 ## Links
 

package/dist/cli/index.mjs

@@ -2197,14 +2197,19 @@ import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
 function loadConfig() {
+  const envApiUrl = process.env.VIDJUTSU_API_URL;
+  const envApiKey = process.env.VIDJUTSU_API_KEY;
   if (existsSync(CONFIG_FILE)) {
     const raw = JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
     if (!raw.apiUrl || raw.apiUrl.includes(".convex.site")) {
       raw.apiUrl = DEFAULT_API_URL;
     }
-    return raw;
+    return {
+      apiUrl: envApiUrl ?? raw.apiUrl,
+      apiKey: envApiKey ?? raw.apiKey
+    };
   }
-  return { apiUrl: DEFAULT_API_URL };
+  return { apiUrl: envApiUrl ?? DEFAULT_API_URL, apiKey: envApiKey };
 }
 function saveConfig(config) {
   if (!existsSync(CONFIG_DIR))
@@ -2237,7 +2242,7 @@ async function publicRequest(method, path, body) {
   }
   return json;
 }
-async function apiRequest(method, path, body) {
+async function apiRequest(method, path, body, options = {}) {
   const config = loadConfig();
   if (!config.apiKey) {
     throw new Error('Not authenticated. Run "vidjutsu auth --key <your_api_key>" first.');
@@ -2245,7 +2250,8 @@ async function apiRequest(method, path, body) {
   const url = `${config.apiUrl}${path}`;
   const headers = {
     Authorization: `Bearer ${config.apiKey}`,
-    "Content-Type": "application/json"
+    "Content-Type": "application/json",
+    ...options.idempotencyKey ? { "Idempotency-Key": options.idempotencyKey } : {}
   };
   const res = await fetch(url, {
     method,
@@ -2601,19 +2607,21 @@ var init_status = __esm(() => {
   status_default = defineCommand({
     meta: { name: "status", description: "Check resource status by ID" },
     args: {
-      id: { type: "positional", description: "Resource ID (acc_xxx, post_xxx, ref_xxx)", required: true }
+      id: { type: "positional", description: "Resource ID (job_xxx, acc_xxx, post_xxx, ref_xxx)", required: true }
     },
     async run({ args }) {
       const id = args.id;
       let path;
-      if (id.startsWith("acc_"))
+      if (id.startsWith("job_"))
+        path = `/v1/distribution/jobs?id=${id}`;
+      else if (id.startsWith("acc_"))
         path = `/v1/accounts?id=${id}`;
       else if (id.startsWith("post_"))
         path = `/v1/posts?id=${id}`;
       else if (id.startsWith("ref_"))
         path = `/v1/references?id=${id}`;
       else {
-        console.error("Unknown ID prefix. Expected acc_, post_, or ref_");
+        console.error("Unknown ID prefix. Expected job_, acc_, post_, or ref_");
         process.exit(1);
       }
       const result = await apiRequest("GET", path);
@@ -2622,6 +2630,148 @@ var init_status = __esm(() => {
   });
 });
 
+// src/cli/commands/balance.ts
+var exports_balance = {};
+__export(exports_balance, {
+  default: () => balance_default
+});
+function fmtTs(ms) {
+  const d2 = new Date(ms);
+  const pad = (n2) => String(n2).padStart(2, "0");
+  return `${d2.getUTCFullYear()}-${pad(d2.getUTCMonth() + 1)}-${pad(d2.getUTCDate())} ${pad(d2.getUTCHours())}:${pad(d2.getUTCMinutes())} UTC`;
+}
+function fmtDelta(n2) {
+  const s2 = n2 >= 0 ? `+${n2}` : String(n2);
+  return s2.padStart(6);
+}
+var balance_default;
+var init_balance = __esm(() => {
+  init_dist2();
+  init_client();
+  balance_default = defineCommand({
+    meta: {
+      name: "balance",
+      description: "Show credit balance and recent ledger entries"
+    },
+    args: {
+      json: {
+        type: "boolean",
+        description: "Emit raw JSON instead of a table",
+        default: false
+      }
+    },
+    async run({ args }) {
+      const res = await apiRequest("GET", "/v1/balance");
+      if (args.json) {
+        console.log(JSON.stringify(res, null, 2));
+        return;
+      }
+      console.log(`Balance: ${res.balance} credits`);
+      if (!res.ledger || res.ledger.length === 0) {
+        console.log(`
+No ledger entries yet.`);
+        return;
+      }
+      console.log(`
+Recent ledger (newest first):`);
+      for (const e2 of res.ledger) {
+        const detail = e2.operationId ?? e2.note ?? "";
+        console.log(`  ${fmtDelta(e2.delta)}  ${e2.reason.padEnd(7)}  ${fmtTs(e2.createdAt)}  ${detail}`);
+      }
+    }
+  });
+});
+
+// src/cli/commands/admin.ts
+var exports_admin = {};
+__export(exports_admin, {
+  default: () => admin_default
+});
+import { spawnSync } from "node:child_process";
+var grant, admin_default;
+var init_admin = __esm(() => {
+  init_dist2();
+  grant = defineCommand({
+    meta: {
+      name: "grant",
+      description: "Grant credits to a client (looked up by email or clientId). Runs the Convex mutation directly via 'npx convex run'."
+    },
+    args: {
+      email: {
+        type: "string",
+        description: "Email of the client to grant credits to"
+      },
+      client: {
+        type: "string",
+        description: "clientId of the client to grant credits to"
+      },
+      amount: {
+        type: "string",
+        description: "Number of credits to grant (positive integer)",
+        required: true
+      },
+      note: {
+        type: "string",
+        description: "Optional admin note recorded on the ledger row"
+      },
+      repo: {
+        type: "string",
+        description: "Path to the vidjutsu Convex repo where 'npx convex run' executes (defaults to cwd)"
+      }
+    },
+    async run({ args }) {
+      if (!args.email && !args.client) {
+        console.error("Error: provide --email <e> or --client <clientId>");
+        process.exit(1);
+      }
+      const amount = Number(args.amount);
+      if (!Number.isInteger(amount) || amount <= 0) {
+        console.error("Error: --amount must be a positive integer");
+        process.exit(1);
+      }
+      const payload = { amount };
+      if (args.email)
+        payload.email = args.email;
+      if (args.client)
+        payload.clientId = args.client;
+      if (args.note)
+        payload.note = args.note;
+      const cwd = args.repo ?? process.cwd();
+      const cmdArgs = [
+        "convex",
+        "run",
+        "services/machineClients:grantCreditsByLookup",
+        JSON.stringify(payload)
+      ];
+      const result = spawnSync("npx", cmdArgs, {
+        cwd,
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      if (result.error) {
+        console.error("Error invoking npx convex:", result.error.message);
+        process.exit(1);
+      }
+      if (result.stdout)
+        process.stdout.write(result.stdout);
+      if (result.stderr)
+        process.stderr.write(result.stderr);
+      if (result.status !== 0) {
+        process.exit(result.status ?? 1);
+      }
+    }
+  });
+  admin_default = defineCommand({
+    meta: {
+      name: "admin",
+      description: "Admin operations (credit grants, etc.)"
+    },
+    subCommands: {
+      grant: () => grant
+    }
+  });
+});
+
 // src/cli/commands/version.ts
 var exports_version = {};
 __export(exports_version, {
@@ -2716,6 +2866,293 @@ var init_update = __esm(() => {
   });
 });
 
+// src/cli/commands/jobs.ts
+var exports_jobs = {};
+__export(exports_jobs, {
+  default: () => jobs_default
+});
+async function getJob(jobId) {
+  return await apiRequest("GET", `/v1/jobs?id=${encodeURIComponent(jobId)}`);
+}
+var jobs_default;
+var init_jobs = __esm(() => {
+  init_dist2();
+  init_client();
+  jobs_default = defineCommand({
+    meta: { name: "jobs", description: "Inspect durable VidJutsu media jobs" },
+    subCommands: {
+      get: defineCommand({
+        meta: { name: "get", description: "Get a job" },
+        args: {
+          id: { type: "positional", description: "Job ID", required: true }
+        },
+        async run({ args }) {
+          console.log(JSON.stringify(await getJob(args.id), null, 2));
+        }
+      }),
+      wait: defineCommand({
+        meta: { name: "wait", description: "Wait for a job to complete" },
+        args: {
+          id: { type: "positional", description: "Job ID", required: true },
+          timeout: { type: "string", description: "Timeout in seconds", default: "600" },
+          interval: { type: "string", description: "Poll interval in milliseconds", default: "1000" }
+        },
+        async run({ args }) {
+          const deadline = Date.now() + Number(args.timeout) * 1000;
+          while (true) {
+            const job = await getJob(args.id);
+            if (job?.status === "completed") {
+              console.log(JSON.stringify(job, null, 2));
+              return;
+            }
+            if (job?.status === "failed" || job?.status === "cancelled") {
+              throw new Error(job.error?.message ?? `Job ${job.status}`);
+            }
+            if (Date.now() >= deadline)
+              throw new Error(`Timed out waiting for ${args.id}`);
+            await new Promise((resolve) => setTimeout(resolve, Number(args.interval)));
+          }
+        }
+      })
+    }
+  });
+});
+
+// src/cli/commands/clone.ts
+var exports_clone = {};
+__export(exports_clone, {
+  default: () => clone_default
+});
+function validateModel(model) {
+  if (model === undefined)
+    return;
+  if (!VALID_MODELS.includes(model)) {
+    throw new Error(`--model must be one of: ${VALID_MODELS.join(", ")}`);
+  }
+  return model;
+}
+function isCharacterId(value) {
+  return value.startsWith("char_");
+}
+function characterRef(value) {
+  return isCharacterId(value) ? { characterId: value } : { characterImageUrl: value };
+}
+async function pollCloneVideo(id, { intervalMs = 3000, timeoutMs = 600000 } = {}) {
+  const deadline = Date.now() + timeoutMs;
+  while (true) {
+    const status = await apiRequest("GET", `/v1/clones/video/${encodeURIComponent(id)}`);
+    if (status.status === "completed")
+      return status;
+    if (status.status === "failed")
+      throw new Error(status.error ?? `Clone video ${id} failed`);
+    if (Date.now() >= deadline)
+      throw new Error(`Timed out waiting for clone video ${id}`);
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+  }
+}
+var VALID_MODELS, clone_default;
+var init_clone = __esm(() => {
+  init_dist2();
+  init_client();
+  VALID_MODELS = ["kling", "seedance"];
+  clone_default = defineCommand({
+    meta: {
+      name: "clone",
+      description: "Clone a source video's motion onto a new character. About 5 minutes end to end for the full chain. " + "Kling motion control is the default model; output is 480p 9:16. Source clips are capped at 15 seconds. " + "Each step below is metered per call."
+    },
+    subCommands: {
+      check: defineCommand({
+        meta: {
+          name: "check",
+          description: "Evaluate whether a source video can be cloned reliably. Metered per call. " + "Exits nonzero when the verdict is weak."
+        },
+        args: {
+          videoUrl: { type: "positional", description: "Public HTTPS URL of the source video", required: true },
+          context: { type: "string", description: "Optional context about the intended clone" }
+        },
+        async run({ args }) {
+          const result = await apiRequest("POST", "/v1/clones/check", {
+            videoUrl: args.videoUrl,
+            context: args.context
+          });
+          console.log(`Verdict: ${result.verdict}`);
+          console.log(`Score: ${result.score}/100`);
+          console.log("Evidence:");
+          for (const item of result.evidence ?? []) {
+            console.log(`  - ${item}`);
+          }
+          if (result.verdict === "weak") {
+            process.exit(1);
+          }
+        }
+      }),
+      character: defineCommand({
+        meta: {
+          name: "character",
+          description: "Create a reusable, persisted character. Create it once, then reuse the printed id for every " + "clone (see `vidjutsu clone starting-image --character <id>` and `clone run --character <id>`). " + "Metered per call."
+        },
+        subCommands: {
+          list: defineCommand({
+            meta: {
+              name: "list",
+              description: "List your persisted characters. Reads are not billed."
+            },
+            async run() {
+              const result = await apiRequest("GET", "/v1/characters");
+              const characters = Array.isArray(result) ? result : result.characters ?? [];
+              if (characters.length === 0) {
+                console.log("No characters yet. Create one with: vidjutsu clone character --prompt ...");
+                return;
+              }
+              for (const c3 of characters) {
+                console.log(`${c3.id}  ${c3.model}  ${c3.createdAt}`);
+              }
+            }
+          })
+        },
+        args: {
+          prompt: { type: "string", description: "Text description of the character to generate" },
+          reference: { type: "string", description: "Optional public HTTPS reference image URL to guide identity" }
+        },
+        async run({ args, rawArgs }) {
+          if (rawArgs[0] === "list")
+            return;
+          if (!args.prompt) {
+            throw new Error("--prompt is required to create a character (or run `vidjutsu clone character list`).");
+          }
+          const result = await apiRequest("POST", "/v1/characters", {
+            prompt: args.prompt,
+            referenceImageUrl: args.reference
+          });
+          console.log(`Character created: ${result.id}`);
+          console.log(`Image: ${result.imageUrl}`);
+          console.log(`Model: ${result.model}`);
+          console.log("");
+          console.log(`Reuse this character with: --character ${result.id}`);
+        }
+      }),
+      "starting-image": defineCommand({
+        meta: {
+          name: "starting-image",
+          description: "Create a character-swapped starting frame, with no overlays. --character accepts either a stored " + "character id (char_...) or a public HTTPS character image URL. Metered per call."
+        },
+        args: {
+          character: {
+            type: "string",
+            description: "Stored character id (char_...) from `clone character`, or a public HTTPS character image URL",
+            required: true
+          },
+          prompt: { type: "string", description: "Instructions for composing the starting frame", required: true },
+          source: { type: "string", description: "Optional public HTTPS source video URL to ground the composition" }
+        },
+        async run({ args }) {
+          const result = await apiRequest("POST", "/v1/clones/starting-image", {
+            ...characterRef(args.character),
+            prompt: args.prompt,
+            sourceVideoUrl: args.source
+          });
+          console.log(result.imageUrl);
+        }
+      }),
+      video: defineCommand({
+        meta: {
+          name: "video",
+          description: "Clone source motion onto a starting image. Kling motion control is the default; seedance is the " + "alternate model, 9:16 at 480p. Metered per call. Returns a task id (HTTP 202); use --wait to poll to completion."
+        },
+        args: {
+          "starting-image": { type: "string", description: "Public HTTPS URL of the starting frame", required: true },
+          source: { type: "string", description: "Public HTTPS URL of the source video whose motion is cloned", required: true },
+          model: { type: "string", description: "kling (default) or seedance" },
+          prompt: { type: "string", description: "Optional override for the default identity-swap prompt (seedance only)" },
+          wait: { type: "boolean", description: "Poll GET status until completed or failed, then print videoUrl" }
+        },
+        async run({ args }) {
+          const model = validateModel(args.model);
+          const accepted = await apiRequest("POST", "/v1/clones/video", {
+            startingImageUrl: args["starting-image"],
+            sourceVideoUrl: args.source,
+            model,
+            prompt: args.prompt
+          });
+          console.log(accepted.id);
+          if (args.wait) {
+            const final = await pollCloneVideo(accepted.id);
+            console.log(final.videoUrl);
+          }
+        }
+      }),
+      status: defineCommand({
+        meta: {
+          name: "status",
+          description: "Poll a clone video task by id. Status reads are not billed."
+        },
+        args: {
+          id: { type: "positional", description: "Clone video task id", required: true }
+        },
+        async run({ args }) {
+          const result = await apiRequest("GET", `/v1/clones/video/${encodeURIComponent(args.id)}`);
+          console.log(JSON.stringify(result, null, 2));
+        }
+      }),
+      run: defineCommand({
+        meta: {
+          name: "run",
+          description: "Run the full clone chain: download the TikTok video, check it, generate a starting image from a " + "reusable stored character, generate the clone video, and wait for it to finish. About 5 minutes end " + "to end. Characters are reusable: create one once with `vidjutsu clone character --prompt ...`, then " + "pass its id here with --character on every run — this command never generates a new random character. " + "--character is required. Kling motion control is the default model; output is 480p 9:16, source clips " + "are capped at 15 seconds. Each step is metered per call. Stops before spending on generation when the " + "check verdict is weak, unless --force is given."
+        },
+        args: {
+          tiktokUrl: { type: "positional", description: "TikTok video URL to clone", required: true },
+          character: {
+            type: "string",
+            description: "Required. Stored character id (char_...) from `vidjutsu clone character --prompt ...`. " + "Characters are reusable across runs — create one once, then pass its id here every time."
+          },
+          "starting-prompt": { type: "string", description: "Prompt for the starting frame composition" },
+          model: { type: "string", description: "kling (default) or seedance" },
+          force: { type: "boolean", description: "Proceed even if the clone check verdict is weak" }
+        },
+        async run({ args }) {
+          const model = validateModel(args.model);
+          if (!args.character) {
+            console.log("Missing --character. Create a reusable character first with: " + 'vidjutsu clone character --prompt "A neutral, camera-ready presenter"');
+            console.log("Then pass its id here: vidjutsu clone run <url> --character char_...");
+            process.exit(1);
+          }
+          console.log(`Downloading ${args.tiktokUrl}...`);
+          const download = await apiRequest("POST", "/v1/videos/download/tiktok", {
+            url: args.tiktokUrl
+          });
+          console.log("Checking cloneability...");
+          const check = await apiRequest("POST", "/v1/clones/check", {
+            videoUrl: download.url
+          });
+          console.log(`Verdict: ${check.verdict} (score ${check.score}/100)`);
+          for (const item of check.evidence ?? []) {
+            console.log(`  - ${item}`);
+          }
+          if (check.verdict === "weak" && !args.force) {
+            console.log("Stopping: the source clip is unlikely to clone well. Pass --force to continue anyway.");
+            process.exit(1);
+          }
+          console.log("Generating starting image...");
+          const startingImage = await apiRequest("POST", "/v1/clones/starting-image", {
+            ...characterRef(args.character),
+            prompt: args["starting-prompt"] ?? "Match the framing and pose of the source video's opening frame",
+            sourceVideoUrl: download.url
+          });
+          console.log("Generating clone video...");
+          const accepted = await apiRequest("POST", "/v1/clones/video", {
+            startingImageUrl: startingImage.imageUrl,
+            sourceVideoUrl: download.url,
+            model
+          });
+          console.log(`Task ${accepted.id} accepted, polling...`);
+          const final = await pollCloneVideo(accepted.id);
+          console.log(final.videoUrl);
+        }
+      })
+    }
+  });
+});
+
 // src/cli/commands/generated/watch.ts
 var exports_watch = {};
 __export(exports_watch, {
@@ -3377,6 +3814,110 @@ var init_info = __esm(() => {
   });
 });
 
+// src/cli/commands/generated/project.ts
+var exports_project = {};
+__export(exports_project, {
+  default: () => project_default
+});
+function parseTags5(raw) {
+  if (!raw)
+    return;
+  return raw.split(",").map((pair) => {
+    const [key, ...rest] = pair.split("=");
+    return { key: key.trim(), value: rest.join("=").trim() };
+  });
+}
+var project_default;
+var init_project = __esm(() => {
+  init_dist2();
+  init_client();
+  project_default = defineCommand({
+    meta: { name: "project", description: "Manage projects" },
+    subCommands: {
+      create: defineCommand({
+        meta: { name: "create", description: "Create an editor project" },
+        args: {
+          name: { type: "string", description: "name", required: true },
+          project: { type: "string", description: "project" },
+          tags: { type: "string", description: "Tags as key=value pairs, comma-separated" },
+          metadata: { type: "string", description: "metadata" }
+        },
+        async run({ args }) {
+          const body = {};
+          if (args["name"] !== undefined)
+            body["name"] = args["name"];
+          if (args["project"] !== undefined)
+            body["project"] = args["project"];
+          const tags = parseTags5(args.tags);
+          if (tags)
+            body.tags = tags;
+          if (args["metadata"] !== undefined)
+            body["metadata"] = args["metadata"];
+          const result = await apiRequest("POST", "/v1/projects", body);
+          console.log(JSON.stringify(result, null, 2));
+        }
+      }),
+      edit: defineCommand({
+        meta: { name: "edit", description: "Edit an editor project" },
+        args: {
+          id: { type: "positional", description: "Project ID", required: true },
+          name: { type: "string", description: "name" },
+          status: { type: "string", description: "status" },
+          project: { type: "string", description: "project" },
+          tags: { type: "string", description: "Tags as key=value pairs, comma-separated" },
+          metadata: { type: "string", description: "metadata" }
+        },
+        async run({ args }) {
+          const body = {};
+          if (args["name"] !== undefined)
+            body["name"] = args["name"];
+          if (args["status"] !== undefined)
+            body["status"] = args["status"];
+          if (args["project"] !== undefined)
+            body["project"] = args["project"];
+          const tags = parseTags5(args.tags);
+          if (tags)
+            body.tags = tags;
+          if (args["metadata"] !== undefined)
+            body["metadata"] = args["metadata"];
+          const result = await apiRequest("PUT", "/v1/projects?id=" + args.id, body);
+          console.log(JSON.stringify(result, null, 2));
+        }
+      }),
+      list: defineCommand({
+        meta: { name: "list", description: "List editor projects" },
+        args: {
+          id: { type: "string", description: "Project ID (omit to list all)" },
+          status: { type: "string", description: "status" }
+        },
+        async run({ args }) {
+          let path = "/v1/projects";
+          const params = new URLSearchParams;
+          if (args["id"])
+            params.set("id", args["id"]);
+          if (args["status"])
+            params.set("status", args["status"]);
+          const qs = params.toString();
+          if (qs)
+            path += "?" + qs;
+          const result = await apiRequest("GET", path);
+          console.log(JSON.stringify(result, null, 2));
+        }
+      }),
+      delete: defineCommand({
+        meta: { name: "delete", description: "Archive an editor project" },
+        args: {
+          id: { type: "positional", description: "Project ID", required: true }
+        },
+        async run({ args }) {
+          const result = await apiRequest("DELETE", "/v1/projects?id=" + args.id);
+          console.log(JSON.stringify(result, null, 2));
+        }
+      })
+    }
+  });
+});
+
 // src/cli/index.ts
 init_dist2();
 var main = defineCommand({
@@ -3391,8 +3932,12 @@ var main = defineCommand({
     upload: () => Promise.resolve().then(() => (init_upload(), exports_upload)).then((m2) => m2.default),
     subscribe: () => Promise.resolve().then(() => (init_subscribe(), exports_subscribe)).then((m2) => m2.default),
     status: () => Promise.resolve().then(() => (init_status(), exports_status)).then((m2) => m2.default),
+    balance: () => Promise.resolve().then(() => (init_balance(), exports_balance)).then((m2) => m2.default),
+    admin: () => Promise.resolve().then(() => (init_admin(), exports_admin)).then((m2) => m2.default),
     version: () => Promise.resolve().then(() => (init_version(), exports_version)).then((m2) => m2.default),
     update: () => Promise.resolve().then(() => (init_update(), exports_update)).then((m2) => m2.default),
+    jobs: () => Promise.resolve().then(() => (init_jobs(), exports_jobs)).then((m2) => m2.default),
+    clone: () => Promise.resolve().then(() => (init_clone(), exports_clone)).then((m2) => m2.default),
     watch: () => Promise.resolve().then(() => (init_watch(), exports_watch)).then((m2) => m2.default),
     extract: () => Promise.resolve().then(() => (init_extract(), exports_extract)).then((m2) => m2.default),
     transcribe: () => Promise.resolve().then(() => (init_transcribe(), exports_transcribe)).then((m2) => m2.default),
@@ -3403,7 +3948,8 @@ var main = defineCommand({
     asset: () => Promise.resolve().then(() => (init_asset(), exports_asset)).then((m2) => m2.default),
     reference: () => Promise.resolve().then(() => (init_reference(), exports_reference)).then((m2) => m2.default),
     usage: () => Promise.resolve().then(() => (init_usage(), exports_usage)).then((m2) => m2.default),
-    info: () => Promise.resolve().then(() => (init_info(), exports_info)).then((m2) => m2.default)
+    info: () => Promise.resolve().then(() => (init_info(), exports_info)).then((m2) => m2.default),
+    project: () => Promise.resolve().then(() => (init_project(), exports_project)).then((m2) => m2.default)
   }
 });
 runMain(main);

package/dist/client.d.ts

@@ -1,6 +1,8 @@
 import createFetchClient from "openapi-fetch";
 import type { paths } from "./schema.js";
 import { type VidJutsuMethods } from "./methods.js";
+import { type DistributionNamespaces } from "./distribution.js";
+import { type JobsNamespaces } from "./jobs.js";
 export interface VidJutsuConfig {
     /** API key. Falls back to VIDJUTSU_API_KEY env var, then ~/.vidjutsu/config.json. */
     apiKey?: string;
@@ -10,7 +12,7 @@ export interface VidJutsuConfig {
 /** The raw openapi-fetch client with typed GET/POST/PUT/DELETE */
 type FetchClient = ReturnType<typeof createFetchClient<paths>>;
 /** Combined client: typed convenience methods + raw openapi-fetch escape hatch */
-export type VidJutsuClient = VidJutsuMethods & {
+export type VidJutsuClient = VidJutsuMethods & DistributionNamespaces & JobsNamespaces & {
     api: FetchClient;
 };
 /**

package/dist/client.js

@@ -1,5 +1,7 @@
 import createFetchClient from "openapi-fetch";
 import { bindMethods } from "./methods.js";
+import { bindDistribution } from "./distribution.js";
+import { bindJobs } from "./jobs.js";
 import { readFileSync, existsSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
@@ -50,5 +52,7 @@ export function createClient(config = {}) {
         },
     });
     const methods = bindMethods(fetchClient);
-    return { ...methods, api: fetchClient };
+    const distribution = bindDistribution(fetchClient);
+    const jobs = bindJobs(fetchClient);
+    return { ...methods, ...distribution, ...jobs, api: fetchClient };
 }

package/dist/distribution.d.ts

@@ -0,0 +1,23 @@
+import type createFetchClient from "openapi-fetch";
+import type { components, paths } from "./schema.js";
+type FetchClient = ReturnType<typeof createFetchClient<paths>>;
+type Job = components["schemas"]["DistributionJob"];
+type AddVideoRequest = components["schemas"]["AddVideoRequest"];
+export interface MutationOptions {
+    idempotencyKey?: string;
+}
+export interface WaitOptions {
+    timeoutMs?: number;
+    pollIntervalMs?: number;
+}
+export interface DistributionNamespaces {
+    videos: {
+        add(body: AddVideoRequest, options?: MutationOptions): Promise<Job>;
+    };
+    jobs: {
+        get(jobId: string): Promise<Job>;
+        waitForResult(jobId: string, options?: WaitOptions): Promise<Job>;
+    };
+}
+export declare function bindDistribution(client: FetchClient): DistributionNamespaces;
+export {};

package/dist/distribution.js

@@ -0,0 +1,56 @@
+export function bindDistribution(client) {
+    const jobs = {
+        async get(jobId) {
+            const result = await client.GET("/v1/distribution/jobs", {
+                params: { query: { id: jobId } },
+            });
+            return requireData(result, "get distribution job");
+        },
+        async waitForResult(jobId, options = {}) {
+            const timeoutMs = options.timeoutMs ?? 10 * 60_000;
+            const pollIntervalMs = options.pollIntervalMs ?? 1_000;
+            const deadline = Date.now() + timeoutMs;
+            while (true) {
+                const job = await jobs.get(jobId);
+                if (job.status === "completed")
+                    return job;
+                if (job.status === "failed" || job.status === "cancelled") {
+                    throw new Error(job.error?.message ?? `Distribution job ${job.status}`);
+                }
+                if (Date.now() >= deadline)
+                    throw new Error(`Timed out waiting for distribution job ${jobId}`);
+                await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+            }
+        },
+    };
+    return {
+        videos: {
+            async add(body, options) {
+                const result = await client.POST("/v1/videos/add", {
+                    body,
+                    params: { header: idempotencyHeader(options) },
+                });
+                return requireData(result, "add video");
+            },
+        },
+        jobs,
+    };
+}
+function idempotencyHeader(options) {
+    return options?.idempotencyKey ? { "Idempotency-Key": options.idempotencyKey } : {};
+}
+function requireData(result, operation) {
+    if (result.data !== undefined)
+        return result.data;
+    const message = extractErrorMessage(result.error) ?? `Vidjutsu failed to ${operation} (HTTP ${result.response.status})`;
+    throw new Error(message);
+}
+function extractErrorMessage(error) {
+    if (!error || typeof error !== "object")
+        return undefined;
+    if ("message" in error && typeof error.message === "string")
+        return error.message;
+    if ("error" in error && typeof error.error === "string")
+        return error.error;
+    return undefined;
+}

package/dist/index.d.ts

@@ -1,4 +1,6 @@
 export { createClient } from "./client.js";
 export type { VidJutsuConfig, VidJutsuClient } from "./client.js";
 export type { VidJutsuMethods } from "./methods.js";
+export type { DistributionNamespaces, MutationOptions, WaitOptions } from "./distribution.js";
+export type { JobsNamespaces } from "./jobs.js";
 export type { paths, components } from "./schema.js";

package/dist/jobs.d.ts

@@ -0,0 +1,14 @@
+import type createFetchClient from "openapi-fetch";
+import type { components, paths } from "./schema.js";
+import type { WaitOptions } from "./distribution.js";
+type FetchClient = ReturnType<typeof createFetchClient<paths>>;
+type MediaJob = components["schemas"]["MediaJob"];
+export interface JobsNamespaces {
+    mediaJobs: {
+        get(jobId: string): Promise<MediaJob>;
+        awaitJob(jobId: string, options?: WaitOptions): Promise<MediaJob>;
+    };
+    awaitJob(jobId: string, options?: WaitOptions): Promise<MediaJob>;
+}
+export declare function bindJobs(client: FetchClient): JobsNamespaces;
+export {};

package/dist/jobs.js

@@ -0,0 +1,50 @@
+export function bindJobs(client) {
+    const mediaJobs = {
+        async get(jobId) {
+            const result = await client.GET("/v1/jobs", {
+                params: { query: { id: jobId } },
+            });
+            return requireData(result, "get media job");
+        },
+        async awaitJob(jobId, options = {}) {
+            const timeoutMs = options.timeoutMs ?? 10 * 60_000;
+            const pollIntervalMs = options.pollIntervalMs ?? 1_000;
+            if (timeoutMs <= 0 || pollIntervalMs <= 0) {
+                throw new Error("timeoutMs and pollIntervalMs must be positive");
+            }
+            const deadline = Date.now() + timeoutMs;
+            while (true) {
+                const job = await mediaJobs.get(jobId);
+                if (job.status === "completed")
+                    return job;
+                if (job.status === "failed" || job.status === "cancelled") {
+                    throw new Error(job.error?.message ?? `Media job ${job.status}`);
+                }
+                if (Date.now() >= deadline) {
+                    throw new Error(`Timed out waiting for media job ${jobId}`);
+                }
+                await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+            }
+        },
+    };
+    return {
+        mediaJobs,
+        awaitJob: mediaJobs.awaitJob,
+    };
+}
+function requireData(result, operation) {
+    if (result.data !== undefined)
+        return result.data;
+    const message = extractErrorMessage(result.error) ??
+        `VidJutsu failed to ${operation} (HTTP ${result.response.status})`;
+    throw new Error(message);
+}
+function extractErrorMessage(error) {
+    if (!error || typeof error !== "object")
+        return undefined;
+    if ("message" in error && typeof error.message === "string")
+        return error.message;
+    if ("error" in error && typeof error.error === "string")
+        return error.error;
+    return undefined;
+}

package/dist/methods.d.ts

@@ -34,16 +34,38 @@ export interface VidJutsuMethods {
     listOrGetAssets(query?: QueryParams<"/v1/assets", "get">): ReturnType<Client["GET"]>;
     /** Delete asset (soft) Auth required. */
     deleteAsset(query?: QueryParams<"/v1/assets", "delete">): ReturnType<Client["DELETE"]>;
+    /** Agent registration (auth.md) */
+    signupAgent(body: ReqBody<"/v1/auth/agent", "post">): ReturnType<Client["POST"]>;
+    /** Initiate claim flow */
+    agentClaim(body: ReqBody<"/v1/auth/agent/claim", "post">): ReturnType<Client["POST"]>;
+    /** Complete claim flow */
+    agentClaimComplete(body: ReqBody<"/v1/auth/agent/claim/complete", "post">): ReturnType<Client["POST"]>;
+    /** Revoke credential */
+    agentRevoke(): ReturnType<Client["POST"]>;
     /** Confirm email verification code Public endpoint. */
     confirmVerification(body: ReqBody<"/v1/auth/verify/confirm", "post">): ReturnType<Client["POST"]>;
     /** Request email verification code Public endpoint. */
     requestVerification(body: ReqBody<"/v1/auth/verify/request", "post">): ReturnType<Client["POST"]>;
+    /** Create a reusable, persisted character image */
+    createCharacter(body: ReqBody<"/v1/characters", "post">): ReturnType<Client["POST"]>;
+    /** List your persisted characters */
+    listCharacters(): ReturnType<Client["GET"]>;
+    /** Fetch a persisted character by id */
+    getCharacter(id: string): ReturnType<Client["GET"]>;
     /** Check spec Auth required. 5 credits. */
     checkSpec(body: ReqBody<"/v1/check", "post">): ReturnType<Client["POST"]>;
     /** Get check rules Auth required. */
     getCheckRules(): ReturnType<Client["GET"]>;
     /** Update check rules Auth required. */
     updateCheckRules(body: ReqBody<"/v1/check/rules", "put">): ReturnType<Client["PUT"]>;
+    /** Evaluate whether a source video can be cloned reliably */
+    cloneCheck(body: ReqBody<"/v1/clones/check", "post">): ReturnType<Client["POST"]>;
+    /** Create a character-swapped starting frame */
+    cloneStartingImage(body: ReqBody<"/v1/clones/starting-image", "post">): ReturnType<Client["POST"]>;
+    /** Clone source motion with Kling motion control or Seedance */
+    cloneVideo(body: ReqBody<"/v1/clones/video", "post">): ReturnType<Client["POST"]>;
+    /** Poll a clone video task */
+    getCloneVideo(id: string): ReturnType<Client["GET"]>;
     /** Check prompt compliance */
     checkCompliancePrompt(body: ReqBody<"/v1/compliance/prompt", "post">): ReturnType<Client["POST"]>;
     /** Check video compliance */
@@ -52,10 +74,14 @@ export interface VidJutsuMethods {
     getCheckoutStatus(query?: QueryParams<"/v1/credits/status", "get">): ReturnType<Client["GET"]>;
     /** Burn fine-print disclaimer onto video */
     createDisclaimer(body: ReqBody<"/v1/disclaimer", "post">): ReturnType<Client["POST"]>;
+    /** Inspect a distribution job Auth required. */
+    getDistributionJob(query?: QueryParams<"/v1/distribution/jobs", "get">): ReturnType<Client["GET"]>;
     /** Extract from media Auth required. 5 credits. */
     extractMedia(body: ReqBody<"/v1/extract", "post">): ReturnType<Client["POST"]>;
     /** API info Public endpoint. */
     getInfo(): ReturnType<Client["GET"]>;
+    /** Inspect a durable VidJutsu media job Auth required. */
+    getJob(query?: QueryParams<"/v1/jobs", "get">): ReturnType<Client["GET"]>;
     /** Burn text overlay onto video Auth required. 5 credits. */
     createOverlay(body: ReqBody<"/v1/overlay", "post">): ReturnType<Client["POST"]>;
     /** Create post Auth required. */
@@ -68,6 +94,14 @@ export interface VidJutsuMethods {
     deletePost(query?: QueryParams<"/v1/posts", "delete">): ReturnType<Client["DELETE"]>;
     /** Get pricing Public endpoint. */
     getPricing(): ReturnType<Client["GET"]>;
+    /** Create editor project */
+    createEditorProject(body: ReqBody<"/v1/projects", "post">): ReturnType<Client["POST"]>;
+    /** Update editor project */
+    updateEditorProject(body: ReqBody<"/v1/projects", "put">, query?: QueryParams<"/v1/projects", "put">): ReturnType<Client["PUT"]>;
+    /** List projects or get by ID */
+    listOrGetEditorProjects(query?: QueryParams<"/v1/projects", "get">): ReturnType<Client["GET"]>;
+    /** Archive editor project (soft) */
+    deleteEditorProject(query?: QueryParams<"/v1/projects", "delete">): ReturnType<Client["DELETE"]>;
     /** Create reference Auth required. */
     createReference(body: ReqBody<"/v1/references", "post">): ReturnType<Client["POST"]>;
     /** Update reference Auth required. */
@@ -76,6 +110,30 @@ export interface VidJutsuMethods {
     listOrGetReferences(query?: QueryParams<"/v1/references", "get">): ReturnType<Client["GET"]>;
     /** Delete reference Auth required. */
     deleteReference(query?: QueryParams<"/v1/references", "delete">): ReturnType<Client["DELETE"]>;
+    /** Scrape Instagram post or reel Auth required. 1 credits. */
+    scrapeInstagramPost(body: ReqBody<"/v1/scrape/instagram/post", "post">): ReturnType<Client["POST"]>;
+    /** Scrape Instagram post comments Auth required. 1 credits. */
+    scrapeInstagramPostComments(body: ReqBody<"/v1/scrape/instagram/post/comments", "post">): ReturnType<Client["POST"]>;
+    /** Scrape Instagram profile Auth required. 1 credits. */
+    scrapeInstagramProfile(body: ReqBody<"/v1/scrape/instagram/profile", "post">): ReturnType<Client["POST"]>;
+    /** Scrape Instagram user posts Auth required. 1 credits. */
+    scrapeInstagramUserPosts(body: ReqBody<"/v1/scrape/instagram/user/posts", "post">): ReturnType<Client["POST"]>;
+    /** Scrape Instagram user reels Auth required. 1 credits. */
+    scrapeInstagramUserReels(body: ReqBody<"/v1/scrape/instagram/user/reels", "post">): ReturnType<Client["POST"]>;
+    /** Scrape TikTok profile Auth required. 1 credits. */
+    scrapeTikTokProfile(body: ReqBody<"/v1/scrape/tiktok/profile", "post">): ReturnType<Client["POST"]>;
+    /** Scrape TikTok profile videos Auth required. 1 credits. */
+    scrapeTikTokProfileVideos(body: ReqBody<"/v1/scrape/tiktok/profile/videos", "post">): ReturnType<Client["POST"]>;
+    /** Scrape TikTok user search Auth required. 1 credits. */
+    scrapeTikTokSearchUsers(body: ReqBody<"/v1/scrape/tiktok/search/users", "post">): ReturnType<Client["POST"]>;
+    /** Scrape TikTok trending feed Auth required. 1 credits. */
+    scrapeTikTokTrending(body: ReqBody<"/v1/scrape/tiktok/trending", "post">): ReturnType<Client["POST"]>;
+    /** Scrape TikTok video Auth required. 1 credits. */
+    scrapeTikTokVideo(body: ReqBody<"/v1/scrape/tiktok/video", "post">): ReturnType<Client["POST"]>;
+    /** Scrape TikTok video comments Auth required. 1 credits. */
+    scrapeTikTokVideoComments(body: ReqBody<"/v1/scrape/tiktok/video/comments", "post">): ReturnType<Client["POST"]>;
+    /** Scrape TikTok video transcript Auth required. 1 credits. */
+    scrapeTikTokVideoTranscript(body: ReqBody<"/v1/scrape/tiktok/video/transcript", "post">): ReturnType<Client["POST"]>;
     /** Create subscription Public endpoint. */
     createSubscription(body: ReqBody<"/v1/subscribe", "post">): ReturnType<Client["POST"]>;
     /** Transcribe media Auth required. 10 credits. */
@@ -86,6 +144,12 @@ export interface VidJutsuMethods {
     uploadFromUrl(body: ReqBody<"/v1/upload/url", "post">): ReturnType<Client["POST"]>;
     /** Get daily usage */
     getUsage(): ReturnType<Client["GET"]>;
+    /** Add a video from an uploaded asset or direct MP4 URL Auth required. */
+    addVideo(body: ReqBody<"/v1/videos/add", "post">): ReturnType<Client["POST"]>;
+    /** Import an Instagram video into VidJutsu Auth required. 1 credits. */
+    downloadInstagramVideo(body: ReqBody<"/v1/videos/download/instagram", "post">): ReturnType<Client["POST"]>;
+    /** Import a TikTok video into VidJutsu Auth required. 1 credits. */
+    downloadTikTokVideo(body: ReqBody<"/v1/videos/download/tiktok", "post">): ReturnType<Client["POST"]>;
     /** Watch media Auth required. 10 credits. */
     watchMedia(body: ReqBody<"/v1/watch", "post">): ReturnType<Client["POST"]>;
 }

package/dist/methods.js

@@ -30,12 +30,33 @@ export function bindMethods(client) {
         deleteAsset(query) {
             return client.DELETE("/v1/assets", { params: { query } });
         },
+        signupAgent(body) {
+            return client.POST("/v1/auth/agent", { body });
+        },
+        agentClaim(body) {
+            return client.POST("/v1/auth/agent/claim", { body });
+        },
+        agentClaimComplete(body) {
+            return client.POST("/v1/auth/agent/claim/complete", { body });
+        },
+        agentRevoke() {
+            return client.POST("/v1/auth/agent/revoke", {});
+        },
         confirmVerification(body) {
             return client.POST("/v1/auth/verify/confirm", { body });
         },
         requestVerification(body) {
             return client.POST("/v1/auth/verify/request", { body });
         },
+        createCharacter(body) {
+            return client.POST("/v1/characters", { body });
+        },
+        listCharacters() {
+            return client.GET("/v1/characters", {});
+        },
+        getCharacter(id) {
+            return client.GET("/v1/characters/{id}", { params: { path: { id } } });
+        },
         checkSpec(body) {
             return client.POST("/v1/check", { body });
         },
@@ -45,6 +66,18 @@ export function bindMethods(client) {
         updateCheckRules(body) {
             return client.PUT("/v1/check/rules", { body });
         },
+        cloneCheck(body) {
+            return client.POST("/v1/clones/check", { body });
+        },
+        cloneStartingImage(body) {
+            return client.POST("/v1/clones/starting-image", { body });
+        },
+        cloneVideo(body) {
+            return client.POST("/v1/clones/video", { body });
+        },
+        getCloneVideo(id) {
+            return client.GET("/v1/clones/video/{id}", { params: { path: { id } } });
+        },
         checkCompliancePrompt(body) {
             return client.POST("/v1/compliance/prompt", { body });
         },
@@ -57,12 +90,18 @@ export function bindMethods(client) {
         createDisclaimer(body) {
             return client.POST("/v1/disclaimer", { body });
         },
+        getDistributionJob(query) {
+            return client.GET("/v1/distribution/jobs", { params: { query } });
+        },
         extractMedia(body) {
             return client.POST("/v1/extract", { body });
         },
         getInfo() {
             return client.GET("/v1/info", {});
         },
+        getJob(query) {
+            return client.GET("/v1/jobs", { params: { query } });
+        },
         createOverlay(body) {
             return client.POST("/v1/overlay", { body });
         },
@@ -81,6 +120,18 @@ export function bindMethods(client) {
         getPricing() {
             return client.GET("/v1/pricing", {});
         },
+        createEditorProject(body) {
+            return client.POST("/v1/projects", { body });
+        },
+        updateEditorProject(body, query) {
+            return client.PUT("/v1/projects", { body, params: { query } });
+        },
+        listOrGetEditorProjects(query) {
+            return client.GET("/v1/projects", { params: { query } });
+        },
+        deleteEditorProject(query) {
+            return client.DELETE("/v1/projects", { params: { query } });
+        },
         createReference(body) {
             return client.POST("/v1/references", { body });
         },
@@ -93,6 +144,42 @@ export function bindMethods(client) {
         deleteReference(query) {
             return client.DELETE("/v1/references", { params: { query } });
         },
+        scrapeInstagramPost(body) {
+            return client.POST("/v1/scrape/instagram/post", { body });
+        },
+        scrapeInstagramPostComments(body) {
+            return client.POST("/v1/scrape/instagram/post/comments", { body });
+        },
+        scrapeInstagramProfile(body) {
+            return client.POST("/v1/scrape/instagram/profile", { body });
+        },
+        scrapeInstagramUserPosts(body) {
+            return client.POST("/v1/scrape/instagram/user/posts", { body });
+        },
+        scrapeInstagramUserReels(body) {
+            return client.POST("/v1/scrape/instagram/user/reels", { body });
+        },
+        scrapeTikTokProfile(body) {
+            return client.POST("/v1/scrape/tiktok/profile", { body });
+        },
+        scrapeTikTokProfileVideos(body) {
+            return client.POST("/v1/scrape/tiktok/profile/videos", { body });
+        },
+        scrapeTikTokSearchUsers(body) {
+            return client.POST("/v1/scrape/tiktok/search/users", { body });
+        },
+        scrapeTikTokTrending(body) {
+            return client.POST("/v1/scrape/tiktok/trending", { body });
+        },
+        scrapeTikTokVideo(body) {
+            return client.POST("/v1/scrape/tiktok/video", { body });
+        },
+        scrapeTikTokVideoComments(body) {
+            return client.POST("/v1/scrape/tiktok/video/comments", { body });
+        },
+        scrapeTikTokVideoTranscript(body) {
+            return client.POST("/v1/scrape/tiktok/video/transcript", { body });
+        },
         createSubscription(body) {
             return client.POST("/v1/subscribe", { body });
         },
@@ -108,6 +195,15 @@ export function bindMethods(client) {
         getUsage() {
             return client.GET("/v1/usage", {});
         },
+        addVideo(body) {
+            return client.POST("/v1/videos/add", { body });
+        },
+        downloadInstagramVideo(body) {
+            return client.POST("/v1/videos/download/instagram", { body });
+        },
+        downloadTikTokVideo(body) {
+            return client.POST("/v1/videos/download/tiktok", { body });
+        },
         watchMedia(body) {
             return client.POST("/v1/watch", { body });
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vidjutsu",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "VidJutsu — video intelligence API. SDK + CLI.",
   "type": "module",
   "main": "./dist/index.js",