@ran-sh/dsh-crew 0.3.7 → 0.4.0

package/src/official-web-bridge.mjs

@@ -0,0 +1,211 @@
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { crewDshHome } from './install/install.mjs';
+import { crewDshRuntimeModule } from './dsh-cli-runtime.mjs';
+
+export const CREW_BRIDGE_PREFIX = '/_dsh/dsh-crew';
+export const CREW_BRIDGE_TARGET = 'http://127.0.0.1:3210';
+const MAX_BODY_BYTES = 4 * 1024 * 1024;
+const HOP_BY_HOP = new Set([
+  'connection', 'keep-alive', 'proxy-authenticate', 'proxy-authorization',
+  'te', 'trailer', 'transfer-encoding', 'upgrade', 'host', 'content-length',
+]);
+
+export function isLoopbackAddress(address) {
+  return address === '127.0.0.1' || address === '::1' || address === '::ffff:127.0.0.1';
+}
+
+function isLocalHostname(hostname) {
+  return hostname === 'localhost' || hostname === '127.0.0.1' || hostname === '[::1]' || hostname === '::1';
+}
+
+export function resolveCrewBridgeTarget(env = process.env) {
+  const raw = env?.DSH_CREW_BRIDGE_TARGET;
+  if (!raw) return CREW_BRIDGE_TARGET;
+  try {
+    const target = new URL(raw);
+    if (target.protocol !== 'http:' || !isLocalHostname(target.hostname.toLowerCase()) || target.pathname !== '/' || target.search || target.hash) return CREW_BRIDGE_TARGET;
+    const port = Number(target.port);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) return CREW_BRIDGE_TARGET;
+    return target.origin;
+  } catch { return CREW_BRIDGE_TARGET; }
+}
+
+export function isTrustedLocalRequest(req) {
+  if (!isLoopbackAddress(req?.socket?.remoteAddress)) return false;
+  const host = typeof req?.headers?.host === 'string' ? req.headers.host.trim().toLowerCase() : '';
+  if (!host) return false;
+  let authority;
+  try { authority = new URL(`http://${host}`); } catch { return false; }
+  if (!isLocalHostname(authority.hostname.toLowerCase())) return false;
+  const fetchSite = String(req?.headers?.['sec-fetch-site'] ?? '').toLowerCase();
+  if (fetchSite && fetchSite !== 'same-origin' && fetchSite !== 'none') return false;
+  const origin = req?.headers?.origin;
+  if (origin !== undefined) {
+    if (typeof origin !== 'string') return false;
+    let parsedOrigin;
+    try { parsedOrigin = new URL(origin); } catch { return false; }
+    if (!isLocalHostname(parsedOrigin.hostname.toLowerCase()) || parsedOrigin.host.toLowerCase() !== host) return false;
+  }
+  return true;
+}
+
+function safeHeaders(source) {
+  const result = {};
+  for (const [rawName, rawValue] of Object.entries(source ?? {})) {
+    const name = rawName.toLowerCase();
+    if (HOP_BY_HOP.has(name) || rawValue === undefined) continue;
+    result[name] = Array.isArray(rawValue) ? rawValue.join(', ') : String(rawValue);
+  }
+  return result;
+}
+
+function sendJson(res, status, value) {
+  const body = Buffer.from(JSON.stringify(value));
+  res.writeHead(status, {
+    'content-type': 'application/json; charset=utf-8',
+    'content-length': String(body.length),
+    'cache-control': 'no-store',
+    'x-content-type-options': 'nosniff',
+    'x-dsh-crew-bridge': '3080-to-3210',
+  });
+  res.end(body);
+}
+
+async function readBoundedBody(req, limit = MAX_BODY_BYTES) {
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of req) {
+    const value = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    size += value.length;
+    if (size > limit) throw Object.assign(new Error('request too large'), { code: 'BODY_TOO_LARGE' });
+    chunks.push(value);
+  }
+  return Buffer.concat(chunks);
+}
+
+async function defaultHealthCheck(fetchImpl = globalThis.fetch, bridgeTarget = CREW_BRIDGE_TARGET) {
+  try {
+    const response = await fetchImpl(`${bridgeTarget}${CREW_BRIDGE_PREFIX}/ping`, {
+      signal: AbortSignal.timeout(1_500),
+      headers: { accept: 'application/json' },
+    });
+    return response.ok;
+  } catch { return false; }
+}
+
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+export function createCrewSidecarSupervisor({
+  home = homedir(),
+  exists = existsSync,
+  bridgeTarget = resolveCrewBridgeTarget(),
+  healthCheck = () => defaultHealthCheck(globalThis.fetch, bridgeTarget),
+  spawnImpl = spawn,
+  wait = delay,
+  maxAttempts = 120,
+  pollInterval = 250,
+} = {}) {
+  let starting = null;
+  let runningChild = null;
+  const runtime = crewDshRuntimeModule({ home });
+  const dshHome = crewDshHome({ home });
+  const bridgePort = new URL(bridgeTarget).port;
+
+  async function start() {
+    if (await healthCheck()) return { ok: true, started: false };
+    if (!exists(runtime)) return { ok: false, code: 'CREW_RUNTIME_NOT_INSTALLED' };
+    const childAlive = runningChild && runningChild.killed !== true && runningChild.exitCode == null;
+    if (!childAlive) {
+      runningChild = spawnImpl(process.execPath, [
+        runtime, '--profile', 'dsh-crew', '--host', '127.0.0.1', '--port', bridgePort,
+      ], {
+        cwd: dshHome,
+        env: { ...process.env, DSH_HOME: dshHome },
+        detached: true,
+        stdio: 'ignore',
+        windowsHide: true,
+      });
+      const ownedChild = runningChild;
+      ownedChild.once?.('exit', () => { if (runningChild === ownedChild) runningChild = null; });
+      ownedChild.unref?.();
+    }
+    for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+      if (await healthCheck()) return { ok: true, started: true };
+      await wait(pollInterval);
+    }
+    return { ok: false, code: 'CREW_BACKEND_START_TIMEOUT' };
+  }
+
+  return {
+    ensure() {
+      if (!starting) starting = start().finally(() => { starting = null; });
+      return starting;
+    },
+  };
+}
+
+const processSupervisor = createCrewSidecarSupervisor();
+
+export async function proxyCrewRequest(req, res, {
+  fetchImpl = globalThis.fetch,
+  ensureBackend = () => processSupervisor.ensure(),
+  bridgeTarget = resolveCrewBridgeTarget(),
+} = {}) {
+  if (!isTrustedLocalRequest(req)) {
+    sendJson(res, 403, { ok: false, code: 'LOCAL_SAME_ORIGIN_ONLY' });
+    return;
+  }
+  let pathname;
+  try { pathname = new URL(req.url, 'http://127.0.0.1:3080').pathname; } catch { pathname = ''; }
+  if (pathname !== CREW_BRIDGE_PREFIX && !pathname.startsWith(`${CREW_BRIDGE_PREFIX}/`)) {
+    sendJson(res, 404, { ok: false, code: 'NOT_FOUND' });
+    return;
+  }
+  try {
+    const backend = await ensureBackend();
+    if (backend?.ok === false) throw new Error('backend unavailable');
+    const method = String(req.method ?? 'GET').toUpperCase();
+    const bodyBuffer = method === 'GET' || method === 'HEAD' ? null : await readBoundedBody(req);
+    const response = await fetchImpl(`${bridgeTarget}${req.url}`, {
+      method,
+      headers: safeHeaders(req.headers),
+      body: bodyBuffer === null ? undefined : new Blob([bodyBuffer]),
+      signal: AbortSignal.timeout(120_000),
+    });
+    const responseBody = Buffer.from(await response.arrayBuffer());
+    const headers = safeHeaders(Object.fromEntries(response.headers.entries()));
+    headers['content-length'] = String(responseBody.length);
+    headers['x-dsh-crew-bridge'] = '3080-to-3210';
+    res.writeHead(response.status, headers);
+    res.end(responseBody);
+  } catch (error) {
+    if (error?.code === 'BODY_TOO_LARGE') sendJson(res, 413, { ok: false, code: 'REQUEST_TOO_LARGE' });
+    else sendJson(res, 503, { ok: false, code: 'CREW_BACKEND_UNAVAILABLE' });
+  }
+}
+
+export function registerOfficialWebBridge(ctx, options = {}) {
+  return ctx.inject(['webServer'], (webCtx) => {
+    const disposeStatus = webCtx.webServer.register({
+      kind: 'exact',
+      path: `${CREW_BRIDGE_PREFIX}/bridge-status`,
+      handler: (req, res) => {
+        if (!isTrustedLocalRequest(req)) return sendJson(res, 403, { ok: false, code: 'LOCAL_SAME_ORIGIN_ONLY' });
+        return sendJson(res, 200, { ok: true, mode: 'official-3080-isolated-3210' });
+      },
+    });
+    const disposeProxy = webCtx.webServer.register({
+      kind: 'prefix',
+      path: CREW_BRIDGE_PREFIX,
+      handler: (req, res) => proxyCrewRequest(req, res, options),
+    });
+    return () => { disposeProxy?.(); disposeStatus?.(); };
+  });
+}
+
+export async function apply(ctx) {
+  registerOfficialWebBridge(ctx);
+}

