sigrank 1.0.39 → 1.0.41

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## [1.0.37](https://github.com/SunrisesIllNeverSee/sigrank-mcp/releases/tag/v1.0.37) (2026-09-08)
+
+### Fixes
+
+* TUI: remove "multi" from Lifetime Tokens display (combined total, not a platform)
+* TUI: Four Degrees "Top" column uses live operator cascade metrics instead of static snapshot
+* TUI: "all" cascade row uses server batched data (from 1.0.36)
+* Added Devin as first-class platform (P.09) across MCP + app
+
+## [1.0.36](https://github.com/SunrisesIllNeverSee/sigrank-mcp/releases/tag/v1.0.36) (2026-09-08)
+
+### Fixes
+
+* TUI: "all" cascade row override uses server batched data to match Lifetime Tokens
+
+## [1.0.35](https://github.com/SunrisesIllNeverSee/sigrank-mcp/releases/tag/v1.0.35) (2026-09-07)
+
+### Fixes
+
+* TUI presentation updates and audit fixes
+
 ## [0.0.203](https://github.com/SunrisesIllNeverSee/sigrank-mcp/compare/v0.0.202...v0.0.203) (2026-08-12)
 
 ### Chores

package/README.md

@@ -161,7 +161,7 @@ smithery tool call sigrank rank_paste '{"text": "1000000 500000 50000 800000"}'
 ## Commands
 
 ```
-⊙ SigRank SignalAF CLI  v0.0.177
+⊙ SigRank SignalAF CLI  v1.0.37
 
 Default (no args)
   sigrank              unified dashboard: cascade + token pillars + board
@@ -407,7 +407,7 @@ All adapters are token-only (no message content, no cost fields, no credentials)
 ## Privacy
 
 - **Token-only persistence and submission.** Local-log adapters read usage metadata only. The optional proxy necessarily handles provider-bound request and response bytes in memory, but never persists their content; it writes only token counts, model/backend metadata, and timestamps. Only token telemetry is submitted to SigRank SignalAF.
-- **Local by default.** `tokenpull` reads only `~/.claude/projects` (Claude) or `~/.codex` (Codex) on your device. Numbers stay on your machine unless you explicitly submit with a codename.
+- **Local by default.** `tokenpull` reads only the selected or detected adapter paths on your device (e.g. `~/.claude/projects` for Claude, `~/.codex` for Codex, plus additional paths for Amp, Devin, Gemini, Goose, and other supported platforms). Numbers stay on your machine unless you explicitly submit with a codename.
 - **Background tooling excluded.** Memory plugins, observers, summarizers (e.g. `claude-mem`, `mem0`, `observer-sessions`) are filtered from both Claude and Codex reads. `subagents/` are kept — they represent real operator work.
 - **Board reads are anonymous.** No account needed to browse, compare, or watch.
 - **Ranked submissions are signed, not trusted.** `sigrank submit` requires a one-time `enroll` (device-bound ed25519 key — the private key never leaves your machine). Verify what's sent with `sigrank submit --dry-run`: the payload is four token counts, ratios, and a signature.

package/adapters/index.mjs

@@ -42,13 +42,16 @@
  */
 
 import { readdir, readFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { homedir } from "node:os";
 import { execFile as execFileCb } from "node:child_process";
 import { promisify } from "node:util";
+import { fileURLToPath } from "node:url";
 import { cachedOmpScan, ompCacheEnabled } from "../omp-cache.mjs";
 
 const execFileP = promisify(execFileCb);
+const PACKAGE_ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
 const DAY_MS = 86_400_000; // shared with tokenpull.mjs but kept local to avoid circular import
 
 // ── File-system helpers ───────────────────────────────────────────────────────
@@ -1075,6 +1078,96 @@ export const proxyAdapter = {
   },
 };
 
+
+// ── ccusage-backed adapters ──────────────────────────────────────────────────
+// ccusage maintains source-specific readers for these platforms and normalizes
+// its daily JSON output into the same four token buckets SigRank requires.
+// Keep these as thin adapters instead of duplicating upstream parsers here.
+// The bundled dependency is preferred; PATH is a fallback for development.
+async function execCcusage(args) {
+  const localEntrypoint = join(
+    PACKAGE_ROOT,
+    "node_modules",
+    "ccusage",
+    "src",
+    "cli.js",
+  );
+  const options = {
+    timeout: 30_000,
+    maxBuffer: 64 * 1024 * 1024,
+  };
+  if (existsSync(localEntrypoint)) {
+    return execFileP(process.execPath, [localEntrypoint, ...args], options);
+  }
+  return execFileP("ccusage", args, options);
+}
+
+function makeCcusageAdapter(platform) {
+  return {
+    platform,
+    defaultRoot: () => homedir(),
+    async *messages() {
+      let data;
+      try {
+        const { stdout } = await execCcusage([
+          platform,
+          "daily",
+          "--json",
+          "--no-cost",
+        ]);
+        data = JSON.parse(stdout || "{}");
+      } catch {
+        return;
+      }
+
+      const rows = Array.isArray(data?.daily)
+        ? data.daily
+        : Array.isArray(data?.data)
+          ? data.data
+          : Array.isArray(data)
+            ? data
+            : [];
+
+      for (const row of rows) {
+        if (!row || typeof row !== "object") continue;
+        const date = row.date || row.day;
+        if (!date) continue;
+        const input = Number(row.inputTokens ?? row.input_tokens ?? 0);
+        const output = Number(row.outputTokens ?? row.output_tokens ?? 0);
+        const cacheCreate = Number(
+          row.cacheCreationTokens ?? row.cache_create_tokens ?? 0,
+        );
+        const cacheRead = Number(
+          row.cacheReadTokens ?? row.cache_read_tokens ?? 0,
+        );
+        if (
+          ![input, output, cacheCreate, cacheRead].every(
+            (n) => Number.isFinite(n) && n >= 0,
+          )
+        ) {
+          continue;
+        }
+        if (input + output + cacheCreate + cacheRead === 0) continue;
+
+        yield {
+          id: `${platform}:${date}`,
+          sid: null,
+          ts: `${date}T12:00:00.000Z`,
+          input,
+          output,
+          cacheCreate,
+          cacheRead,
+          file: `ccusage:${platform}`,
+        };
+      }
+    },
+  };
+}
+
+export const antigravityAdapter = makeCcusageAdapter("antigravity");
+export const grokAdapter = makeCcusageAdapter("grok");
+export const zcodeAdapter = makeCcusageAdapter("zcode");
+
 // ── Registry ──────────────────────────────────────────────────────────────────
 /** All non-Claude, non-Codex adapters keyed by platform ID. */
 export const ADAPTERS = {
@@ -1095,6 +1188,9 @@ export const ADAPTERS = {
   other: otherAdapter,
   omp: ompAdapter,
   proxy: proxyAdapter,
+  antigravity: antigravityAdapter,
+  grok: grokAdapter,
+  zcode: zcodeAdapter,
 };
 
-export const ALL_PLATFORMS = Object.keys(ADAPTERS).concat(["claude", "codex", "grok"]);
+export const ALL_PLATFORMS = Object.keys(ADAPTERS).concat(["claude", "codex"]);

package/adapters/tokenpull.mjs

@@ -18,19 +18,20 @@
 import { readdir, readFile } from "node:fs/promises";
 import { existsSync } from "node:fs";
 import { execFile } from "node:child_process";
-import { join, dirname } from "node:path";
+import { join, dirname, delimiter } from "node:path";
 import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
 import { ADAPTERS, walkFiles } from "./index.mjs";
+import { TOKSCALE_CLIENT_MAP } from "../lib/constants.mjs";
 
 const DAY_MS = 86_400_000;
 
 // Resolve the package root for finding bundled binaries (ccusage, tokscale, etc.)
-const _pkgRoot = join(dirname(fileURLToPath(import.meta.url)));
+const _pkgRoot = join(dirname(fileURLToPath(import.meta.url)), "..");
 const _localBin = join(_pkgRoot, "node_modules", ".bin");
 // Prepend local node_modules/.bin to PATH so bundled deps are found even when
 // not globally installed (e.g., npx sigrank, local dev).
-const _envPath = `${_localBin}${process.env.PATH ? ":" + process.env.PATH : ""}`;
+const _envPath = `${_localBin}${process.env.PATH ? delimiter + process.env.PATH : ""}`;
 
 // ASYNC FIX (2026-06-27): execFile wrapped in a Promise — replaces execSync in the
 // fresh verifier readers. execSync blocks the entire Node event loop (no key handling,
@@ -522,14 +523,17 @@ async function _freshTokscale(platform = "claude") {
       : Array.isArray(data)
         ? data
         : [];
-    const rows = entries.filter(
-      (e) =>
-        e &&
-        e.client === platform &&
-        e.model !== "<synthetic>" &&
-        e.model !== "unknown" &&
-        ((Number(e.input) || 0) > 0 || (Number(e.output) || 0) > 0),
-    );
+    const rows = entries.filter((e) => {
+      if (!e || e.model === "<synthetic>" || e.model === "unknown") return false;
+      const mapped = Object.prototype.hasOwnProperty.call(
+        TOKSCALE_CLIENT_MAP,
+        e.client,
+      )
+        ? TOKSCALE_CLIENT_MAP[e.client]
+        : e.client;
+      if (mapped !== platform) return false;
+      return (Number(e.input) || 0) > 0 || (Number(e.output) || 0) > 0;
+    });
     if (!rows.length) return null;
     const acc = rows.reduce(
       (a, e) => ({

package/identity/keystore.mjs

@@ -149,7 +149,7 @@ export function ensureIdentity() {
   // Regeneration path: a partial/corrupt record. The binding is tied to device_id —
   // if a new device_id is generated, the old codename/operator MUST NOT carry over
   // (bindingForFreshIdentity drops them). Only a reused device_id keeps its binding.
-  const fresh = generateIdentity({ device_id: existing?.device_id });
+  const fresh = generateIdentity();
   const binding = bindingForFreshIdentity(existing, fresh);
   fresh.codename = binding.codename;
   fresh.operator_id = binding.operator_id;
@@ -173,7 +173,13 @@ export function recordEnrollment({ codename, operator_id }) {
 /** Clear the local identity (sign out). Next enroll provisions a fresh device_id. */
 export function clearIdentity() {
   try {
-    if (existsSync(PATH)) unlinkSync(PATH);
+    if (existsSync(DIR)) {
+      for (const file of readdirSync(DIR)) {
+        if (file === "identity.json" || file.startsWith(BACKUP_PREFIX)) {
+          unlinkSync(join(DIR, file));
+        }
+      }
+    }
   } catch {
     /* best-effort */
   }

package/index.mjs

@@ -54,21 +54,28 @@ function serverVersion() {
 // Prevent silent crashes — log to stderr (MCP clients read stdout; stderr is safe for
 // diagnostics). The process exits so the client can respawn with a clean slate rather
 // than hanging on a broken connection.
-process.on("uncaughtException", (err) => {
-  process.stderr.write(
-    `[sigrank-mcp] uncaughtException: ${err?.message || err}\n`,
-  );
-  process.exit(1);
-});
-process.on("unhandledRejection", (reason) => {
-  const msg = reason instanceof Error ? reason.message : String(reason);
-  process.stderr.write(
-    `[sigrank-mcp] unhandledRejection: ${msg}\n`,
-  );
-  process.exit(1);
-});
+// NOTE: These handlers are scoped to MCP mode only — see installMcpCrashHandlers()
+// called inside startMcpServer(). Installing them at module load would break the
+// TUI (process.exit(1) doesn't restore raw mode / alternate screen).
+
+function installMcpCrashHandlers() {
+  process.on("uncaughtException", (err) => {
+    process.stderr.write(
+      `[sigrank-mcp] uncaughtException: ${err?.message || err}\n`,
+    );
+    process.exit(1);
+  });
+  process.on("unhandledRejection", (reason) => {
+    const msg = reason instanceof Error ? reason.message : String(reason);
+    process.stderr.write(
+      `[sigrank-mcp] unhandledRejection: ${msg}\n`,
+    );
+    process.exit(1);
+  });
+}
 
 async function startMcpServer() {
+  installMcpCrashHandlers();
   const server = new Server(
     { name: "sigrank", version: serverVersion() },
     { capabilities: { tools: { listChanged: false }, prompts: { listChanged: false }, resources: { listChanged: false } } },

package/lib/constants.mjs

@@ -68,8 +68,9 @@ export const TOKSCALE_CLIENT_MAP = {
   roocode: "other",
   mux: "other",
   crush: "other",
-  antigravity: "other",
-  "antigravity-cli": "other",
+  antigravity: "antigravity",
+  "antigravity-cli": "antigravity",
+  "antigravity-extension": "antigravity",
   zed: "other",
   kiro: "other",
   trae: "other",
@@ -77,12 +78,12 @@ export const TOKSCALE_CLIENT_MAP = {
   cline: "other",
   "9router": "other",
   gjc: "other",
-  grok: "other",
+  grok: "grok",
   jcode: "other",
   commandcode: "other",
   micode: "other",
   junie: "other",
-  zcode: "other",
+  zcode: "zcode",
   opencodereview: "other",
   codebuddy: "other",
   workbuddy: "other",
@@ -92,25 +93,27 @@ export const TOKSCALE_CLIENT_MAP = {
   reasonix: "other",
   "prime-agent": "other",
   freebuff: "other",
+  cherrystudio: "other",
+  dsh: "other",
+  mcode: "other",
+  fx: "other",
+  lmstudio: "other",
+  unsloth: "other",
+  hindsight: "other",
+  "micode-desktop": "other",
+  muse: "other",
   synthetic: null,
 };
 
 /**
- * Platforms whose local data tokscale CANNOT see, so `tokscale models --json`
- * never lists them as an active client. pullActivePlatforms() auto-detect must
- * probe these directly or their cascade row can never appear, even with GBs of
- * native local telemetry (that was exactly the omp bug: tokscale reports
- * claude/codex/copilot/gemini/grok/kimi/kiro/opencode/pi and nothing else, so
- * a tokscale-detected machine silently dropped oh-my-pi entirely).
+ * Platforms whose local data the pinned tokscale release cannot discover.
  *
- * The adapter pull itself filters out platforms with no data, so probing a
- * platform the operator doesn't use costs one cheap missing-directory walk.
- *
- * As of 2026-08-08: oh-my-pi. Delete an entry once tokscale reports that client
- * (TOKSCALE_CLIENT_MAP already maps the `omp` / `oh-my-pi` client names for
- * when that happens).
+ * Tokscale 4.17.0 includes oh-my-pi (`omp`) directly, so there are currently
+ * no blind platforms that need forced probing. Keep the hook because future
+ * platform-specific discovery gaps can still be added here without changing
+ * pullActivePlatforms().
  */
-export const TOKSCALE_BLIND_PLATFORMS = ["omp"];
+export const TOKSCALE_BLIND_PLATFORMS = [];
 
 /**
  * The "actually on the board" predicate. A submission is ranked only when the

package/manifest.json

@@ -2,7 +2,7 @@
   "$schema": "https://raw.githubusercontent.com/anthropics/mcpb/main/schemas/mcpb-manifest-v0.4.schema.json",
   "manifest_version": "0.4",
   "name": "sigrank",
-  "version": "1.0.38",
+  "version": "1.0.40",
   "description": "Ranks AI coding operators by token cascade efficiency (Yield = cache_read \u00d7 output / input\u00b2). 25 tools including SigRank Standard record, yield calculation, local token usage pulls, signed submission, and tokscale-powered analytics (market share, developer profiles, model trends, cost analysis, device profiles, MCP usage, competitive intelligence). Privacy-first: runs locally, only four token counts leave the machine.",
   "author": {
     "name": "SunrisesIllNeverSee",

package/omp-cache.mjs

@@ -23,7 +23,7 @@
  * obtained, falls back to uncached scan without damaging the cache.
  */
 
-import { execFile as execFileCb } from "node:child_process";
+import { execFile as execFileCb, spawn } from "node:child_process";
 import { promisify } from "node:util";
 import { mkdir, stat, unlink } from "node:fs/promises";
 import { join, dirname } from "node:path";
@@ -31,6 +31,22 @@ import { homedir } from "node:os";
 
 const execFileP = promisify(execFileCb);
 
+/** Run SQL via stdin to avoid OS argument-length limits (E2BIG on large transcripts). */
+function sqliteExecStdin(dbPath, sql, timeoutMs = 30_000) {
+  return new Promise((resolve) => {
+    const child = spawn("sqlite3", [dbPath], {
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: timeoutMs,
+    });
+    let stderr = "";
+    child.stderr.on("data", (d) => { stderr += d; });
+    child.on("error", () => resolve(false));
+    child.on("close", (code) => resolve(code === 0));
+    child.stdin.write(`PRAGMA busy_timeout=${BUSY_TIMEOUT_MS};\n${sql}`);
+    child.stdin.end();
+  });
+}
+
 const CACHE_SCHEMA_VERSION = "1";
 const CACHE_PARSER_VERSION = "omp-stage1-v1";
 const BUSY_TIMEOUT_MS = 5_000;
@@ -57,7 +73,7 @@ async function sqliteJson(dbPath, sql, timeoutMs = 10_000) {
 /** Run a SQLite command that doesn't return rows (DDL/DML). Returns success boolean. */
 async function sqliteExec(dbPath, sql, timeoutMs = 30_000) {
   try {
-    await execFileP("sqlite3", [dbPath, sql], {
+    await execFileP("sqlite3", [dbPath, `PRAGMA busy_timeout=${BUSY_TIMEOUT_MS}; ${sql}`], {
       timeout: timeoutMs,
       maxBuffer: SQLITE_MAX_BUFFER,
     });
@@ -67,8 +83,13 @@ async function sqliteExec(dbPath, sql, timeoutMs = 30_000) {
   }
 }
 
-/** Run multiple SQL statements in a single sqlite3 call (semicolon-separated). */
+/** Run multiple SQL statements in a single sqlite3 call (semicolon-separated).
+ *  Uses stdin for large SQL to avoid OS argument-length limits. */
 async function sqliteExecBatch(dbPath, sql, timeoutMs = 60_000) {
+  // OS arg-length limit: ~256KB on macOS, ~2MB on Linux. Use stdin for safety.
+  if (sql.length > 200_000) {
+    return sqliteExecStdin(dbPath, sql, timeoutMs);
+  }
   return sqliteExec(dbPath, sql, timeoutMs);
 }
 
@@ -425,7 +446,7 @@ export async function* cachedOmpScan({
         const cachedSum = sumFields(cachedRecords, field);
         const uncachedSum = sumFields(uncachedRecords, field);
         if (cachedSum !== uncachedSum) {
-          console.error(
+          throw new Error(
             `[omp-cache] PARITY DRIFT: ${field} cached=${cachedSum} uncached=${uncachedSum} (diff=${cachedSum - uncachedSum})`,
           );
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigrank",
-  "version": "1.0.39",
+  "version": "1.0.41",
   "author": "SunrisesIllNeverSee (https://github.com/SunrisesIllNeverSee)",
   "description": "Upsilon measurement engine distributed through the sigrank CLI/MCP compatibility package, with SigRank public leaderboard tools.",
   "mcpName": "io.github.SunrisesIllNeverSee/sigrank-mcp",

package/presentation/cli.mjs

@@ -29,7 +29,7 @@ import { cascade, classify, CLASS_TIERS, UNCLASSED, tierOf } from "../cascade.mj
 import { ALL_PLATFORMS } from "../adapters.mjs";
 import { ensureIdentity, keystorePath } from "../keystore.mjs";
 import { submitSignedWindow } from "../submit.mjs";
-import { LEADERBOARD_METRIC } from "../lib/constants.mjs";
+import { LEADERBOARD_METRIC, TOKSCALE_CLIENT_MAP } from "../lib/constants.mjs";
 import { execFile } from "child_process";
 import { existsSync, readFileSync } from "fs";
 import os from "os";
@@ -37,9 +37,9 @@ import path from "path";
 import { fileURLToPath } from "url";
 
 // Resolve local node_modules/.bin for bundled deps (ccusage, tokscale)
-const _pkgRoot = path.dirname(fileURLToPath(import.meta.url));
+const _pkgRoot = path.join(path.dirname(fileURLToPath(import.meta.url)), "..");
 const _localBin = path.join(_pkgRoot, "node_modules", ".bin");
-const _envPath = `${_localBin}${process.env.PATH ? ":" + process.env.PATH : ""}`;
+const _envPath = `${_localBin}${process.env.PATH ? path.delimiter + process.env.PATH : ""}`;
 
 // ASYNC FIX (2026-06-27): execFile wrapped in a Promise — replaces execSync for
 // defense-in-depth (shell injection prevention). execFile passes args as an
@@ -429,14 +429,17 @@ async function tokscalePillars(platform = "claude") {
       : Array.isArray(data)
         ? data
         : [];
-    const rows = entries.filter(
-      (e) =>
-        e &&
-        e.client === platform &&
-        e.model !== "<synthetic>" &&
-        e.model !== "unknown" &&
-        ((Number(e.input) || 0) > 0 || (Number(e.output) || 0) > 0),
-    );
+    const rows = entries.filter((e) => {
+      if (!e || e.model === "<synthetic>" || e.model === "unknown") return false;
+      const mapped = Object.prototype.hasOwnProperty.call(
+        TOKSCALE_CLIENT_MAP,
+        e.client,
+      )
+        ? TOKSCALE_CLIENT_MAP[e.client]
+        : e.client;
+      if (mapped !== platform) return false;
+      return (Number(e.input) || 0) > 0 || (Number(e.output) || 0) > 0;
+    });
     if (rows.length) {
       const p = rows.reduce(
         (acc, e) => ({
@@ -458,13 +461,16 @@ async function tokscalePillars(platform = "claude") {
   try {
     const data = JSON.parse(readFileSync(reportPath, "utf8"));
     const entries = data.entries ?? [];
-    const rows = entries.filter(
-      (e) =>
-        e.client === platform &&
-        e.model !== "<synthetic>" &&
-        e.model !== "unknown" &&
-        (e.input > 0 || e.output > 0),
-    );
+    const rows = entries.filter((e) => {
+      if (!e || e.model === "<synthetic>" || e.model === "unknown") return false;
+      const mapped = Object.prototype.hasOwnProperty.call(
+        TOKSCALE_CLIENT_MAP,
+        e.client,
+      )
+        ? TOKSCALE_CLIENT_MAP[e.client]
+        : e.client;
+      return mapped === platform && (e.input > 0 || e.output > 0);
+    });
     if (rows.length === 0) return null;
     const p = rows.reduce(
       (acc, e) => ({

package/tools/_helpers.mjs

@@ -21,7 +21,7 @@ import {
 // Resolve local node_modules/.bin for bundled deps (ccusage, tokscale)
 const _pkgRoot = path.dirname(fileURLToPath(import.meta.url));
 const _localBin = path.join(_pkgRoot, "..", "node_modules", ".bin");
-const _envPath = `${_localBin}${process.env.PATH ? ":" + process.env.PATH : ""}`;
+const _envPath = `${_localBin}${process.env.PATH ? path.delimiter + process.env.PATH : ""}`;
 
 export const DEFAULT_API_BASE =
   process.env.SIGRANK_API_BASE || "https://signalaf.com";

package/tools/tokscale-breakdown.mjs

@@ -113,7 +113,8 @@ export async function tokscaleModelBreakdown(threshold = 0.01) {
 }
 
 export async function handleTokscaleBreakdown(args) {
-  const threshold = Number(args?.threshold ?? 0.01);
+  const raw = Number(args?.threshold ?? 0.01);
+  const threshold = Number.isFinite(raw) ? Math.max(0, raw) : 0.01;
   const platforms = await tokscaleModelBreakdown(threshold);
   return { platforms };
 }

package/tools/tokscale-competitive-intel.mjs

@@ -39,7 +39,11 @@ export const TOOL_DEF = {
 export async function handleTokscaleCompetitiveIntel(args) {
   const target = String(args?.target || "").trim();
   if (!target) {
-    throw new Error("tokscale_competitive_intel requires a non-empty `target` argument (a tokscale client slug like 'claude' or 'codex').");
+    return {
+      target: "",
+      found: false,
+      error: "tokscale_competitive_intel requires a non-empty `target` argument (a tokscale client slug like 'claude' or 'codex').",
+    };
   }
   return await tokscaleCompetitiveIntel(target);
 }

package/tui.mjs

@@ -2,7 +2,8 @@ import { runTui } from './presentation/tui.mjs';
 export * from './presentation/tui.mjs';
 
 import { pathToFileURL } from 'node:url';
-if (import.meta.url === pathToFileURL(process.argv[1]).href) {
+const entry = process.argv[1];
+if (entry && import.meta.url === pathToFileURL(entry).href) {
   runTui().catch((e) => {
     console.error(e);
     process.exit(1);