@someonegg/codex-hub 0.1.9 → 0.2.1

package/dist/server/server/hosting/routes.js

@@ -0,0 +1,152 @@
+import { createReadStream } from "node:fs";
+import { realpath, stat } from "node:fs/promises";
+import { extname, join, resolve, sep } from "node:path";
+import { sendJson } from "../http/router.js";
+import { DiffStore } from "./diff-store.js";
+import { HostingStore } from "./store.js";
+const types = {
+    ".html": "text/html; charset=utf-8",
+    ".css": "text/css; charset=utf-8",
+    ".js": "text/javascript; charset=utf-8",
+    ".mjs": "text/javascript; charset=utf-8",
+    ".json": "application/json",
+    ".svg": "image/svg+xml",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".avif": "image/avif",
+    ".ico": "image/x-icon",
+    ".woff": "font/woff",
+    ".woff2": "font/woff2",
+    ".ttf": "font/ttf",
+    ".otf": "font/otf",
+    ".wasm": "application/wasm",
+    ".xml": "application/xml",
+    ".pdf": "application/pdf",
+    ".webmanifest": "application/manifest+json",
+    ".wav": "audio/wav",
+    ".txt": "text/plain; charset=utf-8",
+    ".mp4": "video/mp4",
+    ".webm": "video/webm",
+    ".mp3": "audio/mpeg",
+};
+export function hostingRoutes(directory) {
+    const store = directory === undefined ? undefined : new HostingStore(directory);
+    const diffs = directory === undefined ? undefined : new DiffStore(directory);
+    return async (request, response) => {
+        const url = new URL(request.url ?? "/", "http://localhost");
+        const path = url.pathname;
+        const head = request.method === "HEAD";
+        if (path === "/api/v1/capabilities" && request.method === "GET") {
+            sendJson(response, 200, { hosting: !!store });
+            return true;
+        }
+        if (path.startsWith("/api/v1/diffs")) {
+            response.setHeader("Cache-Control", "private, no-store");
+            const match = /^\/api\/v1\/diffs\/([^/]+)$/.exec(path);
+            const entry = diffs && match && request.method === "GET" ? await diffs.get(match[1]) : null;
+            if (entry) {
+                sendJson(response, 200, entry);
+            }
+            else if (diffs && match && request.method === "DELETE" && (await diffs.exists(match[1]))) {
+                await diffs.delete(match[1]);
+                response.statusCode = 204;
+                response.end();
+            }
+            else {
+                sendJson(response, 404, {
+                    error: { code: "not_found", message: "Diff not found or already cleaned up" },
+                });
+            }
+            return true;
+        }
+        if (!path.startsWith("/web/") && !path.startsWith("/api/v1/artifacts"))
+            return false;
+        const missing = () => sendJson(response, 404, { error: { code: "not_found", message: "Artifact not found" } }, head);
+        if (!store) {
+            missing();
+            return true;
+        }
+        if (path === "/api/v1/artifacts" && request.method === "GET") {
+            const groups = new Map();
+            for (const { artifact } of await store.entries()) {
+                const list = groups.get(artifact.project) ?? [];
+                list.push(artifact);
+                groups.set(artifact.project, list);
+            }
+            sendJson(response, 200, {
+                projects: [...groups].map(([directory, artifacts]) => ({ directory, artifacts })),
+            });
+            return true;
+        }
+        const deletion = /^\/api\/v1\/artifacts\/([a-f0-9]{32})$/.exec(path);
+        if (deletion && request.method === "DELETE") {
+            if (await store.delete(deletion[1])) {
+                response.statusCode = 204;
+                response.end();
+            }
+            else
+                missing();
+            return true;
+        }
+        const match = /^\/web\/([a-f0-9]{32})\/(?:([a-f0-9]{32})\/(.*))?$/.exec(path);
+        if (!match || (request.method !== "GET" && !head)) {
+            missing();
+            return true;
+        }
+        response.removeHeader("Content-Security-Policy");
+        response.setHeader("Cache-Control", "private, no-store");
+        const entry = await store.get(match[1]);
+        if (!entry) {
+            missing();
+            return true;
+        }
+        if (!match[2]) {
+            response.statusCode = 302;
+            response.setHeader("Location", `/web/${entry.artifact.id}/${entry.artifact.snapshotId}/${url.search}`);
+            response.end();
+            return true;
+        }
+        try {
+            const relative = decodeURIComponent(match[3]);
+            if (relative.split(/[\\/]/).some((part) => part === "..") || relative.includes("\0"))
+                throw new Error("Invalid path");
+            const snapshotRoot = resolve(entry.directory, "snapshots", match[2]);
+            const root = await realpath(snapshotRoot);
+            if (root !== snapshotRoot)
+                throw new Error("Snapshot aliases are not allowed");
+            let file = await realpath(resolve(root, relative || "index.html"));
+            if (!file.startsWith(root + sep))
+                throw new Error("Invalid path");
+            if ((await stat(file)).isDirectory()) {
+                if (!path.endsWith("/")) {
+                    response.statusCode = 302;
+                    response.setHeader("Location", path + "/" + url.search);
+                    response.end();
+                    return true;
+                }
+                file = await realpath(join(file, "index.html"));
+            }
+            if (!file.startsWith(root + sep))
+                throw new Error("Invalid path");
+            const info = await stat(file);
+            if (!info.isFile())
+                throw new Error("Not a file");
+            response.setHeader("Content-Type", types[extname(file).toLowerCase()] ?? "application/octet-stream");
+            response.setHeader("Content-Length", info.size);
+            if (head)
+                response.end();
+            else
+                createReadStream(file)
+                    .on("error", () => response.destroy())
+                    .pipe(response);
+        }
+        catch {
+            missing();
+        }
+        return true;
+    };
+}
+//# sourceMappingURL=routes.js.map

