@stage-labs/metro 0.1.0-beta.182 → 0.1.0-beta.184

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.182",
+  "version": "0.1.0-beta.184",
   "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.182",
+  "version": "0.1.0-beta.184",
   "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/home-fs.ts

@@ -0,0 +1,113 @@
+import { spawn, spawnSync } from 'node:child_process';
+import { createWriteStream, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync, utimesSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import type { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { writeAtomic } from '@metro-labs/core/secure-fs';
+import { agentUser, asUser, type AgentUser } from './user.js';
+
+const WRITE = [
+  'set -e',
+  'mkdir -p -- "$(dirname -- "$1")"',
+  'tmp=$(mktemp -- "$1.metro-XXXXXX")',
+  'trap \'rm -f -- "$tmp"\' EXIT',
+  'cat > "$tmp"',
+  'chmod -- "$2" "$tmp"',
+  'if [ -n "$3" ]; then touch -d "@$3" -- "$tmp"; fi',
+  'mv -f -- "$tmp" "$1"',
+  'trap - EXIT',
+].join('\n');
+
+const octal = (mode: number): string => mode.toString(8);
+const epoch = (mtime: Date | undefined): string => (mtime === undefined ? '' : String(Math.floor(mtime.getTime() / 1000)));
+
+function runAs(user: AgentUser, script: string, args: string[], input?: string): void {
+  const [file, argv] = asUser(user, 'sh', ['-c', script, 'metro', ...args]);
+  const run = spawnSync(file, argv, { input, encoding: 'utf8', stdio: ['pipe', 'ignore', 'pipe'] });
+  if (run.error !== undefined) throw run.error;
+  if (run.status !== 0) throw new Error(`as ${user.name}: ${run.stderr.trim() || `exit ${String(run.status)}`}`);
+}
+
+export function writeHomeText(path: string, text: string, mode = 0o644, mtime?: Date, user = agentUser()): void {
+  if (user !== null) {
+    runAs(user, WRITE, [path, octal(mode), epoch(mtime)], text);
+    return;
+  }
+  writeAtomic(path, text, mode);
+  if (mtime !== undefined) utimesSync(path, mtime, mtime);
+}
+
+export function writeHomeInPlace(path: string, text: string, mode = 0o644, user = agentUser()): void {
+  if (user !== null) {
+    runAs(user, 'mkdir -p -- "$(dirname -- "$1")"; cat > "$1"; chmod -- "$2" "$1"', [path, octal(mode)], text);
+    return;
+  }
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, text, { mode });
+}
+
+function filesUnder(root: string, rel = ''): string[] {
+  return readdirSync(join(root, rel), { withFileTypes: true }).flatMap((entry) => {
+    const inner = rel === '' ? entry.name : `${rel}/${entry.name}`;
+    if (entry.isDirectory()) return filesUnder(root, inner);
+    return entry.isFile() ? [inner] : [];
+  });
+}
+
+export function copyIntoHome(from: string, to: string, user = agentUser()): number {
+  removeHome(to, true, user);
+  const files = filesUnder(from);
+  for (const rel of files) {
+    const source = join(from, rel);
+    writeHomeText(join(to, rel), readFileSync(source, 'utf8'), statSync(source).mode & 0o777, undefined, user);
+  }
+  return files.length;
+}
+
+export function removeHome(path: string, recursive = false, user = agentUser()): void {
+  if (user !== null) {
+    runAs(user, recursive ? 'rm -rf -- "$1"' : 'rm -f -- "$1"', [path]);
+    return;
+  }
+  rmSync(path, { recursive, force: true });
+}
+
+export function moveHome(from: string, to: string, user = agentUser()): void {
+  if (user !== null) {
+    runAs(user, 'mv -f -- "$1" "$2"', [from, to]);
+    return;
+  }
+  renameSync(from, to);
+}
+
+async function receiveAs(user: AgentUser, path: string, source: Readable, mode: number): Promise<void> {
+  const [file, argv] = asUser(user, 'sh', ['-c', WRITE, 'metro', path, octal(mode), '']);
+  const child = spawn(file, argv, { stdio: ['pipe', 'ignore', 'pipe'] });
+  let stderr = '';
+  child.stderr.on('data', (chunk: Buffer) => {
+    stderr += chunk.toString('utf8');
+  });
+  const closed = new Promise<number | null>((resolve, reject) => {
+    child.on('error', reject);
+    child.on('close', resolve);
+  });
+  await pipeline(source, child.stdin);
+  const status = await closed;
+  if (status !== 0) throw new Error(`as ${user.name}: ${stderr.trim() || `exit ${String(status)}`}`);
+}
+
+export async function receiveHomeFile(path: string, source: Readable, mode = 0o600, user = agentUser()): Promise<void> {
+  if (user !== null) {
+    await receiveAs(user, path, source, mode);
+    return;
+  }
+  mkdirSync(dirname(path), { recursive: true });
+  const tmp = `${path}.metro-${String(process.pid)}.part`;
+  try {
+    await pipeline(source, createWriteStream(tmp, { mode }));
+    renameSync(tmp, path);
+  } catch (err) {
+    rmSync(tmp, { force: true });
+    throw err;
+  }
+}

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

@@ -0,0 +1,136 @@
+import { spawn, spawnSync } from 'node:child_process';
+import { existsSync, lstatSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { errMsg, log } from '@metro-labs/core/log';
+import { isRecord } from '@metro-labs/core/is-record';
+import { agentsDir } from '../agents/files.js';
+import { copyIntoHome } from './home-fs.js';
+import { agentMarketplaceDir, agentUser, asUser, claudeBin, forgetAgentUser, wantedAgentUser, type AgentUser } from './user.js';
+import { watchAgentView } from './view.js';
+
+const INSTALL_MS = 10 * 60_000;
+const INSTALLER = 'curl -fsSL https://claude.ai/install.sh | bash';
+const MIGRATED = '.agent-user-migrated';
+
+export type Provisioned = 'off' | 'unsupported' | 'failed' | 'ready';
+
+function run(file: string, args: string[]): void {
+  const done = spawnSync(file, args, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+  if (done.error !== undefined) throw done.error;
+  if (done.status !== 0) throw new Error(`${file} ${args.join(' ')}: ${done.stderr.trim() || `exit ${String(done.status)}`}`);
+}
+
+function ensureUser(name: string): AgentUser | null {
+  if (agentUser() === null) {
+    run('useradd', ['--create-home', '--shell', '/bin/bash', name]);
+    log.info({ user: name }, 'agent-user: created the user Claude Code runs as');
+    forgetAgentUser();
+  }
+  const user = agentUser();
+  if (user !== null) run('chmod', ['700', user.home]);
+  return user;
+}
+
+const absent = (path: string): boolean => {
+  try {
+    lstatSync(path);
+    return false;
+  } catch {
+    return true;
+  }
+};
+
+const encodedCwd = (dir: string): string => dir.replace(/[^A-Za-z0-9]/g, '-');
+
+function moveProject(user: AgentUser, from: string): void {
+  const projects = join(user.home, '.claude', 'projects');
+  const old = join(projects, encodedCwd(from));
+  const next = join(projects, encodedCwd(user.home));
+  if (existsSync(old) && absent(next)) run('mv', ['-T', old, next]);
+}
+
+function migrateClaude(user: AgentUser, dir: string): void {
+  const marker = join(dir, MIGRATED);
+  if (existsSync(marker)) return;
+  const home = homedir();
+  const copied: string[] = [];
+  for (const name of ['.claude', '.claude.json']) {
+    const from = join(home, name);
+    const to = join(user.home, name);
+    if (!existsSync(from) || !absent(to)) continue;
+    run('cp', ['-aT', from, to]);
+    run('chown', ['-hR', `${user.name}:${String(user.gid)}`, to]);
+    copied.push(name);
+  }
+  if (copied.includes('.claude')) moveProject(user, home);
+  run('touch', [marker]);
+  log.info({ user: user.name, copied }, 'agent-user: moved the Claude Code folder and login to the agent user once; root keeps its copy');
+}
+
+function installClaude(user: AgentUser): Promise<void> {
+  if (existsSync(claudeBin(user))) return Promise.resolve();
+  const [file, args] = asUser(user, 'bash', ['-c', INSTALLER]);
+  return new Promise((resolve, reject) => {
+    const child = spawn(file, args, { stdio: ['ignore', 'ignore', 'pipe'], cwd: '/', timeout: INSTALL_MS });
+    let said = '';
+    child.stderr.on('data', (chunk: Buffer) => {
+      said = `${said}${chunk.toString('utf8')}`.slice(-2000);
+    });
+    child.on('error', reject);
+    child.on('close', (code) => {
+      if (code === 0 && existsSync(claudeBin(user))) {
+        log.info({ user: user.name }, 'agent-user: installed Claude Code for the agent user');
+        resolve();
+      } else reject(new Error(`the Claude Code installer failed: ${said.trim() || `exit ${String(code)}`}`));
+    });
+  });
+}
+
+const pluginVersion = (dir: string): string | null => {
+  try {
+    const parsed: unknown = JSON.parse(readFileSync(join(dir, 'plugin', '.claude-plugin', 'plugin.json'), 'utf8'));
+    return isRecord(parsed) && typeof parsed.version === 'string' ? parsed.version : null;
+  } catch {
+    return null;
+  }
+};
+
+function copyMarketplace(user: AgentUser, env: NodeJS.ProcessEnv): void {
+  const store = env.METRO_RUNTIME_STORE?.trim() ?? '';
+  const from = join(store, 'marketplace');
+  if (store === '' || !existsSync(join(from, '.claude-plugin', 'marketplace.json'))) return;
+  const to = agentMarketplaceDir(user);
+  if (pluginVersion(from) !== null && pluginVersion(from) === pluginVersion(to)) return;
+  const files = copyIntoHome(from, to, user);
+  log.info({ files, version: pluginVersion(from) }, 'agent-user: copied the metro plugin where the agent user can load it');
+}
+
+function stopRootSession(): void {
+  const running = spawnSync('tmux', ['has-session', '-t', 'metro'], { stdio: 'ignore' });
+  if (running.error !== undefined || running.status !== 0) return;
+  spawnSync('tmux', ['kill-session', '-t', 'metro'], { stdio: 'ignore' });
+  log.info('agent-user: stopped the Claude session root was running; it comes back as the agent user');
+}
+
+export async function provisionAgentUser(dir = agentsDir(), env: NodeJS.ProcessEnv = process.env): Promise<Provisioned> {
+  const name = wantedAgentUser(dir);
+  if (name === null) return 'off';
+  if (process.platform !== 'linux' || process.getuid?.() !== 0) {
+    log.warn({ user: name }, 'agent-user: running Claude Code as its own user needs Linux and a daemon running as root; the Claude session stays stopped');
+    return 'unsupported';
+  }
+  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();
+    return 'ready';
+  } catch (err) {
+    log.error({ user: name, err: errMsg(err) }, 'agent-user: could not prepare the agent user; the Claude session stays stopped');
+    return 'failed';
+  }
+}

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

@@ -0,0 +1,92 @@
+import { spawnSync } from 'node:child_process';
+import { join } from 'node:path';
+import { isRecord } from '@metro-labs/core/is-record';
+import { readJson } from '@metro-labs/core/secure-fs';
+import { agentsDir } from '../agents/files.js';
+
+export const CONFIG_FILE = 'agent-user.json';
+const NAME_RE = /^[a-z_][a-z0-9_-]{0,31}$/;
+const AGENT_PATH = ['.local/bin', '/usr/local/sbin', '/usr/local/bin', '/usr/sbin', '/usr/bin', '/sbin', '/bin'];
+
+export interface AgentUser {
+  name: string;
+  uid: number;
+  gid: number;
+  home: string;
+}
+
+export interface UserHost {
+  platform: string;
+  uid: number | undefined;
+  lookup: (name: string) => AgentUser | null;
+}
+
+function lookupUser(name: string): AgentUser | null {
+  const run = spawnSync('getent', ['passwd', name], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+  if (run.error !== undefined || run.status !== 0) return null;
+  const [, , uid = '', gid = '', , home = ''] = run.stdout.trim().split(':');
+  const u = Number(uid);
+  const g = Number(gid);
+  return Number.isInteger(u) && u > 0 && Number.isInteger(g) && home.startsWith('/') ? { name, uid: u, gid: g, home } : null;
+}
+
+const realHost: UserHost = { platform: process.platform, uid: process.getuid?.(), lookup: lookupUser };
+
+export function wantedAgentUser(dir = agentsDir()): string | null {
+  const raw = readJson<unknown>(join(dir, CONFIG_FILE), null);
+  if (!isRecord(raw) || raw.enabled === false) return null;
+  const name = typeof raw.user === 'string' ? raw.user : 'agent';
+  return NAME_RE.test(name) && name !== 'root' ? name : null;
+}
+
+let cached: { key: string; user: AgentUser | null } | null = null;
+
+export function agentUser(dir = agentsDir(), host: UserHost = realHost): AgentUser | null {
+  const name = wantedAgentUser(dir);
+  if (name === null || host.platform !== 'linux' || host.uid !== 0) return null;
+  const key = `${dir}\n${name}`;
+  if (cached?.key === key && cached.user !== null) return cached.user;
+  cached = { key, user: host.lookup(name) };
+  return cached.user;
+}
+
+export function forgetAgentUser(): void {
+  cached = null;
+}
+
+export function agentEnv(user: AgentUser, extra: Record<string, string> = {}): Record<string, string> {
+  return {
+    HOME: user.home,
+    USER: user.name,
+    LOGNAME: user.name,
+    SHELL: '/bin/bash',
+    LANG: process.env.LANG ?? 'C.UTF-8',
+    TERM: process.env.TERM ?? 'xterm-256color',
+    PATH: AGENT_PATH.map((p) => (p.startsWith('/') ? p : join(user.home, p))).join(':'),
+    ...extra,
+  };
+}
+
+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]];
+}
+
+export const asAgent = (file: string, args: readonly string[], extra: Record<string, string> = {}): [string, string[]] =>
+  asUser(agentUser(), file, args, extra);
+
+export const agentCommand = (command: readonly string[], extra: Record<string, string> = {}): string[] => {
+  const [file = '', ...args] = command;
+  const [bin, argv] = asAgent(file, args, extra);
+  return [bin, ...argv];
+};
+
+export function claudeBin(user = agentUser()): string {
+  return user === null ? 'claude' : join(user.home, '.local', 'bin', 'claude');
+}
+
+export const claudeHome = (user = agentUser()): string | null => (user === null ? null : user.home);
+
+export const agentMarketplaceDir = (user: AgentUser): string => join(user.home, '.metro', 'marketplace');
+export const agentViewDir = (user: AgentUser): string => join(user.home, '.metro', 'agents');

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

