@v7-cms/proxy 0.0.0-alpha.9 → 0.0.0-stage

package/README.md

@@ -0,0 +1,3 @@
+# Temporary Holding Version
+
+This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.

package/package.json

@@ -1,46 +1,6 @@
 {
   "name": "@v7-cms/proxy",
-  "version": "0.0.0-alpha.9",
-  "type": "module",
-  "exports": {
-    ".": "./src/server.ts",
-    "./http": "./src/http.ts"
-  },
-  "bin": {
-    "v7-cms-proxy": "./dist/cli.mjs"
-  },
-  "scripts": {
-    "check": "tsc --noEmit",
-    "start": "node dist/cli.mjs",
-    "build": "node build.mjs"
-  },
-  "devDependencies": {
-    "esbuild": "0.28.2"
-  },
-  "files": [
-    "dist",
-    "README.md"
-  ],
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/phishinqi/v7-cms.git",
-    "directory": "packages/proxy"
-  },
-  "homepage": "https://github.com/phishinqi/v7-cms#readme",
-  "bugs": {
-    "url": "https://github.com/phishinqi/v7-cms/issues"
-  },
-  "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org"
-  },
-  "description": "Local write proxy for v7-cms, for browsers without the File System Access API.",
-  "keywords": [
-    "cms",
-    "git",
-    "proxy",
-    "local",
-    "v7-cms"
-  ]
-}
+  "version": "0.0.0-stage",
+  "stub": true,
+  "description": "Temporary package placeholder for staged publishing"
+}

package/dist/cli.mjs

