@ours.network/fleet 1.1.4 → 1.1.5

package/dist/harness/claude-code.js

@@ -1,3 +1,4 @@
+import { acpMcpServersFor, validateMcpServers } from './acp-mcp.js';
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { home } from '../paths.js';
@@ -12,8 +13,6 @@ const OPTION_KEYS = [
     'mcp_servers', 'mcp_servers_only',
 ];
 const EFFORT_LEVELS = ['low', 'medium', 'high', 'xhigh', 'max'];
-/** `.mcp.json` server types. Absent means stdio, as the file format has it. */
-const MCP_SERVER_TYPES = ['stdio', 'http', 'sse'];
 /** A role that names its own ACP command runs a process fleet did not choose. */
 const customAcpCommand = (role) => role.session === 'acp' && role.session_options?.acp?.command != null;
 /**
@@ -32,73 +31,6 @@ const customAcpCommand = (role) => role.session === 'acp' && role.session_option
  * `ours:` above the wrong command.
  */
 const declaresOursConnector = (servers) => Object.values(servers).some(s => [s.command ?? '', ...(s.args ?? [])].some(part => /(^|[/\\])ours-mcp($|\s)|@ours\.network[/\\]mcp/.test(part)));
-/** Shape-check `harness_options.mcp_servers` against `.mcp.json`'s own rules. */
-function validateMcpServers(servers) {
-    if (servers == null)
-        return [];
-    const at = (k = '') => ({ path: `harness_options.mcp_servers${k}` });
-    if (typeof servers !== 'object' || Array.isArray(servers))
-        return [{ ...at(), message: 'must be a map of server name to server definition' }];
-    const entries = Object.entries(servers);
-    if (!entries.length)
-        return [{ ...at(), message: 'must declare at least one server, or be omitted' }];
-    const errors = [];
-    for (const [name, raw] of entries) {
-        const p = `.${name}`;
-        if (!/^[A-Za-z0-9_-]+$/.test(name)) {
-            errors.push({ ...at(p), message: 'server name must be [A-Za-z0-9_-]' });
-            continue;
-        }
-        if (raw == null || typeof raw !== 'object' || Array.isArray(raw)) {
-            errors.push({ ...at(p), message: 'must be a map' });
-            continue;
-        }
-        const s = raw;
-        if (s.type != null && !MCP_SERVER_TYPES.includes(s.type))
-            errors.push({ ...at(`${p}.type`), message: `must be one of: ${MCP_SERVER_TYPES.join(', ')}` });
-        const remote = s.type === 'http' || s.type === 'sse';
-        if (remote) {
-            if (typeof s.url !== 'string' || !s.url.trim())
-                errors.push({ ...at(`${p}.url`), message: `must be a non-empty URL for a ${s.type} server` });
-            if (s.command != null)
-                errors.push({ ...at(`${p}.command`), message: `must not be set for a ${s.type} server` });
-        }
-        else {
-            if (typeof s.command !== 'string' || !s.command.trim())
-                errors.push({ ...at(`${p}.command`), message: 'must be a non-empty command for a stdio server' });
-            if (s.args != null && (!Array.isArray(s.args) || s.args.some(a => typeof a !== 'string')))
-                errors.push({ ...at(`${p}.args`), message: 'must be an array of strings' });
-            if (s.url != null)
-                errors.push({ ...at(`${p}.url`), message: 'must not be set for a stdio server' });
-        }
-        for (const key of ['env', 'headers']) {
-            const v = s[key];
-            if (v == null)
-                continue;
-            if (typeof v !== 'object' || Array.isArray(v)
-                || Object.values(v).some(x => typeof x !== 'string'))
-                errors.push({ ...at(`${p}.${key}`), message: 'must be a map of string to string' });
-        }
-    }
-    return errors;
-}
-/** `harness_options.mcp_servers` in ACP's `session/new` array shape. */
-function acpMcpServersFor(servers) {
-    if (!servers)
-        return undefined;
-    // `env` and `headers` are REQUIRED arrays in the protocol, so they are always
-    // sent — empty when the role declared none.
-    const pairs = (r) => Object.entries(r ?? {}).map(([name, value]) => ({ name, value }));
-    return Object.entries(servers).map(([name, s]) => {
-        if (s.type === 'http' || s.type === 'sse')
-            return { name, type: s.type, url: s.url, headers: pairs(s.headers) };
-        // Stdio carries NO `type` field: ACP's stdio variant is the one without it,
-        // and the bundled agent keys on exactly that (claude-agent-acp
-        // acp-agent.js:4058, `!("type" in server)`), so sending `type: 'stdio'`
-        // would drop the server on the floor.
-        return { name, command: s.command, args: s.args ?? [], env: pairs(s.env) };
-    });
-}
 /** Claude Code's accepted --permission-mode values. */
 const PERMISSION_MODES = ['default', 'acceptEdits', 'plan', 'dontAsk', 'bypassPermissions'];
 /**

package/dist/harness/hermes-compatibility.d.ts

@@ -0,0 +1,24 @@
+import { type Exec } from '../exec.js';
+export declare const TESTED_HERMES_ARTIFACT: {
+    readonly commit: "d15ed4445207dda418b984e8bda0f68f48b8c6f3";
+    readonly hermesVersion: "0.21.1";
+    readonly acpVersion: "0.9.0";
+    readonly protocolVersion: 1;
+};
+export interface HermesCompatibilityReport {
+    artifact: typeof TESTED_HERMES_ARTIFACT & {
+        sourceRoot: string;
+        executable: string;
+    };
+    /** Scoped prerequisite only: ACP connection/tool availability and other launch checks remain separate. */
+    pluginMcp: 'absent-in-validated-sources';
+}
+export interface HermesCompatibilityRequest {
+    argv: string[];
+    env: Record<string, string>;
+    home: string;
+}
+/** Check original, unwrapped argv. This does not certify an isolation wrapper or claim MCP tool readiness. */
+export declare function inspectHermesCompatibility(request: HermesCompatibilityRequest, exec?: Exec): Promise<HermesCompatibilityReport>;
+/** Native identity check, separate from session model/provider validation and first actual MCP use. */
+export declare function validateHermesInitialize(response: unknown): void;

