@fyresmith/hive-server 1.0.1-3

package/lib/yjsServer.js

@@ -0,0 +1,277 @@
+import { createRequire } from 'module';
+import { readFileSync } from 'fs';
+import { WebSocketServer } from 'ws';
+import * as vault from './vaultManager.js';
+import * as auth from './auth.js';
+
+// Load both y-websocket and yjs via CJS require so they share the same
+// module instance — avoids the "Yjs was already imported" duplicate warning.
+const require = createRequire(import.meta.url);
+const { setupWSConnection, docs, getYDoc } = require('y-websocket/bin/utils');
+
+const PERSIST_DEBOUNCE_MS = 250;
+const IDLE_ROOM_TTL_MS = 15000;
+
+/** @type {Map<string, {
+ *   docName: string,
+ *   relPath: string,
+ *   clients: Set<any>,
+ *   observed: boolean,
+ *   closed: boolean,
+ *   dirty: boolean,
+ *   flushing: boolean,
+ *   persistTimer: any,
+ *   closeTimer: any,
+ *   lastPersistAt: number|null,
+ *   lastPersistHash: string|null,
+ *   lastPersistError: string|null
+ * }>}
+ */
+const roomStates = new Map();
+
+/** @type {null | ((relPath: string, hash: string, excludeSocketId: string|null) => void)} */
+let broadcastRef = null;
+
+function getOrCreateRoomState(docName, relPath) {
+  let state = roomStates.get(docName);
+  if (!state) {
+    state = {
+      docName,
+      relPath,
+      clients: new Set(),
+      observed: false,
+      closed: false,
+      dirty: false,
+      flushing: false,
+      persistTimer: null,
+      closeTimer: null,
+      lastPersistAt: null,
+      lastPersistHash: null,
+      lastPersistError: null,
+    };
+    roomStates.set(docName, state);
+  } else {
+    state.relPath = relPath;
+  }
+  return state;
+}
+
+function clearTimers(state) {
+  if (state.persistTimer) {
+    clearTimeout(state.persistTimer);
+    state.persistTimer = null;
+  }
+  if (state.closeTimer) {
+    clearTimeout(state.closeTimer);
+    state.closeTimer = null;
+  }
+}
+
+async function flushRoomState(state) {
+  if (state.flushing) return;
+  state.flushing = true;
+
+  try {
+    while (state.dirty) {
+      state.dirty = false;
+      const ydoc = docs.get(state.docName);
+      if (!ydoc) break;
+
+      const text = ydoc.getText('content').toString();
+      try {
+        await vault.writeFile(state.relPath, text);
+        const hash = vault.hashContent(text);
+        state.lastPersistAt = Date.now();
+        state.lastPersistHash = hash;
+        state.lastPersistError = null;
+        broadcastRef?.(state.relPath, hash, null);
+        console.log(`[yjs] Persisted: ${state.relPath}`);
+      } catch (err) {
+        state.lastPersistError = err instanceof Error ? err.message : String(err);
+        state.dirty = true;
+        console.error(`[yjs] Persist error for ${state.relPath}:`, err);
+        await new Promise((resolve) => setTimeout(resolve, 250));
+      }
+    }
+  } finally {
+    state.flushing = false;
+  }
+}
+
+function scheduleRoomPersist(state) {
+  if (state.closed) return;
+  state.dirty = true;
+  if (state.persistTimer) clearTimeout(state.persistTimer);
+  state.persistTimer = setTimeout(() => {
+    state.persistTimer = null;
+    void flushRoomState(state);
+  }, PERSIST_DEBOUNCE_MS);
+}
+
+function observeRoom(state) {
+  if (state.observed) return;
+  const ydoc = docs.get(state.docName);
+  if (!ydoc) return;
+
+  state.observed = true;
+  ydoc.getText('content').observe(() => {
+    if (state.closed) return;
+    scheduleRoomPersist(state);
+  });
+}
+
+function scheduleIdleClose(state) {
+  if (state.closeTimer) clearTimeout(state.closeTimer);
+  state.closeTimer = setTimeout(() => {
+    state.closeTimer = null;
+    if (state.clients.size > 0) return;
+    void closeRoom(state.docName, { closeClients: false, reason: 'idle' });
+  }, IDLE_ROOM_TTL_MS);
+}
+
+async function closeRoom(docName, { closeClients, reason }) {
+  const state = roomStates.get(docName);
+  if (!state) return;
+
+  state.closed = true;
+  clearTimers(state);
+
+  if (closeClients) {
+    for (const conn of state.clients) {
+      try {
+        conn.close(4004, 'Room closed');
+      } catch {
+        // ignore close failures
+      }
+    }
+    state.clients.clear();
+  }
+
+  await flushRoomState(state);
+
+  const ydoc = docs.get(docName);
+  if (ydoc) {
+    try {
+      ydoc.destroy();
+    } catch {
+      // ignore destroy failures
+    }
+    docs.delete(docName);
+  }
+
+  roomStates.delete(docName);
+  console.log(`[yjs] Room closed (${reason}): ${state.relPath}`);
+}
+
+function trackRoomClient(state, conn) {
+  if (state.closeTimer) {
+    clearTimeout(state.closeTimer);
+    state.closeTimer = null;
+  }
+  state.clients.add(conn);
+
+  conn.on('close', () => {
+    if (state.closed) return;
+    state.clients.delete(conn);
+    if (state.clients.size === 0) {
+      scheduleIdleClose(state);
+    }
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+export function getActiveRooms() {
+  return new Set(docs.keys());
+}
+
+export function getRoomStatus() {
+  return [...roomStates.values()].map((state) => ({
+    relPath: state.relPath,
+    clients: state.clients.size,
+    dirty: state.dirty,
+    lastPersistAt: state.lastPersistAt,
+    lastPersistHash: state.lastPersistHash,
+    lastPersistError: state.lastPersistError,
+  }));
+}
+
+export async function forceCloseRoom(relPath) {
+  const docName = encodeURIComponent(relPath);
+  if (!roomStates.has(docName) && !docs.has(docName)) return;
+  await closeRoom(docName, { closeClients: true, reason: 'forced' });
+}
+
+export function startYjsServer(broadcastFileUpdated) {
+  broadcastRef = broadcastFileUpdated;
+  const port = parseInt(process.env.YJS_PORT ?? '3001', 10);
+  const wss = new WebSocketServer({ port });
+
+  wss.on('connection', (conn, req) => {
+    const url = new URL(req.url, 'http://localhost');
+
+    // Strip /yjs/ prefix added by Cloudflare Tunnel routing
+    const rawDocName = url.pathname
+      .replace(/^\/yjs\//, '')
+      .replace(/^\//, '');
+
+    if (!rawDocName) {
+      conn.close(4000, 'Missing room name');
+      return;
+    }
+
+    const token = url.searchParams.get('token');
+    try {
+      auth.verifyWsToken(token);
+    } catch {
+      conn.close(4001, 'Unauthorized');
+      return;
+    }
+
+    let relPath;
+    try {
+      relPath = decodeURIComponent(rawDocName);
+    } catch {
+      conn.close(4002, 'Invalid room path');
+      return;
+    }
+
+    if (!vault.isAllowed(relPath)) {
+      conn.close(4003, 'Forbidden path');
+      return;
+    }
+
+    const isNewRoom = !docs.has(rawDocName);
+
+    if (isNewRoom) {
+      // Pre-create the WSSharedDoc with file content synchronously.
+      // getYDoc registers it in the docs map — setupWSConnection will find
+      // it already populated and send that content as sync step 1, so clients
+      // never see an empty doc and Y.Text never gets double-initialized.
+      const ydoc = getYDoc(rawDocName, true);
+      try {
+        const absPath = vault.safePath(relPath);
+        const content = readFileSync(absPath, 'utf-8');
+        if (content) {
+          ydoc.getText('content').insert(0, content);
+        }
+      } catch {
+        // File doesn't exist yet — start with empty document
+      }
+    }
+
+    setupWSConnection(conn, req, { docName: rawDocName, gc: true });
+    const state = getOrCreateRoomState(rawDocName, relPath);
+    observeRoom(state);
+    trackRoomClient(state, conn);
+
+    if (isNewRoom) {
+      console.log(`[yjs] Room opened: ${relPath}`);
+    }
+  });
+
+  console.log(`[yjs] WebSocket server listening on port ${port}`);
+  return wss;
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@fyresmith/hive-server",
+  "version": "1.0.1-3",
+  "type": "module",
+  "description": "Collaborative Obsidian vault server",
+  "main": "index.js",
+  "files": [
+    "bin",
+    "cli",
+    "lib",
+    "routes",
+    "index.js",
+    "README.md"
+  ],
+  "bin": {
+    "hive": "bin/hive.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "start": "node index.js",
+    "dev": "node --watch index.js",
+    "build": "npm run verify && npm pack --dry-run",
+    "status": "node bin/hive.js status",
+    "verify": "node scripts/verify.mjs",
+    "install-hive": "node scripts/install-hive.mjs",
+    "test": "npm run verify"
+  },
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "chokidar": "^3.6.0",
+    "commander": "^13.1.0",
+    "discord-oauth2": "^2.12.0",
+    "dotenv": "^16.4.5",
+    "execa": "^9.6.0",
+    "express": "^4.19.2",
+    "jsonwebtoken": "^9.0.2",
+    "prompts": "^2.4.2",
+    "socket.io": "^4.7.5",
+    "which": "^6.0.0",
+    "ws": "^8.17.1",
+    "y-websocket": "^1.5.4",
+    "yjs": "^13.6.18"
+  },
+  "devDependencies": {
+    "socket.io-client": "^4.8.3"
+  }
+}

package/routes/auth.js

@@ -0,0 +1,99 @@
+import { Router } from 'express';
+import DiscordOauth2 from 'discord-oauth2';
+import jwt from 'jsonwebtoken';
+import { randomBytes } from 'crypto';
+
+const router = Router();
+const oauth = new DiscordOauth2();
+
+/**
+ * CSRF state map: state → { timestamp }
+ * Entries expire after 10 minutes.
+ * @type {Map<string, {ts: number}>}
+ */
+const stateMap = new Map();
+const STATE_TTL_MS = 10 * 60 * 1000;
+
+function pruneStates() {
+  const now = Date.now();
+  for (const [key, val] of stateMap) {
+    if (now - val.ts > STATE_TTL_MS) stateMap.delete(key);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// GET /auth/login
+// ---------------------------------------------------------------------------
+router.get('/login', (req, res) => {
+  pruneStates();
+  const state = randomBytes(16).toString('hex');
+  stateMap.set(state, { ts: Date.now() });
+
+  const url = oauth.generateAuthUrl({
+    clientId: process.env.DISCORD_CLIENT_ID,
+    scope: ['identify', 'guilds'],
+    redirectUri: process.env.DISCORD_REDIRECT_URI,
+    state,
+  });
+
+  res.redirect(url);
+});
+
+// ---------------------------------------------------------------------------
+// GET /auth/callback
+// ---------------------------------------------------------------------------
+router.get('/callback', async (req, res) => {
+  const { code, state } = req.query;
+
+  if (!state || !stateMap.has(state)) {
+    return res.status(400).send('Invalid or expired state parameter.');
+  }
+  stateMap.delete(state);
+
+  if (!code) {
+    return res.status(400).send('Missing authorization code.');
+  }
+
+  try {
+    // Exchange code for access token
+    const tokenData = await oauth.tokenRequest({
+      clientId: process.env.DISCORD_CLIENT_ID,
+      clientSecret: process.env.DISCORD_CLIENT_SECRET,
+      redirectUri: process.env.DISCORD_REDIRECT_URI,
+      code,
+      scope: ['identify', 'guilds'],
+      grantType: 'authorization_code',
+    });
+
+    const accessToken = tokenData.access_token;
+
+    // Verify guild membership
+    const guilds = await oauth.getUserGuilds(accessToken);
+    const isMember = guilds.some((g) => g.id === process.env.DISCORD_GUILD_ID);
+    if (!isMember) {
+      return res.status(403).send('Access denied: you are not a member of the required Discord server.');
+    }
+
+    // Fetch user profile
+    const user = await oauth.getUser(accessToken);
+    const { id, username, avatar } = user;
+    const avatarUrl = avatar
+      ? `https://cdn.discordapp.com/avatars/${id}/${avatar}.png`
+      : `https://cdn.discordapp.com/embed/avatars/${parseInt(id) % 5}.png`;
+
+    // Sign JWT
+    const token = jwt.sign(
+      { id, username, avatarUrl },
+      process.env.JWT_SECRET,
+      { expiresIn: '30d' }
+    );
+
+    // Redirect to Obsidian URI handler
+    res.redirect(`obsidian://hive-auth?token=${encodeURIComponent(token)}`);
+  } catch (err) {
+    console.error('[auth] OAuth callback error:', err);
+    res.status(500).send('Authentication failed. Please try again.');
+  }
+});
+
+export default router;