@elding/sdk 0.6.0 → 0.6.2

package/README.md

@@ -0,0 +1,67 @@
+# @elding/sdk
+
+Utilise tes clés API sans jamais les écrire dans ton code. Elding garde la clé
+hors de ton app : ton code manipule un placeholder, la vraie valeur est injectée
+au dernier moment et verrouillée à un seul domaine (anti-exfiltration).
+
+```bash
+npm install @elding/sdk
+```
+
+## Pour une clé API HTTP : `configure()`
+
+Utilise `configure()` pour **toute clé d'API HTTP** (OpenAI, Mistral, Stripe,
+Resend, etc.). Retourne de quoi faire un `fetch` normal, sans jamais exposer la clé.
+
+```ts
+import { configure } from "@elding/sdk";
+
+// "MISTRAL_KEY" = nom du secret dans ton vault Elding.
+// 2e arg = le domaine de l'API (verrouillage anti-fuite).
+const { apiKey, baseURL } = await configure("MISTRAL_KEY", "https://api.mistral.ai");
+
+const res = await fetch(`${baseURL}/v1/chat/completions`, {
+  method: "POST",
+  headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
+  body: JSON.stringify({ model: "mistral-small-latest", messages: [...] }),
+});
+```
+
+Important :
+- **Utilise toujours `baseURL`** dans ton `fetch`, jamais l'URL de l'API en dur.
+  En dev, `baseURL` pointe vers le proxy local qui injecte la vraie clé.
+- Mets `apiKey` dans un **header** (`Authorization`, `x-api-key`…), jamais dans l'URL.
+- `configure()` est réservé aux **API HTTP**. Pour autre chose, voir `secret()`.
+
+## Pour un secret non-HTTP : `secret()`
+
+`DATABASE_URL`, `REDIS_URL`, `JWT_SECRET`… tout ce qui n'est pas une API HTTP.
+Retourne la valeur brute. Jamais dans `process.env`, effacée de la mémoire après
+5 min (réglable via `ELDING_CACHE_TTL_MS`).
+
+```ts
+import { secret } from "@elding/sdk";
+
+const dbUrl = await secret("DATABASE_URL");
+```
+
+## Plusieurs secrets d'un coup : `client()`
+
+```ts
+import { client } from "@elding/sdk";
+
+const elding = await client();
+const dbUrl = elding.secret("DATABASE_URL");
+```
+
+## Règle simple
+
+- Clé qui part dans une **requête HTTP** → `configure(nom, "https://api.exemple.com")`.
+- N'importe quel **autre secret** → `secret(nom)`.
+- **Jamais** de clé en dur, jamais dans `process.env`, jamais dans l'URL.
+
+## Dev vs prod
+
+- **Dev** (`elding proxy -- npm run dev`) : la clé n'entre jamais dans ton process.
+- **Prod** (serverless) : la clé est récupérée du vault au runtime. Elle reste
+  verrouillée au domaine, surveillée, révocable en un clic.

package/dist/apiUrl.js

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveBaseUrl = resolveBaseUrl;
 const net_1 = __importDefault(require("net"));
