@karmaniverous/jeeves-server 3.0.0-0

package/client/src/lib/api.ts

@@ -0,0 +1,239 @@
+/**
+ * API client for Jeeves Server backend
+ *
+ * Auth: session cookies (Google OAuth) or key-based (?key= URL param).
+ * When a key is present in the URL, it's stored and passed to all API calls.
+ */
+
+const API_BASE = '/api';
+
+/** Extract and cache auth params from URL (once) */
+const _urlParams = new URLSearchParams(window.location.search);
+const _urlKey = _urlParams.get('key');
+
+/** Auth-related params to forward on every API call (key + deep share params) */
+const _authSuffix = (() => {
+  if (!_urlKey) return '';
+  const params = new URLSearchParams();
+  params.set('key', _urlKey);
+  // Forward deep share params so the server can verify the key
+  for (const p of ['d', 'dirs', 's', 'exp'] as const) {
+    const v = _urlParams.get(p);
+    if (v !== null) params.set(p, v);
+  }
+  return params.toString();
+})();
+
+/** Append auth params to a URL if a key was provided */
+export function withKey(url: string): string {
+  if (!_authSuffix) return url;
+  const sep = url.includes('?') ? '&' : '?';
+  return `${url}${sep}${_authSuffix}`;
+}
+
+export interface DirectoryEntry {
+  name: string;
+  type: 'directory' | 'file';
+  ext: string;
+  size: number | null;
+  mtime: string | null;
+}
+
+export interface DirectoryListing {
+  path: string;
+  entries: DirectoryEntry[];
+  breadcrumbs: BreadcrumbItem[];
+  isInsider: boolean;
+  renderAs?: string;
+  matchedRules?: string[];
+}
+
+export interface BreadcrumbItem {
+  label: string;
+  path: string;
+}
+
+export interface DriveEntry {
+  letter: string;
+  label: string;
+}
+
+export interface FileContent {
+  type: 'markdown' | 'text' | 'svg' | 'mermaid' | 'plantuml' | 'image' | 'binary';
+  content?: string;
+  html?: string;
+  headings?: { level: number; text: string; slug: string }[];
+  language?: string | null;
+  contentType?: string;
+  fileName: string;
+  breadcrumbs: BreadcrumbItem[];
+  isInsider: boolean;
+}
+
+export interface ShareResponse {
+  path: string;
+  url: string;
+  exp: string | null;
+  depth: number;
+  dirs: boolean;
+}
+
+export interface ShareSettings {
+  expiry: string;
+  depth: number;
+  dirs: boolean;
+}
+
+export interface AuthStatus {
+  authenticated: boolean;
+  email?: string;
+  picture?: string;
+  isInsider: boolean;
+  keyCreatedAt?: string | null;
+  searchEnabled?: boolean;
+}
+
+/** Rotate insider key — invalidates all existing shares */
+export async function rotateKey(): Promise<{ ok: boolean; keyCreatedAt?: string }> {
+  return fetchJson('/api/rotate-key', { method: 'POST' });
+}
+
+async function fetchJson<T>(url: string, init?: RequestInit): Promise<T> {
+  const res = await fetch(withKey(url), {
+    ...init,
+    credentials: 'same-origin',
+  });
+
+  if (res.status === 401) {
+    window.location.href = `/auth/login?returnTo=${encodeURIComponent(window.location.pathname)}`;
+    throw new Error('Unauthorized');
+  }
+
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`API error ${String(res.status)}: ${body}`);
+  }
+
+  return res.json() as Promise<T>;
+}
+
+export async function getDrives(): Promise<DriveEntry[]> {
+  return fetchJson<DriveEntry[]>(`${API_BASE}/drives`);
+}
+
+export async function getDirectory(path: string): Promise<DirectoryListing> {
+  return fetchJson<DirectoryListing>(`${API_BASE}/path/${path}`);
+}
+
+export async function getFile(path: string): Promise<FileContent> {
+  // Forward render_diagrams param from page URL (used by PDF/DOCX export via Puppeteer)
+  const pageParams = new URLSearchParams(window.location.search);
+  const renderDiagrams = pageParams.get('render_diagrams');
+  const qs = renderDiagrams ? `?render_diagrams=${renderDiagrams}` : '';
+  return fetchJson<FileContent>(`${API_BASE}/file/${path}${qs}`);
+}
+
+export async function getFileRaw(path: string): Promise<FileContent> {
+  return fetchJson<FileContent>(`${API_BASE}/file/${path}?raw=1`);
+}
+
+export async function getAuthStatus(browsePath?: string): Promise<AuthStatus> {
+  let url = `${API_BASE}/auth/status`;
+  if (browsePath) {
+    url += `?path=${encodeURIComponent(browsePath)}`;
+  }
+  const res = await fetch(withKey(url), { credentials: 'same-origin' });
+  if (!res.ok) {
+    return { authenticated: false, isInsider: false };
+  }
+  return res.json() as Promise<AuthStatus>;
+}
+
+/** Generate an outsider share link — computed server-side, no keys on client */
+export async function getShareLink(
+  targetPath: string,
+  expiry?: string,
+  depth?: number,
+  dirs?: boolean,
+): Promise<ShareResponse> {
+  return fetchJson<ShareResponse>(`${API_BASE}/share`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ path: targetPath, expiry, depth, dirs }),
+  });
+}
+
+export async function saveFile(path: string, content: string): Promise<{ ok: boolean; size: number }> {
+  return fetchJson<{ ok: boolean; size: number }>(`${API_BASE}/file/${path}`, {
+    method: 'PUT',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ content }),
+  });
+}
+
+export interface SearchChunk {
+  text: string;
+  index: number;
+  score: number;
+}
+
+export interface SearchResult {
+  filePath: string;
+  browsePath: string;
+  fileName: string;
+  bestScore: number;
+  mtime?: string;
+  domains?: string[];
+  title?: string;
+  author?: string;
+  participants?: string;
+  chunks: SearchChunk[];
+}
+
+export interface SearchMetadata {
+  domains: string[];
+  authors: string[];
+  participants: string[];
+}
+
+export interface SearchResponse {
+  results: SearchResult[];
+  metadata: SearchMetadata;
+}
+
+export async function searchDocuments(
+  query: string,
+  limit = 20,
+  filter?: Record<string, unknown>,
+): Promise<SearchResponse> {
+  return fetchJson<SearchResponse>(`${API_BASE}/search`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ query, limit, filter }),
+  });
+}
+
+
+export interface SearchFacet {
+  field: string;
+  type: string;
+  uiHint: string;
+  values: string[];
+  rules: string[];
+}
+
+export interface FacetsResponse {
+  facets: SearchFacet[];
+}
+
+export async function fetchFacets(): Promise<FacetsResponse> {
+  return fetchJson<FacetsResponse>(`${API_BASE}/search/facets`);
+}
+
+export async function clearCache(path: string): Promise<{ cleared: { exports: number; diagrams: number } }> {
+  return fetchJson<{ cleared: { exports: number; diagrams: number } }>(
+    `${API_BASE}/export-cache/${path}`,
+    { method: 'DELETE' },
+  );
+}
+

