@fugood/buttress-server 2.26.0-beta.1 → 2.26.0-beta.2

package/lib/routes/anthropic-messages.d.ts

@@ -11,7 +11,7 @@
  *
  * Note: This feature is experimental and may change in future versions.
  */
-import type { EventStream, Config } from '../types';
+import type { EventStream } from '../types';
 /**
  * Stream an Anthropic Messages SSE response from the backend stream.
  *
@@ -52,4 +52,4 @@ export declare function streamAnthropicMessage(completionStream: ReadableStream<
     readonly event: "message_stop";
     readonly data: string;
 }, void, unknown>;
-export default function factory({ global: globalConfig }: Config): import("../types").ButtressApp;
+export default function factory(): import("../types").ButtressApp;

package/lib/routes/openai-compat.d.ts

@@ -6,7 +6,7 @@
  *
  * Note: This feature is experimental and may change in future versions.
  */
-import type { EventStream, Config } from '../types';
+import type { EventStream } from '../types';
 /**
  * Stream an OpenAI-compatible chat completion (SSE) from the backend stream.
  * Mirrors collectChatCompletion (the non-streaming path).
@@ -14,4 +14,4 @@ import type { EventStream, Config } from '../types';
 export declare function streamChatCompletion(completionStream: ReadableStream<EventStream>, completionId: string, created: number, modelId: string, includeUsage: boolean): AsyncGenerator<{
     readonly data: string;
 }, void, unknown>;
-export default function factory({ global: globalConfig }: Config): import("../types").ButtressApp;
+export default function factory(): import("../types").ButtressApp;

package/lib/utils/cors.check.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/utils/cors.d.ts

@@ -0,0 +1,72 @@
+import type { Config } from '../types';
+/**
+ * The server's whole CORS policy, decided in one place, by path.
+ *
+ * Every surface used to install its own `@elysiajs/cors` plugin on its own
+ * router. That does not do what it looks like it does: the plugin works through
+ * an `onRequest` hook, which Elysia runs *before* routing and therefore applies
+ * app-wide regardless of the router it was mounted on, and the plugins' default
+ * response headers all merge into one map on the root app. The four policies
+ * ended up fighting over a single set of `Access-Control-*` headers, last
+ * writer winning:
+ *
+ *  - `/buttress/info` ran without an explicit `allowedHeaders`, which makes
+ *    @elysiajs/cors echo the request's own header names back. That answer
+ *    overwrote every other surface's allow-list, so `Content-Type` was missing
+ *    from it and any browser `POST /functions/<name>` with a JSON body failed
+ *    preflight — the symptom that surfaced this.
+ *  - With that route disabled the *last registered* plugin's header list won
+ *    instead, so `/anthropic-messages` was served `/functions`'s list and lost
+ *    `x-api-key` / `anthropic-version`.
+ *  - `handleOrigin` only ever sets `Access-Control-Allow-Origin` on a match and
+ *    never clears it on a miss, so an origin allow-listed for one surface stayed
+ *    reflected on the others — per-surface `cors_allowed_origins` meant nothing.
+ *
+ * Hence: one hook, one policy per request, chosen by path. A request that no
+ * policy owns gets no `Access-Control-*` headers at all.
+ *
+ * This is CORS only — it decides what a *browser* is willing to hand to script.
+ * It is not the access gate. `functionsAuthGuard` (cross-site `Origin` /
+ * `Sec-Fetch-Site` check) and `buttressAuthGuard` (workspace JWT) still run on
+ * every call and are what actually keeps callers out.
+ */
+export type CorsPolicy = {
+    /** Path the policy owns: this exact path, or anything below it. */
+    path: string;
+    /** `true` reflects whatever `Origin` asked. Only for surfaces with no secrets. */
+    origin: true | string | string[];
+    methods: string[];
+    allowedHeaders: string[];
+    /** Preflight cache lifetime, in seconds. */
+    maxAge: number;
+    /**
+     * Emit `Access-Control-Allow-Credentials`. Never combined with `origin: true`:
+     * reflecting an arbitrary origin *and* allowing credentials is the pairing
+     * that turns a public endpoint into a cross-site read primitive.
+     */
+    credentials: boolean;
+    /** Answer Chrome's Private Network Access opt-in when the client asks for it. */
+    privateNetwork?: boolean;
+};
+/**
+ * Build the policy table from config. The `enable*` flags mirror the conditions
+ * `startServer` mounts each router under, so a surface that isn't served never
+ * gets a CORS answer either.
+ */
+export declare const buildCorsPolicies: (config: Config, enabled?: {
+    openaiCompat?: boolean;
+    anthropicMessages?: boolean;
+    functions?: boolean;
+}) => CorsPolicy[];
+/**
+ * Install the policy table as the single writer of `Access-Control-*` headers.
+ *
+ * Preflights are answered from the hook rather than from `OPTIONS` routes: the
+ * hook runs before routing, so there is nothing to collide with a real route,
+ * and a preflight for an unmounted path simply falls through to a 404. A bare
+ * `OPTIONS` with no `Access-Control-Request-Method` is not a preflight and is
+ * left to routing.
+ */
+export declare const installCors: <T extends {
+    onRequest: (handler: any) => unknown;
+}>(app: T, policies: CorsPolicy[]) => T;

