mpb-localkit 1.3.0

package/dist/cli/index.js

@@ -0,0 +1,853 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { createRequire } from 'module';
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { resolve, join } from 'path';
+import { spawnSync, execSync } from 'child_process';
+
+var colors = {
+  green: (s) => `\x1B[32m${s}\x1B[0m`,
+  yellow: (s) => `\x1B[33m${s}\x1B[0m`,
+  red: (s) => `\x1B[31m${s}\x1B[0m`,
+  cyan: (s) => `\x1B[36m${s}\x1B[0m`,
+  bold: (s) => `\x1B[1m${s}\x1B[0m`,
+  dim: (s) => `\x1B[2m${s}\x1B[0m`
+};
+var log = {
+  info: (msg) => console.log(`${colors.cyan("\u2139")} ${msg}`),
+  success: (msg) => console.log(`${colors.green("\u2713")} ${msg}`),
+  warn: (msg) => console.warn(`${colors.yellow("\u26A0")} ${msg}`),
+  error: (msg) => console.error(`${colors.red("\u2717")} ${msg}`),
+  bold: (msg) => console.log(colors.bold(msg)),
+  dim: (msg) => console.log(colors.dim(msg))
+};
+var CONFIG_CANDIDATES = [
+  "offlinekit.config.ts",
+  "offlinekit.config.js",
+  "offlinekit.schema.ts",
+  "offlinekit.schema.js"
+];
+function findSchemaFile(cwd = process.cwd()) {
+  for (const candidate of CONFIG_CANDIDATES) {
+    const p = resolve(cwd, candidate);
+    if (existsSync(p)) return p;
+  }
+  return null;
+}
+async function loadSchema(filePath) {
+  const mod = await import(filePath);
+  return mod.default ?? mod;
+}
+
+// src/cli/commands/dev.ts
+function registerDev(program2) {
+  program2.command("dev").description("Start OfflineKit in local-only mode (no cloud sync)").action(() => {
+    process.env["OFFLINEKIT_MODE"] = "local";
+    log.bold("OfflineKit Dev Mode");
+    log.info("Running in local-only mode (no cloud sync)");
+    log.dim("All data is stored locally. Sync is disabled.");
+  });
+}
+
+// src/cli/generator/templates/index.ts
+function workerIndexTemplate(_appName) {
+  return `
+import { Hono } from 'hono'
+import { cors } from 'hono/cors'
+import { auth } from './routes/auth.js'
+import { sync } from './routes/sync.js'
+import { ws, WsSessions } from './routes/ws.js'
+import { errors } from './routes/errors.js'
+import { health } from './routes/health.js'
+
+export interface Env {
+  STORAGE: R2Bucket
+  KV: KVNamespace
+  JWT_SECRET: string
+  WS_SESSIONS: DurableObjectNamespace
+}
+
+export { WsSessions }
+
+const app = new Hono<{ Bindings: Env }>()
+
+app.use('/*', cors({
+  origin: '*',
+  allowMethods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
+  allowHeaders: ['Content-Type', 'Authorization'],
+}))
+
+app.route('/auth', auth)
+app.route('/sync', sync)
+app.route('/ws', ws)
+app.route('/errors', errors)
+app.route('/health', health)
+
+export default app
+`.trimStart();
+}
+
+// src/cli/generator/templates/auth.ts
+function authTemplate() {
+  return `
+import { Hono } from 'hono'
+import { sign, verify } from 'hono/jwt'
+import type { Env } from './index.js'
+import { AUTH_KEY, SESSION_KEY, type StoredUser } from '../storage/kv.js'
+
+export const auth = new Hono<{ Bindings: Env }>()
+
+/** Constant-time string comparison to prevent timing side-channels */
+function timingSafeEqual(a: string, b: string): boolean {
+  if (a.length !== b.length) return false
+  const encoder = new TextEncoder()
+  const bufA = encoder.encode(a)
+  const bufB = encoder.encode(b)
+  let result = 0
+  for (let i = 0; i < bufA.length; i++) result |= bufA[i] ^ bufB[i]
+  return result === 0
+}
+
+/** Extract userId from Bearer token \u2014 throws on invalid/expired */
+export async function authMiddleware(c: any, next: () => Promise<void>) {
+  const header = c.req.header('Authorization') ?? ''
+  const token = header.startsWith('Bearer ') ? header.slice(7) : null
+  if (!token) return c.json({ error: 'Unauthorized' }, 401)
+  try {
+    const payload = await verify(token, c.env.JWT_SECRET) as { sub: string }
+    c.set('userId', payload.sub)
+  } catch {
+    return c.json({ error: 'Invalid token' }, 401)
+  }
+  return next()
+}
+
+auth.post('/signup', async (c) => {
+  const { email, passwordHash } = await c.req.json<{ email: string; passwordHash: string }>()
+  if (!email || !passwordHash) return c.json({ error: 'email and passwordHash required' }, 400)
+
+  const existing = await c.env.KV.get(AUTH_KEY(email))
+  if (existing) return c.json({ error: 'Email already registered' }, 409)
+
+  const userId = crypto.randomUUID()
+  const user: StoredUser = { userId, email, passwordHash }
+  await c.env.KV.put(AUTH_KEY(email), JSON.stringify(user))
+
+  const token = await sign({ sub: userId, email, exp: Math.floor(Date.now() / 1000) + 60 * 60 * 24 * 30 }, c.env.JWT_SECRET)
+  return c.json({ user: { id: userId, email }, token }, 201)
+})
+
+auth.post('/signin', async (c) => {
+  const { email, passwordHash } = await c.req.json<{ email: string; passwordHash: string }>()
+  if (!email || !passwordHash) return c.json({ error: 'email and passwordHash required' }, 400)
+
+  const raw = await c.env.KV.get(AUTH_KEY(email))
+  if (!raw) return c.json({ error: 'Invalid credentials' }, 401)
+
+  const user = JSON.parse(raw) as StoredUser
+  if (!timingSafeEqual(user.passwordHash, passwordHash)) return c.json({ error: 'Invalid credentials' }, 401)
+
+  const token = await sign({ sub: user.userId, email, exp: Math.floor(Date.now() / 1000) + 60 * 60 * 24 * 30 }, c.env.JWT_SECRET)
+  return c.json({ user: { id: user.userId, email }, token })
+})
+
+auth.post('/signout', async (c) => {
+  const header = c.req.header('Authorization') ?? ''
+  const token = header.startsWith('Bearer ') ? header.slice(7) : null
+  if (token) await c.env.KV.delete(SESSION_KEY(token))
+  return c.json({ ok: true })
+})
+`.trimStart();
+}
+
+// src/cli/generator/templates/sync.ts
+function syncTemplate() {
+  return `
+import { Hono } from 'hono'
+import type { Env } from './index.js'
+import { authMiddleware } from './auth.js'
+import { docKey, collectionPrefix } from '../storage/r2.js'
+
+interface SyncDoc {
+  _id: string
+  _collection: string
+  _updatedAt: number
+  _deleted: boolean
+  [key: string]: unknown
+}
+
+export const sync = new Hono<{ Bindings: Env }>()
+
+sync.use('/*', authMiddleware)
+
+sync.post('/push', async (c) => {
+  const userId = c.get('userId') as string
+  const { changes } = await c.req.json<{ changes: SyncDoc[] }>()
+
+  await Promise.all(
+    changes.map(async (doc) => {
+      const key = docKey(userId, doc._collection, doc._id)
+      const existing = await c.env.STORAGE.get(key, 'json') as SyncDoc | null
+
+      // LWW \u2014 only overwrite if incoming is newer
+      if (!existing || doc._updatedAt >= existing._updatedAt) {
+        await c.env.STORAGE.put(key, JSON.stringify(doc), {
+          customMetadata: { updatedAt: String(doc._updatedAt) },
+        })
+      }
+    }),
+  )
+
+  return c.json({ ok: true, received: changes.length })
+})
+
+sync.get('/pull', async (c) => {
+  const userId = c.get('userId') as string
+  const since = parseInt(c.req.query('since') ?? '0', 10)
+
+  // Scan all collections for this user \u2014 list all objects under {userId}/
+  const prefix = \`\${userId}/\`
+  const listed = await c.env.STORAGE.list({ prefix })
+
+  const changes = await Promise.all(
+    listed.objects
+      .filter((obj) => {
+        const ts = parseInt(obj.customMetadata?.updatedAt ?? '0', 10)
+        return ts > since
+      })
+      .map(async (obj) => {
+        const blob = await c.env.STORAGE.get(obj.key, 'json')
+        return blob as SyncDoc
+      }),
+  )
+
+  return c.json({ changes: changes.filter(Boolean) })
+})
+`.trimStart();
+}
+
+// src/cli/generator/templates/ws.ts
+function wsTemplate() {
+  return `import { Hono } from 'hono'
+import { verify } from 'hono/jwt'
+import type { Env } from './index.js'
+import { authMiddleware } from './auth.js'
+import { docKey } from '../storage/r2.js'
+
+export const ws = new Hono<{ Bindings: Env }>()
+
+// Proxy WS upgrade requests to the user-scoped Durable Object
+ws.get('/', authMiddleware, async (c) => {
+  const userId = c.get('userId') as string
+  const id = c.env.WS_SESSIONS.idFromName(userId)
+  return c.env.WS_SESSIONS.get(id).fetch(c.req.raw)
+})
+
+// ---- Durable Object: one instance per userId, owns all WebSocket sessions ----
+
+interface SyncDoc {
+  _id: string
+  _collection: string
+  _updatedAt: number
+  _deleted: boolean
+  [key: string]: unknown
+}
+
+interface WsMsg {
+  type: string
+  id?: string
+  payload?: unknown
+  since?: number
+  token?: string
+}
+
+export class WsSessions {
+  private readonly sessions = new Map<WebSocket, { userId: string | null }>()
+
+  constructor(
+    private readonly state: DurableObjectState,
+    private readonly env: Env,
+  ) {}
+
+  async fetch(request: Request): Promise<Response> {
+    if (request.headers.get('Upgrade') !== 'websocket') {
+      return new Response('Expected WebSocket upgrade', { status: 426 })
+    }
+
+    const pair = new WebSocketPair()
+    const [client, server] = Object.values(pair) as [WebSocket, WebSocket]
+    server.accept()
+
+    const session = { userId: null as string | null }
+    this.sessions.set(server, session)
+
+    server.addEventListener('message', async (event) => {
+      let msg: WsMsg
+      try { msg = JSON.parse(event.data as string) as WsMsg } catch { return }
+      try {
+        await this.handle(server, session, msg)
+      } catch (err) {
+        server.send(JSON.stringify({ type: 'error', id: msg.id, payload: { message: String(err) } }))
+      }
+    })
+
+    server.addEventListener('close', () => { this.sessions.delete(server) })
+
+    return new Response(null, { status: 101, webSocket: client })
+  }
+
+  private async handle(ws: WebSocket, session: { userId: string | null }, msg: WsMsg): Promise<void> {
+    if (msg.type === 'auth') {
+      try {
+        const payload = await verify(msg.token ?? '', this.env.JWT_SECRET) as { sub?: string }
+        if (!payload.sub) throw new Error('Missing sub')
+        session.userId = payload.sub
+        ws.send(JSON.stringify({ type: 'auth_ack', id: msg.id }))
+      } catch {
+        ws.send(JSON.stringify({ type: 'error', id: msg.id, payload: { message: 'Unauthorized' } }))
+        ws.close(1008, 'Unauthorized')
+      }
+      return
+    }
+
+    if (!session.userId) {
+      ws.send(JSON.stringify({ type: 'error', id: msg.id, payload: { message: 'Not authenticated' } }))
+      return
+    }
+
+    if (msg.type === 'push') {
+      const { changes } = msg.payload as { changes: SyncDoc[] }
+      await Promise.all(changes.map(async (doc) => {
+        const key = docKey(session.userId!, doc._collection, doc._id)
+        const existing = await this.env.STORAGE.get(key, 'json') as SyncDoc | null
+        if (!existing || doc._updatedAt >= existing._updatedAt) {
+          await this.env.STORAGE.put(key, JSON.stringify(doc), {
+            customMetadata: { updatedAt: String(doc._updatedAt) },
+          })
+        }
+      }))
+      ws.send(JSON.stringify({ type: 'push_ack', id: msg.id, payload: { ok: true } }))
+      this.broadcast(session.userId, ws, { type: 'remote_changes', changes })
+      return
+    }
+
+    if (msg.type === 'pull') {
+      const since = typeof msg.since === 'number' ? msg.since : 0
+      const listed = await this.env.STORAGE.list({ prefix: \`\${session.userId}/\` })
+      const changes = (await Promise.all(
+        listed.objects
+          .filter((o) => parseInt(o.customMetadata?.updatedAt ?? '0', 10) > since)
+          .map((o) => this.env.STORAGE.get(o.key, 'json') as Promise<SyncDoc>),
+      )).filter(Boolean)
+      ws.send(JSON.stringify({ type: 'pull_response', id: msg.id, payload: { changes } }))
+      return
+    }
+
+    ws.send(JSON.stringify({ type: 'error', id: msg.id, payload: { message: \`Unknown type: \${msg.type}\` } }))
+  }
+
+  private broadcast(userId: string, sender: WebSocket, msg: object): void {
+    const data = JSON.stringify(msg)
+    for (const [ws, s] of this.sessions) {
+      if (ws !== sender && s.userId === userId) {
+        try { ws.send(data) } catch { /* stale connection */ }
+      }
+    }
+  }
+}
+
+// JWT verification handled by hono/jwt verify() \u2014 no hand-rolled crypto needed
+`.trimStart();
+}
+
+// src/cli/generator/templates/errors.ts
+function errorsTemplate() {
+  return `
+import { Hono } from 'hono'
+import type { Env } from './index.js'
+import { authMiddleware } from './auth.js'
+
+export const errors = new Hono<{ Bindings: Env }>()
+
+errors.use('/*', authMiddleware)
+
+errors.get('/', async (c) => {
+  const userId = c.get('userId') as string
+  const prefix = \`\${userId}/_errors/\`
+
+  const listed = await c.env.STORAGE.list({ prefix })
+  const results = await Promise.all(
+    listed.objects.map(async (obj) => {
+      const blob = await c.env.STORAGE.get(obj.key)
+      if (!blob) return null
+      return blob.json()
+    }),
+  )
+
+  return c.json({ errors: results.filter(Boolean) })
+})
+`.trimStart();
+}
+
+// src/cli/generator/templates/health.ts
+function healthTemplate() {
+  return `
+import { Hono } from 'hono'
+
+export const health = new Hono()
+
+health.get('/', (c) => {
+  return c.json({ status: 'ok', timestamp: Date.now() })
+})
+`.trimStart();
+}
+
+// src/cli/generator/templates/r2-storage.ts
+function r2StorageTemplate() {
+  return `
+export const docKey = (userId: string, collection: string, docId: string) =>
+  \`\${userId}/\${collection}/\${docId}.json\`
+
+export const collectionPrefix = (userId: string, collection: string) =>
+  \`\${userId}/\${collection}/\`
+`.trimStart();
+}
+
+// src/cli/generator/templates/kv-storage.ts
+function kvStorageTemplate() {
+  return `
+/** Key: auth:{email}  Value: { userId, email, passwordHash } */
+export const AUTH_KEY = (email: string) => \`auth:\${email}\`
+
+/** Key: session:{token}  Value: { userId, email, exp } */
+export const SESSION_KEY = (token: string) => \`session:\${token}\`
+
+/** Key: meta:{userId}  Value: arbitrary metadata object */
+export const META_KEY = (userId: string) => \`meta:\${userId}\`
+
+export interface StoredUser {
+  userId: string
+  email: string
+  passwordHash: string
+}
+
+export interface StoredSession {
+  userId: string
+  email: string
+  exp: number
+}
+`.trimStart();
+}
+
+// src/cli/generator/templates/wrangler.ts
+function wranglerTemplate(appName) {
+  const name = appName.toLowerCase().replace(/[^a-z0-9-]/g, "-");
+  return `name = "${name}-worker"
+main = "src/index.ts"
+compatibility_date = "2024-01-01"
+compatibility_flags = ["nodejs_compat"]
+
+[[r2_buckets]]
+binding = "STORAGE"
+bucket_name = "${name}-storage"
+
+[[kv_namespaces]]
+binding = "KV"
+id = "REPLACE_WITH_KV_NAMESPACE_ID"
+
+[[durable_objects.bindings]]
+name = "WS_SESSIONS"
+class_name = "WsSessions"
+
+[[migrations]]
+tag = "v1"
+new_classes = ["WsSessions"]
+
+# Security: Set secrets via Cloudflare dashboard or CLI:
+#   wrangler secret put JWT_SECRET
+`;
+}
+
+// src/cli/generator/index.ts
+function generateWorker(options) {
+  const { appName, outDir } = options;
+  const dirs = [
+    outDir,
+    join(outDir, "src"),
+    join(outDir, "src", "routes"),
+    join(outDir, "src", "storage")
+  ];
+  for (const dir of dirs) mkdirSync(dir, { recursive: true });
+  const files = [
+    [join(outDir, "wrangler.toml"), wranglerTemplate(appName)],
+    [join(outDir, "src", "index.ts"), workerIndexTemplate()],
+    [join(outDir, "src", "routes", "auth.ts"), authTemplate()],
+    [join(outDir, "src", "routes", "sync.ts"), syncTemplate()],
+    [join(outDir, "src", "routes", "ws.ts"), wsTemplate()],
+    [join(outDir, "src", "routes", "errors.ts"), errorsTemplate()],
+    [join(outDir, "src", "routes", "health.ts"), healthTemplate()],
+    [join(outDir, "src", "storage", "r2.ts"), r2StorageTemplate()],
+    [join(outDir, "src", "storage", "kv.ts"), kvStorageTemplate()],
+    [join(outDir, "package.json"), workerPackageJson(appName)],
+    [join(outDir, "tsconfig.json"), workerTsConfig()]
+  ];
+  for (const [path, content] of files) {
+    writeFileSync(path, content, "utf8");
+  }
+  console.warn(
+    '\n\u26A0  Remember to replace placeholder values in wrangler.toml before deploying:\n   - JWT_SECRET = "REPLACE_WITH_SECRET"  \u2192  set a strong random secret\n   - KV namespace id                     \u2192  set your actual KV namespace ID\n'
+  );
+}
+function workerPackageJson(appName) {
+  const name = appName.toLowerCase().replace(/[^a-z0-9-]/g, "-");
+  return JSON.stringify(
+    {
+      name: `${name}-worker`,
+      version: "1.0.0",
+      type: "module",
+      scripts: {
+        dev: "wrangler dev",
+        deploy: "wrangler deploy",
+        "type-check": "tsc --noEmit"
+      },
+      dependencies: {
+        hono: "^4.6.0"
+      },
+      devDependencies: {
+        "@cloudflare/workers-types": "^4.0.0",
+        typescript: "^5.6.0",
+        wrangler: "^3.0.0"
+      }
+    },
+    null,
+    2
+  );
+}
+function workerTsConfig() {
+  return JSON.stringify(
+    {
+      compilerOptions: {
+        target: "ES2022",
+        module: "ESNext",
+        moduleResolution: "bundler",
+        lib: ["ES2022"],
+        types: ["@cloudflare/workers-types"],
+        strict: true,
+        skipLibCheck: true
+      },
+      include: ["src/**/*"]
+    },
+    null,
+    2
+  );
+}
+
+// src/cli/targets/cloudflare.ts
+var cloudflareTarget = {
+  name: "cloudflare",
+  generate({ appName, outDir }) {
+    generateWorker({ appName, outDir });
+  }
+};
+var nodeTarget = {
+  name: "node",
+  generate({ appName, outDir }) {
+    const dirs = [
+      outDir,
+      join(outDir, "src"),
+      join(outDir, "src", "routes"),
+      join(outDir, "src", "storage")
+    ];
+    for (const dir of dirs) mkdirSync(dir, { recursive: true });
+    const serverEntry = nodeServerEntry(appName);
+    const files = [
+      [join(outDir, "src", "index.ts"), serverEntry],
+      [join(outDir, "src", "routes", "auth.ts"), authTemplate()],
+      [join(outDir, "src", "routes", "sync.ts"), syncTemplate()],
+      [join(outDir, "src", "routes", "ws.ts"), wsTemplate()],
+      [join(outDir, "src", "routes", "errors.ts"), errorsTemplate()],
+      [join(outDir, "src", "routes", "health.ts"), healthTemplate()],
+      [join(outDir, "src", "storage", "r2.ts"), r2StorageTemplate()],
+      [join(outDir, "src", "storage", "kv.ts"), kvStorageTemplate()],
+      [join(outDir, "package.json"), nodePackageJson(appName)],
+      [join(outDir, "tsconfig.json"), nodeTsConfig()]
+    ];
+    for (const [path, content] of files) {
+      writeFileSync(path, content, "utf8");
+    }
+  }
+};
+function nodeServerEntry(appName) {
+  return `import { Hono } from 'hono'
+import { serve } from '@hono/node-server'
+import { createNodeWebSocket } from '@hono/node-ws'
+import { verify } from 'hono/jwt'
+import { auth } from './routes/auth.js'
+import { sync } from './routes/sync.js'
+import { health } from './routes/health.js'
+
+const app = new Hono()
+const { injectWebSocket, upgradeWebSocket } = createNodeWebSocket({ app })
+
+// In-memory session store for WebSocket connections (mirrors DO sessions map)
+const sessions = new Map<WebSocket, { userId: string }>()
+
+app.route('/auth', auth)
+app.route('/sync', sync)
+app.route('/health', health)
+
+app.get('/ws', upgradeWebSocket(() => ({
+  onOpen(_event, ws) {
+    // session added on auth message
+  },
+  async onMessage(event, ws) {
+    let msg: { type: string; [k: string]: unknown }
+    try {
+      msg = JSON.parse(event.data.toString())
+    } catch {
+      ws.send(JSON.stringify({ type: 'error', message: 'Invalid JSON' }))
+      return
+    }
+
+    const session = sessions.get(ws.raw as WebSocket)
+
+    if (msg.type === 'auth') {
+      try {
+        const jwtSecret = process.env.JWT_SECRET
+        if (!jwtSecret) throw new Error('JWT_SECRET not configured')
+        const payload = await verify(msg.token as string, jwtSecret) as { sub: string }
+        if (!payload.sub) throw new Error('Missing sub claim')
+        sessions.set(ws.raw as WebSocket, { userId: payload.sub })
+        ws.send(JSON.stringify({ type: 'auth', ok: true }))
+      } catch {
+        ws.send(JSON.stringify({ type: 'error', message: 'Invalid token' }))
+        ws.close()
+      }
+    } else if (!session) {
+      ws.send(JSON.stringify({ type: 'error', message: 'Not authenticated' }))
+    } else if (msg.type === 'push') {
+      ws.send(JSON.stringify({ type: 'push', ok: true }))
+    } else if (msg.type === 'pull') {
+      ws.send(JSON.stringify({ type: 'pull', changes: [] }))
+    }
+  },
+  onClose(_event, ws) {
+    sessions.delete(ws.raw as WebSocket)
+  },
+})))
+
+const port = parseInt(process.env.PORT ?? '3000', 10)
+console.log(\`${appName} server running on http://localhost:\${port}\`)
+
+const server = serve({ fetch: app.fetch, port })
+injectWebSocket(server)
+`;
+}
+function nodePackageJson(appName) {
+  const name = appName.toLowerCase().replace(/[^a-z0-9-]/g, "-");
+  return JSON.stringify(
+    {
+      name: `${name}-server`,
+      version: "1.0.0",
+      type: "module",
+      scripts: {
+        dev: "tsx watch src/index.ts",
+        start: "node dist/index.js",
+        build: "tsc"
+      },
+      dependencies: {
+        hono: "^4.6.0",
+        "@hono/node-server": "^1.13.0",
+        "@hono/node-ws": "^1.0.0"
+      },
+      devDependencies: {
+        typescript: "^5.6.0",
+        tsx: "^4.0.0",
+        "@types/node": "^22.0.0"
+      }
+    },
+    null,
+    2
+  );
+}
+function nodeTsConfig() {
+  return JSON.stringify(
+    {
+      compilerOptions: {
+        target: "ES2022",
+        module: "ESNext",
+        moduleResolution: "bundler",
+        lib: ["ES2022"],
+        types: ["node"],
+        strict: true,
+        skipLibCheck: true,
+        outDir: "dist"
+      },
+      include: ["src/**/*"]
+    },
+    null,
+    2
+  );
+}
+
+// src/cli/commands/build.ts
+var targets = { cloudflare: cloudflareTarget, node: nodeTarget };
+function registerBuild(program2) {
+  program2.command("build").description("Build the OfflineKit backend bundle").option("-o, --out <dir>", "Output directory", ".offlinekit/worker").option("-n, --name <name>", "App name for the worker", "offlinekit-app").option("-t, --target <target>", "Deploy target: cloudflare or node", "cloudflare").action(async (opts) => {
+    log.bold("OfflineKit Build");
+    const target = targets[opts.target];
+    if (!target) {
+      log.error(`Unknown target: ${opts.target}. Valid targets: ${Object.keys(targets).join(", ")}`);
+      process.exit(1);
+    }
+    const schemaFile = findSchemaFile();
+    if (!schemaFile) {
+      log.error("No schema file found. Create offlinekit.config.ts in your project root.");
+      process.exit(1);
+    }
+    log.info(`Found schema: ${schemaFile}`);
+    try {
+      await loadSchema(schemaFile);
+      log.success("Schema loaded successfully");
+    } catch (err) {
+      log.error(`Schema load failed: ${err instanceof Error ? err.message : String(err)}`);
+      process.exit(1);
+    }
+    const outDir = resolve(process.cwd(), opts.out);
+    log.info(`Generating ${target.name} backend to: ${outDir}`);
+    try {
+      target.generate({ appName: opts.name, outDir });
+      log.success(`Backend generated at ${outDir}`);
+      if (opts.target === "node") {
+        log.dim(`Run: cd ${opts.out} && npm install && npm run dev`);
+      } else {
+        log.dim(`Run: cd ${opts.out} && npm install && wrangler deploy`);
+      }
+    } catch (err) {
+      log.error(`Build failed: ${err instanceof Error ? err.message : String(err)}`);
+      process.exit(1);
+    }
+  });
+}
+function checkWrangler() {
+  try {
+    const result = execSync("wrangler --version", { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+    return result.trim();
+  } catch {
+    return null;
+  }
+}
+function registerDeploy(program2) {
+  program2.command("deploy").description("Deploy the OfflineKit Worker to Cloudflare via Wrangler").option("-d, --dir <dir>", "Worker output directory", ".offlinekit/worker").option("-e, --env <env>", "Wrangler environment (e.g. production, staging)").option("-t, --target <target>", "Deploy target (default: cloudflare)", "cloudflare").option("--dry-run", "Print the wrangler command without running it").action((opts) => {
+    log.bold("OfflineKit Deploy");
+    const serverDir = resolve(process.cwd(), "server");
+    if (existsSync(serverDir)) {
+      log.info("Warning: This project has been ejected (./server/ exists).");
+      log.dim("You can deploy the ejected code directly with `cd server && wrangler deploy`.");
+    }
+    if (opts.target !== "cloudflare") {
+      log.error(`Deploy target "${opts.target}" is not supported yet. Only "cloudflare" is deployable.`);
+      log.dim("For Node.js targets, run `offlinekit build --target node` then deploy the output manually.");
+      process.exit(1);
+    }
+    const version = checkWrangler();
+    if (!version) {
+      log.error("wrangler is not installed or not in PATH.");
+      log.dim("Install it with: npm install -g wrangler");
+      process.exit(1);
+    }
+    log.success(`wrangler ${version}`);
+    const outDir = resolve(process.cwd(), opts.dir);
+    if (!existsSync(outDir)) {
+      log.error(`Worker directory not found: ${outDir}`);
+      log.dim("Run `offlinekit build` first to generate the worker.");
+      process.exit(1);
+    }
+    const tomlPath = resolve(outDir, "wrangler.toml");
+    if (!existsSync(tomlPath)) {
+      log.error(`wrangler.toml not found in ${outDir}`);
+      log.dim("Run `offlinekit build` to regenerate the worker.");
+      process.exit(1);
+    }
+    const args = ["deploy"];
+    if (opts.env) args.push("--env", opts.env);
+    log.info(`Deploying from: ${outDir}`);
+    if (opts.env) log.info(`Environment: ${opts.env}`);
+    if (opts.dryRun) {
+      log.dim(`[dry-run] wrangler ${args.join(" ")}`);
+      log.dim(`[dry-run] cwd: ${outDir}`);
+      return;
+    }
+    const result = spawnSync("wrangler", args, {
+      cwd: outDir,
+      stdio: "inherit",
+      encoding: "utf8"
+    });
+    if (result.status !== 0) {
+      log.error(`wrangler deploy failed (exit ${result.status ?? "unknown"})`);
+      process.exit(result.status ?? 1);
+    }
+    log.success("Deployed successfully!");
+  });
+}
+var targets2 = {
+  cloudflare: cloudflareTarget,
+  node: nodeTarget
+};
+function registerEject(program2) {
+  program2.command("eject").description("Eject generated Worker code into ./server/ for manual customization").option("-o, --out <dir>", "Output directory for ejected code", "server").option("-n, --name <name>", "App name", "offlinekit-app").option("-t, --target <target>", "Deploy target (cloudflare, node)", "cloudflare").action((opts) => {
+    log.bold("OfflineKit Eject");
+    const target = targets2[opts.target];
+    if (!target) {
+      log.error(`Unknown target: "${opts.target}"`);
+      log.dim(`Available targets: ${Object.keys(targets2).join(", ")}`);
+      process.exit(1);
+    }
+    const outDir = resolve(process.cwd(), opts.out);
+    if (existsSync(outDir)) {
+      log.error(`Directory already exists: ${outDir}`);
+      log.dim("Remove it or choose a different output directory with --out.");
+      process.exit(1);
+    }
+    log.info(`Ejecting ${opts.target} code to: ${outDir}`);
+    try {
+      target.generate({ appName: opts.name, outDir });
+      log.success(`Ejected to ./${opts.out}/`);
+      if (opts.target === "node") {
+        log.dim("You can now customize and deploy your Node.js server.");
+        log.dim("");
+        log.dim("Next steps:");
+        log.dim(`  cd ${opts.out}`);
+        log.dim("  npm install");
+        log.dim("  npm run dev");
+        log.dim("");
+        log.dim("To run in production: npm start");
+      } else {
+        log.dim("You can now customize and deploy with `wrangler deploy`.");
+        log.dim("");
+        log.dim("Next steps:");
+        log.dim(`  cd ${opts.out}`);
+        log.dim("  npm install");
+        log.dim("  wrangler deploy");
+        log.dim("");
+        log.dim("Note: Running `offlinekit deploy` will warn that code has been ejected.");
+      }
+    } catch (err) {
+      log.error(`Eject failed: ${err instanceof Error ? err.message : String(err)}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/cli/index.ts
+var require2 = createRequire(import.meta.url);
+var pkg = require2("../../package.json");
+var program = new Command();
+program.name("offlinekit").description(pkg.description).version(pkg.version, "-v, --version", "Print the current version");
+registerDev(program);
+registerBuild(program);
+registerDeploy(program);
+registerEject(program);
+program.parse(process.argv);
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map