@twelvehart/supermemory-runtime 1.0.0-next.0

package/scripts/check-runtime-pack.ts

@@ -0,0 +1,111 @@
+#!/usr/bin/env tsx
+import { execFileSync } from 'node:child_process'
+import { existsSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join, resolve } from 'node:path'
+
+interface PackFileEntry {
+  path?: string
+}
+
+interface PackResult {
+  files?: PackFileEntry[]
+}
+
+const REQUIRED_PATHS = [
+  '.env.example',
+  'docker-compose.prod.yml',
+  'docker-compose.yml',
+  'package.json',
+  'scripts/doctor.ts',
+  'scripts/install.sh',
+  'scripts/mcp-setup.ts',
+  'drizzle/0000_dapper_the_professor.sql',
+  'src/index.ts',
+  'src/db/schema.ts',
+  'src/mcp/index.ts',
+  'tsconfig.json',
+] as const
+
+const FORBIDDEN_PATTERNS = [
+  /^coverage\//,
+  /^data\//,
+  /^dist\//,
+  /^packages\//,
+  /^tests\//,
+  /^2026-03-05-npx-first-installer-/,
+] as const
+
+function parsePackResult(rawOutput: string): PackResult {
+  const parsed = JSON.parse(rawOutput) as unknown
+  if (!Array.isArray(parsed) || parsed.length === 0) {
+    throw new Error('npm pack --json did not return a pack result array')
+  }
+
+  const [firstResult] = parsed
+  if (!firstResult || typeof firstResult !== 'object') {
+    throw new Error('npm pack --json returned an invalid pack result')
+  }
+
+  return firstResult as PackResult
+}
+
+function collectPackPaths(result: PackResult): string[] {
+  const packPaths = result.files
+    ?.map((entry) => entry.path)
+    .filter((path): path is string => typeof path === 'string')
+    .sort()
+
+  if (!packPaths || packPaths.length === 0) {
+    throw new Error('npm pack --json did not report packaged file paths')
+  }
+
+  return packPaths
+}
+
+function assertRequiredPaths(packPaths: string[]): void {
+  const missingPaths = REQUIRED_PATHS.filter((requiredPath) => !packPaths.includes(requiredPath))
+  if (missingPaths.length > 0) {
+    throw new Error(`Runtime package is missing required files: ${missingPaths.join(', ')}`)
+  }
+}
+
+function assertForbiddenPaths(packPaths: string[]): void {
+  const forbiddenPaths = packPaths.filter((packPath) =>
+    FORBIDDEN_PATTERNS.some((pattern) => pattern.test(packPath))
+  )
+
+  if (forbiddenPaths.length > 0) {
+    throw new Error(`Runtime package includes forbidden files: ${forbiddenPaths.join(', ')}`)
+  }
+}
+
+export function validateRuntimePack(repoRoot = resolve(import.meta.dirname, '..')): string[] {
+  const packDestination = join(tmpdir(), `supermemory-runtime-pack-${process.pid}-${Date.now()}`)
+
+  try {
+    const rawOutput = execFileSync(
+      'npm',
+      ['pack', '--json', '--dry-run', '--pack-destination', packDestination],
+      {
+        cwd: repoRoot,
+        encoding: 'utf8',
+      }
+    )
+
+    const packPaths = collectPackPaths(parsePackResult(rawOutput))
+    assertRequiredPaths(packPaths)
+    assertForbiddenPaths(packPaths)
+
+    return packPaths
+  } finally {
+    if (existsSync(packDestination)) {
+      rmSync(packDestination, { recursive: true, force: true })
+    }
+  }
+}
+
+if (import.meta.url === new URL(process.argv[1], 'file://').href) {
+  const packPaths = validateRuntimePack()
+  console.log(`Runtime package validated (${packPaths.length} files)`)
+}

package/scripts/claude-mcp-config.ts

