cozyclay 3.1.3 → 3.1.5

package/bin/update-check.mjs

@@ -52,20 +52,32 @@ export function compareVersions(a, b) {
 	return 0;
 }
 
+// A registry answer whose cache write failed (a read-only home), by cache file.
+// The write is best effort, so a good fetch must not depend on it.
+const fetchedInProcess = new Map();
+
+// The newer of the cache file and this process's own last fetch.
 function readCache(cacheFile) {
+	let disk = null;
 	try {
-		return JSON.parse(readFileSync(cacheFile, "utf8"));
+		disk = JSON.parse(readFileSync(cacheFile, "utf8"));
 	} catch {
-		return null;
+		/* missing or unreadable: the in-process answer, if any, stands */
 	}
+	const memory = fetchedInProcess.get(cacheFile) ?? null;
+	if (!disk) return memory;
+	return memory && !(memory.checkedAt <= disk.checkedAt) ? memory : disk;
 }
 
 function writeCache(cacheFile, cacheDir, latest) {
+	const entry = { latest, checkedAt: Date.now() };
 	try {
 		mkdirSync(cacheDir, { recursive: true });
-		writeFileSync(cacheFile, JSON.stringify({ latest, checkedAt: Date.now() }, null, "\t"));
+		writeFileSync(cacheFile, JSON.stringify(entry, null, "\t"));
+		fetchedInProcess.delete(cacheFile);
 	} catch {
-		/* a read-only home is not a reason to fail a local dev server */
+		// A read-only home is not a reason to fail a local dev server, nor to forget the answer.
+		fetchedInProcess.set(cacheFile, entry);
 	}
 }
 
@@ -134,11 +146,47 @@ export function readUpdateStatus(currentVersion, stateDir) {
 	}
 }
 
