@archlast/cli 0.0.1

package/README.md

@@ -0,0 +1,141 @@
+# Archlast CLI
+
+CLI tool for Archlast development, deployment, and Docker lifecycle management.
+
+## Requirements
+
+- Node.js 18+
+- Docker Desktop or Docker Engine
+- Bun 1.3+
+
+## Installation
+
+```bash
+npm install -g @archlast/cli
+```
+
+On Windows, ensure Bun is on your PATH (the installer adds it, but terminals need a restart):
+
+```powershell
+[Environment]::SetEnvironmentVariable(
+  "Path",
+  "$env:Path;$env:USERPROFILE\\.bun\\bin",
+  "User"
+)
+```
+
+## Quick start
+
+```bash
+archlast init
+archlast start
+archlast status
+archlast logs --follow
+```
+
+To watch and auto-deploy functions during development:
+
+```bash
+archlast dev --path ./archlast --server http://localhost:4000
+```
+
+## Commands
+
+- `dev` - watch `archlast/src` for changes, regenerate types, and deploy deltas
+- `deploy` - one-time deployment to the server
+- `build` - generate types without deploying
+- `pull` - pull schema/files from the server, or use `--docker` to pull an image
+- `init` - scaffold the minimal Archlast project structure
+- `start` / `stop` / `restart` - manage the Docker container
+- `status` - print container status and health
+- `logs` - stream container logs
+- `upgrade` - pull a new image and restart the container
+- `config` - show resolved Docker config (use `--json` for JSON)
+- `generate crud <collection>` - scaffold CRUD handlers from schema
+- `data` - snapshot/export/import/restore data (requires `ARCHLAST_API_KEY`)
+
+## Common options
+
+- `--path <path>` points to your Archlast project folder
+- `--server <url>` sets the API base URL (default: `http://localhost:4000`)
+- `--port <port>` overrides the container port for `start` and `upgrade`
+- `--config <path>` points to `archlast.config.js`
+- `--name <name>` sets the project name when running `init`
+
+## Configuration
+
+The CLI reads configuration in this order:
+1. CLI flags
+2. `archlast.config.js`
+3. `.env` or `.env.local`
+4. defaults
+
+Example `archlast.config.js`:
+
+```js
+export default {
+  docker: {
+    image: "algochad/archlast-server",
+    tag: "latest",
+    containerName: "archlast-server",
+    restartOnDeploy: true,
+  },
+  server: { port: 4000 },
+  paths: {
+    config: ".archlast/config",
+    deploy: ".archlast-deploy",
+  },
+  cors: { origins: ["http://localhost:3000"] },
+  env: {
+    ARCHLAST_DASHBOARD_PORT: "4001",
+    ARCHLAST_STORE_PORT: "7001",
+  },
+};
+```
+
+Environment variables starting with `ARCHLAST_`, `S3_`, `AWS_`, and `STORAGE_`
+are forwarded into the container.
+
+If `containerName` or `volumeName` is not set, the CLI generates unique names per
+project to keep data isolated.
+
+The CLI stores per-project metadata in `.archlast/project.json` and persists the
+selected port when it has to pick a new one.
+
+When `restartOnDeploy` is enabled, `archlast dev` and `archlast deploy` restart the
+Docker container after a successful upload.
+
+## Dev and deploy flow
+
+The server receives deployments at `POST /_archlast/deploy` with payload:
+
+```ts
+{
+  functions: Array<{
+    name: string;
+    type: "query" | "mutation" | "action";
+    filePath: string;
+    code: string;
+  }>;
+  schema: { filePath: string; code: string } | null;
+  timestamp: number;
+}
+```
+
+## Data management
+
+Use the `data` command group to snapshot, export, import, and restore data.
+Set `ARCHLAST_API_KEY` in your environment for authentication.
+
+Examples:
+
+```bash
+archlast data snapshot --name "pre-migration"
+archlast data export ./backup.zip
+archlast data import ./backup.zip --strategy merge
+archlast data restore snapshot-2026-01-01.zip
+```
+
+## Publishing (maintainers)
+
+See `docs/npm-publishing.md` for the release workflow and manual publish steps.

package/dist/analyzer.d.ts

