@lanes-sh/link 0.2.2 → 0.3.1

package/src/server/index.ts

@@ -3,6 +3,13 @@ import type { Logger } from '#connectivity';
 import { capabilityIdForToolName } from '#server/mcp';
 import { ATTACHMENTS_PATH, stageAttachment } from './attachments.ts';
 import { allowedHostnamesFor, rebindingRefusal } from './rebinding.ts';
+import { ANY_ORIGIN, corsAware, type CorsPolicy } from './cors.ts';
+import {
+  DASHBOARD_PATH,
+  dashboardSessions,
+  handleDashboard,
+  servesDashboard,
+} from './dashboard.ts';
 import type { Generation } from './generation.ts';
 import type { Generations } from './generations.ts';
 import { callerKey, failedAuthLimiter, FAILED_AUTH_PER_MINUTE, tooManyAttempts } from './edge.ts';
@@ -49,6 +56,15 @@ export interface ServerOptions {
   readonly authorization?: AuthorizationSurface | undefined;
   /** Hostnames this endpoint answers to. See `./rebinding.ts`. */
   readonly allowedHostnames?: readonly string[] | undefined;
+  /**
+   * Serve the dashboard.
+   *
+   * Off unless asked for, and `serve()` withholds it anyway when the bind
+   * address is not loopback. `lanes link start` asks; `container.ts` does not.
+   * See `./dashboard.ts` for why a deployed instance has no browser-shaped door
+   * to put it behind.
+   */
+  readonly dashboard?: boolean | undefined;
 }
 
 type RefusalReason = Extract<AuthOutcome, { ok: false }>['reason'];
