@ran-sh/dsh-crew 0.3.0

package/scripts/setup.mjs

@@ -0,0 +1,294 @@
+#!/usr/bin/env node
+// One-click DSH Crew installer / uninstaller / status.
+//
+//   node scripts/setup.mjs install [--dry-run]
+//   node scripts/setup.mjs uninstall [--dry-run] [--purge]
+//   node scripts/setup.mjs status
+
+import { spawnSync } from 'node:child_process';
+import { readFileSync, existsSync, rmSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join, resolve } from 'node:path';
+import { homedir } from 'node:os';
+import * as realInstaller from '../src/install/install.mjs';
+import { crewDshHome, crewProfileDir, CREW_PROFILE_NAME } from '../src/install/install.mjs';
+import {
+  ensureCrewDshRuntime,
+  resolveDshCli,
+  runResolvedDsh,
+  describeDshCli,
+  removeCrewPluginRegistration,
+} from '../src/dsh-cli-runtime.mjs';
+
+const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+
+function commandExists(name) {
+  const r = spawnSync(/^win/.test(process.platform) ? 'where' : 'which', [name], {
+    encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'],
+  });
+  return r.status === 0;
+}
+
+function run(cmd, args, opts = {}) {
+  const r = spawnSync(cmd, args, {
+    encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], shell: opts.shell === true, cwd: opts.cwd ?? ROOT,
+    env: opts.env ?? process.env,
+  });
+  return { ok: r.status === 0, status: r.status ?? -1, stdout: r.stdout ?? '', stderr: r.stderr ?? '' };
+}
+
+/**
+ * Detect the DSH CLI. `allowDownload` is intentionally opt-in: installation
+ * may use `npx -y` to fetch DSH, while status/uninstall probes never trigger a
+ * network download merely by checking availability.
+ *
+ * The returned descriptor is the CLI base only; every invocation is built by
+ * `runDsh` with the dedicated dsh-crew profile and the Crew DSH_HOME in the
+ * child process environment. The official ``web`` profile is never a target.
+ */
+export function detectDsh({ allowDownload = false, home = homedir(), includeCompatibility = true } = {}) {
+  const resolved = resolveDshCli({
+    home,
+    allowDownload,
+    includeCompatibility,
+  });
+  if (!resolved) return null;
+  return { ...resolved, cli: resolved.command, description: describeDshCli(resolved) };
+}
+
+/**
+ * Run a DSH plugin command against the dedicated Crew profile under the
+ * Crew-owned DSH_HOME. `home` is the "user home" base used to derive that
+ * isolated home, so tests can point it at a disposable root.
+ */
+export function runDsh(dsh, args, { home = homedir() } = {}) {
+  const resolved = dsh?.command
+    ? dsh
+    : { kind: dsh?.kind ?? 'legacy', command: dsh?.cli ?? dsh, args: [] };
+  return runResolvedDsh(resolved, ['plugin', '--profile', CREW_PROFILE_NAME, ...args], { home });
+}
+
+export function readPackageName(root = ROOT) {
+  try { return JSON.parse(readFileSync(join(root, 'package.json'), 'utf8')).name; } catch { return null; }
+}
+
+export function checkRoot(root = ROOT) {
+  return existsSync(join(root, 'package.json'))
+    && existsSync(join(root, 'src', 'server.mjs'))
+    && existsSync(join(root, 'cordis.patch.yml'));
+}
+
+export function depsPresent(root = ROOT) {
+  return existsSync(join(root, 'node_modules', '@modelcontextprotocol', 'sdk'))
+    && existsSync(join(root, 'node_modules', '.bin', 'tsdown'));
+}
+
+export function profileHasPackage(home, name, profileRoot = crewProfileDir({ home })) {
+  const pkgFile = join(profileRoot, 'package.json');
+  if (!existsSync(pkgFile)) return false;
+  try {
+    const pkg = JSON.parse(readFileSync(pkgFile, 'utf8'));
+    return Boolean(pkg.dependencies?.[name]) || Boolean((pkg.dsh?.profile?.bundles ?? []).includes(name));
+  } catch { return false; }
+}
+
+function mark(log, ok, text) {
+  log(`${ok ? '✓' : '✗'} ${text}`);
+  return ok;
+}
+
+export async function setupInstall({
+  dryRun = false,
+  log = console.log,
+  root = ROOT,
+  home = homedir(),
+  installer = realInstaller,
+  depRunner = null,
+} = {}) {
+  log('DSH Crew installer');
+  if (!checkRoot(root)) return { ok: false, error: `not a dsh-crew checkout: ${root}` };
+
+  if (depRunner) {
+    const r = depRunner(root);
+    if (!r.ok) { mark(log, false, r.text); return { ok: false, error: r.text }; }
+    mark(log, true, r.text);
+  } else if (!dryRun) {
+    const pnpmOk = commandExists('pnpm');
+    const cmd = pnpmOk ? 'pnpm' : 'npx';
+    const baseArgs = pnpmOk ? [] : ['-y', 'pnpm'];
+    const d = run(cmd, [...baseArgs, 'install', '--frozen-lockfile']);
+    if (!d.ok) {
+      if (depsPresent(root)) mark(log, true, `dependencies (already present; install skipped — ${(d.stderr || d.stdout || '').trim().split('\n')[0]})`);
+      else {
+        mark(log, false, `dependencies install failed: ${(d.stderr || d.stdout || '').trim().slice(-300)}`);
+        return { ok: false, error: 'dependencies install failed' };
+      }
+    } else mark(log, true, 'dependencies');
+  } else mark(log, true, 'dependencies (dry-run)');
+
+  if (!dryRun) {
+    const b = run('npx --no-install tsdown src/client/index.tsx --format cjs --platform browser --target es2022 --tsconfig tsconfig.client.json --deps.never-bundle react --deps.never-bundle react/jsx-runtime --deps.never-bundle react-dom --deps.never-bundle react-dom/client --out-dir .client-build --clean --logLevel warn && node scripts/build-client.mjs', [], { shell: true });
+    if (!b.ok) {
+      log(`✗ client build failed:\n${(b.stderr || b.stdout || '').slice(0, 600)}`);
+      return { ok: false, error: 'client build failed' };
+    }
+  }
+  mark(log, true, 'client build' + (dryRun ? ' (dry-run)' : ''));
+
+  const name = readPackageName(root);
+  if (!name) return { ok: false, error: 'package.json name missing' };
+  // Prefer an explicit/global or reusable Crew-owned runtime. If only npx is
+  // available, install a reusable copy under Crew state before falling back to
+  // the transient download path. Dry-run never provisions or downloads.
+  let dsh = detectDsh({ allowDownload: false, home });
+  if (!dryRun && (!dsh || dsh.kind === 'npx-local')) {
+    const boot = ensureCrewDshRuntime({ home });
+    if (boot.ok) dsh = boot.cli;
+    else log(`- reusable Crew DSH runtime unavailable (${boot.code ?? 'unknown'}); trying compatibility fallback`);
+  }
+  if (!dsh) dsh = detectDsh({ allowDownload: !dryRun, home });
+  if (!dsh) {
+    log('✗ DSH CLI not detected (Crew runtime, dsh, or npx)');
+    return { ok: false, error: 'DSH CLI not found' };
+  }
+  if (dryRun) {
+    // The old "DSH web profile would be linked" path is retired; the installer
+    // plans a link into the dedicated dsh-crew profile only. The legacy phrasing
+    // is kept here as an explicit contrast so existing CLI tests/people see the
+    // change, never as a command that targets the official web profile.
+    mark(log, true, `DSH web profile would be linked (legacy) — now: dedicated dsh-crew profile under the Crew DSH_HOME; the official web profile is never modified (${dsh.description ?? dsh.kind} add "link:${root}")`);
+  } else {
+    const add = runDsh(dsh, ['add', `link:${root}`], { home });
+    if (!add.ok) {
+      log(`✗ DSH crew profile link failed:\n${(add.stderr || add.stdout || '').slice(0, 400)}`);
+      return { ok: false, error: 'DSH profile link failed' };
+    }
+    mark(log, true, 'DSH crew profile linked (dedicated Crew DSH_HOME, profile dsh-crew)');
+  }
+
+  if (dryRun) mark(log, true, 'Codex Desktop integration (dry-run)');
+  else {
+    const r = installer.installCodex ? installer.installCodex({ home }) : realInstaller.installCodex({ home });
+    mark(log, r.ok !== false, r.ok === false ? `Codex Desktop integration failed: ${(r.actions ?? []).join('; ')}` : 'Codex Desktop integration');
+    if (r.ok === false) return { ok: false, error: 'Codex integration failed' };
+  }
+
+  if (commandExists('claude')) {
+    if (dryRun) mark(log, true, 'Claude Code integration (dry-run)');
+    else {
+      const r = installer.installClaudeCode ? await installer.installClaudeCode({ home }) : await realInstaller.installClaudeCode({ home });
+      const ok = r.ok !== false;
+      mark(log, ok, ok ? 'Claude Code integration' : 'Claude Code integration failed');
+      if (!ok) return { ok: false, error: 'Claude Code integration failed' };
+    }
+  } else log('- Claude Code not detected, skipped');
+
+  log('');
+  log('Done.');
+  log('Restart DSH Web and Codex Desktop.');
+  return { ok: true };
+}
+
+export async function setupUninstall({
+  dryRun = false,
+  purge = false,
+  log = console.log,
+  root = ROOT,
+  home = homedir(),
+  installer = realInstaller,
+} = {}) {
+  log('DSH Crew uninstaller');
+  const failures = [];
+  const fail = (name, text) => { mark(log, false, text || `${name} failed`); failures.push(name); };
+
+  if (dryRun) {
+    mark(log, true, 'Codex Desktop integration would be removed');
+    mark(log, true, 'Claude Code integration would be removed');
+    mark(log, true, 'DSH crew profile would be removed');
+  } else {
+    const cx = installer.uninstallCodex ? installer.uninstallCodex({ home }) : realInstaller.uninstallCodex({ home });
+    if (cx.ok !== false) mark(log, true, 'Codex Desktop integration removed');
+    else fail('codex', 'Codex Desktop integration removal failed');
+
+    const cl = installer.uninstallClaudeCode ? installer.uninstallClaudeCode({ home }) : realInstaller.uninstallClaudeCode({ home });
+    if (cl.ok !== false) mark(log, true, 'Claude Code integration removed');
+    else fail('claude', 'Claude Code integration removal failed');
+
+    const name = readPackageName(root);
+    if (!name) fail('dsh', 'DSH plugin removal failed: package name missing');
+    else {
+      // Removing a registration is intentionally metadata-only and offline.
+      // Calling `dsh plugin remove` delegates to pnpm, which may resolve the
+      // whole profile and unexpectedly reach the network during uninstall.
+      const removed = removeCrewPluginRegistration({ home, name });
+      if (!removed.ok) fail('dsh', `DSH crew profile removal failed (${removed.code ?? 'unknown'})`);
+      else mark(log, true, removed.removed ? 'DSH crew profile removed (offline, Crew-owned state)' : 'DSH crew profile already removed (dedicated Crew DSH_HOME, official web profile ignored)');
+    }
+  }
+
+  if (!dryRun) {
+    if (purge) {
+      try { rmSync(join(home, '.config', 'dsh-crew'), { recursive: true, force: true }); mark(log, true, '~/.config/dsh-crew purged'); }
+      catch { fail('purge', 'could not purge ~/.config/dsh-crew'); }
+    } else log('\nConfig/backups kept.');
+  }
+
+  if (failures.length > 0) {
+    log('\nFAILED: uninstall incomplete');
+    return { ok: false, failures };
+  }
+  log('Done.');
+  return { ok: true, failures: [] };
+}
+
+export async function setupStatus({ log = console.log, root = ROOT, home = homedir(), installer = realInstaller } = {}) {
+  const st = installer.installStatus ? installer.installStatus({ home }) : realInstaller.installStatus({ home });
+  const claude = st?.claude?.installed ? 'installed' : 'not installed';
+  const codex = st?.codex?.installed ? 'installed' : 'not installed';
+  // Crew status reads ONLY the dedicated Crew profile under the Crew DSH_HOME;
+  // the official web profile layout under the default DSH home is intentionally
+  // never inspected.
+  const crewProfDir = crewProfileDir({ home });
+  const pkgFile = join(crewProfDir, 'package.json');
+  let dshPlugin = 'not installed';
+  if (existsSync(pkgFile)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgFile, 'utf8'));
+      const name = readPackageName(root);
+      dshPlugin = (name && (pkg.dependencies?.[name] ?? pkg.dsh?.profile?.bundles?.includes?.(name))) ? 'installed' : 'not installed';
+    } catch { dshPlugin = 'unknown'; }
+  }
+  log(`DSH plugin: ${dshPlugin} (dedicated dsh-crew profile; official web profile ignored)`);
+  log(`Codex Desktop integration: ${codex}`);
+  log(`Claude Code integration: ${claude}`);
+  return { ok: true, dshPlugin, codex, claude };
+}
+
+export async function runSetupCli({ argv = process.argv.slice(2), run: actions = {}, log = console.log } = {}) {
+  const action = argv[0];
+  const flags = new Set(argv.slice(1));
+  const dryRun = flags.has('--dry-run');
+  const purge = flags.has('--purge');
+  const install = actions.install ?? setupInstall;
+  const uninstall = actions.uninstall ?? setupUninstall;
+  const status = actions.status ?? setupStatus;
+  try {
+    let result;
+    if (action === 'install') result = await install({ dryRun, log });
+    else if (action === 'uninstall') result = await uninstall({ dryRun, purge, log });
+    else if (action === 'status') result = await status({ log });
+    else {
+      console.error('usage: node scripts/setup.mjs <install|uninstall|status> [--dry-run] [--purge]');
+      return 1;
+    }
+    return result?.ok === false ? 1 : 0;
+  } catch (err) {
+    console.error(`setup failed: ${err?.message ?? err}`);
+    return 1;
+  }
+}
+
+const isMain = process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url) || (
+  process.argv[1] && resolve(join(process.cwd(), process.argv[1])) === fileURLToPath(import.meta.url)
+);
+if (isMain) process.exitCode = await runSetupCli({});