@@ -0,0 +1,96 @@
+export interface FunctionDefinition {
+    name: string;
+    type: "query" | "mutation" | "action";
+    filePath: string;
+    hash: string;
+}
+export interface HttpRouteDefinition {
+    name: string;
+    type: "http" | "webhook";
+    method: string;
+    path: string;
+    filePath: string;
+    hash: string;
+}
+export interface RpcDefinition {
+    name: string;
+    procedureType: "query" | "mutation";
+    filePath: string;
+    moduleName: string;
+    hash: string;
+}
+export interface InjectableDefinition {
+    className: string;
+    provide: string;
+    implementation: string;
+    filePath: string;
+    hash: string;
+}
+export interface SchemaDefinition {
+    tables: Record<string, any>;
+    hash: string;
+    /** Path to the schema file (for merged schemas, indicates "schema/*.ts") */
+    filePath?: string;
+    /** For merged schemas, list of all schema files that were combined */
+    files?: string[];
+}
+export interface AnalysisResult {
+    functions: FunctionDefinition[];
+    httpRoutes: HttpRouteDefinition[];
+    rpcRoutes: RpcDefinition[];
+    injectables: InjectableDefinition[];
+    schema: SchemaDefinition | string | null;
+    timestamp: number;
+}
+export declare class CodeAnalyzer {
+    private archlastPath;
+    constructor(archlastPath: string);
+    analyze(): Promise<AnalysisResult>;
+    private analyzeFunctions;
+    private analyzeHttpRoutes;
+    private analyzeRpcRoutes;
+    private analyzeInjectables;
+    /**
+     * Analyze schema definition
+     * Supports both single-file (schema.ts) and folder-based (schema/*.ts) schemas
+     * Priority: Single file > Folder with index.ts > Folder (scanned and merged)
+     */
+    private analyzeSchema;
+    /**
+     * Parse a single schema file
+     */
+    private parseSchemaFile;
+    /**
+     * Scan schema folder for all .ts files
+     */
+    private scanSchemaFolder;
+    /**
+     * Merge multiple schema files into a single schema definition
+     * Later files override earlier ones for conflicting table names
+     */
+    private mergeSchemaFiles;
+    /**
+     * Extract table definitions from schema content
+     * Uses regex parsing to find defineTable calls
+     */
+    private extractTablesFromSchema;
+    private hashString;
+}
+export declare class CodeDiffer {
+    diff(prev: AnalysisResult, current: AnalysisResult): {
+        added: FunctionDefinition[];
+        removed: FunctionDefinition[];
+        modified: FunctionDefinition[];
+        addedRoutes: HttpRouteDefinition[];
+        removedRoutes: HttpRouteDefinition[];
+        modifiedRoutes: HttpRouteDefinition[];
+        addedRpcRoutes: RpcDefinition[];
+        removedRpcRoutes: RpcDefinition[];
+        modifiedRpcRoutes: RpcDefinition[];
+        addedInjectables: InjectableDefinition[];
+        removedInjectables: InjectableDefinition[];
+        modifiedInjectables: InjectableDefinition[];
+        schemaChanged: boolean;
+    };
+}
+//# sourceMappingURL=analyzer.d.ts.map

package/dist/analyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyzer.d.ts","sourceRoot":"","sources":["../src/analyzer.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,kBAAkB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,OAAO,GAAG,UAAU,GAAG,QAAQ,CAAC;IACtC,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,mBAAmB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,aAAa;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,OAAO,GAAG,UAAU,CAAC;IACpC,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,oBAAoB;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,gBAAgB;IAC7B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,4EAA4E;IAC5E,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,sEAAsE;IACtE,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,MAAM,WAAW,cAAc;IAC3B,SAAS,EAAE,kBAAkB,EAAE,CAAC;IAChC,UAAU,EAAE,mBAAmB,EAAE,CAAC;IAClC,SAAS,EAAE,aAAa,EAAE,CAAC;IAC3B,WAAW,EAAE,oBAAoB,EAAE,CAAC;IACpC,MAAM,EAAE,gBAAgB,GAAG,MAAM,GAAG,IAAI,CAAC;IACzC,SAAS,EAAE,MAAM,CAAC;CACrB;AAED,qBAAa,YAAY;IACrB,OAAO,CAAC,YAAY,CAAS;gBAEjB,YAAY,EAAE,MAAM;IAK1B,OAAO,IAAI,OAAO,CAAC,cAAc,CAAC;YAiB1B,gBAAgB;YAuDhB,iBAAiB;YAmDjB,gBAAgB;YAgDhB,kBAAkB;IAkEhC;;;;OAIG;YACW,aAAa;IAgC3B;;OAEG;IACH,OAAO,CAAC,eAAe;IAQvB;;OAEG;YACW,gBAAgB;IAuB9B;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IAsBxB;;;OAGG;IACH,OAAO,CAAC,uBAAuB;IAoB/B,OAAO,CAAC,UAAU;CASrB;AAED,qBAAa,UAAU;IACnB,IAAI,CACA,IAAI,EAAE,cAAc,EACpB,OAAO,EAAE,cAAc,GACxB;QACC,KAAK,EAAE,kBAAkB,EAAE,CAAC;QAC5B,OAAO,EAAE,kBAAkB,EAAE,CAAC;QAC9B,QAAQ,EAAE,kBAAkB,EAAE,CAAC;QAC/B,WAAW,EAAE,mBAAmB,EAAE,CAAC;QACnC,aAAa,EAAE,mBAAmB,EAAE,CAAC;QACrC,cAAc,EAAE,mBAAmB,EAAE,CAAC;QACtC,cAAc,EAAE,aAAa,EAAE,CAAC;QAChC,gBAAgB,EAAE,aAAa,EAAE,CAAC;QAClC,iBAAiB,EAAE,aAAa,EAAE,CAAC;QACnC,gBAAgB,EAAE,oBAAoB,EAAE,CAAC;QACzC,kBAAkB,EAAE,oBAAoB,EAAE,CAAC;QAC3C,mBAAmB,EAAE,oBAAoB,EAAE,CAAC;QAC5C,aAAa,EAAE,OAAO,CAAC;KAC1B;CAsHJ"}

