solvapay 1.0.1-preview.2

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 SolvaPay Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,19 @@
+# solvapay
+
+SolvaPay CLI.
+
+## Usage
+
+```bash
+# Run the SolvaPay CLI init flow
+npx solvapay init
+```
+
+## What `solvapay init` does
+
+- Checks for `package.json` (and can create one if missing)
+- Opens browser authentication and waits for approval
+- Writes `SOLVAPAY_SECRET_KEY` to `.env` (with overwrite confirmation)
+- Ensures `.env` is ignored in `.gitignore`
+- Installs `@solvapay/server` and `@solvapay/core`
+- Verifies the key and prints a quick-start snippet

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/cli.js

@@ -0,0 +1,573 @@
+#!/usr/bin/env node
+
+// src/lib/browser-auth.ts
+import open from "open";
+var INIT_EXCHANGE_TIMEOUT_MS = 10 * 60 * 1e3;
+var POLL_INTERVAL_MS = 2e3;
+var sleep = async (ms) => new Promise((resolve) => {
+  setTimeout(resolve, ms);
+});
+var startSpinner = (message) => {
+  const frames = ["|", "/", "-", "\\"];
+  let frameIndex = 0;
+  process.stdout.write(`${message} ${frames[frameIndex]}`);
+  const timer = setInterval(() => {
+    frameIndex = (frameIndex + 1) % frames.length;
+    process.stdout.write(`\r${message} ${frames[frameIndex]}`);
+  }, 100);
+  return {
+    stop: () => {
+      clearInterval(timer);
+      process.stdout.write(`\r${" ".repeat(message.length + 4)}\r`);
+    }
+  };
+};
+var createInitSession = async (apiBaseUrl) => {
+  const response = await fetch(`${apiBaseUrl}/v1/ui/provider/auth/cli-init/sessions`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({})
+  });
+  if (!response.ok) {
+    const body = await response.text();
+    throw new Error(`Failed to start init session (${response.status}): ${body}`);
+  }
+  return await response.json();
+};
+var openAuthUrl = async (authUrl) => {
+  try {
+    await open(authUrl);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var waitForExchange = async (apiBaseUrl, session) => {
+  const startedAt = Date.now();
+  const spinner = startSpinner("\u23F3 Waiting for authentication...");
+  try {
+    while (Date.now() - startedAt < INIT_EXCHANGE_TIMEOUT_MS) {
+      const response = await fetch(
+        `${apiBaseUrl}/v1/ui/provider/auth/cli-init/sessions/${encodeURIComponent(session.sessionId)}/exchange`,
+        {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${session.pollToken}`
+          }
+        }
+      );
+      if (response.status === 202 || response.status === 409) {
+        await sleep(POLL_INTERVAL_MS);
+        continue;
+      }
+      if (!response.ok) {
+        const body = await response.text();
+        throw new Error(`Init exchange failed (${response.status}): ${body}`);
+      }
+      const payload = await response.json();
+      if (payload.status === "pending") {
+        await sleep(POLL_INTERVAL_MS);
+        continue;
+      }
+      return payload;
+    }
+    return {
+      status: "expired"
+    };
+  } finally {
+    spinner.stop();
+  }
+};
+var verifySecretKey = async (apiBaseUrl, secretKey) => {
+  try {
+    const response = await fetch(`${apiBaseUrl}/v1/sdk/products`, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${secretKey}`
+      }
+    });
+    if (response.ok) {
+      return { ok: true };
+    }
+    const body = await response.text();
+    return {
+      ok: false,
+      warning: `Verification failed (${response.status}): ${body}`
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Network error";
+    return {
+      ok: false,
+      warning: `Verification failed due to network error: ${message}`
+    };
+  }
+};
+
+// src/commands/init.ts
+import chalk from "chalk";
+
+// src/lib/env.ts
+import { access, readFile, writeFile } from "fs/promises";
+import { constants } from "fs";
+import path from "path";
+import readline from "readline/promises";
+import { stdin, stdout } from "process";
+var SOLVAPAY_SECRET_KEY = "SOLVAPAY_SECRET_KEY";
+var envKeyRegex = new RegExp(`^\\s*${SOLVAPAY_SECRET_KEY}\\s*=`, "m");
+var normalizeTrailingNewline = (content) => content.endsWith("\n") ? content : `${content}
+`;
+var askOverwrite = async () => {
+  const rl = readline.createInterface({ input: stdin, output: stdout });
+  try {
+    const answer = (await rl.question(
+      "You're already set up. Overwrite SOLVAPAY_SECRET_KEY? (y/N) "
+    )).trim().toLowerCase();
+    return answer === "y" || answer === "yes";
+  } finally {
+    rl.close();
+  }
+};
+var hasEnvGitignoreEntry = (content) => content.split("\n").map((line) => line.trim()).some((line) => line === ".env" || line === "/.env");
+var ensureEnvInGitignore = async (cwd = process.cwd()) => {
+  const gitignorePath = path.join(cwd, ".gitignore");
+  const exists = await envFileExists(gitignorePath);
+  if (!exists) {
+    await writeFile(gitignorePath, ".env\n", "utf8");
+    return { filePath: gitignorePath, action: "created" };
+  }
+  const currentContent = await readFile(gitignorePath, "utf8");
+  if (hasEnvGitignoreEntry(currentContent)) {
+    return { filePath: gitignorePath, action: "unchanged" };
+  }
+  const next = `${normalizeTrailingNewline(currentContent)}.env
+`;
+  await writeFile(gitignorePath, next, "utf8");
+  return { filePath: gitignorePath, action: "appended" };
+};
+var envFileExists = async (envPath) => {
+  try {
+    await access(envPath, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var writeSolvaPaySecretToEnv = async (secretKey, options = {}) => {
+  const envPath = path.join(options.cwd || process.cwd(), ".env");
+  const keyLine = `${SOLVAPAY_SECRET_KEY}=${secretKey}`;
+  const exists = await envFileExists(envPath);
+  if (!exists) {
+    await writeFile(envPath, `${keyLine}
+`, "utf8");
+    return { filePath: envPath, action: "created" };
+  }
+  const currentContent = await readFile(envPath, "utf8");
+  if (!envKeyRegex.test(currentContent)) {
+    const next = `${normalizeTrailingNewline(currentContent)}${keyLine}
+`;
+    await writeFile(envPath, next, "utf8");
+    return { filePath: envPath, action: "appended" };
+  }
+  const shouldOverwrite = options.confirmOverwrite ? await options.confirmOverwrite() : await askOverwrite();
+  if (!shouldOverwrite) {
+    return { filePath: envPath, action: "unchanged" };
+  }
+  const updatedContent = currentContent.replace(
+    /^\s*SOLVAPAY_SECRET_KEY\s*=.*$/m,
+    keyLine
+  );
+  await writeFile(envPath, updatedContent, "utf8");
+  return { filePath: envPath, action: "updated" };
+};
+
+// src/lib/install.ts
+import { spawn } from "child_process";
+var MAX_ERROR_LOG_LINES = 30;
+var DEFAULT_DIST_TAG = "latest";
+var SOLVAPAY_BASE_PACKAGES = ["@solvapay/server", "@solvapay/core", "@solvapay/auth"];
+var getSolvaPayBasePackages = () => [...SOLVAPAY_BASE_PACKAGES];
+var getPackageSpecifiers = async () => {
+  const distTag = DEFAULT_DIST_TAG;
+  return SOLVAPAY_BASE_PACKAGES.map((pkg) => `${pkg}@${distTag}`);
+};
+var getInstallCommand = async (packageManager) => {
+  const packageSpecifiers = await getPackageSpecifiers();
+  const packageArgs = packageSpecifiers.join(" ");
+  if (packageManager === "yarn") {
+    return `yarn add ${packageArgs}`;
+  }
+  if (packageManager === "pnpm") {
+    return `pnpm add ${packageArgs}`;
+  }
+  return `npm install ${packageArgs}`;
+};
+var getInstallArgs = (packageManager, packageSpecifiers) => {
+  if (packageManager === "yarn") {
+    return ["add", ...packageSpecifiers];
+  }
+  if (packageManager === "pnpm") {
+    return ["add", ...packageSpecifiers];
+  }
+  return ["install", ...packageSpecifiers];
+};
+var ANSI_ESCAPE_RE = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
+var trimLine = (line) => line.replace(ANSI_ESCAPE_RE, "").trim();
+var parsePnpmProgress = (line) => {
+  const progressMatch = line.match(/Progress:\s*resolved\s+(\d+).+downloaded\s+(\d+).+added\s+(\d+)/);
+  if (progressMatch) {
+    const [, resolved, downloaded, added] = progressMatch;
+    return `Installing packages (${added} added, ${downloaded} downloaded, ${resolved} resolved)`;
+  }
+  if (line.includes("Progress:")) {
+    return "Installing packages";
+  }
+  if (line.includes("Done in")) {
+    return "Finalizing install";
+  }
+  return null;
+};
+var parseYarnProgress = (line) => {
+  if (/\[\d+\/\d+\]\s+Resolving packages/.test(line) || line.includes("Resolution step")) {
+    return "Resolving packages";
+  }
+  if (/\[\d+\/\d+\]\s+Fetching packages/.test(line) || line.includes("Fetch step")) {
+    return "Downloading packages";
+  }
+  if (/\[\d+\/\d+\]\s+Linking dependencies/.test(line) || line.includes("Link step")) {
+    return "Linking dependencies";
+  }
+  if (/\[\d+\/\d+\]\s+Building fresh packages/.test(line) || line.includes("Building packages")) {
+    return "Building packages";
+  }
+  if (line.includes("Done in") || line.toLowerCase().includes("done with warnings")) {
+    return "Finalizing install";
+  }
+  return null;
+};
+var parseNpmProgress = (line) => {
+  const lower = line.toLowerCase();
+  if (lower.includes("idealtree")) {
+    return "Resolving packages";
+  }
+  if (lower.includes("reify")) {
+    return "Installing packages";
+  }
+  if (lower.startsWith("added ") || lower.includes("audited ")) {
+    return "Finalizing install";
+  }
+  return null;
+};
+var getProgressMessage = (packageManager, rawLine) => {
+  const line = trimLine(rawLine);
+  if (!line) {
+    return null;
+  }
+  if (packageManager === "pnpm") {
+    return parsePnpmProgress(line);
+  }
+  if (packageManager === "yarn") {
+    return parseYarnProgress(line);
+  }
+  return parseNpmProgress(line);
+};
+var installSolvaPaySdk = async (packageManager, cwd = process.cwd(), onProgress) => {
+  const packageSpecifiers = await getPackageSpecifiers();
+  const command = await getInstallCommand(packageManager);
+  const errorLines = [];
+  let lastProgressMessage = "";
+  return new Promise((resolve) => {
+    const child = spawn(packageManager, getInstallArgs(packageManager, packageSpecifiers), {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      shell: process.platform === "win32"
+    });
+    const recordLine = (line) => {
+      const trimmed = trimLine(line);
+      if (!trimmed) {
+        return;
+      }
+      errorLines.push(trimmed);
+      if (errorLines.length > MAX_ERROR_LOG_LINES) {
+        errorLines.shift();
+      }
+    };
+    const emitProgress = (line) => {
+      const message = getProgressMessage(packageManager, line);
+      if (!message || message === lastProgressMessage) {
+        return;
+      }
+      lastProgressMessage = message;
+      onProgress?.(message);
+    };
+    const handleChunk = (chunk) => {
+      const text = chunk.toString("utf8");
+      const lines = text.split(/\r?\n|\r/g);
+      for (const line of lines) {
+        recordLine(line);
+        emitProgress(line);
+      }
+    };
+    child.stdout?.on("data", handleChunk);
+    child.stderr?.on("data", handleChunk);
+    child.once("error", (error) => {
+      resolve({
+        ok: false,
+        command,
+        warning: error.message
+      });
+    });
+    child.once("close", (code) => {
+      if (code === 0) {
+        resolve({ ok: true, command });
+        return;
+      }
+      resolve({
+        ok: false,
+        command,
+        warning: `Installer exited with code ${code ?? "unknown"}${errorLines.length ? `
+${errorLines.join("\n")}` : ""}`
+      });
+    });
+  });
+};
+
+// src/lib/project.ts
+import { access as access2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { constants as constants2 } from "fs";
+import path2 from "path";
+import readline2 from "readline/promises";
+import { stdin as stdin2, stdout as stdout2 } from "process";
+var fileExists = async (filePath) => {
+  try {
+    await access2(filePath, constants2.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var toPackageName = (cwd) => {
+  const baseName = path2.basename(cwd);
+  const sanitized = baseName.toLowerCase().replace(/[^a-z0-9._-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  return sanitized || "solvapay-app";
+};
+var askCreatePackageJson = async () => {
+  const rl = readline2.createInterface({ input: stdin2, output: stdout2 });
+  try {
+    const answer = (await rl.question("No package.json found. Create one now? (y/N) ")).trim().toLowerCase();
+    return answer === "y" || answer === "yes";
+  } finally {
+    rl.close();
+  }
+};
+var ensureNodeProject = async (options = {}) => {
+  const cwd = options.cwd || process.cwd();
+  const packageJsonPath = path2.join(cwd, "package.json");
+  if (await fileExists(packageJsonPath)) {
+    return { filePath: packageJsonPath, action: "existing" };
+  }
+  const shouldCreate = options.confirmCreate ? await options.confirmCreate() : await askCreatePackageJson();
+  if (!shouldCreate) {
+    return { filePath: packageJsonPath, action: "cancelled" };
+  }
+  const packageJson = {
+    name: toPackageName(cwd),
+    version: "1.0.0",
+    private: true
+  };
+  await writeFile2(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}
+`, "utf8");
+  return { filePath: packageJsonPath, action: "created" };
+};
+var detectPackageManager = async (cwd = process.cwd()) => {
+  const lockfiles = [
+    { file: "pnpm-lock.yaml", packageManager: "pnpm" },
+    { file: "yarn.lock", packageManager: "yarn" },
+    { file: "package-lock.json", packageManager: "npm" },
+    { file: "npm-shrinkwrap.json", packageManager: "npm" }
+  ];
+  let currentDir = path2.resolve(cwd);
+  while (true) {
+    for (const lockfile of lockfiles) {
+      if (await fileExists(path2.join(currentDir, lockfile.file))) {
+        return lockfile.packageManager;
+      }
+    }
+    const packageJsonPath = path2.join(currentDir, "package.json");
+    if (await fileExists(packageJsonPath)) {
+      try {
+        const packageJson = JSON.parse(await readFile2(packageJsonPath, "utf8"));
+        if (packageJson.packageManager?.startsWith("pnpm@")) return "pnpm";
+        if (packageJson.packageManager?.startsWith("yarn@")) return "yarn";
+        if (packageJson.packageManager?.startsWith("npm@")) return "npm";
+      } catch {
+      }
+    }
+    const parentDir = path2.dirname(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+  return "npm";
+};
+
+// src/commands/init.ts
+var DEFAULT_API_BASE_URL = "https://api.solvapay.com";
+var resolveApiBaseUrl = () => (process.env.SOLVAPAY_API_BASE_URL || DEFAULT_API_BASE_URL).replace(/\/$/, "");
+var ASCII_BANNER = ` ____        _            ____
+/ ___|  ___ | |_   ____ _|  _ \\ __ _ _   _
+\\___ \\ / _ \\| \\ \\ / / _\` | |_) / _\` | | | |
+ ___) | (_) | |\\ V / (_| |  __/ (_| | |_| |
+|____/ \\___/|_| \\_/ \\__,_|_|   \\__,_|\\__, |
+                                      |___/`;
+var printBanner = () => {
+  process.stdout.write(`${chalk.cyanBright(ASCII_BANNER)}
+
+`);
+};
+var printQuickStart = () => {
+  process.stdout.write(`
+You're all set! Here's how to get started:
+
+  import { SolvaPay } from '@solvapay/server';
+  const sp = new SolvaPay();
+
+Docs: https://docs.solvapay.com
+`);
+};
+var createInstallProgressReporter = () => {
+  if (!process.stdout.isTTY) {
+    return (message) => {
+      process.stdout.write(`\u{1F4E6} ${message}
+`);
+    };
+  }
+  let lastRenderedLength = 0;
+  return (message) => {
+    const line = `\u{1F4E6} ${message}`;
+    const paddedLine = line.length < lastRenderedLength ? `${line}${" ".repeat(lastRenderedLength - line.length)}` : line;
+    process.stdout.write(`\r${paddedLine}`);
+    lastRenderedLength = line.length;
+  };
+};
+var finishInstallProgressReporter = () => {
+  if (process.stdout.isTTY) {
+    process.stdout.write("\n");
+  }
+};
+var runInitCommand = async () => {
+  const apiBaseUrl = resolveApiBaseUrl();
+  const cwd = process.cwd();
+  printBanner();
+  const projectCheck = await ensureNodeProject();
+  if (projectCheck.action === "cancelled") {
+    process.stdout.write("Initialization cancelled. Run `npm init -y` first, then `solvapay init`.\n");
+    return;
+  }
+  const packageManager = await detectPackageManager(cwd);
+  if (projectCheck.action === "created") {
+    process.stdout.write(`\u{1F50D} Detected ${packageManager} project (package.json created)
+`);
+  } else {
+    process.stdout.write(`\u{1F50D} Detected ${packageManager} project (package.json found)
+`);
+  }
+  process.stdout.write("\u{1F310} Opening browser for authentication...\n");
+  const initSession = await createInitSession(apiBaseUrl);
+  const opened = await openAuthUrl(initSession.authUrl);
+  if (!opened) {
+    process.stdout.write(`   If it doesn't open, visit: ${initSession.authUrl}
+`);
+  }
+  const exchange = await waitForExchange(apiBaseUrl, initSession);
+  if (exchange.status === "cancelled") {
+    throw new Error("Authentication was cancelled. Run `solvapay init` again when you are ready.");
+  }
+  if (exchange.status === "expired") {
+    throw new Error(
+      "Timed out after 10 minutes waiting for authentication. Run `solvapay init` again."
+    );
+  }
+  if (exchange.status !== "complete" || !exchange.secretKey) {
+    throw new Error("Could not retrieve a SolvaPay secret key from the init session.");
+  }
+  if (exchange.email) {
+    process.stdout.write(`\u2705 Authenticated as ${exchange.email}
+`);
+  } else {
+    process.stdout.write("\u2705 Authenticated\n");
+  }
+  const envWrite = await writeSolvaPaySecretToEnv(exchange.secretKey);
+  if (envWrite.action === "created" || envWrite.action === "appended" || envWrite.action === "updated") {
+    process.stdout.write("\u{1F4DD} Secret key saved to .env\n");
+  } else {
+    process.stdout.write("\u{1F4DD} Kept existing SOLVAPAY_SECRET_KEY in .env\n");
+  }
+  const gitignoreWrite = await ensureEnvInGitignore(cwd);
+  if (gitignoreWrite.action === "created" || gitignoreWrite.action === "appended") {
+    process.stdout.write("\u{1F512} Added .env to .gitignore\n");
+  }
+  const onInstallProgress = createInstallProgressReporter();
+  onInstallProgress("Resolving packages");
+  const installResult = await installSolvaPaySdk(packageManager, cwd, onInstallProgress);
+  finishInstallProgressReporter();
+  if (installResult.ok) {
+    process.stdout.write("\u2705 SolvaPay SDK packages installed\n");
+    const installedPackages = getSolvaPayBasePackages();
+    const packageList = installedPackages.join(", ");
+    process.stdout.write(`\u{1F4E6} Added ${installedPackages.length} packages: ${packageList}
+`);
+  } else {
+    const manualInstallCommand = await getInstallCommand(packageManager);
+    process.stdout.write(
+      `\u26A0\uFE0F Install failed (${installResult.warning || "unknown error"}). Run manually: ${manualInstallCommand}
+`
+    );
+  }
+  const verified = await verifySecretKey(apiBaseUrl, exchange.secretKey);
+  if (verified.ok) {
+    process.stdout.write("\u2705 Secret key verified with SolvaPay\n");
+  } else {
+    process.stdout.write(
+      `\u26A0\uFE0F Verification failed, but setup can still continue. Details: ${verified.warning}
+`
+    );
+  }
+  process.stdout.write("\n");
+  printQuickStart();
+};
+
+// src/cli.ts
+var HELP_TEXT = `SolvaPay CLI
+
+Usage:
+  solvapay <command>
+
+Commands:
+  init    Authenticate, configure .env, and install SolvaPay SDK packages
+`;
+var main = async () => {
+  const command = process.argv[2];
+  if (!command || command === "--help" || command === "-h") {
+    process.stdout.write(`${HELP_TEXT}
+`);
+    return;
+  }
+  if (command === "init") {
+    await runInitCommand();
+    return;
+  }
+  process.stderr.write(`Unknown command: ${command}
+
+${HELP_TEXT}
+`);
+  process.exitCode = 1;
+};
+main().catch((error) => {
+  const message = error instanceof Error ? error.message : "Unknown error";
+  process.stderr.write(`Error: ${message}
+`);
+  process.exitCode = 1;
+});

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "solvapay",
+  "version": "1.0.1-preview.2",
+  "description": "SolvaPay CLI",
+  "type": "module",
+  "bin": {
+    "solvapay": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/solvapay/solvapay-sdk.git",
+    "directory": "packages/cli"
+  },
+  "engines": {
+    "node": ">=18.17"
+  },
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "commander": "^14.0.3",
+    "detect-package-manager": "^3.0.2",
+    "fs-extra": "^11.3.4",
+    "inquirer": "^13.3.2",
+    "open": "^11.0.0",
+    "ora": "^9.3.0",
+    "@solvapay/auth": "^1.0.1-preview.2",
+    "@solvapay/core": "^1.0.1-preview.2",
+    "@solvapay/server": "^1.0.1-preview.2"
+  },
+  "devDependencies": {
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.2"
+  },
+  "scripts": {
+    "build": "tsup --config tsup.config.ts",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint src",
+    "lint:fix": "eslint src --fix"
+  }
+}