@stage-labs/metro 0.1.0-beta.183 → 0.1.0-beta.185

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.183",
+  "version": "0.1.0-beta.185",
   "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.183",
+  "version": "0.1.0-beta.185",
   "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/api.ts

@@ -0,0 +1,68 @@
+import { existsSync, rmSync } from 'node:fs';
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { join } from 'node:path';
+import { ApiError } from '@metro-labs/http/api-error';
+import { bodyField, readJsonBody, sessionRoute } from '@metro-labs/http/api-http';
+import { log } from '@metro-labs/core/log';
+import { writeSecure } from '@metro-labs/core/secure-fs';
+import { agentsDir } from '../agents/files.js';
+import { agentUser, CONFIG_FILE, forgetAgentUser, wantedAgentUser } from './user.js';
+
+const PATH = '/api/agent-user';
+const EXIT_DELAY_MS = 500;
+
+export interface AgentUserApiDeps {
+  restart: () => void;
+  agents?: () => string;
+  host?: () => { platform: string; uid: number | undefined; cli: boolean };
+}
+
+export interface AgentUserStatus {
+  enabled: boolean;
+  user: string | null;
+  active: boolean;
+  supported: boolean;
+  reason: string | null;
+}
+
+const realHost = (): { platform: string; uid: number | undefined; cli: boolean } => ({
+  platform: process.platform,
+  uid: process.getuid?.(),
+  cli: (process.env.METRO_CLI_BIN?.trim() ?? '') !== '',
+});
+
+function unsupported(host: { platform: string; uid: number | undefined; cli: boolean }): string | null {
+  if (host.platform !== 'linux') return 'Claude Code can run as its own user on Linux only.';
+  if (host.uid !== 0) return 'Metro runs as a normal user here, so it cannot switch Claude Code to another user.';
+  if (!host.cli) return 'This daemon was not started by metro serve, so nothing would bring it back after the switch.';
+  return null;
+}
+
+export function agentUserStatus(deps: Pick<AgentUserApiDeps, 'agents' | 'host'> = {}): AgentUserStatus {
+  const dir = (deps.agents ?? agentsDir)();
+  const reason = unsupported((deps.host ?? realHost)());
+  const user = wantedAgentUser(dir);
+  return { enabled: user !== null, user, active: user !== null && agentUser(dir) !== null, supported: reason === null, reason };
+}
+
+function setWanted(dir: string, enabled: boolean): void {
+  const path = join(dir, CONFIG_FILE);
+  if (enabled) writeSecure(path, `${JSON.stringify({ user: 'agent' })}\n`);
+  else if (existsSync(path)) rmSync(path);
+  forgetAgentUser();
+}
+
+export function handleAgentUserRequest(req: IncomingMessage, res: ServerResponse, deps: AgentUserApiDeps): boolean {
+  return sessionRoute(req, res, { methods: { [PATH]: ['GET', 'POST'] }, admin: ['POST'], label: 'agent-user-api' }, async (session) => {
+    if (req.method === 'GET') return agentUserStatus(deps);
+    const enabled = bodyField(await readJsonBody(req), 'enabled');
+    if (typeof enabled !== 'boolean') throw new ApiError('enabled must be true or false', 400);
+    const reason = unsupported((deps.host ?? realHost)());
+    if (enabled && reason !== null) throw new ApiError(reason, 400);
+    const dir = (deps.agents ?? agentsDir)();
+    setWanted(dir, enabled);
+    log.info({ enabled, subject: session.subject }, 'agent-user-api: switched from the page; restarting');
+    setTimeout(deps.restart, EXIT_DELAY_MS).unref();
+    return { ...agentUserStatus(deps), restarting: true };
+  });
+}

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

