excalidrop 0.1.2 → 0.1.4

package/src/cli.ts

@@ -1,25 +1,4 @@
 #!/usr/bin/env node
-/**
- * excalidrop — per-project Excalidraw canvas + MCP server setup.
- *
- * Modelled on the `chrome-devtools-mcp` install pattern (`npx -y <pkg>` +
- * `mcpServers` JSON), with one addition: per-project dynamic port selection
- * so multiple checkouts can run their own canvas concurrently.
- *
- * How the dynamic port works:
- *  - `excalidrop init` picks a free port (default scan from 3030) and writes
- *    it to `.excalidrop.json` in the project root.
- *  - `excalidrop mcp` (what the AI agent runs via stdio) resolves that same
- *    file by walking up from cwd, so each project transparently gets its own
- *    canvas URL with nothing hardcoded in the agent config.
- *
- * Commands:
- *  init   pick a port, write .excalidrop.json + .mcp.json, offer agent install
- *  up     start the canvas server on this project's port
- *  mcp    run the MCP stdio server pointed at this project's canvas (for agents)
- *  status show resolved port + canvas health
- *  add    print / run AI-agent install commands
- */
 
 import { spawn, spawnSync } from 'node:child_process';
 import { createConnection } from 'node:net';
@@ -41,11 +20,11 @@ const PORT_SCAN_SIZE = 200;
 interface DropConfig {
   port: number;
   canvasUrl: string;
-  /** Remembered remote canvas (owner/repo) — MCP auto-loads it, agents skip switch_remote. */
+
   remote?: string;
 }
 
-// ─── port utils ──────────────────────────────────────────────────────────────
+
 
 function isPortFree(port: number, host = '127.0.0.1', timeoutMs = 300): Promise<boolean> {
   return new Promise((resolve) => {
@@ -71,7 +50,6 @@ async function findFreePort(preferred?: number, start = DEFAULT_START_PORT): Pro
   for (let port = start; port < start + PORT_SCAN_SIZE; port++) {
     if (await isPortFree(port)) return port;
   }
-  // Fallback: random high port
   for (let i = 0; i < 50; i++) {
     const port = 32000 + Math.floor(Math.random() * 2000);
     if (await isPortFree(port)) return port;
@@ -79,7 +57,7 @@ async function findFreePort(preferred?: number, start = DEFAULT_START_PORT): Pro
   throw new Error('Could not find a free port for the excalidrop canvas server.');
 }
 
-// ─── config discovery ────────────────────────────────────────────────────────
+
 
 function findProjectRoot(cwd: string): string {
   let dir = path.resolve(cwd);
@@ -112,7 +90,7 @@ function findDropConfig(cwd: string): { dir: string; config: DropConfig } | null
           };
         }
       } catch {
-        // corrupt config → ignore, treat as missing
+
       }
     }
     if (dir === root) return null;
@@ -130,7 +108,7 @@ function portFromExpressUrl(url: string | undefined): number | undefined {
   }
 }
 
