pubblue 0.1.0

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,248 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import { createInterface } from "readline/promises";
+import { Command } from "commander";
+
+// src/lib/api.ts
+var PublishApiClient = class {
+  constructor(baseUrl, apiKey) {
+    this.baseUrl = baseUrl;
+    this.apiKey = apiKey;
+  }
+  async request(path3, options = {}) {
+    const url = new URL(path3, this.baseUrl);
+    const res = await fetch(url, {
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`,
+        ...options.headers
+      }
+    });
+    const data = await res.json();
+    if (!res.ok) {
+      throw new Error(data.error || `Request failed with status ${res.status}`);
+    }
+    return data;
+  }
+  async publish(opts) {
+    return this.request("/api/v1/publish", {
+      method: "POST",
+      body: JSON.stringify(opts)
+    });
+  }
+  async get(slug) {
+    const data = await this.request(`/api/v1/publications?slug=${encodeURIComponent(slug)}`);
+    return data.publication;
+  }
+  async list() {
+    const data = await this.request("/api/v1/publications");
+    return data.publications;
+  }
+  async update(opts) {
+    return this.request("/api/v1/publications", {
+      method: "PATCH",
+      body: JSON.stringify(opts)
+    });
+  }
+  async remove(slug) {
+    await this.request(`/api/v1/publications?slug=${encodeURIComponent(slug)}`, {
+      method: "DELETE"
+    });
+  }
+};
+
+// src/lib/config.ts
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+var DEFAULT_BASE_URL = "https://silent-guanaco-514.convex.site";
+function getConfigDir(homeDir) {
+  const home = homeDir || os.homedir();
+  return path.join(home, ".config", "pubblue");
+}
+function getConfigPath(homeDir) {
+  const dir = getConfigDir(homeDir);
+  fs.mkdirSync(dir, { recursive: true, mode: 448 });
+  try {
+    fs.chmodSync(dir, 448);
+  } catch {
+  }
+  return path.join(dir, "config.json");
+}
+function loadConfig(homeDir) {
+  const configPath = getConfigPath(homeDir);
+  if (!fs.existsSync(configPath)) return null;
+  const raw = fs.readFileSync(configPath, "utf-8");
+  return JSON.parse(raw);
+}
+function saveConfig(config, homeDir) {
+  const configPath = getConfigPath(homeDir);
+  fs.writeFileSync(configPath, `${JSON.stringify({ apiKey: config.apiKey }, null, 2)}
+`, {
+    mode: 384
+  });
+  try {
+    fs.chmodSync(configPath, 384);
+  } catch {
+  }
+}
+function getConfig(homeDir) {
+  const envKey = process.env.PUBBLUE_API_KEY;
+  const envUrl = process.env.PUBBLUE_URL;
+  const baseUrl = envUrl || DEFAULT_BASE_URL;
+  if (envKey) {
+    return { apiKey: envKey, baseUrl };
+  }
+  const saved = loadConfig(homeDir);
+  if (!saved) {
+    throw new Error(
+      "Not configured. Run `pubblue configure` or set PUBBLUE_API_KEY environment variable."
+    );
+  }
+  return {
+    apiKey: saved.apiKey,
+    baseUrl
+  };
+}
+
+// src/index.ts
+var program = new Command();
+function createClient() {
+  const config = getConfig();
+  return new PublishApiClient(config.baseUrl, config.apiKey);
+}
+async function readFromStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf-8").trim();
+}
+function printPublishResult(result) {
+  const verb = result.updated ? "Updated" : "Published";
+  console.log(`${verb}: ${result.url}`);
+}
+function formatVisibility(isPublic) {
+  return isPublic ? "public" : "private";
+}
+async function readApiKeyFromPrompt() {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  try {
+    const answer = await rl.question("Enter API key: ");
+    return answer.trim();
+  } finally {
+    rl.close();
+  }
+}
+async function resolveConfigureApiKey(opts) {
+  if (opts.apiKey && opts.apiKeyStdin) {
+    throw new Error("Use only one of --api-key or --api-key-stdin.");
+  }
+  if (opts.apiKey) {
+    return opts.apiKey.trim();
+  }
+  if (opts.apiKeyStdin) {
+    return readFromStdin();
+  }
+  const envKey = process.env.PUBBLUE_API_KEY?.trim();
+  if (envKey) return envKey;
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    throw new Error(
+      "No TTY available. Provide --api-key, --api-key-stdin, or PUBBLUE_API_KEY for configure."
+    );
+  }
+  return readApiKeyFromPrompt();
+}
+program.name("pubblue").description("Publish static content and get shareable URLs").version("0.1.0");
+program.command("configure").description("Configure the CLI with your API key").option("--api-key <key>", "Your API key (less secure: appears in shell history)").option("--api-key-stdin", "Read API key from stdin").action(async (opts) => {
+  try {
+    const apiKey = await resolveConfigureApiKey(opts);
+    saveConfig({ apiKey });
+    console.log("Configuration saved.");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Failed to configure CLI.";
+    console.error(message);
+    process.exit(1);
+  }
+});
+program.command("publish").description("Publish a file").argument("<file>", "Path to the file to publish").option("--slug <slug>", "Custom slug for the URL").option("--title <title>", "Title for the publication").option("--private", "Make the publication private").action(async (file, opts) => {
+  const client = createClient();
+  const filePath = path2.resolve(file);
+  if (!fs2.existsSync(filePath)) {
+    console.error(`File not found: ${filePath}`);
+    process.exit(1);
+  }
+  const content = fs2.readFileSync(filePath, "utf-8");
+  const filename = path2.basename(filePath);
+  const result = await client.publish({
+    filename,
+    content,
+    title: opts.title,
+    slug: opts.slug,
+    isPublic: !opts.private
+  });
+  printPublishResult(result);
+});
+program.command("publish-content").description("Publish content directly from stdin or argument").requiredOption("--filename <name>", "Filename (determines content type, e.g. page.html)").option("--content <content>", "Content string (if not provided, reads from stdin)").option("--slug <slug>", "Custom slug for the URL").option("--title <title>", "Title for the publication").option("--private", "Make the publication private").action(
+  async (opts) => {
+    const client = createClient();
+    const content = opts.content ?? await readFromStdin();
+    const result = await client.publish({
+      filename: opts.filename,
+      content,
+      title: opts.title,
+      slug: opts.slug,
+      isPublic: !opts.private
+    });
+    printPublishResult(result);
+  }
+);
+program.command("get").description("Get details of a publication").argument("<slug>", "Slug of the publication").action(async (slug) => {
+  const client = createClient();
+  const pub = await client.get(slug);
+  console.log(`  Slug:    ${pub.slug}`);
+  console.log(`  File:    ${pub.filename}`);
+  console.log(`  Type:    ${pub.contentType}`);
+  if (pub.title) console.log(`  Title:   ${pub.title}`);
+  console.log(`  Status:  ${formatVisibility(pub.isPublic)}`);
+  console.log(`  Created: ${new Date(pub.createdAt).toLocaleDateString()}`);
+  console.log(`  Updated: ${new Date(pub.updatedAt).toLocaleDateString()}`);
+  console.log(`  Size:    ${pub.content.length} bytes`);
+});
+program.command("update").description("Update publication metadata").argument("<slug>", "Slug of the publication to update").option("--title <title>", "New title").option("--public", "Make the publication public").option("--private", "Make the publication private").action(async (slug, opts) => {
+  const client = createClient();
+  let isPublic;
+  if (opts.public) isPublic = true;
+  else if (opts.private) isPublic = false;
+  const result = await client.update({ slug, title: opts.title, isPublic });
+  console.log(`Updated: ${result.slug}`);
+  if (result.title) console.log(`  Title:  ${result.title}`);
+  console.log(`  Status: ${formatVisibility(result.isPublic)}`);
+});
+program.command("list").description("List your publications").action(async () => {
+  const client = createClient();
+  const pubs = await client.list();
+  if (pubs.length === 0) {
+    console.log("No publications.");
+    return;
+  }
+  for (const pub of pubs) {
+    const date = new Date(pub.createdAt).toLocaleDateString();
+    console.log(
+      `  ${pub.slug}  ${pub.filename}  [${pub.contentType}]  ${formatVisibility(pub.isPublic)}  ${date}`
+    );
+  }
+});
+program.command("delete").description("Delete a publication").argument("<slug>", "Slug of the publication to delete").action(async (slug) => {
+  const client = createClient();
+  await client.remove(slug);
+  console.log(`Deleted: ${slug}`);
+});
+program.parse();

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "pubblue",
+  "version": "0.1.0",
+  "description": "CLI tool for publishing static content via pub.blue",
+  "type": "module",
+  "bin": {
+    "pubblue": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts --format esm --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "tsc --noEmit"
+  },
+  "dependencies": {
+    "commander": "^13.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "22.10.2",
+    "tsup": "^8.3.6",
+    "typescript": "^5.7.2",
+    "vitest": "^3.0.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "esbuild"
+    ]
+  }
+}