@stage-labs/metro 0.1.0-beta.302 → 0.1.0-beta.304

package/runtime/node_modules/@metro-labs/daemon/src/connectors/org-runtime.ts

@@ -1,35 +1,23 @@
 import { log } from '@metro-labs/core/log';
-import { agentsDir } from '../agents/files.js';
-import { assertMigrationOutcomeKnown, beginMigrationOperation, migrationRequestEffectful, type MigrationOperation } from './migration-operations.js';
 import type { FetchLike } from '@metro-labs/core/stations/oauth';
 import type { ToolGroup } from '@metro-labs/core/stations/types';
 import { effectiveConnectorPolicy, type DeliveredConnector, type DeliverySnapshot } from '@metro-labs/http/connector-delivery';
 import type { ApiError } from '@metro-labs/http/api-error';
 import { requestConnectorBlocker, type GateRow } from './gates.js';
 import { publishOrgConnectors } from './publication.js';
-import type { MigrationRuntimeMapping } from './migration-guard.js';
-import { isOrgRelayId, orgRelayId } from './relay-id.js';
+import { orgRelayId } from './relay-id.js';
 import type { RelaySession } from './relay-session.js';
 import type { RelayTarget } from './relay-target.js';
 import type { OrgConnectorSync } from './org-sync.js';
 import { discoverOrgGroups, orgMissing, orgRuntimeError, orgSignin, orgUnavailable } from './org-runtime-discovery.js';
 
