dceky 1.0.0-beta-profile.1 → 1.0.0-beta-yuenler.1

package/lib/commands/visitCanvasGETEndpoint.d.ts

@@ -0,0 +1,20 @@
+declare global {
+    namespace Cypress {
+        interface Chainable {
+            /**
+             * Makes a GET request to Canvas API endpoint
+             * @param opts object containing all arguments
+             * @param opts.path The API path (e.g., '/courses', '/users/self')
+             * @param opts.accessToken The Canvas access token
+             * @returns The API response body
+             * @example cy.visitCanvasGETEndpoint({ path: '/courses', accessToken: 'your_token' })
+             */
+            visitCanvasGETEndpoint(opts: {
+                path: string;
+                accessToken: string;
+            }): Chainable<any>;
+        }
+    }
+}
+declare const visitCanvasGETEndpoint: () => void;
+export default visitCanvasGETEndpoint;

package/lib/commands/visitCanvasGETEndpoint.js

@@ -0,0 +1,26 @@
+"use strict";
+/// <reference types="cypress" />
+Object.defineProperty(exports, "__esModule", { value: true });
+/*----------------------------------------*/
+/* --------------- Command -------------- */
+/*----------------------------------------*/
+var visitCanvasGETEndpoint = function () {
+    Cypress.Commands.add('visitCanvasGETEndpoint', function (opts) {
+        cy.log('Visiting Canvas GET endpoint');
+        var path = opts.path, accessToken = opts.accessToken;
+        cy.log('Canvas API: ' + path);
+        return cy.request({
+            method: 'GET',
+            url: 'https://canvas.harvard.edu/api/v1' + path,
+            qs: {
+                per_page: 200,
+                access_token: accessToken
+            }
+        }).its('body');
+    });
+};
+/*----------------------------------------*/
+/* --------------- Export --------------- */
+/*----------------------------------------*/
+exports.default = visitCanvasGETEndpoint;
+//# sourceMappingURL=visitCanvasGETEndpoint.js.map

package/lib/commands/visitCanvasGETEndpoint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"visitCanvasGETEndpoint.js","sourceRoot":"","sources":["../../src/commands/visitCanvasGETEndpoint.ts"],"names":[],"mappings":";AAAA,iCAAiC;;AAsBjC,4CAA4C;AAC5C,4CAA4C;AAC5C,4CAA4C;AAE5C,IAAM,sBAAsB,GAAG;IAC7B,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,wBAAwB,EAAE,UAAC,IAA2C;QACzF,EAAE,CAAC,GAAG,CAAC,8BAA8B,CAAC,CAAC;QAC/B,IAAA,IAAI,GAAkB,IAAI,KAAtB,EAAE,WAAW,GAAK,IAAI,YAAT,CAAU;QAEnC,EAAE,CAAC,GAAG,CAAC,cAAc,GAAG,IAAI,CAAC,CAAC;QAC9B,OAAO,EAAE,CAAC,OAAO,CAAC;YAChB,MAAM,EAAE,KAAK;YACb,GAAG,EAAE,mCAAmC,GAAG,IAAI;YAC/C,EAAE,EAAE;gBACF,QAAQ,EAAE,GAAG;gBACb,YAAY,EAAE,WAAW;aAC1B;SACF,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IACjB,CAAC,CAAC,CAAC;AACL,CAAC,CAAC;AAEF,4CAA4C;AAC5C,4CAA4C;AAC5C,4CAA4C;AAE5C,kBAAe,sBAAsB,CAAC"}

package/lib/commands/waitForElementVisible.d.ts

@@ -0,0 +1,15 @@
+declare global {
+    namespace Cypress {
+        interface Chainable {
+            /**
+             * Wait for an element to be visible
+             * @param item the CSS selector of interest
+             * @param timeoutSec the number of seconds to wait before timing out (default: 10)
+             * @example cy.waitForElementVisible('#submit-button', 15)
+             */
+            waitForElementVisible(item: string, timeoutSec?: number): Chainable<JQuery<HTMLElement>>;
+        }
+    }
+}
+declare const waitForElementVisible: () => void;
+export default waitForElementVisible;

