@stage-labs/metro 0.1.0-beta.117 → 0.1.0-beta.119

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.117",
+  "version": "0.1.0-beta.119",
   "description": "The metro command line. Sign in once per machine, then hand your MCP connector list to Claude Code without the credentials touching disk, argv or shell history.",
   "license": "MIT",
   "repository": {

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

@@ -1,6 +1,6 @@
 {
   "name": "metro",
-  "version": "0.1.0-beta.117",
+  "version": "0.1.0-beta.119",
   "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, the standing rules loaded at each session start, and a refresh skill for when the daemon could not keep the server list current. No vendor credential ever sits in a config file.",
   "author": {
     "name": "Bonustrack",

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

@@ -33,9 +33,17 @@ export interface RestoredAgent {
   connectors: number;
 }
 
+export type ImportMode = 'append' | 'overwrite';
+
 export interface BundleApiDeps {
   bundle: (subject: string, agentId: string) => Promise<AgentBundle>;
-  restore: (subject: string, bundle: AgentBundle) => Promise<RestoredAgent>;
+  restore: (subject: string, bundle: AgentBundle, mode: ImportMode) => Promise<RestoredAgent>;
+}
+
+export function parseMode(raw: unknown): ImportMode {
+  const mode = isRecord(raw) && typeof raw.mode === 'string' ? raw.mode : 'overwrite';
+  if (mode !== 'append' && mode !== 'overwrite') throw bad("mode is 'append' or 'overwrite'");
+  return mode;
 }
 
 const bad = (what: string): ApiError => new ApiError(`bundle: ${what}`, 400);
@@ -73,7 +81,10 @@ export function parseBundle(raw: unknown): AgentBundle {
 }
 
 async function answer(req: IncomingMessage, deps: BundleApiDeps, subject: string, path: string): Promise<unknown> {
-  if (path === RESTORE_PATH) return deps.restore(subject, parseBundle(await readJsonBody(req, BUNDLE_MAX)));
+  if (path === RESTORE_PATH) {
+    const body: unknown = await readJsonBody(req, BUNDLE_MAX);
+    return deps.restore(subject, parseBundle(body), parseMode(body));
+  }
   const id = parseId(path.slice(AGENTS.length + 1).split('/')[0] ?? '');
   if (id === null) throw new ApiError('no such agent', 404);
   return deps.bundle(subject, id);

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

@@ -206,15 +206,18 @@ function importTarget(dir: string, agent: LoadedAgent & { key: string }): Import
   return { path: same?.path ?? fresh, previous: same?.file };
 }
 
+export type ImportMode = 'append' | 'overwrite';
+
 export async function localImportAgent(
   subject: string,
   agent: LoadedAgent,
   dir = agentsDir(),
+  mode: ImportMode = 'overwrite',
 ): Promise<{ id: string; name: string; key: string; stations: number }> {
   assertLocalOwner(subject, dir);
   assertImportable(agent);
   const { path, previous } = importTarget(dir, agent);
-  const file = fileFor(agent, localOwner(dir), path, previous);
+  const file = fileFor(agent, localOwner(dir), path, previous, mode);
   ensureSecureDir(join(path, '..'));
   save({ path, file });
   if (previous !== undefined && previous.key !== agent.key) unregisterAgentKey(agent.id);
@@ -227,11 +230,17 @@ export async function localImportAgent(
   });
 }
 
-function mergedStations(agent: LoadedAgent, previous: AgentFile | undefined): AgentFile['stations'] {
-  const fromMetro = agent.accounts.map((a) => ({ ...a, allowlist: a.allowlist ?? ['*'] }));
-  const kept = (previous?.stations ?? []).filter(
-    (s) => !fromMetro.some((m) => m.station === s.station && m.id === s.id),
-  );
+function mergedStations(
+  agent: LoadedAgent,
+  previous: AgentFile | undefined,
+  mode: ImportMode,
+): AgentFile['stations'] {
+  const before = previous?.stations ?? [];
+  const here = (station: string, id: string): boolean => before.some((s) => s.station === station && s.id === id);
+  const fromMetro = agent.accounts
+    .map((a) => ({ ...a, allowlist: a.allowlist ?? ['*'] }))
+    .filter((m) => mode === 'overwrite' || !here(m.station, m.id));
+  const kept = before.filter((s) => !fromMetro.some((m) => m.station === s.station && m.id === s.id));
   return [...fromMetro, ...kept];
 }
 
@@ -239,7 +248,8 @@ function fileFor(
   agent: LoadedAgent,
   owner: string | null,
   path: string,
-  previous?: AgentFile,
+  previous: AgentFile | undefined,
+  mode: ImportMode,
 ): AgentFile {
   try {
     return parseAgentFile(
@@ -249,7 +259,7 @@ function fileFor(
         name: previous?.name ?? agent.name,
         key: agent.key,
         owner,
-        stations: mergedStations(agent, previous),
+        stations: mergedStations(agent, previous, mode),
         connectors: previous?.connectors ?? [],
       }),
       path,

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

@@ -39,6 +39,7 @@ import {
   listMemory,
   readMemoryFile,
   readTranscript,
+  writeMemoryFile,
 } from './files.js';
 
 const PREFIX = '/api/claude';
@@ -94,12 +95,16 @@ const parts = (path: string): string[] => path.slice(PREFIX.length + 1).split('/
 const seenIn = (body: Record<string, unknown>): string | null | undefined =>
   'seenAt' in body ? (typeof body.seenAt === 'string' ? body.seenAt : null) : undefined;
 
-async function writeAnswer(req: IncomingMessage, path: string, dir: string): Promise<unknown> {
+const WRITE_HEADS = new Set(['settings', 'skills', 'memory']);
+
+async function writeAnswer(req: IncomingMessage, path: string, search: string, dir: string): Promise<unknown> {
   const [head = '', item = ''] = parts(path);
-  if ((head !== 'settings' && head !== 'skills') || item === '') throw new ApiError('method not allowed', 405);
+  if (!WRITE_HEADS.has(head) || item === '') throw new ApiError('method not allowed', 405);
   const body = await readJsonBody(req, BODY_MAX);
   if (!isRecord(body) || typeof body.text !== 'string') throw new ApiError('text is required', 400);
   if (head === 'skills') return writeClaudeSkill(decodeURIComponent(item), body.text, seenIn(body), dir);
+  if (head === 'memory')
+    return writeMemoryFile(projectOf(new URLSearchParams(search)), decodeURIComponent(item), body.text, dir);
   return writeClaudeSettings(item, body.text, seenIn(body), dir);
 }
 
@@ -217,7 +222,7 @@ function routed(req: IncomingMessage, path: string, search: string, deps: Claude
   if (head === LOGIN) return loginAnswer(req, item, deps);
   const single = item === '' ? SINGLETONS[head] : undefined;
   if (single !== undefined) return single(req, deps);
-  if (req.method === 'PUT') return writeAnswer(req, path, dir);
+  if (req.method === 'PUT') return writeAnswer(req, path, search, dir);
   if (req.method === 'POST') return created(req, path, dir);
   return answer(req.method ?? 'GET', path, new URLSearchParams(search), dir);
 }

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

@@ -2,11 +2,14 @@ import {
   closeSync,
   createReadStream,
   existsSync,
+  mkdirSync,
   openSync,
   readdirSync,
   readSync,
+  renameSync,
   rmSync,
   statSync,
+  writeFileSync,
 } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
@@ -22,6 +25,8 @@ const TEXT_CAP = 20_000;
 const RESULT_CAP = 8_000;
 const INPUT_CAP = 4_000;
 const FILE_CAP = 1_000_000;
+const MEMORY_MAX = 256 * 1024;
+const MEMORY_MODE = 0o644;
 const NOISE = ['<task-notification>', '<system-reminder>', '<local-command', '<command-name>'];
 
 export function claudeDir(): string {
@@ -322,6 +327,21 @@ export function listMemory(project: string, dir = claudeDir()): MemoryListing {
   return { files, index: existsSync(index) ? readCapped(index) : null };
 }
 
+export function writeMemoryFile(project: string, name: string, text: string, dir = claudeDir()): MemoryFile {
+  if (text.trim() === '') throw new ApiError('a memory file cannot be empty', 400);
+  if (Buffer.byteLength(text, 'utf8') > MEMORY_MAX)
+    throw new ApiError(`a memory file is at most ${String(MEMORY_MAX)} bytes`, 400);
+  const folder = memoryDir(project, dir);
+  const file = safeName(name, MEMORY_RE, 'memory file name');
+  mkdirSync(folder, { recursive: true });
+  const path = join(folder, file);
+  const tmp = `${path}.metro-${String(process.pid)}`;
+  writeFileSync(tmp, text, { mode: MEMORY_MODE });
+  renameSync(tmp, path);
+  const stat = statSync(path);
+  return { name: file, bytes: stat.size, modifiedAt: stat.mtime.toISOString() };
+}
+
 export function readMemoryFile(project: string, name: string, dir = claudeDir()): string {
   const path = join(memoryDir(project, dir), safeName(name, MEMORY_RE, 'memory file name'));
   if (!existsSync(path)) throw new ApiError('no such memory file', 404);

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

@@ -104,14 +104,22 @@ async function oauthCapable(url: URL, auth: ConnectorAuth): Promise<boolean> {
   return advertisesOAuth(url);
 }
 
-export function localImportConnectors(rows: LoadedConnector[], dir = agentsDir()): number {
+export function localImportConnectors(
+  rows: LoadedConnector[],
+  dir = agentsDir(),
+  mode: 'append' | 'overwrite' = 'overwrite',
+): number {
   const current = readLocalConnectors(dir);
-  for (const row of rows) {
+  const fresh =
+    mode === 'overwrite'
+      ? rows
+      : rows.filter((row) => !current.some((r) => r.id === row.id || r.name === row.name));
+  for (const row of fresh) {
     const other = current.find((r) => r.id !== row.id && r.name === row.name);
     if (other !== undefined)
       throw new ConnectorError(`a connector named '${row.name}' already exists on this daemon; rename it first`, 409);
   }
-  const imported: LocalConnectorRow[] = rows.map((row) => ({
+  const imported: LocalConnectorRow[] = fresh.map((row) => ({
     id: row.id,
     name: row.name,
     url: row.url,

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

@@ -8,6 +8,7 @@ import { assembleMessage, CodexEventTranslator, parseEvent, SseParser } from './
 import { ToolNames, toResponsesRequest } from './codex-translate.js';
 import { GatewayError, idleMessage, providerStatus, sendError, upstreamMessage, type Watch } from './forward.js';
 import type { ModelConfig } from './model-config.js';
+import { noteUsageHeaders } from './usage.js';
 
 export const CODEX_BASE = 'https://chatgpt.com/backend-api/codex';
 const CODEX_VERSION = '0.153.4';
@@ -186,6 +187,7 @@ export async function codexMessages(
 ): Promise<void> {
   const call: Call = { body, model, sessionId: sessionIdOf(req), watch, deps, names: new ToolNames() };
   const upstream = await reach(call, cfg, state);
+  noteUsageHeaders('codex', upstream.headers);
   if (!upstream.ok) {
     const text = await upstream.text();
     sendError(res, providerStatus(upstream.status), errorKind(upstream.status), upstreamMessage(text, `Codex answered ${String(upstream.status)}`));

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

@@ -15,6 +15,7 @@ import { codexCount, codexMessages, freshCodexState, type CodexDeps } from './co
 import { OPENROUTER_BASE } from './openrouter.js';
 import { isRecord } from '@metro-labs/core/is-record';
 import { forgetServed, noteServed } from './served.js';
+import { forgetUsage, noteUsageHeaders } from './usage.js';
 import type { CodexTokens } from './codex-auth.js';
 
 export const GATEWAY_PREFIX = '/gateway';
@@ -38,6 +39,7 @@ const codexState = freshCodexState();
 
 export function resetGatewayState(): void {
   forgetServed();
+  forgetUsage();
   learned.fields.clear();
   learned.dropBetas = false;
   Object.assign(codexState, freshCodexState());
@@ -102,6 +104,7 @@ async function toAnthropic(
     signal: watch.signal,
     redirect: 'manual',
   });
+  noteUsageHeaders('anthropic', upstream.headers);
   await pipeResponse(upstream, res, watch, key === '' ? {} : { ownCredential: true });
 }
 

package/runtime/node_modules/@metro-labs/daemon/src/gateway/model-api.ts

@@ -2,14 +2,15 @@ import type { IncomingMessage, ServerResponse } from 'node:http';
 import { ApiError } from '@metro-labs/http/api-error';
 import { apiFailure, apiSession, cors, readJsonBody, sendJson } from '@metro-labs/http/api-http';
 import { isRecord } from '@metro-labs/core/is-record';
-import { log } from '@metro-labs/core/log';
+import { errMsg, log } from '@metro-labs/core/log';
 import { beginLogin, CodexAuthError, finishLogin, readCodexCliAuth } from './codex-auth.js';
 import { beginDeviceLogin, pollDeviceLogin } from './codex-device.js';
 import { codexModels, currentTokens, freshCodexState } from './codex.js';
-import { openrouterModels, openrouterZdrModels } from './openrouter.js';
+import { openrouterCredits, openrouterModels, openrouterZdrModels } from './openrouter.js';
 import { anthropicModels, bedrockModels } from './provider-models.js';
 import { syncAvailableModelsQuietly, type SetupDeps } from '../claude/setup.js';
 import { lastServed } from './served.js';
+import { noteUsage, openrouterUsage, usageOf, usageSeen } from './usage.js';
 import type { CodexTokens } from './codex-auth.js';
 import { GatewayError } from './forward.js';
 import {
@@ -57,7 +58,31 @@ interface Route {
   run: Handler;
 }
 
-const settingsBody = (cfg: ModelConfig): Record<string, unknown> => ({ ...publicModelConfig(cfg), lastServed: lastServed() });
+const settingsBody = (cfg: ModelConfig): Record<string, unknown> => ({
+  ...publicModelConfig(cfg),
+  lastServed: lastServed(),
+  usage: usageSeen(),
+});
+
+const CREDITS_TTL_MS = 5 * 60_000;
+
+async function refreshCredits(cfg: ModelConfig, deps: ModelApiDeps, now = Date.now()): Promise<void> {
+  const key = cfg.openrouter.apiKey;
+  if (key === '') return;
+  const seen = usageOf('openrouter');
+  if (seen !== undefined && now - Date.parse(seen.at) < CREDITS_TTL_MS) return;
+  try {
+    const credits = await openrouterCredits(key, deps.openrouterBase, deps.fetchImpl);
+    noteUsage('openrouter', openrouterUsage(credits.total, credits.spent, new Date(now)));
+  } catch (err) {
+    log.warn({ err: errMsg(err) }, 'model-api: could not read the OpenRouter credits');
+  }
+}
+
+async function settingsWithUsage(cfg: ModelConfig, deps: ModelApiDeps): Promise<Record<string, unknown>> {
+  await refreshCredits(cfg, deps);
+  return settingsBody(cfg);
+}
 
 function asApiError(err: unknown): never {
   if (err instanceof ModelConfigError || err instanceof CodexAuthError) throw new ApiError(err.message, 400);
@@ -175,7 +200,7 @@ const named = (table: Record<string, Route>, name: string, method: string | unde
 };
 
 function settingsRoute(method: string | undefined): Route | number {
-  if (method === 'GET') return { method: 'GET', run: (_req, _deps, store) => Promise.resolve(settingsBody(store.read())) };
+  if (method === 'GET') return { method: 'GET', run: (_req, deps, store) => settingsWithUsage(store.read(), deps) };
   if (method === 'PUT') return { method: 'POST', run: (req, deps, store) => update(req, store, deps) };
   return 405;
 }

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

@@ -55,6 +55,29 @@ export async function openrouterModels(base = OPENROUTER_BASE, fetchImpl: typeof
     .slice(0, MODELS_MAX);
 }
 
+export interface OpenRouterCredits {
+  total: number;
+  spent: number;
+}
+
+export async function openrouterCredits(
+  apiKey: string,
+  base = OPENROUTER_BASE,
+  fetchImpl: typeof fetch = fetch,
+): Promise<OpenRouterCredits> {
+  const res = await fetchImpl(`${base}/v1/credits`, {
+    headers: { accept: 'application/json', authorization: `Bearer ${apiKey}` },
+    redirect: 'manual',
+  });
+  if (!res.ok) throw new GatewayError(res.status, 'api_error', `OpenRouter would not report the credits (${String(res.status)})`);
+  const body: unknown = await res.json();
+  const data = isRecord(body) && isRecord(body.data) ? body.data : {};
+  const total = Number(data.total_credits);
+  const spent = Number(data.total_usage);
+  if (!Number.isFinite(total) || !Number.isFinite(spent)) throw new GatewayError(502, 'api_error', 'OpenRouter answered with no credit figures');
+  return { total, spent };
+}
+
 export async function openrouterZdrModels(base = OPENROUTER_BASE, fetchImpl: typeof fetch = fetch): Promise<string[]> {
   const res = await fetchImpl(`${base}/v1/endpoints/zdr`, { headers: { accept: 'application/json' }, redirect: 'manual' });
   if (!res.ok) throw new GatewayError(res.status, 'api_error', `OpenRouter would not list its zero data retention endpoints (${String(res.status)})`);

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

@@ -0,0 +1,140 @@
+export type UsageProvider = 'anthropic' | 'codex' | 'openrouter';
+
+export interface UsageWindow {
+  label: string;
+  used: number | null;
+  resetAt: string | null;
+  detail: string | null;
+}
+
+export interface ProviderUsage {
+  windows: UsageWindow[];
+  note: string | null;
+  at: string;
+}
+
+const latest = new Map<UsageProvider, ProviderUsage>();
+
+export const noteUsage = (provider: UsageProvider, usage: ProviderUsage): void => {
+  latest.set(provider, usage);
+};
+
+export const usageSeen = (): Partial<Record<UsageProvider, ProviderUsage>> => Object.fromEntries(latest);
+
+export const usageOf = (provider: UsageProvider): ProviderUsage | undefined => latest.get(provider);
+
+export const forgetUsage = (): void => {
+  latest.clear();
+};
+
+const clamp = (value: number): number => Math.min(1, Math.max(0, value));
+
+function fraction(raw: string | null): number | null {
+  if (raw === null) return null;
+  const value = Number(raw);
+  return Number.isFinite(value) ? clamp(value) : null;
+}
+
+const MS_THRESHOLD = 1e12;
+
+function whenFrom(raw: string | null, now: Date, relative = false): string | null {
+  if (raw === null || raw.trim() === '') return null;
+  const numeric = Number(raw);
+  if (Number.isFinite(numeric)) {
+    const absolute = numeric > MS_THRESHOLD ? numeric : numeric * 1000;
+    const ms = relative ? now.getTime() + numeric * 1000 : absolute;
+    return new Date(ms).toISOString();
+  }
+  const parsed = Date.parse(raw);
+  return Number.isNaN(parsed) ? null : new Date(parsed).toISOString();
+}
+
+const ANTHROPIC_WINDOWS: [string, string][] = [
+  ['5h', '5-hour window'],
+  ['7d', 'Weekly'],
+  ['7d_sonnet', 'Weekly, Sonnet'],
+];
+
+function anthropicUnified(headers: Headers, now: Date): { windows: UsageWindow[]; note: string | null } {
+  const windows: UsageWindow[] = [];
+  let note: string | null = null;
+  for (const [key, label] of ANTHROPIC_WINDOWS) {
+    const used = fraction(headers.get(`anthropic-ratelimit-unified-${key}-utilization`));
+    if (used === null) continue;
+    const status = headers.get(`anthropic-ratelimit-unified-${key}-status`);
+    const blocked = status !== null && status !== 'allowed' ? status.replaceAll('_', ' ') : null;
+    if (blocked !== null && note === null) note = `${label}: ${blocked}`;
+    windows.push({ label, used, resetAt: whenFrom(headers.get(`anthropic-ratelimit-unified-${key}-reset`), now), detail: blocked });
+  }
+  return { windows, note };
+}
+
+function anthropicKeyed(headers: Headers, now: Date): UsageWindow[] {
+  const limit = Number(headers.get('anthropic-ratelimit-tokens-limit'));
+  const remaining = Number(headers.get('anthropic-ratelimit-tokens-remaining'));
+  if (!Number.isFinite(limit) || !Number.isFinite(remaining) || limit <= 0) return [];
+  return [
+    {
+      label: 'Tokens per minute',
+      used: clamp(1 - remaining / limit),
+      resetAt: whenFrom(headers.get('anthropic-ratelimit-tokens-reset'), now),
+      detail: `${remaining.toLocaleString('en-US')} of ${limit.toLocaleString('en-US')} left`,
+    },
+  ];
+}
+
+export function anthropicUsage(headers: Headers, now = new Date()): ProviderUsage | null {
+  const unified = anthropicUnified(headers, now);
+  if (unified.windows.length > 0) return { ...unified, at: now.toISOString() };
+  const keyed = anthropicKeyed(headers, now);
+  return keyed.length === 0 ? null : { windows: keyed, note: null, at: now.toISOString() };
+}
+
+const MINUTES_PER_HOUR = 60;
+const MINUTES_PER_DAY = 24 * MINUTES_PER_HOUR;
+const MINUTES_PER_WEEK = 7 * MINUTES_PER_DAY;
+
+export function windowLabel(minutes: number | null): string {
+  if (minutes === null || !Number.isFinite(minutes) || minutes <= 0) return 'Usage window';
+  if (minutes === MINUTES_PER_WEEK) return 'Weekly';
+  if (minutes % MINUTES_PER_DAY === 0) return `${String(minutes / MINUTES_PER_DAY)}-day window`;
+  if (minutes % MINUTES_PER_HOUR === 0) return `${String(minutes / MINUTES_PER_HOUR)}-hour window`;
+  return `${String(minutes)}-minute window`;
+}
+
+function codexWindow(headers: Headers, kind: 'primary' | 'secondary', now: Date): UsageWindow | null {
+  const raw = headers.get(`x-codex-${kind}-used-percent`);
+  if (raw === null) return null;
+  const percent = Number(raw);
+  if (!Number.isFinite(percent)) return null;
+  const used = clamp(percent / 100);
+  const minutes = Number(headers.get(`x-codex-${kind}-window-minutes`) ?? 'none');
+  const absolute = whenFrom(headers.get(`x-codex-${kind}-reset-at`), now);
+  const resetAt = absolute ?? whenFrom(headers.get(`x-codex-${kind}-reset-after-seconds`), now, true);
+  return { label: windowLabel(Number.isFinite(minutes) ? minutes : null), used, resetAt, detail: null };
+}
+
+export function codexUsage(headers: Headers, now = new Date()): ProviderUsage | null {
+  const windows = [codexWindow(headers, 'primary', now), codexWindow(headers, 'secondary', now)].filter(
+    (w): w is UsageWindow => w !== null,
+  );
+  if (windows.length === 0) return null;
+  const reached = headers.get('x-codex-rate-limit-reached-type');
+  return { windows, note: reached === null || reached === '' ? null : reached.replaceAll('_', ' '), at: now.toISOString() };
+}
+
+export function noteUsageHeaders(provider: 'anthropic' | 'codex', headers: Headers, now = new Date()): void {
+  const usage = provider === 'anthropic' ? anthropicUsage(headers, now) : codexUsage(headers, now);
+  if (usage !== null) noteUsage(provider, usage);
+}
+
+const dollars = (value: number): string => `$${value.toFixed(2)}`;
+
+export function openrouterUsage(total: number, spent: number, now = new Date()): ProviderUsage {
+  const used = total > 0 ? clamp(spent / total) : null;
+  return {
+    windows: [{ label: 'Credits', used, resetAt: null, detail: `${dollars(spent)} of ${dollars(total)} used` }],
+    note: null,
+    at: now.toISOString(),
+  };
+}

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

@@ -164,10 +164,10 @@ function bundleApi(deps: LocalModeDeps): BundleApiDeps {
       if (bundle.agent.key === '') throw new ApiError(`agent '${agent.name}' has no key to bundle`, 400);
       return bundle;
     },
-    restore: async (subject, bundle) => {
+    restore: async (subject, bundle, mode) => {
       assertLocalOwner(subject);
-      const made = await localImportAgent(subject, loadedAgentOf(bundle));
-      const connectors = localImportConnectors(bundle.connectors);
+      const made = await localImportAgent(subject, 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');

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.117"
+  "version": "0.1.0-beta.119"
 }