excalidrop 0.1.4 → 0.2.2

package/frontend/src/main.tsx

@@ -1,15 +0,0 @@
-import React from 'react'
-import ReactDOM from 'react-dom/client'
-import App from './App.tsx'
-import '@excalidraw/excalidraw/index.css'
-
-const rootElement = document.getElementById('root');
-if (!rootElement) {
-  throw new Error('Root element not found');
-}
-
-ReactDOM.createRoot(rootElement).render(
-  <React.StrictMode>
-    <App />
-  </React.StrictMode>,
-)

package/frontend/src/utils/ghSync.ts

@@ -1,234 +0,0 @@
-
-
-export interface RepoRef { owner: string; repo: string; branch: string }
-
-export function detectRepo(): RepoRef | null {
-  const explicit = (import.meta as any).env?.VITE_REPO_SLUG as string | undefined;
-  if (explicit?.includes('/')) {
-    const [owner, repo] = explicit.split('/');
-    return { owner, repo, branch: 'gh-pages' };
-  }
-  const host = window.location.hostname; // <owner>.github.io
-  const parts = window.location.pathname.split('/').filter(Boolean);
-  if (host.endsWith('.github.io') && parts.length > 0) {
-    return { owner: host.slice(0, -'.github.io'.length), repo: parts[0], branch: 'gh-pages' };
-  }
-  return null;
-}
-
-const TOKEN_KEY = 'excalidrop_gh_token';
-
-export function getToken(): string | null {
-
-  if (window.location.hash.startsWith('#token=')) {
-    const t = decodeURIComponent(window.location.hash.slice('#token='.length));
-    if (t) {
-      localStorage.setItem(TOKEN_KEY, t);
-      history.replaceState(null, '', window.location.pathname + window.location.search);
-      return t;
-    }
-  }
-  return localStorage.getItem(TOKEN_KEY);
-}
-
-export function setToken(t: string | null): void {
-  if (t) localStorage.setItem(TOKEN_KEY, t);
-  else localStorage.removeItem(TOKEN_KEY);
-}
-
-async function gh(path: string, token: string, init?: RequestInit): Promise<any> {
-  const r = await fetch(`https://api.github.com${path}`, {
-    ...init,
-    headers: {
-      Authorization: `Bearer ${token}`,
-      Accept: 'application/vnd.github+json',
-      'Content-Type': 'application/json',
-      ...(init?.headers || {}),
-    },
-  });
-  if (!r.ok) throw new Error(`GitHub ${r.status}: ${(await r.text()).slice(0, 200)}`);
-  return r.json();
-}
-
-
-export async function pushScene(
-  ref: RepoRef, token: string, scene: { elements: unknown[]; files?: Record<string, unknown> },
-): Promise<string> {
-  const path = 'canvas.excalidraw';
-  let sha: string | undefined;
-  try {
-    const cur = await gh(`/repos/${ref.owner}/${ref.repo}/contents/${path}?ref=${ref.branch}`, token);
-    sha = cur.sha;
-  } catch {}
-  const body: any = {
-    message: `excalidrop: autosync ${scene.elements.length} elements`,
-    content: btoa(unescape(encodeURIComponent(JSON.stringify(
-      { type: 'excalidraw', version: 2, source: 'excalidrop', elements: scene.elements },
-      null, 2,
-    )))),
-    branch: ref.branch,
-  };
-  if (sha) body.sha = sha;
-  const out = await gh(`/repos/${ref.owner}/${ref.repo}/contents/${path}`, token, {
-    method: 'PUT',
-    body: JSON.stringify(body),
-  });
-  return out.content.sha as string;
-}
-
-
-export async function loadStaticScene(): Promise<{ elements: any[]; files?: Record<string, unknown> }> {
-  const r = await fetch('./canvas.excalidraw', { cache: 'no-cache' });
-  if (!r.ok) throw new Error(`scene fetch ${r.status}`);
-  const j = await r.json();
-  return { elements: j.elements || [], files: j.files || {} };
-}
-
-
-export async function startDeviceFlow(clientId: string): Promise<{ user_code: string; verification_uri: string }> {
-  const r = await fetch('https://github.com/login/device/code', {
-    method: 'POST',
-    headers: { Accept: 'application/json', 'Content-Type': 'application/json' },
-    body: JSON.stringify({ client_id: clientId }),
-  });
-  if (!r.ok) throw new Error('device flow start failed');
-  const j = await r.json();
-  return { user_code: j.user_code, verification_uri: j.verification_uri };
-}
-
-export interface DeviceFlowSession {
-  device_code: string;
-  user_code: string;
-  verification_uri: string;
-  interval: number;
-
-  expires_at: number;
-}
-
-const FLOW_KEY = 'excalidrop_device_flow';
-
-
-export async function startDeviceFlowFull(clientId: string): Promise<DeviceFlowSession> {
-  const r = await fetch('https://github.com/login/device/code', {
-    method: 'POST',
-    headers: { Accept: 'application/json', 'Content-Type': 'application/json' },
-    body: JSON.stringify({ client_id: clientId }),
-  });
-  if (!r.ok) throw new Error('device flow start failed');
-  const j = await r.json();
-  return {
-    device_code: j.device_code as string,
-    user_code: j.user_code as string,
-    verification_uri: (j.verification_uri as string) || 'https://github.com/login/device',
-    interval: Number(j.interval) || 5,
-    expires_at: Date.now() + (Number(j.expires_in) || 900) * 1000,
-  };
-}
-
-
-export async function pollDeviceToken(
-  clientId: string,
-  session: Pick<DeviceFlowSession, 'device_code' | 'interval' | 'expires_at'>,
-  signal?: AbortSignal,
-): Promise<string> {
-  let interval = session.interval;
-  for (;;) {
-    if (signal?.aborted) throw new DOMException('Login cancelled', 'AbortError');
-    if (Date.now() >= session.expires_at) throw new Error('Login code expired — please try again.');
-    await new Promise((r) => setTimeout(r, interval * 1000));
-    if (signal?.aborted) throw new DOMException('Login cancelled', 'AbortError');
-    const r = await fetch('https://github.com/login/oauth/access_token', {
-      method: 'POST',
-      headers: { Accept: 'application/json', 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        client_id: clientId,
-        device_code: session.device_code,
-        grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
-      }),
-    });
-    if (!r.ok) throw new Error('Login polling failed');
-    const j = await r.json();
-    if (j.access_token) return j.access_token as string;
-    if (j.error === 'authorization_pending') continue;
-    if (j.error === 'slow_down') {
-      interval += 5;
-      continue;
-    }
-    if (j.error) throw new Error(j.error_description || j.error);
-  }
-}
-
-export function saveFlowSession(s: DeviceFlowSession | null): void {
-  try {
-    if (s) sessionStorage.setItem(FLOW_KEY, JSON.stringify(s));
-    else sessionStorage.removeItem(FLOW_KEY);
-  } catch {
-
-  }
-}
-
-export function loadFlowSession(): DeviceFlowSession | null {
-  try {
-    const raw = sessionStorage.getItem(FLOW_KEY);
-    if (!raw) return null;
-    const s = JSON.parse(raw) as DeviceFlowSession;
-    if (!s.device_code || Date.now() >= s.expires_at) {
-      sessionStorage.removeItem(FLOW_KEY);
-      return null;
-    }
-    return s;
-  } catch {
-    return null;
-  }
-}
-
-export type Access = 'editor' | 'viewer' | 'denied';
-
-export type AccessDetail =
-  | 'app-not-installed' // ghu_ token, but the user has no app installation reaching this repo
-  | 'repo-not-covered' // installation(s) exist, but none of them include this repo
-  | 'no-token-permissions' // classic token with no read access to the repo
-  | null; // editor/viewer — no problem to report
-
-
-export async function checkAccess(ref: RepoRef, token: string): Promise<{ access: Access; login: string; detail: AccessDetail }> {
-  const me = await gh('/user', token);
-  const login = (me.login || '') as string;
-  const wanted = `${ref.owner}/${ref.repo}`.toLowerCase();
-
-  const inst = await gh('/user/installations?per_page=100', token).catch(() => null);
-  if (inst?.installations) {
-    if ((inst.installations as unknown[]).length === 0) {
-      return { access: 'denied', login, detail: 'app-not-installed' };
-    }
-    for (const i of inst.installations || []) {
-      const repos = await gh(`/user/installations/${(i as any).id}/repositories?per_page=100`, token).catch(() => null);
-      const hit = (repos?.repositories || []).find((r: any) => r.full_name.toLowerCase() === wanted);
-      if (hit) {
-
-        const perms = await gh(`/repos/${ref.owner}/${ref.repo}/collaborators/${login}/permission`, token).catch(() => null);
-        const p = (perms?.permission || '') as string;
-        if (p === 'read' || p === 'triage') return { access: 'viewer', login, detail: null };
-        return { access: 'editor', login, detail: null };
-      }
-    }
-    return { access: 'denied', login, detail: 'repo-not-covered' };
-  }
-
-  const repo = await gh(`/repos/${ref.owner}/${ref.repo}`, token).catch(() => null);
-  if (!repo?.permissions) return { access: 'denied', login, detail: 'no-token-permissions' };
-  if (repo.permissions.push || repo.permissions.admin || repo.permissions.maintain) {
-    return { access: 'editor', login, detail: null };
-  }
-  return { access: 'viewer', login, detail: null };
-}
-
-
-export const CLIENT_ID =
-  ((import.meta as any).env?.VITE_GITHUB_CLIENT_ID as string | undefined) ||
-  'Iv23liuS2fx3QOEIoDmx';
-export const APP_SLUG =
-  ((import.meta as any).env?.VITE_GITHUB_APP_SLUG as string | undefined) || 'excalidrop';
-export const APP_INSTALL_URL = `https://github.com/apps/${APP_SLUG}/installations/new`;
-
-export const HAS_CLIENT_ID = !!CLIENT_ID && !CLIENT_ID.includes('EXCALIDROP_APP');

