@neetru/cli 1.0.1 → 2.0.0

package/dist/scaffold/auth.js

@@ -1,228 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.scaffoldAuth = scaffoldAuth;
-const fs = __importStar(require("fs-extra"));
-const path = __importStar(require("path"));
-async function scaffoldAuth(config, outDir) {
-    const files = [
-        {
-            name: 'auth.ts',
-            content: `/**
- * Neetru Auth — gerado por neetru add auth
- * Fluxo OAuth 2.0 / OIDC via Neetru Core
- */
-
-const NEETRU_CORE_URL = process.env.NEETRU_CORE_URL ?? '${config.coreUrl}';
-const CLIENT_ID = process.env.NEETRU_CLIENT_ID ?? '${config.clientId}';
-const CLIENT_SECRET = process.env.NEETRU_CLIENT_SECRET ?? '';
-
-export interface NeetruTokens {
-  access_token: string;
-  refresh_token: string;
-  token_type: string;
-  expires_in: number;
-  scope: string;
-}
-
-export interface NeetruUser {
-  uid: string;
-  email: string;
-  displayName?: string;
-  photoURL?: string;
-  tenantId?: string;
-}
-
-/**
- * Gera a URL de autorização OAuth para redirecionar o usuário ao Neetru Core.
- */
-export function getAuthorizationUrl(redirectUri: string, state?: string): string {
-  const params = new URLSearchParams({
-    client_id: CLIENT_ID,
-    redirect_uri: redirectUri,
-    response_type: 'code',
-    scope: 'openid profile email',
-    ...(state ? { state } : {}),
-  });
-  return \`\${NEETRU_CORE_URL}/api/oauth/authorize?\${params.toString()}\`;
-}
-
-/**
- * Troca o authorization code por tokens de acesso.
- * Chamar no callback route após o redirect do Neetru Core.
- */
-export async function exchangeCodeForTokens(
-  code: string,
-  redirectUri: string
-): Promise<NeetruTokens> {
-  const res = await fetch(\`\${NEETRU_CORE_URL}/api/oauth/token\`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({
-      code,
-      client_id: CLIENT_ID,
-      client_secret: CLIENT_SECRET,
-      redirect_uri: redirectUri,
-      grant_type: 'authorization_code',
-    }),
-  });
-
-  if (!res.ok) {
-    const err = await res.text();
-    throw new Error(\`Token exchange failed: \${res.status} — \${err}\`);
-  }
-
-  return res.json() as Promise<NeetruTokens>;
-}
-
-/**
- * Renova o access token usando o refresh token.
- */
-export async function refreshAccessToken(refreshToken: string): Promise<NeetruTokens> {
-  const res = await fetch(\`\${NEETRU_CORE_URL}/api/oauth/token\`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({
-      grant_type: 'refresh_token',
-      refresh_token: refreshToken,
-      client_id: CLIENT_ID,
-      client_secret: CLIENT_SECRET,
-    }),
-  });
-
-  if (!res.ok) {
-    throw new Error(\`Token refresh failed: \${res.status}\`);
-  }
-
-  return res.json() as Promise<NeetruTokens>;
-}
-
-/**
- * Revoga um refresh token (logout).
- */
-export async function revokeToken(refreshToken: string): Promise<void> {
-  await fetch(\`\${NEETRU_CORE_URL}/api/oauth/revoke\`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({ token: refreshToken, client_id: CLIENT_ID }),
-  });
-}
-
-/**
- * Busca o perfil do usuário autenticado.
- */
-export async function getUserProfile(accessToken: string): Promise<NeetruUser> {
-  const res = await fetch(\`\${NEETRU_CORE_URL}/api/userinfo\`, {
-    headers: { Authorization: \`Bearer \${accessToken}\` },
-  });
-
-  if (!res.ok) {
-    throw new Error(\`Failed to fetch user profile: \${res.status}\`);
-  }
-
-  return res.json() as Promise<NeetruUser>;
-}
-`,
-        },
-        {
-            name: 'auth-middleware.ts',
-            content: `/**
- * Neetru Auth Middleware — Next.js App Router
- * Protege rotas que requerem autenticação Neetru.
- */
-
-import { cookies } from 'next/headers';
-import { getUserProfile, refreshAccessToken, type NeetruUser } from './auth';
-
-export interface NeetruSession {
-  user: NeetruUser;
-  accessToken: string;
-}
-
-/**
- * Obtém a sessão Neetru do cookie httpOnly.
- * Retorna null se não autenticado ou sessão expirada.
- */
-export async function getNeetruSession(): Promise<NeetruSession | null> {
-  const cookieStore = await cookies();
-  const accessToken = cookieStore.get('neetru_access_token')?.value;
-  const refreshToken = cookieStore.get('neetru_refresh_token')?.value;
-
-  if (!accessToken && !refreshToken) return null;
-
-  try {
-    const user = await getUserProfile(accessToken ?? '');
-    return { user, accessToken: accessToken ?? '' };
-  } catch {
-    // Try refreshing
-    if (!refreshToken) return null;
-
-    try {
-      const tokens = await refreshAccessToken(refreshToken);
-      const user = await getUserProfile(tokens.access_token);
-      // Note: caller should update cookies with new tokens
-      return { user, accessToken: tokens.access_token };
-    } catch {
-      return null;
-    }
-  }
-}
-
-/**
- * HOF para Server Actions — exige sessão Neetru válida.
- */
-export function requireNeetruSession<TInput, TOutput>(
-  fn: (session: NeetruSession, input: TInput) => Promise<TOutput>
-) {
-  return async (input: TInput): Promise<TOutput> => {
-    const session = await getNeetruSession();
-    if (!session) {
-      throw new Error('Não autenticado. Faça login com Neetru.');
-    }
-    return fn(session, input);
-  };
-}
-`,
-        },
-    ];
-    const created = [];
-    for (const file of files) {
-        const filePath = path.join(outDir, file.name);
-        await fs.writeFile(filePath, file.content, 'utf-8');
-        created.push(path.relative(process.cwd(), filePath));
-    }
-    return created;
-}
-//# sourceMappingURL=auth.js.map

