voop 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,88 @@
+# voop
+
+Publish files to the web instantly with a single command.
+
+![Demo](demo.gif)
+
+## Why?
+
+I use coding agents to create interactive HTML pages instead of static markdown docs. When you can just say "make me a visualization of this data" and get a working HTML page, you need a fast way to share it. This tool lets me go from local file to public URL in one command.
+
+## Alternatives
+
+| Tool | Pros | Cons |
+|------|------|------|
+| [Surge.sh](https://surge.sh) | Free, easy, custom domains | Don't own infra, account required |
+| [Vercel CLI](https://vercel.com) | Great DX, preview URLs | Opinionated, expects frameworks |
+| [Netlify CLI](https://netlify.com) | Feature-rich | Overkill for single files |
+| [Cloudflare Pages](https://pages.cloudflare.com) | Fast CDN | Requires git/project setup |
+| GitHub Pages | Free | Requires repo + git push |
+
+**Why voop?**
+- You own the infrastructure (your R2 bucket, your rules)
+- No account signup/login each time
+- No git workflow or project structure required
+- Files stay up forever (no expiring preview URLs)
+- Single file → single URL, nothing else
+
+```bash
+npx voop index.html
+# https://your-bucket.r2.dev/index-a1b2c3d4.html
+# (copied)
+```
+
+Uses Cloudflare R2 for storage with free egress and global CDN.
+
+## Install
+
+```bash
+npx voop <file>
+```
+
+Or install globally:
+
+```bash
+npm install -g voop
+voop <file>
+```
+
+## Setup
+
+On first run, you'll be guided through an interactive setup wizard:
+
+```bash
+npx voop myfile.html
+# No configuration found. Let's set things up first.
+# → Prompts for credentials...
+# → Tests connection...
+# → Proceeds to upload
+```
+
+Before running, you'll need:
+
+1. **Create R2 Bucket**: [Cloudflare Dashboard](https://dash.cloudflare.com) → R2 → Create bucket → Enable public access
+2. **Create API Token**: R2 → Manage R2 API Tokens → Create with Object Read & Write permissions
+
+The wizard will ask for:
+- Cloudflare Account ID
+- R2 Access Key ID
+- R2 Secret Access Key
+- Bucket name
+- Public URL (e.g., `https://pub-xxx.r2.dev`)
+
+Config is stored at `~/.config/voop/config.json`.
+
+## Usage
+
+```bash
+voop mypage.html      # Upload a file
+voop --setup          # Reconfigure credentials
+voop --test           # Test R2 connection
+voop --help           # Show help
+```
+
+Each file gets a unique URL with a random suffix to avoid conflicts.
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,211 @@
+#!/usr/bin/env node
+import { S3Client, PutObjectCommand, HeadBucketCommand } from "@aws-sdk/client-s3";
+import { lookup } from "mime-types";
+import { existsSync, readFileSync, mkdirSync, writeFileSync } from "fs";
+import { basename, extname } from "path";
+import { randomBytes } from "crypto";
+import { spawn } from "child_process";
+import * as p from "@clack/prompts";
+const CONFIG_PATH = `${process.env.HOME}/.config/voop/config.json`;
+function loadConfig() {
+    if (!existsSync(CONFIG_PATH)) {
+        return null;
+    }
+    try {
+        return JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+function isConfigValid(config) {
+    if (!config)
+        return false;
+    return !!(config.accountId &&
+        config.accessKeyId &&
+        config.secretAccessKey &&
+        config.bucketName &&
+        config.publicUrl);
+}
+function saveConfig(config) {
+    const dir = CONFIG_PATH.replace("/config.json", "");
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+}
+function createS3Client(config) {
+    return new S3Client({
+        region: "auto",
+        endpoint: `https://${config.accountId}.r2.cloudflarestorage.com`,
+        credentials: {
+            accessKeyId: config.accessKeyId,
+            secretAccessKey: config.secretAccessKey,
+        },
+    });
+}
+async function testConnection(config) {
+    const spinner = p.spinner();
+    spinner.start("Testing connection to R2...");
+    try {
+        const client = createS3Client(config);
+        await client.send(new HeadBucketCommand({ Bucket: config.bucketName }));
+        spinner.stop("Connection successful!");
+        return true;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        spinner.stop(`Connection failed: ${message}`);
+        return false;
+    }
+}
+async function setup(existingConfig) {
+    p.intro("voop Setup");
+    p.note(`Before continuing, you'll need:\n` +
+        `1. A Cloudflare account with R2 enabled\n` +
+        `2. An R2 bucket with public access enabled\n` +
+        `3. An R2 API token (create at R2 → Manage R2 API Tokens)\n\n` +
+        `Dashboard: https://dash.cloudflare.com → R2 Object Storage`, "Prerequisites");
+    const result = await p.group({
+        accountId: () => p.text({
+            message: "Cloudflare Account ID",
+            placeholder: "e.g., 1a2b3c4d5e6f7g8h9i0j",
+            initialValue: existingConfig?.accountId || "",
+            validate: (v) => (!v ? "Account ID is required" : undefined),
+        }),
+        accessKeyId: () => p.text({
+            message: "R2 Access Key ID",
+            placeholder: "e.g., abc123def456...",
+            initialValue: existingConfig?.accessKeyId || "",
+            validate: (v) => (!v ? "Access Key ID is required" : undefined),
+        }),
+        secretAccessKey: () => p.password({
+            message: "R2 Secret Access Key",
+            validate: (v) => (!v && !existingConfig?.secretAccessKey ? "Secret Access Key is required" : undefined),
+        }),
+        bucketName: () => p.text({
+            message: "R2 Bucket Name",
+            placeholder: "e.g., my-public-files",
+            initialValue: existingConfig?.bucketName || "",
+            validate: (v) => (!v ? "Bucket name is required" : undefined),
+        }),
+        publicUrl: () => p.text({
+            message: "Public URL (your bucket's public domain)",
+            placeholder: "e.g., https://pub-xxx.r2.dev",
+            initialValue: existingConfig?.publicUrl || "",
+            validate: (v) => {
+                if (!v)
+                    return "Public URL is required";
+                if (!v.startsWith("http"))
+                    return "URL must start with http:// or https://";
+                return undefined;
+            },
+        }),
+    }, {
+        onCancel: () => {
+            p.cancel("Setup cancelled.");
+            return process.exit(0);
+        },
+    });
+    const config = {
+        accountId: result.accountId,
+        accessKeyId: result.accessKeyId,
+        secretAccessKey: result.secretAccessKey || existingConfig?.secretAccessKey || "",
+        bucketName: result.bucketName,
+        publicUrl: result.publicUrl,
+    };
+    saveConfig(config);
+    console.log("");
+    const success = await testConnection(config);
+    if (!success) {
+        p.log.warning("Setup saved but connection test failed. Run 'voop --setup' to reconfigure.");
+    }
+    p.outro(`Config saved to ${CONFIG_PATH}`);
+    return config;
+}
+function copyToClipboard(text) {
+    try {
+        const proc = spawn("pbcopy", [], { stdio: ["pipe", "ignore", "ignore"] });
+        proc.stdin?.write(text);
+        proc.stdin?.end();
+        console.log(`(copied)`);
+    }
+    catch { }
+}
+async function publish(filePath) {
+    let config = loadConfig();
+    if (!isConfigValid(config)) {
+        console.log("No configuration found. Let's set things up first.\n");
+        config = await setup(config);
+        if (!config) {
+            process.exit(1);
+        }
+        console.log("\nProceeding to upload...\n");
+    }
+    if (!existsSync(filePath)) {
+        console.error(`File not found: ${filePath}`);
+        process.exit(1);
+    }
+    const client = createS3Client(config);
+    const fileContent = readFileSync(filePath);
+    const ext = extname(filePath);
+    const baseName = basename(filePath, ext);
+    const shortId = randomBytes(4).toString("hex");
+    const key = `${baseName}-${shortId}${ext}`;
+    const contentType = lookup(filePath) || "application/octet-stream";
+    await client.send(new PutObjectCommand({
+        Bucket: config.bucketName,
+        Key: key,
+        Body: fileContent,
+        ContentType: contentType,
+    }));
+    const publicUrl = config.publicUrl.replace(/\/$/, "");
+    const url = `${publicUrl}/${key}`;
+    console.log(url);
+    copyToClipboard(url);
+}
+const args = process.argv.slice(2);
+if (args.length === 0 || args[0] === "--help" || args[0] === "-h" || args[0] === "help") {
+    console.log(`
+voop - Upload files to the web instantly
+
+USAGE
+  voop <file>      Upload a file and get a public URL
+  voop --setup     Configure or reconfigure credentials
+  voop --test      Test connection to R2
+  voop --help      Show this help
+
+EXAMPLES
+  voop screenshot.png
+  voop document.pdf
+  voop index.html
+
+SETUP
+  On first run, you'll be guided through an interactive setup.
+  Your credentials are stored at: ~/.config/voop/config.json
+
+  To reconfigure at any time, run: voop --setup
+
+REQUIREMENTS
+  - Cloudflare account with R2 Object Storage
+  - R2 bucket with public access enabled
+  - R2 API token (Access Key ID + Secret Access Key)
+
+  Create these at: https://dash.cloudflare.com → R2 Object Storage
+`);
+    process.exit(0);
+}
+if (args[0] === "--setup" || args[0] === "setup") {
+    const existingConfig = loadConfig();
+    await setup(existingConfig);
+}
+else if (args[0] === "--test" || args[0] === "test") {
+    const config = loadConfig();
+    if (!isConfigValid(config)) {
+        console.error("Not configured. Run: voop --setup");
+        process.exit(1);
+    }
+    const success = await testConnection(config);
+    process.exit(success ? 0 : 1);
+}
+else {
+    await publish(args[0]);
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "voop",
+  "version": "0.1.0",
+  "description": "Publish files to the web instantly with a single command using Coudflare R2",
+  "author": "Ye Myat Min",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yemyat/voop"
+  },
+  "keywords": [
+    "cli",
+    "publish",
+    "cloudflare",
+    "r2",
+    "static-hosting"
+  ],
+  "type": "module",
+  "bin": {
+    "voop": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@types/mime-types": "^2.1.4",
+    "typescript": "^5.7.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@aws-sdk/client-s3": "^3.940.0",
+    "@clack/prompts": "^0.11.0",
+    "mime-types": "^3.0.2"
+  }
+}