@uetuluk/create-cli 0.0.1

package/README.md

@@ -0,0 +1,68 @@
+# @uetuluk/create-cli
+
+CLI for the [create.ritsdev.top](https://create.ritsdev.top) platform — a small self-hosted teenybase-as-a-service.
+
+Register an account, provision a teenybase instance under your own subdomain, push schema, stream logs.
+
+## Quick start
+
+```sh
+# no install — just use npx
+npx @uetuluk/create-cli register
+npx @uetuluk/create-cli create
+npx @uetuluk/create-cli list
+```
+
+Or install once:
+
+```sh
+npm i -g @uetuluk/create-cli
+teeny register
+teeny create
+```
+
+## Commands
+
+| | |
+|---|---|
+| `teeny register` | create an account |
+| `teeny login` | log in to an existing account |
+| `teeny logout` | forget local credentials |
+| `teeny whoami` | show current user |
+| `teeny create` | provision a new teenybase instance, returns a `<adj>-<animal>-NNNN` subdomain + admin token |
+| `teeny list` | list your instances |
+| `teeny status <name>` | one instance's details |
+| `teeny delete <name>` | tear down an instance (db + bucket + container) |
+| `teeny deploy <name>` | push your `teenybase.config.ts` to an instance |
+| `teeny logs <name>` | stream live container logs |
+
+All commands take `--server <url>` to point at a different platform; defaults to `https://create.ritsdev.top` (or `TEENY_SERVER` env).
+
+## Files
+
+- Account credentials: `~/.config/teenybase-create/credentials.json`
+- Per-instance admin tokens: `~/.config/teenybase-create/instances/<name>.json`
+
+Both are written `0o600`. The admin token for an instance is shown **only once** at create time; if you lose it, delete and recreate the instance.
+
+## Claude Code skill
+
+If you're using Claude Code, install the platform skill so the assistant knows how to drive this CLI:
+
+```sh
+mkdir -p ~/.claude/skills/create-ritsdev
+curl -fsSL https://create.ritsdev.top/skills/create-ritsdev/SKILL.md \
+  > ~/.claude/skills/create-ritsdev/SKILL.md
+```
+
+## What's a teenybase?
+
+[teenybase](https://teenybase.com) is a tiny declarative backend (auth, schema, REST). Upstream targets Cloudflare Workers + D1; this platform runs a Node + Postgres + MinIO port of the same codebase under your own subdomain on `*.create.ritsdev.top`.
+
+## Quotas
+
+5 instances per account. Delete to free a slot.
+
+## Status
+
+Pre-alpha. Don't put production data in it yet.

package/dist/cli.js

@@ -0,0 +1,293 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { cac } from "cac";
+import colors from "picocolors";
+import prompts from "prompts";
+
+// src/api.ts
+var ApiError = class extends Error {
+  constructor(status, message, body) {
+    super(message);
+    this.status = status;
+    this.body = body;
+  }
+};
+async function api(serverUrl2, path, init = {}) {
+  const headers = new Headers(init.headers);
+  if (init.body && !headers.has("content-type")) headers.set("content-type", "application/json");
+  if (init.token) headers.set("authorization", `Bearer ${init.token}`);
+  const r = await fetch(`${serverUrl2}${path}`, { ...init, headers });
+  const text = await r.text();
+  let body = text;
+  try {
+    body = JSON.parse(text);
+  } catch {
+  }
+  if (!r.ok) {
+    const msg = body && typeof body === "object" && (body.error || body.message) || `HTTP ${r.status}`;
+    throw new ApiError(r.status, msg, body);
+  }
+  return body;
+}
+
+// src/store.ts
+import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+var DEFAULT_SERVER_URL = "https://create.ritsdev.top";
+var CONFIG_DIR = process.env.TEENY_CONFIG_DIR || join(homedir(), ".config", "teenybase-create");
+var credentialsPath = () => join(CONFIG_DIR, "credentials.json");
+function loadCredentials() {
+  const p = credentialsPath();
+  if (!existsSync(p)) return null;
+  try {
+    return JSON.parse(readFileSync(p, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function saveCredentials(c) {
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  const p = credentialsPath();
+  writeFileSync(p, JSON.stringify(c, null, 2));
+  try {
+    chmodSync(p, 384);
+  } catch {
+  }
+}
+function deleteCredentials() {
+  const p = credentialsPath();
+  if (!existsSync(p)) return false;
+  rmSync(p);
+  return true;
+}
+var instanceDir = () => join(CONFIG_DIR, "instances");
+var instancePath = (name) => join(instanceDir(), `${name}.json`);
+function saveInstance(c) {
+  mkdirSync(instanceDir(), { recursive: true });
+  const p = instancePath(c.name);
+  writeFileSync(p, JSON.stringify(c, null, 2));
+  try {
+    chmodSync(p, 384);
+  } catch {
+  }
+}
+function loadInstance(name) {
+  const p = instancePath(name);
+  if (!existsSync(p)) return null;
+  try {
+    return JSON.parse(readFileSync(p, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function deleteInstance(name) {
+  const p = instancePath(name);
+  if (existsSync(p)) rmSync(p);
+}
+
+// src/cli.ts
+var cli = cac("teeny");
+cli.option("--server <url>", `[string] platform URL (default: ${DEFAULT_SERVER_URL} or env TEENY_SERVER)`);
+function serverUrl(opts) {
+  return (opts.server || process.env.TEENY_SERVER || DEFAULT_SERVER_URL).replace(/\/+$/, "");
+}
+function requireAuth() {
+  const c = loadCredentials();
+  if (!c) {
+    console.error(colors.red("not logged in. run `teeny login` or `teeny register`"));
+    process.exit(1);
+  }
+  return c;
+}
+function wrap(fn) {
+  return async (...args) => {
+    try {
+      await fn(...args);
+    } catch (e) {
+      if (e instanceof ApiError) {
+        console.error(colors.red(`${e.status} ${e.message}`));
+      } else {
+        console.error(colors.red(e.message));
+      }
+      process.exit(1);
+    }
+  };
+}
+cli.command("register", "create an account on the platform").option("--email <email>", "[string] email").option("--username <username>", "[string] username (default: derived from email)").option("--password <password>", "[string] password (min 8 chars)").action(wrap(async (opts) => {
+  const url = serverUrl(opts);
+  const email = opts.email ?? (await prompts({ type: "text", name: "v", message: "email:", validate: (v) => /@/.test(v) || "must look like an email" })).v;
+  const username = opts.username ?? (await prompts({ type: "text", name: "v", message: "username:", initial: email.split("@")[0].replace(/[^a-zA-Z0-9_-]/g, "_") })).v;
+  const password = opts.password ?? (await prompts({ type: "password", name: "v", message: "password (min 8):", validate: (v) => v.length >= 8 || "min 8 chars" })).v;
+  const r = await api(url, "/auth/sign-up", {
+    method: "POST",
+    body: JSON.stringify({ email, username, name: username, password, passwordConfirm: password })
+  });
+  saveCredentials({
+    serverUrl: url,
+    email,
+    username: r.record.username,
+    userId: r.record.id,
+    token: r.token,
+    refreshToken: r.refresh_token
+  });
+  console.log(colors.green(`registered as ${username} at ${url}`));
+}));
+cli.command("login", "log in to the platform").option("--email <email>", "[string] email").option("--password <password>", "[string] password").action(wrap(async (opts) => {
+  const url = serverUrl(opts);
+  const email = opts.email ?? (await prompts({ type: "text", name: "v", message: "email:" })).v;
+  const password = opts.password ?? (await prompts({ type: "password", name: "v", message: "password:" })).v;
+  const r = await api(url, "/auth/login-password", {
+    method: "POST",
+    body: JSON.stringify({ email, password })
+  });
+  saveCredentials({
+    serverUrl: url,
+    email,
+    username: r.record.username,
+    userId: r.record.id,
+    token: r.token,
+    refreshToken: r.refresh_token
+  });
+  console.log(colors.green(`logged in as ${r.record.username} at ${url}`));
+}));
+cli.command("logout", "forget local credentials").action(wrap(async () => {
+  if (deleteCredentials()) console.log("logged out");
+  else console.log("not logged in");
+}));
+cli.command("whoami", "show current user").action(wrap(async () => {
+  const c = loadCredentials();
+  if (!c) {
+    console.log("not logged in");
+    return;
+  }
+  console.log(`${colors.bold(c.username)} <${c.email}>`);
+  console.log(`server: ${c.serverUrl}`);
+}));
+cli.command("create", "provision a new instance").action(wrap(async (opts) => {
+  const c = requireAuth();
+  const url = opts.server ? serverUrl(opts) : c.serverUrl;
+  const r = await api(url, "/platform/instances", {
+    method: "POST",
+    token: c.token
+  });
+  saveInstance({ name: r.name, url: r.url, adminToken: r.admin_token, serverUrl: url });
+  console.log(colors.green(`created ${colors.bold(r.name)}`));
+  console.log(`  url:   ${r.url}`);
+  console.log(`  admin token saved to local store (only shown once)`);
+}));
+cli.command("list", "list your instances").action(wrap(async (opts) => {
+  const c = requireAuth();
+  const url = opts.server ? serverUrl(opts) : c.serverUrl;
+  const r = await api(url, "/platform/instances", { token: c.token });
+  if (!r.result.length) {
+    console.log("no instances. run `teeny create`");
+    return;
+  }
+  for (const inst of r.result) {
+    console.log(`  ${colors.green(inst.name)}  ${colors.dim(inst.url)}`);
+    console.log(`    created: ${inst.created_at}`);
+  }
+}));
+cli.command("status <name>", "show instance details").action(wrap(async (name, opts) => {
+  const c = requireAuth();
+  const url = opts.server ? serverUrl(opts) : c.serverUrl;
+  const r = await api(url, `/platform/instances/${encodeURIComponent(name)}`, { token: c.token });
+  console.log(colors.bold(r.result.name));
+  console.log(`  url:     ${r.result.url}`);
+  console.log(`  created: ${r.result.created_at}`);
+}));
+cli.command("delete <name>", "tear down an instance").option("-y, --yes", "[boolean] skip confirmation").action(wrap(async (name, opts) => {
+  const c = requireAuth();
+  const url = opts.server ? serverUrl(opts) : c.serverUrl;
+  if (!opts.yes) {
+    const r = await prompts({ type: "confirm", name: "v", message: `delete ${name}? this is permanent`, initial: false });
+    if (!r.v) {
+      console.log("cancelled");
+      return;
+    }
+  }
+  await api(url, `/platform/instances/${encodeURIComponent(name)}`, { method: "DELETE", token: c.token });
+  deleteInstance(name);
+  console.log(colors.green(`deleted ${name}`));
+}));
+cli.command("deploy <name>", "push schema + migrations to your instance").option("--config <file>", "[string] path to teenybase.config.ts (default: ./teenybase.config.ts)").action(wrap(async (name, opts) => {
+  requireAuth();
+  const inst = loadInstance(name);
+  if (!inst) {
+    console.error(colors.red(`no local credentials for instance "${name}". run \`teeny create\` first, or contact whoever provisioned it`));
+    process.exit(1);
+  }
+  const configPath = opts.config ?? "./teenybase.config.ts";
+  let settings;
+  try {
+    const mod = await import(`${process.cwd()}/${configPath.replace(/^\.\//, "")}`);
+    settings = mod.default ?? mod.settings ?? mod;
+  } catch (e) {
+    console.error(colors.red(`failed to load ${configPath}: ${e.message}`));
+    process.exit(1);
+  }
+  await api(inst.url, "/api/v1/setup-db", {
+    method: "POST",
+    token: inst.adminToken,
+    body: JSON.stringify({})
+  });
+  const r = await api(inst.url, "/api/v1/migrations", {
+    method: "POST",
+    token: inst.adminToken,
+    body: JSON.stringify({ migrations: [], settings, lastVersion: null })
+  });
+  console.log(colors.green(`deployed to ${inst.url}`));
+  if (r.applied?.length) console.log(`  applied: ${r.applied.join(", ")}`);
+}));
+cli.command("logs <name>", "stream live logs from an instance").option("--tail <n>", "[number] initial tail (default: 200)").action(wrap(async (name, opts) => {
+  const c = requireAuth();
+  const url = opts.server ? serverUrl(opts) : c.serverUrl;
+  const tail = opts.tail || "200";
+  const res = await fetch(`${url}/platform/instances/${encodeURIComponent(name)}/logs?tail=${tail}`, {
+    headers: { authorization: `Bearer ${c.token}` }
+  });
+  if (!res.ok || !res.body) {
+    console.error(colors.red(`failed to stream: ${res.status}`));
+    process.exit(1);
+  }
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buf = "";
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buf += decoder.decode(value, { stream: true });
+    let idx;
+    while ((idx = buf.indexOf("\n\n")) >= 0) {
+      const frame = buf.slice(0, idx);
+      buf = buf.slice(idx + 2);
+      const lines = frame.split("\n");
+      let event = "message";
+      let data = "";
+      for (const line of lines) {
+        if (line.startsWith("event: ")) event = line.slice(7);
+        else if (line.startsWith("data: ")) data += line.slice(6);
+      }
+      if (event === "log") {
+        try {
+          const { src, line } = JSON.parse(data);
+          const tag = src === "stderr" ? colors.red("err") : colors.dim("out");
+          console.log(`${tag}  ${line}`);
+        } catch {
+          console.log(data);
+        }
+      } else if (event === "end") {
+        console.log(colors.dim("--- container exited ---"));
+        return;
+      } else if (event === "error") {
+        console.error(colors.red(`stream error: ${data}`));
+        return;
+      }
+    }
+  }
+}));
+cli.help();
+cli.version("0.0.1");
+cli.parse();

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@uetuluk/create-cli",
+  "version": "0.0.1",
+  "description": "CLI for the create.ritsdev.top platform — register, provision, and deploy teenybase instances.",
+  "type": "module",
+  "bin": {
+    "teeny": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": ["teenybase", "platform", "cli", "ritsdev"],
+  "author": "uetuluk",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/uetuluk/create-ritsdev-platform.git",
+    "directory": "cli"
+  },
+  "homepage": "https://github.com/uetuluk/create-ritsdev-platform/tree/main/cli#readme",
+  "bugs": {
+    "url": "https://github.com/uetuluk/create-ritsdev-platform/issues"
+  },
+  "scripts": {
+    "build": "esbuild src/cli.ts --bundle --outfile=dist/cli.js --platform=node --format=esm --packages=external --banner:js=\"#!/usr/bin/env node\" && chmod +x dist/cli.js",
+    "check": "tsc -p tsconfig.json --noEmit",
+    "dev": "tsx src/cli.ts",
+    "prepublishOnly": "npm run check && npm run build"
+  },
+  "dependencies": {
+    "cac": "^6.7.14",
+    "picocolors": "^1.1.1",
+    "prompts": "^2.4.2"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@types/prompts": "^2.4.9",
+    "esbuild": "^0.24.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.6.0"
+  }
+}