@@ -1,317 +0,0 @@
-#!/usr/bin/env node
-
-// src/cli.ts
-import { resolve as resolve2 } from "node:path";
-
-// src/http.ts
-import { createServer } from "node:http";
-import { randomBytes } from "node:crypto";
-
-// src/server.ts
-import { mkdir, readFile, readdir, realpath, rm, stat, writeFile } from "node:fs/promises";
-import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
-var json = (body, status = 200) => ({ status, body });
-var LocalProxy = class {
-  root;
-  token;
-  mediaFolder;
-  constructor(options) {
-    this.root = resolve(options.root);
-    this.token = options.token ?? null;
-    this.mediaFolder = options.mediaFolder ?? "public/images/uploads";
-  }
-  async handle(request) {
-    if (request.method === "OPTIONS") return { status: 204, body: null };
-    if (request.path === "/api/health") {
-      return json({ repo: basename(this.root), version: 1 });
-    }
-    if (this.token && request.token !== this.token) {
-      return json({ error: "Missing or wrong proxy token." }, 401);
-    }
-    try {
-      switch (request.path) {
-        case "/api/v1":
-          return await this.content(request);
-        case "/api/media":
-          return await this.media(request);
-        default:
-          return json({ error: "Not found" }, 404);
-      }
-    } catch (error) {
-      const message = error.message;
-      const status = /outside the repository|escapes/.test(message) ? 403 : 500;
-      return json({ error: message }, status);
-    }
-  }
-  /**
-   * One call carries one storage operation. The shape mirrors the GitHub adapter's capabilities
-   * so the editor cannot tell the two apart.
-   */
-  async content(request) {
-    const body = request.body ?? {};
-    switch (body["action"]) {
-      case "info":
-        return json({ repo: basename(this.root), root: this.root, version: 1 });
-      case "listDir":
-        return json({ entries: await this.listDir(String(body["path"] ?? "")) });
-      case "readFile":
-        return json({ file: await this.readFile(String(body["path"])) });
-      case "exists":
-        return json({ exists: await this.exists(String(body["path"])) });
-      case "writeFile":
-        return json({ result: await this.writeFile(body) });
-      case "deleteFile":
-        await this.deleteFile(String(body["path"]));
-        return json({ ok: true });
-      default:
-        return json({ error: `Unknown action "${String(body["action"])}"` }, 400);
-    }
-  }
-  async listDir(path) {
-    const full = await this.resolve(path);
-    const entries = await readdir(full, { withFileTypes: true }).catch(() => []);
-    return entries.filter((entry) => !entry.name.startsWith(".")).map((entry) => ({
-      name: entry.name,
-      type: entry.isDirectory() ? "dir" : "file"
-    })).sort((a, b) => a.name.localeCompare(b.name));
-  }
-  async readFile(path) {
-    const full = await this.resolve(path);
-    const info = await stat(full).catch(() => null);
-    if (!info?.isFile()) throw new Error(`Not found: ${path}`);
-    const buffer = await readFile(full);
-    const isText = /\.(md|mdx|json|ya?ml|txt|css|js|ts|astro)$/i.test(path);
-    return {
-      text: isText ? buffer.toString("utf8") : void 0,
-      base64: isText ? void 0 : buffer.toString("base64"),
-      size: info.size
-    };
-  }
-  async exists(path) {
-    const full = await this.resolve(path);
-    return stat(full).then(
-      (info) => info.isFile(),
-      () => false
-    );
-  }
-  async writeFile(body) {
-    const path = String(body["path"]);
-    const full = await this.resolve(path, { forWrite: true });
-    await mkdir(dirname(full), { recursive: true });
-    const contents = typeof body["base64"] === "string" ? Buffer.from(body["base64"], "base64") : String(body["text"] ?? "");
-    await writeFile(full, contents);
-    const info = await stat(full);
-    return { size: info.size, mtime: info.mtimeMs };
-  }
-  async deleteFile(path) {
-    const full = await this.resolve(path, { forWrite: true });
-    const info = await stat(full).catch(() => null);
-    if (!info) throw new Error(`Not found: ${path}`);
-    await rm(full);
-  }
-  async media(request) {
-    if (request.method === "GET") {
-      const folder = await this.resolve(this.mediaFolder);
-      const names = await readdir(folder).catch(() => []);
-      return json({
-        assets: names.map((name2) => ({
-          path: `${this.mediaFolder}/${name2}`,
-          url: `/${this.mediaFolder}/${name2}`,
-          name: name2
-        })),
-        cursor: null
-      });
-    }
-    const body = request.body ?? {};
-    const name = String(body["name"] ?? "");
-    if (!name || /[\\/]/.test(name)) return json({ error: "Invalid file name" }, 400);
-    const path = `${this.mediaFolder}/${name}`;
-    await this.writeFile({ path, base64: body["base64"] });
-    return json({ path, url: `/${path}`, name }, 201);
-  }
-  /**
-   * Resolve a repository-relative path to an absolute one, refusing anything that leaves the root.
-   * `forWrite` also allows the file itself not to exist yet, while still checking its parent.
-   */
-  async resolve(path, options = {}) {
-    if (isAbsolute(path)) throw new Error(`${path} is outside the repository.`);
-    const full = resolve(this.root, path);
-    const rel = relative(this.root, full);
-    if (rel.startsWith("..") || isAbsolute(rel)) {
-      throw new Error(`${path} is outside the repository.`);
-    }
-    if (!options.forWrite) {
-      const real = await realpath(full).catch(() => null);
-      if (real) {
-        const realRel = relative(await realpath(this.root), real);
-        if (realRel.startsWith("..") || isAbsolute(realRel)) {
-          throw new Error(`${path} escapes the repository.`);
-        }
-        return real;
-      }
-    }
-    return full;
-  }
-};
-var basename = (path) => path.split(sep).filter(Boolean).pop() ?? path;
-var TOKEN_HEADER = "x-v7-cms-token";
-
-// src/http.ts
-async function startProxy(options) {
-  const token = options.token ?? randomBytes(24).toString("hex");
-  const host = options.host ?? "127.0.0.1";
-  const proxy = new LocalProxy({
-    root: options.root,
-    token,
-    ...options.mediaFolder ? { mediaFolder: options.mediaFolder } : {}
-  });
-  const allowed = new Set(options.allowedOrigins ?? []);
-  const server = createServer((request, response) => {
-    void handle(request, response, proxy, allowed);
-  });
-  await new Promise((resolve3, reject) => {
-    server.once("error", reject);
-    server.listen(options.port ?? 0, host, resolve3);
-  });
-  const address = server.address();
-  const port = typeof address === "object" && address ? address.port : options.port ?? 0;
-  return {
-    server,
-    port,
-    token,
-    url: `http://${host}:${port}`,
-    close: () => new Promise(
-      (resolve3, reject) => server.close((error) => error ? reject(error) : resolve3())
-    )
-  };
-}
-async function handle(request, response, proxy, allowed) {
-  const origin = request.headers.origin;
-  if (origin) {
-    const permitted = allowed.has(origin) || /^http:\/\/(localhost|127\.0\.0\.1|\[::1\]):\d+$/.test(origin);
-    if (!permitted) {
-      response.writeHead(403, { "Content-Type": "application/json" });
-      response.end(JSON.stringify({ error: "Origin not allowed" }));
-      return;
-    }
-    response.setHeader("Access-Control-Allow-Origin", origin);
-    response.setHeader("Vary", "Origin");
-    response.setHeader(
-      "Access-Control-Allow-Headers",
-      `Content-Type, ${TOKEN_HEADER}, Authorization`
-    );
-    response.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
-  }
-  const url = new URL(request.url ?? "/", "http://localhost");
-  const body = await readBody(request);
-  const header = request.headers[TOKEN_HEADER];
-  const bearer = request.headers.authorization?.replace(/^Bearer /, "");
-  const result = await proxy.handle({
-    method: request.method ?? "GET",
-    path: url.pathname,
-    query: url.search.replace(/^\?/, ""),
-    body,
-    ...typeof header === "string" ? { token: header } : typeof bearer === "string" ? { token: bearer } : {}
-  });
-  response.writeHead(result.status, {
-    "Content-Type": "application/json",
-    "Cache-Control": "no-store"
-  });
-  response.end(JSON.stringify(result.body ?? null));
-}
-var MAX_BODY = 32 * 1024 * 1024;
-function readBody(request) {
-  if (request.method === "GET" || request.method === "OPTIONS") return Promise.resolve(void 0);
-  return new Promise((resolve3) => {
-    const chunks = [];
-    let size = 0;
-    request.on("data", (chunk) => {
-      size += chunk.length;
-      if (size > MAX_BODY) {
-        request.destroy();
-        resolve3(void 0);
-        return;
-      }
-      chunks.push(chunk);
-    });
-    request.on("end", () => {
-      const text = Buffer.concat(chunks).toString("utf8");
-      if (!text) return resolve3(void 0);
-      try {
-        resolve3(JSON.parse(text));
-      } catch {
-        resolve3(void 0);
-      }
-    });
-    request.on("error", () => resolve3(void 0));
-  });
-}
-
-// src/cli.ts
-async function main(argv = process.argv.slice(2)) {
-  const args = /* @__PURE__ */ new Map();
-  for (let index = 0; index < argv.length; index += 1) {
-    const token2 = argv[index];
-    if (!token2.startsWith("--")) continue;
-    const next = argv[index + 1];
-    if (next && !next.startsWith("--")) {
-      args.set(token2, next);
-      index += 1;
-    } else {
-      args.set(token2, true);
-    }
-  }
-  if (args.has("--help") || args.has("-h")) {
-    process.stdout.write(
-      [
-        "v7-cms local proxy",
-        "",
-        "Usage: v7-cms-proxy [--root <dir>] [--port <n>] [--host <addr>] [--token <token>]",
-        "",
-        "  --root   Repository root the editor may read and write. Default: the current directory.",
-        "  --port   Port to listen on. Default: 5177.",
-        "  --host   Interface to bind. Default: 127.0.0.1. Do not expose this to a network.",
-        "  --token  Fixed token. Default: a new one each run.",
-        ""
-      ].join("\n")
-    );
-    return;
-  }
-  const root = resolve2(
-    typeof args.get("--root") === "string" ? args.get("--root") : "."
-  );
-  const port = Number(typeof args.get("--port") === "string" ? args.get("--port") : 5177);
-  const host = typeof args.get("--host") === "string" ? args.get("--host") : "127.0.0.1";
-  const token = typeof args.get("--token") === "string" ? args.get("--token") : void 0;
-  if (host !== "127.0.0.1" && host !== "localhost" && host !== "::1") {
-    process.stderr.write(
-      `Refusing to bind ${host}: this proxy can write files and must stay on loopback.
-`
-    );
-    process.exitCode = 1;
-    return;
-  }
-  const proxy = await startProxy({ root, port, host, ...token ? { token } : {} });
-  process.stdout.write(
-    [
-      "",
-      `v7-cms local proxy listening on ${proxy.url}`,
-      `  root:  ${root}`,
-      `  token: ${proxy.token}`,
-      "",
-      "Paste the URL and token into the editor. Press Ctrl+C to stop.",
-      ""
-    ].join("\n")
-  );
-  const stop = () => {
-    void proxy.close().then(() => process.exit(0));
-  };
-  process.on("SIGINT", stop);
-  process.on("SIGTERM", stop);
-}
-if (process.argv[1] && import.meta.url.endsWith(process.argv[1].replace(/\\/g, "/").split("/").pop())) {
-  await main();
-}
-export {
-  main
-};