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

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

@@ -5,7 +5,6 @@ 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';
 
 const MARKER = join('bin', 'metro-plugin.mjs');
 const FILE = '.mcp.json';
@@ -33,29 +32,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,18 +39,12 @@ 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));
+export function serverKeysOf(rows: PluginRow[], saved?: ReadonlyMap<string, string>): Map<string, string> {
+  const keys = new Map(saved);
   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]) {
+  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);
+    const key = availableKey(serverKey(row.name), reserved);
     reserved.add(key);
     keys.set(row.id, key);
   }

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>;
 }

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

@@ -1,28 +1,16 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
-import { whyUnreachable } from '@metro-labs/http/connector-reach';
-import { noteHealth } from './health.js';
-import type { RelayTarget } from './relay-target.js';
 import type { RelaySession } from './relay-session.js';
-import { isRelaySse, passiveRelayListener, type PassiveSseListener } from './relay-passive.js';
-import { isOrgRelayId } from './relay-id.js';
 import { exchangeOrg } from './org-relay.js';
-import { assertLocalMigrationUse, migrationSource, withLocalMigrationOperation } from './migration-guard.js';
-import { agentsDir } from '../agents/files.js';
-import { migrationRequestEffectful, type MigrationOperation } from './migration-operations.js';
 import { ApiError } from '@metro-labs/http/api-error';
-import { errMsg, log } from '@metro-labs/core/log';
-import { answerBlocked, mergeBlocked, screenCalls, type BlockedReason } from './relay-policy.js';
+import { log } from '@metro-labs/core/log';
+import { answerBlocked, mergeBlocked } from './relay-policy.js';
 
 export interface RelayApiDeps {
-  migrationDir?: string;
-  target: (connectorId: string, force: boolean) => Promise<RelayTarget>;
   identify: (req: IncomingMessage) => { subject: string; agentId: string } | null;
-  signedOut: (connectorId: string) => void;
-  blocked?: BlockedReason;
-  open?: (connectorId: string) => RelaySession | Promise<RelaySession> | null;
+  open: (connectorId: string) => RelaySession | Promise<RelaySession>;
 }
 
-const ID_PATH_RE = /^\/relay\/((?:org-)?[A-Za-z0-9][A-Za-z0-9_-]{10})$/;
+const ID_PATH_RE = /^\/relay\/(org-[A-Za-z0-9][A-Za-z0-9_-]{10})$/;
 const METHODS = new Set(['POST', 'GET', 'DELETE']);
 const RELAY_BODY_MAX = 8 * 1024 * 1024;
 const FIRST_BYTE_MS = 120_000;
