@stage-labs/metro 0.1.0-beta.301 → 0.1.0-beta.303

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.301",
+  "version": "0.1.0-beta.303",
   "description": "The metro command line: run your agent on this machine, relaying its chat channels and connectors to Claude Code.",
   "license": "MIT",
   "repository": {

package/runtime/marketplace/plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "metro",
-  "version": "0.1.0-beta.301",
+  "version": "0.1.0-beta.303",
   "description": "Metro for Claude Code, installed by the metro daemon on this machine: every connector the agent holds as its own MCP server relayed through the daemon, the orchestrator-only guard on the main thread, and the standing rules loaded at each session start. No vendor credential ever sits in a config file.",
   "author": {
     "name": "Bonustrack",

package/runtime/node_modules/@metro-labs/daemon/src/agent-user/provision.ts

@@ -34,7 +34,10 @@ function ensureUser(): AgentUser | null {
   openMetroHome();
   forgetAgentUser();
   const user = agentUser();
-  if (user !== null) run(...asUser(user, 'chmod', ['711', user.home]));
+  if (user !== null) {
+    run(...asUser(user, 'chmod', ['711', user.home]));
+    run(...asUser(user, 'sh', ['-c', 'test ! -d "$1" || chmod go-w "$1"', 'sh', join(user.home, '.metro')]));
+  }
   return user;
 }
 

package/runtime/node_modules/@metro-labs/daemon/src/agents/bundle.ts

@@ -5,7 +5,7 @@ import { apiFailure, apiSession, cors, readJsonBody, requireAdmin, sendJson } fr
 import { ApiError } from '@metro-labs/http/api-error';
 import { isRecord } from '@metro-labs/core/is-record';
 import { parseId } from '@metro-labs/core/ids';
-import type { LoadedAccount, LoadedAgent, LoadedConnector } from '../stations/materialize.js';
+import type { LoadedAccount, LoadedAgent } from '../stations/materialize.js';
 import { STATIONS } from '@metro-labs/core/station-names';
 import { approversOf } from './files.js';
 
@@ -17,7 +17,7 @@ const STATION_NAMES = new Set<string>(STATIONS);
 export interface AgentBundle {
   version: 1;
   agent: { id: string; name: string; stations: LoadedAccount[] };
-  connectors: LoadedConnector[];
+  connectors: [];
 }
 
 export const loadedAgentOf = (bundle: AgentBundle): LoadedAgent => ({
@@ -68,13 +68,6 @@ function stationOf(raw: unknown): LoadedAccount {
   };
 }
 
-function connectorOf(raw: unknown): LoadedConnector {
-  if (!isRecord(raw) || typeof raw.id !== 'string' || typeof raw.name !== 'string' || typeof raw.url !== 'string')
-    throw bad('a connector is missing its id, name or url');
-  if (!isRecord(raw.config)) throw bad('a connector has no config');
-  return { id: raw.id, name: raw.name, url: raw.url, config: raw.config };
-}
-
 function agentOf(raw: unknown): AgentBundle['agent'] {
   if (!isRecord(raw)) throw bad('not a v1 agent bundle');
   const { id, name, stations } = raw;
@@ -85,8 +78,7 @@ function agentOf(raw: unknown): AgentBundle['agent'] {
 
 export function parseBundle(raw: unknown): AgentBundle {
   if (!isRecord(raw) || raw.version !== 1) throw bad('not a v1 agent bundle');
-  const connectors = Array.isArray(raw.connectors) ? raw.connectors : [];
-  return { version: 1, agent: agentOf(raw.agent), connectors: connectors.map(connectorOf) };
+  return { version: 1, agent: agentOf(raw.agent), connectors: [] };
 }
 
 async function answer(req: IncomingMessage, deps: BundleApiDeps, path: string): Promise<unknown> {

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

@@ -21,10 +21,10 @@ import {
   trainEventToMetroEvent,
 } from '../routes/http.js';
 import { agentsDir, fileSource } from '../agents/files.js';
-import { publishLocalConnectors } from '../connectors/publication.js';
+import { connectorsReady, publishConnectors } from '../connectors/publication.js';
+import { adoptOrgServerKeys } from '../connectors/org-adopt.js';
 import { readAgentKey } from '../connectors/agent-key.js';
 import { stopOrgConnectorSync, watchOrgConnectorSync } from '../connectors/org-sync-watch.js';
-import { loadConnectorPolicies, readLocalConnectors } from '../connectors/store.js';
 import { ensureMetroPlugin } from '../claude/plugin-install.js';
 import { runningAsRoot } from '../metro-user/privilege.js';
 import { provisionAgentUser } from '../agent-user/provision.js';
@@ -140,10 +140,8 @@ function sessionApis(setLiveEvents: (on: boolean) => void, switchModel: (model:
 async function main(): Promise<void> {
   applyLocalOwner();
 installBearerSessions(agentsDir(), localOwner);
+  adoptOrgServerKeys();
   watchPolicySnapshot();
-  loadConnectorPolicies().catch((err: unknown) => {
-    log.warn({ err: errMsg(err) }, 'connector policy: loading the policies failed');
-  });
   log.info({ agent: await ensureLocalAgent() }, 'local daemon: agent');
   await materializeFrom(fileSource);
   ensureStationDeps();
@@ -160,7 +158,6 @@ installBearerSessions(agentsDir(), localOwner);
   );
   metroMcp.startInbound();
   startPromptExpiry();
-  publishLocalConnectors(readLocalConnectors());
   startUploadReaper();
   startAttachReaper();
   watchOrgConnectorSync({ owner: localOwner, key: readAgentKey });
@@ -195,7 +192,7 @@ async function startClaude(): Promise<void> {
   ensureMetroPlugin()
     .then((outcome) => {
       log.info({ outcome }, 'plugin: metro plugin for Claude Code');
-      if (outcome !== 'skipped') publishLocalConnectors(readLocalConnectors());
+      if (outcome !== 'skipped') publishConnectors();
     })
     .catch((err: unknown) => {
       log.warn({ err: errMsg(err) }, 'plugin: could not ensure the Claude Code plugin');
@@ -203,7 +200,7 @@ async function startClaude(): Promise<void> {
   tryClaudeSetup();
   try { githubSkills().watch(); } catch { log.warn('github-skills: saved source could not be loaded'); }
   tryMemoryJob(memoryRoutine());
-  watchSession();
+  watchSession({ connectorsReady: () => connectorsReady() });
 }
 
 const SHUTDOWN_TIMEOUT_MS = 3_000;

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

@@ -49,6 +49,7 @@ export interface SessionDeps {
   now?: () => number;
   version?: string;
   prepare?: (runner: HarnessRunner) => Promise<void>;
+  connectorsReady?: () => boolean;
 }
 
 export interface SessionStatus {
@@ -316,9 +317,10 @@ function strike(now: number): boolean {
   return true;
 }
 
-export type Ensured = 'started' | 'restarted' | 'running' | 'blocked' | 'off' | 'paused';
+export type Ensured = 'started' | 'restarted' | 'running' | 'blocked' | 'off' | 'paused' | 'waiting';
 
 function holdsBack(deps: SessionDeps, now: number): Ensured | null {
+  if (deps.connectorsReady?.() === false) return 'waiting';
   if (now < memory.pausedUntil) return 'paused';
   if (sessionBlocked(deps) !== null) return 'blocked';
   return strike(now) ? 'paused' : null;

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

@@ -2,7 +2,6 @@ import type { ToolGroup } from '@metro-labs/core/stations/types';
 import { decide, policyFor, setPolicies, type PolicyTarget, type ToolPolicy } from '../policy/policy.js';
 import { serverKeysOf } from './plugin-sync.js';
 import { NEEDS_APPROVAL, revokeToolPrompts, settlePrompts, takeGrant } from '../approvals/pending.js';
-import { isOrgRelayId } from './relay-id.js';
 import type { BlockedReason } from './relay-policy.js';
 
 export interface GateRow {
@@ -101,14 +100,5 @@ export function connectorToolOf(toolName: string, entries: readonly ConnectorGat
   for (const gate of entries)
     for (const prefix of [`mcp__plugin_metro_${gate.server}__`, `mcp__${gate.server}__`])
       if (toolName.startsWith(prefix) && toolName.length > prefix.length) return resolvedTool(gate, toolName.slice(prefix.length));
-  return legacyToolOf(toolName, entries);
-}
-
-function legacyToolOf(toolName: string, entries: readonly ConnectorGate[]): { gate: ConnectorGate; tool: string } | undefined {
-  if (!toolName.startsWith('mcp__metro_box_')) return undefined;
-  const legacy = entries.filter((gate) => !isOrgRelayId(gate.id) && toolName.startsWith(`mcp__${normalized(`metro.box ${gate.name}`)}__`));
-  const gate = legacy.length === 1 ? legacy[0] : undefined;
-  if (gate === undefined) return undefined;
-  const called = toolName.slice(`mcp__${normalized(`metro.box ${gate.name}`)}__`.length);
-  return called === '' ? undefined : resolvedTool(gate, called);
+  return undefined;
 }

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

@@ -0,0 +1,57 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { isRecord } from '@metro-labs/core/is-record';
+import { errMsg, log } from '@metro-labs/core/log';
+import { agentsDir } from '../agents/files.js';
+import { isOrgRelayId, orgRelayId } from './relay-id.js';
+import { readServerKeys, writeServerKeys } from './server-keys.js';
+
+interface Alias {
+  sourceId: string;
+  relayId: string;
+}
+
+function recordsOf(dir: string): unknown[] {
+  let raw: unknown;
+  try {
+    raw = JSON.parse(readFileSync(join(dir, 'connector-migrations.json'), 'utf8'));
+  } catch (err) {
+    if (isRecord(err) && err.code === 'ENOENT') return [];
+    log.warn({ err: errMsg(err) }, 'connectors: the old migration records could not be read; server keys left as they are');
+    return [];
+  }
+  if (isRecord(raw) && raw.version === 1 && Array.isArray(raw.records)) return raw.records;
+  log.warn('connectors: the old migration records are not valid; server keys left as they are');
+  return [];
+}
+
+function aliasOf(record: unknown): Alias[] {
+  if (!isRecord(record) || record.phase !== 'active' || typeof record.sourceId !== 'string' || typeof record.destinationId !== 'string') return [];
+  const relayId = orgRelayId(record.destinationId);
+  return isOrgRelayId(relayId) && record.sourceId !== relayId ? [{ sourceId: record.sourceId, relayId }] : [];
+}
+
+export function adoptOrgServerKeys(dir = agentsDir()): number {
+  try {
+    const aliases = recordsOf(dir).flatMap(aliasOf);
+    if (aliases.length === 0) return 0;
+    const keys = readServerKeys(dir);
+    if (keys === undefined) return 0;
+    let moved = 0;
+    for (const { sourceId, relayId } of aliases) {
+      const key = keys.get(sourceId);
+      if (key === undefined || keys.has(relayId)) continue;
+      keys.delete(sourceId);
+      keys.set(relayId, key);
+      moved += 1;
+    }
+    if (moved > 0) {
+      writeServerKeys(keys, dir);
+      log.info({ moved }, 'connectors: server keys moved to organization connector ids, tool names unchanged');
+    }
+    return moved;
+  } catch (err) {
+    log.warn({ err: errMsg(err) }, 'connectors: the server keys could not be moved to organization connector ids');
+    return 0;
+  }
+}

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 {