@stage-labs/metro 0.1.0-beta.186 → 0.1.0-beta.187

package/package.json

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

@@ -2,13 +2,15 @@ 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 { bodyField, readJsonBody, requireAdmin, 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';
+import { listWorkspace, startMove } from './workspace.js';
 
 const PATH = '/api/agent-user';
+const WORKSPACE = '/api/agent-user/workspace';
 const EXIT_DELAY_MS = 500;
 
 export interface AgentUserApiDeps {
@@ -52,8 +54,21 @@ function setWanted(dir: string, enabled: boolean): void {
   forgetAgentUser();
 }
 
+async function workspaceAnswer(req: IncomingMessage, dir: string): Promise<unknown> {
+  const user = agentUser(dir);
+  if (user === null) throw new ApiError('switch Claude Code to its own user first', 409);
+  if (req.method === 'GET') return { user: user.name, home: user.home, entries: listWorkspace(user) };
+  const started = startMove(bodyField(await readJsonBody(req), 'names'), user);
+  return { started, entries: listWorkspace(user) };
+}
+
 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) => {
+  const methods = { [PATH]: ['GET', 'POST'], [WORKSPACE]: ['GET', 'POST'] };
+  return sessionRoute(req, res, { methods, admin: ['POST'], label: 'agent-user-api' }, async (session, path) => {
+    if (path === WORKSPACE) {
+      requireAdmin(session);
+      return workspaceAnswer(req, (deps.agents ?? agentsDir)());
+    }
     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);

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

@@ -1,12 +1,12 @@
 import { spawn, spawnSync } from 'node:child_process';
-import { existsSync, lstatSync, readFileSync } from 'node:fs';
+import { existsSync, lstatSync, readFileSync, rmSync, writeFileSync } 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 { agentMarketplaceDir, agentUser, asUser, claudeBin, forgetAgentUser, lookupUser, wantedAgentUser, type AgentUser } from './user.js';
 import { watchAgentView } from './view.js';
 
 const INSTALL_MS = 10 * 60_000;
@@ -50,6 +50,17 @@ function moveProject(user: AgentUser, from: string): void {
   if (existsSync(old) && absent(next)) run('mv', ['-T', old, next]);
 }
 
+const stamp = (now: Date): string => now.toISOString().replace(/[-:]/g, '').replace(/\..*$/, '').replace('T', '-');
+
+const kindIs = (path: string, want: 'dir' | 'file'): boolean => {
+  try {
+    const st = lstatSync(path);
+    return want === 'dir' ? st.isDirectory() : st.isFile();
+  } catch {
+    return false;
+  }
+};
+
 function migrateClaude(user: AgentUser, dir: string): void {
   const marker = join(dir, MIGRATED);
   if (existsSync(marker)) return;
@@ -58,13 +69,14 @@ function migrateClaude(user: AgentUser, dir: string): void {
   for (const name of ['.claude', '.claude.json']) {
     const from = join(home, name);
     const to = join(user.home, name);
-    if (!existsSync(from) || !absent(to)) continue;
+    if (!existsSync(from)) continue;
+    if (!absent(to)) run('mv', ['-T', to, `${to}.before-root-${stamp(new Date())}`]);
     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]);
+  writeFileSync(marker, `${user.name}\n`, { mode: 0o600 });
   log.info({ user: user.name, copied }, 'agent-user: moved the Claude Code folder and login to the agent user once; root keeps its copy');
 }
 
@@ -113,9 +125,54 @@ function stopRootSession(): void {
   log.info('agent-user: stopped the Claude session root was running; it comes back as the agent user');
 }
 
+function stopAgentSessions(user: AgentUser): void {
+  spawnSync(...asUser(user, 'tmux', ['kill-server']), { stdio: 'ignore' });
+}
+
+function takeBack(user: AgentUser, now: Date): string[] {
+  const home = homedir();
+  const taken: string[] = [];
+  for (const [name, kind] of [['.claude', 'dir'], ['.claude.json', 'file']] as const) {
+    const from = join(user.home, name);
+    if (!kindIs(from, kind)) continue;
+    const to = join(home, name);
+    if (!absent(to)) run('mv', ['-T', to, `${to}.before-agent-${stamp(now)}`]);
+    run('cp', ['-aT', from, to]);
+    run('chown', ['-hR', 'root:root', to]);
+    taken.push(name);
+  }
+  if (taken.includes('.claude')) {
+    const projects = join(home, '.claude', 'projects');
+    const old = join(projects, encodedCwd(user.home));
+    const next = join(projects, encodedCwd(home));
+    if (existsSync(old) && absent(next)) run('mv', ['-T', old, next]);
+  }
+  return taken;
+}
+
+export function returnToRoot(dir = agentsDir(), now = new Date()): string[] | null {
+  const marker = join(dir, MIGRATED);
+  if (process.platform !== 'linux' || process.getuid?.() !== 0 || !existsSync(marker)) return null;
+  const name = readFileSync(marker, 'utf8').trim() || 'agent';
+  const user = lookupUser(name);
+  if (user === null) return null;
+  stopAgentSessions(user);
+  const taken = takeBack(user, now);
+  rmSync(marker);
+  log.info({ user: user.name, taken }, 'agent-user: switched off; the agent\'s Claude folder and login are root\'s again, root\'s older copy is kept beside it');
+  return taken;
+}
+
 export async function provisionAgentUser(dir = agentsDir(), env: NodeJS.ProcessEnv = process.env): Promise<Provisioned> {
   const name = wantedAgentUser(dir);
-  if (name === null) return 'off';
+  if (name === null) {
+    try {
+      returnToRoot(dir);
+    } catch (err) {
+      log.error({ err: errMsg(err) }, 'agent-user: could not bring the Claude folder back to root; the agent user keeps it, nothing was deleted');
+    }
+    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';

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

@@ -21,7 +21,7 @@ export interface UserHost {
   lookup: (name: string) => AgentUser | null;
 }
 
-function lookupUser(name: string): AgentUser | null {
+export 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(':');

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

@@ -0,0 +1,124 @@
+import { spawn, spawnSync } from 'node:child_process';
+import { lstatSync, mkdtempSync, readdirSync, rmSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { ApiError } from '@metro-labs/http/api-error';
+import { errMsg, log } from '@metro-labs/core/log';
+import type { AgentUser } from './user.js';
+
+const SKIPPED = new Set(['snap', 'lost+found']);
+const SIZE_MS = 4_000;
+const NAMES_MAX = 100;
+
+export type EntryState = 'here' | 'copying' | 'moved' | 'failed';
+
+export interface WorkspaceEntry {
+  name: string;
+  kind: 'folder' | 'file' | 'link';
+  bytes: number | null;
+  state: EntryState;
+  error: string | null;
+}
+
+interface Job {
+  state: 'copying' | 'failed';
+  error: string | null;
+}
+
+const jobs = new Map<string, Job>();
+
+const offered = (name: string): boolean => !name.startsWith('.') && !SKIPPED.has(name) && !name.includes('/');
+
+function kindOf(path: string): WorkspaceEntry['kind'] | null {
+  try {
+    const stat = lstatSync(path);
+    if (stat.isSymbolicLink()) return 'link';
+    if (stat.isDirectory()) return 'folder';
+    return stat.isFile() ? 'file' : null;
+  } catch {
+    return null;
+  }
+}
+
+function sizeOf(path: string): number | null {
+  const run = spawnSync('du', ['-sk', path], { encoding: 'utf8', timeout: SIZE_MS, stdio: ['ignore', 'pipe', 'ignore'] });
+  const kb = Number(run.stdout.split('\t')[0]);
+  return run.status === 0 && Number.isFinite(kb) ? kb * 1024 : null;
+}
+
+const present = (path: string): boolean => kindOf(path) !== null;
+
+function stateOf(name: string, user: AgentUser): Pick<WorkspaceEntry, 'state' | 'error'> {
+  const job = jobs.get(name);
+  if (job !== undefined) return { state: job.state, error: job.error };
+  return { state: present(join(user.home, name)) ? 'moved' : 'here', error: null };
+}
+
+export function listWorkspace(user: AgentUser, from = homedir()): WorkspaceEntry[] {
+  return readdirSync(from)
+    .filter(offered)
+    .flatMap((name): WorkspaceEntry[] => {
+      const path = join(from, name);
+      const kind = kindOf(path);
+      if (kind === null) return [];
+      return [{ name, kind, bytes: kind === 'link' ? null : sizeOf(path), ...stateOf(name, user) }];
+    })
+    .sort((a, b) => a.name.localeCompare(b.name));
+}
+
+function run(file: string, args: string[]): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const child = spawn(file, args, { stdio: ['ignore', 'ignore', 'pipe'] });
+    let said = '';
+    child.stderr.on('data', (chunk: Buffer) => {
+      said = `${said}${chunk.toString('utf8')}`.slice(-1000);
+    });
+    child.on('error', reject);
+    child.on('close', (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`${file}: ${said.trim() || `exit ${String(code)}`}`));
+    });
+  });
+}
+
+async function moveOne(name: string, user: AgentUser, from: string): Promise<void> {
+  const staging = mkdtempSync(join(user.home, '..', '.metro-move-'));
+  try {
+    const staged = join(staging, name);
+    await run('cp', ['-a', '--', join(from, name), staged]);
+    await run('chown', ['-hR', `${String(user.uid)}:${String(user.gid)}`, staged]);
+    const target = join(user.home, name);
+    if (present(target)) throw new Error(`${target} already exists; move or remove it first`);
+    await run('mv', ['-T', '--', staged, target]);
+    jobs.delete(name);
+    log.info({ name, user: user.name }, 'agent-user: moved a folder from root\'s home to the agent user');
+  } finally {
+    rmSync(staging, { recursive: true, force: true });
+  }
+}
+
+function wantedNames(names: unknown): string[] {
+  if (!Array.isArray(names) || names.length === 0 || names.length > NAMES_MAX || !names.every((n) => typeof n === 'string'))
+    throw new ApiError('names must be a list of entries from the list', 400);
+  return [...new Set(names)];
+}
+
+function assertMovable(name: string, listed: ReadonlySet<string>, user: AgentUser): void {
+  if (!listed.has(name)) throw new ApiError(`${name} is not an entry metro offers to move`, 400);
+  if (jobs.get(name)?.state === 'copying') throw new ApiError(`${name} is already being moved`, 409);
+  if (present(join(user.home, name))) throw new ApiError(`${name} already exists in ${user.home}`, 409);
+}
+
+export function startMove(names: unknown, user: AgentUser, from = homedir()): string[] {
+  const wanted = wantedNames(names);
+  const listed = new Set(readdirSync(from).filter(offered));
+  for (const name of wanted) assertMovable(name, listed, user);
+  for (const name of wanted) {
+    jobs.set(name, { state: 'copying', error: null });
+    moveOne(name, user, from).catch((err: unknown) => {
+      jobs.set(name, { state: 'failed', error: errMsg(err) });
+      log.warn({ name, err: errMsg(err) }, 'agent-user: could not move a folder to the agent user');
+    });
+  }
+  return wanted;
+}

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.186"
+  "version": "0.1.0-beta.187"
 }