@stage-labs/metro 0.1.0-beta.227 → 0.1.0-beta.229

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.227",
+  "version": "0.1.0-beta.229",
   "description": "The metro command line: run your agent on this machine, relaying its chat channels and connectors to Claude Code.",
   "license": "MIT",
   "repository": {

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

@@ -1,6 +1,6 @@
 {
   "name": "metro",
-  "version": "0.1.0-beta.227",
+  "version": "0.1.0-beta.229",
   "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/marketplace/plugin/{orchestrator.md → METRO.md}

@@ -1,11 +1,11 @@
 ---
-name: metro-orchestrator
+name: metro
 description: How this box's agent works on metro. Acknowledge, delegate, relay, answer over chat, never block on the terminal. Loaded at every session start by the metro plugin; edit it here to change the rules on this box.
 ---
 
 You are the main thread of a Claude Code session that is connected to chat through metro, on a machine nobody watches. The main thread is an orchestrator: it may only delegate and talk. A guard in the metro plugin denies every other tool on this thread, so this is the shape of the work, not a preference.
 
-**Inbound.** A message arrives as a `<channel source="metro" …>` block. Read `addressed` first: `direct`, `mention` or `reply` means it is for you; without it the message merely happened in a room you watch, so treat it as context and stay silent unless the person plainly wants you. For a message that is for you, the first tool call is `react` on it (👀, then 👍 or ✅ once done) so the person knows you saw it, and any reply goes on the same `line`, passed verbatim.
+**Inbound.** A message arrives as a `<channel source="metro" …>` block. Read `addressed` first: `direct`, `mention` or `reply` means it is for you; without it the message merely happened in a room you watch, so treat it as context and stay silent unless the person plainly wants you. For a message that is for you, the first tool call is `react` on it (👀, then 👍 or ✅ once done) so the person knows you saw it, and any reply goes on the same `line`, passed verbatim. Exception: when the person asks you to close something ("mark as done"), skip the reaction and the acknowledgement: close it directly and confirm once when it is finished.
 
 **Typing.** Whenever you are about to send a message on a line within the next 10 seconds, call `typing` on that `line` first, so the person sees "typing…" while you write. It shows once and fades by itself (about 5 s on the Telegram bot, 10 s on Discord, 25 s on WhatsApp) or when your message arrives, so there is nothing to stop. Only WhatsApp, the Telegram bot and Discord support it; on other channels skip it.
 

package/runtime/marketplace/plugin/STAGE.md

@@ -0,0 +1,32 @@
+---
+name: stage
+description: How to use Stage channels (XMTP groups, https://stage.box) through metro. Create a channel, rename it, add or remove members, set labels and assignees, read its info, and send, reply, react, unreact, delete and read messages. Works only when this agent has an XMTP account in metro.
+---
+
+Stage (https://stage.box) is a messenger built on XMTP. A Stage channel is an XMTP group. You use it with the metro tools below (`mcp__metro__<name>`).
+
+**XMTP only.** All of this needs an XMTP account connected to this agent in metro. Check with `list_accounts`: it must show an account under `xmtp`. Many agents have none. Then none of this works: say so plainly and do not try another channel. The owner can add an XMTP channel on https://metro.box.
+
+**Lines and links.** A channel's line is `metro://xmtp/<account>/<channel id>`. Pass it verbatim as `line`. Its link is `https://stage.box/#/channel/<channel id>`, the last part of the line. Stage shows Markdown, so `[#Launch plan](https://stage.box/#/channel/<channel id>)` is a clickable link. A `message_id` comes from the inbound message or from `read`.
+
+**Channels.**
+- Create: `create_group {"station": "xmtp", "name": "Launch plan", "members": ["0x…"]}`. Members are 0x addresses or XMTP inbox ids. It returns the new `line` and `id`.
+- Rename: `set_channel_metadata {"line": "…", "name": "New title"}`. No tool sets the description or the picture.
+- Add or remove people: `add_members {"line": "…", "members": ["0x…"]}`. `remove_members` takes the same shape.
+- Leave: `close_channel {"line": "…", "removeSelf": true}`.
+- Read: `group_info {"line": "…"}` gives the name, `labels`, `assigned`, `appData` and the members (`inboxId`, `address`). `list_members {"line": "…"}` gives the members only.
+- Direct chat: `dm {"address": "0x…"}` opens a 1:1 chat and returns its line.
+- With several XMTP accounts, add `"account": "<id>"` to `create_group` and `dm`.
+
+**Labels and assignees.** They live in the channel's metadata, and Stage shows them on the channel.
+- Labels: `set_channel_metadata {"line": "…", "metadata": {"labels": ["🚧 In progress", "Metro"]}}`. At most 16 labels of 24 characters each.
+- Assignees: `set_channel_metadata {"line": "…", "metadata": {"assigned": ["0x…"]}}`. Only 0x addresses of current members.
+- Each key you send replaces that whole list. Keys you leave out stay as they are. To add one label or one assignee, read `group_info` first and send the old list plus the new one. `[]` clears a list. Read `group_info` again to check it saved.
+
+**Messages.**
+- Send: `send {"line": "…", "text": "Hello"}`. Reply with a quote: `reply {"line": "…", "message_id": "…", "text": "…"}`.
+- React: `react {"line": "…", "message_id": "…", "emoji": "👍"}`. `unreact` takes the same shape.
+- Delete one of your own messages: `delete {"line": "…", "message_id": "…"}`. XMTP has no edit and no typing.
+- History: `read {"line": "…", "limit": 20}`.
+- Poll: `ask {"line": "…", "question": "Ship today?", "options": ["Yes", "No"]}`.
+- File: `create_upload {"name": "report.pdf"}`, run the `curl` line it returns in a shell, then `send {"line": "…", "attachments": [{"upload": "<upload_id>"}]}`. Files that are not images are refused over about 190 KiB.

package/runtime/marketplace/plugin/bin/session-start.mjs

@@ -6,8 +6,8 @@ import { fileURLToPath } from 'node:url';
 
 const given = (value) => (typeof value === 'string' && value.trim() !== '' ? value.trim() : undefined);
 const claudeDir = given(process.env.CLAUDE_CONFIG_DIR) ?? join(given(process.env.HOME) ?? homedir(), '.claude');
-const SKILL = join(claudeDir, 'skills', 'metro-orchestrator', 'SKILL.md');
-const FALLBACK = join(dirname(dirname(fileURLToPath(import.meta.url))), 'orchestrator.md');
+const SKILL = join(claudeDir, 'skills', 'metro', 'SKILL.md');
+const FALLBACK = join(dirname(dirname(fileURLToPath(import.meta.url))), 'METRO.md');
 
 const body = (text) => text.replace(/^---[\s\S]*?\n---\n/, '').trim();
 
@@ -27,5 +27,5 @@ function guidance() {
 const text = guidance();
 if (text !== '')
   process.stdout.write(
-    `${JSON.stringify({ hookSpecificOutput: { hookEventName: 'SessionStart', additionalContext: `This machine runs as a metro agent. Standing rules, kept in the metro-orchestrator skill:\n\n${text}` } })}\n`,
+    `${JSON.stringify({ hookSpecificOutput: { hookEventName: 'SessionStart', additionalContext: `This machine runs as a metro agent. Standing rules, kept in the metro skill:\n\n${text}` } })}\n`,
   );

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

@@ -7,7 +7,7 @@ import { errMsg, log } from '@metro-labs/core/log';
 import { isRecord } from '@metro-labs/core/is-record';
 import { readJson, writeAtomic, writeJson } from '@metro-labs/core/secure-fs';
 import { agentsDir } from '../agents/files.js';
-import { writeHomeText } from '../agent-user/home-fs.js';
+import { moveHome, removeHome, writeHomeText } from '../agent-user/home-fs.js';
 import { claudeDir } from './files.js';
 import { stagedMarketplaceDir } from './plugin-install.js';
 import { readModelConfig, routedConnection, type ModelConfig } from '../gateway/model-config.js';
@@ -19,9 +19,11 @@ export const PRIVACY_ENV: Record<string, string> = {
   CLAUDE_CODE_GB_DISK_CACHE_WHEN_TELEMETRY_OFF: '1',
 };
 export const RETENTION_DAYS = 7;
-const SKILL_NAME = 'metro-orchestrator';
 const STATE_FILE = 'claude-setup.json';
-const GUIDANCE = 'orchestrator.md';
+const RULES_FILE = 'METRO.md';
+const RULES_SKILL = 'metro';
+const RENAMED_SKILL = 'metro-orchestrator';
+const RENAMED_NAME = /^name:[ \t]*(["']?)metro-orchestrator\1[ \t]*$/m;
 const SYSTEM_PROMPT_FILE = 'system-prompt.md';
 export const SYSTEM_PROMPT_MAX = 64 * 1024;
 
@@ -45,7 +47,7 @@ Your final message is a report to the orchestrator, not a message to a human. It
 export interface SetupDeps {
   dir?: string;
   agents?: string;
-  guidance?: string;
+  plugin?: string;
   env?: NodeJS.ProcessEnv;
 }
 
@@ -57,6 +59,7 @@ export interface SetupReport {
   guard: 'plugin';
   worker: Placed;
   skill: Placed;
+  stage: Placed;
   settings: SettingsOutcome;
 }
 
@@ -68,6 +71,7 @@ export interface SetupStatus {
   guard: 'plugin';
   worker: boolean;
   skill: boolean;
+  stage: boolean;
   privacyApplied: boolean;
   retentionDays: number | null;
 }
@@ -127,22 +131,34 @@ export function setSystemPrompt(text: string, agents = agentsDir()): void {
   writeAtomic(promptPath(agents), `${trimmed}\n`, 0o600);
 }
 
-function guidancePath(env: NodeJS.ProcessEnv = process.env): string {
+function pluginDir(env: NodeJS.ProcessEnv = process.env): string {
   const staged = stagedMarketplaceDir(env);
   if (staged !== null) {
-    const path = join(staged, 'plugin', GUIDANCE);
-    if (existsSync(path)) return path;
+    const dir = join(staged, 'plugin');
+    if (existsSync(join(dir, RULES_FILE))) return dir;
   }
-  return fileURLToPath(new URL(`../../../../plugin/${GUIDANCE}`, import.meta.url));
+  return fileURLToPath(new URL('../../../../plugin', import.meta.url));
 }
 
 const PRIOR_WORKER: ReadonlySet<string> = new Set(['08a0cd8710df285d6512245246bb8b658b7cfc7f3e89490514ee5376779eb2ef']);
-const PRIOR_SKILL: ReadonlySet<string> = new Set([
+const PRIOR_METRO: ReadonlySet<string> = new Set([
   '0b3d122ed95beff09d579cf912cd4238e1db524c41fce4b314de57d6ff5908ad',
   '36f4fb57f231a119d717b5e3d6ccb654f94960fcca708683f376679aead8df25',
   '3840bc50253e51f431691376cf29a925b8245d87b77b8b20804a159e378a6e67',
   'e6b59eba825b4568dfa9ace5049fd9568a2e10d731719976ad2657084fd4e5f9',
+  '5ce3f76d610aae91adc922d0edc6c8be1f27aa2fec4a5e3a6d6231a04fb9310b',
+  'b910597d24f31fa479b130a2545f94dd23684d802d99e36b637fc57c818a33be',
 ]);
+const PRIOR_STAGE: ReadonlySet<string> = new Set();
+
+interface ShippedSkill {
+  name: string;
+  file: string;
+  prior: ReadonlySet<string>;
+}
+
+const METRO_SKILL: ShippedSkill = { name: RULES_SKILL, file: RULES_FILE, prior: PRIOR_METRO };
+const STAGE_SKILL: ShippedSkill = { name: 'stage', file: 'STAGE.md', prior: PRIOR_STAGE };
 
 const digest = (text: string): string => createHash('sha256').update(text).digest('hex');
 
@@ -190,12 +206,39 @@ function applyPrivacy(dir: string, enabled: boolean): SettingsOutcome {
   return mergeSettings(dir, (current) => withPrivacy(current, enabled));
 }
 
-const skillPath = (dir: string): string => join(dir, 'skills', SKILL_NAME, 'SKILL.md');
+const skillPath = (dir: string, name: string): string => join(dir, 'skills', name, 'SKILL.md');
 const workerPath = (dir: string): string => join(dir, 'agents', 'worker.md');
 
-function placeSkill(dir: string, guidance: string): Placed {
-  if (!existsSync(guidance)) return 'missing';
-  return placeFile(skillPath(dir), readFileSync(guidance, 'utf8'), PRIOR_SKILL);
+function placeSkill(dir: string, plugin: string, skill: ShippedSkill): Placed {
+  const source = join(plugin, skill.file);
+  if (!existsSync(source)) return 'missing';
+  return placeFile(skillPath(dir, skill.name), readFileSync(source, 'utf8'), skill.prior);
+}
+
+function moveRenamedSkill(dir: string): void {
+  const from = join(dir, 'skills', RENAMED_SKILL);
+  const old = skillPath(dir, RENAMED_SKILL);
+  if (!existsSync(old)) return;
+  const shipped = PRIOR_METRO.has(digest(readFileSync(old, 'utf8')));
+  if (existsSync(join(dir, 'skills', RULES_SKILL))) {
+    if (shipped) removeHome(from, true);
+    return;
+  }
+  moveHome(from, join(dir, 'skills', RULES_SKILL));
+  log.info({ from, shipped }, 'claude-setup: moved the metro-orchestrator skill to metro');
+  if (shipped) return;
+  const path = skillPath(dir, RULES_SKILL);
+  const text = readFileSync(path, 'utf8');
+  const renamed = text.replace(RENAMED_NAME, `name: ${RULES_SKILL}`);
+  if (renamed !== text) writeHomeText(path, renamed, statSync(path).mode & 0o777);
+}
+
+function tryMoveRenamedSkill(dir: string): void {
+  try {
+    moveRenamedSkill(dir);
+  } catch (err) {
+    log.warn({ err: errMsg(err) }, 'claude-setup: could not move the metro-orchestrator skill to metro');
+  }
 }
 
 const written = (placed: Placed): boolean => placed === 'written' || placed === 'updated';
@@ -204,15 +247,18 @@ export function ensureClaudeSetup(deps: SetupDeps = {}): SetupReport {
   const dir = deps.dir ?? claudeDir();
   const agents = deps.agents ?? agentsDir();
   const privacy = privacyEnabled(agents);
+  const plugin = deps.plugin ?? pluginDir(deps.env);
+  tryMoveRenamedSkill(dir);
   const report: SetupReport = {
     privacy,
     guard: 'plugin',
     worker: placeFile(workerPath(dir), WORKER_AGENT, PRIOR_WORKER),
-    skill: placeSkill(dir, deps.guidance ?? guidancePath(deps.env)),
+    skill: placeSkill(dir, plugin, METRO_SKILL),
+    stage: placeSkill(dir, plugin, STAGE_SKILL),
     settings: applyPrivacy(dir, privacy),
   };
   syncAvailableModelsQuietly({ ...deps, dir, agents });
-  if (written(report.worker) || written(report.skill) || report.settings === 'written')
+  if (written(report.worker) || written(report.skill) || written(report.stage) || report.settings === 'written')
     log.info(report, 'claude-setup: applied the Claude Code setup for a metro box');
   if (report.settings === 'unreadable') log.warn({ path: join(dir, 'settings.json') }, 'claude-setup: settings.json is not valid JSON, so the privacy settings were not written');
   return report;
@@ -231,7 +277,8 @@ export function claudeSetupStatus(deps: SetupDeps = {}): SetupStatus {
     liveEvents: liveEvents(agents),
     guard: 'plugin',
     worker: existsSync(workerPath(dir)),
-    skill: existsSync(skillPath(dir)),
+    skill: existsSync(skillPath(dir, METRO_SKILL.name)),
+    stage: existsSync(skillPath(dir, STAGE_SKILL.name)),
     privacyApplied: Object.keys(PRIVACY_ENV).every((key) => env[key] === '1'),
     retentionDays: typeof days === 'number' ? days : null,
   };

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

@@ -1,6 +1,6 @@
 import { createHash } from 'node:crypto';
 import { isRecord } from '@metro-labs/core/is-record';
-import { resultText } from './text.js';
+import { inlineImage, partText, resultImages, resultParts, resultText, TOOL_ERROR, type InlineImage } from './text.js';
 import { stringOf } from '@metro-labs/http/api-http';
 
 const SIGNATURE_PREFIX = 'metro-codex:';
@@ -82,11 +82,25 @@ export function decodeSignature(signature: unknown): Item | null {
   }
 }
 
+const imagePart = (image: InlineImage): Item => ({ type: 'input_image', image_url: `data:${image.mediaType};base64,${image.data}` });
+
 function userPart(block: Item): Item | null {
   if (block.type === 'text') return { type: 'input_text', text: stringOf(block.text) };
-  if (block.type === 'image' && isRecord(block.source) && block.source.type === 'base64')
-    return { type: 'input_image', image_url: `data:${stringOf(block.source.media_type)};base64,${stringOf(block.source.data)}` };
-  return null;
+  const image = inlineImage(block);
+  return image === null ? null : imagePart(image);
+}
+
+function outputPart(part: Item): Item | null {
+  const image = inlineImage(part);
+  if (image !== null) return imagePart(image);
+  const text = partText(part);
+  return text === '' ? null : { type: 'input_text', text };
+}
+
+function toolOutput(block: Item): string | Item[] {
+  if (resultImages(block).length === 0) return resultText(block);
+  const parts = resultParts(block).map(outputPart).filter((part): part is Item => part !== null);
+  return block.is_error === true ? [{ type: 'input_text', text: TOOL_ERROR }, ...parts] : parts;
 }
 
 function userItems(content: unknown): Item[] {
@@ -101,7 +115,7 @@ function userItems(content: unknown): Item[] {
   for (const block of content.filter(isRecord)) {
     if (block.type === 'tool_result') {
       flush();
-      out.push({ type: 'function_call_output', call_id: stringOf(block.tool_use_id), output: resultText(block) });
+      out.push({ type: 'function_call_output', call_id: stringOf(block.tool_use_id), output: toolOutput(block) });
       continue;
     }
     const part = userPart(block);

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

@@ -3,7 +3,7 @@ import { isRecord } from '@metro-labs/core/is-record';
 import { ToolNames } from './codex-translate.js';
 import { CLIENT_NAME, requestId, SYSTEM_PREFIX } from './gemini-client.js';
 import { cappedEffort, effortToApply } from './effort.js';
-import { resultText } from './text.js';
+import { inlineImage, resultImages, resultText, type InlineImage } from './text.js';
 import { stringOf } from '@metro-labs/http/api-http';
 
 type Item = Record<string, unknown>;
@@ -63,11 +63,22 @@ export function systemText(system: unknown): string {
     .trim();
 }
 
+const imagePart = (image: InlineImage): Item => ({ inlineData: { mimeType: image.mediaType, data: image.data } });
+
+const GEMINI_IMAGES = new Set(['image/png', 'image/jpeg', 'image/webp', 'image/heic', 'image/heif']);
+const geminiSees = (mediaType: string): boolean => GEMINI_IMAGES.has(mediaType);
+
+function toolParts(block: Item, id: string, name: string): Item[] {
+  const images = resultImages(block, geminiSees);
+  const text = resultText(block, geminiSees);
+  const result = text === '' && images.length > 0 ? `Binary content provided (${String(images.length)} item(s)).` : text;
+  return [{ functionResponse: { id, name, response: { result } } }, ...images.map(imagePart)];
+}
+
 function userPart(block: Item): Item | null {
   if (block.type === 'text') return { text: stringOf(block.text) };
-  if (block.type === 'image' && isRecord(block.source) && block.source.type === 'base64')
-    return { inlineData: { mimeType: stringOf(block.source.media_type), data: stringOf(block.source.data) } };
-  return null;
+  const image = inlineImage(block);
+  return image === null ? null : imagePart(image);
 }
 
 function userParts(content: unknown, calls: Map<string, string>): Item[] {
@@ -77,7 +88,7 @@ function userParts(content: unknown, calls: Map<string, string>): Item[] {
   for (const block of content.filter(isRecord)) {
     if (block.type === 'tool_result') {
       const id = stringOf(block.tool_use_id);
-      out.push({ functionResponse: { id, name: calls.get(id) ?? 'tool', response: { result: resultText(block) } } });
+      out.push(...toolParts(block, id, calls.get(id) ?? 'tool'));
       continue;
     }
     const part = userPart(block);

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

@@ -2,13 +2,34 @@ import { isRecord } from '@metro-labs/core/is-record';
 import { stringOf } from '@metro-labs/http/api-http';
 
 const IMAGE_NOTE = '[an image was attached here; this model cannot see it]';
+export const TOOL_ERROR = '[tool error]';
 
 export const nonEmpty = (value: unknown): string | null => (typeof value === 'string' && value !== '' ? value : null);
 
-const partText = (part: Record<string, unknown>): string => (part.type === 'text' ? stringOf(part.text) : part.type === 'image' ? IMAGE_NOTE : '');
+export interface InlineImage {
+  mediaType: string;
+  data: string;
+}
+
+type Part = Record<string, unknown>;
+type Accepts = (mediaType: string) => boolean;
+const anyImage: Accepts = () => true;
+
+export function inlineImage(block: Part, accepts = anyImage): InlineImage | null {
+  if (block.type !== 'image' || !isRecord(block.source) || block.source.type !== 'base64') return null;
+  const image = { mediaType: stringOf(block.source.media_type), data: stringOf(block.source.data) };
+  return image.mediaType !== '' && image.data !== '' && accepts(image.mediaType) ? image : null;
+}
 
-export function resultText(block: Record<string, unknown>): string {
+export const resultParts = (block: Part): Part[] => (Array.isArray(block.content) ? block.content.filter(isRecord) : []);
+
+export const partText = (part: Part, accepts = anyImage): string =>
+  part.type === 'text' ? stringOf(part.text) : part.type === 'image' && inlineImage(part, accepts) === null ? IMAGE_NOTE : '';
+
+export function resultText(block: Part, accepts = anyImage): string {
   const content = block.content;
-  const text = typeof content === 'string' ? content : Array.isArray(content) ? content.filter(isRecord).map(partText).filter((t) => t !== '').join('\n') : '';
-  return block.is_error === true ? `[tool error] ${text}` : text;
+  const text = typeof content === 'string' ? content : resultParts(block).map((part) => partText(part, accepts)).filter((t) => t !== '').join('\n');
+  return block.is_error === true ? `${TOOL_ERROR} ${text}` : text;
 }
+
+export const resultImages = (block: Part, accepts = anyImage): InlineImage[] => resultParts(block).flatMap((part) => inlineImage(part, accepts) ?? []);

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.227"
+  "version": "0.1.0-beta.229"
 }