package/dist/scaffold/auth.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"auth.js","sourceRoot":"","sources":["../../src/scaffold/auth.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIA,oCA6LC;AAjMD,6CAA+B;AAC/B,2CAA6B;AAGtB,KAAK,UAAU,YAAY,CAAC,MAAoB,EAAE,MAAc;IACrE,MAAM,KAAK,GAA6C;QACtD;YACE,IAAI,EAAE,SAAS;YACf,OAAO,EAAE;;;;;0DAK2C,MAAM,CAAC,OAAO;qDACnB,MAAM,CAAC,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4GnE;SACI;QACD;YACE,IAAI,EAAE,oBAAoB;YAC1B,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwDd;SACI;KACF,CAAC;IAEF,MAAM,OAAO,GAAa,EAAE,CAAC;IAC7B,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;QAC9C,MAAM,EAAE,CAAC,SAAS,CAAC,QAAQ,EAAE,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QACpD,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,QAAQ,CAAC,CAAC,CAAC;IACvD,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC"}

package/dist/scaffold/billing.d.ts

@@ -1,3 +0,0 @@
-import type { NeetruConfig } from '../config';
-export declare function scaffoldBilling(config: NeetruConfig, outDir: string): Promise<string[]>;
-//# sourceMappingURL=billing.d.ts.map

package/dist/scaffold/billing.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"billing.d.ts","sourceRoot":"","sources":["../../src/scaffold/billing.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAE9C,wBAAsB,eAAe,CAAC,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAiJ7F"}

package/dist/scaffold/billing.js