-/** Resolve this project's canvas port without side effects (used by `mcp`). */
+
 function resolveSavedPort(cwd: string): number {
   const envPort = Number(process.env.EXCALIDROP_PORT);
   if (Number.isFinite(envPort) && envPort > 0) return envPort;
@@ -141,11 +119,10 @@ function resolveSavedPort(cwd: string): number {
   return DEFAULT_START_PORT;
 }
 
-// ─── agent config snippets (chrome-devtools-mcp style) ───────────────────────
+
 
 function mcpServerJson(): Record<string, unknown> {
-  // No hardcoded port: `excalidrop mcp` resolves `.excalidrop.json` at runtime,
-  // so the same snippet works for every project, concurrently.
+
   return {
     mcpServers: {
       excalidrop: {
@@ -216,7 +193,7 @@ function commandExists(cmd: string): boolean {
   return probe.status === 0;
 }
 
-// ─── commands ────────────────────────────────────────────────────────────────
+
 
 function detectSlug(): string {
   try {
@@ -237,17 +214,12 @@ async function cmdInit(args: string[]): Promise<void> {
   const slug = detectSlug();
 
   const port = await findFreePort(preferred);
-  // Preselect this repo as the remote canvas: the MCP auto-loads it, so the
-  // agent never needs switch_remote for its home project (chrome-devtools-mcp
-  // wrapper pattern: in-memory default + persisted startup target — ours
-  // persists in .excalidrop.json so it survives restarts too).
   const config: DropConfig = { port, canvasUrl: `http://127.0.0.1:${port}`, ...(slug ? { remote: slug } : {}) };
   fs.writeFileSync(path.join(root, CONFIG_NAME), JSON.stringify(config, null, 2) + '\n');
   console.log(`\nexcalidrop: canvas port ${port} saved to ${path.join(root, CONFIG_NAME)}`);
   if (slug) console.log(`excalidrop: remote canvas preselected: ${slug} (agent uses it automatically)`);
 
-  // Seed canvas.excalidraw so `npm i -D excalidrop` leaves a visible file
-  // that export_scene/import_scene round-trip through.
+
   const scenePath = path.join(root, 'canvas.excalidraw');
   if (!fs.existsSync(scenePath)) {
     fs.writeFileSync(
@@ -257,7 +229,7 @@ async function cmdInit(args: string[]): Promise<void> {
     console.log(`excalidrop: empty scene written to ${scenePath}`);
   }
 
-  // Merge into .mcp.json (generic MCP clients + Claude Code project scope)
+
   const mcpPath = path.join(root, MCP_JSON);
   let mcp: Record<string, any> = {};
   if (fs.existsSync(mcpPath)) {
@@ -282,7 +254,7 @@ async function cmdInit(args: string[]): Promise<void> {
     return;
   }
 
-  // Guided remote setup: gh auth → publish empty canvas → agent install → login
+
   if (slug) {
     if (!ghAuthed()) {
       console.log('GitHub: not logged in. Run `gh auth login` first (2FA via GitHub), then re-run init.\n');
@@ -308,7 +280,7 @@ async function cmdInit(args: string[]): Promise<void> {
     return;
   }
 
-  // Try the CLIs that exist; fall back to printing snippets.
+
   let installed = false;
   if (commandExists('claude')) {
     const scopeAnswer = await prompt('Claude Code scope? [project/user] (default: project) ');
@@ -343,8 +315,7 @@ async function cmdUp(args: string[]): Promise<void> {
   const root = findProjectRoot(process.cwd());
   const existing = findDropConfig(process.cwd());
 
-  // Reuse the saved port if it's still free (stable URL per project),
-  // otherwise claim a new one so concurrent projects never collide.
+
   let port: number;
   if (preferred) {
     port = await findFreePort(preferred);
@@ -368,7 +339,7 @@ async function cmdUp(args: string[]): Promise<void> {
 }
 
 function cmdMcp(): void {
-  // What the agent runs over stdio. Port resolves per-project at runtime.
+
   const port = resolveSavedPort(process.cwd());
   const canvasUrl = process.env.EXPRESS_SERVER_URL || `http://127.0.0.1:${port}`;
   const child = spawn(process.execPath, [MCP_ENTRY], {
@@ -409,8 +380,7 @@ function cmdRemote(): void {
   child.on('exit', (code) => process.exit(code ?? 0));
 }
 
-/** One-command per-user setup on ANY repo: gh auth → publish viewer → app install link. */
-async function cmdSetup(args: string[] = []): Promise<void> {
+async function cmdSetup(args: string[]): Promise<void> {
   if (args.includes('--help') || args.includes('-h')) {
     console.log('Usage: npx excalidrop setup\n\nChecks `gh auth`, publishes the viewer to this repo\'s gh-pages\n(enabling Pages if needed), then prints the app-install link and next steps.');
     return;
@@ -467,7 +437,6 @@ async function cmdSetup(args: string[] = []): Promise<void> {
   console.log('\nLogin on the page: pill → device code → github.com/login/device (2FA via GitHub).');
 }
 
-/** Terminal GitHub login via device flow (same flow the agent's github_login uses). */
 async function cmdLogin(): Promise<void> {
   const { APP_CLIENT_ID } = await import('./target.js');
   const clientId = process.env.GITHUB_OAUTH_CLIENT_ID || APP_CLIENT_ID;
@@ -510,7 +479,7 @@ Each project gets its own port (scanned free from ${DEFAULT_START_PORT}), so sev
 checkouts can run concurrently. Agent config needs no hardcoded port.`);
 }
 
-// ─── entry ───────────────────────────────────────────────────────────────────
+
 
 async function main(): Promise<void> {
   const [cmd, ...rest] = process.argv.slice(2);

package/src/index.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-// Disable colors to prevent ANSI color codes from breaking JSON parsing
+
 process.env.NODE_DISABLE_COLORS = '1';
 process.env.NO_COLOR = '1';
 
@@ -30,10 +30,10 @@ import {
 } from './types.js';
 import fetch from 'node-fetch';
 
-// Load environment variables
+
 dotenv.config();
 
-// Safe file path validation to prevent path traversal attacks
+
 const ALLOWED_EXPORT_DIR = process.env.EXCALIDRAW_EXPORT_DIR || process.cwd();
 
 function sanitizeFilePath(filePath: string): string {
@@ -48,14 +48,14 @@ function sanitizeFilePath(filePath: string): string {
   return resolved;
 }
 
-// Express server configuration (mutable — switch_canvas repoints it at runtime)
+
 let ACTIVE_CANVAS_URL = process.env.EXPRESS_SERVER_URL || 'http://127.0.0.1:3000';
 function activeCanvasUrl(): string {
   return process.env.EXPRESS_SERVER_URL || ACTIVE_CANVAS_URL;
 }
-const ENABLE_CANVAS_SYNC = process.env.ENABLE_CANVAS_SYNC !== 'false'; // Default to true
+const ENABLE_CANVAS_SYNC = process.env.ENABLE_CANVAS_SYNC !== 'false';
+
 
-// API Response types
 interface ApiResponse {
   success: boolean;
   element?: ServerElement;
@@ -70,7 +70,7 @@ interface SyncResponse {
   elements?: ServerElement[];
 }
 
-// Helper functions to sync with Express server (canvas) or remote GitHub target
+
 async function syncToCanvas(operation: string, data: any): Promise<SyncResponse | null> {
   const tgt = await import('./target.js');
   if (tgt.isRemote()) {
@@ -150,31 +150,26 @@ async function syncToCanvas(operation: string, data: any): Promise<SyncResponse
   }
 }
 
-// Helper to sync element creation to canvas
 async function createElementOnCanvas(elementData: ServerElement): Promise<ServerElement | null> {
   const result = await syncToCanvas('create', elementData);
   return result?.element || elementData;
 }
 
-// Helper to sync element update to canvas  
 async function updateElementOnCanvas(elementData: Partial<ServerElement> & { id: string }): Promise<ServerElement | null> {
   const result = await syncToCanvas('update', elementData);
   return result?.element || null;
 }
 
-// Helper to sync element deletion to canvas
 async function deleteElementOnCanvas(elementId: string): Promise<any> {
   const result = await syncToCanvas('delete', { id: elementId });
   return result;
 }
 
-// Helper to sync batch creation to canvas
 async function batchCreateElementsOnCanvas(elementsData: ServerElement[]): Promise<ServerElement[] | null> {
   const result = await syncToCanvas('batch_create', elementsData);
   return result?.elements || elementsData;
 }
 
-// Helper to fetch element from canvas
 async function getElementFromCanvas(elementId: string): Promise<ServerElement | null> {
   const tgt = await import('./target.js');
   if (tgt.isRemote()) {
@@ -199,7 +194,6 @@ async function getElementFromCanvas(elementId: string): Promise<ServerElement |
   }
 }
 
-// In-memory storage for scene state
 interface SceneState {
   theme: string;
   viewport: { x: number; y: number; zoom: number };
@@ -214,12 +208,10 @@ const sceneState: SceneState = {
   groups: new Map()
 };
 
-// Points schema: accept both {x, y} objects and [x, y] tuples
 const PointObjectSchema = z.object({ x: z.number(), y: z.number() });
 const PointTupleSchema = z.tuple([z.number(), z.number()]);
 const PointSchema = z.union([PointObjectSchema, PointTupleSchema]);
 
-// Normalize points to [x, y] tuple format that Excalidraw expects
 function normalizePoints(points: Array<{ x: number; y: number } | [number, number]>): [number, number][] {
   return points.map(p => {
     if (Array.isArray(p)) return p as [number, number];
@@ -227,7 +219,6 @@ function normalizePoints(points: Array<{ x: number; y: number } | [number, numbe
   });
 }
 
-// Schema definitions using zod
 const ElementSchema = z.object({
   id: z.string().optional(),
   type: z.enum(Object.values(EXCALIDRAW_ELEMENT_TYPES) as [ExcalidrawElementType, ...ExcalidrawElementType[]]),
@@ -293,7 +284,6 @@ const ResourceSchema = z.object({
   resource: z.enum(['scene', 'library', 'theme', 'elements'])
 });
 
-// Diagram design guide — injected into LLM context via read_diagram_guide tool
 const DIAGRAM_DESIGN_GUIDE = `# Excalidraw Diagram Design Guide
 
 ## Color Palette
@@ -386,7 +376,7 @@ const DIAGRAM_DESIGN_GUIDE = `# Excalidraw Diagram Design Guide
 5. **Refinement** — align, distribute, adjust spacing, screenshot to verify
 `;
 
-// Tool definitions
+
 const tools: Tool[] = [
   {
     name: 'create_element',
@@ -910,7 +900,7 @@ const tools: Tool[] = [
   }
 ];
 
-// Initialize MCP server
+
 const server = new Server(
   {
     name: "mcp-excalidraw-server",
@@ -927,15 +917,13 @@ const server = new Server(
   }
 );
 
-// Helper function to convert text property to label format for Excalidraw
+
 function convertTextToLabel(element: ServerElement): ServerElement {
   const { text, ...rest } = element;
   if (text) {
-    // For standalone text elements, keep text as direct property
     if (element.type === 'text') {
-      return element; // Keep text as direct property
+      return element;
     }
-    // For other elements (rectangle, ellipse, diamond), convert to label format
     return {
       ...rest,
       label: { text }
@@ -944,11 +932,8 @@ function convertTextToLabel(element: ServerElement): ServerElement {
   return element;
 }
 
-// Set up request handler for tool calls
 let toolQueue: Promise<void> = Promise.resolve();
 
-// Serialized: concurrent tool calls (e.g. switch+create+commit in one block)
-// must not interleave against the remote scene store.
 async function handleToolCall(request: CallToolRequest) {
   try {
     const { name, arguments: args } = request.params;
@@ -965,7 +950,6 @@ async function handleToolCall(request: CallToolRequest) {
           id,
           ...elementProps,
           points: elementProps.points ? normalizePoints(elementProps.points) : undefined,
-          // Convert binding IDs to Excalidraw's start/end format
           ...(startElementId ? { start: { id: startElementId } } : {}),
           ...(endElementId ? { end: { id: endElementId } } : {}),
           createdAt: new Date().toISOString(),
@@ -973,17 +957,14 @@ async function handleToolCall(request: CallToolRequest) {
           version: 1
         };
 
-        // Normalize fontFamily from string names to numeric values
         if (element.fontFamily !== undefined) {
           element.fontFamily = normalizeFontFamily(element.fontFamily);
         }
 
-        // For bound arrows without explicit points, set a default
         if ((startElementId || endElementId) && !elementProps.points) {
           (element as any).points = [[0, 0], [100, 0]];
         }
 
-        // Convert text to label format for Excalidraw
         const excalidrawElement = convertTextToLabel(element);
 
         // Create element directly on HTTP server (no local storage)

package/src/server.ts

@@ -31,7 +31,7 @@ import {
 import { z } from 'zod';
 import WebSocket from 'ws';
 
-// Load environment variables
+
 dotenv.config();
 
 const __filename = fileURLToPath(import.meta.url);
@@ -41,12 +41,12 @@ const app: Express = express();
 const server = createServer(app);
 const wss = new WebSocketServer({ server });
 
-// Middleware
+
 app.use(cors());
 app.use(express.json({ limit: '10mb' }));
 app.use(authOptional);
 
-// ─── R2 persistence (scene keyed by repo or SCENE_ID) ───
+
 const SCENE_KEY = `${process.env.GITHUB_REPOSITORY?.replace('/', '__') || process.env.SCENE_ID || 'default'}.json`;
 let r2Cfg = getR2Config();
 let persistTimer: ReturnType<typeof setTimeout> | null = null;
@@ -69,7 +69,7 @@ function schedulePersist(): void {
 }
 void loadFromR2();
 
-// ─── GitHub OAuth (2FA via github.com login; code lives 10min, session 30d cookie) ───
+
 app.get('/api/auth/login', (req, res) => {
   const cid = process.env.GITHUB_CLIENT_ID;
   if (!cid) return res.status(500).json({ success: false, error: 'GITHUB_CLIENT_ID not configured' });
@@ -93,7 +93,7 @@ app.get('/api/auth/callback', async (req, res) => {
 });
 app.get('/api/auth/me', (req, res) => res.json({ user: (req as any).user || null, publicRead: String(process.env.PUBLIC_READ || 'false') }));
 app.post('/api/auth/logout', (_req, res) => { res.setHeader('Set-Cookie', 'excalidrop_token=; Path=/; Max-Age=0'); res.json({ success: true }); });
-// Writes always authed (when OAuth configured); reads public iff PUBLIC_READ=true.
+
 const OPEN_WRITE_PATHS = new Set(['/api/export/image/result', '/api/viewport/result']);
 app.use('/api/', (req, res, next) => {
   if (req.path.startsWith('/auth')) return next();
@@ -106,17 +106,17 @@ app.use('/api/', (req, res, next) => {
 });
 const persist = () => schedulePersist();
 
-// Serve static files from the build directory
+
 const staticDir = path.join(__dirname, '../dist');
 app.use(express.static(staticDir));
-// Also serve frontend assets
+
 app.use(express.static(path.join(__dirname, '../dist/frontend')));
-// Serve Excalidraw fonts so the font subsetting worker can fetch them for export
+
 app.use('/assets/fonts', express.static(
   path.join(__dirname, '../node_modules/@excalidraw/excalidraw/dist/prod/fonts')
 ));
 
-// WebSocket connections
+
 const clients = new Set<WebSocket>();
 
 // Broadcast to all connected clients

package/src/target.ts

@@ -1,8 +1,4 @@
-/** Dynamic backend target: local canvas (HTTP) or remote GitHub repo.
- *  Agents switch with the switch_remote tool; writes commit straight to GitHub.
- *  Token resolution (no user setup): GITHUB_TOKEN env → `gh auth token` →
- *  ~/.config/excalidrop/gh_token (written by github_login device flow).
- */
+
 import { execSync } from 'node:child_process';
 import fs from 'node:fs';
 import os from 'node:os';
@@ -14,11 +10,11 @@ export type Target = { kind: 'local' } | { kind: 'remote'; repo: string };
 let active: Target = { kind: 'local' };
 export const getTarget = (): Target => active;
 
-/** Shared Excalidrop GitHub App Client ID (public, not a secret). */
+
 export const APP_CLIENT_ID = process.env.GITHUB_OAUTH_CLIENT_ID || 'Iv23liuS2fx3QOEIoDmx';
 
 const CONFIG_NAME = '.excalidrop.json';
-/** Walk up from cwd to find the project config (same pattern as the CLI's ports). */
+
 function findConfigDir(): string | null {
   let dir = process.cwd();
   const root = path.parse(dir).root;
@@ -31,7 +27,7 @@ function findConfigDir(): string | null {
     dir = path.dirname(dir);
   }
 }
-/** Remember the remote target per-project so agents don't pass it every call. */
+
 function persistTarget(repo: string | null): void {
   const dir = findConfigDir();
   if (!dir) return;
@@ -42,7 +38,7 @@ function persistTarget(repo: string | null): void {
     fs.writeFileSync(file, JSON.stringify(raw, null, 2) + '\n');
   } catch (e) { logger.warn('could not persist remote target: ' + (e as Error).message); }
 }
-/** Restore the remembered target (called once at MCP startup). */
+
 export function loadSavedTarget(): string | null {
   const dir = findConfigDir();
   if (!dir) return null;
@@ -70,7 +66,7 @@ export function storeToken(t: string): void {
   fs.writeFileSync(TOKEN_FILE, t + '\n', { mode: 0o600 });
 }
 
-/** Parse owner/repo from "owner/repo" or a https://<owner>.github.io/<repo>/ URL. */
+
 export function parseRepo(input: string): string {
   const s = input.trim().replace(/\/$/, '');
   const m = s.match(/^https?:\/\/([a-z0-9-]+)\.github\.io\/([a-z0-9_.-]+)/i);
@@ -79,7 +75,7 @@ export function parseRepo(input: string): string {
   throw new Error(`Cannot parse repo from "${input}" — use owner/repo or a *.github.io/<repo> URL`);
 }
 
-// ─── remote scene store (per-target memory + debounced commit) ───
+
 const scenes = new Map<string, { elements: Map<string, ServerElement>; sha: string | null; dirty: boolean }>();
 let timer: ReturnType<typeof setTimeout> | null = null;
 const SCENE_PATH = process.env.SCENE_PATH || 'canvas.excalidraw';
@@ -133,22 +129,20 @@ export async function commitNow(message?: string): Promise<{ sha: string; count:
   const st = current();
   const elements = Array.from(st.elements.values());
   const doc = { type: 'excalidraw', version: 2, source: 'excalidrop', elements };
-  // Shared putFile handles: sha optimistic concurrency (409) + bootstrapping
-  // main on empty repos (forks off gh-pages) — same path as the remote server.
   const gh = await import('./utils/github.js');
   const newSha = await gh.putFile(repo, SCENE_PATH, doc, message || `excalidrop: update ${elements.length} elements`, 'main', st.sha || undefined);
   st.sha = newSha;
   st.dirty = false;
-  // mirror to gh-pages viewer copy
   try {
     const cur = await gh.getFile(repo, SCENE_PATH, 'gh-pages').catch(() => null);
     await gh.putFile(repo, SCENE_PATH, doc, 'excalidrop: sync viewer', 'gh-pages', cur?.sha);
+    await gh.updateRepoMetadata(repo, { homepage: `https://${repo.replace('/', '.github.io/')}/` });
   } catch (e) { logger.warn('viewer mirror failed: ' + (e as Error).message); }
   logger.info(`Committed ${elements.length} elements to ${repo}`);
   return { sha: st.sha as string, count: elements.length };
 }
 
-// Element ops (remote side)
+
 export function rCreate(el: ServerElement): ServerElement {
   const st = current();
   const full = { ...el, id: el.id || generateId() };
@@ -172,11 +166,7 @@ export function rList(type?: string): ServerElement[] {
 export function rClear(): number { const st = current(); const n = st.elements.size; st.elements.clear(); st.dirty = true; scheduleCommit(); return n; }
 export const isRemote = (): boolean => active.kind === 'remote';
 
-// ─── GitHub App device flow (Node — no CORS issues here) ───
-// NOTE: deliberate device-flow (not web flow): static hosting has nowhere to
-// keep a client_secret, and device flow is the only secretless path per docs.
-// App user-tokens carry no scopes — permissions = user ∩ app. Optional
-// repository_id restricts the token to a single repo (least privilege).
+
 export async function deviceStart(clientId: string): Promise<{ user_code: string; verification_uri: string; device_code: string; interval: number }> {
   const r = await fetch('https://github.com/login/device/code', {
     method: 'POST', headers: { Accept: 'application/json', 'Content-Type': 'application/json' },

package/src/types.ts

@@ -108,7 +108,7 @@ export interface ExcalidrawBinding {
 
 export type ExcalidrawElementType = 'rectangle' | 'ellipse' | 'diamond' | 'arrow' | 'text' | 'line' | 'freedraw' | 'image';
 
-// Excalidraw element types
+
 export const EXCALIDRAW_ELEMENT_TYPES: Record<string, ExcalidrawElementType> = {
   RECTANGLE: 'rectangle',
   ELLIPSE: 'ellipse',
@@ -120,7 +120,7 @@ export const EXCALIDRAW_ELEMENT_TYPES: Record<string, ExcalidrawElementType> = {
   IMAGE: 'image'
 } as const;
 
-// Server-side element with metadata
+
 export interface ServerElement extends Omit<ExcalidrawElementBase, 'id'> {
   id: string;
   type: ExcalidrawElementType;
@@ -138,12 +138,12 @@ export interface ServerElement extends Omit<ExcalidrawElementBase, 'id'> {
     text: string;
   };
   points?: any;
-  // Arrow element binding: connect arrows to shapes by element ID
+
   start?: { id: string };
   end?: { id: string };
 }
 
-// API Response types
+
 export interface ApiResponse<T = any> {
   success: boolean;
   data?: T;
@@ -167,7 +167,7 @@ export interface SyncResponse extends ApiResponse {
   afterCount: number;
 }
 
-// WebSocket message types
+
 export interface WebSocketMessage {
   type: WebSocketMessageType;
   [key: string]: any;
@@ -226,7 +226,7 @@ export interface MermaidConvertMessage extends WebSocketMessage {
   timestamp: string;
 }
 
-// Mermaid conversion types
+
 export interface MermaidConfig {
   startOnLoad?: boolean;
   flowchart?: {
@@ -250,13 +250,13 @@ export interface MermaidConversionResponse extends ApiResponse {
   count: number;
 }
 
-// Canvas cleared message
+
 export interface CanvasClearedMessage extends WebSocketMessage {
   type: 'canvas_cleared';
   timestamp: string;
 }
 
-// Image export types
+
 export interface ExportImageRequestMessage extends WebSocketMessage {
   type: 'export_image_request';
   requestId: string;
@@ -264,7 +264,7 @@ export interface ExportImageRequestMessage extends WebSocketMessage {
   background?: boolean;
 }
 
-// Viewport control types
+
 export interface SetViewportMessage extends WebSocketMessage {
   type: 'set_viewport';
   requestId: string;
@@ -275,20 +275,20 @@ export interface SetViewportMessage extends WebSocketMessage {
   offsetY?: number;
 }
 
-// Snapshot types
+
 export interface Snapshot {
   name: string;
   elements: ServerElement[];
   createdAt: string;
 }
 
-// In-memory storage for Excalidraw elements
+
 export const elements = new Map<string, ServerElement>();
 
-// In-memory storage for snapshots
+
 export const snapshots = new Map<string, Snapshot>();
 
-// In-memory file storage for image elements (Excalidraw BinaryFiles)
+
 export interface ExcalidrawFile {
   id: string;
   dataURL: string;
@@ -297,7 +297,7 @@ export interface ExcalidrawFile {
 }
 export const files = new Map<string, ExcalidrawFile>();
 
-// Validation function for Excalidraw elements
+
 export function validateElement(element: Partial<ServerElement>): element is ServerElement {
   const requiredFields: (keyof ServerElement)[] = ['type', 'x', 'y'];
   const hasRequiredFields = requiredFields.every(field => field in element);
@@ -313,14 +313,12 @@ export function validateElement(element: Partial<ServerElement>): element is Ser
   return true;
 }
 
-// Helper function to generate unique IDs
+
 export function generateId(): string {
   return Date.now().toString(36) + Math.random().toString(36).substring(2);
 }
 
-// Normalize fontFamily from string names to numeric values that Excalidraw expects
-// Excalidraw uses: 1 = Virgil (handwritten), 2 = Helvetica (sans-serif), 3 = Cascadia (monospace)
-// 5 = Excalifont, 6 = Nunito, 7 = Lilita One, 8 = Comic Shanns
+
 export function normalizeFontFamily(fontFamily: string | number | undefined): number | undefined {
   if (fontFamily === undefined) return undefined;
   if (typeof fontFamily === 'number') return fontFamily;

package/src/utils/auth.ts

@@ -41,7 +41,7 @@ export function authOptional(req: Request, _res: Response, next: NextFunction) {
   next();
 }
 
-/** Writes always require auth when GitHub OAuth is configured. Reads are public iff PUBLIC_READ=true. */
+
 export function requireWriteAuth(req: Request, res: Response, next: NextFunction) {
   if (!process.env.GITHUB_CLIENT_ID) return next(); // local dev: open
   const tok = getToken(req);