accelr8 1.0.0 → 2.0.0

package/dist/chunks/server-CG3UEKLP.js

@@ -0,0 +1,270 @@
+#!/usr/bin/env node
+import {
+  CANVAS_H,
+  CANVAS_W,
+  PORT,
+  decode,
+  encode
+} from "./chunk-BVRGM7YI.js";
+
+// src/server.ts
+import { WebSocketServer, WebSocket } from "ws";
+import { randomUUID } from "node:crypto";
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+var MAX_PROJECTS = 500;
+var MAX_MEMBERS = 200;
+var DATA_FILE = join(homedir(), ".accelr8", "server-data.json");
+var projects = /* @__PURE__ */ new Map();
+function load() {
+  if (!existsSync(DATA_FILE)) return;
+  try {
+    const raw = JSON.parse(readFileSync(DATA_FILE, "utf8"));
+    for (const p of raw) projects.set(p.id, p);
+    console.log(`loaded ${projects.size} project(s)`);
+  } catch (e) {
+    console.error("failed to load projects:", e);
+  }
+}
+var saveTimer = null;
+function saveNow() {
+  if (saveTimer) {
+    clearTimeout(saveTimer);
+    saveTimer = null;
+  }
+  try {
+    mkdirSync(dirname(DATA_FILE), { recursive: true });
+    writeFileSync(DATA_FILE, JSON.stringify([...projects.values()], null, 2));
+  } catch (e) {
+    console.error("failed to save projects:", e);
+  }
+}
+function scheduleSave() {
+  if (saveTimer) return;
+  saveTimer = setTimeout(() => {
+    saveTimer = null;
+    saveNow();
+  }, 400);
+}
+var clients = /* @__PURE__ */ new Set();
+function shortCode() {
+  const alphabet = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
+  let code = "";
+  do {
+    code = "";
+    for (let i = 0; i < 6; i++) code += alphabet[Math.floor(Math.random() * alphabet.length)];
+  } while ([...projects.values()].some((p) => p.code === code));
+  return code;
+}
+function onlineIds(projectId) {
+  return [...new Set([...clients].filter((c) => c.projectId === projectId).map((c) => c.id))];
+}
+function summaries() {
+  return [...projects.values()].sort((a, b) => b.createdAt - a.createdAt).map((p) => ({
+    id: p.id,
+    name: p.name,
+    code: p.code,
+    members: p.members.length,
+    online: onlineIds(p.id).length
+  }));
+}
+function roomPeers(projectId, except) {
+  return [...clients].filter((c) => c.projectId === projectId && c !== except);
+}
+function send(c, msg) {
+  if (c.ws.readyState === WebSocket.OPEN) c.ws.send(encode(msg));
+}
+function broadcastProjectList() {
+  const list = summaries();
+  for (const c of clients) send(c, { t: "projects", list });
+}
+function joinRoom(client, project) {
+  leaveRoom(client);
+  client.projectId = project.id;
+  const existing = project.members.find((m) => m.id === client.id);
+  if (!existing) {
+    project.members.push({ id: client.id, name: client.name, color: client.color });
+    scheduleSave();
+  } else if (existing.name !== client.name || existing.color !== client.color) {
+    existing.name = client.name;
+    existing.color = client.color;
+    scheduleSave();
+  }
+  send(client, {
+    t: "joined",
+    project: { id: project.id, name: project.name, code: project.code },
+    grid: project.grid,
+    members: project.members
+  });
+  send(client, { t: "presence", online: onlineIds(project.id) });
+  send(client, { t: "members", members: project.members });
+  for (const c of roomPeers(project.id, client)) {
+    send(c, { t: "members", members: project.members });
+    send(c, { t: "presence", online: onlineIds(project.id) });
+  }
+  broadcastProjectList();
+}
+function leaveRoom(client) {
+  const pid = client.projectId;
+  if (!pid) return;
+  client.projectId = null;
+  const stillHere = [...clients].some((c) => c.id === client.id && c.projectId === pid);
+  for (const c of roomPeers(pid)) {
+    if (!stillHere) send(c, { t: "cursorGone", id: client.id });
+    send(c, { t: "presence", online: onlineIds(pid) });
+  }
+  broadcastProjectList();
+}
+function sanitizeChar(v) {
+  const ch = [...String(v ?? " ")][0] ?? " ";
+  const cp = ch.codePointAt(0) ?? 32;
+  return cp < 32 || cp === 127 ? " " : ch;
+}
+function handleMessage(client, msg) {
+  switch (msg.t) {
+    case "hello": {
+      const u = msg.user || {};
+      client.id = String(u.id || "").slice(0, 40) || "u_anon";
+      client.name = String(u.name || "guest").slice(0, 16);
+      client.color = Number(u.color) || 7;
+      send(client, { t: "welcome", you: { id: client.id, name: client.name, color: client.color } });
+      send(client, { t: "projects", list: summaries() });
+      break;
+    }
+    case "listProjects": {
+      send(client, { t: "projects", list: summaries() });
+      break;
+    }
+    case "createProject": {
+      if (projects.size >= MAX_PROJECTS) {
+        send(client, { t: "joinError", message: "server full: project limit reached" });
+        break;
+      }
+      const name = String(msg.name || "").trim().slice(0, 40) || "untitled";
+      const project = {
+        id: randomUUID(),
+        name,
+        code: shortCode(),
+        createdAt: Date.now(),
+        members: [],
+        grid: {}
+      };
+      projects.set(project.id, project);
+      scheduleSave();
+      joinRoom(client, project);
+      broadcastProjectList();
+      break;
+    }
+    case "joinProject": {
+      const code = String(msg.code || "").trim().toUpperCase();
+      const project = [...projects.values()].find((p) => p.code === code);
+      if (!project) {
+        send(client, { t: "joinError", message: `no project with code ${code}` });
+        break;
+      }
+      if (project.members.length >= MAX_MEMBERS && !project.members.some((m) => m.id === client.id)) {
+        send(client, { t: "joinError", message: "project is full" });
+        break;
+      }
+      joinRoom(client, project);
+      break;
+    }
+    case "leaveProject": {
+      leaveRoom(client);
+      send(client, { t: "projects", list: summaries() });
+      break;
+    }
+    case "cursor": {
+      if (!client.projectId) break;
+      const x = Number(msg.x), y = Number(msg.y);
+      if (!Number.isFinite(x) || !Number.isFinite(y)) break;
+      for (const c of roomPeers(client.projectId, client))
+        send(c, { t: "cursor", id: client.id, x, y });
+      break;
+    }
+    case "paint": {
+      if (!client.projectId) break;
+      const project = projects.get(client.projectId);
+      if (!project) break;
+      const x = Math.floor(Number(msg.x)), y = Math.floor(Number(msg.y));
+      if (!Number.isInteger(x) || !Number.isInteger(y) || x < 0 || y < 0 || x >= CANVAS_W || y >= CANVAS_H) break;
+      const char = sanitizeChar(msg.char);
+      const key = `${x},${y}`;
+      if (char === " ") delete project.grid[key];
+      else project.grid[key] = [char, client.color];
+      scheduleSave();
+      for (const c of roomPeers(client.projectId))
+        send(c, { t: "paint", x, y, char, color: client.color });
+      break;
+    }
+    case "clear": {
+      if (!client.projectId) break;
+      const project = projects.get(client.projectId);
+      if (!project) break;
+      project.grid = {};
+      scheduleSave();
+      for (const c of roomPeers(client.projectId)) send(c, { t: "cleared" });
+      break;
+    }
+  }
+}
+function runServer(port = PORT) {
+  load();
+  const wss = new WebSocketServer({ port });
+  wss.on("connection", (ws) => {
+    const client = { ws, id: "", name: "", color: 7, projectId: null };
+    clients.add(client);
+    ws.on("message", (raw) => {
+      let msg;
+      try {
+        msg = decode(raw.toString());
+      } catch {
+        return;
+      }
+      if (!msg || typeof msg !== "object" || typeof msg.t !== "string") return;
+      try {
+        handleMessage(client, msg);
+      } catch (e) {
+        console.error("bad frame from client:", e instanceof Error ? e.message : e);
+      }
+    });
+    ws.on("close", () => {
+      leaveRoom(client);
+      clients.delete(client);
+    });
+    ws.on("error", () => {
+    });
+  });
+  const alive = /* @__PURE__ */ new WeakMap();
+  wss.on("connection", (ws) => {
+    alive.set(ws, true);
+    ws.on("pong", () => alive.set(ws, true));
+  });
+  setInterval(() => {
+    for (const ws of wss.clients) {
+      if (alive.get(ws) === false) {
+        ws.terminate();
+        continue;
+      }
+      alive.set(ws, false);
+      try {
+        ws.ping();
+      } catch {
+      }
+    }
+  }, 3e4);
+  const stop = () => {
+    saveNow();
+    process.exit(0);
+  };
+  process.on("SIGINT", stop);
+  process.on("SIGTERM", stop);
+  console.log(`accelr8 sync server listening on ws://localhost:${port}`);
+  console.log(`data file: ${DATA_FILE}`);
+  console.log(`share it beyond your machine with:  cloudflared tunnel --url http://localhost:${port}`);
+  return wss;
+}
+export {
+  runServer
+};