package/client/src/lib/auth.tsx

@@ -0,0 +1,50 @@
+/**
+ * Auth provider component.
+ */
+import { useCallback, useEffect, useState } from 'react';
+import type { ReactNode } from 'react';
+
+import { getAuthStatus, rotateKey as apiRotateKey } from './api';
+import { AuthContext } from './AuthContext';
+
+export function AuthProvider({ children }: { children: ReactNode }) {
+  const [loading, setLoading] = useState(true);
+  const [authenticated, setAuthenticated] = useState(false);
+  const [email, setEmail] = useState<string | undefined>();
+  const [picture, setPicture] = useState<string | undefined>();
+  const [isInsider, setIsInsider] = useState(false);
+  const [keyCreatedAt, setKeyCreatedAt] = useState<string | null | undefined>();
+  const [searchEnabled, setSearchEnabled] = useState(false);
+
+  useEffect(() => {
+    const browsePath = window.location.pathname.replace(/^\/browse/, '') || '/';
+    getAuthStatus(browsePath)
+      .then((status) => {
+        setAuthenticated(status.authenticated);
+        setEmail(status.email);
+        setPicture(status.picture);
+        setIsInsider(status.isInsider);
+        setSearchEnabled(!!status.searchEnabled);
+        setKeyCreatedAt(status.keyCreatedAt);
+      })
+      .catch(() => {
+        setAuthenticated(false);
+      })
+      .finally(() => setLoading(false));
+  }, []);
+
+  const rotateKey = useCallback(async () => {
+    const result = await apiRotateKey();
+    if (result.ok && result.keyCreatedAt) {
+      setKeyCreatedAt(result.keyCreatedAt);
+    }
+  }, []);
+
+  return (
+    <AuthContext.Provider
+      value={{ loading, authenticated, email, picture, isInsider, searchEnabled, keyCreatedAt, rotateKey }}
+    >
+      {children}
+    </AuthContext.Provider>
+  );
+}

