@gmickel/gno 2.4.0 → 2.6.0

package/src/serve/security.ts

@@ -69,6 +69,15 @@ export function isRequestAllowed(req: Request, port: number): boolean {
   }
 
   // Unsafe methods - require valid Origin or token
+  return isOriginOrTokenAllowed(req, port);
+}
+
+/**
+ * Origin/token check without the safe-method exemption. Owner-only reads
+ * that return host paths use it so a cross-origin page is refused on GET
+ * the same way as on POST.
+ */
+export function isOriginOrTokenAllowed(req: Request, port: number): boolean {
   return validateToken(req) || validateOrigin(req, port);
 }
 

package/src/serve/server.ts

@@ -1,3 +1,4 @@
+import type { HttpGatewayOverrides } from "../mcp/http-security";
 /**
  * Bun.serve() web server for GNO web UI.
  * Uses Bun's fullstack dev server with HTML imports.
@@ -5,8 +6,6 @@
  *
  * @module src/serve/server
  */
-
-import type { HttpGatewayOverrides } from "../mcp/http-security";
 import type { RequestPeerServer } from "./request-locality";
 import type { ResidentRuntime } from "./resident-runtime";
 import type { ContextHolder } from "./routes/api";
@@ -16,6 +15,7 @@ import {
   resolveHttpGatewayConfig,
 } from "../mcp/http-security";
 import { startBackgroundRuntime } from "./background-runtime";