+// `--no-update-check`, COZYCLAY_NO_UPDATE_CHECK and CI each turn the notice,
+// the Studio chip and the one-click install off.
+export function updateChecksOn(flag, env = process.env) {
+	return Boolean(flag && !env.CI && !env.COZYCLAY_NO_UPDATE_CHECK);
+}
+
+/**
+ * The registry's latest x.y.z with this launch's status: the shape behind
+ * GET /__cozyclay/update and `cclay update --check`. The cache rules are
+ * checkForUpdate's; `fresh` asks the registry even inside the TTL, and a dead
+ * registry still falls back to the cached answer.
+ */
+export async function lookupLatest(currentVersion, stateDir, { fresh = false } = {}) {
+	const cacheFile = join(stateDir, "update-check.json");
+	if (fresh) {
+		const fetched = await fetchLatest();
+		if (fetched) writeCache(cacheFile, stateDir, fetched);
+	} else {
+		await checkForUpdate(currentVersion, stateDir);
+	}
+	const latest = readCache(cacheFile)?.latest;
+	const known = typeof latest === "string" && /^\d+\.\d+\.\d+/.test(latest);
+	return { latest: known ? latest : null, status: readUpdateStatus(currentVersion, stateDir) };
+}
+
+/**
+ * `cclay update --check`: print, install nothing, and exit 0 when this is the
+ * newest release, 10 when a newer one exists, 11 when the registry could not
+ * answer and nothing is cached. Scripts and agents branch on the code.
+ */
+export async function runUpdateCheck({ currentVersion, kind, stateDir }) {
+	const { latest, status } = await lookupLatest(currentVersion, stateDir, { fresh: true });
+	console.log(`current: ${currentVersion}\nlatest: ${latest ?? "unknown"}\nkind: ${kind}\nstatus: ${status}`);
+	return { latest: 0, outdated: 10 }[status] ?? 11;
+}
+
 // npx/bunx runs from a temp dir, so there is no local install to upgrade in
 // place; `npm install -g` is the one command that is right either way.
 export function runUpdate() {
 	const npm = process.platform === "win32" ? "npm.cmd" : "npm";
-	const child = spawn(npm, ["install", "-g", "cozyclay@latest"], { stdio: "inherit", shell: process.platform === "win32" });
+	const child = spawn(npm, ["install", "-g", "cozyclay@latest", "--engine-strict"], { stdio: "inherit", shell: process.platform === "win32" });
 	child.on("error", (err) => {
 		console.error(`cozyclay: could not run npm: ${err.message}`);
 		process.exit(1);

package/bin/update-install.mjs

@@ -0,0 +1,136 @@
+/**
+ * The one-click global update behind POST /__cozyclay/update.
+ *
+ * Two questions live here: may this launcher update itself at all
+ * (canSelfUpdate), and what happened when it tried (an in-memory install
+ * state the Studio polls). Nothing a request carries ever reaches npm: the
+ * only argument that varies is a version that has passed an exact x.y.z test.
+ */
+import { execFile, spawn } from "node:child_process";
+import { constants, accessSync, realpathSync } from "node:fs";
+import { join } from "node:path";
+
+const VERSION = /^\d+\.\d+\.\d+$/;
+const ROOT_TIMEOUT_MS = 2000;
+const INSTALL_TIMEOUT_MS = 5 * 60 * 1000;
+const STDERR_CAP = 64 * 1024;
+
+const ERROR_CODES = [
+	["node_version", ["EBADENGINE"]],
+	["permission", ["EACCES", "EPERM"]],
+	["network", ["ENOTFOUND", "ETIMEDOUT", "ECONNREFUSED", "ECONNRESET", "EAI_AGAIN"]],
+];
+
+// COZYCLAY_NPM_BIN lets a test put a fake npm in front of both calls; win32
+// keeps npm.cmd the way runUpdate spawns it.
+function npmBinary(platform = process.platform) {
+	return process.env.COZYCLAY_NPM_BIN || (platform === "win32" ? "npm.cmd" : "npm");
+}
+
+function npmRootGlobal(npmBin, platform) {
+	return new Promise((resolve) => {
+		execFile(npmBin, ["root", "-g"], { timeout: ROOT_TIMEOUT_MS, shell: platform === "win32", encoding: "utf8" }, (error, stdout) => {
+			resolve(error ? null : String(stdout).trim() || null);
+		});
+	});
+}
+
+const selfUpdateCache = new Map();
+
+/**
+ * True only when all three hold: not Windows (U1 scope), this package's real
+ * path is `<npm root -g>/cozyclay`, and that folder and its parent are
+ * writable. Any doubt answers false, which falls back to a copied command.
+ * Computed once per (pkgRoot, platform, npm) and kept in memory.
+ */
+export function canSelfUpdate({ pkgRoot, platform = process.platform, npmBin = npmBinary(platform) }) {
+	const key = JSON.stringify([pkgRoot, platform, npmBin]);
+	if (!selfUpdateCache.has(key)) selfUpdateCache.set(key, computeSelfUpdate(pkgRoot, platform, npmBin));
+	return selfUpdateCache.get(key);
+}
+
+async function computeSelfUpdate(pkgRoot, platform, npmBin) {
+	if (platform === "win32") return false;
+	const root = await npmRootGlobal(npmBin, platform);
+	if (!root) return false;
+	try {
+		const installed = realpathSync(join(root, "cozyclay"));
+		if (realpathSync(pkgRoot) !== installed) return false;
+		// npm swaps the folder, so the parent has to take writes as well.
+		accessSync(installed, constants.W_OK);
+		accessSync(realpathSync(root), constants.W_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+function classOf(code) {
+	return ERROR_CODES.find(([, codes]) => codes.includes(code))?.[0] ?? null;
+}
+
+/**
+ * permission | network | node_version | npm_missing | other, from npm's
+ * stderr and the spawn error (if any). The `npm error code X` line wins;
+ * otherwise the first known code anywhere in the text decides.
+ */
+export function classifyNpmError(stderr = "", spawnError = null) {
+	if (spawnError?.code === "ENOENT") return "npm_missing";
+	const text = String(stderr ?? "");
+	const lineCode = /npm (?:error|ERR!) code (\S+)/.exec(text)?.[1];
+	if (lineCode && classOf(lineCode)) return classOf(lineCode);
+	if (/Not compatible with your version of node/i.test(text)) return "node_version";
+	for (const token of text.match(/\bE[A-Z_]{2,}\b/g) ?? []) {
+		if (classOf(token)) return classOf(token);
+	}
+	return classOf(spawnError?.code) ?? "other";
+}
+
+/**
+ * The launcher's install state: { phase, errorClass, startedAt, durationMs }.
+ * startInstall is the lock: while a run is updating or has finished and waits
+ * for a restart, it starts nothing and returns false.
+ */
+export function createInstaller({ timeoutMs = INSTALL_TIMEOUT_MS } = {}) {
+	const state = { phase: "idle", errorClass: null, startedAt: null, durationMs: null };
+	let timer = null;
+	function finish(phase, errorClass) {
+		if (state.phase !== "updating") return;
+		clearTimeout(timer);
+		Object.assign(state, { phase, errorClass, durationMs: Date.now() - state.startedAt });
+	}
+	function startInstall(version) {
+		if (!VERSION.test(String(version))) throw new TypeError("cozyclay: refusing to install a version that is not x.y.z");
+		if (state.phase === "updating" || state.phase === "restart_needed") return false;
+		Object.assign(state, { phase: "updating", errorClass: null, startedAt: Date.now(), durationMs: null });
+		const platform = process.platform;
+		let child;
+		try {
+			child = spawn(npmBinary(platform), ["install", "-g", `cozyclay@${version}`, "--engine-strict"], {
+				stdio: ["ignore", "pipe", "pipe"],
+				shell: platform === "win32",
+			});
+		} catch (error) {
+			finish("failed", classifyNpmError("", error));
+			return true;
+		}
+		let stderr = "";
+		child.stdout.resume();
+		child.stderr.setEncoding("utf8");
+		child.stderr.on("data", (chunk) => {
+			if (stderr.length < STDERR_CAP) stderr += chunk.slice(0, STDERR_CAP - stderr.length);
+		});
+		timer = setTimeout(() => {
+			child.kill("SIGTERM");
+			finish("failed", "other");
+		}, timeoutMs);
+		timer.unref?.();
+		child.on("error", (error) => finish("failed", classifyNpmError(stderr, error)));
+		child.on("close", (code, signal) => {
+			if (code === 0 && !signal) finish("restart_needed", null);
+			else finish("failed", classifyNpmError(stderr));
+		});
+		return true;
+	}
+	return { startInstall, getState: () => ({ ...state }) };
+}

package/bin/update-routes.mjs

@@ -0,0 +1,80 @@
+/**
+ * GET and POST /__cozyclay/update: what the Studio's update chip reads, and
+ * the one click that installs. Every input is injected so the route runs
+ * under a test with a mock registry and a fake npm.
+ *
+ * POST reads no body. The version it installs is the registry's latest after
+ * an exact x.y.z test, never anything the request says.
+ */
+const VERSION = /^\d+\.\d+\.\d+$/;
+const NOTES_URL = "https://github.com/NomaDamas/CozyClay/releases/tag/v";
+
+function sendJson(res, status, body, headers = {}) {
+	res.writeHead(status, { "content-type": "application/json; charset=utf-8", "cache-control": "no-store", ...headers });
+	res.end(JSON.stringify(body));
+}
+
+/**
+ * @param {object} options
+ * @param {string} options.currentVersion the running package version
+ * @param {() => Promise<{latest: string|null, status: string}>} options.checkLatest
+ * @param {"global"|"npx"|"clone"} options.kind
+ * @param {boolean} options.enabled false when update checks are off
+ * @param {number} options.port the launcher's loopback port
+ * @param {() => Promise<boolean>} options.canSelfUpdate
+ * @param {{startInstall(version: string): boolean, getState(): object}} options.installer
+ */
+export function createUpdateRoutes({ currentVersion, checkLatest, kind, enabled, port, canSelfUpdate, installer }) {
+	const command = kind === "npx" ? "npx cozyclay" : "npm install -g cozyclay@latest";
+	const hosts = new Set([`127.0.0.1:${port}`, `localhost:${port}`]);
+	// Spelled in two parts so the G014 loopback invariant does not read it as a client URL.
+	const origins = new Set([`http://127.0.0.1:${port}`, `http://${"local" + "host"}:${port}`]);
+
+	async function info() {
+		const base = { enabled, current: currentVersion, latest: null, status: "unknown", kind, canSelfUpdate: false, phase: "idle", errorClass: null, durationMs: null, notesUrl: null, command };
+		if (!enabled) return base;
+		const [{ latest, status }, selfUpdate] = await Promise.all([
+			checkLatest().catch(() => ({ latest: null, status: "unknown" })),
+			kind === "global" ? canSelfUpdate().catch(() => false) : false,
+		]);
+		const { phase, errorClass, durationMs } = installer.getState();
+		const finished = phase === "restart_needed" || phase === "failed";
+		return {
+			...base,
+			latest: latest ?? null,
+			status: latest ? status : "unknown",
+			canSelfUpdate: selfUpdate === true,
+			phase,
+			errorClass: phase === "failed" ? errorClass : null,
+			durationMs: finished ? durationMs : null,
+			notesUrl: latest ? `${NOTES_URL}${latest}` : null,
+		};
+	}
+
+	async function handlePost(req, res) {
+		if (req.headers.origin !== `http://127.0.0.1:${port}`) return sendJson(res, 403, { error: "forbidden origin" });
+		if (!enabled) return sendJson(res, 403, { error: "update checks are disabled" });
+		const { phase } = installer.getState();
+		if (phase === "updating" || phase === "restart_needed") return sendJson(res, 202, await info());
+		const current = await info();
+		if (!(kind === "global" && current.canSelfUpdate && current.status === "outdated" && VERSION.test(current.latest ?? ""))) {
+			return sendJson(res, 409, { error: "self-update unavailable" });
+		}
+		installer.startInstall(current.latest);
+		return sendJson(res, 202, await info());
+	}
+
+	return async function handleUpdateRoute(req, res) {
+		try {
+			if (req.method === "GET") {
+				const origin = req.headers.origin;
+				if (!(origins.has(origin) || (origin === undefined && hosts.has(req.headers.host)))) return sendJson(res, 403, { error: "forbidden origin" });
+				return sendJson(res, 200, await info());
+			}
+			if (req.method === "POST") return await handlePost(req, res);
+			return sendJson(res, 405, { error: "method not allowed" }, { allow: "GET, POST" });
+		} catch {
+			if (!res.headersSent) sendJson(res, 500, { error: "update unavailable" });
+		}
+	};
+}

package/dist/ai-camera-control/index.html

@@ -168,7 +168,7 @@
       <div class="wrap">
         <a class="brand" href="/">CozyClay</a>
         <nav>
-          <a href="/#try">Try it</a>
+          <a href="/app/">Try it</a>
           <a href="/greybox-to-video/">Greybox to video</a>
           <a href="/previs-software/">Previs software</a>
           <a href="/seedance-camera-control/">Seedance</a>

package/dist/app/index.html

@@ -34,15 +34,14 @@
     <title>CozyClay Studio — 3D staging and previs in your browser</title>
 
     <script defer src="https://static.cloudflareinsights.com/beacon.min.js" data-cf-beacon='{"token": "6a4384d1375d4ffc8a30a6346a8ad1a0"}'></script>
-    <script type="module" crossorigin src="/assets/app-DwETmoQZ.js"></script>
+    <script type="module" crossorigin src="/assets/app-CTKcyPM-.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/rolldown-runtime-hePW80VL.js">
-    <link rel="modulepreload" crossorigin href="/assets/modulepreload-polyfill-P2Xu9kJm.js">
-    <link rel="modulepreload" crossorigin href="/assets/task-board-DFfNa0xg.js">
+    <link rel="modulepreload" crossorigin href="/assets/task-board-CkLZGPkv.js">
     <link rel="modulepreload" crossorigin href="/assets/fflate.module-KbGj5-H6.js">
-    <link rel="modulepreload" crossorigin href="/assets/scene-asset-sync-Bz59Ghdz.js">
-    <link rel="modulepreload" crossorigin href="/assets/motion3-compile-DDG3wklD.js">
+    <link rel="modulepreload" crossorigin href="/assets/scene-asset-sync-t45pWCyq.js">
+    <link rel="modulepreload" crossorigin href="/assets/motion3-compile-Du7UXrWn.js">
     <link rel="stylesheet" crossorigin href="/assets/scene-asset-sync-BEjjhNEo.css">
-    <link rel="stylesheet" crossorigin href="/assets/app-BdRlMf4J.css">
+    <link rel="stylesheet" crossorigin href="/assets/app-CEP7jzXB.css">
   </head>
   <body>
     <div id="root">

package/dist/assets/{TaskBoard-U1Yl-4F1.js → TaskBoard-DwXhsJXz.js}

@@ -1 +1 @@
-import{r as e}from"./rolldown-runtime-hePW80VL.js";import{Ti as t,c as n,d as r,f as i,fa as a,l as o,m as s,o as c,v as l}from"./task-board-DFfNa0xg.js";import{o as u,r as d,t as f}from"./motion3-compile-DDG3wklD.js";var p=e(a(),1),m=2e3,h=(e,t)=>new Promise(n=>{let r=setTimeout(n,e);t.addEventListener(`abort`,()=>{clearTimeout(r),n()},{once:!0})});function g(e,n){(0,p.useEffect)(()=>{let r=new Map;for(let[t,i]of Object.entries(e))for(let e of i)r.set(e,n[t]??t);let i=()=>{for(let e of document.querySelectorAll(`[data-node-id]`)){let n=r.get(e.getAttribute(`data-node-id`));n?(e.setAttribute(`data-task-scope`,n),e.setAttribute(`title`,t(`In task: ${n}`,`작업 중: ${n}`,`任务中：${n}`))):e.hasAttribute(`data-task-scope`)&&(e.removeAttribute(`data-task-scope`),e.removeAttribute(`title`))}};i();let a=new MutationObserver(i);return a.observe(document.body,{childList:!0,subtree:!0}),()=>{a.disconnect(),r.clear(),i()}},[e,n])}function _({sessionId:e,pulse:t,labelOf:a,onMainNote:_}){let v=(0,p.useMemo)(()=>c(),[]),y=u(),[b,x]=(0,p.useReducer)((e,t)=>t.seed?s(e,t.seed):t.reset?n():r(e,t.event),void 0,n),[S,C]=(0,p.useState)({}),[w,T]=(0,p.useState)(f),E=(0,p.useRef)(0),D=(0,p.useRef)(_);(0,p.useEffect)(()=>{E.current=b.after,D.current=_},[b.after,_]),(0,p.useEffect)(()=>{x({reset:!0}),E.current=0},[e]),(0,p.useEffect)(()=>d(T),[]),(0,p.useEffect)(()=>y.subscribe(e=>{typeof e?.type!=`string`||!e.type.startsWith(`task.`)||(C(t=>i(t,e)),(e.type===`task.userEdit`||e.type===`task.undone`)&&x({event:e}))}),[y]),(0,p.useEffect)(()=>{if(!e)return;let t=new AbortController;return(async()=>{for(;!t.signal.aborted;){try{let{tasks:n}=await v.board(e);x({seed:n}),await v.events(e,E.current,e=>{if(e.type===`main.turn`&&e.turnId){let n=``;v.frames(e.turnId,e=>{e.type===`text.delta`&&(n+=e.text??``),e.type===`tool.start`&&(n=``)},t.signal).then(()=>D.current?.(n),()=>{})}x({event:e})},t.signal)}catch{}await h(m,t.signal)}})(),()=>t.abort()},[v,e,t]);let O=b.order.filter(e=>b.tasks[e]?.status===`running`&&b.tasks[e]?.turnId),k=O.map(e=>`${e}:${b.tasks[e].turnId}`).join();return(0,p.useEffect)(()=>{let e=O.map(e=>{let t=new AbortController,{turnId:n}=b.tasks[e];return v.frames(n,t=>{let n=o(t,a);n&&x({event:{type:`task.progress`,taskId:e,status:`running`,progress:n}})},t.signal).catch(()=>{}),t});return()=>e.forEach(e=>e.abort())},[v,k,a]),g(S,(0,p.useMemo)(()=>Object.fromEntries(b.order.map(e=>[e,b.tasks[e].title])),[b])),(0,p.useEffect)(()=>{l.set({client:v,labelOf:a,undo:async e=>{let t=await y.run(`task.undo`,{taskId:e});if(t?.ok===!1)throw Error(t.message??t.code);x({event:{type:`task.undone`,taskId:e}})}})},[y,v,a]),(0,p.useEffect)(()=>{l.set({board:b,activity:w})},[b,w]),(0,p.useEffect)(()=>()=>l.set({board:n(),open:null}),[e]),null}export{_ as default};
+import{r as e}from"./rolldown-runtime-hePW80VL.js";import{Fa as t,Ji as n,c as r,d as i,f as a,l as o,m as s,o as c,v as l}from"./task-board-CkLZGPkv.js";import{o as u,r as d,t as f}from"./motion3-compile-Du7UXrWn.js";var p=e(t(),1),m=2e3,h=(e,t)=>new Promise(n=>{let r=setTimeout(n,e);t.addEventListener(`abort`,()=>{clearTimeout(r),n()},{once:!0})});function g(e,t){(0,p.useEffect)(()=>{let r=new Map;for(let[n,i]of Object.entries(e))for(let e of i)r.set(e,t[n]??n);let i=()=>{for(let e of document.querySelectorAll(`[data-node-id]`)){let t=r.get(e.getAttribute(`data-node-id`));t?(e.setAttribute(`data-task-scope`,t),e.setAttribute(`title`,n(`In task: ${t}`,`작업 중: ${t}`,`任务中：${t}`))):e.hasAttribute(`data-task-scope`)&&(e.removeAttribute(`data-task-scope`),e.removeAttribute(`title`))}};i();let a=new MutationObserver(i);return a.observe(document.body,{childList:!0,subtree:!0}),()=>{a.disconnect(),r.clear(),i()}},[e,t])}function _({sessionId:e,pulse:t,labelOf:n,onMainNote:_}){let v=(0,p.useMemo)(()=>c(),[]),y=u(),[b,x]=(0,p.useReducer)((e,t)=>t.seed?s(e,t.seed):t.reset?r():i(e,t.event),void 0,r),[S,C]=(0,p.useState)({}),[w,T]=(0,p.useState)(f),E=(0,p.useRef)(0),D=(0,p.useRef)(_);(0,p.useEffect)(()=>{E.current=b.after,D.current=_},[b.after,_]),(0,p.useEffect)(()=>{x({reset:!0}),E.current=0},[e]),(0,p.useEffect)(()=>d(T),[]),(0,p.useEffect)(()=>y.subscribe(e=>{typeof e?.type!=`string`||!e.type.startsWith(`task.`)||(C(t=>a(t,e)),(e.type===`task.userEdit`||e.type===`task.undone`)&&x({event:e}))}),[y]),(0,p.useEffect)(()=>{if(!e)return;let t=new AbortController;return(async()=>{for(;!t.signal.aborted;){try{let{tasks:n}=await v.board(e);x({seed:n}),await v.events(e,E.current,e=>{if(e.type===`main.turn`&&e.turnId){let n=``;v.frames(e.turnId,e=>{e.type===`text.delta`&&(n+=e.text??``),e.type===`tool.start`&&(n=``)},t.signal).then(()=>D.current?.(n),()=>{})}x({event:e})},t.signal)}catch{}await h(m,t.signal)}})(),()=>t.abort()},[v,e,t]);let O=b.order.filter(e=>b.tasks[e]?.status===`running`&&b.tasks[e]?.turnId),k=O.map(e=>`${e}:${b.tasks[e].turnId}`).join();return(0,p.useEffect)(()=>{let e=O.map(e=>{let t=new AbortController,{turnId:r}=b.tasks[e];return v.frames(r,t=>{let r=o(t,n);r&&x({event:{type:`task.progress`,taskId:e,status:`running`,progress:r}})},t.signal).catch(()=>{}),t});return()=>e.forEach(e=>e.abort())},[v,k,n]),g(S,(0,p.useMemo)(()=>Object.fromEntries(b.order.map(e=>[e,b.tasks[e].title])),[b])),(0,p.useEffect)(()=>{l.set({client:v,labelOf:n,undo:async e=>{let t=await y.run(`task.undo`,{taskId:e});if(t?.ok===!1)throw Error(t.message??t.code);x({event:{type:`task.undone`,taskId:e}})}})},[y,v,n]),(0,p.useEffect)(()=>{l.set({board:b,activity:w})},[b,w]),(0,p.useEffect)(()=>()=>l.set({board:r(),open:null}),[e]),null}export{_ as default};