@@ -0,0 +1,87 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { errMsg, log } from '@metro-labs/core/log';
+import { isRecord } from '@metro-labs/core/is-record';
+import { agentsDir } from '../agents/files.js';
+import { removeHome, writeHomeText } from './home-fs.js';
+import { agentUser, agentViewDir, type AgentUser } from './user.js';
+
+const COPIED = ['policy.json', 'claude-setup.json', 'system-prompt.md'] as const;
+const SYNC_MS = 5_000;
+
+const readText = (path: string): string | null => {
+  try {
+    return readFileSync(path, 'utf8');
+  } catch {
+    return null;
+  }
+};
+
+const readRecord = (path: string): Record<string, unknown> | null => {
+  const text = readText(path);
+  if (text === null) return null;
+  try {
+    const parsed: unknown = JSON.parse(text);
+    return isRecord(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+};
+
+const json = (value: unknown): string => `${JSON.stringify(value, null, 2)}\n`;
+
+function agentFile(dir: string): string | null {
+  const file = readRecord(join(dir, 'agent.json'));
+  if (file === null || typeof file.id !== 'string' || typeof file.key !== 'string') return null;
+  return json({ version: 1, id: file.id, key: file.key });
+}
+
+function modelFile(dir: string): string | null {
+  const cfg = readRecord(join(dir, 'model.json'));
+  if (cfg === null || !Array.isArray(cfg.connections)) return null;
+  const connections = cfg.connections.filter(isRecord).map((c) => ({ id: c.id, provider: c.provider, model: c.model }));
+  return json({ version: 2, route: cfg.route, connections });
+}
+
+export function viewFiles(dir = agentsDir()): Map<string, string | null> {
+  const files = new Map<string, string | null>([
+    ['agent.json', agentFile(dir)],
+    ['model.json', modelFile(dir)],
+  ]);
+  for (const name of COPIED) files.set(name, existsSync(join(dir, name)) ? readText(join(dir, name)) : null);
+  return files;
+}
+
+const written = new Map<string, string | null>();
+
+export function syncAgentView(user: AgentUser | null = agentUser(), dir = agentsDir()): number {
+  if (user === null) return 0;
+  const target = agentViewDir(user);
+  let changed = 0;
+  for (const [name, text] of viewFiles(dir)) {
+    const path = join(target, name);
+    if (written.has(path) && written.get(path) === text) continue;
+    if (text === null) removeHome(path, false, user);
+    else writeHomeText(path, text, 0o600, undefined, user);
+    written.set(path, text);
+    changed += 1;
+  }
+  return changed;
+}
+
+let timer: ReturnType<typeof setInterval> | null = null;
+
+export function watchAgentView(everyMs = SYNC_MS): void {
+  if (timer !== null) return;
+  const tick = (): void => {
+    try {
+      const changed = syncAgentView();
+      if (changed > 0) log.info({ changed }, 'agent-user: refreshed the Metro files the agent may read');
+    } catch (err) {
+      log.warn({ err: errMsg(err) }, 'agent-user: could not refresh the Metro files the agent may read');
+    }
+  };
+  tick();
+  timer = setInterval(tick, everyMs);
+  timer.unref();
+}

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

@@ -23,6 +23,7 @@ import { agentsDir, fileSource } from '../agents/files.js';
 import { syncPluginServers } from '../connectors/plugin-sync.js';
 import { loadConnectorPolicies, readLocalConnectors } from '../connectors/store.js';
 import { ensureMetroPlugin } from '../claude/plugin-install.js';
+import { provisionAgentUser } from '../agent-user/provision.js';
 import { unwatchSession, watchSession } from '../claude/session.js';
 import { tryClaudeSetup } from '../claude/setup.js';
 import { applyLocalOwner } from './local-owner.js';
@@ -147,6 +148,15 @@ installBearerSessions(agentsDir(), localOwner);
     'dispatcher ready',
   );
   markDaemonReady();
+  startClaude().catch((err: unknown) => {
+    log.warn({ err: errMsg(err) }, 'claude: could not start the Claude Code side');
+  });
+}
+
+async function startClaude(): Promise<void> {
+  const agentUser = await provisionAgentUser();
+  if (agentUser !== 'off') log.info({ agentUser }, 'agent-user: Claude Code runs as its own user');
+  if (agentUser === 'failed' || agentUser === 'unsupported') return;
   ensureMetroPlugin()
     .then((outcome) => {
       log.info({ outcome }, 'plugin: metro plugin for Claude Code');

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/files.ts

@@ -5,16 +5,15 @@ import {
   openSync,
   readdirSync,
   readSync,
-  rmSync,
   statSync,
-  utimesSync,
 } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { createInterface } from 'node:readline';
 import { ApiError } from '@metro-labs/http/api-error';
 import { isRecord } from '@metro-labs/core/is-record';
-import { writeAtomic } from '@metro-labs/core/secure-fs';
+import { removeHome, writeHomeText } from '../agent-user/home-fs.js';
+import { agentUser } from '../agent-user/user.js';
 
 export const PROJECT_RE = /^[A-Za-z0-9._-]{1,200}$/;
 export const SESSION_RE = /^[A-Za-z0-9][A-Za-z0-9-]{7,63}$/;
@@ -36,7 +35,8 @@ export function claudeDir(): string {
   if (explicit !== undefined && explicit !== '') return explicit;
   const cfg = process.env.CLAUDE_CONFIG_DIR?.trim();
   if (cfg !== undefined && cfg !== '') return cfg;
-  return join(homedir(), '.claude');
+  const user = agentUser();
+  return join(user === null ? homedir() : user.home, '.claude');
 }
 
 const str = (v: unknown): string | null => (typeof v === 'string' && v !== '' ? v : null);
@@ -284,8 +284,8 @@ export function deleteClaudeSession(project: string, session: string, dir = clau
   const id = safeName(session, SESSION_RE, 'session id');
   const file = join(root, `${id}.jsonl`);
   if (!existsSync(file)) throw new ApiError('no such session', 404);
-  rmSync(file);
-  rmSync(join(root, id), { recursive: true, force: true });
+  removeHome(file);
+  removeHome(join(root, id), true);
 }
 
 export interface MemoryFile {
@@ -361,9 +361,7 @@ export function writeMemoryFile(project: string, name: string, text: string, dir
   if (Buffer.byteLength(text, 'utf8') > MEMORY_MAX)
     throw new ApiError(`a memory file is at most ${String(MEMORY_MAX)} bytes`, 400);
   const path = memoryPath(project, name, dir);
-  writeAtomic(path, text, MEMORY_MODE);
-  const stamp = stampOf(modifiedAt);
-  if (stamp !== null) utimesSync(path, stamp, stamp);
+  writeHomeText(path, text, MEMORY_MODE, stampOf(modifiedAt) ?? undefined);
   const stat = statSync(path);
   return { name, bytes: stat.size, modifiedAt: stat.mtime.toISOString() };
 }
@@ -371,7 +369,7 @@ export function writeMemoryFile(project: string, name: string, text: string, dir
 export function deleteMemoryFile(project: string, name: string, dir = claudeDir()): string {
   const path = memoryPath(project, name, dir);
   if (!existsSync(path)) throw new ApiError('no such memory file', 404);
-  rmSync(path);
+  removeHome(path);
   return name;
 }