@everystack/cli 0.1.0

package/src/cli/utils/upload.ts

@@ -0,0 +1,52 @@
+export interface UploadPayload {
+  channel: string;
+  branch?: string;
+  groupId?: string;
+  runtimeVersion: string;
+  platform: string;
+  message: string;
+  metadata: Record<string, unknown>;
+  expoConfig?: Record<string, unknown>;
+  assets: Array<{
+    path: string;
+    data: string;
+    contentType: string;
+    fileExtension: string;
+    isLaunchAsset: boolean;
+  }>;
+  token?: string;
+}
+
+export interface UploadResult {
+  releaseId?: string;
+  groupId?: string;
+  branch?: string;
+  [key: string]: unknown;
+}
+
+export async function uploadToServer(url: string, payload: UploadPayload): Promise<UploadResult> {
+  const { token, ...body } = payload;
+
+  const headers: Record<string, string> = {
+    'content-type': 'application/json',
+  };
+  if (token) {
+    headers['authorization'] = `Bearer ${token}`;
+  }
+
+  const response = await fetch(url, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify(body),
+  });
+
+  if (!response.ok) {
+    const errorBody = await response.json().catch(() => ({}));
+    throw new Error(
+      `Publish failed for ${payload.platform}: ${(errorBody as any).error || response.status}`
+    );
+  }
+
+  const result = await response.json().catch(() => ({}));
+  return result as UploadResult;
+}

package/src/cli/utils/walk.ts

@@ -0,0 +1,59 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+export interface WalkedFile {
+  relativePath: string;
+  data: string; // base64-encoded
+  contentType: string;
+}
+
+const MIME_MAP: Record<string, string> = {
+  '.js': 'application/javascript',
+  '.mjs': 'application/javascript',
+  '.cjs': 'application/javascript',
+  '.json': 'application/json',
+  '.html': 'text/html',
+  '.css': 'text/css',
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif',
+  '.svg': 'image/svg+xml',
+  '.webp': 'image/webp',
+  '.ttf': 'font/ttf',
+  '.otf': 'font/otf',
+  '.woff': 'font/woff',
+  '.woff2': 'font/woff2',
+  '.map': 'application/json',
+};
+
+function mimeFromPath(filePath: string): string {
+  const ext = path.extname(filePath).toLowerCase();
+  return MIME_MAP[ext] || 'application/octet-stream';
+}
+
+export async function walkDirectory(dir: string): Promise<WalkedFile[]> {
+  const results: WalkedFile[] = [];
+  await walkRecursive(dir, dir, results);
+  return results;
+}
+
+async function walkRecursive(rootDir: string, currentDir: string, results: WalkedFile[]): Promise<void> {
+  const entries = await fs.readdir(currentDir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = path.join(currentDir, entry.name);
+
+    if (entry.isDirectory()) {
+      await walkRecursive(rootDir, fullPath, results);
+    } else if (entry.isFile()) {
+      const data = await fs.readFile(fullPath);
+      const relativePath = path.relative(rootDir, fullPath);
+      results.push({
+        relativePath,
+        data: data.toString('base64'),
+        contentType: mimeFromPath(fullPath),
+      });
+    }
+  }
+}

package/src/client/app-state-provider.tsx

