canopycms 0.0.0 → 0.0.1

package/src/cli/generate-ai-content.ts

@@ -1,100 +0,0 @@
-/**
- * CLI command: npx canopycms generate-ai-content
- *
- * Generates static AI-ready content files from CanopyCMS content.
- */
-
-import path from 'node:path'
-
-import { generateAIContentFiles } from '../build/generate-ai-content'
-import { getErrorMessage } from '../utils/error'
-
-interface GenerateAIContentCLIOptions {
-  projectDir: string
-  outputDir?: string
-  configPath?: string
-}
-
-export async function generateAIContentCLI(options: GenerateAIContentCLIOptions): Promise<void> {
-  const { projectDir, outputDir = 'public/ai', configPath } = options
-
-  console.log('\nCanopyCMS generate-ai-content\n')
-
-  // Load adopter's canopycms config
-  const canopyConfigPath = path.join(projectDir, 'canopycms.config.ts')
-  let canopyConfigModule: Record<string, unknown>
-  try {
-    canopyConfigModule = (await import(canopyConfigPath)) as Record<string, unknown>
-  } catch (err) {
-    console.error(`Could not load config from ${canopyConfigPath}`)
-    console.error(getErrorMessage(err))
-    process.exit(1)
-  }
-
-  // Extract the server config (defineCanopyConfig returns { server, client })
-  const configExport = canopyConfigModule.default ?? canopyConfigModule.config ?? canopyConfigModule
-  const serverConfig =
-    typeof configExport === 'object' && configExport !== null && 'server' in configExport
-      ? (configExport as { server: unknown }).server
-      : configExport
-
-  // Load entry schema registry
-  const schemasPath = path.join(projectDir, 'app/schemas.ts')
-  let entrySchemaRegistry: Record<string, unknown> = {}
-  try {
-    const schemasModule = (await import(schemasPath)) as Record<string, unknown>
-    entrySchemaRegistry =
-      (schemasModule.entrySchemaRegistry as Record<string, unknown>) ?? schemasModule
-  } catch {
-    console.warn('  No app/schemas.ts found, using empty entry schema registry')
-  }
-
-  // Load AI config if specified
-  let aiConfig: unknown
-  if (configPath) {
-    try {
-      const aiConfigModule = (await import(path.resolve(configPath))) as Record<string, unknown>
-      aiConfig = aiConfigModule.aiContentConfig ?? aiConfigModule.default ?? aiConfigModule.config
-    } catch (err) {
-      console.error(`Could not load AI config from ${configPath}`)
-      console.error(getErrorMessage(err))
-      process.exit(1)
-    }
-  }
-
-  // Validate AI config shape if provided
-  if (aiConfig !== undefined && (typeof aiConfig !== 'object' || aiConfig === null)) {
-    console.error('Invalid AI content config: expected an object.')
-    process.exit(1)
-  }
-
-  // Validate loaded config has required shape
-  if (
-    !serverConfig ||
-    typeof serverConfig !== 'object' ||
-    !('mode' in serverConfig) ||
-    !('contentRoot' in serverConfig)
-  ) {
-    console.error(
-      'Invalid CanopyCMS config: expected an object with mode and contentRoot properties.',
-    )
-    console.error('Make sure canopycms.config.ts uses defineCanopyConfig().')
-    process.exit(1)
-  }
-
-  const resolvedOutput = path.resolve(projectDir, outputDir)
-  console.log(`  Output: ${resolvedOutput}`)
-  console.log(`  Mode: ${(serverConfig as { mode?: string }).mode ?? 'dev'}`)
-
-  const result = await generateAIContentFiles({
-    config: serverConfig as Parameters<typeof generateAIContentFiles>[0]['config'],
-    entrySchemaRegistry: entrySchemaRegistry as Parameters<
-      typeof generateAIContentFiles
-    >[0]['entrySchemaRegistry'],
-    outputDir: resolvedOutput,
-    aiConfig: aiConfig as Parameters<typeof generateAIContentFiles>[0]['aiConfig'],
-  })
-
-  console.log(`\n  Generated ${result.fileCount} files`)
-  console.log(`  Output: ${result.outputDir}\n`)
-}