package/lib/utils/workspaceState.d.ts

@@ -11,9 +11,18 @@ export interface ServerKeyPair {
     privateKeyPkcs8: string;
     kid: string;
 }
+export interface BankBinding {
+    /** Public Data Bank API base URL, e.g. https://bank.bricks.tools */
+    endpoint: string;
+    spacename: string;
+    spacekey: string;
+    keyName?: string;
+    issuedAt?: string;
+}
 export interface WorkspaceState {
     workspace: WorkspaceBinding | null;
     serverKeyPair: ServerKeyPair | null;
+    bank: BankBinding | null;
 }
 export declare const resolveStateDir: () => string;
 export declare const resolveStatePath: () => string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fugood/buttress-server",
-  "version": "2.26.0-beta.1",
+  "version": "2.26.0-beta.2",
   "main": "lib/index.mjs",
   "types": "lib/index.d.ts",
   "type": "module",
@@ -69,5 +69,5 @@
     "tsdown": "^0.22.4",
     "typescript": "^7.0.2"
   },
-  "gitHead": "f440d9ba2e55864af3246f9d595829b660b07ada"
+  "gitHead": "e216ee220c5fe1a29c033badb06fe90ba7252cb9"
 }

package/public/status.html

@@ -610,6 +610,16 @@
           <span class="badge badge-info" id="functionsCount">0 functions</span>
         </div>
         <div id="functionsSummary"></div>
+        <div class="section" id="functionsDaemonsSection" style="display:none">
+          <div class="section-title collapsible" onclick="toggleSection(this)">Daemons</div>
+          <div class="collapsible-content" id="functionsDaemons"></div>
+        </div>
+        <div class="section" id="functionsDaemonHistorySection" style="display:none">
+          <div class="section-title collapsible" onclick="toggleSection(this)">Daemon Activity</div>
+          <div class="collapsible-content" id="functionsDaemonHistory">
+            <div class="empty-state">No daemon activity</div>
+          </div>
+        </div>
         <div class="section">
           <div class="section-title collapsible" onclick="toggleSection(this)">Call History</div>
           <div class="collapsible-content" id="functionsCallHistory">
@@ -1287,8 +1297,10 @@
       if (!fns.enabled) return
 
       const count = fns.count ?? 0
+      const daemonCount = fns.daemonCount ?? 0
       document.getElementById('functionsCount').textContent =
-        `${count} function${count !== 1 ? 's' : ''}`
+        `${count} function${count !== 1 ? 's' : ''}` +
+        (daemonCount > 0 ? ` · ${daemonCount} daemon${daemonCount !== 1 ? 's' : ''}` : '')
 
       const c = fns.counters || {}
       const summary = document.getElementById('functionsSummary')
@@ -1309,6 +1321,7 @@
                 </thead>
                 <tbody>
                   ${stat('Calls', c.calls?.total ?? 0, c.calls?.failed ? `${c.calls.failed} failed` : '')}