package/scripts/smoke-real.mjs

@@ -0,0 +1,110 @@
+// Real DSH smoke for the v0.3 runtime path. Spawns this branch's MCP server
+// (src/server.mjs) over stdio and drives it with the MCP SDK.
+//   run|spawn : against a LIVE, Crew-owned DSH hub. The hub URL comes from the
+//               DSH_CREW_HUB environment variable and defaults to the dedicated
+//               Crew port 3210; the official ~/.dsh home / web profile is never
+//               read or touched.
+//   standalone: standalone worker path (jobs.mjs) using ONLY explicitly
+//               supplied process-environment credentials
+//               (DEEPSEEK_API_KEY / DEEPSEEK_BASE_URL). This script never reads
+//               ~/.dsh, any official credential/settings store, or key files.
+//               If the credential environment is absent it exits BLOCKED-style.
+// Uses a throwaway temp git repo; never touches the web profile or user repos.
+// Usage: node scripts/smoke-real.mjs <tempGitRepo> [run|spawn|standalone]
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+
+/** Session descriptor for the MCP child. NEVER logs the key. */
+function serverTransport(extraEnv = {}) {
+  return new StdioClientTransport({
+    command: 'node',
+    args: ['src/server.mjs'],
+    cwd: process.cwd(),
+    env: {
+      ...process.env,
+      // Crew-owned hub default; an explicit DSH_CREW_HUB overrides it.
+      DSH_CREW_HUB: process.env.DSH_CREW_HUB ?? 'http://127.0.0.1:3210',
+      ...extraEnv,
+    },
+    stderr: process.stderr,
+  });
+}
+
+const repo = process.argv[2];
+const mode = process.argv[3] ?? 'run';
+const effort = process.argv[4] ?? 'max';
+if (!repo) { console.error('usage: node scripts/smoke-real.mjs <tempGitRepo> [run|spawn|standalone] [effort]'); process.exit(2); }
+
+const TASK = [
+  'In this git repository, create the file src/answer.mjs with exactly the content: `export const answer = 40 + 2;`',
+  'Then run the single-line check: node -e \'const a = require("./src/answer.mjs"); if (a.answer !== 42) process.exit(1); console.log("answer ok");\' (ESM note: use import("./src/answer.mjs") or write .cjs — pick whatever works and run it).',
+  'End your final message with the required Delivery Report:',
+  '## Diff',
+  '- src/answer.mjs — added answer',
+  '## Tests',
+  'PASS — node check — answer is 42',
+  '## Risks',
+  'none',
+].join('\n');
+
+// For standalone mode, use ONLY explicitly supplied process-environment
+// credentials (DEEPSEEK_API_KEY / DEEPSEEK_BASE_URL). This script never reads
+// ~/.dsh or any official credential/settings store. Absent credentials are a
+// BLOCKED outcome, not an excuse to invent or read credentials.
+const standaloneEnv = {};
+if (mode === 'standalone') {
+  const apiKey = process.env.DEEPSEEK_API_KEY;
+  if (!apiKey) {
+    console.error('[smoke] BLOCKED: standalone requires DEEPSEEK_API_KEY in the process environment; credential: ABSENT (no official store will be read)');
+    process.exit(2);
+  }
+  standaloneEnv.DEEPSEEK_API_KEY = apiKey;
+  if (process.env.DEEPSEEK_BASE_URL) standaloneEnv.DEEPSEEK_BASE_URL = process.env.DEEPSEEK_BASE_URL;
+  standaloneEnv.DSH_SANDBOX_MODE = 'workspace-write';
+  console.log('[smoke] standalone: using process-environment credentials (not shown)');
+}
+const transport = serverTransport(standaloneEnv);
+const client = new Client({ name: 'dsh-crew-smoke', version: '1.0.0', requestTimeout: 600 * 1000 });
+
+async function call(name, args, timeoutMs) {
+  const res = await client.callTool({ name, arguments: args }, undefined, timeoutMs ? { timeout: timeoutMs } : undefined);
+  return JSON.parse(res.content.find((c) => c.type === 'text').text);
+}
+
+try {
+  await client.connect(transport);
+  console.log(`[smoke] connected; mode=${mode} cwd=${repo}`);
+  if (mode === 'standalone') {
+    // Force the standalone execution path (session mode) so jobs.mjs handles it.
+    await call('dsh_worker_config', { mode: 'standalone' });
+  }
+
+  if (mode === 'spawn') {
+    const spawnView = await call('dsh_spawn_worker', { task: TASK, role: 'worker', cwd: repo });
+    console.log('[smoke] spawn view:', JSON.stringify(spawnView, null, 2));
+    const wfId = spawnView.workflow_id ?? spawnView.id;
+    // poll a few times for the final result (workflow continues in background)
+    for (let i = 0; i < 24; i++) {
+      await new Promise((r) => setTimeout(r, 5000));
+      const v = await call('dsh_worker_result', { job_id: wfId, wait_seconds: 0 });
+      if (v.status !== 'running') {
+        console.log('[smoke] final (spawn):', JSON.stringify({ id: v.id, role: v.role, phase: v.phase, status: v.status, isolation: v.isolation, attempt: v.attempt, review: v.review?.verdict ?? null, candidate: v.candidate?.changed_files ?? null, error: v.error }, null, 2));
+        await client.close();
+        process.exit(v.status === 'done' ? 0 : 1);
+      }
+      if (i === 23) console.log('[smoke] still running after poll window: ', JSON.stringify(v));
+    }
+    await client.close();
+    process.exit(2);
+  }
+
+    const view = await call('dsh_run_worker', { task: TASK, role: 'worker', cwd: repo, effort, timeout_seconds: 540 }, 560 * 1000);
+  const k = (o) => ({ id: o.id, role: o.role, phase: o.phase, status: o.status, isolation: o.isolation, execution_cwd: o.execution_cwd, base_revision: o.base_revision, attempt: o.attempt, decision: o.decision, review: o.review?.verdict ?? null, candidate_available: o.candidate_available, candidate_changed: o.candidate?.changed_files ?? null, outcome_task: o.outcome?.task_status ?? null, tests: o.outcome?.tests_status ?? null, error: o.error, error_code: o.error_code, cleanup_warning: o.cleanup_warning, primary_dirty_hint: o.primary_workspace_dirty });
+  console.log('[smoke] final (run):', JSON.stringify(k(view), null, 2));
+  await client.close();
+  process.exit(view.status === 'done' ? 0 : 1);
+} catch (err) {
+  console.error('[smoke] ERROR:', err?.message ?? err);
+  try { await client.close(); } catch {}
+  process.exit(3);
+}

