@orion-monitoring/cli 1.0.0

package/README.md

@@ -0,0 +1,51 @@
+# orion-cli
+
+CLI d'initialisation pour le SDK **Orion** — se connecte à ton instance Orion, récupère ou crée un projet, et génère `orion.config.ts`.
+
+## Usage
+
+```bash
+npx orion-cli
+# ou
+npx create-orion
+```
+
+## Flow
+
+```
+2. Login avec ton compte     (email + mot de passe)
+3. Sélectionner un projet    (ou en créer un nouveau)
+4. Nom de la source          (ex: api-backend, worker-queue)
+5. Environnement             (production / development / staging / test)
+6. Génère nom.config.ts      (token dans .env ou directement)
+```
+
+## Fichier généré
+
+```ts
+// nom.config.ts
+import { defineConfig } from 'orion-cli'
+
+export default defineConfig({
+  token: process.env.ORION_TOKEN!, // ou le token directement
+  source: 'api-backend',
+  environment: 'production',
+  serverUrl: 'wss://api.monorion.com',
+})
+```
+
+## Variable d'environnement
+
+| Variable         | Description                              |
+|------------------|------------------------------------------|
+| `ORION_API_URL`  | Pré-remplit l'URL du serveur au prompt   |
+| `ORION_TOKEN`    | Token injecté si stocké dans `.env`      |
+
+## Dev
+
+```bash
+npm install
+npm run dev    # tsx watch
+npm run build  # compile vers dist/
+npm link       # teste `orion-cli` en global
+```

package/dist/api.d.ts

@@ -0,0 +1,12 @@
+import type { LoginResponse, Project, CreateProjectResponse } from './types.js';
+export declare class ApiError extends Error {
+    status: number;
+    constructor(status: number, message: string);
+}
+export declare function login(baseUrl: string, email: string, password: string): Promise<LoginResponse>;
+export declare function listProjects(baseUrl: string, token: string): Promise<Project[]>;
+export declare function createProject(baseUrl: string, token: string, name: string, label: string): Promise<CreateProjectResponse>;
+export declare function getProjectToken(baseUrl: string, token: string, projectName: string): Promise<string>;
+export declare function registerSource(baseUrl: string, token: string, projectName: string, name: string, description: string, env: string): Promise<{
+    name: string;
+}>;

package/dist/api.js

@@ -0,0 +1,57 @@
+export class ApiError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+        this.name = 'ApiError';
+    }
+}
+async function request(baseUrl, path, options = {}) {
+    const { token, ...fetchOptions } = options;
+    const headers = {
+        'Content-Type': 'application/json',
+        ...(fetchOptions.headers ?? {}),
+    };
+    if (token)
+        headers['Authorization'] = `Bearer ${token}`;
+    const res = await fetch(`${baseUrl}${path}`, {
+        ...fetchOptions,
+        headers,
+        signal: AbortSignal.timeout(10_000),
+    });
+    const data = await res.json().catch(() => ({}));
+    if (!res.ok) {
+        const message = data.message ?? `HTTP ${res.status}`;
+        throw new ApiError(res.status, message);
+    }
+    return data;
+}
+// ─── Auth ─────────────────────────────────────────────────────────────────────
+export async function login(baseUrl, email, password) {
+    return request(baseUrl, '/api/auth/login', {
+        method: 'POST',
+        body: JSON.stringify({ email, password }),
+    });
+}
+// ─── Projects ─────────────────────────────────────────────────────────────────
+export async function listProjects(baseUrl, token) {
+    return request(baseUrl, '/api/projects', { token });
+}
+export async function createProject(baseUrl, token, name, label) {
+    return request(baseUrl, '/api/projects', {
+        method: 'POST',
+        token,
+        body: JSON.stringify({ name, label }),
+    });
+}
+export async function getProjectToken(baseUrl, token, projectName) {
+    const res = await request(baseUrl, `/api/projects/${encodeURIComponent(projectName)}/token`, { token });
+    return res.token;
+}
+export async function registerSource(baseUrl, token, projectName, name, description, env) {
+    return request(baseUrl, `/api/projects/${encodeURIComponent(projectName)}/sources`, {
+        method: 'POST',
+        token,
+        body: JSON.stringify({ name, description, environment: env }),
+    });
+}

package/dist/auth-browser.d.ts

