luckiest-co 1.0.13 → 1.0.14

package/skills/luckiest-design-website/scripts/doctor.mjs

@@ -0,0 +1,177 @@
+#!/usr/bin/env node
+/**
+ * Preflight. Run this BEFORE the interview, not after the first failure.
+ *
+ *   node scripts/doctor.mjs            check everything
+ *   node scripts/doctor.mjs --probe    also spend one API call to read the balance
+ *
+ * Every check that can fail deep inside a build with a misleading message is
+ * checked here with an honest one. The three that actually bite:
+ *
+ *   - a STRIPPED ffmpeg on PATH. It carries ~50 filters and silently lacks
+ *     scale, fps, psnr and the webp muxer, then fails with "No option name
+ *     near ..." or "Unable to choose an output format", both of which read as
+ *     a mistake in your command rather than a missing feature.
+ *   - no KIE_AI_API_KEY, which only matters if you are generating assets.
+ *   - playwright-core resolving from the wrong directory. It is required from
+ *     the BUILD folder, not from the skill.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import { paths } from "./workspace.mjs";
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const rows = [];
+const add = (sev, name, ok, detail, fix) => rows.push({ sev, name, ok, detail, fix });
+
+const run = (cmd, args) => {
+  try {
+    return execFileSync(cmd, args, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+  } catch {
+    return null;
+  }
+};
+
+// ---------------------------------------------------------------- node ----
+const major = Number(process.versions.node.split(".")[0]);
+add("required", "node", major >= 18, `v${process.versions.node}`,
+  "Install Node 18 or newer.");
+
+// -------------------------------------------------------------- ffmpeg ----
+function globWinGet() {
+  const home = process.env.USERPROFILE || process.env.HOME || "";
+  const base = path.join(home, "AppData/Local/Microsoft/WinGet/Packages");
+  if (!fs.existsSync(base)) return [];
+  const out = [];
+  for (const d of fs.readdirSync(base)) {
+    if (!/^Gyan\.FFmpeg/i.test(d)) continue;
+    const inner = path.join(base, d);
+    for (const e of fs.readdirSync(inner)) {
+      const p = path.join(inner, e, "bin/ffmpeg.exe");
+      if (fs.existsSync(p)) out.push(p);
+    }
+  }
+  return out;
+}
+
+const candidates = [
+  process.env.SCROLLCRAFT_FFMPEG,
+  "ffmpeg",
+  ...globWinGet(),
+  "/usr/local/bin/ffmpeg",
+  "/opt/homebrew/bin/ffmpeg",
+  "/usr/bin/ffmpeg",
+  "/snap/bin/ffmpeg",
+].filter(Boolean);
+
+let ffmpeg = null, filterCount = 0;
+for (const c of candidates) {
+  const out = run(c, ["-hide_banner", "-filters"]);
+  if (!out) continue;
+  const n = out.split("\n").length;
+  if (n > filterCount) { filterCount = n; ffmpeg = c; }
+  if (n > 200) break;
+}
+add("required", "ffmpeg (full build)", filterCount > 200,
+  ffmpeg ? `${ffmpeg}  (${filterCount} filters)` : "not found",
+  "A stripped ffmpeg lacks scale/fps/psnr and the webp muxer. Install a full build (macOS: brew install ffmpeg, Linux: apt install ffmpeg, Windows: winget install Gyan.FFmpeg) or set SCROLLCRAFT_FFMPEG to one.");
+
+if (ffmpeg && filterCount > 200) {
+  const enc = run(ffmpeg, ["-hide_banner", "-encoders"]) || "";
+  add("optional", "  └ libwebp encoder", /libwebp/.test(enc),
+    /libwebp/.test(enc) ? "present" : "missing",
+    "Posters fall back to JPEG. Not fatal, just heavier.");
+}
+
+// ---------------------------------------------------------- playwright ----
+let pw = false, pwWhere = "";
+try {
+  createRequire(path.join(process.cwd(), "package.json"))("playwright-core");
+  pw = true; pwWhere = "resolves from cwd";
+} catch {
+  try {
+    createRequire(path.join(HERE, "package.json"))("playwright-core");
+    pw = true; pwWhere = "resolves from the skill, but NOT from cwd";
+  } catch { pwWhere = "not installed"; }
+}
+add("verify", "playwright-core", pw, pwWhere,
+  "Run `npm i playwright-core` inside the build folder. Only needed for the verification pass.");
+
+const chrome = [
+  process.env.SCROLLCRAFT_CHROME,
+  // Windows
+  "C:/Program Files/Google/Chrome/Application/chrome.exe",
+  "C:/Program Files (x86)/Google/Chrome/Application/chrome.exe",
+  "C:/Program Files/Microsoft/Edge/Application/msedge.exe",
+  // macOS
+  "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+  "/Applications/Chromium.app/Contents/MacOS/Chromium",
+  "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
+  // Linux
+  "/usr/bin/google-chrome",
+  "/usr/bin/google-chrome-stable",
+  "/usr/bin/chromium",
+  "/usr/bin/chromium-browser",
+  "/snap/bin/chromium",
+].find((p) => p && fs.existsSync(p));
+add("verify", "Chrome", Boolean(chrome), chrome || "not found",
+  "Install Chrome, or set SCROLLCRAFT_CHROME to an executable.");
+
+// ------------------------------------------------------------- kie key ----
+function findKey() {
+  if (process.env.KIE_AI_API_KEY) return "env";
+  let dir = process.cwd();
+  for (let i = 0; i < 8; i++) {
+    const p = path.join(dir, ".env");
+    if (fs.existsSync(p) && /^\s*KIE_AI_API_KEY\s*=\s*\S+/m.test(fs.readFileSync(p, "utf8"))) return p;
+    const up = path.dirname(dir);
+    if (up === dir) break;
+    dir = up;
+  }
+  return null;
+}
+const keyWhere = findKey();
+add("optional", "KIE_AI_API_KEY", Boolean(keyWhere), keyWhere || "not set",
+  "Only needed to GENERATE imagery. Building from your own photos and footage needs no key and no spend. Copy .env.example to .env to set one.");
+
+// ----------------------------------------------------------- workspace ----
+let ws = null;
+try {
+  ws = paths();
+  add("required", "workspace", true, `${ws.workspace}\n      via ${ws.via}`, "");
+  add("optional", "  └ registry", fs.existsSync(ws.fingerprints),
+    fs.existsSync(ws.fingerprints) ? "present" : "not created yet",
+    "Run `node scripts/workspace.mjs --ensure` to create it.");
+} catch (e) {
+  add("required", "workspace", false, e.message, "Fix or delete the offending .scrollcraft.json.");
+}
+
+// -------------------------------------------------------------- report ----
+const mark = (r) => (r.ok ? "\u001b[32m ok \u001b[0m" : r.sev === "required" ? "\u001b[31mFAIL\u001b[0m" : "\u001b[33mwarn\u001b[0m");
+console.log("\nscrollcraft preflight\n");
+for (const r of rows) {
+  console.log(` [${mark(r)}] ${r.name.padEnd(22)} ${r.detail}`);
+  if (!r.ok && r.fix) console.log(`        ${"\u001b[2m"}${r.fix}${"\u001b[0m"}`);
+}
+
+const hardFails = rows.filter((r) => !r.ok && r.sev === "required");
+const softFails = rows.filter((r) => !r.ok && r.sev !== "required");
+console.log("");
+if (hardFails.length) {
+  console.log(`\u001b[31m${hardFails.length} required check(s) failed. Fix these before building.\u001b[0m\n`);
+  process.exit(1);
+}
+console.log(softFails.length
+  ? `\u001b[33mReady, with ${softFails.length} optional item(s) missing (see above).\u001b[0m\n`
+  : "\u001b[32mReady.\u001b[0m\n");
+
+if (process.argv.includes("--probe") && keyWhere) {
+  const { execFileSync: x } = await import("node:child_process");
+  try {
+    console.log("credit: " + x(process.execPath, [path.join(HERE, "kie.mjs"), "probe"], { encoding: "utf8" }).trim().replace(/^credit:\s*/, ""));
+  } catch (e) { console.log("balance probe failed: " + e.message); }
+}

