weplan 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Albert Ilagan
+
+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,43 @@
+# weplan
+
+Deploy a self-contained HTML file and get back a shareable link — in one command, in under a second. Built for CLI and agent workflows.
+
+```console
+$ npx weplan create report.html
+Deployed uf6vxjhmbz4f (12.3 kB, public)
+
+  https://plan.wecodeph.dev/p/uf6vxjhmbz4f
+```
+
+No account needed to try it: anonymous uploads are public and expire after 12 hours. Sign in (`weplan login`, Google via WorkOS) to keep pages, name them, and make them private.
+
+## Commands
+
+```console
+weplan create <file.html> [--name <name>] [--private] [--allow <emails>]
+weplan update <slug> <file.html>          # replace content, URL stays stable
+weplan access <slug> [--public|--private] [--allow <emails>] [--revoke <emails>]
+weplan list
+weplan delete <slug>
+weplan login | logout | whoami
+weplan status
+```
+
+- `--json` on any command for machine-readable output; errors go to stderr as `{"error": "..."}` with exit code 1.
+- Pass `-` as the file to read HTML from stdin.
+- Private pages are viewable by you and allow-listed emails (they sign in in the browser); scripts can fetch them with `Authorization: Bearer <api key>`.
+
+## Limits (free)
+
+2 MB per page · 100 pages · 25 MB total · 200 uploads/day. Anonymous: 1 MB, 12-hour lifetime, 5 uploads/minute.
+
+## For agents
+
+```markdown
+To share an HTML file as a link, run `npx weplan create <file.html> --json`
+and give the user the `url` from the output. Add `--private --allow <emails>`
+for sensitive content. To revise a shared page without changing its link:
+`npx weplan update <slug> <file.html> --json`.
+```
+
+Zero runtime dependencies. Source and service: <https://github.com/albertilagan/weplan>.

package/dist/index.js

