@volter/supercode-orchestrator 0.5.51 → 0.5.53

package/bin/runtime.mjs

@@ -70,7 +70,7 @@ import {
   TICK_MS, accessPolicy, applyOperator, performRemoveProfileDir, OPERATOR_OPS,
 } from '../index.mjs';
 import * as events from '../events.mjs';
-import { appView, installAgent, installApp, installedApps, removeApp } from '../installed-apps.mjs';
+import { appView, installAgent, installApp, installedAgentRecord, installedApps, removeApp, rh2AgentEnv, rh2Program } from '../installed-apps.mjs';
 import { httpJobExecutor } from '../hosted.mjs';
 import { SupercodeHarnessClient } from '@volter/supercode-harness-sdk';
 
@@ -460,6 +460,30 @@ const ACCESS_OPS = {
  * `apps remove NAME`. */
 async function appsMain(argv) {
   const [verb, ...rest] = argv;
+  // `apps mcp rh2-agent --profile <agent> [--root R]`: `rh2 mcp` as the installed agent, its credential in that one
+  // process's environment (rh2AgentEnv) and nowhere else: no config file carries the token, and the command is fixed,
+  // so nothing can be run in its place to print the token. It is how an agent's session mounts RH2 (mcp/mount.mjs).
+  if (verb === 'mcp') {
+    const opts = {};
+    const words = [];
+    for (let i = 0; i < rest.length; i += 1) {
+      if (rest[i].startsWith('--')) { opts[rest[i].slice(2)] = rest[i + 1]; i += 1; } else words.push(rest[i]);
+    }
+    if (words[0] !== 'rh2-agent' || words.length !== 1 || !opts.profile) {
+      process.stderr.write('apps mcp rh2-agent --profile <agent> [--root R]\n');
+      process.exit(2);
+    }
+    const record = installedAgentRecord(resolve(opts.root ?? defaultRoot()), opts.profile);
+    if (!record) {
+      process.stderr.write(`no rh2-agent is installed for ${opts.profile}: install it with apps install rh2-agent --profile ${opts.profile}\n`);
+      process.exit(1);
+    }
+    const child = spawn(rh2Program(), ['mcp'], { stdio: 'inherit', env: { ...process.env, ...rh2AgentEnv(record) } });
+    for (const signal of ['SIGTERM', 'SIGINT', 'SIGHUP']) process.on(signal, () => child.kill(signal));
+    child.on('error', (error) => { process.stderr.write(`apps mcp: ${error.message}\n`); process.exit(127); });
+    child.on('exit', (code, signal) => process.exit(code ?? (signal ? 1 : 0)));
+    return;
+  }
   const flags = {}, positional = [];
   for (let i = 0; i < rest.length; i += 1) {
     if (rest[i].startsWith('--')) { flags[rest[i].slice(2)] = rest[i + 1]; i += 1; } else positional.push(rest[i]);

package/index.d.ts

@@ -433,6 +433,8 @@ export function mountOrchestratorMcp(o: {
   root: Path; profile: Profile; harness: string; surfaceKey?: string | null;
   launch?: { program: string; arguments?: string[]; env?: Record<string, string> };
   socketPath?: Path; serverPath?: Path; program?: string;
+  /** The agent the session is; its installed rh2-agent is mounted beside the orchestrator server as `rh2-agent`. */
+  agent?: string | null;
 }): { door: McpDoor; ran: string; launch: unknown; mcp_servers: McpServerLaunch[] | null; path: Path | null };
 
 export function socketPathFor(root: Path): Path;

package/installed-apps.mjs

@@ -4,7 +4,8 @@
 // `apps/` folder (owner-only); no `platforms:` block attaches an integration. Uninstalling on the other side revokes the
 // token, and the channel stops; `remove` forgets the record here.
 import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { delimiter, join } from 'node:path';
+import { homedir } from 'node:os';
 
 export const APPS_DIR = 'apps';
 /** The apps this orchestrator can host, by name: what each installs and which adapter it attaches. */
@@ -31,7 +32,7 @@ export function installedApps(root) {
 export async function installAgent({ root, origin, organization, principal, token, profile, fetchImpl = globalThis.fetch }) {
   if (!profile) throw new Error('an RH2 agent is installed for a profile (--profile <agent>)');
   if (!/^prn_/.test(String(principal))) throw new Error('--principal is the RH2 agent\'s principal id (prn_…)');
-  if (!/^https:\/\/|^http:\/\/(localhost|127\.0\.0\.1)(:|\/|$)/.test(String(origin))) throw new Error('the RH2 origin is an https URL');
+  if (!rh2Origin(origin)) throw new Error('the RH2 origin is an https URL');
   const base = new URL(origin).origin;
   const response = await fetchImpl(`${base}/api/v3/rooms`, { headers: { authorization: `Bearer ${token}`, 'x-rh2-organization': organization, origin: base, accept: 'application/json' } });
   if (!response.ok) throw new Error(`RH2 refused the agent's token in ${organization}: HTTP ${response.status}`);
@@ -44,11 +45,42 @@ export async function installAgent({ root, origin, organization, principal, toke
   return { ...record, name: `rh2-agent.${profile}`, token: undefined };
 }
 
+/** The rh2-agent record installed for `agent` (an agent name, as `apps install rh2-agent --profile <agent>` names it),
+ * or null. */
+export function installedAgentRecord(root, agent) {
+  if (typeof agent !== 'string' || !/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(agent)) return null;
+  const path = recordPath(root, 'rh2-agent', agent);
+  if (!existsSync(path)) return null;
+  try {
+    const record = JSON.parse(readFileSync(path, 'utf8'));
+    // the origin install accepted (https, or a loopback for a local RH2), held again wherever the record is used
+    return record?.app === 'rh2-agent' && record.token && rh2Origin(record.origin) ? record : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Whether `origin` is one an RH2 app may be installed for: https, or a loopback for a local RH2. */
+function rh2Origin(origin) {
+  return /^https:\/\/|^http:\/\/(localhost|127\.0\.0\.1)(:|\/|$)/.test(String(origin ?? ''));
+}
+
+/** The `rh2` CLI: on this process's PATH, else where RH2's installer puts it (`~/.local/bin`), else the bare name. */
+export function rh2Program() {
+  const folders = [...String(process.env.PATH ?? '').split(delimiter), join(homedir(), '.local', 'bin')].filter(Boolean);
+  return folders.map((folder) => join(folder, 'rh2')).find((file) => existsSync(file)) ?? 'rh2';
+}
+
+/** The environment the `rh2` CLI reads to act as an installed agent: its RH2 origin, its organization and its token. */
+export function rh2AgentEnv(record) {
+  return { RH2_BASE_URL: record.origin, RH2_ORGANIZATION: record.organizationId, RH2_SESSION_TOKEN: record.token };
+}
+
 /** Exchange an RH2 install code for the installation's token and keep the record. */
 export async function installApp({ root, name, origin, clientId, clientSecret, code, profile = 'default', fetchImpl = globalThis.fetch }) {
   const app = INSTALLABLE_APPS[name];
   if (!app) throw new Error(`no installable app named ${name} (${Object.keys(INSTALLABLE_APPS).join(', ')})`);
-  if (!/^https:\/\/|^http:\/\/(localhost|127\.0\.0\.1)(:|\/|$)/.test(String(origin))) throw new Error('the RH2 origin is an https URL');
+  if (!rh2Origin(origin)) throw new Error('the RH2 origin is an https URL');
   const base = new URL(origin).origin;
   const response = await fetchImpl(`${base}/api/v3/automation/apps/oauth/access`, { method: 'POST', redirect: 'manual', headers: { 'content-type': 'application/json', accept: 'application/json' }, body: JSON.stringify({ clientId, clientSecret, code }) });
   const payload = await response.json().catch(() => ({}));

package/loop.mjs

@@ -453,6 +453,8 @@ export class Orchestrator {
     const mount = mountOrchestratorMcp({
       root: this.state.root, profile, harness: worker.harness, surfaceKey: keyString, launch,
       socketPath: this.bridge?.path ?? socketPathFor(this.state.root), vault: this.vault,
+      // the agent's own sessions speak in RH2 as it; a worker launched to act for it (agent_as) does not
+      agent: agent_as ? null : agent?.identity?.name ?? null,
     });
     this.log('info', `mcp mount (${worker.harness}, ${mount.door}): ${mount.ran}`);
     if (resume_runtime_id) resume_runtime_id = await this.continueFromHermes(profile, keyString, worker, resume_runtime_id, cwd,agentHome);

package/mcp/mount.mjs

@@ -23,11 +23,24 @@ import { SERVER_NAME } from './tools.mjs';
 import { SOCKET_ENV, socketPathFor } from './server.mjs';
 import { mcpServers } from '../hermes-home.mjs';
 import { KANBAN_ENV } from '../hermes-cli.mjs';
+import { installedAgentRecord } from '../installed-apps.mjs';
 
 export { MCP_DOORS, doorFor } from '@volter/supercode-harness-sdk/mcp-doors';
 
 /** The stdio server this module mounts. */
 export const SERVER_PATH = resolve(dirname(fileURLToPath(import.meta.url)), 'server.mjs');
+/** The orchestrator's CLI, whose `apps mcp` runs `rh2 mcp` as an installed agent. */
+const ORCHESTRATOR_BIN = resolve(dirname(fileURLToPath(import.meta.url)), '../bin/orchestrator.mjs');
+/** The MCP server an agent with an installed rh2-agent gets: `rh2 mcp` as that agent (its own name, so the user's own
+ * `rh2` server, whatever it holds, is neither replaced nor relied on). */
+export const RH2_AGENT_SERVER = 'rh2-agent';
+
+/** `rh2 mcp` run as `agent`'s installed RH2 principal: `apps mcp` puts the record's origin, organization and token in
+ * its environment, so no config file carries the token. Null when no rh2-agent is installed for it. */
+function rh2AgentServer(root, agent, program) {
+  if (!installedAgentRecord(root, agent)) return null;
+  return { command: program, args: [ORCHESTRATOR_BIN, 'apps', 'mcp', 'rh2-agent', '--root', root, '--profile', agent] };
+}
 
 const slug = (surfaceKey) => (surfaceKey ? String(surfaceKey).replace(/[^A-Za-z0-9_-]+/g, '-').replace(/^-+|-+$/g, '') || 'session' : 'session');
 
@@ -43,13 +56,19 @@ const slug = (surfaceKey) => (surfaceKey ? String(surfaceKey).replace(/[^A-Za-z0
  * @param {string} [o.socketPath]   defaults to `<root>/orchestrator.sock`
  * @param {string} [o.serverPath]   defaults to this package's `mcp/server.mjs`
  * @param {string} [o.program]      the interpreter, defaults to this node
+ * @param {string|null} [o.agent]   the agent whose own session this is (its name), whose installed rh2-agent is mounted
+ *                                  beside; null for a worker acting for an agent
  * @returns {{door: string, ran: string, launch: object|undefined, mcp_servers: object[]|null, path: string|null}}
  */
-export function mountOrchestratorMcp({ root, profile, harness, surfaceKey = null, launch, socketPath, serverPath = SERVER_PATH, program = process.execPath, vault = new Map(), task = null }) {
+export function mountOrchestratorMcp({ root, profile, harness, surfaceKey = null, launch, socketPath, serverPath = SERVER_PATH, program = process.execPath, vault = new Map(), task = null, agent = null }) {
   const door = doorFor(harness);
   // the profile's own servers (`.mcp.json`, the workers' form; docs/plans/hermes-compat.md row 4), mounted
   // beside this one through the same door, `${VAR}` resolved from the profile's vault
   const own = resolveServers(mcpServers(profile.dir), vault);
+  // an agent the RH2 organization declares acts there as its own principal, through its installed record (ADR 0017),
+  // not through whatever `rh2` the machine's user configured; a profile's own `rh2-agent` entry wins
+  const rh2 = own[RH2_AGENT_SERVER] ? null : rh2AgentServer(root, agent, program);
+  if (rh2) own[RH2_AGENT_SERVER] = rh2;
   const sock = socketPath ?? socketPathFor(root);
   const home = join(profile.dir, harness);
   const env = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-orchestrator",
-  "version": "0.5.51",
+  "version": "0.5.53",
   "type": "module",
   "description": "The orchestrator runtime over the Volter Harness ontology: one typed operational model whose folder is its serialization, read and written through the harness orchestration doors (docs/ORCHESTRATOR-IR.md)",
   "exports": {