package/skills/luckiest-design-website/scripts/encode.sh

@@ -0,0 +1,80 @@
+#!/usr/bin/env bash
+# scrollcraft: encode a clip for scrubbing, not for playback.
+#
+# A normal web encode puts a keyframe every 2-5 seconds. Scrubbing seeks to an
+# arbitrary time, and the decoder must walk from the previous keyframe to get
+# there, so a sparse-GOP file feels like mud under the wheel while playing back
+# perfectly. Dense keyframes cost file size and buy responsiveness. That trade
+# is the entire point of this script.
+#
+#   ./encode.sh in.mp4 out.mp4            desktop master  (1080p, -g 8, crf 20)
+#   ./encode.sh in.mp4 out-m.mp4 mobile   phone variant   (720p,  -g 4, crf 24)
+#
+# CRF override, for the grain-heavy worlds assets.md warns about (marine snow,
+# bioluminescence, smoke, film grain). A dense GOP doubles the cost of grain, so
+# a world like that wants 22-23 rather than the default 20:
+#
+#   ./encode.sh in.mp4 out.mp4 desktop 23        fourth positional argument
+#   SCROLLCRAFT_CRF=23 ./encode.sh in.mp4 out.mp4    or the env var
+#
+# The positional argument wins over the env var; with neither, the defaults
+# below are unchanged.
+#
+# Audio is stripped: these clips are scrubbed, never played, and a muted track
+# is dead weight plus an autoplay-policy hazard.
+set -euo pipefail
+
+# Resolve a FULL ffmpeg build. Several toolchains (Remotion, some Electron apps)
+# put a stripped ffmpeg on PATH that carries maybe 50 filters and silently lacks
+# scale/fps/tile. It fails with "No option name near ..." on any filter chain,
+# which reads like a syntax error in your command rather than a missing filter.
+# Count the filters and go looking for a real build if the count is low.
+pick_ffmpeg() {
+  local cand
+  for cand in \
+    "${SCROLLCRAFT_FFMPEG:-}" \
+    "$(command -v ffmpeg 2>/dev/null || true)" \
+    "${HOME:-/nonexistent}"/AppData/Local/Microsoft/WinGet/Packages/Gyan.FFmpeg_*/ffmpeg-*-full_build/bin/ffmpeg.exe \
+    /usr/local/bin/ffmpeg /opt/homebrew/bin/ffmpeg /usr/bin/ffmpeg /snap/bin/ffmpeg
+  do
+    [ -n "$cand" ] && [ -x "$cand" ] || continue
+    if [ "$("$cand" -hide_banner -filters 2>/dev/null | wc -l)" -gt 200 ]; then
+      echo "$cand"; return 0
+    fi
+  done
+  echo "ERROR: no full ffmpeg build found. Set SCROLLCRAFT_FFMPEG to one." >&2
+  return 1
+}
+FFMPEG="$(pick_ffmpeg)"
+FFPROBE="$(dirname "$FFMPEG")/ffprobe"
+[ -x "$FFPROBE" ] || FFPROBE="$(command -v ffprobe)"
+
+IN="${1:?usage: encode.sh <in> <out> [mobile|desktop] [crf]}"
+OUT="${2:?usage: encode.sh <in> <out> [mobile|desktop] [crf]}"
+MODE="${3:-desktop}"
+
+if [ "$MODE" = "mobile" ]; then
+  SCALE="scale=-2:720"; GOP=4; CRF=24
+else
+  SCALE="scale=-2:1080"; GOP=8; CRF=20
+fi
+
+# Positional beats env var beats the mode default.
+CRF="${4:-${SCROLLCRAFT_CRF:-$CRF}}"
+case "$CRF" in
+  ''|*[!0-9]*) echo "ERROR: crf must be an integer, got '$CRF'" >&2; exit 1 ;;
+esac
+
+mkdir -p "$(dirname "$OUT")"
+
+"$FFMPEG" -y -hide_banner -loglevel error -i "$IN" \
+  -an \
+  -vf "${SCALE}:flags=lanczos,format=yuv420p" \
+  -c:v libx264 -profile:v high -preset slow -crf "$CRF" \
+  -g "$GOP" -keyint_min "$GOP" -sc_threshold 0 \
+  -movflags +faststart \
+  "$OUT"
+
+SIZE=$(du -h "$OUT" | cut -f1)
+DUR=$("$FFPROBE" -v error -show_entries format=duration -of csv=p=0 "$OUT")
+echo "$OUT  ${SIZE}  ${DUR}s  gop=${GOP}  crf=${CRF}"