@@ -1,184 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.scaffoldBilling = scaffoldBilling;
-const fs = __importStar(require("fs-extra"));
-const path = __importStar(require("path"));
-async function scaffoldBilling(config, outDir) {
-    const files = [
-        {
-            name: 'billing.ts',
-            content: `/**
- * Neetru Billing — gerado por neetru add billing
- * Client para consulta de assinaturas, planos e entitlements.
- */
-
-const NEETRU_CORE_URL = process.env.NEETRU_CORE_URL ?? '${config.coreUrl}';
-const CLIENT_ID = process.env.NEETRU_CLIENT_ID ?? '${config.clientId}';
-
-export interface NeetruSubscription {
-  id: string;
-  status: 'active' | 'cancelled' | 'past_due' | 'trialing';
-  planId: string;
-  planName: string;
-  priceMonthly: number;
-  currentPeriodEnd: string;
-  autoRenew: boolean;
-}
-
-export interface NeetruPlan {
-  id: string;
-  name: string;
-  priceMonthly: number;
-  features: string[];
-  limits: Record<string, number>;
-}
-
-export interface NeetruEntitlement {
-  featureKey: string;
-  allowed: boolean;
-  limit?: number;
-  used?: number;
-}
-
-async function apiRequest<T>(
-  endpoint: string,
-  accessToken: string,
-  options?: RequestInit
-): Promise<T> {
-  const res = await fetch(\`\${NEETRU_CORE_URL}\${endpoint}\`, {
-    ...options,
-    headers: {
-      'Authorization': \`Bearer \${accessToken}\`,
-      'X-Client-ID': CLIENT_ID,
-      'Content-Type': 'application/json',
-      ...(options?.headers ?? {}),
-    },
-  });
-
-  if (!res.ok) {
-    const err = await res.text().catch(() => res.statusText);
-    throw new Error(\`Neetru API error \${res.status}: \${err}\`);
-  }
-
-  return res.json() as Promise<T>;
-}
-
-export const neetruBilling = {
-  /**
-   * Retorna a assinatura ativa do usuário autenticado.
-   * Retorna null se sem assinatura ativa.
-   */
-  async getSubscription(accessToken: string): Promise<NeetruSubscription | null> {
-    try {
-      return await apiRequest<NeetruSubscription>('/api/v1/billing/subscription', accessToken);
-    } catch (e) {
-      if ((e as Error).message.includes('404')) return null;
-      throw e;
-    }
-  },
-
-  /**
-   * Lista todos os planos disponíveis (não requer autenticação).
-   */
-  async listPlans(): Promise<NeetruPlan[]> {
-    const res = await fetch(\`\${NEETRU_CORE_URL}/api/v1/plans?clientId=\${CLIENT_ID}\`);
-    if (!res.ok) throw new Error('Falha ao buscar planos');
-    return res.json() as Promise<NeetruPlan[]>;
-  },
-
-  /**
-   * Verifica se uma feature está disponível no plano do usuário.
-   */
-  async checkEntitlement(
-    accessToken: string,
-    featureKey: string
-  ): Promise<NeetruEntitlement> {
-    return apiRequest<NeetruEntitlement>(
-      \`/api/v1/billing/entitlements/\${encodeURIComponent(featureKey)}\`,
-      accessToken
-    );
-  },
-
-  /**
-   * Verifica múltiplos entitlements de uma vez.
-   */
-  async checkEntitlements(
-    accessToken: string,
-    featureKeys: string[]
-  ): Promise<Record<string, NeetruEntitlement>> {
-    const params = new URLSearchParams();
-    featureKeys.forEach((k) => params.append('feature', k));
-    return apiRequest<Record<string, NeetruEntitlement>>(
-      \`/api/v1/billing/entitlements?\${params.toString()}\`,
-      accessToken
-    );
-  },
-
-  /**
-   * Gera URL de checkout para upgrade de plano.
-   */
-  async getCheckoutUrl(accessToken: string, planId: string, returnUrl: string): Promise<string> {
-    const result = await apiRequest<{ checkoutUrl: string }>(
-      '/api/v1/billing/checkout',
-      accessToken,
-      {
-        method: 'POST',
-        body: JSON.stringify({ planId, returnUrl }),
-      }
-    );
-    return result.checkoutUrl;
-  },
-
-  /**
-   * Gera URL do portal de billing self-service (Minha Conta Neetru).
-   */
-  getPortalUrl(returnUrl: string): string {
-    const params = new URLSearchParams({ clientId: CLIENT_ID, returnUrl });
-    return \`\${NEETRU_CORE_URL}/minhaconta?\${params.toString()}\`;
-  },
-};
-`,
-        },
-    ];
-    const created = [];
-    for (const file of files) {
-        const filePath = path.join(outDir, file.name);
-        await fs.writeFile(filePath, file.content, 'utf-8');
-        created.push(path.relative(process.cwd(), filePath));
-    }
-    return created;
-}
-//# sourceMappingURL=billing.js.map