-interface RuntimeDeps {
-  enabled?: () => boolean;
-  mapping?: () => MigrationRuntimeMapping;
-  migrationDir?: string;
+export interface RuntimeDeps {
   publish?: (rows: readonly GateRow[]) => void;
   fetch?: FetchLike;
 }
 
-interface RuntimeRow extends DeliveredConnector {
-  relayId: string;
-  relayName: string;
-}
-
 interface Entry {
   id: string;
-  relayId: string;
   epoch: number;
   stamp: string;
   controller: AbortController;
@@ -41,14 +29,13 @@ interface Entry {
 
 interface Session {
   entry: Entry;
-  operation: MigrationOperation | null;
   controller: AbortController;
   revision: string | null;
   error: ApiError | null;
 }
 
-const stampOf = (row: RuntimeRow): string => JSON.stringify([
-  row.relayId, row.relayName, row.name, row.url, row.auth, row.policy.read ?? 'allow', row.policy.write ?? 'allow',
+const stampOf = (row: DeliveredConnector): string => JSON.stringify([
+  row.name, row.url, row.auth, row.policy.read ?? 'allow', row.policy.write ?? 'allow',
   Object.entries(row.policy.tools ?? {}).sort(([a], [b]) => a.localeCompare(b)), row.policyLayers,
 ]);
 
@@ -85,18 +72,14 @@ export class OrgConnectorRuntime {
     this.update();
   }
 
-  private enabled(): boolean {
-    return !this.stopped && (this.deps.enabled?.() ?? process.env.METRO_CONNECTORS_LIVE_ENABLED === 'true');
-  }
-
-  private abort(session: Session, error: ApiError, drain = false): void {
+  private abort(session: Session, error: ApiError): void {
     session.error ??= error;
-    if (!drain) session.controller.abort();
+    session.controller.abort();
   }
 
-  private publish(rows: RuntimeRow[]): void {
+  private publish(rows: DeliveredConnector[]): void {
     const metadata: GateRow[] = rows.map((row) => ({
-      id: row.relayId, name: row.relayName,
+      id: orgRelayId(row.id), name: row.name,
       config: { policy: effectiveConnectorPolicy(row, this.entries.get(row.id)?.groups ?? {}), toolGroups: { ...this.entries.get(row.id)?.groups } },
     }));
     const text = JSON.stringify(metadata);
@@ -111,48 +94,27 @@ export class OrgConnectorRuntime {
     }
   }
 
-  private invalidateEntries(rows: RuntimeRow[], epoch: number, available: boolean): void {
+  private invalidateEntries(rows: DeliveredConnector[], epoch: number, available: boolean): void {
     for (const [id, entry] of this.entries) {
       const row = rows.find((value) => value.id === id);
       const valid = available && entry.epoch === epoch;
       if (valid && row?.state === 'ready' && entry.stamp === stampOf(row)) continue;
-      const error = valid ? rowError(row) ?? orgUnavailable() : orgUnavailable();
-      this.invalidateEntry(entry, row, error);
+      this.invalidateEntry(entry, valid ? rowError(row) ?? orgUnavailable() : orgUnavailable());
     }
   }
 
-  private invalidateEntry(entry: Entry, row: RuntimeRow | undefined, error: ApiError): void {
-    const drain = !isOrgRelayId(entry.relayId) && row?.relayId !== entry.relayId;
-    if (!drain) entry.controller.abort();
+  private invalidateEntry(entry: Entry, error: ApiError): void {
+    entry.controller.abort();
     this.entries.delete(entry.id);
-    this.abortEntry(entry, error, drain);
-  }
-
-  private abortEntry(entry: Entry, error: ApiError, drain = false): void {
-    for (const session of this.sessions) if (session.entry === entry) this.abort(session, error, drain);
+    for (const session of this.sessions) if (session.entry === entry) this.abort(session, error);
   }
 
-  private mappedRows(rows: DeliveredConnector[], mapping: MigrationRuntimeMapping): RuntimeRow[] {
-    return rows.flatMap((row) => {
-      const alias = mapping.aliases.find((value) => value.destinationId === row.id);
-      if (alias !== undefined) return [{ ...row, relayId: alias.sourceId, relayName: alias.name }];
-      return this.enabled() && !mapping.reserved.includes(row.id) ? [{ ...row, relayId: orgRelayId(row.id), relayName: row.name }] : [];
-    });
-  }
-
-  private mapping(): MigrationRuntimeMapping {
-    if (this.stopped) return { aliases: [], reserved: [] };
-    return this.deps.mapping?.() ?? { aliases: [], reserved: [] };
-  }
-
-  private update(): RuntimeRow[] | null {
+  private update(): DeliveredConnector[] | null {
     try {
-      const mapping = this.mapping();
-      const wanted = this.enabled() || mapping.aliases.length > 0;
-      const snapshot = wanted ? this.sync.read() : null;
+      const snapshot = this.stopped ? null : this.sync.read();
       const epoch = this.sync.epoch();
-      if (this.held(snapshot, wanted, epoch)) return null;
-      const rows = this.mappedRows(snapshot?.connectors ?? [], mapping);
+      if (this.held(snapshot, epoch)) return null;
+      const rows = snapshot?.connectors ?? [];
       this.invalidateEntries(rows, epoch, snapshot !== null);
       this.track(rows, epoch);
       this.publish(rows);
@@ -164,27 +126,19 @@ export class OrgConnectorRuntime {
     }
   }
 
-  private track(rows: RuntimeRow[], epoch: number): void {
+  private track(rows: DeliveredConnector[], epoch: number): void {
     for (const row of rows) {
       if (row.state !== 'ready' || this.entries.has(row.id)) continue;
-      this.entries.set(row.id, { id: row.id, relayId: row.relayId, epoch, stamp: stampOf(row), controller: new AbortController(), groups: {}, scan: null, nextScan: 0, error: null });
+      this.entries.set(row.id, { id: row.id, epoch, stamp: stampOf(row), controller: new AbortController(), groups: {}, scan: null, nextScan: 0, error: null });
     }
   }
 
-  private held(snapshot: DeliverySnapshot | null, wanted: boolean, epoch: number): boolean {
-    if (snapshot !== null || !wanted || !this.sync.lapsed()) return false;
+  private held(snapshot: DeliverySnapshot | null, epoch: number): boolean {
+    if (snapshot !== null || this.stopped || !this.sync.lapsed()) return false;
     this.invalidateEntries([], epoch, false);
     return true;
   }
 
-  refresh(): void {
-    this.update();
-  }
-
-  idle(id?: string): boolean {
-    return ![...this.sessions].some((session) => id === undefined || session.entry.relayId === id);
-  }
-
   private currentEntry(entry: Entry): DeliveredConnector {
     const rows = this.update();
     if (rows === null || entry.epoch !== this.sync.epoch()) throw orgUnavailable();
@@ -193,7 +147,6 @@ export class OrgConnectorRuntime {
     const error = rowError(row);
     if (error !== null) throw error;
     if (entry.controller.signal.aborted || this.entries.get(entry.id) !== entry) throw orgUnavailable();
-    if (!isOrgRelayId(entry.relayId)) assertMigrationOutcomeKnown(entry.relayId, this.deps.migrationDir);
     return row;
   }
 
@@ -216,30 +169,22 @@ export class OrgConnectorRuntime {
     return this.currentEntry(entry);
   }
 
-  private migrationOperation(entry: Entry): MigrationOperation | null {
-    return isOrgRelayId(entry.relayId) ? null : beginMigrationOperation(entry.relayId, this.deps.migrationDir ?? agentsDir(), true);
-  }
-
   private async scan(entry: Entry): Promise<void> {
     const row = this.currentEntry(entry);
     const signal = AbortSignal.any([entry.controller.signal, AbortSignal.timeout(45_000)]);
-    const operation = this.migrationOperation(entry);
-    try {
-      const send = this.deps.fetch ?? fetch;
-      const groups = await discoverOrgGroups(row.url, {
-        fresh: (revision) => this.fresh(entry, revision === undefined ? undefined : { connectorId: entry.id, revision }),
-        current: () => this.currentEntry(entry), signal,
-        fetch: (input, init) => operation?.dispatch(() => send(input, init), { effectful: migrationRequestEffectful(init?.method, init?.body) }) ?? send(input, init),
-      });
-      this.currentEntry(entry);
-      if (JSON.stringify(groups) !== JSON.stringify(entry.groups)) {
-        for (const session of this.sessions) if (session.entry === entry && session.revision !== null) this.abort(session, orgUnavailable());
-      }
-      entry.groups = groups;
-      entry.error = null;
-      entry.nextScan = performance.now() + 60_000;
-      this.update();
-    } finally { operation?.close(); }
+    const groups = await discoverOrgGroups(row.url, {
+      fresh: (revision) => this.fresh(entry, revision === undefined ? undefined : { connectorId: entry.id, revision }),
+      current: () => this.currentEntry(entry), signal,
+      fetch: this.deps.fetch ?? fetch,
+    });
+    this.currentEntry(entry);
+    if (JSON.stringify(groups) !== JSON.stringify(entry.groups)) {
+      for (const session of this.sessions) if (session.entry === entry && session.revision !== null) this.abort(session, orgUnavailable());
+    }
+    entry.groups = groups;
+    entry.error = null;
+    entry.nextScan = performance.now() + 60_000;
+    this.update();
   }
 
   private discover(entry: Entry): Promise<void> | null {
@@ -291,16 +236,15 @@ export class OrgConnectorRuntime {
   open(id: string): RelaySession {
     const rows = this.update();
     if (rows === null) throw orgUnavailable();
-    const mapped = rows.find((row) => row.relayId === id);
-    const error = rowError(mapped);
+    const found = rows.find((row) => orgRelayId(row.id) === id);
+    const error = rowError(found);
     if (error !== null) throw error;
-    const entry = mapped === undefined ? undefined : this.entries.get(mapped.id);
+    const entry = found === undefined ? undefined : this.entries.get(found.id);
     if (entry === undefined) throw orgUnavailable();
-    const session: Session = { entry, operation: this.migrationOperation(entry), controller: new AbortController(), revision: null, error: null };
+    const session: Session = { entry, controller: new AbortController(), revision: null, error: null };
     this.sessions.add(session);
     const blocker = requestConnectorBlocker();
     return {
-      dispatch: (send, effectful) => { this.currentSession(session); return session.operation?.dispatch(send, { effectful }) ?? send(); },
       target: (force) => this.target(session, force),
       current: () => {
         const row = this.currentSession(session);
@@ -312,7 +256,7 @@ export class OrgConnectorRuntime {
         return blocker();
       },
       signal: session.controller.signal,
-      close: () => { this.abort(session, orgUnavailable()); session.operation?.close(); this.sessions.delete(session); },
+      close: () => { this.abort(session, orgUnavailable()); this.sessions.delete(session); },
     };
   }
 

package/runtime/node_modules/@metro-labs/daemon/src/connectors/org-sync-control.ts

@@ -1,22 +1,19 @@
 import { createHash, randomBytes } from 'node:crypto';
 import type { ConnectorSyncStatus } from '@metro-labs/core/connector-sync';
-import { log } from '@metro-labs/core/log';
+import { errMsg, log } from '@metro-labs/core/log';
 import { ApiError } from '@metro-labs/http/api-error';
 import { agentsDir } from '../agents/files.js';
 import { METRO_API, type MetroApi } from './metro-api.js';
 import { OrgConnectorSync, type OrgSyncDeps } from './org-sync.js';
-import { OrgConnectorRuntime } from './org-runtime.js';
+import { OrgConnectorRuntime, type RuntimeDeps } from './org-runtime.js';
 import { connectorSyncScope, disableSavedSync, saveSyncSetting, syncOptedIn, syncSetting } from './org-sync-setting.js';
 import type { RelaySession } from './relay-session.js';
-import type { DeliverySnapshot } from '@metro-labs/http/connector-delivery';
-import { localMigrationIdle, migrationRuntimeMapping } from './migration-guard.js';
-import { publishConnectors } from './publication.js';
+import { publishOrgConnectors } from './publication.js';
 import { orgRuntimeError, orgUnavailable } from './org-runtime-discovery.js';
 
-type ControlDeps = Pick<OrgSyncDeps, 'owner' | 'key' | 'monotonic'> & { api?: MetroApi; dir?: string };
+type ControlDeps = Pick<OrgSyncDeps, 'owner' | 'key' | 'monotonic'> & RuntimeDeps & { api?: MetroApi; dir?: string };
 type Context = Pick<ConnectorSyncStatus, 'owner' | 'agentId' | 'scope' | 'enrolled'>;
 const POLL_MS = 60_000;
-const liveEnabled = (): boolean => process.env.METRO_CONNECTORS_LIVE_ENABLED === 'true';
 const emptyReceipt = { lastReceivedAt: null, leaseExpiresAt: null, counts: null };
 
 export class OrgConnectorControl {
@@ -24,7 +21,7 @@ export class OrgConnectorControl {
   private readonly api: MetroApi;
   private sync: OrgConnectorSync | null = null;
   private runtime: OrgConnectorRuntime | null = null;
-  private readonly draining = new Set<OrgConnectorRuntime>();
+  private unpublished = false;
   private scope: string | null = null;
   private operation = randomBytes(16).toString('hex');
   private timer: ReturnType<typeof setInterval> | null = null;
@@ -49,20 +46,23 @@ export class OrgConnectorControl {
     this.sync?.invalidate();
     this.sync = null;
     this.runtime = null;
-    this.retire(runtime);
-  }
-
-  private retire(runtime: OrgConnectorRuntime | null): void {
-    for (const previous of this.draining) if (previous.idle()) this.draining.delete(previous);
-    if (runtime === null) return;
-    if (!runtime.idle()) this.draining.add(runtime);
     try {
-      runtime.stop();
+      runtime?.stop();
     } catch {
       log.warn('organization connectors: stopped runtime publication could not be cleared');
     }
   }
 
+  private unpublish(): void {
+    if (this.runtime !== null || this.unpublished) return;
+    try {
+      (this.deps.publish ?? publishOrgConnectors)([]);
+      this.unpublished = true;
+    } catch (err) {
+      log.warn({ err: errMsg(err) }, 'organization connectors: the connector list could not be cleared');
+    }
+  }
+
   private reconcile(start: boolean): { context: Context; setting: ReturnType<typeof syncSetting> } {
     const context = this.context();
     if (this.scope !== null && this.scope !== context.scope) {
@@ -73,8 +73,10 @@ export class OrgConnectorControl {
     this.scope = context.scope;
     const setting = syncSetting(this.dir, context.scope);
     if (setting.source === 'scope_changed') disableSavedSync(this.dir);
-    if (!setting.enabled || !context.enrolled) this.clear();
-    else if (start && this.sync === null) {
+    if (!setting.enabled || !context.enrolled) {
+      this.clear();
+      this.unpublish();
+    } else if (start && this.sync === null) {
       const scope = context.scope;
       this.sync = new OrgConnectorSync({ ...this.deps, api: this.api, enabled: () => this.context().scope === scope && syncSetting(this.dir, scope).enabled });
     }
@@ -84,8 +86,8 @@ export class OrgConnectorControl {
 
   private startRuntime(): void {
     if (this.sync === null || this.runtime !== null) return;
-    const mapping = () => migrationRuntimeMapping(this.deps.owner(), this.deps.key(), this.dir);
-    if (liveEnabled() || mapping().aliases.length > 0) this.runtime = new OrgConnectorRuntime(this.sync, { enabled: liveEnabled, mapping, migrationDir: this.dir });
+    this.unpublished = false;
+    this.runtime = new OrgConnectorRuntime(this.sync, this.deps);
   }
 
   status(): ConnectorSyncStatus {
@@ -94,7 +96,7 @@ export class OrgConnectorControl {
       const receipt = this.sync?.status() ?? { state: 'waiting' as const, ...emptyReceipt };
       const state = !setting.enabled ? 'off' : !context.enrolled ? 'not_enrolled' : receipt.state;
       const scope = createHash('sha256').update(`${context.scope}:${this.operation}`).digest('hex');
-      return { ...context, ...setting, ...receipt, scope, state, liveEnabled: liveEnabled() };
+      return { ...context, ...setting, ...receipt, scope, state, liveEnabled: false };
     } catch {
       this.clear();
       throw new ApiError('Metro could not read the connector sync status.', 503);
@@ -105,7 +107,6 @@ export class OrgConnectorControl {
     const current = this.status();
     if (scope !== current.scope) throw new ApiError('The organization or enrollment changed. Refresh the sync status before trying again.', 409);
     if (enabled && !current.enrolled) throw new ApiError('Enroll this agent with its organization before enabling sync.', 409);
-    if (enabled && liveEnabled()) throw new ApiError('Live organization tools are enabled separately on this server. Disable that setting before enabling memory-only sync here.', 409);
     saveSyncSetting(this.dir, enabled, this.context().scope);
     if (!enabled) this.clear();
     else this.tick();
@@ -113,7 +114,10 @@ export class OrgConnectorControl {
   }
 
   async poll(): Promise<void> {
-    if (this.sync === null && !syncOptedIn(this.dir)) return;
+    if (this.sync === null && !syncOptedIn(this.dir)) {
+      this.unpublish();
+      return;
+    }
     try {
       this.reconcile(true);
     } catch (err) {
@@ -123,28 +127,6 @@ export class OrgConnectorControl {
     await this.sync?.sync();
   }
 
-  async fresh(): Promise<DeliverySnapshot> {
-    this.reconcile(true);
-    const sync = this.sync;
-    if (sync === null) throw new ApiError('Enable organization connector sync before moving this connector.', 409);
-    await sync.syncFresh();
-    this.reconcile(false);
-    const snapshot = this.sync === sync ? sync.read() : null;
-    if (snapshot === null) throw new ApiError('A fresh organization connector snapshot is unavailable.', 503);
-    return snapshot;
-  }
-
-  refreshRuntime(): void {
-    this.reconcile(true);
-    this.runtime?.refresh();
-    publishConnectors();
-  }
-
-  migrationIdle(id: string): boolean {
-    for (const runtime of this.draining) if (runtime.idle()) this.draining.delete(runtime);
-    return localMigrationIdle(id, this.dir) && (this.runtime?.idle(id) ?? true) && [...this.draining].every((runtime) => runtime.idle(id));
-  }
-
   private tick(): void {
     this.poll().catch(() => {
       log.warn('organization connectors: memory sync unavailable; cached credentials were cleared');

package/runtime/node_modules/@metro-labs/daemon/src/connectors/org-sync-watch.ts

@@ -1,10 +1,7 @@
 import { ApiError } from '@metro-labs/http/api-error';
 import type { ConnectorSyncStatus } from '@metro-labs/core/connector-sync';
 import { OrgConnectorControl } from './org-sync-control.js';
-import { isOrgRelayId } from './relay-id.js';
 import type { RelaySession } from './relay-session.js';
-import type { DeliverySnapshot } from '@metro-labs/http/connector-delivery';
-import { migrationSource } from './migration-guard.js';
 
 let active: OrgConnectorControl | null = null;
 
@@ -13,20 +10,8 @@ function control(): OrgConnectorControl {
   return active;
 }
 
-export function orgConnectorRelaySession(id: string): Promise<RelaySession> | null {
-  return isOrgRelayId(id) || migrationSource(id)?.phase === 'active' ? control().open(id) : null;
-}
-
-export function freshOrgConnectors(): Promise<DeliverySnapshot> {
-  return control().fresh();
-}
-
-export function refreshOrgConnectorRuntime(): void {
-  control().refreshRuntime();
-}
-
-export function orgConnectorMigrationIdle(id: string): boolean {
-  return control().migrationIdle(id);
+export function orgConnectorRelaySession(id: string): Promise<RelaySession> {
+  return control().open(id);
 }
 
 export function orgConnectorSyncStatus(): ConnectorSyncStatus {

package/runtime/node_modules/@metro-labs/daemon/src/connectors/plugin-sync.ts

@@ -5,11 +5,12 @@ import { join } from 'node:path';
 import { errMsg, log } from '@metro-labs/core/log';
 import { claudeDir } from '../claude/files.js';
 import { loopbackBase } from '../files/attach-serve.js';
-import { isOrgRelayId } from './relay-id.js';
+import { MCP_SERVER_KEY, mcpServerUrl } from '../mcp-server/config.js';
 
 const MARKER = join('bin', 'metro-plugin.mjs');
 const FILE = '.mcp.json';
 const HELPER = 'node "${CLAUDE_PLUGIN_ROOT}/bin/metro-plugin.mjs" headers';
+const MCP_HELPER = 'node "${CLAUDE_PLUGIN_ROOT}/bin/metro-plugin.mjs" mcp-headers';
 const SLUG_MAX = 40;
 
 export interface PluginRow {
@@ -33,29 +34,6 @@ export function serverKey(name: string): string {
   return slug === '' ? 'connector' : slug;
 }
 
-function legacyOwners(rows: PluginRow[], published: PluginRow[]): Map<string, string> {
-  const visible = new Set(published.map((row) => row.id));
-  const taken = new Map<string, number>();
-  const owners = new Map<string, string>();
-  const reserved = new Set<string>();
-  for (const row of rows.filter((entry) => !isOrgRelayId(entry.id))) {
-    const slug = serverKey(row.name);
-    const seen = taken.get(slug) ?? 0;
-    taken.set(slug, seen + 1);
-    const key = seen === 0 ? slug : `${slug}-${row.id.toLowerCase().replace(/[^a-z0-9]/g, '').slice(0, 4)}`;
-    reserved.add(key);
-    if (visible.has(row.id)) owners.set(key, row.id);
-  }
-  for (const row of rows.filter((entry) => isOrgRelayId(entry.id) && visible.has(entry.id)).sort((a, b) => a.id.localeCompare(b.id))) {
-    const key = availableKey(orgKey(row), reserved);
-    reserved.add(key);
-    owners.set(key, row.id);
-  }
-  return new Map([...owners].map(([key, id]) => [id, key]));
-}
-
-const orgKey = (row: PluginRow): string => `org-${serverKey(row.name).slice(0, 35)}-${Buffer.from(row.id.slice(4)).toString('hex')}`;
-
 function availableKey(wanted: string, reserved: ReadonlySet<string>): string {
   let key = wanted;
   let suffix = 1;
@@ -63,28 +41,25 @@ function availableKey(wanted: string, reserved: ReadonlySet<string>): string {
   return key;
 }
 
-export function serverKeysOf(rows: PluginRow[], saved?: ReadonlyMap<string, string>, published: PluginRow[] = rows): Map<string, string> {
-  const keys = new Map(saved ?? legacyOwners(rows, published));
-  const reserved = new Set(keys.values());
-  const local = rows.filter((row) => !isOrgRelayId(row.id));
-  const organization = rows.filter((row) => isOrgRelayId(row.id)).sort((a, b) => a.id.localeCompare(b.id));
-  for (const row of [...local, ...organization]) {
+const reservedKeys = (): ReadonlySet<string> => new Set(mcpServerUrl() === null ? [] : [MCP_SERVER_KEY]);
+
+export function serverKeysOf(rows: PluginRow[], saved?: ReadonlyMap<string, string>, reserved: ReadonlySet<string> = reservedKeys()): Map<string, string> {
+  const keys = new Map([...(saved ?? [])].filter(([, key]) => !reserved.has(key)));
+  const used = new Set([...keys.values(), ...reserved]);
+  for (const row of [...rows].sort((a, b) => a.id.localeCompare(b.id))) {
     if (keys.has(row.id)) continue;
-    const slug = serverKey(row.name);
-    const wanted = isOrgRelayId(row.id)
-      ? orgKey(row)
-      : reserved.has(slug) ? `${slug}-${row.id.toLowerCase().replace(/[^a-z0-9]/g, '').slice(0, 4)}` : slug;
-    const key = availableKey(wanted, reserved);
-    reserved.add(key);
+    const key = availableKey(serverKey(row.name), used);
+    used.add(key);
     keys.set(row.id, key);
   }
   return keys;
 }
 
-export function pluginServers(rows: PluginRow[], base: string, keys: ReadonlyMap<string, string> = serverKeysOf(rows)): Record<string, PluginServer> {
+export function pluginServers(rows: PluginRow[], base: string, keys: ReadonlyMap<string, string> = serverKeysOf(rows), mcpUrl = mcpServerUrl()): Record<string, PluginServer> {
   const out: Record<string, PluginServer> = {};
   const visible = new Set(rows.map((row) => row.id));
   for (const [id, key] of keys) if (visible.has(id)) out[key] = { type: 'http', url: `${base}/relay/${id}`, headersHelper: HELPER };
+  if (mcpUrl !== null) out[MCP_SERVER_KEY] = { type: 'http', url: mcpUrl, headersHelper: MCP_HELPER };
   return out;
 }
 

package/runtime/node_modules/@metro-labs/daemon/src/connectors/publication.ts

@@ -1,11 +1,12 @@
 import { registerConnectors, type GateRow } from './gates.js';
 import { syncPluginServers } from './plugin-sync.js';
 import { persistentServerKeys } from './server-keys.js';
-import { isOrgRelayId } from './relay-id.js';
-import { migrationRecords } from './migration-state.js';
 
-let local: GateRow[] = [];
 let organization: GateRow[] | null = null;
+const BOOT = Date.now();
+const READY_WAIT_MS = 30_000;
+
+export const connectorsReady = (now = Date.now()): boolean => organization !== null || now - BOOT >= READY_WAIT_MS;
 
 function metadata(rows: readonly GateRow[]): GateRow[] {
   return rows.map((row) => structuredClone({
@@ -18,41 +19,19 @@ function metadata(rows: readonly GateRow[]): GateRow[] {
   }));
 }
 
-function publishedRows(records: ReturnType<typeof migrationRecords>, organization: GateRow[]): GateRow[] {
-  const retired = new Set(records.filter((record) => !['preparing', 'prepared'].includes(record.phase)).map((record) => record.sourceId));
-  const aliases = new Map(organization.filter((row) => records.some((record) => record.phase === 'active' && record.sourceId === row.id && record.name === row.name)).map((row) => [row.id, row]));
-  const rows = local.flatMap((row) => {
-    const alias = aliases.get(row.id);
-    return alias !== undefined ? [alias] : retired.has(row.id) ? [] : [row];
-  });
-  rows.push(...organization.filter((row) => isOrgRelayId(row.id) && !records.some((record) => row.id === `org-${record.destinationId ?? ''}`)));
-  return rows;
-}
-
 export function publishConnectors(): void {
-  let rows: GateRow[];
+  if (organization === null) return;
   let keys: Map<string, string>;
   try {
-    const records = migrationRecords().filter((record) => record.phase !== 'rolled_back');
-    if (organization === null && records.some((record) => record.phase === 'active')) return;
-    const org = organization ?? [];
-    rows = publishedRows(records, org);
-    const active = new Set(records.filter((record) => record.phase === 'active').map((record) => record.sourceId));
-    const reserved = [...rows, ...local.filter((row) => active.has(row.id))];
-    keys = persistentServerKeys([...local, ...org.filter((row) => isOrgRelayId(row.id))], undefined, reserved);
+    keys = persistentServerKeys(organization);
   }
   catch (error) {
     registerConnectors([]);
     syncPluginServers([]);
     throw error;
   }
-  registerConnectors(rows, keys);
-  syncPluginServers(rows, { keys });
-}
-
-export function publishLocalConnectors(rows: readonly GateRow[]): void {
-  local = metadata(rows.filter((row) => !isOrgRelayId(row.id)));
-  publishConnectors();
+  registerConnectors(organization, keys);
+  syncPluginServers(organization, { keys });
 }
 
 export function publishOrgConnectors(rows: readonly GateRow[]): void {

package/runtime/node_modules/@metro-labs/daemon/src/connectors/relay-session.ts

@@ -7,5 +7,4 @@ export interface RelaySession {
   blocker: () => BlockedReason;
   signal: AbortSignal;
   close: () => void;
-  dispatch?: (send: () => Promise<Response>, effectful?: boolean) => Promise<Response>;
 }