blimu 0.6.3 → 1.1.0

package/README.md

@@ -1,6 +1,6 @@
 # blimu
 
-Blimu - Authorization as a Service. This package provides the Blimu CLI tool for managing your authorization configuration.
+Blimu - Authorization as a Service. This package provides the Blimu CLI tool for managing your authorization configuration and generating type-safe TypeScript types.
 
 ## Installation
 
@@ -12,23 +12,87 @@ yarn add blimu
 pnpm add blimu
 ```
 
-After installation, the Blimu CLI binary will be automatically downloaded and made available via the `blimu` command.
-
 ## Usage
 
-Once installed, you can use the Blimu CLI to manage your authorization configuration:
+### Codegen Command
+
+Generate type augmentation files from your Blimu configuration:
 
 ```bash
-# Validate your Blimu configuration
-blimu validate ./blimu/
+# Generate type augmentation with defaults
+# Looks for .blimu/config.mjs or .blimu/config.ts in current directory
+# Outputs to .blimu/blimu-types.d.ts
+blimu codegen
+
+# With custom config path
+blimu codegen --config ./custom/path/config.mjs
+
+# With custom output path
+blimu codegen --output ./types/blimu-types.d.ts
+
+# With custom SDK package
+blimu codegen --sdk-package @blimu/custom-backend
+
+# All options together
+blimu codegen --config .blimu/config.mjs --output .blimu/blimu-types.d.ts --sdk-package @blimu/backend
+```
 
-# Push configuration to an environment
-blimu push ./blimu/ --workspace-id <workspace-id> --environment-id <environment-id>
+#### Command Options
 
-# Pull configuration from an environment
-blimu pull ./blimu/ --workspace-id <workspace-id> --environment-id <environment-id>
+- `--config <path>`: Optional path to Blimu config file. If not provided, the CLI will look for `.blimu/config.mjs` or `.blimu/config.ts` in the current directory.
+- `--output <path>`: Optional output path for the generated type augmentation file. Defaults to `.blimu/blimu-types.d.ts`.
+- `--sdk-package <name>`: Optional SDK package name. Defaults to `@blimu/backend`.
+
+#### Config File Format
+
+The CLI looks for a Blimu configuration file in the `.blimu/` directory. The config file should export a default object with the following structure:
+
+```javascript
+// .blimu/config.mjs
+export default {
+  resources: {
+    workspace: {},
+    environment: {},
+  },
+  entitlements: {
+    'workspace:read': {},
+    'workspace:create': {},
+  },
+  plans: {
+    free: {
+      name: 'Free Plan',
+      resource_limits: {
+        workspace_count: 1,
+      },
+    },
+    pro: {
+      name: 'Pro Plan',
+      resource_limits: {
+        workspace_count: 10,
+      },
+    },
+  },
+};
 ```
 
+The config file can be:
+
+- `.mjs` (ES Module JavaScript)
+- `.js` (JavaScript)
+- `.ts` (TypeScript - requires tsx or ts-node)
+
+#### Generated Type Augmentation
+
+The `codegen` command generates a TypeScript declaration file that augments the `@blimu/backend` SDK with union types based on your configuration:
+
+- `ResourceType`: Union of all resource types from your config
+- `EntitlementType`: Union of all entitlement types from your config
+- `PlanType`: Union of all plan types from your config
+- `LimitType`: Union of all resource limit types from your plans
+- `UsageLimitType`: Union of all usage-based limit types from your plans
+
+This provides full type safety and autocomplete when using the Blimu SDK in your application.
+
 ## SDK Packages
 
 For programmatic access to the Blimu API, use the following SDK packages:
@@ -45,6 +109,24 @@ npm install @blimu/client
 npm install @blimu/nestjs
 ```
 
+## Development
+
+To build the CLI from source:
+
+```bash
+yarn build
+# or
+npm run build
+```
+
+To run the CLI in development mode:
+
+```bash
+yarn dev
+# or
+npm run dev
+```
+
 ## Learn More
 
 Visit [https://blimu.com](https://blimu.com) for documentation and more information.

package/dist/index.d.mts

@@ -0,0 +1,285 @@
+import { z } from 'zod';
+
+declare const ResourceDefinitionSchema: z.ZodObject<{
+    is_tenant: z.ZodOptional<z.ZodBoolean>;
+    roles: z.ZodArray<z.ZodString, "many">;
+    parents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        required: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        required: boolean;
+    }, {
+        required: boolean;
+    }>>>;
+    roles_inheritance: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
+}, "strip", z.ZodTypeAny, {
+    roles: string[];
+    is_tenant?: boolean | undefined;
+    parents?: Record<string, {
+        required: boolean;
+    }> | undefined;
+    roles_inheritance?: Record<string, string[]> | undefined;
+}, {
+    roles: string[];
+    is_tenant?: boolean | undefined;
+    parents?: Record<string, {
+        required: boolean;
+    }> | undefined;
+    roles_inheritance?: Record<string, string[]> | undefined;
+}>;
+declare const EntitlementDefinitionSchema: z.ZodObject<{
+    roles: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    plans: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    limit: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    roles?: string[] | undefined;
+    plans?: string[] | undefined;
+    limit?: string | undefined;
+}, {
+    roles?: string[] | undefined;
+    plans?: string[] | undefined;
+    limit?: string | undefined;
+}>;
+declare const FeatureDefinitionSchema: z.ZodObject<{
+    name: z.ZodString;
+    summary: z.ZodOptional<z.ZodString>;
+    entitlements: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    plans: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    default_enabled: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    plans?: string[] | undefined;
+    summary?: string | undefined;
+    entitlements?: string[] | undefined;
+    default_enabled?: boolean | undefined;
+}, {
+    name: string;
+    plans?: string[] | undefined;
+    summary?: string | undefined;
+    entitlements?: string[] | undefined;
+    default_enabled?: boolean | undefined;
+}>;
+declare const PlanDefinitionSchema: z.ZodObject<{
+    name: z.ZodString;
+    summary: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    resource_limits: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    usage_based_limits: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        value: z.ZodNumber;
+        period: z.ZodEnum<["monthly", "yearly", "lifetime"]>;
+    }, "strip", z.ZodTypeAny, {
+        value: number;
+        period: "monthly" | "yearly" | "lifetime";
+    }, {
+        value: number;
+        period: "monthly" | "yearly" | "lifetime";
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    summary?: string | undefined;
+    description?: string | undefined;
+    resource_limits?: Record<string, number> | undefined;
+    usage_based_limits?: Record<string, {
+        value: number;
+        period: "monthly" | "yearly" | "lifetime";
+    }> | undefined;
+}, {
+    name: string;
+    summary?: string | undefined;
+    description?: string | undefined;
+    resource_limits?: Record<string, number> | undefined;
+    usage_based_limits?: Record<string, {
+        value: number;
+        period: "monthly" | "yearly" | "lifetime";
+    }> | undefined;
+}>;
+declare const BlimuConfigSchema: z.ZodObject<{
+    resources: z.ZodRecord<z.ZodString, z.ZodObject<{
+        is_tenant: z.ZodOptional<z.ZodBoolean>;
+        roles: z.ZodArray<z.ZodString, "many">;
+        parents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            required: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            required: boolean;
+        }, {
+            required: boolean;
+        }>>>;
+        roles_inheritance: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
+    }, "strip", z.ZodTypeAny, {
+        roles: string[];
+        is_tenant?: boolean | undefined;
+        parents?: Record<string, {
+            required: boolean;
+        }> | undefined;
+        roles_inheritance?: Record<string, string[]> | undefined;
+    }, {
+        roles: string[];
+        is_tenant?: boolean | undefined;
+        parents?: Record<string, {
+            required: boolean;
+        }> | undefined;
+        roles_inheritance?: Record<string, string[]> | undefined;
+    }>>;
+    entitlements: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        roles: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        plans: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        limit: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        roles?: string[] | undefined;
+        plans?: string[] | undefined;
+        limit?: string | undefined;
+    }, {
+        roles?: string[] | undefined;
+        plans?: string[] | undefined;
+        limit?: string | undefined;
+    }>>>;
+    features: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        name: z.ZodString;
+        summary: z.ZodOptional<z.ZodString>;
+        entitlements: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        plans: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        default_enabled: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        plans?: string[] | undefined;
+        summary?: string | undefined;
+        entitlements?: string[] | undefined;
+        default_enabled?: boolean | undefined;
+    }, {
+        name: string;
+        plans?: string[] | undefined;
+        summary?: string | undefined;
+        entitlements?: string[] | undefined;
+        default_enabled?: boolean | undefined;
+    }>>>;
+    plans: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        name: z.ZodString;
+        summary: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        resource_limits: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        usage_based_limits: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            value: z.ZodNumber;
+            period: z.ZodEnum<["monthly", "yearly", "lifetime"]>;
+        }, "strip", z.ZodTypeAny, {
+            value: number;
+            period: "monthly" | "yearly" | "lifetime";
+        }, {
+            value: number;
+            period: "monthly" | "yearly" | "lifetime";
+        }>>>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        summary?: string | undefined;
+        description?: string | undefined;
+        resource_limits?: Record<string, number> | undefined;
+        usage_based_limits?: Record<string, {
+            value: number;
+            period: "monthly" | "yearly" | "lifetime";
+        }> | undefined;
+    }, {
+        name: string;
+        summary?: string | undefined;
+        description?: string | undefined;
+        resource_limits?: Record<string, number> | undefined;
+        usage_based_limits?: Record<string, {
+            value: number;
+            period: "monthly" | "yearly" | "lifetime";
+        }> | undefined;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    resources: Record<string, {
+        roles: string[];
+        is_tenant?: boolean | undefined;
+        parents?: Record<string, {
+            required: boolean;
+        }> | undefined;
+        roles_inheritance?: Record<string, string[]> | undefined;
+    }>;
+    plans?: Record<string, {
+        name: string;
+        summary?: string | undefined;
+        description?: string | undefined;
+        resource_limits?: Record<string, number> | undefined;
+        usage_based_limits?: Record<string, {
+            value: number;
+            period: "monthly" | "yearly" | "lifetime";
+        }> | undefined;
+    }> | undefined;
+    entitlements?: Record<string, {
+        roles?: string[] | undefined;
+        plans?: string[] | undefined;
+        limit?: string | undefined;
+    }> | undefined;
+    features?: Record<string, {
+        name: string;
+        plans?: string[] | undefined;
+        summary?: string | undefined;
+        entitlements?: string[] | undefined;
+        default_enabled?: boolean | undefined;
+    }> | undefined;
+}, {
+    resources: Record<string, {
+        roles: string[];
+        is_tenant?: boolean | undefined;
+        parents?: Record<string, {
+            required: boolean;
+        }> | undefined;
+        roles_inheritance?: Record<string, string[]> | undefined;
+    }>;
+    plans?: Record<string, {
+        name: string;
+        summary?: string | undefined;
+        description?: string | undefined;
+        resource_limits?: Record<string, number> | undefined;
+        usage_based_limits?: Record<string, {
+            value: number;
+            period: "monthly" | "yearly" | "lifetime";
+        }> | undefined;
+    }> | undefined;
+    entitlements?: Record<string, {
+        roles?: string[] | undefined;
+        plans?: string[] | undefined;
+        limit?: string | undefined;
+    }> | undefined;
+    features?: Record<string, {
+        name: string;
+        plans?: string[] | undefined;
+        summary?: string | undefined;
+        entitlements?: string[] | undefined;
+        default_enabled?: boolean | undefined;
+    }> | undefined;
+}>;
+type ResourceDefinition = z.infer<typeof ResourceDefinitionSchema>;
+type EntitlementDefinition = z.infer<typeof EntitlementDefinitionSchema>;
+type FeatureDefinition = z.infer<typeof FeatureDefinitionSchema>;
+type PlanDefinition = z.infer<typeof PlanDefinitionSchema>;
+type BlimuConfig = z.infer<typeof BlimuConfigSchema>;
+
+type BlimuConfigInput = {
+    resources: Record<string, ResourceDefinition>;
+    entitlements?: Record<string, EntitlementDefinition>;
+    features?: Record<string, FeatureDefinition>;
+    plans?: Record<string, PlanDefinition>;
+};
+declare function defineConfig<T extends BlimuConfigInput>(config: T): T;
+
+type InferResourceTypes<T> = T extends {
+    resources: infer R;
+} ? R extends Record<string, any> ? keyof R : never : never;
+type InferEntitlementTypes<T> = T extends {
+    entitlements: infer E;
+} ? E extends Record<string, any> ? keyof E : never : never;
+type InferPlanTypes<T> = T extends {
+    plans: infer P;
+} ? P extends Record<string, any> ? keyof P : never : never;
+type InferLimitTypes<T> = T extends {
+    plans: infer P;
+} ? P extends Record<string, any> ? P[keyof P] extends {
+    resource_limits?: infer RL;
+} ? RL extends Record<string, any> ? keyof RL : never : never : never : never;
+type InferUsageLimitTypes<T> = T extends {
+    plans: infer P;
+} ? P extends Record<string, any> ? P[keyof P] extends {
+    usage_based_limits?: infer UL;
+} ? UL extends Record<string, any> ? keyof UL : never : never : never : never;
+
+export { type BlimuConfig, BlimuConfigSchema, type EntitlementDefinition, EntitlementDefinitionSchema, type FeatureDefinition, FeatureDefinitionSchema, type InferEntitlementTypes, type InferLimitTypes, type InferPlanTypes, type InferResourceTypes, type InferUsageLimitTypes, type PlanDefinition, PlanDefinitionSchema, type ResourceDefinition, ResourceDefinitionSchema, defineConfig };