@@ -0,0 +1,26 @@
+/**
+ * auth-browser.ts
+ *
+ * Ce module gère le flow d'authentification CLI via navigateur.
+ *
+ * POURQUOI un serveur HTTP local ?
+ * Le navigateur ne peut pas "écrire" dans le terminal directement.
+ * La seule façon pour lui de transmettre une donnée au CLI est
+ * de faire une requête HTTP. On ouvre donc un mini serveur sur
+ * localhost:7777 qui écoute pendant max 5 minutes.
+ *
+ * POURQUOI le module `http` natif ?
+ * Pour ne pas ajouter de dépendance (express, etc.) à un CLI léger.
+ * Le module natif suffit pour une seule route GET /callback.
+ *
+ * DÉPENDANCE NÉCESSAIRE : `open`
+ * npm install open
+ * (ouvre le navigateur par défaut sur macOS, Linux, Windows)
+ */
+/**
+ * Lance le flow d'auth via navigateur.
+ *
+ * @param apiBase - URL de base de l'API (ex: "http://localhost:3001/")
+ * @returns Le JWT que le CLI pourra utiliser pour les appels API
+ */
+export declare function loginWithBrowser(apiBase: string): Promise<string>;

package/dist/auth-browser.js

@@ -0,0 +1,233 @@
+/**
+ * auth-browser.ts
+ *
+ * Ce module gère le flow d'authentification CLI via navigateur.
+ *
+ * POURQUOI un serveur HTTP local ?
+ * Le navigateur ne peut pas "écrire" dans le terminal directement.
+ * La seule façon pour lui de transmettre une donnée au CLI est
+ * de faire une requête HTTP. On ouvre donc un mini serveur sur
+ * localhost:7777 qui écoute pendant max 5 minutes.
+ *
+ * POURQUOI le module `http` natif ?
+ * Pour ne pas ajouter de dépendance (express, etc.) à un CLI léger.
+ * Le module natif suffit pour une seule route GET /callback.
+ *
+ * DÉPENDANCE NÉCESSAIRE : `open`
+ * npm install open
+ * (ouvre le navigateur par défaut sur macOS, Linux, Windows)
+ */
+import http from 'http';
+import { URL } from 'url';
+import { spinner, log } from '@clack/prompts';
+import pc from 'picocolors';
+// Port fixe sur lequel le CLI écoute le callback
+// Ce port doit être whitelisté dans le CORS du backend si besoin
+const CALLBACK_PORT = 7777;
+// Timeout de 5 minutes max pour que l'user se connecte dans le navigateur
+const AUTH_TIMEOUT_MS = 5 * 60 * 1000;
+/**
+ * Lance le flow d'auth via navigateur.
+ *
+ * @param apiBase - URL de base de l'API (ex: "http://localhost:3001/")
+ * @returns Le JWT que le CLI pourra utiliser pour les appels API
+ */
+export async function loginWithBrowser(apiBase) {
+    // ── ÉTAPE 1 : Appelle /api/auth/cli/init ─────────────────────────────────
+    // On envoie notre port de callback au backend.
+    // Le backend génère un state UUID et nous retourne l'URL de login.
+    const initRes = await fetch(`${apiBase}/api/auth/cli/init`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ callbackPort: CALLBACK_PORT }),
+    });
+    if (!initRes.ok) {
+        throw new Error(`Erreur lors de l'initialisation (${initRes.status})`);
+    }
+    const { loginUrl } = await initRes.json();
+    // ── ÉTAPE 2 : Ouvre le navigateur ─────────────────────────────────────────
+    // `open` est un package qui appelle `xdg-open` (Linux), `open` (macOS),
+    // ou `start` (Windows) selon la plateforme.
+    log.info(pc.cyan(`Ouverture du navigateur... si le navigateur ne s'ouvre pas, copiez cette URL :\n  ${loginUrl}`));
+    const { default: open } = await import('open');
+    await open(loginUrl);
+    // ── ÉTAPE 3 : Démarre le serveur local et attend le token ─────────────────
+    // Le website va rediriger vers http://localhost:7777/callback?token=xxx
+    // Notre serveur intercepte ça, extrait le token, et se ferme.
+    const spin = spinner();
+    spin.start('En attente de l\'authentification dans le navigateur');
+    const token = await waitForCallback();
+    spin.stop(pc.green('✓ Authentification réussie !'));
+    return token;
+}
+/**
+ * Démarre un serveur HTTP local sur CALLBACK_PORT,
+ * attend un GET /callback?token=xxx,
+ * retourne le token et ferme le serveur.
+ *
+ * Timeout automatique après AUTH_TIMEOUT_MS.
+ */
+function waitForCallback() {
+    return new Promise((resolve, reject) => {
+        const server = http.createServer((req, res) => {
+            // On parse l'URL pour extraire le ?token= param
+            const reqUrl = new URL(req.url ?? '/', `http://localhost:${CALLBACK_PORT}`);
+            if (reqUrl.pathname !== '/callback') {
+                // Route inconnue → on ignore
+                res.writeHead(404);
+                res.end();
+                return;
+            }
+            const token = reqUrl.searchParams.get('token');
+            if (!token) {
+                // Pas de token dans l'URL → erreur
+                res.writeHead(400, { 'Content-Type': 'text/html; charset=utf-8' });
+                res.end('<h2>Token manquant. Relancez orion-cli.</h2>');
+                server.close();
+                reject(new Error('Token manquant dans le callback'));
+                return;
+            }
+            // ✅ On a le token ! On répond au navigateur avec une belle page
+            // et on résout la Promise.
+            res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+            res.end(`<!DOCTYPE html>
+                <html lang="fr">
+                <head>
+                <meta charset="UTF-8">
+                <meta name="viewport" content="width=device-width, initial-scale=1.0">
+                <title>Orion CLI — Authentifié</title>
+                <style>
+                    *, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+
+                    body {
+                    font-family: system-ui, -apple-system, sans-serif;
+                    background: #161a24;
+                    color: #e8eaef;
+                    display: flex;
+                    align-items: center;
+                    justify-content: center;
+                    min-height: 100vh;
+                    }
+
+                    .card {
+                    width: 100%;
+                    max-width: 22rem;
+                    background: #1c2130;
+                    border: 1px solid #252b3b;
+                    border-radius: 1rem;
+                    padding: 2.5rem 2rem;
+                    text-align: center;
+                    box-shadow: 0 25px 50px rgba(0, 0, 0, 0.5);
+                    }
+
+                    .logo {
+                    font-size: 1.5rem;
+                    font-weight: 700;
+                    color: #ffffff;
+                    letter-spacing: -0.02em;
+                    margin-bottom: 0.25rem;
+                    }
+
+                    .subtitle {
+                    font-size: 0.875rem;
+                    color: #8b92a4;
+                    margin-bottom: 2rem;
+                    }
+
+                    .icon-wrap {
+                    width: 3.5rem;
+                    height: 3.5rem;
+                    background: rgba(2, 241, 148, 0.1);
+                    border: 1px solid rgba(2, 241, 148, 0.25);
+                    border-radius: 50%;
+                    display: flex;
+                    align-items: center;
+                    justify-content: center;
+                    margin: 0 auto 1.25rem;
+                    }
+
+                    .icon-wrap svg {
+                    color: #02f194;
+                    }
+
+                    h2 {
+                    font-size: 1.125rem;
+                    font-weight: 600;
+                    color: #ffffff;
+                    margin-bottom: 0.5rem;
+                    }
+
+                    p {
+                    font-size: 0.875rem;
+                    color: #8b92a4;
+                    line-height: 1.5;
+                    }
+
+                    .divider {
+                    height: 1px;
+                    background: #252b3b;
+                    margin: 1.5rem 0;
+                    }
+
+                    .hint {
+                    font-size: 0.8125rem;
+                    color: #8b92a4;
+                    }
+
+                    .hint code {
+                    color: #02f194;
+                    background: rgba(2, 241, 148, 0.08);
+                    padding: 0.125rem 0.375rem;
+                    border-radius: 0.25rem;
+                    font-family: ui-monospace, monospace;
+                    font-size: 0.8125rem;
+                    }
+                </style>
+                </head>
+                <body>
+                <div class="card">
+                    <p class="logo">Orion</p>
+                    <p class="subtitle">Authentification CLI</p>
+
+                    <div class="icon-wrap">
+                    <svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round">
+                        <polyline points="20 6 9 17 4 12"></polyline>
+                    </svg>
+                    </div>
+
+                    <h2>Authentification réussie !</h2>
+                    <p>Vous pouvez fermer cet onglet<br>et retourner dans le terminal.</p>
+
+                    <div class="divider"></div>
+
+                    <p class="hint">Le setup continue dans <code>orion-cli</code></p>
+                </div>
+                </body>
+            </html>`);
+            // Ferme le serveur proprement après avoir répondu
+            server.close();
+            resolve(token);
+        });
+        // Timeout de sécurité : si l'user ne se connecte pas dans les temps
+        const timeout = setTimeout(() => {
+            server.close();
+            reject(new Error('Timeout : aucune authentification reçue en 5 minutes.'));
+        }, AUTH_TIMEOUT_MS);
+        // Quand le serveur se ferme, on clear le timeout
+        server.on('close', () => clearTimeout(timeout));
+        // Lance l'écoute sur le port
+        server.listen(CALLBACK_PORT, '127.0.0.1', () => {
+            // Le serveur est prêt, le spinner peut afficher son message
+        });
+        // Gestion d'erreur si le port est déjà occupé
+        server.on('error', (err) => {
+            if (err.code === 'EADDRINUSE') {
+                reject(new Error(`Le port ${CALLBACK_PORT} est déjà utilisé.\n` +
+                    `Fermez le processus qui l'utilise et relancez orion-cli.`));
+            }
+            else {
+                reject(err);
+            }
+        });
+    });
+}

