@everystack/cli 0.1.0 → 0.2.0

package/src/plugin.ts

@@ -0,0 +1,123 @@
+/**
+ * @everystack/cli/plugin — OTA updates handler + CLI actions as a composable plugin.
+ *
+ * Registers the updates manifest/asset endpoint for Expo OTA updates,
+ * plus CLI actions for registering builds and managing channels.
+ *
+ * Note: Types are inlined to avoid circular dependency with @everystack/server.
+ */
+
+import type { StorageAdapter } from './storage/index';
+
+/** Minimal plugin context (compatible with @everystack/server/plugin PluginContext) */
+interface PluginContext {
+  db: any;
+  schema: Record<string, any>;
+  verifyToken: (token: string) => Promise<Record<string, unknown> | null>;
+  environment: string;
+  publishJob: (type: string, payload: unknown) => Promise<string>;
+  [key: string]: unknown;
+}
+
+/** Minimal route type (compatible with @everystack/server Route) */
+interface Route {
+  path: string;
+  method?: string;
+  exact?: boolean;
+  handler: (req: Request) => Promise<Response>;
+}
+
+/** Action handler type (compatible with @everystack/server/plugin ActionHandler) */
+type ActionHandler = (payload: unknown, ctx: PluginContext) => Promise<unknown>;
+
+/** Plugin factory function */
+type Plugin = (ctx: PluginContext) => Promise<{
+  routes?: Route[];
+  actions?: Record<string, ActionHandler>;
+}>;
+
+export interface UpdatesPluginOptions {
+  /** Base URL for update asset downloads (e.g., CDN_URL or SITE_URL) */
+  baseUrl?: string;
+  /** Base path for updates routes (default: '/api/updates') */
+  basePath?: string;
+  /** Ed25519 private key for signing manifests */
+  privateKey?: string;
+  /** Default channel name (default: 'production') */
+  defaultChannel?: string;
+}
+
+interface UpdatesContext extends PluginContext {
+  updatesStorage: StorageAdapter;
+  clientBundlesStorage?: StorageAdapter;
+}
+
+export function updatesPlugin(options: UpdatesPluginOptions = {}): Plugin {
+  const basePath = options.basePath ?? '/api/updates';
+
+  return async (ctx) => {
+    const {
+      createUpdatesHandler,
+      handleRegisterWeb,
+      registerMobileRelease,
+      handleListChannels,
+      handleCreateChannel,
+    } = await import('./handler/index');
+    const appCtx = ctx as UpdatesContext;
+
+    const handlerOptions = {
+      db: ctx.db,
+      storage: appCtx.updatesStorage,
+      baseUrl: options.baseUrl ?? process.env.CDN_URL ?? process.env.SITE_URL ?? 'http://localhost:8081',
+      basePath,
+      auth: { verifyToken: ctx.verifyToken },
+      privateKey: options.privateKey ?? process.env.UPDATES_PRIVATE_KEY,
+      defaultChannel: options.defaultChannel ?? 'production',
+      clientBundlesStorage: appCtx.clientBundlesStorage,
+    };
+
+    const handler = createUpdatesHandler(handlerOptions);
+
+    return {
+      routes: [{ path: basePath, handler }],
+      actions: {
+        'register-web': async (payload) => {
+          const req = new Request('http://internal/register-web', {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify(payload),
+          });
+          const res = await handleRegisterWeb(req, handlerOptions);
+          const body = await res.json().catch(() => ({}));
+          if (!res.ok) return { error: (body as any).error || `register-web failed (${res.status})` };
+          return body;
+        },
+        'register-mobile': async (payload) => {
+          try {
+            return await registerMobileRelease(handlerOptions, payload as any);
+          } catch (err: any) {
+            return { error: err?.message || 'register-mobile failed' };
+          }
+        },
+        'channels-list': async () => {
+          const req = new Request('http://internal/channels', { method: 'GET' });
+          const res = await handleListChannels(req, handlerOptions);
+          const body = await res.json().catch(() => ({}));
+          if (!res.ok) return { error: (body as any).error || `channels-list failed (${res.status})` };
+          return body;
+        },
+        'channels-create': async (payload) => {
+          const req = new Request('http://internal/channels', {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify(payload),
+          });
+          const res = await handleCreateChannel(req, handlerOptions);
+          const body = await res.json().catch(() => ({}));
+          if (!res.ok) return { error: (body as any).error || `channels-create failed (${res.status})` };
+          return body;
+        },
+      },
+    };
+  };
+}

package/src/storage/index.ts

@@ -14,12 +14,12 @@ export type StorageOptions =
   | { type: 'filesystem'; directory: string }
   | { type: 's3'; bucket: string; region?: string; endpoint?: string };
 
-export function createStorage(options: StorageOptions): StorageAdapter {
+export async function createStorage(options: StorageOptions): Promise<StorageAdapter> {
   if (options.type === 'filesystem') {
-    const { FilesystemStorageAdapter } = require('./filesystem') as typeof import('./filesystem');
+    const { FilesystemStorageAdapter } = await import('./filesystem');
     return new FilesystemStorageAdapter(options.directory);
   }
-  const { S3StorageAdapter } = require('./s3') as typeof import('./s3');
+  const { S3StorageAdapter } = await import('./s3');
   return new S3StorageAdapter(options.bucket, options.region, options.endpoint);
 }