package/dist/index.d.ts

@@ -0,0 +1,285 @@
+import { z } from 'zod';
+
+declare const ResourceDefinitionSchema: z.ZodObject<{
+    is_tenant: z.ZodOptional<z.ZodBoolean>;
+    roles: z.ZodArray<z.ZodString, "many">;
+    parents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        required: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        required: boolean;
+    }, {
+        required: boolean;
+    }>>>;
+    roles_inheritance: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
+}, "strip", z.ZodTypeAny, {
+    roles: string[];
+    is_tenant?: boolean | undefined;
+    parents?: Record<string, {
+        required: boolean;
+    }> | undefined;
+    roles_inheritance?: Record<string, string[]> | undefined;
+}, {
+    roles: string[];
+    is_tenant?: boolean | undefined;
+    parents?: Record<string, {
+        required: boolean;
+    }> | undefined;
+    roles_inheritance?: Record<string, string[]> | undefined;
+}>;
+declare const EntitlementDefinitionSchema: z.ZodObject<{
+    roles: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    plans: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    limit: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    roles?: string[] | undefined;
+    plans?: string[] | undefined;
+    limit?: string | undefined;
+}, {
+    roles?: string[] | undefined;
+    plans?: string[] | undefined;
+    limit?: string | undefined;
+}>;
+declare const FeatureDefinitionSchema: z.ZodObject<{
+    name: z.ZodString;
+    summary: z.ZodOptional<z.ZodString>;
+    entitlements: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    plans: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    default_enabled: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    plans?: string[] | undefined;
+    summary?: string | undefined;
+    entitlements?: string[] | undefined;
+    default_enabled?: boolean | undefined;
+}, {
+    name: string;
+    plans?: string[] | undefined;
+    summary?: string | undefined;
+    entitlements?: string[] | undefined;
+    default_enabled?: boolean | undefined;
+}>;
+declare const PlanDefinitionSchema: z.ZodObject<{
+    name: z.ZodString;
+    summary: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    resource_limits: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    usage_based_limits: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        value: z.ZodNumber;
+        period: z.ZodEnum<["monthly", "yearly", "lifetime"]>;
+    }, "strip", z.ZodTypeAny, {
+        value: number;
+        period: "monthly" | "yearly" | "lifetime";
+    }, {
+        value: number;
+        period: "monthly" | "yearly" | "lifetime";
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    summary?: string | undefined;
+    description?: string | undefined;
+    resource_limits?: Record<string, number> | undefined;
+    usage_based_limits?: Record<string, {
+        value: number;
+        period: "monthly" | "yearly" | "lifetime";
+    }> | undefined;
+}, {
+    name: string;
+    summary?: string | undefined;
+    description?: string | undefined;
+    resource_limits?: Record<string, number> | undefined;
+    usage_based_limits?: Record<string, {
+        value: number;
+        period: "monthly" | "yearly" | "lifetime";
+    }> | undefined;
+}>;
+declare const BlimuConfigSchema: z.ZodObject<{
+    resources: z.ZodRecord<z.ZodString, z.ZodObject<{
+        is_tenant: z.ZodOptional<z.ZodBoolean>;
+        roles: z.ZodArray<z.ZodString, "many">;
+        parents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            required: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            required: boolean;
+        }, {
+            required: boolean;
+        }>>>;
+        roles_inheritance: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
+    }, "strip", z.ZodTypeAny, {
+        roles: string[];
+        is_tenant?: boolean | undefined;
+        parents?: Record<string, {
+            required: boolean;
+        }> | undefined;
+        roles_inheritance?: Record<string, string[]> | undefined;
+    }, {
+        roles: string[];
+        is_tenant?: boolean | undefined;
+        parents?: Record<string, {
+            required: boolean;
+        }> | undefined;
+        roles_inheritance?: Record<string, string[]> | undefined;
+    }>>;
+    entitlements: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        roles: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        plans: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        limit: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        roles?: string[] | undefined;
+        plans?: string[] | undefined;
+        limit?: string | undefined;
+    }, {
+        roles?: string[] | undefined;
+        plans?: string[] | undefined;
+        limit?: string | undefined;
+    }>>>;
+    features: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        name: z.ZodString;
+        summary: z.ZodOptional<z.ZodString>;
+        entitlements: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        plans: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        default_enabled: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        plans?: string[] | undefined;
+        summary?: string | undefined;
+        entitlements?: string[] | undefined;
+        default_enabled?: boolean | undefined;
+    }, {
+        name: string;
+        plans?: string[] | undefined;
+        summary?: string | undefined;
+        entitlements?: string[] | undefined;
+        default_enabled?: boolean | undefined;
+    }>>>;
+    plans: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        name: z.ZodString;
+        summary: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        resource_limits: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        usage_based_limits: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            value: z.ZodNumber;
+            period: z.ZodEnum<["monthly", "yearly", "lifetime"]>;
+        }, "strip", z.ZodTypeAny, {
+            value: number;
+            period: "monthly" | "yearly" | "lifetime";
+        }, {
+            value: number;
+            period: "monthly" | "yearly" | "lifetime";
+        }>>>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        summary?: string | undefined;
+        description?: string | undefined;
+        resource_limits?: Record<string, number> | undefined;
+        usage_based_limits?: Record<string, {
+            value: number;
+            period: "monthly" | "yearly" | "lifetime";
+        }> | undefined;
+    }, {
+        name: string;
+        summary?: string | undefined;
+        description?: string | undefined;
+        resource_limits?: Record<string, number> | undefined;
+        usage_based_limits?: Record<string, {
+            value: number;
+            period: "monthly" | "yearly" | "lifetime";
+        }> | undefined;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    resources: Record<string, {
+        roles: string[];
+        is_tenant?: boolean | undefined;
+        parents?: Record<string, {
+            required: boolean;
+        }> | undefined;
+        roles_inheritance?: Record<string, string[]> | undefined;
+    }>;
+    plans?: Record<string, {
+        name: string;
+        summary?: string | undefined;
+        description?: string | undefined;
+        resource_limits?: Record<string, number> | undefined;
+        usage_based_limits?: Record<string, {
+            value: number;
+            period: "monthly" | "yearly" | "lifetime";
+        }> | undefined;
+    }> | undefined;
+    entitlements?: Record<string, {
+        roles?: string[] | undefined;
+        plans?: string[] | undefined;
+        limit?: string | undefined;
+    }> | undefined;
+    features?: Record<string, {
+        name: string;
+        plans?: string[] | undefined;
+        summary?: string | undefined;
+        entitlements?: string[] | undefined;
+        default_enabled?: boolean | undefined;
+    }> | undefined;
+}, {
+    resources: Record<string, {
+        roles: string[];
+        is_tenant?: boolean | undefined;
+        parents?: Record<string, {
+            required: boolean;
+        }> | undefined;
+        roles_inheritance?: Record<string, string[]> | undefined;
+    }>;
+    plans?: Record<string, {
+        name: string;
+        summary?: string | undefined;
+        description?: string | undefined;
+        resource_limits?: Record<string, number> | undefined;
+        usage_based_limits?: Record<string, {
+            value: number;
+            period: "monthly" | "yearly" | "lifetime";
+        }> | undefined;
+    }> | undefined;
+    entitlements?: Record<string, {
+        roles?: string[] | undefined;
+        plans?: string[] | undefined;
+        limit?: string | undefined;
+    }> | undefined;
+    features?: Record<string, {
+        name: string;
+        plans?: string[] | undefined;
+        summary?: string | undefined;
+        entitlements?: string[] | undefined;
+        default_enabled?: boolean | undefined;
+    }> | undefined;
+}>;
+type ResourceDefinition = z.infer<typeof ResourceDefinitionSchema>;
+type EntitlementDefinition = z.infer<typeof EntitlementDefinitionSchema>;
+type FeatureDefinition = z.infer<typeof FeatureDefinitionSchema>;
+type PlanDefinition = z.infer<typeof PlanDefinitionSchema>;
+type BlimuConfig = z.infer<typeof BlimuConfigSchema>;
+
+type BlimuConfigInput = {
+    resources: Record<string, ResourceDefinition>;
+    entitlements?: Record<string, EntitlementDefinition>;
+    features?: Record<string, FeatureDefinition>;
+    plans?: Record<string, PlanDefinition>;
+};
+declare function defineConfig<T extends BlimuConfigInput>(config: T): T;
+
+type InferResourceTypes<T> = T extends {
+    resources: infer R;
+} ? R extends Record<string, any> ? keyof R : never : never;
+type InferEntitlementTypes<T> = T extends {
+    entitlements: infer E;
+} ? E extends Record<string, any> ? keyof E : never : never;
+type InferPlanTypes<T> = T extends {
+    plans: infer P;
+} ? P extends Record<string, any> ? keyof P : never : never;
+type InferLimitTypes<T> = T extends {
+    plans: infer P;
+} ? P extends Record<string, any> ? P[keyof P] extends {
+    resource_limits?: infer RL;
+} ? RL extends Record<string, any> ? keyof RL : never : never : never : never;
+type InferUsageLimitTypes<T> = T extends {
+    plans: infer P;
+} ? P extends Record<string, any> ? P[keyof P] extends {
+    usage_based_limits?: infer UL;
+} ? UL extends Record<string, any> ? keyof UL : never : never : never : never;
+
+export { type BlimuConfig, BlimuConfigSchema, type EntitlementDefinition, EntitlementDefinitionSchema, type FeatureDefinition, FeatureDefinitionSchema, type InferEntitlementTypes, type InferLimitTypes, type InferPlanTypes, type InferResourceTypes, type InferUsageLimitTypes, type PlanDefinition, PlanDefinitionSchema, type ResourceDefinition, ResourceDefinitionSchema, defineConfig };