package/dist/auth.d.ts

@@ -0,0 +1,9 @@
+import type { ApiVerifyResponse, NomConfig } from './types.js';
+/**
+ * Vérifie le token auprès de l'API et retourne les infos du projet.
+ */
+export declare function verifyToken(token: string, apiUrl?: string): Promise<ApiVerifyResponse>;
+/**
+ * Construit les headers d'authentification pour les requêtes SDK.
+ */
+export declare function buildAuthHeaders(config: Pick<NomConfig, 'token'>): Record<string, string>;

package/dist/auth.js

@@ -0,0 +1,44 @@
+// URL de ton API — peut être surchargée via NOM_API_URL
+const DEFAULT_API_URL = 'http://localhost:3001/api';
+/**
+ * Vérifie le token auprès de l'API et retourne les infos du projet.
+ */
+export async function verifyToken(token, apiUrl = DEFAULT_API_URL) {
+    try {
+        const res = await fetch(`${apiUrl}/auth/me`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${token}`,
+            },
+            body: JSON.stringify({ token }),
+            signal: AbortSignal.timeout(8000), // timeout 8s
+        });
+        if (!res.ok) {
+            if (res.status === 401) {
+                return { valid: false, error: 'Token invalide ou expiré.' };
+            }
+            if (res.status === 404) {
+                return { valid: false, error: 'Projet introuvable.' };
+            }
+            return { valid: false, error: `Erreur serveur (${res.status}).` };
+        }
+        const data = (await res.json());
+        return { valid: true, projectName: data.projectName };
+    }
+    catch (err) {
+        if (err instanceof Error && err.name === 'TimeoutError') {
+            return { valid: false, error: 'Timeout — serveur injoignable.' };
+        }
+        return { valid: false, error: 'Impossible de contacter le serveur.' };
+    }
+}
+/**
+ * Construit les headers d'authentification pour les requêtes SDK.
+ */
+export function buildAuthHeaders(config) {
+    return {
+        Authorization: `Bearer ${config.token}`,
+        'X-Nom-Source': 'sdk',
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,216 @@
+#!/usr/bin/env node
+import { intro, outro, text, password, select, confirm, spinner, isCancel, cancel, note, log, } from '@clack/prompts';
+import pc from 'picocolors';
+import { listProjects, createProject, getProjectToken, registerSource } from './api.js';
+import { writeConfig, configExists, normalizeName } from './writer.js';
+import { loginWithBrowser } from './auth-browser.js';
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+function bail(value) {
+    if (isCancel(value)) {
+        cancel('Setup annulé.');
+        process.exit(0);
+    }
+}
+function orionBanner() {
+    console.log();
+    console.log(pc.cyan('  ╔═══════════════════════╗'));
+    console.log(pc.cyan('  ║  ') + pc.bold(pc.white('O R I O N')) + pc.cyan('  ·  CLI    ║'));
+    console.log(pc.cyan('  ╚═══════════════════════╝'));
+    console.log();
+}
+// ─── Main ─────────────────────────────────────────────────────────────────────
+async function main() {
+    orionBanner();
+    intro(pc.bgCyan(pc.black(' orion-cli ')));
+    // 0. Config existante ?
+    if (configExists()) {
+        const overwrite = await confirm({
+            message: pc.yellow('Un fichier orion.config.ts existe déjà. L\'écraser ?'),
+            initialValue: false,
+        });
+        bail(overwrite);
+        if (!overwrite) {
+            cancel('Setup annulé — configuration existante conservée.');
+            process.exit(0);
+        }
+    }
+    const base = "http://localhost:3001";
+    // 2. Connexion au compte Orion
+    log.step('Connexion à votre compte Orion');
+    // Propose deux méthodes d'auth
+    const authMethod = await select({
+        message: 'Comment voulez-vous vous connecter ?',
+        options: [
+            {
+                value: 'browser',
+                label: '🌐  Via le navigateur',
+                hint: 'Recommandé',
+            },
+            {
+                value: 'token',
+                label: '🔑  Token personnel',
+                hint: 'Collez votre token depuis le dashboard',
+            },
+        ],
+    });
+    bail(authMethod);
+    let accessToken;
+    if (authMethod === 'browser') {
+        try {
+            accessToken = await loginWithBrowser(base);
+        }
+        catch (err) {
+            cancel(`Échec de l'authentification : ${err instanceof Error ? err.message : String(err)}`);
+            process.exit(1);
+        }
+    }
+    else {
+        // Fallback : token manuel (utile en CI/CD ou si le navigateur ne s'ouvre pas)
+        const manualToken = await password({
+            message: 'Collez votre token personnel (depuis orion.dev/settings) :',
+            mask: '*',
+        });
+        bail(manualToken);
+        accessToken = manualToken;
+    }
+    // 3. Choisir ou créer un projet
+    const projectsSpinner = spinner();
+    projectsSpinner.start('Récupération des projets...');
+    let projects = [];
+    try {
+        projects = await listProjects(base, accessToken);
+        projectsSpinner.stop(pc.green(`✓ ${projects.length} projet(s) trouvé(s)`));
+    }
+    catch {
+        projectsSpinner.stop(pc.yellow('⚠ Impossible de charger les projets'));
+    }
+    const projectOptions = [
+        ...projects.map((p) => ({
+            value: p.name,
+            label: p.label,
+            hint: p.name,
+        })),
+        {
+            value: '__new__',
+            label: pc.cyan('+ Créer un nouveau projet'),
+            hint: '',
+        },
+    ];
+    const selectedProject = await select({
+        message: 'Quel projet utiliser ?',
+        options: projectOptions,
+    });
+    bail(selectedProject);
+    let projectToken;
+    let projectName;
+    if (selectedProject === '__new__') {
+        // Créer un nouveau projet
+        const rawLabel = await text({
+            message: 'Nom affiché du projet (label) ?',
+            placeholder: 'Mon Backend',
+            validate: (v) => !v.trim() ? 'Le label est requis.' : undefined,
+        });
+        bail(rawLabel);
+        const rawName = await text({
+            message: 'Identifiant du projet (slug) ?',
+            placeholder: normalizeName(rawLabel),
+            initialValue: normalizeName(rawLabel),
+            validate: (v) => {
+                const n = normalizeName(v);
+                if (!n)
+                    return 'Identifiant requis.';
+                if (!/^[a-z0-9][a-z0-9-]*$/.test(n))
+                    return 'Minuscules, chiffres et tirets uniquement.';
+                return undefined;
+            },
+        });
+        bail(rawName);
+        const createSpinner = spinner();
+        createSpinner.start('Création du projet...');
+        try {
+            const created = await createProject(base, accessToken, normalizeName(rawName), rawLabel.trim());
+            projectToken = created.token;
+            projectName = created.name;
+            createSpinner.stop(pc.green(`✓ Projet "${created.label}" créé`));
+        }
+        catch (err) {
+            createSpinner.stop(pc.red('✗ Échec de la création'));
+            cancel(`Erreur : ${err instanceof Error ? err.message : String(err)}`);
+            process.exit(1);
+        }
+    }
+    else {
+        // Projet existant → récupérer son token
+        projectName = selectedProject;
+        const tokenSpinner = spinner();
+        tokenSpinner.start('Récupération du token...');
+        try {
+            projectToken = await getProjectToken(base, accessToken, projectName);
+            tokenSpinner.stop(pc.green('✓ Token récupéré'));
+        }
+        catch (err) {
+            tokenSpinner.stop(pc.red('✗ Impossible de récupérer le token'));
+            cancel(`Erreur : ${err instanceof Error ? err.message : String(err)}`);
+            process.exit(1);
+        }
+    }
+    // 4. Nom de la source
+    const source = await text({
+        message: 'Nom de la source (identifie l\'origine des logs) ?',
+        placeholder: 'api-backend',
+        validate: (v) => {
+            if (!v.trim())
+                return 'Requis.';
+            if (!/^[a-z0-9_-]+$/.test(v))
+                return 'Minuscules, chiffres, et - uniquement.';
+            return undefined;
+        },
+    });
+    bail(source);
+    // 5. Description de la source
+    const description = await text({
+        message: 'Description de la source ?',
+        placeholder: 'Gestion des utilisateurs',
+    });
+    bail(description);
+    // 6. Environnement
+    const environment = await select({
+        message: 'Environnement ?',
+        options: [
+            { value: 'prod', label: 'Production', hint: 'prod' },
+            { value: 'dev', label: 'Development', hint: 'dev' },
+            { value: 'staging', label: 'Staging', hint: 'staging' },
+            { value: 'test', label: 'Test', hint: 'test' },
+        ],
+    });
+    bail(environment);
+    // 7. Register source on server
+    let result = await registerSource(base, accessToken, projectName, source, description, environment);
+    // 7. Écriture
+    const writeSpinner = spinner();
+    writeSpinner.start('Écriture de orion.config.ts...');
+    const { configPath } = writeConfig({
+        token: projectToken,
+        projectName: projectName,
+        sourceName: result.name,
+    }, process.cwd());
+    writeSpinner.stop(pc.green('✓ Configuration écrite'));
+    // 8. Résumé
+    note([
+        `Projet     : ${pc.bold(projectName)}`,
+        `Source     : ${pc.bold(result.name)}`,
+        `Config     : ${pc.cyan(configPath)}`,
+    ].join('\n'), 'Récapitulatif');
+    // 9. Outro
+    outro(pc.green('✓ Setup terminé !\n\n') +
+        '  Installez le SDK :\n' +
+        pc.cyan('  npm install orion\n\n') +
+        '  Puis dans votre code :\n' +
+        pc.gray("  import { createLogger } from 'orion'\n") +
+        pc.gray('  const logger = await createLogger()\n') +
+        pc.gray("  logger.info('Hello from Orion!')"));
+}
+main().catch((err) => {
+    console.error(pc.red('\nErreur inattendue :'), err);
+    process.exit(1);
+});

