document-ocr 0.0.0-stage → 3.1.3

package/scripts/postinstall.mjs

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+
+/**
+ * postinstall script for document-ocr
+ *
+ * Sets up a Python virtual environment and installs dependencies
+ * required for local document OCR processing.
+ *
+ * Uses uv to install a compatible Python version (3.14) if the system
+ * Python is a different version or missing.
+ *
+ * Exits 0 even on failure — errors will surface on first scan() call.
+ */
+
+import { execFileSync } from 'node:child_process'
+import { existsSync, rmSync, writeFileSync } from 'node:fs'
+import { join, dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const packageDir = join(__dirname, '..')
+const pythonDir = join(packageDir, 'python')
+const venvDir = join(packageDir, '.venv')
+const markerFile = join(venvDir, '.setup-complete')
+const constraints = join(pythonDir, 'requirements.lock')
+
+// Python version used by the bundled runtime
+const TARGET_PYTHON = '3.14'
+
+function log(msg) {
+  process.stderr.write(`[document-ocr] ${msg}\n`)
+}
+
+function run(cmd, args, opts = {}) {
+  log(`> ${cmd} ${args.join(' ')}`)
+  return execFileSync(cmd, args, {
+    encoding: 'utf-8',
+    stdio: ['pipe', 'pipe', 'pipe'],
+    timeout: 600000, // 10 minutes (OCR dependencies are large)
+    ...opts,
+  })
+}
+
+function hasUv() {
+  try {
+    const version = execFileSync('uv', ['--version'], { encoding: 'utf-8', timeout: 10000 }).trim()
+    log(`Found ${version}`)
+    return true
+  } catch {
+    return false
+  }
+}
+
+function findCompatiblePython() {
+  /**
+   * Find a Python supported by the bundled runtime (3.14).
+   * Check versioned commands first, then generic ones.
+   */
+  const candidates = ['python3.14', 'python3', 'python']
+
+  for (const cmd of candidates) {
+    try {
+      const version = execFileSync(cmd, ['--version'], { encoding: 'utf-8', timeout: 10000 }).trim()
+      const match = version.match(/Python (\d+)\.(\d+)/)
+      if (match) {
+        const major = parseInt(match[1], 10)
+        const minor = parseInt(match[2], 10)
+        if (major === 3 && minor === 14) {
+          log(`Found compatible ${version} via "${cmd}"`)
+          return cmd
+        }
+      }
+    } catch { /* not found */ }
+  }
+  return null
+}
+
+async function main() {
+  // Skip if already set up
+  if (existsSync(markerFile)) {
+    log('Python environment already set up.')
+    return
+  }
+
+  if (process.env.DOCUMENT_OCR_SKIP_PYTHON === '1' || process.env.PASSPORT_OCR_SKIP_PYTHON === '1') {
+    log('Skipping Python setup (DOCUMENT_OCR_SKIP_PYTHON / PASSPORT_OCR_SKIP_PYTHON)')
+    return
+  }
+
+  if (!existsSync(pythonDir) || !existsSync(constraints)) {
+    log('Warning: bundled Python runtime or dependency lock is missing. Local mode will not work.')
+    return
+  }
+
+  const uvAvailable = hasUv()
+
+  // Strategy 1: Use uv to create venv with a pinned Python version
+  // uv can auto-download Python 3.14 even if the system has another version
+  if (uvAvailable && !existsSync(venvDir)) {
+    log(`Creating virtual environment with Python ${TARGET_PYTHON} via uv...`)
+    try {
+      run('uv', ['venv', '--python', TARGET_PYTHON, venvDir])
+      log('Installing Python dependencies...')
+      const venvPython = process.platform === 'win32'
+        ? join(venvDir, 'Scripts', 'python.exe')
+        : join(venvDir, 'bin', 'python')
+      run('uv', ['pip', 'install', '--python', venvPython, '-c', constraints, '-e', pythonDir])
+      writeFileSync(markerFile, new Date().toISOString())
+      log('Setup complete.')
+      return
+    } catch (err) {
+      log(`uv setup failed: ${err.message?.split('\n')[0]}`)
+      log('Trying fallback...')
+      // Clean up failed venv
+      try { rmSync(venvDir, { recursive: true, force: true }) } catch {}
+    }
+  }
+
+  // Strategy 2: Use a compatible system Python directly
+  const pythonCmd = findCompatiblePython()
+  if (pythonCmd) {
+    if (!existsSync(venvDir)) {
+      log(`Creating virtual environment with ${pythonCmd}...`)
+      try {
+        run(pythonCmd, ['-m', 'venv', venvDir])
+      } catch (err) {
+        log(`Warning: Failed to create venv: ${err.message?.split('\n')[0]}`)
+        return
+      }
+    }
+
+    const venvPython = process.platform === 'win32'
+      ? join(venvDir, 'Scripts', 'python.exe')
+      : join(venvDir, 'bin', 'python')
+
+    if (!existsSync(venvPython)) {
+      log(`Warning: venv python not found at ${venvPython}`)
+      return
+    }
+
+    log('Installing Python dependencies...')
+    try {
+      if (uvAvailable) {
+        run('uv', ['pip', 'install', '--python', venvPython, '-c', constraints, '-e', pythonDir])
+      } else {
+        run(venvPython, ['-m', 'pip', 'install', '--upgrade', 'pip'])
+        run(venvPython, ['-m', 'pip', 'install', '-c', constraints, '-e', pythonDir])
+      }
+    } catch (err) {
+      log(`Warning: Failed to install dependencies: ${err.message?.split('\n')[0]}`)
+      log('Retry with: npm rebuild document-ocr')
+      return
+    }
+
+    writeFileSync(markerFile, new Date().toISOString())
+    log('Setup complete.')
+    return
+  }
+
+  // Strategy 3: Nothing worked
+  log('Warning: Could not set up Python environment.')
+  log('The bundled runtime requires Python 3.14.')
+  if (!uvAvailable) {
+    log('Install uv to auto-download a compatible Python:')
+    log('  curl -LsSf https://astral.sh/uv/install.sh | sh')
+  }
+  log('Then retry: npm rebuild document-ocr')
+}
+
+main().catch((err) => {
+  log(`Warning: Setup failed: ${err.message}`)
+  process.exit(0)
+})

package/scripts/sync-hosting.mjs

@@ -0,0 +1,35 @@
+/** Bundle only canonical source/templates, never local credentials or build output. */
+import { cpSync, existsSync, mkdirSync, readdirSync, rmSync, lstatSync, writeFileSync } from 'node:fs'
+import { dirname, extname, join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const packageDir = resolve(dirname(fileURLToPath(import.meta.url)), '..')
+const repo = resolve(packageDir, '../..')
+const destination = join(packageDir, 'hosting')
+const extensions = new Set(['.py', '.html', '.toml', '.yaml', '.yml', '.json', '.jsonc', '.ts', '.js', '.mjs', '.sh', '.tf', '.hcl', '.md'])
+const names = new Set(['Dockerfile', 'Dockerfile.lambda', 'Caddyfile', 'requirements.lock', 'terraform.tfvars.example', 'LICENSE', '.dockerignore', '.gitignore'])
+const excluded = new Set(['node_modules', '__pycache__', '.terraform', '.wrangler', '.aws-sam', 'dist'])
+
+function allowed(source) {
+  const name = source.split('/').at(-1)
+  if (excluded.has(name) || name.startsWith('.env')) return false
+  const details = lstatSync(source)
+  if (details.isSymbolicLink()) return false
+  if (details.isDirectory()) return !name.startsWith('.')
+  return names.has(name) || (!name.startsWith('.') && extensions.has(extname(name)))
+}
+
+rmSync(destination, { recursive: true, force: true })
+mkdirSync(destination, { recursive: true })
+for (const name of ['core', 'deploy', 'infra']) {
+  if (existsSync(join(repo, name))) cpSync(join(repo, name), join(destination, name), { recursive: true, filter: allowed })
+}
+for (const name of ['pyproject.toml', 'requirements.lock', 'README.md', 'HOSTING.md', 'FEATURES.md', 'LICENSE', '.dockerignore', '.gcloudignore']) {
+  if (existsSync(join(repo, name))) cpSync(join(repo, name), join(destination, name))
+}
+// A scaffolding build context must never upload a developer's credentials or data.
+if (!existsSync(join(destination, '.dockerignore'))) {
+  writeFileSync(join(destination, '.dockerignore'), '**\n!core/\n!core/**\n!deploy/\n!deploy/docker/\n!deploy/docker/server.py\n!deploy/lambda/\n!deploy/lambda/handler.py\n!requirements.lock\n**/__pycache__\n')
+}
+writeFileSync(join(destination, '.gitignore'), '.env*\n*.pem\n*.key\n*.tfvars\n*.tfstate*\n.venv/\n**/node_modules/\n**/__pycache__/\n**/.terraform/\n**/.wrangler/\n**/.aws-sam/\nbenchmark-data/\nsample-passports/\n')
+console.log(`[sync-hosting] Bundled ${readdirSync(destination).length} source/template entries`)

package/scripts/sync-python.sh

@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+# Sync canonical Python source into the npm package for bundling.
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PACKAGE_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
+REPO_ROOT="$(cd "$PACKAGE_DIR/../.." && pwd)"
+
+# Copy core/ (the pipeline)
+rm -rf "$PACKAGE_DIR/python/core"
+cp -r "$REPO_ROOT/core" "$PACKAGE_DIR/python/core"
+find "$PACKAGE_DIR/python" -type d -name __pycache__ -exec rm -rf {} + 2>/dev/null || true
+
+# Copy the canonical runtime dependency constraints.
+cp "$REPO_ROOT/requirements.lock" "$PACKAGE_DIR/python/requirements.lock"
+
+# Copy server.py
+cp "$REPO_ROOT/deploy/docker/server.py" "$PACKAGE_DIR/python/server.py"
+
+echo "[sync-python] Synced core/ and server.py into packages/passport-ocr/python/"