@lukoweb/apitogo 0.1.42 → 0.1.44

package/dist/declarations/config/local-manifest.d.ts

@@ -0,0 +1,80 @@
+import { z } from "zod";
+export declare const DEV_PORTAL_MANIFEST_FILENAME = "apitogo.local.json";
+export declare const ManifestPlanInputSchema: z.ZodObject<{
+    sku: z.ZodString;
+    displayName: z.ZodString;
+    isFree: z.ZodBoolean;
+    priceAmount: z.ZodOptional<z.ZodNumber>;
+    priceCurrency: z.ZodOptional<z.ZodString>;
+    billingPeriod: z.ZodOptional<z.ZodEnum<{
+        month: "month";
+        monthly: "monthly";
+        year: "year";
+        annual: "annual";
+    }>>;
+    limitsJson: z.ZodOptional<z.ZodString>;
+    includedActionKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const DevPortalLocalManifestSchema: z.ZodObject<{
+    siteName: z.ZodOptional<z.ZodString>;
+    branding: z.ZodOptional<z.ZodObject<{
+        title: z.ZodOptional<z.ZodString>;
+        logoUrl: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    plans: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        sku: z.ZodString;
+        displayName: z.ZodString;
+        isFree: z.ZodBoolean;
+        priceAmount: z.ZodOptional<z.ZodNumber>;
+        priceCurrency: z.ZodOptional<z.ZodString>;
+        billingPeriod: z.ZodOptional<z.ZodEnum<{
+            month: "month";
+            monthly: "monthly";
+            year: "year";
+            annual: "annual";
+        }>>;
+        limitsJson: z.ZodOptional<z.ZodString>;
+        includedActionKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    backend: z.ZodOptional<z.ZodObject<{
+        sourceDirectory: z.ZodOptional<z.ZodString>;
+        publishDirectory: z.ZodOptional<z.ZodString>;
+        openApiPath: z.ZodOptional<z.ZodString>;
+        runtime: z.ZodOptional<z.ZodString>;
+        runtimeVersion: z.ZodOptional<z.ZodString>;
+        deployed: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    gateway: z.ZodOptional<z.ZodObject<{
+        authMode: z.ZodOptional<z.ZodEnum<{
+            platformManagedEntra: "platformManagedEntra";
+            bringYourOwnOidc: "bringYourOwnOidc";
+        }>>;
+        oidcMetadataUrl: z.ZodOptional<z.ZodString>;
+        oidcAllowedIssuers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        oidcAudiences: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        limitsJson: z.ZodOptional<z.ZodString>;
+        publicHealthActionKey: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    projectId: z.ZodOptional<z.ZodString>;
+    projectName: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ManifestPlanInput = z.infer<typeof ManifestPlanInputSchema>;
+export type DevPortalLocalManifest = z.infer<typeof DevPortalLocalManifestSchema>;
+export type DevPortalPreviewPlan = {
+    sku: string;
+    displayName: string;
+    isFree: boolean;
+    priceAmount: number;
+    priceCurrency: string;
+    billingPeriod: string;
+    limitsJson: string | null;
+    includedActionKeys: string[];
+};
+export type DevPortalPreviewPlanCatalog = {
+    plans: DevPortalPreviewPlan[];
+};
+export declare function normalizeBillingPeriod(period?: string): string;
+export declare function plansToPreviewCatalog(plans: ManifestPlanInput[] | undefined): DevPortalPreviewPlanCatalog;
+export declare function manifestFilePath(rootDir: string): string;
+export declare function parseLocalManifestJson(raw: string): DevPortalLocalManifest | null;
+export declare function readLocalManifest(rootDir: string): Promise<DevPortalLocalManifest | null>;

package/docs/configuration/authentication.md

@@ -45,8 +45,17 @@ VITE_APITOGO_DEV_PORTAL_API_URL=https://your-dev-portal-api.example.com
 ```
 
 **Local preview:** When the backend URL is a placeholder or unreachable, the account area shows a
-message that sign-in unlocks after publish. Docs and API reference remain public. Default Free + Pro
-plans appear on `/pricing` from `apitogo.local.json` without extra MCP steps.
+message that sign-in unlocks after publish. Docs and API reference remain public. Plans on
+`/pricing` load from `apitogo.local.json` (including `includedActionKeys` per plan). Plan edits
+hot-reload without restarting the dev server.
+
+### Dev portal configuration files
+
+| Concern | File |
+| --- | --- |
+| Site nav, docs, plugins, auth wiring | `apitogo.config.tsx` |
+| Plans, rate limits, `includedActionKeys`, project/deploy metadata | `apitogo.local.json` |
+| OIDC and Stripe for publish (MCP only) | `apitogo.local.secrets.json` |
 
 **Production:** Register one OIDC app with redirect URI `https://{backend}/signin-oidc` (see MCP
 `manualSteps.oidcRedirectUri`). The frontend uses cookie sessions via `credentials: "include"` on

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lukoweb/apitogo",
-  "version": "0.1.42",
+  "version": "0.1.44",
   "type": "module",
   "sideEffects": [
     "**/*.css",
@@ -149,6 +149,10 @@
     "./testing": {
       "types": "./dist/declarations/lib/testing/index.d.ts",
       "default": "./src/lib/testing/index.tsx"
+    },
+    "./local-manifest": {
+      "types": "./dist/declarations/config/local-manifest.d.ts",
+      "default": "./src/config/local-manifest.ts"
     }
   },
   "scripts": {
@@ -459,6 +463,10 @@
       "./testing": {
         "types": "./dist/declarations/lib/testing/index.d.ts",
         "default": "./src/lib/testing/index.tsx"
+      },
+      "./local-manifest": {
+        "types": "./dist/declarations/config/local-manifest.d.ts",
+        "default": "./src/config/local-manifest.ts"
       }
     },
     "access": "public"

package/src/config/local-manifest.ts

@@ -0,0 +1,142 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+
+export const DEV_PORTAL_MANIFEST_FILENAME = "apitogo.local.json";
+
+const BillingPeriodSchema = z.enum([
+  "month",
+  "year",
+  "monthly",
+  "annual",
+]);
+
+export const ManifestPlanInputSchema = z.object({
+  sku: z.string().min(1),
+  displayName: z.string().min(1),
+  isFree: z.boolean(),
+  priceAmount: z.number().optional(),
+  priceCurrency: z.string().optional(),
+  billingPeriod: BillingPeriodSchema.optional(),
+  limitsJson: z.string().optional(),
+  includedActionKeys: z.array(z.string()).optional(),
+});
+
+export const DevPortalLocalManifestSchema = z.object({
+  siteName: z.string().optional(),
+  branding: z
+    .object({
+      title: z.string().optional(),
+      logoUrl: z.string().optional(),
+    })
+    .optional(),
+  plans: z.array(ManifestPlanInputSchema).optional(),
+  backend: z
+    .object({
+      sourceDirectory: z.string().optional(),
+      publishDirectory: z.string().optional(),
+      openApiPath: z.string().optional(),
+      runtime: z.string().optional(),
+      runtimeVersion: z.string().optional(),
+      deployed: z.boolean().optional(),
+    })
+    .optional(),
+  gateway: z
+    .object({
+      authMode: z.enum(["platformManagedEntra", "bringYourOwnOidc"]).optional(),
+      oidcMetadataUrl: z.string().optional(),
+      oidcAllowedIssuers: z.array(z.string()).optional(),
+      oidcAudiences: z.array(z.string()).optional(),
+      limitsJson: z.string().optional(),
+      publicHealthActionKey: z.string().optional(),
+    })
+    .optional(),
+  projectId: z.string().optional(),
+  projectName: z.string().optional(),
+});
+
+export type ManifestPlanInput = z.infer<typeof ManifestPlanInputSchema>;
+export type DevPortalLocalManifest = z.infer<typeof DevPortalLocalManifestSchema>;
+
+export type DevPortalPreviewPlan = {
+  sku: string;
+  displayName: string;
+  isFree: boolean;
+  priceAmount: number;
+  priceCurrency: string;
+  billingPeriod: string;
+  limitsJson: string | null;
+  includedActionKeys: string[];
+};
+
+export type DevPortalPreviewPlanCatalog = {
+  plans: DevPortalPreviewPlan[];
+};
+
+export function normalizeBillingPeriod(period?: string): string {
+  if (!period) {
+    return "monthly";
+  }
+
+  const normalized = period.toLowerCase();
+  if (normalized === "month") {
+    return "monthly";
+  }
+  if (normalized === "year") {
+    return "annual";
+  }
+  return normalized;
+}
+
+export function plansToPreviewCatalog(
+  plans: ManifestPlanInput[] | undefined,
+): DevPortalPreviewPlanCatalog {
+  if (!plans?.length) {
+    return { plans: [] };
+  }
+
+  return {
+    plans: plans.map((plan) => ({
+      sku: plan.sku,
+      displayName: plan.displayName,
+      isFree: plan.isFree,
+      priceAmount: plan.priceAmount ?? 0,
+      priceCurrency: plan.priceCurrency ?? "usd",
+      billingPeriod: normalizeBillingPeriod(plan.billingPeriod),
+      limitsJson: plan.limitsJson ?? null,
+      includedActionKeys: plan.includedActionKeys ?? [],
+    })),
+  };
+}
+
+export function manifestFilePath(rootDir: string): string {
+  return path.join(path.resolve(rootDir), DEV_PORTAL_MANIFEST_FILENAME);
+}
+
+export function parseLocalManifestJson(
+  raw: string,
+): DevPortalLocalManifest | null {
+  try {
+    const parsed = JSON.parse(raw) as unknown;
+    const result = DevPortalLocalManifestSchema.safeParse(parsed);
+    if (!result.success) {
+      return null;
+    }
+    return result.data;
+  } catch {
+    return null;
+  }
+}
+
+export async function readLocalManifest(
+  rootDir: string,
+): Promise<DevPortalLocalManifest | null> {
+  const filePath = manifestFilePath(rootDir);
+
+  try {
+    const raw = await readFile(filePath, "utf8");
+    return parseLocalManifestJson(raw);
+  } catch {
+    return null;
+  }
+}

package/src/types.d.ts

@@ -55,3 +55,8 @@ declare module "virtual:zudoku-shiki-register" {
   import type { HighlighterCore } from "shiki/core";
   export const registerShiki: (highlighter: HighlighterCore) => Promise<void>;
 }
+
+declare module "virtual:apitogo-local-manifest" {
+  const catalog: import("./config/local-manifest.ts").DevPortalPreviewPlanCatalog;
+  export default catalog;
+}

package/src/vite/dev-portal-env.ts

@@ -1,76 +1,10 @@
-import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { loadEnv } from "vite";
 
-export const DEV_PORTAL_MANIFEST_FILENAME = "apitogo.local.json";
-
 export const DEV_PORTAL_VITE_ENV_KEYS = [
   "VITE_APITOGO_DEV_PORTAL_API_URL",
-  "VITE_APITOGO_DEV_PORTAL_MOCK_PLANS",
 ] as const;
 
-interface ManifestPlanInput {
-  sku: string;
-  displayName: string;
-  isFree: boolean;
-  priceAmount?: number;
-  priceCurrency?: string;
-  billingPeriod?: string;
-  limitsJson?: string;
-}
-
-interface DevPortalLocalManifest {
-  plans?: ManifestPlanInput[];
-}
-
-function normalizeBillingPeriod(period?: string): string {
-  if (!period) {
-    return "monthly";
-  }
-
-  const normalized = period.toLowerCase();
-  if (normalized === "month") {
-    return "monthly";
-  }
-  if (normalized === "year") {
-    return "annual";
-  }
-  return normalized;
-}
-
-export function plansToMockEnvValue(
-  plans: ManifestPlanInput[] | undefined,
-): string | null {
-  if (!plans?.length) {
-    return null;
-  }
-
-  const mockPlans = plans.map((plan) => ({
-    sku: plan.sku,
-    displayName: plan.displayName,
-    isFree: plan.isFree,
-    priceAmount: plan.priceAmount ?? 0,
-    priceCurrency: plan.priceCurrency ?? "usd",
-    billingPeriod: normalizeBillingPeriod(plan.billingPeriod),
-    limitsJson: plan.limitsJson ?? null,
-  }));
-
-  return JSON.stringify(mockPlans);
-}
-
-export async function readDevPortalManifest(
-  rootDir: string,
-): Promise<DevPortalLocalManifest | null> {
-  const manifestPath = path.join(rootDir, DEV_PORTAL_MANIFEST_FILENAME);
-
-  try {
-    const raw = await readFile(manifestPath, "utf8");
-    return JSON.parse(raw) as DevPortalLocalManifest;
-  } catch {
-    return null;
-  }
-}
-
 export async function loadDevPortalViteDefines(
   rootDir: string,
   mode: string,
@@ -83,11 +17,5 @@ export async function loadDevPortalViteDefines(
     defines.VITE_APITOGO_DEV_PORTAL_API_URL = JSON.stringify(apiUrl);
   }
 
-  const manifest = await readDevPortalManifest(rootDir);
-  const mockPlansValue = plansToMockEnvValue(manifest?.plans);
-  if (mockPlansValue) {
-    defines.VITE_APITOGO_DEV_PORTAL_MOCK_PLANS = JSON.stringify(mockPlansValue);
-  }
-
   return defines;
 }

package/src/vite/plugin-local-manifest.ts

@@ -0,0 +1,79 @@
+import path from "node:path";
+import type { Plugin, ResolvedConfig } from "vite";
+import {
+  DEV_PORTAL_MANIFEST_FILENAME,
+  manifestFilePath,
+  parseLocalManifestJson,
+  plansToPreviewCatalog,
+} from "../config/local-manifest.js";
+
+export const APITOGO_LOCAL_MANIFEST_VIRTUAL_ID = "virtual:apitogo-local-manifest";
+const resolvedVirtualModuleId = `\0${APITOGO_LOCAL_MANIFEST_VIRTUAL_ID}`;
+
+const viteLocalManifestPlugin = (): Plugin => {
+  let rootDir = "";
+  let manifestPath = "";
+
+  const loadManifestModule = async (): Promise<string> => {
+    const { readFile } = await import("node:fs/promises");
+    let catalog = { plans: [] as ReturnType<typeof plansToPreviewCatalog>["plans"] };
+
+    try {
+      const raw = await readFile(manifestPath, "utf8");
+      const manifest = parseLocalManifestJson(raw);
+      catalog = plansToPreviewCatalog(manifest?.plans);
+    } catch {
+      // Missing or invalid manifest — empty catalog for preview.
+    }
+
+    return `export default ${JSON.stringify(catalog)};`;
+  };
+
+  return {
+    name: "apitogo-local-manifest-plugin",
+    configResolved(resolvedConfig: ResolvedConfig) {
+      rootDir = resolvedConfig.root;
+      manifestPath = manifestFilePath(rootDir);
+    },
+    resolveId(id) {
+      if (id === APITOGO_LOCAL_MANIFEST_VIRTUAL_ID) {
+        return resolvedVirtualModuleId;
+      }
+    },
+    async load(id) {
+      if (id !== resolvedVirtualModuleId) {
+        return;
+      }
+
+      return loadManifestModule();
+    },
+    configureServer(server) {
+      const watchPath = path.join(rootDir, DEV_PORTAL_MANIFEST_FILENAME);
+
+      server.watcher.add(watchPath);
+      server.watcher.on("change", async (changedPath) => {
+        if (path.resolve(changedPath) !== path.resolve(manifestPath)) {
+          return;
+        }
+
+        const module = server.moduleGraph.getModuleById(
+          resolvedVirtualModuleId,
+        );
+        if (module) {
+          server.moduleGraph.invalidateModule(module);
+        }
+
+        const mod = await server.moduleGraph.getModuleByUrl(
+          APITOGO_LOCAL_MANIFEST_VIRTUAL_ID,
+        );
+        if (mod) {
+          server.reloadModule(mod);
+        }
+
+        server.ws.send({ type: "full-reload", path: "*" });
+      });
+    },
+  };
+};
+
+export default viteLocalManifestPlugin;

package/src/vite/plugin.ts

@@ -17,12 +17,14 @@ import viteModulesPlugin from "./plugin-modules.js";
 import { viteNavigationPlugin } from "./plugin-navigation.js";
 import { viteSearchPlugin } from "./plugin-search.js";
 import { viteShikiRegisterPlugin } from "./plugin-shiki-register.js";
+import viteLocalManifestPlugin from "./plugin-local-manifest.js";
 import { viteThemePlugin } from "./plugin-theme.js";
 
 export default function vitePlugin(): PluginOption {
   return [
     viteShikiRegisterPlugin(),
     viteConfigReloadPlugin(),
+    viteLocalManifestPlugin(),
     viteMdxPlugin(),
     react({ include: /\.(mdx?|jsx?|tsx?)$/ }),
     viteConfigPlugin(),