@usesidekick/react 0.1.0

package/src/runtime-loader.ts

@@ -0,0 +1,106 @@
+import React from 'react';
+import { transform } from 'sucrase';
+import { createOverride } from './loader';
+import { SDK } from './types';
+
+interface OverrideData {
+  id: string;
+  name: string;
+  description: string;
+  code: string;
+  enabled: boolean;
+}
+
+interface LoadedOverride {
+  id: string;
+  name: string;
+  description: string;
+  enabled: boolean;
+  activate: (sdk: SDK) => void;
+}
+
+export function compileOverride(overrideData: OverrideData): LoadedOverride | null {
+  try {
+    // Transform TypeScript/JSX to plain JavaScript
+    const transformed = transform(overrideData.code, {
+      transforms: ['typescript', 'jsx'],
+      jsxRuntime: 'classic',
+    });
+
+    // Create a module-like environment
+    const exports: { default?: ReturnType<typeof createOverride> } = {};
+    const require = (moduleName: string) => {
+      if (moduleName === 'react') return React;
+      if (moduleName === '@usesidekick/react') {
+        return { createOverride, SDK: {} };
+      }
+      throw new Error(`Module not found: ${moduleName}`);
+    };
+
+    // Execute the transformed code
+    // Prepend destructuring of common React exports so overrides can use
+    // bare names like useState, useEffect, etc. instead of React.useState
+    const reactDestructure = 'var { useState, useEffect, useCallback, useMemo, useRef, useContext, useReducer, memo, forwardRef, createContext, Fragment } = React;\n';
+    const moduleFunction = new Function(
+      'exports',
+      'require',
+      'React',
+      'createOverride',
+      reactDestructure + transformed.code.replace(
+        /import\s+.*?from\s+['"].*?['"]/g,
+        '' // Remove import statements, we inject dependencies
+      ).replace(
+        /export\s+default\s+/,
+        'exports.default = '
+      )
+    );
+
+    moduleFunction(exports, require, React, createOverride);
+
+    if (!exports.default) {
+      console.error(`[Sidekick] Override ${overrideData.id} has no default export`);
+      return null;
+    }
+
+    return {
+      id: overrideData.id,
+      name: overrideData.name,
+      description: overrideData.description,
+      enabled: overrideData.enabled,
+      activate: exports.default.activate,
+    };
+  } catch (error) {
+    console.error(`[Sidekick] Failed to compile override ${overrideData.id}:`, error);
+    return null;
+  }
+}
+
+export async function fetchAndCompileOverrides(
+  endpoint: string
+): Promise<LoadedOverride[]> {
+  try {
+    const response = await fetch(endpoint);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch overrides: ${response.status}`);
+    }
+
+    const data = await response.json();
+    if (!data.success || !Array.isArray(data.overrides)) {
+      throw new Error('Invalid response format');
+    }
+
+    const compiled: LoadedOverride[] = [];
+    for (const override of data.overrides) {
+      // Compile all overrides (enabled or not) so they appear in the list
+      const loaded = compileOverride(override);
+      if (loaded) {
+        compiled.push(loaded);
+      }
+    }
+
+    return compiled;
+  } catch (error) {
+    console.error('[Sidekick] Failed to fetch overrides:', error);
+    return [];
+  }
+}

package/src/server/drizzle-adapter.ts

@@ -0,0 +1,53 @@
+import { eq } from 'drizzle-orm';
+import type { SidekickStorage, OverrideRecord, NewOverrideRecord } from './types';
+import type { sidekickOverrides as OverridesTable } from './drizzle-schema';
+
+type DrizzleDb = {
+  select(): any;
+  insert(table: any): any;
+  update(table: any): any;
+  delete(table: any): any;
+};
+
+export function createDrizzleStorage(
+  db: DrizzleDb,
+  overridesTable: typeof OverridesTable
+): SidekickStorage {
+  return {
+    async listOverrides(): Promise<OverrideRecord[]> {
+      const rows = await db.select().from(overridesTable).orderBy(overridesTable.createdAt);
+      return rows as OverrideRecord[];
+    },
+
+    async getOverride(id: string): Promise<OverrideRecord | null> {
+      const rows = await db.select().from(overridesTable).where(eq(overridesTable.id, id));
+      return (rows[0] as OverrideRecord) ?? null;
+    },
+
+    async createOverride(data: NewOverrideRecord): Promise<void> {
+      await db.insert(overridesTable).values({
+        id: data.id,
+        name: data.name,
+        description: data.description,
+        version: data.version,
+        primitives: data.primitives,
+        code: data.code,
+        enabled: data.enabled ?? true,
+        createdAt: data.createdAt ?? new Date(),
+        updatedAt: data.updatedAt ?? new Date(),
+      });
+    },
+
+    async updateOverride(id: string, data: Partial<OverrideRecord>): Promise<void> {
+      // Strip id and createdAt to prevent accidental PK/immutable field updates
+      const { id: _id, createdAt: _ca, ...updateData } = data;
+      await db.update(overridesTable)
+        .set({ ...updateData, updatedAt: new Date() })
+        .where(eq(overridesTable.id, id));
+    },
+
+    async deleteOverride(id: string): Promise<void> {
+      await db.delete(overridesTable).where(eq(overridesTable.id, id));
+    },
+  };
+}

package/src/server/drizzle-schema.ts

@@ -0,0 +1,16 @@
+import { pgTable, text, timestamp, boolean } from 'drizzle-orm/pg-core';
+
+export const sidekickOverrides = pgTable('overrides', {
+  id: text('id').primaryKey(),
+  name: text('name').notNull(),
+  description: text('description').notNull(),
+  version: text('version').notNull().default('1.0.0'),
+  primitives: text('primitives').notNull(), // JSON array stored as text
+  code: text('code').notNull(),
+  enabled: boolean('enabled').notNull().default(true),
+  createdAt: timestamp('created_at').defaultNow().notNull(),
+  updatedAt: timestamp('updated_at').defaultNow().notNull(),
+});
+
+export type SidekickOverride = typeof sidekickOverrides.$inferSelect;
+export type NewSidekickOverride = typeof sidekickOverrides.$inferInsert;