@onlyne/mcp-gateway 3.0.0 → 3.1.0

package/src/index.ts

@@ -1,18 +1,25 @@
 import {
-  OnlyneNode, OnlyneError, type Auth, type KeyHook, type MaintenanceClock, type NodeId, type Plugins, type Resource,
+  OnlyneNode, OnlyneError, type Auth, type KeyHook, type MaintenanceClock, type NodeId, type Plugins,
+  type Resource, type ResourceDriver,
 } from '@onlyne/lib';
 import { createMcpBridge, resourceOf, McpConnection, type McpServerOptions } from '@onlyne/mcp-core';
 import type { GatewayConfig, ServerConfig } from './config.js';
 import { FileStorage } from '@onlyne/im-gateway/storage';
+import { createMountService, MOUNTS_RESOURCE_PREFIX, type MountService, type MountTransport } from './mounts.js';
 import { t } from './gateway-text.js';
 
 export type { GatewayConfig, ServerConfig } from './config.js';
+export type { MountService } from './mounts.js';
 
 export interface McpGateway {
   readonly node: OnlyneNode;
   readonly config: GatewayConfig;
   /** The MCP connections, one per configured server, keyed by resource id. */
   readonly connections: Map<string, McpConnection>;
+  /** The scheduled-mount service; its driver is part of the node's resource routing. */
+  readonly mounts: MountService;
+  /** Display lines for the node host's TUI: servers, mounts, push queue, recent results. */
+  status(): Promise<string[]>;
   stop(): Promise<void>;
 }
 
@@ -25,10 +32,10 @@ export function nodeClock(): MaintenanceClock {
 }
 
 /**
- * Assembles the gateway: one session per configured MCP server, one Onlyne resource per server.
- * A server that cannot be reached at startup still registers (with its last known tools if the
- * store has them, an empty list otherwise): the node stays up, and the session re-initializes
- * on the first call (RFC 0015 §5).
+ * Assembles the gateway: one session per configured MCP server, one Onlyne resource per server,
+ * and — when configured — one scheduler resource per mount controller. A server that cannot be
+ * reached at startup still registers (with its last known tools if the store has them, an empty
+ * list otherwise): the node stays up, and the session re-initializes on the first call (RFC 0015 §5).
  */
 export interface McpGatewayOptions {
   log?: (message: string, fields?: Record<string, unknown>) => void;
@@ -98,24 +105,70 @@ export async function createMcpGateway(config: GatewayConfig, options: McpGatewa
           node: event.entry.node_id, phase: event.phase, fingerprint: event.entry.fingerprint, cause: event.cause,
         });
       },
-      supports: async () => false,
+      // The gateway stores messages but holds no model context: it can fulfill every plan
+      // except an await, which would need a model to answer. Its own scheduled result
+      // messages are admitted locally under the thread it owns, so this gate must allow
+      // `response: none`; refusing it would turn every run result into a delivery refusal.
+      supports: async plan => plan.response !== 'await',
       inject: async () => { throw new OnlyneError('unsupported_delivery', t('error.noContext')); },
     },
     domainCandidates: async domain_id => node.discovery.candidates(domain_id),
     ...(keys === undefined ? {} : { keys }),
   };
   let node: OnlyneNode;
+  let mounts: MountService | undefined;
+  const requireMounts = (): MountService => {
+    if (mounts === undefined) throw new OnlyneError('unsupported_delivery', 'The scheduler is not assembled yet.');
+    return mounts;
+  };
+  // One driver routes a resource by id: the scheduler owns `mounts:<controller>`, every other id
+  // belongs to the configured MCP server of that name (config rejects a server on the prefix).
+  const resources: ResourceDriver = {
+    validate: (resource, operation, data) => (resource.resource_ref.id.startsWith(MOUNTS_RESOURCE_PREFIX)
+      ? requireMounts().driver.validate(resource, operation, data)
+      : bridge.validate(resource, operation, data)),
+    execute: (resource, request, signal) => (resource.resource_ref.id.startsWith(MOUNTS_RESOURCE_PREFIX)
+      ? requireMounts().driver.execute(resource, request, signal)
+      : bridge.execute(resource, request, signal)),
+  };
   node = new OnlyneNode({
     node_id: owner,
     base_url,
     // RFC 0017 §1: a keyed node advertises the scheme it authenticates with. The keyless
     // binding stays for programmatic callers on loopback.
     authentication: keys === undefined ? ['none'] : ['signature'],
-    plugins: { ...plugins, storage, resources: bridge },
+    plugins: { ...plugins, storage, resources },
     now: () => Date.now(),
     id: () => crypto.randomUUID(),
   });
 
