miinideck 0.1.0

package/README.md

@@ -0,0 +1,60 @@
+# miinideck CLI
+
+Deploy an HTML file, a folder, or a ZIP to a **private, unguessable link** —
+straight from your terminal or your AI coding tool.
+
+```bash
+npx miinideck deploy ./index.html
+npx miinideck deploy ./dist            # a build folder → zipped + deployed
+npx miinideck deploy ./site.zip --keep --password hunter2
+```
+
+You get back one private link (e.g. `https://view.miinideck.com/…`). It's
+no-indexed and unguessable by default, so only the people you send it to can
+open it.
+
+## Setup
+
+1. Create a free account at [miinideck.com](https://www.miinideck.com).
+2. Go to **Settings → API tokens** and create a token.
+3. Make it available to the CLI:
+
+```bash
+export MIINIDECK_TOKEN="mdk_…"
+# or pass --token on each command
+```
+
+## Usage
+
+```
+miinideck deploy <path> [options]
+
+  <path>            an .html file, a .zip bundle, or a folder (zipped for you)
+
+  --token <t>       API token (or set MIINIDECK_TOKEN)
+  --name <title>    title for the link (default: the file / folder name)
+  --password <p>    require a password to open the link
+  --keep            keep the link permanently (default: 7-day self-destruct on
+                    the free tier)
+  --api <url>       API base (default https://www.miinideck.com)
+  --help            show help
+```
+
+The link is printed to **stdout** (so a script or AI tool can capture it);
+progress and hints go to **stderr**.
+
+## Use it from an AI coding tool
+
+Codex, Claude Code, and any terminal agent can run shell commands — so they can
+ship what they just built for you:
+
+> After you build the site, run `npx miinideck deploy ./dist` and give me the link.
+
+## What can it host?
+
+Anything that runs in the browser: a self-contained HTML file, or a built
+static site / app bundled as a folder or ZIP (its CSS, JS, images and assets
+intact). It serves static files — not a backend server.
+
+Per-file size and how long links live depend on your plan; see
+[pricing](https://www.miinideck.com/pricing).

package/index.js

@@ -0,0 +1,337 @@
+#!/usr/bin/env node
+"use strict";
+
+// miinideck CLI (session-31) — deploy an HTML file, a folder, or a ZIP to a
+// private, unguessable link from the terminal or an AI coding tool.
+//
+//   miinideck login                 browser auth (vercel/gh style), no token paste
+//   miinideck deploy <path>         publish → private link (same path re-deploys
+//                                   update the SAME link)
+//   miinideck list                  your deployments, grouped by project
+//   miinideck logout                clear the local token
+//
+// Auth resolves in order: --token  >  MIINIDECK_TOKEN env  >  ~/.miinideck/config.json
+// (written by `login`). stdout carries the link / data; stderr carries progress.
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { spawn } = require("child_process");
+
+const VERSION = require("./package.json").version;
+const DEFAULT_API = (process.env.MIINIDECK_API || "https://www.miinideck.com").replace(/\/+$/, "");
+const CONFIG_DIR = path.join(os.homedir(), ".miinideck");
+const CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
+
+const HELP = `miinideck ${VERSION} — deploy to a private link from your terminal
+
+Usage:
+  miinideck login                    sign in (opens your browser — no token to paste)
+  miinideck deploy <path> [options]  publish a file/folder/zip → a private link
+  miinideck list                     your deployments, grouped by project
+  miinideck logout                   clear the saved sign-in on this machine
+
+Deploy options:
+  --name <title>    title for the link (default: the file / folder name)
+  --password <p>    require a password to open the link
+  --keep            keep the link permanently (free tier: uses your one
+                    always-on slot; default is a 7-day self-destruct)
+  --new             force a brand-new link instead of updating this folder's
+  --token <t>       use a specific API token (else MIINIDECK_TOKEN / saved login)
+  --api <url>       API base (default ${DEFAULT_API})
+
+Re-deploying the SAME path updates the SAME link (the URL doesn't change).
+
+Examples:
+  miinideck login
+  miinideck deploy ./index.html
+  miinideck deploy ./dist                 # a build folder → zipped + deployed
+  miinideck deploy ./dist                 # again → updates the same link
+  miinideck deploy ./site.zip --keep --password hunter2 --new
+`;
+
+function die(msg) {
+  process.stderr.write(`✗ ${msg}\n`);
+  process.exit(1);
+}
+
+function parseArgs(argv) {
+  const out = { _: [], flags: {} };
+  const booleans = new Set(["keep", "new", "help", "version"]);
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a.startsWith("--")) {
+      const key = a.slice(2);
+      out.flags[key] = booleans.has(key) ? true : argv[++i];
+    } else {
+      out._.push(a);
+    }
+  }
+  return out;
+}
+
+// ── config (token + per-path deploy memory) ──────────────────────────────
+function readConfig() {
+  try {
+    return JSON.parse(fs.readFileSync(CONFIG_PATH, "utf8")) || {};
+  } catch {
+    return {};
+  }
+}
+function writeConfig(cfg) {
+  try {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  } catch {
+    /* ignore */
+  }
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2), { mode: 0o600 });
+}
+function resolveToken(flags) {
+  return flags.token || process.env.MIINIDECK_TOKEN || readConfig().token || null;
+}
+function apiBase(flags) {
+  return (flags.api || DEFAULT_API).replace(/\/+$/, "");
+}
+function viewerBaseFrom(api) {
+  if (process.env.MIINIDECK_VIEWER) return process.env.MIINIDECK_VIEWER.replace(/\/+$/, "");
+  return api.replace("://www.", "://view.");
+}
+
+// ── small net helpers ────────────────────────────────────────────────────
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+async function postJson(url, body, token) {
+  const headers = { "Content-Type": "application/json" };
+  if (token) headers.Authorization = `Bearer ${token}`;
+  let res;
+  try {
+    res = await fetch(url, { method: "POST", headers, body: JSON.stringify(body) });
+  } catch (e) {
+    die(`Network error reaching ${url} — ${e && e.message ? e.message : e}`);
+  }
+  let json = null;
+  try {
+    json = await res.json();
+  } catch {
+    /* non-JSON */
+  }
+  return { ok: res.ok, status: res.status, json };
+}
+function openBrowser(url) {
+  try {
+    const isWin = process.platform === "win32";
+    const cmd = process.platform === "darwin" ? "open" : isWin ? "cmd" : "xdg-open";
+    const args = isWin ? ["/c", "start", "", url] : [url];
+    spawn(cmd, args, { stdio: "ignore", detached: true }).unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// ── login (browser authorization) ────────────────────────────────────────
+async function login(args) {
+  const api = apiBase(args.flags);
+  const label = `${os.userInfo().username}@${os.hostname()}`.slice(0, 80);
+
+  const start = await postJson(`${api}/api/v1/cli/auth/start`, { label });
+  if (!start.ok || !start.json || !start.json.device_code) {
+    die((start.json && start.json.error) || "Could not start login.");
+  }
+  const { device_code, verify_url, interval_sec, expires_in_sec } = start.json;
+
+  process.stderr.write(`\nOpening your browser to authorize:\n  ${verify_url}\n\n`);
+  openBrowser(verify_url);
+  process.stderr.write("Waiting for you to click Authorize");
+
+  const deadline = Date.now() + (expires_in_sec || 600) * 1000;
+  const interval = (interval_sec || 3) * 1000;
+  while (Date.now() < deadline) {
+    await sleep(interval);
+    const poll = await postJson(`${api}/api/v1/cli/auth/poll`, { device_code });
+    const st = poll.json && poll.json.status;
+    if (st === "authorized" && poll.json.token) {
+      const cfg = readConfig();
+      cfg.token = poll.json.token;
+      writeConfig(cfg);
+      process.stderr.write("\n✓ Signed in. Saved to ~/.miinideck/config.json\n");
+      return;
+    }
+    if (st === "denied") die("\nAuthorization was denied.");
+    if (st === "expired") die("\nLogin expired. Run `miinideck login` again.");
+    process.stderr.write(".");
+  }
+  die("\nLogin timed out. Run `miinideck login` again.");
+}
+
+function logout() {
+  const cfg = readConfig();
+  delete cfg.token;
+  writeConfig(cfg);
+  process.stderr.write("✓ Signed out on this machine.\n");
+}
+
+// ── list ─────────────────────────────────────────────────────────────────
+async function list(args) {
+  const api = apiBase(args.flags);
+  const token = resolveToken(args.flags);
+  if (!token) die("Not signed in. Run `miinideck login` first.");
+
+  let res;
+  try {
+    res = await fetch(`${api}/api/v1/docs`, { headers: { Authorization: `Bearer ${token}` } });
+  } catch (e) {
+    die(`Network error — ${e && e.message ? e.message : e}`);
+  }
+  if (!res.ok) {
+    const j = await res.json().catch(() => ({}));
+    die(j.error || `Could not list (HTTP ${res.status}).`);
+  }
+  const data = await res.json();
+  if (!data.projects || data.projects.length === 0) {
+    process.stdout.write("No deployments yet. Try:  miinideck deploy ./dist\n");
+    return;
+  }
+  for (const p of data.projects) {
+    process.stdout.write(`\n${p.name}\n`);
+    for (const d of p.docs) {
+      process.stdout.write(`  • ${d.title || "(untitled)"}\n    ${d.url}\n`);
+    }
+  }
+  process.stdout.write("\n");
+}
+
+// ── deploy ─────────────────────────────────────────────────────────────────
+async function zipDirectory(dir) {
+  const JSZip = require("jszip");
+  const zip = new JSZip();
+  const root = path.resolve(dir);
+  const SKIP = new Set(["node_modules", ".git", ".DS_Store", ".next", ".vercel"]);
+  const walk = (d) => {
+    for (const name of fs.readdirSync(d)) {
+      if (SKIP.has(name)) continue;
+      const full = path.join(d, name);
+      const stat = fs.statSync(full);
+      if (stat.isDirectory()) walk(full);
+      else zip.file(path.relative(root, full).split(path.sep).join("/"), fs.readFileSync(full));
+    }
+  };
+  walk(root);
+  return zip.generateAsync({ type: "nodebuffer", compression: "DEFLATE" });
+}
+
+async function readTarget(target) {
+  let stat;
+  try {
+    stat = fs.statSync(target);
+  } catch {
+    die(`Path not found: ${target}`);
+  }
+  const base = path.basename(target.replace(/[/\\]+$/, "")) || "upload";
+  if (stat.isDirectory()) {
+    return { bytes: await zipDirectory(target), fileKind: "zip", contentType: "application/zip", sourceFilename: `${base}.zip` };
+  }
+  const lower = target.toLowerCase();
+  if (lower.endsWith(".zip")) {
+    return { bytes: fs.readFileSync(target), fileKind: "zip", contentType: "application/zip", sourceFilename: base };
+  }
+  if (lower.endsWith(".html") || lower.endsWith(".htm")) {
+    return { bytes: fs.readFileSync(target), fileKind: "html", contentType: "text/html", sourceFilename: base };
+  }
+  die("Unsupported file. Give an .html file, a .zip, or a folder.");
+}
+
+async function deploy(args) {
+  const target = args._[1];
+  if (!target) die("Give a path:  miinideck deploy <path>");
+
+  const token = resolveToken(args.flags);
+  if (!token) die("Not signed in. Run `miinideck login` first (or pass --token).");
+
+  const api = apiBase(args.flags);
+  const viewer = viewerBaseFrom(api);
+  const targetKey = path.resolve(target);
+
+  const cfg = readConfig();
+  cfg.deploys = cfg.deploys || {};
+  const knownDocId = !args.flags.new ? cfg.deploys[targetKey] || null : null;
+
+  const { bytes, fileKind, contentType, sourceFilename } = await readTarget(target);
+  const size = bytes.length;
+  process.stderr.write(
+    `→ ${knownDocId ? "Updating" : "Uploading"} ${sourceFilename} (${(size / 1048576).toFixed(2)} MB)…\n`,
+  );
+
+  // 1. signed URL — try as an update first if we've deployed this path before.
+  let step1 = await postJson(
+    `${api}/api/v1/upload-url`,
+    knownDocId ? { size, fileKind, replace_doc_id: knownDocId } : { size, fileKind },
+    token,
+  );
+  // The remembered doc may have been deleted on the server — fall back to new.
+  if (!step1.ok && knownDocId) {
+    step1 = await postJson(`${api}/api/v1/upload-url`, { size, fileKind }, token);
+  }
+  if (!step1.ok) die((step1.json && step1.json.error) || `Could not start upload (HTTP ${step1.status}).`);
+  const { signedUrl, path: storagePath, slug } = step1.json || {};
+  if (!signedUrl || !storagePath || !slug) die("Malformed server response (upload-url).");
+
+  // 2. PUT raw bytes straight to storage.
+  let put;
+  try {
+    put = await fetch(signedUrl, { method: "PUT", headers: { "Content-Type": contentType }, body: bytes });
+  } catch (e) {
+    die(`Storage upload failed — ${e && e.message ? e.message : e}`);
+  }
+  if (!put.ok) die(`Storage upload failed (HTTP ${put.status}).`);
+
+  // 3. finalize.
+  const finalizeBody = { path: storagePath, slug, fileKind, source_filename: sourceFilename };
+  if (knownDocId && step1.json.slug === slug) finalizeBody.replace_doc_id = knownDocId;
+  if (args.flags.name) finalizeBody.title = String(args.flags.name);
+  if (args.flags.password) finalizeBody.password = String(args.flags.password);
+  if (args.flags.keep) finalizeBody.expiry_preset = "never";
+
+  const step3 = await postJson(`${api}/api/v1/finalize`, finalizeBody, token);
+  if (!step3.ok) die((step3.json && step3.json.error) || `Could not finalize (HTTP ${step3.status}).`);
+
+  // Remember this path → doc for next time.
+  if (step3.json.id) {
+    cfg.deploys[targetKey] = step3.json.id;
+    writeConfig(cfg);
+  }
+
+  const link = `${viewer}/${step3.json.slug}`;
+  if (step3.json.replaced) {
+    process.stderr.write("✓ Updated — same link:\n");
+  } else {
+    if (args.flags.keep && step3.json.always_on === false) {
+      process.stderr.write("  note: always-on slot full — self-destructs in 7 days.\n");
+    } else if (!args.flags.keep) {
+      process.stderr.write("  (self-destructs in 7 days — pass --keep to make it permanent)\n");
+    }
+    process.stderr.write("✓ Private link ready:\n");
+  }
+  process.stdout.write(`${link}\n`);
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.flags.version) {
+    process.stdout.write(`${VERSION}\n`);
+    return;
+  }
+  if (args.flags.help || args._.length === 0) {
+    process.stdout.write(HELP);
+    return;
+  }
+  const cmd = args._[0];
+  if (cmd === "login") return login(args);
+  if (cmd === "logout") return logout();
+  if (cmd === "list" || cmd === "ls") return list(args);
+  if (cmd === "deploy") return deploy(args);
+  die(`Unknown command: ${cmd}\nTry:  miinideck --help`);
+}
+
+main().catch((e) => die(e && e.message ? e.message : String(e)));

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "miinideck",
+  "version": "0.1.0",
+  "description": "Deploy an HTML file, folder, or ZIP to a private, unguessable miinideck link — straight from your terminal or AI coding tool.",
+  "keywords": [
+    "miinideck",
+    "deploy",
+    "html",
+    "static",
+    "private",
+    "share",
+    "cli"
+  ],
+  "homepage": "https://www.miinideck.com",
+  "license": "MIT",
+  "type": "commonjs",
+  "bin": {
+    "miinideck": "index.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "index.js",
+    "README.md"
+  ],
+  "dependencies": {
+    "jszip": "^3.10.1"
+  }
+}