claude-simple 0.1.0

package/public/api.js

@@ -0,0 +1,78 @@
+// api.js — HTTP + WebSocket helpers
+import { ctx, hubMode, selectedMachineId } from './state.js';
+
+/** Active edge machine id (hub). */
+export function currentMachineId(opts = {}) {
+  if (opts.machineId !== undefined) return opts.machineId;
+  return ctx.machineId || selectedMachineId.peek() || null;
+}
+
+/** Hub endpoints that must NOT be proxied to an edge. */
+function isHubOnlyPath(path) {
+  const p = path.split('?')[0];
+  return p === '/api/hub'
+    || p === '/api/machines'
+    || p.startsWith('/api/auth/');
+}
+
+export async function api(method, path, body, signal, opts = {}) {
+  const machineId = currentMachineId(opts);
+  const headers = {
+    'Content-Type': 'application/json',
+    ...(ctx.token ? { Authorization: `Bearer ${ctx.token}` } : {}),
+  };
+
+  // Hub mode: route data APIs to the selected edge (sessions/files/git/…)
+  if (hubMode.peek() && machineId && !isHubOnlyPath(path)) {
+    headers['X-Machine-Id'] = machineId;
+  }
+
+  const res = await fetch(path, {
+    method,
+    signal,
+    headers,
+    ...(body !== undefined ? { body: JSON.stringify(body) } : {}),
+  });
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) throw new Error(data.error || `HTTP ${res.status}`);
+  return data;
+}
+
+export function sendWs(data) {
+  if (ctx.ws?.readyState === WebSocket.OPEN) ctx.ws.send(JSON.stringify(data));
+}
+
+/** Query string for download links (token + machine in hub mode). */
+export function authQuery(extra = {}) {
+  const q = new URLSearchParams(extra);
+  if (ctx.token) q.set('token', ctx.token);
+  const mid = currentMachineId();
+  if (hubMode.peek() && mid) q.set('machine', mid);
+  return q.toString();
+}
+
+/** Headers for raw fetch (e.g. file upload) in hub mode. */
+export function authHeaders(extra = {}) {
+  const h = { ...extra };
+  if (ctx.token) h.Authorization = `Bearer ${ctx.token}`;
+  const mid = currentMachineId();
+  if (hubMode.peek() && mid) h['X-Machine-Id'] = mid;
+  return h;
+}
+
+export async function probeHub() {
+  try {
+    const res = await fetch('/api/hub');
+    if (!res.ok) {
+      hubMode.value = false;
+      return false;
+    }
+    const data = await res.json();
+    if (data?.hub) {
+      hubMode.value = true;
+      return data;
+    }
+  } catch { /* standalone */ }
+  hubMode.value = false;
+  return false;
+}

package/public/app.js

@@ -0,0 +1,95 @@
+// app.js — Entry point
+import { ctx } from './state.js';
+import { probeHub } from './api.js';
+import { initShell, showApp, initAuth, resumeSession, switchTab, shouldRestoreSessionOnBoot } from './shell.js';
+import { initChat } from './chat.js';
+import { initFilesTab } from './files.js';
+import { initGitTab } from './git.js';
+import { initSettings } from './settings.js';
+import { initTerminal } from './terminal.js';
+import { initImagePaste } from './chat.js';
+import { initMetaAgent } from './agent-panel.js';
+import { initRouter, applyInitialRoute, parseHashPath } from './router.js';
+
+function markBootReady() {
+  const root = document.documentElement;
+  root.classList.add('boot-ready');
+  root.classList.remove('boot-pending');
+  // Keep boot-restore until welcome is intentionally shown (goHome)
+}
+
+function clearBootRestore() {
+  document.documentElement.classList.remove('boot-restore');
+}
+
+const deepLink = parseHashPath(location.hash.slice(1) || '/');
+const restoreSession = shouldRestoreSessionOnBoot() || !!(ctx.token && deepLink?.id);
+
+// 1. Build DOM (welcome already suppressed via html.boot-restore CSS when restoring)
+initShell({ restoreSession });
+
+// 2. Feature panels
+initChat();
+initFilesTab();
+initGitTab();
+initSettings();
+initTerminal();
+initImagePaste();
+initMetaAgent();
+initRouter(resumeSession, switchTab);
+
+// 3. Boot data
+(async () => {
+  const hubPromise = probeHub();
+
+  if (ctx.token) {
+    try {
+      const auth = document.getElementById('auth-screen');
+      const app = document.getElementById('app');
+      if (auth) { auth.style.display = 'none'; auth.classList.add('hidden'); }
+      if (app) { app.style.display = 'flex'; app.classList.remove('hidden'); }
+
+      if (restoreSession) {
+        document.documentElement.classList.add('boot-restore');
+        const welcome = document.getElementById('welcome');
+        const pv = document.getElementById('project-view');
+        if (welcome) {
+          welcome.classList.add('hidden');
+          welcome.style.display = 'none';
+        }
+        if (pv) {
+          pv.classList.remove('hidden');
+          pv.style.cssText = 'display:flex;flex-direction:column;flex:1;min-height:0;overflow:hidden';
+        }
+      }
+
+      const hub = await hubPromise;
+      await showApp({ hub, deepLink });
+      if (!deepLink?.id) {
+        applyInitialRoute();
+        // Home: allow calendar; drop restore lock
+        if (!(location.hash || '').startsWith('#/session/')) clearBootRestore();
+      }
+      // Reveal only after shell + route/session start settled
+      requestAnimationFrame(() => {
+        requestAnimationFrame(markBootReady);
+      });
+    } catch (e) {
+      console.error('[boot]', e);
+      ctx.token = null;
+      localStorage.removeItem('token');
+      clearBootRestore();
+      await initAuth();
+      markBootReady();
+    }
+  } else {
+    clearBootRestore();
+    await initAuth();
+    markBootReady();
+  }
+})();
+
+// When user goes home later, allow welcome again
+document.addEventListener('router:home', () => {
+  clearBootRestore();
+});

package/public/base.css

@@ -0,0 +1,4 @@
+@import "tailwindcss";
+@plugin "daisyui" {
+  themes: light, dark;
+}

package/public/cache.js

@@ -0,0 +1,27 @@
+// cache.js — IndexedDB-backed cache for sessions and workspaces
+import { idb } from './lib.js';
+
+const db = idb('claude-ui');
+const SESSIONS_TTL = 5 * 60 * 1000; // 5 minutes
+
+export async function getCachedSessions() {
+  try { return await db.get('sessions') ?? null; }
+  catch { return null; }
+}
+
+export async function setCachedSessions(sessions) {
+  try { await db.set('sessions', sessions, { ttl: SESSIONS_TTL }); }
+  catch {}
+}
+
+export async function getCachedWorkspaces() {
+  try { return await db.get('workspaces') ?? null; }
+  catch { return null; }
+}
+
+export async function setCachedWorkspaces(workspaces) {
+  try { await db.set('workspaces', workspaces, { ttl: 60 * 60 * 1000 }); } // 1 hour
+  catch {}
+}
+
+// lastSessionContext lives in shell/session-context.js (avoid stale cache.js in browsers)