WeChat Mini-Program Automation

Overview

Use

miniprogram-automator

to drive the WeChat DevTools to complete page navigation, element querying, interaction, Mocking, runtime monitoring, screenshots, and regression verification.

This skill defaults to a practical reference-style output:

Prioritize providing directly runnable standalone Node.js script templates
Output Jest versions only when users explicitly request integration with a testing framework
Confirm the solution and prerequisites first, then proceed to script implementation

Default Output Structure

When triggered, answer following this structure first:

Explain the plan first: What type of script will be generated, which inputs are required
List pre-check items: Project directory, CLI path, security settings, page path, selectors
Provide complete scripts: Prioritize standalone scripts, supplement with Jest version if necessary
Provide run commands: Install dependencies, execution commands, optional parameters
Provide verification points and notes: Waiting strategies, Mock restoration, connection closure, screenshot limitations

If the user has provided complete path, page, selector, and target behavior, do not repeatedly ask questions and directly deliver the script.

Step 1: Collect Key Inputs First

If the user hasn't provided complete information, first fill in these fields:

1.1 Project directory openable by DevTools

The

projectPath

automator.launch({ projectPath })

should be the actual directory opened by DevTools.

Do not mechanically interpret it as the "source code repository root directory":

Native mini-programs: Usually the directory containing
```
project.config.json
```
/
```
app.json
```
Taro / uni-app / custom build chains: Usually the compiled output directory actually opened by DevTools, such as
```
dist/
```
,
```
build/
```
,
```
miniprogram/
```

If unsure, ask the user first:

"Do you usually open the source code root directory or the compiled dist/build directory in WeChat DevTools?"

1.2 WeChat DevTools CLI Path

Common default paths:

macOS:

/Applications/wechatwebdevtools.app/Contents/MacOS/cli

Windows:

C:\Program Files (x86)\Tencent\微信web开发者工具\cli.bat

If DevTools is installed in a standard location,

cliPath

can be omitted, and the SDK will automatically find it by the default path.

If the user's environment is non-standard, ask the user to confirm the actual path first.

1.3 miniprogram-automator Version

Must use version
0.12.0
or above, otherwise CLI command format compatibility issues will be triggered.

Older versions (such as

0.5.x

) use the deprecated

cli --auto <path>

syntax, which is no longer supported by the current WeChat DevTools (3.x), manifesting as:

[error] { code: 31, message: "Error: Missing param 'project / appid'" }

Upgrade method:

bash

npm install miniprogram-automator@latest --save-dev

New versions (

0.12.x

) use the correct

cli auto --project <path> --auto-port <port>

syntax.

1.4 Security Settings

Before using

automator.launch()

, must remind the user to check:

WeChat DevTools → Settings → Security Settings → Enable Service Port

Without this step, common script behaviors include:

Launch failure
Connection timeout
CLI executable but WebSocket cannot be established

1.5 Target Page and Assertion Targets

At least confirm:

Page path, such as
```
/pages/home/index
```
Whether to use
```
reLaunch
```
/
```
navigateTo
```
/
```
switchTab
```
What to verify: Text, class names, data, screenshots, logs, exceptions, Mock request results
Whether key selectors are stable

Step 2: Choose the Correct Workflow

2.1

launch

connect

Three workflows, choose according to scenarios:

Scenario	Recommended Method
Fully automated: Script starts DevTools itself	`automator.launch()`
DevTools is already running, connect directly	CLI v2 + `automator.connect()`
DevTools is running and automation port is ready	Direct `automator.connect()`

Method 1:
automator.launch()
(Fully Automated Launch)

The SDK internally calls the CLI to start DevTools, no manual operation required. Two hard prerequisites:

DevTools must be completely closed (Cmd+Q), otherwise it will report
```
Failed to launch wechat web devTools
```
— launch cannot coexist with running instances.
"Trust Project" confirmation box pops up for the first run, requiring manual click by the user, so
```
timeout
```
is recommended to be
```
120000
```
(2 minutes).

miniProgram = await automator.launch({
  cliPath: CLI_PATH,
  projectPath: PROJECT_PATH,
  timeout: 120000,
})

Method 2: CLI v2 +
automator.connect()
(DevTools Already Running)

