@someonegg/codex-hub 0.1.9 → 0.2.0

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.0",
   "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",