package/dist/analyzer.js

@@ -0,0 +1,404 @@
+import * as fs from "fs";
+import * as path from "path";
+import { glob } from "glob";
+export class CodeAnalyzer {
+    archlastPath;
+    constructor(archlastPath) {
+        this.archlastPath = path.resolve(archlastPath);
+    }
+    async analyze() {
+        const functions = await this.analyzeFunctions();
+        const httpRoutes = await this.analyzeHttpRoutes();
+        const rpcRoutes = await this.analyzeRpcRoutes();
+        const injectables = await this.analyzeInjectables();
+        const schema = await this.analyzeSchema();
+        return {
+            functions,
+            httpRoutes,
+            rpcRoutes,
+            injectables,
+            schema,
+            timestamp: Date.now(),
+        };
+    }
+    async analyzeFunctions() {
+        const pattern = path.join(this.archlastPath, "src", "**/*.ts").replace(/\\/g, "/");
+        const files = await glob(pattern, {
+            ignore: ["**/node_modules/**", "**/_generated/**", "**/schema.ts"],
+        });
+        const functions = [];
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf-8");
+            const srcPath = path.join(this.archlastPath, "src");
+            const relativePath = path.relative(srcPath, file);
+            // Simple regex to detect exported functions
+            const queryMatches = content.matchAll(/export\s+(?:const|let)\s+(\w+)\s*=\s*query\s*\(/g);
+            const mutationMatches = content.matchAll(/export\s+(?:const|let)\s+(\w+)\s*=\s*mutation\s*\(/g);
+            const actionMatches = content.matchAll(/export\s+(?:const|let)\s+(\w+)\s*=\s*action\s*\(/g);
+            for (const match of queryMatches) {
+                functions.push({
+                    name: match[1],
+                    type: "query",
+                    filePath: relativePath,
+                    hash: this.hashString(content),
+                });
+            }
+            for (const match of mutationMatches) {
+                functions.push({
+                    name: match[1],
+                    type: "mutation",
+                    filePath: relativePath,
+                    hash: this.hashString(content),
+                });
+            }
+            for (const match of actionMatches) {
+                functions.push({
+                    name: match[1],
+                    type: "action",
+                    filePath: relativePath,
+                    hash: this.hashString(content),
+                });
+            }
+        }
+        return functions;
+    }
+    async analyzeHttpRoutes() {
+        const pattern = path.join(this.archlastPath, "src", "**/*.ts").replace(/\\/g, "/");
+        const files = await glob(pattern, {
+            ignore: ["**/node_modules/**", "**/_generated/**", "**/schema.ts"],
+        });
+        const routes = [];
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf-8");
+            const srcPath = path.join(this.archlastPath, "src");
+            const relativePath = path.relative(srcPath, file);
+            // Detect http.get, http.post, etc.
+            // Use [\s\S]*? to handle multiline object definitions
+            const httpMatches = content.matchAll(/export\s+(?:const|let)\s+(\w+)\s*=\s*http\.(get|post|put|delete|patch)\s*\(\s*\{[\s\S]*?path:\s*["']([^"']+)["']/g);
+            for (const match of httpMatches) {
+                routes.push({
+                    name: match[1],
+                    type: "http",
+                    method: match[2].toUpperCase(),
+                    path: match[3],
+                    filePath: relativePath,
+                    hash: this.hashString(content),
+                });
+            }
+            // Detect webhook definitions
+            const webhookMatches = content.matchAll(/export\s+(?:const|let)\s+(\w+)\s*=\s*webhook\s*\(\s*\{[^}]*path:\s*["']([^"']+)["']/g);
+            for (const match of webhookMatches) {
+                routes.push({
+                    name: match[1],
+                    type: "webhook",
+                    method: "POST",
+                    path: match[2],
+                    filePath: relativePath,
+                    hash: this.hashString(content),
+                });
+            }
+        }
+        return routes;
+    }
+    async analyzeRpcRoutes() {
+        const pattern = path.join(this.archlastPath, "src", "**/*.ts").replace(/\\/g, "/");
+        const files = await glob(pattern, {
+            ignore: ["**/node_modules/**", "**/_generated/**", "**/schema.ts"],
+        });
+        const routes = [];
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf-8");
+            const srcPath = path.join(this.archlastPath, "src");
+            const relativePath = path.relative(srcPath, file);
+            const moduleName = relativePath.replace(/\.ts$/, "");
+            // Detect rpc.query definitions
+            const queryMatches = content.matchAll(/export\s+(?:const|let)\s+(\w+)\s*=\s*rpc\.query\s*\(/g);
+            for (const match of queryMatches) {
+                routes.push({
+                    name: match[1],
+                    procedureType: "query",
+                    filePath: relativePath,
+                    moduleName,
+                    hash: this.hashString(content),
+                });
+            }
+            // Detect rpc.mutation definitions
+            const mutationMatches = content.matchAll(/export\s+(?:const|let)\s+(\w+)\s*=\s*rpc\.mutation\s*\(/g);
+            for (const match of mutationMatches) {
+                routes.push({
+                    name: match[1],
+                    procedureType: "mutation",
+                    filePath: relativePath,
+                    moduleName,
+                    hash: this.hashString(content),
+                });
+            }
+        }
+        return routes;
+    }
+    async analyzeInjectables() {
+        const pattern = path.join(this.archlastPath, "src", "**/*.ts").replace(/\\/g, "/");
+        const files = await glob(pattern, {
+            ignore: ["**/node_modules/**", "**/_generated/**", "**/schema.ts"],
+        });
+        const injectables = [];
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf-8");
+            const srcPath = path.join(this.archlastPath, "src");
+            const relativePath = path.relative(srcPath, file);
+            // Detect @Injectable() decorators
+            // Pattern: @Injectable({ provide: 'Token', useFactory: 'Implementation' })
+            // or @Injectable() for simple cases
+            const decoratorMatches = content.matchAll(/@Injectable\s*\(\s*(?:\{([^}]*)\})?\s*\)\s*(?:export\s+)?class\s+(\w+)/g);
+            for (const match of decoratorMatches) {
+                const optionsStr = match[1] || "";
+                const className = match[2];
+                // Parse options
+                let provide = className;
+                let implementation = "default";
+                const provideMatch = optionsStr.match(/provide:\s*["']([^"']+)["']/);
+                if (provideMatch) {
+                    provide = provideMatch[1];
+                }
+                const factoryMatch = optionsStr.match(/useFactory:\s*["']([^"']+)["']/);
+                if (factoryMatch) {
+                    implementation = factoryMatch[1];
+                }
+                injectables.push({
+                    className,
+                    provide,
+                    implementation,
+                    filePath: relativePath,
+                    hash: this.hashString(content),
+                });
+            }
+            // Also detect @Factory decorator
+            const factoryMatches = content.matchAll(/@Factory\s*\(\s*["']([^"']+)["']\s*,\s*["']([^"']+)["']\s*\)\s*(?:export\s+)?class\s+(\w+)/g);
+            for (const match of factoryMatches) {
+                injectables.push({
+                    className: match[3],
+                    provide: match[1],
+                    implementation: match[2],
+                    filePath: relativePath,
+                    hash: this.hashString(content),
+                });
+            }
+        }
+        return injectables;
+    }
+    /**
+     * Analyze schema definition
+     * Supports both single-file (schema.ts) and folder-based (schema/*.ts) schemas
+     * Priority: Single file > Folder with index.ts > Folder (scanned and merged)
+     */
+    async analyzeSchema() {
+        const srcPath = path.join(this.archlastPath, "src");
+        const singleSchemaPath = path.join(srcPath, "schema.ts");
+        const schemaFolderPath = path.join(srcPath, "schema");
+        const schemaIndexPath = path.join(schemaFolderPath, "index.ts");
+        // Check for single schema file first (highest priority)
+        if (fs.existsSync(singleSchemaPath)) {
+            const content = fs.readFileSync(singleSchemaPath, "utf-8");
+            return this.parseSchemaFile(singleSchemaPath, content);
+        }
+        // Check for schema folder
+        if (!fs.existsSync(schemaFolderPath)) {
+            return null;
+        }
+        // Check for schema/index.ts
+        if (fs.existsSync(schemaIndexPath)) {
+            const content = fs.readFileSync(schemaIndexPath, "utf-8");
+            return this.parseSchemaFile(schemaIndexPath, content);
+        }
+        // Scan and merge all schema files in folder
+        const schemaFiles = await this.scanSchemaFolder(schemaFolderPath);
+        if (schemaFiles.length === 0) {
+            return null;
+        }
+        return this.mergeSchemaFiles(schemaFiles);
+    }
+    /**
+     * Parse a single schema file
+     */
+    parseSchemaFile(filePath, content) {
+        return {
+            tables: this.extractTablesFromSchema(content),
+            filePath: path.relative(this.archlastPath, filePath),
+            hash: this.hashString(content),
+        };
+    }
+    /**
+     * Scan schema folder for all .ts files
+     */
+    async scanSchemaFolder(folderPath) {
+        const pattern = path.join(folderPath, "*.ts").replace(/\\/g, "/");
+        const files = await glob(pattern, {
+            ignore: ["**/node_modules/**", "**/_generated/**"],
+        });
+        const schemaFiles = [];
+        for (const file of files) {
+            // Skip index.ts as it's handled separately
+            if (path.basename(file) === "index.ts") {
+                continue;
+            }
+            const content = fs.readFileSync(file, "utf-8");
+            schemaFiles.push({
+                filePath: file,
+                content,
+            });
+        }
+        return schemaFiles;
+    }
+    /**
+     * Merge multiple schema files into a single schema definition
+     * Later files override earlier ones for conflicting table names
+     */
+    mergeSchemaFiles(schemaFiles) {
+        const tables = {};
+        const hashes = [];
+        for (const { filePath, content } of schemaFiles) {
+            const fileTables = this.extractTablesFromSchema(content);
+            // Merge tables (later files override)
+            Object.assign(tables, fileTables);
+            hashes.push(this.hashString(content));
+        }
+        // Combined hash from all files
+        const combinedHash = this.hashString(hashes.join("|"));
+        return {
+            tables,
+            filePath: "schema/*.ts", // Indicator that this is a merged schema
+            hash: combinedHash,
+            files: schemaFiles.map(f => path.relative(this.archlastPath, f.filePath)),
+        };
+    }
+    /**
+     * Extract table definitions from schema content
+     * Uses regex parsing to find defineTable calls
+     */
+    extractTablesFromSchema(content) {
+        const tables = {};
+        // Pattern to match defineTable calls
+        // export const <tableName> = defineTable({ ... }, options?)
+        const tableMatches = content.matchAll(/export\s+(?:const|let)\s+(\w+)\s*=\s*defineTable\s*\(\s*\{([^}]+)\}/g);
+        for (const match of tableMatches) {
+            const tableName = match[1];
+            tables[tableName] = {
+                name: tableName,
+                fields: match[2] || "",
+            };
+        }
+        return tables;
+    }
+    hashString(str) {
+        let hash = 0;
+        for (let i = 0; i < str.length; i++) {
+            const char = str.charCodeAt(i);
+            hash = (hash << 5) - hash + char;
+            hash = hash & hash;
+        }
+        return hash.toString(36);
+    }
+}
+export class CodeDiffer {
+    diff(prev, current) {
+        const prevFuncMap = new Map(prev.functions.map((f) => [f.name, f]));
+        const currFuncMap = new Map(current.functions.map((f) => [f.name, f]));
+        const added = [];
+        const removed = [];
+        const modified = [];
+        // Find added and modified functions
+        for (const [name, func] of currFuncMap) {
+            const prevFunc = prevFuncMap.get(name);
+            if (!prevFunc) {
+                added.push(func);
+            }
+            else if (prevFunc.hash !== func.hash) {
+                modified.push(func);
+            }
+        }
+        // Find removed functions
+        for (const [name, func] of prevFuncMap) {
+            if (!currFuncMap.has(name)) {
+                removed.push(func);
+            }
+        }
+        // Diff HTTP routes
+        const prevRouteMap = new Map((prev.httpRoutes || []).map((r) => [r.name, r]));
+        const currRouteMap = new Map((current.httpRoutes || []).map((r) => [r.name, r]));
+        const addedRoutes = [];
+        const removedRoutes = [];
+        const modifiedRoutes = [];
+        for (const [name, route] of currRouteMap) {
+            const prevRoute = prevRouteMap.get(name);
+            if (!prevRoute) {
+                addedRoutes.push(route);
+            }
+            else if (prevRoute.hash !== route.hash) {
+                modifiedRoutes.push(route);
+            }
+        }
+        for (const [name, route] of prevRouteMap) {
+            if (!currRouteMap.has(name)) {
+                removedRoutes.push(route);
+            }
+        }
+        // Diff RPC routes
+        const prevRpcMap = new Map((prev.rpcRoutes || []).map((r) => [`${r.moduleName}.${r.name}`, r]));
+        const currRpcMap = new Map((current.rpcRoutes || []).map((r) => [`${r.moduleName}.${r.name}`, r]));
+        const addedRpcRoutes = [];
+        const removedRpcRoutes = [];
+        const modifiedRpcRoutes = [];
+        for (const [fullName, route] of currRpcMap) {
+            const prevRoute = prevRpcMap.get(fullName);
+            if (!prevRoute) {
+                addedRpcRoutes.push(route);
+            }
+            else if (prevRoute.hash !== route.hash) {
+                modifiedRpcRoutes.push(route);
+            }
+        }
+        for (const [fullName, route] of prevRpcMap) {
+            if (!currRpcMap.has(fullName)) {
+                removedRpcRoutes.push(route);
+            }
+        }
+        // Diff injectables
+        const prevInjectableMap = new Map((prev.injectables || []).map((i) => [`${i.provide}:${i.implementation}`, i]));
+        const currInjectableMap = new Map((current.injectables || []).map((i) => [`${i.provide}:${i.implementation}`, i]));
+        const addedInjectables = [];
+        const removedInjectables = [];
+        const modifiedInjectables = [];
+        for (const [key, injectable] of currInjectableMap) {
+            const prevInjectable = prevInjectableMap.get(key);
+            if (!prevInjectable) {
+                addedInjectables.push(injectable);
+            }
+            else if (prevInjectable.hash !== injectable.hash) {
+                modifiedInjectables.push(injectable);
+            }
+        }
+        for (const [key, injectable] of prevInjectableMap) {
+            if (!currInjectableMap.has(key)) {
+                removedInjectables.push(injectable);
+            }
+        }
+        const prevHash = typeof prev.schema === "string" ? prev.schema : prev.schema?.hash;
+        const currHash = typeof current.schema === "string" ? current.schema : current.schema?.hash;
+        const schemaChanged = prevHash !== currHash;
+        return {
+            added,
+            removed,
+            modified,
+            addedRoutes,
+            removedRoutes,
+            modifiedRoutes,
+            addedRpcRoutes,
+            removedRpcRoutes,
+            modifiedRpcRoutes,
+            addedInjectables,
+            removedInjectables,
+            modifiedInjectables,
+            schemaChanged,
+        };
+    }
+}

package/dist/auth.d.ts

@@ -0,0 +1,14 @@
+export declare function validateApiKey(apiKey: string): {
+    valid: boolean;
+    error?: string;
+};
+export declare class AdminTokenNotFoundError extends Error {
+    constructor();
+}
+export declare function isBetterAuthApiKey(token: string): boolean;
+export declare function extractFromEnv(content: string, varName: string): string | null;
+export declare function readAdminToken(archlastPath?: string): string;
+export declare function getAuthHeaders(archlastPath?: string): Record<string, string>;
+export declare function hashString(str: string): string;
+export declare function hashFile(filePath: string): string;
+//# sourceMappingURL=auth.d.ts.map

package/dist/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../src/auth.ts"],"names":[],"mappings":"AAMA,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAcjF;AAED,qBAAa,uBAAwB,SAAQ,KAAK;;CAUjD;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAY9E;AAED,wBAAgB,cAAc,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,CAyD5D;AAED,wBAAgB,cAAc,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAK5E;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAQ9C;AAED,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAOjD"}