package/dist/cli.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+import {
+  DEFAULT_SERVER,
+  PORT,
+  VERSION
+} from "./chunks/chunk-BVRGM7YI.js";
+
+// src/cli.ts
+var HELP = `
+accelr8 v${VERSION} - collaborative ascii canvas in your terminal
+
+USAGE
+  accelr8                      open the app
+  accelr8 join <CODE>          open straight into a project
+  accelr8 serve                run your own sync server
+
+OPTIONS
+  --name <name>                display name (remembered for next time)
+  --server <url>               sync server url
+                               (default: ${DEFAULT_SERVER})
+  --port <port>                port for serve (default: ${PORT})
+  -v, --version                print version
+  -h, --help                   this help
+
+IN THE APP
+  mouse                        click tabs, buttons, project rows, brushes
+  click + drag on canvas       paint    (right-click erases)
+  tab / 1 2 3                  switch tabs
+  q                            quit
+
+Everyone in a project sees everyone else's cursor move live on the canvas.
+`;
+function argVal(args, flag) {
+  const i = args.indexOf(flag);
+  if (i >= 0 && i + 1 < args.length) return args[i + 1];
+  return void 0;
+}
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.includes("-h") || args.includes("--help")) {
+    console.log(HELP);
+    return;
+  }
+  if (args.includes("-v") || args.includes("--version")) {
+    console.log(VERSION);
+    return;
+  }
+  if (args[0] === "serve") {
+    const port = Number(argVal(args, "--port") || PORT);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+      console.error(`invalid port: ${argVal(args, "--port")}`);
+      process.exit(1);
+    }
+    const { runServer } = await import("./chunks/server-CG3UEKLP.js");
+    runServer(port);
+    return;
+  }
+  let joinCode;
+  if (args[0] === "join") {
+    joinCode = args[1];
+    if (!joinCode || joinCode.startsWith("-")) {
+      console.error("usage: accelr8 join <CODE>");
+      process.exit(1);
+    }
+  }
+  if (!process.stdout.isTTY) {
+    console.error("accelr8 is a terminal app and needs an interactive terminal (TTY).");
+    process.exit(1);
+  }
+  const { runClient } = await import("./chunks/client-FMFGODEU.js");
+  runClient({
+    name: argVal(args, "--name"),
+    server: argVal(args, "--server"),
+    joinCode
+  });
+}
+main();