package/dist/scaffold/billing.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"billing.js","sourceRoot":"","sources":["../../src/scaffold/billing.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIA,0CAiJC;AArJD,6CAA+B;AAC/B,2CAA6B;AAGtB,KAAK,UAAU,eAAe,CAAC,MAAoB,EAAE,MAAc;IACxE,MAAM,KAAK,GAA6C;QACtD;YACE,IAAI,EAAE,YAAY;YAClB,OAAO,EAAE;;;;;0DAK2C,MAAM,CAAC,OAAO;qDACnB,MAAM,CAAC,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4HnE;SACI;KACF,CAAC;IAEF,MAAM,OAAO,GAAa,EAAE,CAAC;IAC7B,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;QAC9C,MAAM,EAAE,CAAC,SAAS,CAAC,QAAQ,EAAE,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QACpD,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,QAAQ,CAAC,CAAC,CAAC;IACvD,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC"}

package/dist/scaffold/usage.d.ts

@@ -1,3 +0,0 @@
-import type { NeetruConfig } from '../config';
-export declare function scaffoldUsage(config: NeetruConfig, outDir: string): Promise<string[]>;
-//# sourceMappingURL=usage.d.ts.map

package/dist/scaffold/usage.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"usage.d.ts","sourceRoot":"","sources":["../../src/scaffold/usage.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAE9C,wBAAsB,aAAa,CAAC,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAsI3F"}

package/dist/scaffold/usage.js

