this_file: README.md
Install in FontLab
To install into FontLab 9, open install.vfpy from a checkout in FontLab
(double-click it or drop it onto FontLab), then restart FontLab. The file is a
short stub that hands the work to
fontlab-instamix; if
instamix is not installed yet, the stub installs it from PyPI first. Instamix
installs the package into FontLab's own site-packages and records the install
under the extension id com.fontlab.remopy.
Development status — 2026-11-05
Canonical source inspected for this proposal: 33a03efbda44. This is a dated source observation, not an installed or native acceptance claim.
Reconcile caller migrations and Issue 207 distribution changes without removing genuine supported-host or SDK compatibility.
Requalify installed launch/catalogue/nonce execution on the supported host and the App-owned native UI consumer; timeouts do not cancel host code.
Repository and development
src/fontlab_remopy/ contains clients, actions, discovery and MCP compatibility; examples/, glyphs/ and tests/ hold consumers and checks. App owns the relocated examples/native_ui.py.
Run uv sync --extra test, ./test.sh, uv run --extra test --with "mcp==1.30.0" python -m pytest -q, and uv run --extra test --with "mcp==1.26.0" python -m pytest -q. All three lines are required for the advertised SDK range.
Keep runtime, ordinary installed artifacts, native workflows and published documentation as separate acceptance results. Track open checks in TODO.md, the implementation route in PLAN.md, and dated evidence in CHANGELOG.md.
FontLab Remopy
fontlab_remopy controls FontLab remotely using native MCP and macOS application
launch/file association. Python 3.11+ is required. Agent prompts, role selection
and AI libraries belong to Aidus and are not dependencies here.
from fontlab_remopy import FontLab
with FontLab() as fl:
print(fl.fonts())
answer = fl.eval("value + 2", value=40)
families = fl.eval('[f["family_name"] for f in fontpr.list_fonts()["fonts"]]')
completed = fl.run("print(message); result={'answer':42}", message="Łódź")
print(completed.value, completed.stdout, completed.stderr)
@fl.python
def metrics(name: str):
import fontpr
return fontpr.get_glyph_metrics(glyph_name=name)
# With an open font containing A:
print(metrics("A"))
CrossOver and Wine script submission
submit requests a script open and prints its resolved path with
execution_verified: false. It does not establish host readiness or completed
execution. execute retains authenticated native MCP execution. A launch or
submission timeout leaves the outcome unknown; inspect the host before repeating.
No operation retries automatically.
Choose the backend explicitly. CrossOver requires its existing standard macOS
~/Library/Application Support/CrossOver/Bottles/NAME bottle, a native executable
path inside that bottle's drive_c, and an executable CrossOver Wine launcher.
The validated absolute bottle selector avoids configured bottle search paths.
Scripts are existing native files and may be outside the bottle:
fontlab-remopy --timeout 10 submit ./probe.vfpy --backend crossover \
--bottle fontlab --wine /Applications/CrossOver.app/Contents/SharedSupport/CrossOver/bin/wine \
--executable "$HOME/Library/Application Support/CrossOver/Bottles/fontlab/drive_c/Program Files/Fontlab/FontLab 9/FontLab 9.exe"
For ordinary Wine, use --backend wine --prefix /existing/prefix, together with
--wine /path/to/wine and --executable /existing/prefix/drive_c/path/FontLab.exe.
Both executable and script must be inside that prefix's drive_c; no Z: mapping
is assumed. launch takes the same backend options without a script path.
Default macOS launch and submit PATH use the existing application provider.
Python callers can import launch and submit_script explicitly from
fontlab_remopy.platforms.crossover or fontlab_remopy.platforms.wine:
submit_script(path, executable, bottle="fontlab", wine=launcher, timeout=10);
ordinary Wine uses prefix=prefix_path instead of bottle.
Paths, executable launcher permissions and finite positive deadlines are checked
before starting a process. These routes have offline command-construction tests;
actual Windows execution, Windows uv/Python bootstrap, installation and MCP
bridge availability still require separate native qualification.
Documentation test environment
Documentation checks use a separate Python 3.13 environment, matching
.github/workflows/docs.yml and the Python 3.13 requirements lock. This is a
build contract, not a change to Remopy's Python 3.11 host requirement.
Use uv 0.13.7 and the exact locked dependencies:
uv venv --python 3.13 .docs-venv
uv pip install --python .docs-venv/bin/python --require-hashes -r src_docs/requirements.txt
PATH="$PWD/.docs-venv/bin:$PATH" sh src_docs/build.sh
PATH="$PWD/.docs-venv/bin:$PATH" python -m unittest discover -s tests_docs -v
Run the build before checking generated output. Do not use an unrelated global
MaterialX installation: the reviewed browser assets and search configuration
require mkdocs-materialx==10.1.8. MaterialX 10.2 changes those assets and the
search plugin configuration; updating the lock requires a separate asset and
licence review, not relaxed assertions. PySide6 is not FontLab's native
PythonQt environment; native checks use pythonqtside in FontLab.
API reference
| Name | What it does |
|---|---|
FontLab(command=None, timeout=30) |
Synchronous client; use as with FontLab() as fl:. command is the bridge executable, timeout seconds per call |
AsyncFontLab(command=None, timeout=30) |
Same operations as async with and await |
fl.run(code, **vars) |
Run Python in FontLab; returns ExecutionResult(value, stdout, stderr); set result to return a value |
fl.eval(expression, **vars) |
Evaluate one expression; returns the JSON value |
fl.execute_script(path, **vars) |
Run a .flpy/.vfpy file, __file__ set to its resolved path |
fl.tool(name, **arguments) / fl.tools() |
Call any native tool by name / list the live catalogue with schemas. Unknown argument names raise ValueError (FontLab would drop them silently); the master argument is master_name |
fl.fonts(), fl.output(), named controls |
Open fonts; recent captured output; the catalogue tools listed below |
@fl.python |
Run a decorated function remotely with JSON arguments and result |
enable_mcp() |
Inside FontLab: set mcp.enabled and notify the host (no save()) |
setup_mcp(), launch(), submit_script(), find_bridge() |
Launch FontLab, enable MCP from outside, locate the bridge |
call_tool(), run_python(), execute_script(), probe_tools() |
One-shot async functions for single calls |
Errors: NativeExecutionError (a tool or the remote Python failed; .payload has type,
message, traceback and partial output), ResultTransportError (the result could not be
recovered; the call may have run), ValueError (bad timeout, variable name or oversized
code), FileNotFoundError (no bridge executable), RuntimeError (used outside a context, or
after a timeout until you open a fresh one), and TimeoutError (the call exceeded timeout;
the outcome is unknown, so check FontLab before repeating).
Two different time limits apply. timeout is how long this client waits for one MCP call.
FontLab's run_python tool also enforces its own fixed five-second execution deadline,
which Remopy cannot change: code passed to run, eval or a @fl.python function must
finish within it, so split longer work into short calls and read the resulting state.
Remote code is limited to 32768 bytes and its output to 65536 bytes.
One context reuses one authenticated MCP connection. Idle time has no deadline;
each initialization/call has the configured timeout (30 seconds by default).
This synchronous API also works in notebooks with an existing event loop. It
owns a dedicated AnyIO portal thread and releases its bridge on context exit or
close(). AsyncFontLab exposes the same operations with async with and
await; enter and exit that context on the same task. Calls are serialized.
After timeout/cancellation, queued/new calls fail until a fresh context opens.
The original one-shot async functions (call_tool, run_python,
execute_script, probe_tools) retain their existing result shapes.
run returns ExecutionResult(value, stdout, stderr); set result in ordinary
Python to return a value. eval returns the value directly. Context methods
execute_script(path, **variables) preserve the resolved filename. JSON data is
bound into an isolated namespace; fontlab, fontgate, fontpr, and PythonQt
are prebound when available. Explicit variables take precedence. Imports/names
from FontLab's global script scope are not inherited or changed. Python streams
are captured during execution; concurrent Python threads share those interpreter
streams. Native Output is never cleared.
Unicode text, including U+0085, U+2028 and U+2029, round-trips unchanged in
values, captured streams and native exception messages; only LF frames envelopes.
@fl.python preserves the local function signature and metadata, binds defaults
locally, and transports arguments/results as JSON. Put imports inside the body.
Globals/closures, async function bodies, unavailable source, native object
results, and non-JSON values fail clearly; notebook source limitations can use
run/eval. Native exceptions retain type/message/traceback and partial output
in NativeExecutionError.payload. Truncated/missing/unsupported JSON results
raise ResultTransportError. The wrapper counts toward native 32768-byte code
and 65536-byte output bounds; FontLab's fixed five-second execution deadline is
unchanged. A timeout leaves execution outcome unknown and never triggers retry.
Named controls include fonts, current_font, current_glyphs, glyph("A"),
font_info, font_metrics, glyph_metrics, list_actions, run_actions,
output, font open/new/save/close/activation and metric setters. Mutating calls
perform the requested native operation. tool(name, **arguments) accesses the
whole live catalogue; tools() gives its current schemas. output() reads MCP's
recent capture; eval("fontlab.GetProperty('output')") reads the full native
Output. See examples/control.py for runnable ordinary Python and examples/native_smoke.py for a read-only check of the one-shot async functions.
App's native UI example
creates a native panel, modeless dialog and removable
Preview drawing from @fl.python functions; --typerig composes a real TypeRig
widget. Install Fontlabapp (and optionally typerig) in the host first. The example
retains its native handles across calls, waits outside the UI thread, and removes
only its own resources in finally.
execute_script() reads .flpy/.vfpy source, preserves its resolved filename as
file, and verifies the native run_python success payload. Native errors raise
NativeExecutionError with the original payload. call_tool() returns the actual
SDK result, including real errors. FontLab's fixed execution deadline remains
unchanged. Timeouts leave a mutation's outcome unknown; operations are never
automatically retried.
launch() requests application launch. submit_script() uses file association
and returns execution_verified=False: submission alone cannot prove execution.
The library's launch/file-association implementation currently supports macOS;
MCP can use an explicitly configured executable on other supported SDK platforms.
setup_mcp() submits one unique .vfpy macro, verifies a nonce-matched native
completion marker, then authenticates the bridge and discovers the tool catalogue.
Only the extended mcp.enabled preference is set, using load() and a host
notification. Failed/timeout setup retains local macro/status files for inspection.
enable_mcp() performs the same preference update when called inside FontLab.
It does not call save() or clear application logs.
Discovery checks an explicit argument or FONTLAB_MCP_COMMAND, then the native bridge on PATH or the FontLab 9 bundle. The legacy AIDUS_FONTLAB_MCP_COMMAND variable remains accepted for migration. Paths containing spaces are preserved. An explicit missing executable never falls back to a different FontLab build.
fontlab-remopy launch
fontlab-remopy --timeout 15 setup
fontlab-remopy tools
fontlab-remopy execute example.flpy
fontlab-remopy call list_fonts
The MCP SDK (v1 or v2 line) owns framing, authentication, process spawning and teardown. A small relay normalizes only isError:null, preserving actual true error flags and RPC errors. Its downstream writer channel closes before transport teardown; otherwise the SDK server writer prevents upstream child cleanup. The dedicated relay process gives its child 0.25 seconds of EOF grace before SDK termination, inside its parent's two-second shutdown window. This changes process cleanup only, not FontLab's Python execution deadline. The constant exists in SDK 1.26, 1.30 and 2.3; the adjustment is isolated to the relay subprocess.
Remopy runs on both MCP SDK lines (mcp>=1.26,<3). mcp/compat.py holds the only
differences it meets: v2's snake_case fields (is_error, next_cursor), wire dumps
with by_alias=True, and v1's RootModel wrapper around JSON-RPC messages. Test both:
uv sync --extra test
./test.sh # locked SDK (2.x)
uv run --extra test --with "mcp==1.30.0" python -m pytest -q # v1 line
uv run --extra test --with "mcp==1.26.0" python -m pytest -q # v1 floor
uv build
The test suite (run against mcp 2.3.0, 1.30.0 and 1.26.0 at commit 907d014) covers reusable sync/async sessions, decorated functions, JSON/Unicode/stream transport, source failures, native error parsing, extended preference setup, normalization, real SDK framing and timeout child-process cleanup by PID. Envelope regressions cover Unicode separators, missing/duplicate/malformed and oversized results, and verify that decoding failures never replay operations. Live checks verify nonce-matched .flpy execution through MCP, launch, native preference setup and the authenticated tool catalogue in FontLab 9 (46 tools at migration, 47 in the later MCP v2 session). Installed-artifact checks and project-wide release gates are recorded in WORK.md.
MIGRATION.json retains historical source hashes and the recovery archive digest. No recovery archive is present in this checkout or its distributions; this change does not relicense historical recovery bytes. Current first-party source and documentation are licensed under Apache-2.0, with the Fontlab Ltd. copyright retained in NOTICE. Third-party materials keep their original terms and notices. Versions use hatch-vcs and Git tags.
Package layout
Public imports such as from fontlab_remopy import FontLab are unchanged and
remain lazy. client.py provides the sync/async clients, actions.py their named
controls and python() decorator, remote.py function transport, results.py
execution envelopes, and import-light host.py the in-FontLab helper. setup.py
uses the platforms layer; application launch/submission lives in platforms/macos/.
Unsupported launch/submission errors name the platform; explicit bridge discovery
remains available for MCP use outside macOS.
mcp/ contains transport APIs, compat.py isolates SDK version differences, and
relay.py runs as python -m fontlab_remopy.mcp.relay <command>. The deprecated
python -m fontlab_remopy.mcp_bridge <command> entry point and its normalize_result
and relay imports remain compatible with saved MCP configurations. They now emit a
DeprecationWarning on stderr; stdout stays reserved for MCP. Aidus uses the relay.
Remopy 2.0 removed the eight pre-1.2 module paths (control, controls, execution,
functions, launch_api, mcp_api, mcp_compat, native); the CHANGELOG
lists the replacement import for each.
Remote-control FontLab from Glyphs
glyphs/fontlab_remote.py runs inside Glyphs 3 or 4 (or any Python 3.8+) with the
standard library only, so Glyphs' Python needs nothing installed. It starts FontLab's
bundled fontlab-mcp bridge (which holds the authentication for FontLab's local
server) and speaks MCP over its standard input/output, with a deadline on every read.
Install: copy the file into Glyphs' Scripts folder (Script > Open Scripts Folder,
i.e. ~/Library/Application Support/Glyphs 3/Scripts/), then Script > Reload Scripts.
FontLab must be running with external MCP clients enabled (Preferences > Aidus).
Run Script > FontLab Remote Control to print FontLab's version and open fonts
next to Glyphs' current font in the Macro panel. From your own Glyphs scripts:
from fontlab_remote import FontLabClient
with FontLabClient() as fl:
print([t["name"] for t in fl.tools()])
print(fl.call("list_fonts")) # any FontLab MCP tool
print(fl.eval("2 + 40")) # a JSON value from FontLab Python
fl.run_python("print(fontlab.CurrentFont())") # output text
Tool errors, bridge exits (with the bridge's message) and missed deadlines raise
FontLabError. FONTLAB_MCP_COMMAND selects another bridge. Glyphs' Python must be
configured (Glyphs > Settings > Addons); a framework that no longer exists makes every
Glyphs script fail before this one starts.
Status
Issue 101 migration and the added control scope are complete and released as
verified v0.2.0 (RELEASE.md): launch, .flpy, MCP setup/catalogue/calls,
synchronous and asynchronous contexts, decorated remote functions, JSON/Unicode
results and streams, errors, per-call deadlines with unknown-outcome fencing and
process cleanup, all checked from installed artifacts in FontLab.
Issue 233 source/build-only documentation
Maintained site source is src_docs/md, configured by src_docs/mkdocs.yml;
docs/ is generated output. Use a separate Python 3.13 docs environment, uv
0.13.7 and the exact hash-locked requirements. Run sh src_docs/build.sh and
python -m unittest discover -s tests_docs -v with that environment on PATH.
Every main push builds exact source X, optionally makes a normal docs-only child
Y, and independently verifies immutable lineage, source identity, source epoch
and complete tracked/untracked generated parity. No private Pages permission,
configuration, deployment or automatic publication request is enabled.
Source/generated review, actual Actions, owner installation and native acceptance
remain separate. Do not change runtime dependencies, startup or recovery pins for
a site build.
Metadata
Release files for fontlab-remopy 2.0.10
For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.
Source distribution (sdist)
| File | Size | Uploaded | Provenance | Actions |
|---|---|---|---|---|
| fontlab_remopy-2.0.10.tar.gz | 71.7 kB | With provenance | Details for fontlab_remopy-2.0.10.tar.gz |
Built distribution (wheel)
| File | Interpreter | ABI | Platform | Actions Reset |
|---|---|---|---|---|
| fontlab_remopy-2.0.10-py3-none-any.whl | Python 3 | none | any | Details for fontlab_remopy-2.0.10-py3-none-any.whl |
Total release size: 107.3 kB
Release files / fontlab_remopy-2.0.10.tar.gz
| Download URL | fontlab_remopy-2.0.10.tar.gz |
|---|---|
| Size | 71.7 kB |
| Tags | Source |
|
SHA-256 checksum How to use checksums |
be4653874d6918a4f1beffcd1ebac9463dfd6322a8e7a0efee2a8b60e7de7315
|
|
BLAKE2b-256 checksum How to use checksums |
e9821fb9a6115d629ec0272f3ab9e93fd481e2b430a9f6b87cdd7a5b3e142eb7
|
| Upload date | |
|
Uploaded using Trusted Publishing? What is trusted publishing? |
Yes |
| Uploaded via |
twine/7.0.0 CPython/3.13.16
|
Provenance
Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.
PyPI Publish Attestation
PyPI verified that this artifact, at this checksum, originated from the publisher listed below.
Signed by GitHub Actions, verified by PyPI on Nov 18, 2026.
Transparency logRelease files / fontlab_remopy-2.0.10-py3-none-any.whl
| Download URL | fontlab_remopy-2.0.10-py3-none-any.whl |
|---|---|
| Size | 35.6 kB |
| Tags | Python 3 |
|
SHA-256 checksum How to use checksums |
7a25a7611e3deb12443db67eeccee68b7f4790569437c8f04ba251238cc3dbc4
|
|
BLAKE2b-256 checksum How to use checksums |
64c912af258286285fd74d2eee75244cacee4d6172b79b33a6702ebd002037f2
|
| Upload date | |
|
Uploaded using Trusted Publishing? What is trusted publishing? |
Yes |
| Uploaded via |
twine/7.0.0 CPython/3.13.16
|
Provenance
Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.
PyPI Publish Attestation
PyPI verified that this artifact, at this checksum, originated from the publisher listed below.
Signed by GitHub Actions, verified by PyPI on Nov 18, 2026.
Transparency logSecurity for fontlab-remopy 2.0.10
Provenance
Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.
Full provenance
Both files in this release have been uploaded with provenance metadata.
Attestation for fontlab_remopy-2.0.10.tar.gz
PyPI Publish Attestation
PyPI verified that this artifact, at this checksum, originated from the publisher listed below.
Signed by GitHub Actions, verified by PyPI on Nov 18, 2026.
Transparency logA note on package security
PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.
To learn more about protecting yourself from malicious actors, visit our package security documentation.