package/package.json

@@ -1,19 +1,54 @@
 {
   "name": "accelr8",
-  "version": "1.0.0",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "keywords": [],
-  "author": "",
+  "version": "2.0.0",
+  "description": "Collaborative ascii canvas in your terminal. Real multiplayer, live cursors, mouse-driven TUI.",
+  "type": "module",
   "license": "ISC",
-  "dependencies": {
-    "reblessed": "^0.2.1"
+  "author": "Pat Santiago",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Patonchain/accelr8-cli.git"
   },
   "bin": {
-    "accelr8": "bin/index.js"
+    "accelr8": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "worker",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "cli",
+    "tui",
+    "ascii",
+    "collaborative",
+    "canvas",
+    "live-cursors",
+    "terminal",
+    "accelr8"
+  ],
+  "scripts": {
+    "build": "node scripts/build.mjs",
+    "dev": "tsx src/cli.ts",
+    "serve": "tsx src/cli.ts serve",
+    "smoketest": "tsx src/smoketest.ts",
+    "rendertest": "tsx src/rendertest.ts",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "terminal-kit": "3.1.2",
+    "ws": "8.18.0"
   },
-  "devDependencies": {},
-  "description": ""
+  "devDependencies": {
+    "@types/node": "22.10.2",
+    "@types/terminal-kit": "2.5.7",
+    "@types/ws": "8.5.13",
+    "esbuild": "0.28.1",
+    "tsx": "4.19.2",
+    "typescript": "5.7.2"
+  }
 }

