@yugabytedb/meko-mcp 1.2.0 → 2.1.0

package/bin/create-meko-setup.mjs

@@ -7,9 +7,14 @@ import { dirname, join } from 'node:path';
 
 import { install, uninstall } from '../lib/installer.mjs';
 import { askChoice, askMultiChoice, askText, askSecret, askYesNo, close as closePrompts } from '../lib/prompt.mjs';
-import { banner, error, dim, info } from '../lib/logger.mjs';
-import { isPackagedInstall, selfInvocation } from '../lib/clients/common.mjs';
+import { banner, error, dim, info, warn } from '../lib/logger.mjs';
+import {
+  isPackagedInstall,
+  MEKO_PRODUCTION_CONSOLE_URL,
+  selfInvocation,
+} from '../lib/clients/common.mjs';
 import { getClientAdapters } from '../lib/clients/index.mjs';
+import { resolveSuggestedMcpUrl } from '../lib/url-selection.mjs';
 import { parseClientList } from '../lib/clients/aliases.mjs';
 import { startMigration, runChildMigration, readStatus, stopMigration } from '../lib/migrate.mjs';
 import { checkLatest } from '../lib/version-check.mjs';
@@ -28,6 +33,8 @@ const options = {
   'cursor-hook-mode': { type: 'string',  default: 'native' },
   'skip-skills':      { type: 'boolean', default: false },
   'skip-validation':  { type: 'boolean', default: false },
+  statusline:         { type: 'boolean', default: false },
+  'no-statusline':    { type: 'boolean', default: false },
   'no-canary':        { type: 'boolean', default: false },
   'dry-run':          { type: 'boolean', default: false },
   'check-updates':    { type: 'boolean', default: false },
@@ -79,7 +86,7 @@ Examples:
   create-meko-setup
 
   # Cloud Meko for Claude Code (non-interactive):
-  create-meko-setup --url https://your-mcp.mekodev.com/mcp --api-key "$MEKO_API_KEY" --yes
+  create-meko-setup --url https://mcp.mekodata.ai/mcp --api-key "$MEKO_API_KEY" --yes
 
   # Local Meko with Cursor config:
   create-meko-setup --client cursor --local --scope project --yes
@@ -102,7 +109,7 @@ Options:
                         Comma-separated, or "all" to target every supported client (default: claude-code)
                         codex covers BOTH the OpenAI Codex CLI and the Codex Desktop App
                         (they share ~/.codex/config.toml).
-  --url <url>           MCP server URL (from app.mekodev.com > Datapacks > Connect)
+  --url <url>           MCP server URL (from cloud.mekodata.ai > Datapacks > Connect)
   --api-key <key>       API key for Cloud Meko authentication
   --local               Use local Meko at http://localhost:8000/mcp
   --scope <scope>       Config scope: user or project (default: user)
@@ -111,6 +118,11 @@ Options:
   --name <name>         MCP server name in config (default: meko)
   --cursor-hook-mode    Cursor hook mode: native or claude-compat (default: native)
   --skip-skills         Skip plugin and skills installation
+  --statusline          Wire the Meko datapack-pin indicator into Claude Code's
+                        statusline (composes with any existing statusLine).
+                        Default: ON under --yes, prompted otherwise.
+                        Claude Code only.
+  --no-statusline       Skip statusline wiring even under --yes.
   --skip-validation     Skip post-install validation
   --no-canary           Skip the canary datapack_list call. The
                         connectivity + tools/list checks still run.
@@ -398,6 +410,11 @@ async function main() {
   let url    = flags.url    ?? null;
   let apiKey = normalizeApiKey(flags['api-key']);
   let skipSkills = flags['skip-skills'];
+  // Statusline: --no-statusline always wins. --statusline forces on. Otherwise
+  // default to on under --yes (programmatic), and prompt with Y default
+  // interactively. Resolved later after the interactive prompts since the
+  // flag may flip in the interactive flow.
+  let installStatusline = !flags['no-statusline'] && (flags.statusline || flags.yes);
   // Tracks whether the full interactive flow already prompted for the API
   // key. The Cloud-URL fallback below should only run for the
   // semi-interactive `--url ... --client ...` paste path — otherwise
@@ -453,6 +470,28 @@ async function main() {
     }
   }
 
+  let suggestedUrl = null;
+  if (!url && !flags.local) {
+    suggestedUrl = resolveSuggestedMcpUrl({
+      adapters: getClientAdapters(),
+      clients,
+      name: flags.name,
+      scope: flags.scope,
+      projectRoot,
+    });
+    if (flags.yes) {
+      if (suggestedUrl.source === 'conflict') {
+        const conflicts = suggestedUrl.existingUrls.map((existingUrl) => `\n  - ${existingUrl}`).join('');
+        error(
+          `Selected clients have different existing Meko URLs:${conflicts}\n` +
+          'Pass --url explicitly to choose which endpoint to install.',
+        );
+        process.exit(1);
+      }
+      url = suggestedUrl.url;
+    }
+  }
+
   // Interactive mode: URL not provided and not auto-accepting defaults
   if (!url && !flags.yes) {
     banner('Meko Setup');
@@ -463,7 +502,7 @@ async function main() {
     // When only Cloud is available, skip the prompt entirely — asking to
     // pick between one option is pointless UX.
     const connectionOptions = [
-      { label: 'Cloud Meko', description: 'Hosted at mekodev.com (requires URL + API key)' },
+      { label: 'Cloud Meko', description: 'Hosted at mekodata.ai (requires an API key)' },
     ];
     if (!isPackagedInstall()) {
       connectionOptions.push({
@@ -478,7 +517,19 @@ async function main() {
 
     if (connectionType === 'Cloud Meko') {
       // Step 2 — MCP URL
-      url = await askText('MCP server URL (from app.mekodev.com > Datapacks > Connect):');
+      if (suggestedUrl?.source === 'existing') {
+        dim(`Using the existing Meko endpoint as the default: ${suggestedUrl.url}`);
+      } else if (suggestedUrl?.source === 'conflict') {
+        const conflicts = suggestedUrl.existingUrls.map((existingUrl) => `\n  - ${existingUrl}`).join('');
+        warn(
+          `Selected clients use different Meko endpoints:${conflicts}\n` +
+          'Enter the endpoint to use for this install.',
+        );
+      }
+      url = await askText(
+        `MCP server URL (from ${MEKO_PRODUCTION_CONSOLE_URL} > Datapacks > Connect):`,
+        suggestedUrl?.url ?? undefined,
+      );
 
       // Step 3 — API key. Normalize: terminal paste can drag in trailing
       // whitespace/CR or accidental surrounding quotes, all of which would
@@ -498,6 +549,19 @@ async function main() {
     if (!installSkills) {
       skipSkills = true;
     }
+
+    // Step 5 — statusline (Claude Code only). --no-statusline / --statusline
+    // skip the prompt; otherwise ask with Y default. The prompt only matters
+    // when at least one selected client is claude-code; for desktop / cursor /
+    // codex the install() orchestrator simply skips the step (the adapters
+    // don't expose installStatusline()).
+    if (!flags['no-statusline'] && !flags.statusline && clients.includes('claude-code')) {
+      installStatusline = await askYesNo(
+        'Show the active Meko datapack in Claude Code\'s statusline? ' +
+        '(composes with any existing statusLine — non-destructive)',
+        true,
+      );
+    }
   }
 
   // Validation — URL must be set by now
@@ -544,6 +608,10 @@ async function main() {
         skipSkills,
         skipValidation: flags['skip-validation'],
         skipCanary:     flags['no-canary'],
+        // Statusline is Claude Code only. For other clients the orchestrator
+        // skips the step regardless of the flag because the adapter doesn't
+        // expose installStatusline(); explicit guard keeps step counts honest.
+        installStatusline: client === 'claude-code' && installStatusline,
         dryRun:         flags['dry-run'],
         verbose:        flags.verbose,
         yes:            flags.yes,

package/lib/clients/claude-code.mjs

@@ -1,4 +1,4 @@
-import { mkdirSync } from "node:fs";
+import { chmodSync, copyFileSync, mkdirSync, unlinkSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 
@@ -14,8 +14,10 @@ import {
 } from "../config.mjs";
 import { detectClaude, detectExistingMeko, getClaudeCodeConfigPath } from "../detect.mjs";
 import {
+  MEKO_MCP_USER_AGENT,
   redactKey,
   resolveHooksRoot,
+  resolveStatuslineSource,
   run,
   shellQuote,
   writeInstallerMarker,
@@ -44,15 +46,23 @@ const MEKO_MARKETPLACE_NAME = "meko-agent-skills";
 
 // Meko MCP tools to union into `permissions.allow` so Claude Code resolves
 // them without the deferred-tools ToolSearch round-trip (issue #5). The set
-// is intentionally tight — only tools the agent calls proactively per
-// the meko-mcp-tools skill — to avoid bloating every user's settings.
+// is intentionally tight — the memory/conversation tools the agent actually
+// reaches for per the meko-mcp-tools skill — to avoid bloating every user's
+// settings.
+//
+// `memory_add` stays on this list even though the skill no longer tells the
+// agent to fire it proactively (server-side extraction now captures
+// conversationally-stated facts automatically). It's kept because the skill
+// still uses memory_add for the narrow explicit-save cases — "remember this",
+// output-only/tool-derived facts, and overwriting corrections — and pre-
+// allowing it keeps those calls prompt-free. `conversation_add_message` is the
+// tool that now drives capture-plus-extraction, so it must resolve instantly.
 //
 // NOTE: `permissions.allow` is verified to cover user-prompt bypass. Whether
 // it also bypasses the deferred-tools schema-fetch gate must be re-verified
 // empirically before this flag is considered load-bearing for #5. Tracked
 // as Phase 10.1 in skills/TEST_PLAN.md.
 const MEKO_ALWAYS_AVAILABLE_TOOLS = [
-  "mcp__meko__db_summarize_database",
   "mcp__meko__memory_add",
   "mcp__meko__memory_search",
   "mcp__meko__memory_get_all",
@@ -125,7 +135,8 @@ export function createClaudeCodeAdapter(options = {}) {
     buildRegisterCommand({ name, url, scope, apiKey }) {
       let cmd =
         `claude mcp add --transport http --scope ${shellQuote(scope)} ` +
-        `${shellQuote(name)} ${shellQuote(url)}`;
+        `${shellQuote(name)} ${shellQuote(url)} ` +
+        `--header ${shellQuote(`User-Agent: ${MEKO_MCP_USER_AGENT}`)}`;
       if (apiKey) {
         cmd += ` --header ${shellQuote(`Authorization: Bearer ${apiKey}`)}`;
       }
@@ -207,14 +218,89 @@ export function createClaudeCodeAdapter(options = {}) {
         );
       }
     },
+    /**
+     * Wire the Meko datapack-pin statusline contribution into ~/.claude/settings.json.
+     *
+     * Composable: if the user already has a `statusLine.command`, that command
+     * is preserved as the inner command and our wrapper appends `Meko: <name>`
+     * after its output. Idempotent: if our wrapper is already wired, no-op.
+     *
+     * Restore-on-uninstall: the original command is preserved in
+     * settings.json under `_meko.statusLine.previousCommand` so `uninstall()`
+     * can restore it. Absent that key (fresh install), uninstall removes the
+     * whole `statusLine` block.
+     */
+    installStatusline({ dryRun, verbose, log, settingsPath }) {
+      const scriptSource = resolveStatuslineSource();
+      const scriptDest = join(homedir(), ".claude", "meko-statusline.sh");
+
+      const existing = readJsonFile(settingsPath) ?? {};
+      const existingCmd =
+        existing?.statusLine?.type === "command" && typeof existing?.statusLine?.command === "string"
+          ? existing.statusLine.command.trim()
+          : "";
+
+      // Detect prior install of our wrapper. Re-wiring is a no-op for the
+      // command (already points at the wrapper); we still re-copy the script
+      // so a refreshed installer ships an updated copy.
+      const alreadyWired = existingCmd.includes("meko-statusline.sh");
+      const innerCmd =
+        alreadyWired
+          ? (existing?._meko?.statusLine?.previousCommand ?? "")
+          : existingCmd;
+
+      const wrapperCmd = innerCmd
+        ? `${shellQuote(scriptDest)} --inner-cmd ${shellQuote(innerCmd)}`
+        : shellQuote(scriptDest);
+
+      if (dryRun) {
+        log.dim(`  Would copy ${scriptSource} → ${scriptDest}`);
+        log.dim(`  Would set ${settingsPath} statusLine.command = ${wrapperCmd}`);
+        if (innerCmd) log.dim(`    (preserving prior inner command: ${innerCmd})`);
+        return;
+      }
+
+      mkdirSync(join(homedir(), ".claude"), { recursive: true });
+      copyFileSync(scriptSource, scriptDest);
+      chmodSync(scriptDest, 0o755);
+
+      const patch = {
+        statusLine: { type: "command", command: wrapperCmd },
+      };
+      // Stash the inner command so uninstall can restore it. Only write this
+      // namespace on the first install (when alreadyWired is false), so a
+      // re-install never overwrites the genuine original with our wrapper.
+      if (!alreadyWired) {
+        patch._meko = { statusLine: { previousCommand: innerCmd || null } };
+      }
+      mergeSettings(settingsPath, patch);
+
+      if (verbose) {
+        log.dim(`  Statusline script: ${scriptDest}`);
+        log.dim(`  Wrapper command: ${wrapperCmd}`);
+        if (innerCmd) log.dim(`  Inner command preserved: ${innerCmd}`);
+        if (alreadyWired) log.dim(`  (refreshed existing wrapper, no settings change beyond script copy)`);
+      }
+    },
     installSkills({ scope, dryRun, verbose, log }) {
       // NB: we deliberately do NOT pass --sparse. Claude CLI's sparse
       // path filter silently produces an empty clone for our layout,
       // leaving the marketplace.json missing. Full clone is small
       // (~few MB, mostly markdown) and is the only way that reliably
       // succeeds today.
+      // Marketplace source is normally the public generated skills repo. Use
+      // an explicit HTTPS URL: GitHub's owner/repo shorthand makes Claude Code
+      // clone over SSH, which fails for users without GitHub SSH credentials.
+      // A dev/e2e
+      // override lets a test install the plugin from a LOCAL working-tree
+      // checkout (a directory path) so unreleased skill changes can be
+      // exercised end-to-end before they are published to `yugabyte/meko-skills`.
+      // Only set MEKO_PLUGIN_MARKETPLACE_SOURCE in tests.
+      const marketplaceSource =
+        process.env.MEKO_PLUGIN_MARKETPLACE_SOURCE
+        || "https://github.com/yugabyte/meko-skills.git";
       const marketplaceCmd =
-        `claude plugin marketplace add yugabyte/meko-mcp-server --scope ${scope}`;
+        `claude plugin marketplace add ${shellQuote(marketplaceSource)} --scope ${shellQuote(scope)}`;
       // `claude plugin list` dropped --scope in CLI 2.1.x; it prints all
       // scopes. The match-by-token regex used below is scope-agnostic by
       // design — `plugin update` failing with "not found" on a
@@ -393,6 +479,44 @@ export function createClaudeCodeAdapter(options = {}) {
         results.push({ key: "hooks", ok: false, message: `Could not prune Meko hook entries: ${err.message}` });
       }
 
+      try {
+        // Restore the user's prior statusLine.command (if any) and remove our
+        // bookkeeping. If no prior command was preserved, remove the whole
+        // statusLine block — installStatusline() only added it on first
+        // install, so we own it cleanly.
+        const cfg = readJsonFile(settingsPath) ?? {};
+        const wrapperWired =
+          cfg?.statusLine?.type === "command" &&
+          typeof cfg?.statusLine?.command === "string" &&
+          cfg.statusLine.command.includes("meko-statusline.sh");
+        if (wrapperWired) {
+          const prev = cfg?._meko?.statusLine?.previousCommand;
+          if (typeof prev === "string" && prev.length > 0) {
+            cfg.statusLine = { type: "command", command: prev };
+            results.push({ key: "statusline", ok: true, message: "Restored prior statusLine.command." });
+          } else {
+            delete cfg.statusLine;
+            results.push({ key: "statusline", ok: true, message: "Removed Meko statusLine wrapper." });
+          }
+          if (cfg?._meko?.statusLine) {
+            delete cfg._meko.statusLine;
+            if (cfg._meko && Object.keys(cfg._meko).length === 0) delete cfg._meko;
+          }
+          writeJsonFile(settingsPath, cfg);
+          // Remove the copied script too — installStatusline() owns it, so
+          // leaving it behind would be a stale orphan after uninstall.
+          try {
+            unlinkSync(join(homedir(), ".claude", "meko-statusline.sh"));
+          } catch {
+            // Best-effort: absent file (ENOENT) or unreadable dir is fine.
+          }
+        } else {
+          results.push({ key: "statusline", ok: false, message: "Statusline wrapper was not installed (nothing to remove)." });
+        }
+      } catch (err) {
+        results.push({ key: "statusline", ok: false, message: `Could not restore statusLine: ${err.message}` });
+      }
+
       try {
         // Qualified plugin@marketplace form — CLI 2.1.x rejects the bare
         // name (issue #63). Before: `catch` swallowed every failure as
@@ -460,6 +584,13 @@ export function createClaudeCodeAdapter(options = {}) {
       }
 
       const authHeader = getHeader(entry.headers, "Authorization");
+      const userAgent = getHeader(entry.headers, "User-Agent");
+      if (!userAgent) {
+        return {
+          ok: false,
+          message: `Server "${serverName}" in ${configPath} is missing the User-Agent header required by the Cloud WAF.`,
+        };
+      }
       if (apiKey) {
         const expected = `Bearer ${apiKey}`;
         if (authHeader !== expected) {

package/lib/clients/claude-desktop.mjs

@@ -9,6 +9,7 @@ import {
   removeKeys,
 } from "../config.mjs";
 import {
+  MEKO_MCP_USER_AGENT,
   getAssetRoot,
   getInstallerVersion,
   markerIsStale,
@@ -31,6 +32,7 @@ import {
  *   "meko": {
  *     "command": "npx",
  *     "args": ["-y", "mcp-remote", "<url>", "--transport", "http-only",
+ *              "--header", "User-Agent:meko-mcp-installer/1.0 (...)",
  *              "--header", "Authorization:Bearer ${MEKO_API_KEY}"],
  *     "env": { "MEKO_API_KEY": "<key>" }
  *   }
@@ -97,9 +99,11 @@ export function createClaudeDesktopAdapter(options = {}) {
       const fromMcpb =
         /\bClaude\b[^ ]*\bExtensions\b/i.test(commandJoined) ||
         /mcp-remote-launcher\.js/.test(commandJoined);
+      const url = getMcpRemoteEntryUrl(entry);
       return {
         found: true,
         status: fromMcpb ? "Configured (via .mcpb extension)" : "Configured",
+        ...(url ? { url } : {}),
       };
     },
     removeRegistration(name) {
@@ -122,8 +126,10 @@ export function createClaudeDesktopAdapter(options = {}) {
       mergeSettings(path, { mcpServers: { [name]: server } });
     },
     setHookEnvironment({ dryRun, log }) {
-      // Claude Desktop has no hook API; the skill carries the proactive-memory
-      // behavior instead. Nothing to write here.
+      // Claude Desktop has no hook API, so the skill mandates per-turn
+      // conversation_add_message posting (the server extracts memories from
+      // those posts); proactive memory_add is no longer the model. Nothing to
+      // write here.
       if (dryRun) {
         log.dim("  No hook environment required for Claude Desktop (skill-driven).");
       }
@@ -132,6 +138,8 @@ export function createClaudeDesktopAdapter(options = {}) {
       const assetRoot = assetRootResolver();
       const script = join(assetRoot, "scripts", "package-desktop-skill.sh");
       const output = join(assetRoot, "meko-mcp-tools-desktop.skill");
+      const selectOutput = join(assetRoot, "meko-select-datapack-desktop.skill");
+      const outputs = [output, selectOutput];
       // The .skill output is a ZIP file, so we can't drop a marker inside it.
       // Stamp the marker in the parent dir instead — it signals which
       // installer version produced the bundle sitting alongside it, so a
@@ -141,9 +149,11 @@ export function createClaudeDesktopAdapter(options = {}) {
 
       if (dryRun) {
         log.dim(`  Would run: bash ${script}`);
-        log.dim(`  Would produce: ${output}`);
+        for (const skillOutput of outputs) {
+          log.dim(`  Would produce: ${skillOutput}`);
+        }
         log.dim(`  Would write .meko-installer marker (version=${currentVersion}) in ${markerDir}`);
-        return { marketplace: "skipped", skills: "dry-run", output };
+        return { marketplace: "skipped", skills: "dry-run", output, outputs };
       }
 
       if (!existsSync(script)) {
@@ -158,7 +168,7 @@ export function createClaudeDesktopAdapter(options = {}) {
       // re-drag the .skill into Claude Desktop's Extensions panel; we can't do
       // that step for them. Keep rebuilding either way.
       const existingMarker = readInstallerMarker(markerDir);
-      if (existsSync(output) && existingMarker && markerIsStale(markerDir, currentVersion)) {
+      if (outputs.some((skillOutput) => existsSync(skillOutput)) && existingMarker && markerIsStale(markerDir, currentVersion)) {
         log.warn(
           `Claude Desktop .skill bundle was produced by installer ${existingMarker.version}. ` +
             `Rebuilding — you will need to re-drag it into Claude Desktop > Settings > Extensions.`,
@@ -172,8 +182,9 @@ export function createClaudeDesktopAdapter(options = {}) {
         return { marketplace: "skipped", skills: "error", error: err.message };
       }
 
-      if (!existsSync(output)) {
-        log.warn(`Expected ${output} after packaging but it was not produced.`);
+      const missingOutputs = outputs.filter((skillOutput) => !existsSync(skillOutput));
+      if (missingOutputs.length) {
+        log.warn(`Expected skill bundle(s) were not produced: ${missingOutputs.join(", ")}`);
         return { marketplace: "skipped", skills: "error" };
       }
 
@@ -186,12 +197,14 @@ export function createClaudeDesktopAdapter(options = {}) {
         log.warn(`Could not write .skill installer marker: ${err.message}`);
       }
 
-      log.info(`Built Meko skill bundle: ${output}`);
+      for (const skillOutput of outputs) {
+        log.info(`Built Meko skill bundle: ${skillOutput}`);
+      }
       log.info(
-        "Install it in Claude Desktop: Settings > Extensions > Import skill, " +
-          "or drag the .skill file onto the Claude Desktop window.",
+        "Install both in Claude Desktop: Settings > Extensions > Import skill, " +
+          "or drag each .skill file onto the Claude Desktop window.",
       );
-      return { marketplace: "skipped", skills: "ok", output };
+      return { marketplace: "skipped", skills: "ok", output, outputs };
     },
     uninstall({ name }) {
       const results = [];
@@ -246,6 +259,12 @@ export function createClaudeDesktopAdapter(options = {}) {
             `Server "${serverName}" in ${path} is missing required "command" and "args" fields.`,
         };
       }
+      if (!entry.args.includes(`User-Agent:${MEKO_MCP_USER_AGENT}`)) {
+        return {
+          ok: false,
+          message: `Server "${serverName}" in ${path} is missing the User-Agent header required by the Cloud WAF.`,
+        };
+      }
 
       return { ok: true, message: `Server "${serverName}" is registered in ${path}.` };
     },
@@ -262,7 +281,15 @@ export function createClaudeDesktopAdapter(options = {}) {
  * @returns {{command: string, args: string[], env?: Record<string,string>}}
  */
 export function buildMcpRemoteEntry({ url, apiKey }) {
-  const args = ["-y", "mcp-remote", url, "--transport", "http-only"];
+  const args = [
+    "-y",
+    "mcp-remote",
+    url,
+    "--transport",
+    "http-only",
+    "--header",
+    `User-Agent:${MEKO_MCP_USER_AGENT}`,
+  ];
   const entry = { command: "npx", args };
   if (apiKey) {
     // `Authorization:Bearer ${MEKO_API_KEY}` with no space around the colon
@@ -275,6 +302,18 @@ export function buildMcpRemoteEntry({ url, apiKey }) {
   return entry;
 }
 
+/** Read the remote URL from installer-managed or MCPB Claude Desktop entries. */
+export function getMcpRemoteEntryUrl(entry) {
+  if (typeof entry?.env?.MEKO_MCP_URL === "string") {
+    return entry.env.MEKO_MCP_URL;
+  }
+  if (typeof entry?.url === "string") return entry.url;
+  if (!Array.isArray(entry?.args)) return undefined;
+  const remoteIndex = entry.args.indexOf("mcp-remote");
+  const candidate = remoteIndex >= 0 ? entry.args[remoteIndex + 1] : undefined;
+  return typeof candidate === "string" ? candidate : undefined;
+}
+
 function defaultRunPackageScript(scriptPath) {
   if (!statSync(scriptPath).isFile()) {
     throw new Error(`Not a file: ${scriptPath}`);