When DevTools has already opened the project (and you don't want to close and restart it), use the CLI v2 command to enable the automation WebSocket port, then connect with

connect()

automator.launch()
actually still uses the old CLI format (
cli --auto <path>
) internally, which may fail on some new versions of DevTools. If
launch()
reports an error, switching to this method is usually more stable.

const { spawnSync } = require('node:child_process')

const CLI_PATH = process.env.WECHAT_DEVTOOLS_CLI ||
  '/Applications/wechatwebdevtools.app/Contents/MacOS/cli'
const PROJECT_PATH = process.env.MINIPROGRAM_PROJECT_PATH || '/path/to/project'
const AUTO_PORT = Number(process.env.WECHAT_AUTO_PORT || 9420)

// Step 1: Enable automation ws port with CLI v2
// If the DevTools HTTP service port is not the default value, pass it via --port
function enableAutomation(httpPort) {
  const args = ['auto', '--project', PROJECT_PATH, '--auto-port', String(AUTO_PORT)]
  if (httpPort) args.push('--port', String(httpPort))
  const result = spawnSync(CLI_PATH, args, { encoding: 'utf8', timeout: 20000 })
  return { success: result.status === 0, output: (result.stdout || '') + (result.stderr || '') }
}

const { success, output } = enableAutomation()
if (!success) throw new Error(`CLI auto command failed:\n${output}`)

// Step 2: Connect to the automation ws endpoint
const miniProgram = await automator.connect({
  wsEndpoint: `ws://127.0.0.1:${AUTO_PORT}`,
})

Port Conflict Issue: If the DevTools HTTP service port is not the default value (e.g., due to multiple instances), adding

--port

to the CLI v2 command will cause a conflict error. To detect the actual port: call the CLI once with a placeholder port, then parse the actual port from the output. See Template E for a complete example.

Method 3: Direct
automator.connect()
(Port Already Ready)

DevTools has manually enabled the automation port (via tool menu or previous CLI v2 call), connect directly:

const miniProgram = await automator.connect({
  wsEndpoint: 'ws://localhost:9420',
})

Note:

miniProgram.close()

obtained via

connect()

only disconnects the WebSocket connection and does not close DevTools.

2.2 Standalone Script or Jest

Scenario	Recommendation
Temporary verification, single-page debugging, script tooling	Standalone Node.js script
Regression testing, multiple cases, team collaboration, CI	Jest

2.3 How to Choose Waiting Strategy

Priority is as follows:

```
await page.waitFor('stable selector')
```

await page.waitFor(async () => condition is met)

await page.waitFor(number of milliseconds)

as a fallback

Do not rely entirely on fixed

sleep(2000)

from the start. Fixed waiting can only be used as a fallback, not the main synchronization method.

Step 3: Core Rules

3.1 Prioritize

waitFor

for Page Waiting

page.waitFor()

supports three forms:

await page.waitFor('.page-title')
await page.waitFor(async () => (await page.$$('.loaded-item')).length > 0)
await page.waitFor(500)

Recommended writing: Use selector or real condition assertion waiting first, then add a short fallback waiting. Do not write condition functions that always return

true

3.2 Page-level Selectors Cannot Penetrate Custom Components

This is the most common mistake.

Wrong Approach:

const input = await page.$('form-panel input')

Correct Approach:

const panel = await page.$('form-panel')
const input = await panel.$('input')

Reason: The query scope of

page.$

page.$$

is the page root node, and cannot directly select elements inside custom components; even using descendant selectors like

form-panel input

won't work. To select elements inside a component, first get the component host element, then use

element.$

element.$$

to continue querying within the component scope.

3.3 Prioritize

value()

property('value')

When Reading Input Values

If the target is a native

input

textarea

const value = await input.value()
// or
const value2 = await input.property('value')

If the target is a custom component instance, then consider:

const data = await panel.data()

Do not confuse "reading native input values" with "reading component internal data".

data()

is more suitable for component instances, not a general method for reading input boxes.

3.4 Prioritize Official

mockWxMethod

for Mocking WeChat APIs

If the task is to mock

wx.request

wx.getLocation

, etc., prioritize using:

await miniProgram.mockWxMethod('request', (options = {}) => {
  const res = {
    data: { code: 0, list: [{ id: 1, title: 'Mock Item A' }] },
    statusCode: 200,
    header: { 'content-type': 'application/json' },
    cookies: [],
    errMsg: 'request:ok',
  }

  Promise.resolve().then(() => {
    if (typeof options.success === 'function') options.success(res)
    if (typeof options.complete === 'function') options.complete(res)
  })

  return {
    abort() {},
    onHeadersReceived() {},
    offHeadersReceived() {},
    onChunkReceived() {},
    offChunkReceived() {},
  }
})

Restore when finished:

await miniProgram.restoreWxMethod('request')

Additional Notes:

```
mockWxMethod
```
also supports directly passing a fixed result object; no need to always write functions for simple scenarios
If a function is passed, the function body will be serialized and executed, do not rely on closure references to external variables
If you need to call the original wx method, you can use
```
this.origin
```
inside the function

Only consider

evaluate()

when the user explicitly needs deeper runtime injection, or when

mockWxMethod

cannot cover the target scenario.

3.5 Use

miniProgram.screenshot()

for Screenshots, and Only for DevTools Simulator

await miniProgram.screenshot({ path: '/abs/path/to/file.png' })

Additional Notes:

When passing
```
{ path }
```
, the screenshot will be saved to a file
When no parameters are passed, it returns the base64 encoding of the image data, suitable for in-memory comparison or upload

Must remind:

Screenshots are only applicable to the DevTools Simulator
Not applicable to real machine debugging screens
Ensure the page has rendered stably before taking screenshots

3.6 Cleanup Actions Must Be Put in

finally

Whether it's a standalone script or Jest, ensure:

Restore mocked wx methods
Unbind event listeners (if used)
Close the mini-program instance

try {
  // Execute test logic
} finally {
  await miniProgram.restoreWxMethod('request').catch(() => {})
  await miniProgram.close().catch(() => {})
}

Template A: General Skeleton for Standalone Scripts

When the user says "give me a script", "don't change the testing framework yet", "want to run it quickly", start with this template first.

const automator = require('miniprogram-automator')
const path = require('node:path')
const fs = require('node:fs/promises')

const CLI_PATH = process.env.WECHAT_DEVTOOLS_CLI || '/Applications/wechatwebdevtools.app/Contents/MacOS/cli'
const PROJECT_PATH = process.env.MINIPROGRAM_PROJECT_PATH || '/absolute/path/to/devtools-project'
const TARGET_PAGE = '/pages/home/index'  // Must start with /
const OUTPUT_DIR = path.resolve(process.cwd(), 'outputs')

async function main() {
  let miniProgram
  try {
    await fs.mkdir(OUTPUT_DIR, { recursive: true })

    // Prerequisite: DevTools is completely closed (Cmd+Q); first run requires confirming trust project in the interface
    miniProgram = await automator.launch({
      cliPath: CLI_PATH,
      projectPath: PROJECT_PATH,
      timeout: 120000,  // Leave enough time for first launch + user trust confirmation
    })

    const page = await miniProgram.reLaunch(TARGET_PAGE)

    // Prioritize stable selectors for main synchronization, fixed waiting only for short fallback
    await page.waitFor('.page-title')
    await page.waitFor(100)
    const title = await page.$('.page-title')
    const titleText = await title.text()

    console.log('Current title: ', titleText)

    await miniProgram.screenshot({
      path: path.join(OUTPUT_DIR, 'current-page.png'),
    })

    console.log('Screenshot completed')
  } finally {
    if (miniProgram) {
      await miniProgram.close()
    }
  }
}

main().catch((error) => {
  console.error(error)
  process.exit(1)
})

Template B: Input and Validation Inside Custom Components

When the user mentions "there's an input in the component", "why can't page.$ find it", "need to read value or data", use this template.

const automator = require('miniprogram-automator')

async function run() {
  let miniProgram
  try {
    miniProgram = await automator.launch({
      cliPath: process.env.WECHAT_DEVTOOLS_CLI || '/Applications/wechatwebdevtools.app/Contents/MacOS/cli',
      projectPath: process.env.MINIPROGRAM_PROJECT_PATH || '/absolute/path/to/devtools-project',
    })

    const page = await miniProgram.reLaunch('/pages/form/index')
    await page.waitFor(300)

    const panel = await page.$('form-panel')
    if (!panel) throw new Error('form-panel not found')

    const input = await panel.$('input')
    if (!input) throw new Error('Input inside component not found')

    await input.tap()
    await input.input('13800138000')

    await page.waitFor(100)

    const value = await input.value()
    if (value !== '13800138000') {
      throw new Error(`Input value does not match expectation: ${value}`)
    }

    // panel must be a custom component instance; native components or ordinary elements are not suitable for reading internal state with data()
    const panelData = await panel.data().catch(() => null)
    console.log('panel.data() =', panelData)
  } finally {
    if (miniProgram) await miniProgram.close()
  }
}

run().catch((error) => {
  console.error(error)
  process.exit(1)
})

When answering, clearly explain:

```
page.$
```
cannot cross component boundaries
Prioritize
```
value()
```
/
```
property('value')
```
for reading native input values
Use component instance's
```
data()
```
to read component internal state

Template C: Mock

wx.request

+ Listen to

console/exception

When the user wants to create regression scripts, fake interfaces, offline verification, or exception monitoring, prioritize this template.

First check the real feedback path of the target page: Some pages only update

loading

, print

console

, or pop toast after successful requests, instead of rendering lists or tables. For example, the official demo's

packageAPI/pages/network/request/request

belongs to this type, so assertions should be designed around button status, logs, toast, or page data, rather than assuming the page will definitely render a list.

const automator = require('miniprogram-automator')

async function run() {
  let miniProgram
  const consoleEvents = []
  const exceptionEvents = []

  try {
    miniProgram = await automator.launch({
      cliPath: process.env.WECHAT_DEVTOOLS_CLI || '/Applications/wechatwebdevtools.app/Contents/MacOS/cli',
      projectPath: process.env.MINIPROGRAM_PROJECT_PATH || '/absolute/path/to/devtools-project',
    })

    miniProgram.on('console', (payload) => {
      consoleEvents.push(payload)
    })

    miniProgram.on('exception', (payload) => {
      exceptionEvents.push(payload)
    })

    await miniProgram.mockWxMethod('request', (options = {}) => {
      const res = {
        data: {
          code: 0,
          list: [
            { id: 1, title: 'Mock Item A' },
            { id: 2, title: 'Mock Item B' },
          ],
        },
        statusCode: 200,
        header: { 'content-type': 'application/json' },
        cookies: [],
        errMsg: 'request:ok',
      }

      Promise.resolve().then(() => {
        if (typeof options.success === 'function') options.success(res)
        if (typeof options.complete === 'function') options.complete(res)
      })

      return {
        abort() {},
        onHeadersReceived() {},
        offHeadersReceived() {},
        onChunkReceived() {},
        offChunkReceived() {},
      }
    })

    const page = await miniProgram.reLaunch('/packageAPI/pages/network/request/request')
    await page.waitFor('button')

    const button = await page.$('button')
    if (!button) {
      throw new Error('Request page button not found')
    }

    await button.tap()
    await page.waitFor(100)

    const pageData = await page.data().catch(() => ({}))
    if (pageData.loading !== false) {
      throw new Error(`Loading status abnormal after request: ${JSON.stringify(pageData)}`)
    }

    const successLogs = consoleEvents.filter((event) => {
      if (!event || typeof event !== 'object' || !Array.isArray(event.args)) return false
      return event.args.some((arg) => String(arg).includes('request success'))
    })

    if (!successLogs.length) {
      throw new Error(`No request success logs observed: ${JSON.stringify(consoleEvents)}`)
    }

    const consoleErrors = consoleEvents.filter((event) => {
      return event && typeof event === 'object' && event.type === 'error'
    })

    if (consoleErrors.length) {
      throw new Error(`console.error exists: ${JSON.stringify(consoleErrors)}`)
    }

    if (exceptionEvents.length) {
      throw new Error(`Exceptions exist: ${JSON.stringify(exceptionEvents)}`)
    }
  } finally {
    if (miniProgram) {
      await miniProgram.restoreWxMethod('request').catch(() => {})
      await miniProgram.close().catch(() => {})
    }
  }
}

run().catch((error) => {
  console.error(error)
  process.exit(1)
})

Additional Notes:

The payload obtained by the
```
console
```
event callback usually contains
```
type
```
and
```
args
```
When judging failures, prioritize filtering by
```
payload.type === 'error'
```
, do not count normal
```
log
```
as failures

Template E: Complete Script for CLI v2 +

connect()

When the user says "DevTools is already open", "don't want to restart the tool", "launch reports an error and want to switch methods", use this template.

const automator = require('miniprogram-automator')
const path = require('node:path')
const fs = require('node:fs/promises')
const { spawnSync } = require('node:child_process')

const CLI_PATH =
  process.env.WECHAT_DEVTOOLS_CLI ||
  '/Applications/wechatwebdevtools.app/Contents/MacOS/cli'

// projectPath is the actual directory opened by DevTools (contains project.config.json)
const PROJECT_PATH =
  process.env.MINIPROGRAM_PROJECT_PATH || '/absolute/path/to/project'

// Automation WebSocket port, default 9420
const AUTO_PORT = Number(process.env.WECHAT_AUTO_PORT || 9420)

const TARGET_PAGE = '/pages/home/index'
const OUTPUT_DIR = path.resolve(process.cwd(), 'outputs')

/**
 * Detect the current HTTP service port of DevTools.
 * Principle: Call the CLI once with a placeholder port, then parse the actual port from the error output.
 * If the tool is not running, return null (CLI will start it automatically).
 */
function detectHttpPort() {
  if (process.env.WECHAT_DEVTOOLS_PORT) {
    return Number(process.env.WECHAT_DEVTOOLS_PORT)
  }
  try {
    const result = spawnSync(
      CLI_PATH,
      ['auto', '--project', PROJECT_PATH, '--port', '9999'],
      { encoding: 'utf8', timeout: 8000 },
    )
    const output = (result.stdout || '') + (result.stderr || '')
    const match = output.match(/started on http:\/\/127\.0\.0\.1:(\d+)/)
    if (match) return Number(match[1])
  } catch (_) {}
  return null
}

/**
 * Enable automation WebSocket port with CLI v2 command.
 * Command: cli auto --project <path> --auto-port <port> [--port <httpPort>]
 */
function enableAutomation(httpPort) {
  const args = ['auto', '--project', PROJECT_PATH, '--auto-port', String(AUTO_PORT)]
  if (httpPort) args.push('--port', String(httpPort))
  const result = spawnSync(CLI_PATH, args, { encoding: 'utf8', timeout: 20000 })
  return {
    success: result.status === 0,
    output: (result.stdout || '') + (result.stderr || ''),
  }
}

async function main() {
  let miniProgram
  try {
    await fs.mkdir(OUTPUT_DIR, { recursive: true })

    // Step 1: Detect HTTP port to avoid CLI port conflict errors
    const httpPort = detectHttpPort()
    console.log(httpPort ? `HTTP Port: ${httpPort}` : 'No HTTP port detected, started by CLI')

    // Step 2: Enable automation ws port with CLI v2
    const { success, output } = enableAutomation(httpPort)
    if (!success) throw new Error(`CLI auto command failed:\n${output}`)
    console.log('Automation port is ready')

    // Step 3: Connect to ws endpoint
    miniProgram = await automator.connect({
      wsEndpoint: `ws://127.0.0.1:${AUTO_PORT}`,
    })
    console.log('Connected')

    // Step 4: Navigate to page and operate
    const page = await miniProgram.reLaunch(TARGET_PAGE)
    await page.waitFor('.page-title')
    await page.waitFor(200)

    await miniProgram.screenshot({ path: path.join(OUTPUT_DIR, 'page.png') })
    console.log('Screenshot completed')
  } finally {
    if (miniProgram) {
      // In connect mode, close() only disconnects the ws connection, does not close DevTools
      await miniProgram.close().catch(() => {})
    }
  }
}

main().catch((error) => {
  console.error(error)
  process.exit(1)
})

Additional Notes:

```
close()
```
in
```
connect()
```
mode only disconnects the WebSocket connection and does not close the DevTools window — this is different from the behavior of
```
close()
```
after
```
launch()
```
```
--auto-port
```
is the automation ws port (used by automator to connect),
```
--port
```
is the tool's HTTP service port (used by CLI management), they are different
If unsure about the tool's HTTP port, use
```
detectHttpPort()
```
to detect first; if the tool is not running, CLI will start it automatically

Template D: Batch Screenshot Script Snippet

When the user wants to batch screenshot multiple pages, perform visual regression, or output a PNG list, this segment can be reused.

const PAGES = [
  { id: 'home', path: '/pages/home/index' },
  { id: 'list', path: '/pages/list/index' },
]

for (const item of PAGES) {
  const page = await miniProgram.reLaunch(item.path)
  await page.waitFor(500)
  await miniProgram.screenshot({
    path: path.join(OUTPUT_DIR, `${item.id}.png`),
  })
}

Additional Notes:

If the page relies on asynchronous requests or animations, do not rely solely on
```
waitFor(500)
```
, cooperate with selector waiting
It's better to output
```
index.json
```
to summarize whether each page is successful
When the user only wants to take screenshots, a dedicated script can also be generated directly in this direction

When to Provide Jest Versions

If the user explicitly says "write as Jest cases", "integrate with CI", "create regression suites", rewrite the standalone script into:

```
beforeAll
```
: Launch
```
miniProgram
```
```
afterAll
```
: Restore Mocks, close
```
miniProgram
```
```
test/it
```
: Execute page navigation, interaction, and assertions

But do not switch to Jest by default when the user only wants "a script template", as this will complicate simple problems.

Common Errors and Corrections

Common Error	Correct Approach
Fix `projectPath` as the source code repository root directory	Set it to "the actual directory opened by DevTools"; in scenarios like Taro, it may be `dist/`
Only remind to install dependencies, not security settings	Must remind to enable the service port
Rely entirely on fixed `sleep`	Prioritize `page.waitFor(selector/condition)`
Use `page.$('form-panel input')` to query elements inside components	First `page.$('form-panel')` , then `panel.$('input')`
Use runtime patch `wx.request` as the default solution	Default to `miniProgram.mockWxMethod('request', ...)`
Forget to restore mocks	Use `restoreWxMethod` in `finally` or `afterAll`
Treat screenshots as a real machine capability	Clearly state that screenshots only support DevTools simulator
Directly read `input.data()` as a general solution	For native input boxes, prioritize `value()` / `property('value')` ; read component state via component instance's `data()`
Use old versions of `miniprogram-automator` (0.5.x, etc.)	Upgrade to `0.12.0+` ; old CLI command format is deprecated and will report code 31 error
Call `automator.launch()` when DevTools is already running	Ensure DevTools is completely closed (Cmd+Q) before launch
Do not set timeout or set too short timeout for `launch()`	First launch + user trust confirmation takes time, recommend `timeout: 120000`
Page path does not start with `/` (e.g., `page/component/index` )	Must start with `/` (e.g., `/page/component/index` ), otherwise the path will be incorrectly concatenated
Directly screenshot pages that may time out with selector waiting (e.g., home page list)	For complex pages like home page, fixed waiting `waitFor(2000)` as fallback is more reliable
Still use `launch()` when DevTools is open, or `launch()` always reports errors	Switch to CLI v2 + `connect()` method: First execute `cli auto --project <path> --auto-port <port>` to enable automation port, then `automator.connect({ wsEndpoint })`
`close()` after `connect()` closes DevTools	In connect mode, `close()` only disconnects the ws connection, does not close the tool window; behavior differs from `launch()`

Troubleshooting Tips

Launch Failure / Timeout

Check these first:

Whether
```
miniprogram-automator
```
version is
```
>= 0.12.0
```
(old versions will report code 31)
Whether DevTools is completely closed (launch() cannot coexist with running instances)
Whether DevTools is installed and logged in
Whether CLI path is correct
Whether Security Settings → Service Port is enabled
Whether
```
projectPath
```
is really the directory opened by DevTools (contains
```
project.config.json
```
)
Whether a sufficiently long
```
timeout
```
is set (recommend
```
120000
```
for first launch)

launch()

keeps failing (especially when DevTools is running), switch to CLI v2 +
connect()
method (see Template E):

First execute

cli auto --project <path> --auto-port <port>

to enable automation ws port

Then connect with `automator.connect({ wsEndpoint: 'ws://127.0.0.1:<port>' })
Use
```
detectHttpPort()
```
to detect current HTTP port to avoid port conflict errors

Page Navigation Successful but Elements Cannot Be Found

Check these first:

Whether selectors are stable
Whether the page is still rendering asynchronously
Whether elements inside components are mistakenly treated as page-level nodes for querying

Mock Not Taking Effect

Check these first:

Whether the mock was installed before the page's first request
Whether the business layer actually calls the mocked wx method
Whether there is residual pollution from previous rounds at the end of the use case

Screenshot Failure

Check these first:

Whether running in DevTools simulator
Whether the page has rendered stably
Whether the output directory is writable

Implementation Habits When Answering

If the user asks you to directly modify project files, follow this path first:

First explain which script file you plan to create or modify
First confirm the path, page, CLI, target behavior
Then write the file
Finally provide run commands and success judgment methods

If the user is just asking "how to do", output the template first, do not create a bunch of files without permission.

miniprogram-automation

NPX Install

Tags

SKILL.md Content (Chinese)

WeChat Mini-Program Automation

Overview

Default Output Structure

Step 1: Collect Key Inputs First

1.1 Project directory openable by DevTools

1.2 WeChat DevTools CLI Path

1.3 miniprogram-automator Version

1.4 Security Settings

1.5 Target Page and Assertion Targets

Step 2: Choose the Correct Workflow

2.1
`launch`
or
`connect`

2.2 Standalone Script or Jest

2.3 How to Choose Waiting Strategy

Step 3: Core Rules

3.1 Prioritize
`waitFor`
for Page Waiting

3.2 Page-level Selectors Cannot Penetrate Custom Components

3.3 Prioritize
`value()`
or
`property('value')`
When Reading Input Values

3.4 Prioritize Official
`mockWxMethod`
for Mocking WeChat APIs

3.5 Use
`miniProgram.screenshot()`
for Screenshots, and Only for DevTools Simulator

3.6 Cleanup Actions Must Be Put in
`finally`

Template A: General Skeleton for Standalone Scripts

Template B: Input and Validation Inside Custom Components

Template C: Mock
`wx.request`
+ Listen to
`console/exception`

Template E: Complete Script for CLI v2 +
`connect()`

Template D: Batch Screenshot Script Snippet

When to Provide Jest Versions

Common Errors and Corrections

Troubleshooting Tips

Launch Failure / Timeout

Page Navigation Successful but Elements Cannot Be Found

Mock Not Taking Effect

Screenshot Failure

Implementation Habits When Answering

miniprogram-automation

NPX Install

Tags

SKILL.md Content (Chinese)

WeChat Mini-Program Automation

Overview

Default Output Structure

Step 1: Collect Key Inputs First

1.1 Project directory openable by DevTools

1.2 WeChat DevTools CLI Path

1.3 miniprogram-automator Version

1.4 Security Settings

1.5 Target Page and Assertion Targets

Step 2: Choose the Correct Workflow

2.1 launch or connect

2.2 Standalone Script or Jest

2.3 How to Choose Waiting Strategy

Step 3: Core Rules

3.1 Prioritize waitFor for Page Waiting

3.2 Page-level Selectors Cannot Penetrate Custom Components

3.3 Prioritize value() or property('value') When Reading Input Values

3.4 Prioritize Official mockWxMethod for Mocking WeChat APIs

3.5 Use miniProgram.screenshot() for Screenshots, and Only for DevTools Simulator

3.6 Cleanup Actions Must Be Put in finally

Template A: General Skeleton for Standalone Scripts

Template B: Input and Validation Inside Custom Components

Template C: Mock wx.request + Listen to console/exception

Template E: Complete Script for CLI v2 + connect()

Template D: Batch Screenshot Script Snippet

When to Provide Jest Versions

Common Errors and Corrections

Troubleshooting Tips

Launch Failure / Timeout

Page Navigation Successful but Elements Cannot Be Found

Mock Not Taking Effect

Screenshot Failure

Implementation Habits When Answering

2.1
`launch`
or
`connect`

3.1 Prioritize
`waitFor`
for Page Waiting

3.3 Prioritize
`value()`
or
`property('value')`
When Reading Input Values

3.4 Prioritize Official
`mockWxMethod`
for Mocking WeChat APIs

3.5 Use
`miniProgram.screenshot()`
for Screenshots, and Only for DevTools Simulator

3.6 Cleanup Actions Must Be Put in
`finally`

Template C: Mock
`wx.request`
+ Listen to
`console/exception`

Template E: Complete Script for CLI v2 +
`connect()`