package/client/src/lib/codeBlockCm6.ts

@@ -0,0 +1,129 @@
+/**
+ * Replaces server-rendered highlight.js code blocks in markdown with
+ * CodeMirror 6 read-only instances for syntax highlighting and code folding.
+ * Call after rendering markdown HTML.
+ */
+import { getLanguageExtension, loadCodeMirror } from '@/lib/codemirror';
+
+/** Map highlight.js language classes to file extensions for CM6 */
+function langClassToExt(className: string): string | null {
+  const match = /language-(\w+)/.exec(className);
+  if (!match) return null;
+  const lang = match[1];
+  // Map hljs language names to file extensions
+  const map: Record<string, string> = {
+    javascript: 'js', typescript: 'ts', python: 'py',
+    json: 'json', yaml: 'yaml', yml: 'yaml',
+    html: 'html', css: 'css', xml: 'xml',
+    java: 'java', rust: 'rs', sql: 'sql', php: 'php',
+    cpp: 'cpp', c: 'c', markdown: 'md',
+    jsx: 'jsx', tsx: 'tsx', scss: 'scss',
+    bash: 'sh', shell: 'sh', sh: 'sh',
+    plaintext: '', text: '',
+  };
+  return map[lang] ?? lang;
+}
+
+export function initCodeBlockCm6(container: HTMLElement, theme: 'light' | 'dark' = 'dark'): () => void {
+  const cleanups: (() => void)[] = [];
+  const pres = container.querySelectorAll('pre');
+  const mounts: Promise<void>[] = [];
+
+  for (const pre of pres) {
+    const code = pre.querySelector('code');
+    if (!code) continue;
+
+    // Skip diagram placeholders
+    if (pre.closest('.embedded-diagram-lazy')) continue;
+    if (pre.closest('.embedded-diagram-rendered')) continue;
+
+    const ext = langClassToExt(code.className) ?? '';
+
+    const text = code.textContent ?? '';
+    if (!text.trim()) continue;
+
+    // Create a wrapper div for the CM6 instance
+    const wrapper = document.createElement('div');
+    wrapper.className = 'cm6-embedded-code';
+    pre.replaceWith(wrapper);
+
+    // Load CM6 async and mount
+    mounts.push(mountCm6(wrapper, text, ext, theme, cleanups));
+  }
+
+  // Signal completion for Puppeteer export
+  void Promise.all(mounts).then(() => {
+    container.setAttribute('data-cm6-ready', 'true');
+  });
+
+  return () => { for (const fn of cleanups) fn(); };
+}
+
+async function mountCm6(
+  wrapper: HTMLDivElement,
+  text: string,
+  ext: string,
+  theme: 'light' | 'dark',
+  cleanups: (() => void)[],
+): Promise<void> {
+  try {
+    const { EditorView, EditorState, basicSetup, oneDark } = await loadCodeMirror();
+    const langExt = await getLanguageExtension(ext);
+
+    // Check if wrapper is still in the DOM (component may have unmounted)
+    if (!wrapper.isConnected) return;
+
+    const extensions = [
+      basicSetup,
+      EditorState.readOnly.of(true),
+      EditorView.editable.of(false),
+      // Theme must come before custom overrides so our styles win
+      ...(theme === 'dark' ? [oneDark] : []),
+      EditorView.theme({
+        '&': {
+          fontSize: '14px',
+          borderRadius: '0.5rem',
+          overflow: 'hidden',
+          border: '1px solid var(--color-border)',
+        },
+        '.cm-scroller': { overflow: 'auto' },
+        '.cm-content': {
+          fontFamily: "'JetBrains Mono', 'Fira Code', 'Consolas', monospace",
+          padding: '0.75rem 0',
+        },
+        '.cm-gutters': {
+          fontFamily: "'JetBrains Mono', 'Fira Code', 'Consolas', monospace",
+          backgroundColor: 'var(--color-muted)',
+          borderRight: '1px solid var(--color-border)',
+          color: 'var(--color-muted-foreground)',
+        },
+        '&.cm-editor': {
+          backgroundColor: 'var(--color-muted)',
+        },
+        '.cm-cursor': { display: 'none' },
+        '.cm-activeLineGutter': {
+          backgroundColor: 'transparent',
+        },
+        '.cm-activeLine': {
+          backgroundColor: 'transparent',
+        },
+      }),
+    ];
+
+    if (langExt) {
+      extensions.push(langExt);
+    }
+
+    const state = EditorState.create({ doc: text, extensions });
+    const view = new EditorView({ state, parent: wrapper });
+
+    cleanups.push(() => view.destroy());
+  } catch {
+    // If CM6 fails to load, restore the original pre/code
+    wrapper.innerHTML = `<pre class="hljs rounded-lg overflow-x-auto text-sm border border-border p-4 bg-muted text-foreground"><code>${escapeHtml(text)}</code></pre>`;
+  }
+}
+
+function escapeHtml(str: string): string {
+  return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}

