Model or dataset
zhoushoujianwork/easyeda-agent avatar
zhoushoujianwork/easyeda-agent

easyeda-agent, a Go CLI that puts typed schematic actions behind a checked installer

EasyEDA Pro (JLC EDA professional edition) automation: the hands of your AI harness — typed schematic/PCB actions via CLI, Agent Skill and stdio MCP, in line with JLC's mission of prioritizing engineer training over board sales.

1,074 stars123 forksGoNOASSERTION

At a glance

What is it?
easyeda-agent 1.9.0 drives EasyEDA Pro through a connector, a local daemon, and an agent skill. Here is what the installer verifies, what the workflow refuses to guess, and where it stops.
Who is it for?
easyeda-agent is aimed at someone who already has a working EasyEDA Pro V4 project and wants an agent to operate on real engineering data rather than on a screenshot. It earns its keep on library authoring and silkscreen cleanup, where evidence and geometry can be checked.
Can I use it commercially?
Check first. The repository uses a licence we do not classify automatically, so read its LICENSE file before any commercial use.
Is it still maintained?
Yes. The repository last received commits 1 day ago.
What is it written in?
Mainly Go, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • zhoushoujianwork/easyeda-agent1,074 ★ · +652
Star history
Repository2026-09-122026-11-15
zhoushoujianwork/easyeda-agent4221.1k

652 Stars in the last 64 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

Three moving parts, and only one of them touches the API

The project ships as three separate things, and the split is what keeps a design write reviewable. An AI agent or skill talks to the `easyeda` CLI and its local daemon; the daemon sends typed actions, audit records, and artifacts to an EDA Agent Connector packaged as a `.eext` extension; and the connector is the only piece that calls the official `eda.*` API inside EasyEDA Pro.

text
AI Agent / Skill
       │
       ▼
easyeda CLI + local daemon
       │ typed actions / audit / artifacts
       ▼
EDA Agent Connector (.eext)
       │ official eda.* API
       ▼
EasyEDA Pro project

The stated reason for that layering is that dropping arbitrary JavaScript into the editor is hard to review and hard to confirm when it half-succeeds. Typed actions with declared inputs and outputs give you both a diff to read and a result to check.

The installers verify checksums before replacing anything

Installation is a piped script on both platforms, and the verification happens before the write, not after it:

bash
curl -fsSL https://raw.githubusercontent.com/zhoushoujianwork/easyeda-agent/main/install.sh | bash
powershell
irm https://raw.githubusercontent.com/zhoushoujianwork/easyeda-agent/main/install.ps1 | iex

Both fetch `checksums.txt` first, verify the SHA-256 of every asset, and cross-check the CLI's `--version` against the skill's `metadata.version` before replacing installed files. Five environment variables change the behaviour: `EASYEDA_VERSION`, `EASYEDA_INSTALL_DIR`, `EASYEDA_INSTALL_SKILLS`, `EASYEDA_SKILL_PRESERVE`, and `EASYEDA_GITHUB_PROXY`. The installer also detects Codex, Codex Desktop, and Claude Code, and prints the connector download URL so the second half of the install is not a scavenger hunt.

The PowerShell installer will not edit your PATH for you

The Windows script defaults to `%USERPROFILE%\.local\bin` and treats PATH as something the user owns. If that directory is not already on the user's PATH, the script only prints the command to add it. Two escape hatches exist, and the distinction between them matters: `-AddToPath` works when you download the script to a file and run it, while `$env:EASYEDA_ADD_TO_PATH=1` works in the piped form where there is no argument to pass. Machine-level PATH is never touched under either option. This is a small decision with a large blast radius avoided, since a tool that edits a global environment variable during a curl-pipe-bash is a different proposition from one that tells you what to run.

V4 is the floor, and a version gap is a diagnostic, not a permit

The mainline targets EasyEDA Pro V4, with V4.1.60 or a newer V4 build recommended, and a V3 environment is supposed to be upgraded before any live write. Starting the runtime is one command, followed by enabling the setting that permits external interaction in the target project:

bash
easyeda daemon start
bash
easyeda health
easyeda update --check --exit-code  # 可选:安装版本对账

`easyeda health` reports the host product version in its own `hostCompatibility` field, which is what makes a V3 host visible rather than inferred. The framing to note is that version differences are emitted as diagnostics and are explicitly not treated as authorisation to proceed with a design action. If the connector lacks the action you need or the protocol does not match, the answer is to upgrade the component, not to retry.

Datasheet validation runs offline, before EasyEDA is opened