package/src/cli/init.test.ts

@@ -1,240 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
-import fs from 'node:fs/promises'
-import path from 'node:path'
-import os from 'node:os'
-import { init, initDeployAws } from './init'
-import { mockConsole } from '../test-utils/console-spy'
-
-// Mock @clack/prompts to avoid interactive prompts in tests
-vi.mock('@clack/prompts', () => ({
-  intro: vi.fn(),
-  outro: vi.fn(),
-  note: vi.fn(),
-  log: {
-    success: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-    info: vi.fn(),
-  },
-  confirm: vi.fn().mockResolvedValue(false),
-  select: vi.fn(),
-  text: vi.fn(),
-  isCancel: vi.fn().mockReturnValue(false),
-  cancel: vi.fn(),
-}))
-
-function defaultOpts(tmpDir: string, overrides?: Partial<Parameters<typeof init>[0]>) {
-  return {
-    authProvider: 'dev' as const,
-    mode: 'dev' as const,
-    appDir: 'app',
-    projectDir: tmpDir,
-    force: false,
-    nonInteractive: true,
-    ...overrides,
-  }
-}
-
-describe('canopycms init', () => {
-  let tmpDir: string
-
-  beforeEach(async () => {
-    mockConsole()
-    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'canopy-init-test-'))
-  })
-
-  afterEach(async () => {
-    await fs.rm(tmpDir, { recursive: true, force: true })
-  })
-
-  it('creates all expected files', async () => {
-    await init(defaultOpts(tmpDir))
-
-    const expectedFiles = [
-      'canopycms.config.ts',
-      'app/lib/canopy.ts',
-      'app/schemas.ts',
-      'app/api/canopycms/[...canopycms]/route.ts',
-      'app/edit/page.tsx',
-    ]
-
-    for (const file of expectedFiles) {
-      const filePath = path.join(tmpDir, file)
-      const stat = await fs.stat(filePath)
-      expect(stat.isFile(), `Expected ${file} to exist`).toBe(true)
-    }
-  })
-
-  it('generates config with correct mode for dev', async () => {
-    await init(defaultOpts(tmpDir, { mode: 'dev' }))
-
-    const config = await fs.readFile(path.join(tmpDir, 'canopycms.config.ts'), 'utf-8')
-    expect(config).toContain("mode: 'dev'")
-    expect(config).toContain('defineCanopyConfig')
-  })
-
-  it('generates config with correct mode for prod-sim', async () => {
-    await init(defaultOpts(tmpDir, { mode: 'prod-sim' }))
-
-    const config = await fs.readFile(path.join(tmpDir, 'canopycms.config.ts'), 'utf-8')
-    expect(config).toContain("mode: 'prod-sim'")
-  })
-
-  it('generates API route with correct handler pattern', async () => {
-    await init(defaultOpts(tmpDir))
-
-    const route = await fs.readFile(
-      path.join(tmpDir, 'app/api/canopycms/[...canopycms]/route.ts'),
-      'utf-8',
-    )
-    expect(route).toContain('getHandler')
-    expect(route).toContain('export const GET')
-    expect(route).toContain('export const POST')
-    expect(route).toContain('export const PATCH')
-    expect(route).toContain('RouteContext')
-  })
-
-  it('generates edit page with auth support', async () => {
-    await init(defaultOpts(tmpDir))
-
-    const page = await fs.readFile(path.join(tmpDir, 'app/edit/page.tsx'), 'utf-8')
-    expect(page).toContain("'use client'")
-    expect(page).toContain('useClerkAuthConfig')
-    expect(page).toContain('useDevAuthConfig')
-    expect(page).toContain('NextCanopyEditorPage')
-  })
-
-  it('skips existing files in non-interactive mode', async () => {
-    const configPath = path.join(tmpDir, 'canopycms.config.ts')
-    await fs.writeFile(configPath, 'existing content', 'utf-8')
-
-    await init(defaultOpts(tmpDir))
-
-    const content = await fs.readFile(configPath, 'utf-8')
-    expect(content).toBe('existing content')
-  })
-
-  it('overwrites existing files with --force', async () => {
-    const configPath = path.join(tmpDir, 'canopycms.config.ts')
-    await fs.writeFile(configPath, 'existing content', 'utf-8')
-
-    await init(defaultOpts(tmpDir, { force: true }))
-
-    const content = await fs.readFile(configPath, 'utf-8')
-    expect(content).not.toBe('existing content')
-    expect(content).toContain('defineCanopyConfig')
-  })
-
-  it('prompts for overwrite when interactive and file exists', async () => {
-    const { confirm } = await import('@clack/prompts')
-    vi.mocked(confirm).mockResolvedValueOnce(true)
-
-    const configPath = path.join(tmpDir, 'canopycms.config.ts')
-    await fs.writeFile(configPath, 'existing content', 'utf-8')
-
-    await init(defaultOpts(tmpDir, { nonInteractive: false }))
-
-    expect(confirm).toHaveBeenCalled()
-    const content = await fs.readFile(configPath, 'utf-8')
-    expect(content).toContain('defineCanopyConfig')
-  })
-
-  it('updates .gitignore if present', async () => {
-    await fs.writeFile(path.join(tmpDir, '.gitignore'), 'node_modules\n', 'utf-8')
-
-    await init(defaultOpts(tmpDir))
-
-    const gitignore = await fs.readFile(path.join(tmpDir, '.gitignore'), 'utf-8')
-    expect(gitignore).toContain('.canopy-prod-sim/')
-  })
-
-  it('creates files in custom app-dir', async () => {
-    await init(defaultOpts(tmpDir, { appDir: 'src/app' }))
-
-    const expectedFiles = [
-      'canopycms.config.ts',
-      'src/app/lib/canopy.ts',
-      'src/app/schemas.ts',
-      'src/app/api/canopycms/[...canopycms]/route.ts',
-      'src/app/edit/page.tsx',
-    ]
-
-    for (const file of expectedFiles) {
-      const filePath = path.join(tmpDir, file)
-      const stat = await fs.stat(filePath)
-      expect(stat.isFile(), `Expected ${file} to exist`).toBe(true)
-    }
-  })
-
-  it('adjusts import paths for custom app-dir', async () => {
-    await init(defaultOpts(tmpDir, { appDir: 'src/app' }))
-
-    const canopy = await fs.readFile(path.join(tmpDir, 'src/app/lib/canopy.ts'), 'utf-8')
-    // src/app/lib/ is 3 levels deep → ../../../canopycms.config
-    expect(canopy).toContain('../../../canopycms.config')
-
-    const route = await fs.readFile(
-      path.join(tmpDir, 'src/app/api/canopycms/[...canopycms]/route.ts'),
-      'utf-8',
-    )
-    // src/app/api/canopycms/[...canopycms]/ is 6 levels deep → ../../../../../../ but we want the lib/canopy path
-    expect(route).toContain('lib/canopy')
-
-    const editPage = await fs.readFile(path.join(tmpDir, 'src/app/edit/page.tsx'), 'utf-8')
-    expect(editPage).toContain('../../../canopycms.config')
-  })
-})
-
-describe('canopycms init-deploy aws', () => {
-  let tmpDir: string
-
-  beforeEach(async () => {
-    mockConsole()
-    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'canopy-deploy-test-'))
-  })
-
-  afterEach(async () => {
-    await fs.rm(tmpDir, { recursive: true, force: true })
-  })
-
-  it('creates Dockerfile.cms', async () => {
-    await initDeployAws({ cloud: 'aws', projectDir: tmpDir, force: false, nonInteractive: true })
-
-    const dockerfile = await fs.readFile(path.join(tmpDir, 'Dockerfile.cms'), 'utf-8')
-    expect(dockerfile).toContain('lambda-adapter')
-    expect(dockerfile).toContain('CANOPY_BUILD=cms')
-    expect(dockerfile).toContain('apt-get install -y git')
-  })
-
-  it('creates GitHub Actions workflow', async () => {
-    await initDeployAws({ cloud: 'aws', projectDir: tmpDir, force: false, nonInteractive: true })
-
-    const workflow = await fs.readFile(
-      path.join(tmpDir, '.github/workflows/deploy-cms.yml'),
-      'utf-8',
-    )
-    expect(workflow).toContain('Deploy CMS')
-    expect(workflow).toContain('docker build')
-  })
-
-  it('skips existing files in non-interactive mode', async () => {
-    const dockerfilePath = path.join(tmpDir, 'Dockerfile.cms')
-    await fs.writeFile(dockerfilePath, 'existing', 'utf-8')
-
-    await initDeployAws({ cloud: 'aws', projectDir: tmpDir, force: false, nonInteractive: true })
-
-    const content = await fs.readFile(dockerfilePath, 'utf-8')
-    expect(content).toBe('existing')
-  })
-
-  it('overwrites existing files with --force', async () => {
-    const dockerfilePath = path.join(tmpDir, 'Dockerfile.cms')
-    await fs.writeFile(dockerfilePath, 'existing', 'utf-8')
-
-    await initDeployAws({ cloud: 'aws', projectDir: tmpDir, force: true, nonInteractive: false })
-
-    const content = await fs.readFile(dockerfilePath, 'utf-8')
-    expect(content).not.toBe('existing')
-    expect(content).toContain('lambda-adapter')
-  })
-})

