@iblai/iblai-js 1.8.4 → 1.8.7

package/dist/playwright/index.cjs

@@ -1713,6 +1713,821 @@ async function verifyMemoryNotExists(page, content) {
     logger.info(`Verified memory removed: "${content}"`);
 }
 
+// ============================
+// Navigation Helpers
+// ============================
+/**
+ * Check if the Sandbox tab is visible in the edit-mentor modal.
+ * Returns true if the tab exists and is visible (i.e. mentor has is_claw_enabled === true).
+ */
+async function isSandboxTabVisible(page) {
+    const tab = page.getByRole('tab', { name: 'Sandbox', exact: true });
+    try {
+        await test$1.expect(tab).toBeVisible({ timeout: 5000 });
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+/**
+ * Switch to the Sandbox tab inside the edit-mentor modal.
+ * Assumes the modal is already open and the user has permission to see the tab.
+ */
+async function switchToSandboxTab(page) {
+    const tab = page.getByRole('tab', { name: 'Sandbox', exact: true });
+    await test$1.expect(tab).toBeVisible({ timeout: 10000 });
+    await tab.click();
+    await test$1.expect(page.getByRole('heading', { name: 'Sandbox' }).or(page.getByText('Sandbox'))).toBeVisible({ timeout: 10000 });
+    logger.info('Switched to Sandbox tab');
+}
+/**
+ * Switch to the Skills tab inside the edit-mentor modal.
+ */
+async function switchToSkillsTab(page) {
+    const tab = page.getByRole('tab', { name: 'Skills', exact: true });
+    await test$1.expect(tab).toBeVisible({ timeout: 10000 });
+    await tab.click();
+    logger.info('Switched to Skills tab');
+}
+// ============================
+// Instance Table Helpers (not-connected state)
+// ============================
+/**
+ * Verify the instance table is visible with all expected column headers.
+ * Should be called when the mentor has no connected sandbox instance.
+ */
+async function verifyInstanceTableVisible(page) {
+    const table = page.locator('table');
+    await test$1.expect(table).toBeVisible({ timeout: 15000 });
+    await test$1.expect(table.locator('th').filter({ hasText: 'NAME' })).toBeVisible();
+    await test$1.expect(table.locator('th').filter({ hasText: 'URL' })).toBeVisible();
+    await test$1.expect(table.locator('th').filter({ hasText: 'TYPE' })).toBeVisible();
+    await test$1.expect(table.locator('th').filter({ hasText: 'STATUS' })).toBeVisible();
+    await test$1.expect(table.locator('th').filter({ hasText: 'HEALTH' })).toBeVisible();
+    await test$1.expect(table.locator('th').filter({ hasText: 'VERSION' })).toBeVisible();
+    await test$1.expect(table.locator('th').filter({ hasText: 'LAST CHECK' })).toBeVisible();
+    logger.info('Instance table is visible with correct headers');
+}
+/**
+ * Get the number of rows currently displayed in the instance table (excluding empty-state rows).
+ */
+async function getInstanceRowCount(page) {
+    const rows = page.locator('table tbody tr').filter({ hasNot: page.locator('td[colspan]') });
+    const count = await rows.count();
+    logger.info(`Instance table has ${count} rows`);
+    return count;
+}
+/**
+ * Verify the empty state is shown when there are no instances.
+ */
+async function verifyInstanceTableEmpty(page) {
+    await test$1.expect(page.getByText(/No instances available/i)).toBeVisible({ timeout: 10000 });
+    logger.info('Instance table empty state is displayed');
+}
+/**
+ * Filter the instance table by search query (name or URL).
+ */
+async function searchInstances(page, query) {
+    const searchInput = page.getByPlaceholder('Search instances...');
+    await test$1.expect(searchInput).toBeVisible({ timeout: 10000 });
+    await searchInput.fill(query);
+    // Let the filter apply
+    await page.waitForTimeout(300);
+    logger.info(`Searched instances with query: "${query}"`);
+}
+/**
+ * Clear the instance table search query.
+ */
+async function clearInstanceSearch(page) {
+    const searchInput = page.getByPlaceholder('Search instances...');
+    await searchInput.fill('');
+    await page.waitForTimeout(300);
+    logger.info('Cleared instance search');
+}
+/**
+ * Open the Actions dropdown menu for a specific instance row.
+ * Returns the dropdown menu locator.
+ */
+async function openInstanceActionsMenu(page, instanceName) {
+    const row = page.locator('table tbody tr').filter({ hasText: instanceName });
+    await test$1.expect(row).toBeVisible({ timeout: 10000 });
+    const actionsButton = row.getByRole('button', { name: 'Actions' });
+    await test$1.expect(actionsButton).toBeVisible({ timeout: 5000 });
+    await actionsButton.click();
+    const menu = page.getByRole('menu');
+    await test$1.expect(menu).toBeVisible({ timeout: 5000 });
+    return menu;
+}
+// ============================
+// Create Instance Helpers
+// ============================
+/**
+ * Open the "New Instance" dialog by clicking the Add Instance button.
+ * Returns the dialog locator.
+ */
+async function openNewInstanceDialog(page) {
+    const addButton = page.getByRole('button', { name: /Add Instance/i });
+    await test$1.expect(addButton).toBeVisible({ timeout: 10000 });
+    await addButton.click();
+    const dialog = page.getByRole('dialog').filter({ hasText: 'New Instance' });
+    return waitForDialogReady(page, dialog);
+}
+/**
+ * Fill the New Instance form and submit it.
+ * @param name - Display name for the instance
+ * @param serverUrl - Fully qualified https URL
+ * @param clawType - 'openclaw' (default) or 'ironclaw'
+ * @param gatewayToken - Optional auth token
+ */
+async function createInstance(page, { name, serverUrl, clawType = 'openclaw', gatewayToken, }) {
+    await openNewInstanceDialog(page);
+    await page.getByLabel('Name').fill(name);
+    await page.getByLabel('Server URL').fill(serverUrl);
+    if (clawType !== 'openclaw') {
+        const typeSelect = page.getByLabel('Type');
+        await typeSelect.click();
+        const option = page.getByRole('option', { name: new RegExp(clawType, 'i') });
+        await test$1.expect(option).toBeVisible({ timeout: 5000 });
+        await option.click();
+    }
+    if (gatewayToken) {
+        await page.getByLabel('Gateway Token').fill(gatewayToken);
+    }
+    const createButton = page.getByRole('button', { name: /^Create$/i });
+    await test$1.expect(createButton).toBeEnabled({ timeout: 5000 });
+    await createButton.click();
+    await test$1.expect(page.getByText('Instance created', { exact: false })).toBeVisible({
+        timeout: 10000,
+    });
+    logger.info(`Created instance "${name}" at ${serverUrl}`);
+}
+/**
+ * Cancel the New Instance dialog without submitting.
+ */
+async function cancelNewInstanceDialog(page) {
+    const dialog = page.getByRole('dialog').filter({ hasText: 'New Instance' });
+    await test$1.expect(dialog).toBeVisible({ timeout: 5000 });
+    await page.keyboard.press('Escape');
+    await test$1.expect(dialog).not.toBeVisible({ timeout: 5000 });
+    logger.info('Cancelled New Instance dialog');
+}
+// ============================
+// Edit Instance Helpers
+// ============================
+/**
+ * Open the Edit dialog for an instance from its Actions menu.
+ * Returns the edit dialog locator.
+ */
+async function openEditInstanceDialog(page, instanceName) {
+    await openInstanceActionsMenu(page, instanceName);
+    const editItem = page.getByRole('menuitem', { name: /Edit/i });
+    await test$1.expect(editItem).toBeVisible({ timeout: 5000 });
+    await editItem.click();
+    const dialog = page.getByRole('dialog').filter({ hasText: 'Edit Instance' });
+    return waitForDialogReady(page, dialog);
+}
+/**
+ * Edit an existing instance with new values.
+ * @param instanceName - The current name of the instance to edit
+ * @param updates - Fields to update
+ */
+async function editInstance(page, instanceName, updates) {
+    await openEditInstanceDialog(page, instanceName);
+    if (updates.name !== undefined) {
+        const nameInput = page.getByLabel('Name');
+        await nameInput.fill(updates.name);
+    }
+    if (updates.serverUrl !== undefined) {
+        const urlInput = page.getByLabel('Server URL');
+        await urlInput.fill(updates.serverUrl);
+    }
+    if (updates.clawType !== undefined) {
+        const typeSelect = page.getByLabel('Type');
+        await typeSelect.click();
+        const option = page.getByRole('option', { name: new RegExp(updates.clawType, 'i') });
+        await test$1.expect(option).toBeVisible({ timeout: 5000 });
+        await option.click();
+    }
+    const saveButton = page.getByRole('button', { name: /^Save$/i });
+    await test$1.expect(saveButton).toBeEnabled({ timeout: 5000 });
+    await saveButton.click();
+    await test$1.expect(page.getByText('Instance updated', { exact: false })).toBeVisible({
+        timeout: 10000,
+    });
+    logger.info(`Edited instance "${instanceName}" with updates: ${JSON.stringify(updates)}`);
+}
+// ============================
+// Delete Instance Helpers
+// ============================
+/**
+ * Delete an instance via the Actions menu, confirming the deletion dialog.
+ */
+async function deleteInstance(page, instanceName) {
+    await openInstanceActionsMenu(page, instanceName);
+    const deleteItem = page.getByRole('menuitem', { name: /Delete/i });
+    await test$1.expect(deleteItem).toBeVisible({ timeout: 5000 });
+    await deleteItem.click();
+    const dialog = page.getByRole('dialog').filter({ hasText: 'Delete Instance' });
+    await test$1.expect(dialog).toBeVisible({ timeout: 5000 });
+    const confirmButton = dialog.getByRole('button', { name: /^Delete$/i });
+    await test$1.expect(confirmButton).toBeVisible({ timeout: 5000 });
+    await confirmButton.click();
+    await test$1.expect(page.getByText('Instance deleted', { exact: false })).toBeVisible({
+        timeout: 10000,
+    });
+    logger.info(`Deleted instance "${instanceName}"`);
+}
+/**
+ * Open the delete confirmation dialog and cancel it without deleting.
+ */
+async function cancelDeleteInstance(page, instanceName) {
+    await openInstanceActionsMenu(page, instanceName);
+    const deleteItem = page.getByRole('menuitem', { name: /Delete/i });
+    await deleteItem.click();
+    const dialog = page.getByRole('dialog').filter({ hasText: 'Delete Instance' });
+    await test$1.expect(dialog).toBeVisible({ timeout: 5000 });
+    const cancelButton = dialog.getByRole('button', { name: /Cancel/i });
+    await cancelButton.click();
+    await test$1.expect(dialog).not.toBeVisible({ timeout: 5000 });
+    logger.info(`Cancelled delete of instance "${instanceName}"`);
+}
+// ============================
+// Connect / Disconnect Helpers
+// ============================
+/**
+ * Connect the current mentor to an instance via the Actions menu.
+ */
+async function connectToInstance(page, instanceName) {
+    await openInstanceActionsMenu(page, instanceName);
+    const connectItem = page.getByRole('menuitem', { name: /Connect/i });
+    await test$1.expect(connectItem).toBeVisible({ timeout: 5000 });
+    await connectItem.click();
+    await test$1.expect(page.getByText('Instance connected', { exact: false })).toBeVisible({
+        timeout: 10000,
+    });
+    // After connect, the UI should switch to show the Connected Instance card
+    await test$1.expect(page.getByText('Connected Instance')).toBeVisible({ timeout: 10000 });
+    logger.info(`Connected mentor to instance "${instanceName}"`);
+}
+/**
+ * Disconnect the current mentor from its connected instance,
+ * confirming the disconnect dialog.
+ */
+async function disconnectInstance(page) {
+    const disconnectButton = page.getByRole('button', { name: /^Disconnect$/i });
+    await test$1.expect(disconnectButton).toBeVisible({ timeout: 10000 });
+    await disconnectButton.click();
+    const dialog = page.getByRole('dialog').filter({ hasText: 'Disconnect Instance' });
+    await test$1.expect(dialog).toBeVisible({ timeout: 5000 });
+    const confirmButton = dialog.getByRole('button', { name: /^Disconnect$/i });
+    await confirmButton.click();
+    await test$1.expect(page.getByText('Instance disconnected', { exact: false })).toBeVisible({
+        timeout: 10000,
+    });
+    logger.info('Disconnected mentor from instance');
+}
+/**
+ * Open the disconnect confirmation dialog and cancel it.
+ */
+async function cancelDisconnectInstance(page) {
+    const disconnectButton = page.getByRole('button', { name: /^Disconnect$/i });
+    await disconnectButton.click();
+    const dialog = page.getByRole('dialog').filter({ hasText: 'Disconnect Instance' });
+    await test$1.expect(dialog).toBeVisible({ timeout: 5000 });
+    const cancelButton = dialog.getByRole('button', { name: /Cancel/i });
+    await cancelButton.click();
+    await test$1.expect(dialog).not.toBeVisible({ timeout: 5000 });
+    logger.info('Cancelled disconnect');
+}
+// ============================
+// Health-check / Connectivity Helpers
+// ============================
+/**
+ * Open an instance's actions menu and click "Run checks". Resolves once the
+ * health-check + connectivity-test toasts have surfaced (success or error).
+ */
+async function runInstanceChecks(page, instanceName) {
+    await openInstanceActionsMenu(page, instanceName);
+    const runChecks = page.getByRole('menuitem', { name: /Run checks/i });
+    await test$1.expect(runChecks).toBeVisible({ timeout: 5000 });
+    await runChecks.click();
+    // Each action toasts independently. We don't assert success vs. error here —
+    // callers can inspect the row's status/health afterwards via `getInstanceHealthLabel`.
+    await test$1.expect(page.getByText(/Health check (passed|failed)|Connectivity test (passed|failed)/i).first()).toBeVisible({ timeout: 15000 });
+    logger.info(`Ran checks for instance "${instanceName}"`);
+}
+/**
+ * Trigger the "Run checks" button on the connected-instance card. Used for the
+ * connected-state flow rather than the table dropdown.
+ */
+async function runConnectedInstanceChecks(page) {
+    await test$1.expect(page.getByText('Connected Instance')).toBeVisible({ timeout: 10000 });
+    const runChecks = page.getByRole('button', { name: /Run checks/i });
+    await test$1.expect(runChecks).toBeVisible({ timeout: 5000 });
+    await test$1.expect(runChecks).toBeEnabled();
+    await runChecks.click();
+    await test$1.expect(page.getByText(/Health check (passed|failed)|Connectivity test (passed|failed)/i).first()).toBeVisible({ timeout: 15000 });
+    logger.info('Ran checks on connected instance');
+}
+/**
+ * Read the canonical health label rendered by `StatusDot` for the given row.
+ * Returns "Healthy" / "Unhealthy" / null (em-dash for unknown).
+ */
+async function getInstanceHealthLabel(page, instanceName) {
+    const row = page.locator('table tbody tr').filter({ hasText: instanceName });
+    await test$1.expect(row).toBeVisible({ timeout: 10000 });
+    // Health is the 5th data cell (Name, URL, Type, Status, Health, …).
+    const healthCell = row.locator('td').nth(4);
+    const text = (await healthCell.innerText()).trim();
+    if (text === 'Healthy' || text === 'Unhealthy')
+        return text;
+    return null;
+}
+/**
+ * Read the canonical status label rendered by `StatusDot` for the given row.
+ * Returns "Active" / "Error" / null (em-dash for unknown).
+ */
+async function getInstanceStatusLabel(page, instanceName) {
+    const row = page.locator('table tbody tr').filter({ hasText: instanceName });
+    await test$1.expect(row).toBeVisible({ timeout: 10000 });
+    // Status is the 4th data cell (Name, URL, Type, Status, …).
+    const statusCell = row.locator('td').nth(3);
+    const text = (await statusCell.innerText()).trim();
+    if (text === 'Active' || text === 'Error')
+        return text;
+    return null;
+}
+/**
+ * Verify that the Connect dropdown item is blocked (dimmed + cursor-not-allowed)
+ * because the instance status is unhealthy. Hovering should reveal the unhealthy
+ * tooltip explaining why.
+ */
+async function verifyConnectDisabledForUnhealthy(page, instanceName) {
+    await openInstanceActionsMenu(page, instanceName);
+    const connectItem = page.getByRole('menuitem', { name: /^Connect$/i });
+    await test$1.expect(connectItem).toBeVisible({ timeout: 5000 });
+    await test$1.expect(connectItem).toHaveClass(/opacity-50/);
+    await test$1.expect(connectItem).toHaveClass(/cursor-not-allowed/);
+    // Close the menu without firing Connect.
+    await page.keyboard.press('Escape');
+    logger.info(`Verified Connect is blocked for unhealthy instance "${instanceName}"`);
+}
+// ============================
+// Connected-State Helpers
+// ============================
+/**
+ * Verify the Connected Instance card shows the expected fields.
+ * The URL field shows the full server_url; other fields are status/health/last-check.
+ */
+async function verifyConnectedInstanceCard(page) {
+    await test$1.expect(page.getByText('Connected Instance')).toBeVisible({ timeout: 10000 });
+    // Labels inside the card
+    await test$1.expect(page.getByText('Name', { exact: true })).toBeVisible();
+    await test$1.expect(page.getByText('URL', { exact: true })).toBeVisible();
+    await test$1.expect(page.getByText('Status', { exact: true })).toBeVisible();
+    await test$1.expect(page.getByText('Health', { exact: true })).toBeVisible();
+    await test$1.expect(page.getByText('Last Check', { exact: true })).toBeVisible();
+    logger.info('Connected instance card is displayed with all expected fields');
+}
+/**
+ * Toggle the Auto Push on Save switch.
+ * Returns the new checked state.
+ */
+async function toggleAutoPush(page) {
+    const switchEl = page
+        .locator('div')
+        .filter({ hasText: /^Auto Push on Save/ })
+        .getByRole('switch')
+        .first();
+    await test$1.expect(switchEl).toBeVisible({ timeout: 10000 });
+    const wasChecked = await switchEl.isChecked();
+    await switchEl.click();
+    await test$1.expect(page.getByText(/Configuration updated/i)).toBeVisible({ timeout: 10000 });
+    const isNowChecked = await switchEl.isChecked();
+    logger.info(`Toggled auto-push from ${wasChecked} to ${isNowChecked}`);
+    return isNowChecked;
+}
+/**
+ * Click the Push button to push the current configuration to the worker.
+ */
+async function pushConfiguration(page) {
+    const pushButton = page.getByRole('button', { name: /^Push$/i });
+    await test$1.expect(pushButton).toBeVisible({ timeout: 10000 });
+    await pushButton.click();
+    await test$1.expect(page.getByText(/Configuration push queued/i)).toBeVisible({ timeout: 10000 });
+    logger.info('Pushed configuration to worker');
+}
+// ============================
+// LLM Model Selection Helpers
+// ============================
+/**
+ * Open the LLM provider picker by clicking Change (or Select Model) in the Model row.
+ * Returns the picker dialog locator.
+ */
+async function openLLMProviderPicker(page) {
+    const triggerButton = page.getByRole('button', { name: /^Change$|^Select Model$/i });
+    await test$1.expect(triggerButton).toBeVisible({ timeout: 10000 });
+    await triggerButton.click();
+    const dialog = page.getByRole('dialog').filter({ hasText: 'Select Provider' });
+    return waitForDialogReady(page, dialog);
+}
+/**
+ * Pick an LLM provider + model combination via the provider picker flow.
+ * @param providerName - The provider key (e.g. 'anthropic', 'openai')
+ * @param modelName - The model name (e.g. 'claude-sonnet-4-5-20250929')
+ */
+async function selectLLMModel(page, providerName, modelName) {
+    await openLLMProviderPicker(page);
+    // Click the provider card
+    const providerCard = page.getByRole('dialog').getByText(new RegExp(`^${providerName}$`, 'i'));
+    await test$1.expect(providerCard).toBeVisible({ timeout: 10000 });
+    await providerCard.click();
+    // Model selection modal ("LLM Selection")
+    const modelDialog = page.getByRole('dialog').filter({ hasText: 'LLM Selection' });
+    await test$1.expect(modelDialog).toBeVisible({ timeout: 10000 });
+    const modelButton = modelDialog.getByRole('button', { name: new RegExp(modelName, 'i') });
+    await test$1.expect(modelButton).toBeVisible({ timeout: 10000 });
+    await modelButton.click();
+    await test$1.expect(page.getByText('Model updated', { exact: false })).toBeVisible({
+        timeout: 10000,
+    });
+    logger.info(`Selected model ${providerName}/${modelName}`);
+}
+/**
+ * Get the currently-selected model identifier shown next to the Model row.
+ * Returns null if no model is set (button reads "Select Model").
+ */
+async function getCurrentModel(page) {
+    var _a;
+    const selectButton = page.getByRole('button', { name: /^Select Model$/i });
+    const hasSelectButton = await selectButton.isVisible().catch(() => false);
+    if (hasSelectButton)
+        return null;
+    // When a model is set, the row shows: Model <tooltip> <model-text> [Change]
+    const modelRow = page
+        .locator('div.rounded-lg.border')
+        .filter({ has: page.getByRole('button', { name: /^Change$/i }) });
+    const text = await modelRow.textContent();
+    // Extract the model identifier — it's the text before "Change"
+    const cleaned = (_a = text === null || text === void 0 ? void 0 : text.replace(/Change$/, '').replace(/^Model/, '').trim()) !== null && _a !== void 0 ? _a : null;
+    logger.info(`Current model: ${cleaned}`);
+    return cleaned;
+}
+// ============================
+// Agent Config Prompts Helpers (Prompts tab)
+// ============================
+const AGENT_PROMPT_LABELS = [
+    'Identity',
+    'Soul',
+    'User Context',
+    'Tools',
+    'Agents',
+    'Bootstrap',
+    'Heartbeat',
+    'Memory',
+];
+/**
+ * Verify that all 8 agent config prompt fields are visible in the Prompts tab.
+ * Only renders when the mentor has enable_claw === true on its settings.
+ *
+ * Note: PATCH on the agent-config endpoint is upsert — there's no separate
+ * "Create Agent Config" button anymore. The first edit on any field bootstraps
+ * the row.
+ */
+async function verifyAgentConfigPromptsVisible(page) {
+    for (const label of AGENT_PROMPT_LABELS) {
+        await test$1.expect(page.getByText(label, { exact: true })).toBeVisible({ timeout: 10000 });
+    }
+    logger.info('All agent config prompt fields are visible');
+}
+/**
+ * Open the edit modal for a specific agent prompt field (e.g. Identity, Soul).
+ */
+async function openAgentPromptEditModal(page, field) {
+    const row = page
+        .locator('div.rounded-lg.border.p-6')
+        .filter({ hasText: new RegExp(`^${field}$`) });
+    const editButton = row.getByRole('button', { name: /Edit/i });
+    await test$1.expect(editButton).toBeVisible({ timeout: 10000 });
+    await editButton.click();
+    const dialog = page.getByRole('dialog').filter({ hasText: `Edit ${field}` });
+    return waitForDialogReady(page, dialog);
+}
+/**
+ * Edit an agent prompt field (opens the modal, types content, saves).
+ */
+async function editAgentPrompt(page, field, content) {
+    await openAgentPromptEditModal(page, field);
+    // The RichTextEditor renders into a contenteditable element; fall back to textarea if simpler.
+    const editorRegion = page.locator('[contenteditable="true"]').first();
+    const textarea = page.locator('textarea').first();
+    const hasEditor = await editorRegion.isVisible().catch(() => false);
+    if (hasEditor) {
+        await editorRegion.click();
+        await page.keyboard.press('ControlOrMeta+A');
+        await page.keyboard.press('Delete');
+        await page.keyboard.type(content);
+    }
+    else {
+        await textarea.fill(content);
+    }
+    const saveButton = page.getByRole('button', { name: /^Save$/i });
+    await test$1.expect(saveButton).toBeEnabled({ timeout: 5000 });
+    await saveButton.click();
+    await test$1.expect(page.getByText(`${field} updated successfully`, { exact: false })).toBeVisible({
+        timeout: 10000,
+    });
+    logger.info(`Edited agent prompt "${field}" with ${content.length} chars`);
+}
+// ============================
+// Skills Tab Helpers
+// ============================
+/**
+ * Verify the Skills tab content is loaded (either showing skill rows or the empty state).
+ */
+async function verifySkillsTabVisible(page) {
+    // Either at least one skill toggle row is visible, or the empty message is shown
+    const hasSkills = await page
+        .getByRole('switch')
+        .first()
+        .isVisible()
+        .catch(() => false);
+    if (hasSkills) {
+        logger.info('Skills tab is visible with skills rendered');
+        return;
+    }
+    await test$1.expect(page.getByText(/No skills available for this platform/i)).toBeVisible({
+        timeout: 10000,
+    });
+    logger.info('Skills tab is visible with empty state');
+}
+/**
+ * Verify that the "No skills available" empty state is shown.
+ */
+async function verifySkillsEmptyState(page) {
+    await test$1.expect(page.getByText(/No skills available for this platform/i)).toBeVisible({
+        timeout: 10000,
+    });
+    logger.info('Skills empty state is displayed');
+}
+/**
+ * Count the number of skill rows rendered in the Skills tab.
+ * Each row represents an available (enabled) platform skill.
+ */
+async function getSkillRowCount(page) {
+    const rows = page.locator('div.rounded-lg.border.p-6').filter({ has: page.getByRole('switch') });
+    const count = await rows.count();
+    logger.info(`${count} skill row(s) displayed`);
+    return count;
+}
+/**
+ * Verify that a specific skill row is visible in the Skills tab.
+ */
+async function verifySkillVisible(page, skillName) {
+    const row = page
+        .locator('div.rounded-lg.border.p-6')
+        .filter({ hasText: skillName })
+        .filter({ has: page.getByRole('switch') });
+    await test$1.expect(row).toBeVisible({ timeout: 10000 });
+    logger.info(`Skill "${skillName}" is visible`);
+}
+/**
+ * Check if a specific skill is currently enabled for the mentor.
+ */
+async function isSkillEnabled(page, skillName) {
+    const switchEl = page.getByLabel(new RegExp(`^${skillName} (enabled|disabled)$`));
+    await test$1.expect(switchEl).toBeVisible({ timeout: 10000 });
+    const enabled = await switchEl.isChecked();
+    logger.info(`Skill "${skillName}" is ${enabled ? 'enabled' : 'disabled'}`);
+    return enabled;
+}
+/**
+ * Enable a skill for the current mentor by toggling it on.
+ * No-op if already enabled. Waits for the success toast.
+ */
+async function enableSkill(page, skillName) {
+    const disabledSwitch = page.getByLabel(`${skillName} disabled`);
+    const isDisabled = await disabledSwitch.isVisible().catch(() => false);
+    if (!isDisabled) {
+        logger.info(`Skill "${skillName}" already enabled`);
+        return;
+    }
+    await disabledSwitch.click();
+    await test$1.expect(page.getByText(`${skillName} enabled`, { exact: false })).toBeVisible({
+        timeout: 10000,
+    });
+    logger.info(`Enabled skill "${skillName}"`);
+}
+/**
+ * Disable a skill for the current mentor by toggling it off.
+ * No-op if already disabled. Waits for the success toast.
+ */
+async function disableSkill(page, skillName) {
+    const enabledSwitch = page.getByLabel(`${skillName} enabled`);
+    const isEnabled = await enabledSwitch.isVisible().catch(() => false);
+    if (!isEnabled) {
+        logger.info(`Skill "${skillName}" already disabled`);
+        return;
+    }
+    await enabledSwitch.click();
+    await test$1.expect(page.getByText(`${skillName} disabled`, { exact: false })).toBeVisible({
+        timeout: 10000,
+    });
+    logger.info(`Disabled skill "${skillName}"`);
+}
+/**
+ * Toggle a skill's enabled state (flips whatever the current state is).
+ * Returns the new checked state.
+ */
+async function toggleSkill(page, skillName) {
+    const wasEnabled = await isSkillEnabled(page, skillName);
+    if (wasEnabled) {
+        await disableSkill(page, skillName);
+        return false;
+    }
+    await enableSkill(page, skillName);
+    return true;
+}
+/**
+ * Open the "New Skill" dialog by clicking the New Skill button in the Skills tab.
+ * Returns the dialog locator.
+ */
+async function openNewSkillDialog(page) {
+    const newButton = page.getByRole('button', { name: /^New Skill$/i });
+    await test$1.expect(newButton).toBeVisible({ timeout: 10000 });
+    await newButton.click();
+    const dialog = page.getByRole('dialog').filter({ hasText: 'New Skill' });
+    return waitForDialogReady(page, dialog);
+}
+/**
+ * Type content into the RichTextEditor Instruction field.
+ * The editor renders as a contenteditable element.
+ */
+async function fillInstructionEditor(page, content) {
+    // RichTextEditor uses a contenteditable region
+    const editor = page.locator('[contenteditable="true"]').first();
+    const hasEditor = await editor.isVisible().catch(() => false);
+    if (hasEditor) {
+        await editor.click();
+        await page.keyboard.press('ControlOrMeta+A');
+        await page.keyboard.press('Delete');
+        if (content) {
+            await page.keyboard.type(content);
+        }
+        return;
+    }
+    // Fallback: a plain labelled input/textarea named "Instruction"
+    const textarea = page.getByLabel('Instruction');
+    await textarea.fill(content);
+}
+/**
+ * Fill the skill form fields (name, slug, description, version, instruction).
+ * The form is used by both the New and Edit dialogs.
+ * The Instruction field is a rich-text (markdown) editor.
+ */
+async function fillSkillForm(page, values) {
+    await page.getByLabel('Name').fill(values.name);
+    await page.getByLabel('Slug').fill(values.slug);
+    if (values.version !== undefined) {
+        await page.getByLabel('Version').fill(values.version);
+    }
+    if (values.description !== undefined) {
+        await page.getByLabel('Description').fill(values.description);
+    }
+    if (values.instruction !== undefined) {
+        await fillInstructionEditor(page, values.instruction);
+    }
+}
+/**
+ * Create a new platform-level skill via the Skills tab.
+ */
+async function createSkill(page, values) {
+    await openNewSkillDialog(page);
+    await fillSkillForm(page, values);
+    const createButton = page.getByRole('button', { name: /^Create$/i });
+    await test$1.expect(createButton).toBeEnabled({ timeout: 5000 });
+    await createButton.click();
+    await test$1.expect(page.getByText('Skill created', { exact: false })).toBeVisible({
+        timeout: 10000,
+    });
+    logger.info(`Created skill "${values.name}"`);
+}
+/**
+ * Open the Actions dropdown for a specific skill row.
+ * Returns the dropdown menu locator.
+ */
+async function openSkillActionsMenu(page, skillName) {
+    const actionsButton = page.getByRole('button', { name: `${skillName} actions` });
+    await test$1.expect(actionsButton).toBeVisible({ timeout: 10000 });
+    await actionsButton.click();
+    const menu = page.getByRole('menu');
+    await test$1.expect(menu).toBeVisible({ timeout: 5000 });
+    return menu;
+}
+/**
+ * Open the Edit Skill dialog from the actions menu.
+ * Returns the dialog locator.
+ */
+async function openEditSkillDialog(page, skillName) {
+    await openSkillActionsMenu(page, skillName);
+    const editItem = page.getByRole('menuitem', { name: /Edit/i });
+    await test$1.expect(editItem).toBeVisible({ timeout: 5000 });
+    await editItem.click();
+    const dialog = page.getByRole('dialog').filter({ hasText: 'Edit Skill' });
+    return waitForDialogReady(page, dialog);
+}
+/**
+ * Edit an existing platform-level skill.
+ * @param skillName - The current name of the skill to edit
+ * @param updates - Fields to update on the skill
+ */
+async function editSkill(page, skillName, updates) {
+    await openEditSkillDialog(page, skillName);
+    if (updates.name !== undefined) {
+        await page.getByLabel('Name').fill(updates.name);
+    }
+    if (updates.slug !== undefined) {
+        await page.getByLabel('Slug').fill(updates.slug);
+    }
+    if (updates.version !== undefined) {
+        await page.getByLabel('Version').fill(updates.version);
+    }
+    if (updates.description !== undefined) {
+        await page.getByLabel('Description').fill(updates.description);
+    }
+    if (updates.instruction !== undefined) {
+        await fillInstructionEditor(page, updates.instruction);
+    }
+    const saveButton = page.getByRole('button', { name: /^Save$/i });
+    await test$1.expect(saveButton).toBeEnabled({ timeout: 5000 });
+    await saveButton.click();
+    await test$1.expect(page.getByText('Skill updated', { exact: false })).toBeVisible({
+        timeout: 10000,
+    });
+    logger.info(`Edited skill "${skillName}" with updates: ${JSON.stringify(updates)}`);
+}
+/**
+ * Delete a platform-level skill, confirming the deletion dialog.
+ */
+async function deleteSkill(page, skillName) {
+    await openSkillActionsMenu(page, skillName);
+    const deleteItem = page.getByRole('menuitem', { name: /Delete/i });
+    await test$1.expect(deleteItem).toBeVisible({ timeout: 5000 });
+    await deleteItem.click();
+    const dialog = page.getByRole('dialog').filter({ hasText: 'Delete Skill' });
+    await test$1.expect(dialog).toBeVisible({ timeout: 5000 });
+    const confirmButton = dialog.getByRole('button', { name: /^Delete$/i });
+    await test$1.expect(confirmButton).toBeVisible({ timeout: 5000 });
+    await confirmButton.click();
+    await test$1.expect(page.getByText('Skill deleted', { exact: false })).toBeVisible({
+        timeout: 10000,
+    });
+    logger.info(`Deleted skill "${skillName}"`);
+}
+/**
+ * Open the delete confirmation for a skill and cancel it (no deletion).
+ */
+async function cancelDeleteSkill(page, skillName) {
+    await openSkillActionsMenu(page, skillName);
+    const deleteItem = page.getByRole('menuitem', { name: /Delete/i });
+    await deleteItem.click();
+    const dialog = page.getByRole('dialog').filter({ hasText: 'Delete Skill' });
+    await test$1.expect(dialog).toBeVisible({ timeout: 5000 });
+    const cancelButton = dialog.getByRole('button', { name: /Cancel/i });
+    await cancelButton.click();
+    await test$1.expect(dialog).not.toBeVisible({ timeout: 5000 });
+    logger.info(`Cancelled delete of skill "${skillName}"`);
+}
+// ============================
+// Combined Workflow Helpers
+// ============================
+/**
+ * Full workflow: open Sandbox tab, create a new instance, connect the mentor to it.
+ * Returns when the mentor is successfully connected.
+ */
+async function setupSandboxInstance(page, instance) {
+    await switchToSandboxTab(page);
+    await createInstance(page, instance);
+    await connectToInstance(page, instance.name);
+    await verifyConnectedInstanceCard(page);
+    logger.info(`Sandbox setup complete for "${instance.name}"`);
+}
+/**
+ * Full workflow: open Sandbox tab, disconnect the current instance (if any),
+ * then delete it from the table.
+ */
+async function teardownSandboxInstance(page, instanceName) {
+    await switchToSandboxTab(page);
+    // If a connected instance is present, disconnect first
+    const disconnectButton = page.getByRole('button', { name: /^Disconnect$/i });
+    if (await disconnectButton.isVisible().catch(() => false)) {
+        await disconnectInstance(page);
+    }
+    await deleteInstance(page, instanceName);
+    logger.info(`Sandbox teardown complete for "${instanceName}"`);
+}
+
 // ============================
 // Navigation Helpers
 // ============================
@@ -2625,8 +3440,13 @@ exports.billingCreditsSection = billingCreditsSection;
 exports.billingPlanSection = billingPlanSection;
 exports.buildReportUrl = buildReportUrl;
 exports.canChatWithEmbedMentor = canChatWithEmbedMentor;
+exports.cancelDeleteInstance = cancelDeleteInstance;
+exports.cancelDeleteSkill = cancelDeleteSkill;
+exports.cancelDisconnectInstance = cancelDisconnectInstance;
+exports.cancelNewInstanceDialog = cancelNewInstanceDialog;
 exports.checkAdminStatus = checkAdminStatus;
 exports.clearDateRangeFilter = clearDateRangeFilter;
+exports.clearInstanceSearch = clearInstanceSearch;
 exports.clickBackHome = clickBackHome;
 exports.clickBillingAddCredits = clickBillingAddCredits;
 exports.clickBillingManageBilling = clickBillingManageBilling;
@@ -2636,14 +3456,25 @@ exports.clickDownloadAgain = clickDownloadAgain;
 exports.clickManualDownloadLink = clickManualDownloadLink;
 exports.closeCreditBalanceDropdown = closeCreditBalanceDropdown;
 exports.closeWithEsc = closeWithEsc;
+exports.connectToInstance = connectToInstance;
 exports.createAuthSetup = createAuthSetup;
 exports.createEnvConfig = createEnvConfig;
+exports.createInstance = createInstance;
 exports.createPlaywrightConfig = createPlaywrightConfig;
+exports.createSkill = createSkill;
 exports.creditBalancePanel = creditBalancePanel;
 exports.creditBalancePlanBadge = creditBalancePlanBadge;
 exports.creditBalanceTrigger = creditBalanceTrigger;
 exports.deleteFirstMemory = deleteFirstMemory;
+exports.deleteInstance = deleteInstance;
 exports.deleteMemoryByContent = deleteMemoryByContent;
+exports.deleteSkill = deleteSkill;
+exports.disableSkill = disableSkill;
+exports.disconnectInstance = disconnectInstance;
+exports.editAgentPrompt = editAgentPrompt;
+exports.editInstance = editInstance;
+exports.editSkill = editSkill;
+exports.enableSkill = enableSkill;
 exports.expectBillingAutoRechargeSection = expectBillingAutoRechargeSection;
 exports.expectBillingCreditsSection = expectBillingCreditsSection;
 exports.expectBillingPlanSection = expectBillingPlanSection;
@@ -2672,10 +3503,15 @@ exports.getBillingPlanLabel = getBillingPlanLabel;
 exports.getBrowserKey = getBrowserKey;
 exports.getCreditBalancePlanLabel = getCreditBalancePlanLabel;
 exports.getCreditBalanceRemaining = getCreditBalanceRemaining;
+exports.getCurrentModel = getCurrentModel;
 exports.getCurrentTenantShowPaywall = getCurrentTenantShowPaywall;
+exports.getInstanceHealthLabel = getInstanceHealthLabel;
+exports.getInstanceRowCount = getInstanceRowCount;
+exports.getInstanceStatusLabel = getInstanceStatusLabel;
 exports.getMemoryCount = getMemoryCount;
 exports.getMentorIdFromUrl = getMentorIdFromUrl;
 exports.getPaginationInfo = getPaginationInfo;
+exports.getSkillRowCount = getSkillRowCount;
 exports.goToFirstPage = goToFirstPage;
 exports.goToLastPage = goToLastPage;
 exports.goToNextPage = goToNextPage;
@@ -2687,6 +3523,8 @@ exports.isJSON = isJSON;
 exports.isMemoryTabVisible = isMemoryTabVisible;
 exports.isOnFirstPage = isOnFirstPage;
 exports.isOnLastPage = isOnLastPage;
+exports.isSandboxTabVisible = isSandboxTabVisible;
+exports.isSkillEnabled = isSkillEnabled;
 exports.logger = logger;
 exports.loginWithEmailAndPassword = loginWithEmailAndPassword;
 exports.loginWithMicrosoftIdp = loginWithMicrosoftIdp;
@@ -2696,13 +3534,27 @@ exports.navigateToAuditLogAndWaitForData = navigateToAuditLogAndWaitForData;
 exports.navigateToDataReports = navigateToDataReports;
 exports.navigateToReportDownload = navigateToReportDownload;
 exports.openAddMemoryDialog = openAddMemoryDialog;
+exports.openAgentPromptEditModal = openAgentPromptEditModal;
 exports.openCreditBalanceDropdown = openCreditBalanceDropdown;
+exports.openEditInstanceDialog = openEditInstanceDialog;
+exports.openEditSkillDialog = openEditSkillDialog;
+exports.openInstanceActionsMenu = openInstanceActionsMenu;
+exports.openLLMProviderPicker = openLLMProviderPicker;
+exports.openNewInstanceDialog = openNewInstanceDialog;
+exports.openNewSkillDialog = openNewSkillDialog;
+exports.openSkillActionsMenu = openSkillActionsMenu;
 exports.parseReportUrlParams = parseReportUrlParams;
+exports.pushConfiguration = pushConfiguration;
 exports.reliableClick = reliableClick;
 exports.reliableFill = reliableFill;
 exports.retry = retry;
+exports.runConnectedInstanceChecks = runConnectedInstanceChecks;
+exports.runInstanceChecks = runInstanceChecks;
 exports.safeWaitForURL = safeWaitForURL;
+exports.searchInstances = searchInstances;
 exports.selectDateFromCalendar = selectDateFromCalendar;
+exports.selectLLMModel = selectLLMModel;
+exports.setupSandboxInstance = setupSandboxInstance;
 exports.shouldAddNewRowWhenClickingAddRowButton = shouldAddNewRowWhenClickingAddRowButton;
 exports.shouldAllowEditingCellValuesInCSVEditor = shouldAllowEditingCellValuesInCSVEditor;
 exports.shouldCancelCombiningReports = shouldCancelCombiningReports;
@@ -2721,23 +3573,36 @@ exports.shouldShowCombiningReportsDialog = shouldShowCombiningReportsDialog;
 exports.shouldVerifyCSVEditorDialogAccessibility = shouldVerifyCSVEditorDialogAccessibility;
 exports.signUpWithEmailAndPassword = signUpWithEmailAndPassword;
 exports.switchToMemoryTab = switchToMemoryTab;
+exports.switchToSandboxTab = switchToSandboxTab;
+exports.switchToSkillsTab = switchToSkillsTab;
+exports.teardownSandboxInstance = teardownSandboxInstance;
 exports.test = test;
+exports.toggleAutoPush = toggleAutoPush;
 exports.toggleMemorySwitch = toggleMemorySwitch;
+exports.toggleSkill = toggleSkill;
+exports.verifyAgentConfigPromptsVisible = verifyAgentConfigPromptsVisible;
 exports.verifyAuditLogEmptyState = verifyAuditLogEmptyState;
 exports.verifyAuditLogEntryStructure = verifyAuditLogEntryStructure;
 exports.verifyAuditLogGenericError = verifyAuditLogGenericError;
 exports.verifyAuditLogLoading = verifyAuditLogLoading;
 exports.verifyAuditLogPermissionError = verifyAuditLogPermissionError;
 exports.verifyAuditLogTableVisible = verifyAuditLogTableVisible;
+exports.verifyConnectDisabledForUnhealthy = verifyConnectDisabledForUnhealthy;
+exports.verifyConnectedInstanceCard = verifyConnectedInstanceCard;
 exports.verifyCurrentPage = verifyCurrentPage;
 exports.verifyDonePhase = verifyDonePhase;
 exports.verifyDownloadingPhase = verifyDownloadingPhase;
 exports.verifyErrorPhase = verifyErrorPhase;
+exports.verifyInstanceTableEmpty = verifyInstanceTableEmpty;
+exports.verifyInstanceTableVisible = verifyInstanceTableVisible;
 exports.verifyMemoryExists = verifyMemoryExists;
 exports.verifyMemoryNotExists = verifyMemoryNotExists;
 exports.verifyMemoryTabMemoriesList = verifyMemoryTabMemoriesList;
 exports.verifyMemoryTabSettings = verifyMemoryTabSettings;
 exports.verifyPreparingPhase = verifyPreparingPhase;
+exports.verifySkillVisible = verifySkillVisible;
+exports.verifySkillsEmptyState = verifySkillsEmptyState;
+exports.verifySkillsTabVisible = verifySkillsTabVisible;
 exports.waitForAuditLogDataLoaded = waitForAuditLogDataLoaded;
 exports.waitForBillingTabReady = waitForBillingTabReady;
 exports.waitForCreditBalanceLoaded = waitForCreditBalanceLoaded;