@@ -0,0 +1,83 @@
+import React, { createContext, useCallback, useContext, useEffect, useRef } from 'react';
+
+export interface AppStateUpdateProviderProps {
+  children: React.ReactNode;
+  checkInterval?: number;
+  autoReload?: boolean;
+  onUpdateApplied?: () => void;
+  onError?: (error: Error) => void;
+}
+
+interface AppStateContextValue {
+  updateApp: () => Promise<void>;
+}
+
+const AppStateContext = createContext<AppStateContextValue | null>(null);
+
+export function AppStateUpdateProvider({
+  children,
+  checkInterval = 60000,
+  autoReload = true,
+  onUpdateApplied,
+  onError,
+}: AppStateUpdateProviderProps) {
+  const lastCheckRef = useRef<number>(0);
+
+  const updateApp = useCallback(async () => {
+    try {
+      const Updates = await import('expo-updates');
+      const result = await Updates.checkForUpdateAsync();
+
+      if (result.isAvailable) {
+        await Updates.fetchUpdateAsync();
+        if (autoReload) {
+          await Updates.reloadAsync();
+          onUpdateApplied?.();
+        }
+      }
+    } catch (err) {
+      const e = err instanceof Error ? err : new Error(String(err));
+      onError?.(e);
+    }
+  }, [autoReload, onUpdateApplied, onError]);
+
+  useEffect(() => {
+    let AppState: any;
+    let subscription: any;
+
+    (async () => {
+      try {
+        const RN = await import('react-native');
+        AppState = RN.AppState;
+
+        subscription = AppState.addEventListener('change', async (nextState: string) => {
+          if (nextState === 'active') {
+            const now = Date.now();
+            if (now - lastCheckRef.current >= checkInterval) {
+              lastCheckRef.current = now;
+              await updateApp();
+            }
+          }
+        });
+      } catch {
+        // react-native not available (SSR/web)
+      }
+    })();
+
+    return () => {
+      subscription?.remove?.();
+    };
+  }, [checkInterval, updateApp]);
+
+  return (
+    <AppStateContext.Provider value={{ updateApp }}>
+      {children}
+    </AppStateContext.Provider>
+  );
+}
+
+export function useAppState(): AppStateContextValue {
+  const ctx = useContext(AppStateContext);
+  if (!ctx) throw new Error('useAppState must be used within AppStateUpdateProvider');
+  return ctx;
+}

package/src/client/index.ts

@@ -0,0 +1,2 @@
+export { UpdatesProvider, useUpdates } from './updates-provider';
+export { AppStateUpdateProvider, useAppState } from './app-state-provider';

package/src/client/updates-provider.tsx

@@ -0,0 +1,69 @@
+import React, { createContext, useCallback, useContext, useState } from 'react';
+
+export interface UpdatesContextValue {
+  checkForUpdate: () => Promise<void>;
+  isChecking: boolean;
+  isDownloading: boolean;
+  availableUpdate: { id: string; createdAt: string } | null;
+  error: Error | null;
+}
+
+const UpdatesContext = createContext<UpdatesContextValue | null>(null);
+
+export interface UpdatesProviderProps {
+  children: React.ReactNode;
+  onUpdateAvailable?: (update: { id: string; createdAt: string }) => void;
+  onError?: (error: Error) => void;
+}
+
+export function UpdatesProvider({ children, onUpdateAvailable, onError }: UpdatesProviderProps) {
+  const [isChecking, setIsChecking] = useState(false);
+  const [isDownloading, setIsDownloading] = useState(false);
+  const [availableUpdate, setAvailableUpdate] = useState<{ id: string; createdAt: string } | null>(null);
+  const [error, setError] = useState<Error | null>(null);
+
+  const checkForUpdate = useCallback(async () => {
+    setIsChecking(true);
+    setError(null);
+
+    try {
+      const Updates = await import('expo-updates');
+      const result = await Updates.checkForUpdateAsync();
+
+      if (result.isAvailable) {
+        const manifest = result.manifest as any;
+        const update = { id: manifest?.id || '', createdAt: manifest?.createdAt || '' };
+        setAvailableUpdate(update);
+        onUpdateAvailable?.(update);
+
+        setIsDownloading(true);
+        await Updates.fetchUpdateAsync();
+        setIsDownloading(false);
+        await Updates.reloadAsync();
+      }
+    } catch (err) {
+      const e = err instanceof Error ? err : new Error(String(err));
+      setError(e);
+      onError?.(e);
+    } finally {
+      setIsChecking(false);
+      setIsDownloading(false);
+    }
+  }, [onUpdateAvailable, onError]);
+
+  const value: UpdatesContextValue = {
+    checkForUpdate,
+    isChecking,
+    isDownloading,
+    availableUpdate,
+    error,
+  };
+
+  return <UpdatesContext.Provider value={value}>{children}</UpdatesContext.Provider>;
+}
+
+export function useUpdates(): UpdatesContextValue {
+  const ctx = useContext(UpdatesContext);
+  if (!ctx) throw new Error('useUpdates must be used within UpdatesProvider');
+  return ctx;
+}

package/src/handler/assets.ts