@@ -43,8 +31,7 @@ const PASS_RES = [
 const keepaliveMs = (): number =>
   Number(process.env.METRO_RELAY_KEEPALIVE_MS) || 25_000;
 
-const reconnectUrl = (id: string): string =>
-  `https://metro.box/#/connector/${id}`;
+const isRelaySse = (contentType: string | undefined): boolean => /^text\/event-stream\s*(?:;|$)/i.test(contentType ?? '');
 
 function answer(
   res: ServerResponse,
@@ -56,13 +43,6 @@ function answer(
   res.end(JSON.stringify(body));
 }
 
-const signinAnswer = (res: ServerResponse, id: string): void => {
-  answer(res, 424, {
-    error: 'this connector needs signing in again',
-    reconnect: reconnectUrl(id),
-  });
-};
-
 function closeIfBodyUnread(req: IncomingMessage, res: ServerResponse): void {
   if (req.readableEnded) return;
   const drop = (): void => {
@@ -108,10 +88,9 @@ async function forward(
   target: { url: string; headers: Record<string, string> },
   body: Uint8Array<ArrayBuffer> | null,
   signal: AbortSignal,
-  sensitive = false,
 ): Promise<Response> {
   const firstByte = setTimeout(() => {
-    log.warn(sensitive ? {} : { url: target.url }, 'relay: upstream sent no response in time');
+    log.warn('relay: upstream sent no response in time');
   }, FIRST_BYTE_MS);
   firstByte.unref?.();
   try {
@@ -132,12 +111,12 @@ interface Keepalive {
   stop: () => void;
 }
 
-function startKeepalive(res: ServerResponse, listener?: PassiveSseListener): Keepalive {
+function startKeepalive(res: ServerResponse): Keepalive {
   let timer: ReturnType<typeof setTimeout> | undefined;
   const arm = (): void => {
     timer = setTimeout(() => {
       try {
-        if (listener?.keepaliveAllowed() !== false) res.write(': keepalive\n\n');
+        res.write(': keepalive\n\n');
       } catch {
         log.debug('relay: keepalive write failed');
       }
@@ -173,17 +152,13 @@ async function pumpBody(
   res: ServerResponse,
   body: ReadableStream<Uint8Array>,
   touch: () => void,
-  listener?: PassiveSseListener,
 ): Promise<void> {
   const reader = body.getReader();
   for (;;) {
     const { done, value } = await reader.read();
     if (done) return;
-    listener?.observe(value);
     touch();
-    if (listener !== undefined) listener.forwarding = true;
     if (!res.write(value)) await drainedOrClosed(res);
-    if (listener !== undefined) listener.forwarding = false;
   }
 }
 
@@ -196,7 +171,7 @@ function passedHeaders(upstream: Response): Record<string, string> {
   return headers;
 }
 
-async function pipe(res: ServerResponse, upstream: Response, answers: Record<string, unknown>[], listener?: PassiveSseListener): Promise<void> {
+async function pipe(res: ServerResponse, upstream: Response, answers: Record<string, unknown>[]): Promise<void> {
   const headers = passedHeaders(upstream);
   if (answers.length > 0 && (upstream.status === 200 || upstream.status === 202)) {
     await mergeBlocked(res, upstream, headers, answers);
@@ -210,46 +185,38 @@ async function pipe(res: ServerResponse, upstream: Response, answers: Record<str
     res.end();
     return;
   }
-  const keepalive = sse ? startKeepalive(res, listener) : null;
+  const keepalive = sse ? startKeepalive(res) : null;
   try {
-    await pumpBody(res, upstream.body, () => keepalive?.touch(), listener);
+    await pumpBody(res, upstream.body, () => keepalive?.touch());
   } finally {
     keepalive?.stop();
   }
   res.end();
 }
 
-const authFailed = (status: number): boolean =>
-  status === 401 || status === 403;
-
-type Exchanged =
-  | { kind: 'response'; upstream: Response }
-  | { kind: 'missing' }
-  | { kind: 'signin' };
+async function deliver(res: ServerResponse, upstream: Response, answers: Record<string, unknown>[]): Promise<void> {
+  if (upstream.status >= 300 && upstream.status < 400) {
+    await upstream.body?.cancel();
+    answer(res, 502, { error: 'the connector redirected; metro does not follow' });
+    return;
+  }
+  await pipe(res, upstream, answers);
+}
 
-async function exchange(
+async function relayOnce(
   req: IncomingMessage,
+  res: ServerResponse,
   connectorId: string,
   deps: RelayApiDeps,
-  body: Uint8Array<ArrayBuffer> | null,
   signal: AbortSignal,
-  dispatch: MigrationOperation['dispatch'],
-): Promise<Exchanged> {
-  assertLocalMigrationUse(connectorId, deps.migrationDir);
-  const target = await deps.target(connectorId, false);
-  assertLocalMigrationUse(connectorId, deps.migrationDir);
-  if (target.kind !== 'ok') return { kind: target.kind };
-  let upstream = await dispatch(() => forward(req, target, body, signal), { effectful: migrationRequestEffectful(req.method, body) });
-  if (!authFailed(upstream.status)) return { kind: 'response', upstream };
-  await upstream.body?.cancel();
-  assertLocalMigrationUse(connectorId, deps.migrationDir);
-  const fresh = await deps.target(connectorId, true);
-  assertLocalMigrationUse(connectorId, deps.migrationDir);
-  if (fresh.kind !== 'ok') return { kind: 'signin' };
-  upstream = await dispatch(() => forward(req, fresh, body, signal), { effectful: migrationRequestEffectful(req.method, body) });
-  if (!authFailed(upstream.status)) return { kind: 'response', upstream };
-  await upstream.body?.cancel();
-  return { kind: 'signin' };
+): Promise<void> {
+  const read = req.method === 'POST' ? await readCapped(req) : null;
+  const session = await deps.open(connectorId);
+  try {
+    const out = await exchangeOrg(connectorId, session, read, signal, (target, body, guard) => forward(req, target, body, guard));
+    if (out.kind === 'blocked') answerBlocked(res, out.screened);
+    else await deliver(res, out.upstream, out.answers);
+  } finally { session.close(); }
 }
 
 async function relayExchange(
@@ -268,7 +235,7 @@ async function relayExchange(
     res.socket?.removeListener('close', bail);
   });
   try {
-    await relayOnce(req, res, connectorId, deps, control);
+    await relayOnce(req, res, connectorId, deps, control.signal);
   } catch (err) {
     if (!control.signal.aborted) throw err;
     log.debug({ connector: connectorId }, 'relay: the client left before the answer ended');
@@ -276,71 +243,6 @@ async function relayExchange(
   }
 }
 
-async function deliver(
-  res: ServerResponse,
-  connectorId: string,
-  deps: RelayApiDeps,
-  out: Exchanged,
-  answers: Record<string, unknown>[],
-  listener?: PassiveSseListener,
-): Promise<void> {
-  if (out.kind === 'missing') {
-    answer(res, 404, { error: 'no such connector' });
-    return;
-  }
-  if (out.kind === 'signin') {
-    noteHealth(connectorId, false, 'the sign-in has expired, connect it again');
-    deps.signedOut(connectorId);
-    signinAnswer(res, connectorId);
-    return;
-  }
-  if (out.upstream.status >= 300 && out.upstream.status < 400) {
-    await out.upstream.body?.cancel();
-    noteHealth(connectorId, false, 'the connector redirected; metro does not follow');
-    answer(res, 502, { error: 'the connector redirected; metro does not follow' });
-    return;
-  }
-  const { status } = out.upstream;
-  noteHealth(connectorId, status < 400, status < 400 ? null : `the connector answered ${String(status)}`);
-  await pipe(res, out.upstream, answers, listener);
-}
-
-async function relayOrg(req: IncomingMessage, res: ServerResponse, id: string, deps: RelayApiDeps, read: Uint8Array<ArrayBuffer> | null, signal: AbortSignal): Promise<void> {
-  const session = await deps.open?.(id);
-  if (session === undefined || session === null) throw new ApiError('Organization connector tools are not switched on yet.', 503);
-  try {
-    const out = await exchangeOrg(id, session, read, signal, (target, body, guard) => {
-      const send = () => forward(req, target, body, guard, true);
-      return session.dispatch?.(send, migrationRequestEffectful(req.method, body)) ?? send();
-    });
-    if (out.kind === 'blocked') answerBlocked(res, out.screened);
-    else await deliver(res, id, deps, out, out.answers);
-  } finally { session.close(); }
-}
-
-async function relayOnce(
-  req: IncomingMessage,
-  res: ServerResponse,
-  connectorId: string,
-  deps: RelayApiDeps,
-  control: AbortController,
-): Promise<void> {
-  const { signal } = control;
-  const read = req.method === 'POST' ? await readCapped(req) : null;
-  const dir = deps.migrationDir ?? agentsDir();
-  if (isOrgRelayId(connectorId) || migrationSource(connectorId, dir)?.phase === 'active') return relayOrg(req, res, connectorId, deps, read, signal);
-  await withLocalMigrationOperation(connectorId, dir, async (operation) => {
-    const screened = read === null || deps.blocked === undefined ? null : screenCalls(read, connectorId, deps.blocked);
-    if (screened?.forward === null) {
-      answerBlocked(res, screened);
-      return;
-    }
-    const out = await exchange(req, connectorId, deps, screened === null ? read : screened.forward, signal, operation.dispatch);
-    const listener = out.kind === 'response' ? passiveRelayListener(req, res, out.upstream, operation, () => { control.abort(); }) : undefined;
-    await deliver(res, connectorId, deps, out, screened?.answers ?? [], listener);
-  });
-}
-
 function dispatch(
   req: IncomingMessage,
   res: ServerResponse,
@@ -354,19 +256,12 @@ function dispatch(
   }
   relayExchange(req, res, connectorId, deps)
     .catch((err: unknown) => {
-      if (err instanceof ApiError) {
-        answer(res, err.status, { error: err.message });
-        if (!res.writableEnded) res.end();
-      } else if (isOrgRelayId(connectorId)) {
+      if (err instanceof ApiError) answer(res, err.status, { error: err.message });
+      else {
         log.warn({ connector: connectorId }, 'organization relay: request failed');
         answer(res, 503, { error: 'The organization connector is unavailable. Try again.' });
-        if (!res.writableEnded) res.end();
-      } else {
-        log.warn({ err: errMsg(err), connector: connectorId }, 'relay: failed');
-        noteHealth(connectorId, false, `metro could not reach the connector: ${whyUnreachable(err)}`);
-        answer(res, 502, { error: `metro could not reach the connector: ${whyUnreachable(err)}` });
-        if (!res.writableEnded) res.end();
       }
+      if (!res.writableEnded) res.end();
       closeIfBodyUnread(req, res);
     });
 }

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

@@ -33,14 +33,27 @@ function parseKeys(text: string): Map<string, string> {
   return keys;
 }
 
-export function persistentServerKeys(rows: PluginRow[], dir = agentsDir(), published: PluginRow[] = rows): Map<string, string> {
-  const path = join(dir, 'connector-server-keys.json');
-  const marker = join(dir, 'connector-server-keys.initialized');
-  const saved = readKeys(path, marker);
-  const keys = serverKeysOf(rows, saved, published);
-  if (keys.size > 0 && keys.size !== saved?.size) {
-    if (saved === undefined) writeSecure(marker, '1\n');
-    writeSecure(path, `${JSON.stringify({ version: 1, keys: Object.fromEntries(keys) }, null, 2)}\n`);
-  }
+const sameKeys = (a: ReadonlyMap<string, string>, b: ReadonlyMap<string, string>): boolean =>
+  a.size === b.size && [...a].every(([id, key]) => b.get(id) === key);
+
+function serverKeyFiles(dir = agentsDir()): { path: string; marker: string } {
+  return { path: join(dir, 'connector-server-keys.json'), marker: join(dir, 'connector-server-keys.initialized') };
+}
+
+export function readServerKeys(dir = agentsDir()): Map<string, string> | undefined {
+  const { path, marker } = serverKeyFiles(dir);
+  return readKeys(path, marker);
+}
+
+export function writeServerKeys(keys: ReadonlyMap<string, string>, dir = agentsDir()): void {
+  const { path, marker } = serverKeyFiles(dir);
+  if (!existsSync(marker)) writeSecure(marker, '1\n');
+  writeSecure(path, `${JSON.stringify({ version: 1, keys: Object.fromEntries(keys) }, null, 2)}\n`);
+}
+
+export function persistentServerKeys(rows: PluginRow[], dir = agentsDir()): Map<string, string> {
+  const saved = readServerKeys(dir);
+  const keys = serverKeysOf(rows, saved);
+  if (saved === undefined ? keys.size > 0 : !sameKeys(saved, keys)) writeServerKeys(keys, dir);
   return keys;
 }

package/runtime/node_modules/@metro-labs/daemon/src/routes/local-mode.ts

@@ -6,7 +6,6 @@ import { assertAttachOwner, finishGmailUpgrade, startGmailAttach } from './gmail
 import { detachWithGmailRevocation } from './gmail-detach.js';
 import { recentSenders } from '../agents/senders.js';
 import { forwardTrainCall } from '../stations/train-call.js';
-import { publishLocalConnectors } from '../connectors/publication.js';
 import { invalidateOrgConnectorSync, orgConnectorRelaySession, orgConnectorSyncStatus, setOrgConnectorSync } from '../connectors/org-sync-watch.js';
 import type { AgentApiDeps } from '../agents/api.js';
 import { ATTACHABLE, type AccountApiDeps } from '../agents/accounts-api.js';
@@ -14,32 +13,9 @@ import type { SessionApis } from './session-apis.js';
 import type { ModeInfo } from '@metro-labs/http/mode-api';
 import { loadedAgentOf, type AgentBundle, type BundleApiDeps } from '../agents/bundle.js';
 import { METRO_VERSION } from '@metro-labs/core/version';
-import type { ConnectorApiDeps } from '../connectors/api.js';
-import { connectorMigrationPreview } from '../connectors/migration-preview.js';
-import { ConnectorMigrations } from '../connectors/migration-control.js';
-import { migrationExportableRows } from '../connectors/migration-guard.js';
-import { ConnectorTransfers } from '../connectors/transfer-api.js';
-import { copyConnectorRows } from '../connectors/transfer-store.js';
 import { authenticate } from '../mcp/request-identity.js';
 import type { RelayApiDeps } from '../connectors/relay.js';
-import {
-  readLocalConnectors,
-  localImportConnectors,
-  localCreateConnector,
-  localCreatePendingConnector,
-  localDeleteConnector,
-  localDisconnectConnector,
-  localGetConnector,
-  localListConnectors,
-  localReconnectConnector,
-  localRelayTarget,
-  localRenameConnector,
-  localVerifyConnector,
-  localMarkSignedOut,
-  localConnectorTools,
-  localSetConnectorPolicy,
-} from '../connectors/store.js';
-import { blockedReason } from '../connectors/gates.js';
+import { connectorGates } from '../connectors/gates.js';
 import {
   setLocalOwner,
   localAttachAccount,
@@ -117,43 +93,17 @@ function agentApi(deps: LocalModeDeps): AgentApiDeps {
   };
 }
 
-const allConnectorIds = (): string[] => readLocalConnectors().map((c) => c.id);
-
 function connectorIdsOfLocalAgents(ids: string[]): Promise<Map<string, string[]>> {
-  const all = allConnectorIds();
+  const all = connectorGates().map((gate) => gate.id);
   return Promise.resolve(new Map(ids.map((id) => [id, all] as const)));
 }
 
-const connectorApi: ConnectorApiDeps = {
-  migrationPreview: () => connectorMigrationPreview(localOwner()),
-  listConnectors: async () => {
-    const rows = await localListConnectors();
-    publishLocalConnectors(readLocalConnectors());
-    return rows;
-  },
-  createConnector: localCreateConnector,
-  verifyConnector: localVerifyConnector,
-  connectorTools: localConnectorTools,
-  disconnectConnector: localDisconnectConnector,
-  renameConnector: localRenameConnector,
-  deleteConnector: localDeleteConnector,
-  setConnectorPolicy: (id, policy) => localSetConnectorPolicy(id, policy),
-  createPendingConnector: localCreatePendingConnector,
-  reconnectConnector: localReconnectConnector,
-  getConnector: localGetConnector,
-};
-
 const relayApi: RelayApiDeps = {
-  target: (connectorId, force) => localRelayTarget(connectorId, force),
   open: orgConnectorRelaySession,
   identify: (req) => {
     const who = authenticate(req);
     return who?.kind === 'agent' ? { subject: 'agent-key', agentId: who.agentId } : null;
   },
-  signedOut: (id) => {
-    localMarkSignedOut(id);
-  },
-  blocked: blockedReason,
 };
 
 
@@ -164,18 +114,17 @@ function bundleApi(deps: LocalModeDeps): BundleApiDeps {
       const bundle: AgentBundle = {
         version: 1,
         agent: { id: file.id, name: file.name ?? '', stations: file.stations.filter((a) => a.station !== 'gmail' || a.config.managed !== true) },
-        connectors: migrationExportableRows(readLocalConnectors()).map((c) => ({ id: c.id, name: c.name, url: c.url, config: { ...c.config } })),
+        connectors: [],
       };
       return Promise.resolve(bundle);
     },
     restore: async (bundle, mode) => {
       const made = await localImportAgent(loadedAgentOf(bundle), undefined, mode);
-      const connectors = localImportConnectors(bundle.connectors, undefined, mode);
       for (const station of new Set(bundle.agent.stations.map((a) => a.station)))
         await deps.syncStations(station).catch((err: unknown) => {
           log.warn({ station, err: errMsg(err) }, 'restore: station reload failed, the change lands at the next boot');
         });
-      return { id: made.id, name: made.name, stations: made.stations, connectors };
+      return { id: made.id, name: made.name, stations: made.stations, connectors: 0 };
     },
   };
 }
@@ -206,10 +155,7 @@ export function localSessionApis(deps: LocalModeDeps): SessionApis {
   return {
     agentApi: agentApi(deps),
     bundleApi: bundleApi(deps),
-    connectorApi,
     connectorSyncApi: { status: orgConnectorSyncStatus, set: setOrgConnectorSync },
-    connectorMigrationApi: new ConnectorMigrations(),
-    connectorTransfers: new ConnectorTransfers({ read: () => migrationExportableRows(readLocalConnectors()), copy: copyConnectorRows }),
     enrollApi: { owner: () => localOwner(), invalidate: invalidateOrgConnectorSync },
     relayApi,
     claudeApi: { liveEvents: deps.liveEvents },

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

@@ -2,14 +2,8 @@ import type { IncomingMessage, ServerResponse } from 'node:http';
 import { handleSessionApiRequest } from './session.js';
 import { handleApprovalsRequest } from '../approvals/api.js';
 import { handleAgentApiRequest, type AgentApiDeps } from '../agents/api.js';
-import {
-  handleConnectorApiRequest,
-  type ConnectorApiDeps,
-} from '../connectors/api.js';
 import type { RelayApiDeps } from '../connectors/relay.js';
-import type { ConnectorTransfers } from '../connectors/transfer-api.js';
 import { handleConnectorSyncRequest, type ConnectorSyncApiDeps } from '../connectors/org-sync-api.js';
-import { handleMigrationRequest, type MigrationApiDeps } from '../connectors/migration-api.js';
 import { handleEnrollRequest, type EnrollApiDeps } from '../connectors/enroll-api.js';
 import { handleClaudeRequest, type ClaudeApiDeps } from '../claude/api.js';
 import type { ModeInfo } from '@metro-labs/http/mode-api';
@@ -38,11 +32,8 @@ export interface SessionApis {
   gateway?: GatewayDeps;
   terminalApi?: TerminalApiDeps;
   claudeApi?: ClaudeApiDeps;
-  connectorApi?: ConnectorApiDeps;
-  connectorTransfers?: ConnectorTransfers;
   enrollApi?: EnrollApiDeps;
   connectorSyncApi?: ConnectorSyncApiDeps;
-  connectorMigrationApi?: MigrationApiDeps;
   relayApi?: RelayApiDeps;
   mode?: () => ModeInfo;
 }
@@ -59,11 +50,8 @@ export function handleSessionApis(
     () => handleSessionApiRequest(req, res),
     () => handleRunEventsRequest(req, res),
     () => handleApprovalsRequest(req, res),
-    ...when(apis.connectorTransfers, (d) => d.handle(req, res)),
     ...when(apis.enrollApi, (d) => handleEnrollRequest(req, res, d)),
     ...when(apis.connectorSyncApi, (d) => handleConnectorSyncRequest(req, res, d)),
-    ...when(apis.connectorMigrationApi, (d) => handleMigrationRequest(req, res, d)),
-    ...when(apis.connectorApi, (d) => handleConnectorApiRequest(req, res, d)),
     ...when(apis.bundleApi, (d) => handleBundleRequest(req, res, d)),
     ...when(apis.updateApi, (d) => handleUpdateRequest(req, res, d)),
     ...when(apis.controlApi, (d) => handleControlRequest(req, res, d)),

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

@@ -39,13 +39,6 @@ export interface LoadedAccount {
   config: Record<string, unknown>;
 }
 
-export interface LoadedConnector {
-  id: string;
-  name: string;
-  url: string;
-  config: Record<string, unknown>;
-}
-
 export interface LoadedAgent {
   id: string;
   name: string;

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.302"
+  "version": "0.1.0-beta.303"
 }

package/runtime/sdk-runner/runner.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.1.0-beta.302",
+  "version": "0.1.0-beta.303",
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "0.3.287",
     "@modelcontextprotocol/sdk": "^1.29.0",