@envsafes-org/cli 0.0.6 → 0.0.7

package/package.json

@@ -1,11 +1,14 @@
 {
     "name": "@envsafes-org/cli",
-    "version": "0.0.6",
+    "version": "0.0.7",
     "description": "CLI pour EnvSafe - Gestionnaire sécurisé de variables d'environnement",
     "main": "dist/index.js",
     "bin": {
         "envsafe": "./dist/index.js"
     },
+    "files": [
+        "dist"
+    ],
     "repository": {
         "type": "git",
         "url": "git+https://github.com/Ifiboys/envsafe-cli.git"

package/STORAGE_AGENT_README.md

@@ -1,328 +0,0 @@
-# EnvSafe Storage Agent (BYOS)
-
-Agent simple pour héberger vos secrets chiffrés EnvSafe sur votre propre infrastructure.
-
-## Qu'est-ce que c'est ?
-
-Cet agent vous permet de stocker vos secrets chiffrés sur **votre propre serveur** au lieu du cloud EnvSafe, tout en continuant à utiliser l'interface EnvSafe et la CLI.
-
-## ⚠  Rappel Important de Sécurité
-
-**Même avec cet agent sur votre serveur, vos données sont DÉJÀ chiffrées (AES-256-GCM).** 
-
-- **Cet agent ne peut PAS lire vos secrets**
-- Il stocke uniquement du texte illisible
-- **Seule votre clé privée locale peut déchiffrer les données**
-- EnvSafe (SaaS) ne peut pas non plus lire vos secrets
-
-## Installation
-
-### Prérequis
-
-- Docker et Docker Compose
-- Node.js 18+ (si vous lancez sans Docker)
-
-### Avec Docker (Recommandé)
-
-```bash
-# Cloner ce dépôt
-git clone https://github.com/Ifiboys/envsafe-storage-agent
-cd envsafe-storage-agent
-
-# Configurer les variables d'environnement
-cp .env.example .env
-# Éditez .env et définissez AUTH_SECRET avec une valeur très sécurisée
-
-# Lancer l'agent
-docker-compose up -d
-```
-
-### Sans Docker
-
-```bash
-npm install
-npm run build
-npm start
-```
-
-## Configuration
-
-### Variables d'environnement
-
-```bash
-# SECRET PARTAGÉ - Utilisez un générateur de mots de passe sécurisé
-AUTH_SECRET=your-very-long-and-secure-secret-here
-
-# Port d'écoute
-PORT=3001
-
-# Base de données (SQLite par défaut, PostgreSQL recommandé en production)
-DATABASE_URL=file:./envsafe-storage.db
-# Exemple PostgreSQL:
-# DATABASE_URL=postgresql://user:password@localhost:5432/envsafe_storage
-```
-
-### Génération du secret
-
-```bash
-# Utilisez cette commande pour générer un secret sécurisé:
-openssl rand -hex 32
-```
-
-## Configuration dans EnvSafe
-
-1. Allez dans votre projet EnvSafe
-2. Paramètres → Stockage
-3. Activez **"Stockage Externe (BYOS)"**
-4. Renseignez:
-   - **URL**: `https://votre-serveur.com` (l'URL où votre agent est accessible)
-   - **Secret**: Le même `AUTH_SECRET` que vous avez défini dans `.env`
-5. Cliquez sur **"Tester la connexion"**
-6. Si le test est réussi, sauvegardez
-
-## API Endpoints
-
-L'agent expose ces routes (toutes protégées par authentification):
-
-- `GET /health` - Vérification de la santé de l'agent
-- `POST /store-secret` - Stocke un secret chiffré
-- `GET /get-secret` - Récupère un secret chiffré
-- `GET /get-all-secrets` - Récupère tous les secrets d'un environnement
-- `DELETE /delete-secret` - Supprime un secret
-
-## Exemple de Code de l'Agent
-
-Voici un exemple complet d'agent de stockage (Node.js + Express):
-
-```typescript
-import express, { Request, Response } from "express";
-import crypto from "crypto";
-import { PrismaClient } from "@prisma/client";
-
-const app = express();
-const prisma = new PrismaClient();
-
-app.use(express.json());
-
-// ⚠️ IMPORTANT: Cet agent stocke UNIQUEMENT des données CHIFFRÉES
-// Il ne peut PAS lire vos secrets
-
-// Middleware d'authentification
-const authenticate = (req: Request, res: Response, next: Function) => {
-    const authHeader = req.headers.authorization;
-    const timestamp = req.headers["x-envsafe-timestamp"] as string;
-    const signature = req.headers["x-envsafe-signature"] as string;
-
-    if (!authHeader || !timestamp || !signature) {
-        return res.status(401).json({ error: "Missing authentication headers" });
-    }
-
-    const token = authHeader.replace("Bearer ", "");
-    const expectedSecret = process.env.AUTH_SECRET;
-
-    if (!expectedSecret) {
-        console.error("AUTH_SECRET not configured");
-        return res.status(500).json({ error: "Server misconfiguration" });
-    }
-
-    // Vérifier le token
-    if (token !== expectedSecret) {
-        console.warn(`Failed authentication attempt from ${req.ip}`);
-        return res.status(401).json({ error: "Invalid token" });
-    }
-
-    // Vérifier la signature HMAC
-    const expectedSignature = crypto
-        .createHmac("sha256", expectedSecret)
-        .update(timestamp)
-        .digest("hex");
-
-    if (signature !== expectedSignature) {
-        console.warn(`Invalid HMAC signature from ${req.ip}`);
-        return res.status(401).json({ error: "Invalid signature" });
-    }
-
-    // Vérifier que le timestamp n'est pas trop ancien (5 minutes max)
-    const now = Date.now();
-    const requestTime = parseInt(timestamp);
-    if (Math.abs(now - requestTime) > 5 * 60 * 1000) {
-        return res.status(401).json({ error: "Request expired" });
-    }
-
-    next();
-};
-
-// Health check
-app.get("/health", authenticate, (req: Request, res: Response) => {
-    res.json({ 
-        status: "healthy",
-        timestamp: new Date().toISOString(),
-        version: "1.0.0"
-    });
-});
-
-// Stocker un secret chiffré
-app.post("/store-secret", authenticate, async (req: Request, res: Response) => {
-    const { key, encryptedValue, environmentId } = req.body;
-
-    if (!key || !encryptedValue || !environmentId) {
-        return res.status(400).json({ error: "Missing required fields" });
-    }
-
-    try {
-        // Note: encryptedValue est déjà chiffré par le client
-        // L'agent ne fait que le stocker, il ne peut pas le lire
-        await prisma.encryptedVariable.upsert({
-            where: {
-                environmentId_key: { environmentId, key }
-            },
-            create: { key, encryptedValue, environmentId },
-            update: { encryptedValue }
-        });
-
-        console.log(`✅ Stored encrypted variable: ${key} for env: ${environmentId}`);
-        res.json({ success: true });
-    } catch (error) {
-        console.error("Error storing variable:", error);
-        res.status(500).json({ error: "Failed to store variable" });
-    }
-});
-
-// Récupérer un secret chiffré
-app.get("/get-secret", authenticate, async (req: Request, res: Response) => {
-    const { key, environmentId } = req.query;
-
-    if (!key || !environmentId) {
-        return res.status(400).json({ error: "Missing required parameters" });
-    }
-
-    try {
-        const variable = await prisma.encryptedVariable.findUnique({
-            where: {
-                environmentId_key: {
-                    environmentId: environmentId as string,
-                    key: key as string
-                }
-            }
-        });
-
-        if (!variable) {
-            return res.status(404).json({ error: "Variable not found" });
-        }
-
-        // Retourne la valeur chiffrée (toujours illisible)
-        res.json({ encryptedValue: variable.encryptedValue });
-    } catch (error) {
-        console.error("Error getting variable:", error);
-        res.status(500).json({ error: "Failed to get variable" });
-    }
-});
-
-const PORT = process.env.PORT || 3001;
-
-app.listen(PORT, () => {
-    console.log(`🔐 EnvSafe Storage Agent running on port ${PORT}`);
-    console.log(`⚠️  Reminder: This agent stores ENCRYPTED data only`);
-    console.log(`⚠️  Even with database access, secrets remain unreadable`);
-});
-```
-
-### Schéma Prisma pour l'agent
-
-```prisma
-// prisma/schema.prisma (pour l'agent de stockage)
-
-datasource db {
-  provider = "postgresql"
-  url      = env("DATABASE_URL")
-}
-
-generator client {
-  provider = "prisma-client-js"
-}
-
-model EncryptedVariable {
-  id             String   @id @default(cuid())
-  key            String
-  encryptedValue String   @map("encrypted_value") // Toujours chiffré (AES-256-GCM)
-  environmentId  String   @map("environment_id")
-  
-  createdAt      DateTime @default(now()) @map("created_at")
-  updatedAt      DateTime @updatedAt @map("updated_at")
-
-  @@unique([environmentId, key])
-  @@map("encrypted_variables")
-}
-```
-
-## Sécurité
-
-### Authentification
-
-Toutes les requêtes doivent inclure:
-- `Authorization: Bearer <AUTH_SECRET>`
-- `X-EnvSafe-Timestamp: <timestamp>`
-- `X-EnvSafe-Signature: <HMAC-SHA256>`
-
-### Ce que l'agent NE FAIT PAS
-
-- ❌ Il ne stocke PAS de secrets en clair
-- ❌ Il ne peut PAS déchiffrer vos données
-- ❌ Il n'a PAS accès à vos clés de déchiffrement
-
-### Ce qu'il FAIT
-
-- ✅ Il stocke des blobs chiffrés (texte illisible)
-- ✅ Il vérifie l'authentification HMAC des requêtes
-- ✅ Il refuse les requêtes non autorisées
-
-## Production
-
-### Recommandations
-
-1. **HTTPS Obligatoire** : Utilisez un reverse proxy (Nginx, Caddy) avec certificat SSL
-2. **Base de données externe** : Utilisez PostgreSQL au lieu de SQLite
-3. **Firewall** : Limitez l'accès à l'IP du serveur EnvSafe
-4. **Backups** : Configurez des sauvegardes régulières de votre base de données
-5. **Monitoring** : Surveillez les logs et les tentatives d'accès
-
-### Exemple Nginx
-
-```nginx
-server {
-    listen 443 ssl http2;
-    server_name envsafe-storage.votre-domaine.com;
-
-    ssl_certificate /etc/letsencrypt/live/votre-domaine.com/fullchain.pem;
-    ssl_certificate_key /etc/letsencrypt/live/votre-domaine.com/privkey.pem;
-
-    location / {
-        proxy_pass http://localhost:3001;
-        proxy_set_header Host $host;
-        proxy_set_header X-Real-IP $remote_addr;
-    }
-}
-```
-
-## Logs
-
-Les logs de l'agent incluent:
-- Tentatives d'authentification (succès/échecs)
-- Opérations de stockage/récupération
-- Erreurs système
-
-```bash
-# Voir les logs en temps réel
-docker-compose logs -f
-```
-
-## Support
-
-Pour toute question ou problème:
-- Documentation: https://envsafe.vercel.app/docs
-- Issues: https://github.com/Ifiboys/envsafe-storage-agent/issues
-- Email: oladokunefi123@gmail.com
-
-## Licence
-
-MIT - Voir LICENSE

package/src/commands/login.ts

@@ -1,58 +0,0 @@
-import chalk from "chalk";
-import inquirer from "inquirer";
-import { config } from "../index.js";
-import { apiRequest } from "../utils/api.js";
-
-import open from "open";
-
-export async function login(options: { token?: string }) {
-    let token = options.token;
-
-    if (!token) {
-        const dashboardUrl = config.get("dashboardUrl") as string;
-        const loginUrl = `${dashboardUrl}/dashboard?redirect=tokens`;
-
-        console.log(chalk.cyan(`\nOuverture du navigateur pour générer un token...\n`));
-        console.log(chalk.dim(`Si le navigateur ne s'ouvre pas, visitez : ${loginUrl}`));
-
-        try {
-            await open(loginUrl);
-        } catch (err) {
-            // Ignore error if browser fails to open
-        }
-
-        const answers = await inquirer.prompt([
-            {
-                type: "password",
-                name: "token",
-                message: "Collez votre token API EnvSafe ici:",
-                mask: "*",
-                validate: (input) => input.length > 0 || "Le token est requis",
-            },
-        ]);
-        token = answers.token;
-    }
-
-    console.log(chalk.dim("Vérification du token..."));
-
-    try {
-        // Test the token
-        const response = await apiRequest("/api/v1/projects", {
-            method: "GET",
-            token,
-        });
-
-        if (response.error) {
-            console.log(chalk.red(`✗ Erreur: ${response.error}`));
-            return;
-        }
-
-        // Save token
-        config.set("token", token);
-
-        console.log(chalk.green("✓ Connexion réussie!"));
-        console.log(chalk.dim(`  ${response.count} projet(s) accessible(s)`));
-    } catch (error: any) {
-        console.log(chalk.red(`✗ Erreur de connexion: ${error.message}`));
-    }
-}

package/src/commands/projects.ts

@@ -1,40 +0,0 @@
-import chalk from "chalk";
-import { config } from "../index.js";
-import { apiRequest } from "../utils/api.js";
-
-export async function projects() {
-    const token = config.get("token") as string;
-
-    if (!token) {
-        console.log(chalk.red("✗ Non connecté. Utilisez 'envsafe login' d'abord."));
-        return;
-    }
-
-    try {
-        const response = await apiRequest("/api/v1/projects", {
-            method: "GET",
-            token,
-        });
-
-        if (response.error) {
-            console.log(chalk.red(`✗ ${response.error}`));
-            return;
-        }
-
-        console.log(chalk.cyan("\n📁 Projets accessibles\n"));
-
-        if (response.projects.length === 0) {
-            console.log(chalk.dim("  Aucun projet trouvé."));
-            return;
-        }
-
-        for (const project of response.projects) {
-            console.log(chalk.bold(`  ${project.name}`));
-            console.log(chalk.dim(`    slug: ${project.slug}`));
-            console.log(chalk.dim(`    envs: ${project.environments.join(", ")}`));
-            console.log("");
-        }
-    } catch (error: any) {
-        console.log(chalk.red(`✗ Erreur: ${error.message}`));
-    }
-}

package/src/commands/pull.ts

@@ -1,53 +0,0 @@
-import chalk from "chalk";
-import ora from "ora";
-import fs from "fs";
-import { config } from "../index.js";
-import { apiRequest } from "../utils/api.js";
-
-export async function pull(
-    project: string,
-    options: { env: string; output: string }
-) {
-    const token = config.get("token") as string;
-
-    if (!token) {
-        console.log(chalk.red("✗ Non connecté. Utilisez 'envsafe login' d'abord."));
-        return;
-    }
-
-    const spinner = ora(`Téléchargement des variables pour ${project} (${options.env})...`).start();
-
-    try {
-        const response = await apiRequest(`/api/v1/projects/${project}/${options.env}`, {
-            method: "GET",
-            token,
-        });
-
-        if (response.error) {
-            spinner.fail(chalk.red(response.error));
-
-            // Suggestion intelligente si l'utilisateur a confondu projet et environnement
-            const commonEnvs = ["development", "dev", "staging", "stg", "production", "prod", "test"];
-            if (commonEnvs.includes(project.toLowerCase()) || response.error.includes("trouvé")) {
-                console.log(chalk.yellow("\n💡 Astuce : La syntaxe est 'envsafe pull <MON_PROJET>'"));
-                console.log(chalk.yellow(`   Vous avez essayé de pull le projet "${project}".`));
-                console.log(chalk.yellow(`   Utilisez 'envsafe projects' pour voir la liste de vos projets/slugs.`));
-            }
-            return;
-        }
-
-        // Format as .env content
-        const envContent = Object.entries(response.variables as Record<string, string>)
-            .map(([key, value]) => `${key}="${value}"`)
-            .join("\n");
-
-        // Write to file
-        fs.writeFileSync(options.output, envContent + "\n");
-
-        spinner.succeed(
-            chalk.green(`✓ ${response.count} variable(s) téléchargée(s) vers ${options.output}`)
-        );
-    } catch (error: any) {
-        spinner.fail(chalk.red(`Erreur: ${error.message}`));
-    }
-}

package/src/commands/push.ts

@@ -1,64 +0,0 @@
-import chalk from "chalk";
-import ora from "ora";
-import fs from "fs";
-import dotenv from "dotenv";
-import { config } from "../index.js";
-import { apiRequest } from "../utils/api.js";
-
-export async function push(
-    project: string,
-    options: { env: string; file: string }
-) {
-    const token = config.get("token") as string;
-
-    if (!token) {
-        console.log(chalk.red("✗ Non connecté. Utilisez 'envsafe login' d'abord."));
-        return;
-    }
-
-    // Check if file exists
-    if (!fs.existsSync(options.file)) {
-        console.log(chalk.red(`✗ Fichier non trouvé: ${options.file}`));
-        return;
-    }
-
-    const spinner = ora(`Envoi des variables vers ${project} (${options.env})...`).start();
-
-    try {
-        // Parse .env file
-        const envContent = fs.readFileSync(options.file, "utf-8");
-        const parsed = dotenv.parse(envContent);
-
-        const response = await apiRequest(`/api/v1/projects/${project}/${options.env}`, {
-            method: "POST",
-            token,
-            body: { variables: parsed },
-        });
-
-        if (response.error) {
-            spinner.fail(chalk.red(response.error));
-
-            // Suggestion intelligente
-            const commonEnvs = ["development", "dev", "staging", "stg", "production", "prod", "test"];
-            if (commonEnvs.includes(project.toLowerCase()) || response.error.includes("trouvé")) {
-                console.log(chalk.yellow("\n💡 Astuce : La syntaxe est 'envsafe push <MON_PROJET>'"));
-                console.log(chalk.yellow(`   Vous avez essayé de push vers le projet "${project}".`));
-                console.log(chalk.yellow(`   Utilisez 'envsafe projects' pour voir la liste de vos projets/slugs.`));
-            }
-            return;
-        }
-
-        spinner.succeed(
-            chalk.green(`✓ ${response.created} variable(s) créée(s)`)
-        );
-
-        if (response.errors?.length > 0) {
-            console.log(chalk.yellow("\nAvertissements:"));
-            response.errors.forEach((err: string) => {
-                console.log(chalk.dim(`  - ${err}`));
-            });
-        }
-    } catch (error: any) {
-        spinner.fail(chalk.red(`Erreur: ${error.message}`));
-    }
-}

package/src/commands/run.ts

@@ -1,55 +0,0 @@
-import chalk from "chalk";
-import { spawn } from "child_process";
-import { config } from "../index.js";
-import { apiRequest } from "../utils/api.js";
-
-export async function run(
-    project: string,
-    command: string[],
-    options: { env: string }
-) {
-    const token = config.get("token") as string;
-
-    if (!token) {
-        console.log(chalk.red("✗ Non connecté. Utilisez 'envsafe login' d'abord."));
-        process.exit(1);
-    }
-
-    console.log(chalk.dim(`Récupération des variables pour ${project} (${options.env})...`));
-
-    try {
-        const response = await apiRequest(`/api/v1/projects/${project}/${options.env}`, {
-            method: "GET",
-            token,
-        });
-
-        if (response.error) {
-            console.log(chalk.red(`✗ ${response.error}`));
-            process.exit(1);
-        }
-
-        const variables = response.variables as Record<string, string>;
-        console.log(chalk.green(`✓ ${Object.keys(variables).length} variable(s) chargée(s)`));
-        console.log(chalk.dim(`Exécution: ${command.join(" ")}\n`));
-
-        // Spawn the command with injected env vars
-        const [cmd, ...args] = command;
-        const child = spawn(cmd, args, {
-            env: { ...process.env, ...variables },
-            stdio: "inherit",
-            shell: true,
-        });
-
-        child.on("close", (code) => {
-            process.exit(code ?? 0);
-        });
-
-        child.on("error", (err) => {
-            console.error(chalk.red(`Erreur d'exécution: ${err.message}`));
-            process.exit(1);
-        });
-    } catch (error: any) {
-        console.log(chalk.red(`✗ Erreur: ${error.message}`));
-        process.exit(1);
-    }
-}

package/src/commands/whoami.ts

@@ -1,33 +0,0 @@
-import chalk from "chalk";
-import { config } from "../index.js";
-import { apiRequest } from "../utils/api.js";
-
-export async function whoami() {
-    const token = config.get("token") as string;
-    const apiUrl = config.get("apiUrl") as string;
-
-    if (!token) {
-        console.log(chalk.red("✗ Non connecté. Utilisez 'envsafe login' d'abord."));
-        return;
-    }
-
-    try {
-        const user = await apiRequest("/api/v1/user/me", {
-            method: "GET",
-            token
-        });
-
-        console.log(chalk.cyan("\n🔐 EnvSafe CLI\n"));
-        console.log(`  Utilisateur: ${chalk.white(user.name)} (${chalk.dim(user.email)})`);
-
-        if (user.lastLoginAt) {
-            const date = new Date(user.lastLoginAt).toLocaleString();
-            console.log(`  Dernière connexion: ${chalk.dim(date)}`);
-        }
-
-        console.log(`  API:   ${chalk.dim(apiUrl)}`);
-        console.log(`  Token: ${chalk.dim(token.substring(0, 12) + "...")}\n`);
-    } catch (error: any) {
-        console.log(chalk.red(`✗ Impossible de récupérer les infos utilisateur: ${error.message}`));
-    }
-}

package/src/index.ts

@@ -1,105 +0,0 @@
-#!/usr/bin/env node
-
-import { Command } from "commander";
-import chalk from "chalk";
-import Conf from "conf";
-import { login } from "./commands/login.js";
-import { pull } from "./commands/pull.js";
-import { push } from "./commands/push.js";
-import { run } from "./commands/run.js";
-import { projects } from "./commands/projects.js";
-import { whoami } from "./commands/whoami.js";
-import pkg from "../package.json";
-
-// Config store for token
-export const config = new Conf({
-    projectName: "envsafe-cli",
-    schema: {
-        token: { type: "string", default: "" },
-        apiUrl: { type: "string", default: "https://envsafe.vercel.app" },
-        dashboardUrl: { type: "string", default: "https://envsafe.vercel.app" },
-    },
-});
-
-const program = new Command();
-
-program
-    .name("envsafe")
-    .description(chalk.cyan("🔐 EnvSafe CLI - Gestionnaire sécurisé de variables d'environnement"))
-    .version(pkg.version);
-
-// Login command
-program
-    .command("login")
-    .description("Se connecter avec un token API")
-    .option("-t, --token <token>", "Token API")
-    .action(login);
-
-// Whoami command
-program
-    .command("whoami")
-    .description("Afficher l'utilisateur connecté")
-    .action(whoami);
-
-// Projects command
-program
-    .command("projects")
-    .alias("ls")
-    .description("Lister les projets accessibles")
-    .action(projects);
-
-// Pull command
-program
-    .command("pull")
-    .description("Télécharger les variables d'environnement")
-    .argument("<project>", "Slug du projet")
-    .option("-e, --env <environment>", "Environnement (development, staging, production)", "development")
-    .option("-o, --output <file>", "Fichier de sortie", ".env")
-    .action(pull);
-
-// Push command
-program
-    .command("push")
-    .description("Envoyer les variables d'environnement")
-    .argument("<project>", "Slug du projet")
-    .option("-e, --env <environment>", "Environnement", "development")
-    .option("-f, --file <file>", "Fichier source", ".env")
-    .action(push);
-
-// Run command
-program
-    .command("run")
-    .description("Exécuter une commande avec les variables d'environnement injectées")
-    .argument("<project>", "Slug du projet")
-    .option("-e, --env <environment>", "Environnement", "development")
-    .argument("<command...>", "Commande à exécuter")
-    .action(run);
-
-// Config command
-program
-    .command("config")
-    .description("Gérer la configuration")
-    .option("--api-url <url>", "Définir l'URL de l'API EnvSafe")
-    .option("--show", "Afficher la configuration actuelle")
-    .action((options) => {
-        if (options.apiUrl) {
-            config.set("apiUrl", options.apiUrl);
-            console.log(chalk.green(`✓ URL de l'API définie: ${options.apiUrl}`));
-        }
-        if (options.show) {
-            console.log(chalk.cyan("Configuration actuelle:"));
-            console.log(`  API URL: ${config.get("apiUrl")}`);
-            console.log(`  Token: ${config.get("token") ? "••••••••" : "(non défini)"}`);
-        }
-    });
-
-// Logout command
-program
-    .command("logout")
-    .description("Se déconnecter")
-    .action(() => {
-        config.set("token", "");
-        console.log(chalk.green("✓ Déconnexion réussie"));
-    });
-
-program.parse();

package/src/utils/api.ts

@@ -1,36 +0,0 @@
-import { config } from "../index.js";
-
-interface ApiRequestOptions {
-    method: "GET" | "POST" | "PUT" | "DELETE";
-    token?: string;
-    body?: any;
-}
-
-export async function apiRequest(endpoint: string, options: ApiRequestOptions) {
-    const apiUrl = config.get("apiUrl") as string;
-    const token = options.token || (config.get("token") as string);
-
-    const url = `${apiUrl}${endpoint}`;
-
-    const headers: Record<string, string> = {
-        "Content-Type": "application/json",
-    };
-
-    if (token) {
-        headers["Authorization"] = `Bearer ${token}`;
-    }
-
-    const response = await fetch(url, {
-        method: options.method,
-        headers,
-        body: options.body ? JSON.stringify(options.body) : undefined,
-    });
-
-    const data = await response.json();
-
-    if (!response.ok && !data.error) {
-        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-    }
-
-    return data;
-}

package/tsconfig.json

@@ -1,22 +0,0 @@
-{
-    "compilerOptions": {
-        "target": "ES2022",
-        "module": "NodeNext",
-        "moduleResolution": "NodeNext",
-        "outDir": "./dist",
-        "rootDir": "./src",
-        "strict": true,
-        "esModuleInterop": true,
-        "skipLibCheck": true,
-        "forceConsistentCasingInFileNames": true,
-        "declaration": true,
-        "resolveJsonModule": true
-    },
-    "include": [
-        "src/**/*"
-    ],
-    "exclude": [
-        "node_modules",
-        "dist"
-    ]
-}