@@ -0,0 +1,30 @@
+import type { UpdatesHandlerOptions } from './types';
+
+export async function handleAssets(request: Request, options: UpdatesHandlerOptions): Promise<Response> {
+  const url = new URL(request.url);
+  const key = url.searchParams.get('key');
+
+  if (!key) {
+    return new Response(JSON.stringify({ error: 'No asset key provided.' }), {
+      status: 400,
+      headers: { 'content-type': 'application/json' },
+    });
+  }
+
+  const result = await options.storage.get(key);
+
+  if (!result) {
+    return new Response(JSON.stringify({ error: `Asset "${key}" not found.` }), {
+      status: 404,
+      headers: { 'content-type': 'application/json' },
+    });
+  }
+
+  return new Response(new Uint8Array(result.data), {
+    status: 200,
+    headers: {
+      'content-type': result.contentType,
+      'cache-control': 'public, max-age=31536000, immutable',
+    },
+  });
+}

package/src/handler/branches.ts

@@ -0,0 +1,70 @@
+import type { UpdatesHandlerOptions } from './types';
+import { checkAuth, jsonError } from './helpers';
+
+export async function handleListBranches(request: Request, options: UpdatesHandlerOptions): Promise<Response> {
+  // List all keys under releases/ and extract unique branch names
+  const keys = await options.storage.list('releases/');
+  const branchNames = new Set<string>();
+
+  for (const key of keys) {
+    // Keys: releases/{branchName}/{runtimeVersion}/{groupId}/{platform}/...
+    const parts = key.split('/');
+    if (parts.length >= 2 && parts[1]) {
+      branchNames.add(parts[1]);
+    }
+  }
+
+  const branches = [...branchNames].sort().map(name => ({ name }));
+
+  return new Response(JSON.stringify({ branches }), {
+    status: 200,
+    headers: { 'content-type': 'application/json' },
+  });
+}
+
+export async function handleCreateBranch(request: Request, options: UpdatesHandlerOptions): Promise<Response> {
+  const authResult = await checkAuth(request, options);
+  if (authResult) return authResult;
+
+  let body: { name?: string };
+  try {
+    body = await request.json() as { name?: string };
+  } catch {
+    return jsonError(400, 'Invalid JSON body.');
+  }
+
+  if (!body.name) {
+    return jsonError(400, 'Missing name.');
+  }
+
+  // Check if branch already has releases in S3
+  const keys = await options.storage.list(`releases/${body.name}/`);
+  if (keys.length > 0) {
+    return jsonError(409, `Branch "${body.name}" already exists.`);
+  }
+
+  // Branches are virtual — return acknowledgment (materializes on first publish)
+  return new Response(JSON.stringify({
+    name: body.name,
+    createdAt: new Date().toISOString(),
+  }), {
+    status: 201,
+    headers: { 'content-type': 'application/json' },
+  });
+}
+
+export async function handleDeleteBranch(request: Request, options: UpdatesHandlerOptions, branchName: string): Promise<Response> {
+  const authResult = await checkAuth(request, options);
+  if (authResult) return authResult;
+
+  // Check S3 for releases under this branch
+  const keys = await options.storage.list(`releases/${branchName}/`);
+  if (keys.length > 0) {
+    return jsonError(409, `Branch "${branchName}" has releases. Delete releases first.`);
+  }
+
+  return new Response(JSON.stringify({ deleted: true }), {
+    status: 200,
+    headers: { 'content-type': 'application/json' },
+  });
+}

package/src/handler/channels-crud.ts

