@gentbajko/slopify 3.14.2 → 3.15.0

package/dist/edge/http/studio.js

@@ -234,6 +234,7 @@ export function studioRoutes(deps) {
             channelPlaylists: readChannelPlaylists(deps.db),
             pairing: studioPairing(deps.db),
             autoComment: readSetting(deps.db, autoCommentKey) === "on",
+            unpacked: deps.unpackedExtension ?? null,
         });
     })
         // Post and pin each video's comment once it is public (opt-in: it posts in your name).

package/dist/main.js

@@ -1,5 +1,6 @@
 import { randomBytes, randomUUID } from "node:crypto";
 import { existsSync } from "node:fs";
+import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { serve } from "@hono/node-server";
 import ffmpegStatic from "ffmpeg-static";
@@ -78,6 +79,7 @@ import { documentsDir, nodeDocumentsHost } from "./slices/storage/documents.js";
 import { createFilesService, ensureFilesFolders, filesLayoutOf, filesMoveKey, settleFilesLocation, } from "./slices/storage/files-location.js";
 import { createPlaces, recoverPlaces } from "./slices/storage/places.js";
 import { reconcileStorage } from "./slices/storage/reconcile.js";
+import { installUnpackedExtension, unpackedExtensionDir, } from "./slices/studio/unpacked.js";
 import { previewPictures } from "./slices/style-preview/images.js";
 import { ffmpegStylePreview } from "./slices/style-preview/render.js";
 import { createStylePreviews, stylePreviewDir } from "./slices/style-preview/service.js";
@@ -496,6 +498,18 @@ export async function boot(config, options = {}) {
             void autostart.refresh().catch((error) => {
                 log.write("warn", "autostart.refresh", { detail: causedBy(error) });
             });
+        // The Chrome extension, unpacked in a folder this install keeps current; loaded from there
+        // it reloads itself after each update (`slices/studio/unpacked.ts`). A container's data
+        // folder isn't the host's, so there it stays a download.
+        const extensionDist = fileURLToPath(new URL("../dist/extension", import.meta.url));
+        let unpackedExtension;
+        if (!container)
+            try {
+                unpackedExtension = installUnpackedExtension(join(extensionDist, "slopify-studio-chrome.zip"), unpackedExtensionDir(paths.dataDir));
+            }
+            catch (error) {
+                log.write("warn", "studio.extension", { detail: causedBy(error) });
+            }
         const app = createApp({
             autostart,
             rebuild,
@@ -541,7 +555,8 @@ export async function boot(config, options = {}) {
             log,
             version,
             webDist: fileURLToPath(new URL("../dist/web", import.meta.url)),
-            extensionDist: fileURLToPath(new URL("../dist/extension", import.meta.url)),
+            extensionDist,
+            unpackedExtension,
             flushSoon: flusher.soon,
             probe: nodeCliProbe,
             hostCliStatus: hostCli?.status,

package/dist/patch-notes/3.15.0.md

@@ -0,0 +1,5 @@
+# Slopify 3.15.0
+
+Released 9 October 2026.
+
+- **The Studio extension updates itself with Slopify (Chrome, Edge, Brave).** Slopify now keeps the extension in a folder of its own and puts each new version there when it updates. Load the extension once from that folder (Settings → YouTube Studio shows it, with Copy), and from then on it switches to the new version by itself, once you haven't used it for 45 minutes, so a fill is never interrupted. No more downloading, unzipping and reloading after every update, and no waiting for the store. The store version keeps updating through the store as before. (Extension 1.3.3.)

package/dist/patch-notes/index.json

@@ -1,4 +1,10 @@
 [
+  {
+    "id": "3.15.0",
+    "title": "Slopify 3.15.0",
+    "version": "3.15.0",
+    "date": "2026-10-09"
+  },
   {
     "id": "3.14.2",
     "title": "Slopify 3.14.2",

package/dist/slices/studio/unpacked.js

@@ -0,0 +1,45 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join, normalize, sep } from "node:path";
+import { strFromU8, unzipSync } from "fflate";
+export function unpackedExtensionDir(dataDir) {
+    return join(dataDir, "extension", "chrome");
+}
+// Puts the zip's build in `target` when the version there differs. The new build is written
+// beside it and swapped in whole, so Chrome never reads half of one and half of another.
+export function installUnpackedExtension(zipPath, target) {
+    const files = unzipSync(readFileSync(zipPath));
+    const manifest = files["manifest.json"];
+    if (manifest === undefined)
+        throw new Error(`The Slopify Studio extension bundled with Slopify has no manifest.json (${zipPath}). Update or reinstall Slopify.`);
+    const version = String(JSON.parse(strFromU8(manifest)).version);
+    if (installedVersion(target) === version)
+        return { path: target, version };
+    const next = `${target}.next`;
+    const old = `${target}.old`;
+    rmSync(next, { recursive: true, force: true });
+    rmSync(old, { recursive: true, force: true });
+    for (const [name, bytes] of Object.entries(files)) {
+        if (name.endsWith("/"))
+            continue;
+        const path = normalize(name);
+        if (isAbsolute(path) || path === ".." || path.startsWith(`..${sep}`))
+            throw new Error(`The Slopify Studio extension bundled with Slopify has a file outside its folder (${name}). Update or reinstall Slopify.`);
+        mkdirSync(dirname(join(next, path)), { recursive: true });
+        writeFileSync(join(next, path), bytes, { mode: 0o644 });
+    }
+    mkdirSync(dirname(target), { recursive: true });
+    if (existsSync(target))
+        renameSync(target, old);
+    renameSync(next, target);
+    rmSync(old, { recursive: true, force: true });
+    return { path: target, version };
+}
+export function installedVersion(target) {
+    try {
+        const parsed = JSON.parse(readFileSync(join(target, "manifest.json"), "utf8"));
+        return typeof parsed.version === "string" ? parsed.version : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}