package/dist/index.js

@@ -0,0 +1,93 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BlimuConfigSchema: () => BlimuConfigSchema,
+  EntitlementDefinitionSchema: () => EntitlementDefinitionSchema,
+  FeatureDefinitionSchema: () => FeatureDefinitionSchema,
+  PlanDefinitionSchema: () => PlanDefinitionSchema,
+  ResourceDefinitionSchema: () => ResourceDefinitionSchema,
+  defineConfig: () => defineConfig
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/config/schema.ts
+var import_zod = require("zod");
+var ResourceDefinitionSchema = import_zod.z.object({
+  is_tenant: import_zod.z.boolean().optional(),
+  roles: import_zod.z.array(import_zod.z.string()).min(1, "At least one role must be defined"),
+  parents: import_zod.z.record(import_zod.z.string(), import_zod.z.object({ required: import_zod.z.boolean() })).optional(),
+  roles_inheritance: import_zod.z.record(
+    import_zod.z.string().min(1),
+    // local role
+    // Allow tokens containing letters, numbers, underscores or dashes
+    // Examples: parent->editor, organization->admin, workspace_v2->viewer
+    import_zod.z.array(import_zod.z.string().regex(/^([a-z0-9_-]+->)*[a-z0-9_-]+$/i)).min(1)
+  ).optional()
+});
+var EntitlementDefinitionSchema = import_zod.z.object({
+  roles: import_zod.z.array(import_zod.z.string()).min(1).optional(),
+  plans: import_zod.z.array(import_zod.z.string()).optional(),
+  limit: import_zod.z.string().optional()
+  // Reference to usage-based limit
+});
+var FeatureDefinitionSchema = import_zod.z.object({
+  name: import_zod.z.string(),
+  summary: import_zod.z.string().optional(),
+  entitlements: import_zod.z.array(import_zod.z.string()).optional(),
+  plans: import_zod.z.array(import_zod.z.string()).optional(),
+  default_enabled: import_zod.z.boolean().optional()
+});
+var PlanDefinitionSchema = import_zod.z.object({
+  name: import_zod.z.string().min(1, "Plan name is required"),
+  summary: import_zod.z.string().optional(),
+  description: import_zod.z.string().min(1, "Plan description is required").optional(),
+  resource_limits: import_zod.z.record(import_zod.z.string(), import_zod.z.number().int().min(0)).optional(),
+  usage_based_limits: import_zod.z.record(
+    import_zod.z.string(),
+    import_zod.z.object({
+      value: import_zod.z.number().int().min(0),
+      period: import_zod.z.enum(["monthly", "yearly", "lifetime"])
+    })
+  ).optional()
+});
+var BlimuConfigSchema = import_zod.z.object({
+  resources: import_zod.z.record(import_zod.z.string().min(1), ResourceDefinitionSchema),
+  entitlements: import_zod.z.record(import_zod.z.string().min(1), EntitlementDefinitionSchema).optional(),
+  features: import_zod.z.record(import_zod.z.string().min(1), FeatureDefinitionSchema).optional(),
+  plans: import_zod.z.record(import_zod.z.string().min(1), PlanDefinitionSchema).optional()
+});
+
+// src/config/define-config.ts
+function defineConfig(config) {
+  const validated = BlimuConfigSchema.parse(config);
+  return config;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BlimuConfigSchema,
+  EntitlementDefinitionSchema,
+  FeatureDefinitionSchema,
+  PlanDefinitionSchema,
+  ResourceDefinitionSchema,
+  defineConfig
+});
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/config/schema.ts","../src/config/define-config.ts"],"sourcesContent":["// Library exports for programmatic usage\n\n/**\n * Configuration utilities\n */\nexport { defineConfig } from './config/define-config';\nexport type {\n  BlimuConfig,\n  ResourceDefinition,\n  EntitlementDefinition,\n  FeatureDefinition,\n  PlanDefinition,\n} from './config/schema';\nexport {\n  BlimuConfigSchema,\n  ResourceDefinitionSchema,\n  EntitlementDefinitionSchema,\n  FeatureDefinitionSchema,\n  PlanDefinitionSchema,\n} from './config/schema';\n\n/**\n * Type inference utilities\n */\nexport type {\n  InferResourceTypes,\n  InferEntitlementTypes,\n  InferPlanTypes,\n  InferLimitTypes,\n  InferUsageLimitTypes,\n} from './types/infer';\n","import { z } from 'zod';\n\n/**\n * Zod schema for resource definition\n */\nexport const ResourceDefinitionSchema = z.object({\n  is_tenant: z.boolean().optional(),\n  roles: z.array(z.string()).min(1, 'At least one role must be defined'),\n  parents: z.record(z.string(), z.object({ required: z.boolean() })).optional(),\n  roles_inheritance: z\n    .record(\n      z.string().min(1), // local role\n      // Allow tokens containing letters, numbers, underscores or dashes\n      // Examples: parent->editor, organization->admin, workspace_v2->viewer\n      z.array(z.string().regex(/^([a-z0-9_-]+->)*[a-z0-9_-]+$/i)).min(1),\n    )\n    .optional(),\n});\n\n/**\n * Zod schema for entitlement definition\n */\nexport const EntitlementDefinitionSchema = z.object({\n  roles: z.array(z.string()).min(1).optional(),\n  plans: z.array(z.string()).optional(),\n  limit: z.string().optional(), // Reference to usage-based limit\n});\n\n/**\n * Zod schema for feature definition\n */\nexport const FeatureDefinitionSchema = z.object({\n  name: z.string(),\n  summary: z.string().optional(),\n  entitlements: z.array(z.string()).optional(),\n  plans: z.array(z.string()).optional(),\n  default_enabled: z.boolean().optional(),\n});\n\n/**\n * Zod schema for plan definition\n */\nexport const PlanDefinitionSchema = z.object({\n  name: z.string().min(1, 'Plan name is required'),\n  summary: z.string().optional(),\n  description: z.string().min(1, 'Plan description is required').optional(),\n  resource_limits: z.record(z.string(), z.number().int().min(0)).optional(),\n  usage_based_limits: z\n    .record(\n      z.string(),\n      z.object({\n        value: z.number().int().min(0),\n        period: z.enum(['monthly', 'yearly', 'lifetime']),\n      }),\n    )\n    .optional(),\n});\n\n/**\n * Zod schema for complete Blimu configuration\n */\nexport const BlimuConfigSchema = z.object({\n  resources: z.record(z.string().min(1), ResourceDefinitionSchema),\n  entitlements: z.record(z.string().min(1), EntitlementDefinitionSchema).optional(),\n  features: z.record(z.string().min(1), FeatureDefinitionSchema).optional(),\n  plans: z.record(z.string().min(1), PlanDefinitionSchema).optional(),\n});\n\n/**\n * Type inference from schemas\n */\nexport type ResourceDefinition = z.infer<typeof ResourceDefinitionSchema>;\nexport type EntitlementDefinition = z.infer<typeof EntitlementDefinitionSchema>;\nexport type FeatureDefinition = z.infer<typeof FeatureDefinitionSchema>;\nexport type PlanDefinition = z.infer<typeof PlanDefinitionSchema>;\nexport type BlimuConfig = z.infer<typeof BlimuConfigSchema>;\n","import {\n  BlimuConfigSchema,\n  type BlimuConfig,\n  type ResourceDefinition,\n  type EntitlementDefinition,\n  type FeatureDefinition,\n  type PlanDefinition,\n} from './schema';\n\n/**\n * Input type for defineConfig (allows partial config during definition)\n * Uses proper types inferred from Zod schemas for full type safety\n */\nexport type BlimuConfigInput = {\n  resources: Record<string, ResourceDefinition>;\n  entitlements?: Record<string, EntitlementDefinition>;\n  features?: Record<string, FeatureDefinition>;\n  plans?: Record<string, PlanDefinition>;\n};\n\n/**\n * Defines and validates a Blimu configuration.\n *\n * This function validates the config using Zod schemas and returns\n * a type-safe, validated configuration object.\n *\n * @param config - The Blimu configuration object\n * @returns The validated configuration\n * @throws {z.ZodError} If the configuration is invalid\n *\n * @example\n * ```typescript\n * import { defineConfig } from 'blimu';\n *\n * export default defineConfig({\n *   resources: {\n *     workspace: {\n *       roles: ['admin', 'editor', 'viewer'],\n *       is_tenant: true,\n *     },\n *   },\n *   entitlements: {\n *     'workspace:read': {\n *       roles: ['admin', 'editor', 'viewer'],\n *     },\n *   },\n * });\n * ```\n */\nexport function defineConfig<T extends BlimuConfigInput>(config: T): T {\n  // Validate the config using Zod schema\n  const validated = BlimuConfigSchema.parse(config);\n\n  // Return the original config (with proper typing) after validation\n  // This preserves the exact structure and types from the input\n  return config as T & BlimuConfig;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAA,iBAAkB;AAKX,IAAM,2BAA2B,aAAE,OAAO;AAAA,EAC/C,WAAW,aAAE,QAAQ,EAAE,SAAS;AAAA,EAChC,OAAO,aAAE,MAAM,aAAE,OAAO,CAAC,EAAE,IAAI,GAAG,mCAAmC;AAAA,EACrE,SAAS,aAAE,OAAO,aAAE,OAAO,GAAG,aAAE,OAAO,EAAE,UAAU,aAAE,QAAQ,EAAE,CAAC,CAAC,EAAE,SAAS;AAAA,EAC5E,mBAAmB,aAChB;AAAA,IACC,aAAE,OAAO,EAAE,IAAI,CAAC;AAAA;AAAA;AAAA;AAAA,IAGhB,aAAE,MAAM,aAAE,OAAO,EAAE,MAAM,gCAAgC,CAAC,EAAE,IAAI,CAAC;AAAA,EACnE,EACC,SAAS;AACd,CAAC;AAKM,IAAM,8BAA8B,aAAE,OAAO;AAAA,EAClD,OAAO,aAAE,MAAM,aAAE,OAAO,CAAC,EAAE,IAAI,CAAC,EAAE,SAAS;AAAA,EAC3C,OAAO,aAAE,MAAM,aAAE,OAAO,CAAC,EAAE,SAAS;AAAA,EACpC,OAAO,aAAE,OAAO,EAAE,SAAS;AAAA;AAC7B,CAAC;AAKM,IAAM,0BAA0B,aAAE,OAAO;AAAA,EAC9C,MAAM,aAAE,OAAO;AAAA,EACf,SAAS,aAAE,OAAO,EAAE,SAAS;AAAA,EAC7B,cAAc,aAAE,MAAM,aAAE,OAAO,CAAC,EAAE,SAAS;AAAA,EAC3C,OAAO,aAAE,MAAM,aAAE,OAAO,CAAC,EAAE,SAAS;AAAA,EACpC,iBAAiB,aAAE,QAAQ,EAAE,SAAS;AACxC,CAAC;AAKM,IAAM,uBAAuB,aAAE,OAAO;AAAA,EAC3C,MAAM,aAAE,OAAO,EAAE,IAAI,GAAG,uBAAuB;AAAA,EAC/C,SAAS,aAAE,OAAO,EAAE,SAAS;AAAA,EAC7B,aAAa,aAAE,OAAO,EAAE,IAAI,GAAG,8BAA8B,EAAE,SAAS;AAAA,EACxE,iBAAiB,aAAE,OAAO,aAAE,OAAO,GAAG,aAAE,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,EAAE,SAAS;AAAA,EACxE,oBAAoB,aACjB;AAAA,IACC,aAAE,OAAO;AAAA,IACT,aAAE,OAAO;AAAA,MACP,OAAO,aAAE,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC;AAAA,MAC7B,QAAQ,aAAE,KAAK,CAAC,WAAW,UAAU,UAAU,CAAC;AAAA,IAClD,CAAC;AAAA,EACH,EACC,SAAS;AACd,CAAC;AAKM,IAAM,oBAAoB,aAAE,OAAO;AAAA,EACxC,WAAW,aAAE,OAAO,aAAE,OAAO,EAAE,IAAI,CAAC,GAAG,wBAAwB;AAAA,EAC/D,cAAc,aAAE,OAAO,aAAE,OAAO,EAAE,IAAI,CAAC,GAAG,2BAA2B,EAAE,SAAS;AAAA,EAChF,UAAU,aAAE,OAAO,aAAE,OAAO,EAAE,IAAI,CAAC,GAAG,uBAAuB,EAAE,SAAS;AAAA,EACxE,OAAO,aAAE,OAAO,aAAE,OAAO,EAAE,IAAI,CAAC,GAAG,oBAAoB,EAAE,SAAS;AACpE,CAAC;;;ACjBM,SAAS,aAAyC,QAAc;AAErE,QAAM,YAAY,kBAAkB,MAAM,MAAM;AAIhD,SAAO;AACT;","names":[]}