package/frontend/src/utils/mermaidConverter.ts

@@ -1,43 +0,0 @@
-import { parseMermaidToExcalidraw, MermaidConfig } from '@excalidraw/mermaid-to-excalidraw';
-import type { ExcalidrawElement } from '@excalidraw/excalidraw/types/element/types';
-import type { BinaryFiles } from '@excalidraw/excalidraw/types/types';
-
-export interface MermaidConversionResult {
-  elements: readonly ExcalidrawElement[];
-  files?: BinaryFiles;
-  error?: string;
-}
-
-
-export const convertMermaidToExcalidraw = async (
-  mermaidDefinition: string,
-  config?: MermaidConfig
-): Promise<MermaidConversionResult> => {
-  try {
-    const result = await parseMermaidToExcalidraw(mermaidDefinition, config);
-    
-    return {
-      elements: result.elements,
-      files: result.files,
-    };
-  } catch (error) {
-    console.error('Error converting Mermaid to Excalidraw:', error);
-    return {
-      elements: [],
-      error: error instanceof Error ? error.message : String(error),
-    };
-  }
-};
-
-
-export const DEFAULT_MERMAID_CONFIG: MermaidConfig = {
-  startOnLoad: false,
-  flowchart: {
-    curve: 'linear',
-  },
-  themeVariables: {
-    fontSize: '20px',
-  },
-  maxEdges: 500,
-  maxTextSize: 50000,
-};