package/lib/commands/waitForElementVisible.js

@@ -0,0 +1,20 @@
+"use strict";
+/// <reference types="cypress" />
+Object.defineProperty(exports, "__esModule", { value: true });
+/*----------------------------------------*/
+/* --------------- Command -------------- */
+/*----------------------------------------*/
+var waitForElementVisible = function () {
+    Cypress.Commands.add('waitForElementVisible', function (item, timeoutSec) {
+        cy.log('Waiting for element to be visible');
+        timeoutSec = timeoutSec || 10;
+        var timeoutMs = timeoutSec * 1000;
+        cy.log("Wait for ".concat(item, " to be visible"));
+        return cy.get(item, { timeout: timeoutMs }).should('be.visible');
+    });
+};
+/*----------------------------------------*/
+/* --------------- Export --------------- */
+/*----------------------------------------*/
+exports.default = waitForElementVisible;
+//# sourceMappingURL=waitForElementVisible.js.map

package/lib/commands/waitForElementVisible.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"waitForElementVisible.js","sourceRoot":"","sources":["../../src/commands/waitForElementVisible.ts"],"names":[],"mappings":";AAAA,iCAAiC;;AAoBjC,4CAA4C;AAC5C,4CAA4C;AAC5C,4CAA4C;AAE5C,IAAM,qBAAqB,GAAG;IAC5B,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,uBAAuB,EAAE,UAAC,IAAY,EAAE,UAAmB;QAC9E,EAAE,CAAC,GAAG,CAAC,mCAAmC,CAAC,CAAC;QAC5C,UAAU,GAAG,UAAU,IAAI,EAAE,CAAC;QAE9B,IAAM,SAAS,GAAG,UAAU,GAAG,IAAI,CAAC;QACpC,EAAE,CAAC,GAAG,CAAC,mBAAY,IAAI,mBAAgB,CAAC,CAAC;QACzC,OAAO,EAAE,CAAC,GAAG,CAAC,IAAI,EAAE,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;IACnE,CAAC,CAAC,CAAC;AACL,CAAC,CAAC;AAEF,4CAA4C;AAC5C,4CAA4C;AAC5C,4CAA4C;AAE5C,kBAAe,qBAAqB,CAAC"}

package/lib/index.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.init = exports.genConfiguration = void 0;
+// Import helpers
 var init_1 = __importDefault(require("./init"));
 exports.init = init_1.default;
 var genConfiguration_1 = __importDefault(require("./genConfiguration"));

package/lib/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;AAAA,gDAA0B;AASxB,eATK,cAAI,CASL;AARN,wEAAkD;AAOhD,2BAPK,0BAAgB,CAOL;AALlB,sDAAsD;AACtD,IAAA,cAAI,GAAE,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;AAAA,iBAAiB;AACjB,gDAA0B;AASxB,eATK,cAAI,CASL;AARN,wEAAkD;AAOhD,2BAPK,0BAAgB,CAOL;AALlB,sDAAsD;AACtD,IAAA,cAAI,GAAE,CAAC"}

package/lib/init.d.ts

@@ -1,13 +1,6 @@
-declare global {
-    namespace Cypress {
-        interface Chainable {
-            /**
-             * Custom command to click an element by selector
-             * @example cy.clickSomething('.my-button')
-             */
-            clickSomething(selector: string): Chainable<Element>;
-        }
-    }
-}
+/**
+ * Initialize custom commands
+ * @author Gabe Abrams
+ */
 declare const init: () => void;
 export default init;

package/lib/init.js

@@ -1,10 +1,41 @@
 "use strict";