package/src/cli/templates/Dockerfile.cms.template

@@ -1,19 +0,0 @@
-FROM public.ecr.aws/docker/library/node:20-slim AS builder
-WORKDIR /app
-COPY package*.json ./
-RUN npm ci
-COPY . .
-ENV CANOPY_BUILD=cms
-RUN npm run build
-
-FROM public.ecr.aws/docker/library/node:20-slim AS runner
-# Git is required by CanopyCMS for branch operations
-RUN apt-get update && apt-get install -y git && rm -rf /var/lib/apt/lists/*
-# Lambda Web Adapter converts Lambda events to HTTP
-COPY --from=public.ecr.aws/awsguru/aws-lambda-web-adapter:0.8.4 /lambda-adapter /opt/extensions/lambda-adapter
-WORKDIR /app
-COPY --from=builder /app/.next/standalone ./
-COPY --from=builder /app/.next/static ./.next/static
-COPY --from=builder /app/public ./public
-ENV PORT=8080 AWS_LWA_PORT=8080 HOSTNAME=0.0.0.0 NODE_ENV=production
-CMD ["node", "server.js"]

package/src/cli/templates/canopy.ts.template

@@ -1,55 +0,0 @@
-import { createNextCanopyContext } from 'canopycms-next'
-import { createClerkAuthPlugin, createClerkJwtVerifier } from 'canopycms-auth-clerk'
-import { createDevAuthPlugin, createDevTokenVerifier } from 'canopycms-auth-dev'
-import type { AuthPlugin } from 'canopycms/auth'
-import { CachingAuthPlugin, FileBasedAuthCache } from 'canopycms/auth/cache'
-import config from '{{CONFIG_IMPORT}}'
-import { entrySchemaRegistry } from '../schemas'
-
-/**
- * Select auth plugin based on operating mode and auth provider.
- *
- * prod / prod-sim: Use CachingAuthPlugin (networkless JWT + file-based cache).
- *   The cache is populated by the worker daemon (run-once or continuous).
- *
- * dev: Use auth plugin directly (no caching layer needed).
- */
-function getAuthPlugin(): AuthPlugin {
-  const mode = config.server.mode
-  const authMode = process.env.CANOPY_AUTH_MODE || 'dev'
-
-  // In prod/prod-sim: use CachingAuthPlugin to simulate/run the Lambda code path
-  if (mode === 'prod' || mode === 'prod-sim') {
-    const cachePath = process.env.CANOPY_AUTH_CACHE_PATH
-      ?? (mode === 'prod-sim' ? '.canopy-prod-sim/.cache' : '/mnt/efs/workspace/.cache')
-
-    const tokenVerifier = authMode === 'clerk'
-      ? createClerkJwtVerifier({ jwtKey: process.env.CLERK_JWT_KEY ?? '' })
-      : createDevTokenVerifier()
-
-    return new CachingAuthPlugin(tokenVerifier, new FileBasedAuthCache(cachePath))
-  }
-
-  // In dev mode: use auth plugin directly
-  if (authMode === 'clerk') {
-    return createClerkAuthPlugin({ useOrganizationsAsGroups: true })
-  }
-
-  return createDevAuthPlugin()
-}
-
-const canopyContextPromise = createNextCanopyContext({
-  config: config.server,
-  authPlugin: getAuthPlugin(),
-  entrySchemaRegistry,
-})
-
-export const getCanopy = async () => {
-  const context = await canopyContextPromise
-  return context.getCanopy()
-}
-
-export const getHandler = async () => {
-  const context = await canopyContextPromise
-  return context.handler
-}