+import { handleCompiledContext } from "./compiled-context";
 import { handleContextBuild, handleContextVerify } from "./context-capsule";
 import { DocumentEventBus } from "./doc-events";
 import {
@@ -82,6 +82,7 @@ import {
   handleTrashDoc,
   handleUpdateCollection,
   handleUpdateCollectionEgressPolicy,
+  handleRequestStatus,
   handleUpdateDoc,
   handleVerifyConnector,
 } from "./routes/api";
@@ -101,6 +102,24 @@ import {
   handleCreateSectionTarget,
   handleResolveSectionTarget,
 } from "./routes/section-targets";
+import {
+  handleSessionsAddSource,
+  handleSessionsAutomationDisable,
+  handleSessionsAutomationEnable,
+  handleSessionsAutomationPreview,
+  handleSessionsAutomationRemove,
+  handleSessionsAutomationRun,
+  handleSessionsAutomationSet,
+  handleSessionsDiscover,
+  handleSessionsImport,
+  handleSessionsInit,
+  handleSessionsRemoveSource,
+  handleSessionsStatus,
+} from "./routes/sessions";
+
+/** `/api/sessions/automation/:id[/...]` path parameter. */
+const automationProfileId = (req: Request): string =>
+  decodeURIComponent(new URL(req.url).pathname.split("/")[4] ?? "");
 import {
   handleTraceDelete,
   handleTraceExport,
@@ -109,7 +128,11 @@ import {
   handleTracePurge,
   handleTraceShow,
 } from "./routes/traces";
-import { forbiddenResponse, isRequestAllowed } from "./security";
+import {
+  forbiddenResponse,
+  isOriginOrTokenAllowed,
+  isRequestAllowed,
+} from "./security";
 import {
   createSpaBundleSource,
   type SpaBundleSource,
@@ -566,6 +589,8 @@ export async function startServer(
         "/collections": spaPageRoute,
         "/connectors": spaPageRoute,
         "/traces": spaPageRoute,
+        "/sessions": spaPageRoute,
+        "/context/compiled": spaPageRoute,
         "/ask": spaPageRoute,
         "/graph": spaPageRoute,
         "/clipper/pair": spaPageRoute,
@@ -832,6 +857,174 @@ export async function startServer(
             );
           },
         },
+        "/api/sessions/status": {
+          GET: async (req: Request) =>
+            withSecurityHeaders(
+              await handleResidentRead(runtime as ResidentRuntime, req, () =>
+                handleSessionsStatus(ctxHolder)
+              ),
+              isDev
+            ),
+        },
+        "/api/sessions/discover": {
+          GET: async (req: Request, server: RequestPeerServer) => {
+            // Returns host paths: a cross-origin page is refused like a write.
+            if (!isOriginOrTokenAllowed(req, port)) {
+              return withSecurityHeaders(forbiddenResponse(), isDev);
+            }
+            return withSecurityHeaders(
+              await handleResidentRead(runtime as ResidentRuntime, req, () =>
+                handleSessionsDiscover(ctxHolder, req, { server })
+              ),
+              isDev
+            );
+          },
+        },
+        "/api/sessions/import": {
+          POST: async (req: Request) => {
+            if (!isRequestAllowed(req, port)) {
+              return withSecurityHeaders(forbiddenResponse(), isDev);
+            }
+            return withSecurityHeaders(
+              await handleSessionsImport(ctxHolder, req),
+              isDev
+            );
+          },
+        },
+        "/api/sessions/sources": {
+          POST: async (req: Request, server: RequestPeerServer) => {
+            if (!isRequestAllowed(req, port)) {
+              return withSecurityHeaders(forbiddenResponse(), isDev);
+            }
+            return withSecurityHeaders(
+              await handleSessionsAddSource(ctxHolder, store, req, { server }),
+              isDev
+            );
+          },
+        },
+        "/api/sessions/sources/:id": {
+          DELETE: async (req: Request, server: RequestPeerServer) => {
+            if (!isRequestAllowed(req, port)) {
+              return withSecurityHeaders(forbiddenResponse(), isDev);
+            }
+            const id = decodeURIComponent(
+              new URL(req.url).pathname.split("/")[4] ?? ""
+            );
+            return withSecurityHeaders(
+              await handleSessionsRemoveSource(ctxHolder, store, id, req, {
+                server,
+              }),
+              isDev
+            );
+          },
+        },
+        "/api/sessions/automation/run": {
+          POST: async (req: Request) => {
+            if (!isRequestAllowed(req, port)) {
+              return withSecurityHeaders(forbiddenResponse(), isDev);
+            }
+            return withSecurityHeaders(
+              await handleSessionsAutomationRun(ctxHolder, store, req),
+              isDev
+            );
+          },
+        },
+        "/api/sessions/automation/:id": {
+          PUT: async (req: Request, server: RequestPeerServer) => {
+            if (!isRequestAllowed(req, port)) {
+              return withSecurityHeaders(forbiddenResponse(), isDev);
+            }
+            return withSecurityHeaders(
+              await handleSessionsAutomationSet(
+                ctxHolder,
+                store,
+                automationProfileId(req),
+                req,
+                { server }
+              ),
+              isDev
+            );
+          },
+          DELETE: async (req: Request, server: RequestPeerServer) => {
+            if (!isRequestAllowed(req, port)) {
+              return withSecurityHeaders(forbiddenResponse(), isDev);
+            }
+            return withSecurityHeaders(
+              await handleSessionsAutomationRemove(
+                ctxHolder,
+                store,
+                automationProfileId(req),
+                req,
+                { server }
+              ),
+              isDev
+            );
+          },
+        },
+        "/api/sessions/automation/:id/preview": {
+          GET: async (req: Request, server: RequestPeerServer) =>
+            !isOriginOrTokenAllowed(req, port)
+              ? withSecurityHeaders(forbiddenResponse(), isDev)
+              : withSecurityHeaders(
+                  await handleResidentRead(
+                    runtime as ResidentRuntime,
+                    req,
+                    () =>
+                      handleSessionsAutomationPreview(
+                        ctxHolder,
+                        automationProfileId(req),
+                        req,
+                        { server }
+                      )
+                  ),
+                  isDev
+                ),
+        },
+        "/api/sessions/automation/:id/enable": {
+          POST: async (req: Request, server: RequestPeerServer) => {
+            if (!isRequestAllowed(req, port)) {
+              return withSecurityHeaders(forbiddenResponse(), isDev);
+            }
+            return withSecurityHeaders(
+              await handleSessionsAutomationEnable(
+                ctxHolder,
+                store,
+                automationProfileId(req),
+                req,
+                { server }
+              ),
+              isDev
+            );
+          },
+        },
+        "/api/sessions/automation/:id/disable": {
+          POST: async (req: Request, server: RequestPeerServer) => {
+            if (!isRequestAllowed(req, port)) {
+              return withSecurityHeaders(forbiddenResponse(), isDev);
+            }
+            return withSecurityHeaders(
+              await handleSessionsAutomationDisable(
+                ctxHolder,
+                store,
+                automationProfileId(req),
+                req,
+                { server }
+              ),
+              isDev
+            );
+          },
+        },
+        "/api/sessions/init": {
+          POST: async (req: Request, server: RequestPeerServer) => {
+            if (!isRequestAllowed(req, port)) {
+              return withSecurityHeaders(forbiddenResponse(), isDev);
+            }
+            return withSecurityHeaders(
+              await handleSessionsInit(ctxHolder, store, req, { server }),
+              isDev
+            );
+          },
+        },
         "/api/memory/remember": {
           POST: async (req: Request) => {
             if (!isRequestAllowed(req, port)) {
@@ -1045,6 +1238,18 @@ export async function startServer(
             );
           },
         },
+        "/api/requests/:requestId": {
+          GET: async (req: Request) => {
+            const url = new URL(req.url);
+            const requestId = decodeURIComponent(
+              url.pathname.split("/").pop() || ""
+            );
+            return withSecurityHeaders(
+              await handleRequestStatus(store, requestId),
+              isDev
+            );
+          },
+        },
         "/api/doc": {
           GET: async (req: Request) => {
             const url = new URL(req.url);
@@ -1164,6 +1369,46 @@ export async function startServer(
             );
           },
         },
+        "/api/context/compiled/preview": {
+          POST: async (req: Request, server: RequestPeerServer) => {
+            if (!isRequestAllowed(req, port))
+              return withSecurityHeaders(forbiddenResponse(), isDev);
+            return withSecurityHeaders(
+              await handleResidentRead(
+                runtime as ResidentRuntime,
+                req,
+                (signal) =>
+                  handleCompiledContext(
+                    ctxHolder.current,
+                    new Request(req, { signal }),
+                    { requestIP: () => server.requestIP(req) },
+                    "preview"
+                  )
+              ),
+              isDev
+            );
+          },
+        },
+        "/api/context/compiled/check": {
+          POST: async (req: Request, server: RequestPeerServer) => {
+            if (!isRequestAllowed(req, port))
+              return withSecurityHeaders(forbiddenResponse(), isDev);
+            return withSecurityHeaders(
+              await handleResidentRead(
+                runtime as ResidentRuntime,
+                req,
+                (signal) =>
+                  handleCompiledContext(
+                    ctxHolder.current,
+                    new Request(req, { signal }),
+                    { requestIP: () => server.requestIP(req) },
+                    "check"
+                  )
+              ),
+              isDev
+            );
+          },
+        },
         "/api/context/verify": {
           POST: async (req: Request) => {
             if (!isRequestAllowed(req, port)) {

package/src/serve/session-automation.ts

@@ -0,0 +1,146 @@
+/**
+ * Daemon-only session automation tick: heartbeat, coalesced schedule
+ * admissions and a drain of pending profiles through the manual importer.
+ *
+ * Runs only in `gno daemon` on a session-archive config (never in `serve`).
+ * One tick at a time over the daemon's background-work tracker; the owner
+ * config is reread every tick, so enable/disable take effect without a
+ * restart. Imports take the shared write lease; a busy lease backs off.
+ */
+
+import type { SessionAutomationRunResult } from "../sessions/types";
+import type { SqliteAdapter } from "../store/sqlite/adapter";
+
+import { acquireCliWriteLease } from "../core/write-lease";
+import { heartbeatAutomation, tickAutomation } from "../sessions/automation";
+import { AUTOMATION_TICK_MS } from "../sessions/automation-state";
+
+const LEASE_HOLDER_COMMAND = "gno daemon (session automation)";
+
+/**
+ * The importer syncs the lexical index itself, so the resident watcher later
+ * sees unchanged files and never queues embedding: do it here for the
+ * collections a run synced, and mark the mutation (as the REST import does).
+ */
+export function notifyAutomationImport(
+  result: SessionAutomationRunResult,
+  sink: {
+    markMutation: () => void;
+    notifySyncComplete: (collections: string[]) => void;
+  }
+): void {
+  const collections = [
+    ...new Set(
+      result.receipts.flatMap((receipt) => receipt.lexical.collections)
+    ),
+  ];
+  if (collections.length === 0) return;
+  sink.markMutation();
+  sink.notifySyncComplete(collections);
+}
+
+export interface SessionAutomationSchedulerOptions {
+  store: SqliteAdapter;
+  configPath: string;
+  indexName: string;
+  dbPath: string;
+  startBackgroundWork: (
+    operation: (signal: AbortSignal) => Promise<void>
+  ) => boolean;
+  /** Called after every run; the daemon logs content-free counts. */
+  onResult?: (result: SessionAutomationRunResult) => void;
+  onError?: (error: unknown) => void;
+  now?: () => Date;
+  tickMs?: number;
+}
+
+export class SessionAutomationScheduler {
+  readonly #options: SessionAutomationSchedulerOptions;
+  readonly #startedAt: Date;
+  #timer: ReturnType<typeof setTimeout> | null = null;
+  #heartbeat: ReturnType<typeof setInterval> | null = null;
+  #running: Promise<void> | null = null;
+  #disposed = false;
+
+  constructor(options: SessionAutomationSchedulerOptions) {
+    this.#options = options;
+    this.#startedAt = (options.now ?? (() => new Date()))();
+  }
+
+  /** Drain once at startup, then tick; heartbeat independently of ticks. */
+  start(): void {
+    this.#beat();
+    this.#heartbeat = setInterval(
+      () => this.#beat(),
+      this.#options.tickMs ?? AUTOMATION_TICK_MS
+    );
+    this.#heartbeat.unref?.();
+    this.#schedule(0);
+  }
+
+  /** A tick or import in progress must not let the heartbeat go stale. */
+  #beat(): void {
+    if (this.#disposed) return;
+    const options = this.#options;
+    heartbeatAutomation({
+      configPath: options.configPath,
+      indexName: options.indexName,
+      now: options.now,
+      daemonStartedAt: this.#startedAt,
+    }).catch((error: unknown) => options.onError?.(error));
+  }
+
+  /** One tick; coalesces with a tick already in flight. */
+  tick(): Promise<void> {
+    if (this.#running) return this.#running;
+    const options = this.#options;
+    const run = tickAutomation({
+      configPath: options.configPath,
+      indexName: options.indexName,
+      store: options.store,
+      now: options.now,
+      daemonStartedAt: this.#startedAt,
+      // The daemon serves MCP and status over HTTP: keep its loop free.
+      inChildProcess: true,
+      acquireLease: async () => {
+        const lease = await acquireCliWriteLease({
+          dbPath: options.dbPath,
+          waitMs: 0,
+          noWait: true,
+          command: LEASE_HOLDER_COMMAND,
+        });
+        return lease.ok ? { ok: true, release: lease.release } : { ok: false };
+      },
+    })
+      .then((results) => {
+        for (const result of results) options.onResult?.(result);
+      })
+      .catch((error: unknown) => options.onError?.(error))
+      .finally(() => {
+        this.#running = null;
+        this.#schedule(options.tickMs ?? AUTOMATION_TICK_MS);
+      });
+    this.#running = run;
+    return run;
+  }
+
+  dispose(): void {
+    this.#disposed = true;
+    if (this.#heartbeat) clearInterval(this.#heartbeat);
+    this.#heartbeat = null;
+    if (this.#timer) clearTimeout(this.#timer);
+    this.#timer = null;
+  }
+
+  #schedule(delayMs: number): void {
+    if (this.#disposed) return;
+    if (this.#timer) clearTimeout(this.#timer);
+    this.#timer = setTimeout(() => {
+      this.#timer = null;
+      if (this.#disposed || this.#running) return;
+      const started = this.#options.startBackgroundWork(() => this.tick());
+      if (!started) this.#schedule(this.#options.tickMs ?? AUTOMATION_TICK_MS);
+    }, delayMs);
+    this.#timer.unref?.();
+  }
+}

package/src/serve/spa-production-build.ts

@@ -79,12 +79,13 @@ const contentTypeFor = (path: string): string => {
   return "application/octet-stream";
 };
 
-export const isStandaloneExecutable = (): boolean =>
-  import.meta.path.includes("/$bunfs/") ||
-  import.meta.path.includes("\\$bunfs\\");
+export const isBunfsPath = (path: string): boolean => {
+  const normalized = path.replaceAll("\\", "/");
+  return normalized.includes("/$bunfs/") || normalized.startsWith("B:/~BUN/");
+};
 
-export const isBunfsPath = (path: string): boolean =>
-  path.includes("/$bunfs/") || path.includes("\\$bunfs\\");
+export const isStandaloneExecutable = (): boolean =>
+  isBunfsPath(import.meta.path);
 
 const rewriteProductionHtml = (html: string, jsEntryPath: string): string => {
   const script = `<script type="module" src="/${basename(jsEntryPath)}"></script>`;