vercel-vm-factory 0.1.0

package/README.md

@@ -0,0 +1,59 @@
+# Vercel VM Factory
+
+Create a tiny Vercel Container deployment: copy `wsterm` from `ghcr.io/v1xingyue/ws-shell:v1.1.alpine` into a selected base image, then deploy with Vercel CLI.
+
+```bash
+npx vercel-vm-factory create \
+  --base ubuntu \
+  --project ws-shell-ubuntu \
+  --client-id YOUR_GITHUB_CLIENT_ID \
+  --client-secret YOUR_GITHUB_CLIENT_SECRET \
+  --github-userid 12345678
+```
+
+Run without flags for prompts:
+
+```bash
+npx vercel-vm-factory create
+```
+
+Check local setup:
+
+```bash
+npx vercel-vm-factory doctor
+```
+
+The script checks `vercel --version` and `vercel whoami`; if you are not logged in, it runs `vercel login`.
+
+Use `--help` to show all flags.
+
+Entered GitHub values are reused from `~/.vercel-vm-factory/defaults.json`; press Enter to keep the placeholder value or skip an empty one.
+
+The generated project contains only `Dockerfile.vercel`.
+
+CLI mapping:
+
+- Vercel Team -> `--scope TEAM_SLUG` when needed; omit it to use the CLI default scope
+- Project Name -> `--project x-shell`
+- Application Preset -> patched through Vercel API as `framework=container`
+- Root Directory -> generated project directory
+
+Base presets:
+
+- `alpine` -> `alpine:3.23`
+- `ubuntu` -> `ubuntu:24.04`
+- `debian` -> `debian:13-slim`
+
+Custom base:
+
+```bash
+npx vercel-vm-factory create --base fedora:42 --project ws-shell-fedora
+```
+
+Before deploying, set the GitHub OAuth callback URL to:
+
+```text
+https://PROJECT.vercel.app/auth/github/callback
+```
+
+Use `--dry-run` to generate files without deploying.

package/bin/vercel-vm-factory.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "../deploy-vm.mjs";

package/deploy-vm.mjs