Library creation is the workflow with the most guardrails, and the first step happens without EasyEDA running at all. `easyeda lib device validate --spec ...` checks the datasheet evidence, the geometry, and the pin-to-pad mapping locally, and only then does `lib device build` create the full assets. The contract behind those two commands lives with the skill, in a library authoring reference, so the rules travel with the agent rather than with one operator's habits. The intended sequence is to check whether the part already exists in the EasyEDA or LCSC library, read the whole datasheet if it does not, verify the ordering suffix, pin table, package drawing, and recommended land pattern, keep the evidence page numbers, and read the mapping back afterwards. It pauses and asks when a scan is blurry, the package suffix is ambiguous, or the pad evidence is missing.

There is no programmatic undo, so the workflow is guards and read-back

The EasyEDA extension API does not offer a programmatic undo, which is the single fact that shapes every design step in this project. Risk is reduced with source data, pre-write guards, read-back, and failure rollback instead. In practice that means checking the target project, page, device identity, and source data before a write; reading pins, nets, geometry, and object bindings back after it; running the schematic chain of `layout-lint`, then `check`, then `bridge-check`, then DRC and reporting each stage separately; and using the real DRC rules for PCB work rather than a proxy. Partial success, timeouts, and unconfirmable results all stop the retry loop. Auto-save acts as a safety net, but saves at key nodes stay explicit.

Four limits the project states outright

The capability section is unusually candid, and each entry tells you what to do instead. Full maze autorouting on a dense board needs an external Freerouting; the built-in router is aimed at short connections and clear local routing. Controlled impedance cannot be automated, because the dielectric thickness, the Er value, and the copper thickness needed to compute it cannot be fully read from the current `eda.*` API, so the tool does not claim impedance compliance it cannot verify. Automatic library creation from a PDF still depends on an exact part number and original manufacturer evidence. And a schematic standardisation pass replaces parts by LCSC part number or exact model while keeping the designator, the position, and the PCB synchronised identity, reporting pin differences and guiding the rewiring when there are any.

Two direct Go dependencies, and a dev daemon that refuses to lie

The module is `github.com/zhoushoujianwork/easyeda-agent` on Go 1.26.3, with exactly two direct requirements: `github.com/coder/websocket` and `github.com/spf13/cobra`. The `Makefile` encodes the same honesty at the developer level. `local-daemon-restart` refuses to run unless the installed version ends in `-dev.` and the installed CLI reports exactly that same version, and its help text notes that `daemon start` safely replaces an old daemon on port 60832 without importing a connector or restarting EDA. `local-check` runs the offline CLI, skill, daemon, and connector gate, and `make pcb-solver-test` is documented as running offline with no EDA present, so the routing algorithms can be worked on without the application. The `package.json` at the root is a separate private bundle for the DeepSeek Harness, named `easyeda-agent-dsh` and carrying its own patch file.

Editorial conclusion

easyeda-agent is aimed at someone who already has a working EasyEDA Pro V4 project and wants an agent to operate on real engineering data rather than on a screenshot. It earns its keep on library authoring and silkscreen cleanup, where evidence and geometry can be checked. It is the wrong tool for dense autorouting, for anything that depends on controlled impedance, and for anyone unwilling to grant EasyEDA permission for external interaction. Before the first write, run the health check, confirm the host version field, and decide which of the four stated limits you are willing to own yourself.

Frequently asked questions

What does easyeda-agent actually install?

Three things: the easyeda CLI and its local daemon, an EDA Agent Connector extension that runs inside EasyEDA Pro, and the easyeda-agent skill for your AI client. The installer verifies SHA-256 checksums and cross-checks the CLI version against the skill metadata version before replacing files.

Which EasyEDA Pro version does easyeda-agent require?

The mainline targets EasyEDA Pro V4, with V4.1.60 or a newer V4 build recommended. A V3 host should be upgraded before any live write, and easyeda health reports the host product version in a hostCompatibility field so the mismatch is visible.

Can easyeda-agent route a dense board automatically?

Not fully. The capability notes say dense-board maze autorouting needs an external Freerouting, and the built-in router suits short connections and clear local routing. They also note the EasyEDA extension API has no programmatic undo, so the workflow relies on pre-write guards and read-back.

Does easyeda-agent check controlled impedance for me?

No. The dielectric thickness, the Er value, and the copper thickness required cannot be fully read from the current eda.* API, so the project states it cannot automatically claim impedance compliance. Those values have to come from elsewhere.

How does easyeda-agent handle a blurry datasheet scan?

It pauses and asks. PDF-driven library creation still depends on an exact part number and original manufacturer evidence, and it stops when the scan is unclear, the package suffix is ambiguous, or the pad evidence is missing. Validation runs offline before EasyEDA is opened.

Official sources

  1. Issues
  2. Project website
  3. README
  4. Releases
  5. zhoushoujianwork/easyeda-agent on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/zhoushoujianwork-easyeda-agent.svg)](https://hysenlabs.com/projects/zhoushoujianwork-easyeda-agent)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/zhoushoujianwork-easyeda-agent.svg)](https://hysenlabs.com/projects/zhoushoujianwork-easyeda-agent)

Was this useful?