package/worker/src/worker.ts

@@ -0,0 +1,293 @@
+// accelr8 hosted sync server: Cloudflare Worker + a single Durable Object
+// ("Lobby") that speaks the same JSON protocol as src/server.ts.
+// Uses the WebSocket hibernation API; per-socket state lives in attachments
+// so it survives DO eviction. Each project persists under its own storage key.
+
+export interface Env {
+  LOBBY: DurableObjectNamespace;
+}
+
+type DurableObjectNamespace = any;
+type DurableObjectState = any;
+
+interface Member { id: string; name: string; color: number }
+interface Project {
+  id: string;
+  name: string;
+  code: string;
+  createdAt: number;
+  members: Member[];
+  grid: Record<string, [string, number]>;
+}
+interface Att { id: string; name: string; color: number; projectId: string | null }
+
+const ALPHABET = 'ABCDEFGHJKLMNPQRSTUVWXYZ23456789';
+const MAX_PROJECTS = 500;
+const MAX_MEMBERS = 200;
+const CANVAS_W = 100;
+const CANVAS_H = 30;
+
+/** First code point of the input, or ' ' if empty/control. */
+function sanitizeChar(v: unknown): string {
+  const ch = [...String(v ?? ' ')][0] ?? ' ';
+  const cp = ch.codePointAt(0) ?? 32;
+  return cp < 0x20 || cp === 0x7f ? ' ' : ch;
+}
+
+export default {
+  async fetch(request: Request, env: Env): Promise<Response> {
+    const id = env.LOBBY.idFromName('main');
+    return env.LOBBY.get(id).fetch(request);
+  },
+};
+
+export class Lobby {
+  ctx: DurableObjectState;
+  projects: Map<string, Project> | null = null;
+
+  constructor(ctx: DurableObjectState) {
+    this.ctx = ctx;
+  }
+
+  async ensureLoaded(): Promise<Map<string, Project>> {
+    if (this.projects) return this.projects;
+    const map = new Map<string, Project>();
+    const stored = await this.ctx.storage.list({ prefix: 'project:' });
+    for (const [, v] of stored) {
+      const p = v as Project;
+      map.set(p.id, p);
+    }
+    this.projects = map;
+    return map;
+  }
+
+  saveProject(p: Project) {
+    this.ctx.storage.put(`project:${p.id}`, p);
+  }
+
+  async fetch(request: Request): Promise<Response> {
+    if (request.headers.get('Upgrade')?.toLowerCase() !== 'websocket') {
+      return new Response(
+        'accelr8 sync server. connect with the accelr8 CLI:  npm install -g accelr8\n',
+        { status: 200, headers: { 'content-type': 'text/plain' } },
+      );
+    }
+    const pair = new (globalThis as any).WebSocketPair();
+    const client = pair[0], server = pair[1];
+    this.ctx.acceptWebSocket(server);
+    server.serializeAttachment(null); // no hello yet
+    return new Response(null, { status: 101, webSocket: client } as any);
+  }
+
+  // ---- helpers ----
+  sockets(): any[] {
+    return this.ctx.getWebSockets();
+  }
+  att(ws: any): Att | null {
+    try { return ws.deserializeAttachment(); } catch { return null; }
+  }
+  setAtt(ws: any, a: Att | null) {
+    ws.serializeAttachment(a);
+  }
+  sendTo(ws: any, msg: object) {
+    try { ws.send(JSON.stringify(msg)); } catch {}
+  }
+  peers(projectId: string, except?: any): any[] {
+    return this.sockets().filter((s) => s !== except && this.att(s)?.projectId === projectId);
+  }
+  onlineIds(projectId: string): string[] {
+    // dedupe: the same user id can be connected from several terminals
+    return [...new Set(
+      this.sockets()
+        .map((s) => this.att(s))
+        .filter((a): a is Att => !!a && a.projectId === projectId)
+        .map((a) => a.id),
+    )];
+  }
+  summaries(projects: Map<string, Project>) {
+    return [...projects.values()]
+      .sort((a, b) => b.createdAt - a.createdAt)
+      .map((p) => ({
+        id: p.id,
+        name: p.name,
+        code: p.code,
+        members: p.members.length,
+        online: this.onlineIds(p.id).length,
+      }));
+  }
+  shortCode(projects: Map<string, Project>): string {
+    let code = '';
+    do {
+      code = '';
+      for (let i = 0; i < 6; i++) code += ALPHABET[Math.floor(Math.random() * ALPHABET.length)];
+    } while ([...projects.values()].some((p) => p.code === code));
+    return code;
+  }
+  broadcastProjectList(projects: Map<string, Project>) {
+    const list = this.summaries(projects);
+    for (const s of this.sockets()) {
+      if (this.att(s)) this.sendTo(s, { t: 'projects', list });
+    }
+  }
+
+  joinRoom(ws: any, a: Att, project: Project, projects: Map<string, Project>) {
+    this.leaveRoom(ws, a, projects);
+    a.projectId = project.id;
+    this.setAtt(ws, a);
+
+    const existing = project.members.find((m) => m.id === a.id);
+    if (!existing) {
+      project.members.push({ id: a.id, name: a.name, color: a.color });
+      this.saveProject(project);
+    } else if (existing.name !== a.name || existing.color !== a.color) {
+      existing.name = a.name;
+      existing.color = a.color;
+      this.saveProject(project);
+    }
+
+    this.sendTo(ws, {
+      t: 'joined',
+      project: { id: project.id, name: project.name, code: project.code },
+      grid: project.grid,
+      members: project.members,
+    });
+    this.sendTo(ws, { t: 'presence', online: this.onlineIds(project.id) });
+    this.sendTo(ws, { t: 'members', members: project.members });
+
+    for (const s of this.peers(project.id, ws)) {
+      this.sendTo(s, { t: 'members', members: project.members });
+      this.sendTo(s, { t: 'presence', online: this.onlineIds(project.id) });
+    }
+    this.broadcastProjectList(projects);
+  }
+
+  leaveRoom(ws: any, a: Att, projects: Map<string, Project>) {
+    const pid = a.projectId;
+    if (!pid) return;
+    a.projectId = null;
+    this.setAtt(ws, a);
+    // if the same user id is still in the room from another terminal, keep its cursor
+    const stillHere = this.sockets().some((s) => {
+      const sa = this.att(s);
+      return sa && sa.id === a.id && sa.projectId === pid;
+    });
+    for (const s of this.peers(pid)) {
+      if (!stillHere) this.sendTo(s, { t: 'cursorGone', id: a.id });
+      this.sendTo(s, { t: 'presence', online: this.onlineIds(pid) });
+    }
+    this.broadcastProjectList(projects);
+  }
+
+  async webSocketMessage(ws: any, raw: string | ArrayBuffer) {
+    let msg: any;
+    try {
+      msg = JSON.parse(typeof raw === 'string' ? raw : new TextDecoder().decode(raw));
+    } catch {
+      return;
+    }
+    const projects = await this.ensureLoaded();
+    let a = this.att(ws);
+
+    if (msg.t === 'hello') {
+      const u = msg.user || {};
+      a = {
+        id: String(u.id || '').slice(0, 40) || 'u_anon',
+        name: String(u.name || 'guest').slice(0, 16),
+        color: Number(u.color) || 7,
+        projectId: null,
+      };
+      this.setAtt(ws, a);
+      this.sendTo(ws, { t: 'welcome', you: { id: a.id, name: a.name, color: a.color } });
+      this.sendTo(ws, { t: 'projects', list: this.summaries(projects) });
+      return;
+    }
+    if (!a) return; // must hello first
+
+    switch (msg.t) {
+      case 'listProjects': {
+        this.sendTo(ws, { t: 'projects', list: this.summaries(projects) });
+        break;
+      }
+      case 'createProject': {
+        if (projects.size >= MAX_PROJECTS) {
+          this.sendTo(ws, { t: 'joinError', message: 'server full: project limit reached' });
+          break;
+        }
+        const name = String(msg.name || '').trim().slice(0, 40) || 'untitled';
+        const project: Project = {
+          id: crypto.randomUUID(),
+          name,
+          code: this.shortCode(projects),
+          createdAt: Date.now(),
+          members: [],
+          grid: {},
+        };
+        projects.set(project.id, project);
+        this.saveProject(project);
+        this.joinRoom(ws, a, project, projects);
+        break;
+      }
+      case 'joinProject': {
+        const code = String(msg.code || '').trim().toUpperCase();
+        const project = [...projects.values()].find((p) => p.code === code);
+        if (!project) {
+          this.sendTo(ws, { t: 'joinError', message: `no project with code ${code}` });
+          break;
+        }
+        if (project.members.length >= MAX_MEMBERS && !project.members.some((m) => m.id === a!.id)) {
+          this.sendTo(ws, { t: 'joinError', message: 'project is full' });
+          break;
+        }
+        this.joinRoom(ws, a, project, projects);
+        break;
+      }
+      case 'leaveProject': {
+        this.leaveRoom(ws, a, projects);
+        this.sendTo(ws, { t: 'projects', list: this.summaries(projects) });
+        break;
+      }
+      case 'cursor': {
+        if (!a.projectId) break;
+        const x = Number(msg.x), y = Number(msg.y);
+        if (!Number.isFinite(x) || !Number.isFinite(y)) break;
+        for (const s of this.peers(a.projectId, ws))
+          this.sendTo(s, { t: 'cursor', id: a.id, x, y });
+        break;
+      }
+      case 'paint': {
+        if (!a.projectId) break;
+        const project = projects.get(a.projectId);
+        if (!project) break;
+        const x = Math.floor(Number(msg.x)), y = Math.floor(Number(msg.y));
+        if (!Number.isInteger(x) || !Number.isInteger(y) || x < 0 || y < 0 || x >= CANVAS_W || y >= CANVAS_H) break;
+        const char = sanitizeChar(msg.char);
+        const key = `${x},${y}`;
+        if (char === ' ') delete project.grid[key];
+        else project.grid[key] = [char, a.color];
+        this.saveProject(project);
+        for (const s of this.peers(a.projectId))
+          this.sendTo(s, { t: 'paint', x, y, char, color: a.color });
+        break;
+      }
+      case 'clear': {
+        if (!a.projectId) break;
+        const project = projects.get(a.projectId);
+        if (!project) break;
+        project.grid = {};
+        this.saveProject(project);
+        for (const s of this.peers(a.projectId)) this.sendTo(s, { t: 'cleared' });
+        break;
+      }
+    }
+  }
+
+  async webSocketClose(ws: any) {
+    const projects = await this.ensureLoaded();
+    const a = this.att(ws);
+    if (a) this.leaveRoom(ws, a, projects);
+  }
+
+  async webSocketError(ws: any) {
+    return this.webSocketClose(ws);
+  }
+}