@@ -123,11 +123,11 @@ export async function provisionAgentUser(dir = agentsDir(), env: NodeJS.ProcessE
   try {
     const user = ensureUser(name);
     if (user === null) throw new Error(`the user ${name} could not be found after creating it`);
+    stopRootSession();
     migrateClaude(user, dir);
     await installClaude(user);
     copyMarketplace(user, env);
     watchAgentView();
-    stopRootSession();
     return 'ready';
   } catch (err) {
     log.error({ user: name, err: errMsg(err) }, 'agent-user: could not prepare the agent user; the Claude session stays stopped');

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

@@ -70,7 +70,7 @@ export function agentEnv(user: AgentUser, extra: Record<string, string> = {}): R
 export function asUser(user: AgentUser | null, file: string, args: readonly string[], extra: Record<string, string> = {}): [string, string[]] {
   if (user === null) return [file, [...args]];
   const env = Object.entries(agentEnv(user, extra)).map(([k, v]) => `${k}=${v}`);
-  return ['runuser', ['-u', user.name, '--', 'env', '-i', ...env, file, ...args]];
+  return ['setpriv', [`--reuid=${String(user.uid)}`, `--regid=${String(user.gid)}`, '--init-groups', 'env', '-i', ...env, file, ...args]];
 }
 
 export const asAgent = (file: string, args: readonly string[], extra: Record<string, string> = {}): [string, string[]] =>

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

@@ -21,6 +21,7 @@ import {
   type PendingAtt,
   type PendingMsg,
 } from './pending.js';
+import { agentUser } from '../agent-user/user.js';
 
 interface InboundDeps {
   mcp: Server;
@@ -106,11 +107,12 @@ export class InboundRelay {
   }
 
   private async surfaceMedia(ctx: MediaCtx, p: SavedMedia): Promise<void> {
-    const note = await buildMediaNote(p, ctx.text ?? '');
+    const ownUser = agentUser() !== null;
+    const note = await buildMediaNote(p, ctx.text ?? '', !ownUser);
     if (!note) return;
     await this.surfaceNote(ctx, p, note, {
       ...(p.url ? { url: p.url } : {}),
-      local_path: note.path,
+      ...(ownUser ? {} : { local_path: note.path }),
     });
   }
 

package/runtime/node_modules/@metro-labs/daemon/src/channels/media-note.ts

@@ -50,22 +50,27 @@ function howToRead(url: string | undefined, tooBig: boolean): string {
   return 'Fetch the Public URL to view it. The path is on the daemon host, so the Read tool works only for an agent running there.';
 }
 
+const headline = (kind: string, name: string, mime: string | undefined, size: number): string =>
+  `[${kind} attachment received: ${name}${mime ? `, ${mime}` : ''}${size ? ` (${(size / 1024 / 1024).toFixed(2)} MB)` : ''}]\n`;
+
+const whereItIs = (path: string, url: string | undefined, size: number, showPath: boolean): string =>
+  showPath ? `Daemon-host path: ${path}\n${howToRead(url, size > MAX_INLINE_BYTES)}` : 'Fetch the Public URL to get the file.';
+
 export async function buildMediaNote(
   p: SavedMedia,
   caption: string,
+  showPath = true,
 ): Promise<MediaNote | null> {
   const path = p.attachmentPath ?? p.localPath;
   if (!path) return null;
   const kind = p.kind ?? mediaKind(p.mime, p.name);
   const name = p.name ?? path.split('/').pop() ?? 'attachment';
   const size = await fileSize(path);
-  const sizeNote = size ? ` (${(size / 1024 / 1024).toFixed(2)} MB)` : '';
   const content =
     (caption ? `${caption}\n` : '') +
-    `[${kind} attachment received: ${name}${p.mime ? `, ${p.mime}` : ''}${sizeNote}]\n` +
+    headline(kind, name, p.mime, size) +
     (p.url ? `Public URL: ${p.url}\n` : '') +
-    `Daemon-host path: ${path}\n` +
-    howToRead(p.url, size > MAX_INLINE_BYTES);
+    whereItIs(path, p.url, size, showPath);
   return { content, kind, name, path };
 }
 

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

@@ -96,9 +96,14 @@ function realDir(dir: string): string {
   }
 }
 
+const encodedCwd = (dir: string): string => dir.replace(/[^A-Za-z0-9]/g, '-');
+
 export function hasConversation(home: string, dir = claudeDir()): boolean {
   const cwd = realDir(home);
-  return listClaudeProjects(dir).some((project) => project.sessions > 0 && project.cwd !== null && realDir(project.cwd) === cwd);
+  const folder = encodedCwd(cwd);
+  return listClaudeProjects(dir).some(
+    (project) => project.sessions > 0 && (project.id === folder || (project.cwd !== null && realDir(project.cwd) === cwd)),
+  );
 }
 
 function metroCommand(deps: SessionDeps, home: string): string[] {

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

@@ -1,5 +1,6 @@
 import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { writeHomeInPlace } from '../agent-user/home-fs.js';
+import { agentMarketplaceDir, agentUser } from '../agent-user/user.js';
 import { join } from 'node:path';
 import { errMsg, log } from '@metro-labs/core/log';
 import { claudeDir } from '../claude/files.js';
@@ -70,7 +71,9 @@ function pluginRootsUnder(dir: string, depth: number, out: string[]): void {
 
 export function stagedPluginDir(env: NodeJS.ProcessEnv = process.env): string | null {
   const store = env.METRO_RUNTIME_STORE?.trim() ?? '';
-  return store === '' ? null : join(store, 'marketplace', 'plugin');
+  if (store === '') return null;
+  const user = agentUser();
+  return join(user === null ? join(store, 'marketplace') : agentMarketplaceDir(user), 'plugin');
 }
 
 export function installedPluginFiles(dir = claudeDir(), staged = stagedPluginDir()): string[] {

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

@@ -5,7 +5,8 @@ import { isRecord } from '@metro-labs/core/is-record';
 import { log } from '@metro-labs/core/log';
 import { openrouterModels, openrouterZdrModels } from './openrouter.js';
 import { anthropicModels, bedrockModels } from './provider-models.js';
-import { syncAvailableModelsQuietly } from '../claude/setup.js';
+import { routeOf, syncAvailableModelsQuietly } from '../claude/setup.js';
+import { sessionRunning, stopSession } from '../claude/session.js';
 import { forgetOne } from './usage.js';
 import {
   addConnection,
@@ -35,10 +36,19 @@ const DEVICE_ID_RE = /^[A-Za-z0-9_-]{16,64}$/;
 
 export type { ModelApiDeps } from './model-store.js';
 
+function restartRunningSession(): boolean {
+  if (!sessionRunning()) return false;
+  stopSession();
+  return true;
+}
+
 function kept(store: Store, next: ModelConfig, deps: ModelApiDeps, note: string, fields: Record<string, unknown>): unknown {
+  const before = routeOf(store.read());
   store.write(next);
   syncAvailableModelsQuietly(deps.setup ?? {}, next);
   log.info(fields, note);
+  if (routeOf(next) !== before && (deps.restartSession ?? restartRunningSession)())
+    log.info({ was: before, now: routeOf(next) }, 'model-api: the model changed, so the Claude session restarts on it');
   return settingsBody(next);
 }
 

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

@@ -23,6 +23,7 @@ export interface ModelApiDeps {
   anthropicBase?: string;
   bedrockControlBase?: string;
   setup?: SetupDeps;
+  restartSession?: () => boolean;
 }
 
 export interface Store {

package/runtime/node_modules/@metro-labs/daemon/src/mcp/read-tool.ts

@@ -5,6 +5,7 @@ import { agentIdForAccount, accountFromLine, knownAccounts } from '../agents/map
 import { attachmentUrl } from '../files/attach-serve.js';
 import { stationByName } from '../stations/registry.js';
 import { errResult, makeCtx, okJson, toErr } from './ctx.js';
+import { agentUser } from '../agent-user/user.js';
 
 const FILTERS: readonly (readonly [string, ReadFilter, string])[] = [
   ['query', 'query', 'query'],
@@ -45,7 +46,8 @@ function withUrls(result: unknown, agentId: string | undefined): unknown {
   const attachments = files.map((f: unknown) => {
     if (!isRecord(f) || typeof f.local_path !== 'string') return f;
     const url = attachmentUrl(f.local_path, agentId);
-    return url === null ? f : { ...f, url };
+    const shown = agentUser() === null ? f : Object.fromEntries(Object.entries(f).filter(([key]) => key !== 'local_path'));
+    return url === null ? shown : { ...shown, url };
   });
   return { ...result, message: { ...result.message, attachments } };
 }

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

@@ -195,6 +195,7 @@ export function localSessionApis(deps: LocalModeDeps): SessionApis {
     claudeApi: {},
     updateApi: { restart: deps.restart },
     controlApi: { restart: deps.restart, stop: deps.stop },
+    agentUserApi: { restart: deps.restart },
     ownerApi: { setOwner: (owner) => setLocalOwner(owner) },
     machineApi: {},
     modelApi: {},

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

@@ -17,12 +17,14 @@ import { handleMachineRequest, type MachineApiDeps } from '../server/machine.js'
 import { handleModelRequest, type ModelApiDeps } from '../gateway/model-api.js';
 import type { GatewayDeps } from '../gateway/gateway.js';
 import { handleTerminalRequest, type TerminalApiDeps } from '../terminal/api.js';
+import { handleAgentUserRequest, type AgentUserApiDeps } from '../agent-user/api.js';
 
 export interface SessionApis {
   agentApi?: AgentApiDeps;
   bundleApi?: BundleApiDeps;
   updateApi?: UpdateApiDeps;
   controlApi?: ControlApiDeps;
+  agentUserApi?: AgentUserApiDeps;
   ownerApi?: OwnerApiDeps;
   machineApi?: MachineApiDeps;
   modelApi?: ModelApiDeps;
@@ -49,6 +51,7 @@ export function handleSessionApis(
     ...when(apis.bundleApi, (d) => handleBundleRequest(req, res, d)),
     ...when(apis.updateApi, (d) => handleUpdateRequest(req, res, d)),
     ...when(apis.controlApi, (d) => handleControlRequest(req, res, d)),
+    ...when(apis.agentUserApi, (d) => handleAgentUserRequest(req, res, d)),
     ...when(apis.ownerApi, (d) => handleOwnerRequest(req, res, d)),
     ...when(apis.machineApi, (d) => handleMachineRequest(req, res, d)),
     ...when(apis.modelApi, (d) => handleModelRequest(req, res, d)),

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

@@ -64,7 +64,13 @@ async function fromPathAs(
 ): Promise<ResolvedAttachment> {
   const proc = Bun.spawn(agentCommand(['cat', '--', path]), { stdout: 'pipe', stderr: 'pipe' });
   const name = a.name ?? basenameOf(path) ?? 'attachment';
-  const saved = await streamToTemp(proc.stdout, name);
+  let saved: Awaited<ReturnType<typeof streamToTemp>>;
+  try {
+    saved = await streamToTemp(proc.stdout, name);
+  } catch (err) {
+    proc.kill();
+    throw err;
+  }
   if ((await proc.exited) !== 0) {
     await removeInlineTemp(saved.dir);
     throw new Error(

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.183"
+  "version": "0.1.0-beta.185"
 }