package/dist/index.mjs

@@ -0,0 +1,61 @@
+// src/config/schema.ts
+import { z } from "zod";
+var ResourceDefinitionSchema = z.object({
+  is_tenant: z.boolean().optional(),
+  roles: z.array(z.string()).min(1, "At least one role must be defined"),
+  parents: z.record(z.string(), z.object({ required: z.boolean() })).optional(),
+  roles_inheritance: z.record(
+    z.string().min(1),
+    // local role
+    // Allow tokens containing letters, numbers, underscores or dashes
+    // Examples: parent->editor, organization->admin, workspace_v2->viewer
+    z.array(z.string().regex(/^([a-z0-9_-]+->)*[a-z0-9_-]+$/i)).min(1)
+  ).optional()
+});
+var EntitlementDefinitionSchema = z.object({
+  roles: z.array(z.string()).min(1).optional(),
+  plans: z.array(z.string()).optional(),
+  limit: z.string().optional()
+  // Reference to usage-based limit
+});
+var FeatureDefinitionSchema = z.object({
+  name: z.string(),
+  summary: z.string().optional(),
+  entitlements: z.array(z.string()).optional(),
+  plans: z.array(z.string()).optional(),
+  default_enabled: z.boolean().optional()
+});
+var PlanDefinitionSchema = z.object({
+  name: z.string().min(1, "Plan name is required"),
+  summary: z.string().optional(),
+  description: z.string().min(1, "Plan description is required").optional(),
+  resource_limits: z.record(z.string(), z.number().int().min(0)).optional(),
+  usage_based_limits: z.record(
+    z.string(),
+    z.object({
+      value: z.number().int().min(0),
+      period: z.enum(["monthly", "yearly", "lifetime"])
+    })
+  ).optional()
+});
+var BlimuConfigSchema = z.object({
+  resources: z.record(z.string().min(1), ResourceDefinitionSchema),
+  entitlements: z.record(z.string().min(1), EntitlementDefinitionSchema).optional(),
+  features: z.record(z.string().min(1), FeatureDefinitionSchema).optional(),
+  plans: z.record(z.string().min(1), PlanDefinitionSchema).optional()
+});
+
+// src/config/define-config.ts
+function defineConfig(config) {
+  const validated = BlimuConfigSchema.parse(config);
+  return config;
+}
+export {
+  BlimuConfigSchema,
+  EntitlementDefinitionSchema,
+  FeatureDefinitionSchema,
+  PlanDefinitionSchema,
+  ResourceDefinitionSchema,
+  defineConfig
+};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/config/schema.ts","../src/config/define-config.ts"],"sourcesContent":["import { z } from 'zod';\n\n/**\n * Zod schema for resource definition\n */\nexport const ResourceDefinitionSchema = z.object({\n  is_tenant: z.boolean().optional(),\n  roles: z.array(z.string()).min(1, 'At least one role must be defined'),\n  parents: z.record(z.string(), z.object({ required: z.boolean() })).optional(),\n  roles_inheritance: z\n    .record(\n      z.string().min(1), // local role\n      // Allow tokens containing letters, numbers, underscores or dashes\n      // Examples: parent->editor, organization->admin, workspace_v2->viewer\n      z.array(z.string().regex(/^([a-z0-9_-]+->)*[a-z0-9_-]+$/i)).min(1),\n    )\n    .optional(),\n});\n\n/**\n * Zod schema for entitlement definition\n */\nexport const EntitlementDefinitionSchema = z.object({\n  roles: z.array(z.string()).min(1).optional(),\n  plans: z.array(z.string()).optional(),\n  limit: z.string().optional(), // Reference to usage-based limit\n});\n\n/**\n * Zod schema for feature definition\n */\nexport const FeatureDefinitionSchema = z.object({\n  name: z.string(),\n  summary: z.string().optional(),\n  entitlements: z.array(z.string()).optional(),\n  plans: z.array(z.string()).optional(),\n  default_enabled: z.boolean().optional(),\n});\n\n/**\n * Zod schema for plan definition\n */\nexport const PlanDefinitionSchema = z.object({\n  name: z.string().min(1, 'Plan name is required'),\n  summary: z.string().optional(),\n  description: z.string().min(1, 'Plan description is required').optional(),\n  resource_limits: z.record(z.string(), z.number().int().min(0)).optional(),\n  usage_based_limits: z\n    .record(\n      z.string(),\n      z.object({\n        value: z.number().int().min(0),\n        period: z.enum(['monthly', 'yearly', 'lifetime']),\n      }),\n    )\n    .optional(),\n});\n\n/**\n * Zod schema for complete Blimu configuration\n */\nexport const BlimuConfigSchema = z.object({\n  resources: z.record(z.string().min(1), ResourceDefinitionSchema),\n  entitlements: z.record(z.string().min(1), EntitlementDefinitionSchema).optional(),\n  features: z.record(z.string().min(1), FeatureDefinitionSchema).optional(),\n  plans: z.record(z.string().min(1), PlanDefinitionSchema).optional(),\n});\n\n/**\n * Type inference from schemas\n */\nexport type ResourceDefinition = z.infer<typeof ResourceDefinitionSchema>;\nexport type EntitlementDefinition = z.infer<typeof EntitlementDefinitionSchema>;\nexport type FeatureDefinition = z.infer<typeof FeatureDefinitionSchema>;\nexport type PlanDefinition = z.infer<typeof PlanDefinitionSchema>;\nexport type BlimuConfig = z.infer<typeof BlimuConfigSchema>;\n","import {\n  BlimuConfigSchema,\n  type BlimuConfig,\n  type ResourceDefinition,\n  type EntitlementDefinition,\n  type FeatureDefinition,\n  type PlanDefinition,\n} from './schema';\n\n/**\n * Input type for defineConfig (allows partial config during definition)\n * Uses proper types inferred from Zod schemas for full type safety\n */\nexport type BlimuConfigInput = {\n  resources: Record<string, ResourceDefinition>;\n  entitlements?: Record<string, EntitlementDefinition>;\n  features?: Record<string, FeatureDefinition>;\n  plans?: Record<string, PlanDefinition>;\n};\n\n/**\n * Defines and validates a Blimu configuration.\n *\n * This function validates the config using Zod schemas and returns\n * a type-safe, validated configuration object.\n *\n * @param config - The Blimu configuration object\n * @returns The validated configuration\n * @throws {z.ZodError} If the configuration is invalid\n *\n * @example\n * ```typescript\n * import { defineConfig } from 'blimu';\n *\n * export default defineConfig({\n *   resources: {\n *     workspace: {\n *       roles: ['admin', 'editor', 'viewer'],\n *       is_tenant: true,\n *     },\n *   },\n *   entitlements: {\n *     'workspace:read': {\n *       roles: ['admin', 'editor', 'viewer'],\n *     },\n *   },\n * });\n * ```\n */\nexport function defineConfig<T extends BlimuConfigInput>(config: T): T {\n  // Validate the config using Zod schema\n  const validated = BlimuConfigSchema.parse(config);\n\n  // Return the original config (with proper typing) after validation\n  // This preserves the exact structure and types from the input\n  return config as T & BlimuConfig;\n}\n"],"mappings":";AAAA,SAAS,SAAS;AAKX,IAAM,2BAA2B,EAAE,OAAO;AAAA,EAC/C,WAAW,EAAE,QAAQ,EAAE,SAAS;AAAA,EAChC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,GAAG,mCAAmC;AAAA,EACrE,SAAS,EAAE,OAAO,EAAE,OAAO,GAAG,EAAE,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,CAAC,CAAC,EAAE,SAAS;AAAA,EAC5E,mBAAmB,EAChB;AAAA,IACC,EAAE,OAAO,EAAE,IAAI,CAAC;AAAA;AAAA;AAAA;AAAA,IAGhB,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,gCAAgC,CAAC,EAAE,IAAI,CAAC;AAAA,EACnE,EACC,SAAS;AACd,CAAC;AAKM,IAAM,8BAA8B,EAAE,OAAO;AAAA,EAClD,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,CAAC,EAAE,SAAS;AAAA,EAC3C,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,SAAS;AAAA,EACpC,OAAO,EAAE,OAAO,EAAE,SAAS;AAAA;AAC7B,CAAC;AAKM,IAAM,0BAA0B,EAAE,OAAO;AAAA,EAC9C,MAAM,EAAE,OAAO;AAAA,EACf,SAAS,EAAE,OAAO,EAAE,SAAS;AAAA,EAC7B,cAAc,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,SAAS;AAAA,EAC3C,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,SAAS;AAAA,EACpC,iBAAiB,EAAE,QAAQ,EAAE,SAAS;AACxC,CAAC;AAKM,IAAM,uBAAuB,EAAE,OAAO;AAAA,EAC3C,MAAM,EAAE,OAAO,EAAE,IAAI,GAAG,uBAAuB;AAAA,EAC/C,SAAS,EAAE,OAAO,EAAE,SAAS;AAAA,EAC7B,aAAa,EAAE,OAAO,EAAE,IAAI,GAAG,8BAA8B,EAAE,SAAS;AAAA,EACxE,iBAAiB,EAAE,OAAO,EAAE,OAAO,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,EAAE,SAAS;AAAA,EACxE,oBAAoB,EACjB;AAAA,IACC,EAAE,OAAO;AAAA,IACT,EAAE,OAAO;AAAA,MACP,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC;AAAA,MAC7B,QAAQ,EAAE,KAAK,CAAC,WAAW,UAAU,UAAU,CAAC;AAAA,IAClD,CAAC;AAAA,EACH,EACC,SAAS;AACd,CAAC;AAKM,IAAM,oBAAoB,EAAE,OAAO;AAAA,EACxC,WAAW,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,GAAG,wBAAwB;AAAA,EAC/D,cAAc,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,GAAG,2BAA2B,EAAE,SAAS;AAAA,EAChF,UAAU,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,GAAG,uBAAuB,EAAE,SAAS;AAAA,EACxE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,GAAG,oBAAoB,EAAE,SAAS;AACpE,CAAC;;;ACjBM,SAAS,aAAyC,QAAc;AAErE,QAAM,YAAY,kBAAkB,MAAM,MAAM;AAIhD,SAAO;AACT;","names":[]}

package/dist/main.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+"use strict";var b=Object.create;var y=Object.defineProperty;var j=Object.getOwnPropertyDescriptor;var w=Object.getOwnPropertyNames;var C=Object.getPrototypeOf,I=Object.prototype.hasOwnProperty;var $=(i,t,s,o)=>{if(t&&typeof t=="object"||typeof t=="function")for(let e of w(t))!I.call(i,e)&&e!==s&&y(i,e,{get:()=>t[e],enumerable:!(o=j(t,e))||o.enumerable});return i};var f=(i,t,s)=>(s=i!=null?b(C(i)):{},$(t||!i||!i.__esModule?y(s,"default",{value:i,enumerable:!0}):s,i));var T=require("commander");var n=f(require("path")),h=f(require("fs")),r=f(require("@clack/prompts"));var c=f(require("fs")),p=f(require("path"));function d(i){let{configPath:t,outputPath:s,typesPackages:o=["@blimu/types","@blimu/backend"]}=i,e=[],a=o.join(" and ");e.push("/**"),e.push(` * Type Augmentation for ${a}`),e.push(" *"),e.push(` * This file augments the ${a} packages with union types`),e.push(" * specific to your environment configuration."),e.push(" *"),e.push(" * Types are automatically inferred from your blimu.config.ts file."),e.push(" * No regeneration needed when you update your config!"),e.push(" *"),e.push(" * Make sure to include this file in your tsconfig.json:"),e.push(" * {"),e.push(' *   "include": ["blimu-types.d.ts"]'),e.push(" * }"),e.push(" */"),e.push("");let u=p.dirname(s),l=p.isAbsolute(t)?p.resolve(t):p.resolve(u,t),m=p.relative(u,l).replace(/\.(ts|mjs|js)$/,""),k=m.startsWith(".")?m:`./${m}`;e.push(`import type config from '${k}';`),e.push("import type {"),e.push("  InferResourceTypes,"),e.push("  InferEntitlementTypes,"),e.push("  InferPlanTypes,"),e.push("  InferLimitTypes,"),e.push("  InferUsageLimitTypes,"),e.push("} from 'blimu';"),e.push("");for(let v of o)e.push(`declare module '${v}' {`),e.push("  /**"),e.push("   * Resource types inferred from your Blimu configuration."),e.push("   */"),e.push("  type ResourceType = InferResourceTypes<typeof config>;"),e.push(""),e.push("  /**"),e.push("   * Entitlement types inferred from your Blimu configuration."),e.push("   */"),e.push("  type EntitlementType = InferEntitlementTypes<typeof config>;"),e.push(""),e.push("  /**"),e.push("   * Plan types inferred from your Blimu configuration."),e.push("   */"),e.push("  type PlanType = InferPlanTypes<typeof config>;"),e.push(""),e.push("  /**"),e.push("   * Limit types inferred from your Blimu configuration."),e.push("   */"),e.push("  type LimitType = InferLimitTypes<typeof config>;"),e.push(""),e.push("  /**"),e.push("   * Usage limit types inferred from your Blimu configuration."),e.push("   */"),e.push("  type UsageLimitType = InferUsageLimitTypes<typeof config>;"),e.push("}"),e.push("");c.existsSync(u)||c.mkdirSync(u,{recursive:!0}),c.writeFileSync(s,e.join(`
+`),"utf-8")}function x(){let i=[n.join(process.cwd(),"blimu.config.ts"),n.join(process.cwd(),"blimu.config.mjs"),n.join(process.cwd(),"blimu.config.js")];for(let t of i)if(h.existsSync(t))return t;return null}function A(i,t){let o=n.relative(i,t).replace(/\.(ts|mjs|js)$/,"");return o.startsWith(".")?o:`./${o}`}function P(i){i.command("codegen").description("Generate type augmentation file from Blimu config").option("--config <path>","Path to Blimu config file (defaults to blimu.config.ts in project root)").option("--output <path>","Output path for generated type augmentation file (defaults to blimu-types.d.ts in project root)").action(async t=>{let s=r.spinner();try{let o=t.config||x();o||(r.cancel("No config file found. Please provide --config or ensure blimu.config.ts exists in project root."),process.exit(1));let e=n.isAbsolute(o)?o:n.resolve(process.cwd(),o);h.existsSync(e)||(r.cancel(`Config file not found: ${e}`),process.exit(1)),r.log.step(`Using config file: ${e}`);let a=t.output?n.isAbsolute(t.output)?t.output:n.resolve(process.cwd(),t.output):n.join(process.cwd(),"blimu-types.d.ts");r.log.step(`Output: ${a}`);let u=n.dirname(a),l=A(u,e);s.start("Generating type augmentation file with type inference..."),d({configPath:l,outputPath:a}),s.stop("\u26A1\uFE0F Successfully generated type augmentation file"),r.log.success(`Generated at: ${a}`),r.log.info("\u{1F4A1} Tip: Types are automatically inferred from your config."),r.log.info("   No regeneration needed when you update blimu.config.ts!")}catch(o){s.stop("\u274C Failed to generate type augmentation"),r.log.error(`Failed to generate type augmentation: ${o instanceof Error?o.message:String(o)}`),o instanceof Error&&o.stack&&r.log.error(o.stack),process.exit(1)}})}var g=new T.Command;g.name("blimu").description("Blimu - Authorization as a Service CLI").version(process.env.npm_package_version||"0.7.0");P(g);g.parse();
+//# sourceMappingURL=main.js.map

package/dist/main.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/main.ts","../src/commands/codegen.ts","../src/utils/type-augmentation-generator.ts"],"sourcesContent":["import { Command } from 'commander';\nimport { codegenCommand } from './commands/codegen';\n\nconst program = new Command();\n\nprogram\n  .name('blimu')\n  .description('Blimu - Authorization as a Service CLI')\n  .version(process.env.npm_package_version || '0.7.0');\n\n// Register commands\ncodegenCommand(program);\n\n// Parse arguments\nprogram.parse();\n","import { Command } from 'commander';\nimport * as path from 'path';\nimport * as fs from 'fs';\nimport * as clack from '@clack/prompts';\nimport { generateTypeAugmentationFile } from '../utils/type-augmentation-generator';\n\n/**\n * Find default config file in project root\n */\nfunction findDefaultConfig(): string | null {\n  const possiblePaths = [\n    path.join(process.cwd(), 'blimu.config.ts'),\n    path.join(process.cwd(), 'blimu.config.mjs'),\n    path.join(process.cwd(), 'blimu.config.js'),\n  ];\n\n  for (const configPath of possiblePaths) {\n    if (fs.existsSync(configPath)) {\n      return configPath;\n    }\n  }\n\n  return null;\n}\n\n/**\n * Get relative import path from output directory to config file\n * Handles both relative paths and ensures proper extension handling\n */\nfunction getRelativeImportPath(fromDir: string, toFile: string): string {\n  const relative = path.relative(fromDir, toFile);\n  // Remove .ts/.mjs/.js extension for import\n  const withoutExt = relative.replace(/\\.(ts|mjs|js)$/, '');\n  // Ensure it starts with ./ or ../\n  if (!withoutExt.startsWith('.')) {\n    return `./${withoutExt}`;\n  }\n  return withoutExt;\n}\n\n/**\n * Register the codegen command\n */\nexport function codegenCommand(program: Command): void {\n  program\n    .command('codegen')\n    .description('Generate type augmentation file from Blimu config')\n    .option(\n      '--config <path>',\n      'Path to Blimu config file (defaults to blimu.config.ts in project root)',\n    )\n    .option(\n      '--output <path>',\n      'Output path for generated type augmentation file (defaults to blimu-types.d.ts in project root)',\n    )\n    .action(async (options) => {\n      const spinner = clack.spinner();\n\n      try {\n        // Find config file\n        const configPath = options.config || findDefaultConfig();\n        if (!configPath) {\n          clack.cancel(\n            'No config file found. Please provide --config or ensure blimu.config.ts exists in project root.',\n          );\n          process.exit(1);\n        }\n\n        // Resolve to absolute path\n        const absoluteConfigPath = path.isAbsolute(configPath)\n          ? configPath\n          : path.resolve(process.cwd(), configPath);\n\n        if (!fs.existsSync(absoluteConfigPath)) {\n          clack.cancel(`Config file not found: ${absoluteConfigPath}`);\n          process.exit(1);\n        }\n\n        clack.log.step(`Using config file: ${absoluteConfigPath}`);\n\n        // Determine output path\n        const outputPath = options.output\n          ? path.isAbsolute(options.output)\n            ? options.output\n            : path.resolve(process.cwd(), options.output)\n          : path.join(process.cwd(), 'blimu-types.d.ts');\n\n        clack.log.step(`Output: ${outputPath}`);\n\n        // Calculate relative path from output to config for import statement\n        const outputDir = path.dirname(outputPath);\n        const relativeConfigPath = getRelativeImportPath(outputDir, absoluteConfigPath);\n\n        // Generate type augmentation file\n        spinner.start('Generating type augmentation file with type inference...');\n\n        generateTypeAugmentationFile({\n          configPath: relativeConfigPath,\n          outputPath,\n          // Always augment both @blimu/types and @blimu/backend\n          // This is an internal implementation detail, not user-configurable\n        });\n\n        spinner.stop('⚡️ Successfully generated type augmentation file');\n\n        clack.log.success(`Generated at: ${outputPath}`);\n        clack.log.info('💡 Tip: Types are automatically inferred from your config.');\n        clack.log.info('   No regeneration needed when you update blimu.config.ts!');\n      } catch (error) {\n        spinner.stop('❌ Failed to generate type augmentation');\n        clack.log.error(\n          `Failed to generate type augmentation: ${error instanceof Error ? error.message : String(error)}`,\n        );\n        if (error instanceof Error && error.stack) {\n          clack.log.error(error.stack);\n        }\n        process.exit(1);\n      }\n    });\n}\n","import * as fs from 'fs';\nimport * as path from 'path';\n\n/**\n * Options for generating type augmentation file\n */\nexport interface GenerateTypeAugmentationOptions {\n  /** Path to the config file (relative to output directory or absolute) */\n  configPath: string;\n  /** Output path for the generated type augmentation file */\n  outputPath: string;\n  /** Types package names to augment (defaults to ['@blimu/types', '@blimu/backend']) */\n  typesPackages?: string[];\n}\n\n/**\n * Generate type augmentation file for @blimu/types and @blimu/backend using type inference utilities.\n *\n * This generates a .d.ts file that imports the config and uses type inference\n * utilities to automatically extract types from the config structure.\n *\n * @param options - Generation options\n */\nexport function generateTypeAugmentationFile(options: GenerateTypeAugmentationOptions): void {\n  const { configPath, outputPath, typesPackages = ['@blimu/types', '@blimu/backend'] } = options;\n\n  const lines: string[] = [];\n\n  // Header\n  const packageNames = typesPackages.join(' and ');\n  lines.push('/**');\n  lines.push(` * Type Augmentation for ${packageNames}`);\n  lines.push(' *');\n  lines.push(` * This file augments the ${packageNames} packages with union types`);\n  lines.push(' * specific to your environment configuration.');\n  lines.push(' *');\n  lines.push(' * Types are automatically inferred from your blimu.config.ts file.');\n  lines.push(' * No regeneration needed when you update your config!');\n  lines.push(' *');\n  lines.push(' * Make sure to include this file in your tsconfig.json:');\n  lines.push(' * {');\n  lines.push(' *   \"include\": [\"blimu-types.d.ts\"]');\n  lines.push(' * }');\n  lines.push(' */');\n  lines.push('');\n\n  // Calculate output directory and relative import path\n  const outputDir = path.dirname(outputPath);\n  const resolvedConfigPath = path.isAbsolute(configPath)\n    ? path.resolve(configPath)\n    : path.resolve(outputDir, configPath);\n  const relativeConfigPath = path.relative(outputDir, resolvedConfigPath);\n  // Remove .ts/.mjs/.js extension and ensure it starts with ./\n  const importPath = relativeConfigPath.replace(/\\.(ts|mjs|js)$/, '');\n  const finalImportPath = importPath.startsWith('.') ? importPath : `./${importPath}`;\n\n  // Import config and type utilities\n  lines.push(`import type config from '${finalImportPath}';`);\n  lines.push('import type {');\n  lines.push('  InferResourceTypes,');\n  lines.push('  InferEntitlementTypes,');\n  lines.push('  InferPlanTypes,');\n  lines.push('  InferLimitTypes,');\n  lines.push('  InferUsageLimitTypes,');\n  lines.push(\"} from 'blimu';\");\n  lines.push('');\n\n  // Generate module augmentation for each package\n  for (const typesPackage of typesPackages) {\n    lines.push(`declare module '${typesPackage}' {`);\n    lines.push('  /**');\n    lines.push('   * Resource types inferred from your Blimu configuration.');\n    lines.push('   */');\n    lines.push('  type ResourceType = InferResourceTypes<typeof config>;');\n    lines.push('');\n    lines.push('  /**');\n    lines.push('   * Entitlement types inferred from your Blimu configuration.');\n    lines.push('   */');\n    lines.push('  type EntitlementType = InferEntitlementTypes<typeof config>;');\n    lines.push('');\n    lines.push('  /**');\n    lines.push('   * Plan types inferred from your Blimu configuration.');\n    lines.push('   */');\n    lines.push('  type PlanType = InferPlanTypes<typeof config>;');\n    lines.push('');\n    lines.push('  /**');\n    lines.push('   * Limit types inferred from your Blimu configuration.');\n    lines.push('   */');\n    lines.push('  type LimitType = InferLimitTypes<typeof config>;');\n    lines.push('');\n    lines.push('  /**');\n    lines.push('   * Usage limit types inferred from your Blimu configuration.');\n    lines.push('   */');\n    lines.push('  type UsageLimitType = InferUsageLimitTypes<typeof config>;');\n    lines.push('}');\n    lines.push('');\n  }\n\n  // Ensure output directory exists\n  if (!fs.existsSync(outputDir)) {\n    fs.mkdirSync(outputDir, { recursive: true });\n  }\n\n  // Write file\n  fs.writeFileSync(outputPath, lines.join('\\n'), 'utf-8');\n}\n"],"mappings":"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","names":["import_commander","path","fs","clack","fs","path","generateTypeAugmentationFile","options","configPath","outputPath","typesPackages","lines","packageNames","outputDir","resolvedConfigPath","importPath","finalImportPath","typesPackage","findDefaultConfig","possiblePaths","configPath","getRelativeImportPath","fromDir","toFile","withoutExt","codegenCommand","program","options","spinner","absoluteConfigPath","outputPath","outputDir","relativeConfigPath","generateTypeAugmentationFile","error","program","codegenCommand"]}

package/package.json

@@ -1,19 +1,34 @@
 {
   "name": "blimu",
-  "version": "0.6.3",
-  "description": "Blimu - Authorization as a Service",
-  "main": "index.js",
-  "types": "index.d.ts",
-  "bin": "./bin/blimu",
+  "version": "1.1.0",
+  "description": "Blimu - Authorization as a Service CLI",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": "./dist/main.js",
   "files": [
-    "index.js",
-    "index.d.ts",
+    "dist",
     "README.md",
-    "bin/**",
-    "scripts/**"
+    "bin/**"
   ],
   "scripts": {
-    "postinstall": "node scripts/postinstall.js"
+    "build": "tsup",
+    "dev": "tsx watch src/main.ts",
+    "type-check": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "yarn build"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.11.0",
+    "commander": "^12.1.0",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/node": "^25.0.8",
+    "tsup": "^8.5.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.16"
   },
   "repository": {
     "type": "git",
@@ -25,9 +40,10 @@
     "authorization",
     "rbac",
     "access-control",
-    "permissions"
+    "permissions",
+    "cli"
   ],
   "engines": {
-    "node": ">=18"
+    "node": ">=18.0.0"
   }
 }

package/index.d.ts

@@ -1,4 +0,0 @@
-// This package is a placeholder to reserve the "blimu" package name on npm
-// For the actual Blimu SDK, please use @blimu/backend, @blimu/client, or @blimu/nestjs
-
-export {};

package/index.js

@@ -1,4 +0,0 @@
-// This package is a placeholder to reserve the "blimu" package name on npm
-// For the actual Blimu SDK, please use @blimu/backend, @blimu/client, or @blimu/nestjs
-
-module.exports = {};

package/scripts/download-binary.js

@@ -1,243 +0,0 @@
-#!/usr/bin/env node
-
-const https = require('https');
-const fs = require('fs');
-const path = require('path');
-const { execSync } = require('child_process');
-
-const BIN_DIR = path.join(__dirname, '..', 'bin');
-const GITHUB_REPO = 'blimu-dev/blimu-cli';
-
-// Platform mapping
-const platformMap = {
-  darwin: 'darwin',
-  linux: 'linux',
-  win32: 'windows',
-};
-
-// Architecture mapping
-const archMap = {
-  x64: 'amd64',
-  arm64: 'arm64',
-};
-
-function getPlatformInfo() {
-  const platform = process.platform;
-  const arch = process.arch;
-
-  const goPlatform = platformMap[platform];
-  const goArch = archMap[arch];
-
-  if (!goPlatform || !goArch) {
-    throw new Error(
-      `Unsupported platform: ${platform}/${arch}. Supported platforms: darwin, linux, win32. Supported architectures: x64, arm64`,
-    );
-  }
-
-  const binaryName = platform === 'win32' ? 'blimu.exe' : 'blimu';
-  const assetName = `blimu-${goPlatform}-${goArch}${platform === 'win32' ? '.exe' : ''}`;
-
-  return {
-    platform: goPlatform,
-    arch: goArch,
-    binaryName,
-    assetName,
-  };
-}
-
-/**
- * Verify that an existing binary matches the current platform/architecture
- * Returns true if the binary is correct, false otherwise
- */
-function verifyBinaryArchitecture(binaryPath) {
-  try {
-    // Use 'file' command to check binary type (available on macOS and Linux)
-    const output = execSync(`file "${binaryPath}"`, { encoding: 'utf8' });
-
-    const platform = process.platform;
-    const arch = process.arch;
-
-    if (platform === 'darwin') {
-      // macOS: should be "Mach-O 64-bit executable arm64" or "Mach-O 64-bit executable x86_64"
-      const expectedArch = arch === 'arm64' ? 'arm64' : 'x86_64';
-      if (!output.includes('Mach-O') || !output.includes(expectedArch)) {
-        return false;
-      }
-    } else if (platform === 'linux') {
-      // Linux: should be "ELF 64-bit LSB executable, x86-64" or "ELF 64-bit LSB executable, ARM aarch64"
-      const expectedArch = arch === 'arm64' ? 'ARM aarch64' : 'x86-64';
-      if (!output.includes('ELF') || !output.includes(expectedArch)) {
-        return false;
-      }
-    } else if (platform === 'win32') {
-      // Windows: should be "PE32+ executable"
-      if (!output.includes('PE32+')) {
-        return false;
-      }
-    }
-
-    return true;
-  } catch (err) {
-    // If 'file' command fails or is not available, assume binary is incorrect to be safe
-    // This will trigger a re-download
-    return false;
-  }
-}
-
-function downloadFile(url, dest) {
-  return new Promise((resolve, reject) => {
-    const file = fs.createWriteStream(dest);
-    https
-      .get(url, (response) => {
-        if (response.statusCode === 302 || response.statusCode === 301) {
-          // Follow redirect
-          return downloadFile(response.headers.location, dest).then(resolve).catch(reject);
-        }
-        if (response.statusCode !== 200) {
-          file.close();
-          fs.unlinkSync(dest);
-          reject(new Error(`Failed to download: ${response.statusCode} ${response.statusMessage}`));
-          return;
-        }
-        response.pipe(file);
-        file.on('finish', () => {
-          file.close();
-          resolve();
-        });
-      })
-      .on('error', (err) => {
-        file.close();
-        if (fs.existsSync(dest)) {
-          fs.unlinkSync(dest);
-        }
-        reject(err);
-      });
-  });
-}
-
-function getReleaseUrl(version, assetName) {
-  return new Promise((resolve, reject) => {
-    // Always use latest release - version parameter is ignored
-    const tag = 'latest';
-    const url = `https://api.github.com/repos/${GITHUB_REPO}/releases/${tag}`;
-
-    https
-      .get(
-        url,
-        {
-          headers: {
-            'User-Agent': 'blimu-installer',
-            Accept: 'application/vnd.github.v3+json',
-          },
-        },
-        (res) => {
-          let data = '';
-          res.on('data', (chunk) => {
-            data += chunk;
-          });
-          res.on('end', () => {
-            if (res.statusCode === 404) {
-              reject(
-                new Error(
-                  `Latest CLI release not found. Please check the blimu-cli repository for available releases.`,
-                ),
-              );
-              return;
-            }
-            if (res.statusCode !== 200) {
-              reject(
-                new Error(`Failed to fetch latest release: ${res.statusCode} ${res.statusMessage}`),
-              );
-              return;
-            }
-            try {
-              const release = JSON.parse(data);
-              const asset = release.assets.find((a) => a.name === assetName);
-              if (!asset) {
-                reject(new Error(`Asset ${assetName} not found in latest release`));
-                return;
-              }
-              resolve(asset.browser_download_url);
-            } catch (err) {
-              reject(err);
-            }
-          });
-        },
-      )
-      .on('error', reject);
-  });
-}
-
-async function main(version) {
-  try {
-    // Always use latest version - version parameter is ignored for consistency
-    // This ensures users always get the latest CLI features and fixes
-    version = null;
-
-    const { binaryName, assetName } = getPlatformInfo();
-
-    // Create bin directory if it doesn't exist
-    if (!fs.existsSync(BIN_DIR)) {
-      fs.mkdirSync(BIN_DIR, { recursive: true });
-    }
-
-    const binaryPath = path.join(BIN_DIR, binaryName);
-
-    // Check if binary already exists and is executable
-    if (fs.existsSync(binaryPath)) {
-      // Verify the binary matches the current platform/architecture
-      const isCorrectArchitecture = verifyBinaryArchitecture(binaryPath);
-
-      if (isCorrectArchitecture) {
-        try {
-          // Try to make it executable (Unix only)
-          if (process.platform !== 'win32') {
-            fs.chmodSync(binaryPath, 0o755);
-          }
-          console.log(`✅ Blimu CLI binary already exists at ${binaryPath}`);
-          return;
-        } catch (err) {
-          // If we can't check/update permissions, continue to download
-        }
-      } else {
-        // Binary exists but is for wrong platform/architecture - delete it
-        console.log(`⚠️  Existing binary is for wrong platform/architecture, will re-download...`);
-        try {
-          fs.unlinkSync(binaryPath);
-        } catch (err) {
-          console.warn(`Warning: Could not delete incorrect binary: ${err.message}`);
-        }
-      }
-    }
-
-    console.log(
-      `📥 Downloading Blimu CLI binary (latest) for ${process.platform}/${process.arch}...`,
-    );
-
-    // Get release download URL
-    const downloadUrl = await getReleaseUrl(version, assetName);
-    console.log(`🔗 Download URL: ${downloadUrl}`);
-
-    // Download the binary
-    await downloadFile(downloadUrl, binaryPath);
-
-    // Make binary executable (Unix only)
-    if (process.platform !== 'win32') {
-      fs.chmodSync(binaryPath, 0o755);
-    }
-
-    console.log(`✅ Blimu CLI binary downloaded successfully to ${binaryPath}`);
-  } catch (error) {
-    console.error(`❌ Failed to download Blimu CLI binary: ${error.message}`);
-    console.error(`\nYou can manually install it by running:`);
-    console.error(`  go install github.com/blimu-dev/blimu-cli/cmd/blimucli@latest`);
-    console.error(`\nOr download from: https://github.com/${GITHUB_REPO}/releases/latest`);
-    process.exit(1);
-  }
-}
-
-if (require.main === module) {
-  main();
-}
-
-module.exports = { main, getPlatformInfo };

package/scripts/postinstall.js

@@ -1,22 +0,0 @@
-#!/usr/bin/env node
-
-const { main } = require('./download-binary');
-
-// Only run download if we're in a production install (not in development)
-// Check if we're in node_modules (production install) or in the repo (development)
-const isProductionInstall = __dirname.includes('node_modules');
-
-if (isProductionInstall || process.env.BLIMU_DOWNLOAD_CLI !== 'false') {
-  // Always download the latest CLI version
-  main(null).catch((error) => {
-    // Fail the install if binary download fails
-    console.error('Error: Failed to download Blimu CLI binary during install.');
-    console.error(error.message);
-    console.error('\nThe package will download the latest available CLI version.');
-    console.error('\nYou can manually install it by running:');
-    console.error('  go install github.com/blimu-dev/blimu-cli/cmd/blimucli@latest');
-    process.exit(1);
-  });
-} else {
-  console.log('Skipping Blimu CLI binary download (development mode)');
-}