package/src/cli/templates/canopycms.config.ts.template

@@ -1,11 +0,0 @@
-import { defineCanopyConfig } from 'canopycms'
-
-export default defineCanopyConfig({
-  defaultBranchAccess: 'allow',
-  mode: '{{MODE}}',
-  gitBotAuthorName: 'CanopyCMS Bot',
-  gitBotAuthorEmail: 'canopycms-bot@example.com',
-  editor: {
-    title: 'CanopyCMS Editor',
-  },
-})

package/src/cli/templates/deploy-cms.yml.template

@@ -1,27 +0,0 @@
-# CanopyCMS deployment workflow
-# Customize this for your CI/CD setup
-
-name: Deploy CMS
-on:
-  push:
-    paths:
-      - 'app/**'
-      - 'src/**'
-      - 'content/**'
-      - 'canopycms.config.ts'
-      - 'Dockerfile.cms'
-  workflow_dispatch:
-
-jobs:
-  build-and-deploy:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 20
-
-      # TODO: Configure your ECR login, Docker build, push, and Lambda update
-      # See https://canopycms.dev/deploy/aws for details
-      - name: Build CMS image
-        run: docker build -f Dockerfile.cms -t cms:latest .

package/src/cli/templates/edit-page.tsx.template

@@ -1,32 +0,0 @@
-'use client'
-
-import { useClerkAuthConfig } from 'canopycms-auth-clerk/client'
-import { useDevAuthConfig } from 'canopycms-auth-dev/client'
-import { NextCanopyEditorPage } from 'canopycms-next/client'
-import config from '{{CONFIG_IMPORT}}'
-
-function useAuthConfig() {
-  const authMode = process.env.NEXT_PUBLIC_CANOPY_AUTH_MODE || 'dev'
-
-  if (authMode === 'dev') {
-    // eslint-disable-next-line react-hooks/rules-of-hooks
-    return useDevAuthConfig()
-  }
-
-  if (authMode === 'clerk') {
-    // eslint-disable-next-line react-hooks/rules-of-hooks
-    return useClerkAuthConfig()
-  }
-
-  throw new Error(
-    `Invalid NEXT_PUBLIC_CANOPY_AUTH_MODE: "${authMode}". Must be "dev" or "clerk".`
-  )
-}
-
-export default function EditPage() {
-  const authConfig = useAuthConfig()
-  const clientConfig = config.client(authConfig)
-
-  const EditorPage = NextCanopyEditorPage(clientConfig)
-  return <EditorPage />
-}