package/skills/luckiest-design-website/scripts/kie.mjs

@@ -0,0 +1,202 @@
+#!/usr/bin/env node
+/**
+ * scrollcraft asset generator: kie.ai unified jobs API.
+ *
+ *   POST https://api.kie.ai/api/v1/jobs/createTask   { model, input }
+ *   GET  https://api.kie.ai/api/v1/jobs/recordInfo?taskId=...
+ *
+ * COMMANDS
+ *   still  <prompt> <out.png> [--ar 16:9] [--ref a.png]
+ *          seedream/5-pro-text-to-image (or -image-to-image with --ref).
+ *          Photoreal by default. Stills are cheap; generate, look, reroll.
+ *
+ *   shot   <prompt> <in.png> <out.mp4> [--tail b.png] [--dur 5]
+ *          kling/v2-1-pro image-to-video. --tail pins the LAST frame, which is
+ *          the whole trick behind a seamless chain: leg N's tail is leg N+1's
+ *          head, so the cut between them is frame-identical and invisible.
+ *
+ *   probe  print account credit and exit.
+ *
+ * Env: KIE_AI_API_KEY, read from the project-root .env if not already set.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+
+const API = "https://api.kie.ai";
+const UPLOAD = "https://kieai.redpandaai.co/api/file-base64-upload";
+
+const MODELS = {
+  still:     "seedream/5-pro-text-to-image",
+  stillEdit: "seedream/5-pro-image-to-image",
+  shot:      "kling/v2-1-pro",
+};
+
+// ---------------------------------------------------------------- key ----
+function findEnv(start) {
+  let dir = path.resolve(start);
+  for (let i = 0; i < 8; i++) {
+    const p = path.join(dir, ".env");
+    if (fs.existsSync(p)) return p;
+    const up = path.dirname(dir);
+    if (up === dir) break;
+    dir = up;
+  }
+  return null;
+}
+function loadKey() {
+  if (process.env.KIE_AI_API_KEY) return process.env.KIE_AI_API_KEY;
+  const envPath = findEnv(process.cwd());
+  if (!envPath) throw new Error("KIE_AI_API_KEY not set and no .env found walking up from " + process.cwd());
+  for (const line of fs.readFileSync(envPath, "utf8").split(/\r?\n/)) {
+    const m = line.match(/^\s*KIE_AI_API_KEY\s*=\s*(.+?)\s*$/);
+    if (m) return m[1].replace(/^["']|["']$/g, "");
+  }
+  throw new Error("KIE_AI_API_KEY not found in " + envPath);
+}
+const KEY = loadKey();
+const H = { "Content-Type": "application/json", Authorization: `Bearer ${KEY}` };
+
+// ------------------------------------------------------------- helpers ----
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+async function uploadLocal(file) {
+  const abs = path.resolve(file);
+  if (!fs.existsSync(abs)) throw new Error("input not found: " + abs);
+  const ext = path.extname(abs).slice(1).toLowerCase();
+  const mime = ext === "jpg" ? "image/jpeg" : `image/${ext}`;
+  const dataUrl = `data:${mime};base64,${fs.readFileSync(abs).toString("base64")}`;
+  const res = await fetch(UPLOAD, {
+    method: "POST", headers: H,
+    body: JSON.stringify({ base64Data: dataUrl, uploadPath: "scrollcraft", fileName: path.basename(abs) }),
+  });
+  const j = await res.json();
+  const url = j?.data?.downloadUrl || j?.data?.fileUrl || j?.data?.url;
+  if (!url) throw new Error("upload failed: " + JSON.stringify(j));
+  return url;
+}
+
+// A local path becomes a hosted URL; an http(s) string passes straight through.
+const asUrl = (v) => (/^https?:\/\//i.test(v) ? Promise.resolve(v) : uploadLocal(v));
+
+async function createTask(model, input) {
+  const res = await fetch(`${API}/api/v1/jobs/createTask`, {
+    method: "POST", headers: H, body: JSON.stringify({ model, input }),
+  });
+  const j = await res.json();
+  if (j.code !== 200 || !j?.data?.taskId) throw new Error(`createTask ${model}: ${JSON.stringify(j)}`);
+  return j.data.taskId;
+}
+
+async function waitTask(taskId, { label = "job", timeoutMs = 15 * 60 * 1000 } = {}) {
+  const t0 = Date.now();
+  let delay = 4000;
+  for (;;) {
+    if (Date.now() - t0 > timeoutMs) throw new Error(`${label}: timed out after ${Math.round((Date.now() - t0) / 1000)}s`);
+    const res = await fetch(`${API}/api/v1/jobs/recordInfo?taskId=${encodeURIComponent(taskId)}`, { headers: H });
+    const j = await res.json();
+    const d = j?.data || {};
+    const state = d.state || d.status;
+    if (state === "success") {
+      let out = d.resultJson;
+      if (typeof out === "string") { try { out = JSON.parse(out); } catch {} }
+      const urls = out?.resultUrls || out?.result_urls || out?.urls || [];
+      if (!urls.length) throw new Error(`${label}: success with no result url: ${JSON.stringify(d)}`);
+      return urls;
+    }
+    if (state === "fail" || state === "failed") {
+      throw new Error(`${label} failed: ${d.failMsg || d.failCode || JSON.stringify(d)}`);
+    }
+    process.stderr.write(`  ${label}: ${state || "queued"} (${Math.round((Date.now() - t0) / 1000)}s)\n`);
+    await sleep(delay);
+    delay = Math.min(delay * 1.25, 15000);
+  }
+}
+
+async function download(url, out) {
+  fs.mkdirSync(path.dirname(path.resolve(out)), { recursive: true });
+  const res = await fetch(url);
+  if (!res.ok) throw new Error(`download ${res.status} ${url}`);
+  fs.writeFileSync(path.resolve(out), Buffer.from(await res.arrayBuffer()));
+  return out;
+}
+
+function flag(argv, name, dflt = null) {
+  const i = argv.indexOf(name);
+  return i > -1 && argv[i + 1] ? argv[i + 1] : dflt;
+}
+function flags(argv, name) {
+  const out = [];
+  argv.forEach((a, i) => { if (a === name && argv[i + 1]) out.push(argv[i + 1]); });
+  return out;
+}
+
+// ---------------------------------------------------------------- main ----
+const [cmd, ...rest] = process.argv.slice(2);
+
+try {
+  if (cmd === "probe") {
+    const r = await fetch(`${API}/api/v1/chat/credit`, { headers: H });
+    const j = await r.json();
+    console.log("credit:", j.data);
+
+  } else if (cmd === "still") {
+    const [prompt, out] = rest;
+    if (!prompt || !out) throw new Error('usage: kie.mjs still "<prompt>" <out.png> [--ar 16:9] [--ref a.png]');
+    const ar = flag(rest, "--ar", "16:9");
+    const refs = flags(rest, "--ref");
+    let model = MODELS.still;
+    // aspect_ratio, quality and output_format are all required by seedream;
+    // omitting any one returns a bare "This field is required" that does not
+    // name the field, so keep them explicit rather than relying on defaults.
+    const input = {
+      prompt,
+      aspect_ratio: ar,
+      quality: flag(rest, "--quality", "high"),
+      output_format: "png",
+      nsfw_checker: false,
+    };
+    if (refs.length) {
+      model = MODELS.stillEdit;
+      input.image_urls = await Promise.all(refs.map(asUrl));
+    }
+    const id = await createTask(model, input);
+    const urls = await waitTask(id, { label: path.basename(out) });
+    await download(urls[0], out);
+    console.log(out);
+
+  } else if (cmd === "shot") {
+    const [prompt, head, out] = rest;
+    if (!prompt || !head || !out) {
+      throw new Error('usage: kie.mjs shot "<prompt>" <head.png> <out.mp4> [--tail b.png] [--dur 5]');
+    }
+    const dur = flag(rest, "--dur", "5");
+    const tail = flag(rest, "--tail");
+    const input = {
+      prompt,
+      image_url: await asUrl(head),
+      duration: String(dur),
+      // Camera-move clips are graded on smoothness, so the negative prompt
+      // targets exactly what breaks a scrub: judder, warping, cuts.
+      negative_prompt: "blur, distortion, low quality, warping, morphing, jitter, flicker, text, watermark, cut, scene change",
+      cfg_scale: 0.5,
+    };
+    if (tail) input.tail_image_url = await asUrl(tail);
+    const id = await createTask(MODELS.shot, input);
+    const urls = await waitTask(id, { label: path.basename(out), timeoutMs: 20 * 60 * 1000 });
+    await download(urls[0], out);
+    console.log(out);
+
+  } else {
+    console.error(`scrollcraft asset generator
+
+  node kie.mjs probe
+  node kie.mjs still "<prompt>" <out.png> [--ar 16:9] [--ref ref.png]
+  node kie.mjs shot  "<prompt>" <head.png> <out.mp4> [--tail tail.png] [--dur 5]
+`);
+    process.exit(1);
+  }
+} catch (err) {
+  console.error("ERROR:", err.message);
+  process.exit(1);
+}

package/skills/luckiest-design-website/scripts/serve.mjs

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+/**
+ * scrollcraft static server.
+ *
+ * A scrollcraft page cannot be verified from file://. The engine fetches each
+ * clip as a Blob, and file:// fetches are blocked by CORS in every browser, so
+ * the page silently falls back to posters and looks fine while proving nothing.
+ * Serve it.
+ *
+ *   node serve.mjs --root builds/perkform --port 4500
+ */
+import http from "node:http";
+import fs from "node:fs";
+import path from "node:path";
+
+const argv = process.argv.slice(2);
+const arg = (n, d) => { const i = argv.indexOf(n); return i > -1 && argv[i + 1] ? argv[i + 1] : d; };
+
+const ROOT = path.resolve(arg("--root", "."));
+const PORT = parseInt(arg("--port", "4500"), 10);
+
+const TYPES = {
+  ".html": "text/html; charset=utf-8", ".css": "text/css; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8", ".json": "application/json",
+  ".mp4": "video/mp4", ".webm": "video/webm",
+  ".webp": "image/webp", ".png": "image/png", ".jpg": "image/jpeg",
+  ".svg": "image/svg+xml", ".woff2": "font/woff2",
+};
+
+http.createServer((req, res) => {
+  const url = decodeURIComponent(req.url.split("?")[0]);
+  let file = path.join(ROOT, url === "/" ? "/index.html" : url);
+
+  // Refuse to serve outside the root even if the path walks up.
+  if (!file.startsWith(ROOT)) { res.writeHead(403).end("forbidden"); return; }
+  if (fs.existsSync(file) && fs.statSync(file).isDirectory()) file = path.join(file, "index.html");
+  if (!fs.existsSync(file)) { res.writeHead(404).end("not found"); return; }
+
+  const ext = path.extname(file).toLowerCase();
+  const stat = fs.statSync(file);
+  res.writeHead(200, {
+    "Content-Type": TYPES[ext] || "application/octet-stream",
+    "Content-Length": stat.size,
+    // No caching: verification loops re-shoot the same URLs after edits, and a
+    // cached clip or stylesheet makes you screenshot the previous build.
+    "Cache-Control": "no-store",
+    "Accept-Ranges": "bytes",
+  });
+  fs.createReadStream(file).pipe(res);
+}).listen(PORT, () => {
+  console.log(`scrollcraft: ${ROOT}\n  http://localhost:${PORT}`);
+});