@blankdotpage/cli 0.1.0

package/README.md

@@ -0,0 +1,40 @@
+# @blankdotpage/cli
+
+Simple command-line interface for Blank Page.
+
+## Install
+
+```bash
+npm i -g @blankdotpage/cli
+```
+
+This installs both command aliases:
+
+- `blankpage`
+- `bp`
+
+## Default endpoint
+
+By default, CLI commands target:
+
+- `https://blank.page`
+
+Override target endpoint with either:
+
+- `--app-url https://your-preview.fly.dev`
+- `BLANKPAGE_CLI_APP_URL=https://your-preview.fly.dev`
+- `BLANKPAGE_APP_URL=https://your-preview.fly.dev`
+
+## Commands
+
+```bash
+blankpage login [--app-url <url>] [--no-browser]
+blankpage whoami
+blankpage create <file.md>
+blankpage view <page-id>
+blankpage update <page-id> <file.md>
+blankpage delete <page-id>
+blankpage share <file.md> [--title "..."]
+blankpage share --page-id <page-id> [--title "..."]
+blankpage unshare <link-id-or-url>
+```

package/dist/index.js

@@ -0,0 +1,602 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import fs2 from "node:fs/promises";
+import os2 from "node:os";
+import { spawn } from "node:child_process";
+import { URL } from "node:url";
+
+// src/lib/args.ts
+function parseArgs(argv) {
+  const booleanFlags = /* @__PURE__ */ new Set(["json", "no-browser", "help", "h"]);
+  let command = null;
+  const positionals = [];
+  const flags = {};
+  for (let i = 0; i < argv.length; i++) {
+    const token = argv[i];
+    if (token.startsWith("--")) {
+      const key = token.slice(2);
+      const next = argv[i + 1];
+      if (!booleanFlags.has(key) && next && !next.startsWith("--")) {
+        flags[key] = next;
+        i++;
+      } else {
+        flags[key] = true;
+      }
+      continue;
+    }
+    if (!command) {
+      command = token;
+      continue;
+    }
+    positionals.push(token);
+  }
+  return { command, positionals, flags };
+}
+function stringFlag(flags, key) {
+  const value = flags[key];
+  return typeof value === "string" ? value : void 0;
+}
+function booleanFlag(flags, key) {
+  return flags[key] === true;
+}
+
+// src/lib/config.ts
+import os from "node:os";
+import path from "node:path";
+import fs from "node:fs/promises";
+function resolveConfigPath() {
+  if (process.env.BLANKPAGE_CLI_CONFIG_PATH) {
+    return process.env.BLANKPAGE_CLI_CONFIG_PATH;
+  }
+  return path.join(os.homedir(), ".blankpage", "cli.json");
+}
+async function loadConfig() {
+  const configPath = resolveConfigPath();
+  try {
+    const raw = await fs.readFile(configPath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+async function saveConfig(config) {
+  const configPath = resolveConfigPath();
+  await fs.mkdir(path.dirname(configPath), { recursive: true });
+  await fs.writeFile(configPath, JSON.stringify(config, null, 2), "utf8");
+}
+
+// src/lib/http.ts
+var ApiError = class extends Error {
+  status;
+  body;
+  constructor({
+    status,
+    body,
+    message
+  }) {
+    super(message);
+    this.status = status;
+    this.body = body;
+  }
+};
+function buildUrl(appUrl, endpoint) {
+  if (endpoint.startsWith("http://") || endpoint.startsWith("https://")) {
+    return endpoint;
+  }
+  const base = appUrl.endsWith("/") ? appUrl.slice(0, -1) : appUrl;
+  const path2 = endpoint.startsWith("/") ? endpoint : `/${endpoint}`;
+  return `${base}${path2}`;
+}
+async function parseBody(response) {
+  const contentType = response.headers.get("content-type") ?? "";
+  if (contentType.includes("application/json")) {
+    return response.json();
+  }
+  return response.text();
+}
+var ApiClient = class {
+  appUrl;
+  token;
+  constructor({ appUrl, token }) {
+    this.appUrl = appUrl;
+    this.token = token;
+  }
+  async request({
+    method,
+    endpoint,
+    body
+  }) {
+    const response = await fetch(buildUrl(this.appUrl, endpoint), {
+      method,
+      headers: {
+        ...this.token ? { Authorization: `Bearer ${this.token}` } : {},
+        ...body ? { "Content-Type": "application/json" } : {}
+      },
+      body: body ? JSON.stringify(body) : void 0
+    });
+    const parsed = await parseBody(response);
+    if (!response.ok) {
+      const fallback = parsed && typeof parsed === "object" && "error" in parsed ? String(parsed.error) : `Request failed with status ${response.status}`;
+      throw new ApiError({
+        status: response.status,
+        body: parsed,
+        message: fallback
+      });
+    }
+    return parsed;
+  }
+  get(endpoint) {
+    return this.request({ method: "GET", endpoint });
+  }
+  post(endpoint, body) {
+    return this.request({ method: "POST", endpoint, body });
+  }
+  delete(endpoint) {
+    return this.request({ method: "DELETE", endpoint });
+  }
+};
+
+// src/lib/output.ts
+function printJson(payload) {
+  process.stdout.write(`${JSON.stringify(payload)}
+`);
+}
+function printText(message) {
+  process.stdout.write(`${message}
+`);
+}
+function printError(message) {
+  process.stderr.write(`${message}
+`);
+}
+
+// src/lib/state.ts
+import { randomBytes } from "node:crypto";
+async function fetchRemoteState(client) {
+  const response = await client.get("/api/sync?lastUpdatedAt=0");
+  if ("status" in response) {
+    if (response.status !== "success") {
+      throw new Error(`Unexpected sync response status: ${response.status}`);
+    }
+    if (response.state === null) {
+      return {
+        version: 2,
+        lastUpdatedAt: 0,
+        pages: []
+      };
+    }
+    return response.state;
+  }
+  if (response.state === null) {
+    return {
+      version: 2,
+      lastUpdatedAt: 0,
+      pages: []
+    };
+  }
+  return response.state;
+}
+async function pushRemoteState(client, state) {
+  const response = await client.post("/api/sync", { state });
+  if (response.status !== "success") {
+    throw new Error("User mismatch while syncing state");
+  }
+}
+function generatePageId() {
+  const alphabet = "0123456789abc";
+  const bytes = randomBytes(10);
+  let id = "";
+  for (let i = 0; i < bytes.length; i++) {
+    id += alphabet[bytes[i] % alphabet.length];
+  }
+  return id;
+}
+
+// src/index.ts
+function getDefaultAppUrl() {
+  return process.env.BLANKPAGE_CLI_APP_URL || process.env.BLANKPAGE_APP_URL || "https://blank.page";
+}
+function resolveAppUrl({
+  appUrlFlag,
+  configAppUrl
+}) {
+  return appUrlFlag || configAppUrl || getDefaultAppUrl();
+}
+function requireToken(token) {
+  if (!token) {
+    throw new Error("Not logged in. Run `blankpage login` first.");
+  }
+  return token;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function maybeOpenBrowser(url) {
+  const platform = process.platform;
+  if (platform === "darwin") {
+    spawn("open", [url], { stdio: "ignore", detached: true }).unref();
+    return;
+  }
+  if (platform === "linux") {
+    spawn("xdg-open", [url], { stdio: "ignore", detached: true }).unref();
+    return;
+  }
+  if (platform === "win32") {
+    spawn("cmd", ["/c", "start", "", url], {
+      stdio: "ignore",
+      detached: true
+    }).unref();
+  }
+}
+function output(json, payload, text) {
+  if (json) {
+    printJson(payload);
+    return;
+  }
+  if (text) {
+    printText(text);
+    return;
+  }
+  printText(String(payload));
+}
+async function readMarkdownFile(filePath) {
+  return fs2.readFile(filePath, "utf8");
+}
+function findPageOrThrow(state, pageId) {
+  const page = state.pages.find((entry) => entry.id === pageId);
+  if (!page) {
+    throw new Error(`Page not found: ${pageId}`);
+  }
+  return page;
+}
+async function commandLogin(ctx) {
+  const noBrowser = booleanFlag(ctx.flags, "no-browser");
+  const timeoutSeconds = Number(
+    stringFlag(ctx.flags, "timeout-seconds") ?? "300"
+  );
+  const clientName = stringFlag(ctx.flags, "client-name") ?? `blankpage-cli@${os2.hostname()}`;
+  const client = new ApiClient({ appUrl: ctx.appUrl });
+  const started = await client.post("/api/cli/auth/start", {
+    clientName
+  });
+  output(
+    ctx.json,
+    {
+      event: "login_started",
+      authorizeUrl: started.authorizeUrl,
+      challengeId: started.challengeId,
+      challengeSecret: started.challengeSecret
+    },
+    `Open this URL to authorize: ${started.authorizeUrl}`
+  );
+  if (!noBrowser) {
+    maybeOpenBrowser(started.authorizeUrl);
+  }
+  const deadline = Date.now() + timeoutSeconds * 1e3;
+  while (Date.now() < deadline) {
+    try {
+      const poll = await client.post(`/api/cli/auth/poll/${started.challengeId}`, {
+        challengeSecret: started.challengeSecret,
+        tokenName: clientName
+      });
+      if (poll.status === "pending") {
+        await sleep(started.pollIntervalMs);
+        continue;
+      }
+      await saveConfig({
+        appUrl: ctx.appUrl,
+        token: poll.token,
+        tokenExpiresAt: poll.expiresAt
+      });
+      output(
+        ctx.json,
+        {
+          event: "login_success",
+          tokenExpiresAt: poll.expiresAt
+        },
+        "Login successful. CLI token saved."
+      );
+      return;
+    } catch (error) {
+      if (error instanceof ApiError) {
+        const status = error.body && typeof error.body === "object" && "status" in error.body && typeof error.body.status === "string" ? error.body.status : void 0;
+        if (status === "pending") {
+          await sleep(started.pollIntervalMs);
+          continue;
+        }
+        if (status === "consumed") {
+          throw new Error(
+            "This challenge was already consumed. Run `blankpage login` again."
+          );
+        }
+        if (status === "expired") {
+          throw new Error(
+            "Login challenge expired. Run `blankpage login` again."
+          );
+        }
+        if (status === "invalid") {
+          throw new Error(
+            "Invalid login challenge. Run `blankpage login` again."
+          );
+        }
+      }
+      throw error;
+    }
+  }
+  throw new Error("Login timed out before authorization was completed.");
+}
+async function commandWhoAmI(ctx) {
+  const config = await loadConfig();
+  const token = requireToken(config.token);
+  const client = new ApiClient({ appUrl: ctx.appUrl, token });
+  const whoami = await client.get("/api/cli/whoami");
+  output(
+    ctx.json,
+    whoami,
+    `${whoami.email}${whoami.handle ? ` (@${whoami.handle})` : ""}`
+  );
+}
+async function commandCreate(ctx) {
+  const filePath = ctx.positionals[0];
+  if (!filePath) {
+    throw new Error("Usage: blankpage create <markdown-file>");
+  }
+  const config = await loadConfig();
+  const token = requireToken(config.token);
+  const client = new ApiClient({ appUrl: ctx.appUrl, token });
+  const content = await readMarkdownFile(filePath);
+  const state = await fetchRemoteState(client);
+  const now = Date.now();
+  const pageId = generatePageId();
+  state.pages.push({
+    id: pageId,
+    title: null,
+    content,
+    lastUpdatedAt: now
+  });
+  state.lastUpdatedAt = now;
+  state.version = state.version || 2;
+  await pushRemoteState(client, state);
+  output(
+    ctx.json,
+    { event: "create_success", pageId },
+    `Created page: ${pageId}`
+  );
+}
+async function commandView(ctx) {
+  const pageId = ctx.positionals[0];
+  if (!pageId) {
+    throw new Error("Usage: blankpage view <page-id>");
+  }
+  const config = await loadConfig();
+  const token = requireToken(config.token);
+  const client = new ApiClient({ appUrl: ctx.appUrl, token });
+  const state = await fetchRemoteState(client);
+  const page = findPageOrThrow(state, pageId);
+  if (ctx.json) {
+    output(ctx.json, {
+      pageId: page.id,
+      title: page.title,
+      content: page.content
+    });
+    return;
+  }
+  printText(page.content);
+}
+async function commandUpdate(ctx) {
+  const pageId = ctx.positionals[0];
+  const filePath = ctx.positionals[1];
+  if (!pageId || !filePath) {
+    throw new Error("Usage: blankpage update <page-id> <markdown-file>");
+  }
+  const config = await loadConfig();
+  const token = requireToken(config.token);
+  const client = new ApiClient({ appUrl: ctx.appUrl, token });
+  const content = await readMarkdownFile(filePath);
+  const state = await fetchRemoteState(client);
+  const page = findPageOrThrow(state, pageId);
+  const now = Date.now();
+  page.content = content;
+  page.lastUpdatedAt = now;
+  state.lastUpdatedAt = now;
+  await pushRemoteState(client, state);
+  output(
+    ctx.json,
+    { event: "update_success", pageId: page.id },
+    `Updated page: ${page.id}`
+  );
+}
+async function commandDelete(ctx) {
+  const pageId = ctx.positionals[0];
+  if (!pageId) {
+    throw new Error("Usage: blankpage delete <page-id>");
+  }
+  const config = await loadConfig();
+  const token = requireToken(config.token);
+  const client = new ApiClient({ appUrl: ctx.appUrl, token });
+  const state = await fetchRemoteState(client);
+  const before = state.pages.length;
+  state.pages = state.pages.filter((page) => page.id !== pageId);
+  if (state.pages.length === before) {
+    throw new Error(`Page not found: ${pageId}`);
+  }
+  state.lastUpdatedAt = Date.now();
+  await pushRemoteState(client, state);
+  output(
+    ctx.json,
+    { event: "delete_success", pageId },
+    `Deleted page: ${pageId}`
+  );
+}
+async function commandShare(ctx) {
+  const pageIdFlag = stringFlag(ctx.flags, "page-id");
+  const title = stringFlag(ctx.flags, "title");
+  const config = await loadConfig();
+  const token = requireToken(config.token);
+  const client = new ApiClient({ appUrl: ctx.appUrl, token });
+  const state = await fetchRemoteState(client);
+  let pageId;
+  let content;
+  if (pageIdFlag) {
+    if (ctx.positionals.length > 0) {
+      throw new Error(
+        "When --page-id is used, do not pass a markdown file path."
+      );
+    }
+    const page = findPageOrThrow(state, pageIdFlag);
+    pageId = page.id;
+    content = page.content;
+  } else {
+    const filePath = ctx.positionals[0];
+    if (!filePath) {
+      throw new Error(
+        "Usage: blankpage share <markdown-file> [--title ...] or blankpage share --page-id <id>"
+      );
+    }
+    content = await readMarkdownFile(filePath);
+    pageId = generatePageId();
+    const now = Date.now();
+    state.pages.push({
+      id: pageId,
+      title: null,
+      content,
+      lastUpdatedAt: now
+    });
+    state.lastUpdatedAt = now;
+    await pushRemoteState(client, state);
+  }
+  const link = await client.post("/api/link", {
+    content,
+    title,
+    pageId,
+    linkId: null
+  });
+  const whoami = await client.get("/api/cli/whoami");
+  const url = whoami.handle && link.slug ? `${ctx.appUrl}/@${whoami.handle}/${link.slug}` : `${ctx.appUrl}/@${link.linkId}`;
+  output(
+    ctx.json,
+    {
+      event: "share_success",
+      pageId: link.pageId,
+      linkId: link.linkId,
+      url
+    },
+    `Shared! Here's your link: ${url}
+Use \`blankpage unshare <id-or-url>\` to delete it.`
+  );
+}
+function parseShareInput(input) {
+  try {
+    const parsed = new URL(input);
+    const segments = parsed.pathname.split("/").filter(Boolean);
+    if (segments.length === 1 && segments[0].startsWith("@")) {
+      return { linkId: segments[0].slice(1) };
+    }
+    if (segments.length === 2 && segments[0].startsWith("@")) {
+      return { slug: segments[1] };
+    }
+  } catch {
+  }
+  if (input.startsWith("@")) {
+    return { linkId: input.slice(1) };
+  }
+  return { linkId: input };
+}
+async function commandUnshare(ctx) {
+  const input = ctx.positionals[0];
+  if (!input) {
+    throw new Error("Usage: blankpage unshare <link-id-or-url>");
+  }
+  const config = await loadConfig();
+  const token = requireToken(config.token);
+  const client = new ApiClient({ appUrl: ctx.appUrl, token });
+  const parsed = parseShareInput(input);
+  let linkId = parsed.linkId;
+  if (!linkId && parsed.slug) {
+    const links = await client.get("/api/shared-links");
+    const found = links.sharedLinks.find((link) => link.slug === parsed.slug);
+    if (!found) {
+      throw new Error(`Shared link not found for slug: ${parsed.slug}`);
+    }
+    linkId = found.id;
+  }
+  if (!linkId) {
+    throw new Error("Unable to resolve shared link id.");
+  }
+  await client.delete(`/api/link/${linkId}`);
+  output(
+    ctx.json,
+    { event: "unshare_success", linkId },
+    `Unshared link: ${linkId}`
+  );
+}
+function printHelp() {
+  printText(`blankpage CLI
+
+Commands:
+  blankpage login [--app-url <url>] [--no-browser] [--json]
+  blankpage whoami [--app-url <url>] [--json]
+  blankpage create <markdown-file> [--app-url <url>] [--json]
+  blankpage update <page-id> <markdown-file> [--app-url <url>] [--json]
+  blankpage view <page-id> [--app-url <url>] [--json]
+  blankpage delete <page-id> [--app-url <url>] [--json]
+  blankpage share <markdown-file> [--title "..."] [--app-url <url>] [--json]
+  blankpage share --page-id <page-id> [--title "..."] [--app-url <url>] [--json]
+  blankpage unshare <link-id-or-url> [--app-url <url>] [--json]
+`);
+}
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const config = await loadConfig();
+  const appUrl = resolveAppUrl({
+    appUrlFlag: stringFlag(args.flags, "app-url"),
+    configAppUrl: config.appUrl
+  });
+  const json = booleanFlag(args.flags, "json");
+  const ctx = {
+    appUrl,
+    json,
+    flags: args.flags,
+    positionals: args.positionals
+  };
+  switch (args.command) {
+    case "login":
+      await commandLogin(ctx);
+      return;
+    case "whoami":
+      await commandWhoAmI(ctx);
+      return;
+    case "create":
+      await commandCreate(ctx);
+      return;
+    case "view":
+      await commandView(ctx);
+      return;
+    case "update":
+      await commandUpdate(ctx);
+      return;
+    case "delete":
+      await commandDelete(ctx);
+      return;
+    case "share":
+      await commandShare(ctx);
+      return;
+    case "unshare":
+      await commandUnshare(ctx);
+      return;
+    case "help":
+    case "--help":
+    case "-h":
+    case null:
+      printHelp();
+      return;
+    default:
+      throw new Error(`Unknown command: ${args.command}`);
+  }
+}
+main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  printError(message);
+  process.exitCode = 1;
+});

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@blankdotpage/cli",
+  "version": "0.1.0",
+  "description": "CLI for Blank Page",
+  "type": "module",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "bin": {
+    "blankpage": "./dist/index.js",
+    "bp": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "esbuild src/index.ts --bundle --platform=node --target=node18 --format=esm --outfile=dist/index.js",
+    "prepack": "npm run build",
+    "test": "tsx --test tests/*.test.ts"
+  },
+  "devDependencies": {
+    "esbuild": "^0.25.10"
+  }
+}