package/src/role-profiles.mjs

@@ -0,0 +1,107 @@
+// Versioned, narrow Worker/Reviewer profiles. Profiles configure one DSH
+// delegation; they are not general Agent personas and never contain prompts or
+// credentials.
+
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { homedir } from 'node:os';
+
+export const ROLE_PROFILE_SCHEMA_VERSION = 1;
+export const DEFAULT_ROLE_PROFILES = Object.freeze({
+  'worker-default': Object.freeze({
+    role: 'worker', routing: 'auto', isolation: 'worktree', fallback: true,
+    timeout_seconds: 1800, review_strictness: 'standard',
+  }),
+  'reviewer-default': Object.freeze({
+    role: 'reviewer', routing: 'stable', isolation: 'readonly', fallback: false,
+    timeout_seconds: 1800, review_strictness: 'strict',
+  }),
+});
+
+const ID = /^[a-z0-9][a-z0-9._-]{0,63}$/;
+const ROLES = new Set(['worker', 'reviewer']);
+const ROUTING = new Set(['auto', 'priority', 'stable']);
+const ISOLATION = new Set(['worktree', 'readonly', 'shared']);
+const STRICTNESS = new Set(['standard', 'strict']);
+
+function normalizeProfile(id, raw) {
+  if (!ID.test(id) || !raw || typeof raw !== 'object' || Array.isArray(raw)) return null;
+  if (!ROLES.has(raw.role)) return null;
+  const base = DEFAULT_ROLE_PROFILES[`${raw.role}-default`];
+  const routing = raw.routing ?? base.routing;
+  const isolation = raw.isolation ?? base.isolation;
+  const reviewStrictness = raw.review_strictness ?? base.review_strictness;
+  const timeout = raw.timeout_seconds ?? base.timeout_seconds;
+  if (!ROUTING.has(routing) || !ISOLATION.has(isolation) || !STRICTNESS.has(reviewStrictness)) return null;
+  if (!Number.isInteger(timeout) || timeout < 1 || timeout > 7200) return null;
+  if (raw.fallback !== undefined && typeof raw.fallback !== 'boolean') return null;
+  return {
+    role: raw.role,
+    routing,
+    isolation,
+    fallback: raw.fallback ?? base.fallback,
+    timeout_seconds: timeout,
+    review_strictness: reviewStrictness,
+  };
+}
+
+export function roleProfilesFile({ home = homedir() } = {}) {
+  return join(home, '.config', 'dsh-crew', 'profiles.json');
+}
+
+export function loadRoleProfiles({ home = homedir(), file = roleProfilesFile({ home }) } = {}) {
+  if (!existsSync(file)) {
+    return { schema_version: ROLE_PROFILE_SCHEMA_VERSION, ok: true, source: 'defaults', profiles: { ...DEFAULT_ROLE_PROFILES }, errors: [] };
+  }
+  let raw;
+  try { raw = JSON.parse(readFileSync(file, 'utf8')); } catch {
+    return { schema_version: ROLE_PROFILE_SCHEMA_VERSION, ok: false, source: 'file', profiles: { ...DEFAULT_ROLE_PROFILES }, errors: [{ code: 'PROFILE_FILE_INVALID' }] };
+  }
+  return parseRoleProfiles(raw);
+}
+
+function parseRoleProfiles(raw) {
+  const errors = [];
+  const profiles = { ...DEFAULT_ROLE_PROFILES };
+  if (raw?.schema_version !== ROLE_PROFILE_SCHEMA_VERSION || !raw.profiles || typeof raw.profiles !== 'object' || Array.isArray(raw.profiles)) {
+    return { schema_version: ROLE_PROFILE_SCHEMA_VERSION, ok: false, source: 'file', profiles, errors: [{ code: 'PROFILE_FILE_INVALID' }] };
+  }
+  for (const [id, value] of Object.entries(raw.profiles)) {
+    if (id in DEFAULT_ROLE_PROFILES) {
+      const normalized = normalizeProfile(id, value);
+      if (!normalized || JSON.stringify(normalized) !== JSON.stringify(DEFAULT_ROLE_PROFILES[id])) {
+        errors.push({ code: 'PROFILE_DEFAULT_RESERVED', profile_id: id });
+      }
+      continue;
+    }
+    const profile = normalizeProfile(id, value);
+    if (!profile) errors.push({ code: 'PROFILE_INVALID', profile_id: ID.test(id) ? id : '<invalid>' });
+    else profiles[id] = profile;
+  }
+  return { schema_version: ROLE_PROFILE_SCHEMA_VERSION, ok: errors.length === 0, source: 'file', profiles, errors: errors.slice(0, 32) };
+}
+
+export function saveRoleProfiles(document, { home = homedir(), file = roleProfilesFile({ home }) } = {}) {
+  const parsed = parseRoleProfiles(document);
+  if (!parsed.ok) return parsed;
+  const custom = Object.fromEntries(Object.entries(parsed.profiles).filter(([id]) => !(id in DEFAULT_ROLE_PROFILES)));
+  const payload = { schema_version: ROLE_PROFILE_SCHEMA_VERSION, profiles: custom };
+  mkdirSync(dirname(file), { recursive: true });
+  const temp = `${file}.tmp-${process.pid}-${Date.now()}`;
+  try {
+    writeFileSync(temp, `${JSON.stringify(payload, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
+    renameSync(temp, file);
+  } catch (error) {
+    rmSync(temp, { force: true });
+    return { ...parsed, ok: false, errors: [{ code: 'PROFILE_FILE_WRITE_FAILED' }], error_code: 'PROFILE_FILE_WRITE_FAILED' };
+  }
+  return { ...parsed, source: 'file' };
+}
+
+export function resolveRoleProfile(registry, profileId, role = 'worker') {
+  const id = profileId ?? `${role}-default`;
+  const profile = registry?.profiles?.[id];
+  if (!profile) return { ok: false, code: 'PROFILE_NOT_FOUND', profile_id: id };
+  if (profile.role !== role) return { ok: false, code: 'PROFILE_ROLE_MISMATCH', profile_id: id, expected_role: role };
+  return { ok: true, profile_id: id, profile: { ...profile } };
+}

package/src/runtime-identity.mjs

@@ -8,7 +8,7 @@
 // Keep this module pure and dependency-free so Hub, MCP and tests all use the
 // exact same compatibility rules.
 
-export const RUNTIME_VERSION = '0.3.7';
+export const RUNTIME_VERSION = '0.4.0';
 export const HUB_PROTOCOL_VERSION = 1;
 
 export const HUB_CAPABILITIES = Object.freeze([
@@ -21,6 +21,11 @@ export const HUB_CAPABILITIES = Object.freeze([
   'model-catalog',
   'presets',
   'config',
+  'canonical-events',
+  'evidence',
+  'profiles',
+  'workspace-context',
+  'extension-contract',
 ]);
 
 // Capabilities the current MCP workflow depends on for full Hub execution.