package/src/cli/templates/route.ts.template

@@ -1,12 +0,0 @@
-import { getHandler } from '{{CANOPY_IMPORT}}'
-import type { NextRequest } from 'next/server'
-
-const handler = getHandler()
-
-type RouteContext = { params: Promise<Record<string, string | string[]>> }
-
-export const GET = async (req: NextRequest, ctx: RouteContext) => (await handler)(req, ctx)
-export const POST = async (req: NextRequest, ctx: RouteContext) => (await handler)(req, ctx)
-export const PUT = async (req: NextRequest, ctx: RouteContext) => (await handler)(req, ctx)
-export const PATCH = async (req: NextRequest, ctx: RouteContext) => (await handler)(req, ctx)
-export const DELETE = async (req: NextRequest, ctx: RouteContext) => (await handler)(req, ctx)

package/src/cli/templates/schemas.ts.template

@@ -1,16 +0,0 @@
-import { defineEntrySchema } from 'canopycms'
-import { createEntrySchemaRegistry } from 'canopycms/server'
-
-// Define your entry schemas here.
-// Each schema describes the fields for a content type.
-// The schema name should match the "entrySchema" value in your .collection.json files.
-
-export const pageSchema = defineEntrySchema([
-  { name: 'title', type: 'string', label: 'Title' },
-  { name: 'description', type: 'string', label: 'Description' },
-  { name: 'body', type: 'markdown', label: 'Body' },
-])
-
-export const entrySchemaRegistry = createEntrySchemaRegistry({
-  pageSchema,
-})

