clawmini 0.0.8 → 0.0.9

package/src/cli/commands/serve.test.ts

@@ -0,0 +1,67 @@
+import { describe, it, expect } from 'vitest';
+import { resolveEnabledServices } from './serve.js';
+
+describe('resolveEnabledServices', () => {
+  it('defaults to daemon + web when no adapter configs are present', () => {
+    const result = resolveEnabledServices({
+      adapterConfigPresent: { 'adapter-discord': false, 'adapter-google-chat': false },
+    });
+    expect(result).toEqual(['daemon', 'web']);
+  });
+
+  it('includes discord when its config file is present', () => {
+    const result = resolveEnabledServices({
+      adapterConfigPresent: { 'adapter-discord': true, 'adapter-google-chat': false },
+    });
+    expect(result).toEqual(['daemon', 'web', 'adapter-discord']);
+  });
+
+  it('includes both adapters when both configs are present', () => {
+    const result = resolveEnabledServices({
+      adapterConfigPresent: { 'adapter-discord': true, 'adapter-google-chat': true },
+    });
+    expect(result).toEqual(['daemon', 'web', 'adapter-discord', 'adapter-google-chat']);
+  });
+
+  it('honors --only as an explicit subset', () => {
+    const result = resolveEnabledServices({
+      only: 'daemon,web',
+      adapterConfigPresent: { 'adapter-discord': true, 'adapter-google-chat': true },
+    });
+    expect(result).toEqual(['daemon', 'web']);
+  });
+
+  it('resolves adapter short names in --only', () => {
+    const result = resolveEnabledServices({
+      only: 'discord,google-chat',
+      adapterConfigPresent: { 'adapter-discord': false, 'adapter-google-chat': false },
+    });
+    expect(result).toEqual(['adapter-discord', 'adapter-google-chat']);
+  });
+
+  it('filters via --exclude when no --only is given', () => {
+    const result = resolveEnabledServices({
+      exclude: 'web,discord',
+      adapterConfigPresent: { 'adapter-discord': true, 'adapter-google-chat': true },
+    });
+    expect(result).toEqual(['daemon', 'adapter-google-chat']);
+  });
+
+  it('applies --exclude on top of --only', () => {
+    const result = resolveEnabledServices({
+      only: 'daemon,web,discord',
+      exclude: 'discord',
+      adapterConfigPresent: { 'adapter-discord': true, 'adapter-google-chat': false },
+    });
+    expect(result).toEqual(['daemon', 'web']);
+  });
+
+  it('throws on unknown service name', () => {
+    expect(() =>
+      resolveEnabledServices({
+        only: 'nope',
+        adapterConfigPresent: { 'adapter-discord': false, 'adapter-google-chat': false },
+      })
+    ).toThrow(/Unknown service/);
+  });
+});

package/src/cli/commands/serve.ts