package/client/src/lib/codeBlockCopy.ts

@@ -0,0 +1,43 @@
+/**
+ * Injects copy buttons into all <pre> blocks within a container element.
+ * Call after rendering markdown HTML.
+ */
+import { createElement, Copy, Check } from 'lucide';
+
+function createIcon(iconData: typeof Copy, size = 14): SVGSVGElement {
+  return createElement(iconData, { size }) as unknown as SVGSVGElement;
+}
+
+export function injectCopyButtons(container: HTMLElement) {
+  const pres = container.querySelectorAll('pre');
+  pres.forEach((pre) => {
+    if (pre.querySelector('.code-copy-btn')) return; // already injected
+
+    // Make pre relative for absolute positioning of button
+    pre.style.position = 'relative';
+
+    const btn = document.createElement('button');
+    btn.className = 'code-copy-btn';
+    btn.title = 'Copy to clipboard';
+    btn.innerHTML = '';
+    btn.appendChild(createIcon(Copy));
+
+    btn.addEventListener('click', () => {
+      const code = pre.querySelector('code');
+      const text = code?.textContent ?? pre.textContent ?? '';
+      void navigator.clipboard.writeText(text).then(() => {
+        btn.innerHTML = '';
+        const checkIcon = createIcon(Check);
+        btn.appendChild(checkIcon);
+        btn.style.color = '#4ade80';
+        setTimeout(() => {
+          btn.innerHTML = '';
+          btn.appendChild(createIcon(Copy));
+          btn.style.color = '';
+        }, 1500);
+      });
+    });
+
+    pre.appendChild(btn);
+  });
+}

