devpush 0.0.0-stage → 1.0.0-beta.4

package/src/package/plugins.ts

@@ -0,0 +1,141 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  statSync,
+  writeFileSync,
+} from 'node:fs'
+import { dirname, isAbsolute, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+import { pluginApiVersion } from '../plugins/version'
+
+export { pluginApiVersion } from '../plugins/version'
+export type Runtime = 'node' | 'cloudflare'
+
+/** Build-time declaration. Entry modules are imported separately by target. */
+export interface DevpushPlugin {
+  id: string
+  apiVersion: typeof pluginApiVersion
+  runtimes: readonly Runtime[]
+  server?: string | URL
+  client?: string | URL
+}
+
+export function definePlugin(plugin: DevpushPlugin): Readonly<DevpushPlugin>
+export function definePlugin(value: unknown): Readonly<DevpushPlugin> {
+  if (!value || typeof value !== 'object' || Array.isArray(value))
+    throw new Error('Plugin declaration must be an object.')
+  const plugin = value as Record<string, unknown>
+  if (typeof plugin.id !== 'string' || !/^[a-z][a-z0-9-]*$/.test(plugin.id))
+    throw new Error(
+      'Plugin IDs must use lowercase letters, numbers and hyphens.',
+    )
+  if (plugin.apiVersion !== pluginApiVersion)
+    throw new Error(`Incompatible plugin API: ${plugin.id}`)
+  if (
+    !Array.isArray(plugin.runtimes) ||
+    !plugin.runtimes.length ||
+    plugin.runtimes.some(
+      (runtime: unknown) => runtime !== 'node' && runtime !== 'cloudflare',
+    )
+  )
+    throw new Error(`Invalid plugin runtimes: ${plugin.id}`)
+  for (const side of ['server', 'client']) {
+    const entry = plugin[side]
+    if (entry !== undefined && typeof entry !== 'string' && !(entry instanceof URL))
+      throw new Error(`Invalid ${side} entry for plugin ${plugin.id}.`)
+    if (entry instanceof URL && entry.protocol !== 'file:')
+      throw new Error(`Plugin ${plugin.id} entries must use file URLs.`)
+  }
+  if (!plugin.server && !plugin.client)
+    throw new Error(`Plugin has no entry modules: ${plugin.id}`)
+  return Object.freeze({
+    ...plugin,
+    runtimes: Object.freeze([...plugin.runtimes]),
+  }) as Readonly<DevpushPlugin>
+}
+
+export function generatePlugins(
+  plugins: readonly DevpushPlugin[],
+  target: Runtime,
+  root: string,
+) {
+  const seen = new Set<string>()
+  const entries = plugins.map((value) => {
+    const plugin = definePlugin(value)
+    if (seen.has(plugin.id)) throw new Error(`Duplicate plugin: ${plugin.id}`)
+    seen.add(plugin.id)
+    if (!plugin.runtimes.includes(target))
+      throw new Error(`Plugin ${plugin.id} does not support ${target}.`)
+    function entry(module: string | URL | undefined) {
+      if (module === undefined) return undefined
+      const path = module instanceof URL ? fileURLToPath(module) : module
+      if (!isAbsolute(path) || !existsSync(path) || !statSync(path).isFile())
+        throw new Error(
+          `Plugin ${plugin.id} entry must be an existing absolute file: ${path}`,
+        )
+      return path.replaceAll('\\', '/')
+    }
+    return {
+      id: plugin.id,
+      server: entry(plugin.server),
+      client: entry(plugin.client),
+    }
+  })
+  const directory = resolve(root, '.devpush')
+  mkdirSync(directory, { recursive: true })
+  const paths = {
+    server: resolve(directory, 'plugins.server.ts'),
+    client: resolve(directory, 'plugins.ui.ts'),
+  }
+  for (const side of ['server', 'client'] as const) {
+    const selected = entries.filter((entry) => entry[side])
+    const imports = selected.map(
+      (entry, index) =>
+        `import plugin${index} from ${JSON.stringify(entry[side])}`,
+    )
+    const declarations = selected.map(
+      (entry, index) =>
+        `{ id: ${JSON.stringify(entry.id)}, implementation: plugin${index} }`,
+    )
+    writeFileSync(
+      paths[side],
+      `${imports.join('\n')}\nexport default [${declarations.join(',\n')}]\n`,
+    )
+  }
+  return {
+    ...paths,
+    clientDirectories: [
+      ...new Set(
+        entries.flatMap((entry) =>
+          entry.client ? [dirname(entry.client)] : [],
+        ),
+      ),
+    ],
+    serverEntries: entries.flatMap((entry) =>
+      entry.server ? [entry.server] : [],
+    ),
+    packageNames: [
+      ...new Set(
+        entries.flatMap((entry) => {
+          const file = entry.server ?? entry.client
+          if (!file) return []
+          let packageDirectory = dirname(file)
+          for (;;) {
+            const manifest = resolve(packageDirectory, 'package.json')
+            if (existsSync(manifest)) {
+              const metadata = JSON.parse(readFileSync(manifest, 'utf8')) as {
+                name?: unknown
+              }
+              return typeof metadata.name === 'string' ? [metadata.name] : []
+            }
+            const parent = dirname(packageDirectory)
+            if (parent === packageDirectory) return []
+            packageDirectory = parent
+          }
+        }),
+      ),
+    ],
+  }
+}

package/src/package/sqlite.mjs

@@ -0,0 +1,2 @@
+// Keep native loading in Node and resolve it from this package's dependencies.
+export { default } from 'better-sqlite3'

package/src/package/vite-api.d.ts

@@ -0,0 +1,5 @@
+import type { UserConfig } from 'vite'
+import type { DevpushOptions } from './config'
+
+export type { DevpushOptions } from './config'
+export declare function devpush(options?: DevpushOptions): UserConfig

package/src/package/vite.ts

@@ -0,0 +1,324 @@
+import { defineConfig, searchForWorkspaceRoot } from 'vite'
+import type { Plugin } from 'vite'
+
+import { cloudflare } from '@cloudflare/vite-plugin'
+import { tanstackStart } from '@tanstack/react-start/plugin/vite'
+
+import viteReact from '@vitejs/plugin-react'
+import tailwindcss from '@tailwindcss/vite'
+import { nitro } from 'nitro/vite'
+import { runtimeDependencies } from 'nitro/meta'
+import { createRequire } from 'node:module'
+import { fileURLToPath } from 'node:url'
+import { relative, resolve } from 'node:path'
+import { mkdirSync } from 'node:fs'
+import type { DevpushOptions } from './config'
+import { generatePlugins } from './plugins'
+import { clientDisconnectPlugin } from '../../dev/client-disconnect'
+
+const watchIgnored = [
+  '../.git/**',
+  '../.tmp/**',
+  '../agent/**',
+  '../node_modules/**',
+  '**/.git/**',
+  '**/.output/**',
+  '**/.tanstack/**',
+  '**/.tmp/**',
+  '**/.data/**',
+  '**/.wrangler/**',
+  '**/public/uploads/**',
+  '**/dist/**',
+  '**/node_modules/**',
+]
+
+const packageRoot = resolve(fileURLToPath(new URL('../..', import.meta.url)))
+const nitroRequire = createRequire(import.meta.resolve('nitro/package.json'))
+
+/** Build the source application in the consuming project, never in node_modules. */
+export function devpush(options: DevpushOptions = {}) {
+  const target = options.target ?? process.env.DEVPUSH_DEPLOY_TARGET ?? 'node'
+  if (target !== 'node' && target !== 'cloudflare')
+    throw new Error('devpush target must be node or cloudflare.')
+  const root = resolve(options.root ?? process.cwd())
+  const source = resolve(packageRoot, 'src')
+  const tslib = fileURLToPath(import.meta.resolve('tslib/tslib.es6.mjs'))
+  const generated = resolve(root, '.devpush')
+  const plugins = generatePlugins(options.plugins ?? [], target, root)
+  const installed = root !== packageRoot
+  if (installed) mkdirSync(generated, { recursive: true })
+  const routeTree = resolve(generated, 'routeTree.gen.ts')
+  let development = false
+
+  const deploymentStyles = {
+    name: 'devpush-plugin-styles',
+    enforce: 'pre' as const,
+    transform(code: string, id: string) {
+      if (/(?:\?|&)(?:url|raw)(?:&|$)/.test(id)) return
+      if (
+        id.split('?')[0] !==
+        fileURLToPath(new URL('../../src/styles.css', import.meta.url))
+      )
+        return
+      return (
+        code +
+        plugins.clientDirectories
+          .map((directory) => `\n@source ${JSON.stringify(directory)};\n`)
+          .join('') +
+        [
+          '.output',
+          'dist',
+          '.devpush',
+          '.wrangler',
+          '.tmp',
+          'node_modules/.vite',
+        ]
+          .map(
+            (directory) =>
+              `\n@source not ${JSON.stringify(resolve(root, directory))};\n`,
+          )
+          .join('')
+      )
+    },
+  }
+
+  const isVitest = process.env.VITEST === 'true'
+  const isCloudflare = target === 'cloudflare'
+  const cloudflareAssetHeaders: Plugin = {
+    name: 'devpush:cloudflare-asset-headers',
+    generateBundle() {
+      if (this.environment.name !== 'client') return
+      this.emitFile({
+        type: 'asset',
+        fileName: '_headers',
+        source:
+          '/assets/*\n  Cache-Control: public, max-age=31536000, immutable\n',
+      })
+    },
+  }
+  const platformEnv = fileURLToPath(
+    new URL(
+      isCloudflare
+        ? '../../src/server/runtime/platform-env.cloudflare.ts'
+        : '../../src/server/runtime/platform-env.ts',
+      import.meta.url,
+    ),
+  )
+
+  const consumer: Plugin = {
+    name: 'devpush:consumer',
+    enforce: 'pre' as const,
+    configResolved(config) {
+      // The dev module runner needs Node to load CommonJS deps.
+      // Production transforms the source package before Nitro.
+      if (config.command !== 'serve') return
+      for (const environment of Object.values(config.environments)) {
+        environment.optimizeDeps.exclude = [
+          ...new Set([
+            ...(environment.optimizeDeps.exclude ?? []),
+            'devpush',
+            'devpush/plugins/server',
+            'devpush/plugins/client',
+            ...plugins.packageNames,
+          ]),
+        ]
+      }
+      if (isCloudflare) return
+      development = true
+      const environment = config.environments.ssr
+      if (!environment) return
+      environment.resolve.noExternal = [
+        'devpush',
+        /^@tanstack\//,
+        /^seroval(?:-plugins)?(?:\/|$)/,
+        ...plugins.packageNames,
+      ]
+    },
+    async resolveId(id, importer) {
+      // Nitro's generated modules resolve relative to the consumer.
+      // Resolve its runtime imports from the package that owns them.
+      if (
+        development &&
+        !isCloudflare &&
+        runtimeDependencies.some(
+          (name) => id === name || id.startsWith(name + '/'),
+        )
+      )
+        return this.resolve(id, nitroRequire.resolve('nitro'), {
+          skipSelf: true,
+        })
+      if (!isCloudflare && !development && id === 'better-sqlite3')
+        return { id: 'devpush/sqlite', external: true }
+      if (
+        id === './routeTree.gen' &&
+        importer?.split('?')[0] === resolve(source, 'router.tsx')
+      )
+        return routeTree
+    },
+  }
+  const pluginBoundary: Plugin = {
+    name: 'devpush:plugins',
+    enforce: 'pre',
+    transform(_code, id) {
+      if (this.environment.name !== 'client') return
+      const path = id.split('?')[0]!
+      if (
+        plugins.serverEntries.includes(path) ||
+        (!path.startsWith(source + '/') && /\.server\.[cm]?[jt]sx?$/.test(path))
+      )
+        this.error(`Server-only plugin module imported by client: ${path}`)
+    },
+  }
+
+  return defineConfig({
+    root,
+    publicDir: resolve(packageRoot, 'public'),
+    ssr: installed ? { noExternal: true } : undefined,
+    optimizeDeps: installed ? { exclude: ['devpush'] } : undefined,
+    resolve: {
+      dedupe: [
+        'react',
+        'react-dom',
+        ...(installed
+          ? ['@tanstack/react-router', '@tanstack/react-query']
+          : []),
+      ],
+      alias: [
+        {
+          find: '#devpush/plugins/registered-server',
+          replacement: plugins.server,
+        },
+        {
+          find: '#devpush/plugins/registered-client',
+          replacement: plugins.client,
+        },
+        { find: /^tslib$/, replacement: tslib },
+        {
+          find: '#devpush/server/mcp/oauth-discovery',
+          replacement: fileURLToPath(
+            new URL(
+              isCloudflare
+                ? '../../src/server/mcp/oauth-discovery.cloudflare.ts'
+                : '../../src/server/mcp/oauth-discovery.ts',
+              import.meta.url,
+            ),
+          ),
+        },
+        {
+          find: '#devpush/server/realtime/workspace-object',
+          replacement: fileURLToPath(
+            new URL(
+              isCloudflare
+                ? '../../src/server/realtime/workspace-object.cloudflare.ts'
+                : '../../src/server/realtime/workspace-object.ts',
+              import.meta.url,
+            ),
+          ),
+        },
+        {
+          find: '#devpush/server/storage/local-object-store',
+          replacement: fileURLToPath(
+            new URL(
+              isCloudflare
+                ? '../../src/server/storage/local-object-store.cloudflare.ts'
+                : '../../src/server/storage/local-object-store.ts',
+              import.meta.url,
+            ),
+          ),
+        },
+        {
+          find: '#devpush/server/runtime/platform-env',
+          replacement: platformEnv,
+        },
+        {
+          find: /^#devpush\/server\/db$/,
+          replacement: fileURLToPath(
+            new URL(
+              process.env.DEVPUSH_TEST_LIBSQL === '1' && isVitest
+                ? '../../src/test/db-libsql.ts'
+                : isCloudflare
+                  ? '../../src/server/db/index.cloudflare.ts'
+                  : '../../src/server/db/index.ts',
+              import.meta.url,
+            ),
+          ),
+        },
+      ],
+      tsconfigPaths: !installed,
+    },
+    server: {
+      fs: {
+        allow: [
+          searchForWorkspaceRoot(root),
+          packageRoot,
+          ...plugins.clientDirectories,
+        ],
+      },
+      port: 7429,
+      strictPort: true,
+      allowedHosts: ['host.lima.internal'],
+      watch: {
+        ignored: watchIgnored,
+      },
+    },
+    nitro: {
+      scanDirs: [],
+      watchOptions: {
+        ignored: watchIgnored,
+        usePolling: true,
+      },
+    },
+    plugins: isVitest
+      ? []
+      : [
+          ...(isCloudflare
+            ? [
+                cloudflareAssetHeaders,
+                cloudflare({
+                  configPath:
+                    options.wranglerConfig ??
+                    process.env.DEVPUSH_WRANGLER_CONFIG,
+                  viteEnvironment: { name: 'ssr' },
+                }),
+              ]
+            : [
+                nitro({
+                  features: { websocket: true },
+                  plugins: [
+                    resolve(
+                      source,
+                      'server/runtime/node-asset-cache-plugin.ts',
+                    ),
+                    resolve(source, 'server/runtime/node-scheduler-plugin.ts'),
+                  ],
+                  handlers: [
+                    {
+                      route: '/api/workspaces/updates',
+                      handler: resolve(
+                        source,
+                        'server/realtime/node-handler.ts',
+                      ),
+                    },
+                  ],
+                  rollupConfig: { external: [/^@sentry\//] },
+                  alias: { tslib },
+                  traceDeps: installed
+                    ? ['devpush/sqlite', 'better-sqlite3', 'tslib*']
+                    : ['better-sqlite3', 'tslib*'],
+                  scanDirs: [],
+                  watchOptions: { ignored: watchIgnored, usePolling: true },
+                }),
+              ]),
+          ...(installed ? [consumer] : []),
+          pluginBoundary,
+          deploymentStyles,
+          tailwindcss(),
+          tanstackStart({
+            srcDirectory: relative(root, source),
+            router: installed ? { generatedRouteTree: routeTree } : {},
+          }),
+          viteReact(),
+          ...(!isCloudflare ? [clientDisconnectPlugin()] : []),
+        ],
+  })
+}

package/src/package/watch-guard.cjs

@@ -0,0 +1,26 @@
+const fs = require('node:fs')
+
+const originalWatch = fs.watch
+let warned = false
+
+fs.watch = function watchWithEmfileGuard(...args) {
+  const watcher = originalWatch.apply(this, args)
+
+  watcher.on('error', (error) => {
+    if (error && error.code === 'EMFILE') {
+      if (!warned) {
+        warned = true
+        console.warn(
+          'Ignored fs.watch EMFILE from the dev server. File reload for that watcher may be disabled.',
+        )
+      }
+      return
+    }
+
+    queueMicrotask(() => {
+      throw error
+    })
+  })
+
+  return watcher
+}

package/src/plugins/client.ts

@@ -0,0 +1,57 @@
+import type { ComponentType, ReactNode } from 'react'
+import { pluginApiVersion } from './version'
+
+export interface WorkspacePluginProps {
+  teamSlug: string
+  role: string
+}
+export interface SettingsContribution<TProps> {
+  navigation: readonly { href: `#${string}`; label: string }[]
+  Content: ComponentType<TProps>
+  Pending: ComponentType
+}
+export interface ProfileContribution {
+  fields: ReactNode
+  complete: () => Promise<void>
+}
+export interface EmailPreferenceContribution {
+  fields: ReactNode
+  dirty: boolean
+  pending: boolean
+  save: () => Promise<void>
+  reset: () => void
+}
+export interface ClientPlugin {
+  emailPreferences?: {
+    useFields: (input: { userId: string }) => EmailPreferenceContribution
+  }
+
+  apiVersion: typeof pluginApiVersion
+  workspace?: {
+    header?: ComponentType<WorkspacePluginProps>
+    notice?: ComponentType<WorkspacePluginProps>
+    useServerSetup?: (input: { teamSlug: string }) => {
+      fields: ReactNode
+      ready: boolean
+    }
+    settings?: SettingsContribution<WorkspacePluginProps>
+    onboarding?: ComponentType<
+      WorkspacePluginProps & { onContinue: () => void }
+    >
+    requestAction?: (input: { teamSlug: string; error: unknown }) => boolean
+  }
+  account?: SettingsContribution<{ userId: string }>
+  profile?: {
+    useFields: (input: { userId: string }) => ProfileContribution
+  }
+}
+export interface ClientPluginEntry {
+  id: string
+  implementation: ClientPlugin
+}
+
+export function defineClientPlugin(
+  plugin: Omit<ClientPlugin, 'apiVersion'>,
+): Readonly<ClientPlugin> {
+  return Object.freeze({ ...plugin, apiVersion: pluginApiVersion })
+}