@@ -0,0 +1,427 @@
+#!/usr/bin/env node
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { homedir } from "node:os";
+import path from "node:path";
+
+const bases = {
+  alpine: "alpine:3.23",
+  ubuntu: "ubuntu:24.04",
+  debian: "debian:13-slim",
+};
+
+const { command, args } = parseCommand(process.argv.slice(2));
+const scriptRoot = path.resolve(import.meta.dirname);
+const workspaceRoot = process.cwd();
+const stateRoot = path.join(homedir(), ".vercel-vm-factory");
+const defaultsPath = path.join(stateRoot, "defaults.json");
+const legacyDefaultsPath = path.join(scriptRoot, ".defaults.json");
+const defaults = { ...(await readDefaults(legacyDefaultsPath)), ...(await readDefaults(defaultsPath)) };
+const colorEnabled = output.isTTY && !process.env.NO_COLOR;
+const color = {
+  dim: (text) => paint(text, "2"),
+  cyan: (text) => paint(text, "36"),
+  green: (text) => paint(text, "32"),
+  yellow: (text) => paint(text, "33"),
+  red: (text) => paint(text, "31"),
+  bold: (text) => paint(text, "1"),
+};
+
+try {
+  if (args.help || args.h || command === "help") {
+    printHelp();
+    process.exit(0);
+  }
+  if (!["create", "doctor"].includes(command)) {
+    throw new Error(`Unknown command: ${command}. Run vercel-vm-factory help`);
+  }
+  await main();
+} catch (error) {
+  const message = error instanceof Error ? error.message : String(error);
+  if (message.includes("scope does not exist")) {
+    console.error(`\nScope not found. Leave scope empty, or set the real CLI slug with --scope.`);
+    console.error(`If it was saved before, edit or delete: ${defaultsPath}`);
+  }
+  console.error(message);
+  process.exit(1);
+}
+
+async function main() {
+  printHeader();
+
+  if (args.doctor || command === "doctor") {
+    await doctor();
+    return;
+  }
+
+  const baseName = await chooseBase(args.base ?? defaults.base ?? "alpine");
+  const baseImage = bases[baseName] ?? baseName;
+  const scope = await optionalValue("scope", "Vercel team/scope", defaults.scope);
+  const project = await value("project", "Vercel project name", defaults.project ?? `ws-shell-${baseName}`);
+  const wsShellImage = args.from ?? process.env.WS_SHELL_IMAGE ?? defaults.from ?? "ghcr.io/v1xingyue/ws-shell:v1.1.alpine";
+  const prod = args.prod !== "false";
+  const dryRun = Boolean(args["dry-run"]);
+  const skipLink = Boolean(args["skip-link"]);
+
+  const oauthRedirectUrl =
+    args["redirect-url"] ??
+    process.env.OAUTH_REDIRECT_URL ??
+    defaults["redirect-url"] ??
+    `https://${project}.vercel.app/auth/github/callback`;
+
+  const appDir = path.join(workspaceRoot, ".vercel-vm-factory", ".generated", project);
+  const dockerfile = makeDockerfile({ baseImage, wsShellImage });
+
+  await rm(appDir, { recursive: true, force: true });
+  await mkdir(appDir, { recursive: true });
+  await writeFile(path.join(appDir, "Dockerfile.vercel"), dockerfile);
+
+  printSummary({
+    base: `${baseName} -> ${baseImage}`,
+    project,
+    scope: scope || "default",
+    source: wsShellImage,
+    callback: oauthRedirectUrl,
+    dockerfile: path.join(appDir, "Dockerfile.vercel"),
+    target: prod ? "production" : "preview",
+  });
+
+  if (dryRun) {
+    ok("dry run: skipped vercel deploy");
+    return;
+  }
+
+  await ensureVercelReady();
+
+  const githubClientId = await secret("client-id", "GitHub client id", process.env.GITHUB_CLIENT_ID ?? defaults["client-id"]);
+  const githubClientSecret = await secret(
+    "client-secret",
+    "GitHub client secret",
+    process.env.GITHUB_CLIENT_SECRET ?? defaults["client-secret"],
+  );
+  const allowedUserIds = await secret("github-userid", "Allowed GitHub numeric user id(s)", process.env.ALLOWED_USER_IDS ?? defaults["github-userid"]);
+
+  await writeDefaults(defaultsPath, {
+    ...defaults,
+    base: baseName,
+    scope: scope || undefined,
+    project,
+    from: wsShellImage,
+    "client-id": githubClientId,
+    "client-secret": githubClientSecret,
+    "github-userid": allowedUserIds,
+  });
+
+  const commonArgs = [];
+  if (args.token) commonArgs.push("--token", args.token);
+  if (scope) commonArgs.push("--scope", scope);
+
+  if (!skipLink) {
+    step("Linking Vercel project");
+    await runNoUrl("vercel", ["link", "--yes", "--project", project, "--cwd", appDir, ...commonArgs]);
+  } else {
+    warn("skip-link enabled; using existing .vercel/project.json");
+  }
+
+  step("Setting project framework=container");
+  await setContainerFramework(appDir, commonArgs);
+
+  const vercelArgs = [
+    "deploy",
+    appDir,
+    "--yes",
+    "--logs",
+    "--env",
+    `OAUTH_REDIRECT_URL=${oauthRedirectUrl}`,
+  ];
+
+  if (githubClientId) vercelArgs.push("--env", `GITHUB_CLIENT_ID=${githubClientId}`);
+  if (githubClientSecret) vercelArgs.push("--env", `GITHUB_CLIENT_SECRET=${githubClientSecret}`);
+  if (allowedUserIds) vercelArgs.push("--env", `ALLOWED_USER_IDS=${allowedUserIds}`);
+  if (prod) vercelArgs.push("--prod");
+  vercelArgs.push(...commonArgs);
+
+  step("Deploying");
+  const deploymentUrl = await run("vercel", vercelArgs);
+  console.log(`\n${color.green("Deployment URL:")} ${color.bold(deploymentUrl)}`);
+}
+
+async function setContainerFramework(appDir, commonArgs) {
+  const projectFile = path.join(appDir, ".vercel", "project.json");
+  const projectConfig = JSON.parse(await readFile(projectFile, "utf8"));
+  if (!projectConfig.projectId) throw new Error(`Missing projectId in ${projectFile}`);
+
+  await runNoUrl("vercel", [
+    "api",
+    `/v10/projects/${projectConfig.projectId}`,
+    "-X",
+    "PATCH",
+    "-F",
+    "framework=container",
+    ...commonArgs,
+  ]);
+}
+
+async function ensureVercelReady() {
+  step("Checking Vercel CLI");
+  try {
+    const version = await runCapture("vercel", ["--version"]);
+    ok(version.split("\n").filter(Boolean).at(-1) || "vercel installed");
+  } catch {
+    throw new Error("Vercel CLI is not installed. Install it with: pnpm add -g vercel");
+  }
+
+  step("Checking Vercel login");
+  try {
+    const whoami = await runCapture("vercel", ["whoami"]);
+    ok(`logged in as ${whoami.trim()}`);
+  } catch {
+    warn("Vercel CLI is not logged in. Starting vercel login...");
+    await runNoUrl("vercel", ["login"]);
+  }
+}
+
+async function doctor() {
+  await ensureVercelReady();
+  console.log("");
+  console.log(color.bold("Saved defaults"));
+  printKeyValue("defaults file", defaultsPath);
+  printKeyValue("base", defaults.base || "not set");
+  printKeyValue("project", defaults.project || "not set");
+  printKeyValue("scope", defaults.scope || "not set");
+  printKeyValue("source image", defaults.from || "ghcr.io/v1xingyue/ws-shell:v1.1.alpine");
+  printKeyValue("client id", defaults["client-id"] ? mask(defaults["client-id"]) : "not set");
+  printKeyValue("client secret", defaults["client-secret"] ? mask(defaults["client-secret"]) : "not set");
+  printKeyValue("github userid", defaults["github-userid"] ? mask(defaults["github-userid"]) : "not set");
+}
+
+function makeDockerfile({ baseImage, wsShellImage }) {
+  return `ARG WS_SHELL_IMAGE=${wsShellImage}
+ARG BASE_IMAGE=${baseImage}
+
+FROM \${WS_SHELL_IMAGE} AS ws-shell
+FROM \${BASE_IMAGE} AS base
+
+# wsterm already embeds the web UI; runtime config comes from environment variables.
+COPY --from=ws-shell /app/bin/wsterm /app/bin/wsterm
+
+WORKDIR /app
+ENV ENABLE_SSL=false
+EXPOSE 80
+CMD ["/app/bin/wsterm","-bind",":80","-fork","/bin/sh"]
+`;
+}
+
+async function value(name, question, fallback) {
+  const current = args[name] ?? fallback;
+  if (args[name]) return args[name];
+  if (!input.isTTY) return current || "";
+
+  const rl = createInterface({ input, output });
+  const answer = (await rl.question(`${question}${fallback ? ` [${fallback}]` : ""}: `)).trim();
+  rl.close();
+  return answer || current || "";
+}
+
+async function secret(name, question, fallback) {
+  if (args[name]) return args[name];
+  if (!input.isTTY) return fallback || "";
+
+  const rl = createInterface({ input, output });
+  const placeholder = fallback ? mask(fallback) : "skip";
+  const answer = (await rl.question(`${question} [${placeholder}]: `)).trim();
+  rl.close();
+  return answer || fallback || "";
+}
+
+async function optionalValue(name, question, fallback) {
+  if (args[name] !== undefined) return args[name];
+  if (!input.isTTY) return "";
+
+  const rl = createInterface({ input, output });
+  const suffix = fallback ? ` [${fallback}; Enter to skip]` : " [skip]";
+  const answer = (await rl.question(`${question}${suffix}: `)).trim();
+  rl.close();
+  return answer;
+}
+
+async function chooseBase(fallback) {
+  if (args.base) return args.base;
+  if (!input.isTTY) return fallback;
+
+  const names = Object.keys(bases);
+  console.log(color.bold("Choose base image"));
+  names.forEach((name, index) => console.log(`  ${color.cyan(String(index + 1))}. ${name} ${color.dim(`(${bases[name]})`)}`));
+  console.log(`  ${color.cyan("4")}. custom image`);
+
+  const rl = createInterface({ input, output });
+  const answer = (await rl.question(`Base [${fallback}]: `)).trim();
+  rl.close();
+
+  if (!answer) return fallback;
+  if (bases[answer]) return answer;
+  if (/^[1-3]$/.test(answer)) return names[Number(answer) - 1];
+  if (answer === "4") return value("custom-base", "Custom base image", defaults["custom-base"]);
+  return answer;
+}
+
+async function readDefaults(file) {
+  try {
+    return JSON.parse(await readFile(file, "utf8"));
+  } catch {
+    return {};
+  }
+}
+
+async function writeDefaults(file, data) {
+  const clean = Object.fromEntries(Object.entries(data).filter(([, value]) => value));
+  await mkdir(path.dirname(file), { recursive: true });
+  await writeFile(file, `${JSON.stringify(clean, null, 2)}\n`);
+}
+
+function mask(value) {
+  if (value.length <= 8) return "********";
+  return `${value.slice(0, 4)}...${value.slice(-4)}`;
+}
+
+function parseArgs(argv) {
+  const out = {};
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (!arg.startsWith("--")) continue;
+
+    const [rawKey, rawValue] = arg.slice(2).split("=", 2);
+    out[rawKey] = rawValue ?? (argv[i + 1]?.startsWith("--") ? true : argv[i + 1]) ?? true;
+    if (rawValue === undefined && argv[i + 1] && !argv[i + 1].startsWith("--")) i += 1;
+  }
+  return out;
+}
+
+function parseCommand(argv) {
+  const known = new Set(["create", "doctor", "help"]);
+  const first = argv[0];
+  if (first && !first.startsWith("--")) {
+    return { command: known.has(first) ? first : first, args: parseArgs(argv.slice(1)) };
+  }
+  return { command: "create", args: parseArgs(argv) };
+}
+
+function run(command, commandArgs) {
+  return new Promise((resolve, reject) => {
+    let seenUrl = "";
+    const child = spawn(command, commandArgs, { stdio: ["inherit", "pipe", "pipe"] });
+
+    child.stdout.on("data", (chunk) => {
+      const text = chunk.toString();
+      output.write(text);
+      seenUrl = findLastUrl(text) || seenUrl;
+    });
+
+    child.stderr.on("data", (chunk) => {
+      const text = chunk.toString();
+      output.write(text);
+      seenUrl = findLastUrl(text) || seenUrl;
+    });
+
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0 && seenUrl) resolve(seenUrl);
+      else if (code === 0) reject(new Error("vercel finished but no deployment url was found"));
+      else reject(new Error(`vercel exited with code ${code}`));
+    });
+  });
+}
+
+function runCapture(command, commandArgs) {
+  return new Promise((resolve, reject) => {
+    let text = "";
+    const child = spawn(command, commandArgs, { stdio: ["ignore", "pipe", "pipe"] });
+    child.stdout.on("data", (chunk) => {
+      text += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+      text += chunk.toString();
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) resolve(text.trim());
+      else reject(new Error(text.trim() || `${command} exited with code ${code}`));
+    });
+  });
+}
+
+function runNoUrl(command, commandArgs) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, commandArgs, { stdio: "inherit" });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`${command} exited with code ${code}`));
+    });
+  });
+}
+
+function findLastUrl(text) {
+  return text.match(/https:\/\/[^\s]+\.vercel\.app/g)?.at(-1) ?? "";
+}
+
+function printHeader() {
+  console.log(color.bold(color.cyan("Vercel VM Factory")));
+  console.log(color.dim("Build a Container deployment from a tiny Dockerfile.vercel"));
+  console.log("");
+}
+
+function printSummary(items) {
+  console.log(color.bold("Deployment plan"));
+  for (const [key, value] of Object.entries(items)) {
+    printKeyValue(key, value);
+  }
+  console.log("");
+}
+
+function printKeyValue(key, value) {
+  console.log(`${color.dim(`${key.padEnd(14)} `)}${value}`);
+}
+
+function step(text) {
+  console.log(`${color.cyan("->")} ${text}`);
+}
+
+function ok(text) {
+  console.log(`${color.green("OK")} ${text}`);
+}
+
+function warn(text) {
+  console.log(`${color.yellow("!")} ${text}`);
+}
+
+function paint(text, code) {
+  return colorEnabled ? `\u001b[${code}m${text}\u001b[0m` : text;
+}
+
+function printHelp() {
+  printHeader();
+  console.log(`Usage:
+  vercel-vm-factory create
+  vercel-vm-factory create --base ubuntu --project x-shell
+  vercel-vm-factory doctor
+  npx vercel-vm-factory create
+
+Options:
+  --base NAME          alpine, ubuntu, debian, or a custom image
+  --project NAME       Vercel project name
+  --scope SLUG         Optional Vercel team/user scope slug
+  --from IMAGE         Source image for /app/bin/wsterm
+  --client-id VALUE    GitHub OAuth client id
+  --client-secret VAL  GitHub OAuth client secret
+  --github-userid VAL  Allowed GitHub numeric user id(s)
+  --redirect-url URL   OAuth redirect URL
+  --prod=false         Deploy preview instead of production
+  --skip-link          Reuse existing generated .vercel/project.json
+  --dry-run            Generate Dockerfile.vercel only
+  --doctor             Check Vercel CLI/login and saved defaults
+  --help               Show this help
+`);
+}

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "vercel-vm-factory",
+  "version": "0.1.0",
+  "description": "Create Vercel Container deployments for ws-shell from selectable base images.",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "vercel-vm-factory": "bin/vercel-vm-factory.js"
+  },
+  "files": [
+    "bin/",
+    "deploy-vm.mjs",
+    "README.md"
+  ],
+  "scripts": {
+    "deploy": "node deploy-vm.mjs create",
+    "doctor": "node deploy-vm.mjs doctor",
+    "pack:check": "npm pack --dry-run"
+  }
+}