dist-site 0.1.0

package/bin/dist.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../dist/index.js';

package/dist/index.js

@@ -0,0 +1,584 @@
+// src/commands/deploy.ts
+import { resolve } from "path";
+
+// src/lib/config.ts
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+var CONFIG_DIR = join(homedir(), ".dist");
+var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+async function getConfig() {
+  try {
+    const raw = await readFile(CONFIG_FILE, "utf-8");
+    const config = JSON.parse(raw);
+    if (config.api_token) return config;
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function updateConfig(updates) {
+  let config = {};
+  try {
+    const raw = await readFile(CONFIG_FILE, "utf-8");
+    config = JSON.parse(raw);
+  } catch {
+  }
+  config = { ...config, ...updates };
+  await mkdir(CONFIG_DIR, { recursive: true });
+  await writeFile(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n");
+  return config;
+}
+async function clearConfig() {
+  await mkdir(CONFIG_DIR, { recursive: true });
+  await writeFile(CONFIG_FILE, JSON.stringify({}, null, 2) + "\n");
+}
+
+// src/lib/ignore.ts
+import { readFile as readFile2 } from "fs/promises";
+import { join as join2 } from "path";
+import ignore from "ignore";
+
+// ../shared/dist/constants.js
+var FREE_TIER = {
+  deploys_per_day: 10,
+  deploys_per_month: 50,
+  max_deployment_size_bytes: 50 * 1024 * 1024,
+  // 50 MB
+  max_file_count: 5e3,
+  max_single_file_bytes: 25 * 1024 * 1024,
+  // 25 MB
+  ttl_seconds: 7 * 24 * 60 * 60,
+  // 7 days
+  max_concurrent_deployments: 20
+};
+var PAID_TIER = {
+  deploys_per_day: Infinity,
+  deploys_per_month: Infinity,
+  max_deployment_size_bytes: 200 * 1024 * 1024,
+  // 200 MB
+  max_file_count: 5e4,
+  max_single_file_bytes: 100 * 1024 * 1024,
+  // 100 MB
+  ttl_seconds: 30 * 24 * 60 * 60,
+  // 30 days
+  max_concurrent_deployments: Infinity
+};
+var API_BASE_URL = "https://api.dist.site";
+var BUILT_IN_IGNORES = [
+  "node_modules",
+  ".git",
+  ".DS_Store",
+  "Thumbs.db",
+  ".env",
+  ".env.*",
+  "*.log",
+  ".wrangler",
+  ".cache",
+  ".next",
+  ".nuxt",
+  ".svelte-kit"
+];
+
+// src/lib/ignore.ts
+async function createIgnoreFilter(dir) {
+  const ig = ignore();
+  ig.add(BUILT_IN_IGNORES);
+  try {
+    const content = await readFile2(join2(dir, ".distignore"), "utf-8");
+    ig.add(content);
+  } catch {
+  }
+  try {
+    const content = await readFile2(join2(dir, ".gitignore"), "utf-8");
+    ig.add(content);
+  } catch {
+  }
+  return ig;
+}
+
+// src/lib/archive.ts
+import { create } from "tar";
+import { stat, readdir } from "fs/promises";
+import { join as join3, relative } from "path";
+async function scanDir(dir, base, ig) {
+  const files = [];
+  let totalSize = 0;
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join3(dir, entry.name);
+    const relativePath = relative(base, fullPath);
+    if (ig.ignores(relativePath)) continue;
+    if (entry.isDirectory()) {
+      if (ig.ignores(relativePath + "/")) continue;
+      const sub = await scanDir(fullPath, base, ig);
+      files.push(...sub.files);
+      totalSize += sub.totalSize;
+    } else if (entry.isFile()) {
+      const fileStat = await stat(fullPath);
+      files.push(relativePath);
+      totalSize += fileStat.size;
+    }
+  }
+  return { files, totalSize };
+}
+async function createArchive(dir, ig) {
+  const { files, totalSize } = await scanDir(dir, dir, ig);
+  if (files.length === 0) {
+    throw new Error("No files to deploy");
+  }
+  if (files.length > FREE_TIER.max_file_count) {
+    throw new Error(
+      `Too many files (${files.length}). Maximum is ${FREE_TIER.max_file_count}.`
+    );
+  }
+  if (!files.includes("index.html") && !files.includes("index.htm")) {
+    throw new Error(
+      "No index.html found in the directory. Create one or run this from a build output directory."
+    );
+  }
+  for (const file of files) {
+    const fileStat = await stat(join3(dir, file));
+    if (fileStat.size > FREE_TIER.max_single_file_bytes) {
+      throw new Error(
+        `File "${file}" is too large (${(fileStat.size / 1024 / 1024).toFixed(1)} MB). Maximum is ${FREE_TIER.max_single_file_bytes / 1024 / 1024} MB.`
+      );
+    }
+  }
+  const tarStream = create({ gzip: true, cwd: dir }, files);
+  const chunks = [];
+  let totalBytes = 0;
+  for await (const chunk of tarStream) {
+    const c = chunk;
+    const buf = new Uint8Array(c.buffer, c.byteOffset, c.byteLength);
+    chunks.push(buf);
+    totalBytes += buf.byteLength;
+  }
+  const buffer = new Uint8Array(totalBytes);
+  let offset = 0;
+  for (const chunk of chunks) {
+    buffer.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  if (buffer.byteLength > FREE_TIER.max_deployment_size_bytes) {
+    throw new Error(
+      `Compressed size (${(buffer.byteLength / 1024 / 1024).toFixed(1)} MB) exceeds limit (${FREE_TIER.max_deployment_size_bytes / 1024 / 1024} MB).`
+    );
+  }
+  return { buffer, files, totalSize };
+}
+
+// src/lib/api.ts
+async function deploy(archive, apiToken) {
+  const response = await fetch(`${API_BASE_URL}/deploy`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/gzip",
+      authorization: `Bearer ${apiToken}`
+    },
+    body: archive.buffer.slice(
+      archive.byteOffset,
+      archive.byteOffset + archive.byteLength
+    )
+  });
+  if (!response.ok) {
+    const error = await response.json();
+    throw new Error(error.error || `Deploy failed (${response.status})`);
+  }
+  return response.json();
+}
+async function deleteDeploy(subdomain, token) {
+  const response = await fetch(`${API_BASE_URL}/deploy/${subdomain}`, {
+    method: "DELETE",
+    headers: {
+      authorization: `Bearer ${token}`
+    }
+  });
+  if (!response.ok) {
+    const error = await response.json();
+    throw new Error(error.error || `Delete failed (${response.status})`);
+  }
+}
+async function sendCode(email) {
+  const response = await fetch(`${API_BASE_URL}/auth/send-code`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ email })
+  });
+  if (!response.ok) {
+    const error = await response.json();
+    throw new Error(error.error || `Failed to send code (${response.status})`);
+  }
+}
+async function verifyCode(email, code) {
+  const response = await fetch(`${API_BASE_URL}/auth/verify`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ email, code })
+  });
+  if (!response.ok) {
+    const error = await response.json();
+    throw new Error(error.error || `Verification failed (${response.status})`);
+  }
+  return response.json();
+}
+async function getMe(apiToken) {
+  const response = await fetch(`${API_BASE_URL}/auth/me`, {
+    headers: { authorization: `Bearer ${apiToken}` }
+  });
+  if (!response.ok) {
+    const error = await response.json();
+    throw new Error(error.error || `Failed to get status (${response.status})`);
+  }
+  return response.json();
+}
+async function createToken(apiToken, name) {
+  const response = await fetch(`${API_BASE_URL}/auth/tokens`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${apiToken}`
+    },
+    body: JSON.stringify({ name })
+  });
+  if (!response.ok) {
+    const error = await response.json();
+    throw new Error(
+      error.error || `Failed to create token (${response.status})`
+    );
+  }
+  return response.json();
+}
+async function listTokens(apiToken) {
+  const response = await fetch(`${API_BASE_URL}/auth/tokens`, {
+    headers: { authorization: `Bearer ${apiToken}` }
+  });
+  if (!response.ok) {
+    const error = await response.json();
+    throw new Error(
+      error.error || `Failed to list tokens (${response.status})`
+    );
+  }
+  return response.json();
+}
+async function revokeToken(apiToken, name) {
+  const response = await fetch(
+    `${API_BASE_URL}/auth/tokens/${encodeURIComponent(name)}`,
+    {
+      method: "DELETE",
+      headers: { authorization: `Bearer ${apiToken}` }
+    }
+  );
+  if (!response.ok) {
+    const error = await response.json();
+    throw new Error(
+      error.error || `Failed to revoke token (${response.status})`
+    );
+  }
+}
+async function logout(apiToken) {
+  const response = await fetch(`${API_BASE_URL}/auth/logout`, {
+    method: "DELETE",
+    headers: { authorization: `Bearer ${apiToken}` }
+  });
+  if (!response.ok) {
+    const error = await response.json();
+    throw new Error(error.error || `Logout failed (${response.status})`);
+  }
+}
+
+// src/commands/deploy.ts
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+}
+function formatDate(iso) {
+  return new Date(iso).toLocaleDateString("en-US", {
+    month: "short",
+    day: "numeric",
+    year: "numeric"
+  });
+}
+async function runDeploy(dir) {
+  const targetDir = resolve(dir || ".");
+  process.stdout.write("\x1B[90m\u25E6 Loading config...\x1B[0m\r");
+  const config = await getConfig();
+  if (!config?.api_token) {
+    process.stdout.write("\x1B[2K\r");
+    console.error(
+      "\x1B[31m\u2717 Not logged in. Run `dist login` to authenticate.\x1B[0m"
+    );
+    process.exit(1);
+  }
+  process.stdout.write("\x1B[90m\u25E6 Scanning files...\x1B[0m\r");
+  const ig = await createIgnoreFilter(targetDir);
+  process.stdout.write("\x1B[90m\u25E6 Creating archive...\x1B[0m\r");
+  const archive = await createArchive(targetDir, ig);
+  process.stdout.write(
+    `\x1B[90m\u25E6 Uploading ${archive.files.length} files (${formatBytes(archive.buffer.byteLength)})...\x1B[0m\r`
+  );
+  let result;
+  try {
+    result = await deploy(archive.buffer, config.api_token);
+  } catch (err) {
+    process.stdout.write("\x1B[2K\r");
+    console.error(`\x1B[31m\u2717 ${err.message}\x1B[0m`);
+    process.exit(1);
+  }
+  process.stdout.write("\x1B[2K\r");
+  console.log(
+    `\x1B[32m\u2713\x1B[0m Deployed ${result.file_count} files (${formatBytes(result.total_size_bytes)})`
+  );
+  console.log();
+  console.log(`  \x1B[36m\x1B[1m${result.url}\x1B[0m`);
+  console.log();
+  console.log(`  Expires: ${formatDate(result.expires_at)} (7 days)`);
+  console.log(`  Admin token: \x1B[33m${result.admin_token}\x1B[0m`);
+  console.log(`  \x1B[90m(save this token to delete the deployment)\x1B[0m`);
+}
+
+// src/commands/delete.ts
+async function runDelete(subdomain, token) {
+  if (!token) {
+    const config = await getConfig();
+    if (!config?.api_token) {
+      console.error(
+        "Usage: dist delete <subdomain> --token <admin-token>\n   or: dist login first, then: dist delete <subdomain>"
+      );
+      process.exit(1);
+    }
+    token = config.api_token;
+  }
+  process.stdout.write("\x1B[90m\u25E6 Deleting deployment...\x1B[0m\r");
+  try {
+    await deleteDeploy(subdomain, token);
+  } catch (err) {
+    process.stdout.write("\x1B[2K\r");
+    console.error(`\x1B[31m\u2717 ${err.message}\x1B[0m`);
+    process.exit(1);
+  }
+  process.stdout.write("\x1B[2K\r");
+  console.log(
+    `\x1B[32m\u2713\x1B[0m Deleted \x1B[36m${subdomain}.dist.site\x1B[0m`
+  );
+}
+
+// src/commands/auth.ts
+import { createInterface } from "readline/promises";
+import { stdin, stdout } from "process";
+function prompt(rl, question) {
+  return rl.question(question);
+}
+async function runSignup() {
+  const rl = createInterface({ input: stdin, output: stdout });
+  try {
+    const email = (await prompt(rl, "  Enter your email: ")).trim();
+    if (!email || !email.includes("@")) {
+      console.error("\x1B[31m\u2717 Invalid email address\x1B[0m");
+      process.exit(1);
+    }
+    process.stdout.write("  Sending verification code...\r");
+    try {
+      await sendCode(email);
+    } catch (err) {
+      process.stdout.write("\x1B[2K\r");
+      console.error(`\x1B[31m\u2717 ${err.message}\x1B[0m`);
+      process.exit(1);
+    }
+    process.stdout.write("\x1B[2K\r");
+    console.log("  \x1B[32m\u2713\x1B[0m Code sent! Check your inbox.");
+    const code = (await prompt(rl, "  Enter code: ")).trim();
+    if (!code) {
+      console.error("\x1B[31m\u2717 No code entered\x1B[0m");
+      process.exit(1);
+    }
+    let result;
+    try {
+      result = await verifyCode(email, code);
+    } catch (err) {
+      console.error(`\x1B[31m\u2717 ${err.message}\x1B[0m`);
+      process.exit(1);
+    }
+    await updateConfig({
+      api_token: result.api_token,
+      user_id: result.user_id
+    });
+    console.log(`  \x1B[32m\u2713\x1B[0m Logged in as \x1B[36m${result.email}\x1B[0m`);
+    console.log("    API token saved to ~/.dist/config.json");
+  } finally {
+    rl.close();
+  }
+}
+async function runLogout() {
+  const config = await getConfig();
+  if (!config?.api_token) {
+    console.log("Not logged in.");
+    return;
+  }
+  process.stdout.write("\x1B[90m\u25E6 Logging out...\x1B[0m\r");
+  try {
+    await logout(config.api_token);
+  } catch {
+  }
+  await clearConfig();
+  process.stdout.write("\x1B[2K\r");
+  console.log("\x1B[32m\u2713\x1B[0m Logged out. Token revoked.");
+}
+
+// src/commands/tokens.ts
+function requireAuth(config) {
+  if (!config?.api_token) {
+    console.error("\x1B[31m\u2717 Not logged in. Run `dist login` first.\x1B[0m");
+    process.exit(1);
+  }
+}
+async function runTokensList() {
+  const config = await getConfig();
+  requireAuth(config);
+  const result = await listTokens(config.api_token);
+  if (result.tokens.length === 0) {
+    console.log("No API tokens.");
+    return;
+  }
+  console.log("\x1B[1mAPI Tokens:\x1B[0m\n");
+  for (const token of result.tokens) {
+    const date = new Date(token.created_at).toLocaleDateString("en-US", {
+      month: "short",
+      day: "numeric",
+      year: "numeric"
+    });
+    console.log(`  \x1B[36m${token.name}\x1B[0m  \x1B[90mcreated ${date}\x1B[0m`);
+  }
+}
+async function runTokensCreate(name) {
+  const config = await getConfig();
+  requireAuth(config);
+  const result = await createToken(config.api_token, name);
+  console.log(`\x1B[32m\u2713\x1B[0m Created token \x1B[36m${result.name}\x1B[0m`);
+  console.log();
+  console.log(`  \x1B[33m${result.api_token}\x1B[0m`);
+  console.log();
+  console.log("  \x1B[90mSave this token \u2014 it won't be shown again.\x1B[0m");
+}
+async function runTokensRevoke(name) {
+  const config = await getConfig();
+  requireAuth(config);
+  await revokeToken(config.api_token, name);
+  console.log(`\x1B[32m\u2713\x1B[0m Revoked token \x1B[36m${name}\x1B[0m`);
+}
+
+// src/commands/status.ts
+async function runStatus() {
+  const config = await getConfig();
+  if (!config?.api_token) {
+    console.error("\x1B[31m\u2717 Not logged in. Run `dist login` first.\x1B[0m");
+    process.exit(1);
+  }
+  process.stdout.write("\x1B[90m\u25E6 Fetching account info...\x1B[0m\r");
+  let me;
+  try {
+    me = await getMe(config.api_token);
+  } catch (err) {
+    process.stdout.write("\x1B[2K\r");
+    console.error(`\x1B[31m\u2717 ${err.message}\x1B[0m`);
+    process.exit(1);
+  }
+  process.stdout.write("\x1B[2K\r");
+  console.log(`\x1B[1mAccount\x1B[0m`);
+  console.log(`  Email: \x1B[36m${me.email}\x1B[0m`);
+  console.log(`  Tier:  ${me.tier}`);
+  console.log(`  ID:    \x1B[90m${me.user_id}\x1B[0m`);
+  console.log();
+  console.log(`\x1B[1mUsage\x1B[0m`);
+  console.log(
+    `  Deploys today:      ${me.usage.deploys_today} / ${me.limits.deploys_per_day}`
+  );
+  console.log(
+    `  Deploys this month: ${me.usage.deploys_this_month} / ${me.limits.deploys_per_month}`
+  );
+  console.log(
+    `  Active deployments: ${me.usage.active_deployments} / ${me.limits.max_concurrent_deployments}`
+  );
+}
+
+// src/index.ts
+var args = process.argv.slice(2);
+var command = args[0];
+async function main() {
+  if (command === "signup" || command === "login") {
+    await runSignup();
+  } else if (command === "logout") {
+    await runLogout();
+  } else if (command === "status" || command === "whoami") {
+    await runStatus();
+  } else if (command === "tokens") {
+    const subcommand = args[1];
+    if (subcommand === "create") {
+      const name = args[2];
+      if (!name) {
+        console.error("Usage: dist tokens create <name>");
+        process.exit(1);
+      }
+      await runTokensCreate(name);
+    } else if (subcommand === "revoke") {
+      const name = args[2];
+      if (!name) {
+        console.error("Usage: dist tokens revoke <name>");
+        process.exit(1);
+      }
+      await runTokensRevoke(name);
+    } else {
+      await runTokensList();
+    }
+  } else if (command === "delete" || command === "rm") {
+    const subdomain = args[1];
+    const tokenFlagIdx = args.indexOf("--token");
+    const token = tokenFlagIdx !== -1 ? args[tokenFlagIdx + 1] : void 0;
+    if (!subdomain) {
+      console.error("Usage: dist delete <subdomain> [--token <admin-token>]");
+      process.exit(1);
+    }
+    await runDelete(subdomain, token);
+  } else if (command === "help" || command === "--help" || command === "-h") {
+    printHelp();
+  } else if (command === "version" || command === "--version" || command === "-v") {
+    console.log("dist-site v0.1.0");
+  } else {
+    const dir = command && !command.startsWith("-") ? command : void 0;
+    await runDeploy(dir);
+  }
+}
+function printHelp() {
+  console.log(`
+\x1B[1mdist-site\x1B[0m \u2014 Deploy static sites to random subdomains
+
+\x1B[1mUsage:\x1B[0m
+  dist                              Deploy current directory
+  dist <dir>                        Deploy specific directory
+  dist login                        Log in with email verification
+  dist logout                       Log out and revoke token
+  dist status                       Show account and usage info
+  dist tokens                       List API tokens
+  dist tokens create <name>         Create a named API token
+  dist tokens revoke <name>         Revoke an API token
+  dist delete <id> [--token <t>]    Delete a deployment
+
+\x1B[1mOptions:\x1B[0m
+  -h, --help     Show this help
+  -v, --version  Show version
+
+\x1B[1mExamples:\x1B[0m
+  $ npx dist-site login
+  $ npx dist-site
+  $ npx dist-site ./build
+  $ npx dist-site delete k7m2x9
+  $ npx dist-site tokens create ci
+
+\x1B[90mhttps://dist.site\x1B[0m
+`);
+}
+main().catch((err) => {
+  console.error(`\x1B[31m\u2717 ${err.message}\x1B[0m`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "dist-site",
+  "version": "0.1.0",
+  "description": "Deploy static sites to random subdomains of dist.site",
+  "type": "module",
+  "bin": {
+    "dist": "./bin/dist.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "bin"
+  ],
+  "keywords": [
+    "deploy",
+    "static-site",
+    "hosting",
+    "preview"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "ignore": "^7.0.5",
+    "tar": "^7.5.7"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "@dist-site/shared": "0.1.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch"
+  }
+}