sliftutils 1.7.8 → 1.7.10

package/bin/storageserver.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+"use strict";
+require("typenode");
+require("../storage/remoteStorage/storageServerCli");

package/bundler/bundleEntry.ts

@@ -32,7 +32,6 @@ async function main() {
     if (name.endsWith(".ts") || name.endsWith(".tsx")) {
         name = name.split(".").slice(0, -1).join(".");
     }
-    name += ".js";
 
     let modules = Object.values(require.cache).filter(x => x?.id !== module.id);
 
@@ -42,16 +41,21 @@ async function main() {
         entryPoints: [entryPoint],
     });
 
-    let finalPath = `${outputFolder}/${name}`;
-    let tempPath = `${finalPath}.tmp`;
-
-    try {
-        await fs.promises.writeFile(tempPath, bundled.bundle);
-        await fs.promises.rename(tempPath, finalPath);
-    } finally {
+    // Two artifacts: `name.js` without the sourcemap (the sourcemap is usually bigger than the code
+    // itself, so this is what production serves) and `name.debug.js` with the inline sourcemap
+    // appended (serve it behind something like a ?debug query param).
+    async function write(finalPath: string, contents: string) {
+        let tempPath = `${finalPath}.tmp`;
         try {
-            await fs.promises.unlink(tempPath);
-        } catch { }
+            await fs.promises.writeFile(tempPath, contents);
+            await fs.promises.rename(tempPath, finalPath);
+        } finally {
+            try {
+                await fs.promises.unlink(tempPath);
+            } catch { }
+        }
     }
+    await write(`${outputFolder}/${name}.js`, bundled.bundle);
+    await write(`${outputFolder}/${name}.debug.js`, bundled.bundle + "\n" + bundled.sourceMapComment);
 }
 main().catch(err => { console.error(err); process.exitCode = 1; }).finally(() => process.exit());

package/bundler/bundler.ts

