@everystack/mcp 0.3.2 → 0.4.0

package/dist/tools/project-status.js

@@ -0,0 +1,138 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+const V1_PACKAGES = ['@everystack/server', '@everystack/cli', '@everystack/ui'];
+const V2_PACKAGES = ['@everystack/api', '@everystack/auth', '@everystack/admin', '@everystack/logging', '@everystack/security', '@everystack/query'];
+const V3_PACKAGES = ['@everystack/jobs', '@everystack/storage', '@everystack/images'];
+function readJson(path) {
+    if (!existsSync(path))
+        return null;
+    try {
+        return JSON.parse(readFileSync(path, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+function detectTier(installed) {
+    const hasV3 = V3_PACKAGES.some((p) => installed.includes(p));
+    const hasV2 = V2_PACKAGES.some((p) => installed.includes(p));
+    const hasV1 = V1_PACKAGES.some((p) => installed.includes(p));
+    if (hasV3) {
+        return { tier: 'V3', explanation: `Full platform — has V3 packages (${V3_PACKAGES.filter((p) => installed.includes(p)).join(', ')})` };
+    }
+    if (hasV2) {
+        return { tier: 'V2', explanation: `Dynamic — has V2 packages (${V2_PACKAGES.filter((p) => installed.includes(p)).join(', ')})` };
+    }
+    if (hasV1) {
+        return { tier: 'V1', explanation: `Static — has V1 packages (${V1_PACKAGES.filter((p) => installed.includes(p)).join(', ')})` };
+    }
+    return { tier: 'unknown', explanation: 'No everystack packages found in dependencies' };
+}
+export function analyzeProjectStatus(projectPath) {
+    const warnings = [];
+    // Read package.json
+    const pkg = readJson(join(projectPath, 'package.json'));
+    if (!pkg) {
+        return {
+            tier: 'unknown',
+            tierExplanation: 'No package.json found at project path',
+            packages: { installed: [], missing: [] },
+            files: {
+                sstConfig: false, schemaDir: false, schemaFiles: [],
+                migrationsDir: false, serverDir: false, handlerFile: null,
+                workerFile: null, imageFile: null, seedFile: null,
+            },
+            deployment: { sstOutputs: false, stage: null, secrets: [] },
+            warnings: [
+                'No package.json found — is this the correct project path?',
+                'No project here yet? Describe what you want to build and Claude will help create one.',
+            ],
+        };
+    }
+    // Collect everystack dependencies
+    const allDeps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
+    const installed = Object.keys(allDeps).filter((d) => d.startsWith('@everystack/'));
+    const allKnown = [...V1_PACKAGES, ...V2_PACKAGES, ...V3_PACKAGES];
+    const missing = allKnown.filter((p) => !installed.includes(p));
+    // Detect tier
+    const { tier, explanation } = detectTier(installed);
+    // Check key files/directories
+    const sstConfig = existsSync(join(projectPath, 'sst.config.ts'));
+    const schemaDir = existsSync(join(projectPath, 'db'));
+    const migrationsDir = existsSync(join(projectPath, 'db', 'migrations')) ||
+        existsSync(join(projectPath, 'server', 'drizzle'));
+    const serverDir = existsSync(join(projectPath, 'server'));
+    // Find schema files
+    const schemaFiles = [];
+    if (schemaDir) {
+        const schemaPath = join(projectPath, 'db', 'schema.ts');
+        if (existsSync(schemaPath))
+            schemaFiles.push('db/schema.ts');
+        const indexPath = join(projectPath, 'db', 'index.ts');
+        if (existsSync(indexPath))
+            schemaFiles.push('db/index.ts');
+    }
+    // Check handler files
+    const handlerCandidates = ['server/api.ts', 'server/handler.ts', 'server/index.ts'];
+    const handlerFile = handlerCandidates.find((f) => existsSync(join(projectPath, f))) ?? null;
+    const workerFile = existsSync(join(projectPath, 'server', 'worker.ts')) ? 'server/worker.ts' : null;
+    const imageFile = existsSync(join(projectPath, 'server', 'image.ts')) ? 'server/image.ts' : null;
+    const seedFile = existsSync(join(projectPath, 'db', 'seed.ts')) ? 'db/seed.ts' : null;
+    // Check deployment state
+    const sstOutputsPath = join(projectPath, '.sst', 'outputs.json');
+    const sstOutputs = existsSync(sstOutputsPath);
+    let stage = null;
+    const secrets = [];
+    if (sstOutputs) {
+        const outputs = readJson(sstOutputsPath);
+        if (outputs) {
+            // SST outputs are keyed by stage
+            const keys = Object.keys(outputs);
+            if (keys.length > 0)
+                stage = keys[0];
+        }
+    }
+    // Check for sst secret files
+    const sstDir = join(projectPath, '.sst');
+    if (existsSync(sstDir)) {
+        const secretCandidates = ['JwtSecret', 'DatabaseUrl', 'GoogleClientId', 'GoogleClientSecret', 'AppleClientId'];
+        for (const s of secretCandidates) {
+            if (existsSync(join(sstDir, 'secrets', s))) {
+                secrets.push(s);
+            }
+        }
+    }
+    // Warnings
+    if (tier !== 'unknown' && tier !== 'V1' && !schemaDir) {
+        warnings.push('V2+ project but no db/ directory found — schema is required for PostgREST');
+    }
+    if (tier !== 'unknown' && tier !== 'V1' && schemaFiles.length === 0) {
+        warnings.push('No schema.ts found in db/ — create your Drizzle schema');
+    }
+    if (tier !== 'unknown' && !sstConfig) {
+        warnings.push('No sst.config.ts found — required for deployment');
+    }
+    if (installed.includes('@everystack/api') && !handlerFile) {
+        warnings.push('@everystack/api installed but no handler file found in server/');
+    }
+    if (installed.includes('@everystack/jobs') && !workerFile) {
+        warnings.push('@everystack/jobs installed but no server/worker.ts found');
+    }
+    if (installed.includes('@everystack/images') && !imageFile) {
+        warnings.push('@everystack/images installed but no server/image.ts found');
+    }
+    if (tier !== 'unknown' && tier !== 'V1' && !seedFile) {
+        warnings.push('No db/seed.ts found — recommended for development');
+    }
+    return {
+        tier,
+        tierExplanation: explanation,
+        packages: { installed, missing },
+        files: {
+            sstConfig, schemaDir, schemaFiles, migrationsDir,
+            serverDir, handlerFile, workerFile, imageFile, seedFile,
+        },
+        deployment: { sstOutputs, stage, secrets },
+        warnings,
+    };
+}

package/dist/tools/project-validate.d.ts

@@ -0,0 +1,19 @@
+type Severity = 'error' | 'warning' | 'info';
+interface ValidationResult {
+    severity: Severity;
+    category: string;
+    message: string;
+    file?: string;
+    fix?: string;
+}
+interface ValidationReport {
+    results: ValidationResult[];
+    summary: {
+        errors: number;
+        warnings: number;
+        info: number;
+    };
+}
+export declare function validateProject(projectPath: string): ValidationReport;
+export {};
+//# sourceMappingURL=project-validate.d.ts.map

package/dist/tools/project-validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-validate.d.ts","sourceRoot":"","sources":["../../src/tools/project-validate.ts"],"names":[],"mappings":"AAGA,KAAK,QAAQ,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;AAE7C,UAAU,gBAAgB;IACxB,QAAQ,EAAE,QAAQ,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,UAAU,gBAAgB;IACxB,OAAO,EAAE,gBAAgB,EAAE,CAAC;IAC5B,OAAO,EAAE;QACP,MAAM,EAAE,MAAM,CAAC;QACf,QAAQ,EAAE,MAAM,CAAC;QACjB,IAAI,EAAE,MAAM,CAAC;KACd,CAAC;CACH;AAqUD,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,gBAAgB,CAuBrE"}

package/dist/tools/project-validate.js

@@ -0,0 +1,323 @@
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+function readFileSafe(path) {
+    if (!existsSync(path))
+        return null;
+    try {
+        return readFileSync(path, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
+function readJsonSafe(path) {
+    const content = readFileSafe(path);
+    if (!content)
+        return null;
+    try {
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+function checkPackageJson(projectPath, results) {
+    const pkg = readJsonSafe(join(projectPath, 'package.json'));
+    if (!pkg) {
+        results.push({
+            severity: 'error',
+            category: 'project',
+            message: 'No package.json found',
+            fix: 'Run `npm init` or create package.json manually',
+        });
+        return;
+    }
+    const deps = {
+        ...(pkg.dependencies || {}),
+        ...(pkg.devDependencies || {}),
+    };
+    // Check for required peer dependencies
+    if (deps['@everystack/api'] && !deps['drizzle-orm']) {
+        results.push({
+            severity: 'error',
+            category: 'dependencies',
+            message: '@everystack/api requires drizzle-orm as a peer dependency',
+            fix: 'Run `pnpm add drizzle-orm drizzle-kit`',
+        });
+    }
+    if (deps['@everystack/server'] && !deps['sst']) {
+        results.push({
+            severity: 'warning',
+            category: 'dependencies',
+            message: '@everystack/server expects sst as a peer dependency for deployment',
+            fix: 'Run `pnpm add -D sst`',
+        });
+    }
+    if (deps['@everystack/query'] && !deps['@tanstack/react-query']) {
+        results.push({
+            severity: 'error',
+            category: 'dependencies',
+            message: '@everystack/query requires @tanstack/react-query as a peer dependency',
+            fix: 'Run `pnpm add @tanstack/react-query`',
+        });
+    }
+}
+function checkSecurityConfig(projectPath, results) {
+    // Check for exposed secrets in common locations
+    const dangerousFiles = ['.env', '.env.local', '.env.production'];
+    for (const f of dangerousFiles) {
+        const content = readFileSafe(join(projectPath, f));
+        if (content) {
+            if (content.includes('JWT_SECRET') || content.includes('DATABASE_URL')) {
+                results.push({
+                    severity: 'warning',
+                    category: 'security',
+                    message: `${f} contains sensitive values — use SST secrets instead`,
+                    file: f,
+                    fix: 'Run `pnpm sst secret set JwtSecret "value" --stage dev` and remove from .env',
+                });
+            }
+            // Check gitignore
+            const gitignore = readFileSafe(join(projectPath, '.gitignore'));
+            if (gitignore && !gitignore.includes(f)) {
+                results.push({
+                    severity: 'error',
+                    category: 'security',
+                    message: `${f} is not in .gitignore — secrets may be committed`,
+                    file: '.gitignore',
+                    fix: `Add '${f}' to .gitignore`,
+                });
+            }
+        }
+    }
+    // Check for hardcoded secrets in handler files
+    const serverFiles = ['server/api.ts', 'server/handler.ts', 'server/plugins/api.ts'];
+    for (const f of serverFiles) {
+        const content = readFileSafe(join(projectPath, f));
+        if (content) {
+            if (/['"](?:sk_|pk_|secret_)[a-zA-Z0-9]+['"]/.test(content)) {
+                results.push({
+                    severity: 'error',
+                    category: 'security',
+                    message: `Possible hardcoded API key in ${f}`,
+                    file: f,
+                    fix: 'Move secrets to SST secret management',
+                });
+            }
+        }
+    }
+}
+function checkHandlerConfig(projectPath, results) {
+    const handlerCandidates = [
+        'server/plugins/api.ts',
+        'server/api.ts',
+        'server/handler.ts',
+    ];
+    let handlerSource = null;
+    let handlerFile = null;
+    for (const f of handlerCandidates) {
+        const content = readFileSafe(join(projectPath, f));
+        if (content && content.includes('createHandler')) {
+            handlerSource = content;
+            handlerFile = f;
+            break;
+        }
+    }
+    if (!handlerSource || !handlerFile)
+        return;
+    // pgSettings is required for RLS
+    if (!handlerSource.includes('pgSettings')) {
+        results.push({
+            severity: 'warning',
+            category: 'security',
+            message: 'No pgSettings configured — RLS policies will not receive JWT claims',
+            file: handlerFile,
+            fix: 'Add pgSettings to your createHandler() config. Read everystack://security for the pattern.',
+        });
+    }
+    // Check for auth configuration
+    if (!handlerSource.includes('verifyToken')) {
+        results.push({
+            severity: 'warning',
+            category: 'security',
+            message: 'No auth.verifyToken configured — all routes are unauthenticated',
+            file: handlerFile,
+            fix: 'Add auth.verifyToken to createHandler() config',
+        });
+    }
+    // exposedTables should be set
+    if (!handlerSource.includes('exposedTables')) {
+        results.push({
+            severity: 'warning',
+            category: 'security',
+            message: 'No exposedTables set — all schema tables are accessible via API',
+            file: handlerFile,
+            fix: 'Add exposedTables to restrict which tables are accessible',
+        });
+    }
+    // maxEmbedDepth should be set
+    if (!handlerSource.includes('maxEmbedDepth')) {
+        results.push({
+            severity: 'info',
+            category: 'security',
+            message: 'maxEmbedDepth not set — using default (3). Set explicitly to prevent deep query DoS.',
+            file: handlerFile,
+        });
+    }
+    // rowOwnership for user-scoped tables
+    if (!handlerSource.includes('rowOwnership')) {
+        results.push({
+            severity: 'info',
+            category: 'security',
+            message: 'No rowOwnership configured — consider it for user-scoped mutation control',
+            file: handlerFile,
+            fix: 'Add rowOwnership for tables where users should only modify their own rows',
+        });
+    }
+}
+function checkSchemaConventions(projectPath, results) {
+    const schemaPath = join(projectPath, 'db', 'schema.ts');
+    const source = readFileSafe(schemaPath);
+    if (!source)
+        return;
+    // Check for UUID primary keys (recommended)
+    const serialPkRegex = /serial\(['"]id['"]\)\.primaryKey/;
+    if (serialPkRegex.test(source)) {
+        results.push({
+            severity: 'info',
+            category: 'conventions',
+            message: 'Using serial IDs — UUID primary keys are recommended for distributed systems',
+            file: 'db/schema.ts',
+        });
+    }
+    // Check for timestamps
+    const tableNames = [...source.matchAll(/export\s+const\s+(\w+)\s*=\s*pgTable/g)].map((m) => m[1]);
+    for (const name of tableNames) {
+        // Find the table definition block
+        const tableRegex = new RegExp(`export\\s+const\\s+${name}\\s*=\\s*pgTable\\([^,]+,\\s*\\{([^}]+)\\}`);
+        const match = source.match(tableRegex);
+        if (match) {
+            const block = match[1];
+            if (!block.includes('created_at') && !block.includes('createdAt')) {
+                results.push({
+                    severity: 'info',
+                    category: 'conventions',
+                    message: `Table '${name}' has no createdAt timestamp`,
+                    file: 'db/schema.ts',
+                });
+            }
+        }
+    }
+}
+function checkMigrations(projectPath, results) {
+    const migrationsDir = join(projectPath, 'db', 'migrations');
+    const serverDrizzle = join(projectPath, 'server', 'drizzle');
+    const hasDbMigrations = existsSync(migrationsDir);
+    const hasServerDrizzle = existsSync(serverDrizzle);
+    if (!hasDbMigrations && !hasServerDrizzle) {
+        const hasSchema = existsSync(join(projectPath, 'db', 'schema.ts'));
+        if (hasSchema) {
+            results.push({
+                severity: 'warning',
+                category: 'database',
+                message: 'Schema exists but no migrations directory found',
+                fix: 'Run `npx drizzle-kit generate` to create migrations',
+            });
+        }
+        return;
+    }
+    // Check for RLS in migrations
+    const dir = hasServerDrizzle ? serverDrizzle : migrationsDir;
+    try {
+        const files = readdirSync(dir).filter((f) => f.endsWith('.sql'));
+        let hasRls = false;
+        for (const f of files) {
+            const content = readFileSafe(join(dir, f));
+            if (content && content.includes('ENABLE ROW LEVEL SECURITY')) {
+                hasRls = true;
+                break;
+            }
+        }
+        if (!hasRls && files.length > 0) {
+            results.push({
+                severity: 'warning',
+                category: 'security',
+                message: 'No RLS policies found in migrations — tables are not protected at database level',
+                fix: 'Add RLS policies via custom SQL migrations. Read everystack://security for templates.',
+            });
+        }
+    }
+    catch {
+        // ignore
+    }
+}
+function checkDeploymentReadiness(projectPath, results) {
+    // SST config
+    if (!existsSync(join(projectPath, 'sst.config.ts'))) {
+        results.push({
+            severity: 'info',
+            category: 'deployment',
+            message: 'No sst.config.ts — project is not configured for AWS deployment',
+            fix: 'Create sst.config.ts following everystack://deployment',
+        });
+        return;
+    }
+    const sstConfig = readFileSafe(join(projectPath, 'sst.config.ts'));
+    if (sstConfig) {
+        // Check for VPC configuration
+        if (!sstConfig.includes('Vpc') && !sstConfig.includes('vpc')) {
+            results.push({
+                severity: 'info',
+                category: 'deployment',
+                message: 'No VPC configured in sst.config.ts — RDS requires a VPC',
+            });
+        }
+    }
+}
+function checkFileConventions(projectPath, results) {
+    // Check for default exports (everystack uses named exports)
+    const srcDirs = ['server', 'db', 'lib'];
+    for (const dir of srcDirs) {
+        const dirPath = join(projectPath, dir);
+        if (!existsSync(dirPath))
+            continue;
+        try {
+            const files = readdirSync(dirPath).filter((f) => f.endsWith('.ts') && !f.endsWith('.test.ts'));
+            for (const f of files) {
+                const content = readFileSafe(join(dirPath, f));
+                if (content && /^export\s+default\s/m.test(content)) {
+                    results.push({
+                        severity: 'info',
+                        category: 'conventions',
+                        message: `${dir}/${f} uses default export — everystack convention prefers named exports`,
+                        file: `${dir}/${f}`,
+                    });
+                }
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+}
+export function validateProject(projectPath) {
+    const results = [];
+    checkPackageJson(projectPath, results);
+    checkSecurityConfig(projectPath, results);
+    checkHandlerConfig(projectPath, results);
+    checkSchemaConventions(projectPath, results);
+    checkMigrations(projectPath, results);
+    checkDeploymentReadiness(projectPath, results);
+    checkFileConventions(projectPath, results);
+    // Sort: errors first, then warnings, then info
+    const order = { error: 0, warning: 1, info: 2 };
+    results.sort((a, b) => order[a.severity] - order[b.severity]);
+    return {
+        results,
+        summary: {
+            errors: results.filter((r) => r.severity === 'error').length,
+            warnings: results.filter((r) => r.severity === 'warning').length,
+            info: results.filter((r) => r.severity === 'info').length,
+        },
+    };
+}

package/dist/tools/schema-analyze.d.ts

@@ -0,0 +1,46 @@
+interface ColumnInfo {
+    name: string;
+    dbName: string;
+    type: string;
+    modifiers: string[];
+}
+interface TableInfo {
+    name: string;
+    exportName: string;
+    columns: ColumnInfo[];
+    file: string;
+}
+interface RelationInfo {
+    name: string;
+    table: string;
+    type: 'one' | 'many';
+    fields: string[];
+    references: string[];
+    relationName?: string;
+}
+interface HandlerConfig {
+    exposedTables: string[];
+    hiddenColumns: Record<string, string[]>;
+    protectedFields: Record<string, string[]>;
+    rowOwnership: Record<string, {
+        column: string;
+        userField: string;
+    }>;
+    softDelete: {
+        tables: string[];
+    };
+    pgSettings: boolean;
+    relations: Record<string, Record<string, unknown>>;
+    publicRoutes: string[];
+    publicRpc: string[];
+}
+interface SchemaAnalysis {
+    tables: TableInfo[];
+    relations: RelationInfo[];
+    handlerConfig: Partial<HandlerConfig> | null;
+    issues: string[];
+    suggestions: string[];
+}
+export declare function analyzeSchema(projectPath: string): SchemaAnalysis;
+export {};
+//# sourceMappingURL=schema-analyze.d.ts.map

package/dist/tools/schema-analyze.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-analyze.d.ts","sourceRoot":"","sources":["../../src/tools/schema-analyze.ts"],"names":[],"mappings":"AAGA,UAAU,UAAU;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB;AAED,UAAU,SAAS;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,UAAU,EAAE,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,UAAU,YAAY;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,KAAK,GAAG,MAAM,CAAC;IACrB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,UAAU,aAAa;IACrB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IACxC,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IAC1C,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACpE,UAAU,EAAE;QAAE,MAAM,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IACjC,UAAU,EAAE,OAAO,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACnD,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB;AAED,UAAU,cAAc;IACtB,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,SAAS,EAAE,YAAY,EAAE,CAAC;IAC1B,aAAa,EAAE,OAAO,CAAC,aAAa,CAAC,GAAG,IAAI,CAAC;IAC7C,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB;AA2ND,wBAAgB,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,cAAc,CAkJjE"}