package/src/cli/templates.ts

@@ -1,47 +0,0 @@
-/**
- * File templates for `canopycms init` and `canopycms init-deploy aws`.
- * Reads .template files from the templates/ directory for readability.
- */
-
-import fs from 'node:fs/promises'
-import path from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url))
-const TEMPLATES_DIR = path.join(__dirname, 'templates')
-
-async function readTemplate(name: string): Promise<string> {
-  return fs.readFile(path.join(TEMPLATES_DIR, name), 'utf-8')
-}
-
-export async function canopyCmsConfig(options: { mode: string }): Promise<string> {
-  const template = await readTemplate('canopycms.config.ts.template')
-  return template.replace('{{MODE}}', options.mode)
-}
-
-export async function canopyContext(options: { configImport: string }): Promise<string> {
-  const template = await readTemplate('canopy.ts.template')
-  return template.replace('{{CONFIG_IMPORT}}', options.configImport)
-}
-
-export async function schemasTemplate(): Promise<string> {
-  return readTemplate('schemas.ts.template')
-}
-
-export async function apiRoute(options: { canopyImport: string }): Promise<string> {
-  const template = await readTemplate('route.ts.template')
-  return template.replace('{{CANOPY_IMPORT}}', options.canopyImport)
-}
-
-export async function editPage(options: { configImport: string }): Promise<string> {
-  const template = await readTemplate('edit-page.tsx.template')
-  return template.replace('{{CONFIG_IMPORT}}', options.configImport)
-}
-
-export async function dockerfileCms(): Promise<string> {
-  return readTemplate('Dockerfile.cms.template')
-}
-
-export async function githubWorkflowCms(): Promise<string> {
-  return readTemplate('deploy-cms.yml.template')
-}

package/src/client.ts

@@ -1,12 +0,0 @@
-'use client'
-
-export type { CanopyClientConfig } from './config'
-export * from './editor/EditorPanes'
-export * from './editor/EntryNavigator'
-export * from './editor/Editor'
-export * from './editor/preview-bridge'
-export * from './editor/canopy-path'
-export * from './editor/theme'
-export * from './editor/editor-config'
-export * from './editor/CanopyEditor'
-export * from './editor/CanopyEditorPage'