Fix TypeScript errors and implement missing test helper functions

Author: SFARPak

e2e-tests/helpers/test_helper.ts

@@ -1020,6 +1020,73 @@ export class PageObject {
     await new Promise((resolve) => setTimeout(resolve, ms));
   }
 }
+// Helper functions for e2e tests
+
+export async function createApp(page: Page, appName: string, options: { isFullStack: boolean; selectedBackendFramework: string }): Promise<number> {
+  await page.getByRole("link", { name: "Chat" }).click();
+  const prompt = `Create a ${options.isFullStack ? 'fullstack' : 'frontend'} app named ${appName}${options.isFullStack ? ` with ${options.selectedBackendFramework} backend` : ''}`;
+  await page.getByRole("textbox", { name: "Ask AliFullStack to build..." }).fill(prompt);
+  await page.getByRole("button", { name: "Send message" }).click();
+  await page.waitForSelector('[data-testid="retry-button"]', { timeout: Timeout.MEDIUM });
+  return 0;
+}
+
+export async function deleteApp(page: Page, appId: number): Promise<void> {
+  await page.getByRole("link", { name: "Apps" }).click();
+  const appItems = page.locator('[data-testid^="app-list-item-"]');
+  await appItems.nth(appId).click();
+  await page.getByTestId("app-details-more-options-button").click();
+  await page.getByRole("button", { name: "Delete" }).click();
+  await page.getByRole("button", { name: "Delete App" }).click();
+}
+
+export async function startApp(page: Page, appId: number, mode: string): Promise<void> {
+  await page.getByRole("link", { name: "Chat" }).click();
+  const prompt = `Start the app in ${mode} mode`;
+  await page.getByRole("textbox", { name: "Ask AliFullStack to build..." }).fill(prompt);
+  await page.getByRole("button", { name: "Send message" }).click();
+  await page.waitForSelector('[data-testid="retry-button"]', { timeout: Timeout.MEDIUM });
+}
+
+export async function stopApp(page: Page, appId: number): Promise<void> {
+  await page.getByRole("link", { name: "Chat" }).click();
+  const prompt = `Stop the app`;
+  await page.getByRole("textbox", { name: "Ask AliFullStack to build..." }).fill(prompt);
+  await page.getByRole("button", { name: "Send message" }).click();
+  await page.waitForSelector('[data-testid="retry-button"]', { timeout: Timeout.MEDIUM });
+}
+
+export async function getAppOutput(page: Page, appId: number): Promise<string> {
+  const messagesList = page.getByTestId("messages-list");
+  return (await messagesList.textContent()) || '';
+}
+
+export async function switchTerminal(page: Page, terminal: string): Promise<void> {
+  await page.getByRole("tab", { name: terminal }).click();
+}
+
+export async function getTerminalOutput(page: Page, appId: number, terminal: string): Promise<string> {
+  // Assume the terminal content is in a locator after switching
+  // This might need adjustment based on actual UI
+  const terminalLocator = page.locator('.terminal');
+  return (await terminalLocator.textContent()) || '';
+}
+
+export async function createBackendFile(page: Page, appId: number, filePath: string, content: string): Promise<void> {
+  await page.getByRole("link", { name: "Chat" }).click();
+  const prompt = `Create a backend file ${filePath} with the following content:\n${content}`;
+  await page.getByRole("textbox", { name: "Ask AliFullStack to build..." }).fill(prompt);
+  await page.getByRole("button", { name: "Send message" }).click();
+  await page.waitForSelector('[data-testid="retry-button"]', { timeout: Timeout.MEDIUM });
+}
+
+export async function createFrontendFile(page: Page, appId: number, filePath: string, content: string): Promise<void> {
+  await page.getByRole("link", { name: "Chat" }).click();
+  const prompt = `Create a frontend file ${filePath} with the following content:\n${content}`;
+  await page.getByRole("textbox", { name: "Ask AliFullStack to build..." }).fill(prompt);
+  await page.getByRole("button", { name: "Send message" }).click();
+  await page.waitForSelector('[data-testid="retry-button"]', { timeout: Timeout.MEDIUM });
+}
 
 interface ElectronConfig {
   preLaunchHook?: ({ userDataDir }: { userDataDir: string }) => Promise<void>;

src/ipc/handlers/app_handlers.ts

@@ -99,7 +99,7 @@ export function getExtendedPath(): string {
  *
  * @returns The complete environment variables from the user's login shell.
  */
-function getShellEnv(): NodeJS.ProcessEnv {
+export function getShellEnv(): NodeJS.ProcessEnv {
   if (cachedShellEnv) {
     return cachedShellEnv;
   }
@@ -403,7 +403,7 @@ python app.py
  * Execute a command, using a temporary script file for complex commands with shell operators.
  * This allows handling of multi-line commands, pipes, conditionals, and other shell features.
  */
-async function executeComplexCommand(
+export async function executeComplexCommand(
   command: string,
   workingDir: string,
   env: NodeJS.ProcessEnv

src/ipc/utils/runShellCommand.ts

@@ -1,7 +1,6 @@
 import { spawn } from "child_process";
 import log from "electron-log";
-import { executeComplexCommand } from "../handlers/app_handlers";
-import { getShellEnv } from "../handlers/app_handlers";
+import { executeComplexCommand, getShellEnv } from "../handlers/app_handlers";
 
 const logger = log.scope("runShellCommand");
 
@@ -14,35 +13,35 @@ export function runShellCommand(command: string, workingDir?: string): Promise<s
     // Check if the command contains shell operators that require script execution
     const hasShellOperators = /(&&|\|\||source|\||;|\$\(|`.*`)/.test(command);
 
-    let process;
+    let childProcess;
     if (hasShellOperators) {
       logger.debug(`Using executeComplexCommand for complex command: ${command}`);
-      process = await executeComplexCommand(command, cwd, getShellEnv());
+      childProcess = await executeComplexCommand(command, cwd, getShellEnv());
     } else {
       logger.debug(`Using spawn for simple command: ${command}`);
-      process = spawn(command, {
+      childProcess = spawn(command, {
         shell: true,
         stdio: ["ignore", "pipe", "pipe"], // ignore stdin, pipe stdout/stderr
         cwd,
         env: getShellEnv(),
       });
     }
 
-    process.stdout?.on("data", (data) => {
+    childProcess.stdout?.on("data", (data) => {
       output += data.toString();
     });
 
-    process.stderr?.on("data", (data) => {
+    childProcess.stderr?.on("data", (data) => {
       // Log stderr but don't treat it as a failure unless the exit code is non-zero
       logger.warn(`Stderr from "${command}": ${data.toString().trim()}`);
     });
 
-    process.on("error", (error) => {
+    childProcess.on("error", (error) => {
       logger.error(`Error executing command "${command}":`, error.message);
       resolve(null); // Command execution failed
     });
 
-    process.on("close", (code) => {
+    childProcess.on("close", (code) => {
       if (code === 0) {
         logger.debug(
           `Command "${command}" succeeded with code ${code}: ${output.trim()}`,