@codeyam/codeyam-cli 0.1.0-staging.596f0eb → 0.1.0-staging.6e699e5

package/analyzer-template/packages/aws/src/lib/ecs/ecsDefineContainer.ts

@@ -5,18 +5,19 @@ export default function ecsDefineContainer({
   containerImage,
   environmentVariables = {},
   openPort,
-  dependsOn,
+  command,
 }: {
   containerName: string;
   containerImage: string;
   environmentVariables?: { [key: string]: string };
   openPort?: number;
-  dependsOn?: ContainerDefinition['dependsOn'];
+  command?: string[];
 }): ContainerDefinition {
   return {
     name: containerName,
     image: containerImage,
     essential: true,
+    command,
     environment: Object.entries(environmentVariables).map(([name, value]) => ({
       name,
       value,
@@ -38,6 +39,5 @@ export default function ecsDefineContainer({
         'awslogs-stream-prefix': `${process.env.ECS_CLUSTER_NAME}`,
       },
     },
-    dependsOn,
   };
 }

package/analyzer-template/packages/aws/src/lib/ecs/ecsTaskFactory.ts

@@ -5,51 +5,22 @@ export type EcsStartConfig = {
 };
 
 /**
- * Prepare to run an ECS task for the classical analysis-then-capture flow
- * which uses a 'project' image for analysis and a 'playwright' image for capture.
+ * Prepare to run an ECS task for analysis with distributed capture orchestration.
+ * Uses the unified 'combo' image which includes both analysis and capture capabilities.
  */
-export function getEcsStartConfigForAnalysisThenCapture(
-  projectEnvironmentVariables: Record<string, string>,
-  playwrightEnvironmentVariables: Record<string, string>,
-): EcsStartConfig {
-  return {
-    taskDefinition: getEcsTaskDefinitionName(
-      EcsTaskDefinitionUse.AnalyzeThenCapture,
-    ),
-    containerEnvironmentVariables: [
-      [
-        getEcsImageNameForType(EcsImageType.Project),
-        projectEnvironmentVariables,
-      ],
-      [
-        getEcsImageNameForType(EcsImageType.Playwright),
-        playwrightEnvironmentVariables,
-      ],
-    ],
-  };
-}
-
-/**
- * Prepare to run an ECS task for the new analysis flow with distributed capture
- * tasks orchestrated from only a 'project' image.
- */
-export function getEcsStartConfigFoAnalysisWithOrchestration(
+export function getEcsStartConfigForAnalysis(
   environmentVariables: Record<string, string>,
 ): EcsStartConfig {
   return {
-    taskDefinition: getEcsTaskDefinitionName(
-      EcsTaskDefinitionUse.AnalyzeWithOrchestration,
-    ),
-    containerEnvironmentVariables: [
-      [getEcsImageNameForType(EcsImageType.Project), environmentVariables],
-    ],
+    taskDefinition: getEcsTaskDefinitionName(EcsTaskDefinitionUse.Analysis),
+    containerEnvironmentVariables: [[getEcsImageName(), environmentVariables]],
   };
 }
 
 /**
  * Prepare to run an ECS worker task that implements the capture portion of the
- * distributed orchestration, which uses a 'combo' image. This task is launched
- * from a task created with `getEcsStartConfigFoAnalysisWithOrchestration()`
+ * distributed orchestration. Uses the same unified 'combo' image.
+ * This task is launched from a task created with `getEcsStartConfigForAnalysis()`
  */
 export function getEcsStartConfigForOrchestrationTask(
   environmentVariables: Record<string, string>,
@@ -58,52 +29,29 @@ export function getEcsStartConfigForOrchestrationTask(
     taskDefinition: getEcsTaskDefinitionName(
       EcsTaskDefinitionUse.OrchestrationTask,
     ),
-    containerEnvironmentVariables: [
-      [getEcsImageNameForType(EcsImageType.Combo), environmentVariables],
-    ],
+    containerEnvironmentVariables: [[getEcsImageName(), environmentVariables]],
   };
 }
 
 export enum EcsTaskDefinitionUse {
-  /* A 'project' image runs analysis while a 'playwright' image captures the entities. */
-  AnalyzeThenCapture = 'analyze-then-capture',
-  /* A 'project' image runs analysis while firing up distributed capture orchestration. */
-  AnalyzeWithOrchestration = 'analyze-with-orchestration',
-  /* A worker task that combines 'project' and 'playwright' code, launched by orchestration. */
+  /* Main analysis task - runs analysis and fires up distributed capture orchestration. */
+  Analysis = 'analysis',
+  /* A worker task launched by orchestration to capture scenarios. */
   OrchestrationTask = 'orchestration-task',
 }
 
 export function getEcsTaskDefinitionName(forUse: EcsTaskDefinitionUse): string {
   switch (forUse) {
-    case EcsTaskDefinitionUse.AnalyzeThenCapture:
-      return `${process.env.ECR_REPOSITORY_NAME}-project-and-playwright`;
-    case EcsTaskDefinitionUse.AnalyzeWithOrchestration:
-      return `${process.env.ECR_REPOSITORY_NAME}-project`;
+    case EcsTaskDefinitionUse.Analysis:
+      return `${process.env.ECR_REPOSITORY_NAME}-analysis`;
     case EcsTaskDefinitionUse.OrchestrationTask:
-      return `${process.env.ECR_REPOSITORY_NAME}-combo`;
+      return `${process.env.ECR_REPOSITORY_NAME}-orchestration`;
     default:
       throw new Error(`Unknown task definition use: ${forUse}`);
   }
 }
 
-export enum EcsImageType {
-  /* The virtualized server that runs the project code. */
-  Project = 'project',
-  /* The playwright capture process which waits for the project to be ready. */
-  Playwright = 'playwright',
-  /* A combo image that combines both project and playwright code, used by orchestration. */
-  Combo = 'combo',
-}
-
-export function getEcsImageNameForType(type: EcsImageType): string {
-  switch (type) {
-    case EcsImageType.Project:
-      return `${process.env.ECR_REPOSITORY_NAME}-project`;
-    case EcsImageType.Playwright:
-      return `${process.env.ECR_REPOSITORY_NAME}-playwright`;
-    case EcsImageType.Combo:
-      return `${process.env.ECR_REPOSITORY_NAME}-combo`;
-    default:
-      throw new Error(`Unknown image type: ${type}`);
-  }
+/** Returns the name of the unified Docker image used for all ECS tasks. */
+export function getEcsImageName(): string {
+  return `${process.env.ECR_REPOSITORY_NAME}-combo`;
 }

package/analyzer-template/packages/aws/src/lib/s3/checkS3ObjectExists.ts

@@ -0,0 +1,47 @@
+import { S3Client, HeadObjectCommand } from '@aws-sdk/client-s3';
+
+interface CheckS3ObjectExistsArgs {
+  bucketName: string;
+  key: string;
+}
+
+interface CheckS3ObjectExistsResult {
+  exists: boolean;
+  size?: number;
+}
+
+/**
+ * Check if an object exists in S3 using a HEAD request.
+ * Returns the object size if it exists.
+ */
+export default async function checkS3ObjectExists({
+  bucketName,
+  key,
+}: CheckS3ObjectExistsArgs): Promise<CheckS3ObjectExistsResult> {
+  const s3Client = new S3Client({});
+
+  const command = new HeadObjectCommand({
+    Bucket: bucketName,
+    Key: key,
+  });
+
+  try {
+    const response = await s3Client.send(command);
+    return {
+      exists: true,
+      size: response.ContentLength,
+    };
+  } catch (error: unknown) {
+    // NotFound is expected when object doesn't exist
+    if (
+      error &&
+      typeof error === 'object' &&
+      'name' in error &&
+      error.name === 'NotFound'
+    ) {
+      return { exists: false };
+    }
+    // Re-throw unexpected errors
+    throw error;
+  }
+}

package/analyzer-template/packages/aws/src/lib/s3/uploadFileToS3.ts

@@ -24,11 +24,18 @@ export default async function uploadFileToS3({
   });
 
   try {
+    let lastLoggedMB = 0;
     upload.on('httpUploadProgress', (progress) => {
-      console.log(progress);
+      const loadedMB = Math.floor((progress.loaded ?? 0) / (1024 * 1024));
+      // Log every 10MB to avoid spam
+      if (loadedMB >= lastLoggedMB + 10) {
+        lastLoggedMB = loadedMB;
+        console.log(`Uploading ${key}... ${loadedMB}MB`);
+      }
     });
 
     await upload.done();
+    console.log(`Uploaded ${key}`);
   } catch (error) {
     console.log('Error. File not uploaded.', error);
     throw error;

package/analyzer-template/packages/database/src/lib/kysely/db.ts

@@ -33,8 +33,8 @@ import {
 } from './tables/commitBranchesTable';
 import { CommitsTable, createCommitsTable } from './tables/commitsTable';
 import {
-  createDebugReportsTable,
-  DebugReportsTable,
+  createDebugBundlesTable,
+  DebugBundlesTable,
 } from './tables/debugReportsTable';
 import { createEntitiesTable, EntitiesTable } from './tables/entitiesTable';
 import {
@@ -101,7 +101,7 @@ const databaseSchema = {
   branches: schemaField<BranchesTable>(),
   commit_branches: schemaField<CommitBranchesTable>(),
   commits: schemaField<CommitsTable>(),
-  debug_reports: schemaField<DebugReportsTable>(),
+  debug_reports: schemaField<DebugBundlesTable>(),
   entities: schemaField<EntitiesTable>(),
   entity_branches: schemaField<EntityBranchesTable>(),
   entity_statements: schemaField<EntityStatementsTable>(),
@@ -377,7 +377,7 @@ export async function createSqliteSchema(db: Kysely<Database>): Promise<void> {
   await createBranchesTable(db);
   await createCommitBranchesTable(db);
   await createCommitsTable(db);
-  await createDebugReportsTable(db);
+  await createDebugBundlesTable(db);
   await createEntitiesTable(db);
   await createEntityBranchesTable(db);
   await createEntityStatementsTable(db);

package/analyzer-template/packages/database/src/lib/kysely/tableRelations.ts

@@ -6,7 +6,7 @@ import { BackgroundJobsTable } from './tables/backgroundJobsTable';
 import { BranchesTable } from './tables/branchesTable';
 import { CommitsTable } from './tables/commitsTable';
 import { CommitBranchesTable } from './tables/commitBranchesTable';
-import { DebugReportsTable } from './tables/debugReportsTable';
+import { DebugBundlesTable } from './tables/debugReportsTable';
 import { EntitiesTable } from './tables/entitiesTable';
 import { EntityBranchesTable } from './tables/entityBranchesTable';
 import { FilesTable } from './tables/filesTable';
@@ -105,4 +105,4 @@ export type DbUserScenario = Selectable<UserScenariosTable> & {
 
 export type DbStatement = Selectable<StatementsTable>;
 
-export type DbDebugReport = Selectable<DebugReportsTable>;
+export type DbDebugBundle = Selectable<DebugBundlesTable>;

package/analyzer-template/packages/database/src/lib/kysely/tables/debugReportsTable.ts

@@ -3,7 +3,12 @@ import type { Generated, JSONColumnType } from 'kysely';
 
 import { schemaField, defaultNow } from '../schemaHelpers';
 
-interface DebugReportMetadata {
+/**
+ * Metadata for a debug bundle upload.
+ * Note: "bundle" refers to the tarball upload (base + delta).
+ * The markdown "debug report" from /codeyam:diagnose is stored in feedback.debugReport.
+ */
+interface DebugBundleMetadata {
   timestamp: string;
   git: {
     sha: string;
@@ -20,28 +25,48 @@ interface DebugReportMetadata {
     platform: string;
     arch: string;
   };
+  feedback?: {
+    source: string;
+    issueType?: string;
+    description?: string;
+    email?: string;
+    entitySha?: string;
+    scenarioId?: string;
+    analysisId?: string;
+    currentUrl?: string;
+    recentActivity?: string[];
+    debugReport?: string;
+    entityName?: string;
+    entityType?: string;
+    scenarioName?: string;
+    errorMessage?: string;
+  };
 }
 
-const debugReportsSchema = {
+// Table name remains 'debug_reports' in the database for backwards compatibility
+const debugBundlesSchema = {
   id: schemaField<Generated<string>>(),
   project_slug: schemaField<string>(),
   s3_key: schemaField<string>(),
   file_size_bytes: schemaField<number | null>(),
-  metadata: schemaField<JSONColumnType<DebugReportMetadata> | null>(),
+  metadata: schemaField<JSONColumnType<DebugBundleMetadata> | null>(),
   status: schemaField<string | null>(),
   created_at: schemaField<Generated<string>>(),
   uploaded_at: schemaField<string | null>(),
+  base_sha: schemaField<string | null>(),
+  delta_size_bytes: schemaField<number | null>(),
 } as const;
 
-export type DebugReportsTable = {
-  [K in keyof typeof debugReportsSchema]: (typeof debugReportsSchema)[K];
+export type DebugBundlesTable = {
+  [K in keyof typeof debugBundlesSchema]: (typeof debugBundlesSchema)[K];
 };
 
-export const DebugReportsTableColumns = Object.keys(
-  debugReportsSchema,
-) as (keyof DebugReportsTable)[];
+export const DebugBundlesTableColumns = Object.keys(
+  debugBundlesSchema,
+) as (keyof DebugBundlesTable)[];
 
-export async function createDebugReportsTable(db: Kysely<any>): Promise<void> {
+export async function createDebugBundlesTable(db: Kysely<any>): Promise<void> {
+  // Table name remains 'debug_reports' for backwards compatibility
   await db.schema
     .createTable('debug_reports')
     .addColumn('id', 'uuid', (col: ColumnDefinitionBuilder) => col.primaryKey())
@@ -56,6 +81,8 @@ export async function createDebugReportsTable(db: Kysely<any>): Promise<void> {
     .addColumn('status', 'varchar')
     .addColumn('created_at', 'datetime', defaultNow(true))
     .addColumn('uploaded_at', 'datetime')
+    .addColumn('base_sha', 'varchar')
+    .addColumn('delta_size_bytes', 'bigint')
     .ifNotExists()
     .execute();
 }

package/analyzer-template/packages/database/src/lib/loadReadyToBeCapturedAnalyses.ts

@@ -40,15 +40,19 @@ export default async function loadReadyToBeCapturedAnalyses(
           .whereRef('scenarios.analysis_id', '=', 'analyses.id'),
       ).as('scenarios'),
     ])
+    // Cross-database compatible: use -> (not ->>) for boolean JSON fields
+    // PostgreSQL: jsonb `true` auto-casts to string 'true' for comparison
+    // SQLite: -> returns text 'true' which equals string 'true'
+    // (Note: ->> returns integer 1 in SQLite for booleans, breaking string comparisons)
     .where(
-      // Use ->> to extract as text for proper comparison (-> returns JSONB which doesn't compare to string)
-      sql<string>` ${sql.ref('analyses.status')} ->> 'readyToBeCaptured'`,
+      sql<string>`${sql.ref('analyses.status')} -> 'readyToBeCaptured'`,
       '=',
       'true',
     )
     // Exclude entities that are not exported - they cannot be captured because they can't be imported
+    // Use -> operator for cross-database boolean comparison
     .where(
-      sql<boolean>`(${sql.ref('entities.metadata')} ->> 'notExported') IS NULL OR (${sql.ref('entities.metadata')} ->> 'notExported') != 'true'`,
+      sql<boolean>`(${sql.ref('entities.metadata')} -> 'notExported') IS NULL OR (${sql.ref('entities.metadata')} -> 'notExported') != 'true'`,
     );
 
   if (projectId) {

package/analyzer-template/packages/generate/index.ts

@@ -1,6 +1,8 @@
 export { default as getComponentImportStatements } from './src/lib/getComponentImportStatements';
 export { default as componentScenarioPageRemix } from './src/lib/componentScenarioPage/componentScenarioPageRemix';
 export { default as componentScenarioPageNext } from './src/lib/componentScenarioPage/componentScenarioPageNext';
+export { default as generateScenarioServerComponent } from './src/lib/componentScenarioPage/generateScenarioServerComponent';
+export { default as generateScenarioClientWrapper } from './src/lib/componentScenarioPage/generateScenarioClientWrapper';
 export { default as getComponentScenarioPath } from './src/lib/getComponentScenarioPath';
 export { default as libDemoComponent } from './src/lib/libDemoComponent';
 export { default as directExecutionScript } from './src/lib/directExecutionScript';
@@ -9,4 +11,5 @@ export { default as safeFolder } from './src/lib/safeFolder';
 export { default as deepMerge } from './src/lib/deepMerge';
 export { default as simpleRootRemix } from './src/lib/simpleRootRemix';
 export { default as mergeRootRemix } from './src/lib/mergeRootRemix';
+export { default as scenarioComponentForServer } from './src/lib/scenarioComponentForServer';
 export { PLACEHOLDER_IMAGE_SRC } from './src/lib/constants';

package/analyzer-template/packages/generate/src/lib/componentScenarioPage/componentScenarioPageNext.ts

@@ -6,6 +6,7 @@ import escapeQuotes from '../escapeQuotes';
 import getIFrameMessageListenerCode from './getIFrameMessageListenerCode';
 import getImageReplacementCode from './getImageReplacementCode';
 import getNextJsErrorClosingCode from './getNextJsErrorClosingCode';
+import generateScenarioServerComponent from './generateScenarioServerComponent';
 
 const VERSION = '0.5.1';
 
@@ -28,6 +29,21 @@ export default function componentScenarioPageNext({
 }) {
   const fileName = file.name.split('.')[0];
 
+  // For async components (Server Components), generate a Server Component page
+  // that uses a separate client wrapper for interactive features
+  if (entity.metadata?.isAsync) {
+    return generateScenarioServerComponent({
+      file,
+      entity,
+      analysis,
+      currentPath,
+      appPath,
+      scenario,
+      relativeMocksDir,
+    });
+  }
+
+  // For non-async components, use the existing client component approach
   return `/* eslint-disable */
   "use client";
   import {
@@ -58,7 +74,7 @@ ${getComponentImportStatement({
 ${getImageReplacementCode()}
 
 function Scenario({ name, width, height, children }: { name: string, width: string, height: string, children: ReactNode }) {
-  
+
   useEffect(() => {
     if (typeof window === 'undefined') return;
 

package/analyzer-template/packages/generate/src/lib/componentScenarioPage/generateScenarioClientWrapper.ts

@@ -0,0 +1,193 @@
+import type { Scenario } from '~codeyam/types';
+import { safeFileName } from '~codeyam/utils';
+import getImageReplacementCode from './getImageReplacementCode';
+import getNextJsErrorClosingCode from './getNextJsErrorClosingCode';
+
+/**
+ * Generates the ScenarioClientWrapper component code.
+ * This is a Client Component that handles all the interactive features
+ * (iframe messaging, console interception, error closing, etc.)
+ * while allowing the actual page to be a Server Component.
+ */
+export default function generateScenarioClientWrapper(
+  scenario: Scenario,
+): string {
+  const safeScenarioName = safeFileName(scenario.name);
+
+  return `"use client";
+/* eslint-disable */
+// ScenarioClientWrapper - Client Component for interactive features
+// This wraps Server Components to add client-side interactivity
+
+import {
+  useCallback,
+  useEffect,
+  useState,
+  type ReactNode,
+} from 'react';
+import { scenarios } from "./MockData_${safeScenarioName}";
+
+// Inject image interception code at module level
+${getImageReplacementCode()}
+
+interface ScenarioClientWrapperProps {
+  scenarioName: string;
+  fileName: string;
+  version: string;
+  children: ReactNode;
+}
+
+export function ScenarioClientWrapper({
+  scenarioName,
+  fileName,
+  version,
+  children,
+}: ScenarioClientWrapperProps) {
+  const [internalVersion, setInternalVersion] = useState(1);
+  const [searchParams] = useState(() =>
+    typeof window !== 'undefined'
+      ? new URLSearchParams(window.location.search)
+      : new URLSearchParams()
+  );
+  const widthOverride = searchParams.get('width');
+  const heightOverride = searchParams.get('height') || 'auto';
+
+  // Set page metadata
+  useEffect(() => {
+    document.title = \`\${fileName}: \${scenarioName} CodeYam Demo v\${version}\`;
+    let metaDesc = document.querySelector('meta[name="description"]');
+    if (!metaDesc) {
+      metaDesc = document.createElement('meta');
+      metaDesc.setAttribute('name', 'description');
+      document.head.appendChild(metaDesc);
+    }
+    metaDesc.setAttribute('content', \`This is a demo of the \${fileName} component\`);
+  }, [fileName, scenarioName, version]);
+
+  // Message posting helper
+  const respond = useCallback((message: any) => {
+    try {
+      window.parent.postMessage({
+        type: 'codeyam-update',
+        name: scenarioName,
+        message,
+      }, '*');
+    } catch (e) {
+      console.warn('Error posting message to parent', message, e);
+    }
+  }, [scenarioName]);
+
+  // Handle data override messages from parent
+  useEffect(() => {
+    const eventListener = (event: MessageEvent) => {
+      if (event.data.type === 'codeyam-override-data') {
+        const parsedData = JSON.parse(event.data.data);
+        console.log("Override data received");
+        respond("Set override data to " + JSON.stringify(parsedData, null, 2));
+        scenarios().updateData(scenarioName, parsedData);
+        setInternalVersion(prev => prev + 1);
+      }
+    };
+    window.addEventListener('message', eventListener);
+    return () => window.removeEventListener('message', eventListener);
+  }, [respond, scenarioName]);
+
+  // Console interception
+  useEffect(() => {
+    const oldConsoleLog = console.log;
+    console.log = function(...args: any[]) {
+      oldConsoleLog(...args);
+      try {
+        window.parent.postMessage({
+          type: 'codeyam-log',
+          name: scenarioName,
+          data: {
+            log: {
+              name: "console.log",
+              args
+            }
+          }
+        }, '*');
+      } catch (e) {
+        oldConsoleLog('Error posting message to parent', e);
+      }
+    };
+
+    const oldConsoleError = console.error;
+    console.error = function(...args: any[]) {
+      oldConsoleError(...args);
+      window.parent.postMessage({
+        type: 'codeyam-log',
+        name: scenarioName,
+        data: {
+          log: {
+            name: "console.error",
+            args
+          }
+        }
+      }, '*');
+    };
+
+    return () => {
+      console.log = oldConsoleLog;
+      console.error = oldConsoleError;
+    };
+  }, [scenarioName]);
+
+  // Next.js error closing
+  ${getNextJsErrorClosingCode()}
+
+  // Height calculation and resize messaging
+  useEffect(() => {
+    if (typeof window === 'undefined') return;
+
+    const calculateHeight = () => {
+      const bodyHeight = document.body.offsetHeight;
+      const htmlHeight = document.documentElement.offsetHeight;
+      const scrollHeight = Math.max(
+        document.body.scrollHeight,
+        document.documentElement.scrollHeight,
+        document.body.offsetHeight,
+        document.documentElement.offsetHeight,
+        document.body.clientHeight,
+        document.documentElement.clientHeight
+      );
+      return Math.max(100, bodyHeight, htmlHeight, scrollHeight);
+    };
+
+    const calculatedHeight = calculateHeight();
+    parent.postMessage({ type: 'codeyam-resize', name: scenarioName, height: calculatedHeight }, '*');
+
+    const eventListener = (event: MessageEvent) => {
+      if (event.data.name === scenarioName) {
+        if (event.data.type === 'codeyam-respond') {
+          const calculatedHeight = calculateHeight();
+          parent.postMessage({ type: 'codeyam-resize', name: scenarioName, height: calculatedHeight }, '*');
+        }
+      }
+    };
+
+    window.addEventListener('message', eventListener);
+    return () => window.removeEventListener('message', eventListener);
+  }, [scenarioName]);
+
+  const width = widthOverride || 'auto';
+
+  return (
+    <div className='flex flex-col justify-center items-center h-screen' data-version={internalVersion}>
+      <div className='w-full flex items-center justify-center'>
+        <div id='component' style={{
+          minWidth: width !== 'auto' ? \`min(\${width}, 100vw)\` : undefined,
+          height: heightOverride !== 'auto' ? heightOverride : undefined,
+          minHeight: heightOverride !== 'auto' ? heightOverride : undefined,
+          display: 'block',
+          padding: '6px'
+        }}>
+          {children}
+        </div>
+      </div>
+    </div>
+  );
+}
+`;
+}