canopycms 0.0.0 → 0.0.2

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/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.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'