storyforge 0.18.0 → 0.18.1

package/dist/index.js

@@ -2,6 +2,10 @@
 import {
   log
 } from "./chunk-GJQ45C5W.js";
+import {
+  concatWithExtras
+} from "./chunk-7KBSDIP5.js";
+import "./chunk-ZHECC3YI.js";
 import "./chunk-NSPRIPOP.js";
 
 // src/commands/dev.ts
@@ -9,9 +13,18 @@ import * as fs2 from "fs";
 import * as os2 from "os";
 import * as path2 from "path";
 import * as http from "http";
-import { execFile, exec as execCb, execSync, spawn } from "child_process";
+import { exec as execCb, execSync, spawn } from "child_process";
 import { promisify } from "util";
 
+// src/utils/open-browser.ts
+import { execFile } from "child_process";
+function openBrowser(url) {
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  execFile(cmd, [url], (err) => {
+    if (err) log.warn(`Could not open browser automatically. Open manually: ${url}`);
+  });
+}
+
 // src/config.ts
 import * as fs from "fs";
 import * as path from "path";
@@ -24,13 +37,30 @@ var FORGE_ENV_PATHS = [
   path.join(os.homedir(), ".forge.env")
   // ~/.forge.env (legacy short form)
 ];
-function getForgeDir() {
-  fs.mkdirSync(FORGE_DIR, { recursive: true });
-  return FORGE_DIR;
+function normalizeBridgeUrl(url) {
+  return url.replace(/\/+$/, "");
 }
-function saveCredentials(creds) {
-  getForgeDir();
-  fs.writeFileSync(CREDS_PATH, JSON.stringify(creds, null, 2));
+function readCredsFile(credsPath) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(credsPath, "utf-8"));
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function readLinks(file) {
+  const raw = file.links;
+  if (!Array.isArray(raw)) return [];
+  return raw.filter(
+    (l) => !!l && typeof l === "object" && typeof l.url === "string" && typeof l.workerToken === "string" && typeof l.label === "string"
+  );
+}
+function saveCredentials(creds, credsPath = CREDS_PATH) {
+  fs.mkdirSync(path.dirname(credsPath), { recursive: true });
+  const links = readLinks(readCredsFile(credsPath));
+  const out = { ...creds };
+  if (links.length > 0) out.links = links;
+  fs.writeFileSync(credsPath, JSON.stringify(out, null, 2));
 }
 function loadCredentials() {
   try {
@@ -39,6 +69,35 @@ function loadCredentials() {
     return null;
   }
 }
+function saveLink(entry, credsPath = CREDS_PATH) {
+  fs.mkdirSync(path.dirname(credsPath), { recursive: true });
+  const file = readCredsFile(credsPath);
+  const url = normalizeBridgeUrl(entry.url);
+  const links = readLinks(file).filter((l) => normalizeBridgeUrl(l.url) !== url);
+  links.push({ url, workerToken: entry.workerToken, label: entry.label });
+  file.links = links;
+  fs.writeFileSync(credsPath, JSON.stringify(file, null, 2), { mode: 384 });
+  try {
+    fs.chmodSync(credsPath, 384);
+  } catch {
+  }
+}
+function findLink(url, credsPath = CREDS_PATH) {
+  const target = normalizeBridgeUrl(url);
+  return readLinks(readCredsFile(credsPath)).find((l) => normalizeBridgeUrl(l.url) === target) ?? null;
+}
+function resolveBridgeToken(opts) {
+  const env = opts.env ?? process.env;
+  const envToken = env.FORGE_BRIDGE_TOKEN ?? env.BRIDGE_TOKEN;
+  if (envToken) return { token: envToken, source: "env" };
+  const link = findLink(opts.url, opts.credsPath);
+  if (link?.workerToken) return { token: link.workerToken, source: "link", label: link.label };
+  return null;
+}
+function resolveBridgeTokenForCommand(opts) {
+  if (opts.explicit) return opts.explicit;
+  return resolveBridgeToken({ url: opts.url, env: opts.env, credsPath: opts.credsPath })?.token ?? null;
+}
 function findEnvFilesWalkingUp(startDir) {
   const found = [];
   const home = os.homedir();
@@ -886,12 +945,6 @@ function collectFiles(dir, base = "") {
 function stripFences(text) {
   return text.replace(/^```(?:tsx?|jsx?|typescript|javascript)?\n?/m, "").replace(/\n?```\s*$/m, "").trim();
 }
-function openBrowser(url) {
-  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
-  execFile(cmd, [url], (err) => {
-    if (err) log.warn(`Could not open browser automatically. Open manually: ${url}`);
-  });
-}
 async function devCommand(options) {
   const env = loadDotEnv();
   const port = parseInt(options.port || String(PORT), 10);
@@ -901,10 +954,10 @@ async function devCommand(options) {
   if (env.loaded.length > 0) {
     log.info(`Loaded env: ${env.loaded.join(", ")} from ${env.sources.join(", ")}`);
   }
-  const bridgeToken = process.env.FORGE_BRIDGE_TOKEN ?? process.env.BRIDGE_TOKEN ?? "";
-  if (bridgeToken) {
-    const apiUrl = process.env.FORGE_BRIDGE_URL ?? WEB_URL;
-    const credResult = await fetchBridgeCredentials({ apiUrl, token: bridgeToken });
+  const bridgeApiUrl = process.env.FORGE_BRIDGE_URL ?? WEB_URL;
+  const bridge = resolveBridgeToken({ url: bridgeApiUrl });
+  if (bridge) {
+    const credResult = await fetchBridgeCredentials({ apiUrl: bridgeApiUrl, token: bridge.token });
     if (credResult.error) {
       log.info(`Bridge cred fetch skipped: ${credResult.error}`);
     } else if (credResult.loaded.length > 0) {
@@ -1676,9 +1729,7 @@ Return ONLY the complete updated TSX. No markdown fences, no explanation.`;
       console.log(`  Script generation \u2192 ${scriptGenModel}`);
       console.log(`  POST http://localhost:${port}/api/script-gen`);
     }
-    const bridgeUrl = process.env.FORGE_BRIDGE_URL ?? WEB_URL;
-    const bridgeToken2 = process.env.FORGE_BRIDGE_TOKEN ?? process.env.BRIDGE_TOKEN ?? "";
-    if (bridgeToken2) {
+    if (bridge) {
       const pkgVersion = (() => {
         try {
           const here = path2.dirname(new URL(import.meta.url).pathname);
@@ -1689,20 +1740,21 @@ Return ONLY the complete updated TSX. No markdown fences, no explanation.`;
         return "0.0.0";
       })();
       void (async () => {
-        const { BridgePoller } = await import("./bridge-poller-WSSTXFPC.js");
-        const poller = new BridgePoller({ baseUrl: bridgeUrl, token: bridgeToken2, clientVersion: `storyforge ${pkgVersion}` });
+        const { BridgePoller } = await import("./bridge-poller-67VQZZ3U.js");
+        const poller = new BridgePoller({ baseUrl: bridgeApiUrl, token: bridge.token, clientVersion: `storyforge ${pkgVersion}` });
         poller.start();
       })();
       console.log("");
-      console.log(`  Bridge tunnel \u2192 ${bridgeUrl}/api/cli-bridge/* (outbound polling)`);
+      const via = bridge.source === "link" ? ` (linked as ${bridge.label})` : "";
+      console.log(`  Bridge tunnel \u2192 ${bridgeApiUrl}/api/cli-bridge/* (outbound polling)${via}`);
     } else {
       console.log("");
-      console.log("  Bridge tunnel disabled \u2014 set FORGE_BRIDGE_TOKEN to expose your CLI seats.");
-      console.log("  Vercel env vars do NOT reach this laptop. Pick ONE of these:");
+      log.warn("Bridge tunnel disabled \u2014 no worker token for this deployment.");
+      console.log(`  Run  storyforge link  to pair this machine with ${bridgeApiUrl} (recommended).`);
+      console.log("  Or provide FORGE_BRIDGE_TOKEN yourself:");
       console.log("    a) export FORGE_BRIDGE_TOKEN=xxx in your shell, then re-run storyforge");
       console.log("    b) drop FORGE_BRIDGE_TOKEN=xxx into ./.env (cwd) or ~/.forge/.env");
       console.log("    c) one-shot:  FORGE_BRIDGE_TOKEN=xxx npx storyforge");
-      console.log(`  Use the SAME token value you set on Vercel as FORGE_BRIDGE_TOKEN.`);
     }
     console.log("");
     console.log("  Ctrl+C to stop");
@@ -1753,17 +1805,146 @@ async function loginCommand() {
   }
 }
 
+// src/commands/link.ts
+import * as os3 from "os";
+
+// package.json
+var package_default = {
+  name: "storyforge",
+  version: "0.18.1",
+  description: "StoryForge \u2014 local bridge for the Forge video production web app. Parallel clip-render orchestrator (Remotion 4 + Manim + HyperFrames + ffmpeg) + final video stitcher + dependency doctor.",
+  type: "module",
+  bin: {
+    storyforge: "./dist/index.js"
+  },
+  files: [
+    "dist/",
+    "README.md"
+  ],
+  scripts: {
+    build: "tsup",
+    lint: "tsc --noEmit",
+    test: "vitest run",
+    prepublishOnly: "npm run build"
+  },
+  dependencies: {
+    "@ccusage/codex": "18.0.11",
+    "@mozilla/readability": "0.6.0",
+    ccusage: "18.0.11",
+    jsdom: "29.1.1",
+    "react-tweet": "3.3.0"
+  },
+  devDependencies: {
+    tsup: "8.5.0",
+    typescript: "5.8.3"
+  },
+  publishConfig: {
+    access: "public"
+  },
+  keywords: [
+    "video",
+    "remotion",
+    "storyforge",
+    "cli",
+    "forge"
+  ],
+  license: "MIT",
+  engines: {
+    node: ">=18.0.0"
+  },
+  repository: {
+    type: "git",
+    url: "git+https://github.com/backspacevenkat/forge.git",
+    directory: "packages/cli"
+  }
+};
+
+// src/commands/link.ts
+var DEFAULT_BRIDGE_URL = "https://forge.algo-thinker.com";
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function linkCommand(opts = {}) {
+  const baseUrl = normalizeBridgeUrl(opts.baseUrl ?? process.env.FORGE_BRIDGE_URL ?? DEFAULT_BRIDGE_URL);
+  log.banner("\nStoryForge \u2014 Link this machine\n");
+  let start;
+  try {
+    const resp = await fetch(`${baseUrl}/api/cli-bridge/link/start`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Accept: "application/json" },
+      body: JSON.stringify({ cliVersion: package_default.version, host: os3.hostname() })
+    });
+    if (!resp.ok) {
+      const text = await resp.text().catch(() => "");
+      log.error(`Could not start link (${resp.status}) at ${baseUrl}: ${text.slice(0, 200)}`);
+      process.exit(1);
+    }
+    start = await resp.json();
+  } catch (err) {
+    log.error(`Could not reach ${baseUrl}: ${err.message}`);
+    process.exit(1);
+  }
+  console.log(`  Verification code:  ${start.code}`);
+  console.log(`  Approve at:         ${start.approveUrl}`);
+  console.log("");
+  console.log("  Check that the code above matches the one shown in your browser,");
+  console.log("  then approve. Waiting for approval\u2026");
+  console.log("");
+  if (!opts.noOpen) openBrowser(start.approveUrl);
+  const pollUrl = `${baseUrl}/api/cli-bridge/link/poll?linkId=${encodeURIComponent(start.linkId)}`;
+  const intervalMs = Math.max(1e3, start.pollIntervalMs || 2e3);
+  const expiresAtMs = Date.parse(start.expiresAt);
+  const deadline = Number.isFinite(expiresAtMs) ? expiresAtMs : Date.now() + 10 * 60 * 1e3;
+  while (Date.now() < deadline) {
+    await sleep(intervalMs);
+    let body;
+    try {
+      const resp = await fetch(pollUrl, { headers: { Accept: "application/json" } });
+      if (!resp.ok) continue;
+      body = await resp.json();
+    } catch {
+      continue;
+    }
+    switch (body.status) {
+      case "pending":
+        continue;
+      case "approved":
+        if (!body.workerToken || !body.label) {
+          log.error("Approval response was missing the worker token. Run `storyforge link` again.");
+          process.exit(1);
+        }
+        saveLink({ url: baseUrl, workerToken: body.workerToken, label: body.label });
+        log.success(`Linked as ${body.label}`);
+        return;
+      case "denied":
+        log.error("Link request was denied in the browser.");
+        process.exit(1);
+        return;
+      case "consumed":
+        log.error("Link request was already used. Run `storyforge link` again.");
+        process.exit(1);
+        return;
+      case "expired":
+        log.error("Link request expired, run `storyforge link` again.");
+        process.exit(1);
+        return;
+      default:
+        continue;
+    }
+  }
+  log.error("Link request expired, run `storyforge link` again.");
+  process.exit(1);
+}
+
 // src/commands/doctor.ts
 import { spawn as spawn2 } from "child_process";
 import { promisify as promisify2 } from "util";
 import { execFile as execFileCb } from "child_process";
-import os3 from "os";
+import os4 from "os";
 var execFile2 = promisify2(execFileCb);
 async function runDoctor() {
-  const platform = os3.platform();
-  const arch = os3.arch();
-  const cores = os3.cpus().length;
-  const ramGb = Math.round(os3.totalmem() / 1024 ** 3);
+  const platform = os4.platform();
+  const arch = os4.arch();
+  const cores = os4.cpus().length;
+  const ramGb = Math.round(os4.totalmem() / 1024 ** 3);
   const renderers = await Promise.all([
     checkFfmpeg(platform),
     checkPython(),
@@ -1834,7 +2015,7 @@ async function checkPython() {
     installed: probe.installed,
     version: probe.version,
     rationale: "manim engine runtime",
-    installCommand: os3.platform() === "darwin" ? "brew install python@3.12" : "sudo apt install -y python3",
+    installCommand: os4.platform() === "darwin" ? "brew install python@3.12" : "sudo apt install -y python3",
     required: false
   };
 }
@@ -1936,7 +2117,7 @@ async function doctorCommand() {
 import { spawn as spawn3 } from "child_process";
 import readline2 from "readline/promises";
 import { stdin as input, stdout as output } from "process";
-import os4 from "os";
+import os5 from "os";
 function planInstall(missing, platform) {
   const steps = [];
   for (const r of missing) {
@@ -2066,15 +2247,13 @@ async function installRenderersCommand(opts = {}) {
 }
 
 // src/commands/render.ts
-import { spawn as spawn4 } from "child_process";
 import * as fs5 from "fs";
-import * as os6 from "os";
 import * as path5 from "path";
 
 // src/lib/manifest.ts
 import * as fs3 from "fs";
 import * as path3 from "path";
-import * as os5 from "os";
+import * as os6 from "os";
 var DEFAULT_BASE_URL = "https://forge.algo-thinker.com";
 function localCacheRelPath(artifact) {
   if (artifact.kind === "clips" && artifact.aspect) {
@@ -2087,7 +2266,7 @@ function resolveCacheRoot(slug, override) {
   if (override) return path3.resolve(override, slug);
   const envOverride = process.env.FORGE_CACHE_DIR;
   if (envOverride) return path3.resolve(envOverride, slug);
-  return path3.join(os5.homedir(), ".forge", "cache", slug);
+  return path3.join(os6.homedir(), ".forge", "cache", slug);
 }
 function resolveBaseUrl(override) {
   return (override ?? process.env.FORGE_BASE_URL ?? DEFAULT_BASE_URL).replace(/\/$/, "");
@@ -2206,6 +2385,16 @@ async function downloadFile(url, absPath, signal) {
 function clipsInOrder(ready, aspect) {
   return ready.filter(({ artifact }) => artifact.kind === "clips" && (artifact.aspect ?? "16:9") === aspect).map(({ absPath }) => absPath);
 }
+function brandExtrasFromPull(ready) {
+  let watermarkPath;
+  let brandAudioPath;
+  for (const { artifact, absPath } of ready) {
+    if (artifact.kind !== "brand") continue;
+    if (artifact.brandSlot === "watermark") watermarkPath = absPath;
+    else if (artifact.brandSlot === "brand_audio") brandAudioPath = absPath;
+  }
+  return { watermarkPath, brandAudioPath };
+}
 function formatPullSummary(result) {
   const parts = [
     `${result.fresh} cached`,
@@ -2228,8 +2417,11 @@ async function renderCommand(opts) {
   const outPath = path5.resolve(opts.out ?? "out.mp4");
   log.info(`render \xB7 slug=${opts.slug} \xB7 aspect=${aspect}`);
   log.info(`cache  \xB7 ${cacheRoot}`);
+  loadDotEnv();
+  const baseUrl = resolveBaseUrl(opts.baseUrl);
+  const token = resolveBridgeTokenForCommand({ url: baseUrl, explicit: opts.token }) ?? void 0;
   log.info(`fetching manifest\u2026`);
-  const manifest = await fetchManifest(opts.slug, { baseUrl: opts.baseUrl, token: opts.token });
+  const manifest = await fetchManifest(opts.slug, { baseUrl, token });
   log.info(`manifest \xB7 ${manifest.artifacts.length} artifact(s) \xB7 updated ${manifest.updatedAt}`);
   if (opts.clean && fs5.existsSync(cacheRoot)) {
     log.info(`--clean: wiping cache dir`);
@@ -2254,41 +2446,23 @@ async function renderCommand(opts) {
   if (clipPaths.length === 0) {
     throw new Error(`no clips for aspect ${aspect} \u2014 manifest may be empty or all pulls failed`);
   }
-  log.info(`stitching ${clipPaths.length} clip(s) \u2192 ${outPath}`);
-  await ffmpegConcat(clipPaths, outPath);
+  const brand = brandExtrasFromPull(pullResult.ready);
+  const brandNote = [
+    brand.watermarkPath ? "watermark" : null,
+    brand.brandAudioPath ? "audio bed" : null
+  ].filter(Boolean).join(" + ");
+  log.info(`stitching ${clipPaths.length} clip(s)${brandNote ? ` + brand (${brandNote})` : ""} \u2192 ${outPath}`);
+  await ffmpegConcat(clipPaths, outPath, brand);
   const finalStat = fs5.statSync(outPath);
   log.success(`done \xB7 ${outPath} (${(finalStat.size / 1024 / 1024).toFixed(1)} MB)`);
 }
-async function ffmpegConcat(inputs, outPath) {
-  const tmpDir = fs5.mkdtempSync(path5.join(os6.tmpdir(), "storyforge-render-"));
-  const listPath = path5.join(tmpDir, "concat.txt");
-  const listBody = inputs.map((p) => `file '${p.replace(/'/g, "'\\''")}'`).join("\n") + "\n";
-  fs5.writeFileSync(listPath, listBody);
+async function ffmpegConcat(inputs, outPath, brand = {}) {
   fs5.mkdirSync(path5.dirname(outPath), { recursive: true });
-  await new Promise((resolve6, reject) => {
-    const proc = spawn4("ffmpeg", [
-      "-y",
-      "-f",
-      "concat",
-      "-safe",
-      "0",
-      "-i",
-      listPath,
-      "-c",
-      "copy",
-      "-movflags",
-      "+faststart",
-      outPath
-    ], { stdio: ["ignore", "inherit", "inherit"] });
-    proc.on("error", reject);
-    proc.on("close", (code) => {
-      try {
-        fs5.rmSync(tmpDir, { recursive: true, force: true });
-      } catch {
-      }
-      if (code === 0) resolve6();
-      else reject(new Error(`ffmpeg exited ${code}`));
-    });
+  await concatWithExtras({
+    segmentPaths: inputs,
+    outPath,
+    watermarkPath: brand.watermarkPath,
+    brandAudioPath: brand.brandAudioPath
   });
 }
 
@@ -2297,13 +2471,14 @@ import * as fs6 from "fs";
 import * as path6 from "path";
 import * as readline3 from "readline";
 async function pushCommand(opts) {
-  const token = resolveBridgeToken(opts.token);
+  loadDotEnv();
+  const baseUrl = resolveBaseUrl(opts.baseUrl);
+  const token = resolveBridgeTokenForCommand({ url: baseUrl, explicit: opts.token });
   if (!token) {
     throw new Error(
-      "push requires a bridge token. Run `storyforge login`, set BRIDGE_TOKEN, or pass --token <bearer>."
+      "push requires a bridge token. Run `storyforge link`, set BRIDGE_TOKEN, or pass --token <bearer>."
     );
   }
-  const baseUrl = resolveBaseUrl(opts.baseUrl);
   const cacheRoot = resolveCacheRoot(opts.slug, opts.cache);
   log.info(`push \xB7 slug=${opts.slug}`);
   log.info(`cache \xB7 ${cacheRoot}`);
@@ -2421,13 +2596,6 @@ async function postFinalize(slug, baseUrl, token, args) {
   if (!resp.ok) throw new Error(`finalize HTTP ${resp.status}: ${text.slice(0, 300)}`);
   return JSON.parse(text);
 }
-function resolveBridgeToken(explicit) {
-  if (explicit) return explicit;
-  if (process.env.FORGE_BRIDGE_TOKEN) return process.env.FORGE_BRIDGE_TOKEN;
-  if (process.env.BRIDGE_TOKEN) return process.env.BRIDGE_TOKEN;
-  loadDotEnv();
-  return process.env.FORGE_BRIDGE_TOKEN ?? process.env.BRIDGE_TOKEN ?? null;
-}
 function humanBytes(n) {
   if (n < 1024) return `${n}B`;
   if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)}K`;
@@ -2445,13 +2613,14 @@ import * as fs7 from "fs";
 import * as path7 from "path";
 var ALLOWED_EXTS = /* @__PURE__ */ new Set([".mp4", ".webm", ".mov"]);
 async function pushHookCommand(opts) {
-  const token = resolveBridgeToken2(opts.token);
+  loadDotEnv();
+  const baseUrl = resolveBaseUrl(opts.baseUrl);
+  const token = resolveBridgeTokenForCommand({ url: baseUrl, explicit: opts.token });
   if (!token) {
     throw new Error(
-      "push-hook requires a bridge token. Run `storyforge login`, set BRIDGE_TOKEN, or pass --token <bearer>."
+      "push-hook requires a bridge token. Run `storyforge link`, set BRIDGE_TOKEN, or pass --token <bearer>."
     );
   }
-  const baseUrl = resolveBaseUrl(opts.baseUrl);
   if (opts.files.length === 0) throw new Error("no files to upload");
   log.info(`push-hook \xB7 slug=${opts.slug}`);
   log.info(`api    \xB7 ${baseUrl}`);
@@ -2501,63 +2670,6 @@ async function pushHookCommand(opts) {
     throw new Error("all hooks failed to upload");
   }
 }
-function resolveBridgeToken2(explicit) {
-  if (explicit) return explicit;
-  if (process.env.FORGE_BRIDGE_TOKEN) return process.env.FORGE_BRIDGE_TOKEN;
-  if (process.env.BRIDGE_TOKEN) return process.env.BRIDGE_TOKEN;
-  loadDotEnv();
-  return process.env.FORGE_BRIDGE_TOKEN ?? process.env.BRIDGE_TOKEN ?? null;
-}
-
-// package.json
-var package_default = {
-  name: "storyforge",
-  version: "0.18.0",
-  description: "StoryForge \u2014 local bridge for the Forge video production web app. Parallel clip-render orchestrator (Remotion 4 + Manim + HyperFrames + ffmpeg) + final video stitcher + dependency doctor.",
-  type: "module",
-  bin: {
-    storyforge: "./dist/index.js"
-  },
-  files: [
-    "dist/",
-    "README.md"
-  ],
-  scripts: {
-    build: "tsup",
-    lint: "tsc --noEmit",
-    prepublishOnly: "npm run build"
-  },
-  dependencies: {
-    "@ccusage/codex": "18.0.11",
-    "@mozilla/readability": "0.6.0",
-    ccusage: "18.0.11",
-    jsdom: "29.1.1",
-    "react-tweet": "3.3.0"
-  },
-  devDependencies: {
-    tsup: "8.5.0",
-    typescript: "5.8.3"
-  },
-  publishConfig: {
-    access: "public"
-  },
-  keywords: [
-    "video",
-    "remotion",
-    "storyforge",
-    "cli",
-    "forge"
-  ],
-  license: "MIT",
-  engines: {
-    node: ">=18.0.0"
-  },
-  repository: {
-    type: "git",
-    url: "git+https://github.com/backspacevenkat/forge.git",
-    directory: "packages/cli"
-  }
-};
 
 // src/index.ts
 var VERSION = package_default.version;
@@ -2571,6 +2683,7 @@ Usage:
   storyforge push-hook <slug> <file> [<file>...]
                                    Upload standalone hook MP4(s) to a project on Storj
   storyforge login                 Log in to forge.algo-thinker.com
+  storyforge link                  Pair this machine with a Forge deployment (mints a bridge worker token)
   storyforge doctor                Probe local renderers (ffmpeg / python / manim / hyperframes)
   storyforge install-renderers     Install missing renderers (interactive, asks per-tool)
   storyforge install-renderers -y  Same, but auto-confirm every prompt
@@ -2636,6 +2749,14 @@ async function main() {
     await loginCommand();
     return;
   }
+  if (firstArg === "link") {
+    const opts2 = parseArgs(args.slice(1));
+    await linkCommand({
+      baseUrl: typeof opts2["base-url"] === "string" ? opts2["base-url"] : void 0,
+      noOpen: opts2.open === false
+    });
+    return;
+  }
   if (firstArg === "doctor") {
     await doctorCommand();
     return;

package/dist/stitch-5AG5JLZZ.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+import {
+  LEGACY_SECTION_TRANSITION_ROOT,
+  buildFinalEncodeContract,
+  channelPackageProvenance,
+  concatWithExtras,
+  formatSrtTime,
+  normalizeClip,
+  renderCrossfadeFallback,
+  renderSectionTransition,
+  resolutionFor,
+  resolveChannelPackage,
+  srtFromTimings,
+  stitchFinalVideo
+} from "./chunk-7KBSDIP5.js";
+import {
+  FINAL_LOUDNORM_FILTER,
+  buildFinalConcatArgs,
+  buildFinalEncodeArgs
+} from "./chunk-ZHECC3YI.js";
+import "./chunk-NSPRIPOP.js";
+export {
+  FINAL_LOUDNORM_FILTER,
+  LEGACY_SECTION_TRANSITION_ROOT,
+  buildFinalConcatArgs,
+  buildFinalEncodeArgs,
+  buildFinalEncodeContract,
+  channelPackageProvenance,
+  concatWithExtras,
+  formatSrtTime,
+  normalizeClip,
+  renderCrossfadeFallback,
+  renderSectionTransition,
+  resolutionFor,
+  resolveChannelPackage,
+  srtFromTimings,
+  stitchFinalVideo
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "storyforge",
-  "version": "0.18.0",
+  "version": "0.18.1",
   "description": "StoryForge — local bridge for the Forge video production web app. Parallel clip-render orchestrator (Remotion 4 + Manim + HyperFrames + ffmpeg) + final video stitcher + dependency doctor.",
   "type": "module",
   "bin": {
@@ -13,6 +13,7 @@
   "scripts": {
     "build": "tsup",
     "lint": "tsc --noEmit",
+    "test": "vitest run",
     "prepublishOnly": "npm run build"
   },
   "dependencies": {