package/frontend/src/utils/webmcp.ts

@@ -1,265 +0,0 @@
-
-
-interface MinimalCanvasApi {
-  getSceneElements(): Array<Record<string, any>>;
-  updateScene(scene: { elements: Array<Record<string, any>> }): void;
-  resetScene(): void;
-}
-
-export type CanvasApiGetter = () => MinimalCanvasApi | null | undefined;
-
-export interface WebMCPHandle {
-  available: boolean;
-  count: number;
-  cleanup: () => void;
-}
-
-interface ModelContextLike {
-  registerTool(
-    tool: {
-      name: string;
-      title?: string;
-      description: string;
-      inputSchema: Record<string, unknown>;
-      annotations?: Record<string, unknown>;
-      execute: (args: any, opts?: { signal?: AbortSignal }) => unknown | Promise<unknown>;
-    },
-    options?: { signal?: AbortSignal },
-  ): Promise<void>;
-}
-
-function getModelContext(): ModelContextLike | null {
-  try {
-    const doc = document as unknown as Record<string, unknown>;
-    const nav = navigator as unknown as Record<string, unknown>;
-    const mc =
-      (doc['modelContext'] as ModelContextLike | undefined) ??
-      (nav['modelContext'] as ModelContextLike | undefined);
-    if (mc && typeof mc.registerTool === 'function') return mc;
-  } catch {
-
-  }
-  return null;
-}
-
-function newId(): string {
-  try {
-    if (typeof crypto !== 'undefined' && 'randomUUID' in crypto) {
-      return (crypto as Crypto).randomUUID().slice(0, 12);
-    }
-  } catch {
-
-  }
-  return `el_${Math.random().toString(36).slice(2, 10)}`;
-}
-
-function summarize(el: Record<string, any>): Record<string, unknown> {
-  const out: Record<string, unknown> = {
-    id: el['id'],
-    type: el['type'],
-    x: Math.round(Number(el['x'] ?? 0)),
-    y: Math.round(Number(el['y'] ?? 0)),
-  };
-  if (el['width'] !== undefined) out['width'] = el['width'];
-  if (el['height'] !== undefined) out['height'] = el['height'];
-  const text =
-    (typeof el['text'] === 'string' && el['text']) ||
-    (el['label'] as { text?: string } | undefined)?.text;
-  if (text) out['text'] = String(text).slice(0, 120);
-  if (el['locked']) out['locked'] = true;
-  return out;
-}
-
-const ELEMENT_SCHEMA: Record<string, unknown> = {
-  type: 'object',
-  properties: {
-    id: { type: 'string', description: 'Custom element ID (auto-generated if omitted)' },
-    type: { type: 'string', description: 'Excalidraw element type: rectangle, ellipse, diamond, text, arrow, line, freedraw, image' },
-    x: { type: 'number' },
-    y: { type: 'number' },
-    width: { type: 'number' },
-    height: { type: 'number' },
-    text: { type: 'string', description: 'Label text for shapes / content for text elements' },
-    backgroundColor: { type: 'string' },
-    strokeColor: { type: 'string' },
-    strokeWidth: { type: 'number' },
-    fontSize: { type: 'number' },
-    startElementId: { type: 'string', description: 'For arrows: bind start to this element ID' },
-    endElementId: { type: 'string', description: 'For arrows: bind end to this element ID' },
-  },
-  required: ['type', 'x', 'y'],
-  additionalProperties: true,
-};
-
-
-export function registerCanvasWebMCP(getApi: CanvasApiGetter): WebMCPHandle {
-  const noop = () => {};
-  const mc = getModelContext();
-  if (!mc) return { available: false, count: 0, cleanup: noop };
-
-  const controller = new AbortController();
-  const signal = controller.signal;
-  let count = 0;
-
-  const requireApi = (): MinimalCanvasApi => {
-    const api = getApi();
-    if (!api) throw new Error('Canvas not ready yet');
-    return api;
-  };
-
-  const safeRegister = (tool: Parameters<ModelContextLike['registerTool']>[0]): void => {
-    try {
-      const p = mc.registerTool(tool, { signal });
-      if (p && typeof (p as Promise<void>).catch === 'function') {
-        (p as Promise<void>).catch(() => {
-
-        });
-      }
-      count += 1;
-    } catch {
-
-    }
-  };
-
-  safeRegister({
-    name: 'describe_scene',
-    title: 'Describe canvas scene',
-    description:
-      'Read-only summary of the live Excalidraw canvas: element counts by type plus id/type/position/label per element (capped at 200). Call before editing.',
-    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
-    annotations: { readOnlyHint: true },
-    execute: () => {
-      const api = requireApi();
-      const els = api.getSceneElements().filter((e) => !e['isDeleted']);
-      const byType: Record<string, number> = {};
-      for (const e of els) {
-        const t = String(e['type'] ?? 'unknown');
-        byType[t] = (byType[t] ?? 0) + 1;
-      }
-      return {
-        count: els.length,
-        byType,
-        elements: els.slice(0, 200).map(summarize),
-      };
-    },
-  });
-
-  safeRegister({
-    name: 'create_elements',
-    title: 'Create canvas elements',
-    description:
-      'Add new elements to the live canvas in one batch. Assign custom ids to shapes so arrows can reference them via startElementId/endElementId.',
-    inputSchema: {
-      type: 'object',
-      properties: { elements: { type: 'array', items: ELEMENT_SCHEMA, minItems: 1 } },
-      required: ['elements'],
-      additionalProperties: false,
-    },
-    annotations: { destructiveHint: false },
-    execute: (args: { elements?: Array<Record<string, any>> }) => {
-      const api = requireApi();
-      const input = Array.isArray(args?.elements) ? args.elements : [];
-      if (input.length === 0) throw new Error('elements must be a non-empty array');
-      if (input.length > 200) throw new Error('max 200 elements per call');
-      const created = input.map((raw) => {
-        if (!raw || typeof raw !== 'object') throw new Error('each element must be an object');
-        if (typeof raw['type'] !== 'string') throw new Error('each element needs a type');
-        if (typeof raw['x'] !== 'number' || typeof raw['y'] !== 'number') {
-          throw new Error('each element needs numeric x and y');
-        }
-        const { startElementId, endElementId, ...rest } = raw;
-        const el: Record<string, any> = { id: newId(), ...rest };
-        if (typeof startElementId === 'string') el['start'] = { id: startElementId };
-        if (typeof endElementId === 'string') el['end'] = { id: endElementId };
-        if ((el['type'] === 'arrow' || el['type'] === 'line') && !Array.isArray(el['points'])) {
-          el['points'] = [
-            [0, 0],
-            [100, 0],
-          ];
-        }
-        return el;
-      });
-      const current = api.getSceneElements();
-      api.updateScene({ elements: [...current, ...created] });
-      return { ok: true, count: created.length, ids: created.map((e) => e['id']) };
-    },
-  });
-
-  safeRegister({
-    name: 'update_element',
-    title: 'Update canvas element',
-    description: 'Patch position, size, colors, or text of one element by id on the live canvas.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        id: { type: 'string', description: 'Element ID from describe_scene' },
-        patch: {
-          type: 'object',
-          description: 'Fields to merge (x, y, width, height, backgroundColor, strokeColor, text, ...)',
-        },
-      },
-      required: ['id', 'patch'],
-      additionalProperties: false,
-    },
-    annotations: { destructiveHint: false },
-    execute: (args: { id?: string; patch?: Record<string, unknown> }) => {
-      const api = requireApi();
-      if (!args?.id) throw new Error('id is required');
-      if (!args?.patch || typeof args.patch !== 'object') throw new Error('patch must be an object');
-      const current = api.getSceneElements();
-      const idx = current.findIndex((e) => e['id'] === args.id);
-      if (idx === -1) throw new Error(`Element ${args.id} not found`);
-      const next = current.slice();
-      next[idx] = { ...current[idx], ...args.patch, id: args.id };
-      api.updateScene({ elements: next });
-      return { ok: true, id: args.id };
-    },
-  });
-
-  safeRegister({
-    name: 'delete_element',
-    title: 'Delete canvas element',
-    description: 'Remove one element by id from the live canvas.',
-    inputSchema: {
-      type: 'object',
-      properties: { id: { type: 'string' } },
-      required: ['id'],
-      additionalProperties: false,
-    },
-    annotations: { destructiveHint: true },
-    execute: (args: { id?: string }) => {
-      const api = requireApi();
-      if (!args?.id) throw new Error('id is required');
-      const current = api.getSceneElements();
-      if (!current.some((e) => e['id'] === args.id)) throw new Error(`Element ${args.id} not found`);
-      api.updateScene({ elements: current.filter((e) => e['id'] !== args.id) });
-      return { ok: true, deleted: args.id };
-    },
-  });
-
-  safeRegister({
-    name: 'clear_canvas',
-    title: 'Clear canvas',
-    description: 'Remove ALL elements from the live canvas. Ask the user to confirm first.',
-    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
-    annotations: { destructiveHint: true, consequentialHint: true },
-    execute: () => {
-      const api = requireApi();
-      const n = api.getSceneElements().length;
-      api.resetScene();
-      return { ok: true, cleared: n };
-    },
-  });
-
-  return {
-    available: true,
-    count,
-    cleanup: () => {
-      try {
-        controller.abort();
-      } catch {
-
-      }
-    },
-  };
-}