tabwright 1.0.0 → 2.0.0

package/src/doctor.ts

@@ -1,321 +0,0 @@
-import { compareVersions, supportsRelayFeatures, type ExtensionStatus } from './relay-client.js'
-import { RELAY_REVIEW_FEATURES } from './protocol.js'
-import type { TabwrightAgentSkillStatus } from './tabwright-agent-skill.js'
-
-export type DoctorCheckStatus = 'pass' | 'warn' | 'fail' | 'info'
-
-export interface DoctorSession {
-  id: string
-  browser: string | null
-  extensionId: string | null
-  cwd: string | null
-  connected?: boolean
-  pageUrl?: string | null
-  pagesCount?: number
-}
-
-export interface DoctorCheck {
-  id: 'relay' | 'extension' | 'session' | 'capabilities' | 'skill'
-  status: DoctorCheckStatus
-  message: string
-  detail?: string
-}
-
-export interface DoctorNextStep {
-  title: string
-  command?: string
-  fallbackCommand?: string
-}
-
-export interface DoctorReport {
-  ready: boolean
-  version: string
-  cwd: string
-  checks: DoctorCheck[]
-  next: DoctorNextStep
-}
-
-export function buildDoctorReport(options: {
-  version: string
-  cwd: string
-  remote: boolean
-  relayVersion: string | null
-  relayFeatures?: string[] | null
-  relayError?: string | null
-  extensions: ExtensionStatus[]
-  sessions: DoctorSession[]
-  capabilityCount: number
-  skillStatus?: TabwrightAgentSkillStatus
-}): DoctorReport {
-  const usableSessions = options.sessions.filter((session) => {
-    if (session.connected === false) {
-      return false
-    }
-    if (!session.extensionId) {
-      return true
-    }
-    return options.extensions.some((extension) => {
-      return (
-        (extension.extensionId === session.extensionId || extension.stableKey === session.extensionId) &&
-        extension.activeTargets > 0
-      )
-    })
-  })
-  const newerExtension = options.extensions.find((extension) => {
-    return extension.playwriterVersion && compareVersions(extension.playwriterVersion, options.version) > 0
-  })
-  const relayFeatureMismatch =
-    options.relayFeatures !== undefined &&
-    !supportsRelayFeatures({ features: options.relayFeatures, requiredFeatures: RELAY_REVIEW_FEATURES })
-  const relayCheck: DoctorCheck = (() => {
-    if (!options.relayVersion) {
-      return {
-        id: 'relay',
-        status: 'fail',
-        message: `${options.remote ? 'Remote' : 'Local'} relay is not reachable.`,
-        detail:
-          options.relayError ||
-          (options.remote
-            ? 'Check the relay host, token, and network path.'
-            : 'Tabwright could not start or reach the relay. Read the relay log for the underlying error.'),
-      }
-    }
-    if (compareVersions(options.relayVersion, options.version) < 0) {
-      return {
-        id: 'relay',
-        status: 'warn',
-        message: `Relay ${options.relayVersion} is older than CLI ${options.version}.`,
-        detail: 'Restart Tabwright so the CLI can replace the older relay.',
-      }
-    }
-    if (relayFeatureMismatch) {
-      return {
-        id: 'relay',
-        status: 'warn',
-        message: `Relay ${options.relayVersion} is reachable, but current saved-data features are missing.`,
-        detail: 'Core browser control may still work. Restart Tabwright before using recordings or capabilities.',
-      }
-    }
-    return {
-      id: 'relay',
-      status: 'pass',
-      message: `Relay ${options.relayVersion} is reachable.`,
-    }
-  })()
-
-  const extensionCheck: DoctorCheck = (() => {
-    if (options.extensions.length === 0) {
-      return {
-        id: 'extension',
-        status: usableSessions.length > 0 ? 'info' : 'fail',
-        message: 'No Chrome extension connection was found.',
-        detail:
-          'User-Chrome workflows and replay recording require the extension; direct, headless, and cloud sessions do not.',
-      }
-    }
-
-    const activeTargets = options.extensions.reduce((total, extension) => {
-      return total + extension.activeTargets
-    }, 0)
-    if (activeTargets === 0) {
-      return {
-        id: 'extension',
-        status: 'warn',
-        message: `${options.extensions.length} extension connection(s) found, but no tab is enabled.`,
-        detail: 'Open the target tab and click the Tabwright extension icon until it turns green.',
-      }
-    }
-
-    const legacyCount = options.extensions.filter((extension) => {
-      return extension.connectionHealth === 'legacy' || !extension.features
-    }).length
-    const missingFeatures = [
-      ...new Set(
-        options.extensions.flatMap((extension) => {
-          return extension.missingFeatures || []
-        }),
-      ),
-    ]
-    const compatibilityDetails = [
-      legacyCount > 0
-        ? `${legacyCount} connection(s) use the legacy handshake, so optional feature support is unknown.`
-        : '',
-      missingFeatures.length > 0 ? `Missing optional features: ${missingFeatures.join(', ')}.` : '',
-    ].filter((detail) => {
-      return detail.length > 0
-    })
-    if (compatibilityDetails.length > 0) {
-      const versionDetail = newerExtension?.playwriterVersion
-        ? ` Extension ${newerExtension.playwriterVersion} is newer than CLI ${options.version}.`
-        : ''
-      return {
-        id: 'extension',
-        status: 'warn',
-        message: `${options.extensions.length} extension connection(s), ${activeTargets} enabled tab(s); core browser control is available with limited optional features.`,
-        detail: `${compatibilityDetails.join(' ')}${versionDetail}`,
-      }
-    }
-
-    if (newerExtension?.playwriterVersion) {
-      return {
-        id: 'extension',
-        status: 'info',
-        message: `${options.extensions.length} extension connection(s), ${activeTargets} enabled tab(s); negotiated features are ready.`,
-        detail: `Extension ${newerExtension.playwriterVersion} is newer than CLI ${options.version}, but the advertised feature set is fully supported.`,
-      }
-    }
-
-    return {
-      id: 'extension',
-      status: 'pass',
-      message: `${options.extensions.length} extension connection(s), ${activeTargets} enabled tab(s).`,
-    }
-  })()
-
-  const sessionCheck: DoctorCheck =
-    usableSessions.length > 0
-      ? {
-          id: 'session',
-          status: 'pass',
-          message: `${usableSessions.length} usable session(s).`,
-          detail: `Healthy session: ${usableSessions[0]!.id}. Only reuse a session you created for this task.`,
-        }
-      : {
-          id: 'session',
-          status: 'warn',
-          message:
-            options.sessions.length > 0
-              ? 'Session records exist, but none are currently usable.'
-              : 'No active session exists yet.',
-          detail:
-            options.sessions.length > 0
-              ? 'Reconnect or enable the matching browser before reusing a session.'
-              : 'Create one before running Playwright code.',
-        }
-
-  const capabilityCheck: DoctorCheck =
-    options.capabilityCount > 0
-      ? {
-          id: 'capabilities',
-          status: 'pass',
-          message: `${options.capabilityCount} saved ${options.capabilityCount === 1 ? 'capability is' : 'capabilities are'} discoverable from this directory.`,
-        }
-      : {
-          id: 'capabilities',
-          status: 'info',
-          message: 'No saved capabilities are discoverable from this directory yet.',
-          detail: 'This does not block browser control. Record or create a capability after the first successful task.',
-        }
-
-  const skillCheck: DoctorCheck | null = (() => {
-    if (!options.skillStatus) {
-      return null
-    }
-    if (options.skillStatus.state === 'current') {
-      return {
-        id: 'skill',
-        status: 'pass',
-        message: 'The installed Tabwright skill matches this CLI.',
-        detail: options.skillStatus.installedPath,
-      }
-    }
-    return {
-      id: 'skill',
-      status: 'warn',
-      message:
-        options.skillStatus.state === 'missing'
-          ? 'The Tabwright skill is not installed for Codex.'
-          : 'The installed Tabwright skill does not match this CLI.',
-      detail: `Run: ${options.skillStatus.installCommand}`,
-    }
-  })()
-
-  const next: DoctorNextStep = (() => {
-    if (!options.relayVersion) {
-      return {
-        title: options.remote
-          ? 'Check the remote relay host, token, and network path, then run doctor again.'
-          : 'Read the relay log, fix the startup error, then run doctor again.',
-        ...(options.remote ? {} : { command: 'tabwright logfile' }),
-      }
-    }
-
-    if (relayFeatureMismatch) {
-      return {
-        title: 'Restart the local service so recordings and capabilities become available.',
-        command: 'tabwright session list',
-      }
-    }
-
-    if (options.skillStatus && options.skillStatus.state !== 'current') {
-      return {
-        title:
-          options.skillStatus.state === 'missing'
-            ? 'Install the Tabwright skill bundled with this CLI.'
-            : 'Update the installed Tabwright skill to match this CLI.',
-        command: options.skillStatus.installCommand,
-      }
-    }
-
-    const enabledExtension = options.extensions.find((extension) => {
-      return extension.activeTargets > 0
-    })
-    if (enabledExtension) {
-      return {
-        title: 'Create a task-owned session for the enabled Chrome tab.',
-        command: enabledExtension.stableKey
-          ? `tabwright session new --browser ${enabledExtension.stableKey}`
-          : 'tabwright session new',
-      }
-    }
-
-    if (usableSessions.length > 0) {
-      return {
-        title: 'Create a task-owned headless session instead of reusing another agent session.',
-        command: 'tabwright session new --browser headless',
-      }
-    }
-
-    if (options.extensions.length > 0) {
-      return {
-        title: 'Open the target tab and click the Tabwright extension icon until it turns green.',
-        fallbackCommand: 'tabwright session new --browser headless',
-      }
-    }
-
-    return {
-      title: 'Connect your Chrome extension, or start a standalone headless session.',
-      command: 'tabwright session new --browser headless',
-    }
-  })()
-
-  return {
-    ready: relayCheck.status !== 'fail' && extensionCheck.status !== 'fail' && sessionCheck.status === 'pass',
-    version: options.version,
-    cwd: options.cwd,
-    checks: [relayCheck, extensionCheck, sessionCheck, capabilityCheck, ...(skillCheck ? [skillCheck] : [])],
-    next,
-  }
-}
-
-export function formatDoctorReport(report: DoctorReport): string {
-  const symbols: Record<DoctorCheckStatus, string> = {
-    pass: 'PASS',
-    warn: 'WARN',
-    fail: 'FAIL',
-    info: 'INFO',
-  }
-  const checks = report.checks.flatMap((check) => {
-    return [`[${symbols[check.status]}] ${check.message}`, ...(check.detail ? [`       ${check.detail}`] : [])]
-  })
-  return [
-    `Tabwright doctor ${report.version}`,
-    `Directory: ${report.cwd}`,
-    '',
-    ...checks,
-    '',
-    `Next: ${report.next.title}`,
-    ...(report.next.command ? [`  ${report.next.command}`] : []),
-    ...(report.next.fallbackCommand ? [`Fallback: ${report.next.fallbackCommand}`] : []),
-  ].join('\n')
-}