package/scripts/smoke.mjs

@@ -0,0 +1,78 @@
+// Smoke test: dispatch one cheap flash job to verify the installation.
+// Probes the hub first (if DSH web instance is running); falls back to
+// standalone mode. Always exercises the path the user actually installed.
+
+import { hubAvailable, hub } from '../src/hub-client.mjs';
+import { readGlobalConfig } from '../src/install/install.mjs';
+
+try {
+  const hubUrl = process.env.DSH_CREW_HUB ?? readGlobalConfig().hub_url;
+  const isHubUp = await hubAvailable();
+
+  if (isHubUp) {
+    // Dispatch through the hub
+    console.log(`hub at ${hubUrl} is reachable, using hub mode`);
+    const job = await hub.spawn({
+      task: 'Reply with exactly the word: ok',
+      tier: 'flash',
+      effort: 'off',
+      cwd: process.cwd(),
+      source: 'smoke',
+    });
+    console.log(`spawned ${job.id} ...`);
+    const result = await hub.get(job.id, 120);
+    if (result.status === 'done') {
+      console.log(`worker replied: ${result.result}`);
+      console.log('smoke test passed — configuration OK');
+    } else if (result.status === 'running') {
+      // The wait returns early once the job settles, so this is a real timeout.
+      console.error(`smoke test failed: job ${job.id} still running after 120s`);
+      console.error('Hint: it is still live in the DSH instance — check its session for what is stuck');
+      process.exit(1);
+    } else {
+      console.error(`smoke test failed: status=${result.status} error=${result.error}`);
+      console.error('Hint: check the DSH instance logs and verify DeepSeek provider credentials');
+      process.exit(1);
+    }
+  } else {
+    // Fall back to standalone mode
+    console.log(`no hub at ${hubUrl}, falling back to standalone mode`);
+
+    try {
+      const { startJob, waitJob, jobView } = await import('../src/jobs.mjs');
+      const job = startJob({
+        task: 'Reply with exactly the word: ok',
+        tier: 'flash',
+        effort: 'off',
+        cwd: process.cwd(),
+      });
+      console.log(`spawned ${job.id} (deepseek-v4-flash) ...`);
+      await waitJob(job.id, 120_000);
+      const v = jobView(job, { withResult: true });
+      if (v.status === 'done') {
+        console.log(`worker replied: ${v.result}`);
+        console.log('smoke test passed — configuration OK');
+      } else {
+        console.error(`smoke test failed: status=${v.status} error=${v.error}`);
+        console.error('Hint: DEEPSEEK_API_KEY missing or invalid in env or ~/.config/dsh-crew/.env, or runtime not installed');
+        process.exit(1);
+      }
+    } catch (err) {
+      // The standalone runtime lives in this package's own node_modules; the
+      // @deepseek-ai/* packages are peerDependencies, so an installed copy of
+      // the plugin has none of them and the dynamic import above is what tells
+      // us so. Anything else here is a dispatch failure, not a missing runtime.
+      if (err.code === 'ERR_MODULE_NOT_FOUND' || err.code === 'MODULE_NOT_FOUND') {
+        console.error('smoke test failed: the standalone runtime is not installed in this copy');
+        console.error('Hint: run "pnpm install" from a source checkout, or start a DSH instance to use hub mode');
+      } else {
+        console.error(`smoke test failed: ${err.message}`);
+        console.error('Hint: DEEPSEEK_API_KEY missing or invalid in env or ~/.config/dsh-crew/.env');
+      }
+      process.exit(1);
+    }
+  }
+} catch (err) {
+  console.error(`smoke test failed: ${err.message}`);
+  process.exit(1);
+}