+                  ${stat('Daemon runs', c.daemons?.invocations ?? 0, c.daemons?.failed ? `${c.daemons.failed} failed` : '')}
                   ${stat('Uploads', `${c.uploads?.total ?? 0} (${formatBytes(c.uploads?.bytes ?? 0)})`, c.uploads?.failed ? `${c.uploads.failed} failed` : '')}
                   ${stat('Downloads', `${c.downloads?.total ?? 0} (${formatBytes(c.downloads?.bytes ?? 0)})`, c.downloads?.missed ? `${c.downloads.missed} missed` : '')}
                   ${stat('Auth checks', c.auth?.total ?? 0, c.auth?.denied ? `${c.auth.denied} denied` : '')}
@@ -1319,6 +1332,8 @@
         `
       })
 
+      renderFunctionsDaemons(fns.daemons || [], fns.history?.daemons || [])
+
       const history = fns.history || {}
       const statusBadge = i => i.success ?
         '<span class="badge badge-success">Success</span>' :
@@ -1362,6 +1377,67 @@
       ])
     }
 
+    // Live daemon state + recent daemon event invocations
+    function renderFunctionsDaemons(daemons, activity) {
+      const hasDaemons = daemons.length > 0
+      document.getElementById('functionsDaemonsSection').style.display = hasDaemons ? '' : 'none'
+      document.getElementById('functionsDaemonHistorySection').style.display =
+        hasDaemons || activity.length > 0 ? '' : 'none'
+
+      if (hasDaemons) {
+        const container = document.getElementById('functionsDaemons')
+        const stateBadge = d => d.state === 'running' ?
+          '<span class="badge badge-success">Running</span>' :
+          `<span class="badge badge-error">Error${d.error ? `: ${escapeHtml(d.error)}` : ''}</span>`
+        const bankBadge = d => {
+          if (!d.bankSubscriptions) return '-'
+          const cls = d.bank === 'connected' ? 'badge-success' :
+            d.bank === 'connecting' ? 'badge-info' : 'badge-warning'
+          return `<span class="badge ${cls}">${escapeHtml(d.bank || 'connecting')} (${d.bankSubscriptions})</span>`
+        }
+        withScrollPreserve(container, () => {
+          container.innerHTML = `
+            <div class="table-wrapper">
+              <div class="table-inner">
+                <table>
+                  <thead>
+                    <tr>
+                      <th>Daemon</th><th>State</th><th>Started</th><th>Timers</th>
+                      <th>Bank</th><th>Events</th><th>Runs</th>
+                    </tr>
+                  </thead>
+                  <tbody>
+                    ${daemons.map(d => `
+                      <tr>
+                        <td title="${escapeHtml(d.description || '')}">${escapeHtml(d.name)}</td>
+                        <td>${stateBadge(d)}</td>
+                        <td><span class="timestamp">${d.startedAt ? formatRelativeTime(d.startedAt) : '-'}</span></td>
+                        <td>${d.timers ?? 0}</td>
+                        <td>${bankBadge(d)}</td>
+                        <td>${d.listening ? '<span class="badge badge-info">listening</span>' : '-'}</td>
+                        <td>${d.counts?.runs ?? 0}${d.counts?.failed ? ` <span class="badge badge-error">${d.counts.failed} failed</span>` : ''}</td>
+                      </tr>
+                    `).join('')}
+                  </tbody>
+                </table>
+              </div>
+            </div>
+          `
+        })
+      }
+
+      renderHistory('functionsDaemonHistory', activity, [
+        { label: 'Time', render: i => `<span class="timestamp">${formatRelativeTime(i.timestamp)}</span>` },
+        { label: 'Daemon', render: i => escapeHtml(i.name) },
+        { label: 'Event', render: i => `<span class="badge badge-info">${escapeHtml(i.event || '-')}</span>` },
+        { label: 'Duration', render: i => `${(i.durationMs / 1000).toFixed(2)}s` },
+        { label: 'Status', render: i => i.success ?
+          '<span class="badge badge-success">Success</span>' :
+          `<span class="badge badge-error">Failed: ${escapeHtml(i.error || 'Unknown')}</span>`
+        },
+      ])
+    }
+
     // Fallback: Fetch status via HTTP polling
     let pollingInterval = null