package/dist/server/server/hosting/store.js

@@ -0,0 +1,158 @@
+import { randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import { copyFile, lstat, mkdir, readdir, readFile, realpath, rename, rm, writeFile, } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, join, resolve, sep } from "node:path";
+import { HostingLock } from "./lock.js";
+export const ID = /^[a-f0-9]{32}$/;
+export const defaultHostingDirectory = join(homedir(), ".codex-hub", "hosting");
+function parseArtifact(json) {
+    const value = JSON.parse(json);
+    if (!value ||
+        !ID.test(value.id) ||
+        !ID.test(value.snapshotId) ||
+        typeof value.project !== "string" ||
+        typeof value.source !== "string" ||
+        typeof value.name !== "string" ||
+        typeof value.title !== "string" ||
+        !Number.isFinite(Date.parse(value.createdAt)) ||
+        !Number.isFinite(Date.parse(value.updatedAt)) ||
+        value.url !== `/web/${value.id}/`)
+        throw new Error("Invalid artifact metadata");
+    return value;
+}
+async function copySnapshot(from, to) {
+    const info = await lstat(from);
+    if (info.isDirectory()) {
+        await mkdir(to);
+        for (const item of await readdir(from)) {
+            await copySnapshot(join(from, item), join(to, item));
+        }
+        return;
+    }
+    if (!info.isFile())
+        throw new Error(`Only regular files and directories can be published: ${from}`);
+    await copyFile(from, to, constants.COPYFILE_EXCL);
+}
+function inside(child, parent) {
+    return child === parent || child.startsWith(parent.endsWith(sep) ? parent : parent + sep);
+}
+export class HostingStore {
+    root;
+    constructor(root = defaultHostingDirectory) {
+        if (!root.trim())
+            throw new Error("Hosting directory must not be empty");
+        this.root = resolve(root.startsWith("~/") ? join(homedir(), root.slice(2)) : root);
+    }
+    async locked(action) {
+        const lock = new HostingLock(this.root, ".write-lock");
+        try {
+            while (!lock.acquire())
+                await new Promise((done) => setTimeout(done, 30));
+            return await action();
+        }
+        finally {
+            lock.close();
+        }
+    }
+    async get(id) {
+        if (!ID.test(id))
+            return undefined;
+        const directory = join(this.root, "artifacts", id);
+        let directoryExists = false;
+        try {
+            const canonicalDirectory = join(await realpath(this.root), "artifacts", id);
+            if ((await realpath(directory)) !== canonicalDirectory)
+                throw new Error("Artifact aliases are not allowed");
+            if (!(await lstat(directory)).isDirectory())
+                throw new Error("Invalid artifact directory");
+            directoryExists = true;
+            const artifact = parseArtifact(await readFile(join(directory, "artifact.json"), "utf8"));
+            if (artifact.id !== id)
+                throw new Error("Artifact identity does not match directory");
+            return { artifact, directory: canonicalDirectory };
+        }
+        catch (error) {
+            if (directoryExists || error.code !== "ENOENT")
+                console.warn(`Skipping damaged hosting entry ${directory}: ${String(error)}`);
+            return undefined;
+        }
+    }
+    async entries() {
+        let children;
+        try {
+            children = await readdir(join(this.root, "artifacts"), { withFileTypes: true });
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return [];
+            throw error;
+        }
+        const results = [];
+        for (const child of children) {
+            if (!child.isDirectory() || !ID.test(child.name))
+                continue;
+            const entry = await this.get(child.name);
+            if (entry)
+                results.push(entry);
+        }
+        return results;
+    }
+    async publish(sourcePath, projectPathInput, nameInput, title) {
+        const source = await realpath(resolve(sourcePath));
+        const project = await realpath(resolve(projectPathInput));
+        if (!(await lstat(source)).isDirectory() || !(await lstat(project)).isDirectory())
+            throw new Error("Source and project must be directories");
+        await mkdir(this.root, { recursive: true });
+        const root = await realpath(this.root);
+        if (inside(source, root) || inside(root, source))
+            throw new Error("Source must not overlap hosting storage");
+        const name = nameInput ?? basename(source);
+        if (!name.trim())
+            throw new Error("Artifact name must not be empty");
+        if (!(await lstat(join(source, "index.html"))).isFile())
+            throw new Error("Source requires index.html");
+        return this.locked(async () => {
+            const previous = (await this.entries()).find(({ artifact }) => artifact.project === project && artifact.name === name)?.artifact;
+            const id = previous?.id ?? randomUUID().replaceAll("-", "");
+            const directory = join(root, "artifacts", id);
+            await mkdir(join(directory, "snapshots"), { recursive: true });
+            const snapshotId = randomUUID().replaceAll("-", "");
+            const temp = join(directory, "snapshots", `.tmp-${snapshotId}`);
+            const metadataTemp = join(directory, `.artifact-${snapshotId}.json`);
+            try {
+                await copySnapshot(source, temp);
+                await rename(temp, join(directory, "snapshots", snapshotId));
+                const now = new Date().toISOString();
+                const artifact = {
+                    id,
+                    name,
+                    title: title ?? previous?.title ?? name,
+                    project,
+                    source,
+                    snapshotId,
+                    createdAt: previous?.createdAt ?? now,
+                    updatedAt: now,
+                    url: `/web/${id}/`,
+                };
+                await writeFile(metadataTemp, JSON.stringify(artifact));
+                await rename(metadataTemp, join(directory, "artifact.json"));
+                return artifact;
+            }
+            finally {
+                await rm(temp, { recursive: true, force: true });
+                await rm(metadataTemp, { force: true });
+            }
+        });
+    }
+    async delete(id) {
+        return this.locked(async () => {
+            const entry = await this.get(id);
+            if (!entry)
+                return false;
+            await rm(entry.directory, { recursive: true });
+            return true;
+        });
+    }
+}
+//# sourceMappingURL=store.js.map