package/dist/harness/hermes-compatibility.js

@@ -0,0 +1,191 @@
+import { accessSync, constants, lstatSync, readFileSync, readdirSync, realpathSync } from 'node:fs';
+import { basename, delimiter, dirname, isAbsolute, join, resolve } from 'node:path';
+import YAML from 'yaml';
+import { realExec } from '../exec.js';
+export const TESTED_HERMES_ARTIFACT = {
+    commit: 'd15ed4445207dda418b984e8bda0f68f48b8c6f3', hermesVersion: '0.21.1', acpVersion: '0.9.0', protocolVersion: 1,
+};
+const fail = (detail) => { throw new Error(`Hermes compatibility: ${detail}. Use the tested Hermes source/build and a supported hermes-acp launcher, or validate the new artifact before launch`); };
+const object = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+function stat(path) {
+    try {
+        return lstatSync(path);
+    }
+    catch (e) {
+        if (e.code === 'ENOENT')
+            return undefined;
+        return fail('cannot inspect a required artifact or plugin file');
+    }
+}
+function read(path) {
+    const info = stat(path);
+    if (!info)
+        return undefined;
+    if (!info.isFile() || info.isSymbolicLink())
+        return fail('artifact and plugin inputs must be regular non-symlink files');
+    try {
+        return new TextDecoder('utf-8', { fatal: true }).decode(readFileSync(path));
+    }
+    catch {
+        return fail('cannot read a required UTF-8 artifact or plugin file');
+    }
+}
+function document(path) {
+    const text = read(path);
+    if (text === undefined)
+        return {};
+    try {
+        const value = path.endsWith('.json') ? JSON.parse(text) : YAML.parse(text);
+        if (object(value))
+            return value;
+    }
+    catch { /* parser diagnostics may contain secrets */ }
+    return fail('invalid artifact or plugin configuration');
+}
+const CONSOLE_BODY = '# -*- coding: utf-8 -*-\nimport sys\nfrom acp_adapter.entry import main\nif __name__ == "__main__":\n    if sys.argv[0].endswith("-script.pyw"):\n        sys.argv[0] = sys.argv[0][:-11]\n    elif sys.argv[0].endswith(".exe"):\n        sys.argv[0] = sys.argv[0][:-4]\n    sys.exit(main())\n';
+function launcher(request) {
+    if (request.argv.length !== 1 || !request.argv[0])
+        return fail('only the original hermes-acp executable without shell commands or extra flags has been tested');
+    const command = request.argv[0];
+    const candidates = isAbsolute(command) ? [command] : command.includes('/') ? [resolve(command)] : (request.env.PATH ?? '').split(delimiter).filter(Boolean).map(path => join(path, command));
+    let executable;
+    for (const path of candidates) {
+        try {
+            accessSync(path, constants.X_OK);
+            executable = realpathSync(path);
+            break;
+        }
+        catch { /* next PATH entry */ }
+    }
+    if (!executable)
+        return fail('hermes-acp executable was not found');
+    const text = read(executable);
+    if (!text || text.length > 4096)
+        return fail('unrecognized hermes-acp launcher');
+    const sourceRoot = dirname(dirname(dirname(executable)));
+    const interpreter = join(sourceRoot, 'venv/bin/python3');
+    if (basename(executable) === 'hermes-acp' && text === `#!${interpreter}\n${CONSOLE_BODY}`)
+        return { executable, sourceRoot, interpreter };
+    const shim = /^#!\/usr\/bin\/env bash\nunset PYTHONPATH\nunset PYTHONHOME\nexec "([^"\n]+)\/venv\/bin\/python" "\1\/hermes" acp "\$@"\n$/.exec(text);
+    if (shim && isAbsolute(shim[1]))
+        return { executable, sourceRoot: shim[1], interpreter: join(shim[1], 'venv/bin/python') };
+    return fail('unrecognized hermes-acp launcher; a version string alone does not identify tested code');
+}
+// Standard-library metadata only. No Hermes config, dotenv, plugin module, or credential loader is imported.
+const METADATA_PROBE = `import importlib.metadata as m, importlib.util as u, json
+s=u.find_spec('acp_adapter')
+e=m.entry_points()
+e=e.select(group='hermes_agent.plugins') if hasattr(e,'select') else e.get('hermes_agent.plugins',[])
+print(json.dumps({'hermesVersion':m.version('hermes-agent'),'acpVersion':m.version('agent-client-protocol'),'adapterOrigin':s.origin if s else None,'entryPoints':[{'name':x.name,'value':x.value} for x in e]}))`;
+function collectPlugins(directory, source, skip = new Set(), prefix = '', depth = 0) {
+    const info = stat(directory);
+    if (!info)
+        return [];
+    if (!info.isDirectory() || info.isSymbolicLink())
+        return fail('plugin source must be a non-symlink directory');
+    const found = [];
+    for (const entry of readdirSync(directory, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+        if (depth === 0 && skip.has(entry.name))
+            continue;
+        if (entry.isSymbolicLink())
+            return fail('unverified symlink in plugin discovery');
+        if (!entry.isDirectory())
+            continue;
+        const path = join(directory, entry.name);
+        const filename = ['plugin.yaml', 'plugin.yml', 'plugin.json'].find(name => stat(join(path, name)));
+        if (!filename) {
+            if (depth === 0)
+                found.push(...collectPlugins(path, source, new Set(), entry.name, 1));
+            continue;
+        }
+        const data = document(join(path, filename));
+        const name = typeof data.name === 'string' && data.name ? data.name : entry.name;
+        found.push({ name, key: prefix ? `${prefix}/${entry.name}` : name, source, portable: filename === 'plugin.json', path });
+    }
+    return found;
+}
+function names(value, field) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value) || value.some(name => typeof name !== 'string'))
+        return fail(`plugins.${field} must contain literal names`);
+    if (value.some(name => /\$\{/.test(name)))
+        return fail(`plugins.${field} interpolation is unsupported; use literal names`);
+    return value;
+}
+function validatePluginSources(request, sourceRoot, metadata) {
+    for (const name of ['HERMES_BUNDLED_PLUGINS', 'HERMES_ENABLE_PROJECT_PLUGINS'])
+        if (request.env[name] !== undefined)
+            return fail('plugin discovery environment overrides are unsupported');
+    for (const filename of ['.env', '.op.env']) {
+        const content = read(join(request.home, filename));
+        if (content === undefined)
+            continue;
+        if (/[\0\u001c-\u001f\u0085]/.test(content))
+            return fail('unsupported plugin dotenv encoding');
+        for (const line of content.split(/\r\n?|\n/)) {
+            const match = /^\s*(?:export\s+)?(?:'([^']+)'|([^\s=#]+))\s*=/.exec(line);
+            if (match && ['HERMES_BUNDLED_PLUGINS', 'HERMES_ENABLE_PROJECT_PLUGINS'].includes(match[1] ?? match[2]))
+                return fail('plugin discovery redirection in selected-home dotenv is unsupported; remove it with the role stopped');
+        }
+    }
+    const config = document(join(request.home, 'config.yaml'));
+    if (config.plugins !== undefined && !object(config.plugins))
+        return fail('plugins configuration must be a map');
+    const plugins = object(config.plugins) ? config.plugins : {};
+    const enabled = names(plugins.enabled, 'enabled');
+    const disabled = names(plugins.disabled, 'disabled') ?? [];
+    const bundled = join(sourceRoot, 'plugins');
+    // Match native precedence: bundled, bundled/platforms, home, then entry points. Project plugins are refused above.
+    const all = [...collectPlugins(bundled, 'bundled', new Set(['memory', 'context_engine', 'platforms', 'model-providers'])), ...collectPlugins(join(bundled, 'platforms'), 'bundled'), ...collectPlugins(join(request.home, 'plugins'), 'home'), ...metadata.entryPoints.map(entry => ({ name: entry.name, key: entry.name, source: 'entrypoint', portable: false }))];
+    const winners = new Map(all.map(plugin => [plugin.key, plugin]));
+    for (const plugin of winners.values()) {
+        if ([plugin.key, plugin.name].some(name => disabled.includes(name)))
+            continue;
+        // Known bundled code includes native auto-loaded backends. It is part of the pinned clean source.
+        if (plugin.source !== 'bundled' && enabled && ![plugin.key, plugin.name].some(name => enabled.includes(name)))
+            continue;
+        if (!plugin.portable && plugin.source !== 'bundled')
+            return fail('enabled unreviewed home/entry-point plugin code cannot be verified MCP-free; disable that plugin or validate its artifact');
+        if (plugin.portable && plugin.path && stat(join(plugin.path, 'mcp.json'))) {
+            const mcp = document(join(plugin.path, 'mcp.json'));
+            if (!object(mcp.mcpServers) || Object.keys(mcp.mcpServers).length)
+                return fail('enabled plugin provides MCP; disable the plugin and declare extras through ACP mcpServers');
+        }
+    }
+}
+/** Check original, unwrapped argv. This does not certify an isolation wrapper or claim MCP tool readiness. */
+export async function inspectHermesCompatibility(request, exec = realExec) {
+    const chain = launcher(request);
+    // Use ordinary supervisor execution state, not role overrides, for inspection subprocesses.
+    const env = { PATH: process.env.PATH, HOME: request.env.HOME, HERMES_HOME: request.home };
+    const opts = { env, timeout: 10_000 };
+    const [head, status] = await Promise.all([
+        exec('git', ['-C', chain.sourceRoot, 'rev-parse', 'HEAD'], opts),
+        exec('git', ['-C', chain.sourceRoot, 'status', '--porcelain', '--untracked-files=all'], opts),
+    ]);
+    if (head.code || status.code || head.stdout.trim() !== TESTED_HERMES_ARTIFACT.commit || status.stdout.trim())
+        return fail('source checkout is not the tested clean Git artifact');
+    const result = await exec(chain.interpreter, ['-I', '-B', '-c', METADATA_PROBE], opts);
+    if (result.code)
+        return fail('could not inspect the tested Python package metadata');
+    let metadata;
+    try {
+        const value = JSON.parse(result.stdout);
+        if (!object(value) || typeof value.adapterOrigin !== 'string' || !Array.isArray(value.entryPoints) || value.entryPoints.some(entry => !object(entry) || typeof entry.name !== 'string' || typeof entry.value !== 'string'))
+            return fail('invalid Python package metadata');
+        metadata = value;
+    }
+    catch {
+        return fail('invalid Python package metadata');
+    }
+    if (metadata.hermesVersion !== TESTED_HERMES_ARTIFACT.hermesVersion || metadata.acpVersion !== TESTED_HERMES_ARTIFACT.acpVersion || resolve(metadata.adapterOrigin) !== join(chain.sourceRoot, 'acp_adapter/__init__.py'))
+        return fail('Python packages or ACP source origin differ from the tested build');
+    validatePluginSources(request, chain.sourceRoot, metadata);
+    return { artifact: { ...TESTED_HERMES_ARTIFACT, sourceRoot: chain.sourceRoot, executable: chain.executable }, pluginMcp: 'absent-in-validated-sources' };
+}
+/** Native identity check, separate from session model/provider validation and first actual MCP use. */
+export function validateHermesInitialize(response) {
+    if (!object(response) || response.protocolVersion !== TESTED_HERMES_ARTIFACT.protocolVersion || !object(response.agentInfo) || response.agentInfo.name !== 'hermes-agent' || response.agentInfo.version !== TESTED_HERMES_ARTIFACT.hermesVersion)
+        fail('ACP initialize identity/protocol does not match the tested Hermes artifact');
+}

package/dist/harness/hermes-config.d.ts

@@ -0,0 +1,12 @@
+import type { ResolvedRole } from '../config.js';
+import { type McpServerSpec } from './acp-mcp.js';
+import type { AcpMcpServer, RoleDirs, SessionPrep, ValidationError } from './types.js';
+export interface HermesOptions {
+    mcp_servers?: Record<string, McpServerSpec>;
+}
+export declare function validateHermesOptions(options: unknown): ValidationError[];
+export declare function validateHermesRole(role: ResolvedRole): ValidationError[];
+/** Complete environment: transport MUST use inheritEnvironment:false after this final merge. */
+export declare function hermesChildEnvironment(role: ResolvedRole, home: string, trustedFleetEnv: Record<string, string>, inherited?: NodeJS.ProcessEnv): Record<string, string>;
+export declare function hermesMcpServers(role: ResolvedRole, trustedFleetEnv?: Record<string, string>): AcpMcpServer[];
+export declare function prepareHermesConfig(role: ResolvedRole, dirs: RoleDirs): Promise<SessionPrep>;