-/// <reference types="cypress" />
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+// Import all commands
+var assertDoesNotHaveClass_1 = __importDefault(require("./commands/assertDoesNotHaveClass"));
+var assertHasClass_1 = __importDefault(require("./commands/assertHasClass"));
+var assertNumElements_1 = __importDefault(require("./commands/assertNumElements"));
+var clickWithRetry_1 = __importDefault(require("./commands/clickWithRetry"));
+var getNumElements_1 = __importDefault(require("./commands/getNumElements"));
+var handleHarvardKey_1 = __importDefault(require("./commands/handleHarvardKey"));
+var launchAs_1 = __importDefault(require("./commands/launchAs"));
+var launchLTIUsingToken_1 = __importDefault(require("./commands/launchLTIUsingToken"));
+var navigateToHref_1 = __importDefault(require("./commands/navigateToHref"));
+var runScript_1 = __importDefault(require("./commands/runScript"));
+var typeInto_1 = __importDefault(require("./commands/typeInto"));
+var visitCanvasGETEndpoint_1 = __importDefault(require("./commands/visitCanvasGETEndpoint"));
+var waitForElementVisible_1 = __importDefault(require("./commands/waitForElementVisible"));
+/**
+ * Initialize custom commands
+ * @author Gabe Abrams
+ */
 var init = function () {
-    Cypress.Commands.add('clickSomething', function (selector) {
-        cy.get(selector).click();
-    });
+    // Execute each command adder
+    (0, assertDoesNotHaveClass_1.default)();
+    (0, assertHasClass_1.default)();
+    (0, assertNumElements_1.default)();
+    (0, clickWithRetry_1.default)();
+    (0, getNumElements_1.default)();
+    (0, handleHarvardKey_1.default)();
+    (0, launchAs_1.default)();
+    (0, launchLTIUsingToken_1.default)();
+    (0, navigateToHref_1.default)();
+    (0, runScript_1.default)();
+    (0, typeInto_1.default)();
+    (0, visitCanvasGETEndpoint_1.default)();
+    (0, waitForElementVisible_1.default)();
 };
 exports.default = init;
 //# sourceMappingURL=init.js.map

package/lib/init.js.map

@@ -1 +1 @@
-{"version":3,"file":"init.js","sourceRoot":"","sources":["../src/init.ts"],"names":[],"mappings":";AAAA,iCAAiC;;AAejC,IAAM,IAAI,GAAG;IACX,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,gBAAgB,EAAE,UAAC,QAAgB;QACtD,EAAE,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,KAAK,EAAE,CAAC;IAC3B,CAAC,CAAC,CAAC;AACL,CAAC,CAAC;AAEF,kBAAe,IAAI,CAAC"}
+{"version":3,"file":"init.js","sourceRoot":"","sources":["../src/init.ts"],"names":[],"mappings":";;;;;AAAA,sBAAsB;AACtB,6FAAuE;AACvE,6EAAuD;AACvD,mFAA6D;AAC7D,6EAAuD;AACvD,6EAAuD;AACvD,iFAA2D;AAC3D,iEAA2C;AAC3C,uFAAiE;AACjE,6EAAuD;AACvD,mEAA6C;AAC7C,iEAA2C;AAC3C,6FAAuE;AACvE,2FAAqE;AAErE;;;GAGG;AACH,IAAM,IAAI,GAAG;IACX,6BAA6B;IAC7B,IAAA,gCAAsB,GAAE,CAAC;IACzB,IAAA,wBAAc,GAAE,CAAC;IACjB,IAAA,2BAAiB,GAAE,CAAC;IACpB,IAAA,wBAAc,GAAE,CAAC;IACjB,IAAA,wBAAc,GAAE,CAAC;IACjB,IAAA,0BAAgB,GAAE,CAAC;IACnB,IAAA,kBAAQ,GAAE,CAAC;IACX,IAAA,6BAAmB,GAAE,CAAC;IACtB,IAAA,wBAAc,GAAE,CAAC;IACjB,IAAA,mBAAS,GAAE,CAAC;IACZ,IAAA,kBAAQ,GAAE,CAAC;IACX,IAAA,gCAAsB,GAAE,CAAC;IACzB,IAAA,+BAAqB,GAAE,CAAC;AAC1B,CAAC,CAAC;AAEF,kBAAe,IAAI,CAAC"}