+  const transport: MountTransport = {
+    // One thread per task: the first mount creates it, a restart recovers the same id, and the
+    // result messages land in one readable conversation instead of one thread per run.
+    ensureThread: async (threadId, title) => {
+      try {
+        await node.threads.create(node.auth, {
+          id: threadId, title,
+          idempotency_key: crypto.randomUUID(),
+          retry_until: new Date(Date.now() + 86_400_000).toISOString(),
+        });
+      } catch (error) {
+        if (!(error instanceof OnlyneError) || error.error.code !== 'id_conflict') throw error;
+      }
+    },
+    // A target this node cannot name yet is a queue condition, not a peer refusal: the run's
+    // result stays pending until discovery finds the controller.
+    resolveTarget: async id => { await node.discovery.resolve(id); },
+    send: (controller, message) => node.client.send(controller, message, { response: 'none', execution: 'existing' }),
+  };
+  mounts = createMountService({
+    owner, config: config.mounts, servers: config.servers, storage,
+    connections, transport,
+    ...(options.log === undefined ? {} : { log: options.log }),
+  });
+  await mounts.start();
+  const mountService = mounts;
+
   const gatewayAuth: Auth = { actor: owner };
   for (const [index, entry] of config.servers.entries()) {
     const controllers = Array.from(new Set([owner, ...(entry.controllers ?? [])]));
@@ -133,19 +186,29 @@ export async function createMcpGateway(config: GatewayConfig, options: McpGatewa
       retention_ms: 0,
       data: definition.data,
     };
-    try {
-      await node.resources.describe(gatewayAuth, definition.resource_ref);
-    } catch (error) {
-      if (!(error instanceof OnlyneError) || error.error.code !== 'not_found') throw error;
-      await node.resources.register(gatewayAuth, resource);
-    }
+    await registerResource(node, gatewayAuth, resource);
+  }
+  for (const { resource } of mountService.resources()) {
+    await registerResource(node, gatewayAuth, resource);
   }
 
   return {
-    node, config, connections,
+    node, config, connections, mounts: mountService,
+    status: () => mountService.status(),
     async stop(): Promise<void> {
+      await mountService.stop();
       node.client.stopMaintenance();
       for (const connection of connections.values()) await connection.close();
     },
   };
 }
+
+/** Registration is idempotent for the same definition; a changed definition is a real conflict. */
+async function registerResource(node: OnlyneNode, auth: Auth, resource: Resource): Promise<void> {
+  try {
+    await node.resources.describe(auth, resource.resource_ref);
+  } catch (error) {
+    if (!(error instanceof OnlyneError) || error.error.code !== 'not_found') throw error;
+    await node.resources.register(auth, resource);
+  }
+}

package/src/main.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env bun
-import { createLogger, createNodeKey, startNodeHost } from '@onlyne/node-host';
+import { createLogger, createNodeKey, startNodeHost, type NodeHostOptions } from '@onlyne/node-host';
 import { resolveLocale, setLocale } from '@onlyne/node-host/i18n';
 import { dirname, join } from 'node:path';
 import { loadConfig } from './config.js';
@@ -17,9 +17,11 @@ const config = await loadConfig(path);
 // logger and the node host below are built after this point so their text follows it too.
 setLocale(resolveLocale(config.language));
 // On a terminal the TUI owns the screen, so log lines go to the ring it renders and to a file
-// beside the store; the ring alone would vanish with the process.
+// beside the store; the ring alone would vanish with the process. `ONLYNE_NO_TUI=1` asks for
+// the JSON log even on a terminal, so the operator keeps a machine-readable stream.
+const forceJson = process.env.ONLYNE_NO_TUI === '1';
 const { log, ring } = createLogger(
-  !(process.stdin.isTTY && process.stdout.isTTY), 200, join(dirname(config.storage_path), 'gateway.log'),
+  forceJson || !(process.stdin.isTTY && process.stdout.isTTY), 200, join(dirname(config.storage_path), 'gateway.log'),
 );
 // RFC 0017 §2: the CLI is always keyed, and a missing key is generated and saved under
 // ~/.config/onlyne/keys/<node-id>/ instead of being a hand-written prerequisite.
@@ -37,7 +39,14 @@ handler = request => gateway.node.fetch(request);
 gateway.node.client.runMaintenance();
 // Discovery starts only once the real handler is served: a candidate probe aimed at this
 // node must reach the gateway instead of the starting stub.
-const host = await startNodeHost({ node: gateway.node, endpoint, bind: config.server.bind, ring, log });
+// The scheduler's status lines ride into the shared trust TUI through the host's status hook;
+// the node host owns how they are drawn.
+type NodeHostSurface = NodeHostOptions & { status?: () => Promise<string[]> };
+const hostOptions: NodeHostSurface = {
+  node: gateway.node, endpoint, bind: config.server.bind, ring, log,
+  status: () => gateway.status(),
+};
+const host = await startNodeHost(hostOptions);
 
 const shutdown = async (): Promise<void> => {
   await host.close();