@@ -0,0 +1,487 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { readFileSync as readFileSync2 } from "node:fs";
+import { extname } from "node:path";
+import { parseArgs } from "node:util";
+
+// ../../packages/core/src/index.ts
+var LIMITS = {
+  anonymous: {
+    maxPageBytes: 1 * 1024 * 1024,
+    ttlSeconds: 12 * 60 * 60,
+    createsPerMinute: 5
+  },
+  free: {
+    maxPageBytes: 2 * 1024 * 1024,
+    maxPages: 100,
+    maxTotalBytes: 25 * 1024 * 1024,
+    writesPerDay: 200
+  }
+};
+class WeplanError extends Error {
+  status;
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+    this.name = "WeplanError";
+  }
+}
+
+class WeplanClient {
+  baseUrl;
+  token;
+  fetchFn;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.token = options.token;
+    this.fetchFn = options.fetch ?? fetch;
+  }
+  async create(html, options = {}) {
+    const params = new URLSearchParams;
+    if (options.name)
+      params.set("name", options.name);
+    if (options.visibility)
+      params.set("visibility", options.visibility);
+    if (options.allow?.length)
+      params.set("allow", options.allow.join(","));
+    const query = params.size ? `?${params}` : "";
+    return this.request("POST", `/api/pages${query}`, { html });
+  }
+  async update(slug, html) {
+    return this.request("PUT", `/api/pages/${encodeURIComponent(slug)}`, { html });
+  }
+  async get(slug) {
+    return this.request("GET", `/api/pages/${encodeURIComponent(slug)}`);
+  }
+  async setAccess(slug, update) {
+    return this.request("PATCH", `/api/pages/${encodeURIComponent(slug)}`, {
+      json: update
+    });
+  }
+  async list() {
+    const body = await this.request("GET", "/api/pages");
+    return body.pages;
+  }
+  async delete(slug) {
+    await this.request("DELETE", `/api/pages/${encodeURIComponent(slug)}`);
+  }
+  async health() {
+    return this.request("GET", "/health");
+  }
+  async authConfig() {
+    return this.request("GET", "/auth/config");
+  }
+  async exchange(accessToken) {
+    return this.request("POST", "/auth/exchange", {
+      json: { accessToken }
+    });
+  }
+  async exchangeCode(code) {
+    return this.request("POST", "/auth/exchange", { json: { code } });
+  }
+  async me() {
+    return this.request("GET", "/api/me");
+  }
+  async revokeKey() {
+    await this.request("DELETE", "/api/keys/current");
+  }
+  async request(method, path, body) {
+    const headers = { accept: "application/json" };
+    if (this.token)
+      headers["authorization"] = `Bearer ${this.token}`;
+    let payload;
+    if (body?.html !== undefined) {
+      headers["content-type"] = "text/html; charset=utf-8";
+      payload = body.html;
+    } else if (body?.json !== undefined) {
+      headers["content-type"] = "application/json";
+      payload = JSON.stringify(body.json);
+    }
+    let response;
+    try {
+      response = await this.fetchFn(`${this.baseUrl}${path}`, { method, headers, body: payload });
+    } catch (cause) {
+      throw new WeplanError(`could not reach ${this.baseUrl}: ${cause.message}`, 0);
+    }
+    if (!response.ok) {
+      let message = `${response.status} ${response.statusText}`;
+      try {
+        const parsed = await response.json();
+        if (parsed.error)
+          message = parsed.error;
+      } catch {}
+      throw new WeplanError(message, response.status);
+    }
+    return await response.json();
+  }
+}
+
+// src/config.ts
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+function configPath() {
+  const base = process.env["XDG_CONFIG_HOME"] || join(homedir(), ".config");
+  return join(base, "weplan", "config.json");
+}
+function readConfig() {
+  try {
+    return JSON.parse(readFileSync(configPath(), "utf8"));
+  } catch {
+    return {};
+  }
+}
+function writeConfig(config) {
+  const path = configPath();
+  mkdirSync(dirname(path), { recursive: true, mode: 448 });
+  writeFileSync(path, JSON.stringify(config, null, 2) + `
+`, { mode: 384 });
+}
+function clearConfig() {
+  const path = configPath();
+  if (existsSync(path))
+    unlinkSync(path);
+}
+
+// src/login.ts
+import { randomUUID } from "node:crypto";
+import { createInterface } from "node:readline";
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var describe = (err) => err.message ?? err.error_description ?? err.error;
+async function postForm(url, fields) {
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "content-type": "application/x-www-form-urlencoded", accept: "application/json" },
+    body: new URLSearchParams(fields)
+  });
+  return { ok: response.ok, body: await response.json() };
+}
+async function login(client, log, options = {}) {
+  const config = await client.authConfig();
+  if (!options.paste) {
+    const started = await startDeviceFlow(config);
+    if (started)
+      return deviceLogin(client, config, started, log);
+    log("  Device sign-in isn't available for this service; using the paste-a-code flow instead.");
+  }
+  return pasteLogin(client, config, log);
+}
+async function startDeviceFlow(config) {
+  try {
+    const start = await postForm(config.deviceAuthorizationUrl, {
+      client_id: config.clientId
+    });
+    return start.ok && "device_code" in start.body ? start.body : null;
+  } catch {
+    return null;
+  }
+}
+async function deviceLogin(client, config, device, log) {
+  log("");
+  log(`  Open  ${device.verification_uri_complete}`);
+  log(`  and confirm the code  ${device.user_code}`);
+  log("");
+  log("  Waiting for sign-in…");
+  let intervalMs = (device.interval || 5) * 1000;
+  const deadline = Date.now() + device.expires_in * 1000;
+  while (Date.now() < deadline) {
+    await sleep(intervalMs);
+    const poll = await postForm(config.tokenUrl, {
+      grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+      device_code: device.device_code,
+      client_id: config.clientId
+    });
+    if (poll.ok && "access_token" in poll.body) {
+      const exchange = await client.exchange(poll.body.access_token);
+      return { apiKey: exchange.apiKey, email: exchange.user.email };
+    }
+    const err = poll.body;
+    switch (err.error) {
+      case "authorization_pending":
+        continue;
+      case "slow_down":
+        intervalMs += 1000;
+        continue;
+      case "access_denied":
+        throw new Error("sign-in was denied");
+      case "expired_token":
+        throw new Error("sign-in code expired; run `weplan login` again");
+      default:
+        throw new Error(`sign-in failed: ${describe(err)}`);
+    }
+  }
+  throw new Error("sign-in timed out; run `weplan login` again");
+}
+async function pasteLogin(client, config, log) {
+  const state = randomUUID();
+  const authorize = new URL(config.authorizeUrl);
+  authorize.searchParams.set("response_type", "code");
+  authorize.searchParams.set("client_id", config.clientId);
+  authorize.searchParams.set("redirect_uri", config.cliCallbackUrl);
+  authorize.searchParams.set("provider", "authkit");
+  authorize.searchParams.set("state", state);
+  log("");
+  log(`  Open  ${authorize}`);
+  log("  then paste the code the page shows you.");
+  log("");
+  const pasted = (await prompt("  Code: ")).trim();
+  const separator = pasted.indexOf(".");
+  if (separator === -1 || pasted.slice(0, separator) !== state) {
+    throw new Error("invalid or expired sign-in code — start sign-in again and paste the full code");
+  }
+  const exchange = await client.exchangeCode(pasted.slice(separator + 1));
+  return { apiKey: exchange.apiKey, email: exchange.user.email };
+}
+function prompt(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer);
+    });
+  });
+}
+
+// src/index.ts
+var DEFAULT_URL = "https://plan.wecodeph.dev";
+var VERSION = "0.2.0";
+var HELP = `weplan — deploy a self-contained HTML file, get a shareable link
+
+Usage
+  weplan create <file.html> [--name <name>] [--private] [--allow <emails>]
+  weplan update <slug> <file.html>          Replace a page's content, same URL
+  weplan access <slug> [--public|--private] [--allow <emails>] [--revoke <emails>]
+  weplan list                               List your pages
+  weplan delete <slug>                      Delete a page
+  weplan login [--paste] | logout | whoami  Sign in with your work account (WorkOS)
+  weplan status                             Check the service is reachable
+
+Options
+  --name <name>       Human-readable slug (3-63 chars, a-z 0-9 hyphen); requires login
+  --private           Only you and allow-listed emails can view; requires login
+  --allow <emails>    Comma-separated emails to grant view access (implies --private)
+  --revoke <emails>   Comma-separated emails to remove from the allow list
+  --public            Make the page viewable by anyone with the link
+  --paste             Login: use the paste-a-code flow instead of the device code flow
+  --json              Machine-readable JSON output (for agents)
+  --url <url>         Service URL (default: $WEPLAN_URL, then saved config${DEFAULT_URL ? `, then ${DEFAULT_URL}` : ""})
+  --token <token>     API key (default: $WEPLAN_TOKEN, then saved config from \`weplan login\`)
+  -h, --help          Show this help
+  -v, --version       Show version
+
+Without login, uploads are public and expire after 12 hours. Pass "-" as the file to read stdin.
+`;
+function fail(message, asJson) {
+  process.stderr.write(asJson ? JSON.stringify({ error: message }) + `
+` : `error: ${message}
+`);
+  process.exit(1);
+}
+function readHtml(file, asJson) {
+  if (file === "-")
+    return readFileSync2(0, "utf8");
+  const ext = extname(file).toLowerCase();
+  if (ext !== ".html" && ext !== ".htm") {
+    fail(`expected an .html file, got "${file}" (weplan serves everything as text/html)`, asJson);
+  }
+  try {
+    return readFileSync2(file, "utf8");
+  } catch (cause) {
+    fail(`could not read ${file}: ${cause.message}`, asJson);
+  }
+}
+function formatSize(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 describeAccess(page) {
+  if (page.visibility === "public")
+    return "public";
+  const count = page.allow?.length ?? 0;
+  return `private (you${count ? ` + ${count} allowed` : ""})`;
+}
+function printPage(page, verb, asJson) {
+  if (asJson) {
+    process.stdout.write(JSON.stringify(page) + `
+`);
+    return;
+  }
+  const lines = [`${verb} ${page.slug} (${formatSize(page.size)}, ${describeAccess(page)})`, "", `  ${page.url}`];
+  if (page.allow?.length)
+    lines.push("", `  allowed: ${page.allow.join(", ")}`);
+  if (page.expiresAt) {
+    lines.push("", `  anonymous upload — expires ${page.expiresAt}. Run \`weplan login\` to keep pages.`);
+  }
+  process.stdout.write(lines.join(`
+`) + `
+`);
+}
+function splitEmails(value) {
+  if (!value)
+    return;
+  return value.split(",").map((e) => e.trim()).filter(Boolean);
+}
+async function main() {
+  const { values: flags, positionals } = parseArgs({
+    args: process.argv.slice(2),
+    allowPositionals: true,
+    options: {
+      name: { type: "string" },
+      private: { type: "boolean", default: false },
+      public: { type: "boolean", default: false },
+      allow: { type: "string" },
+      revoke: { type: "string" },
+      paste: { type: "boolean", default: false },
+      json: { type: "boolean", default: false },
+      url: { type: "string" },
+      token: { type: "string" },
+      help: { type: "boolean", short: "h", default: false },
+      version: { type: "boolean", short: "v", default: false }
+    }
+  });
+  const asJson = flags.json;
+  if (flags.version) {
+    process.stdout.write(VERSION + `
+`);
+    return;
+  }
+  const command = positionals[0];
+  if (flags.help || !command) {
+    process.stdout.write(HELP);
+    if (!command && !flags.help)
+      process.exit(1);
+    return;
+  }
+  if (flags.private && flags.public)
+    fail("--private and --public are mutually exclusive", asJson);
+  const saved = readConfig();
+  const baseUrl = flags.url ?? process.env["WEPLAN_URL"] ?? saved.url ?? DEFAULT_URL;
+  if (!baseUrl)
+    fail("no service URL configured: pass --url or set WEPLAN_URL", asJson);
+  const token = flags.token ?? process.env["WEPLAN_TOKEN"] ?? saved.apiKey;
+  const client = new WeplanClient({ baseUrl, token });
+  switch (command) {
+    case "create": {
+      const file = positionals[1];
+      if (!file)
+        fail("usage: weplan create <file.html> [--name <name>] [--private] [--allow <emails>]", asJson);
+      const allow = splitEmails(flags.allow);
+      const page = await client.create(readHtml(file, asJson), {
+        name: flags.name,
+        visibility: flags.private || allow?.length ? "private" : undefined,
+        allow
+      });
+      printPage(page, "Deployed", asJson);
+      return;
+    }
+    case "update": {
+      const [, slug, file] = positionals;
+      if (!slug || !file)
+        fail("usage: weplan update <slug> <file.html>", asJson);
+      printPage(await client.update(slug, readHtml(file, asJson)), "Updated", asJson);
+      return;
+    }
+    case "access": {
+      const slug = positionals[1];
+      if (!slug)
+        fail("usage: weplan access <slug> [--public|--private] [--allow <emails>] [--revoke <emails>]", asJson);
+      const update = {
+        visibility: flags.private ? "private" : flags.public ? "public" : undefined,
+        allow: splitEmails(flags.allow),
+        revoke: splitEmails(flags.revoke)
+      };
+      const changed = update.visibility || update.allow || update.revoke;
+      const page = changed ? await client.setAccess(slug, update) : await client.get(slug);
+      printPage(page, changed ? "Updated access for" : "Page", asJson);
+      return;
+    }
+    case "list": {
+      const pages = await client.list();
+      if (asJson) {
+        process.stdout.write(JSON.stringify({ pages }) + `
+`);
+        return;
+      }
+      if (pages.length === 0) {
+        process.stdout.write(`no pages yet
+`);
+        return;
+      }
+      for (const page of pages) {
+        process.stdout.write(`${page.slug.padEnd(24)} ${formatSize(page.size).padStart(9)}  ${page.visibility.padEnd(7)}  ${page.updatedAt}  ${page.url}
+`);
+      }
+      return;
+    }
+    case "delete": {
+      const slug = positionals[1];
+      if (!slug)
+        fail("usage: weplan delete <slug>", asJson);
+      await client.delete(slug);
+      process.stdout.write(asJson ? JSON.stringify({ deleted: slug }) + `
+` : `Deleted ${slug}
+`);
+      return;
+    }
+    case "login": {
+      const result = await login(client, (line) => process.stderr.write(line + `
+`), { paste: flags.paste });
+      writeConfig({ url: baseUrl, apiKey: result.apiKey, email: result.email });
+      process.stdout.write(asJson ? JSON.stringify({ email: result.email, config: configPath() }) + `
+` : `
+Signed in as ${result.email}. Credentials saved to ${configPath()}
+`);
+      return;
+    }
+    case "logout": {
+      if (saved.apiKey) {
+        try {
+          await new WeplanClient({ baseUrl, token: saved.apiKey }).revokeKey();
+        } catch {}
+      }
+      clearConfig();
+      process.stdout.write(asJson ? JSON.stringify({ loggedOut: true }) + `
+` : `Signed out.
+`);
+      return;
+    }
+    case "whoami": {
+      if (!token)
+        fail("not signed in; run `weplan login`", asJson);
+      const me = await client.me();
+      if (asJson) {
+        process.stdout.write(JSON.stringify(me) + `
+`);
+        return;
+      }
+      const { usage } = me;
+      process.stdout.write(`${me.email || me.id}
+  pages    ${usage.pages}/${usage.limits.maxPages}
+  storage  ${formatSize(usage.bytes)} / ${formatSize(usage.limits.maxTotalBytes)}
+  uploads  ${usage.writesToday}/${usage.limits.writesPerDay} today
+`);
+      return;
+    }
+    case "status": {
+      const health = await client.health();
+      process.stdout.write(asJson ? JSON.stringify(health) + `
+` : `ok — ${baseUrl}
+  login: ${health.loginEnabled ? "enabled" : "not configured"}
+  anonymous uploads: ${health.anonymousUploads ? "enabled (12h expiry)" : "disabled"}
+`);
+      return;
+    }
+    default:
+      fail(`unknown command "${command}" — run weplan --help`, asJson);
+  }
+}
+main().catch((cause) => {
+  const asJson = process.argv.includes("--json");
+  if (cause instanceof WeplanError)
+    fail(cause.message, asJson);
+  fail(cause.message ?? String(cause), asJson);
+});

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "weplan",
+  "version": "0.2.0",
+  "description": "Deploy a self-contained HTML file and get back a shareable link. Built for CLI and agent workflows.",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "weplan": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "keywords": [
+    "cloudflare",
+    "deploy",
+    "html",
+    "share",
+    "agent",
+    "cli"
+  ],
+  "scripts": {
+    "build": "bun build src/index.ts --target=node --outdir=dist --banner '#!/usr/bin/env node'",
+    "typecheck": "tsc --noEmit",
+    "dev": "bun run src/index.ts"
+  },
+  "devDependencies": {
+    "@types/node": "26.4.0",
+    "@weplan/core": "workspace:*",
+    "typescript": "7.0.2"
+  },
+  "homepage": "https://plan.wecodeph.dev",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/albertilagan/weplan.git",
+    "directory": "apps/cli"
+  },
+  "bugs": "https://github.com/albertilagan/weplan/issues"
+}