@venn-lang/cli 0.1.0

package/src/run/node-io.ts

@@ -0,0 +1,27 @@
+import { readFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { resolveAlias } from "@venn-lang/contracts";
+import type { ModuleIo } from "@venn-lang/runtime";
+
+/** Where a `#alias/…` specifier is resolved from. */
+interface Roots {
+  paths: Record<string, string>;
+  rootDir: string;
+}
+
+/**
+ * Node-backed module IO: read files, resolve relative specifiers against the
+ * importer, and `#alias/…` specifiers through `[paths]` in `venn.toml`.
+ */
+export function createNodeModuleIo(roots: Roots): ModuleIo {
+  return {
+    read: (uri) => readFile(uri, "utf8"),
+    resolve: (base, spec) => resolveSpec(spec, base, roots),
+  };
+}
+
+function resolveSpec(spec: string, base: string, roots: Roots): string {
+  if (spec.startsWith(".")) return resolve(dirname(base), spec);
+  const alias = resolveAlias({ spec, paths: roots.paths });
+  return alias ? resolve(roots.rootDir, alias.dir, alias.rest) : spec;
+}

package/src/run/npm-loader.ts

@@ -0,0 +1,41 @@
+import { createRequire } from "node:module";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import type { NpmModules } from "@venn-lang/runtime";
+
+/**
+ * Loading an installed package, the way Node loads one.
+ *
+ * Resolution is Node's own, rooted at `target/`, the directory holding the
+ * generated `package.json` and the `node_modules` beside it. `exports` maps,
+ * conditions, scoped names and the rest are what a package means, and a second
+ * implementation of them would agree with Node right up until it did not.
+ */
+export function createNpmLoader(args: { root: string }): NpmModules {
+  const target = join(args.root, "target");
+  const from = createRequire(pathToFileURL(join(target, "package.json")));
+  return {
+    async load(spec) {
+      const found = resolvePath(from, spec);
+      if (!found) return undefined;
+      return (await import(pathToFileURL(found).href)) as Record<string, unknown>;
+    },
+  };
+}
+
+type Resolver = { resolve: (spec: string) => string };
+
+/**
+ * Where the package lives, or nothing when it is not installed.
+ *
+ * Not installed is an ordinary state: the manifest asks for a package and
+ * nobody has run `venn install` yet. The import that named it reports that
+ * itself, which is a better place to say it than inside a resolver.
+ */
+function resolvePath(from: Resolver, spec: string): string | undefined {
+  try {
+    return from.resolve(spec);
+  } catch {
+    return undefined;
+  }
+}

package/src/run/package-types.ts

@@ -0,0 +1,66 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import type { TypeSpec } from "@venn-lang/types";
+
+/** Where derived types are kept: derived, so under `target/` with the rest. */
+export function typesDir(root: string): string {
+  return join(root, "target", "types");
+}
+
+/**
+ * Derive what each installed package publishes, and keep it.
+ *
+ * Written once, at install, rather than worked out on every check: reading a
+ * package's declarations through the compiler takes about a second for a large
+ * one, and the answer only changes when what is installed does.
+ */
+export async function deriveTypes(args: {
+  root: string;
+  packages: readonly string[];
+}): Promise<{ name: string; total: number; typed: number }[]> {
+  // Loaded when it is needed and not before: it pulls in the TypeScript
+  // compiler, which is ten megabytes that `venn run` should never pay for.
+  const { readPackageTypes } = await import("@venn-lang/dts");
+  const from = join(args.root, "target", "package.json");
+  const dir = typesDir(args.root);
+  await mkdir(dir, { recursive: true });
+  const found: { name: string; total: number; typed: number }[] = [];
+  for (const name of args.packages) {
+    const types = readPackageTypes({ package: name, from });
+    await writeFile(fileFor(dir, name), `${JSON.stringify(types, null, 2)}\n`, "utf8");
+    found.push({
+      name,
+      total: types.covered.total,
+      typed: types.covered.total - types.covered.dynamic,
+    });
+  }
+  return found;
+}
+
+/** What was derived earlier, by the specifier each was derived for. */
+export async function loadDerivedTypes(args: {
+  root: string;
+  packages: readonly string[];
+}): Promise<Map<string, Record<string, TypeSpec>>> {
+  const dir = typesDir(args.root);
+  const out = new Map<string, Record<string, TypeSpec>>();
+  for (const name of args.packages) {
+    const text = await readFile(fileFor(dir, name), "utf8").catch(() => undefined);
+    const parsed = text && parse(text);
+    if (parsed) out.set(name, parsed.exports);
+  }
+  return out;
+}
+
+/** A scope holds a slash and a file name cannot, so `@types/node` becomes `@types__node`. */
+function fileFor(dir: string, name: string): string {
+  return join(dir, `${name.replace("/", "__")}.json`);
+}
+
+function parse(text: string): { exports: Record<string, TypeSpec> } | undefined {
+  try {
+    return JSON.parse(text) as { exports: Record<string, TypeSpec> };
+  } catch {
+    return undefined;
+  }
+}

package/src/run/run-file.ts

@@ -0,0 +1,106 @@
+import { type Console, ConsolePort, type Host } from "@venn-lang/contracts";
+import { type Problem, parse } from "@venn-lang/core";
+import { type HttpClient, HttpClientPort, type HttpServer, HttpServerPort } from "@venn-lang/http";
+import { createNodeServer } from "@venn-lang/http/node";
+import {
+  type CleanupSink,
+  checkImports,
+  createRunner,
+  type EventSink,
+  type ModuleIo,
+  type NpmModules,
+  type RunFilter,
+  type RunResult,
+  resolveImports,
+} from "@venn-lang/runtime";
+import { allPlugins, stdlibPortBindings } from "@venn-lang/stdlib";
+
+/** What one `.vn` file amounted to. */
+export interface RunFileOutcome {
+  /** Everything refused or reported. Empty when the file ran clean. */
+  problems: Problem[];
+  /** Absent when nothing ran: the parse or the imports stopped it first. */
+  result?: RunResult;
+}
+
+/** The source to run, the implementations behind its ports, and how to run it. */
+export interface RunFileArgs {
+  source: string;
+  uri: string;
+  host: Host;
+  sink: EventSink;
+  httpClient: HttpClient;
+  /** Injected when the caller needs to close the servers itself, as `venn run` does. */
+  httpServer?: HttpServer;
+  console?: Console;
+  filter?: RunFilter;
+  bail?: boolean;
+  env?: Record<string, unknown>;
+  io?: ModuleIo;
+  /** How an installed package is loaded, when the host can load one. */
+  npm?: NpmModules;
+  /** Where the program registers what it opened, so the host can close it. */
+  cleanup?: CleanupSink;
+  /** "test" runs the flows; "script" executes the file top to bottom. */
+  mode?: "test" | "script";
+}
+
+/**
+ * Parse and run a `.vn` source with the full stdlib loaded.
+ *
+ * The HttpClient, HttpServer and Console ports take injected implementations
+ * (real in the CLI, fakes in tests); every other port takes the binding
+ * `@venn-lang/stdlib` supplies.
+ *
+ * @param args - The source and its uri, the host and the ports, and how to run
+ * it: the filter, the mode, the environment, the module and package loaders.
+ * @returns The problems and, when anything ran, the run's result. A failing
+ * flow is a `Problem` here, not an exception.
+ * @throws Whatever an action or a loaded module let escape the runner.
+ */
+export async function runFile(args: RunFileArgs): Promise<RunFileOutcome> {
+  const { ast, problems } = parse(args.source, { uri: args.uri });
+  if (problems.length > 0) return { problems };
+  const io = args.io;
+  const resolved = io
+    ? await resolveImports({ document: ast, uri: args.uri, io, npm: args.npm })
+    : undefined;
+  const graph =
+    resolved && io
+      ? { modules: resolved.modules, resolve: io.resolve, npm: resolved.npm }
+      : undefined;
+  // Refused before anything runs. An import that names something the other file
+  // never published would otherwise surface halfway through, as a value that
+  // was quietly `undefined` until something called it.
+  const bad = graph ? checkImports({ document: ast, uri: args.uri, graph }) : [];
+  if (bad.length > 0) return { problems: bad };
+  const runner = createRunner({
+    host: args.host,
+    plugins: allPlugins,
+    sink: args.sink,
+    ports: bindings(args),
+    uri: args.uri,
+    filter: args.filter,
+    bail: args.bail,
+    env: args.env,
+    moduleFragments: resolved?.fragments,
+    modules: graph,
+    moduleDecos: resolved?.decos,
+    cleanup: args.cleanup,
+  });
+  const result = args.mode === "script" ? await runner.script(ast) : await runner.run(ast);
+  // The result carries its own problems, a decorator that refused the program
+  // among them, so both travel back together rather than one replacing the other.
+  return { problems: result.problems ?? [], result };
+}
+
+function bindings(args: RunFileArgs) {
+  const console = args.console ? [{ port: ConsolePort, impl: args.console }] : [];
+  // After the stdlib: the last binding wins, and these are the real ones.
+  return [
+    { port: HttpClientPort, impl: args.httpClient },
+    ...stdlibPortBindings,
+    { port: HttpServerPort, impl: args.httpServer ?? createNodeServer() },
+    ...console,
+  ];
+}

package/src/run/should-leave.ts

@@ -0,0 +1,11 @@
+/**
+ * Whether the process should go now, or hand the decision to the event loop.
+ *
+ * The distinction the exit code alone cannot carry: `exit 0` and "ran off the
+ * end" both arrive as zero, and only one of them is a request to stop. A
+ * program that merely finished its last line may still be serving; one that
+ * asked to leave, or that ended badly, is done either way.
+ */
+export function shouldLeave(args: { code: number; requested: boolean }): boolean {
+  return args.requested || args.code !== 0;
+}

package/src/run/step-titles.ts

@@ -0,0 +1,61 @@
+import {
+  type Block,
+  type Document,
+  type FlowDecl,
+  type IfStmt,
+  isBlock,
+  isFragmentDecl,
+  isIfStmt,
+  isRunStmt,
+  isStepDecl,
+  type Statement,
+} from "@venn-lang/core";
+
+interface Walk {
+  document: Document;
+  /** Fragments already entered, so a recursive `run` cannot loop forever. */
+  seen: Set<string>;
+}
+
+/**
+ * Every step title a flow can reach: nested in groups, loops, branches and
+ * `try`, and followed through `run <fragment>` into fragments of the same file.
+ */
+export function stepTitlesOf(flow: FlowDecl, document: Document): string[] {
+  return fromBlock(flow.body, { document, seen: new Set() });
+}
+
+function fromBlock(block: Block, walk: Walk): string[] {
+  return block.stmts.flatMap((stmt) => fromStatement(stmt, walk));
+}
+
+function fromStatement(stmt: Statement, walk: Walk): string[] {
+  if (isStepDecl(stmt)) return [stmt.title, ...fromBlock(stmt.body, walk)];
+  if (isRunStmt(stmt)) return fromFragment(stmt.target, walk);
+  if (isIfStmt(stmt)) return fromIf(stmt, walk);
+  return nestedBlocks(stmt).flatMap((block) => fromBlock(block, walk));
+}
+
+function fromIf(stmt: IfStmt, walk: Walk): string[] {
+  const then = fromBlock(stmt.then, walk);
+  const otherwise = stmt.otherwise;
+  if (!otherwise) return then;
+  const tail = isBlock(otherwise) ? fromBlock(otherwise, walk) : fromStatement(otherwise, walk);
+  return [...then, ...tail];
+}
+
+function fromFragment(name: string, walk: Walk): string[] {
+  if (walk.seen.has(name)) return [];
+  const decl = walk.document.decls.find((node) => isFragmentDecl(node) && node.name === name);
+  if (!isFragmentDecl(decl)) return [];
+  walk.seen.add(name);
+  return fromBlock(decl.body, walk);
+}
+
+// group / forEach / repeat / while / parallel / race / try all carry blocks.
+function nestedBlocks(stmt: Statement): Block[] {
+  const node = stmt as { body?: Block; handler?: Block; finalizer?: Block };
+  return [node.body, node.handler, node.finalizer].filter((block): block is Block =>
+    Array.isArray(block?.stmts),
+  );
+}

package/src/shutdown/create-leave.ts

@@ -0,0 +1,42 @@
+import type { Leave, Shutdown } from "./shutdown.types.js";
+
+/** How long a close may take before the program stops waiting for it. */
+const GRACE_MS = 5_000;
+
+/**
+ * Leaving, done properly: close what is open, then go.
+ *
+ * Two things make this more than `await close(); exit()`. A second signal means
+ * the user is done asking nicely, so it leaves at once. And a closer that never
+ * settles must not hold the program hostage, so the wait has a deadline: an
+ * unclean exit beats a process that cannot be stopped.
+ */
+export function createLeave(args: {
+  shutdown: Shutdown;
+  exit: (code: number) => void;
+  graceMs?: number;
+}): Leave {
+  let leaving = false;
+  return (code) => {
+    if (leaving) return args.exit(code);
+    leaving = true;
+    void finish({ ...args, code });
+  };
+}
+
+async function finish(args: {
+  shutdown: Shutdown;
+  exit: (code: number) => void;
+  graceMs?: number;
+  code: number;
+}): Promise<void> {
+  await Promise.race([args.shutdown.close(), deadline(args.graceMs ?? GRACE_MS)]);
+  args.exit(args.code);
+}
+
+/** A timer that does not itself keep the program alive. */
+function deadline(ms: number): Promise<void> {
+  return new Promise<void>((resolve) => {
+    setTimeout(resolve, ms).unref();
+  });
+}

package/src/shutdown/create-shutdown.ts

@@ -0,0 +1,34 @@
+import type { Closer, Shutdown } from "./shutdown.types.js";
+
+/**
+ * The registry: what to close, and the promise that it happened.
+ *
+ * Closing runs newest first, because a thing opened later may be standing on one
+ * opened earlier. One closer that throws must not strand the rest: leaving is
+ * the goal, and a half-closed program still has to go.
+ */
+export function createShutdown(): Shutdown {
+  const closers = new Set<Closer>();
+  let closing: Promise<void> | undefined;
+  return {
+    add: (closer) => {
+      closers.add(closer);
+      return () => {
+        closers.delete(closer);
+      };
+    },
+    close: () => {
+      closing ??= closeAll(closers);
+      return closing;
+    },
+  };
+}
+
+async function closeAll(closers: Set<Closer>): Promise<void> {
+  for (const closer of [...closers].reverse()) {
+    await Promise.resolve()
+      .then(() => closer())
+      .catch(() => {});
+  }
+  closers.clear();
+}

package/src/shutdown/index.ts

@@ -0,0 +1,7 @@
+export { createLeave } from "./create-leave.js";
+export { createShutdown } from "./create-shutdown.js";
+export { installExitHook } from "./install-exit-hook.js";
+export { installFaultHooks } from "./install-fault-hooks.js";
+export { type HooksArgs, installHooks } from "./install-hooks.js";
+export { installSignalHooks } from "./install-signal-hooks.js";
+export type { Closer, Leave, Shutdown, Unregister } from "./shutdown.types.js";

package/src/shutdown/install-exit-hook.ts

@@ -0,0 +1,21 @@
+import process from "node:process";
+import type { Shutdown, Unregister } from "./shutdown.types.js";
+
+/**
+ * The quiet ending: a program that simply ran out of things to do.
+ *
+ * `beforeExit` is the only moment a script without a server gets, so its
+ * `teardown` has to run here or it never runs at all. The timer is what buys
+ * the closing its time: a promise alone does not hold the loop open, and
+ * without it Node could leave mid-cleanup.
+ */
+export function installExitHook(shutdown: Shutdown): Unregister {
+  const onBeforeExit = () => {
+    const hold = setInterval(() => {}, 1_000);
+    void shutdown.close().finally(() => clearInterval(hold));
+  };
+  process.once("beforeExit", onBeforeExit);
+  return () => {
+    process.off("beforeExit", onBeforeExit);
+  };
+}

package/src/shutdown/install-fault-hooks.ts

@@ -0,0 +1,30 @@
+import process from "node:process";
+import { errorLine } from "../reporters/index.js";
+import type { Leave, Unregister } from "./shutdown.types.js";
+
+/**
+ * The two ways a program dies without being asked to.
+ *
+ * Node's default for both is to print a stack and vanish, losing the sockets,
+ * the reason and the exit code at once. Catching them means the failure is
+ * stated in the language's own voice and the machine gets its resources back on
+ * the way out.
+ */
+export function installFaultHooks(args: {
+  leave: Leave;
+  report?: (message: string) => void;
+}): Unregister {
+  const onFault = (cause: unknown) => fault({ ...args, cause });
+  process.on("uncaughtException", onFault);
+  process.on("unhandledRejection", onFault);
+  return () => {
+    process.off("uncaughtException", onFault);
+    process.off("unhandledRejection", onFault);
+  };
+}
+
+function fault(args: { leave: Leave; report?: (message: string) => void; cause: unknown }): void {
+  const write = args.report ?? ((message: string) => process.stderr.write(`${message}\n`));
+  write(errorLine(args.cause));
+  args.leave(1);
+}

package/src/shutdown/install-hooks.ts

@@ -0,0 +1,36 @@
+import type { SignalSource } from "@venn-lang/contracts";
+import { createLeave } from "./create-leave.js";
+import { installExitHook } from "./install-exit-hook.js";
+import { installFaultHooks } from "./install-fault-hooks.js";
+import { installSignalHooks } from "./install-signal-hooks.js";
+import type { Leave, Shutdown } from "./shutdown.types.js";
+
+/** Everything the process-level hooks need from the outside world. */
+export interface HooksArgs {
+  signals: SignalSource;
+  shutdown: Shutdown;
+  /** How the program leaves. Injected so a test can watch instead of dying. */
+  exit: (code: number) => void;
+  /** Where a fault is announced. Defaults to stderr. */
+  report?: (message: string) => void;
+  graceMs?: number;
+}
+
+/**
+ * Hand the process its hooks. The three ways a program can end (asked to stop,
+ * broken, or simply finished) all end the same way.
+ *
+ * Returns the `leave` these hooks share, so a command that decides to stop on
+ * its own terms unwinds through exactly the same path.
+ */
+export function installHooks(args: HooksArgs): Leave {
+  const leave = createLeave({
+    shutdown: args.shutdown,
+    exit: args.exit,
+    graceMs: args.graceMs,
+  });
+  installSignalHooks({ signals: args.signals, leave });
+  installFaultHooks({ leave, report: args.report });
+  installExitHook(args.shutdown);
+  return leave;
+}

package/src/shutdown/install-signal-hooks.ts

@@ -0,0 +1,26 @@
+import { ALL_SIGNALS, type SignalSource, type SystemSignal } from "@venn-lang/contracts";
+import type { Leave, Unregister } from "./shutdown.types.js";
+
+/** What the shell means by each signal, in exit codes. */
+const CODES: Record<SystemSignal, number> = {
+  SIGINT: 130,
+  SIGTERM: 143,
+  SIGBREAK: 130,
+  SIGHUP: 129,
+};
+
+/**
+ * Every way a system can ask this program to stop, wired to the same ending.
+ *
+ * `Ctrl+C` is the one everybody knows; `SIGTERM` is how a supervisor or a CI
+ * runner asks; `SIGBREAK` is Windows' Ctrl+Break; `SIGHUP` is the terminal
+ * closing with the program still inside it. All four deserve the same care.
+ */
+export function installSignalHooks(args: { signals: SignalSource; leave: Leave }): Unregister {
+  const offs = ALL_SIGNALS.map((signal) =>
+    args.signals.on(signal, () => args.leave(CODES[signal])),
+  );
+  return () => {
+    for (const off of offs) off();
+  };
+}

package/src/shutdown/shutdown.types.ts

@@ -0,0 +1,20 @@
+/** Something the program opened that has to be given back before it leaves. */
+export type Closer = () => Promise<void> | void;
+
+/** Drops a registration, for work whose lifetime is shorter than the process. */
+export type Unregister = () => void;
+
+/**
+ * The list of things this process still owes the machine.
+ *
+ * Whoever opens something registers how to close it; whoever is leaving calls
+ * `close` once and everything unwinds, newest first.
+ */
+export interface Shutdown {
+  add(closer: Closer): Unregister;
+  /** Close everything. Runs once; later callers await the same pass. */
+  close(): Promise<void>;
+}
+
+/** How the program leaves, once there is nothing left to give back. */
+export type Leave = (code: number) => void;

package/src/title/index.ts

@@ -0,0 +1,2 @@
+export { programTitle } from "./program-title.js";
+export { setProgramTitle } from "./set-program-title.js";

package/src/title/program-title.ts

@@ -0,0 +1,15 @@
+import { basename } from "node:path";
+
+/** How long a title may get before it stops being readable in a tab. */
+const MAX = 60;
+
+/**
+ * What this process calls itself: `venn run server.vn`, not `node`.
+ *
+ * The terminal tab is the only place a long-running program announces itself,
+ * and "node" says nothing about which program, which file, or whose.
+ */
+export function programTitle(args: { command: string; target?: string }): string {
+  const name = args.target ? basename(args.target) : "";
+  return `venn ${args.command}${name ? ` ${name}` : ""}`.slice(0, MAX);
+}

package/src/title/set-program-title.ts

@@ -0,0 +1,15 @@
+import process from "node:process";
+import { programTitle } from "./program-title.js";
+
+/**
+ * Name the process after the program it is running.
+ *
+ * Until something says otherwise, Windows reports the executable path (the
+ * `node` the terminal tab shows) and puts it back when the process exits. So
+ * this is set once and never undone: restoring it by hand would write that path
+ * over whatever title the terminal had before, which is worse than doing
+ * nothing.
+ */
+export function setProgramTitle(args: { command: string; target?: string }): void {
+  process.title = programTitle(args);
+}

package/src/upgrade/index.ts

@@ -0,0 +1,6 @@
+export { installSiteOf } from "./install-site.js";
+export { isNewer, latestVersion } from "./latest-version.js";
+export type { InstallSite, PackageManager, UpgradeOptions } from "./upgrade.types.js";
+export { runUpgrade } from "./upgrade-command.js";
+export { PACKAGE_NAME, refusalFor, upgradeCommandFor } from "./upgrade-plan.js";
+export { VERSION } from "./version.js";

package/src/upgrade/install-site.ts

@@ -0,0 +1,70 @@
+import type { InstallSite, PackageManager } from "./upgrade.types.js";
+
+/**
+ * Where each manager keeps what it installed for the user rather than for a
+ * project. A copy sitting under one of these is global wherever it was invoked
+ * from, which matters because several of them live under the home directory:
+ * running from `~` would otherwise make a global install look like a local one.
+ */
+const GLOBAL_ROOTS: readonly string[] = [
+  "/pnpm/global/",
+  "/.bun/install/global/",
+  "/bun/install/global/",
+  "/lib/node_modules/",
+  "/npm/node_modules/",
+  "/nodejs/node_modules/",
+];
+
+/**
+ * Which manager installed this copy, and whether it did so globally.
+ *
+ * Read from the path the CLI is running out of rather than from the
+ * environment: `npm_config_user_agent` only exists while a package script is
+ * running, and is empty when the binary is invoked directly, which is every
+ * time anyone actually uses it.
+ *
+ * Each manager keeps its global root somewhere unmistakable, so the path is
+ * enough to tell them apart on all three operating systems.
+ *
+ * @param path Where the running CLI lives. Must be a plain path: pass
+ * `fileURLToPath(import.meta.url)`, since a `file:///` URL would be read as
+ * living outside every project.
+ * @param cwd The directory the user invoked it from.
+ * @returns The manager and whether the install is global, or `unknown` when the
+ * path matches nothing recognisable.
+ */
+export function installSiteOf(args: { path: string; cwd: string }): InstallSite {
+  const path = normalise(args.path);
+  const manager = managerOf(path);
+  if (!manager) return { manager: "unknown", global: false };
+  return { manager, global: isGlobal(path, normalise(args.cwd)) };
+}
+
+function normalise(path: string): string {
+  return path.split("\\").join("/").toLowerCase();
+}
+
+function managerOf(path: string): PackageManager | undefined {
+  if (path.includes("/.bun/") || path.includes("/bun/install/global/")) return "bun";
+  if (path.includes("/pnpm/")) return "pnpm";
+  if (path.includes("/yarn/") || path.includes("/.yarn/")) return "yarn";
+  return path.includes("/node_modules/") ? "npm" : undefined;
+}
+
+/**
+ * A copy under the working directory belongs to that project, not to the user,
+ * unless it sits in a global root that happens to be an ancestor of it.
+ *
+ * Upgrading a copy the project owns would move a version its manifest still
+ * pins, so the next install would put the old one back and the user would be
+ * left wondering which of the two is running.
+ */
+function isGlobal(path: string, cwd: string): boolean {
+  if (isGlobalRoot(path)) return true;
+  return !path.startsWith(`${cwd}/`);
+}
+
+function isGlobalRoot(path: string): boolean {
+  if (GLOBAL_ROOTS.some((root) => path.includes(root))) return true;
+  return path.includes("/yarn/") && path.includes("/global/");
+}