package/package.json

@@ -1,17 +1,11 @@
 {
   "name": "dceky",
-  "version": "1.0.0-beta-profile.1",
+  "version": "1.0.0-beta-yuenler.1",
   "description": "Cypress toolkit for Harvard DCE",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "scripts": {
-    "build": "tsc --project ./tsconfig.json",
-    "cypress": "npx cypress open",
-    "cy:open:stage": "cross-env CYPRESS_PROFILE=stage npx cypress open",
-    "cy:open:prod": "cross-env CYPRESS_PROFILE=prod npx cypress open",
-    "cy:run:stage": "cross-env CYPRESS_PROFILE=stage npx cypress run",
-    "cy:run:prod": "cross-env CYPRESS_PROFILE=prod npx cypress run",
-    "launch-cypress": "npx tsx ./profileChooser/chooseProfile.ts"
+    "build": "tsc --project ./tsconfig.json"
   },
   "repository": {
     "type": "git",
@@ -28,21 +22,11 @@
     "url": "https://github.com/harvard-edtech/dceky/issues"
   },
   "homepage": "https://github.com/harvard-edtech/dceky#readme",
-  "dependencies": {
-    "deepmerge": "4.3.1",
-    "clear": "^0.1.0",
-    "prompt-sync": "^4.2.0"
+  "peerDependencies": {
+    "cypress": "x.x.x"
   },
   "devDependencies": {
-    "@types/deepmerge": "2.1.0",
-    "@types/node": "^24.6.1",
-    "typescript": "5.9.3"
-  },
-  "peerDependencies": {
-    "cypress": "14.5.4",
-    "@types/clear": "^0.1.4",
     "@types/node": "^22.7.0",
-    "@types/prompt-sync": "^4.2.3",
     "typescript": "^5.9.3"
   }
 }

package/src/commands/assertDoesNotHaveClass.ts

@@ -0,0 +1,40 @@
+/// <reference types="cypress" />
+
+/*----------------------------------------*/
+/* ---------------- Type ---------------- */
+/*----------------------------------------*/
+
+declare global {
+  namespace Cypress {
+    interface Chainable {
+      /**
+       * Assert that an element does not have a specific className
+       * @param opts object containing all arguments
+       * @param opts.item the css selector for finding the element
+       * @param opts.className the className to check for
+       * @example cy.assertDoesNotHaveClass({ item: '.my-button', className: 'disabled' })
+       */
+      assertDoesNotHaveClass(opts: {
+        item: string;
+        className: string;
+      }): Chainable<JQuery<HTMLElement>>;
+    }
+  }
+}
+
+/*----------------------------------------*/
+/* --------------- Command -------------- */
+/*----------------------------------------*/
+
+const assertDoesNotHaveClass = () => {
+  Cypress.Commands.add('assertDoesNotHaveClass', (opts: { item: string; className: string }) => {
+    cy.log(`Assert ${opts.item} does not have class ${opts.className}`);
+    return cy.get(opts.item).should('not.have.class', opts.className);
+  });
+};
+
+/*----------------------------------------*/
+/* --------------- Export --------------- */
+/*----------------------------------------*/
+
+export default assertDoesNotHaveClass;

package/src/commands/assertHasClass.ts

@@ -0,0 +1,40 @@
+/// <reference types="cypress" />
+
+/*----------------------------------------*/
+/* ---------------- Type ---------------- */
+/*----------------------------------------*/
+
+declare global {
+  namespace Cypress {
+    interface Chainable {
+      /**
+       * Assert that an element has a specific className
+       * @param opts object containing all arguments
+       * @param opts.item the css selector for finding the element
+       * @param opts.className the className to check for
+       * @example cy.assertHasClass({ item: '.my-button', className: 'active' })
+       */
+      assertHasClass(opts: {
+        item: string;
+        className: string;
+      }): Chainable<JQuery<HTMLElement>>;
+    }
+  }
+}
+
+/*----------------------------------------*/
+/* --------------- Command -------------- */
+/*----------------------------------------*/
+
+const assertHasClass = () => {
+  Cypress.Commands.add('assertHasClass', (opts: { item: string; className: string }) => {
+    cy.log(`Assert ${opts.item} has class ${opts.className}`);
+    return cy.get(opts.item).should('have.class', opts.className);
+  });
+};
+
+/*----------------------------------------*/
+/* --------------- Export --------------- */
+/*----------------------------------------*/
+
+export default assertHasClass;

package/src/commands/assertNumElements.ts

@@ -0,0 +1,37 @@
+/// <reference types="cypress" />
+
+/*----------------------------------------*/
+/* ---------------- Type ---------------- */
+/*----------------------------------------*/
+
+declare global {
+  namespace Cypress {
+    interface Chainable {
+      /**
+       * Assert a certain number of elements
+       * @param opts object containing all arguments
+       * @param opts.item a CSS selector corresponding to the item
+       * @param opts.num the precise number of elements expected
+       * @example cy.assertNumElements({ item: '.list-item', num: 5 })
+       */
+      assertNumElements(opts: { item: string; num: number }): Chainable<Element>;
+    }
+  }
+}
+
+/*----------------------------------------*/
+/* --------------- Command -------------- */
+/*----------------------------------------*/
+
+const assertNumElements = () => {
+  Cypress.Commands.add('assertNumElements', (opts: { item: string; num: number }) => {
+    cy.log(`Assert ${opts.num} elements match ${opts.item}`);
+    cy.get(opts.item).should('have.length', opts.num);
+  });
+};
+
+/*----------------------------------------*/
+/* --------------- Export --------------- */
+/*----------------------------------------*/
+
+export default assertNumElements;

package/src/commands/clickWithRetry.ts

@@ -0,0 +1,51 @@
+/// <reference types="cypress" />
+
+/*----------------------------------------*/
+/* ---------------- Type ---------------- */
+/*----------------------------------------*/
+
+declare global {
+  namespace Cypress {
+    interface Chainable {
+      /**
+       * Click an element with visibility checking, scrolling, and timeout handling
+       * @param item the CSS selector of interest
+       * @param timeoutSec the number of seconds to wait before timing out (default: 10)
+       * @param dontScrollTo if true, do not scroll to the element (default: false)
+       * @example cy.clickWithRetry('.submit-button', 15, false)
+       */
+      clickWithRetry(item: string, timeoutSec?: number, dontScrollTo?: boolean): Chainable<JQuery<HTMLElement>>;
+    }
+  }
+}
+
+/*----------------------------------------*/
+/* --------------- Command -------------- */
+/*----------------------------------------*/
+
+const clickWithRetry = () => {
+  Cypress.Commands.add('clickWithRetry', (item: string, timeoutSec?: number, dontScrollTo?: boolean) => {
+    timeoutSec = timeoutSec || 10;
+    dontScrollTo = dontScrollTo || false;
+
+    cy.log(`Click ${item}`);
+    
+    // Wait for element to be visible first using our own function
+    cy.waitForElementVisible(item, timeoutSec);
+    
+    // If scrolling is disabled, try to click directly
+    if (dontScrollTo) {
+      return cy.get(item).click();
+    } else {
+      // Scroll to element and then click using our own function
+      cy.get(item).scrollIntoView();
+      return cy.get(item).click();
+    }
+  });
+};
+
+/*----------------------------------------*/
+/* --------------- Export --------------- */
+/*----------------------------------------*/
+
+export default clickWithRetry;

package/src/commands/getNumElements.ts

@@ -0,0 +1,38 @@
+/// <reference types="cypress" />
+
+/*----------------------------------------*/
+/* ---------------- Type ---------------- */
+/*----------------------------------------*/
+
+declare global {
+  namespace Cypress {
+    interface Chainable {
+      /**
+       * Get number of elements
+       * @param item a CSS selector corresponding to the item
+       * @returns the number of elements on the page
+       * @example cy.getNumElements('.list-item').then((count) => { ... })
+       */
+      getNumElements(item: string): Chainable<JQuery<any>>;
+    }
+  }
+}
+
+/*----------------------------------------*/
+/* --------------- Command -------------- */
+/*----------------------------------------*/
+
+const getNumElements = () => {
+  Cypress.Commands.add('getNumElements', (selector: string) => {
+    cy.log(`Count elements matching ${selector}`);
+    return cy.get(selector).then(($elements: any) => {
+      return cy.wrap($elements.length);
+    });
+  });
+};
+
+/*----------------------------------------*/
+/* --------------- Export --------------- */
+/*----------------------------------------*/
+
+export default getNumElements;

package/src/commands/handleHarvardKey.ts

@@ -0,0 +1,87 @@
+/// <reference types="cypress" />
+
+/*----------------------------------------*/
+/* ---------------- Type ---------------- */
+/*----------------------------------------*/
+
+declare global {
+  namespace Cypress {
+    interface Chainable {
+      /**
+       * Handle a HarvardKey login page for a user
+       * @param url the URL to visit for HarvardKey authentication
+       * @example cy.handleHarvardKey('https://canvas.harvard.edu/login/saml')
+       */
+      handleHarvardKey(url: string): Chainable<void>;
+    }
+  }
+}
+
+/*----------------------------------------*/
+/* --------------- Command -------------- */
+/*----------------------------------------*/
+
+const handleHarvardKey = () => {
+  Cypress.Commands.add('handleHarvardKey', (url: string) => {
+    cy.log('Handling HarvardKey authentication');
+    
+    // Get credentials from environment variables
+    const username = (window as any).Cypress.env('HARVARD_USERNAME');
+    const password = (window as any).Cypress.env('HARVARD_PASSWORD');
+    
+    if (!username) {
+      throw new Error(`HARVARD_USERNAME environment variable is not set`);
+    }
+    
+    if (!password) {
+      throw new Error(`HARVARD_PASSWORD environment variable is not set`);
+    }
+
+    cy.visit(url);
+
+    // Get the Harvard login URL using originWithKaixa with auto-initialized functions
+    cy.origin('https://apps.cirrusidentity.com', () => {
+      Cypress.require('dceky');
+
+      return cy.navigateToHref({
+         item: '#idp_1001962798_button', 
+         domain: 'https://apps.cirrusidentity.com'
+        });
+    }).then((fullUrl: any) => {
+      // Navigate to the Harvard login page using originWithKaixa
+      cy.origin('https://harvard.idp.cirrusidentity.com', { 
+        args: { username, password, fullUrl } 
+      }, ({ args }: any) => {
+        Cypress.require('dceky');
+        const { username, password, fullUrl } = args;
+        
+        cy.on('uncaught:exception', (e: any) => {
+          // Ignore known HarvardKey errors
+          if (!e.message.includes('ready is not defined')) {
+            throw e;
+          }
+          return false;
+        });
+        
+        cy.visit(fullUrl.toString());
+        
+        // Wait for and fill in the login form using enhanced functions
+        cy.waitForElementVisible('#username');
+        cy.waitForElementVisible('#password');
+        
+        // Add credentials using enhanced functions
+        cy.typeInto({ item: '#username', text: username });
+        cy.typeInto({ item: '#password', text: password });
+        
+        // Submit the form using clickWithRetry
+        cy.clickWithRetry('input[type="submit"], button[type="submit"], .btn-primary');
+      });
+    });
+  });
+};
+
+/*----------------------------------------*/
+/* --------------- Export --------------- */
+/*----------------------------------------*/
+
+export default handleHarvardKey;

package/src/commands/launchAs.ts

@@ -0,0 +1,104 @@
+/// <reference types="cypress" />
+
+/*----------------------------------------*/
+/* ---------------- Type ---------------- */
+/*----------------------------------------*/
+
+declare global {
+  namespace Cypress {
+    interface Chainable {
+      /**
+       * Log into Canvas and launch an LTI app as a specific user from environment variables.
+       * The user should be defined as environment variables with the following properties:
+       * - {name}_ACCESS_TOKEN: Canvas access token for the user
+       * - {name}_USERNAME: Username (if no access token)
+       * - {name}_PASSWORD: Password (if using username)
+       * - {name}_IS_XID: Set to 'true' if using XID login
+       * - {name}_TYPE: User type ('student', 'ta', 'teacher') for local mode
+       * - {name}_SIM_INDEX: Simulator index for local mode
+       * @param name the name of the user (used as prefix for environment variables)
+       * @param courseId the Canvas ID of the course to launch from (uses COURSE_ID env var if not provided)
+       * @param appName the name of the app as it appears in the course's left-hand nav (uses APP_NAME env var if not provided)
+       * @example cy.launchAs('student1', 12345, 'My LTI App')
+       */
+      launchAs(name: string, courseId?: number, appName?: string): Chainable<void>;
+    }
+  }
+}
+
+/*----------------------------------------*/
+/* --------------- Command -------------- */
+/*----------------------------------------*/
+
+const launchAs = () => {
+  Cypress.Commands.add('launchAs', (name: string, courseId?: number, appName?: string) => {
+    cy.log(`🚀 Launch as ${name}`);
+
+    // Get default values from environment variables if not provided
+    if (!courseId) {
+      const envCourseId = Cypress.env('COURSE_ID');
+      if (!envCourseId) {
+        throw new Error('courseId parameter is required or COURSE_ID environment variable must be set');
+      }
+      courseId = parseInt(envCourseId, 10);
+    }
+
+    if (!appName) {
+      appName = Cypress.env('APP_NAME');
+      if (!appName) {
+        throw new Error('appName parameter is required or APP_NAME environment variable must be set');
+      }
+    }
+
+    // Check if this is a local launch
+    const isLocal = Cypress.env('LOCAL') === 'true';
+
+    if (isLocal) {
+      // Handle local simulator launch
+      const userType = Cypress.env(`${name}_TYPE`) || 'teacher';
+      const simIndex = Cypress.env(`${name}_SIM_INDEX`) || '0';
+      const simLaunchButtonId = `${userType}_${simIndex}-launch-button`;
+
+      cy.log('Local mode: launching simulator');
+      cy.visit('https://localhost:8088/simulator');
+
+      // Handle potential SSL certificate issues
+      cy.get('body').then(($body) => {
+        if ($body.find('.ssl').length > 0) {
+          cy.log('Handling SSL certificate issue');
+          cy.get('#details-button').click();
+          cy.get('#proceed-link').click();
+        }
+      });
+
+      // Launch the app
+      cy.get(`#${simLaunchButtonId}`).click();
+
+      // Check for authorization screen
+      cy.wait(1000);
+      cy.get('body').then(($body) => {
+        if ($body.find('.authorize-button').length > 0) {
+          cy.get('.authorize-button').click();
+        }
+      });
+
+      return;
+    }
+
+    // Handle production launch with access token
+    const accessToken = Cypress.env(`${name}_ACCESS_TOKEN`);
+    
+    if (!accessToken) {
+      throw new Error(`${name}_ACCESS_TOKEN environment variable is required for user "${name}"`);
+    }
+
+    // Launch using the access token
+    cy.launchLTIUsingToken(accessToken, courseId, appName);
+  });
+};
+
+/*----------------------------------------*/
+/* --------------- Export --------------- */
+/*----------------------------------------*/
+
+export default launchAs;