-const DEFAULT_BASE_URL = "https://elding-dev.vercel.app";
+const DEFAULT_BASE_URL = "https://elding.app";
 function stripBrackets(hostname) {
     return hostname.startsWith("[") && hostname.endsWith("]")
         ? hostname.slice(1, -1)

package/dist/client.d.ts

@@ -2,6 +2,7 @@ export type ClientOptions = {
     setId?: string;
     refreshToken?: string;
     envFallback?: boolean;
+    cacheTtlMs?: number;
 };
 export declare class EldingClient {
     private secrets;
@@ -11,5 +12,6 @@ export declare class EldingClient {
     secret(name: string): string;
     secretOrUndefined(name: string): string | undefined;
     all(): Record<string, string>;
+    wipe(): void;
     allWithEnvFallback(): Record<string, string>;
 }

package/dist/client.js

@@ -11,10 +11,10 @@ class EldingClient {
         this.envFallback = envFallback;
     }
     static async create(options = {}) {
-        // 1. Resolve setId
-        const setId = options.setId ?? (0, config_js_1.readProjectConfig)()?.setId;
+        // 1. Resolve setId : option explicite → .elding.json (dev) → ELDING_SET_ID (serverless/CI)
+        const setId = options.setId ?? (0, config_js_1.readProjectConfig)()?.setId ?? process.env.ELDING_SET_ID?.trim();
         if (!setId)
-            throw new Error("[elding] setId introuvable. Lancez `elding init` ou passez setId en option.");
+            throw new Error("[elding] setId introuvable. Lancez `elding init`, passez setId en option, ou définissez ELDING_SET_ID.");
         // 2. Resolve refresh token
         const refreshToken = options.refreshToken ?? (0, config_js_1.readGlobalConfig)()?.refreshToken;
         if (!refreshToken)
@@ -48,6 +48,13 @@ class EldingClient {
     all() {
         return { ...this.secrets };
     }
+    // Efface les secrets de la mémoire du client. Best-effort : les strings JS sont
+    // immuables (on ne peut pas écraser les octets), mais on supprime les références
+    // pour que le GC les récupère et qu'aucun secret ne survive au-delà du TTL.
+    wipe() {
+        for (const name of Object.keys(this.secrets))
+            delete this.secrets[name];
+    }
     // Explicit escape hatch for legacy code that intentionally wants process.env fallback values.
     allWithEnvFallback() {
         if (!this.envFallback)

package/dist/config.js

@@ -30,8 +30,14 @@ function tokenFromFile() {
         return null;
     }
 }
+// Fallback serverless (Vercel, CI) : aucun keychain ni fichier ~/.elding,
+// le token est fourni via la variable d'env ELDING_REFRESH_TOKEN.
+function tokenFromEnv() {
+    const t = process.env.ELDING_REFRESH_TOKEN;
+    return t && t.trim() ? t.trim() : null;
+}
 function readGlobalConfig() {
-    const token = tokenFromKeychain() ?? tokenFromFile();
+    const token = tokenFromKeychain() ?? tokenFromFile() ?? tokenFromEnv();
     if (!token || !REFRESH_TOKEN.test(token))
         return null;
     return { refreshToken: token };

package/dist/configure.d.ts

@@ -4,6 +4,8 @@ export type ProviderConfig = {
     baseURL?: string;
     defaultHeaders?: Record<string, string>;
 };
+/** Efface immédiatement les secrets gardés en mémoire par le SDK. */
+export declare function clearSecretCache(): void;
 export declare function configure(secretName: string, target: string, options?: ClientOptions): Promise<ProviderConfig>;
 /**
  * Récupère la VALEUR BRUTE d'un secret (DATABASE_URL, config, secrets non-HTTP).

package/dist/configure.js

@@ -1,17 +1,43 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearSecretCache = clearSecretCache;
 exports.configure = configure;
 exports.secret = secret;
 const proxy_js_1 = require("./proxy.js");
 const client_js_1 = require("./client.js");
 const SECRET_NAME = /^[A-Z0-9_]+$/;
-// Client mis en cache : on ne fetch les secrets qu'une seule fois par process.
+// Durée de vie max des secrets en mémoire. Contrairement à un `.env` ou à
+// `doppler run` (valeurs présentes tout le process), Elding ne garde les secrets
+// que quelques minutes puis les efface : fenêtre d'exposition minimale.
+// Défaut 5 min. Réglable via l'option `cacheTtlMs` ou ELDING_CACHE_TTL_MS.
+const DEFAULT_CACHE_TTL_MS = 300_000;
+function resolveTtl(options) {
+    const fromEnv = Number(process.env.ELDING_CACHE_TTL_MS);
+    const ttl = options.cacheTtlMs ?? (Number.isFinite(fromEnv) && fromEnv > 0 ? fromEnv : DEFAULT_CACHE_TTL_MS);
+    return Math.max(1_000, ttl);
+}
 let clientPromise = null;
+let cachedAt = 0;
 function getClient(options) {
-    if (!clientPromise)
+    const ttl = resolveTtl(options);
+    if (clientPromise && Date.now() - cachedAt > ttl)
+        clearSecretCache();
+    if (!clientPromise) {
+        cachedAt = Date.now();
         clientPromise = client_js_1.EldingClient.create(options);
+        // Auto-efface après le TTL, sans bloquer la sortie du process (timer unref).
+        const t = setTimeout(clearSecretCache, ttl);
+        t.unref?.();
+    }
     return clientPromise;
 }
+/** Efface immédiatement les secrets gardés en mémoire par le SDK. */
+function clearSecretCache() {
+    const p = clientPromise;
+    clientPromise = null;
+    cachedAt = 0;
+    p?.then((c) => c.wipe()).catch(() => { });
+}
 /**
  * Config unifiée pour un provider : utilise le proxy si actif (clé jamais en mémoire),
  * sinon récupère la vraie clé du vault (mode client). Le même code marche en dev

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { EldingClient, type ClientOptions } from "./client.js";
-export { configure, secret, type ProviderConfig } from "./configure.js";
+export { configure, secret, clearSecretCache, type ProviderConfig } from "./configure.js";
 export { EldingClient };
 export type { ClientOptions };
 export { isProxyActive } from "./proxy.js";

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isProxyActive = exports.EldingClient = exports.secret = exports.configure = void 0;
+exports.isProxyActive = exports.EldingClient = exports.clearSecretCache = exports.secret = exports.configure = void 0;
 exports.client = client;
 const client_js_1 = require("./client.js");
 Object.defineProperty(exports, "EldingClient", { enumerable: true, get: function () { return client_js_1.EldingClient; } });
@@ -8,6 +8,7 @@ Object.defineProperty(exports, "EldingClient", { enumerable: true, get: function
 var configure_js_1 = require("./configure.js");
 Object.defineProperty(exports, "configure", { enumerable: true, get: function () { return configure_js_1.configure; } });
 Object.defineProperty(exports, "secret", { enumerable: true, get: function () { return configure_js_1.secret; } });
+Object.defineProperty(exports, "clearSecretCache", { enumerable: true, get: function () { return configure_js_1.clearSecretCache; } });
 // ── Avancé : vérifier le mode (proxy actif ou non) ──
 var proxy_js_1 = require("./proxy.js");
 Object.defineProperty(exports, "isProxyActive", { enumerable: true, get: function () { return proxy_js_1.isProxyActive; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elding/sdk",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "description": "Elding SDK — accès aux secrets depuis le code, zéro .env",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",