excalidrop 0.1.4 → 0.2.1

package/src/utils/github.ts

@@ -1,121 +0,0 @@
-
-import logger from './logger.js';
-import { execSync } from 'node:child_process';
-
-const API = 'https://api.github.com';
-
-export function token(): string {
-  if (process.env.GITHUB_TOKEN) return process.env.GITHUB_TOKEN;
-  try {
-    return execSync('gh auth token', { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
-  } catch { return ''; }
-}
-
-export function currentRepo(): string {
-  try {
-    const url = execSync('git config --get remote.origin.url', { encoding: 'utf8' }).trim();
-    const m = url.match(/github\.com[:/]([^/]+\/[^/]+?)(\.git)?$/);
-    return (m?.[1] || '').toLowerCase();
-  } catch { return ''; }
-}
-export const SCENE_PATH = process.env.SCENE_PATH || 'canvas.excalidraw';
-
-export const CANVAS_BRANCH = process.env.CANVAS_BRANCH || 'excalidrop';
-
-export function allowedRepos(): string[] {
-  const list = (process.env.ALLOWED_REPOS || '').split(',').map(s => s.trim().toLowerCase()).filter(Boolean);
-  if (list.length) return list;
-  const cur = currentRepo();
-  return cur ? [cur] : [];
-}
-
-export function assertRepo(_repo: string): void {
-
-}
-function headers(): Record<string, string> {
-  return { Authorization: `Bearer ${token()}`, Accept: 'application/vnd.github+json', 'User-Agent': 'excalidrop', 'Content-Type': 'application/json' };
-}
-export async function getFile(repo: string, path: string, ref = CANVAS_BRANCH): Promise<{ sha: string; content: any } | null> {
-  assertRepo(repo);
-  const r = await fetch(`${API}/repos/${repo}/contents/${path}?ref=${ref}`, { headers: headers() });
-  if (r.status === 404) return null;
-  if (!r.ok) throw new Error(`GitHub get ${r.status}: ${await r.text()}`);
-  const j = await r.json() as any;
-  const text = Buffer.from(j.content, 'base64').toString('utf8');
-  return { sha: j.sha, content: JSON.parse(text) };
-}
-
-async function ensureBranch(repo: string, branch: string): Promise<void> {
-  const has = await fetch(`${API}/repos/${repo}/git/ref/heads/${branch}`, { headers: headers() });
-  if (has.ok) return;
-  const repoInfo = await (await fetch(`${API}/repos/${repo}`, { headers: headers() })).json() as any;
-  const from = repoInfo.default_branch || 'main';
-  const ref = await (await fetch(`${API}/repos/${repo}/git/ref/heads/${from}`, { headers: headers() })).json() as any;
-  if (!ref.object?.sha) throw new Error(`cannot create ${branch}: no ${from} branch`);
-  const mkRef = await fetch(`${API}/repos/${repo}/git/refs`, { method: 'POST', headers: headers(), body: JSON.stringify({ ref: `refs/heads/${branch}`, sha: ref.object.sha }) });
-  if (!mkRef.ok) throw new Error(`cannot create ${branch}: ${(await mkRef.text()).slice(0, 200)}`);
-}
-export async function putFile(repo: string, path: string, data: any, message: string, branch = CANVAS_BRANCH, sha?: string): Promise<string> {
-  assertRepo(repo);
-  if (!token()) throw new Error('GITHUB_TOKEN missing');
-  const body: any = { message, content: Buffer.from(JSON.stringify(data, null, 2)).toString('base64'), branch };
-  if (sha) body.sha = sha;
-  let r = await fetch(`${API}/repos/${repo}/contents/${path}`, { method: 'PUT', headers: headers(), body: JSON.stringify(body) });
-  if (r.status === 404) {
-
-    await ensureBranch(repo, branch);
-    const existing = await getFile(repo, path, branch).catch(() => null);
-    if (existing?.sha) body.sha = existing.sha;
-    else delete body.sha;
-    r = await fetch(`${API}/repos/${repo}/contents/${path}`, { method: 'PUT', headers: headers(), body: JSON.stringify(body) });
-  }
-  if (r.status === 409) throw new Error('CONFLICT: file changed upstream, refetch sha and retry');
-  if (r.status === 422 && !sha) {
-
-    const existing = await getFile(repo, path, branch).catch(() => null);
-    if (!existing?.sha) throw new Error(`GitHub put 422: ${(await r.text()).slice(0, 200)}`);
-    body.sha = existing.sha;
-    r = await fetch(`${API}/repos/${repo}/contents/${path}`, { method: 'PUT', headers: headers(), body: JSON.stringify(body) });
-    if (r.status === 409) throw new Error('CONFLICT: file changed upstream, refetch sha and retry');
-  }
-  if (!r.ok) throw new Error(`GitHub put ${r.status}: ${await r.text()}`);
-  const j = await r.json() as any;
-  logger.info(`Committed ${path}@${branch} in ${repo}`);
-  return j.content.sha;
-}
-
-export async function loadScene(repo: string): Promise<{ elements: any[]; files: any[]; sha: string | null }> {
-  assertRepo(repo);
-  const f = await getFile(repo, SCENE_PATH, CANVAS_BRANCH).catch(() => null);
-  if (!f) return { elements: [], files: [], sha: null };
-  return { elements: f.content.elements || [], files: f.content.files || [], sha: f.sha };
-}
-
-export async function saveScene(repo: string, elements: any[], files: any[], sha: string | null, msg: string): Promise<string> {
-  return putFile(repo, SCENE_PATH, { type: 'excalidraw', version: 2, source: 'excalidrop', elements, files: files || {} }, msg, CANVAS_BRANCH, sha || undefined);
-}
-
-export async function syncPages(_repo: string, _scene: any): Promise<void> {
-
-}
-
-export async function updateRepoMetadata(repo: string, updates: { description?: string; homepage?: string }): Promise<void> {
-  assertRepo(repo);
-  if (!token()) throw new Error('GITHUB_TOKEN missing');
-  const r = await fetch(`${API}/repos/${repo}`, { method: 'PATCH', headers: headers(), body: JSON.stringify(updates) });
-  if (!r.ok) throw new Error(`GitHub PATCH ${r.status}: ${await r.text()}`);
-  logger.info(`Updated metadata for ${repo}`);
-}
-
-export async function ensureRepoMetadata(repo: string, homepage: string): Promise<void> {
-  assertRepo(repo);
-  if (!token()) throw new Error('GITHUB_TOKEN missing');
-  const r = await fetch(`${API}/repos/${repo}`, { headers: headers() });
-  if (!r.ok) throw new Error(`GitHub GET ${r.status}: ${await r.text()}`);
-  const data = await r.json() as any;
-  if (!data.description || data.description.trim() === '') {
-    await updateRepoMetadata(repo, { description: homepage, homepage });
-  } else if (!data.homepage || data.homepage.trim() === '') {
-    await updateRepoMetadata(repo, { homepage });
-  }
-}

package/src/utils/logger.ts

@@ -1,35 +0,0 @@
-import winston from 'winston';
-import { tmpdir } from 'os';
-import { join } from 'path';
-
-const LOG_FILE_PATH = process.env.LOG_FILE_PATH || join(tmpdir(), 'excalidraw.log');
-
-const logger: winston.Logger = winston.createLogger({
-  level: process.env.LOG_LEVEL || 'info',
-
-  format: winston.format.combine(
-    winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss.SSS' }),
-    winston.format.uncolorize(),
-    winston.format.metadata({ fillExcept: ['message', 'level', 'timestamp'] }),
-    winston.format.printf(info => {
-      const extra = info.metadata && Object.keys(info.metadata).length
-        ? ` ${JSON.stringify(info.metadata)}`
-        : '';
-      return `${info.timestamp} [${info.level}] ${info.message}${extra}`
-    })
-  ),
-
-  transports: [
-    new winston.transports.Console({
-      level: 'warn',
-      stderrLevels: ['warn','error']
-    }),
-
-    new winston.transports.File({
-      filename: LOG_FILE_PATH,
-      level: 'debug'
-    })
-  ]
-});
-
-export default logger;

package/src/utils/r2store.ts

@@ -1,70 +0,0 @@
-import crypto from 'node:crypto';
-
-
-export interface R2Config {
-  accountId: string; keyId: string; secret: string; bucket: string; prefix: string; endpoint: string;
-}
-
-export function getR2Config(): R2Config | null {
-  let accountId = process.env.R2_ACCOUNT_ID || '';
-  let keyId = process.env.R2_ACCESS_KEY_ID || '';
-  let secret = process.env.R2_SECRET_ACCESS_KEY || '';
-  const raw = process.env.CLOUDFLARER2TOKEN || '';
-  if ((!keyId || !secret || !accountId) && raw) {
-    const parts: string[] = raw.trim().split(':');
-    if (parts.length >= 3) { accountId = accountId || (parts[0] as string); keyId = keyId || (parts[1] as string); secret = secret || parts.slice(2).join(':'); }
-    else if (parts.length === 2) { keyId = keyId || (parts[0] as string); secret = secret || (parts[1] as string); }
-    else { secret = secret || raw.trim(); }
-  }
-  const bucket = process.env.R2_BUCKET || 'excalidrop';
-  const prefix = process.env.R2_KEY_PREFIX || 'scenes/';
-  if (!accountId || !keyId || !secret) return null;
-  return { accountId, keyId, secret, bucket, prefix, endpoint: `https://${accountId}.r2.cloudflarestorage.com` };
-}
-
-async function sha256Hex(data: string | Buffer): Promise<string> {
-  return crypto.createHash('sha256').update(data).digest('hex');
-}
-function hmac(key: Buffer | string, data: string): Buffer {
-  return crypto.createHmac('sha256', key).update(data).digest();
-}
-
-function sign(method: string, urlStr: string, keyId: string, secret: string, region = 'auto', payloadHash?: string, contentType?: string): { Authorization: string; 'x-amz-date': string; 'x-amz-content-sha256': string } {
-  const url = new URL(urlStr);
-  const now = new Date();
-  const amzDate = now.toISOString().replace(/[-:]/g, '').split('.')[0] + 'Z';
-  const dateStamp = amzDate.slice(0, 8);
-  const hash = payloadHash ?? '';
-  const headers: Record<string, string> = { host: url.host, 'x-amz-content-sha256': hash, 'x-amz-date': amzDate };
-  if (contentType) headers['content-type'] = contentType;
-  const signedHeaders = Object.keys(headers).sort().join(';');
-  const canonicalHeaders = Object.keys(headers).sort().map(k => `${k}:${headers[k]}\n`).join('');
-  const canonical = [method, url.pathname + (url.search ? '' : ''), url.searchParams.toString(), canonicalHeaders, signedHeaders, hash].join('\n');
-  const scope = `${dateStamp}/${region}/s3/aws4_request`;
-  const toSign = ['AWS4-HMAC-SHA256', amzDate, scope, crypto.createHash('sha256').update(canonical).digest('hex')].join('\n');
-  const kDate = hmac('AWS4' + secret, dateStamp);
-  const kRegion = hmac(kDate, region);
-  const kService = hmac(kRegion, 's3');
-  const kSign = hmac(kService, 'aws4_request');
-  const sig = hmac(kSign, toSign).toString('hex');
-  return { Authorization: `AWS4-HMAC-SHA256 Credential=${keyId}/${scope}, SignedHeaders=${signedHeaders}, Signature=${sig}`, 'x-amz-date': amzDate, 'x-amz-content-sha256': hash };
-}
-
-export async function r2Get(cfg: R2Config, key: string): Promise<any | null> {
-  const url = `${cfg.endpoint}/${cfg.bucket}/${cfg.prefix}${key}`;
-  const empty = await sha256Hex('');
-  const s = sign('GET', url, cfg.keyId, cfg.secret, 'auto', empty);
-  const r = await fetch(url, { headers: { Authorization: s.Authorization, 'x-amz-date': s['x-amz-date'], 'x-amz-content-sha256': empty } });
-  if (r.status === 404 || r.status === 403) return null;
-  if (!r.ok) throw new Error(`R2 GET ${r.status}: ${await r.text()}`);
-  return r.json();
-}
-
-export async function r2Put(cfg: R2Config, key: string, body: any): Promise<void> {
-  const data = typeof body === 'string' ? body : JSON.stringify(body);
-  const url = `${cfg.endpoint}/${cfg.bucket}/${cfg.prefix}${key}`;
-  const hash = await sha256Hex(data);
-  const s = sign('PUT', url, cfg.keyId, cfg.secret, 'auto', hash, 'application/json');
-  const r = await fetch(url, { method: 'PUT', body: data, headers: { Authorization: s.Authorization, 'x-amz-date': s['x-amz-date'], 'x-amz-content-sha256': hash, 'Content-Type': 'application/json' } });
-  if (!r.ok) throw new Error(`R2 PUT ${r.status}: ${await r.text()}`);
-}