synabun 2026.4.21 → 2026.4.25-beta.1

package/mcp-server/src/tools/browser-interact.ts

@@ -13,7 +13,7 @@ const returnSnapshotField = z.object({
 
 const tabIdField = z.string().optional().describe('Target a specific tab within the session. Auto-resolved from environment if omitted.');
 
-function formatClickHints(result: Record<string, unknown>): string {
+function formatClickHints(result: Record<string, unknown>): string {
   const hints = result.hints as Array<{ role: string; text: string; ariaLabel: string; placeholder: string; selector?: string; nth?: number }> | undefined;
   if (!hints?.length) return '';
   const heading = result.hintsLabel as string | undefined;
@@ -24,8 +24,13 @@ function formatClickHints(result: Record<string, unknown>): string {
     msg += `\n- ${h.role}: "${label.substring(0, 60)}"${sel}`;
   }
   msg += '\n\nRetry browser_click/fill with one of the selectors above, or use browser_snapshot with mode="interactive".';
-  return msg;
-}
+  return msg;
+}
+
+function locationSuffix(result: Record<string, unknown>): string {
+  if (ni.isBrowserCompactMode()) return '';
+  return result.url ? ` — ${result.url} "${result.title}"` : '';
+}
 
 // ── browser_click ──
 
@@ -61,7 +66,7 @@ export async function handleBrowserClick(args: {
   if (result.error) return text(`Click failed: ${result.error}${formatClickHints(result)}`);
 
   const healed = result.healed ? ' (auto-healed via textHint)' : '';
-  let msg = `Clicked "${args.selector}"${healed} — now at ${result.url} "${result.title}"`;
+  let msg = `Clicked "${args.selector}"${healed}${locationSuffix(result)}`;
   if (args.returnSnapshot) {
     const snap = formatInlineSnapshot(result, {
       mode: args.returnSnapshot.mode,
@@ -94,37 +99,36 @@ export async function handleBrowserFill(args: { selector: string; value: string;
   const result = await ni.fill(resolved.sessionId, args.selector, args.value, args.nthMatch, resolved.tabId, args.textHint);
   if (result.error) return text(`Fill failed: ${result.error}${formatClickHints(result)}`);
 
-  const location = result.url ? ` — ${result.url} "${result.title}"` : '';
-  const healed = result.healed ? ' (auto-healed via textHint)' : '';
-  return text(`Filled "${args.selector}"${healed} with "${args.value.slice(0, 100)}"${location}`);
-}
+  const healed = result.healed ? ' (auto-healed via textHint)' : '';
+  return text(`Filled "${args.selector}"${healed} with "${args.value.slice(0, 100)}"${locationSuffix(result)}`);
+}
 
 // ── browser_type ──
 
 export const browserTypeSchema = {
   selector: z.string().optional().describe('Playwright selector for the element to type into. If omitted, types into the currently focused element using keyboard events.'),
   text: z.string().describe('The text to type character by character (appends to existing content).'),
-  nthMatch: z.coerce.number().int().min(0).optional().describe('If the selector matches multiple elements, type into the Nth (0-indexed).'),
-  textHint: z.string().optional().describe('Optional auto-heal hint. If the primary selector matches 0 elements, server retries once with role=*[name~="<textHint>"] before failing.'),
-  sessionId: z.string().optional().describe('Browser session ID. If omitted, auto-selects the only open session.'),
-  tabId: tabIdField,
-};
+  nthMatch: z.coerce.number().int().min(0).optional().describe('If the selector matches multiple elements, type into the Nth (0-indexed).'),
+  textHint: z.string().optional().describe('Optional auto-heal hint. If the primary selector matches 0 elements, server retries once with role=*[name~="<textHint>"] before failing.'),
+  mode: z.enum(['sequential', 'insert']).optional().describe('Typing strategy. "sequential" sends key events. "insert" bulk-inserts text faster but may skip keydown handlers. Codex fast mode defaults to insert.'),
+  sessionId: z.string().optional().describe('Browser session ID. If omitted, auto-selects the only open session.'),
+  tabId: tabIdField,
+};
 
 export const browserTypeDescription =
   'Type text character-by-character (simulates real keystrokes; appends). Provide a selector to target, or omit to type into the focused element. Prefer over browser_fill for contenteditable/rich-text editors. Call browser_cheatsheet for per-platform compose selectors.';
 
-export async function handleBrowserType(args: { selector?: string; text: string; nthMatch?: number; textHint?: string; sessionId?: string; tabId?: string }) {
-  const resolved = await ni.resolveSession(args.sessionId, undefined, args.tabId);
-  if ('error' in resolved) return text(resolved.error);
-
-  const result = await ni.type(resolved.sessionId, args.selector ?? null, args.text, args.nthMatch, resolved.tabId, args.textHint);
-  if (result.error) return text(`Type failed: ${result.error}${formatClickHints(result)}`);
-
-  const target = args.selector ? `"${args.selector}"` : 'focused element';
-  const location = result.url ? ` — ${result.url} "${result.title}"` : '';
-  const healed = result.healed ? ' (auto-healed via textHint)' : '';
-  return text(`Typed "${args.text.slice(0, 100)}" into ${target}${healed}${location}`);
-}
+export async function handleBrowserType(args: { selector?: string; text: string; nthMatch?: number; textHint?: string; mode?: 'sequential' | 'insert'; sessionId?: string; tabId?: string }) {
+  const resolved = await ni.resolveSession(args.sessionId, undefined, args.tabId);
+  if ('error' in resolved) return text(resolved.error);
+
+  const result = await ni.type(resolved.sessionId, args.selector ?? null, args.text, args.nthMatch, resolved.tabId, args.textHint, args.mode);
+  if (result.error) return text(`Type failed: ${result.error}${formatClickHints(result)}`);
+
+  const target = args.selector ? `"${args.selector}"` : 'focused element';
+  const healed = result.healed ? ' (auto-healed via textHint)' : '';
+  return text(`Typed "${args.text.slice(0, 100)}" into ${target}${healed}${locationSuffix(result)}`);
+}
 
 // ── browser_hover ──
 
@@ -146,10 +150,9 @@ export async function handleBrowserHover(args: { selector: string; nthMatch?: nu
   const result = await ni.hover(resolved.sessionId, args.selector, args.nthMatch, resolved.tabId, args.textHint);
   if (result.error) return text(`Hover failed: ${result.error}${formatClickHints(result)}`);
 
-  const location = result.url ? ` — ${result.url} "${result.title}"` : '';
-  const healed = result.healed ? ' (auto-healed via textHint)' : '';
-  return text(`Hovered over "${args.selector}"${healed}${location}`);
-}
+  const healed = result.healed ? ' (auto-healed via textHint)' : '';
+  return text(`Hovered over "${args.selector}"${healed}${locationSuffix(result)}`);
+}
 
 // ── browser_select ──
 
@@ -171,9 +174,8 @@ export async function handleBrowserSelect(args: { selector: string; value: strin
   const result = await ni.selectOption(resolved.sessionId, args.selector, args.value, args.nthMatch, resolved.tabId);
   if (result.error) return text(`Select failed: ${result.error}${formatClickHints(result)}`);
 
-  const location = result.url ? ` — ${result.url} "${result.title}"` : '';
-  return text(`Selected "${args.value}" in "${args.selector}"${location}`);
-}
+  return text(`Selected "${args.value}" in "${args.selector}"${locationSuffix(result)}`);
+}
 
 // ── browser_press ──
 
@@ -193,9 +195,8 @@ export async function handleBrowserPress(args: { key: string; sessionId?: string
   const result = await ni.pressKey(resolved.sessionId, args.key, resolved.tabId);
   if (result.error) return text(`Press failed: ${result.error}`);
 
-  const location = result.url ? ` — ${result.url} "${result.title}"` : '';
-  return text(`Pressed "${args.key}"${location}`);
-}
+  return text(`Pressed "${args.key}"${locationSuffix(result)}`);
+}
 
 // ── browser_scroll ──
 
@@ -236,7 +237,7 @@ export async function handleBrowserScroll(args: {
   if (result.error) return text(`Scroll failed: ${result.error}`);
 
   const target = args.selector ? `"${args.selector}"` : 'page';
-  let msg = `Scrolled ${args.direction} ${args.distance ?? 500}px in ${target} — now at ${result.url} "${result.title}"`;
+  let msg = `Scrolled ${args.direction} ${args.distance ?? 500}px in ${target}${locationSuffix(result)}`;
   if (args.returnSnapshot) {
     const snap = formatInlineSnapshot(result, {
       mode: args.returnSnapshot.mode,
@@ -268,5 +269,5 @@ export async function handleBrowserUpload(args: { selector: string; filePaths: s
   const result = await ni.upload(resolved.sessionId, args.selector, args.filePaths, args.nthMatch, resolved.tabId);
   if (result.error) return text(`Upload failed: ${result.error}${formatClickHints(result)}`);
 
-  return text(`Uploaded ${args.filePaths.length} file(s) via "${args.selector}" — now at ${result.url} "${result.title}"`);
-}
+  return text(`Uploaded ${args.filePaths.length} file(s) via "${args.selector}"${locationSuffix(result)}`);
+}

package/mcp-server/src/tools/browser-navigate.ts

@@ -13,6 +13,14 @@ const returnSnapshotField = z.object({
   format: z.enum(['text', 'json']).optional(),
 }).optional().describe('If set, the server also captures a snapshot after the action and returns it in the same response — one round-trip instead of two. Matches browser_snapshot params.');
 
+function formatBrowserLocation(result: Record<string, unknown>, action: string): string {
+  if (ni.isBrowserCompactMode()) {
+    const title = typeof result.title === 'string' && result.title ? ` "${result.title}"` : '';
+    return `${action}${title}`;
+  }
+  return `${action} ${result.url} — "${result.title}"`;
+}
+
 // ── browser_navigate ──
 
 export const browserNavigateSchema = {
@@ -42,7 +50,7 @@ export async function handleBrowserNavigate(args: {
   const result = await ni.navigate(resolved.sessionId, args.url, resolved.tabId, rs);
   if (result.error) return text(`Navigation failed: ${result.error}`);
 
-  let msg = `Navigated to ${result.url} — "${result.title}"`;
+  let msg = formatBrowserLocation(result, 'Navigated');
   if (args.returnSnapshot) {
     const snap = formatInlineSnapshot(result, {
       mode: args.returnSnapshot.mode,
@@ -70,7 +78,7 @@ export async function handleBrowserGoBack(args: { sessionId?: string; tabId?: st
   const result = await ni.goBack(resolved.sessionId, resolved.tabId);
   if (result.error) return text(`Go back failed: ${result.error}`);
 
-  return text(`Went back to ${result.url} — "${result.title}"`);
+  return text(formatBrowserLocation(result, 'Went back to'));
 }
 
 // ── browser_go_forward ──
@@ -89,7 +97,7 @@ export async function handleBrowserGoForward(args: { sessionId?: string; tabId?:
   const result = await ni.goForward(resolved.sessionId, resolved.tabId);
   if (result.error) return text(`Go forward failed: ${result.error}`);
 
-  return text(`Went forward to ${result.url} — "${result.title}"`);
+  return text(formatBrowserLocation(result, 'Went forward to'));
 }
 
 // ── browser_reload ──
@@ -108,5 +116,5 @@ export async function handleBrowserReload(args: { sessionId?: string; tabId?: st
   const result = await ni.reload(resolved.sessionId, resolved.tabId);
   if (result.error) return text(`Reload failed: ${result.error}`);
 
-  return text(`Reloaded — now at ${result.url} "${result.title}"`);
+  return text(formatBrowserLocation(result, 'Reloaded'));
 }

package/mcp-server/src/tools/loop.ts

@@ -53,13 +53,17 @@ function resolveSessionId(explicit?: string): string | null {
     } catch { /* dir read failed */ }
   }
 
-  // Fallback: scan for any active loop file (legacy — no terminal scoping)
+  // Fallback: STRICT — only match legacy loops without terminalSessionId.
+  // Previously this scanned ALL active loops and returned the first, which
+  // let one Claude session claim another's scheduled loop when env was unset.
+  // Server-launched loops always set terminalSessionId; manual/legacy loops
+  // (created without server) don't, so they remain claimable here.
   try {
-    const files = readdirSync(LOOP_DIR).filter(f => f.endsWith('.json'));
+    const files = readdirSync(LOOP_DIR).filter(f => f.endsWith('.json') && !f.startsWith('pending-'));
     for (const file of files) {
       try {
         const data = JSON.parse(readFileSync(join(LOOP_DIR, file), 'utf-8'));
-        if (data?.active) return file.replace('.json', '');
+        if (data?.active && !data.terminalSessionId) return file.replace('.json', '');
       } catch { /* skip corrupt files */ }
     }
   } catch { /* dir read failed */ }

package/mcp-server/src/tools/profile.ts

@@ -14,13 +14,31 @@ export const profileSchema = {
 export const profileDescription =
   'Switch MCP tool profiles at runtime without restarting. Use "get" to see current profile and available presets. Use "set" to enable/disable tool groups dynamically — the client will be notified of the tool list change.';
 
+const ALWAYS_ON_TOOL_COUNT = 10;
+const GROUP_TOOL_ESTIMATES: Record<string, number> = {
+  git: 1,
+  image: 1,
+  whiteboard: 3,
+  card: 4,
+  tictactoe: 2,
+  browser: 20,
+  browser_twitter: 1,
+  browser_facebook: 1,
+  browser_tiktok: 4,
+  browser_whatsapp: 2,
+  browser_instagram: 5,
+  browser_linkedin: 8,
+  leonardo: 5,
+  discord: 8,
+};
+
 export async function handleProfile(args: { action: string; profile?: string }) {
   if (args.action === 'get') {
     const { profile, activeGroups } = getActiveProfile();
     const presets = Object.entries(PROFILE_PRESETS).map(([name, groups]) => ({
       name,
       groups,
-      toolEstimate: name === 'core' ? '~11' : name === 'standard' ? '~22' : name === 'browser' ? '~61' : '~74',
+      toolEstimate: `~${ALWAYS_ON_TOOL_COUNT + groups.reduce((sum, group) => sum + (GROUP_TOOL_ESTIMATES[group] || 0), 0)}`,
     }));
     return text(JSON.stringify({
       currentProfile: profile,

package/neural-interface/lib/loop-logger.js

@@ -0,0 +1,103 @@
+/**
+ * Per-loop file logger keyed by terminalSessionId.
+ *
+ * Writes to data/logs/loop-{terminalSessionId}.log.
+ * Format: ISO timestamp | tag | message | JSON metadata
+ * Mirrors to console with [loop:{tag}] prefix so existing console workflow still works.
+ *
+ * Auto-rotates: keeps newest 50 logfiles, deletes older.
+ */
+
+import { existsSync, mkdirSync, appendFileSync, readdirSync, statSync, unlinkSync } from 'node:fs';
+import { resolve, join } from 'node:path';
+
+const PACKAGE_ROOT = resolve(new URL('..', import.meta.url).pathname, '..');
+const DATA_HOME = process.env.SYNABUN_DATA_HOME || PACKAGE_ROOT;
+const LOG_DIR = resolve(DATA_HOME, 'data', 'logs');
+const MAX_LOG_FILES = 50;
+
+let _ensuredDir = false;
+let _rotated = false;
+
+function ensureDir() {
+  if (_ensuredDir) return;
+  try {
+    if (!existsSync(LOG_DIR)) mkdirSync(LOG_DIR, { recursive: true });
+    _ensuredDir = true;
+  } catch (err) {
+    console.warn('[loop-logger] mkdir failed:', err.message);
+  }
+}
+
+function rotateOnce() {
+  if (_rotated) return;
+  _rotated = true;
+  try {
+    if (!existsSync(LOG_DIR)) return;
+    const files = readdirSync(LOG_DIR)
+      .filter(f => f.startsWith('loop-') && f.endsWith('.log'))
+      .map(f => {
+        const fp = join(LOG_DIR, f);
+        let mtime = 0;
+        try { mtime = statSync(fp).mtimeMs; } catch { /* ok */ }
+        return { f, fp, mtime };
+      })
+      .sort((a, b) => b.mtime - a.mtime);
+    if (files.length <= MAX_LOG_FILES) return;
+    for (const entry of files.slice(MAX_LOG_FILES)) {
+      try { unlinkSync(entry.fp); } catch { /* ok */ }
+    }
+  } catch (err) {
+    console.warn('[loop-logger] rotate failed:', err.message);
+  }
+}
+
+export function loopLogPath(terminalSessionId) {
+  if (!terminalSessionId) return null;
+  return resolve(LOG_DIR, `loop-${terminalSessionId}.log`);
+}
+
+/**
+ * Append one structured log entry to the per-loop file AND mirror to console.
+ * @param {string|null} terminalSessionId — if null, only logs to console
+ * @param {string} tag — short identifier (launch, driver, pty, hook, ui, etc.)
+ * @param {string} msg — human-readable message
+ * @param {object} [meta] — additional structured data (will be JSON-stringified)
+ */
+export function loopLog(terminalSessionId, tag, msg, meta = undefined) {
+  const ts = new Date().toISOString();
+  const safeMeta = (meta && Object.keys(meta).length > 0) ? safeJson(meta) : '';
+  const line = `${ts} | ${tag} | ${msg}${safeMeta ? ' | ' + safeMeta : ''}\n`;
+
+  // Console mirror
+  console.log(`[loop:${tag}] ${msg}${safeMeta ? ' ' + safeMeta : ''}`);
+
+  if (!terminalSessionId) return;
+
+  ensureDir();
+  rotateOnce();
+  try {
+    appendFileSync(loopLogPath(terminalSessionId), line);
+  } catch (err) {
+    console.warn(`[loop-logger] append failed for ${terminalSessionId}:`, err.message);
+  }
+}
+
+function safeJson(obj) {
+  try {
+    return JSON.stringify(obj, (_k, v) => {
+      if (typeof v === 'string' && v.length > 800) return v.slice(0, 800) + `…(+${v.length - 800})`;
+      return v;
+    });
+  } catch {
+    return '<unserializable>';
+  }
+}
+
+/**
+ * Convenience wrapper for hooks that may not know terminalSessionId yet.
+ * Reads SYNABUN_TERMINAL_SESSION env var.
+ */
+export function loopLogFromEnv(tag, msg, meta) {
+  loopLog(process.env.SYNABUN_TERMINAL_SESSION || null, tag, msg, meta);
+}

package/neural-interface/lib/mcp-installer.js

@@ -331,6 +331,115 @@ export function detectServer(repoPath) {
   return { ok: true, detected, attempts };
 }
 
+// OS-aware install hints for self-fetching runtime binaries the detected
+// command depends on. Used by the preflight check in checkSelfFetcherAvailable().
+const SELF_FETCHER_INSTALL_HINTS = {
+  uvx:  { mac: 'brew install uv', linux: 'curl -LsSf https://astral.sh/uv/install.sh | sh', win: 'winget install astral-sh.uv  or  powershell -c "irm https://astral.sh/uv/install.ps1 | iex"' },
+  uv:   { mac: 'brew install uv', linux: 'curl -LsSf https://astral.sh/uv/install.sh | sh', win: 'winget install astral-sh.uv  or  powershell -c "irm https://astral.sh/uv/install.ps1 | iex"' },
+  pipx: { mac: 'brew install pipx', linux: 'python3 -m pip install --user pipx && pipx ensurepath', win: 'python -m pip install --user pipx && pipx ensurepath' },
+  npx:  { mac: 'brew install node', linux: 'install Node.js (https://nodejs.org)', win: 'winget install OpenJS.NodeJS' },
+  bunx: { mac: 'brew install oven-sh/bun/bun', linux: 'curl -fsSL https://bun.sh/install | bash', win: 'powershell -c "irm bun.sh/install.ps1 | iex"' },
+  bun:  { mac: 'brew install oven-sh/bun/bun', linux: 'curl -fsSL https://bun.sh/install | bash', win: 'powershell -c "irm bun.sh/install.ps1 | iex"' },
+  pnpm: { mac: 'brew install pnpm', linux: 'npm install -g pnpm', win: 'npm install -g pnpm' },
+  yarn: { mac: 'brew install yarn', linux: 'npm install -g yarn', win: 'npm install -g yarn' },
+};
+
+function installHintFor(cmd) {
+  const h = SELF_FETCHER_INSTALL_HINTS[cmd];
+  if (!h) return null;
+  const platform = process.platform; // 'darwin' | 'linux' | 'win32'
+  if (platform === 'darwin') return h.mac;
+  if (platform === 'win32') return h.win;
+  return h.linux;
+}
+
+// Probe whether a command exists on the user's PATH. OS-agnostic.
+// On Windows uses `where`, elsewhere `command -v`. Handles .exe resolution on
+// Windows (`where uvx` finds `uvx.exe`).
+export function checkCommandOnPath(cmd) {
+  if (!cmd) return false;
+  const isWin = process.platform === 'win32';
+  const probeCmd = isWin ? 'where' : 'sh';
+  const probeArgs = isWin ? [cmd] : ['-c', `command -v ${cmd}`];
+  try {
+    const r = spawnSync(probeCmd, probeArgs, { stdio: 'ignore', timeout: 5000 });
+    return r.status === 0;
+  } catch { return false; }
+}
+
+// For self-fetching commands (uvx/npx/pipx/...) verify the runtime is available.
+// Returns { available, command, installHint } so the install endpoint can warn
+// the user before registering something that will fail at launch.
+export function checkSelfFetcherAvailable(detected) {
+  if (!detected || !detected.command) return { available: true, command: null, installHint: null };
+  const cmd = String(detected.command).toLowerCase();
+  const available = checkCommandOnPath(detected.command);
+  return {
+    available,
+    command: detected.command,
+    installHint: available ? null : installHintFor(cmd),
+  };
+}
+
+// Returns true if the detected command fetches its package at runtime
+// (uvx / uv run / npx / pipx / bunx / dlx) so local dependency install is unnecessary.
+export function commandSelfFetches(detected) {
+  if (!detected || !detected.command) return false;
+  const cmd = String(detected.command).toLowerCase();
+  const args = Array.isArray(detected.args) ? detected.args.map(a => String(a).toLowerCase()) : [];
+  if (cmd === 'uvx' || cmd === 'pipx' || cmd === 'bunx') return true;
+  if (cmd === 'npx') return true;
+  if (cmd === 'uv' && args[0] === 'run') return true;
+  if (cmd === 'pnpm' && args[0] === 'dlx') return true;
+  if (cmd === 'yarn' && args[0] === 'dlx') return true;
+  return false;
+}
+
+function detectClaudePlugin(repoPath) {
+  const manifestPath = join(repoPath, '.claude-plugin', 'plugin.json');
+  if (!existsSync(manifestPath)) return null;
+  const manifest = tryReadJson(manifestPath);
+  if (!manifest || !manifest.name) return null;
+  const marketplacePath = join(repoPath, '.claude-plugin', 'marketplace.json');
+  const marketplace = existsSync(marketplacePath) ? tryReadJson(marketplacePath) : null;
+  const hooks = manifest.hooks && typeof manifest.hooks === 'object' ? Object.keys(manifest.hooks) : [];
+  return { manifest, marketplace, hooks };
+}
+
+function scanHints(repoPath) {
+  const hints = [];
+  if (existsSync(join(repoPath, '.claude-plugin', 'plugin.json'))) hints.push('claude-plugin');
+  if (existsSync(join(repoPath, '.codex'))) hints.push('codex');
+  if (existsSync(join(repoPath, 'gemini-extension.json'))) hints.push('gemini');
+  if (existsSync(join(repoPath, '.cursor'))) hints.push('cursor');
+  if (existsSync(join(repoPath, '.windsurf'))) hints.push('windsurf');
+  return hints;
+}
+
+// Classify a cloned repo. MCP wins if both present (preserves existing behavior).
+export function classifyRepo(repoPath) {
+  if (!existsSync(repoPath)) return { ok: false, kind: 'unknown', error: `Repo path does not exist: ${repoPath}` };
+  const hints = scanHints(repoPath);
+  const mcp = detectServer(repoPath);
+  if (mcp.ok) {
+    const out = { ok: true, kind: 'mcp', detected: mcp.detected, attempts: mcp.attempts, hints };
+    const plugin = detectClaudePlugin(repoPath);
+    if (plugin) out.alsoClaudePlugin = { manifest: plugin.manifest, marketplace: plugin.marketplace };
+    return out;
+  }
+  const plugin = detectClaudePlugin(repoPath);
+  if (plugin) {
+    return { ok: true, kind: 'claude-plugin', plugin: { manifest: plugin.manifest, marketplace: plugin.marketplace, hooks: plugin.hooks }, hints };
+  }
+  return {
+    ok: false,
+    kind: 'unknown',
+    error: "Couldn't identify the repo type. Looked for: mcp.json / smithery.*, package.json, pyproject.toml, README mcpServers block, and .claude-plugin/plugin.json.",
+    hints,
+    mcpError: mcp.error,
+  };
+}
+
 export async function installDependencies({ dataHome, name, repoPath, onLine }) {
   const pm = detectPackageManager(repoPath);
   const hasPkg = existsSync(join(repoPath, 'package.json'));