package/client/src/lib/codemirror.ts

@@ -0,0 +1,77 @@
+/**
+ * Shared CodeMirror 6 utilities: core loader and language detection.
+ * Used by both CodeViewer (read-only) and CodeEditor (editable).
+ */
+
+/** Lazy-load core CodeMirror modules */
+export async function loadCodeMirror() {
+  const [
+    { EditorView, basicSetup },
+    { EditorState },
+    { keymap },
+    { oneDark },
+  ] = await Promise.all([
+    import('codemirror'),
+    import('@codemirror/state'),
+    import('@codemirror/view'),
+    import('@codemirror/theme-one-dark'),
+  ]);
+  return { EditorView, EditorState, basicSetup, keymap, oneDark };
+}
+
+/** Map file extensions to CodeMirror language support (lazy-loaded) */
+export async function getLanguageExtension(ext: string) {
+  switch (ext.toLowerCase()) {
+    case 'js':
+    case 'jsx':
+    case 'mjs':
+    case 'cjs':
+      return (await import('@codemirror/lang-javascript')).javascript({ jsx: ext.includes('x') });
+    case 'ts':
+    case 'tsx':
+    case 'mts':
+    case 'cts':
+      return (await import('@codemirror/lang-javascript')).javascript({ jsx: ext.includes('x'), typescript: true });
+    case 'html':
+    case 'htm':
+      return (await import('@codemirror/lang-html')).html();
+    case 'css':
+    case 'scss':
+      return (await import('@codemirror/lang-css')).css();
+    case 'json':
+    case 'jsonl':
+      return (await import('@codemirror/lang-json')).json();
+    case 'md':
+    case 'mdx':
+    case 'markdown':
+      return (await import('@codemirror/lang-markdown')).markdown();
+    case 'py':
+    case 'pyw':
+      return (await import('@codemirror/lang-python')).python();
+    case 'xml':
+    case 'svg':
+    case 'xsl':
+    case 'xhtml':
+      return (await import('@codemirror/lang-xml')).xml();
+    case 'yaml':
+    case 'yml':
+      return (await import('@codemirror/lang-yaml')).yaml();
+    case 'c':
+    case 'h':
+    case 'cpp':
+    case 'hpp':
+    case 'cc':
+    case 'cxx':
+      return (await import('@codemirror/lang-cpp')).cpp();
+    case 'java':
+      return (await import('@codemirror/lang-java')).java();
+    case 'rs':
+      return (await import('@codemirror/lang-rust')).rust();
+    case 'sql':
+      return (await import('@codemirror/lang-sql')).sql();
+    case 'php':
+      return (await import('@codemirror/lang-php')).php();
+    default:
+      return null;
+  }
+}

package/client/src/lib/runner-api.ts

