@ran-sh/dsh-crew 2.2.1 → 2.2.3

package/src/install/desktop-profile.mjs

@@ -0,0 +1,168 @@
+// Desktop-client integration for the official DSH desktop application.
+//
+// The desktop app (an Electron client) boots its own Harness against ~/.dsh with
+// the app-exclusive `desktop` profile — the CLI refuses to manage that profile —
+// and applies that profile's user patch layer, which the Harness hot-watches. So
+// the only way the desktop app shows the Crew panel is an insert in
+// <official home>/profiles/desktop/cordis.patch.yml pointing at the Crew web
+// bridge snapshot. That file lives in the official home, which Crew otherwise
+// treats as read-only: this module is reachable ONLY from the explicit
+// `dsh-crew desktop attach|detach|status` commands and never runs during install,
+// update or any supervision path. attach is idempotent and re-points a stale
+// revision; detach removes exactly the block this module wrote, leaving the rest
+// of the file byte for byte.
+
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { basename, dirname, join } from 'node:path';
+import { homedir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+
+const BRIDGE_ID = 'dsh-crew-official-web-bridge';
+const BRIDGE_PACKAGE = '@ran-sh/dsh-crew-web-bridge';
+const MARKER = '# dsh-crew desktop bridge (managed by dsh-crew; remove with: dsh-crew desktop detach)';
+const REVISION_RE = /^[a-f0-9]{64}$/;
+
+export function desktopPatchFile({ home = homedir() } = {}) {
+  return join(home, '.dsh', 'profiles', 'desktop', 'cordis.patch.yml');
+}
+
+/** The bridge entry the Crew launcher itself would load, straight from the overlay. */
+export function crewBridgeEntry({ home = homedir() } = {}) {
+  const overlayFile = join(home, '.config', 'dsh-crew', 'frontend', 'official-web.patch.json');
+  let parsed;
+  try { parsed = JSON.parse(readFileSync(overlayFile, 'utf8')); } catch { return { ok: false, code: 'CREW_BRIDGE_OVERLAY_UNAVAILABLE', overlayFile }; }
+  const root = Array.isArray(parsed) && parsed.length === 1 ? parsed[0] : null;
+  const insert = root && Array.isArray(root.insert) && root.insert.length === 1 ? root.insert[0] : null;
+  const entryUri = insert && typeof insert.name === 'string' ? insert.name : null;
+  if (!entryUri || insert.id !== BRIDGE_ID || !entryUri.startsWith('file://')) {
+    return { ok: false, code: 'CREW_BRIDGE_OVERLAY_INVALID', overlayFile };
+  }
+  let entryPath;
+  try { entryPath = fileURLToPath(entryUri); } catch { return { ok: false, code: 'CREW_BRIDGE_OVERLAY_INVALID', overlayFile }; }
+  if (!existsSync(entryPath)) return { ok: false, code: 'CREW_BRIDGE_SNAPSHOT_MISSING', overlayFile, entry: entryUri };
+  // The launcher checks the same pair before it starts a frontend: the snapshot's
+  // own manifest must claim to be Crew-managed and must agree with the revision
+  // its directory is named after.
+  const revision = basename(dirname(dirname(entryPath)));
+  let manifest;
+  try { manifest = JSON.parse(readFileSync(join(dirname(entryPath), 'package.json'), 'utf8')); } catch { manifest = null; }
+  if (!manifest || manifest.name !== BRIDGE_PACKAGE || manifest.dshCrewManagedFrontend !== true
+    || manifest.dshCrewFrontendRevision !== revision || !REVISION_RE.test(revision)) {
+    return { ok: false, code: 'CREW_BRIDGE_SNAPSHOT_INVALID', overlayFile, entry: entryUri, revision };
+  }
+  return { ok: true, overlayFile, entry: entryUri, entryPath, revision };
+}
+
+function blockFor(entryUri, eol) {
+  return [
+    MARKER,
+    '- insert:',
+    `    - id: ${BRIDGE_ID}`,
+    `      name: '${entryUri}'`,
+    '',
+  ].join(eol);
+}
+
+function blockPattern(eol) {
+  const e = eol === '\r\n' ? '\\r\\n' : '\\n';
+  return new RegExp(
+    `^${MARKER.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}${e}- insert:${e} {4}- id: ${BRIDGE_ID}${e} {6}name: '[^'${e}]*'${e}?`,
+    'm',
+  );
+}
+
+function detectsEol(text) {
+  return text.includes('\r\n') ? '\r\n' : '\n';
+}
+
+// Fail closed on a patch layer whose shape this module does not understand: a
+// top-level YAML array of patch entries. Anything else is somebody's file.
+function looksLikePatchArray(text) {
+  const firstMeaningful = text.split(/\r?\n/).find((line) => line.trim() !== '' && !line.trimStart().startsWith('#'));
+  if (firstMeaningful === undefined) return true;
+  const trimmed = firstMeaningful.trimStart();
+  return trimmed.startsWith('-') || trimmed === '[]' || trimmed === '---';
+}
+
+export function desktopStatus({ home = homedir() } = {}) {
+  const patchFile = desktopPatchFile({ home });
+  const bridge = crewBridgeEntry({ home });
+  let text = null;
+  try { text = readFileSync(patchFile, 'utf8'); } catch { text = null; }
+  const eol = text === null ? '\n' : detectsEol(text);
+  const block = text === null ? null : blockPattern(eol).exec(text);
+  return {
+    ok: true,
+    path: patchFile,
+    file_present: text !== null,
+    bridge: bridge.ok ? { entry: bridge.entry, revision: bridge.revision } : null,
+    bridge_error: bridge.ok ? null : bridge.code,
+    attached: block !== null,
+    current: block !== null && bridge.ok ? block[0].includes(bridge.entry) : false,
+  };
+}
+
+function writeAtomic(file, text) {
+  const temp = `${file}.dsh-crew.${process.pid}.tmp`;
+  writeFileSync(temp, text);
+  renameSync(temp, file);
+}
+
+export function desktopAttach({ home = homedir(), dryRun = false, log = () => {} } = {}) {
+  const bridge = crewBridgeEntry({ home });
+  if (!bridge.ok) return { ok: false, code: bridge.code, error: `Crew bridge snapshot is unavailable (${bridge.code})` };
+  const patchFile = desktopPatchFile({ home });
+  let text = null;
+  try { text = readFileSync(patchFile, 'utf8'); } catch { text = null; }
+  const eol = text === null ? '\n' : detectsEol(text);
+  if (text !== null && !looksLikePatchArray(text)) {
+    return { ok: false, code: 'DESKTOP_PATCH_SHAPE_UNSUPPORTED', error: `${patchFile} is not a top-level patch array; refusing to edit it`, path: patchFile };
+  }
+  const block = blockFor(bridge.entry, eol);
+  const withoutBlock = text === null ? null : text.replace(blockPattern(eol), '');
+  const current = withoutBlock !== null && text.includes(bridge.entry) && withoutBlock !== text;
+  const base = withoutBlock ?? '';
+  const separator = base === '' || base.endsWith('\n') ? '' : eol;
+  const next = `${base}${separator}${block}`;
+  if (text !== null && next === text) {
+    log(`- desktop app already carries the Crew bridge for revision ${bridge.revision}`);
+    return { ok: true, changed: false, path: patchFile, entry: bridge.entry, revision: bridge.revision };
+  }
+  if (dryRun) {
+    log(`- would ${current ? 're-point' : 'attach'} the Crew bridge in ${patchFile} (revision ${bridge.revision})`);
+    return { ok: true, changed: true, dryRun: true, path: patchFile, entry: bridge.entry, revision: bridge.revision };
+  }
+  mkdirSync(dirname(patchFile), { recursive: true });
+  writeAtomic(patchFile, next);
+  log(`✓ desktop app ${current ? 're-pointed to' : 'attached to'} the Crew bridge (revision ${bridge.revision})`);
+  log('  the Harness hot-watches this patch layer; if the panel does not appear, restart the desktop app');
+  return { ok: true, changed: true, path: patchFile, entry: bridge.entry, revision: bridge.revision };
+}
+
+export function desktopDetach({ home = homedir(), dryRun = false, log = () => {} } = {}) {
+  const patchFile = desktopPatchFile({ home });
+  let text;
+  try { text = readFileSync(patchFile, 'utf8'); } catch {
+    log('- desktop patch layer is absent; nothing to remove');
+    return { ok: true, changed: false, path: patchFile };
+  }
+  const eol = detectsEol(text);
+  const next = text.replace(blockPattern(eol), '');
+  if (next === text) {
+    log('- the Crew bridge is not present in the desktop patch layer');
+    return { ok: true, changed: false, path: patchFile };
+  }
+  if (dryRun) return { ok: true, changed: true, dryRun: true, path: patchFile };
+  // A file this module created holds only its own block: remove the file rather
+  // than leave an empty one behind.
+  if (next.trim() === '') {
+    rmSync(patchFile, { force: true });
+    log('✓ removed the Crew bridge from the desktop patch layer (the file held nothing else)');
+    return { ok: true, changed: true, path: patchFile, removed_file: true };
+  }
+  writeAtomic(patchFile, next);
+  log('✓ removed the Crew bridge from the desktop patch layer');
+  return { ok: true, changed: true, path: patchFile };
+}
+
+export { MARKER as DESKTOP_BRIDGE_MARKER, BRIDGE_ID as DESKTOP_BRIDGE_ID };

package/src/install/harness-config-import.mjs

@@ -0,0 +1,204 @@
+// Mirror the operator's user-level DSH configuration from the OFFICIAL home into
+// Crew's own home, so the Crew hub works with the same models, providers, policy
+// and MCP servers as the desktop app the operator actually uses.
+//
+// The official home is read-only here — nothing under ~/.dsh is ever written.
+// Secrets are never copied either: provider entries reference their keys through
+// `apiKeyEnv`, and those variables live in the operator's user environment, which
+// every harness process inherits.
+//
+// Two hazards shape the rules:
+//   1. The desktop app runs a DIFFERENT cohort than Crew pins (0.1.7-rc.2 vs
+//      0.1.6-alpha.1), so an entry may name a package Crew's runtime does not
+//      have. The Harness installs patches fail-loud, so such an entry would break
+//      the hub: it is skipped and reported instead.
+//   2. Crew's own managed blocks (the desktop bridge insert) are not user
+//      configuration and are never mirrored.
+
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { homedir } from 'node:os';
+import { crewDshHome } from './install.mjs';
+import { crewDshRuntimeRoot } from '../dsh-cli-runtime.mjs';
+import { DESKTOP_BRIDGE_ID, DESKTOP_BRIDGE_MARKER } from './desktop-profile.mjs';
+
+const CREW_PROFILE_NAME = 'dsh-crew';
+
+export function officialHomeDir({ home = homedir() } = {}) {
+  return join(home, '.dsh');
+}
+
+export function configMirrorTargets({ home = homedir() } = {}) {
+  const crewHome = crewDshHome({ home });
+  const official = officialHomeDir({ home });
+  return {
+    crewHome,
+    homeLayer: {
+      label: 'home layer (MCP servers)',
+      source: join(official, 'cordis.patch.yml'),
+      target: join(crewHome, 'cordis.patch.yml'),
+    },
+    profileLayer: {
+      label: 'profile layer (models/providers/policy)',
+      source: join(official, 'profiles', 'desktop', 'cordis.patch.yml'),
+      target: join(crewHome, 'profiles', CREW_PROFILE_NAME, 'cordis.patch.yml'),
+    },
+  };
+}
+
+// Does the Harness's resolution of this specifier succeed inside the Crew runtime
+// tree? npm nests whole subtrees under family packages, so the nested scopes are
+// checked too — that is where a hoisted sibling actually resolves from.
+function resolvesInRuntime(runtimeRoot, specifier) {
+  if (typeof specifier !== 'string' || specifier === '') return true;
+  if (specifier.startsWith('.') || specifier.startsWith('/') || specifier.startsWith('file:')) return true;
+  const moduleRoot = join(runtimeRoot, 'node_modules');
+  const parts = specifier.split('/');
+  if (existsSync(join(moduleRoot, ...parts))) return true;
+  const scopeDir = join(moduleRoot, '@deepseek-ai');
+  let packages;
+  try { packages = readdirSync(scopeDir); } catch { return false; }
+  for (const name of packages) {
+    const nested = join(scopeDir, name, 'node_modules');
+    if (existsSync(join(nested, ...parts))) return true;
+    let inner;
+    try { inner = readdirSync(join(nested, '@deepseek-ai')); } catch { continue; }
+    for (const deeper of inner) {
+      if (existsSync(join(nested, '@deepseek-ai', deeper, 'node_modules', ...parts))) return true;
+    }
+  }
+  return false;
+}
+
+// Split a patch layer into its top-level entries, verbatim. A comment at column 0
+// is NOT part of the preceding entry — it separates entries (Crew's own managed
+// block marker sits between entries, and attaching it to the entry above would
+// drop that entry from the mirror).
+function splitEntries(text) {
+  const entries = [];
+  let current = null;
+  const flush = () => { if (current) entries.push(current); current = null; };
+  for (const line of text.split(/\r?\n/)) {
+    if (line.startsWith('- ') || line === '-') {
+      flush();
+      current = [line];
+      continue;
+    }
+    if (line.startsWith('#')) {
+      flush();
+      entries.push([line]);
+      continue;
+    }
+    if (current) current.push(line);
+  }
+  flush();
+  return entries.map((lines) => lines.join('\n').replace(/\s+$/, ''));
+}
+
+function entryMeta(entry) {
+  return {
+    id: entry.match(/^- id:[ \t]*(\S+)/m)?.[1] ?? null,
+    insertId: entry.match(/^[ \t]+- id:[ \t]*(\S+)/m)?.[1] ?? null,
+    name: entry.match(/^[ \t]+name:[ \t]*["']?([^"'\s]+)/m)?.[1] ?? null,
+  };
+}
+
+function isOwnManagedBlock(entry, meta) {
+  return entry.includes(DESKTOP_BRIDGE_MARKER) || meta.id === DESKTOP_BRIDGE_ID || meta.insertId === DESKTOP_BRIDGE_ID;
+}
+
+function mirrorLayer({ layer, crewHome, runtimeRoot, dryRun, log }) {
+  const { source, target, label } = layer;
+  if (!existsSync(source)) {
+    log(`- ${label}: no official source at ${source}; nothing to mirror`);
+    return { ok: true, changed: false, entries: 0, skipped: [], source, target, label };
+  }
+  const eol = readFileSync(source, 'utf8').includes('\r\n') ? '\r\n' : '\n';
+  const kept = [];
+  const skipped = [];
+  const isCommentOnly = (entry) => entry.split(/\r?\n/).every((line) => line.trim() === '' || line.startsWith('#'));
+  for (const entry of splitEntries(readFileSync(source, 'utf8'))) {
+    if (entry.trim() === '') continue;
+    if (isCommentOnly(entry) && !entry.includes(DESKTOP_BRIDGE_MARKER)) continue; // file prose, not configuration
+    const meta = entryMeta(entry);
+    if (isOwnManagedBlock(entry, meta)) {
+      skipped.push({ id: meta.insertId ?? meta.id, reason: 'crew-managed' });
+      continue;
+    }
+    if (!meta.id && !meta.insertId) {
+      skipped.push({ id: null, reason: 'unrecognized-entry' });
+      continue;
+    }
+    if (!resolvesInRuntime(runtimeRoot, meta.name)) {
+      skipped.push({ id: meta.id ?? meta.insertId, name: meta.name, reason: 'not-in-crew-cohort' });
+      continue;
+    }
+    kept.push(entry);
+  }
+  const header = [
+    `# Mirrored from ${source} by dsh-crew config import.`,
+    '# Crew keeps its own DSH home; this layer carries the operator\'s user-level',
+    '# configuration so the Crew hub matches the desktop app. Edit the source and',
+    '# re-run the import — changes here are overwritten.',
+    '',
+  ].join(eol);
+  const body = kept.length ? `${header}${kept.join(`${eol}${eol}`)}${eol}` : '';
+  const existing = existsSync(target) ? readFileSync(target, 'utf8') : null;
+  for (const item of skipped) {
+    log(`  ! skipped ${item.id ?? '(unknown entry)'}${item.name ? ` [${item.name}]` : ''}: ${
+      item.reason === 'not-in-crew-cohort'
+        ? 'package is not in the Crew runtime cohort'
+        : item.reason === 'crew-managed' ? 'Crew-managed block' : 'unrecognized entry shape'
+    }`);
+  }
+  if (existing === body) {
+    log(`- ${label}: already mirrored (${kept.length} entries)`);
+    return { ok: true, changed: false, entries: kept.length, skipped, source, target, label };
+  }
+  if (dryRun) {
+    log(`- ${label}: would mirror ${kept.length} entries -> ${target}`);
+    return { ok: true, changed: true, dryRun: true, entries: kept.length, skipped, source, target, label };
+  }
+  if (!existsSync(dirname(target))) {
+    return { ok: false, code: 'CREW_HOME_LAYER_MISSING', error: `Crew directory is absent: ${dirname(target)}`, label };
+  }
+  const temp = `${target}.dsh-crew.${process.pid}.tmp`;
+  writeFileSync(temp, body);
+  renameSync(temp, target);
+  log(`✓ ${label}: mirrored ${kept.length} entries -> ${target}`);
+  return { ok: true, changed: true, entries: kept.length, skipped, source, target, label };
+}
+
+export function mirrorOfficialHarnessConfig({ home = homedir(), dryRun = false, log = () => {} } = {}) {
+  const targets = configMirrorTargets({ home });
+  const runtimeRoot = crewDshRuntimeRoot({ home });
+  const layers = [];
+  for (const layer of [targets.homeLayer, targets.profileLayer]) {
+    const result = mirrorLayer({ layer, crewHome: targets.crewHome, runtimeRoot, dryRun, log });
+    layers.push(result);
+    if (!result.ok) return { ok: false, code: result.code, error: result.error, layers };
+  }
+  return {
+    ok: true,
+    changed: layers.some((layer) => layer.changed),
+    dryRun,
+    layers: layers.map(({ label, source, target, changed, entries, skipped }) => ({ label, source, target, changed, entries, skipped })),
+  };
+}
+
+export function officialConfigMirrorStatus({ home = homedir() } = {}) {
+  const targets = configMirrorTargets({ home });
+  const inspect = (layer) => {
+    let targetText = null;
+    try { targetText = readFileSync(layer.target, 'utf8'); } catch { targetText = null; }
+    return {
+      label: layer.label,
+      source: layer.source,
+      source_present: existsSync(layer.source),
+      target: layer.target,
+      target_present: targetText !== null,
+      mirrored: targetText !== null && targetText.includes('by dsh-crew config import'),
+    };
+  };
+  return { ok: true, home_layer: inspect(targets.homeLayer), profile_layer: inspect(targets.profileLayer) };
+}

package/src/install/install-legacy.mjs

@@ -497,7 +497,7 @@ export function writeGlobalConfig(patch) {
 }
 
 /** What is currently installed where — drives the settings-page buttons. */
-export function installStatus({ home = homedir(), root = ROOT, env = process.env } = {}) {
+export function installStatus({ home = homedir(), root = ROOT, env = process.env, claudeDetected = undefined } = {}) {
   // Host integrations are installed from the profile's loader link, not from the
   // release directory, so an upgrade re-points one link instead of rewriting four
   // host configurations. Readiness has to judge them against the path they were
@@ -549,9 +549,16 @@ export function installStatus({ home = homedir(), root = ROOT, env = process.env
     || existsSync(join(codexRoot, 'agents', 'ds-flash.toml'))
     || existsSync(join(codexRoot, 'agents', 'ds-pro.toml'));
   const missing = Object.entries(components).filter(([, present]) => !present).map(([key]) => key);
+  // `installed` stays the footprint: the settings name our plugin, which is a
+  // deliberate distinction from `ready` (an enabled setting is not a callable
+  // plugin). `host_detected` records the other half a renderer needs — a machine
+  // with no Claude Code has nothing installed and nothing to repair, even though
+  // the best-effort settings are there.
+  const claudeHostDetected = claudeDetected === undefined ? resolveClaudeCommand() !== null : claudeDetected === true;
   return {
     claude: {
       installed: claudeFootprint,
+      host_detected: claudeHostDetected,
       ready: claudeMissing.length === 0,
       hud: hudWired,
       components: claudeComponents,