@@ -0,0 +1,174 @@
+import { eq, and } from 'drizzle-orm';
+import type { UpdatesHandlerOptions } from './types';
+import { opsItems } from '../schema';
+import {
+  checkAuth,
+  jsonError,
+  mirrorToDb,
+  updateChannelPointers,
+  type ChannelMetadata,
+} from './helpers';
+
+export async function handleListChannels(request: Request, options: UpdatesHandlerOptions): Promise<Response> {
+  // List channels from S3 _channels/ directory
+  const keys = await options.storage.list('_channels/');
+  const channels: ChannelMetadata[] = [];
+
+  for (const key of keys) {
+    if (!key.endsWith('.json')) continue;
+    try {
+      const result = await options.storage.get(key);
+      if (result) {
+        channels.push(JSON.parse(result.data.toString('utf8')));
+      }
+    } catch { /* skip malformed */ }
+  }
+
+  // Sort by createdAt descending
+  channels.sort((a, b) => (b.createdAt || '').localeCompare(a.createdAt || ''));
+
+  // Shape response for backward compatibility
+  const shaped = channels.map(ch => ({
+    name: ch.name,
+    type: 'release_channel',
+    status: ch.status,
+    data: { branchRef: ch.branchRef },
+    createdAt: ch.createdAt,
+    updatedAt: ch.updatedAt,
+  }));
+
+  return new Response(JSON.stringify({ channels: shaped }), {
+    status: 200,
+    headers: { 'content-type': 'application/json' },
+  });
+}
+
+export async function handleCreateChannel(request: Request, options: UpdatesHandlerOptions): Promise<Response> {
+  const authResult = await checkAuth(request, options);
+  if (authResult) return authResult;
+
+  let body: { name?: string; branchName?: string };
+  try {
+    body = await request.json() as { name?: string; branchName?: string };
+  } catch {
+    return jsonError(400, 'Invalid JSON body.');
+  }
+
+  if (!body.name) {
+    return jsonError(400, 'Missing name.');
+  }
+
+  // Check S3 for existing channel
+  const existingKey = `_channels/${body.name}.json`;
+  const exists = await options.storage.exists(existingKey);
+  if (exists) {
+    return jsonError(409, `Channel "${body.name}" already exists.`);
+  }
+
+  const branchRef = body.branchName || body.name;
+  const now = new Date().toISOString();
+
+  // Write to S3
+  const channelMeta: ChannelMetadata = {
+    name: body.name,
+    branchRef,
+    status: 'active',
+    createdAt: now,
+    updatedAt: now,
+  };
+  await options.storage.put(existingKey, Buffer.from(JSON.stringify(channelMeta)), 'application/json');
+
+  // Mirror to DB
+  await mirrorToDb(options.db, async () => {
+    await options.db
+      .insert(opsItems)
+      .values({
+        type: 'release_channel',
+        name: body.name,
+        status: 'active',
+        data: { branchRef },
+      })
+      .returning();
+  });
+
+  return new Response(JSON.stringify({
+    name: channelMeta.name,
+    type: 'release_channel',
+    status: channelMeta.status,
+    data: { branchRef },
+    createdAt: now,
+    updatedAt: now,
+  }), {
+    status: 201,
+    headers: { 'content-type': 'application/json' },
+  });
+}
+
+export async function handleEditChannel(request: Request, options: UpdatesHandlerOptions, channelName: string): Promise<Response> {
+  const authResult = await checkAuth(request, options);
+  if (authResult) return authResult;
+
+  let body: { branchName?: string };
+  try {
+    body = await request.json() as { branchName?: string };
+  } catch {
+    return jsonError(400, 'Invalid JSON body.');
+  }
+
+  if (!body.branchName) {
+    return jsonError(400, 'Missing branchName.');
+  }
+
+  // Read channel from S3
+  const key = `_channels/${channelName}.json`;
+  const result = await options.storage.get(key);
+  if (!result) {
+    return jsonError(404, `Channel "${channelName}" not found.`);
+  }
+
+  const channelMeta = JSON.parse(result.data.toString('utf8')) as ChannelMetadata;
+  channelMeta.branchRef = body.branchName;
+  channelMeta.updatedAt = new Date().toISOString();
+
+  // Write back to S3
+  await options.storage.put(key, Buffer.from(JSON.stringify(channelMeta)), 'application/json');
+
+  // Regenerate channel pointers for the new branch
+  await updateChannelPointers(options.storage, channelName, body.branchName);
+
+  // Mirror to DB
+  await mirrorToDb(options.db, async () => {
+    const [channel] = await options.db
+      .select()
+      .from(opsItems)
+      .where(and(
+        eq(opsItems.type, 'release_channel'),
+        eq(opsItems.name, channelName),
+      ))
+      .limit(1);
+
+    if (channel) {
+      const existingData = (channel.data as Record<string, unknown>) || {};
+      await options.db
+        .update(opsItems)
+        .set({
+          data: { ...existingData, branchRef: body.branchName },
+          updatedAt: new Date(),
+        })
+        .where(eq(opsItems.id, channel.id))
+        .returning();
+    }
+  });
+
+  return new Response(JSON.stringify({
+    name: channelMeta.name,
+    type: 'release_channel',
+    status: channelMeta.status,
+    data: { branchRef: channelMeta.branchRef },
+    createdAt: channelMeta.createdAt,
+    updatedAt: channelMeta.updatedAt,
+  }), {
+    status: 200,
+    headers: { 'content-type': 'application/json' },
+  });
+}