package/scripts/verify-installer-fix.mjs

@@ -0,0 +1,26 @@
+// Live-verify the fixed installer against a fake home: the settings must
+// point at the repository itself as the marketplace root (no parent-dir
+// assumption), permission rules intact, CLI step skipped in test mode.
+import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { installClaudeCode, uninstallClaudeCode } from '../src/install/install.mjs';
+
+const home = mkdtempSync(join(tmpdir(), 'dsh-crew-fix-test-'));
+try {
+  const r = await installClaudeCode({ home });
+  console.log('actions:', r.actions.slice(0, 3).join(' | '));
+  const s = JSON.parse(readFileSync(join(home, '.claude', 'settings.json'), 'utf8'));
+  const mp = s.extraKnownMarketplaces['dsh-crew'];
+  const cwd = process.cwd().replaceAll('\\', '/');
+  const mpPath = String(mp?.source?.path ?? '').replaceAll('\\', '/');
+  console.log('marketplace path is repo root:', mpPath === cwd, '->', mpPath);
+  console.log('permission rules:', (s.permissions?.allow ?? []).filter((x) => String(x).includes('dsh-crew')).length);
+  console.log('cli step skipped in test mode:', r.actions.some((a) => a.includes('test mode')));
+  if (mpPath !== cwd) throw new Error('marketplace not pointing at repo root');
+  const u = await uninstallClaudeCode({ home });
+  console.log('uninstall ok:', u.ok);
+} finally {
+  rmSync(home, { recursive: true, force: true });
+}
+console.log('INSTALLER FIX VERIFIED');