package/dist/types.d.ts

@@ -0,0 +1,30 @@
+export type Environment = 'production' | 'development' | 'staging' | 'test';
+export interface LoginResponse {
+    accessToken: string;
+    user: {
+        id: number;
+        email: string;
+        pseudo: string;
+        first_name: string;
+        last_name: string;
+    };
+}
+export interface Project {
+    id: string;
+    name: string;
+    label: string;
+}
+export interface CreateProjectResponse {
+    id: number;
+    name: string;
+    label: string;
+    token: string;
+}
+export interface GetTokenResponse {
+    token: string;
+}
+export interface OrionConfig {
+    token: string;
+    projectName: string;
+    sourceName: string;
+}

package/dist/types.js

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

package/dist/writer.d.ts

@@ -0,0 +1,6 @@
+import type { OrionConfig } from './types.js';
+export declare function writeConfig(config: OrionConfig, targetDir?: string): {
+    configPath: string;
+};
+export declare function configExists(targetDir?: string): boolean;
+export declare function normalizeName(raw: string): string;

package/dist/writer.js

@@ -0,0 +1,29 @@
+import fs from 'node:fs';
+import path from 'node:path';
+export function writeConfig(config, targetDir = process.cwd()) {
+    const configPath = path.join(targetDir, 'orion.config.ts');
+    const content = [
+        `import { defineConfig } from 'orion-cli'`,
+        ``,
+        `export default defineConfig({`,
+        `  token: '${config.token}',`,
+        `  projectName: '${config.projectName}',`,
+        `  sourceName: '${config.sourceName}',`,
+        `})`,
+        ``,
+    ].join('\n');
+    fs.writeFileSync(configPath, content, 'utf-8');
+    return { configPath };
+}
+export function configExists(targetDir = process.cwd()) {
+    return fs.existsSync(path.join(targetDir, 'orion.config.ts'));
+}
+// Normalise un nom de projet comme le fait ton backend
+export function normalizeName(raw) {
+    return raw
+        .toLowerCase()
+        .trim()
+        .replace(/\s+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '');
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@orion-monitoring/cli",
+  "version": "1.0.0",
+  "description": "CLI to initialize an Orion logging project",
+  "type": "module",
+  "bin": {
+    "orion-cli": "./dist/index.js",
+    "create-orion": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.7.0",
+    "open": "^11.0.0",
+    "picocolors": "^1.0.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ]
+}