package/src/editor-examples.ts

@@ -1,158 +0,0 @@
-import { page, getCDPSession, createEditor, console } from './debugger-examples-types.js'
-
-// Example: List available scripts
-async function listScripts() {
-  const cdp = await getCDPSession({ page })
-  const editor = createEditor({ cdp })
-  await editor.enable()
-
-  const scripts = editor.list({ pattern: /app/ })
-  console.log(scripts)
-}
-
-// Example: Read a script with line numbers
-async function readScript() {
-  const cdp = await getCDPSession({ page })
-  const editor = createEditor({ cdp })
-  await editor.enable()
-
-  const { content, totalLines } = await editor.read({
-    url: 'https://example.com/app.js',
-  })
-  console.log('Total lines:', totalLines)
-  console.log(content)
-
-  const { content: partial } = await editor.read({
-    url: 'https://example.com/app.js',
-    offset: 100,
-    limit: 50,
-  })
-  console.log(partial)
-}
-
-// Example: Edit a script (exact string replacement)
-async function editScript() {
-  const cdp = await getCDPSession({ page })
-  const editor = createEditor({ cdp })
-  await editor.enable()
-
-  await editor.edit({
-    url: 'https://example.com/app.js',
-    oldString: 'const DEBUG = false',
-    newString: 'const DEBUG = true',
-  })
-
-  const dryRunResult = await editor.edit({
-    url: 'https://example.com/app.js',
-    oldString: 'old code',
-    newString: 'new code',
-    dryRun: true,
-  })
-  console.log('Dry run result:', dryRunResult)
-}
-
-// Example: Search across all scripts
-async function searchScripts() {
-  const cdp = await getCDPSession({ page })
-  const editor = createEditor({ cdp })
-  await editor.enable()
-
-  const matches = await editor.grep({ regex: /console\.log/ })
-  console.log(matches)
-
-  const todoMatches = await editor.grep({
-    regex: /TODO|FIXME/i,
-    pattern: /app/,
-  })
-  console.log(todoMatches)
-}
-
-// Example: Write entire script content
-async function writeScript() {
-  const cdp = await getCDPSession({ page })
-  const editor = createEditor({ cdp })
-  await editor.enable()
-
-  const { content } = await editor.read({ url: 'https://example.com/app.js' })
-  const newContent = content.replace(/console\.log/g, 'console.debug')
-
-  await editor.write({
-    url: 'https://example.com/app.js',
-    content: newContent,
-  })
-}
-
-// Example: Edit an inline script (scripts without URL get inline://{id} URLs)
-async function editInlineScript() {
-  const cdp = await getCDPSession({ page })
-  const editor = createEditor({ cdp })
-  await editor.enable()
-
-  const matches = await editor.grep({ regex: /myFunction/ })
-  if (matches.length > 0) {
-    const { url } = matches[0]
-    console.log('Found in:', url)
-
-    await editor.edit({
-      url,
-      oldString: 'return false',
-      newString: 'return true',
-    })
-  }
-}
-
-// Example: List and read CSS stylesheets
-async function readStylesheet() {
-  const cdp = await getCDPSession({ page })
-  const editor = createEditor({ cdp })
-  await editor.enable()
-
-  const stylesheets = await editor.list({ pattern: /\.css/ })
-  console.log('Stylesheets:', stylesheets)
-
-  if (stylesheets.length > 0) {
-    const { content, totalLines } = await editor.read({
-      url: stylesheets[0],
-    })
-    console.log('Total lines:', totalLines)
-    console.log(content)
-  }
-}
-
-// Example: Edit a CSS stylesheet
-async function editStylesheet() {
-  const cdp = await getCDPSession({ page })
-  const editor = createEditor({ cdp })
-  await editor.enable()
-
-  await editor.edit({
-    url: 'https://example.com/styles.css',
-    oldString: 'color: red',
-    newString: 'color: blue',
-  })
-}
-
-// Example: Search CSS for specific properties
-async function searchStyles() {
-  const cdp = await getCDPSession({ page })
-  const editor = createEditor({ cdp })
-  await editor.enable()
-
-  const matches = await editor.grep({
-    regex: /background-color/,
-    pattern: /\.css/,
-  })
-  console.log(matches)
-}
-
-export {
-  listScripts,
-  readScript,
-  editScript,
-  searchScripts,
-  writeScript,
-  editInlineScript,
-  readStylesheet,
-  editStylesheet,
-  searchStyles,
-}