@@ -0,0 +1,336 @@
+#!/usr/bin/env tsx
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+
+export type ClaudeMcpScope = 'user' | 'project' | 'local';
+
+type JsonObject = Record<string, unknown>;
+
+export interface ClaudeMcpRegistrationEntry {
+  scope: ClaudeMcpScope;
+  sourcePath: string;
+  command: string;
+  args: string[];
+  type: string;
+}
+
+export interface ClaudeMcpRegistrationCheck {
+  status: 'missing' | 'match' | 'mismatch';
+  scope: ClaudeMcpScope;
+  projectKey: string;
+  expectedCommand: string;
+  expectedArgs: string[];
+  entries: ClaudeMcpRegistrationEntry[];
+}
+
+interface CheckOptions {
+  expectedArgs: string[];
+  expectedCommand: string;
+  homeDir?: string;
+  name: string;
+  projectDir?: string;
+  scope: ClaudeMcpScope;
+}
+
+const HOME_CONFIG_CANDIDATES = ['.claude/settings.json', '.claude.json'] as const;
+
+function isObject(value: unknown): value is JsonObject {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function readJsonObject(path: string): JsonObject | null {
+  if (!existsSync(path)) {
+    return null;
+  }
+
+  try {
+    const parsed = JSON.parse(readFileSync(path, 'utf-8')) as unknown;
+    return isObject(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function resolveRealPath(path: string): string {
+  try {
+    return realpathSync.native(path);
+  } catch {
+    return resolve(path);
+  }
+}
+
+function normalizeComparableValue(value: string): string {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return trimmed;
+  }
+
+  if (trimmed.startsWith('-')) {
+    return trimmed;
+  }
+
+  const absoluteCandidate = trimmed.startsWith('/') ? trimmed : resolve(trimmed);
+  if (existsSync(absoluteCandidate)) {
+    return resolveRealPath(absoluteCandidate);
+  }
+
+  return trimmed;
+}
+
+function getHomeConfigPaths(homeDir = homedir()): string[] {
+  const resolvedHome = resolve(homeDir);
+  return HOME_CONFIG_CANDIDATES.map((relativePath) => join(resolvedHome, relativePath));
+}
+
+export function getClaudeProjectKey(projectDir = process.cwd()): string {
+  return resolveRealPath(projectDir);
+}
+
+function getEntryFromHomeConfig(
+  configPath: string,
+  scope: ClaudeMcpScope,
+  name: string,
+  projectKey: string
+): ClaudeMcpRegistrationEntry | null {
+  const config = readJsonObject(configPath);
+  if (!config) {
+    return null;
+  }
+
+  let serverConfig: JsonObject | null = null;
+  if (scope === 'user') {
+    const mcpServers = isObject(config.mcpServers) ? config.mcpServers : null;
+    serverConfig = mcpServers && isObject(mcpServers[name]) ? (mcpServers[name] as JsonObject) : null;
+  } else {
+    const projects = isObject(config.projects) ? config.projects : null;
+    const projectConfig = projects && isObject(projects[projectKey]) ? (projects[projectKey] as JsonObject) : null;
+    const mcpServers = projectConfig && isObject(projectConfig.mcpServers) ? projectConfig.mcpServers : null;
+    serverConfig = mcpServers && isObject(mcpServers[name]) ? (mcpServers[name] as JsonObject) : null;
+  }
+
+  if (!serverConfig) {
+    return null;
+  }
+
+  return {
+    scope,
+    sourcePath: configPath,
+    command: typeof serverConfig.command === 'string' ? serverConfig.command : '',
+    args: Array.isArray(serverConfig.args)
+      ? serverConfig.args.filter((arg): arg is string => typeof arg === 'string')
+      : [],
+    type: typeof serverConfig.type === 'string' ? serverConfig.type : '',
+  };
+}
+
+function getEntryFromProjectConfig(
+  projectDir: string,
+  name: string
+): ClaudeMcpRegistrationEntry | null {
+  const configPath = join(resolve(projectDir), '.mcp.json');
+  const config = readJsonObject(configPath);
+  if (!config) {
+    return null;
+  }
+
+  const mcpServers = isObject(config.mcpServers) ? config.mcpServers : null;
+  const serverConfig = mcpServers && isObject(mcpServers[name]) ? (mcpServers[name] as JsonObject) : null;
+  if (!serverConfig) {
+    return null;
+  }
+
+  return {
+    scope: 'project',
+    sourcePath: configPath,
+    command: typeof serverConfig.command === 'string' ? serverConfig.command : '',
+    args: Array.isArray(serverConfig.args)
+      ? serverConfig.args.filter((arg): arg is string => typeof arg === 'string')
+      : [],
+    type: typeof serverConfig.type === 'string' ? serverConfig.type : '',
+  };
+}
+
+function getRegistrationEntries(
+  scope: ClaudeMcpScope,
+  name: string,
+  projectDir: string,
+  homeDir?: string
+): ClaudeMcpRegistrationEntry[] {
+  if (scope === 'project') {
+    const projectEntry = getEntryFromProjectConfig(projectDir, name);
+    return projectEntry ? [projectEntry] : [];
+  }
+
+  const projectKey = getClaudeProjectKey(projectDir);
+  return getHomeConfigPaths(homeDir)
+    .map((configPath) => getEntryFromHomeConfig(configPath, scope, name, projectKey))
+    .filter((entry): entry is ClaudeMcpRegistrationEntry => entry !== null);
+}
+
+export function findClaudeMcpRegistrations(
+  name: string,
+  projectDir = process.cwd(),
+  homeDir?: string
+): ClaudeMcpRegistrationEntry[] {
+  const scopes: ClaudeMcpScope[] = ['project', 'local', 'user'];
+  return scopes.flatMap((scope) => getRegistrationEntries(scope, name, projectDir, homeDir));
+}
+
+function isExpectedRegistration(
+  entry: ClaudeMcpRegistrationEntry,
+  expectedCommand: string,
+  expectedArgs: string[]
+): boolean {
+  if (entry.type && entry.type !== 'stdio') {
+    return false;
+  }
+
+  if (entry.command !== expectedCommand) {
+    return false;
+  }
+
+  const normalizedExpectedArgs = expectedArgs.map(normalizeComparableValue);
+  const normalizedActualArgs = entry.args.map(normalizeComparableValue);
+
+  if (normalizedExpectedArgs.length !== normalizedActualArgs.length) {
+    return false;
+  }
+
+  return normalizedExpectedArgs.every((arg, index) => arg === normalizedActualArgs[index]);
+}
+
+export function checkClaudeMcpRegistration(options: CheckOptions): ClaudeMcpRegistrationCheck {
+  const projectDir = resolve(options.projectDir ?? process.cwd());
+  const projectKey = getClaudeProjectKey(projectDir);
+  const entries = getRegistrationEntries(options.scope, options.name, projectDir, options.homeDir);
+  const expectedArgs = options.expectedArgs.map(normalizeComparableValue);
+
+  if (entries.length === 0) {
+    return {
+      status: 'missing',
+      scope: options.scope,
+      projectKey,
+      expectedCommand: options.expectedCommand,
+      expectedArgs,
+      entries: [],
+    };
+  }
+
+  if (entries.some((entry) => isExpectedRegistration(entry, options.expectedCommand, expectedArgs))) {
+    return {
+      status: 'match',
+      scope: options.scope,
+      projectKey,
+      expectedCommand: options.expectedCommand,
+      expectedArgs,
+      entries,
+    };
+  }
+
+  return {
+    status: 'mismatch',
+    scope: options.scope,
+    projectKey,
+    expectedCommand: options.expectedCommand,
+    expectedArgs,
+    entries,
+  };
+}
+
+function parseScope(value: string): ClaudeMcpScope {
+  if (value === 'user' || value === 'project' || value === 'local') {
+    return value;
+  }
+  throw new Error(`Invalid scope: ${value}`);
+}
+
+function parseCliArgs(): CheckOptions {
+  const args = process.argv.slice(2);
+  if (args[0] !== 'check') {
+    throw new Error('Usage: claude-mcp-config.ts check --scope <scope> --name <name> --command <command> [--arg <value>]');
+  }
+
+  let scope: ClaudeMcpScope | undefined;
+  let name = '';
+  let expectedCommand = '';
+  const expectedArgs: string[] = [];
+  let projectDir: string | undefined;
+  let homeDir: string | undefined;
+
+  for (let index = 1; index < args.length; index += 1) {
+    const arg = args[index];
+
+    if (arg === '--scope') {
+      scope = parseScope(args[index + 1] ?? '');
+      index += 1;
+      continue;
+    }
+
+    if (arg === '--name') {
+      name = args[index + 1] ?? '';
+      index += 1;
+      continue;
+    }
+
+    if (arg === '--command') {
+      expectedCommand = args[index + 1] ?? '';
+      index += 1;
+      continue;
+    }
+
+    if (arg === '--arg') {
+      expectedArgs.push(args[index + 1] ?? '');
+      index += 1;
+      continue;
+    }
+
+    if (arg === '--project-dir') {
+      projectDir = args[index + 1];
+      index += 1;
+      continue;
+    }
+
+    if (arg === '--home-dir') {
+      homeDir = args[index + 1];
+      index += 1;
+      continue;
+    }
+
+    throw new Error(`Unknown argument: ${arg}`);
+  }
+
+  if (!scope || !name || !expectedCommand) {
+    throw new Error('Missing required arguments for check');
+  }
+
+  return { scope, name, expectedCommand, expectedArgs, projectDir, homeDir };
+}
+
+function runCli(): void {
+  const result = checkClaudeMcpRegistration(parseCliArgs());
+  console.log(JSON.stringify(result));
+
+  switch (result.status) {
+    case 'match':
+      process.exit(0);
+    case 'missing':
+      process.exit(10);
+    case 'mismatch':
+      process.exit(11);
+  }
+}
+
+const executedPath = process.argv[1];
+if (executedPath) {
+  const currentPath = resolveRealPath(executedPath);
+  const modulePath = resolveRealPath(new URL(import.meta.url).pathname);
+  if (currentPath === modulePath) {
+    try {
+      runCli();
+    } catch (error) {
+      console.error(error instanceof Error ? error.message : String(error));
+      process.exit(2);
+    }
+  }
+}

package/scripts/docker-entrypoint.sh

@@ -0,0 +1,183 @@
+#!/bin/sh
+# =============================================================================
+# Docker Entrypoint Script for SuperMemory Clone API
+# =============================================================================
+# This script runs before the main application starts:
+# 1. Waits for required services (database, redis) to be ready
+# 2. Runs database migrations
+# 3. Starts the application
+#
+# Environment variables:
+#   DATABASE_URL    - Database connection string
+#   REDIS_URL       - Redis connection string (optional)
+#   SKIP_MIGRATIONS - Set to "true" to skip migrations
+#   MAX_RETRIES     - Max connection attempts (default: 30)
+#   RETRY_INTERVAL  - Seconds between retries (default: 2)
+# =============================================================================
+
+set -e
+
+# -----------------------------------------------------------------------------
+# Configuration
+# -----------------------------------------------------------------------------
+MAX_RETRIES="${MAX_RETRIES:-30}"
+RETRY_INTERVAL="${RETRY_INTERVAL:-2}"
+
+# Colors for output (if terminal supports it)
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# -----------------------------------------------------------------------------
+# Logging functions
+# -----------------------------------------------------------------------------
+log_info() {
+    echo "${GREEN}[INFO]${NC} $1"
+}
+
+log_warn() {
+    echo "${YELLOW}[WARN]${NC} $1"
+}
+
+log_error() {
+    echo "${RED}[ERROR]${NC} $1"
+}
+
+# -----------------------------------------------------------------------------
+# Wait for PostgreSQL to be ready
+# -----------------------------------------------------------------------------
+wait_for_postgres() {
+    if [ -z "$DATABASE_URL" ]; then
+        log_warn "DATABASE_URL not set, skipping PostgreSQL check"
+        return 0
+    fi
+
+    # Check if this is a PostgreSQL connection string
+    if echo "$DATABASE_URL" | grep -q "postgresql://\|postgres://"; then
+        log_info "Waiting for PostgreSQL to be ready..."
+
+        # Extract host and port from DATABASE_URL
+        # Format: postgresql://user:pass@host:port/dbname
+        DB_HOST=$(echo "$DATABASE_URL" | sed -n 's/.*@\([^:]*\):.*/\1/p')
+        DB_PORT=$(echo "$DATABASE_URL" | sed -n 's/.*:\([0-9]*\)\/.*/\1/p')
+
+        DB_HOST="${DB_HOST:-localhost}"
+        DB_PORT="${DB_PORT:-5432}"
+
+        RETRIES=0
+        until nc -z "$DB_HOST" "$DB_PORT" 2>/dev/null; do
+            RETRIES=$((RETRIES + 1))
+            if [ $RETRIES -ge $MAX_RETRIES ]; then
+                log_error "PostgreSQL is not available after $MAX_RETRIES attempts"
+                exit 1
+            fi
+            log_info "PostgreSQL is unavailable - attempt $RETRIES/$MAX_RETRIES - sleeping ${RETRY_INTERVAL}s"
+            sleep $RETRY_INTERVAL
+        done
+
+        log_info "PostgreSQL is ready!"
+    else
+        log_info "Using SQLite database, no connection wait needed"
+    fi
+}
+
+# -----------------------------------------------------------------------------
+# Wait for Redis to be ready (optional)
+# -----------------------------------------------------------------------------
+wait_for_redis() {
+    if [ -z "$REDIS_URL" ]; then
+        log_warn "REDIS_URL not set, skipping Redis check"
+        return 0
+    fi
+
+    log_info "Waiting for Redis to be ready..."
+
+    # Extract host and port from REDIS_URL
+    # Format: redis://host:port
+    REDIS_HOST=$(echo "$REDIS_URL" | sed -n 's/redis:\/\/\([^:]*\):.*/\1/p')
+    REDIS_PORT=$(echo "$REDIS_URL" | sed -n 's/redis:\/\/[^:]*:\([0-9]*\).*/\1/p')
+
+    REDIS_HOST="${REDIS_HOST:-localhost}"
+    REDIS_PORT="${REDIS_PORT:-6379}"
+
+    RETRIES=0
+    until nc -z "$REDIS_HOST" "$REDIS_PORT" 2>/dev/null; do
+        RETRIES=$((RETRIES + 1))
+        if [ $RETRIES -ge $MAX_RETRIES ]; then
+            log_error "Redis is not available after $MAX_RETRIES attempts"
+            exit 1
+        fi
+        log_info "Redis is unavailable - attempt $RETRIES/$MAX_RETRIES - sleeping ${RETRY_INTERVAL}s"
+        sleep $RETRY_INTERVAL
+    done
+
+    log_info "Redis is ready!"
+}
+
+# -----------------------------------------------------------------------------
+# Run database migrations
+# -----------------------------------------------------------------------------
+run_migrations() {
+    if [ "$SKIP_MIGRATIONS" = "true" ]; then
+        log_warn "SKIP_MIGRATIONS is set, skipping database migrations"
+        return 0
+    fi
+
+    log_info "Running database migrations..."
+
+    # Check if drizzle directory exists with migrations
+    if [ -d "/app/drizzle" ] && [ "$(ls -A /app/drizzle 2>/dev/null)" ]; then
+        # For production, use drizzle-kit migrate
+        # This requires drizzle-kit to be installed
+        if command -v npx >/dev/null 2>&1; then
+            npx drizzle-kit migrate || {
+                log_warn "Migration failed, continuing anyway (migrations may already be applied)"
+            }
+        else
+            log_warn "npx not available, skipping drizzle migrations"
+        fi
+    else
+        log_info "No migrations found in /app/drizzle, skipping"
+    fi
+
+    log_info "Database migrations complete!"
+}
+
+# -----------------------------------------------------------------------------
+# Create data directory if needed
+# -----------------------------------------------------------------------------
+setup_directories() {
+    log_info "Setting up directories..."
+
+    # Ensure data directory exists and is writable
+    mkdir -p /app/data
+
+    log_info "Directories ready!"
+}
+
+# -----------------------------------------------------------------------------
+# Main entrypoint
+# -----------------------------------------------------------------------------
+main() {
+    log_info "Starting SuperMemory Clone API..."
+    log_info "Environment: ${NODE_ENV:-development}"
+
+    # Setup directories
+    setup_directories
+
+    # Wait for services
+    wait_for_postgres
+    wait_for_redis
+
+    # Run migrations
+    run_migrations
+
+    log_info "Starting application..."
+
+    # Execute the main command (node dist/index.js)
+    exec node dist/index.js
+}
+
+# Run main function
+main "$@"