@@ -0,0 +1,172 @@
+/**
+ * API client for jeeves-runner proxy endpoints.
+ * Unwraps runner API responses and maps snake_case to camelCase.
+ */
+
+import { withKey } from './api';
+
+const RUNNER_BASE = '/api/runner';
+
+async function runnerFetch<T>(path: string, init?: RequestInit): Promise<T> {
+  const res = await fetch(withKey(`${RUNNER_BASE}${path}`), {
+    ...init,
+    credentials: 'same-origin',
+  });
+
+  if (res.status === 401) {
+    window.location.href = `/auth/login?returnTo=${encodeURIComponent(window.location.pathname)}`;
+    throw new Error('Unauthorized');
+  }
+
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`Runner API error ${String(res.status)}: ${body}`);
+  }
+
+  return res.json() as Promise<T>;
+}
+
+// --- Raw runner API shapes (snake_case) ---
+
+interface RawJob {
+  id: string;
+  name: string;
+  type: string;
+  schedule: string;
+  enabled: number;
+  overlap_policy: string;
+  last_status: string | null;
+  last_run: string | null;
+  description: string | null;
+}
+
+interface RawRun {
+  id: number;
+  job_id: string;
+  status: string;
+  trigger: string;
+  started_at: string;
+  finished_at: string | null;
+  duration_ms: number | null;
+  exit_code: number | null;
+  stdout_tail: string;
+  stderr_tail: string;
+}
+
+interface RawStats {
+  totalJobs: number;
+  running: number;
+  okLastHour: number;
+  errorsLastHour: number;
+}
+
+// --- Public types (camelCase) ---
+
+export interface RunnerStats {
+  totalJobs: number;
+  running: number;
+  okLastHour: number;
+  errorsLastHour: number;
+}
+
+export interface RunnerJob {
+  id: string;
+  name: string;
+  type: string;
+  schedule: string;
+  enabled: boolean;
+  overlapPolicy: string;
+  status: string | null;
+  lastRun: string | null;
+  description: string | null;
+}
+
+export interface RunEntry {
+  id: number;
+  jobId: string;
+  status: string;
+  trigger: string;
+  startedAt: string;
+  finishedAt: string | null;
+  durationMs: number | null;
+  exitCode: number | null;
+  stdoutTail: string;
+  stderrTail: string;
+}
+
+function mapJob(raw: RawJob): RunnerJob {
+  return {
+    id: raw.id,
+    name: raw.name,
+    type: raw.type,
+    schedule: raw.schedule,
+    enabled: raw.enabled === 1,
+    overlapPolicy: raw.overlap_policy,
+    status: raw.last_status,
+    lastRun: raw.last_run,
+    description: raw.description,
+  };
+}
+
+function mapRun(raw: RawRun): RunEntry {
+  return {
+    id: raw.id,
+    jobId: raw.job_id,
+    status: raw.status,
+    trigger: raw.trigger,
+    startedAt: raw.started_at,
+    finishedAt: raw.finished_at,
+    durationMs: raw.duration_ms,
+    exitCode: raw.exit_code,
+    stdoutTail: raw.stdout_tail,
+    stderrTail: raw.stderr_tail,
+  };
+}
+
+export async function getRunnerStats(): Promise<RunnerStats> {
+  const raw = await runnerFetch<RawStats>('/stats');
+  return raw;
+}
+
+export async function getRunnerJobs(): Promise<RunnerJob[]> {
+  const raw = await runnerFetch<{ jobs: RawJob[] }>('/jobs');
+  return raw.jobs.map(mapJob);
+}
+
+export async function getRunnerJob(id: string): Promise<RunnerJob> {
+  const raw = await runnerFetch<{ job: RawJob }>(
+    `/jobs/${encodeURIComponent(id)}`,
+  );
+  return mapJob(raw.job);
+}
+
+export async function getJobRuns(
+  id: string,
+  limit = 20,
+): Promise<RunEntry[]> {
+  const raw = await runnerFetch<{ runs: RawRun[] }>(
+    `/jobs/${encodeURIComponent(id)}/runs?limit=${String(limit)}`,
+  );
+  return raw.runs.map(mapRun);
+}
+
+export async function triggerJobRun(id: string): Promise<{ ok: boolean }> {
+  return runnerFetch<{ ok: boolean }>(
+    `/jobs/${encodeURIComponent(id)}/run`,
+    { method: 'POST' },
+  );
+}
+
+export async function enableJob(id: string): Promise<{ ok: boolean }> {
+  return runnerFetch<{ ok: boolean }>(
+    `/jobs/${encodeURIComponent(id)}/enable`,
+    { method: 'POST' },
+  );
+}
+
+export async function disableJob(id: string): Promise<{ ok: boolean }> {
+  return runnerFetch<{ ok: boolean }>(
+    `/jobs/${encodeURIComponent(id)}/disable`,
+    { method: 'POST' },
+  );
+}