server.json
1 field changed
- version
-
0.9.200.10.17
io.github.partcad/partcad
7 changes recorded. MCP Harbor re-reads this listing from the official registry every six hours and asks the live server what it exposes, and keeps what changed between one look and the next.
https://raw.githubusercontent.com/partcad/partcad/HEAD/AGENTS.md
− what `--fast-only` leaves an assembly out for (`partcad.fast_only`).− `remote_sandbox.execute`, so one implementation of provisioning and forwarding, not two. You can exercise+ `framing` is also how a file crosses: as raw bytes after the message (an *attachment*) to a client that says it+ reads them, and as base64 to any other, under the same key -- so a reader takes both (`framing.as_bytes`). The+ editor extension's copy is `ide/vscode/src/common/framing.ts`.+ what `--fast-only` leaves an assembly out for (`partcad.fast_only`). The daemon opens a window of its own,+ with a `reason` and nobody's declaration, around creating a sandbox and every install into one+ (`runtime_python.INSTALL_WINDOW_SECONDS`): `pip` is silent while it downloads, and without it a slow network+ ended in "the service stopped responding" before `pip` could say what was wrong.+ `part_kinds` is the same kind of rule for `pc add part`: the types a part is added from a file as. The CLI+ refuses any other before it starts a daemon, and the daemon's `add.object` refuses it too, because the editor+ extension and an agent's `execute` reach that method without the CLI. Only PartCAD's own factory types are+ listed there; the native formats are its `//builtin/import` `partTypes`, which a client reads from+ `partcad_client.object_types`, and a test holds the two halves together.+ `remote_sandbox.execute`, so one implementation of provisioning and forwarding, not two. What travels is+ `partcad_utils.container_files`'s to decide, for every caller: bytes as bytes (the service's frame dialect, not+ base64 in JSON), and a directory by content -- the container keeps what it has been sent in a bounded store+ and is asked which digests it lacks, so the wrappers go once per container rather than once per command. The+ JSON dialect stays in the service for one reader: a `partcad-service-remote-docker` is installed on its own+ machine, so a client asks its `GET /` which it speaks, and an older client's JSON is forwarded as JSON. You can exercise
https://raw.githubusercontent.com/partcad/partcad/HEAD/AGENTS.md
− -x -p no:error-for-skips -p no:warnings --dist no # unit tests (matches CI)+ `object_names` is the rule that a name is one object of its package whatever its kind, and the order a bare+ name is looked for in (parts, interfaces, assemblies, sketches, scenes, software). It is here because both+ ends read it: PartCAD refuses a second declaration of a name as it loads a package, and `assy_lint` reports it+ where it is written -- and a rule with a copy per reader is a rule whose copies disagree about which object a+ name is.+ -x -p no:error-for-skips -p no:warnings -n logical --dist worksteal # unit tests (matches CI)+ **pytest runs in parallel everywhere it gates, and a test has to hold up under that.** Both CI jobs run+ `pytest-xdist` with a worker per logical CPU (`-n logical --dist worksteal`), and the `pytest` `pre-commit` hook+ with one per physical core (`PC_PYTEST_WORKERS` overrides it). The workers are separate processes sharing one+ filesystem, one `$HOME`, one Docker daemon and one network, and which tests a worker gets, in which order,+ changes with the number of workers. So a test may not:+ * leave process-wide state behind for whatever the worker runs next -- a logger's level, a handler, a module+ attribute, a cached context. A serial run happens to keep one order, and a test that passes only after (or+ before) another is a test that fails on some machines and not others;+ * rely on a port having been free a moment ago -- keep the probe socket bound for as long as the port is meant+ to stay unanswered;+ * list a directory other processes write to, such as the system temporary directory, and attribute what it+ finds to itself;+ * rely on another test having started a daemon, or on being the one that starts it;+ * bound a duration tightly: a worker shares the machine with the others, so leave seconds of headroom, and+ where a bound has to sit below some other timeout to mean anything, lengthen that timeout in the test.+ The suites that cannot be parallel run in jobs of their own, one file each and in one process:+ `tests/ide/test_ide_e2e.py` (`PC_TEST_IDE_E2E=1`) and `tests/partcad/unit/test_docker_sandbox_live.py`+ (`PC_TEST_SANDBOX_IMAGE`). Both skip in the parallel run.
We can't find the internet
Attempting to reconnect
Something went wrong!
Attempting to reconnect