@@ -110,6 +126,7 @@ export interface RequestHandler {
 export function createRequestHandler(options: ServerOptions): RequestHandler {
   let probedAt = 0;
   const failedAuth = failedAuthLimiter();
+  const sessions = dashboardSessions();
 
   /**
    * Re-read the config because a call named a tool we do not serve.
@@ -169,6 +186,19 @@ export function createRequestHandler(options: ServerOptions): RequestHandler {
         });
       }
 
+      // Above the 404 gate and outside the bearer path below, because a
+      // top-level browser navigation carries no `Authorization` header — so it
+      // authenticates itself, against the same authenticator. Unset, this is
+      // never reached and `/dashboard` is a 404 like any other unknown path.
+      if (options.dashboard && url.pathname === DASHBOARD_PATH) {
+        return await handleDashboard(request, {
+          generations: options.generations,
+          authenticator: options.authenticator,
+          primary: options.primary,
+          sessions,
+        });
+      }
+
       if (
         url.pathname !== MCP_PATH &&
         url.pathname !== ATTACHMENTS_PATH &&
@@ -335,17 +365,26 @@ export function serve(options: ServeOptions): RunningServer {
   const host = options.host ?? primary.config.instance.host;
   const port = options.port ?? primary.config.instance.port;
 
-  const allowedHostnames = options.allowedHostnames ?? allowedHostnamesFor(host, isLoopback(host));
+  const loopback = isLoopback(host);
+  const allowedHostnames = options.allowedHostnames ?? allowedHostnamesFor(host, loopback);
+
+  // Cross-origin access, and its absence, are decided here for the same reason
+  // `allowedHostnames` and `dashboard` are: they are all properties of what this
+  // is bound to. The two are mutually exclusive and the exclusion is the
+  // decision — see `./cors.ts`, and ADR-039.
+  const cors: CorsPolicy | undefined = loopback
+    ? undefined
+    : { allowedOrigins: primary.config.auth.allowed_origins ?? [ANY_ORIGIN] };
   const handler = createRequestHandler({
     ...options,
+    dashboard: servesDashboard(options.dashboard, loopback),
     ...(allowedHostnames ? { allowedHostnames } : {}),
   });
 
-  const server = Bun.serve({
-    hostname: host,
-    port,
-    fetch: (request: Request) => handler.fetch(request),
-  });
+  const route = (request: Request): Promise<Response> => handler.fetch(request);
+  const fetch = cors ? corsAware(route, [MCP_PATH, ATTACHMENTS_PATH], cors) : route;
+
+  const server = Bun.serve({ hostname: host, port, fetch });
 
   return {
     url: `http://${host}:${port}${MCP_PATH}`,

package/src/server/mcp/index.ts

@@ -28,6 +28,7 @@ export {
   visibleCapabilities,
   visibleToolCount,
   type BuildServerOptions,
+  type ConnectionState,
   type MergedCapability,
   type ProfileRuntime,
 } from './visibility.ts';

package/src/server/mcp/instructions.ts

@@ -87,6 +87,23 @@ const SETUP = `**What is set up is answerable.** Before saying something cannot
 that an account must be added, call \`setup_overview\` — then \`setup_provider\`
 for the exact command. Running it is the owner's to do; inventing it is not.`;
 
+/**
+ * The one about not signing as the wrong person.
+ *
+ * It carries no names, and that is deliberate rather than thrift. Inlining the
+ * declaration would put a per-profile list into a string with a fixed ceiling —
+ * so the workspace with the most identities to keep straight is exactly the one
+ * whose list would be summarised away first. A pointer costs the same for one
+ * profile as for twenty, and `identity_list` has room to say when each applies,
+ * which is the half that actually prevents the mistake.
+ *
+ * Conditional like the rest: a profile that declares nothing has no `identity`
+ * connection, so the capability is unreachable and this paragraph is unspent.
+ */
+const IDENTITY = `**Identity is declared, not inferred.** Where a name, address or handle of the
+owner's is needed, call \`identity_list\`: a profile may hold several, each with a
+note on when it applies.`;
+
 const FILES = `**Files are named, not carried.** Where a tool takes attachments, give a path, an
 HTTPS URL, or an attachment already on another message; the endpoint reads the
 bytes. Never encode a file into a call — that is the thing this replaces.`;
@@ -122,6 +139,7 @@ const OWNER_HABITS: Record<string, string> = {
   skills: SKILLS,
   vault: VAULT,
   setup: SETUP,
+  identity: IDENTITY,
 };
 
 /**
@@ -137,6 +155,15 @@ const OWNER_HABITS: Record<string, string> = {
  * precisely the one that holds no skills directory, so the skill is not a place
  * it can go. Only an endpoint serving remote clients spends it.
  *
+ * Raised a second time, to 2500, for `IDENTITY`, and the same answer for the
+ * same reason: an agent signing as the wrong person has already sent the
+ * message, and a skill loaded only when relevant is not loaded at the moment
+ * that happens. The measured worst case — twenty profiles, twenty connections
+ * each, every owner provider reachable, remote clients — is 2474, so this is
+ * the measurement plus a little, not a round number picked first. Two things
+ * hold it there: the paragraph names no identity, and it is spent only by a
+ * profile that declared one.
+ *
  * Exported because the test asserted `2000` as a literal while the code
  * reserved room against a second, differently-derived number — so the two could
  * disagree, and did. There is no separate listing allowance any more: `spent`
@@ -144,7 +171,7 @@ const OWNER_HABITS: Record<string, string> = {
  * exactly the final length, because `join` adds the same two characters the
  * reduce already counted.
  */
-export const MAX_INSTRUCTIONS = 2300;
+export const MAX_INSTRUCTIONS = 2500;
 
 /** Which of the owner-layer providers this principal can actually reach. */
 function ownerProviders(merged: ReadonlyMap<string, MergedCapability>): string[] {

package/src/server/mcp/visibility.ts

@@ -20,6 +20,20 @@ import { allowedConnections } from '#policy';
  * still a leak.
  */
 
+/**
+ * A connection's reconciled state, as much of it as a reader needs.
+ *
+ * Structural rather than the store's own `ConnectionRecord`: `server` does not
+ * import `stores` (`src/architecture.test.ts`), and what a surface that reports
+ * wants from a connection is its key and whether it is working — not the
+ * timestamps and credential expiry the repository keeps behind it.
+ */
+export interface ConnectionState {
+  readonly provider: string;
+  readonly id: string;
+  readonly status: string;
+}
+
 /** Everything one profile contributes to the endpoint. */
 export interface ProfileRuntime {
   readonly config: Config;
@@ -35,6 +49,25 @@ export interface ProfileRuntime {
    * how often to ask (ADR-014).
    */
   refreshSkills?(): Promise<void>;
+  /**
+   * Which target's adapters this profile was opened against.
+   *
+   * Not derivable from `config`: a target is *selected* per run, and the config
+   * only says which one is the default. Optional for the same reason the one
+   * below is — a runtime built to answer "what is visible" was never opened
+   * against anything.
+   */
+  readonly target?: string | undefined;
+  /**
+   * Reconciled connection state, for a surface that reports rather than
+   * dispatches.
+   *
+   * Optional exactly as `refreshSkills` is: only a served endpoint holds the
+   * state handle this reads through, and nothing on the dispatch path asks —
+   * a capability's visibility is decided by policy, not by whether the
+   * credential behind it currently works.
+   */
+  connections?(): Promise<readonly ConnectionState[]>;
 }
 
 export interface BuildServerOptions {

package/src/stores/blobs/route.ts

@@ -0,0 +1,123 @@
+import { containedKey, type BlobKey, type BlobMetadata, type BlobStore } from './index.ts';
+
+/**
+ * Sending part of a store's key space somewhere else.
+ *
+ * `scopeBlobStore` narrows a store to a namespace; this one splits a store
+ * between backends. A key under a route's prefix is served by that route's
+ * store — which is rooted *at* the prefix, so the prefix is stripped on the way
+ * in and put back on the way out — and every other key falls through to the
+ * base.
+ *
+ * It exists for one shape and it is worth naming it, because the alternative
+ * was much larger. A profile's memory is not addressed by a name anything
+ * declares: core scopes the profile's blob root to `<provider>/<connection>`
+ * inside `buildProviderContext`, and `lanes link memory` reaches the same bytes
+ * by calling the same two functions. So "put memory somewhere else" is not a
+ * question the provider, the dispatcher, or the CLI can be asked — it is a
+ * property of the store all three were handed. Routing the root means none of
+ * them changes, and none of them can disagree about where an entry went.
+ *
+ * A route's store is expected to enforce its own containment: it is a
+ * `BlobStore` like any other, and the base's rules do not travel across the
+ * boundary.
+ */
+
+export interface BlobRoute {
+  /**
+   * The key prefix this route claims, ending in `/`.
+   *
+   * Directory-shaped on purpose. A bare `memory` would also claim
+   * `memory-archive/x`, and a store that quietly swallows a neighbouring
+   * namespace is the kind of bug that surfaces as missing data rather than as
+   * an error.
+   */
+  readonly prefix: string;
+  /** A store rooted at `prefix`, so it never sees the prefix itself. */
+  readonly store: BlobStore;
+}
+
+export function routeBlobStore(base: BlobStore, routes: readonly BlobRoute[]): BlobStore {
+  if (routes.length === 0) return base;
+
+  const normalised = routes.map((route) => {
+    if (route.prefix.length === 0) {
+      throw new Error('A blob route prefix must not be empty — that is the base store.');
+    }
+    return { ...route, prefix: route.prefix.endsWith('/') ? route.prefix : `${route.prefix}/` };
+  });
+
+  /**
+   * Which store owns this key, and what it calls it.
+   *
+   * Contained first, so `memory/../elsewhere.md` is judged by where it lands
+   * rather than by how it is spelled — routing on the raw string would let a
+   * traversal pick its own backend, which is a weaker answer than either store
+   * gives on its own.
+   */
+  const routeFor = (key: BlobKey): { store: BlobStore; key: BlobKey } => {
+    const resolved = containedKey(key);
+    for (const route of normalised) {
+      if (resolved.startsWith(route.prefix)) {
+        return { store: route.store, key: resolved.slice(route.prefix.length) };
+      }
+    }
+    return { store: base, key };
+  };
+
+  return {
+    async put(key, data, options) {
+      const to = routeFor(key);
+      return to.store.put(to.key, data, options);
+    },
+
+    async get(key) {
+      const to = routeFor(key);
+      return to.store.get(to.key);
+    },
+
+    async has(key) {
+      const to = routeFor(key);
+      return to.store.has(to.key);
+    },
+
+    async delete(key) {
+      const to = routeFor(key);
+      return to.store.delete(to.key);
+    },
+
+    /**
+     * Merge the listings, with routed keys removed from the base's.
+     *
+     * Three cases, and the middle one is the one that is easy to miss: a
+     * listing prefix *inside* a route belongs wholly to that route, a listing
+     * prefix *containing* a route has to include everything that route holds,
+     * and a listing that touches neither is the base's alone. Sorted at the end
+     * because callers rely on it — `skillFingerprint` sorts its own output, but
+     * `loadProfileSkills` reads the listing in order.
+     */
+    async list(prefix) {
+      const asked = prefix ?? '';
+
+      for (const route of normalised) {
+        if (asked.startsWith(route.prefix)) {
+          const inner = await route.store.list(asked.slice(route.prefix.length));
+          return inner.map((entry) => ({ ...entry, key: `${route.prefix}${entry.key}` }));
+        }
+      }
+
+      const results: BlobMetadata[] = (await base.list(asked)).filter(
+        (entry) => !normalised.some((route) => entry.key.startsWith(route.prefix)),
+      );
+
+      for (const route of normalised) {
+        if (!route.prefix.startsWith(asked)) continue;
+        for (const entry of await route.store.list()) {
+          results.push({ ...entry, key: `${route.prefix}${entry.key}` });
+        }
+      }
+
+      return results.sort((a, b) => a.key.localeCompare(b.key));
+    },
+  };
+}