@@ -9,7 +9,12 @@ export async function bundle(config: {
     rootPath: string;
     entryPoints: string[];
 }): Promise<{
+    // The runnable bundle, WITHOUT the sourcemap comment (the sourcemap is usually bigger than the
+    // code itself, so the default artifact ships without it).
     bundle: string;
+    // The trailing inline-sourcemap line comment. Append to `bundle` (with a newline) for the debug
+    // variant of the bundle.
+    sourceMapComment: string;
 }> {
     const { modules, rootPath, entryPoints } = config;
 
@@ -55,9 +60,9 @@ export async function bundle(config: {
         code += `\n;globalThis.require(${JSON.stringify(entryPoint)});`;
     }
     code += "\n;});";
-    code += "\n" + encodeSourceMapLineComment(finalizeInProgressSourceMap(inProgressSourceMap));
     return {
         bundle: code,
+        sourceMapComment: encodeSourceMapLineComment(finalizeInProgressSourceMap(inProgressSourceMap)),
     };
 }
 

package/{teststorage → examplestorage}/browser.tsx

@@ -9,24 +9,18 @@ import { formatNumber, formatDateTime } from "socket-function/src/formatting/for
 import { css } from "typesafecss";
 import { InputLabel } from "../render-utils/InputLabel";
 import { redButton, greenButton, errorMessage } from "../render-utils/colors";
-import { ArchivesRemote } from "../storage/remoteStorage/ArchivesRemote";
+import { createArchives } from "../storage/remoteStorage/createArchives";
 import { ArchiveFileInfo } from "../storage/IArchives";
 
-const STORAGE_ADDRESS = "storage.vidgridweb.com";
-const STORAGE_PORT = 4444;
-const ACCOUNT = "test";
-const BUCKET = "testfiles";
+// The bucket's routing URL: server, account ("example"), and bucket ("examplefiles") in one.
+// Nothing else is needed - the first call creates the bucket if it doesn't exist yet.
+const STORAGE_URL = "https://storage.vidgridweb.com:4444/file/example/examplefiles/storage/storagerouting.json";
 const ACCESS_CHECK_INTERVAL = 1000 * 15;
 
-const archives = new ArchivesRemote({
-    address: STORAGE_ADDRESS,
-    port: STORAGE_PORT,
-    account: ACCOUNT,
-    bucketName: BUCKET,
-});
+const archives = createArchives(STORAGE_URL);
 
 @observer
-class TestStoragePage extends preact.Component {
+class ExampleStoragePage extends preact.Component {
     synced = observable({
         files: [] as ArchiveFileInfo[],
         loaded: false,
@@ -34,16 +28,16 @@ class TestStoragePage extends preact.Component {
         content: "",
         contentLoaded: false,
         newFileName: "",
-        accessLink: "",
+        access: undefined as { link: string; machineId: string; ip: string } | undefined,
         error: "",
     });
 
     componentDidMount() {
         void (async () => {
             while (true) {
-                let link = await archives.waitingForAccess();
-                this.synced.accessLink = link || "";
-                if (!link) break;
+                let access = await archives.waitingForAccess();
+                this.synced.access = access;
+                if (!access) break;
                 await delay(ACCESS_CHECK_INTERVAL);
             }
             await this.refresh();
@@ -90,12 +84,14 @@ class TestStoragePage extends preact.Component {
     render() {
         let synced = this.synced;
         return <div className={css.vbox(12).pad2(16)}>
-            <div>Storage test site. Account {ACCOUNT}, bucket {BUCKET} on {STORAGE_ADDRESS}:{STORAGE_PORT}</div>
+            <div>Storage example site. Bucket {STORAGE_URL}</div>
             {synced.error && <div className={errorMessage}>{synced.error}</div>}
-            {!synced.loaded && !synced.accessLink && <div>Loading files...</div>}
-            {!synced.loaded && synced.accessLink && <div className={css.vbox(8)}>
-                <div>This machine does not have access to the account yet. Grant it here:</div>
-                <a href={synced.accessLink} target="_blank">{synced.accessLink}</a>
+            {!synced.loaded && !synced.access && <div>Loading files...</div>}
+            {!synced.loaded && synced.access && <div className={css.vbox(8)}>
+                <div>This machine does not have access to the account yet.</div>
+                <div>Machine: {synced.access.machineId}</div>
+                <div>IP: {synced.access.ip}</div>
+                <a href={synced.access.link} target="_blank">{synced.access.link}</a>
             </div>}
             {synced.loaded && <div className={css.hbox(24).alignItems("flex-start")}>
                 <div className={css.vbox(8)}>
@@ -142,7 +138,7 @@ class TestStoragePage extends preact.Component {
 
 async function main() {
     if (isNode()) return;
-    preact.render(<TestStoragePage />, document.body);
+    preact.render(<ExampleStoragePage />, document.body);
 }
 
 main().catch(console.error);

package/{teststorage/server.ts → examplestorage/exampleserver.ts}

@@ -7,10 +7,10 @@ import { hostServer } from "../misc/https/hostServer";
 // Import browser code, so it is allowed to be required by the client
 import "./browser";
 
-// Static test site for the remote storage system (storage/remoteStorage). The browser talks to
+// Static example site for the remote storage system (storage/remoteStorage). The browser talks to
 // the storage server directly, so this server only serves the page.
 
-const DOMAIN = "stest.vidgridweb.com";
+const DOMAIN = "storageexample.vidgridweb.com";
 const PORT = 4445;
 
 process.on("unhandledRejection", (error) => {
@@ -24,17 +24,17 @@ async function main() {
     RequireController.allowAllNodeModules();
     SocketFunction.expose(RequireController);
     SocketFunction.setDefaultHTTPCall(RequireController, "requireHTML", {
-        requireCalls: ["./teststorage/browser.tsx"],
+        requireCalls: ["./examplestorage/browser.tsx"],
     });
     RequireController.addStaticRoot(path.resolve("."));
 
     await hostServer({
         domain: DOMAIN,
         port: PORT,
-        cloudflareApiTokenPath: os.homedir() + "/vidgridweb.com.key",
+        cloudflareApiToken: { path: os.homedir() + "/vidgridweb.com.key" },
         setDNSRecord: true,
     });
-    console.log(`Storage test site running at https://${DOMAIN}:${PORT}`);
+    console.log(`Storage example site running at https://${DOMAIN}:${PORT}`);
 }
 
 main().catch(e => {