@@ -0,0 +1,284 @@
+import { Command } from 'commander';
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import net from 'node:net';
+import path from 'node:path';
+
+import { getClawminiDir, getSocketPath } from '../../shared/workspace.js';
+import { installBuiltinPolicies } from '../builtin-policies.js';
+import { exportLiteToAllEnvironments } from '../../shared/lite.js';
+import { ensureDefaultPoliciesFile, refreshAllAgents } from './up.js';
+import { getDiscordConfigPath } from '../../adapter-discord/config.js';
+import { getGoogleChatConfigPath } from '../../adapter-google-chat/config.js';
+import { startSupervisorControl } from '../supervisor-actions.js';
+import { getControlSocketPath } from '../supervisor-control.js';
+import {
+  getSupervisorPidPath,
+  readSupervisorPid,
+  removeSupervisorPid,
+  writeSupervisorPid,
+} from '../supervisor-pid.js';
+import { Supervisor, type ServiceName } from '../supervisor.js';
+
+const ALL_SERVICES: ServiceName[] = ['daemon', 'web', 'adapter-discord', 'adapter-google-chat'];
+
+const SERVICE_ALIASES: Record<string, ServiceName> = {
+  daemon: 'daemon',
+  web: 'web',
+  discord: 'adapter-discord',
+  'adapter-discord': 'adapter-discord',
+  'google-chat': 'adapter-google-chat',
+  'adapter-google-chat': 'adapter-google-chat',
+};
+
+interface ResolveInput {
+  only?: string | undefined;
+  exclude?: string | undefined;
+  adapterConfigPresent?: Partial<Record<ServiceName, boolean>> | undefined;
+}
+
+// Exported for unit tests.
+export function resolveEnabledServices(opts: ResolveInput): ServiceName[] {
+  const parseList = (csv: string | undefined): ServiceName[] => {
+    if (!csv) return [];
+    const names = csv
+      .split(',')
+      .map((s) => s.trim())
+      .filter(Boolean);
+    return names.map((name) => {
+      const resolved = SERVICE_ALIASES[name];
+      if (!resolved) {
+        throw new Error(
+          `Unknown service: '${name}'. Valid: ${Object.keys(SERVICE_ALIASES).join(', ')}`
+        );
+      }
+      return resolved;
+    });
+  };
+
+  const configPresent: Record<ServiceName, boolean> = {
+    daemon: true,
+    web: true,
+    'adapter-discord': false,
+    'adapter-google-chat': false,
+    ...(opts.adapterConfigPresent ?? {}),
+  };
+
+  const excluded = new Set(parseList(opts.exclude));
+
+  const only = parseList(opts.only);
+  if (only.length > 0) {
+    return only.filter((n) => !excluded.has(n));
+  }
+
+  return ALL_SERVICES.filter((n) => configPresent[n] && !excluded.has(n));
+}
+
+async function runPreStart(): Promise<void> {
+  await installBuiltinPolicies();
+  ensureDefaultPoliciesFile();
+  await exportLiteToAllEnvironments();
+  await refreshAllAgents();
+}
+
+interface ServeOptions {
+  detach?: boolean;
+  only?: string;
+  exclude?: string;
+}
+
+async function runForeground(enabled: ServiceName[]): Promise<void> {
+  const logDir = path.join(getClawminiDir(), 'logs');
+  const supervisor = new Supervisor(logDir);
+
+  writeSupervisorPid(process.pid);
+  process.on('exit', () => {
+    removeSupervisorPid();
+    try {
+      fs.unlinkSync(getControlSocketPath());
+    } catch {
+      // best-effort cleanup
+    }
+  });
+
+  const onSignal = () => {
+    void supervisor.shutdown(0);
+  };
+  process.on('SIGINT', onSignal);
+  process.on('SIGTERM', onSignal);
+
+  if (enabled.includes('daemon')) {
+    process.stderr.write('[supervisor] starting daemon...\n');
+    await supervisor.startService('daemon');
+    await supervisor.waitForDaemonSocket();
+    process.stderr.write('[supervisor] daemon ready\n');
+  }
+
+  for (const name of enabled) {
+    if (name === 'daemon') continue;
+    await supervisor.startService(name);
+  }
+
+  startSupervisorControl(supervisor);
+
+  process.stderr.write(`[supervisor] running: ${enabled.join(', ')}\n`);
+  process.stderr.write("[supervisor] press Ctrl-C to stop (or run 'clawmini down' elsewhere)\n");
+}
+
+function isSocketLive(socketPath: string): Promise<boolean> {
+  return new Promise((resolve) => {
+    const client = net.createConnection({ path: socketPath });
+    client.on('connect', () => {
+      client.destroy();
+      resolve(true);
+    });
+    client.on('error', () => resolve(false));
+  });
+}
+
+function printSupervisorLogTail(supLog: string, fromOffset: number): void {
+  if (!fs.existsSync(supLog)) return;
+  const size = fs.statSync(supLog).size;
+  if (size <= fromOffset) return;
+  const fd = fs.openSync(supLog, 'r');
+  try {
+    const len = size - fromOffset;
+    const buf = Buffer.alloc(len);
+    fs.readSync(fd, buf, 0, len, fromOffset);
+    const text = buf.toString('utf-8');
+    process.stderr.write('--- supervisor.log ---\n');
+    process.stderr.write(text);
+    if (!text.endsWith('\n')) process.stderr.write('\n');
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+
+async function runDetached(args: string[]): Promise<never> {
+  const clawDir = getClawminiDir();
+  const logDir = path.join(clawDir, 'logs');
+  if (!fs.existsSync(logDir)) fs.mkdirSync(logDir, { recursive: true });
+  const supLog = path.join(logDir, 'supervisor.log');
+  const supLogOffset = fs.existsSync(supLog) ? fs.statSync(supLog).size : 0;
+  const outFd = fs.openSync(supLog, 'a');
+
+  // Drop any stale pid file so we can detect the new child writing one.
+  removeSupervisorPid();
+
+  const childArgs = args.filter((a) => a !== '--detach' && a !== '-d');
+  const child = spawn(process.execPath, childArgs, {
+    detached: true,
+    stdio: ['ignore', outFd, outFd],
+    cwd: process.cwd(),
+    env: process.env,
+  });
+  child.unref();
+  fs.closeSync(outFd);
+
+  const pidPath = getSupervisorPidPath();
+  const socketPath = getSocketPath();
+  const STARTUP_TIMEOUT_MS = 30_000;
+  const deadline = Date.now() + STARTUP_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    if (child.exitCode !== null || child.signalCode !== null) {
+      console.error(
+        `clawmini serve exited during startup (code=${child.exitCode}, signal=${child.signalCode}).`
+      );
+      printSupervisorLogTail(supLog, supLogOffset);
+      process.exit(1);
+    }
+    if (fs.existsSync(pidPath) && fs.existsSync(socketPath)) {
+      console.log(`Started clawmini supervisor in background (pid ${child.pid}).`);
+      console.log(`  Logs:   clawmini logs -f`);
+      console.log(`  Stop:   clawmini down`);
+      process.exit(0);
+    }
+    await new Promise((r) => setTimeout(r, 100));
+  }
+
+  console.error(`clawmini serve did not become ready within ${STARTUP_TIMEOUT_MS / 1000}s.`);
+  printSupervisorLogTail(supLog, supLogOffset);
+  process.exit(1);
+}
+
+export const serveCmd = new Command('serve')
+  .description('Run daemon, web UI, and configured adapters under one supervisor')
+  .option('-d, --detach', 'Run in the background; logs go to .clawmini/logs/')
+  .option('--only <services>', 'Comma-separated subset to run (daemon,web,discord,google-chat)')
+  .option('--exclude <services>', 'Comma-separated services to skip')
+  .action(async (options: ServeOptions) => {
+    const clawDir = getClawminiDir();
+    if (!fs.existsSync(clawDir)) {
+      console.error(`Not a clawmini workspace (no ${clawDir}). Run 'clawmini init' first.`);
+      process.exit(1);
+    }
+
+    const existingSupervisorPid = readSupervisorPid();
+    if (existingSupervisorPid) {
+      console.error(
+        `clawmini serve is already running (pid ${existingSupervisorPid}). Run 'clawmini down' to stop it.`
+      );
+      process.exit(1);
+    }
+
+    const socketPath = getSocketPath();
+    if (fs.existsSync(socketPath)) {
+      if (await isSocketLive(socketPath)) {
+        console.error(
+          "A clawmini daemon is already running (socket present). Run 'clawmini down' before 'clawmini serve'."
+        );
+        process.exit(1);
+      }
+      // Socket file is left over from a crashed/killed daemon — remove it
+      // so we can bind cleanly.
+      try {
+        fs.unlinkSync(socketPath);
+        process.stderr.write(`[supervisor] removed stale socket at ${socketPath}\n`);
+      } catch (err) {
+        console.error(
+          `Failed to remove stale socket at ${socketPath}: ${err instanceof Error ? err.message : String(err)}`
+        );
+        process.exit(1);
+      }
+    }
+
+    let enabled: ServiceName[];
+    try {
+      enabled = resolveEnabledServices({
+        only: options.only,
+        exclude: options.exclude,
+        adapterConfigPresent: {
+          'adapter-discord': fs.existsSync(getDiscordConfigPath()),
+          'adapter-google-chat': fs.existsSync(getGoogleChatConfigPath()),
+        },
+      });
+    } catch (err) {
+      console.error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+
+    if (enabled.length === 0) {
+      console.error('No services selected. Check --only/--exclude.');
+      process.exit(1);
+    }
+
+    if (options.detach) {
+      await runDetached(process.argv.slice(1));
+      return;
+    }
+
+    try {
+      await runPreStart();
+    } catch (err) {
+      console.error('Pre-start setup failed:', err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+
+    try {
+      await runForeground(enabled);
+    } catch (err) {
+      console.error('Failed to start services:', err instanceof Error ? err.message : String(err));
+      removeSupervisorPid();
+      process.exit(1);
+    }
+  });

package/src/cli/commands/up.ts

@@ -1,15 +1,135 @@
 import { Command } from 'commander';
 import { getDaemonClient } from '../client.js';
-import { getSocketPath } from '../../shared/workspace.js';
+import {
+  getAgent,
+  getAgentOverlay,
+  getPoliciesPath,
+  getSocketPath,
+  listAgents,
+  refreshAgentTemplate,
+  refreshAgentSkills,
+  formatPlanActions,
+} from '../../shared/workspace.js';
 import fs from 'node:fs';
+import path from 'node:path';
+import { installBuiltinPolicies } from '../builtin-policies.js';
+import { exportLiteToAllEnvironments } from '../../shared/lite.js';
+
+// resolvePolicies only exposes built-ins when a policies file exists, so a
+// fresh project needs an empty one for run-host etc. to be visible.
+export function ensureDefaultPoliciesFile(): void {
+  const policiesPath = getPoliciesPath();
+  if (fs.existsSync(policiesPath)) return;
+  fs.mkdirSync(path.dirname(policiesPath), { recursive: true });
+  fs.writeFileSync(policiesPath, JSON.stringify({ policies: {} }, null, 2));
+}
+
+interface DivergedAction {
+  action: 'skip-diverged';
+  relPath: string;
+  reason: 'edited' | 'no-recorded-sha';
+}
+
+function logPlanWarnings(
+  agentId: string,
+  directory: string | undefined,
+  actions: Array<{ action: string; relPath: string; reason?: string }>
+): void {
+  const workdir = directory ?? agentId;
+  for (const rawAction of actions) {
+    if (rawAction.action !== 'skip-diverged') continue;
+    const action = rawAction as DivergedAction;
+    if (action.reason === 'edited') {
+      console.warn(
+        `./${path.join(workdir, action.relPath)} differs from template; skipping refresh. Run 'clawmini agents refresh ${agentId} --accept' to overwrite.`
+      );
+    } else if (action.reason === 'no-recorded-sha') {
+      console.warn(
+        `./${path.join(workdir, action.relPath)} has no recorded SHA; skipping. Run 'clawmini agents refresh ${agentId} --accept' to adopt the current file.`
+      );
+    }
+  }
+}
+
+// Walk every agent and refresh its tracked files against the installed
+// clawmini. Workdir-template refresh requires `extends`; skill refresh runs
+// for any agent that hasn't opted out via `skillsDir: null`. Diverged files
+// are skipped with a warning. Returns the aggregated plan actions for
+// dry-run printing.
+export async function refreshAllAgents(opts: { dryRun?: boolean } = {}): Promise<string[]> {
+  const output: string[] = [];
+  const agentIds = await listAgents();
+  for (const agentId of agentIds) {
+    let overlay;
+    try {
+      overlay = await getAgentOverlay(agentId);
+    } catch (err) {
+      console.warn(
+        `Skipping refresh for agent '${agentId}': ${err instanceof Error ? err.message : String(err)}`
+      );
+      continue;
+    }
+    if (!overlay) continue;
+
+    try {
+      if (overlay.extends) {
+        const plan = await refreshAgentTemplate(
+          agentId,
+          overlay,
+          process.cwd(),
+          opts.dryRun ? { dryRun: true } : {}
+        );
+        if (plan) {
+          logPlanWarnings(agentId, overlay.directory, plan.actions);
+          output.push(...formatPlanActions(plan, { agentId }));
+        }
+      }
+
+      const resolved = await getAgent(agentId);
+      if (resolved) {
+        const skillsPlan = await refreshAgentSkills(
+          agentId,
+          resolved,
+          process.cwd(),
+          opts.dryRun ? { dryRun: true } : {}
+        );
+        if (skillsPlan) {
+          logPlanWarnings(agentId, overlay.directory, skillsPlan.actions);
+          output.push(...formatPlanActions(skillsPlan, { agentId }));
+        }
+      }
+    } catch (err) {
+      console.warn(
+        `Failed to refresh agent '${agentId}': ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  return output;
+}
 
 export const upCmd = new Command('up')
   .description('Start the local clawmini daemon server')
-  .action(async () => {
+  .option('--dry-run', 'Print the per-file refresh plan without writing anything')
+  .action(async (options: { dryRun?: boolean }) => {
     try {
       const socketPath = getSocketPath();
       const wasRunning = fs.existsSync(socketPath);
 
+      if (options.dryRun) {
+        const lines = await refreshAllAgents({ dryRun: true });
+        if (lines.length === 0) {
+          console.log('Dry run: no agents to refresh.');
+        } else {
+          for (const line of lines) console.log(line);
+        }
+        return;
+      }
+
+      await installBuiltinPolicies();
+      ensureDefaultPoliciesFile();
+      await exportLiteToAllEnvironments();
+      await refreshAllAgents();
+
       const client = await getDaemonClient({ autoStart: true });
       // Perform a ping to ensure the server is responding
       await client.ping.query();

package/src/cli/commands/web-api/agents.ts

@@ -3,6 +3,7 @@ import { z } from 'zod';
 import {
   listAgents,
   getAgent,
+  getAgentOverlay,
   writeAgentSettings,
   deleteAgent,
   isValidAgentId,
@@ -44,7 +45,7 @@ export async function handleApiAgents(
 
       const body = await parseJsonBody(req, schema);
 
-      const existing = await getAgent(body.id);
+      const existing = await getAgentOverlay(body.id);
       if (existing) {
         sendJsonResponse(res, 409, { error: 'Agent already exists' });
         return true;
@@ -106,7 +107,7 @@ export async function handleApiAgents(
 
         const body = await parseJsonBody(req, schema);
 
-        const agent = (await getAgent(agentId)) || {};
+        const agent = (await getAgentOverlay(agentId)) || {};
         if (body.directory !== undefined) agent.directory = body.directory;
         if (body.env !== undefined) agent.env = body.env;
         if (body.commands !== undefined) agent.commands = body.commands;

package/src/cli/index.ts

@@ -6,6 +6,8 @@ import { chatsCmd } from './commands/chats.js';
 import { agentsCmd } from './commands/agents.js';
 import { downCmd } from './commands/down.js';
 import { upCmd } from './commands/up.js';
+import { serveCmd } from './commands/serve.js';
+import { logsCmd } from './commands/logs.js';
 import { webCmd } from './commands/web.js';
 import { jobsCmd } from './commands/jobs.js';
 import { exportLiteCmd } from './commands/export-lite.js';
@@ -25,6 +27,8 @@ program.addCommand(environmentsCmd);
 program.addCommand(skillsCmd);
 program.addCommand(downCmd);
 program.addCommand(upCmd);
+program.addCommand(serveCmd);
+program.addCommand(logsCmd);
 program.addCommand(webCmd);
 program.addCommand(jobsCmd);
 program.addCommand(exportLiteCmd);

package/src/cli/install-detection.test.ts

@@ -0,0 +1,72 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import { detectInstall } from './install-detection.js';
+
+describe('detectInstall', () => {
+  let tmp: string;
+
+  beforeEach(() => {
+    tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'clawmini-install-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmp, { recursive: true, force: true });
+  });
+
+  it('reports isNpmGlobal=false for an entry path that lives outside npm root', () => {
+    // Use a real path under tmp so realpath resolves.
+    const entryDir = path.join(tmp, 'devcheckout', 'dist');
+    fs.mkdirSync(entryDir, { recursive: true });
+    const entry = path.join(entryDir, 'cli.mjs');
+    fs.writeFileSync(entry, '');
+    const info = detectInstall(entry);
+    expect(info.isNpmGlobal).toBe(false);
+    // entryRealPath is whatever realpath returns; on macOS /tmp is itself a
+    // symlink to /private/tmp, so just check it ends with our suffix.
+    expect(info.entryRealPath.endsWith(path.join('devcheckout', 'dist', 'cli.mjs'))).toBe(true);
+  });
+
+  it('detects npm-link as NOT npm-global (the symlink target lives outside npm root)', () => {
+    // Real install layout: <npmRoot>/clawmini/dist/cli.mjs as a SYMLINK to
+    // <devCheckout>/dist/cli.mjs. After realpath, the entry path resolves to
+    // the dev checkout, so isNpmGlobal must be false.
+    const npmRoot = path.join(tmp, 'npm-root');
+    const devRoot = path.join(tmp, 'dev-checkout');
+    fs.mkdirSync(npmRoot, { recursive: true });
+    fs.mkdirSync(path.join(devRoot, 'dist'), { recursive: true });
+    const realEntry = path.join(devRoot, 'dist', 'cli.mjs');
+    fs.writeFileSync(realEntry, '');
+
+    // Simulate `npm link`: a symlink at npm root → the dev checkout.
+    fs.symlinkSync(devRoot, path.join(npmRoot, 'clawmini'));
+
+    const linkedEntry = path.join(npmRoot, 'clawmini', 'dist', 'cli.mjs');
+    const info = detectInstall(linkedEntry);
+    // The realpath of `linkedEntry` lands inside devRoot, not npmRoot.
+    expect(info.entryRealPath).toBe(fs.realpathSync(realEntry));
+    // We have no way to mock `npm root -g` in this test, so the host's real
+    // npm root is consulted. The test asserts a *property* of the realpath,
+    // not the boolean (which depends on the host). So:
+    expect(info.entryRealPath.startsWith(fs.realpathSync(devRoot))).toBe(true);
+  });
+
+  it('detects a real npm install as npm-global when entry is under npm root', () => {
+    // We can't mock execFileSync without restructuring — instead, exercise
+    // the path-prefix logic by giving an entry under our fake "npm root" and
+    // checking via realpath comparison directly. This documents the
+    // realpath-based check; the integration boolean is asserted in the
+    // detect path against the real `npm root -g`.
+    const npmRoot = path.join(tmp, 'npm-root');
+    const installedRoot = path.join(npmRoot, 'clawmini');
+    fs.mkdirSync(path.join(installedRoot, 'dist'), { recursive: true });
+    const entry = path.join(installedRoot, 'dist', 'cli.mjs');
+    fs.writeFileSync(entry, '');
+
+    const realEntry = fs.realpathSync(entry);
+    const realNpmRoot = fs.realpathSync(npmRoot);
+    expect(realEntry.startsWith(realNpmRoot + path.sep)).toBe(true);
+  });
+});

package/src/cli/install-detection.ts

@@ -0,0 +1,48 @@
+import fs from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import path from 'node:path';
+
+export interface InstallInfo {
+  /** True when the running clawmini binary lives under `npm root -g` after realpath. */
+  isNpmGlobal: boolean;
+  /** The realpath of the running entry point (process.argv[1] resolved). */
+  entryRealPath: string;
+  /** The realpath of `npm root -g`, when available. */
+  npmRootRealPath: string | null;
+}
+
+function realpathOrNull(p: string): string | null {
+  try {
+    return fs.realpathSync(p);
+  } catch {
+    return null;
+  }
+}
+
+function getNpmRootGlobal(): string | null {
+  try {
+    const out = execFileSync('npm', ['root', '-g'], {
+      encoding: 'utf-8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    });
+    return out.trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+export function detectInstall(entryPath: string = process.argv[1] ?? ''): InstallInfo {
+  const entryRealPath = realpathOrNull(entryPath) ?? entryPath;
+  const npmRoot = getNpmRootGlobal();
+  const npmRootRealPath = npmRoot ? (realpathOrNull(npmRoot) ?? npmRoot) : null;
+
+  let isNpmGlobal = false;
+  if (npmRootRealPath) {
+    const rootWithSep = npmRootRealPath.endsWith(path.sep)
+      ? npmRootRealPath
+      : npmRootRealPath + path.sep;
+    isNpmGlobal = entryRealPath === npmRootRealPath || entryRealPath.startsWith(rootWithSep);
+  }
+
+  return { isNpmGlobal, entryRealPath, npmRootRealPath };
+}