@everystack/mcp 0.3.2 → 0.3.3

package/dist/resources/index.js

@@ -0,0 +1,182 @@
+import { readFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+// Resolve the directory containing resource files.
+// tsx (our runtime) polyfills __dirname in ESM. ts-jest uses CJS where __dirname is native.
+// We use a dynamic eval to avoid import.meta.url appearing in CJS output (which would throw).
+function getResourcesDir() {
+    // In CJS (ts-jest), __dirname is a global
+    try {
+        return globalThis.__dirname
+            || eval('__dirname');
+    }
+    catch {
+        // In pure ESM, fall back to import.meta.url
+        const { fileURLToPath } = require('node:url');
+        return dirname(fileURLToPath(eval('import.meta.url')));
+    }
+}
+const RESOURCES_DIR = getResourcesDir();
+function loadResource(filename) {
+    return readFileSync(join(RESOURCES_DIR, filename), 'utf-8');
+}
+const RESOURCES = [
+    // Beginner — plain English intro, read first for new users
+    {
+        uri: 'everystack://getting-started',
+        name: 'Getting Started (Beginners)',
+        description: 'Plain English intro for complete beginners. What everystack is, what the tiers mean, what each prerequisite is and why. Read this FIRST for users with no programming experience or no existing project.',
+        filename: 'getting-started.md',
+    },
+    // Beginner — AWS account and credential setup
+    {
+        uri: 'everystack://aws-setup',
+        name: 'AWS Setup (Beginners)',
+        description: 'Step-by-step AWS account creation and IAM credential setup for beginners. Read when check_environment reports missing AWS credentials.',
+        filename: 'aws-setup.md',
+    },
+    // Beginner — first local run walkthrough
+    {
+        uri: 'everystack://first-run',
+        name: 'First Run (Beginners)',
+        description: 'What happens when you run your app locally for the first time. Explains Metro bundler, hot reload, opening in browser or phone, and common first-run errors. Read after scaffolding a new project.',
+        filename: 'first-run.md',
+    },
+    // Beginner — V2 transition guide (adding database to existing app)
+    {
+        uri: 'everystack://adding-database',
+        name: 'Adding a Database (V2 Transition)',
+        description: 'Guide for adding PostgreSQL, API handler, and authentication to an existing Expo app. Read this when a feature needs data persistence or user accounts. Covers PostgreSQL setup, V2 package installation, schema creation, handler config, auth flow, migrations, and RLS security.',
+        filename: 'adding-database.md',
+    },
+    // Core — read these first (for developers)
+    {
+        uri: 'everystack://core',
+        name: 'everystack Core Architecture',
+        description: 'Architecture, package map, V1-V2-V3 tiers, key patterns, project conventions, handler overview, CLI commands. Read this first.',
+        filename: 'core.md',
+    },
+    {
+        uri: 'everystack://security',
+        name: 'everystack Security',
+        description: 'Three-layer security model (Edge/API/Database), AWS IAM profiles (Create/Manage/Deploy), RLS guide with copy-paste policies, deployment checklist. Read before any auth or deployment guidance.',
+        filename: 'security.md',
+    },
+    // Detail — load on demand
+    {
+        uri: 'everystack://handler-options',
+        name: 'Handler Options Reference',
+        description: 'Complete createHandler() options: auth, relations, rpc, hooks, pgSettings, softDelete, naming, exposedTables, hiddenColumns, protectedFields, rowOwnership, cache.',
+        filename: 'handler-options.md',
+    },
+    {
+        uri: 'everystack://query-protocol',
+        name: 'Query Protocol',
+        description: 'PostgREST query protocol: filters (eq, neq, gt, lt, like, ilike, is, in), negation, logical groups (or, and), column selection, relation embedding, ordering, pagination, aggregates, JSON path filtering.',
+        filename: 'query-protocol.md',
+    },
+    {
+        uri: 'everystack://client-api',
+        name: 'Client API',
+        description: 'Typed client: createClient(), query builder (.from, .eq, .select, .order, .limit), mutations (.insert, .update, .delete), token refresh, error handling.',
+        filename: 'client-api.md',
+    },
+    {
+        uri: 'everystack://auth',
+        name: 'Authentication',
+        description: 'JWT auth: createAuthHandlers(), signup/signin/refresh flows, HS256 edge verification, OAuth, password hashing, token lifecycle, AuthProvider React context.',
+        filename: 'auth.md',
+    },
+    {
+        uri: 'everystack://schema-patterns',
+        name: 'Schema Design Patterns',
+        description: 'Drizzle schema design: pgTable, column types, relations, indexes, timestamps, soft delete, UUID vs serial, migration workflow, drizzle-kit commands.',
+        filename: 'schema-patterns.md',
+    },
+    {
+        uri: 'everystack://deployment',
+        name: 'Deployment Guide',
+        description: 'SST deployment: sst.config.ts setup, secrets, stages (dev/production), CloudFront, Lambda configuration, VPC, RDS Aurora Serverless, resource linking.',
+        filename: 'deployment.md',
+    },
+    {
+        uri: 'everystack://admin',
+        name: 'Admin Dashboard',
+        description: 'Declarative admin: AdminRoot, AdminLayout, resource config, field types, EverystackAdapter, presets, custom widgets, navigation.',
+        filename: 'admin.md',
+    },
+    {
+        uri: 'everystack://jobs',
+        name: 'Background Jobs',
+        description: 'SQS background workers: createWorkerHandler, publishJob, job types, dead letter queue, cron scheduling, Postgres materialization adapter.',
+        filename: 'jobs.md',
+    },
+    {
+        uri: 'everystack://storage',
+        name: 'File Storage',
+        description: 'S3 file storage: createStorageHandler, presigned uploads, MIME validation, CDN delivery, ownership enforcement, client upload flow.',
+        filename: 'storage.md',
+    },
+    {
+        uri: 'everystack://logging',
+        name: 'Logging & Analytics',
+        description: 'Structured logging: log levels, crash reports, analytics events, S3 log storage, CloudWatch ingestion trigger, client SDK, admin dashboard integration.',
+        filename: 'logging.md',
+    },
+    {
+        uri: 'everystack://security-device',
+        name: 'Device Security',
+        description: 'Device attestation: Apple App Attest, Google Play Integrity, RS256 device keys, biometric auth, certificate pinning.',
+        filename: 'security-device.md',
+    },
+    {
+        uri: 'everystack://testing',
+        name: 'Testing Patterns',
+        description: 'Testing conventions: Jest setup, TDD workflow, test file structure, mocking patterns (ESM, sharp, AWS SDK), template database isolation, integration tests.',
+        filename: 'testing.md',
+    },
+    {
+        uri: 'everystack://plugins',
+        name: 'Plugin Architecture',
+        description: 'Plugin system: createPluginLambdaHandler, Plugin type, PluginContext, composing handlers from multiple packages, plugin registration order.',
+        filename: 'plugins.md',
+    },
+    {
+        uri: 'everystack://ssr',
+        name: 'Server-Side Rendering',
+        description: 'SSR: getWebHandler, direct Drizzle queries in loaders, JSON-LD structured data, OG meta tags, cache headers, hydration debugging.',
+        filename: 'ssr.md',
+    },
+    {
+        uri: 'everystack://images',
+        name: 'Image Processing',
+        description: 'Sharp image processing: createImageHandler, on-demand resizing, format conversion, EXIF extraction, variant generation, CDN delivery.',
+        filename: 'images.md',
+    },
+    {
+        uri: 'everystack://events',
+        name: 'Events & WebSocket',
+        description: 'Real-time events: PostgreSQL LISTEN/NOTIFY, WebSocket fan-out, Lambda event bridge, client useSignal hook, table change notifications.',
+        filename: 'events.md',
+    },
+    {
+        uri: 'everystack://cli',
+        name: 'CLI Reference',
+        description: 'Full CLI command reference: update, db:migrate, db:seed, db:psql, console, logs:errors, logs:tail, logs:query, cache:purge, certs, channels, diag, analyze:ssr.',
+        filename: 'cli.md',
+    },
+    {
+        uri: 'everystack://project-claude-md',
+        name: 'Project CLAUDE.md Template',
+        description: 'Template for a project-level CLAUDE.md file. Read this and adapt it when scaffolding a new everystack app. Replace placeholders ({PROJECT_NAME}, {ONE_LINE_DESCRIPTION}, {ANNOTATED_DIRECTORY_TREE}) with actual project details.',
+        filename: 'project-claude-md.md',
+    },
+];
+export function registerResources(server) {
+    for (const r of RESOURCES) {
+        const content = loadResource(r.filename);
+        server.resource(r.name, r.uri, { mimeType: 'text/markdown' }, async () => ({
+            contents: [{ uri: r.uri, mimeType: 'text/markdown', text: content }],
+        }));
+    }
+}
+export { RESOURCES, loadResource };

package/dist/tools/check-environment.d.ts

@@ -0,0 +1,25 @@
+export type EnvironmentPhase = 'local' | 'deploy';
+export interface PrerequisiteCheck {
+    name: string;
+    required: boolean;
+    status: 'found' | 'not_found';
+    version: string | null;
+    installHint: string;
+    tier: 'V1' | 'V2';
+    phase: 'local' | 'deploy';
+    description: string;
+    whyNeeded: string;
+    installCommands: string[];
+    serviceRunning?: boolean;
+}
+export interface EnvironmentReport {
+    phase: EnvironmentPhase;
+    prerequisites: PrerequisiteCheck[];
+    ready: boolean;
+    readyForTier: 'V1' | 'V2' | 'V3' | 'none';
+    suggestions: string[];
+    platform: 'macOS' | 'linux' | 'windows' | 'unknown';
+    nextSteps: string[];
+}
+export declare function checkEnvironment(phase?: EnvironmentPhase): EnvironmentReport;
+//# sourceMappingURL=check-environment.d.ts.map

package/dist/tools/check-environment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-environment.d.ts","sourceRoot":"","sources":["../../src/tools/check-environment.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,gBAAgB,GAAG,OAAO,GAAG,QAAQ,CAAC;AAElD,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE,OAAO,GAAG,WAAW,CAAC;IAC9B,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,IAAI,GAAG,IAAI,CAAC;IAClB,KAAK,EAAE,OAAO,GAAG,QAAQ,CAAC;IAC1B,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,gBAAgB,CAAC;IACxB,aAAa,EAAE,iBAAiB,EAAE,CAAC;IACnC,KAAK,EAAE,OAAO,CAAC;IACf,YAAY,EAAE,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,MAAM,CAAC;IAC1C,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,QAAQ,EAAE,OAAO,GAAG,OAAO,GAAG,SAAS,GAAG,SAAS,CAAC;IACpD,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB;AAiCD,wBAAgB,gBAAgB,CAAC,KAAK,GAAE,gBAA0B,GAAG,iBAAiB,CAgQrF"}

package/dist/tools/check-environment.js

@@ -0,0 +1,281 @@
+import { execSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+function detectPlatform() {
+    const p = process.platform;
+    if (p === 'darwin')
+        return 'macOS';
+    if (p === 'linux')
+        return 'linux';
+    if (p === 'win32')
+        return 'windows';
+    return 'unknown';
+}
+function tryExec(cmd, timeout = 10000) {
+    try {
+        return execSync(cmd, { timeout, stdio: 'pipe', encoding: 'utf-8' }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+function parseVersion(output, pattern) {
+    if (!output)
+        return null;
+    if (pattern) {
+        const match = output.match(pattern);
+        return match?.[1] ?? null;
+    }
+    return output.replace(/^v/, '');
+}
+function meetsMinVersion(version, major) {
+    if (!version)
+        return false;
+    const parsed = parseInt(version.split('.')[0], 10);
+    return !isNaN(parsed) && parsed >= major;
+}
+export function checkEnvironment(phase = 'local') {
+    const prerequisites = [];
+    const suggestions = [];
+    const platform = detectPlatform();
+    const isLocal = phase === 'local';
+    // Node.js
+    const nodeOutput = tryExec('node --version');
+    const nodeVersion = parseVersion(nodeOutput);
+    const nodeOk = meetsMinVersion(nodeVersion, 20);
+    prerequisites.push({
+        name: 'node',
+        required: true,
+        status: nodeVersion ? 'found' : 'not_found',
+        version: nodeVersion,
+        installHint: 'Install Node.js 20+ from https://nodejs.org',
+        tier: 'V1',
+        phase: 'local',
+        description: 'Node.js runs your code. Your app is written in TypeScript, and Node.js is the engine that executes it.',
+        whyNeeded: 'Without Node.js, none of the code can run.',
+        installCommands: platform === 'macOS'
+            ? ['brew install node', 'Or download from https://nodejs.org']
+            : platform === 'linux'
+                ? ['sudo apt install nodejs npm', 'Or download from https://nodejs.org']
+                : ['Download and install from https://nodejs.org'],
+    });
+    if (!nodeVersion) {
+        suggestions.push('Node.js is not installed. Install Node.js 20+ from https://nodejs.org');
+    }
+    else if (!nodeOk) {
+        suggestions.push(`Node.js ${nodeVersion} is installed but version 20+ is required. Upgrade at https://nodejs.org`);
+    }
+    // pnpm (recommended, not required)
+    const pnpmOutput = tryExec('pnpm --version');
+    const pnpmVersion = parseVersion(pnpmOutput);
+    prerequisites.push({
+        name: 'pnpm',
+        required: false,
+        status: pnpmVersion ? 'found' : 'not_found',
+        version: pnpmVersion,
+        installHint: 'Install pnpm: npm install -g pnpm (recommended for monorepos)',
+        tier: 'V1',
+        phase: 'local',
+        description: 'A faster way to install code libraries your app depends on. Recommended but not required.',
+        whyNeeded: 'Makes installing dependencies faster and more reliable.',
+        installCommands: ['npm install -g pnpm'],
+    });
+    if (!pnpmVersion) {
+        suggestions.push('pnpm is not installed. Recommended for monorepos: npm install -g pnpm');
+    }
+    // git
+    const gitOutput = tryExec('git --version');
+    const gitVersion = parseVersion(gitOutput, /git version (\d+\.\d+\.\d+)/);
+    prerequisites.push({
+        name: 'git',
+        required: true,
+        status: gitVersion ? 'found' : 'not_found',
+        version: gitVersion,
+        installHint: 'Install git from https://git-scm.com',
+        tier: 'V1',
+        phase: 'local',
+        description: 'Tracks every change to your code. Like an unlimited undo button for your entire project.',
+        whyNeeded: 'Without git, you cannot track changes, undo mistakes, or collaborate.',
+        installCommands: platform === 'macOS'
+            ? ['xcode-select --install']
+            : platform === 'linux'
+                ? ['sudo apt install git']
+                : ['Download from https://git-scm.com'],
+    });
+    if (!gitVersion) {
+        suggestions.push('git is not installed. Install from https://git-scm.com');
+    }
+    // Expo CLI
+    const expoOutput = tryExec('npx expo --version');
+    const expoVersion = parseVersion(expoOutput);
+    prerequisites.push({
+        name: 'expo',
+        required: true,
+        status: expoVersion ? 'found' : 'not_found',
+        version: expoVersion,
+        installHint: 'Expo is available via npx. Ensure Node.js is installed, then run: npx create-expo-app',
+        tier: 'V1',
+        phase: 'local',
+        description: 'The framework that makes your app work on phones, tablets, and the web from the same code.',
+        whyNeeded: 'Without Expo, you cannot create or run the app.',
+        installCommands: ['Runs via npx (no separate install needed). Requires Node.js.'],
+    });
+    if (!expoVersion) {
+        suggestions.push('Expo CLI not available. Ensure Node.js is installed — Expo runs via npx.');
+    }
+    // SST (deploy phase only)
+    const sstOutput = tryExec('npx sst version');
+    const sstVersion = parseVersion(sstOutput, /(\d+\.\d+\.\d+)/);
+    prerequisites.push({
+        name: 'sst',
+        required: !isLocal,
+        status: sstVersion ? 'found' : 'not_found',
+        version: sstVersion,
+        installHint: 'SST is installed as a dev dependency: pnpm add -D sst (or npx sst)',
+        tier: 'V1',
+        phase: 'deploy',
+        description: isLocal
+            ? 'Manages your cloud infrastructure. Not needed yet — you can build and run your app locally first.'
+            : 'Manages your cloud infrastructure. Tells AWS what servers, databases, and storage your app needs.',
+        whyNeeded: isLocal
+            ? 'Only needed when you are ready to deploy your app to the internet.'
+            : 'Without SST, you cannot deploy your app to the internet.',
+        installCommands: ['Installed as a project dependency when you create your app.'],
+    });
+    if (!sstVersion && !isLocal) {
+        suggestions.push('SST not found. It installs as a dev dependency: pnpm add -D sst');
+    }
+    // AWS CLI (deploy phase only)
+    const awsOutput = tryExec('aws --version');
+    const awsVersion = parseVersion(awsOutput, /aws-cli\/(\d+\.\d+\.\d+)/);
+    prerequisites.push({
+        name: 'aws-cli',
+        required: !isLocal,
+        status: awsVersion ? 'found' : 'not_found',
+        version: awsVersion,
+        installHint: 'Install AWS CLI from https://aws.amazon.com/cli/',
+        tier: 'V1',
+        phase: 'deploy',
+        description: isLocal
+            ? 'A command-line tool for Amazon Web Services. Not needed yet — you can build and run your app locally first.'
+            : 'A command-line tool that lets your computer talk to Amazon Web Services, where your app runs.',
+        whyNeeded: isLocal
+            ? 'Only needed when you are ready to deploy your app to the internet.'
+            : 'Without it, you cannot deploy or manage your app on AWS.',
+        installCommands: platform === 'macOS'
+            ? ['brew install awscli']
+            : platform === 'linux'
+                ? ['curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip" && unzip awscliv2.zip && sudo ./aws/install']
+                : ['Download from https://aws.amazon.com/cli/'],
+    });
+    if (!awsVersion && !isLocal) {
+        suggestions.push('AWS CLI is not installed. Install from https://aws.amazon.com/cli/');
+    }
+    // AWS credentials (deploy phase only)
+    const home = homedir();
+    const hasAwsCreds = existsSync(join(home, '.aws', 'credentials')) || existsSync(join(home, '.aws', 'config'));
+    prerequisites.push({
+        name: 'aws-credentials',
+        required: !isLocal,
+        status: hasAwsCreds ? 'found' : 'not_found',
+        version: null,
+        installHint: 'Read everystack://aws-setup for step-by-step AWS account and credential setup.',
+        tier: 'V1',
+        phase: 'deploy',
+        description: isLocal
+            ? 'A password file for your AWS account. Not needed yet — you can build and run your app locally first.'
+            : 'A password file that proves your computer is allowed to deploy to your AWS account.',
+        whyNeeded: isLocal
+            ? 'Only needed when you are ready to deploy your app to the internet.'
+            : 'Without credentials, AWS will reject all deploy commands.',
+        installCommands: ['Read everystack://aws-setup for full setup guide', 'aws configure'],
+    });
+    if (!hasAwsCreds && !isLocal) {
+        suggestions.push("AWS credentials not configured. Read everystack://aws-setup for step-by-step setup, or run 'aws configure' if you already have access keys.");
+    }
+    // PostgreSQL
+    const psqlOutput = tryExec('psql --version');
+    const psqlVersion = parseVersion(psqlOutput, /psql \(PostgreSQL\) (\d+\.\d+)/);
+    const pgReadyOutput = psqlVersion ? tryExec('pg_isready') : null;
+    const pgServiceUp = pgReadyOutput !== null && pgReadyOutput.includes('accepting connections');
+    prerequisites.push({
+        name: 'postgresql',
+        required: true,
+        status: psqlVersion ? 'found' : 'not_found',
+        version: psqlVersion,
+        serviceRunning: psqlVersion ? pgServiceUp : undefined,
+        installHint: 'Install PostgreSQL: brew install postgresql (macOS) or https://www.postgresql.org/download/',
+        tier: 'V2',
+        phase: 'local',
+        description: 'A database that stores your app data: users, posts, recipes, or whatever your app needs.',
+        whyNeeded: 'Without PostgreSQL, your app cannot have user accounts or saved data (needed for V2+).',
+        installCommands: platform === 'macOS'
+            ? ['brew install postgresql@16', 'brew services start postgresql@16']
+            : platform === 'linux'
+                ? ['sudo apt install postgresql', 'sudo systemctl start postgresql']
+                : ['Download from https://www.postgresql.org/download/'],
+    });
+    if (!psqlVersion) {
+        suggestions.push('PostgreSQL is not installed. Needed for V2+ (database tier). Install: brew install postgresql');
+    }
+    else if (!pgServiceUp) {
+        suggestions.push(platform === 'macOS'
+            ? 'PostgreSQL is installed but the service is not running. Start it: brew services start postgresql@16'
+            : platform === 'linux'
+                ? 'PostgreSQL is installed but the service is not running. Start it: sudo systemctl start postgresql'
+                : 'PostgreSQL is installed but the service is not running. Start the PostgreSQL service.');
+    }
+    // Determine readiness — in local phase, only local-phase prerequisites count
+    const relevant = isLocal
+        ? prerequisites.filter(c => c.phase === 'local')
+        : prerequisites;
+    const v1Required = relevant.filter(c => c.tier === 'V1' && c.required);
+    const v2Required = relevant.filter(c => c.tier === 'V2' && c.required);
+    const v1Ready = nodeOk && v1Required.every(c => c.status === 'found');
+    const v2Ready = v1Ready && v2Required.every(c => c.status === 'found');
+    // V3 uses same prerequisites as V2 (adds SQS/S3 which are AWS services, no local tooling)
+    const v3Ready = v2Ready;
+    const readyForTier = v3Ready ? 'V3' : v2Ready ? 'V2' : v1Ready ? 'V1' : 'none';
+    // Build nextSteps
+    const nextSteps = [];
+    const missing = relevant.filter(p => p.required && p.status === 'not_found');
+    if (missing.length === 0) {
+        if (isLocal) {
+            nextSteps.push('All local development prerequisites installed. Ready to create and run your app.');
+            // Hint about deploy-phase tools if not yet installed
+            const deployMissing = prerequisites.filter(p => p.phase === 'deploy' && p.status === 'not_found');
+            if (deployMissing.length > 0) {
+                nextSteps.push('When you are ready to put your app on the internet, run check_environment with phase "deploy" to see what else is needed.');
+            }
+        }
+        else {
+            nextSteps.push('All prerequisites installed. Ready to create a new app.');
+        }
+    }
+    else {
+        const installOrder = isLocal
+            ? ['node', 'git', 'pnpm', 'expo', 'postgresql']
+            : ['node', 'git', 'pnpm', 'aws-cli', 'aws-credentials', 'expo', 'sst', 'postgresql'];
+        const ordered = installOrder
+            .map(name => missing.find(p => p.name === name))
+            .filter((p) => p !== undefined);
+        for (const p of ordered) {
+            if (p.tier === 'V2') {
+                nextSteps.push(`Optional for now: Install ${p.name} — ${p.description.split('.')[0]}. Only needed for apps with user accounts or a database (V2+).`);
+            }
+            else {
+                nextSteps.push(`Install ${p.name} — ${p.description.split('.')[0]}. ${p.installCommands[0]}`);
+            }
+        }
+    }
+    return {
+        phase,
+        prerequisites,
+        ready: readyForTier !== 'none',
+        readyForTier,
+        suggestions,
+        platform,
+        nextSteps,
+    };
+}

package/dist/tools/index.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerTools(server: McpServer): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tools/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AASzE,wBAAgB,aAAa,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAcrD"}

package/dist/tools/index.js

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { checkEnvironment } from './check-environment.js';
+// NOTE (Brick 0): the legacy regex tools — project_status, schema_analyze,
+// project_validate — are intentionally NOT registered. They predate the v3
+// Model/Module surface and return wrong answers on Model-based apps (e.g. they
+// report a securely-derived handler config as "all tables accessible"). They are
+// rebuilt on @everystack/model in Brick 1 and re-registered there. Their source
+// files remain for that rewrite to reference.
+export function registerTools(server) {
+    server.tool('check_environment', 'Verify development prerequisites are installed (Node.js, pnpm, git, Expo, SST, AWS CLI, PostgreSQL). Run this first when a user wants to start a new project or is having setup issues. Use phase "local" (default) to check only what is needed to build and run locally. Use phase "deploy" when ready to deploy to AWS.', {
+        phase: z.enum(['local', 'deploy']).optional().describe('Check prerequisites for local development (default) or AWS deployment'),
+    }, async ({ phase }) => {
+        const report = checkEnvironment(phase ?? 'local');
+        return {
+            content: [{ type: 'text', text: JSON.stringify(report, null, 2) }],
+        };
+    });
+}

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

@@ -0,0 +1,28 @@
+interface ProjectStatus {
+    tier: 'V1' | 'V2' | 'V3' | 'unknown';
+    tierExplanation: string;
+    packages: {
+        installed: string[];
+        missing: string[];
+    };
+    files: {
+        sstConfig: boolean;
+        schemaDir: boolean;
+        schemaFiles: string[];
+        migrationsDir: boolean;
+        serverDir: boolean;
+        handlerFile: string | null;
+        workerFile: string | null;
+        imageFile: string | null;
+        seedFile: string | null;
+    };
+    deployment: {
+        sstOutputs: boolean;
+        stage: string | null;
+        secrets: string[];
+    };
+    warnings: string[];
+}
+export declare function analyzeProjectStatus(projectPath: string): ProjectStatus;
+export {};
+//# sourceMappingURL=project-status.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"project-status.d.ts","sourceRoot":"","sources":["../../src/tools/project-status.ts"],"names":[],"mappings":"AAUA,UAAU,aAAa;IACrB,IAAI,EAAE,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,SAAS,CAAC;IACrC,eAAe,EAAE,MAAM,CAAC;IACxB,QAAQ,EAAE;QACR,SAAS,EAAE,MAAM,EAAE,CAAC;QACpB,OAAO,EAAE,MAAM,EAAE,CAAC;KACnB,CAAC;IACF,KAAK,EAAE;QACL,SAAS,EAAE,OAAO,CAAC;QACnB,SAAS,EAAE,OAAO,CAAC;QACnB,WAAW,EAAE,MAAM,EAAE,CAAC;QACtB,aAAa,EAAE,OAAO,CAAC;QACvB,SAAS,EAAE,OAAO,CAAC;QACnB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;QAC3B,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;QAC1B,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;QACzB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;KACzB,CAAC;IACF,UAAU,EAAE;QACV,UAAU,EAAE,OAAO,CAAC;QACpB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;QACrB,OAAO,EAAE,MAAM,EAAE,CAAC;KACnB,CAAC;IACF,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAgCD,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,MAAM,GAAG,aAAa,CAoHvE"}