routstrd 0.2.8 → 0.2.9

package/dist/index.js

@@ -2122,6 +2122,71 @@ var require_commander = __commonJS((exports) => {
   exports.InvalidOptionArgumentError = InvalidArgumentError;
 });
 
+// src/utils/logger.ts
+import { appendFile, mkdir } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+function getLogFileForDate(date = new Date) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return join(LOGS_DIR, `${year}-${month}-${day}.log`);
+}
+async function ensureLogDir() {
+  if (!existsSync(LOGS_DIR)) {
+    await mkdir(LOGS_DIR, { recursive: true });
+  }
+}
+async function writeLog(level, ...args) {
+  await ensureLogDir();
+  const timestamp = new Date().toISOString();
+  const message = args.map((a) => {
+    if (a instanceof Error) {
+      return `${a.message}${a.stack ? `
+${a.stack}` : ""}`;
+    }
+    if (typeof a === "object") {
+      try {
+        return JSON.stringify(a);
+      } catch {
+        return String(a);
+      }
+    }
+    return String(a);
+  }).join(" ");
+  const line = `[${timestamp}] [${level}] ${message}
+`;
+  const logFile = getLogFileForDate(new Date(timestamp));
+  try {
+    await appendFile(logFile, line);
+  } catch (error) {
+    console.error("Failed to write log:", error);
+  }
+}
+var HOME, LOG_DIR, LOGS_DIR, logger;
+var init_logger = __esm(() => {
+  HOME = process.env.HOME || process.env.USERPROFILE || "";
+  LOG_DIR = process.env.ROUTSTRD_DIR || `${HOME}/.routstrd`;
+  LOGS_DIR = join(LOG_DIR, "logs");
+  logger = {
+    log: (...args) => {
+      console.log(...args);
+      writeLog("INFO", ...args);
+    },
+    debug: (...args) => {
+      writeLog("DEBUG", ...args);
+    },
+    error: (...args) => {
+      console.error(...args);
+      writeLog("ERROR", ...args);
+    },
+    info: (...args) => {
+      console.log(...args);
+      writeLog("INFO", ...args);
+    }
+  };
+});
+
 // src/utils/config.ts
 var HOME2, CONFIG_DIR, SOCKET_PATH, PID_FILE, DB_PATH, CONFIG_FILE, LOGS_DIR2, DEFAULT_CONFIG;
 var init_config = __esm(() => {
@@ -2140,6 +2205,193 @@ var init_config = __esm(() => {
   };
 });
 
+// src/utils/process-lock.ts
+import { randomUUID } from "crypto";
+import { mkdir as mkdir2, readFile, rm, stat, writeFile } from "fs/promises";
+import { dirname } from "path";
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isProcessRunning(pid) {
+  if (!Number.isFinite(pid) || pid <= 0) {
+    return false;
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    const code = error.code;
+    return code === "EPERM";
+  }
+}
+async function readLockOwner(lockDir) {
+  try {
+    const raw = await readFile(`${lockDir}/owner.json`, "utf8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.pid === "number" && typeof parsed.createdAt === "number") {
+      return {
+        pid: parsed.pid,
+        createdAt: parsed.createdAt,
+        token: typeof parsed.token === "string" ? parsed.token : undefined
+      };
+    }
+  } catch {
+  }
+  return null;
+}
+async function isLockStale(lockDir, staleAfterMs) {
+  const owner = await readLockOwner(lockDir);
+  if (owner) {
+    return !isProcessRunning(owner.pid) || Date.now() - owner.createdAt > staleAfterMs;
+  }
+  try {
+    const info = await stat(lockDir);
+    return Date.now() - info.mtimeMs > staleAfterMs;
+  } catch {
+    return false;
+  }
+}
+async function acquireCrossProcessLock(lockDir, options = {}) {
+  const acquireTimeoutMs = options.acquireTimeoutMs ?? 120000;
+  const retryIntervalMs = options.retryIntervalMs ?? 100;
+  const staleAfterMs = options.staleAfterMs ?? 120000;
+  const deadline = Date.now() + acquireTimeoutMs;
+  await mkdir2(dirname(lockDir), { recursive: true });
+  while (true) {
+    try {
+      await mkdir2(lockDir);
+      const token = randomUUID();
+      const owner = { pid: process.pid, createdAt: Date.now(), token };
+      await writeFile(`${lockDir}/owner.json`, JSON.stringify(owner), "utf8");
+      let released = false;
+      return async () => {
+        if (released)
+          return;
+        released = true;
+        const currentOwner = await readLockOwner(lockDir);
+        if (currentOwner?.token === token) {
+          await rm(lockDir, { recursive: true, force: true });
+        }
+      };
+    } catch (error) {
+      const code = error.code;
+      if (code !== "EEXIST") {
+        throw error;
+      }
+      if (await isLockStale(lockDir, staleAfterMs)) {
+        options.log?.(`Removing stale lock at ${lockDir}`);
+        await rm(lockDir, { recursive: true, force: true });
+        continue;
+      }
+      if (Date.now() >= deadline) {
+        throw new Error(`Timed out waiting to acquire lock ${lockDir}`);
+      }
+      await delay(retryIntervalMs);
+    }
+  }
+}
+async function withCrossProcessLock(lockDir, fn, options = {}) {
+  const release = await acquireCrossProcessLock(lockDir, options);
+  try {
+    return await fn();
+  } finally {
+    await release();
+  }
+}
+var init_process_lock = () => {
+};
+
+// src/start-daemon.ts
+import { existsSync as existsSync2 } from "fs";
+function getTodayLogFile() {
+  const now = new Date;
+  const year = now.getFullYear();
+  const month = String(now.getMonth() + 1).padStart(2, "0");
+  const day = String(now.getDate()).padStart(2, "0");
+  return `${LOGS_DIR2}/${year}-${month}-${day}.log`;
+}
+async function isDaemonHealthy(port) {
+  const controller = new AbortController;
+  const timeoutId = setTimeout(() => controller.abort(), 2000);
+  try {
+    const existing = await fetch(`http://localhost:${port}/health`, {
+      signal: controller.signal
+    });
+    return existing.ok;
+  } catch {
+    return false;
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+async function startDaemonUnlocked(options) {
+  const args = [];
+  const port = options.port || "8008";
+  const pollIntervalMs = 250;
+  const startupTimeoutMs = 10 * 60 * 1000;
+  if (await isDaemonHealthy(port)) {
+    logger.log(`Routstr daemon already running on http://localhost:${port}/v1`);
+    return;
+  }
+  if (options.port) {
+    args.push("--port", options.port);
+  }
+  if (options.provider) {
+    args.push("--provider", options.provider);
+  }
+  if (!existsSync2(LOGS_DIR2)) {
+    await Bun.$`mkdir -p ${LOGS_DIR2}`;
+  }
+  const daemonScript = new URL("./daemon/index.js", import.meta.url).pathname;
+  const todayLogFile = getTodayLogFile();
+  const shellCmd = `bun run "${daemonScript}" ${args.map((a) => `'${a}'`).join(" ")} >> "${todayLogFile}" 2>&1`;
+  const proc = Bun.spawn(["sh", "-c", shellCmd], {
+    stdout: "inherit",
+    stderr: "inherit",
+    stdin: "ignore",
+    detached: true
+  });
+  proc.unref();
+  let exitCode = null;
+  proc.exited.then((code) => {
+    exitCode = code;
+  });
+  const maxPolls = Math.ceil(startupTimeoutMs / pollIntervalMs);
+  for (let i = 0;i < maxPolls; i++) {
+    await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+    if (exitCode !== null) {
+      throw new Error(`Daemon process exited early with code ${exitCode}. Check logs in ${LOGS_DIR2}`);
+    }
+    if (await isDaemonHealthy(port)) {
+      logger.log(`Routstr daemon started (PID: ${proc.pid}).`);
+      return;
+    }
+  }
+  throw new Error(`Daemon failed to start within ${Math.round(startupTimeoutMs / 1000)} seconds. Check logs in ${LOGS_DIR2}`);
+}
+async function startDaemon(options = {}) {
+  const port = options.port || "8008";
+  const startupTimeoutMs = 10 * 60 * 1000;
+  if (await isDaemonHealthy(port)) {
+    logger.log(`Routstr daemon already running on http://localhost:${port}/v1`);
+    return;
+  }
+  await withCrossProcessLock(DAEMON_STARTUP_LOCK_PATH, async () => {
+    await startDaemonUnlocked(options);
+  }, {
+    acquireTimeoutMs: startupTimeoutMs + 30000,
+    staleAfterMs: startupTimeoutMs + 30000,
+    log: (message) => logger.debug(message)
+  });
+}
+var DAEMON_STARTUP_LOCK_PATH;
+var init_start_daemon = __esm(() => {
+  init_logger();
+  init_config();
+  init_process_lock();
+  DAEMON_STARTUP_LOCK_PATH = `${CONFIG_DIR}/routstrd-startup.lock`;
+});
+
 // node_modules/nostr-tools/node_modules/@noble/curves/node_modules/@noble/hashes/esm/_assert.js
 function number(n) {
   if (!Number.isSafeInteger(n) || n < 0)
@@ -9325,23 +9577,11 @@ function getNpubSuffix(config) {
   return npub.slice(-7);
 }
 async function startDaemonProcess() {
-  if (!existsSync3(LOGS_DIR2)) {
-    await Bun.$`mkdir -p ${LOGS_DIR2}`;
-  }
-  const proc = Bun.spawn(["bun", "run", `${import.meta.dir}/../daemon/index.ts`], {
-    stdout: "inherit",
-    stderr: "inherit",
-    stdin: "ignore",
-    detached: true
+  const config = await loadConfig();
+  await startDaemon({
+    port: String(config.port || 8008),
+    provider: config.provider || undefined
   });
-  proc.unref();
-  for (let i2 = 0;i2 < 50; i2++) {
-    await new Promise((resolve) => setTimeout(resolve, 100));
-    if (await isDaemonRunning()) {
-      return;
-    }
-  }
-  throw new Error("Daemon failed to start within 5 seconds");
 }
 async function ensureDaemonRunning() {
   if (await isDaemonRunning()) {
@@ -9386,6 +9626,7 @@ async function handleDaemonCommand(path, options = {}) {
   }
 }
 var init_daemon_client = __esm(() => {
+  init_start_daemon();
   init_config();
   init_nip98();
 });
@@ -14667,157 +14908,24 @@ var {
   Help
 } = import__.default;
 
-// src/utils/logger.ts
-import { appendFile, mkdir } from "fs/promises";
-import { existsSync } from "fs";
-import { join } from "path";
-var HOME = process.env.HOME || process.env.USERPROFILE || "";
-var LOG_DIR = process.env.ROUTSTRD_DIR || `${HOME}/.routstrd`;
-var LOGS_DIR = join(LOG_DIR, "logs");
-function getLogFileForDate(date = new Date) {
-  const year = date.getFullYear();
-  const month = String(date.getMonth() + 1).padStart(2, "0");
-  const day = String(date.getDate()).padStart(2, "0");
-  return join(LOGS_DIR, `${year}-${month}-${day}.log`);
-}
-async function ensureLogDir() {
-  if (!existsSync(LOGS_DIR)) {
-    await mkdir(LOGS_DIR, { recursive: true });
-  }
-}
-async function writeLog(level, ...args) {
-  await ensureLogDir();
-  const timestamp = new Date().toISOString();
-  const message = args.map((a) => {
-    if (a instanceof Error) {
-      return `${a.message}${a.stack ? `
-${a.stack}` : ""}`;
-    }
-    if (typeof a === "object") {
-      try {
-        return JSON.stringify(a);
-      } catch {
-        return String(a);
-      }
-    }
-    return String(a);
-  }).join(" ");
-  const line = `[${timestamp}] [${level}] ${message}
-`;
-  const logFile = getLogFileForDate(new Date(timestamp));
-  try {
-    await appendFile(logFile, line);
-  } catch (error) {
-    console.error("Failed to write log:", error);
-  }
-}
-var logger = {
-  log: (...args) => {
-    console.log(...args);
-    writeLog("INFO", ...args);
-  },
-  debug: (...args) => {
-    writeLog("DEBUG", ...args);
-  },
-  error: (...args) => {
-    console.error(...args);
-    writeLog("ERROR", ...args);
-  },
-  info: (...args) => {
-    console.log(...args);
-    writeLog("INFO", ...args);
-  }
-};
-
-// src/start-daemon.ts
-init_config();
-import { existsSync as existsSync2 } from "fs";
-function getTodayLogFile() {
-  const now = new Date;
-  const year = now.getFullYear();
-  const month = String(now.getMonth() + 1).padStart(2, "0");
-  const day = String(now.getDate()).padStart(2, "0");
-  return `${LOGS_DIR2}/${year}-${month}-${day}.log`;
-}
-async function startDaemon(options = {}) {
-  const args = [];
-  const port = options.port || "8008";
-  const pollIntervalMs = 250;
-  const startupTimeoutMs = 10 * 60 * 1000;
-  try {
-    const controller = new AbortController;
-    const timeoutId = setTimeout(() => controller.abort(), 2000);
-    const existing = await fetch(`http://localhost:${port}/health`, {
-      signal: controller.signal
-    });
-    clearTimeout(timeoutId);
-    if (existing.ok) {
-      logger.log(`Routstr daemon already running on http://localhost:${port}/v1`);
-      return;
-    }
-  } catch {
-  }
-  if (options.port) {
-    args.push("--port", options.port);
-  }
-  if (options.provider) {
-    args.push("--provider", options.provider);
-  }
-  if (!existsSync2(LOGS_DIR2)) {
-    await Bun.$`mkdir -p ${LOGS_DIR2}`;
-  }
-  const daemonScript = new URL("./daemon/index.js", import.meta.url).pathname;
-  const todayLogFile = getTodayLogFile();
-  const shellCmd = `bun run "${daemonScript}" ${args.map((a) => `'${a}'`).join(" ")} >> "${todayLogFile}" 2>&1`;
-  const proc = Bun.spawn(["sh", "-c", shellCmd], {
-    stdout: "inherit",
-    stderr: "inherit",
-    stdin: "ignore",
-    detached: true
-  });
-  proc.unref();
-  let exitCode = null;
-  proc.exited.then((code) => {
-    exitCode = code;
-  });
-  const maxPolls = Math.ceil(startupTimeoutMs / pollIntervalMs);
-  for (let i = 0;i < maxPolls; i++) {
-    await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
-    if (exitCode !== null) {
-      throw new Error(`Daemon process exited early with code ${exitCode}. Check logs in ${LOGS_DIR2}`);
-    }
-    try {
-      const controller = new AbortController;
-      const timeoutId = setTimeout(() => controller.abort(), 2000);
-      const res = await fetch(`http://localhost:${port}/health`, {
-        signal: controller.signal
-      });
-      clearTimeout(timeoutId);
-      if (res.ok) {
-        logger.log(`Routstr daemon started (PID: ${proc.pid}).`);
-        return;
-      }
-    } catch {
-    }
-  }
-  throw new Error(`Daemon failed to start within ${Math.round(startupTimeoutMs / 1000)} seconds. Check logs in ${LOGS_DIR2}`);
-}
-
 // src/cli.ts
+init_start_daemon();
 init_daemon_client();
 
 // src/utils/clients.ts
 init_daemon_client();
 init_nip98();
+init_logger();
 
 // src/integrations/registry.ts
 import { join as join3 } from "path";
 
 // src/integrations/opencode.ts
-import { existsSync as existsSync4, mkdirSync } from "fs";
-import { readFile, writeFile } from "fs/promises";
-import { dirname } from "path";
+init_logger();
 init_daemon_client();
+import { existsSync as existsSync4, mkdirSync } from "fs";
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname2 } from "path";
 var OPENCODE_SMALL_MODEL = "routstr/minimax-m2.5";
 async function installOpencodeIntegration(config, apiKey, integrationConfig) {
   const { name, configPath } = integrationConfig;
@@ -14828,7 +14936,7 @@ Installing routstr models in opencode.json...`);
   let opencodeConfig;
   try {
     if (existsSync4(configPath)) {
-      const content = await readFile(configPath, "utf-8");
+      const content = await readFile2(configPath, "utf-8");
       opencodeConfig = JSON.parse(content);
     } else {
       opencodeConfig = { provider: {} };
@@ -14840,7 +14948,7 @@ Installing routstr models in opencode.json...`);
     opencodeConfig.provider = {};
   }
   try {
-    mkdirSync(dirname(configPath), { recursive: true });
+    mkdirSync(dirname2(configPath), { recursive: true });
     const data = await callDaemon("/models");
     const models = data.output?.models || [];
     if (models.length === 0) {
@@ -14862,7 +14970,7 @@ Installing routstr models in opencode.json...`);
       models: modelsObj
     };
     opencodeConfig.small_model = OPENCODE_SMALL_MODEL;
-    await writeFile(configPath, JSON.stringify(opencodeConfig, null, 2));
+    await writeFile2(configPath, JSON.stringify(opencodeConfig, null, 2));
     logger.log(`Added "routstr" provider with ${models.length} models to opencode.json`);
   } catch (error) {
     logger.error("Failed to install models in opencode.json:", error);
@@ -14870,10 +14978,11 @@ Installing routstr models in opencode.json...`);
 }
 
 // src/integrations/pi.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync2 } from "fs";
-import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
-import { dirname as dirname2 } from "path";
+init_logger();
 init_daemon_client();
+import { existsSync as existsSync5, mkdirSync as mkdirSync2 } from "fs";
+import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname3 } from "path";
 async function installPiIntegration(config, apiKey, integrationConfig) {
   const { name, configPath } = integrationConfig;
   logger.log(`
@@ -14883,7 +14992,7 @@ Installing routstr models in pi models.json...`);
   let piConfig = {};
   try {
     if (existsSync5(configPath)) {
-      const content = await readFile2(configPath, "utf-8");
+      const content = await readFile3(configPath, "utf-8");
       piConfig = JSON.parse(content);
     }
   } catch {
@@ -14893,7 +15002,7 @@ Installing routstr models in pi models.json...`);
     piConfig.providers = {};
   }
   try {
-    mkdirSync2(dirname2(configPath), { recursive: true });
+    mkdirSync2(dirname3(configPath), { recursive: true });
     const data = await callDaemon("/models");
     const models = data.output?.models || [];
     if (models.length === 0) {
@@ -14909,7 +15018,7 @@ Installing routstr models in pi models.json...`);
       apiKey,
       models: providerModels
     };
-    await writeFile2(configPath, JSON.stringify(piConfig, null, 2));
+    await writeFile3(configPath, JSON.stringify(piConfig, null, 2));
     logger.log(`Added "routstr" provider with ${models.length} models to pi models.json`);
   } catch (error) {
     logger.error("Failed to install models in pi models.json:", error);
@@ -14917,10 +15026,11 @@ Installing routstr models in pi models.json...`);
 }
 
 // src/integrations/openclaw.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync3 } from "fs";
-import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
-import { dirname as dirname3 } from "path";
+init_logger();
 init_daemon_client();
+import { existsSync as existsSync6, mkdirSync as mkdirSync3 } from "fs";
+import { readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
+import { dirname as dirname4 } from "path";
 var OPENCLAW_PROVIDER_ID = "routstr";
 var OPENCLAW_DEFAULT_PRIMARY_MODEL = "routstr/minimax-m2.5";
 var OPENCLAW_DEFAULT_FALLBACK_MODEL = "routstr/kimi-k2.5";
@@ -14933,7 +15043,7 @@ Installing routstr models in openclaw.json...`);
   let openclawConfig = {};
   try {
     if (existsSync6(configPath)) {
-      const content = await readFile3(configPath, "utf-8");
+      const content = await readFile4(configPath, "utf-8");
       openclawConfig = JSON.parse(content);
     }
   } catch {
@@ -14952,7 +15062,7 @@ Installing routstr models in openclaw.json...`);
     openclawConfig.agents.defaults = {};
   }
   try {
-    mkdirSync3(dirname3(configPath), { recursive: true });
+    mkdirSync3(dirname4(configPath), { recursive: true });
     const data = await callDaemon("/models");
     const models = data.output?.models || [];
     if (models.length === 0) {
@@ -14984,7 +15094,7 @@ Installing routstr models in openclaw.json...`);
         fallbacks: [OPENCLAW_DEFAULT_FALLBACK_MODEL]
       };
     }
-    await writeFile3(configPath, JSON.stringify(openclawConfig, null, 2));
+    await writeFile4(configPath, JSON.stringify(openclawConfig, null, 2));
     logger.log(`Added "${OPENCLAW_PROVIDER_ID}" provider with ${models.length} models to openclaw.json`);
   } catch (error) {
     logger.error("Failed to install models in openclaw.json:", error);
@@ -14992,10 +15102,11 @@ Installing routstr models in openclaw.json...`);
 }
 
 // src/integrations/claudecode.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync4 } from "fs";
-import { readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
-import { dirname as dirname4 } from "path";
+init_logger();
 init_daemon_client();
+import { existsSync as existsSync7, mkdirSync as mkdirSync4 } from "fs";
+import { readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
+import { dirname as dirname5 } from "path";
 async function installClaudeCodeIntegration(config, apiKey, integrationConfig) {
   const { name, configPath } = integrationConfig;
   logger.log(`
@@ -15005,7 +15116,7 @@ Installing routstr configuration in ${configPath}...`);
   let settings = {};
   try {
     if (existsSync7(configPath)) {
-      const content = await readFile4(configPath, "utf-8");
+      const content = await readFile5(configPath, "utf-8");
       settings = JSON.parse(content);
     }
   } catch (error) {
@@ -15040,8 +15151,8 @@ Installing routstr configuration in ${configPath}...`);
     logger.error("Failed to fetch models for Claude Code integration:", error);
   }
   try {
-    mkdirSync4(dirname4(configPath), { recursive: true });
-    await writeFile4(configPath, JSON.stringify(settings, null, 2));
+    mkdirSync4(dirname5(configPath), { recursive: true });
+    await writeFile5(configPath, JSON.stringify(settings, null, 2));
     logger.log(`Successfully updated ${configPath} with routstr settings.`);
   } catch (error) {
     logger.error(`Failed to write to ${configPath}:`, error);
@@ -15267,9 +15378,12 @@ async function addClientAction(options) {
 
 // src/cli.ts
 init_config();
+init_logger();
 import { existsSync as existsSync9, mkdirSync as mkdirSync5 } from "fs";
 import { execSync } from "child_process";
+
 // src/integrations/index.ts
+init_logger();
 function ask(question) {
   process.stdout.write(question);
   if (!process.stdin.isTTY) {
@@ -15413,6 +15527,8 @@ init_esm2();
 
 // src/daemon/wallet/cocod-client.ts
 import { existsSync as existsSync8 } from "fs";
+init_logger();
+init_process_lock();
 var DEFAULT_CONFIG_DIR = process.env.COCOD_DIR || `${process.env.HOME || process.env.USERPROFILE || ""}/.cocod`;
 var DEFAULT_SOCKET_PATH = process.env.COCOD_SOCKET || `${DEFAULT_CONFIG_DIR}/cocod.sock`;
 function resolveCocodExecutable(cocodPath) {
@@ -15438,7 +15554,7 @@ async function isCocodInstalled(cocodPath) {
 // package.json
 var package_default = {
   name: "routstrd",
-  version: "0.2.8",
+  version: "0.2.9",
   module: "src/index.ts",
   type: "module",
   private: false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "routstrd",
-  "version": "0.2.8",
+  "version": "0.2.9",
   "module": "src/index.ts",
   "type": "module",
   "private": false,