@@ -1,173 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.scaffoldUsage = scaffoldUsage;
-const fs = __importStar(require("fs-extra"));
-const path = __importStar(require("path"));
-async function scaffoldUsage(config, outDir) {
-    const content = `/**
- * Neetru Usage Reporter — gerado por neetru add usage
- * Envia eventos de uso para metered billing via Neetru Core.
- * Eventos são acumulados em memória e enviados em batch a cada 60s.
- */
-
-const NEETRU_CORE_URL = process.env.NEETRU_CORE_URL ?? '${config.coreUrl}';
-const CLIENT_ID = process.env.NEETRU_CLIENT_ID ?? '${config.clientId}';
-
-export interface UsageEvent {
-  eventType: string;
-  quantity: number;
-  tenantId?: string;
-  metadata?: Record<string, string | number | boolean>;
-  timestamp?: number;
-}
-
-export class NeetruUsageReporter {
-  private queue: UsageEvent[] = [];
-  private flushInterval: ReturnType<typeof setInterval> | null = null;
-  private accessToken: string;
-  private readonly batchSize: number;
-  private readonly flushIntervalMs: number;
-
-  constructor(options: {
-    accessToken: string;
-    batchSize?: number;
-    flushIntervalMs?: number;
-  }) {
-    this.accessToken = options.accessToken;
-    this.batchSize = options.batchSize ?? 50;
-    this.flushIntervalMs = options.flushIntervalMs ?? 60_000;
-    this.startAutoFlush();
-  }
-
-  /**
-   * Registra um evento de uso.
-   * Os eventos são enviados automaticamente em batch.
-   */
-  track(eventType: string, quantity: number = 1, metadata?: UsageEvent['metadata']): void {
-    this.queue.push({
-      eventType,
-      quantity,
-      metadata,
-      timestamp: Date.now(),
-    });
-
-    if (this.queue.length >= this.batchSize) {
-      this.flush().catch(console.error);
-    }
-  }
-
-  /**
-   * Envia todos os eventos pendentes imediatamente.
-   */
-  async flush(): Promise<void> {
-    if (this.queue.length === 0) return;
-
-    const batch = this.queue.splice(0, this.batchSize);
-
-    try {
-      const res = await fetch(\`\${NEETRU_CORE_URL}/api/v1/usage\`, {
-        method: 'POST',
-        headers: {
-          'Authorization': \`Bearer \${this.accessToken}\`,
-          'X-Client-ID': CLIENT_ID,
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({ events: batch }),
-      });
-
-      if (!res.ok) {
-        // Put events back in queue to retry
-        this.queue.unshift(...batch);
-        console.error(\`[NeetruUsage] Flush failed: \${res.status}\`);
-      }
-    } catch (err) {
-      // Network error — put events back
-      this.queue.unshift(...batch);
-      console.error('[NeetruUsage] Network error during flush:', err);
-    }
-  }
-
-  /**
-   * Atualiza o access token (ex: após refresh).
-   */
-  updateToken(newToken: string): void {
-    this.accessToken = newToken;
-  }
-
-  /**
-   * Para o auto-flush e envia eventos pendentes.
-   * Chamar ao encerrar a aplicação (process.on('beforeExit')).
-   */
-  async destroy(): Promise<void> {
-    if (this.flushInterval) {
-      clearInterval(this.flushInterval);
-      this.flushInterval = null;
-    }
-    await this.flush();
-  }
-
-  private startAutoFlush(): void {
-    this.flushInterval = setInterval(() => {
-      this.flush().catch(console.error);
-    }, this.flushIntervalMs);
-
-    // Don't block process exit
-    if (this.flushInterval.unref) {
-      this.flushInterval.unref();
-    }
-  }
-}
-
-// Singleton for convenience
-let _instance: NeetruUsageReporter | null = null;
-
-export function initUsageReporter(accessToken: string): NeetruUsageReporter {
-  _instance = new NeetruUsageReporter({ accessToken });
-  return _instance;
-}
-
-export function getUsageReporter(): NeetruUsageReporter {
-  if (!_instance) {
-    throw new Error('UsageReporter não inicializado. Chame initUsageReporter(accessToken) primeiro.');
-  }
-  return _instance;
-}
-`;
-    const filePath = path.join(outDir, 'usage-reporter.ts');
-    await fs.writeFile(filePath, content, 'utf-8');
-    return [path.relative(process.cwd(), filePath)];
-}
-//# sourceMappingURL=usage.js.map

package/dist/scaffold/usage.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"usage.js","sourceRoot":"","sources":["../../src/scaffold/usage.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIA,sCAsIC;AA1ID,6CAA+B;AAC/B,2CAA6B;AAGtB,KAAK,UAAU,aAAa,CAAC,MAAoB,EAAE,MAAc;IACtE,MAAM,OAAO,GAAG;;;;;;0DAMwC,MAAM,CAAC,OAAO;qDACnB,MAAM,CAAC,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyHnE,CAAC;IAEA,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;IACxD,MAAM,EAAE,CAAC,SAAS,CAAC,QAAQ,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;IAC/C,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,QAAQ,CAAC,CAAC,CAAC;AAClD,CAAC"}

package/dist/scaffold/users.d.ts

@@ -1,3 +0,0 @@
-import type { NeetruConfig } from '../config';
-export declare function scaffoldUsers(config: NeetruConfig, outDir: string): Promise<string[]>;
-//# sourceMappingURL=users.d.ts.map

package/dist/scaffold/users.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"users.d.ts","sourceRoot":"","sources":["../../src/scaffold/users.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAE9C,wBAAsB,aAAa,CAAC,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAgG3F"}