package/dist/server/server/http/create-server.js

@@ -3,6 +3,9 @@ import { realpath, stat } from "node:fs/promises";
 import { createServer as createHttpServer, } from "node:http";
 import { createServer as createHttpsServer } from "node:https";
 import { extname, resolve, sep } from "node:path";
+import { DiffStore } from "../hosting/diff-store.js";
+import { HostingLock } from "../hosting/lock.js";
+import { hostingRoutes } from "../hosting/routes.js";
 import { emptyApiRouter, sendJson } from "./router.js";
 import { applySecurityHeaders } from "./security.js";
 const CONTENT_TYPES = {
@@ -21,12 +24,12 @@ function sendText(response, status, message, headOnly) {
     response.setHeader("Content-Length", Buffer.byteLength(message));
     response.end(headOnly ? undefined : message);
 }
-async function serveFile(response, filePath, headOnly) {
+async function serveFile(response, filePath, headOnly, status = 200) {
     try {
         const info = await stat(filePath);
         if (!info.isFile())
             return false;
-        response.statusCode = 200;
+        response.statusCode = status;
         response.setHeader("Content-Type", CONTENT_TYPES[extname(filePath)] ?? "application/octet-stream");
         response.setHeader("Content-Length", info.size);
         if (headOnly) {
@@ -45,11 +48,34 @@ async function serveFile(response, filePath, headOnly) {
 }
 export function createServer(config, apiRouter = emptyApiRouter, closeServices = () => { }, upgrades) {
     const clientRoot = realpathSync(config.clientDirectory);
+    const finish = (server) => {
+        const lock = config.hostingDirectory
+            ? new HostingLock(config.hostingDirectory, ".server-lock")
+            : undefined;
+        try {
+            if (lock && !lock.acquire())
+                throw new Error("Hosting directory is already used by another Hub server");
+        }
+        catch (error) {
+            lock?.close();
+            throw error;
+        }
+        server.once("close", () => lock?.close());
+        server.once("error", () => {
+            if (!server.listening)
+                lock?.close();
+        });
+        return attachLifecycle(server, closeServices, upgrades);
+    };
+    const hosting = hostingRoutes(config.hostingDirectory);
+    const diffs = config.hostingDirectory ? new DiffStore(config.hostingDirectory) : undefined;
     const clientRootPrefix = `${clientRoot}${sep}`;
     const requestListener = async (request, response) => {
         applySecurityHeaders(response, request);
         const headOnly = request.method === "HEAD";
         try {
+            if (await hosting(request, response))
+                return;
             if (await apiRouter(request, response))
                 return;
             if (request.method !== "GET" && !headOnly) {
@@ -62,7 +88,14 @@ export function createServer(config, apiRouter = emptyApiRouter, closeServices =
             const url = new URL(request.url ?? "/", "http://localhost");
             const decodedPath = decodeURIComponent(url.pathname);
             const sessionPage = /^\/sessions\/[A-Za-z0-9_-]{20,100}\/?$/.test(decodedPath);
-            const relativePath = decodedPath === "/" ? "index.html" : sessionPage ? "index.html" : decodedPath.slice(1);
+            const diffPage = /^\/diffs\/([a-f0-9-]{36})$/.exec(decodedPath);
+            const appPage = decodedPath === "/" ||
+                sessionPage ||
+                ((decodedPath === "/artifacts" || diffPage) && config.hostingDirectory);
+            const pageStatus = diffPage && diffs && !(await diffs.exists(diffPage[1])) ? 404 : 200;
+            if (diffPage)
+                response.setHeader("Cache-Control", "private, no-store");
+            const relativePath = appPage ? "index.html" : decodedPath.slice(1);
             const requestedPath = resolve(clientRoot, relativePath);
             let canonicalPath;
             try {
@@ -73,7 +106,7 @@ export function createServer(config, apiRouter = emptyApiRouter, closeServices =
                 return;
             }
             if (canonicalPath.startsWith(clientRootPrefix) &&
-                (await serveFile(response, canonicalPath, headOnly))) {
+                (await serveFile(response, canonicalPath, headOnly, pageStatus))) {
                 return;
             }
             sendText(response, 404, "Not found", headOnly);
@@ -84,7 +117,7 @@ export function createServer(config, apiRouter = emptyApiRouter, closeServices =
     };
     if (!config.tls.enabled) {
         const server = createHttpServer(requestListener);
-        return attachLifecycle(server, closeServices, upgrades);
+        return finish(server);
     }
     const requireClientCertificate = config.tls.certificateAuthorityPath !== undefined;
     const server = createHttpsServer({
@@ -97,7 +130,7 @@ export function createServer(config, apiRouter = emptyApiRouter, closeServices =
         requestCert: requireClientCertificate,
         rejectUnauthorized: requireClientCertificate,
     }, requestListener);
-    return attachLifecycle(server, closeServices, upgrades);
+    return finish(server);
 }
 /** Own startup cleanup as well as the server's pre-drain shutdown hook. */
 export async function startServer(config, apiRouter, closeServices, upgrades) {

package/dist/server/server/http/router.js

@@ -2,7 +2,7 @@ export function sendJson(response, status, body, headOnly = false) {
     const json = JSON.stringify(body);
     response.statusCode = status;
     response.setHeader("Content-Type", "application/json; charset=utf-8");
-    response.setHeader("Cache-Control", "no-store");
+    response.setHeader("Cache-Control", response.getHeader("Cache-Control") ?? "no-store");
     response.setHeader("Content-Length", Buffer.byteLength(json));
     response.end(headOnly ? undefined : json);
 }

package/dist/server/server/main.js

@@ -1,11 +1,66 @@
 #!/usr/bin/env node
+import { parseArgs } from "node:util";
 import { commandLineHelp, loadConfig } from "./config.js";
 import { createCodexHub } from "./create-hub.js";
+import { DiffStore } from "./hosting/diff-store.js";
+import { HostingStore } from "./hosting/store.js";
 import { createApiRouter } from "./http/api-router.js";
 import { startServer } from "./http/create-server.js";
 import { createTerminalPreviewWebSocket } from "./http/terminal-preview-websocket.js";
 import { uploadDirectory } from "./http/upload-routes.js";
+async function runResourceCommand(resource, action, args) {
+    const { values, positionals } = parseArgs({
+        args,
+        allowPositionals: true,
+        options: {
+            project: { type: "string" },
+            name: { type: "string" },
+            title: { type: "string" },
+            "hosting-dir": { type: "string" },
+            json: { type: "boolean" },
+            help: { type: "boolean" },
+        },
+    });
+    if (values.help || action === "--help") {
+        console.log(commandLineHelp());
+        return;
+    }
+    if (!["publish", "list", "delete"].includes(action) ||
+        positionals.length !== (action === "list" ? 0 : 1))
+        throw new Error("Expected page/diff publish <source>, list, or delete <id>");
+    const pages = new HostingStore(values["hosting-dir"]);
+    const diffs = new DiffStore(values["hosting-dir"]);
+    let result;
+    if (action === "publish") {
+        if (resource === "page" && !values.project)
+            throw new Error("page publish requires --project");
+        const entry = resource === "page"
+            ? await pages.publish(positionals[0], values.project, values.name, values.title)
+            : await diffs.publish(positionals[0], values.title);
+        const title = entry.title.replace(/[\\[\]]/g, "\\$&").replace(/[\r\n]/g, " ");
+        console.log(values.json ? JSON.stringify(entry) : `${entry.url}\n[${title}](${entry.url})`);
+        return;
+    }
+    if (action === "list") {
+        result =
+            resource === "page"
+                ? (await pages.entries()).map(({ artifact }) => artifact)
+                : await diffs.list();
+    }
+    else {
+        if (resource === "page")
+            await pages.delete(positionals[0]);
+        else
+            await diffs.delete(positionals[0]);
+        result = { id: positionals[0], deleted: true };
+    }
+    console.log(JSON.stringify(result, null, values.json ? undefined : 2));
+}
 async function main() {
+    if (["page", "diff"].includes(process.argv[2])) {
+        await runResourceCommand(process.argv[2], process.argv[3], process.argv.slice(4));
+        return;
+    }
     const command = loadConfig();
     if (command.kind === "help") {
         console.log(commandLineHelp());

package/dist/server/shared/diff.js

@@ -0,0 +1,158 @@
+const pathEscapes = {
+    a: "\x07",
+    b: "\b",
+    f: "\f",
+    v: "\v",
+    n: "\n",
+    t: "\t",
+    r: "\r",
+};
+/** Git quotes paths as C strings, including octal-escaped UTF-8 bytes. */
+function decodePath(value) {
+    if (!value.startsWith('"'))
+        return value;
+    const bytes = [];
+    const inner = value.slice(1, value.lastIndexOf('"'));
+    for (let i = 0; i < inner.length; i++) {
+        if (inner[i] === "\\") {
+            const octal = /^[0-7]{1,3}/.exec(inner.slice(i + 1));
+            if (octal) {
+                bytes.push(parseInt(octal[0], 8));
+                i += octal[0].length;
+                continue;
+            }
+            const escape = inner[++i];
+            bytes.push(...new TextEncoder().encode(pathEscapes[escape] ?? escape));
+        }
+        else {
+            const point = String.fromCodePoint(inner.codePointAt(i));
+            bytes.push(...new TextEncoder().encode(point));
+            i += point.length - 1;
+        }
+    }
+    return new TextDecoder().decode(new Uint8Array(bytes));
+}
+function pathName(value) {
+    return decodePath(value).replace(/^[ab]\//, "");
+}
+/** Only repeated paths can be inferred reliably without extended headers. */
+function headerPath(value) {
+    const quoted = /^"(?:[^"\\]|\\.)*" /.exec(value);
+    let oldPath;
+    let newPath;
+    if (quoted) {
+        oldPath = value.slice(0, quoted[0].length - 1);
+        newPath = value.slice(quoted[0].length);
+    }
+    else {
+        const quotedNew = / ("(?:[^"\\]|\\.)*")$/.exec(value);
+        // Unquoted, identical paths have equal lengths, regardless of embedded spaces.
+        const separator = quotedNew?.index ?? (value.length - 1) / 2;
+        if (!Number.isInteger(separator) || value[separator] !== " ")
+            return null;
+        oldPath = value.slice(0, separator);
+        newPath = value.slice(separator + 1);
+    }
+    const oldName = decodePath(oldPath);
+    const newName = decodePath(newPath);
+    return oldName.startsWith("a/") &&
+        newName.startsWith("b/") &&
+        oldName.slice(2) === newName.slice(2)
+        ? newName.slice(2)
+        : null;
+}
+export function parseDiff(raw) {
+    const files = [];
+    let file;
+    let pathResolved = false;
+    let oldLine = 0;
+    let newLine = 0;
+    let oldRemaining = 0;
+    let newRemaining = 0;
+    let inHunk = false;
+    let warning = false;
+    const finishHunk = () => {
+        if (oldRemaining || newRemaining)
+            warning = true;
+        inHunk = false;
+        oldRemaining = newRemaining = 0;
+    };
+    const finishFile = () => {
+        finishHunk();
+        if (file && !pathResolved)
+            warning = true;
+    };
+    const lines = raw.split("\n");
+    if (lines.at(-1) === "")
+        lines.pop();
+    for (const text of lines) {
+        if (text.startsWith("diff --git ")) {
+            finishFile();
+            const path = headerPath(text.slice(11));
+            pathResolved = path !== null;
+            file = {
+                path: path ?? text.slice(11),
+                lines: [],
+                additions: 0,
+                deletions: 0,
+            };
+            files.push(file);
+        }
+        if (!file) {
+            if (text.trim())
+                warning = true;
+            continue;
+        }
+        const hunk = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/.exec(text);
+        if (hunk) {
+            finishHunk();
+            oldLine = Number(hunk[1]);
+            newLine = Number(hunk[3]);
+            oldRemaining = Number(hunk[2] ?? 1);
+            newRemaining = Number(hunk[4] ?? 1);
+            inHunk = true;
+            file.lines.push({ text, kind: "meta" });
+            continue;
+        }
+        if (inHunk && (oldRemaining || newRemaining) && /^[ +\-]/.test(text)) {
+            const kind = text[0] === "+" ? "add" : text[0] === "-" ? "remove" : "context";
+            const line = { text: text.slice(1), kind };
+            if (kind !== "add") {
+                line.old = oldLine++;
+                oldRemaining--;
+            }
+            if (kind !== "remove") {
+                line.next = newLine++;
+                newRemaining--;
+            }
+            if (oldRemaining < 0 || newRemaining < 0)
+                warning = true;
+            if (kind === "add")
+                file.additions++;
+            if (kind === "remove")
+                file.deletions++;
+            file.lines.push(line);
+            continue;
+        }
+        if (/^(\+\+\+|---) /.test(text)) {
+            const path = text.slice(4);
+            if (path !== "/dev/null") {
+                file.path = pathName(path.replace(/\t$/, ""));
+                pathResolved = true;
+            }
+        }
+        const renamed = /^(?:rename|copy) to (.*)$/.exec(text);
+        if (renamed) {
+            file.path = decodePath(renamed[1]);
+            pathResolved = true;
+        }
+        if (!/^(diff --git |index |--- |\+\+\+ |new file mode |deleted file mode |old mode |new mode |similarity index |dissimilarity index |rename from |rename to |copy from |copy to |Binary files .* differ$|\$)/.test(text))
+            warning = true;
+        if (inHunk && /^[+\- ]/.test(text))
+            warning = true;
+        file.lines.push({ text, kind: "meta" });
+    }
+    finishFile();
+    return { files, warning: warning || files.length === 0 };
+}
+//# sourceMappingURL=diff.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@someonegg/codex-hub",
-  "version": "0.1.9",
+  "version": "0.2.1",
   "description": "Local project and session hub for Codex",
   "type": "module",
   "engines": {
@@ -20,7 +20,8 @@
     "format:check": "prettier --check .",
     "lint": "lint-client",
     "prepack": "npm run build",
-    "test:package": "node scripts/test-package.mjs"
+    "test:package": "node scripts/test-package.mjs",
+    "test:hosting": "npm run build && node --import tsx scripts/test-hosting.mjs"
   },
   "keywords": [
     "codex",