Compare commits

..
Author SHA1 Message Date
bquarkz a9ede541af Merge pull request 'feat(pbs): resolve editorial chains and expose read-only external sources' (#35) from dev/pbs-editorial-chains-sdk-navigation into master
Test / Build skipped: 16, passed: 942
JaCoCo Coverage #### Project Overview No changes detected, that affect the code coverage. * Line Coverage: 66.91% (23371/34928) * Branch Coverage: 56.47% (9948/17616) * Lines of Code: 34928 * Cyclomatic Complexity: 15041 #### Quality Gates Summary Output truncated.
Intrepid/Prometeu/Studio/pipeline/head This commit looks good
Reviewed-on: #35
2026-10-07 08:36:18 +00:00
bquarkz d71e46ade8 fix(ci): publish coverage separately from test checks
Test / Build skipped: 16, passed: 838
JaCoCo Coverage #### Project Overview No changes detected, that affect the code coverage. * Line Coverage: 66.91% (23370/34928) * Branch Coverage: 56.47% (9947/17616) * Lines of Code: 34928 * Cyclomatic Complexity: 15041 #### Quality Gates Summary Output truncated.
Intrepid/Prometeu/Studio/pipeline/pr-master This commit looks good
2026-10-07 09:25:14 +01:00
bquarkz 8dff6d8d5f package testing
Test / Build skipped: 16, passed: 838
Intrepid/Prometeu/Studio/pipeline/pr-master This commit looks good
2026-10-07 09:09:31 +01:00
bquarkz 967b9ec598 feat(pbs): resolve editorial chains and expose read-only external sources
Intrepid/Prometeu/Studio/pipeline/head Build started...
Test / Build skipped: 16, passed: 838
Intrepid/Prometeu/Studio/pipeline/pr-master This commit looks good
2026-10-07 09:00:31 +01:00
bquarkz d0737df0ac feat(studio): integrate project MCP setup and lifecycle
Intrepid/Prometeu/Studio/pipeline/pr-master This commit looks good
Test / Build skipped: 15, passed: 926
Intrepid/Prometeu/Studio/pipeline/head This commit looks good
2026-09-29 19:24:28 +01:00
bquarkz 97cf5e1919 Merge branch 'dev/studio-headless-runtime-ai-first'
Test / Build skipped: 15, passed: 909
Intrepid/Prometeu/Studio/pipeline/head This commit looks good
2026-09-29 16:42:37 +01:00
86 changed files with 3998 additions and 274 deletions
+90 -19
View File
@@ -32,25 +32,94 @@ At runtime, the app boots an embedded packer, restores project-local Studio stat
## External Coding Agents (MCP)
Open a project and select **DEV → Copy MCP configuration**. The copied JSON is a
provider-neutral connection descriptor: use its `url` and `headers.Authorization`
in your external client's Streamable HTTP MCP setup, and provide its `projectRoot`
and instructions to the agent. Adapt the configuration syntax to your client;
there is no embedded chat or provider-specific setup wizard.
Studio includes its own `mcp --project <absolute-root>` mode. Configure the native
client once; project grants and desktop restarts no longer require copying ports
or tokens. The initial integration targets Codex on macOS.
Keep the descriptor/token private and out of versioned files and logs. The endpoint
is local to this computer. After restarting Studio, copy it again and update the
client: both the port and token are ephemeral. Copying or connecting does not
authorize edits or start a task.
1. Install/stage Studio with its bundled Java runtime (see below). New projects
prepare the local client entry during scaffolding. Opening an existing project
also prepares its enabled integration automatically; Studio starts the shared
MCP server itself. **DEV → Prepare assistant** retries preparation after resolving
a reported setup conflict. Opening a project does not grant agent control.
2. Open the coding client in the project directory. Trust the project and reload
MCP once if the client requests it. Studio does not alter client approval policy.
Tools can initialize/list even before the desktop is open or access is granted.
3. Open the project in Studio and grant control in DEV (save first if prompted).
Active Debug prevents granting. The connector discovers access automatically.
4. The agent acquires a task, consults project/language/SDK references, edits saved
project files with its native tools and validates through LSP/build. SDK and
external libraries remain read-only.
5. Recover uncertain operations by operationId/clientRequestId lookup within the
same task; never replay build/advance blindly. Explicitly release control when
done. Human reclaim also revokes access; stop direct external file edits separately.
1. Connect, discover tools, read project context and applicable language/SDK references.
2. In DEV, grant control (save all first if prompted). Active Debug prevents granting.
3. The agent acquires a task, edits saved project files using its own tools, and
validates through LSP/build. SDK and external libraries are consultable, read-only.
4. Poll operations by operationId or clientRequestId. Recover a lost start receipt
by lookup; never retry frame advancement blindly with a new ID.
5. The agent explicitly releases control. To interrupt, use DEV's reclaim button
and stop the external client separately: Studio cannot prevent its direct file writes.
The client invokes the same Studio artifact over stdio. It forwards to Studio's
project-scoped loopback service using protected, transient
`.studio/mcp/connection.json`. The permanent `.codex/config.toml` entry contains
installed Java/classpath/root arguments, not credentials. Both local outputs are
ignored by Git. Unrelated client settings are preserved; tracked or conflicting
Studio entries require deliberate resolution. `.studio/setup.json` preserves
neutral integration intent and existing runtime/editor settings.
After desktop restart, grant again in DEV. Keep the same client session and
configuration; old task identities and operation receipts are not restored.
DEV displays connection separately from project authority. No project-local
launcher, Python transport script or embedded chat is required.
### Reading external source code
VS Code F12 opens SDK/core and admitted libraries as read-only documents, with
hover, continued F12 and syntax highlighting. SDK/core stay bundled; no editorial
copies are created. After a source revision changes or a session ends, navigate
again instead of reusing old positions.
For MCP, use `studio_language_query` with `operation: "definition"`, then pass a
returned `prometeu-source:` URI to `operation: "readExternalSource"`. The response
contains `descriptor` and `text`; hover and definition accept the same URI within
the owning task. Another task cannot reuse it. MCP does not require VS Code open.
External or mixed edit proposals are refused in full. Library installation/cache
management is outside this feature. See the [extension guide](tools/vscode-extension/README.md).
### Installation and IntelliJ development
Build and stage the complete distribution, including its Java runtime:
```bash
./gradlew :prometeu-app:stageStudioInstallation
```
The macOS default is `~/Library/Application Support/Prometeu/Studio/current`.
Staging validates a new version before atomically changing `current`, retaining
older versions for rollback and running processes. Native client registration
uses absolute paths and argument arrays, independent of shell PATH:
```text
command: <installation>/current/runtime/bin/java
args: ["-cp", "<installation>/current/lib/*", "p.studio.app.StudioLauncher", "mcp", "--project", "<absolute-project-root>"]
```
For development, use an isolated installation:
```bash
./gradlew :prometeu-app:stageStudioInstallation -PstudioInstallationRoot=/absolute/dev-installation
```
In IntelliJ, run/debug `p.studio.app.StudioLauncher` with the `prometeu-app`
runtime classpath and VM option `-Dstudio.installationRoot=/absolute/dev-installation`.
The desktop and client-owned connector are separate JVMs. To debug the latter,
add the development-only VM argument
`-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=127.0.0.1:5005`
before `-cp` in the local MCP entry, restart that MCP process, then use IntelliJ's
**Remote JVM Debug** on localhost:5005. Do not commit this local configuration.
Because manual edits to the managed entry are protected, restore its original
content before using preparation again. Regular registration never enables JDWP.
The packaged automated gate checks bundled Java, upgrade/rollback, project paths
with spaces, minimal environment, scaffold/preparation and JavaFX startup:
```bash
./gradlew :prometeu-app:installedConnectorTest
```
The current production tools cover context, references, task control, LSP,
build/pack, operation lookup/cancellation and headless execution (17 tools).
@@ -67,7 +136,9 @@ for schemas, authorization, limits and delivery boundaries.
| Symptom | Action |
| --- | --- |
| Connection rejected after Studio restarts | Copy DEV's configuration again: the token and OS-assigned endpoint are session-local. Do not publish the token. |
| Waiting for access / desktop restarted | Open the project and grant again in DEV. Keep the existing client configuration. |
| Stale connection / incompatible catalog | Grant fresh access, or update the installed Studio when versions differ. Do not edit transient credentials. |
| Preparation conflict | Preserve the existing client settings; resolve a tracked/user-owned/edited Studio table explicitly, then prepare again. |
| Acquisition rejected or project busy | Grant control in DEV first; stop manual Debug before granting. Query an existing operation instead of starting another; serialize headless calls. |
| `RUNTIME_UNAVAILABLE` or handshake incompatibility | Check the project's configured runtime installation and its packaged headless command. Studio does not download a substitute. |
| `NO_FRAME_AVAILABLE` | Advance at least one frame before requesting a capture. |
@@ -127,7 +198,7 @@ are not considered fixed by the passing integration tests:
regression passes, but the toolchain/target alignment needs separate review.
Cross-platform desktop coverage remains a validation boundary, not a confirmed
product defect. Desktop acceptance so far covers macOS ARM64 and Codex CLI only.
product defect. Baseline HTTP desktop acceptance covers macOS ARM64 and Codex CLI only. The integrated stdio flow completed its separate acceptance gates through automated validation and user-confirmed native-client, graphical-launch and IntelliJ checks; see [LSN-0077](discussion/lessons/DSC-0070-studio-persistent-mcp-connector/LSN-0077-integrated-mcp-stable-setup-and-ephemeral-access.md) for evidence provenance.
The first real Codex CLI acceptance run exercised editing, LSP, build/pack, input,
1,110 frames, native MCP images and explicit release. The developer confirmed the
@@ -8,6 +8,14 @@ tags: [studio, lsp, vscode, compiler-pbs, editor, definition]
# PBS go-to-definition uses editorial lookup and physical files
> Historical policy: DEC-0062 / PLN-0141 explicitly superseded the physical-only
> definition restriction in October 2026. SDK/core and dependencies now use
> revision-bound read-only external documents for supporting clients. Compiler
> Spec 23 and Studio Spec 11 define the current contract. The original lesson below
> preserves the earlier decision; it must not be read as prohibiting today's
> external navigation. References, symbols, links and hierarchies retain their
> separately scoped contracts. See LSN-0078 for the implementation and pitfalls.
## Original Problem
PBS editor assistance already had compiler-backed completion, hover, and signature help (`LSN-0051`). Users still could not jump from a use to a declaration. Wave 1 explicitly deferred `go to definition`.
@@ -0,0 +1,190 @@
---
id: LSN-0078
ticket: pbs-editorial-chains-sdk-navigation
title: PBS chains and revision-bound external sources
created: 2026-10-07
tags: [compiler, compiler-pbs, lsp, studio, sdk, navigation]
---
# PBS chains and revision-bound external sources
Domain owner: `compiler/pbs`. Propagation: `compiler/general` and `studio`.
DEC-0062 and PLN-0141 were implemented together. This lesson preserves the outcome
and validation after their workflow artifacts are removed.
## Original problem
Compilation supported expressions such as `Input.pad().left().down()`, but the
editorial receiver scanner only understood identifier/dot sequences. Hover,
definition, completion and signature help therefore lost the receiver after a call.
Separately, definition discarded SDK/core handles because their bundled resources
had virtual paths rather than regular files. SDK hover could succeed while F12
returned nothing. These were independent defects requiring integrated acceptance.
A third regression fixture confirmed that source discovery skipped a dependency
explicitly admitted under `.workspace`: the crawler tested every ancestor of the
absolute path against ignored directory names.
## Consolidated decision
Keep language resolution in the frontend. Share receiver typing across the four
project queries, using PBS parsing and flow semantics. Support known-return call
chains, nested arguments, typed/inferred variables, parentheses and recoverable
partial code. Unknown or ambiguous receivers stay unresolved. This changes no
language rule, compiler/linker pipeline, ABI or runtime behavior.
Expose SDK/core and admitted dependency sources as read-only in-memory documents.
SDK/core remain bundled, without editorial extraction. Libraries remain their
existing physical sources; a library inside the project directory is still an
external owner. Dependency installation, download, cache management and its future
Studio UI remain DSC-0072 / AGD-0074.
Each external document binds content, byte ranges and frontend semantic context to
the same analyzed revision. The host emits an opaque project-session URI; the
content digest is not an SDK version. VS Code and MCP share that source and
semantic authority. They do not implement another PBS resolver.
All proposals touching external sources are refused as a whole. Normal project
editing remains available. References, workspace symbols, links and hierarchies
retain their earlier physical scopes. External definition does not expand them.
## Final implementation
1. `PbsParser.parseExpression` exposes the existing expression grammar for complete
receiver fragments. `PbsEditorialSupportService` locates a fragment boundary and
delegates its type to `PbsFlowExpressionAnalyzer`. The same path serves all four
project queries, including trailing dots and unfinished arguments.
2. `SourceCrawler` tests ignored descendants relative to the explicitly admitted
traversal root. It does not admit incidental `.workspace` trees as project code.
3. `FrontendSourceDocument` carries exact text, origin, presentation metadata,
read-only ownership and opaque frontend context. Definition locations optionally
carry that source; invalid path/range combinations are rejected. PBS preserves
source ownership separately from `SourceKind.PROJECT`; external ownership wins
when paths overlap. Existing default-empty frontend capabilities remain valid.
4. `ExternalSourceRegistry` belongs to `TcpLspServerHost`, not the shared compiler
bridge. It retains source/context together, with separate consumer grants,
acknowledged uses and reconnect validation. Repeated uses in one semantic
snapshot coalesce. Another reader's release cannot invalidate a retained source.
5. LSP negotiates external support and emits `prometeu-source:` destinations only
to supporting clients. External read, retain, release and revalidate requests
share server-issued consumer identity. The bridge uses retained content for
positions, hover, definition and highlighting. Unsupported consumers keep local
physical navigation without receiving unusable external targets.
6. VS Code registers a `TextDocumentContentProvider`, assigns PBS language, routes
hover/F12/highlighting and prevents external edit commands. Disconnect preserves
displayed text but disables queries until validation; the status bar explains
unavailable external documents. Changed revisions require fresh navigation.
7. MCP adds `readExternalSource` to `studio_language_query`. Task-owned consumers
survive short-lived sockets, acknowledge returned definitions, revalidate before
reuse, and release on task return/cancellation. Cross-task/project replay is
refused. Failed navigation releases unacknowledged results; failed responses
roll back newly retained sources. No human editor is needed.
### Example
A project definition on `Gfx.clear` opens the bundled SDK source. Hover/F12 on its
`LowGfx.clear` call reaches the host declaration. F12 on `Color` reaches the core
resource. The same operations work through MCP by reading the returned external
URI and querying positions in that text. A dependency under `.workspace/repos/lib`
uses the same presentation and write protection.
If that library changes on disk while a document is open, the retained document's
hover/F12 still use its old AST and old text. After disconnect, revalidation against
the changed source fails; clients must navigate again for new content and ranges.
## Validation evidence
Failures were reproduced before production changes: all four chain assertions
failed, both crawler/admitted-FileTable fixtures failed, and the old bridge test
confirmed SDK hover with empty bundled definition alongside working local F12.
Final module results (2026-10-07):
| Suite | Executed successfully | Skipped |
| --- | ---: | ---: |
| PBS frontend | 245 | 0 |
| Frontend API | 27 | 0 |
| Build pipeline | 141 | 15 existing disabled cases |
| LSP | 38 | 1 opt-in development-host case in the ordinary run |
| App: AutomationLspQueries, McpContract, CompilerProjectKnowledge | 24 | 0 |
| Core: TaskLanguageQueries | 1 | 0 |
| Actual VS Code Development Host, run separately | 1 | 0 |
All 477 executed JUnit cases passed across these scoped runs. TypeScript compilation,
`discussion validate` and `git diff --check` also passed. The disabled main-project
pipeline integration test was not treated as evidence.
The actual VS Code host exercised typing refusal, declaration selection, semantic
highlighting, hover, continued F12, a physical `.workspace` library with Unicode/CRLF,
reconnection and normal project edits. Provider tests exercised cached disconnected
text, matching/changed revisions, close and canceled reads. MCP tests used the actual
TCP server independently of VS Code, including task return, aliases, mixed rename
refusal and changed revisions. Registry tests covered multiple readers, distinct
projects, last release, task/session lifetime and canceled/unopened navigation.
The source-snapshot regression changed a dependency on disk after navigation and
verified that old hover/F12 still used the original declaration and semantic context.
Dedicated write-boundary checks refuse external didChange/didSave, formatting,
rename, prepareRename and code actions, including unnegotiated identities.
Commands are preserved in the plan-derived development instructions and test owners:
```sh
./gradlew :prometeu-compiler:frontends:prometeu-frontend-pbs:test :prometeu-compiler:prometeu-frontend-api:test :prometeu-compiler:prometeu-build-pipeline:test :prometeu-lsp:prometeu-lsp-v1:test --console=plain
./gradlew :prometeu-app:test --tests '*AutomationLspQueriesTest' --tests '*McpContractTest' --tests '*CompilerProjectKnowledgeTest' :prometeu-studio-core:test --tests '*TaskLanguageQueriesTest' --console=plain
npm --prefix tools/vscode-extension run compile
PROMETEU_VSCODE_DEV_TEST=1 ./gradlew :prometeu-lsp:prometeu-lsp-v1:test --tests '*ExternalSourceDevelopmentHostTest' --console=plain
```
Packaged Studio was excluded from the initial acceptance above. On 2026-10-07,
the user explicitly requested this additional validation. The existing
`InstalledKnowledgeTest` now launches its isolated probe with the Java runtime
from `installDist`, using distribution JARs plus test probe classes, with its working
directory and projects outside the checkout. It asserts that the frontend and LSP
bridge load from JARs and that SDK/core resources have `jar:` URLs.
The packaged gate passed:
```sh
./gradlew :prometeu-app:installedKnowledgeTest --console=plain
```
Besides reading the installed documentation and compiling its example, it verifies
project-to-SDK, SDK-to-host and SDK-to-core definitions, matching declaration lines,
exact SDK/core text against JAR bytes, read-only bundled descriptors, SDK hover and
semantic tokens, and source revalidation after reconnect. The project contains only
its original manifest and sources after navigation: no bundled source extraction.
The first run caught an incorrect cursor position in the test fixture; calculating
the position from the source fragment fixed the fixture. No production fix was needed.
This is a packaged resource/backend gate; it does not launch the Studio desktop or
repeat the VS Code UI checks against the installed process.
## Pitfalls
- Compiler success does not prove editorial resolution. Query the four surfaces.
- A physical path under the project root is not proof of editable ownership.
- Retaining text alone is insufficient: fresh analysis can attach different meaning
to old positions. Keep the corresponding semantic context.
- MCP socket closure is not task completion. Retain consumer state independently.
- VS Code normalizes escaped URI components. The first actual-host run exposed
mismatched identities from escaped slashes; emitted URIs now use unreserved
characters and keep names separately in metadata.
- `TextEditor.edit` is an extension programming API, not user typing. The real UI
gate uses the `type` command; backend edit proposals are checked independently.
If another extension changes a virtual buffer, the provider refuses queries whose
text differs from the retained revision.
- VS Code MarkdownString properties need direct inspection; JSON serialization can
show `{}` even when hover contains valid content.
- Enriching a shared definition DTO can accidentally expand references. Keep each
surface's admission policy explicit; the compatibility suite caught this coupling.
- Do not silently drop external edits from a mixed proposal. Refuse the operation.
## References
- [Compiler Spec 23](../../../docs/specs/compiler/23.%20Compiler%20Pipeline%20Entry%20Points%20Specification.md).
- [PBS Spec 5](../../../docs/specs/compiler-languages/pbs/5.%20Manifest,%20Stdlib,%20and%20SDK%20Resolution%20Specification.md).
- [PBS Spec 8](../../../docs/specs/compiler-languages/pbs/8.%20Stdlib%20Environment%20Packaging%20and%20Loading%20Specification.md).
- [Studio Spec 11](../../../docs/specs/studio/11.%20MCP%20Tools%20and%20Project%20Knowledge%20Contract.md).
- [Extension guide](../../../tools/vscode-extension/README.md).
- [Historical physical-only policy, LSN-0068](../DSC-0039-pbs-lsp-go-to-definition/LSN-0068-pbs-go-to-definition-uses-editorial-lookup-and-physical-files.md).
- DEC-0031 / LSN-0049 still govern removal of the old embedded editor/VFS; none was restored.
@@ -0,0 +1,178 @@
---
id: LSN-0077
ticket: studio-persistent-mcp-connector
title: Integrated Studio MCP Through Stable Setup and Ephemeral Access
created: 2026-09-29
tags: [studio, mcp, connection, lifecycle, installation]
---
# Integrated Studio MCP: Stable Setup, Ephemeral Access
Owner: **studio**, MCP integration, project lifecycle and local installation.
DSC-0070 / DEC-0061 / PLN-0140 delivered this integration, including the user's
accepted revision for automatic preparation on project open. These identifiers
are historical references; maintained contracts are linked below. Automated
validation and the user's confirmation of final manual acceptance are recorded
separately.
## Original Problem
The original integration exposed a new HTTP port and bearer token on each Studio
restart. Developers had to configure their coding client repeatedly. Ad hoc
transport scripts then duplicated initialization, authentication and result
handling, obscuring native MCP tools and images.
The durable solution separates three lifetimes: installation, connection and
project authority. A stable client registration must not imply durable permission
to edit, and a transport interruption must not replay work.
## Consolidated Design
The distributed Studio artifact supports two modes. Normal invocation opens the
desktop. `StudioLauncher mcp --project <absolute-root>` runs a stdio connector
without JavaFX, Spring desktop composition, LSP or a second HTTP server. The coding
client owns that process; developers do not launch it manually for each project.
The desktop starts one shared loopback HTTP server. Opening a project prepares its
enabled integration automatically through the same neutral port used by scaffold
and the explicit DEV retry. An explicitly disabled integration remains disabled.
Preparation failure is visible in DEV and does not make the project unusable.
Opening a project does not publish credentials or grant control.
The macOS installation has a stable `current` reference pointing to a validated,
versioned distribution containing dependency JARs and Java. The native client
invokes the absolute installed Java path with a classpath/main/project argument
array. Updating the installation changes the reference, not every project's client
entry. Old versions remain available for rollback and existing processes.
The tradeoff is an additional lightweight JVM for stdio transport, plus managed
installation lifecycle. In return, there are no per-project launchers or copied
connector binaries, and execution does not depend on an interactive shell PATH.
## Configuration and Authority Have Different Owners
| Surface | Lifetime and responsibility |
| --- | --- |
| `.studio/setup.json` | Neutral integration intent; preserves runtime/editor settings |
| `.codex/config.toml` | Local installed command, arguments and canonical project binding; no transient credentials |
| `.studio/mcp/connection.json` | Protected, temporary discovery data published by human grant |
| Core grant/task/operation records | In-memory authority and receipts; never restored from configuration |
Preparation edits only a managed client entry, validates the result with a TOML
parser and preserves unrelated settings/comments. User-owned, edited or tracked
entries cause explicit conflicts. Initial client trust or reload may still be
required; Studio does not change approval policy.
Human grant publishes a fresh credential scoped to one canonical project root.
HTTP sessions are bound to that credential, and the server enforces scope even
for knowledge reads. Restricting only the connector would leave a direct HTTP
bypass. Acquisition still creates a separate task identity through shared Core
services.
## Publication Is Part of the Grant Transaction
Publication cannot be a best-effort snapshot listener. The neutral lifecycle port
coordinates preparation, publication, activation, invalidation and cleanup:
1. Save and verify documents under the existing handoff rules.
2. Acquire the OS publication lock and write a private temporary descriptor outside
the authority monitor.
3. Atomically publish, then activate under the grant generation fence. Acquisition
remains unavailable until the transition completes.
4. Abort failed or superseded grants and remove their provisional access.
5. Revoke credentials before asynchronous work cleanup; remove only the owned
publication and release its lock.
The lock file's inode is retained. Deleting it could let another process lock a
new inode while the first owner still holds the old one. The OS releases the lock
after a crash, allowing safe replacement of stale discovery data. Directories are
0700 and secret-bearing files 0600; Git exclusion alone is not access control.
Cleanup checks publication ownership so an old callback cannot delete newer data.
File cleanup failure must not prevent runtime cancellation.
## Reconnect Without Replaying Intent
The stdio connector initializes and lists its packaged catalog before Studio or a
grant is available. It verifies live instance, root and catalog identity before
forwarding. Calls preserve structured results and native image blocks; response
limits are separate from the smaller request limit.
Discovery and ping may be retried. Build and frame advancement must not be
resubmitted automatically after a lost response. Within the same authorized task,
recover by operationId/clientRequestId lookup. After restart, old in-memory
receipts are unavailable: report an unknown outcome and require a fresh grant/task
and an explicit next intent. Connection liveness and working/manual authority are
separate DEV states.
## Implementation Findings
- JSON-RPC numeric IDs must be compared by numeric value. Jackson can represent
the same wire number with different integer node types.
- Grant publication is asynchronous. Tests must await the transition without
blocking the JavaFX thread or assuming a button callback completes filesystem IO.
- `jlink` can generate read-only license files. Normalize staged runtime write
permissions so subsequent Gradle installation updates can replace them.
- An IntelliJ desktop can run from classes without a managed installation. A
generic “preparation incomplete” message hid this prerequisite. The specific
diagnostic now points to `:prometeu-app:stageStudioInstallation` and the optional
`studio.installationRoot` VM setting.
- Preparation belongs to project opening, not only creation or a manual DEV
button. Otherwise existing projects retain unnecessary onboarding friction.
- Capture data larger than 1 MiB must not inherit the request-body cap. The
connector bounds response size and body-read time separately.
## Verified Results and Acceptance
The full implementation gate recorded 839 passing tests, 15 existing skips and no
failures, including installation, desktop and real runtime gates. The later
missing-installation diagnostic and automatic-open revision passed their targeted
preparation, Core, app, architecture and runtime suites. Installation staging,
`git diff --check` and `discussion validate` also passed.
Process tests cover cold initialization, later grant and restart in one connector;
large images; root/session scope; stale identity/catalog rejection; lost build
response with execution count remaining one; unknown old-task receipts; concurrent
publisher JVMs and crash recovery; protected files; grant/close races; TOML
preservation; and stable installed Java across updates.
On 2026-09-29, after being asked specifically about the outstanding manual gates,
the user confirmed that all were finished. This closes the native Codex
acquire/build/image/release and reconnect-after-restart cycle, installation update
and graphical-client launch, and IntelliJ debugger attachment. The provenance of
this final evidence is **user-reported acceptance**, not an additional automated
run or an independently observed transcript. The implementation's automated
environment was macOS ARM64 with bundled Corretto 21.0.4 and Codex CLI 0.158.0
installed; that version inspection alone was not treated as native-client proof.
The prior HTTP-only acceptance from DSC-0068 was not substituted for these gates.
The first accepted integration remains Codex on macOS; other clients/platforms
and the embedded terminal are outside this delivery.
## Operational Example
Open the project in Studio. Its enabled client integration is prepared without a
separate per-project Run. Start the coding client in that project and satisfy its
initial trust/reload requirements. Grant access in DEV, acquire the task through
native tools, edit/validate, then release. After Studio restarts, grant again;
keep the client configuration unchanged. An old task is never restored.
For an IntelliJ desktop, run `p.studio.app.StudioLauncher` with the
`prometeu-app` classpath and Java 21. If a managed installation is missing, stage
it once with `./gradlew :prometeu-app:stageStudioInstallation`. An isolated
installation uses the `studio.installationRoot` desktop VM property. The MCP
stdio process remains client-owned; attach Remote JVM Debug to that process using
an explicit development-only loopback JDWP option. Do not configure the desktop
Run itself with `mcp --project` arguments.
## References
- DEC-0061 and PLN-0140: historical source decision and completed implementation
plan for DSC-0070; removed from active workflow during housekeeping.
- [Studio shell and project creation](../../../docs/specs/studio/1.%20Studio%20Shell%20and%20Workspace%20Layout%20Specification.md).
- [Project-local state and discovery](../../../docs/specs/studio/8.%20Project-Local%20Studio%20State%20Specification.md).
- [Core and adapter architecture](../../../docs/specs/studio/9.%20Studio%20Core%20and%20Adapter%20Architecture%20Specification.md).
- [DEV and authority](../../../docs/specs/studio/10.%20DEV%20and%20Automation%20Specification.md).
- [MCP contract and acceptance boundary](../../../docs/specs/studio/11.%20MCP%20Tools%20and%20Project%20Knowledge%20Contract.md).
- [Setup and IntelliJ debugging](../../../README.md).
- [DSC-0068 baseline lesson](../DSC-0068-studio-headless-runtime-ai-first/LSN-0076-ai-first-studio-through-shared-authority-and-headless-evidence.md).
- DSC-0071: the separate embedded-terminal discussion; unchanged by this work.
@@ -537,3 +537,22 @@ The current PBS design direction is:
10. `declare host` remains reserved to stdlib/toolchain interface modules.
11. Reserved attributes such as `[Host(...)]` are compile-time metadata, not runtime objects.
12. The compiler consumes `Host` metadata to produce runtime-facing host-binding artifacts defined elsewhere.
## Editorial exposure of external sources
SDK/core remain reserved bundled sources. Editorial navigation MUST NOT extract
or copy them into a project or disk cache. Compiler-known dependency sources,
including those under `.workspace`, and SDK/core are exposed as read-only external
documents with revision-consistent text, ranges and frontend semantic context.
Hover and continued definition use that retained context. Compilation, module
admission, ABI and linking rules are unchanged. See Compiler Spec 23 §8.3 and
Studio Spec 11 for the consumer protocol and atomic write restrictions (DEC-0062).
PBS project hover, definition, completion and signature help MUST share receiver
type resolution using PBS expression parsing and semantic overload rules. Coverage
includes function/method chains with known return types, nested call arguments,
explicitly typed and inferred variables, parentheses, completion after a trailing
dot and signature help during incomplete arguments. An unrelated parse error MUST
NOT invalidate a recoverable receiver. Unknown or ambiguous receivers MUST NOT
invent a type or overload. Indexing/operator-produced receivers are outside the
new coverage; existing behavior MUST NOT regress.
@@ -356,3 +356,13 @@ Content hashes identify the packaged texts, not a semantic language release.
Conformance MUST include reading all indexed references from installed JARs outside
the repository and compiling the shipped example against the installed SDK. No
network access or source checkout may be required by that reference-read path.
## Editorial exposure of external sources
SDK/core remain reserved bundled sources. Editorial navigation MUST NOT extract
or copy them into a project or disk cache. Compiler-known dependency sources,
including those under `.workspace`, and SDK/core are exposed as read-only external
documents with revision-consistent text, ranges and frontend semantic context.
Hover and continued definition use that retained context. Compilation, module
admission, ABI and linking rules are unchanged. See Compiler Spec 23 §8.3 and
Studio Spec 11 for the consumer protocol and atomic write restrictions (DEC-0062).
@@ -272,7 +272,17 @@ Absent editor capabilities MUST have deterministic fallback behavior at tooling
3. host protocols that can represent unsupported operations SHOULD do so explicitly;
4. and absent editor capability MUST NOT be reported as a compiler failure.
When a frontend exposes definition or navigation, each returned location MUST identify a compiler-known physical source file. A resolved symbol without a physical file MUST produce an empty definition response. Tooling MUST NOT require virtual documents, untitled buffers, or synthetic URIs for this capability.
When a frontend exposes definition or navigation, each returned location MUST identify a compiler-known source in the analyzed revision. Editable main-project locations use `file:`. Bundled SDK/core and ordinary dependency sources use server-issued `prometeu-source:` identities for consumers that negotiate external-source support. Ownership, not physical containment or `SourceKind.PROJECT`, determines editability. Clients without support receive only editable physical project destinations; absent frontend support retains the empty fallback. This explicitly supersedes the earlier physical-only definition policy (DEC-0062).
`FrontendLanguageService.supportsExternalSources` and `sourceDocument` are optional,
with false/empty defaults. `FrontendDefinitionLocation.source`, when present,
contains the known source's exact text, origin, name, language, read-only ownership
and opaque frontend context. Compiler contracts do not mint session URIs; that is
the project host's responsibility. The content digest is not an SDK version.
External source snapshots MUST retain the exact analyzed text, source origin and frontend semantic context together. Declaration offsets and UTF-16 protocol positions MUST be calculated from that text. The frontend owns hover and continued definition inside external documents; adapters MUST NOT resolve language semantics. SDK/core MUST remain bundled without editorial extraction. Unknown, expired, unreadable or unauthorized identities MUST report unavailable without arbitrary path fallback.
External URIs are scoped to a project-server session and a content revision, not an SDK semantic version. A project-owned registry retains snapshots per consumer, independently of transport connections. Last release or project shutdown releases text and semantic context together. Reconnection MUST revalidate before queries resume; changed revisions require fresh navigation, never old positions applied to new text. One consumer closing MUST NOT invalidate another. All edit proposals touching an external source, including physical aliases, MUST be refused atomically. References, workspace symbols, document links and hierarchies retain their existing physical scopes; external navigation does not expand them.
When a frontend exposes find-references, each returned usage or declaration location MUST identify a compiler-known physical source file. A cursor offset whose definition response is empty MUST produce an empty references response. Host `includeDeclaration` MAY add the canonical declaration location only when that declaration is a compiler-known physical source file; it MUST NOT invent a virtual, untitled, or synthetic location.
@@ -142,3 +142,23 @@ This specification is complete enough when:
- workspace and shell responsibilities are clearly separated;
- the shell-level expectations for workspace architecture are explicit;
- the baseline Studio frame is stable enough for implementation planning.
## Project Assistant Preparation (DEC-0061)
Project creation MUST scaffold neutral agent-integration intent in
`.studio/setup.json` and invoke the same preparation port used by existing
projects in DEV. Application infrastructure resolves installed Studio and client
configuration; the wizard/Core MUST NOT serialize provider TOML or launch an
agent. Failed preparation leaves a usable project with actionable incomplete
readiness in DEV, never a false ready claim. Runtime/editor settings and unrelated
client configuration MUST survive. Preparation grants no project control.
### Automatic preparation when opening a project
Opening a project MUST prepare its enabled MCP integration using the same neutral
port as scaffold and DEV retry. Desktop composition MUST start the shared loopback
server before project sessions become available; no external command or separate
per-project desktop Run is required. Explicitly disabled integration MUST remain
disabled. Preparation failure MUST remain visible in DEV readiness without blocking
project use. Opening MUST NOT publish credentials or grant/acquire agent control.
The coding client continues to own its configured stdio process and initial trust.
@@ -164,7 +164,7 @@ DEV MUST expose:
- the four control states, project identity, current managed operation and diagnostics;
- a canonical-image canvas with session/build/logical-frame/render-frame identity and stale status;
- a short history of Studio calls, not an independent code history;
- **Copy MCP configuration**, plus short connection/use instructions when the real MCP composition is available.
- **Prepare assistant**, plus short connection/use instructions when the real MCP composition is available.
Actions MUST reflect shared service authority. DEV MUST NOT own a duplicate
lock or release authority when disposing visual subscriptions. Presentation
@@ -177,8 +177,7 @@ in Debug with its existing host/protocol/lifecycle, subject to symmetric guards.
“Agent working” means the task has been acquired; it is not a claim to observe
all external edits, reasoning or conversation.
Without a real composed MCP endpoint, configuration copy MUST be unavailable
rather than produce a fabricated endpoint or token. Test doubles MAY supply
Preparation MUST report missing installation or configuration conflicts explicitly; it does not depend on a live grant or fabricate endpoint credentials. Test doubles MAY supply
operations/captures to isolated tests, never masquerade as product execution.
## 6. Operations and Lost Responses
@@ -274,19 +273,18 @@ that it uses. Capture/build correlation MUST NOT introduce code snapshots.
Concrete tool names, input schemas, response envelopes and HTTP lifecycle are
specified in [MCP Tools and Project Knowledge Contract](11.%20MCP%20Tools%20and%20Project%20Knowledge%20Contract.md).
The app MUST host Streamable HTTP at `127.0.0.1:<OS-assigned-port>/mcp` while
Studio is open. It MUST generate a random token per Studio start, require it
on connections, validate Origin and reject unexpected origins. No remote
binding, accounts, OAuth or stdio MCP bridge is part of this baseline.
Copied configuration MUST contain the actual endpoint/token and MUST NOT be
written to versioned files. Instructions MUST explain that restart requires
refreshing client configuration. Copying configuration and authenticating
MUST NOT grant control.
The desktop MUST host Streamable HTTP at `127.0.0.1:<OS-assigned-port>/mcp`.
DEC-0061 adds Studio-owned stdio discovery and one-time preparation as specified
in spec 11. Each human grant publishes a fresh project-scoped credential through
the required lifecycle participant in spec 8. Authentication, project scope and
task identity remain separate checks. There is no global credential bypass.
Restart invalidates old access and requires a fresh human grant, while the native
client's command/configuration remains unchanged. No remote binding, accounts or
OAuth are introduced. Preparation never grants editing authority.
| Tool group | Required capabilities | Required authority |
| --- | --- | --- |
| Context/references | Project identity, languages, versions, capabilities and paginated references | Authenticated connection; no grant required |
| Context/references | Project identity, languages, versions, capabilities and paginated references | Project credential; no acquired task required |
| Control | Acquire task and release control | Prior human grant for acquisition; valid task identity for release |
| Language | Existing LSP diagnostics/navigation and supported capabilities | Valid project/task identity |
| Build | Compile and pack | Valid project/task identity |
@@ -373,7 +371,7 @@ mature gameplay library is not a prerequisite.
- Pixel-art generation, full-game libraries, audio capture or deep guest introspection.
- Shared editing, isolated worktrees, code snapshots/journals/checkpoints, merge/apply, divergence recovery, undo/rollback or automatic commits/clean-tree gates.
- Replacing compiler, Packer, LSP, VM or human Debug semantics; a new general-purpose Studio source editor.
- Remote MCP, accounts/OAuth, stdio MCP bridge, network runtime discovery or provider-specific connection wizard.
- Remote MCP, accounts/OAuth and network runtime discovery. Studio-owned stdio and local Codex preparation are the explicit DEC-0061 additions.
- Additional language implementation, persistent operation recovery or automatic task resumption.
- Integrated discussion-framework agendas/decisions/plans in the product; those are future work, not this runtime/DEV/MCP contract.
@@ -390,3 +388,14 @@ Implementation is conformant only when all phase gates hold and:
7. Lost operation responses cannot duplicate execution; runtime crash cannot trigger replay or implicit authority release.
8. Language context and indexed local references reflect real installed support and work without source checkouts.
9. Manual Debug, architecture boundaries, packaging and real-client integration pass their regression gates.
## Integrated Connection Revision (DEC-0061)
Connection and authority MUST be displayed separately. Initialization/ping
liveness determines connection, while Core determines waiting/working/manual
control. A missing descriptor means waiting for access, not proof that Studio is
closed. Preparation reports initial client trust/reload requirements without
modifying approval policy. Revocation removes published access even before
asynchronous worker/runtime cleanup finishes. New grants never restore old task
IDs or receipts. Full integrated native-client acceptance belongs to PLN-0140;
the prior HTTP acceptance alone is insufficient.
@@ -3,7 +3,7 @@
## Status, Scope and Authority
Owner: **studio**, application adapter and neutral automation API. This document
formalizes DEC-0060 B5–B9 and PLN-0139 steps 15–16. It complements
formalizes DEC-0060 B5–B9 and the integrated connection revision in DEC-0061 (PLN-0140). It complements
[DEV and Automation](10.%20DEV%20and%20Automation%20Specification.md), which owns
project authority, lifecycle, captures and phase gates. It does not change those
rules or the runtime-owned headless protocol.
@@ -11,7 +11,7 @@ rules or the runtime-owned headless protocol.
The packaged machine-readable input schemas, authority classification and
examples are in `prometeu-app/src/main/resources/mcp/studio-tools-v1.json`.
Contract version is `1.0`. Catalog membership is not runtime availability:
`tools/list` MUST expose only composed handlers, never placeholder implementations.
HTTP `tools/list` MUST expose only composed handlers, never placeholder implementations. The offline Studio stdio entry MUST advertise the packaged catalog and report unavailable live capabilities explicitly.
Steps 17–21 connect the functional providers and DEV configuration assistance;
steps 22–28 provide the real runtime gateway and integrated acceptance.
@@ -23,18 +23,24 @@ initialization exchange negotiates that supported revision; no compatibility
with other revisions or deprecated HTTP+SSE transport is claimed. An offered
unsupported revision receives the supported revision in `InitializeResult`.
Each start generates a fresh 256-bit random bearer token. Every request MUST
include `Authorization: Bearer <token>`. Missing/wrong credentials return 401.
There is no query-string token, OAuth, cookie authentication, remote bind option,
stdio bridge or wildcard listener. The endpoint has no query parameters.
Each desktop start generates a new instance identity. Each human project grant
publishes a fresh 256-bit bearer credential scoped to that canonical project root.
Every HTTP request MUST include `Authorization: Bearer <credential>`; missing,
wrong or revoked credentials return 401. Initialized HTTP sessions MUST be bound
to that credential/root; mixing another credential with an existing session returns
403. All tools, including knowledge reads, MUST enforce the authenticated root
before dispatch. No instance-wide credential bypass is permitted.
There is no query-string token, OAuth, cookie authentication, remote bind option
or wildcard listener. The endpoint has no query parameters. Studio also provides
its own stdio mode, described below; it is part of the same artifact.
Native clients may omit `Origin`. If present, it MUST exactly equal the live
endpoint's origin (`http://127.0.0.1:<port>`); `null`, other ports/hosts/schemes
and multiple Origin headers fail. Host MUST match the live loopback authority.
Unexpected origins/hosts return 403. No permissive browser CORS policy is emitted.
Credentials MUST NOT appear in diagnostics, exception messages, object string
representations, generated reports or versioned configuration. Explicit copying
for the external client is provided in step 21, not by logging startup secrets.
representations, generated reports or versioned configuration. The project discovery file is the only secret-bearing setup output; persistent client configuration and clipboard assistance MUST NOT export secrets.
Initialization assigns a separate random `Mcp-Session-Id`. Subsequent requests
include this header and the negotiated `MCP-Protocol-Version`. The server can
@@ -62,34 +68,87 @@ and [tools](https://modelcontextprotocol.io/specification/2025-06-18/server/tool
contracts. Optional SSE, server-initiated requests, sampling, prompts, resource
subscriptions and list-change notifications are not advertised.
### 1.1 DEV Connection Assistance
### 1.1 Integrated Studio Entry and Offline Catalog
DEV displays the current endpoint without credentials and provides **Copy MCP
configuration** for an open project. The neutral `AgentConnectionGuide` supplies
availability and a deliberate clipboard export; JavaFX MUST NOT depend on the
HTTP server or keep credentials in labels, diagnostics, project state or history.
Connection lifecycle changes refresh availability. A closed project or stopped
server cannot export a descriptor. Unloading DEV only unsubscribes presentation
listeners; it does not stop the endpoint or revoke project authority.
`StudioLauncher mcp --project <absolute-root>` MUST dispatch before JavaFX or
Spring desktop startup. The root MUST be canonicalized once, contain the project
manifest and remain bound for the process lifetime, independently of client cwd.
The mode MUST NOT open a desktop, LSP, runtime or another HTTP listener. It uses
newline-framed UTF-8 JSON-RPC on stdin/stdout; stdout is protocol-only. Requests
are bounded to 1 MiB. EOF closes transport resources without releasing task control.
The copied text is a provider-neutral JSON descriptor with `transport` set to
`streamable-http`, the live `url`, `headers.Authorization`, canonical `projectRoot`
and `instructions`. It is not a promise of a drop-in configuration format for
every external client. The developer maps URL/header fields to that client's MCP
configuration; a provider-specific wizard remains out of scope. The secret is
materialized only for explicit copying and MUST NOT be written to versioned files
or logs. Clipboard success/failure feedback MUST NOT repeat credential-bearing
content or raw exceptions. The clipboard itself is a deliberate secret export.
Initialize, initialized notification, ping and tools/list MUST work before the
desktop, descriptor or grant exists. Offline descriptors come from the same
packaged catalog as HTTP. A deterministic fingerprint covers protocol and tool
schemas. Before forwarding, the connector MUST validate the descriptor, initialize
HTTP, check instance/root/fingerprint metadata, and compare live descriptors with
the packaged catalog. Missing handlers return unsupported capability; incompatible
protocol/schema fails explicitly rather than silently changing the client's tools.
Copied instructions and MCP initialization guidance direct the client to discover
actual tools, read project context and applicable language/SDK/library references,
wait for human grant before acquisition, edit saved files within project scope,
validate with LSP/build, recover operation receipts by clientRequestId and release
explicitly. Missing language support is a reported limitation, not a PBS fallback.
They also explain that SDK/external libraries are read-only, revocation cannot
stop external file writes, copying grants no authority, and a Studio restart
requires fresh endpoint/token configuration. No provider or model is required
to test this guidance and the MCP service contract.
Tool calls MUST preserve structuredContent, text/error blocks and native image
blocks. Response bounds MUST support images above the 1 MiB request limit; the
current response cap is 32 MiB, including a bounded body-read deadline. Network
redirects MUST NOT be followed. The connector MUST reject another project root.
Discovery runs on calls and bounded background checks. Missing publication means
waiting for access, not proof that the desktop is closed. Distinguish invalid
file/permissions, stale credentials/instance, catalog incompatibility and transport
reconnection. Calls cannot wait indefinitely for a grant. No reconnect path may
resubmit a tool call. An uncertain response MUST retain available clientRequestId
correlation and instruct receipt lookup within the same authorized task. A new
desktop/task has no old receipt registry and requires a fresh human grant.
### 1.2 Stable Installation and Project Preparation
The initial delivery targets Codex on macOS. Studio owns a versioned installation
under `~/Library/Application Support/Prometeu/Studio`, with an atomic `current`
reference. Each version includes `lib` dependencies and a compatible Java runtime
under `runtime`. Validate a staged version before switching `current`; retain
previous versions for rollback and already-running processes. Failed validation
MUST leave the existing reference intact. Registered commands MUST work without
an interactive shell PATH, external JDK or developer checkout.
The client command is the absolute `current/runtime/bin/java`, with argument-array
values `-cp`, `<current>/lib/*`, `p.studio.app.StudioLauncher`, `mcp`, `--project`,
and the canonical root. No project-local executable, generated transport script,
helper binary or separate launcher installation is allowed. The desktop and
connector use the same Studio artifact. JDWP is an explicit development-only JVM
option; IntelliJ attaches to the client-owned connector process separately from
the desktop Debug configuration.
New-project scaffolding and existing-project preparation MUST use the same neutral
preparation port. `.studio/setup.json` stores integration schema/enabled/profile
intent, preserving runtime/editor settings; it contains no endpoint/credential/task.
Application infrastructure owns `.codex/config.toml` serialization. Its managed
`mcp_servers.prometeu_studio` table stores the stable command, arguments, project
cwd and cold-start timeout. Preserve all unrelated tables, comments, approval
policy and server entries byte-for-byte; validate edits with a TOML parser.
Repetition with identical values MUST be a no-op. User-owned or modified managed
entries and tracked client configuration MUST produce an actionable conflict,
never an overwrite. Keep a protected recovery copy of the previous owned block
without copying unrelated secrets. Precise ignore rules protect machine-local
client configuration and transient discovery without deleting existing rules.
Preparation MUST report incomplete writes/installations truthfully. Trust/reload
instructions apply to initial client registration only; no client trust or tool
approval may be bypassed. Grant and desktop restart MUST NOT require changing the
client configuration. A clone is prepared locally to resolve its own installation
and project paths. No global client configuration is rewritten.
### 1.3 DEV Connection Assistance
DEV MUST expose preparation/readiness through neutral API contracts and show
connection status separately from Core authority. Waiting for access, connected
and reconnecting derive from project-scoped initialization/ping activity with a
bounded liveness window; a retained HTTP session ID alone is insufficient. Working
remains an authority/operation state. DEV MUST NOT invent knowledge of a client
before it connects. A transport drop MUST NOT revoke a task or grant new control.
Preparation, labels, clipboard, diagnostics and history MUST NOT expose secrets.
Closing/hiding DEV only unsubscribes visual listeners. Human grant/reclaim and
project/application teardown retain their shared Core semantics. Instructions
cover native file edits, project knowledge, grant/acquire, validation, receipt
lookup, images and explicit release without generated transport clients.
## 2. Identity and Admission
@@ -101,7 +160,7 @@ prove authorization.
The authority levels in the packaged catalog are:
- `authenticated`: connection authentication only; project/context/reference reads
are allowed before grant. No task token is returned by discovery.
need no acquired task. HTTP access still requires the project credential published by human grant. Offline catalog discovery returns no task token.
- `granted`: acquisition validates the prior human grant and atomically creates
the sole task identity. The transport session ID is not that identity.
- `task`: `projectRoot` and `taskId` must identify the current acquired task.
@@ -187,7 +246,7 @@ for one fixed port. The public LSP configuration default remains unchanged for
other hosts. A manifest language change requires reopening that project's server;
the adapter MUST NOT send queries to a server bound to another language/root.
Each query uses a short-lived client connection. For document requests, the
Each query uses a short-lived client connection. For physical document requests, the
adapter opens exactly the saved UTF-8 text and waits for that connection's
published diagnostics before issuing the semantic query. Other dependency files
are read from disk by the existing compiler bridge. A fresh connection prevents
@@ -207,14 +266,54 @@ Core bounds the request worker wait to 12 seconds. Documents are limited to 4 Mi
of UTF-8 and task-local hierarchy state to 1024 items. These are adapter resource
guards, unrelated to the runtime's deterministic frame/watchdog semantics.
Document URIs must resolve to known physical project/dependency source files.
Document URIs must resolve to known physical project/dependency source files or to an external identity owned by the current task and project.
Symlink targets are canonicalized before admission. External sources may be
queried, but edit-producing queries on read-only roots are rejected. Every URI in
returned workspace-edit proposals is checked against the same editable/read-only
scope; an unsafe proposal is rejected as a whole. File-operation edits and
executable commands are not offered; `workspace/applyEdit` is always refused.
No query writes a file. Virtual SDK declarations may not have physical definition
locations in the existing LSP; indexed SDK references remain available instead.
No query writes a file. `readExternalSource` reads the exact registered external
revision; hover and definition on its URI use the retained frontend semantic
context. Indexed SDK reference tools remain separate and available. MCP needs no
VS Code connection and MUST retain its consumer across short-lived query sockets.
Task return/cancellation releases that task's external uses; project shutdown
invalidates all identities. Cross-task/project replay is refused.
### External-source protocol (DEC-0062)
Initialize negotiates `capabilities.experimental.prometeuExternalSources: true`;
the server advertises the same flag only when supported. External definitions use
`prometeu-source:` URIs minted by the project host. A descriptor carries `uri`,
`revision` (content digest), `origin`, `name`, `languageId` and `readOnly: true`.
Locations carry ordinary LSP UTF-16 ranges over that exact source text.
The `prometeu/readExternalSource`, `prometeu/retainExternalSource`,
`prometeu/releaseExternalSource` and `prometeu/revalidateExternalSource` requests
carry `uri` and a server-issued `consumerId`. Initialize returns that identity in
`capabilities.experimental.prometeuExternalConsumerId`. Reconnecting clients pass
it as `initializationOptions.prometeuExternalConsumerId`; MCP also requests
`initializationOptions.prometeuExternalPersistentConsumer: true` on first use.
`releaseExternalSource` with `uri: null` releases the consumer and all its sources.
A read or explicit retain acknowledges a navigation result; unacknowledged results
are released when the socket closes. MCP acknowledges returned definitions before
closing its query connection and rolls back newly retained results on failure.
Read-only edit refusal uses LSP error `-32010`, mapped to MCP `READ_ONLY_SCOPE`.
Consumer identity is scoped to the
project session; the MCP adapter additionally binds it to its authorized task.
Read returns the descriptor plus `text`. Retain/release are idempotent per consumer.
Revalidation confirms the same admitted origin and revision before queries resume;
a changed revision reports unavailable and requires new navigation. Unknown,
expired, unauthorized and unreadable sources are explicit errors, never disk reads
chosen by client paths. Consumers are created by the server, not caller-selected.
VS Code uses a read-only text content provider, with the source language and no
save-back path. Disconnect may leave the immutable text visible, but blocks
semantic queries until revalidation. No content-change event may replace the old
revision under old positions. Closing the last consumer releases the snapshot;
one reader closing must not invalidate another reader. Edit operations and mixed
workspace edits are rejected in their entirety, including physical aliases.
Packaged Studio validation is excluded from this delivery; development tests must
exercise both VS Code and independent MCP navigation.
## 4. Result, Error and Operation Contracts
@@ -335,7 +434,7 @@ reference provider, not a Studio-maintained language specification.
`studio_project_context` resolves an exact, canonical root registered by an open
project session. It does not use the focused window, accept a source-directory
path as a project root, acquire a manual lease, or require an AI grant. A session
path as a project root, acquire a manual lease, or acquire task authority. The HTTP boundary separately requires the grant-published project credential. A session
is discoverable only after successful opening and until closure begins.
Unregistered/closed roots return `PROJECT_NOT_OPEN`.
@@ -395,8 +494,7 @@ example references identify their SDK major and target; unsupported selections
MUST NOT silently reuse another SDK/target. Numbered spec/draft revisions and the
reference-index schema revision MUST NOT be reported as language/compiler versions.
`studio_reference_read` is authenticated but does not require a control grant or
task. It resolves the explicit open root and its current saved manifest selection
`studio_reference_read` is authenticated but does not require an acquired task; the transport still requires a grant-published project credential. It resolves the explicit open root and its current saved manifest selection
on every read. Changing SDK/target can invalidate previously advertised IDs.
Only IDs in that project's installed index can be read, including when other
languages/providers are installed globally. SDK and external-library texts remain
@@ -442,7 +540,7 @@ The production registry composes all 17 tools as of step 23, including headless
handlers bound to the actual `HeadlessProcessGateway`. Missing project runtime
configuration fails at boot with `RUNTIME_UNAVAILABLE`; tool discovery does not
grant authority or launch a process. No fake runtime is shipped.
DEV configuration-copy is connected as of step 21. The automated HTTP conformance
The former configuration-copy flow is superseded by DEC-0061 permanent preparation and grant-time discovery. The automated HTTP conformance
gate exercises all 17 tool contracts using real project knowledge/LSP and test-only
build/runtime ports; a separate HTTP test uses the real compiler/packer. This
completes MCP-phase conformance. The packaged-runtime gate additionally exercises
@@ -493,3 +591,26 @@ cycles using the extracted Studio ZIP. The latter verified listener closure and
old-credential rejection after restart. API/Core and JavaFX MUST NOT import
MCP/HTTP implementations; architecture tests enforce it. Consolidated acceptance
evidence and deferred findings live in the DSC-0068 lesson, not in temporary logs.
### Integrated Connection Acceptance (DEC-0061)
Prior DSC-0068 native-client evidence covers the original HTTP flow only. The
integrated flow additionally requires a real native Codex session initialized
before grant, unchanged configuration through desktop restart/new grant, native
images/build/release, scaffold and existing-project preparation, installation
update and graphical launch, plus IntelliJ connector attachment. Automated
fixtures cannot substitute for these gates. PLN-0140 completed automated validation
and the user confirmed all outstanding manual gates on 2026-09-29. The manual
confirmation is user-reported acceptance, not an independently observed test run.
[LSN-0077](../../../discussion/lessons/DSC-0070-studio-persistent-mcp-connector/LSN-0077-integrated-mcp-stable-setup-and-ephemeral-access.md)
preserves the result and evidence provenance after workflow housekeeping.
### Automatic preparation when opening a project
Opening a project MUST prepare its enabled MCP integration using the same neutral
port as scaffold and DEV retry. Desktop composition MUST start the shared loopback
server before project sessions become available; no external command or separate
per-project desktop Run is required. Explicitly disabled integration MUST remain
disabled. Preparation failure MUST remain visible in DEV readiness without blocking
project use. Opening MUST NOT publish credentials or grant/acquire agent control.
The coding client continues to own its configured stdio process and initial trust.
@@ -79,7 +79,7 @@ The main session-restoration store MUST NOT include:
- heavy operational output;
- recomputable results that do not represent session restoration state.
Under DEC-0060, automation grants, task/control identities, active runtime sessions and the task-local operation/deduplication registry MUST NOT be persisted or restored through `.studio/state.json` or `.studio/setup.json`. Reopening a project MUST start under manual control. Restoring DEV as the selected workspace is presentation restoration, not permission to resume work. MCP connection credentials MUST NOT be stored in versioned files; they are regenerated on Studio restart. See the [DEV and Automation Specification](10.%20DEV%20and%20Automation%20Specification.md).
Under DEC-0060, automation grants, task/control identities, active runtime sessions and the task-local operation/deduplication registry MUST NOT be persisted or restored through `.studio/state.json` or `.studio/setup.json`. Reopening a project MUST start under manual control. Restoring DEV as the selected workspace is presentation restoration, not permission to resume work. MCP connection credentials MUST NOT be stored in versioned files; they are regenerated for every project grant and never restored on restart. See the [DEV and Automation Specification](10.%20DEV%20and%20Automation%20Specification.md).
`Project-local activity` and project-local setup may still live under `.studio/`, but they are separate persistence concerns and not part of the main session-restoration store defined here.
@@ -105,3 +105,36 @@ This specification is complete enough when:
- accepted and excluded categories are explicit;
- load, restore, save, and fallback timing are explicit;
- and the ownership boundary with `StudioProjectSession` is normatively locked.
## Integrated MCP Discovery (DEC-0061)
`.studio/setup.json` MUST carry neutral `agentIntegration` intent with
`schemaVersion:1`, `enabled` and `clientProfile`. Preserve runtime and editor
fields. This intent is configuration, not readiness or authorization. Machine-local
resolved client configuration is a separate preparation output.
The transient descriptor is `.studio/mcp/connection.json`, limited to 16 KiB.
Schema v1 requires integral `schemaVersion:1` and nonempty string `instanceId`,
`projectRoot`, `endpoint`, `credential`, `catalogFingerprint`. Root MUST match the
connector's canonical root. Endpoint MUST be `http://127.0.0.1:<port>/mcp`, with
no userinfo, query, fragment or redirect. Grant/task IDs and receipts are forbidden.
On macOS `.studio/mcp` MUST be owned by the current user with mode 0700;
descriptor, lock and temporary files MUST be 0600 before secrets are written.
Reject symlinked/unsafe paths and tracked descriptor targets. Add precise ignore
rules idempotently without changing unrelated project permissions or files.
Ownership MUST use an OS-held lock on the stable `publication.lock` inode; do
not delete the lock file on ordinary cleanup. A second live publisher fails. A
crashed process releases its lock through the OS; a new owner may atomically
replace stale content. Write a protected same-directory temporary file and
atomically rename it. Cleanup checks both instance and publication generation
so an old callback cannot remove newer discovery data.
Publication is a required grant lifecycle participant, not a swallowed observer.
Prepare/publish occur outside the Core monitor; authority activation uses a
generation fence. Acquisition cannot succeed until publication and grant both
commit. Failure aborts credentials/files and reports a failed grant. Revoke/close
invalidate credentials before asynchronous work cleanup, then remove owned
publication and release ownership. File cleanup failure MUST NOT prevent runtime
cancellation. An already-admitted release response MUST remain deliverable.
@@ -114,9 +114,9 @@ The JavaFX module MUST NOT directly invoke compiler implementations, `p.packer`,
Spring Boot MUST be used only by `prometeu-app` for desktop composition and lifecycle. `WebApplicationType.NONE` remains a valid composition mode with an explicitly managed local HTTP adapter. Conformance MUST NOT impose an unconditional absence of a web server that would forbid the DEC-0060 MCP exception.
The sole accepted HTTP-server use is an in-process MCP Streamable HTTP endpoint at `127.0.0.1:<OS-assigned-port>/mcp`. The application/infrastructure adapter MUST own its transport dependencies and lifecycle. It MUST require a random per-Studio-start token, validate Origin and reject unexpected origins, and stop with Studio. Connection authentication MUST NOT grant project/task authority. The token MUST NOT be stored in versioned files, and restart requires refreshed client configuration.
The sole accepted HTTP-server use is an in-process MCP Streamable HTTP endpoint at `127.0.0.1:<OS-assigned-port>/mcp`. The application/infrastructure adapter MUST own its transport dependencies and lifecycle. It MUST require a fresh grant-published project credential, validate project/session scope and Origin, and stop with Studio. Connection authentication MUST NOT grant project/task authority. Credentials MUST NOT be stored in versioned files. Restart requires a fresh human grant, while the stable client configuration remains unchanged.
This exception does not authorize a web UI, remote binding, general-purpose web application, accounts, OAuth, or a stdio MCP bridge. HTTP/MCP dependencies MUST NOT enter API/Core or the JavaFX adapter. Spring Data, Spring AI and durable event infrastructure remain outside the accepted architecture.
This exception does not authorize a web UI, remote binding, general-purpose web application, accounts or OAuth. DEC-0061 explicitly adds the Studio-owned stdio mode and local client preparation. HTTP/MCP dependencies MUST NOT enter API/Core or the JavaFX adapter. Spring Data, Spring AI and durable event infrastructure remain outside the accepted architecture.
Spring configuration MAY create core services, infrastructure adapters, and a JavaFX composition factory. It MUST NOT use field injection, context lookup, broad service bags, or a replacement static container.
@@ -178,3 +178,17 @@ The architecture is conformant only when all of the following hold together:
- migrating the Studio to Rust, Electron, Tauri, or a parallel rewrite;
- redesigning compiler, Packer, LSP, or runtime semantics;
- introducing microservices or durable event infrastructure.
## Integrated MCP Connection Boundary (DEC-0061)
The same Studio application artifact MUST support `mcp --project` over stdio
before desktop composition. It connects to the existing loopback HTTP adapter;
it MUST NOT implement separate authority, operations, language services or runtime
semantics. Offline catalog loading does not initialize the desktop graph.
API exposes neutral preparation/readiness and connection-publication lifecycle
ports. Core orchestrates save, publication commit/abort, grant, revocation and
shutdown through those ports. Application infrastructure owns credentials, file
locks/atomic discovery, HTTP identity checks, TOML preparation and managed
installation/runtime packaging. JavaFX consumes neutral status and actions only.
Filesystem publication MUST NOT run under a long-held authority monitor.
+11
View File
@@ -84,3 +84,14 @@ Normative reminders:
- the Studio backend is exposed through neutral API contracts shared by JavaFX and the local MCP adapter, without duplicated authority or orchestration;
- Spring Boot remains the desktop composition root with the narrow DEC-0060 local MCP HTTP exception; Spring Modulith still verifies the JavaFX-free `p.studio.core` boundary;
- `p.studio.Container`, `AppContainer`, and the mixed `prometeu-studio` module are not valid final architecture.
## Integrated MCP connection
DEC-0061 revises the baseline with Studio-owned `mcp --project` mode, grant-time
project discovery, scoped HTTP credentials, one-time scaffold/preparation and a
stable installation with bundled Java. Specs 8–11 define the lifecycle and
transport boundaries; spec 1 defines project creation. PLN-0140 is complete;
automated results and user-confirmed manual acceptance are consolidated in
[LSN-0077](../../../discussion/lessons/DSC-0070-studio-persistent-mcp-connector/LSN-0077-integrated-mcp-stable-setup-and-ephemeral-access.md).
The earlier HTTP evidence was not substituted for these gates. The embedded
terminal remains separate.
+11 -6
View File
@@ -27,17 +27,22 @@ pipeline {
--no-daemon
"""
}
junit testResults: '**/build/test-results/test/TEST-*.xml'
}
withChecks(name: 'JaCoCo Coverage', includeStage: false) {
recordCoverage(tools: [[parser: 'JACOCO', pattern: "build/reports/jacoco/jacocoTestReport/jacocoTestReport.xml"]],
id: 'jacoco',
name: 'JaCoCo Coverage',
checksName: 'JaCoCo Coverage',
sourceDirectories: [[path: 'glob:**/src/main/java']],
sourceCodeEncoding: 'UTF-8',
sourceCodeRetention: 'EVERY_BUILD',
qualityGates: [
[threshold: 50.0, metric: 'CLASS', baseline: 'PROJECT', unstable: true],
[threshold: 50.0, metric: 'METHOD', baseline: 'PROJECT', unstable: true],
[threshold: 50.0, metric: 'LINE', baseline: 'PROJECT', unstable: true],
[threshold: 50.0, metric: 'INSTRUCTION', baseline: 'PROJECT', unstable: true],
[threshold: 40.0, metric: 'BRANCH', baseline: 'PROJECT', unstable: true]])
junit testResults: '**/build/test-results/test/TEST-*.xml'
[threshold: 50.0, metric: 'CLASS', baseline: 'PROJECT', criticality: 'UNSTABLE'],
[threshold: 50.0, metric: 'METHOD', baseline: 'PROJECT', criticality: 'UNSTABLE'],
[threshold: 50.0, metric: 'LINE', baseline: 'PROJECT', criticality: 'UNSTABLE'],
[threshold: 50.0, metric: 'INSTRUCTION', baseline: 'PROJECT', criticality: 'UNSTABLE'],
[threshold: 40.0, metric: 'BRANCH', baseline: 'PROJECT', criticality: 'UNSTABLE']])
}
}
} // Test
+1
View File
@@ -12,6 +12,7 @@ spring-boot = "3.5.16"
spring-modulith = "1.4.13"
[libraries]
tomlj = { group = "org.tomlj", name = "tomlj", version = "1.1.1" }
javafx-controls = { group = "org.openjfx", name = "javafx-controls", version.ref = "javafx" }
javafx-fxml = { group = "org.openjfx", name = "javafx-fxml", version.ref = "javafx" }
richtextfx = { group = "org.fxmisc.richtext", name = "richtextfx", version.ref = "richtextfx" }
+48
View File
@@ -4,6 +4,7 @@ plugins {
}
dependencies {
implementation(libs.tomlj)
implementation(project(":prometeu-infra"))
implementation(project(":prometeu-lsp:prometeu-lsp-api"))
implementation(project(":prometeu-lsp:prometeu-lsp-v1"))
@@ -26,6 +27,36 @@ application {
mainClass = "p.studio.app.StudioLauncher"
}
val studioJava = javaToolchains.launcherFor { languageVersion = JavaLanguageVersion.of(21) }
val studioRuntime = layout.buildDirectory.dir("studio-runtime")
val assembleStudioRuntime by tasks.registering(Exec::class) {
val jdk = studioJava.get().metadata.installationPath.asFile
inputs.property("jdk", jdk.absolutePath)
outputs.dir(studioRuntime)
doFirst { delete(studioRuntime) }
// jlink license files can be read-only; Gradle Sync must be able to refresh the installed image.
doLast {
studioRuntime.get().asFile.walkTopDown().filter { it.isFile }.forEach {
check(it.setWritable(true, true)) { "Cannot normalize staged runtime permissions" }
}
}
commandLine(jdk.resolve("bin/jlink"), "--add-modules", "ALL-MODULE-PATH", "--strip-debug", "--no-header-files",
"--no-man-pages", "--output", studioRuntime.get().asFile)
}
distributions {
main { contents { from(assembleStudioRuntime) { into("runtime") } } }
}
tasks.register<JavaExec>("stageStudioInstallation") {
group = "application"
description = "Stages and validates the bundled Studio/Java installation; no project launcher is created."
dependsOn(tasks.named("installDist"))
classpath = sourceSets["main"].runtimeClasspath
mainClass = "p.studio.app.install.ManagedStudioInstallation"
args(layout.buildDirectory.dir("install/prometeu-app").get().asFile.absolutePath,
providers.gradleProperty("studioInstallationRoot").getOrElse(
"${System.getProperty("user.home")}/Library/Application Support/Prometeu/Studio"))
}
javafx {
version = libs.versions.javafx.get()
modules("javafx.controls", "javafx.fxml")
@@ -77,3 +108,20 @@ tasks.register<Test>("headlessMcpDesktopTest") {
systemProperty("java.awt.headless", "false")
systemProperty("studio.test.runtimeInstall", providers.gradleProperty("studioRuntimeInstall").getOrElse(""))
}
// Subprocess tests exercise the actual Studio main and OS ownership boundaries.
tasks.withType<Test>().configureEach {
systemProperty("studio.test.classpath", sourceSets["test"].runtimeClasspath.asPath)
}
tasks.named<Test>("test") { exclude("**/InstalledConnectorTest.class") }
tasks.register<Test>("installedConnectorTest") {
group = "verification"
description = "Validates installed Java, stable updates, project preparation and JavaFX startup (requires a display)."
dependsOn(tasks.named("installDist"))
testClassesDirs = sourceSets["test"].output.classesDirs
classpath = sourceSets["test"].runtimeClasspath
useJUnitPlatform()
include("**/InstalledConnectorTest.class")
systemProperty("studio.test.distribution", layout.buildDirectory.dir("install/prometeu-app").get().asFile.absolutePath)
}
@@ -230,13 +230,16 @@ public class StudioApplicationConfiguration {
@Bean(destroyMethod = "close")
DefaultProjectSessionFactory projectSessionFactory(ProjectLocalStudioStateStore stateStore,
ProjectLocalStudioSetupStore setupStore, LspLifecyclePort lsp,
p.studio.core.project.ProjectAccessRegistry access, OperationExecutor operations) {
return new DefaultProjectSessionFactory(stateStore, setupStore, lsp, access, operations);
p.studio.core.project.ProjectAccessRegistry access, OperationExecutor operations,
p.studio.api.automation.AutomationConnectionLifecycle connections,
p.studio.api.automation.AgentIntegrationPreparation preparation) {
return new DefaultProjectSessionFactory(stateStore, setupStore, lsp, access, operations, connections, preparation);
}
@Bean
ProjectCatalog projectCatalog(ObjectMapper mapper, ProjectLocalStudioSetupStore setupStore) {
return new ProjectCatalogService(resolveDefaultProjectsRoot(), mapper, setupStore);
ProjectCatalog projectCatalog(ObjectMapper mapper, ProjectLocalStudioSetupStore setupStore,
p.studio.api.automation.AgentIntegrationPreparation preparation) {
return new ProjectCatalogService(resolveDefaultProjectsRoot(), mapper, setupStore, preparation);
}
@Bean
@@ -340,10 +343,19 @@ public class StudioApplicationConfiguration {
return new p.studio.app.mcp.LocalMcpServer(mapper, tools);
}
@Bean
p.studio.api.automation.AutomationConnectionLifecycle connectionLifecycle(p.studio.app.mcp.LocalMcpServer server, ObjectMapper mapper) {
return new p.studio.app.mcp.ProjectConnectionPublisher(server, mapper);
}
@Bean
p.studio.api.automation.AgentIntegrationPreparation agentPreparation(ObjectMapper mapper) {
return new p.studio.app.mcp.StudioAgentPreparation(p.studio.app.install.ManagedStudioInstallation.defaultRoot(), mapper);
}
@Bean
p.studio.api.automation.AgentConnectionGuide connectionGuide(p.studio.app.mcp.LocalMcpServer server,
p.studio.core.project.ProjectAccessRegistry projects, ObjectMapper mapper) {
return new p.studio.app.mcp.McpConnectionGuide(server, projects, mapper);
p.studio.core.project.ProjectAccessRegistry projects, ObjectMapper mapper,
p.studio.api.automation.AgentIntegrationPreparation preparation) {
return new p.studio.app.mcp.McpConnectionGuide(server, projects, mapper, preparation);
}
private static Path resolveDefaultProjectsRoot() {
@@ -7,6 +7,11 @@ public final class StudioLauncher {
}
public static void main(String[] args) {
if (args.length > 0 && "mcp".equals(args[0])) {
try { p.studio.app.mcp.stdio.StudioMcpStdio.main(args); }
catch (Exception failure) { System.err.println("Studio MCP could not start. Check --project, the manifest and installation."); System.exit(1); }
return;
}
Application.launch(App.class, args);
}
}
@@ -0,0 +1,55 @@
package p.studio.app.install;
import java.io.IOException;
import java.nio.file.*;
import java.util.*;
import java.util.concurrent.TimeUnit;
/** One versioned application installation; client entries always refer to current. */
public final class ManagedStudioInstallation {
public static final class MissingInstallation extends IOException {
public MissingInstallation() {
super("Studio installation is missing. In the Studio checkout, run ./gradlew :prometeu-app:stageStudioInstallation, then prepare the assistant again. If using an isolated installation, set -Dstudio.installationRoot to that installation in the desktop VM options.");
}
}
private ManagedStudioInstallation() { }
public static Path defaultRoot() {
return Path.of(System.getProperty("studio.installationRoot", Path.of(System.getProperty("user.home"),
"Library", "Application Support", "Prometeu", "Studio").toString())).toAbsolutePath();
}
public static void ensureAvailable(Path base) throws Exception {
if (Files.isExecutable(base.resolve("current/runtime/bin/java")) && Files.isDirectory(base.resolve("current/lib"))) return;
Path location = Path.of(ManagedStudioInstallation.class.getProtectionDomain().getCodeSource().getLocation().toURI());
if (!Files.isRegularFile(location) || !Files.isDirectory(location.getParent().getParent().resolve("runtime")))
throw new MissingInstallation();
install(location.getParent().getParent(), base);
}
public static synchronized Path install(Path source, Path base) throws Exception {
source = source.toRealPath(); Files.createDirectories(base.resolve("versions"));
Path version = base.resolve("versions").resolve(UUID.randomUUID().toString());
Files.createDirectory(version);
for (String part : List.of("lib", "runtime")) {
if (!Files.isDirectory(source.resolve(part))) throw new IOException("Incomplete Studio distribution");
try (var paths = Files.walk(source.resolve(part))) {
for (Path from : paths.toList()) {
Path to = version.resolve(source.relativize(from));
if (Files.isDirectory(from)) Files.createDirectories(to);
else Files.copy(from, to, StandardCopyOption.COPY_ATTRIBUTES);
}
}
}
var process = new ProcessBuilder(version.resolve("runtime/bin/java").toString(), "-cp", version.resolve("lib/*").toString(),
"p.studio.app.install.StudioInstallationProbe").redirectError(ProcessBuilder.Redirect.DISCARD).redirectOutput(ProcessBuilder.Redirect.DISCARD).start();
if (!process.waitFor(30, TimeUnit.SECONDS)) { process.destroyForcibly(); throw new IOException("Installation validation timed out"); }
if (process.exitValue() != 0) throw new IOException("Installation validation failed");
Path link = base.resolve(".current-" + UUID.randomUUID());
try { Files.createSymbolicLink(link, base.toAbsolutePath().relativize(version.toAbsolutePath()));
Files.move(link, base.resolve("current"), StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING);
} finally { Files.deleteIfExists(link); }
return version;
}
public static void main(String[] args) throws Exception {
if (args.length != 2) throw new IllegalArgumentException("distribution and installation root required");
install(Path.of(args[0]), Path.of(args[1]));
}
}
@@ -0,0 +1,12 @@
package p.studio.app.install;
/** Packaging health check; it never starts the GUI or opens projects. */
public final class StudioInstallationProbe {
public static void main(String[] args) throws Exception {
var catalog = new p.studio.app.mcp.McpToolCatalog(new com.fasterxml.jackson.databind.ObjectMapper());
if (catalog.names().isEmpty()) throw new IllegalStateException("Missing catalog");
for (String type : java.util.List.of("javafx.application.Application", "javafx.fxml.FXMLLoader",
"p.studio.app.App", "java.net.http.HttpClient", "com.sun.net.httpserver.HttpServer", "org.tomlj.Toml"))
Class.forName(type, false, StudioInstallationProbe.class.getClassLoader());
}
}
@@ -10,6 +10,8 @@ import p.studio.api.automation.*;
import p.studio.api.project.ProjectCatalog;
import p.studio.core.language.LanguageQueryPort;
import p.studio.lsp.api.LspServerLifecycle;
import p.studio.lsp.services.protocol.ExternalSourceLanguageServer;
import org.eclipse.lsp4j.jsonrpc.Launcher;
import java.net.*;
import java.nio.file.*;
@@ -24,7 +26,7 @@ public final class AutomationLspQueries implements LanguageQueryPort {
private final ObjectMapper mapper;
private final com.google.gson.Gson gson = new MessageJsonHandler(Map.of()).getGson();
private final Map<TaskIdentity, Map<String, CallHierarchyItem>> items = new ConcurrentHashMap<>();
private static final Set<String> OPERATIONS = Set.of("diagnostics", "completion", "hover", "signatureHelp", "definition",
private static final Set<String> OPERATIONS = Set.of("readExternalSource", "diagnostics", "completion", "hover", "signatureHelp", "definition",
"references", "documentSymbols", "workspaceSymbols", "prepareRename", "rename", "codeActions", "formatting",
"documentLinks", "foldingRanges", "selectionRanges", "prepareCallHierarchy", "incomingCalls", "outgoingCalls", "semanticTokens");
private static final Set<String> EDITS = Set.of("completion", "prepareRename", "rename", "codeActions", "formatting");
@@ -33,7 +35,47 @@ public final class AutomationLspQueries implements LanguageQueryPort {
this.lifecycle = lifecycle; this.projects = projects; this.knowledge = knowledge; this.mapper = mapper;
}
@Override public void endTask(TaskIdentity task) { items.remove(task); }
private record ExternalTask(String consumer, p.studio.lsp.messages.LspServerEndpoint endpoint,
p.studio.lsp.messages.LspProjectContext binding, Set<String> uris) {}
private final Map<TaskIdentity, ExternalTask> externalTasks = new ConcurrentHashMap<>();
@Override public void endTask(TaskIdentity task) {
items.remove(task);
final var state = externalTasks.remove(task);
if (state == null) return;
final var workers = Executors.newCachedThreadPool();
try (var socket = new Socket()) {
socket.connect(new InetSocketAddress(state.endpoint().host(), state.endpoint().port()), 2000);
final var client = new QuietClient();
final var launcher = new Launcher.Builder<ExternalSourceLanguageServer>().setLocalService(client)
.setRemoteInterface(ExternalSourceLanguageServer.class).setInput(socket.getInputStream())
.setOutput(socket.getOutputStream()).setExecutorService(workers).create();
final var listening = launcher.startListening();
try {
final var server = launcher.getRemoteProxy();
final var init = new InitializeParams();
init.setRootUri(state.binding().projectRoot().toUri().toString());
init.setCapabilities(new ClientCapabilities());
init.getCapabilities().setExperimental(Map.of("prometeuExternalSources", true));
init.setInitializationOptions(Map.of("prometeuExternalConsumerId", state.consumer()));
server.initialize(init).get(2, TimeUnit.SECONDS);
server.releaseExternalSource(new ExternalSourceLanguageServer.Request(state.consumer(), null)).get(2, TimeUnit.SECONDS);
} finally { listening.cancel(true); }
} catch (Exception failure) {
// A closed project host has already released its registry. Other cleanup
// failures are surfaced instead of silently reporting a successful task end.
if (lifecycle.endpoint(state.binding()).isPresent())
throw new IllegalStateException("Could not release task external sources", failure);
} finally { workers.shutdownNow(); }
}
private static class QuietClient implements LanguageClient {
public void telemetryEvent(Object event) {}
public void publishDiagnostics(PublishDiagnosticsParams event) {}
public void showMessage(MessageParams message) {}
public CompletableFuture<MessageActionItem> showMessageRequest(ShowMessageRequestParams request) { return CompletableFuture.completedFuture(null); }
public void logMessage(MessageParams message) {}
}
@Override public Map<String, Object> query(TaskIdentity task, String operation, Map<String, Object> parameters) throws Exception {
if (!OPERATIONS.contains(operation)) throw failure(AutomationFailure.Code.UNSUPPORTED_CAPABILITY, "Unsupported language operation: " + operation);
@@ -55,7 +97,15 @@ public final class AutomationLspQueries implements LanguageQueryPort {
uri = params.path("uri").asText(null);
if (uri == null) throw new IllegalArgumentException("uri is required");
}
Path document = uri == null ? null : sourcePath(context, uri);
final boolean external = uri != null && uri.startsWith("prometeu-source:");
if (external) {
final var state = externalTasks.get(task);
if (state == null || !state.uris().contains(uri)) throw failure(AutomationFailure.Code.OUTSIDE_PROJECT_SCOPE, "Unknown task-owned external source");
if (EDITS.contains(operation)) throw failure(AutomationFailure.Code.READ_ONLY_SCOPE, "External sources are read-only");
if (!Set.of("readExternalSource", "hover", "definition").contains(operation))
throw failure(AutomationFailure.Code.UNSUPPORTED_CAPABILITY, "Operation is unavailable for external documents");
} else if (operation.equals("readExternalSource")) throw new IllegalArgumentException("An external source URI is required");
Path document = uri == null || external ? null : sourcePath(context, uri);
if (document != null && EDITS.contains(operation)) requireEditable(context, document.toUri().toString());
String source = null;
if (document != null) {
@@ -83,14 +133,28 @@ public final class AutomationLspQueries implements LanguageQueryPort {
return CompletableFuture.completedFuture(new ApplyWorkspaceEditResponse(false));
}
};
var launcher = LSPLauncher.createClientLauncher(client, socket.getInputStream(), socket.getOutputStream(), workers, consumer -> consumer);
var launcher = new Launcher.Builder<ExternalSourceLanguageServer>().setLocalService(client)
.setRemoteInterface(ExternalSourceLanguageServer.class).setInput(socket.getInputStream())
.setOutput(socket.getOutputStream()).setExecutorService(workers).create();
var listening = launcher.startListening();
final var server = launcher.getRemoteProxy();
final var acquired = new HashSet<String>();
boolean succeeded = false;
try {
var server = launcher.getRemoteProxy();
var initialize = new InitializeParams();
initialize.setRootUri(binding.projectRoot().toUri().toString());
initialize.setCapabilities(new ClientCapabilities());
initialize.getCapabilities().setExperimental(Map.of("prometeuExternalSources", true));
final var previous = externalTasks.get(task);
initialize.setInitializationOptions(previous == null
? Map.of("prometeuExternalPersistentConsumer", true)
: Map.of("prometeuExternalConsumerId", previous.consumer(), "prometeuExternalPersistentConsumer", true));
var capabilities = await(server.initialize(initialize), deadline).getCapabilities();
final var experimental = gson.toJsonTree(capabilities.getExperimental());
if (experimental.isJsonObject() && experimental.getAsJsonObject().has("prometeuExternalConsumerId")) {
final String consumer = experimental.getAsJsonObject().get("prometeuExternalConsumerId").getAsString();
externalTasks.putIfAbsent(task, new ExternalTask(consumer, endpoint, binding, ConcurrentHashMap.newKeySet()));
}
server.initialized(new InitializedParams());
requireCapability(operation, capabilities);
List<Diagnostic> currentDiagnostics = List.of();
@@ -99,9 +163,17 @@ public final class AutomationLspQueries implements LanguageQueryPort {
server.getTextDocumentService().didOpen(new DidOpenTextDocumentParams(new TextDocumentItem(uri, primary.id(), 1, source)));
currentDiagnostics = await(diagnostics, deadline);
}
if (external) {
final var request = new ExternalSourceLanguageServer.Request(externalTasks.get(task).consumer(), uri);
source = await(server.revalidateExternalSource(request), deadline).text();
if (source.getBytes(java.nio.charset.StandardCharsets.UTF_8).length > 4 * 1024 * 1024)
throw failure(AutomationFailure.Code.LIMIT_EXCEEDED, "External source exceeds 4 MiB");
}
var text = server.getTextDocumentService();
var id = uri == null ? null : new TextDocumentIdentifier(uri);
Object result = switch (operation) {
case "readExternalSource" -> await(server.readExternalSource(
new ExternalSourceLanguageServer.Request(externalTasks.get(task).consumer(), uri)), deadline);
case "diagnostics" -> currentDiagnostics;
case "hover" -> await(text.hover(new HoverParams(id, position(params.path("position"), source))), deadline);
case "completion" -> await(text.completion(new CompletionParams(id, position(params.path("position"), source))), deadline);
@@ -136,6 +208,17 @@ public final class AutomationLspQueries implements LanguageQueryPort {
};
var wire = mapper.readTree(gson.toJson(result));
validateEdits(context, wire);
if (operation.equals("definition") && externalTasks.containsKey(task)) {
final var returned = new HashSet<String>();
rememberExternalUris(returned, wire);
acquired.addAll(returned);
acquired.removeAll(externalTasks.get(task).uris());
for (String externalUri : returned) {
await(server.retainExternalSource(new ExternalSourceLanguageServer.Request(
externalTasks.get(task).consumer(), externalUri)), deadline);
externalTasks.get(task).uris().add(externalUri);
}
}
var limitations = new ArrayList<String>();
if (operation.equals("codeActions") && wire.isArray()) {
for (var action : wire) if (action.has("command")) {
@@ -147,11 +230,30 @@ public final class AutomationLspQueries implements LanguageQueryPort {
var output = new LinkedHashMap<String, Object>();
output.put("operation", operation); output.put("result", mapper.convertValue(wire, Object.class));
output.put("limitations", limitations);
succeeded = true;
return Collections.unmodifiableMap(output);
} finally { listening.cancel(true); }
} finally {
if (!succeeded && !acquired.isEmpty() && externalTasks.containsKey(task)) {
final var state = externalTasks.get(task);
final boolean interrupted = Thread.interrupted();
try {
for (String acquiredUri : acquired) {
state.uris().remove(acquiredUri);
server.releaseExternalSource(new ExternalSourceLanguageServer.Request(state.consumer(), acquiredUri))
.get(500, TimeUnit.MILLISECONDS);
}
} finally { if (interrupted) Thread.currentThread().interrupt(); }
}
listening.cancel(true);
}
} finally { workers.shutdownNow(); }
}
private void rememberExternalUris(Set<String> uris, com.fasterxml.jackson.databind.JsonNode node) {
if (node.isObject() && node.path("uri").asText().startsWith("prometeu-source:")) uris.add(node.path("uri").asText());
if (node.isContainerNode()) node.forEach(child -> rememberExternalUris(uris, child));
}
private void addItemIds(TaskIdentity task, com.fasterxml.jackson.databind.JsonNode node) {
if (node.isObject() && node.has("uri") && node.has("selectionRange") && node.has("name") && node.has("kind")) {
var stored = items.computeIfAbsent(task, ignored -> new ConcurrentHashMap<>());
@@ -163,6 +265,12 @@ public final class AutomationLspQueries implements LanguageQueryPort {
}
private static void requireCapability(String operation, ServerCapabilities caps) {
if (operation.equals("readExternalSource")) {
final var raw = new com.google.gson.Gson().toJsonTree(caps.getExperimental());
if (!raw.isJsonObject() || !raw.getAsJsonObject().has("prometeuExternalSources"))
throw failure(AutomationFailure.Code.UNSUPPORTED_CAPABILITY, "LSP does not advertise external sources");
return;
}
Object capability = switch (operation) {
case "diagnostics" -> caps.getTextDocumentSync();
case "hover" -> caps.getHoverProvider(); case "completion" -> caps.getCompletionProvider();
@@ -233,6 +341,7 @@ public final class AutomationLspQueries implements LanguageQueryPort {
catch (ExecutionException failure) {
if (failure.getCause() instanceof org.eclipse.lsp4j.jsonrpc.ResponseErrorException response) {
int code = response.getResponseError().getCode();
if (code == -32010) throw failure(AutomationFailure.Code.READ_ONLY_SCOPE, response.getResponseError().getMessage());
if (code == -32602) throw new IllegalArgumentException("LSP rejected query parameters");
if (code == -32601 || code == -32600)
throw failure(AutomationFailure.Code.UNSUPPORTED_CAPABILITY, response.getResponseError().getMessage());
@@ -20,7 +20,22 @@ public final class LocalMcpServer implements AutoCloseable {
private static final int MAX_CONNECTION_SESSIONS = 128;
private final ObjectMapper mapper;
private final McpToolRegistry tools;
private final Map<String, AtomicBoolean> sessions = new ConcurrentHashMap<>();
private record Session(ProjectCredentials.Credential credential, AtomicBoolean initialized, java.util.concurrent.atomic.AtomicLong lastSeen) { }
private final Map<String, Session> sessions = new ConcurrentHashMap<>();
private final ProjectCredentials credentials = new ProjectCredentials();
private volatile String instanceId;
public ProjectCredentials credentials() { return credentials; }
public String instanceId() { return instanceId; }
public synchronized void activateCredential(String instance, ProjectCredentials.Credential credential) {
if (server == null || !Objects.equals(instanceId, instance)) throw new IllegalStateException("Studio instance changed");
credential.activate();
}
public String catalogFingerprint() { return tools.catalogFingerprint(); }
public boolean connected(java.nio.file.Path root) {
long now = System.nanoTime();
return sessions.values().stream().anyMatch(s -> s.initialized.get() && s.credential.active() && s.credential.root().equals(root)
&& now - s.lastSeen.get() < TimeUnit.SECONDS.toNanos(10));
}
private final SecureRandom random = new SecureRandom();
private HttpServer server;
private ExecutorService executor;
@@ -42,7 +57,8 @@ public final class LocalMcpServer implements AutoCloseable {
this.tools = Objects.requireNonNull(tools);
}
public synchronized void start() throws IOException {
public void start() throws IOException {
synchronized (this) {
if (server != null) return;
// No configurable bind address: remote and wildcard exposure cannot be enabled accidentally.
var next = HttpServer.create(new InetSocketAddress(InetAddress.getByName("127.0.0.1"), 0), 32);
@@ -50,17 +66,20 @@ public final class LocalMcpServer implements AutoCloseable {
Thread.ofPlatform().daemon().name("studio-mcp-", 1).factory(), new ThreadPoolExecutor.AbortPolicy());
var timers = Executors.newSingleThreadScheduledExecutor(Thread.ofPlatform().daemon().name("studio-mcp-deadlines").factory());
try {
connection = new Connection(URI.create("http://127.0.0.1:" + next.getAddress().getPort() + "/mcp"), secret());
instanceId = UUID.randomUUID().toString();
connection = new Connection(URI.create("http://127.0.0.1:" + next.getAddress().getPort() + "/mcp"));
deadlines = timers;
next.createContext("/mcp", this::handle);
next.setExecutor(workers);
next.start();
timers.scheduleWithFixedDelay(() -> connectionListeners.forEach(LocalMcpServer::notifyConnectionListener), 2, 2, TimeUnit.SECONDS);
executor = workers; server = next;
connectionListeners.forEach(LocalMcpServer::notifyConnectionListener);
} catch (RuntimeException failure) {
next.stop(0); workers.shutdownNow(); timers.shutdownNow(); connection = null;
throw failure;
}
}
connectionListeners.forEach(LocalMcpServer::notifyConnectionListener);
}
public Connection connection() {
var current = connection;
@@ -68,20 +87,20 @@ public final class LocalMcpServer implements AutoCloseable {
return current;
}
public synchronized boolean isRunning() { return server != null; }
@Override public synchronized void close() {
@Override public void close() {
synchronized (this) {
if (server == null) return;
connection = null; server.stop(0); server = null;
sessions.clear(); executor.shutdownNow(); deadlines.shutdownNow();
sessions.clear(); credentials.clear(); executor.shutdownNow(); deadlines.shutdownNow();
}
connectionListeners.forEach(LocalMcpServer::notifyConnectionListener);
}
/** Only explicit connection/configuration consumers may obtain the bearer token; never log it. */
/** Public endpoint metadata contains no credential. */
public static final class Connection {
private final URI endpoint;
private final String token;
private Connection(URI endpoint, String token) { this.endpoint = endpoint; this.token = token; }
private Connection(URI endpoint) { this.endpoint = endpoint; }
public URI endpoint() { return endpoint; }
public String authorizationHeader() { return "Bearer " + token; }
@Override public String toString() { return "LocalMcpConnection[endpoint=" + endpoint + ", credentials=REDACTED]"; }
}
@@ -101,13 +120,17 @@ public final class LocalMcpServer implements AutoCloseable {
|| !authority.equals(single(headers, "Host"))
|| origin != null && !("http://" + authority).equals(origin)) { empty(exchange, 403); return; }
String authorization = single(headers, "Authorization");
if (authorization == null || !MessageDigest.isEqual(current.authorizationHeader().getBytes(StandardCharsets.UTF_8), authorization.getBytes(StandardCharsets.UTF_8))) {
var credential = credentials.authenticate(authorization);
if (credential == null) {
empty(exchange, 401); return;
}
String version = single(headers, "MCP-Protocol-Version");
if (version != null && !PROTOCOL_VERSION.equals(version)) { empty(exchange, 400); return; }
String sessionId = single(headers, "Mcp-Session-Id");
AtomicBoolean initialized = sessionId == null ? null : sessions.get(sessionId);
var session = sessionId == null ? null : sessions.get(sessionId);
if (session != null && session.credential != credential) { empty(exchange, 403); return; }
AtomicBoolean initialized = session == null ? null : session.initialized;
if (session != null) session.lastSeen.set(System.nanoTime());
if (sessionId != null && initialized == null) { empty(exchange, 404); return; }
String method = exchange.getRequestMethod();
if (method.equals("GET")) { exchange.getResponseHeaders().set("Allow", "POST, DELETE"); empty(exchange, 405); return; }
@@ -148,14 +171,16 @@ public final class LocalMcpServer implements AutoCloseable {
send(exchange, 400, error(id.isMissingNode() ? NullNode.instance : id, -32602, "Invalid initialization")); return;
}
synchronized (sessions) {
sessions.values().removeIf(s -> !s.credential.active());
if (sessions.size() >= MAX_CONNECTION_SESSIONS) { empty(exchange, 503); return; }
sessionId = secret(); sessions.put(sessionId, new AtomicBoolean());
sessionId = secret(); sessions.put(sessionId, new Session(credential, new AtomicBoolean(), new java.util.concurrent.atomic.AtomicLong(System.nanoTime())));
}
exchange.getResponseHeaders().set("Mcp-Session-Id", sessionId);
var result = mapper.createObjectNode().put("protocolVersion", PROTOCOL_VERSION);
result.putObject("capabilities").putObject("tools").put("listChanged", false);
result.putObject("serverInfo").put("name", "prometeu-studio-mcp").put("version", "1.0");
result.put("instructions", McpConnectionGuide.INSTRUCTIONS);
result.putObject("_meta").put("instanceId", instanceId).put("projectRoot", credential.root().toString()).put("catalogFingerprint", tools.catalogFingerprint());
send(exchange, 200, response(id, result)); return;
}
if (initialized == null) { empty(exchange, 400); return; }
@@ -174,7 +199,18 @@ public final class LocalMcpServer implements AutoCloseable {
}
case "tools/call" -> {
if (!params.path("name").isTextual()) throw new IllegalArgumentException("Missing tool name");
yield tools.call(params.get("name").asText(), params.get("arguments")).wire();
var arguments = params.get("arguments");
if (arguments == null || !arguments.path("projectRoot").isTextual()) throw new IllegalArgumentException("Missing root");
java.nio.file.Path requested;
try { requested = java.nio.file.Path.of(arguments.path("projectRoot").asText());
if (!requested.isAbsolute()) throw new IllegalArgumentException("Relative root");
requested = requested.toRealPath();
} catch (java.io.IOException | RuntimeException invalid) { throw new IllegalArgumentException("Invalid root"); }
if (!credential.active() || !credential.root().equals(requested)) {
yield McpToolResult.failure(mapper, new p.studio.api.automation.AutomationFailure(
p.studio.api.automation.AutomationFailure.Code.OUTSIDE_PROJECT_SCOPE, "Connection is bound to another project or no longer authorized")).wire();
}
yield tools.call(params.get("name").asText(), arguments).wire();
}
default -> null;
};
@@ -7,12 +7,11 @@ import p.studio.core.project.ProjectAccessRegistry;
import java.nio.file.Path;
import java.util.Optional;
/** Builds a provider-neutral connection descriptor from the live server, only on explicit export. */
/** Projects connection liveness and permanent setup independently of task authority. */
public final class McpConnectionGuide implements AgentConnectionGuide {
public static final String INSTRUCTIONS = """
Configure your external coding client's MCP connection using the url and Authorization header below.
This is a provider-neutral descriptor, not a provider-specific configuration file.
Keep the token private; do not commit this descriptor, write it into project files or include it in logs.
Use the Studio tools for this project. Wait for the developer to grant access in DEV, then acquire control.
The installed Studio connector discovers the connection automatically; do not write transport scripts or copy tokens.
Connect and list available tools. Read studio_project_context for the explicit projectRoot and consult
studio_reference_read for the declared languages, SDK and libraries before editing as needed.
Do not assume PBS or another language when support/documentation is missing; report the limitation.
@@ -26,25 +25,42 @@ public final class McpConnectionGuide implements AgentConnectionGuide {
Observe headless images/state when those tools are available, and explicitly studio_control_release
when finished. On revocation stop external edits too: Studio cannot stop your native file writes.
Existing edits are preserved. Git/review/recovery remain the developer's responsibility.
Recopy and update your client's connection after Studio restart: endpoint and token are ephemeral.
After Studio restart, wait for a fresh human grant. The connector reconnects automatically; old task identities are invalid.
""";
private final LocalMcpServer server;
private final ProjectAccessRegistry projects;
private final ObjectMapper mapper;
private final p.studio.api.automation.AgentIntegrationPreparation preparation;
public McpConnectionGuide(LocalMcpServer server, ProjectAccessRegistry projects, ObjectMapper mapper) {
this.server = server; this.projects = projects; this.mapper = mapper;
this(server, projects, mapper, new StudioAgentPreparation(p.studio.app.install.ManagedStudioInstallation.defaultRoot(), mapper));
}
public McpConnectionGuide(LocalMcpServer server, ProjectAccessRegistry projects, ObjectMapper mapper,
p.studio.api.automation.AgentIntegrationPreparation preparation) {
this.server = server; this.projects = projects; this.mapper = mapper; this.preparation = preparation;
}
@Override public boolean supportsPreparation() { return true; }
@Override public Optional<String> endpoint() {
try { return Optional.of(server.connection().endpoint().toString()); }
catch (IllegalStateException unavailable) { return Optional.empty(); }
}
@Override public String configuration(Path root) {
Path canonical = projects.requireOpenRoot(root);
var live = server.connection();
var value = mapper.createObjectNode().put("transport", "streamable-http").put("url", live.endpoint().toString());
value.putObject("headers").put("Authorization", live.authorizationHeader());
value.put("projectRoot", canonical.toString()).put("instructions", INSTRUCTIONS);
return value.toPrettyString();
return "Run the installed Studio in mcp --project mode for " + canonical + "\n" + INSTRUCTIONS;
}
@Override public p.studio.api.automation.AgentIntegrationPreparation.Result prepare(Path root) {
return preparation.prepare(projects.requireOpenRoot(root));
}
@Override public p.studio.api.automation.AgentIntegrationPreparation.Result preparationStatus(Path root) {
return preparation.status(projects.requireOpenRoot(root));
}
@Override public State state(Path root) {
try {
Path canonical = projects.requireOpenRoot(root);
if (!server.isRunning()) return State.UNAVAILABLE;
if (server.connected(canonical)) return State.CONNECTED;
var control = projects.requireAutomation(canonical).snapshot().state();
return control == p.studio.api.automation.ControlState.AGENT_WORKING ? State.RECONNECTING : State.WAITING_FOR_ACCESS;
} catch (RuntimeException unavailable) { return State.UNAVAILABLE; }
}
@Override public OperationSubscription subscribe(Runnable changed) { return server.onConnectionChanged(changed); }
}
@@ -21,6 +21,14 @@ public final class McpToolCatalog {
} catch (IOException failure) { throw new IllegalStateException("Cannot read packaged MCP contract", failure); }
}
public Set<String> names() { return definitions.keySet(); }
public String fingerprint() {
try {
var digest = java.security.MessageDigest.getInstance("SHA-256");
digest.update(LocalMcpServer.PROTOCOL_VERSION.getBytes(java.nio.charset.StandardCharsets.UTF_8));
definitions.keySet().stream().sorted().forEach(name -> digest.update(descriptor(name).toString().getBytes(java.nio.charset.StandardCharsets.UTF_8)));
return java.util.HexFormat.of().formatHex(digest.digest());
} catch (java.security.NoSuchAlgorithmException impossible) { throw new IllegalStateException(impossible); }
}
public JsonNode definition(String name) {
var definition = definitions.get(name);
if (definition == null) throw new IllegalArgumentException("Unknown tool");
@@ -22,6 +22,7 @@ public final class McpToolRegistry {
catalog.names().stream().filter(handlers::containsKey).forEach(name -> descriptors.add(catalog.descriptor(name)));
return descriptors;
}
public String catalogFingerprint() { return catalog.fingerprint(); }
public McpToolResult call(String name, JsonNode arguments) {
var handler = handlers.get(name);
if (handler == null) throw new IllegalArgumentException("Unknown or unavailable tool");
@@ -0,0 +1,79 @@
package p.studio.app.mcp;
import com.fasterxml.jackson.databind.*;
import java.io.IOException;
import java.net.URI;
import java.nio.file.*;
import java.nio.file.attribute.PosixFilePermissions;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import static java.nio.file.LinkOption.NOFOLLOW_LINKS;
/** Local discovery data is untrusted until paths, permissions and live identity are verified. */
public final class ProjectConnectionFiles {
public static final String RELATIVE = ".studio/mcp/connection.json";
private static final Set<java.nio.file.attribute.PosixFilePermission> FILE_MODE = PosixFilePermissions.fromString("rw-------");
private ProjectConnectionFiles() { }
public static Path directory(Path root) throws IOException {
Path studio = root.resolve(".studio"), directory = studio.resolve("mcp");
safeDirectory(studio, false); safeDirectory(directory, true); return directory;
}
private static void safeDirectory(Path path, boolean privateDirectory) throws IOException {
if (!Files.exists(path, NOFOLLOW_LINKS)) Files.createDirectory(path, PosixFilePermissions.asFileAttribute(PosixFilePermissions.fromString("rwx------")));
if (Files.isSymbolicLink(path) || !Files.isDirectory(path, NOFOLLOW_LINKS)) throw new IOException("Unsafe connection directory");
if (privateDirectory) requirePrivate(path, true);
}
public static void requirePrivate(Path path, boolean directory) throws IOException {
if (Files.isSymbolicLink(path) || !(directory ? Files.isDirectory(path, NOFOLLOW_LINKS) : Files.isRegularFile(path, NOFOLLOW_LINKS)))
throw new IOException("Unsafe connection file");
var expected = directory ? PosixFilePermissions.fromString("rwx------") : FILE_MODE;
if (!Files.getPosixFilePermissions(path, NOFOLLOW_LINKS).equals(expected)
|| !Files.getOwner(path, NOFOLLOW_LINKS).equals(Files.getOwner(Path.of(System.getProperty("user.home")))))
throw new IOException("Connection permissions must be restricted to the current user");
}
public static void atomicPrivateWrite(Path target, byte[] bytes) throws IOException {
if (Files.exists(target, NOFOLLOW_LINKS)) requirePrivate(target, false);
var temp = Files.createTempFile(target.getParent(), ".connection-", ".tmp", PosixFilePermissions.asFileAttribute(FILE_MODE));
try { Files.write(temp, bytes); Files.move(temp, target, StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING); }
finally { Files.deleteIfExists(temp); }
}
public static boolean tracked(Path root, String relative) throws IOException {
try {
var process = new ProcessBuilder("git", "-C", root.toString(), "ls-files", "-z", "--", relative).redirectError(ProcessBuilder.Redirect.DISCARD).start();
if (!process.waitFor(5, TimeUnit.SECONDS)) { process.destroyForcibly(); throw new IOException("Git check timed out"); }
if (process.exitValue() != 0 && process.exitValue() != 128) throw new IOException("Cannot verify file tracking");
return process.getInputStream().read() != -1;
} catch (InterruptedException interrupted) { Thread.currentThread().interrupt(); throw new IOException("Git check interrupted"); }
}
public static void ignore(Path root, String relative) throws IOException {
Path path = root.resolve(".gitignore");
if (Files.isSymbolicLink(path)) throw new IOException("Unsafe ignore file");
String old = Files.exists(path) ? Files.readString(path) : "";
String rule = "/" + relative;
if (old.lines().anyMatch(rule::equals)) return;
Files.writeString(path, old + (old.isEmpty() || old.endsWith("\n") ? "" : "\n") + rule + "\n");
}
public static Descriptor read(Path root, ObjectMapper mapper) throws IOException {
Path path = root.resolve(RELATIVE);
if (Files.isSymbolicLink(root.resolve(".studio"))) throw new IOException("Unsafe discovery path");
requirePrivate(path.getParent(), true); requirePrivate(path, false);
byte[] bytes;
try (var input = Files.newInputStream(path, NOFOLLOW_LINKS)) { bytes = input.readNBytes(16 * 1024 + 1); }
if (bytes.length > 16 * 1024) throw new IOException("Connection descriptor too large");
var json = mapper.readTree(bytes);
if (json == null || !json.path("schemaVersion").isIntegralNumber() || !json.path("schemaVersion").canConvertToInt() || json.path("schemaVersion").asInt(-1) != 1) throw new IOException("Unsupported connection schema");
for (String field : Set.of("instanceId", "projectRoot", "endpoint", "credential", "catalogFingerprint"))
if (!json.path(field).isTextual() || json.path(field).asText().isBlank()) throw new IOException("Invalid connection descriptor");
try {
if (!Path.of(json.path("projectRoot").asText()).equals(root)) throw new IOException("Connection project mismatch");
URI endpoint = URI.create(json.path("endpoint").asText());
if (!"http".equals(endpoint.getScheme()) || !"127.0.0.1".equals(endpoint.getHost()) || endpoint.getPort() < 1
|| endpoint.getPort() > 65535 || !"/mcp".equals(endpoint.getRawPath()) || endpoint.getRawQuery() != null
|| endpoint.getRawFragment() != null || endpoint.getUserInfo() != null) throw new IOException("Invalid loopback endpoint");
return new Descriptor(endpoint, json.path("instanceId").asText(), json.path("credential").asText(), json.path("catalogFingerprint").asText());
} catch (IllegalArgumentException invalid) { throw new IOException("Invalid connection descriptor"); }
}
public record Descriptor(URI endpoint, String instanceId, String credential, String catalogFingerprint) {
@Override public String toString() { return "ProjectConnectionDescriptor[REDACTED]"; }
}
}
@@ -0,0 +1,52 @@
package p.studio.app.mcp;
import com.fasterxml.jackson.databind.ObjectMapper;
import p.studio.api.automation.AutomationConnectionLifecycle;
import java.nio.channels.*;
import java.nio.file.*;
import java.nio.file.attribute.PosixFilePermissions;
import java.util.Set;
/** The lock inode outlives a publication. Its OS lock, not a stale PID/file, establishes ownership. */
public final class ProjectConnectionPublisher implements AutomationConnectionLifecycle {
private final LocalMcpServer server;
private final ObjectMapper mapper;
public ProjectConnectionPublisher(LocalMcpServer server, ObjectMapper mapper) { this.server = server; this.mapper = mapper; }
@Override public Publication prepare(Path projectRoot) throws Exception {
Path root = projectRoot.toRealPath();
final String instance = server.instanceId();
final var endpoint = server.connection().endpoint();
if (ProjectConnectionFiles.tracked(root, ProjectConnectionFiles.RELATIVE)) throw new IllegalStateException("Connection file is tracked");
ProjectConnectionFiles.ignore(root, ".studio/mcp/");
Path directory = ProjectConnectionFiles.directory(root), lockPath = directory.resolve("publication.lock");
if (Files.exists(lockPath, LinkOption.NOFOLLOW_LINKS)) ProjectConnectionFiles.requirePrivate(lockPath, false);
var channel = FileChannel.open(lockPath, Set.of(StandardOpenOption.CREATE, StandardOpenOption.WRITE, LinkOption.NOFOLLOW_LINKS),
PosixFilePermissions.asFileAttribute(PosixFilePermissions.fromString("rw-------")));
FileLock lock;
try { lock = channel.tryLock(); if (lock == null) throw new AutomationConnectionLifecycle.OwnershipConflict(); }
catch (OverlappingFileLockException conflict) { channel.close(); throw new AutomationConnectionLifecycle.OwnershipConflict(); }
catch (Exception conflict) { channel.close(); throw conflict; }
var credential = server.credentials().prepare(root);
return new Publication() {
private boolean published, closed;
public void publish() throws Exception {
var value = mapper.createObjectNode().put("schemaVersion", 1).put("instanceId", instance)
.put("projectRoot", root.toString()).put("endpoint", endpoint.toString())
.put("credential", credential.secret()).put("catalogFingerprint", server.catalogFingerprint());
ProjectConnectionFiles.atomicPrivateWrite(directory.resolve("connection.json"), mapper.writeValueAsBytes(value)); published = true;
}
public void activate() { server.activateCredential(instance, credential); }
public void invalidate() { credential.invalidate(); }
public synchronized void close() throws Exception {
if (closed) return; closed = true; invalidate();
try {
if (published && Files.exists(directory.resolve("connection.json"), LinkOption.NOFOLLOW_LINKS)) {
var current = ProjectConnectionFiles.read(root, mapper);
if (instance.equals(current.instanceId()) && credential.secret().equals(current.credential()))
Files.delete(directory.resolve("connection.json"));
}
} finally { try { lock.release(); } finally { channel.close(); } }
}
};
}
}
@@ -0,0 +1,42 @@
package p.studio.app.mcp;
import java.nio.file.Path;
import java.security.MessageDigest;
import java.security.SecureRandom;
import java.nio.charset.StandardCharsets;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
/** Memory-only authentication; never a substitute for the Core grant/task checks. */
public final class ProjectCredentials {
private final Map<String, Credential> credentials = new ConcurrentHashMap<>();
public Credential prepare(Path root) {
byte[] bytes = new byte[32]; new SecureRandom().nextBytes(bytes);
var credential = new Credential(root, Base64.getUrlEncoder().withoutPadding().encodeToString(bytes));
credentials.put(credential.secret, credential); return credential;
}
public Credential authenticate(String header) {
if (header == null || !header.startsWith("Bearer ")) return null;
String token = header.substring(7);
var found = credentials.get(token);
return found != null && found.active && MessageDigest.isEqual(token.getBytes(StandardCharsets.UTF_8),
found.secret.getBytes(StandardCharsets.UTF_8)) ? found : null;
}
public void clear() { credentials.values().forEach(Credential::invalidate); credentials.clear(); }
public final class Credential {
private final Path root;
private final String secret;
private volatile boolean active;
private boolean invalidated;
private Credential(Path root, String secret) { this.root = root; this.secret = secret; }
public Path root() { return root; }
public String secret() { return secret; }
public synchronized void activate() {
if (invalidated) throw new IllegalStateException("Credential invalidated");
active = true;
}
public synchronized void invalidate() { active = false; invalidated = true; credentials.remove(secret, this); }
public boolean active() { return active; }
@Override public String toString() { return "ProjectCredential[REDACTED]"; }
}
}
@@ -0,0 +1,124 @@
package p.studio.app.mcp;
import com.fasterxml.jackson.databind.ObjectMapper;
import p.studio.api.automation.AgentIntegrationPreparation;
import p.studio.app.install.ManagedStudioInstallation;
import java.nio.file.*;
import java.nio.file.attribute.PosixFilePermissions;
import java.nio.charset.StandardCharsets;
import java.util.*;
import org.tomlj.Toml;
/** Only the managed entry is edited; unrelated client configuration remains byte-for-byte intact. */
public final class StudioAgentPreparation implements AgentIntegrationPreparation {
private final Path installation;
private final ObjectMapper mapper;
private final Map<Path, Result> preparationFailures = new java.util.concurrent.ConcurrentHashMap<>();
private static final String BEGIN = "# Studio managed MCP entry ";
private static final String END = "# End Studio managed MCP entry\n";
public StudioAgentPreparation(Path installation, ObjectMapper mapper) { this.installation = installation; this.mapper = mapper; }
@Override public synchronized Result prepare(Path projectRoot) {
var result = prepareLocal(projectRoot);
Path key = preparationKey(projectRoot);
if (result.ready()) preparationFailures.remove(key); else preparationFailures.put(key, result);
return result;
}
private Result prepareLocal(Path projectRoot) {
try {
Path root = projectRoot.toRealPath();
if (!Files.isRegularFile(root.resolve("prometeu.json"))) return new Result(false, "Project manifest not found.");
if (ProjectConnectionFiles.tracked(root, ".codex/config.toml"))
return new Result(false, "Client configuration is tracked. Keep machine-specific registration local before preparing this project.");
Path directory = root.resolve(".codex"), config = directory.resolve("config.toml");
if (Files.isSymbolicLink(directory) || Files.isSymbolicLink(config)) return new Result(false, "Client configuration path is unsafe.");
String old = Files.exists(config) ? Files.readString(config) : "";
String next = merge(old, entry(root));
ManagedStudioInstallation.ensureAvailable(installation);
Files.createDirectories(directory);
ProjectConnectionFiles.ignore(root, ".codex/config.toml");
ProjectConnectionFiles.ignore(root, ".studio/mcp/");
if (!old.equals(next)) {
int previous = old.indexOf(BEGIN);
if (previous >= 0) {
ProjectConnectionFiles.ignore(root, ".codex/.studio-mcp.previous.toml");
String owned = old.substring(previous, old.indexOf(END, previous) + END.length());
ProjectConnectionFiles.atomicPrivateWrite(directory.resolve(".studio-mcp.previous.toml"), owned.getBytes(StandardCharsets.UTF_8));
}
Path temporary = Files.createTempFile(directory, ".studio-config-", ".tmp", PosixFilePermissions.asFileAttribute(PosixFilePermissions.fromString("rw-------")));
try { Files.writeString(temporary, next); Files.move(temporary, config, StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING); }
finally { Files.deleteIfExists(temporary); }
}
Path studio = root.resolve(".studio");
if (Files.isSymbolicLink(studio)) throw new IllegalStateException("Unsafe setup directory");
Files.createDirectories(studio);
Path setup = studio.resolve("setup.json");
if (Files.isSymbolicLink(setup)) throw new IllegalStateException("Unsafe setup file");
var value = Files.exists(setup) ? mapper.readTree(Files.readAllBytes(setup)) : mapper.createObjectNode();
if (!(value instanceof com.fasterxml.jackson.databind.node.ObjectNode object)) throw new IllegalStateException("Invalid setup");
object.putObject("agentIntegration").put("schemaVersion", 1).put("enabled", true).put("clientProfile", "codex");
String setupText = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(object);
if (!Files.exists(setup) || !Files.readString(setup).equals(setupText)) {
Path temporary = Files.createTempFile(studio, ".setup-", ".tmp");
try { Files.writeString(temporary, setupText); Files.move(temporary, setup, StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING); }
finally { Files.deleteIfExists(temporary); }
}
return new Result(true, "Assistant prepared. Trust this project in your client and reload MCP once if requested. Then grant access in DEV; no token copying or restart reconfiguration is needed.");
} catch (ManagedStudioInstallation.MissingInstallation missing) { return new Result(false, missing.getMessage()); }
catch (Conflict conflict) { return new Result(false, conflict.getMessage()); }
catch (Exception failure) { return new Result(false, "Preparation incomplete. Check the Studio installation and project/configuration permissions; existing client settings were not deliberately replaced."); }
}
@Override public Result status(Path projectRoot) {
var failure = preparationFailures.get(preparationKey(projectRoot));
if (failure != null) return failure;
try {
Path root = projectRoot.toRealPath(), config = root.resolve(".codex/config.toml");
if (Files.isSymbolicLink(config.getParent()) || Files.isSymbolicLink(config))
return new Result(false, "Unsafe client configuration path. Prepare the assistant after resolving it.");
if (!Files.isRegularFile(config)) return new Result(false, "Assistant setup is incomplete. Prepare the assistant for this project.");
String old = Files.readString(config);
if (!old.equals(merge(old, entry(root))) || !Files.isExecutable(installation.resolve("current/runtime/bin/java")))
return new Result(false, "Assistant setup is incomplete. Prepare the assistant from an installed Studio.");
return new Result(true, "Assistant prepared. Trust this project in your client and reload MCP once if requested.");
} catch (Conflict conflict) { return new Result(false, conflict.getMessage()); }
catch (Exception unavailable) { return new Result(false, "Assistant setup could not be verified. Prepare the assistant again."); }
}
private static Path preparationKey(Path root) {
try { return root.toRealPath(); }
catch (java.io.IOException missing) { return root.toAbsolutePath().normalize(); }
}
public String entry(Path root) throws Exception {
Path current = installation.resolve("current").toAbsolutePath();
return "[mcp_servers.prometeu_studio]\ncommand = " + quote(current.resolve("runtime/bin/java").toString())
+ "\nargs = " + mapper.writeValueAsString(List.of("-cp", current.resolve("lib/*").toString(), "p.studio.app.StudioLauncher", "mcp", "--project", root.toString()))
+ "\ncwd = " + quote(root.toString()) + "\nstartup_timeout_sec = 20\ntool_timeout_sec = 90\n";
}
private String quote(String text) throws Exception { return mapper.writeValueAsString(text); }
static String merge(String old, String entry) throws Exception {
if (Toml.parse(old).hasErrors()) throw new Conflict("Existing client TOML is invalid; repair it before preparation.");
String block = BEGIN + hash(entry) + "\n" + entry + END;
int start = old.indexOf(BEGIN), end = old.indexOf(END);
String next;
if (start >= 0) {
int body = old.indexOf('\n', start) + 1;
if (start > 0 && old.charAt(start - 1) != '\n' || body == 0 || end < body || old.indexOf(BEGIN, body) >= 0 || !old.substring(start + BEGIN.length(), body - 1).equals(hash(old.substring(body, end))))
throw new Conflict("The Studio MCP entry was edited. Resolve the managed-entry conflict explicitly.");
next = old.substring(0, start) + block + old.substring(end + END.length());
} else {
if (end >= 0 || Toml.parse(old).contains("mcp_servers.prometeu_studio")) throw new Conflict("A user-owned Studio MCP entry already exists; resolve it explicitly.");
next = old + (old.isEmpty() || old.endsWith("\n") ? "" : "\n") + block;
}
if (Toml.parse(next).hasErrors()) throw new Conflict("Client configuration conflicts with the Studio entry; nothing was overwritten.");
var actual = Toml.parse(next).getTable("mcp_servers.prometeu_studio");
var expected = Toml.parse(entry).getTable("mcp_servers.prometeu_studio");
if (actual == null || expected == null || !actual.keySet().equals(expected.keySet())
|| !Objects.equals(actual.getString("command"), expected.getString("command"))
|| !Objects.equals(actual.getString("cwd"), expected.getString("cwd"))
|| !Objects.equals(actual.getLong("startup_timeout_sec"), expected.getLong("startup_timeout_sec"))
|| !Objects.equals(actual.getLong("tool_timeout_sec"), expected.getLong("tool_timeout_sec"))
|| actual.getArray("args") == null || !actual.getArray("args").toList().equals(expected.getArray("args").toList()))
throw new Conflict("The managed Studio table conflicts with other client settings; resolve it explicitly.");
return next;
}
private static String hash(String text) throws Exception { return HexFormat.of().formatHex(java.security.MessageDigest.getInstance("SHA-256").digest(text.getBytes(StandardCharsets.UTF_8))); }
private static final class Conflict extends Exception { Conflict(String text) { super(text); } }
}
@@ -0,0 +1,170 @@
package p.studio.app.mcp.stdio;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.node.ObjectNode;
import p.studio.app.mcp.*;
import java.io.*;
import java.net.http.*;
import java.nio.file.*;
import java.time.Duration;
import java.util.*;
/** Owns only HTTP transport. Never retries a tools/call or creates task authority. */
final class StudioMcpConnection implements AutoCloseable {
private final Path root;
private final ObjectMapper mapper;
private final McpToolCatalog catalog;
private final HttpClient client = HttpClient.newBuilder().connectTimeout(Duration.ofSeconds(2)).followRedirects(HttpClient.Redirect.NEVER).build();
private ProjectConnectionFiles.Descriptor descriptor;
private String session;
private Set<String> available = Set.of();
// Diagnostic correlation only: Core remains the sole validator of task authority.
private final LinkedHashMap<String, String> observedTaskInstances = new LinkedHashMap<>();
private long sequence;
private volatile String status = "WAITING_FOR_ACCESS";
StudioMcpConnection(Path root, ObjectMapper mapper, McpToolCatalog catalog) { this.root = root; this.mapper = mapper; this.catalog = catalog; }
String status() { return status; }
synchronized void probe() {
try { connect(); exchange("ping", mapper.createObjectNode(), true, 3); status = "CONNECTED"; }
catch (Exception failure) { disconnect(); }
}
synchronized JsonNode call(String tool, JsonNode arguments) {
boolean dispatched = false;
try {
catalog.validateArguments(tool, arguments);
try {
if (!Path.of(arguments.path("projectRoot").asText()).toRealPath().equals(root))
return failure("OUTSIDE_PROJECT_SCOPE", "The connector is bound to another project.");
} catch (IOException inaccessible) { return failure("INVALID_REQUEST", "Project root cannot be resolved."); }
connect();
String taskInstance = observedTaskInstances.get(arguments.path("taskId").asText());
if (tool.equals("studio_operation_get") && taskInstance != null && !taskInstance.equals(descriptor.instanceId()))
return failure("OUTCOME_UNKNOWN", "Studio restarted; this task's in-memory receipts are unavailable. Obtain a fresh grant/task and decide the next intent explicitly; do not replay the old operation.");
if (!available.contains(tool)) return failure("UNSUPPORTED_CAPABILITY", "The live Studio does not provide this tool.");
var params = mapper.createObjectNode().put("name", tool).set("arguments", arguments);
dispatched = true;
var response = exchange("tools/call", params, true, 70);
if (response.has("error")) throw new ProtocolFailure(response.get("error"));
status = "CONNECTED";
var result = response.required("result");
if (tool.equals("studio_control_acquire") && !result.path("isError").asBoolean()) {
String task = result.path("structuredContent").path("value").path("taskId").asText();
if (!task.isBlank()) {
observedTaskInstances.put(task, descriptor.instanceId());
if (observedTaskInstances.size() > 64) observedTaskInstances.remove(observedTaskInstances.keySet().iterator().next());
}
}
return result;
} catch (ProtocolFailure protocol) { throw protocol;
} catch (IllegalArgumentException invalid) {
return failure("INVALID_REQUEST", "Invalid tool arguments or project root.");
} catch (Exception unavailable) {
disconnect();
var result = failure(dispatched ? "OUTCOME_UNKNOWN" : status,
dispatched ? "Response unavailable; do not replay. For the same authorized task, look up operationId/clientRequestId. After Studio restart, obtain a new grant; old receipts may be unavailable."
: guidance());
if (dispatched && arguments != null && arguments.path("clientRequestId").isTextual())
((ObjectNode) result.path("structuredContent").path("error")).put("clientRequestId", arguments.path("clientRequestId").asText());
((ObjectNode) result.path("content").get(0)).put("text", result.path("structuredContent").toString());
return result;
}
}
private String guidance() {
return switch (status) {
case "VERSION_INCOMPATIBLE" -> "Studio and its installed connector are incompatible; update the installation.";
case "STALE_CONNECTION" -> "Connection credentials are stale or invalid; grant access again in DEV.";
case "INVALID_DESCRIPTOR" -> "Project connection data or permissions are invalid; prepare the project again.";
default -> "Open Studio and this project, then grant access in DEV. The connection will be discovered without restarting this client.";
};
}
private void connect() throws Exception {
ProjectConnectionFiles.Descriptor next;
try { next = ProjectConnectionFiles.read(root, mapper); }
catch (NoSuchFileException absent) { status = "WAITING_FOR_ACCESS"; throw absent; }
catch (IOException invalid) {
status = Files.exists(root.resolve(ProjectConnectionFiles.RELATIVE)) ? "INVALID_DESCRIPTOR" : "WAITING_FOR_ACCESS";
throw invalid;
}
if (!catalog.fingerprint().equals(next.catalogFingerprint())) { status = "VERSION_INCOMPATIBLE"; throw new IOException("Incompatible catalog"); }
if (session != null && next.equals(descriptor)) return;
descriptor = next; session = null; status = "RECONNECTING";
var params = mapper.createObjectNode().put("protocolVersion", LocalMcpServer.PROTOCOL_VERSION);
params.putObject("capabilities"); params.putObject("clientInfo").put("name", "studio-project-connector").put("version", "1");
var result = exchange("initialize", params, true, 5).required("result");
if (!LocalMcpServer.PROTOCOL_VERSION.equals(result.path("protocolVersion").asText())
|| !catalog.fingerprint().equals(result.path("_meta").path("catalogFingerprint").asText())) {
status = "VERSION_INCOMPATIBLE"; throw new IOException("Incompatible protocol");
}
if (!next.instanceId().equals(result.path("_meta").path("instanceId").asText())
|| !root.toString().equals(result.path("_meta").path("projectRoot").asText())) {
status = "STALE_CONNECTION"; throw new IOException("Wrong instance");
}
exchange("notifications/initialized", mapper.createObjectNode(), false, 5);
var descriptors = exchange("tools/list", mapper.createObjectNode(), true, 5).path("result").path("tools");
if (!descriptors.isArray()) throw new IOException("Invalid catalog");
var names = new HashSet<String>();
for (var tool : descriptors) {
String name = tool.path("name").asText();
if (!catalog.names().contains(name) || !catalog.descriptor(name).equals(tool) || !names.add(name)) {
status = "VERSION_INCOMPATIBLE"; throw new IOException("Incompatible tools");
}
}
available = Set.copyOf(names); status = "CONNECTED";
}
private JsonNode exchange(String method, JsonNode params, boolean responseExpected, int seconds) throws Exception {
var message = mapper.createObjectNode().put("jsonrpc", "2.0").put("method", method);
if (responseExpected) message.put("id", ++sequence);
message.set("params", params);
var request = HttpRequest.newBuilder(descriptor.endpoint()).timeout(Duration.ofSeconds(seconds))
.header("Authorization", "Bearer " + descriptor.credential()).header("Content-Type", "application/json")
.header("Accept", "application/json, text/event-stream").header("MCP-Protocol-Version", LocalMcpServer.PROTOCOL_VERSION);
if (session != null) request.header("Mcp-Session-Id", session);
var pending = client.sendAsync(request.POST(HttpRequest.BodyPublishers.ofString(message.toString())).build(),
info -> boundedBody());
HttpResponse<byte[]> response;
try { response = pending.get(seconds, java.util.concurrent.TimeUnit.SECONDS); }
catch (Exception failure) { pending.cancel(true); throw failure; }
if (response.statusCode() != 200 && response.statusCode() != 202) {
if (response.statusCode() == 401 || response.statusCode() == 403 || response.statusCode() == 404) status = "STALE_CONNECTION";
throw new IOException("Connection rejected");
}
response.headers().firstValue("Mcp-Session-Id").ifPresent(value -> session = value);
if (method.equals("initialize") && session == null) throw new IOException("Missing session identity");
if (!responseExpected) return mapper.nullNode();
var json = mapper.readTree(response.body());
if (json == null || !"2.0".equals(json.path("jsonrpc").asText()) || !json.path("id").isIntegralNumber() || !message.get("id").bigIntegerValue().equals(json.path("id").bigIntegerValue())
|| json.has("result") == json.has("error")) throw new IOException("Invalid response");
return json;
}
private static HttpResponse.BodySubscriber<byte[]> boundedBody() {
return new HttpResponse.BodySubscriber<>() {
final HttpResponse.BodySubscriber<byte[]> delegate = HttpResponse.BodySubscribers.ofByteArray();
java.util.concurrent.Flow.Subscription subscription;
long bytes;
public java.util.concurrent.CompletionStage<byte[]> getBody() { return delegate.getBody(); }
public void onSubscribe(java.util.concurrent.Flow.Subscription value) { subscription = value; delegate.onSubscribe(value); }
public void onNext(List<java.nio.ByteBuffer> buffers) {
for (var buffer : buffers) bytes += buffer.remaining();
if (bytes > 32L * 1024 * 1024) { subscription.cancel(); delegate.onError(new IOException("Response too large")); }
else delegate.onNext(buffers);
}
public void onError(Throwable failure) { delegate.onError(failure); }
public void onComplete() { delegate.onComplete(); }
};
}
private ObjectNode failure(String code, String message) {
var value = mapper.createObjectNode().put("isError", true);
var data = value.putObject("structuredContent").put("status", "error");
data.putObject("error").put("code", code).put("message", message);
value.putArray("content").addObject().put("type", "text").put("text", data.toString());
return value;
}
static final class ProtocolFailure extends RuntimeException {
final JsonNode error;
ProtocolFailure(JsonNode error) { super("Studio protocol error"); this.error = error.deepCopy(); }
}
private void disconnect() { if (status.equals("CONNECTED")) status = "RECONNECTING"; session = null; available = Set.of(); }
@Override public void close() { client.shutdownNow(); }
}
@@ -0,0 +1,83 @@
package p.studio.app.mcp.stdio;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.*;
import p.studio.app.mcp.*;
import java.io.*;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import java.util.concurrent.*;
/** A mode of Studio itself; no JavaFX, Spring, HTTP listener or agent runtime is started here. */
public final class StudioMcpStdio {
private StudioMcpStdio() { }
public static void main(String[] args) throws Exception {
if (args.length != 3 || !"mcp".equals(args[0]) || !"--project".equals(args[1]) || !Path.of(args[2]).isAbsolute())
throw new IllegalArgumentException("Usage: mcp --project <absolute-project-root>");
Path root = Path.of(args[2]).toRealPath();
if (!Files.isRegularFile(root.resolve("prometeu.json"))) throw new IllegalArgumentException("Project manifest not found");
run(root, System.in, System.out);
}
public static void run(Path root, InputStream input, OutputStream output) throws Exception {
var mapper = new ObjectMapper().enable(JsonParser.Feature.STRICT_DUPLICATE_DETECTION).enable(DeserializationFeature.FAIL_ON_TRAILING_TOKENS);
mapper.getFactory().setStreamReadConstraints(com.fasterxml.jackson.core.StreamReadConstraints.builder().maxStringLength(32 * 1024 * 1024).build());
var catalog = new McpToolCatalog(mapper);
var timer = Executors.newSingleThreadScheduledExecutor(Thread.ofPlatform().daemon().name("studio-mcp-discovery").factory());
try (var connection = new StudioMcpConnection(root, mapper, catalog)) {
timer.scheduleWithFixedDelay(connection::probe, 0, 2, TimeUnit.SECONDS);
boolean initialized = false, negotiated = false;
var line = new ByteArrayOutputStream(); int next;
while ((next = input.read()) != -1) {
if (next != '\n') {
if (line.size() >= 1024 * 1024) throw new IOException("MCP request exceeds limit");
line.write(next); continue;
}
JsonNode message;
try { message = mapper.readTree(StandardCharsets.UTF_8.newDecoder().decode(java.nio.ByteBuffer.wrap(line.toByteArray())).toString()); }
catch (Exception malformed) { line.reset(); write(output, error(mapper, mapper.nullNode(), -32700, "Invalid JSON")); continue; }
line.reset();
if (message == null || !message.isObject() || !message.path("jsonrpc").isTextual() || !"2.0".equals(message.path("jsonrpc").asText())
|| !message.path("method").isTextual() || message.has("id") && !(message.path("id").isTextual() || message.path("id").isIntegralNumber())) {
write(output, error(mapper, mapper.nullNode(), -32600, "Invalid request")); continue;
}
String method = message.path("method").asText();
if (!message.has("id")) { if (negotiated && "notifications/initialized".equals(method)) initialized = true; continue; }
var id = message.get("id"); JsonNode result;
if (method.equals("initialize") && !negotiated) {
var params = message.path("params");
if (!params.path("protocolVersion").isTextual() || !params.path("capabilities").isObject() || !params.path("clientInfo").isObject()) {
write(output, error(mapper, id, -32602, "Invalid initialization")); continue;
}
var value = mapper.createObjectNode().put("protocolVersion", LocalMcpServer.PROTOCOL_VERSION);
value.putObject("capabilities").putObject("tools").put("listChanged", false);
value.putObject("serverInfo").put("name", "prometeu-studio").put("version", "1");
value.put("instructions", McpConnectionGuide.INSTRUCTIONS + "\nProject root: " + root);
result = value; negotiated = true;
} else if (!initialized) { write(output, error(mapper, id, -32600, "Initialization required")); continue; }
else if (method.equals("ping")) result = mapper.createObjectNode();
else if (method.equals("tools/list")) {
var value = mapper.createObjectNode(); var tools = value.putArray("tools");
catalog.names().forEach(name -> tools.add(catalog.descriptor(name))); result = value;
} else if (method.equals("tools/call")) {
String tool = message.path("params").path("name").asText();
var arguments = message.path("params").path("arguments");
try { catalog.validateArguments(tool, arguments); }
catch (IllegalArgumentException invalid) { write(output, error(mapper, id, -32602, "Invalid tool arguments")); continue; }
try { result = connection.call(tool, arguments); }
catch (StudioMcpConnection.ProtocolFailure protocol) {
var reply = mapper.createObjectNode().put("jsonrpc", "2.0"); reply.set("id", id); reply.set("error", protocol.error);
write(output, reply); continue;
}
} else { write(output, error(mapper, id, -32601, "Method not found")); continue; }
var reply = mapper.createObjectNode().put("jsonrpc", "2.0"); reply.set("id", id); reply.set("result", result); write(output, reply);
}
} finally { timer.shutdownNow(); }
}
private static JsonNode error(ObjectMapper mapper, JsonNode id, int code, String text) {
var reply = mapper.createObjectNode().put("jsonrpc", "2.0"); reply.set("id", id);
reply.putObject("error").put("code", code).put("message", text); return reply;
}
private static void write(OutputStream output, JsonNode value) throws IOException {
output.write(value.toString().getBytes(StandardCharsets.UTF_8)); output.write('\n'); output.flush();
}
}
@@ -367,7 +367,7 @@
{
"name": "studio_language_query",
"authority": "task",
"description": "Query supported project LSP capabilities after synchronizing saved files. Returns refactoring proposals, never applies edits.",
"description": "Query project LSP capabilities using saved project files or task-owned read-only external sources. readExternalSource reads an external URI returned by definition; hover and definition can continue inside it. Returns refactoring proposals, never applies edits.",
"inputSchema": {
"type": "object",
"properties": {
@@ -40,6 +40,12 @@ class DevDesktopTest {
completed.get(10, TimeUnit.SECONDS);
}
static void awaitWaiting(AutomationSession authority) throws Exception {
long deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(5);
while (authority.snapshot().state() != ControlState.WAITING_FOR_AGENT && System.nanoTime() < deadline) Thread.sleep(5);
assertEquals(ControlState.WAITING_FOR_AGENT, authority.snapshot().state());
}
@Test void devDebugNavigationBackgroundProjectionAndDisposal() throws Exception {
var pool = Executors.newSingleThreadExecutor();
var authority = new DefaultAutomationSession(root, new ExecutorOperationExecutor(pool));
@@ -70,6 +76,9 @@ class DevDesktopTest {
assertEquals(1, subscriptions.get());
assertTrue(((Button) dev[0].rootNode().lookup("#dev-mcp-config")).isDisabled());
((Button) dev[0].rootNode().lookup("#dev-grant")).fire();
});
awaitWaiting(authority);
fx(() -> {
assertEquals(ControlState.WAITING_FOR_AGENT, authority.snapshot().state());
host[0].change(WorkspaceId.DEBUG); assertEquals(0, subscriptions.get());
assertEquals(ControlState.WAITING_FOR_AGENT, authority.snapshot().state());
@@ -96,8 +105,8 @@ class DevDesktopTest {
locale.setLocale(java.util.Locale.forLanguageTag("pt-BR"));
host[0].deactivateCurrentWorkspace(); assertEquals(0, subscriptions.get());
authority.grant(false); locale.setLocale(java.util.Locale.ENGLISH);
assertEquals(ControlState.WAITING_FOR_AGENT, authority.snapshot().state());
});
awaitWaiting(authority);
} finally {
fx(() -> { if (host[0] != null) host[0].deactivateCurrentWorkspace(); if (stage[0] != null) stage[0].close(); });
authority.closeAsync().toCompletableFuture().get(5, TimeUnit.SECONDS); pool.shutdownNow();
@@ -120,56 +129,39 @@ class DevDesktopTest {
});
}
@Test void copiesLiveConnectionWithoutGrantOrCredentialDisplayAndRefreshesAvailability() throws Exception {
@Test void preparesConnectionWithoutGrantAndRemainsAvailableWhenTransportStops() throws Exception {
var mapper = new com.fasterxml.jackson.databind.ObjectMapper();
var projects = new p.studio.core.project.ProjectAccessRegistry();
var savedClipboard = new java.util.HashMap<javafx.scene.input.DataFormat, Object>();
var copied = new java.util.concurrent.atomic.AtomicReference<String>();
var prepared = new CompletableFuture<Void>();
var view = new DevWorkspace[1]; var stage = new Stage[1];
try (var pool = Executors.newSingleThreadExecutor();
var server = new p.studio.app.mcp.LocalMcpServer(mapper, new p.studio.app.mcp.McpToolRegistry(
new p.studio.app.mcp.McpToolCatalog(mapper), mapper, java.util.Map.of()))) {
var authority = new DefaultAutomationSession(root, new ExecutorOperationExecutor(pool));
var registration = projects.register(root, authority::enterManual, () -> !authority.snapshot().closed(), authority);
var guide = new p.studio.app.mcp.McpConnectionGuide(server, projects, mapper);
var guide = new p.studio.app.mcp.McpConnectionGuide(server, projects, mapper, project -> {
prepared.complete(null);
return new p.studio.api.automation.AgentIntegrationPreparation.Result(true, "Prepared; trust/reload once.");
});
server.start();
try {
fx(() -> {
var clipboard = javafx.scene.input.Clipboard.getSystemClipboard();
clipboard.getContentTypes().forEach(type -> savedClipboard.put(type, clipboard.getContent(type)));
var project = new ProjectReference("Connection smoke", "1", "pbs", 1, ProjectTarget.Game, root);
view[0] = new DevWorkspace(project, authority, new I18nService(), new StudioEventBus(), guide);
stage[0] = new Stage(); stage[0].setScene(new Scene(new VBox(view[0].rootNode()), 1050, 800)); stage[0].show();
view[0].load();
var button = (Button) view[0].rootNode().lookup("#dev-mcp-config"); assertFalse(button.isDisabled());
button.fire(); copied.set(clipboard.getString());
assertEquals(ControlState.MANUAL, authority.snapshot().state());
assertEquals(server.connection().endpoint().toString(), ((Label) view[0].rootNode().lookup("#dev-mcp-endpoint")).getText());
assertTrue(view[0].rootNode().lookupAll(".label").stream().filter(n -> n instanceof Label)
.noneMatch(n -> ((Label) n).getText().contains(server.connection().authorizationHeader())));
var button = (Button) view[0].rootNode().lookup("#dev-mcp-config"); assertFalse(button.isDisabled()); button.fire();
});
var first = mapper.readTree(copied.get());
assertTrue(server.connection().authorizationHeader().equals(first.path("headers").path("Authorization").asText()));
assertEquals(root.toRealPath().toString(), first.path("projectRoot").asText());
prepared.get(5, TimeUnit.SECONDS);
assertEquals(ControlState.MANUAL, authority.snapshot().state());
server.close();
fx(() -> assertTrue(((Button) view[0].rootNode().lookup("#dev-mcp-config")).isDisabled()));
fx(() -> assertFalse(((Button) view[0].rootNode().lookup("#dev-mcp-config")).isDisabled()));
server.start(); authority.grant(false).toCompletableFuture().join();
fx(() -> {
var button = (Button) view[0].rootNode().lookup("#dev-mcp-config"); assertFalse(button.isDisabled());
button.fire(); copied.set(javafx.scene.input.Clipboard.getSystemClipboard().getString());
assertEquals(ControlState.WAITING_FOR_AGENT, authority.snapshot().state());
});
var next = mapper.readTree(copied.get());
assertFalse(first.path("headers").equals(next.path("headers")));
assertTrue(server.connection().authorizationHeader().equals(next.path("headers").path("Authorization").asText()));
assertEquals(ControlState.WAITING_FOR_AGENT, authority.snapshot().state());
authority.closeAsync().toCompletableFuture().get(5, TimeUnit.SECONDS);
fx(() -> assertTrue(((Button) view[0].rootNode().lookup("#dev-mcp-config")).isDisabled()));
} finally {
fx(() -> {
if (view[0] != null) view[0].unLoad();
if (stage[0] != null) stage[0].close();
javafx.scene.input.Clipboard.getSystemClipboard().setContent(savedClipboard);
});
fx(() -> { if (view[0] != null) view[0].unLoad(); if (stage[0] != null) stage[0].close(); });
authority.closeAsync().toCompletableFuture().get(5, TimeUnit.SECONDS); registration.close();
}
}
@@ -52,6 +52,7 @@ public final class InstalledKnowledgeProbe {
BuilderPipelineContext.fromConfig(new BuilderPipelineConfig(false, root.toString())), LogAggregator.empty());
check(result.diagnostics().stream().noneMatch(issue -> issue.isError()), "Example must compile without errors");
check(result.bytecodeBytes().length > 0, "Example must produce bytecode");
verifyExternalSources(provider.getClass().getClassLoader());
registration.unsubscribe();
System.out.println("Installed knowledge verified: " + docs.size() + " references; example compiled");
}
@@ -59,4 +60,64 @@ public final class InstalledKnowledgeProbe {
private static void check(boolean condition, String message) {
if (!condition) throw new AssertionError(message);
}
private static void verifyExternalSources(ClassLoader loader) throws Exception {
var resource = loader.getResource("game/stdlib/1/sdk/gfx/main.pbs");
check(resource != null && resource.getProtocol().equals("jar"), "SDK must be read from a JAR URL");
check(p.studio.lsp.services.compiler.CompilerLanguageServiceBridge.class.getProtectionDomain()
.getCodeSource().getLocation().getPath().endsWith(".jar"), "LSP bridge must come from installed JAR");
Path root = Files.createDirectory(Path.of("external-sources")).toRealPath();
Files.createDirectories(root.resolve("src"));
Files.writeString(root.resolve("prometeu.json"), """
{"name":"app","version":"1.0.0","language":"pbs","stdlib":"1","target":"Game","dependencies":[]}
""");
String source = "import { Gfx } from @sdk:gfx;\nfn main() -> void { Gfx.clear(0); }\n";
Path file = Files.writeString(root.resolve("src/main.pbs"), source);
Files.writeString(root.resolve("src/mod.barrel"), "pub fn main() -> void;\n");
var context = new p.studio.lsp.messages.LspProjectContext("installed", "pbs", root);
var bridge = new p.studio.lsp.services.compiler.CompilerLanguageServiceBridge();
try (var registry = new p.studio.lsp.services.compiler.ExternalSourceRegistry()) {
String consumer = registry.connect(null, false);
int[] sdkUse = position(source, "Gfx.clear", "Gfx.".length());
var targets = bridge.navigation(context, file.toUri().toString(), source, sdkUse[0], sdkUse[1], registry, consumer).locations();
check(targets.size() == 1, "Packaged SDK definition must resolve");
String uri = targets.getFirst().uri();
check(uri.startsWith("prometeu-source:"), "SDK must use a virtual URI");
var content = registry.read(consumer, uri);
check(content.descriptor().readOnly() && content.descriptor().origin().equals("bundled"), "Bundled SDK must be read-only");
try (var stream = resource.openStream()) {
check(content.text().equals(new String(stream.readAllBytes(), java.nio.charset.StandardCharsets.UTF_8)), "SDK text must exactly match JAR bytes");
}
int[] hostUse = position(content.text(), "LowGfx.clear", "LowGfx.".length());
check(bridge.externalHover(context, uri, hostUse[0], hostUse[1], registry, consumer).markdown().contains("clear"), "SDK hover must work");
var host = bridge.navigation(context, uri, null, hostUse[0], hostUse[1], registry, consumer).locations().getFirst();
check(registry.read(consumer, host.uri()).text().split("\n")[host.startLine()].contains("clear"), "SDK to host definition range must match");
check(!bridge.externalSemanticTokens(context, uri, registry, consumer).tokens().isEmpty(), "SDK semantic highlighting must work");
int[] colorUse = position(content.text(), "color: Color", 7);
var core = bridge.navigation(context, uri, null, colorUse[0], colorUse[1], registry, consumer).locations().getFirst();
var coreContent = registry.read(consumer, core.uri());
check(coreContent.descriptor().readOnly() && coreContent.descriptor().name().replace('\\', '/').contains("core/color"), "SDK to core definition must resolve");
var coreResource = loader.getResource("game/stdlib/1/core/color/main.pbs");
check(coreResource != null && coreResource.getProtocol().equals("jar"), "Core must be read from a JAR URL");
try (var stream = coreResource.openStream()) {
check(coreContent.text().equals(new String(stream.readAllBytes(), java.nio.charset.StandardCharsets.UTF_8)), "Core text must exactly match JAR bytes");
}
check(coreContent.text().split("\n")[core.startLine()].contains("Color"), "Core definition range must match");
registry.disconnect(consumer);
registry.connect(consumer, false);
check(registry.revalidate(consumer, uri, path -> bridge.currentSource(context, path)).text().equals(content.text()), "Bundled source must revalidate after reconnect");
}
try (var files = Files.walk(root)) {
check(files.filter(Files::isRegularFile).map(root::relativize).map(Path::toString).collect(java.util.stream.Collectors.toSet())
.equals(java.util.Set.of("prometeu.json", "src/main.pbs", "src/mod.barrel")), "Navigation must not extract bundled sources into the project");
}
System.out.println("Packaged external sources verified: JAR bytes, SDK/host/core navigation, hover, tokens, read-only, reconnect, no extraction");
}
private static int[] position(String text, String needle, int offset) {
int index = text.indexOf(needle);
check(index >= 0, "Missing source fragment: " + needle);
String prefix = text.substring(0, index + offset);
return new int[] {(int) prefix.chars().filter(c -> c == '\n').count(), prefix.length() - prefix.lastIndexOf('\n') - 1};
}
}
@@ -20,7 +20,7 @@ class InstalledKnowledgeTest {
}
String probeClasses = Path.of(InstalledKnowledgeProbe.class.getProtectionDomain().getCodeSource().getLocation().toURI()).toString();
Path output = outsideRepository.resolve("probe.log");
var process = new ProcessBuilder(Path.of(System.getProperty("java.home"), "bin", "java").toString(),
var process = new ProcessBuilder(distribution.resolve("runtime/bin/java").toString(),
"-cp", jars + java.io.File.pathSeparator + probeClasses, InstalledKnowledgeProbe.class.getName())
.directory(outsideRepository.toFile()).redirectErrorStream(true).redirectOutput(output.toFile()).start();
try {
@@ -28,6 +28,7 @@ class InstalledKnowledgeTest {
String log = Files.readString(output);
assertEquals(0, process.exitValue(), log);
assertTrue(log.contains("references; example compiled"), log);
assertTrue(log.contains("Packaged external sources verified"), log);
} finally { if (process.isAlive()) process.destroyForcibly().waitFor(); }
}
}
@@ -0,0 +1,79 @@
package p.studio.app.install;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;
import p.studio.app.mcp.StudioAgentPreparation;
import p.studio.core.project.*;
import p.studio.api.project.*;
import java.nio.file.*;
import java.util.*;
import java.util.concurrent.TimeUnit;
import static org.junit.jupiter.api.Assertions.*;
class InstalledConnectorTest {
@TempDir Path temporary;
@Test void bundledJavaAndStableUpdateWorkWithSpacesMinimalEnvironmentAndBothPreparationPaths() throws Exception {
Path base = temporary.resolve("Application Support/Studio");
Path source = Path.of(System.getProperty("studio.test.distribution"));
Path first = ManagedStudioInstallation.install(source, base);
var mapper = new ObjectMapper();
var preparation = new StudioAgentPreparation(base, mapper);
var catalog = new ProjectCatalogService(temporary, mapper, new ProjectLocalStudioSetupStore(mapper), preparation);
var scaffold = catalog.createProject(new ProjectCreationRequest("Scaffold Game", temporary, "pbs", 1, ProjectTarget.Game, "src", 8, "/my/runtime"));
assertTrue(preparation.status(scaffold.rootPath()).ready());
Path existing = Files.createDirectory(temporary.resolve("Existing Project"));
Files.copy(scaffold.rootPath().resolve("prometeu.json"), existing.resolve("prometeu.json"));
Files.createDirectory(existing.resolve(".studio"));
Files.writeString(existing.resolve(".studio/setup.json"), "{\"runtimePath\":\"/preserved/runtime\",\"custom\":42}");
Files.createDirectory(existing.resolve(".codex"));
String custom = "# preserve\napproval_policy = \"on-request\"\n[mcp_servers.other]\ncommand = \"other\"\n";
Files.writeString(existing.resolve(".codex/config.toml"), custom);
assertTrue(preparation.prepare(existing).ready());
var config = existing.resolve(".codex/config.toml");
String stable = Files.readString(config); var modified = Files.getLastModifiedTime(config);
assertTrue(stable.startsWith(custom)); assertTrue(preparation.prepare(existing).ready());
assertEquals(stable, Files.readString(config)); assertEquals(modified, Files.getLastModifiedTime(config));
var setup = mapper.readTree(Files.readString(existing.resolve(".studio/setup.json")));
assertEquals(42, setup.path("custom").asInt()); assertEquals("/preserved/runtime", setup.path("runtimePath").asText());
assertFalse(Files.exists(existing.resolve(".studio/mcp/connection.json")));
runConnector(base, existing);
Path second = ManagedStudioInstallation.install(source, base);
assertNotEquals(first, second); assertTrue(Files.isDirectory(first));
assertEquals(second.toRealPath(), base.resolve("current").toRealPath());
assertEquals(stable, Files.readString(config)); runConnector(base, existing);
assertThrows(Exception.class, () -> ManagedStudioInstallation.install(existing, base));
assertEquals(second.toRealPath(), base.resolve("current").toRealPath()); runConnector(base, existing);
// Test fixture only: installed runtime/lib must load and start JavaFX, without checkout application classes.
String fixtures = Path.of(DesktopProbe.class.getProtectionDomain().getCodeSource().getLocation().toURI()).toString();
var desktop = minimal(base.resolve("current/runtime/bin/java").toString(), "-cp", base.resolve("current/lib/*") + java.io.File.pathSeparator + fixtures,
DesktopProbe.class.getName()).redirectError(temporary.resolve("desktop.stderr").toFile()).start();
try { assertTrue(desktop.waitFor(20, TimeUnit.SECONDS)); assertEquals(0, desktop.exitValue(), Files.readString(temporary.resolve("desktop.stderr"))); }
finally { desktop.destroyForcibly(); }
}
void runConnector(Path base, Path root) throws Exception {
var process = minimal(base.resolve("current/runtime/bin/java").toString(), "-cp", base.resolve("current/lib/*").toString(),
"p.studio.app.StudioLauncher", "mcp", "--project", root.toRealPath().toString()).start();
try {
String input = "{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"initialize\",\"params\":{\"protocolVersion\":\"2025-06-18\",\"capabilities\":{},\"clientInfo\":{\"name\":\"installed-test\",\"version\":\"1\"}}}\n";
process.getOutputStream().write(input.getBytes(java.nio.charset.StandardCharsets.UTF_8)); process.getOutputStream().close();
assertTrue(process.waitFor(15, TimeUnit.SECONDS)); assertEquals(0, process.exitValue());
assertEquals("prometeu-studio", new ObjectMapper().readTree(process.getInputStream()).path("result").path("serverInfo").path("name").asText());
} finally { process.destroyForcibly(); }
}
ProcessBuilder minimal(String... args) {
var builder = new ProcessBuilder(args).directory(temporary.toFile());
builder.environment().clear(); builder.environment().put("PATH", "/usr/bin:/bin"); builder.environment().put("HOME", System.getProperty("user.home"));
return builder;
}
public static class DesktopProbe {
public static void main(String[] args) {
javafx.application.Platform.startup(() -> {
try {
var stage = new javafx.stage.Stage(); stage.setScene(new javafx.scene.Scene(new javafx.scene.control.Label("Installed Studio JavaFX")));
stage.show(); stage.close(); System.exit(0);
} catch (Throwable failure) { System.exit(2); }
});
}
}
}
@@ -18,6 +18,7 @@ import java.util.concurrent.*;
import static org.junit.jupiter.api.Assertions.*;
class AutomationLspQueriesTest {
String httpAuthorization;
@TempDir Path temporary;
final ObjectMapper mapper = new ObjectMapper();
final ExecutorService workers = Executors.newCachedThreadPool();
@@ -53,6 +54,36 @@ class AutomationLspQueriesTest {
Map<String, Object> at(int line, int character) {
return Map.of("uri", source.toUri().toString(), "position", Map.of("line", line, "character", character));
}
@Test void bundledSourcesAreReadableAcrossConnectionsAndOwnedByTheTask() throws Exception {
Files.writeString(source, "import { Gfx } from @sdk:gfx;\nfn main() -> void { Gfx.clear(0); }\n");
Files.writeString(source.resolveSibling("mod.barrel"), "pub fn main() -> void;\n");
acquire();
final var definition = query("definition", at(1, 24)).path("result");
assertFalse(definition.isEmpty(), definition.toString());
final String uri = definition.get(0).path("uri").asText();
assertTrue(uri.startsWith("prometeu-source:"), uri);
final var content = query("readExternalSource", Map.of("uri", uri)).path("result");
assertTrue(content.path("descriptor").path("readOnly").asBoolean());
assertEquals("bundled", content.path("descriptor").path("origin").asText());
final String text = content.path("text").asText();
final int offset = text.indexOf("LowGfx.clear") + "LowGfx.".length();
assertTrue(offset > "LowGfx.".length());
final String prefix = text.substring(0, offset);
final var position = Map.of("line", (int) prefix.chars().filter(c -> c == '\n').count(),
"character", offset - prefix.lastIndexOf('\n') - 1);
final var request = Map.<String, Object>of("uri", uri, "position", position);
assertTrue(query("hover", request).path("result").toString().contains("clear"));
final var host = query("definition", request).path("result");
assertFalse(host.isEmpty());
assertTrue(query("readExternalSource", Map.of("uri", host.get(0).path("uri").asText()))
.path("result").path("text").asText().contains("declare host LowGfx"));
assertEquals(AutomationFailure.Code.READ_ONLY_SCOPE, assertThrows(AutomationException.class,
() -> query("formatting", request)).failure().code());
session.automation().reclaim().toCompletableFuture().join();
acquire();
assertEquals(AutomationFailure.Code.OUTSIDE_PROJECT_SCOPE, assertThrows(AutomationException.class,
() -> query("readExternalSource", Map.of("uri", uri))).failure().code());
}
@Test void diagnosticsAndNavigationSeeSavedChangesOverTheActualServer() throws Exception {
acquire();
assertTrue(query("diagnostics", at(0, 0)).path("result").isArray());
@@ -134,6 +165,8 @@ class AutomationLspQueriesTest {
try (var server = new p.studio.app.mcp.LocalMcpServer(mapper, tools);
var client = java.net.http.HttpClient.newHttpClient()) {
server.start();
var credential = server.credentials().prepare(root.toRealPath());
credential.activate(); httpAuthorization = "Bearer " + credential.secret();
var initialize = mapper.createObjectNode().put("jsonrpc", "2.0").put("id", 1).put("method", "initialize");
var setup = initialize.putObject("params").put("protocolVersion", "2025-06-18");
setup.putObject("capabilities"); setup.putObject("clientInfo").put("name", "language-test").put("version", "1");
@@ -155,7 +188,7 @@ class AutomationLspQueriesTest {
private java.net.http.HttpResponse<String> post(java.net.http.HttpClient client, p.studio.app.mcp.LocalMcpServer server,
String connection, JsonNode body) throws Exception {
var request = java.net.http.HttpRequest.newBuilder(server.connection().endpoint()).timeout(java.time.Duration.ofSeconds(15))
.header("Authorization", server.connection().authorizationHeader()).header("Content-Type", "application/json")
.header("Authorization", httpAuthorization).header("Content-Type", "application/json")
.header("Accept", "application/json, text/event-stream").header("MCP-Protocol-Version", "2025-06-18");
if (connection != null) request.header("Mcp-Session-Id", connection);
return client.send(request.POST(java.net.http.HttpRequest.BodyPublishers.ofString(body.toString())).build(), java.net.http.HttpResponse.BodyHandlers.ofString());
@@ -183,26 +216,43 @@ class AutomationLspQueriesTest {
assertTrue(cleaned.get());
assertEquals(ControlState.MANUAL, session.automation().snapshot().state());
}
@Test void externalDependencyNavigationIsReadableButRefactoringIsReadOnly() throws Exception {
Path lib = Files.createDirectories(temporary.resolve("lib")).toRealPath();
@org.junit.jupiter.params.ParameterizedTest
@org.junit.jupiter.params.provider.ValueSource(booleans = {false, true})
void externalDependencyNavigationIsReadableButRefactoringIsReadOnly(boolean inWorkspace) throws Exception {
Path lib = Files.createDirectories(inWorkspace ? root.resolve(".workspace/repos/lib") : temporary.resolve("lib")).toRealPath();
manifest(lib, "lib", List.of());
Path module = Files.createDirectories(lib.resolve("src/shared"));
Path declaration = module.resolve("main.pbs");
Files.writeString(declaration, "fn answer() -> int { return 42; }\n");
Files.writeString(declaration, "// á 😀\r\nfn answer() -> int { return helper(); }\r\nfn helper() -> int { return 42; }\r\n");
Files.writeString(module.resolve("mod.barrel"), "pub fn answer() -> int;\n");
manifest(root, "app", List.of(Map.of("path", "../lib")));
manifest(root, "app", List.of(Map.of("path", inWorkspace ? ".workspace/repos/lib" : "../lib")));
Files.createDirectories(root.resolve(".workspace/repos")); Files.writeString(root.resolve(".workspace/repos/registry.json"), "{}");
Files.writeString(source, "import { answer } from @lib:shared;\nfn main() -> int { return answer(); }\n");
Files.writeString(source.resolveSibling("mod.barrel"), "pub fn main() -> int;\n");
acquire();
var locations = query("definition", at(1, 26)).path("result");
assertFalse(locations.isEmpty(), locations.toString());
assertEquals(declaration.toUri().toString(), locations.get(0).path("uri").asText());
assertTrue(locations.get(0).path("uri").asText().startsWith("prometeu-source:"));
assertEquals(Files.readString(declaration), query("readExternalSource", Map.of("uri", locations.get(0).path("uri").asText())).path("result").path("text").asText());
final String externalUri = locations.get(0).path("uri").asText();
assertEquals(1, locations.get(0).path("range").path("start").path("line").asInt());
final var nested = query("definition", Map.of("uri", externalUri, "position", Map.of("line", 1, "character", 28))).path("result");
assertFalse(nested.isEmpty(), nested.toString());
assertEquals(2, nested.get(0).path("range").path("start").path("line").asInt());
assertEquals("documentSymbols", query("documentSymbols", Map.of("uri", declaration.toUri().toString())).path("operation").asText());
assertEquals(AutomationFailure.Code.READ_ONLY_SCOPE, assertThrows(AutomationException.class,
() -> query("formatting", Map.of("uri", declaration.toUri().toString()))).failure().code());
final Path alias = Files.createSymbolicLink(root.resolve("src/dependency-alias.pbs"), declaration);
assertEquals(AutomationFailure.Code.READ_ONLY_SCOPE, assertThrows(AutomationException.class,
() -> query("formatting", Map.of("uri", alias.toUri().toString()))).failure().code());
var rename = new HashMap<>(at(1, 26)); rename.put("newName", "renamed");
assertEquals(AutomationFailure.Code.READ_ONLY_SCOPE, assertThrows(AutomationException.class, () -> query("rename", rename)).failure().code());
final String oldText = Files.readString(declaration);
Files.writeString(declaration, "// changed revision\n" + oldText);
assertThrows(AutomationException.class, () -> query("readExternalSource", Map.of("uri", externalUri)));
final var renewed = query("definition", at(1, 26)).path("result");
assertNotEquals(externalUri, renewed.get(0).path("uri").asText());
assertEquals(2, renewed.get(0).path("range").path("start").path("line").asInt());
}
private void manifest(Path path, String name, List<?> dependencies) throws Exception {
mapper.writeValue(path.resolve("prometeu.json").toFile(), Map.of("name", name, "version", "1.0.0", "language", "pbs", "stdlib", "1", "target", "Game", "dependencies", dependencies));
@@ -15,6 +15,12 @@ class LocalMcpServerTest {
final HttpClient client = HttpClient.newBuilder().connectTimeout(Duration.ofSeconds(3)).build();
LocalMcpServer server;
String session;
@org.junit.jupiter.api.io.TempDir java.nio.file.Path root;
String authorization;
void authorize(java.nio.file.Path project) throws Exception {
var credential = server.credentials().prepare(project.toRealPath());
credential.activate(); authorization = "Bearer " + credential.secret();
}
AtomicInteger calls;
@BeforeEach void start() throws Exception {
@@ -22,7 +28,7 @@ class LocalMcpServerTest {
server = new LocalMcpServer(mapper, new McpToolRegistry(new McpToolCatalog(mapper), mapper, Map.of(
"studio_project_context", args -> { calls.incrementAndGet(); return McpToolResult.success(mapper, mapper.createObjectNode().put("projectRoot", args.get("projectRoot").asText())); },
"studio_control_acquire", args -> McpToolResult.failure(mapper, new AutomationFailure(AutomationFailure.Code.NOT_GRANTED, "Human grant required")))));
server.start();
server.start(); authorize(root);
}
@AfterEach void close() { server.close(); client.close(); }
HttpResponse<String> request(String method, URI uri, String body, String token, String origin, String protocol, String sessionId) throws Exception {
@@ -35,7 +41,7 @@ class LocalMcpServerTest {
return client.send(request.method(method, body == null ? HttpRequest.BodyPublishers.noBody() : HttpRequest.BodyPublishers.ofString(body)).build(), HttpResponse.BodyHandlers.ofString());
}
HttpResponse<String> post(String body) throws Exception {
return request("POST", server.connection().endpoint(), body, server.connection().authorizationHeader(), null, LocalMcpServer.PROTOCOL_VERSION, session);
return request("POST", server.connection().endpoint(), body.replace("/project", root.toRealPath().toString()), authorization, null, LocalMcpServer.PROTOCOL_VERSION, session);
}
static String init() { return "{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"initialize\",\"params\":{\"protocolVersion\":\"2025-06-18\",\"clientInfo\":{\"name\":\"test-client\",\"version\":\"1\"},\"capabilities\":{}}}"; }
void initialize() throws Exception {
@@ -51,11 +57,11 @@ class LocalMcpServerTest {
var response = post("{\"jsonrpc\":\"2.0\",\"id\":3,\"method\":\"tools/call\",\"params\":{\"name\":\"studio_project_context\",\"arguments\":{\"projectRoot\":\"/project\"}}}");
assertEquals(200, response.statusCode()); assertEquals(1, calls.get());
assertEquals("ok", mapper.readTree(response.body()).path("result").path("structuredContent").path("status").asText());
assertEquals(200, request("DELETE", server.connection().endpoint(), null, server.connection().authorizationHeader(), null, null, session).statusCode());
assertEquals(200, request("DELETE", server.connection().endpoint(), null, authorization, null, null, session).statusCode());
assertEquals(404, post("{\"jsonrpc\":\"2.0\",\"id\":4,\"method\":\"ping\"}").statusCode());
}
@Test void authAndOriginAreCheckedBeforeProtocolOrTools() throws Exception {
var endpoint = server.connection().endpoint(); var token = server.connection().authorizationHeader();
var endpoint = server.connection().endpoint(); var token = authorization;
assertEquals("127.0.0.1", endpoint.getHost()); assertTrue(endpoint.getPort() > 0);
assertEquals(401, request("POST", endpoint, init(), null, null, null, null).statusCode());
assertEquals(401, request("POST", endpoint, init(), "Bearer wrong", null, null, null).statusCode());
@@ -66,10 +72,10 @@ class LocalMcpServerTest {
assertFalse(server.connection().toString().contains(token.substring(7)));
}
@Test void restartChangesCredentialsInvalidatesConnectionsAndDoesNotPersistThem() throws Exception {
initialize(); var old = server.connection(); server.close();
initialize(); var old = authorization; server.close();
assertFalse(server.isRunning()); assertThrows(IllegalStateException.class, server::connection);
server.start(); assertFalse(old.authorizationHeader().equals(server.connection().authorizationHeader()));
assertEquals(401, request("POST", server.connection().endpoint(), init(), old.authorizationHeader(), null, null, null).statusCode());
server.start(); authorize(root); assertFalse(old.equals(authorization));
assertEquals(401, request("POST", server.connection().endpoint(), init(), old, null, null, null).statusCode());
assertEquals(404, post(init()).statusCode());
session = null; initialize();
}
@@ -81,13 +87,13 @@ class LocalMcpServerTest {
assertEquals(400, post("{\"jsonrpc\":\"2.0\",\"method\":123}").statusCode());
assertEquals(400, post("{\"jsonrpc\":\"2.0\",\"id\":1,\"id\":2,\"method\":\"ping\"}").statusCode());
assertEquals(400, post("{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"ping\"} {}").statusCode());
assertEquals(400, request("POST", server.connection().endpoint(), init(), server.connection().authorizationHeader(), null, "unknown", session).statusCode());
assertEquals(400, request("POST", server.connection().endpoint(), init(), authorization, null, "unknown", session).statusCode());
var bad = post("{\"jsonrpc\":\"2.0\",\"id\":3,\"method\":\"tools/call\",\"params\":{\"name\":\"studio_project_context\",\"arguments\":{\"projectRoot\":\"relative\"}}}");
assertEquals(-32602, mapper.readTree(bad.body()).path("error").path("code").intValue()); assertEquals(0, calls.get());
assertEquals(413, post(" ".repeat(1024 * 1024 + 1)).statusCode());
}
@Test void exactEndpointNoSseAndInitializationAreEnforced() throws Exception {
var endpoint = server.connection().endpoint(); var token = server.connection().authorizationHeader();
var endpoint = server.connection().endpoint(); var token = authorization;
assertEquals(400, post("{\"jsonrpc\":\"2.0\",\"id\":3,\"method\":\"tools/list\"}").statusCode());
var initialized = post(init()); session = initialized.headers().firstValue("Mcp-Session-Id").orElseThrow();
assertEquals(-32600, mapper.readTree(post("{\"jsonrpc\":\"2.0\",\"id\":3,\"method\":\"tools/list\"}").body()).path("error").path("code").asInt());
@@ -117,7 +123,7 @@ class LocalMcpServerTest {
server.close();
server = new LocalMcpServer(mapper, new McpToolRegistry(new McpToolCatalog(mapper), mapper,
McpProjectKnowledgeTools.handlers(knowledge, mapper)));
server.start();
server.start(); authorize(root);
initialize();
var call = mapper.createObjectNode().put("jsonrpc", "2.0").put("id", 2).put("method", "tools/call");
call.putObject("params").put("name", "studio_project_context").putObject("arguments").put("projectRoot", root.toString());
@@ -153,13 +159,13 @@ class LocalMcpServerTest {
var connection = server.connection();
try (var socket = new java.net.Socket("127.0.0.1", connection.endpoint().getPort())) {
socket.setSoTimeout(3000);
String request = "POST /mcp HTTP/1.1\r\nHost: evil.example\r\nAuthorization: " + connection.authorizationHeader()
String request = "POST /mcp HTTP/1.1\r\nHost: evil.example\r\nAuthorization: " + authorization
+ "\r\nContent-Length: 0\r\nConnection: close\r\n\r\n";
socket.getOutputStream().write(request.getBytes(java.nio.charset.StandardCharsets.UTF_8));
var status = new java.io.BufferedReader(new java.io.InputStreamReader(socket.getInputStream())).readLine();
assertTrue(status.contains("403"));
}
var request = HttpRequest.newBuilder(connection.endpoint()).header("Authorization", connection.authorizationHeader())
var request = HttpRequest.newBuilder(connection.endpoint()).header("Authorization", authorization)
.header("Origin", "http://" + connection.endpoint().getRawAuthority()).header("Origin", "https://evil.example")
.POST(HttpRequest.BodyPublishers.ofString(init())).build();
assertEquals(403, client.send(request, HttpResponse.BodyHandlers.discarding()).statusCode());
@@ -167,13 +173,29 @@ class LocalMcpServerTest {
@Test void contentNegotiationAcceptsWeightedTypesAndRejectsInvalidUtf8() throws Exception {
var connection = server.connection();
var request = HttpRequest.newBuilder(connection.endpoint()).header("Authorization", connection.authorizationHeader())
var request = HttpRequest.newBuilder(connection.endpoint()).header("Authorization", authorization)
.header("Accept", "application/json;q=1, text/event-stream;q=0.5").header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(init())).build();
assertEquals(200, client.send(request, HttpResponse.BodyHandlers.discarding()).statusCode());
var invalid = HttpRequest.newBuilder(connection.endpoint()).header("Authorization", connection.authorizationHeader())
var invalid = HttpRequest.newBuilder(connection.endpoint()).header("Authorization", authorization)
.header("Accept", "application/json, text/event-stream").header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofByteArray(new byte[]{(byte) 0xc3, (byte) 0x28})).build();
assertEquals(400, client.send(invalid, HttpResponse.BodyHandlers.discarding()).statusCode());
}
@Test void projectCredentialsCannotCrossRootsOrReuseAnotherSession() throws Exception {
initialize();
var other = java.nio.file.Files.createDirectory(root.resolve("other")).toRealPath();
var credential = server.credentials().prepare(other); credential.activate();
var wire = "{\"jsonrpc\":\"2.0\",\"id\":4,\"method\":\"tools/list\"}";
assertEquals(403, request("POST", server.connection().endpoint(), wire, "Bearer " + credential.secret(), null,
LocalMcpServer.PROTOCOL_VERSION, session).statusCode());
var call = mapper.createObjectNode().put("jsonrpc", "2.0").put("id", 5).put("method", "tools/call");
call.putObject("params").put("name", "studio_project_context").putObject("arguments").put("projectRoot", other.toString());
var reply = mapper.readTree(post(call.toString()).body());
assertEquals("OUTSIDE_PROJECT_SCOPE", reply.path("result").path("structuredContent").path("error").path("code").asText());
assertEquals(0, calls.get());
server.credentials().authenticate(authorization).invalidate();
assertEquals(401, post(wire).statusCode());
}
}
@@ -15,38 +15,34 @@ import static org.junit.jupiter.api.Assertions.*;
class McpConnectionGuideTest {
@TempDir Path root;
@Test void exportsLiveProjectDescriptorWithoutGrantAndTracksRestartWithoutRetainingSecrets() throws Exception {
@Test void preparationIsStableAndSeparateFromAuthority() throws Exception {
var mapper = new ObjectMapper(); var projects = new ProjectAccessRegistry();
try (var workers = Executors.newSingleThreadExecutor();
var server = new LocalMcpServer(mapper, new McpToolRegistry(new McpToolCatalog(mapper), mapper, Map.of()))) {
var authority = new DefaultAutomationSession(root, new ExecutorOperationExecutor(workers));
var registration = projects.register(root, authority::enterManual, () -> !authority.snapshot().closed(), authority);
var guide = new McpConnectionGuide(server, projects, mapper);
assertTrue(guide.endpoint().isEmpty());
assertThrows(IllegalStateException.class, () -> guide.configuration(root));
var notifications = new AtomicInteger();
var subscription = guide.subscribe(notifications::incrementAndGet);
server.start(); assertEquals(2, notifications.get());
var descriptor = mapper.readTree(guide.configuration(root));
assertEquals(server.connection().endpoint().toString(), descriptor.path("url").asText());
assertEquals(root.toRealPath().toString(), descriptor.path("projectRoot").asText());
// Do not put bearer credentials into assertion diagnostics.
assertTrue(server.connection().authorizationHeader().equals(descriptor.path("headers").path("Authorization").asText()));
assertFalse(guide.toString().contains(descriptor.path("headers").path("Authorization").asText()));
var prepared = new AtomicInteger();
var canonical = root.toRealPath();
var guide = new McpConnectionGuide(server, projects, mapper, project -> {
assertEquals(canonical, project); prepared.incrementAndGet();
return new AgentIntegrationPreparation.Result(true, "Prepared; trust/reload once.");
});
assertEquals(AgentConnectionGuide.State.UNAVAILABLE, guide.state(root));
var stable = guide.configuration(root);
assertTrue(guide.prepare(root).ready()); assertEquals(1, prepared.get());
assertEquals(ControlState.MANUAL, authority.snapshot().state());
assertNull(authority.snapshot().task());
server.start();
assertEquals(AgentConnectionGuide.State.WAITING_FOR_ACCESS, guide.state(root));
assertFalse(stable.contains("Bearer"));
for (var instruction : List.of("studio_project_context", "studio_reference_read", "studio_control_acquire", "studio_control_release",
"studio_language_query", "studio_build_start", "clientRequestId", "read-only", "restart", "native file writes"))
assertTrue(descriptor.path("instructions").asText().contains(instruction));
var old = server.connection(); server.close(); assertEquals(3, notifications.get()); assertTrue(guide.endpoint().isEmpty());
server.start(); assertEquals(4, notifications.get());
var fresh = mapper.readTree(guide.configuration(root));
assertTrue(fresh.path("headers").path("Authorization").asText().equals(server.connection().authorizationHeader()));
assertFalse(fresh.path("headers").path("Authorization").asText().equals(old.authorizationHeader()));
assertTrue(stable.contains(instruction));
server.close(); server.start(); assertEquals(stable, guide.configuration(root));
assertThrows(AutomationException.class, () -> guide.configuration(root.resolve("unopened")));
authority.closeAsync().toCompletableFuture().join();
assertThrows(AutomationException.class, () -> guide.configuration(root));
registration.close(); subscription.close(); server.close(); assertEquals(4, notifications.get());
registration.close();
}
}
}
@@ -20,6 +20,7 @@ import java.util.function.*;
import static org.junit.jupiter.api.Assertions.*;
class McpTaskToolsTest {
String httpAuthorization;
@TempDir Path root;
final ObjectMapper mapper = new ObjectMapper();
final ExecutorService workers = Executors.newCachedThreadPool();
@@ -243,6 +244,8 @@ class McpTaskToolsTest {
compose(shipper);
try (var server = new LocalMcpServer(mapper, tools); var client = java.net.http.HttpClient.newHttpClient()) {
server.start();
var credential = server.credentials().prepare(root.toRealPath());
credential.activate(); httpAuthorization = "Bearer " + credential.secret();
var initialize = mapper.createObjectNode().put("jsonrpc", "2.0").put("id", 1).put("method", "initialize");
var params = initialize.putObject("params").put("protocolVersion", "2025-06-18");
params.putObject("capabilities"); params.putObject("clientInfo").put("name", "task-test").put("version", "1");
@@ -281,6 +284,8 @@ class McpTaskToolsTest {
try (var server = new LocalMcpServer(mapper, new McpToolRegistry(new McpToolCatalog(mapper), mapper, handlers));
var client = java.net.http.HttpClient.newHttpClient()) {
server.start();
var credential = server.credentials().prepare(root.toRealPath());
credential.activate(); httpAuthorization = "Bearer " + credential.secret();
var unauthorized = java.net.http.HttpRequest.newBuilder(server.connection().endpoint()).POST(java.net.http.HttpRequest.BodyPublishers.ofString("{}"))
.timeout(java.time.Duration.ofSeconds(5)).build();
assertEquals(401, client.send(unauthorized, java.net.http.HttpResponse.BodyHandlers.discarding()).statusCode());
@@ -315,7 +320,7 @@ class McpTaskToolsTest {
var captured = httpCall(client, server, first, "studio_headless_capture", args()); value(captured);
assertArrayEquals(session.snapshot().capture().png(), Base64.getDecoder().decode(captured.path("content").get(1).path("data").asText()));
var deleted = java.net.http.HttpRequest.newBuilder(server.connection().endpoint()).DELETE()
.header("Authorization", server.connection().authorizationHeader()).header("Mcp-Session-Id", first).build();
.header("Authorization", httpAuthorization).header("Mcp-Session-Id", first).build();
assertEquals(200, client.send(deleted, java.net.http.HttpResponse.BodyHandlers.discarding()).statusCode());
assertEquals(ControlState.AGENT_WORKING, session.snapshot().state());
String reconnected = connect(client, server);
@@ -367,7 +372,7 @@ class McpTaskToolsTest {
}
java.net.http.HttpResponse<String> post(java.net.http.HttpClient client, LocalMcpServer server, String connection, JsonNode body) throws Exception {
var request = java.net.http.HttpRequest.newBuilder(server.connection().endpoint()).timeout(java.time.Duration.ofSeconds(10))
.header("Authorization", server.connection().authorizationHeader()).header("Content-Type", "application/json")
.header("Authorization", httpAuthorization).header("Content-Type", "application/json")
.header("Accept", "application/json, text/event-stream").header("MCP-Protocol-Version", "2025-06-18");
if (connection != null) request.header("Mcp-Session-Id", connection);
return client.send(request.POST(java.net.http.HttpRequest.BodyPublishers.ofString(body.toString())).build(), java.net.http.HttpResponse.BodyHandlers.ofString());
@@ -0,0 +1,115 @@
package p.studio.app.mcp;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.jupiter.api.*;
import org.junit.jupiter.api.io.TempDir;
import java.nio.file.*;
import java.nio.file.attribute.PosixFilePermissions;
import java.util.Map;
import static org.junit.jupiter.api.Assertions.*;
class ProjectConnectionPublisherTest {
@TempDir Path temporary;
final ObjectMapper mapper = new ObjectMapper();
LocalMcpServer server;
Path root;
@BeforeEach void start() throws Exception {
root = temporary.toRealPath();
server = new LocalMcpServer(mapper, new McpToolRegistry(new McpToolCatalog(mapper), mapper, Map.of())); server.start();
}
@AfterEach void stop() { server.close(); }
@Test void publishesPrivatelyOnlyActivatesExplicitlyAndCleansUpOwnedGeneration() throws Exception {
Files.writeString(root.resolve(".gitignore"), "# existing\n/build/\n");
var publisher = new ProjectConnectionPublisher(server, mapper);
var publication = publisher.prepare(root);
publication.publish();
var descriptor = ProjectConnectionFiles.read(root, mapper);
assertNull(server.credentials().authenticate("Bearer " + descriptor.credential()));
publication.activate();
assertEquals(root, server.credentials().authenticate("Bearer " + descriptor.credential()).root());
var file = root.resolve(ProjectConnectionFiles.RELATIVE);
assertEquals(PosixFilePermissions.fromString("rw-------"), Files.getPosixFilePermissions(file));
assertEquals(PosixFilePermissions.fromString("rwx------"), Files.getPosixFilePermissions(file.getParent()));
assertFalse(descriptor.toString().contains(descriptor.credential()));
assertThrows(Exception.class, () -> publisher.prepare(root));
publication.invalidate(); assertNull(server.credentials().authenticate("Bearer " + descriptor.credential()));
publication.close(); assertFalse(Files.exists(file)); assertTrue(Files.exists(file.resolveSibling("publication.lock")));
try (var next = publisher.prepare(root)) {
next.publish(); next.activate(); publication.close();
assertTrue(Files.exists(file));
assertNotEquals(descriptor.credential(), ProjectConnectionFiles.read(root, mapper).credential());
}
assertEquals("# existing\n/build/\n/.studio/mcp/\n", Files.readString(root.resolve(".gitignore")));
}
@Test void unsafePathsAndPermissionsNeverPublishSecrets() throws Exception {
Path destination = Files.createDirectory(root.resolve("outside"));
Files.createSymbolicLink(root.resolve(".studio"), destination);
assertThrows(Exception.class, () -> new ProjectConnectionPublisher(server, mapper).prepare(root));
assertFalse(Files.exists(destination.resolve("mcp")));
Files.delete(root.resolve(".studio"));
Path directory = ProjectConnectionFiles.directory(root);
Files.setPosixFilePermissions(directory, PosixFilePermissions.fromString("rwxr-xr-x"));
assertThrows(Exception.class, () -> new ProjectConnectionPublisher(server, mapper).prepare(root));
}
@Test void malformedDescriptorsNeverSupplyAnArbitraryEndpoint() throws Exception {
try (var publication = new ProjectConnectionPublisher(server, mapper).prepare(root)) {
publication.publish();
Path path = root.resolve(ProjectConnectionFiles.RELATIVE);
var valid = mapper.readTree(Files.readString(path));
for (String endpoint : java.util.List.of("https://example.com/mcp", "http://127.0.0.1:123/mcp?x=1", "http://localhost:123/mcp")) {
var bad = valid.deepCopy(); ((com.fasterxml.jackson.databind.node.ObjectNode) bad).put("endpoint", endpoint);
Files.writeString(path, bad.toString()); assertThrows(Exception.class, () -> ProjectConnectionFiles.read(root, mapper));
}
Files.writeString(path, valid.toString());
}
}
@Test void osLockRejectsAnotherJvmAndCrashAllowsRecoveryWithoutUnlinkingLock() throws Exception {
Process owner = ownerProcess();
try {
assertEquals("READY", java.util.concurrent.CompletableFuture.supplyAsync(() -> {
try { return owner.inputReader().readLine(); } catch (java.io.IOException failure) { throw new java.io.UncheckedIOException(failure); }
}).get(10, java.util.concurrent.TimeUnit.SECONDS));
var lock = root.resolve(".studio/mcp/publication.lock");
var inode = Files.readAttributes(lock, java.nio.file.attribute.BasicFileAttributes.class).fileKey();
Process conflict = ownerProcess();
try { assertTrue(conflict.waitFor(10, java.util.concurrent.TimeUnit.SECONDS)); assertEquals(2, conflict.exitValue()); }
finally { conflict.destroyForcibly(); }
owner.destroyForcibly(); assertTrue(owner.waitFor(10, java.util.concurrent.TimeUnit.SECONDS));
assertTrue(Files.exists(root.resolve(ProjectConnectionFiles.RELATIVE)));
try (var recovered = new ProjectConnectionPublisher(server, mapper).prepare(root)) {
recovered.publish(); recovered.activate();
assertEquals(server.instanceId(), ProjectConnectionFiles.read(root, mapper).instanceId());
assertEquals(inode, Files.readAttributes(lock, java.nio.file.attribute.BasicFileAttributes.class).fileKey());
}
} finally { owner.destroyForcibly(); }
}
@Test void trackedDiscoveryTargetIsRejectedWithoutWritingCredentials() throws Exception {
var directory = ProjectConnectionFiles.directory(root);
var target = directory.resolve("connection.json"); Files.writeString(target, "tracked placeholder");
for (var command : java.util.List.of(java.util.List.of("git", "init", "-q"), java.util.List.of("git", "add", "-f", ProjectConnectionFiles.RELATIVE))) {
var process = new ProcessBuilder(command).directory(root.toFile()).redirectError(ProcessBuilder.Redirect.DISCARD).start();
assertTrue(process.waitFor(5, java.util.concurrent.TimeUnit.SECONDS)); assertEquals(0, process.exitValue());
}
assertThrows(Exception.class, () -> new ProjectConnectionPublisher(server, mapper).prepare(root));
assertEquals("tracked placeholder", Files.readString(target));
assertFalse(Files.exists(directory.resolve("publication.lock")));
}
private Process ownerProcess() throws Exception {
return new ProcessBuilder(Path.of(System.getProperty("java.home"), "bin/java").toString(), "-cp",
System.getProperty("studio.test.classpath"), Owner.class.getName(), root.toString())
.redirectError(ProcessBuilder.Redirect.DISCARD).start();
}
public static class Owner {
public static void main(String[] args) throws Exception {
var mapper = new ObjectMapper();
try (var server = new LocalMcpServer(mapper, new McpToolRegistry(new McpToolCatalog(mapper), mapper, Map.of()))) {
server.start();
try (var publication = new ProjectConnectionPublisher(server, mapper).prepare(Path.of(args[0]))) {
publication.publish(); publication.activate(); System.out.println("READY"); System.out.flush(); System.in.read();
} catch (Exception conflict) { System.exit(2); }
}
}
}
}
@@ -0,0 +1,36 @@
package p.studio.app.mcp;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;
import java.nio.file.*;
import static org.junit.jupiter.api.Assertions.*;
class StudioAgentPreparationTest {
@TempDir Path temporary;
@Test void preservesUnrelatedTomlAndRejectsUserOwnedOrEditedEntry() throws Exception {
var preparation = new StudioAgentPreparation(temporary.resolve("Application Support/Studio"), new ObjectMapper());
String entry = preparation.entry(temporary.toRealPath());
String custom = "# keep exactly\napproval_policy = \"on-request\"\n[mcp_servers.custom]\ncommand = \"custom\"\n";
String merged = StudioAgentPreparation.merge(custom, entry);
assertTrue(merged.startsWith(custom)); assertEquals(merged, StudioAgentPreparation.merge(merged, entry));
assertFalse(merged.contains("credential")); assertFalse(merged.contains("connection.json"));
assertThrows(Exception.class, () -> StudioAgentPreparation.merge("[mcp_servers.prometeu_studio]\ncommand=\"mine\"\n", entry));
assertThrows(Exception.class, () -> StudioAgentPreparation.merge(merged.replace("startup_timeout_sec = 20", "startup_timeout_sec = 30"), entry));
String updated = StudioAgentPreparation.merge(merged, preparation.entry(temporary.resolve("another project")));
assertTrue(updated.startsWith(custom)); assertTrue(updated.contains("another project"));
}
@Test void absentInstallationReportsIncompleteAndDoesNotModifyClientConfig() throws Exception {
Files.writeString(temporary.resolve("prometeu.json"), "{}");
Files.createDirectory(temporary.resolve(".codex"));
Path config = temporary.resolve(".codex/config.toml"); Files.writeString(config, "# preserve\n");
var preparation = new StudioAgentPreparation(temporary.resolve("missing"), new ObjectMapper());
var result = preparation.prepare(temporary);
assertFalse(result.ready()); assertEquals("# preserve\n", Files.readString(config));
assertTrue(result.message().contains("Studio installation is missing"));
assertTrue(result.message().contains(":prometeu-app:stageStudioInstallation"));
assertTrue(result.message().contains("-Dstudio.installationRoot"));
assertFalse(Files.exists(temporary.resolve(".studio/mcp")));
assertEquals(result, preparation.status(temporary.toRealPath()));
}
}
@@ -0,0 +1,204 @@
package p.studio.app.mcp.stdio;
import com.fasterxml.jackson.databind.*;
import org.junit.jupiter.api.*;
import org.junit.jupiter.api.io.TempDir;
import p.studio.app.mcp.*;
import java.io.*;
import java.nio.file.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
import static org.junit.jupiter.api.Assertions.*;
class StudioMcpStdioTest {
@TempDir Path temporary;
final ObjectMapper mapper = new ObjectMapper();
Path root;
@BeforeEach void project() throws Exception { root = temporary.toRealPath(); Files.writeString(root.resolve("prometeu.json"), "{}"); }
LocalMcpServer server(AtomicInteger calls, String image) {
return new LocalMcpServer(mapper, new McpToolRegistry(new McpToolCatalog(mapper), mapper, Map.of("studio_project_context", args -> {
calls.incrementAndGet();
return McpToolResult.successWithCapture(mapper, mapper.createObjectNode().put("projectRoot", args.path("projectRoot").asText()),
new p.studio.api.automation.CanonicalCapture("session", "build", 1, 1, 1, 1, 1, Base64.getDecoder().decode(image)), false);
})));
}
@Test void coldProcessDiscoversLaterGrantPreservesLargeImagesAndSurvivesRestart() throws Exception {
var count = new AtomicInteger(); String pixels = "A".repeat(1024 * 1024 + 100);
try (var process = new Connector(root); var server = server(count, pixels)) {
process.initialize();
assertEquals(17, process.request("tools/list", mapper.createObjectNode()).path("result").path("tools").size());
var waiting = process.call("studio_project_context", root);
assertEquals("WAITING_FOR_ACCESS", waiting.path("structuredContent").path("error").path("code").asText());
assertFalse(Files.exists(root.resolve(".studio")));
server.start();
var publisher = new ProjectConnectionPublisher(server, mapper);
try (var publication = publisher.prepare(root)) {
publication.publish(); publication.activate();
var result = process.call("studio_project_context", root);
assertFalse(result.path("isError").asBoolean(), result.path("structuredContent").toString());
assertEquals(pixels, result.path("content").get(1).path("data").asText());
assertEquals(root.toString(), result.path("structuredContent").path("value").path("projectRoot").asText());
Path other = Files.createDirectory(root.resolve("other"));
assertEquals("OUTSIDE_PROJECT_SCOPE", process.call("studio_project_context", other).path("structuredContent").path("error").path("code").asText());
assertEquals(1, count.get());
}
server.close(); server.start();
assertEquals("WAITING_FOR_ACCESS", process.call("studio_project_context", root).path("structuredContent").path("error").path("code").asText());
try (var fresh = publisher.prepare(root)) {
fresh.publish(); fresh.activate();
assertFalse(process.call("studio_project_context", root).path("isError").asBoolean());
assertEquals(2, count.get());
}
}
}
@Test void invalidArgumentsAndMalformedLinesDoNotLaunchDesktopOrBreakCorrelation() throws Exception {
try (var connector = new Connector(root)) {
connector.send("{bad json}");
assertEquals(-32700, connector.read().path("error").path("code").asInt());
connector.initialize();
assertEquals(-32601, connector.request("no-method", mapper.createObjectNode()).path("error").path("code").asInt());
assertTrue(connector.request("ping", mapper.createObjectNode()).has("result"));
}
var process = new ProcessBuilder(java(), "-cp", classpath(), "p.studio.app.StudioLauncher", "mcp", "--project", "relative")
.redirectError(ProcessBuilder.Redirect.DISCARD).start();
assertTrue(process.waitFor(10, TimeUnit.SECONDS)); assertNotEquals(0, process.exitValue());
assertEquals(0, process.getInputStream().readAllBytes().length);
}
@Test void lostBuildResponseIsNotReplayedAndReceiptCanBeLookedUpAfterReconnect() throws Exception {
var builds = new AtomicInteger(); var mapper = this.mapper;
var handlers = Map.<String, java.util.function.Function<JsonNode, McpToolResult>>of(
"studio_build_start", args -> { builds.incrementAndGet(); return McpToolResult.success(mapper, mapper.createObjectNode().put("operationId", "op-1")); },
"studio_operation_get", args -> McpToolResult.success(mapper, mapper.createObjectNode().put("operationId", "op-1")));
try (var server = new LocalMcpServer(mapper, new McpToolRegistry(new McpToolCatalog(mapper), mapper, handlers));
var transport = java.net.http.HttpClient.newHttpClient()) {
server.start();
var proxy = com.sun.net.httpserver.HttpServer.create(new java.net.InetSocketAddress("127.0.0.1", 0), 0);
var dropped = new java.util.concurrent.atomic.AtomicBoolean();
proxy.createContext("/mcp", exchange -> {
try (exchange) {
var bytes = exchange.getRequestBody().readAllBytes();
var incoming = mapper.readTree(bytes);
var request = java.net.http.HttpRequest.newBuilder(server.connection().endpoint());
for (String header : List.of("Authorization", "Content-Type", "Accept", "Mcp-Session-Id", "MCP-Protocol-Version")) {
String value = exchange.getRequestHeaders().getFirst(header); if (value != null) request.header(header, value);
}
var response = transport.send(request.POST(java.net.http.HttpRequest.BodyPublishers.ofByteArray(bytes)).build(), java.net.http.HttpResponse.BodyHandlers.ofByteArray());
if (incoming.path("params").path("name").asText().equals("studio_build_start") && dropped.compareAndSet(false, true)) {
exchange.sendResponseHeaders(200, 100); return; // Committed tool, intentionally incomplete transport response.
}
response.headers().firstValue("Mcp-Session-Id").ifPresent(value -> exchange.getResponseHeaders().set("Mcp-Session-Id", value));
exchange.sendResponseHeaders(response.statusCode(), response.body().length == 0 ? -1 : response.body().length);
exchange.getResponseBody().write(response.body());
} catch (InterruptedException interrupted) { Thread.currentThread().interrupt(); }
});
proxy.start();
try (var publication = new ProjectConnectionPublisher(server, mapper).prepare(root);
var connection = new StudioMcpConnection(root, mapper, new McpToolCatalog(mapper))) {
publication.publish(); publication.activate();
var path = root.resolve(ProjectConnectionFiles.RELATIVE);
var descriptor = (com.fasterxml.jackson.databind.node.ObjectNode) mapper.readTree(Files.readString(path));
descriptor.put("endpoint", "http://127.0.0.1:" + proxy.getAddress().getPort() + "/mcp"); Files.writeString(path, descriptor.toString());
var args = mapper.createObjectNode().put("projectRoot", root.toString()).put("taskId", "task").put("clientRequestId", "intent-1");
var unknown = connection.call("studio_build_start", args);
assertEquals("OUTCOME_UNKNOWN", unknown.path("structuredContent").path("error").path("code").asText());
assertEquals("intent-1", unknown.path("structuredContent").path("error").path("clientRequestId").asText());
connection.probe(); assertEquals(1, builds.get());
var recovered = connection.call("studio_operation_get", args);
assertEquals("op-1", recovered.path("structuredContent").path("value").path("operationId").asText());
assertEquals(1, builds.get());
} finally { proxy.stop(0); }
}
}
@Test void restartedInstanceCannotClaimRecoveryOfOldTaskReceipts() throws Exception {
var calls = new AtomicInteger();
var handlers = Map.<String, java.util.function.Function<JsonNode, McpToolResult>>of(
"studio_control_acquire", args -> McpToolResult.success(mapper, mapper.createObjectNode().put("taskId", UUID.randomUUID().toString())),
"studio_operation_get", args -> { calls.incrementAndGet(); return McpToolResult.success(mapper, mapper.createObjectNode().put("operationId", "fresh")); });
try (var server = new LocalMcpServer(mapper, new McpToolRegistry(new McpToolCatalog(mapper), mapper, handlers));
var connection = new StudioMcpConnection(root, mapper, new McpToolCatalog(mapper))) {
server.start(); var publisher = new ProjectConnectionPublisher(server, mapper);
String task;
try (var publication = publisher.prepare(root)) {
publication.publish(); publication.activate();
task = connection.call("studio_control_acquire", mapper.createObjectNode().put("projectRoot", root.toString()))
.path("structuredContent").path("value").path("taskId").asText();
}
server.close(); server.start();
try (var publication = publisher.prepare(root)) {
publication.publish(); publication.activate();
var old = mapper.createObjectNode().put("projectRoot", root.toString()).put("taskId", task).put("clientRequestId", "old");
assertEquals("OUTCOME_UNKNOWN", connection.call("studio_operation_get", old).path("structuredContent").path("error").path("code").asText());
assertEquals(0, calls.get());
String fresh = connection.call("studio_control_acquire", mapper.createObjectNode().put("projectRoot", root.toString()))
.path("structuredContent").path("value").path("taskId").asText();
old.put("taskId", fresh);
assertFalse(connection.call("studio_operation_get", old).path("isError").asBoolean()); assertEquals(1, calls.get());
}
}
}
@Test void staleIdentityAndCatalogMismatchAreRejectedBeforeToolDispatch() throws Exception {
var calls = new AtomicInteger();
try (var server = server(calls, "AAAA")) {
server.start();
try (var publication = new ProjectConnectionPublisher(server, mapper).prepare(root)) {
publication.publish(); publication.activate();
Path path = root.resolve(ProjectConnectionFiles.RELATIVE);
String valid = Files.readString(path);
try {
for (String field : List.of("instanceId", "catalogFingerprint")) {
var invalid = (com.fasterxml.jackson.databind.node.ObjectNode) mapper.readTree(valid); invalid.put(field, "outdated");
Files.writeString(path, invalid.toString());
try (var connection = new StudioMcpConnection(root, mapper, new McpToolCatalog(mapper))) {
var result = connection.call("studio_project_context", mapper.createObjectNode().put("projectRoot", root.toString()));
assertEquals(field.equals("instanceId") ? "STALE_CONNECTION" : "VERSION_INCOMPATIBLE",
result.path("structuredContent").path("error").path("code").asText());
}
}
assertEquals(0, calls.get());
} finally { Files.writeString(path, valid); }
}
}
}
static String java() { return Path.of(System.getProperty("java.home"), "bin/java").toString(); }
static String classpath() { return System.getProperty("studio.test.classpath"); }
final class Connector implements AutoCloseable {
final Process process;
final BufferedReader reader;
final BufferedWriter writer;
final ExecutorService reads = Executors.newSingleThreadExecutor();
final Path errors;
int sequence;
Connector(Path project) throws Exception {
errors = Files.createTempFile(temporary, "stdio-", ".stderr");
process = new ProcessBuilder(java(), "-cp", classpath(), "p.studio.app.StudioLauncher", "mcp", "--project", project.toString())
.directory(temporary.toFile()).redirectError(errors.toFile()).start();
reader = process.inputReader(); writer = process.outputWriter();
}
void send(String value) throws Exception { writer.write(value); writer.newLine(); writer.flush(); }
JsonNode read() throws Exception {
String line = reads.submit(reader::readLine).get(15, TimeUnit.SECONDS);
assertNotNull(line, Files.readString(errors)); return mapper.readTree(line);
}
JsonNode request(String method, JsonNode params) throws Exception {
var value = mapper.createObjectNode().put("jsonrpc", "2.0").put("id", ++sequence).put("method", method); value.set("params", params);
send(value.toString()); var response = read(); assertEquals(sequence, response.path("id").asInt()); return response;
}
void initialize() throws Exception {
var params = mapper.createObjectNode().put("protocolVersion", "2025-06-18"); params.putObject("capabilities"); params.putObject("clientInfo").put("name", "process-test").put("version", "1");
assertEquals("2025-06-18", request("initialize", params).path("result").path("protocolVersion").asText());
send("{\"jsonrpc\":\"2.0\",\"method\":\"notifications/initialized\"}");
}
JsonNode call(String name, Path root) throws Exception {
var params = mapper.createObjectNode().put("name", name); params.putObject("arguments").put("projectRoot", root.toString());
return request("tools/call", params).path("result");
}
public void close() throws Exception {
try { writer.close(); assertTrue(process.waitFor(10, TimeUnit.SECONDS), "EOF must terminate the connector"); assertEquals(0, process.exitValue(), Files.readString(errors)); }
finally { process.destroyForcibly(); reads.shutdownNow(); }
}
}
}
@@ -39,6 +39,7 @@ class HeadlessMcpDesktopTest {
LocalMcpServer server;
HttpClient client;
String connection, task, build, session;
String authorization = "Bearer unavailable";
Path installation, source;
DevWorkspace dev;
Stage stage;
@@ -76,9 +77,9 @@ class HeadlessMcpDesktopTest {
stage = new Stage(); stage.setTitle("Real MCP / headless / DEV conformance");
stage.setScene(new Scene((javafx.scene.Parent) dev.rootNode(), 1000, 800)); stage.show(); dev.load();
});
connect();
}
void connect() throws Exception {
authorization = "Bearer " + p.studio.app.mcp.ProjectConnectionFiles.read(root, mapper).credential();
connection = null;
var initialize = request("initialize");
var params = initialize.putObject("params").put("protocolVersion", "2025-06-18");
@@ -96,8 +97,15 @@ class HeadlessMcpDesktopTest {
assertTrue(owned.stream().noneMatch(ProcessHandle::isAlive), "No managed runtime may survive the test");
}
void acquire() throws Exception {
void grant() throws Exception {
fx(() -> ((Button) dev.rootNode().lookup("#dev-grant")).fire());
long deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(10);
while (project.automation().snapshot().state() != ControlState.WAITING_FOR_AGENT && System.nanoTime() < deadline) Thread.sleep(10);
assertEquals(ControlState.WAITING_FOR_AGENT, project.automation().snapshot().state());
connect();
}
void acquire() throws Exception {
grant();
task = value(call("studio_control_acquire", args())).path("taskId").asText();
}
void prepareLongRun() throws Exception {
@@ -121,7 +129,7 @@ class HeadlessMcpDesktopTest {
prepareLongRun();
var receipt = startRunning("cancel-me");
var delete = HttpRequest.newBuilder(server.connection().endpoint()).DELETE()
.header("Authorization", server.connection().authorizationHeader()).header("Mcp-Session-Id", connection).build();
.header("Authorization", authorization).header("Mcp-Session-Id", connection).build();
assertEquals(200, client.send(delete, HttpResponse.BodyHandlers.discarding()).statusCode());
client.close(); client = HttpClient.newHttpClient(); connect();
assertEquals(ControlState.AGENT_WORKING, project.automation().snapshot().state());
@@ -159,7 +167,7 @@ class HeadlessMcpDesktopTest {
refreshEntered.get(10, TimeUnit.SECONDS);
assertEquals(ControlState.RETURNING_CONTROL, project.automation().snapshot().state());
assertFalse(project.automation().snapshot().manualAllowed());
assertEquals("INVALID_TASK", call("studio_operation_get", args().put("clientRequestId", "revoked")).path("structuredContent").path("error").path("code").asText());
assertEquals(401, post(request("ping")).statusCode());
assertSame(lastCapture, project.automation().snapshot().capture(), "Revoked work must not publish a late frame");
refreshGate.complete(null);
assertEquals(ControlState.MANUAL, project.automation().snapshot().state());
@@ -169,19 +177,19 @@ class HeadlessMcpDesktopTest {
}
@Test void waitingRevokeProjectCloseAndReopenNeverRestoreAuthority() throws Exception {
fx(() -> ((Button) dev.rootNode().lookup("#dev-grant")).fire());
grant();
fx(() -> ((Button) dev.rootNode().lookup("#dev-reclaim")).fire());
assertEquals(ControlState.MANUAL, project.automation().snapshot().state());
assertEquals("NOT_GRANTED", call("studio_control_acquire", args()).path("structuredContent").path("error").path("code").asText());
assertEquals(401, post(request("ping")).statusCode());
prepareLongRun(); startRunning("close-project");
fx(dev::unLoad);
assertEquals(ControlState.AGENT_WORKING, project.automation().snapshot().state(), "DEV does not own task lifetime");
project.close();
assertTrue(owned.stream().noneMatch(ProcessHandle::isAlive));
assertEquals("PROJECT_NOT_OPEN", call("studio_operation_get", args().put("clientRequestId", "close-project")).path("structuredContent").path("error").path("code").asText());
assertEquals(401, post(request("ping")).statusCode());
project = app.getBean(ProjectSessionFactory.class).open(project.projectReference());
assertEquals(ControlState.MANUAL, project.automation().snapshot().state());
assertEquals("INVALID_TASK", call("studio_build_start", args().put("clientRequestId", "late")).path("structuredContent").path("error").path("code").asText());
assertEquals(401, post(request("ping")).statusCode());
}
@Test void applicationContextShutdownClosesActiveProjectAndRuntime() throws Exception {
@@ -270,13 +278,13 @@ class HeadlessMcpDesktopTest {
}
@Test void fullHttpLoopMatchesRawRuntimePixelsAndDisplayedDevAcrossResetAndRebuild() throws Exception {
assertEquals(401, post(request("ping")).statusCode());
grant();
assertEquals(17, mapper.readTree(post(request("tools/list")).body()).path("result").path("tools").size());
assertTrue(value(call("studio_project_context", args())).path("languages").toString().contains("pbs"));
value(call("studio_reference_read", args().put("referenceId", "pbs:quickstart").put("limit", 100)));
var sdk = value(call("studio_reference_read", args().put("referenceId", "pbs:sdk:game:1:sdk/input/main.pbs").put("limit", 1000)));
assertTrue(sdk.toString().contains("InputPad"), "Consult installed SDK source through the indexed read-only reference");
assertEquals("NOT_GRANTED", call("studio_control_acquire", args()).path("structuredContent").path("error").path("code").asText());
fx(() -> ((Button) dev.rootNode().lookup("#dev-grant")).fire());
assertEquals(ControlState.WAITING_FOR_AGENT, project.automation().snapshot().state());
task = value(call("studio_control_acquire", args())).path("taskId").asText();
assertFalse(task.isBlank());
@@ -442,7 +450,7 @@ class HeadlessMcpDesktopTest {
}
HttpResponse<String> post(JsonNode body) throws Exception {
var request = HttpRequest.newBuilder(server.connection().endpoint()).timeout(Duration.ofSeconds(15))
.header("Authorization", server.connection().authorizationHeader()).header("Content-Type", "application/json")
.header("Authorization", authorization).header("Content-Type", "application/json")
.header("Accept", "application/json, text/event-stream").header("MCP-Protocol-Version", "2025-06-18");
if (connection != null) request.header("Mcp-Session-Id", connection);
return client.send(request.POST(HttpRequest.BodyPublishers.ofString(body.toString())).build(), HttpResponse.BodyHandlers.ofString());
@@ -32,6 +32,7 @@ import p.studio.compiler.services.FrontendDocumentLink;
import p.studio.compiler.services.FrontendFoldingRange;
import p.studio.compiler.services.FrontendSelectionRange;
import p.studio.compiler.services.FrontendDefinitionLocation;
import p.studio.compiler.services.FrontendSourceDocument;
import p.studio.compiler.services.FrontendDocumentRequest;
import p.studio.compiler.services.FrontendDocumentSymbol;
import p.studio.compiler.services.FrontendRenameEdit;
@@ -63,6 +64,38 @@ import java.util.Objects;
import java.util.Optional;
public final class PBSFrontendLanguageService implements FrontendLanguageService {
@Override
public boolean supportsExternalSources() { return true; }
@Override
public Optional<FrontendSourceDocument> sourceDocument(
final FrontendDocumentRequest request,
final FrontendEditorialContext context,
final Path path) {
if (!(context.projectSurface() instanceof PbsSemanticReadSurface surface)
|| !(context.sourceFiles() instanceof FileTableReader files)) return Optional.empty();
FrontendSourceDocument projectSource = null;
for (final var entry : surface.astByFile().entrySet()) {
final var handle = files.get(entry.getKey());
if (handle == null || !handle.getCanonPath().toAbsolutePath().normalize().equals(path.toAbsolutePath().normalize())) continue;
final var text = handle.readUtf8();
if (text.isEmpty()) return Optional.empty();
final boolean bundled = surface.sourceKindByFile().get(entry.getKey()) == SourceKind.SDK_INTERFACE;
final Path owner = surface.ownerRootByFile().get(entry.getKey());
final boolean external = bundled || owner == null || !owner.toAbsolutePath().normalize().equals(request.projectRoot().toAbsolutePath().normalize());
final var source = new FrontendSourceDocument(path, text.orElseThrow(),
bundled ? "bundled" : external ? "dependency" : "project",
handle.getRelativePath().toString(), "pbs", external,
new FrontendEditorialContext(entry.getValue(),
surface.supplementalTopDeclsByFile().getOrDefault(entry.getKey(), ReadOnlyList.empty()),
context.semanticContext(), files, surface));
// A dependency may physically overlap a project source root. External
// ownership wins even if another file-table entry treats it as local.
if (external) return Optional.of(source);
projectSource = source;
}
return Optional.ofNullable(projectSource);
}
private final PbsEditorialSupportService editorialSupportService;
private final PBSSemanticTokenProvider semanticTokenProvider;
@@ -257,7 +290,12 @@ public final class PBSFrontendLanguageService implements FrontendLanguageService
typedSupplementalTopDecls,
feSurfaceContext,
offset)) {
toFrontendLocation(location, fileTable).ifPresent(locations::add);
final var handle = fileTable.get(location.span().getFileId());
if (handle != null) {
sourceDocument(request, editorialContext, handle.getCanonPath()).ifPresent(source ->
locations.add(new FrontendDefinitionLocation(source.path(),
toOffset(location.span().getStart()), toOffset(location.span().getEnd()), source)));
}
}
return List.copyOf(locations);
}
@@ -401,14 +439,16 @@ public final class PBSFrontendLanguageService implements FrontendLanguageService
}
final LinkedHashMap<String, FrontendRenameEdit> edits = new LinkedHashMap<>();
for (final PbsEditorialLocation site : planned.sites()) {
toFrontendLocation(site, fileTable).ifPresent(location ->
edits.putIfAbsent(
final var mapped = toFrontendLocation(site, fileTable);
if (mapped.isEmpty()) return FrontendRenameResult.refused("rename requires a non-editable source");
final var location = mapped.orElseThrow();
edits.putIfAbsent(
frontendLocationKey(location),
new FrontendRenameEdit(
location.path(),
location.startOffset(),
location.endOffset(),
newName)));
newName));
}
if (edits.isEmpty()) {
return FrontendRenameResult.refused("not renameable");
@@ -19,6 +19,7 @@ public final class PbsParser {
private final PbsTokenCursor cursor;
private final PbsTopLevelParser topLevelParser;
private final PbsBlockParser blockParser;
private final PbsExprParser expressionParser;
private PbsParser(
final ReadOnlyList<PbsToken> tokens,
@@ -29,6 +30,7 @@ public final class PbsParser {
this.cursor = context.cursor();
final var exprParser = new PbsExprParser(context, this::parseExpressionSurfaceBlock);
this.expressionParser = exprParser;
final var attributeParser = new PbsAttributeParser(context, this::isTopLevelRestartToken);
final var typeParser = new PbsTypeParser(context);
@@ -64,6 +66,16 @@ public final class PbsParser {
return topLevelParser.parseFile();
}
/** Parses a complete expression fragment using the same grammar as a source file. */
public static PbsAst.Expression parseExpression(
final ReadOnlyList<PbsToken> tokens,
final FileId fileId,
final p.studio.compiler.source.diagnostics.DiagnosticSink diagnostics) {
final var parser = new PbsParser(tokens, fileId, diagnostics, ParseMode.ORDINARY);
final var expression = parser.expressionParser.parseExpression();
return parser.cursor.isAtEnd() && !diagnostics.hasErrors() ? expression : null;
}
private PbsAst.Block parseExpressionSurfaceBlock(final String message) {
return blockParser.parseBlock(message);
}
@@ -5,6 +5,7 @@ import p.studio.compiler.pbs.ast.PbsAst;
import p.studio.compiler.pbs.lexer.PbsLexer;
import p.studio.compiler.pbs.lexer.PbsToken;
import p.studio.compiler.pbs.lexer.PbsTokenKind;
import p.studio.compiler.pbs.parser.PbsParser;
import p.studio.compiler.source.Span;
import p.studio.compiler.source.diagnostics.DiagnosticSink;
import p.studio.compiler.source.identifiers.FileId;
@@ -1396,6 +1397,11 @@ public final class PbsEditorialSupportService {
private TypeView resolveReceiverTypeBeforeDot(
final int dotTokenIndex,
final ScopeState scopeState) {
final PbsAst.Expression receiver = receiverExpressionBefore(dotTokenIndex);
if (receiver != null) {
return analyzeExpressionType(receiver, scopeState.scope(), null,
scopeState.returnType(), scopeState.resultErrorName(), scopeState.receiverType());
}
final List<String> segments = resolveChainSegmentsEndingAt(dotTokenIndex - 1);
if (segments.isEmpty()) {
return TypeView.unknown();
@@ -1407,6 +1413,34 @@ public final class PbsEditorialSupportService {
return current;
}
private PbsAst.Expression receiverExpressionBefore(final int dotTokenIndex) {
// Locate only the fragment boundary here; grammar and overload selection
// remain in the existing PBS parser and flow expression analyzer.
int start = dotTokenIndex;
int depth = 0;
for (int index = dotTokenIndex - 1; index >= 0; index--) {
final var kind = token(index).kind();
if (kind == PbsTokenKind.COMMENT) { start = index; continue; }
if (kind == PbsTokenKind.RIGHT_PAREN) {
depth++;
} else if (kind == PbsTokenKind.LEFT_PAREN) {
if (depth == 0) break;
depth--;
} else if (depth == 0 && kind != PbsTokenKind.IDENTIFIER
&& kind != PbsTokenKind.DOT && kind != PbsTokenKind.THIS
&& kind != PbsTokenKind.NEW) {
break;
}
start = index;
}
if (start == dotTokenIndex || depth != 0) return null;
final var fragment = new ArrayList<PbsToken>();
for (int index = start; index < dotTokenIndex; index++) fragment.add(token(index));
final int end = token(dotTokenIndex).start();
fragment.add(new PbsToken(PbsTokenKind.EOF, "", end, end));
return PbsParser.parseExpression(ReadOnlyList.wrap(fragment), ast.span().getFileId(), DiagnosticSink.empty());
}
private TypeView resolveBaseChainType(
final String baseName,
final ScopeState scopeState) {
@@ -132,11 +132,16 @@ public class PBSFrontendPhaseService implements FrontendPhaseService {
final Map<FileId, ReadOnlyList<p.studio.compiler.pbs.ast.PbsAst.TopDecl>> supplementalTopDeclsByFile = new LinkedHashMap<>();
final Map<FileId, ReadOnlyList<PbsInlineHintSurface>> inlineHintsByFile = new LinkedHashMap<>();
final Map<FileId, SourceKind> sourceKindByFile = new LinkedHashMap<>();
final Map<FileId, Path> ownerRootByFile = new LinkedHashMap<>();
for (final var entry : importedSemanticContexts.entrySet()) {
supplementalTopDeclsByFile.put(entry.getKey(), entry.getValue().supplementalTopDecls());
}
for (final var parsedSourceFile : assembly.parsedSourceFiles()) {
astByFile.put(parsedSourceFile.fileId(), parsedSourceFile.ast());
final var sourceHandle = ctx.fileTable.get(parsedSourceFile.fileId());
if (sourceHandle != null && parsedSourceFile.sourceKind() != SourceKind.SDK_INTERFACE) {
ownerRootByFile.put(parsedSourceFile.fileId(), ctx.projectTable.get(sourceHandle.getProjectId()).getRootPath());
}
sourceKindByFile.put(
parsedSourceFile.fileId(),
parsedSourceFile.sourceKind() == null ? SourceKind.PROJECT : parsedSourceFile.sourceKind());
@@ -158,6 +163,7 @@ public class PBSFrontendPhaseService implements FrontendPhaseService {
Map.copyOf(supplementalTopDeclsByFile),
Map.copyOf(inlineHintsByFile),
Map.copyOf(sourceKindByFile),
Map.copyOf(ownerRootByFile),
physicalModuleFiles,
moduleCompletionLabels(ctx, physicalModuleFiles));
}
@@ -225,6 +231,7 @@ public class PBSFrontendPhaseService implements FrontendPhaseService {
Map<FileId, ReadOnlyList<p.studio.compiler.pbs.ast.PbsAst.TopDecl>> supplementalTopDeclsByFile,
Map<FileId, ReadOnlyList<PbsInlineHintSurface>> inlineHintsByFile,
Map<FileId, SourceKind> sourceKindByFile,
Map<FileId, Path> ownerRootByFile,
Map<ModuleReference, Path> physicalModuleFileByReference,
List<String> moduleCompletionLabels) {
}
@@ -16,6 +16,79 @@ import static org.junit.jupiter.api.Assertions.*;
final class PbsEditorialSupportServiceTest {
private final PbsEditorialSupportService service = new PbsEditorialSupportService();
@Test
void receiverMatrixHandlesNestedCallsVariablesParenthesesAndRecovery() {
final String declarations = """
declare struct Button() { fn down(value: int) -> bool { return true; } }
declare struct Pad() { fn left() -> Button { return new Button(); } }
fn pad(value: int) -> Pad { return new Pad(); }
fn number() -> int { return 1; }
""";
for (final String receiver : List.of("pad(number()).left()", "(pad(1).left())", "typed", "inferred")) {
for (final String suffix : List.of("down(1);", "down(", "")) {
final String source = declarations + """
fn main() -> void {
let typed: Button = new Button();
let inferred = pad(1).left();
""" + receiver + "." + suffix + "\n}\ndeclare ;";
final var ast = parseAllowingErrors(source);
final int member = source.lastIndexOf(receiver + ".") + receiver.length() + 1;
assertTrue(service.completion(source, ast, ReadOnlyList.empty(), member).stream()
.anyMatch(item -> item.label().equals("down")), receiver + "/" + suffix);
if (!suffix.isEmpty()) {
assertTrue(service.hover(source, ast, ReadOnlyList.empty(), member).isPresent(), receiver);
assertFalse(service.definition(source, ast, ReadOnlyList.empty(), member).isEmpty(), receiver);
assertTrue(service.signatureHelp(source, ast, ReadOnlyList.empty(), member + 5).isPresent(), receiver);
}
}
}
}
@Test
void ambiguousAndUnknownReceiverDoNotInventMembers() {
final String source = """
declare struct A() { fn onlyA() -> int { return 1; } }
declare struct B() { fn onlyB() -> int { return 2; } }
fn choose(value: int) -> A { return new A(); }
fn choose(value: int) -> B { return new B(); }
fn main() -> void { choose(1).onlyA(); missing().onlyA(); }
""";
final var ast = parseOrdinary(source);
for (final String receiver : List.of("choose(1).", "missing().")) {
final int offset = source.indexOf(receiver) + receiver.length();
assertTrue(service.hover(source, ast, ReadOnlyList.empty(), offset).isEmpty());
assertTrue(service.definition(source, ast, ReadOnlyList.empty(), offset).isEmpty());
assertTrue(service.completion(source, ast, ReadOnlyList.empty(), offset).isEmpty());
assertTrue(service.signatureHelp(source, ast, ReadOnlyList.empty(), offset + 6).isEmpty());
}
}
@Test
void chainedReceiversShareTypeResolutionAcrossEditorialQueries() {
final String source = """
import { Input } from @sdk:input;
fn main() -> void {
Input.pad().left().down();
}
""";
final var ast = parseOrdinary(source);
final var supplemental = supplementalTopDecls("""
declare host Input { fn pad() -> Pad; }
declare builtin type Pad(pub id: int) { fn left() -> Button; }
declare builtin type Button(pub id: int) { fn down() -> bool; }
""");
final int offset = source.indexOf("down");
assertAll(
() -> assertEquals("Button", service.hover(source, ast, supplemental, offset)
.orElseThrow().origin()),
() -> assertEquals(100, service.definition(source, ast, supplemental, offset)
.getFirst().span().getFileId().getId()),
() -> assertTrue(service.completion(source, ast, supplemental, offset).stream()
.anyMatch(candidate -> candidate.label().equals("down"))),
() -> assertEquals("down() -> bool", service.signatureHelp(source, ast, supplemental, offset + 5)
.orElseThrow().signatures().getFirst().label()));
}
@Test
void shouldResolveGeneralCompletionAndHoverAcrossLocalAndImportedSymbols() {
final var source = """
@@ -26,6 +26,7 @@ final class SourceCrawler extends SimpleFileVisitor<Path> {
private final ReadOnlySet<String> allowedExtensions;
private final List<Path> paths;
private Path traversalRoot;
public SourceCrawler(
final ReadOnlySet<String> allowedExtensions,
@@ -36,7 +37,12 @@ final class SourceCrawler extends SimpleFileVisitor<Path> {
@Override
public FileVisitResult preVisitDirectory(final Path path, final BasicFileAttributes attrs) {
for (final var directory : path) {
if (traversalRoot == null) {
// The caller already admitted this source root. Ignore only descendants,
// not ancestors such as .workspace containing an explicitly resolved library.
traversalRoot = path;
}
for (final var directory : traversalRoot.relativize(path)) {
if (!isAllowedPath(directory)) {
return FileVisitResult.SKIP_SUBTREE;
}
@@ -83,4 +89,4 @@ final class SourceCrawler extends SimpleFileVisitor<Path> {
return allowedExtensions.contains(extension);
}
}
}
@@ -0,0 +1,64 @@
package p.studio.compiler.workspaces.stages;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;
import p.studio.utilities.structures.ReadOnlySet;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Set;
import static org.junit.jupiter.api.Assertions.assertEquals;
class SourceCrawlerTest {
@TempDir Path project;
@Test
void resolvedWorkspaceLibraryEntersFileTable() throws Exception {
final Path library = Files.createDirectories(project.resolve(".workspace/repos/lib/src")).getParent();
Files.createDirectories(project.resolve("src"));
Files.writeString(project.resolve("prometeu.json"), """
{"name":"app","version":"1.0.0","language":"pbs","stdlib":"1","target":"Game",
"dependencies":[{"path":".workspace/repos/lib"}]}
""");
Files.writeString(library.resolve("prometeu.json"), """
{"name":"lib","version":"1.0.0","language":"pbs","stdlib":"1","target":"Game",
"dependencies":[]}
""");
Files.writeString(project.resolve(".workspace/repos/registry.json"), "{}");
final Path source = Files.writeString(library.resolve("src/main.pbs"), "fn value() -> int { return 1; }");
Files.writeString(library.resolve("src/mod.barrel"), "export { value };\n");
final var context = p.studio.compiler.models.BuilderPipelineContext.fromConfig(
new p.studio.compiler.messages.BuilderPipelineConfig(false, project.toString()));
final var logs = p.studio.utilities.logs.LogAggregator.empty();
org.junit.jupiter.api.Assertions.assertFalse(new ResolveDepsPipelineStage().run(context, logs).hasErrors());
org.junit.jupiter.api.Assertions.assertFalse(new LoadSourcesPipelineStage().run(context, logs).hasErrors());
final var loaded = new ArrayList<Path>();
for (int i = 0; i < context.fileTable.size(); i++) {
loaded.add(context.fileTable.get(new p.studio.compiler.source.identifiers.FileId(i)).getCanonPath());
}
org.junit.jupiter.api.Assertions.assertTrue(loaded.contains(source.toRealPath()), loaded.toString());
}
@Test
void explicitlyAdmittedDependencyRootInsideWorkspaceIsTraversed() throws Exception {
final Path sourceRoot = Files.createDirectories(project.resolve(".workspace/repos/lib/src"));
final Path source = Files.writeString(sourceRoot.resolve("main.pbs"), "fn value() -> int { return 1; }");
final Path incidental = Files.createDirectories(sourceRoot.resolve(".workspace/incidental"));
Files.writeString(incidental.resolve("hidden.pbs"), "fn hidden() -> int { return 2; }");
final var paths = new ArrayList<Path>();
Files.walkFileTree(sourceRoot, new SourceCrawler(ReadOnlySet.wrap(Set.of("pbs")), paths));
assertEquals(java.util.List.of(source), paths);
}
@Test
void ordinaryRootDoesNotCollectIncidentalWorkspaceSources() throws Exception {
final Path source = Files.writeString(project.resolve("main.pbs"), "fn value() -> int { return 1; }");
final Path hidden = Files.createDirectories(project.resolve(".workspace/repos/lib"));
Files.writeString(hidden.resolve("hidden.pbs"), "fn hidden() -> int { return 2; }");
final var paths = new ArrayList<Path>();
Files.walkFileTree(project, new SourceCrawler(ReadOnlySet.wrap(Set.of("pbs")), paths));
assertEquals(java.util.List.of(source), paths);
}
}
@@ -6,7 +6,12 @@ import java.util.Objects;
public record FrontendDefinitionLocation(
Path path,
int startOffset,
int endOffset) {
int endOffset,
FrontendSourceDocument source) {
public FrontendDefinitionLocation(Path path, int startOffset, int endOffset) {
this(path, startOffset, endOffset, null);
}
public FrontendDefinitionLocation {
path = Objects.requireNonNull(path, "path").toAbsolutePath().normalize();
@@ -16,5 +21,9 @@ public record FrontendDefinitionLocation(
if (endOffset < startOffset) {
throw new IllegalArgumentException("endOffset must not be before startOffset");
}
if (source != null && (!path.equals(source.path())
|| endOffset > source.text().getBytes(java.nio.charset.StandardCharsets.UTF_8).length)) {
throw new IllegalArgumentException("location must fit its source revision");
}
}
}
@@ -11,6 +11,13 @@ import java.util.Optional;
* Optional frontend-owned editor services.
*/
public interface FrontendLanguageService {
default boolean supportsExternalSources() { return false; }
default Optional<FrontendSourceDocument> sourceDocument(
FrontendDocumentRequest request, FrontendEditorialContext context, java.nio.file.Path path) {
return Optional.empty();
}
default Optional<FrontendEditorialContext> prepareEditorialContext(
final FrontendPhaseContext phaseContext) {
return Optional.empty();
@@ -0,0 +1,31 @@
package p.studio.compiler.services;
import java.nio.file.Path;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.HexFormat;
import java.util.Objects;
/** A compiler-known source and the semantic context for exactly that content. */
public record FrontendSourceDocument(
Path path, String text, String origin, String name, String languageId,
boolean readOnly, FrontendEditorialContext context) {
public FrontendSourceDocument {
path = Objects.requireNonNull(path).toAbsolutePath().normalize();
Objects.requireNonNull(text);
Objects.requireNonNull(origin);
Objects.requireNonNull(name);
Objects.requireNonNull(languageId);
Objects.requireNonNull(context);
}
public String revision() {
try {
return HexFormat.of().formatHex(MessageDigest.getInstance("SHA-256")
.digest(text.getBytes(StandardCharsets.UTF_8)));
} catch (NoSuchAlgorithmException impossible) {
throw new IllegalStateException(impossible);
}
}
}
@@ -0,0 +1,21 @@
package p.studio.compiler.services;
import org.junit.jupiter.api.Test;
import java.nio.charset.StandardCharsets;
import java.nio.file.Path;
import static org.junit.jupiter.api.Assertions.*;
class FrontendSourceDocumentTest {
@Test void locationCannotMixPathsOrExceedTheExactUtf8SourceRevision() {
final Path path = Path.of("/virtual/stdlib/sdk/main.pbs");
final String text = "// á 😀\r\nfn f() {}\r\n";
final var context = new FrontendEditorialContext(null, null, null);
final var source = new FrontendSourceDocument(path, text, "bundled", "sdk/main.pbs", "pbs", true, context);
final int bytes = text.getBytes(StandardCharsets.UTF_8).length;
assertDoesNotThrow(() -> new FrontendDefinitionLocation(path, 0, bytes, source));
assertThrows(IllegalArgumentException.class, () -> new FrontendDefinitionLocation(path, 0, bytes + 1, source));
assertThrows(IllegalArgumentException.class, () -> new FrontendDefinitionLocation(Path.of("/other.pbs"), 0, 1, source));
assertNotEquals(source.revision(), new FrontendSourceDocument(path, text.replace("\r\n", "\n"),
"bundled", "sdk/main.pbs", "pbs", true, context).revision());
}
}
@@ -20,6 +20,7 @@ public final class TcpLspServerHost {
private final LspServerConfiguration serverConfiguration;
private final LspProjectContext context;
private final CompilerLanguageServiceBridge compilerBridge;
private final p.studio.lsp.services.compiler.ExternalSourceRegistry externalSources = new p.studio.lsp.services.compiler.ExternalSourceRegistry();
private final ExecutorService clientExecutor;
private volatile boolean closed;
private volatile ServerSocket serverSocket;
@@ -72,8 +73,8 @@ public final class TcpLspServerHost {
}
private void handleClient(final Socket socket) {
final var server = new PrometeuLanguageServer(context, compilerBridge, externalSources);
try (socket) {
final var server = new PrometeuLanguageServer(context, compilerBridge);
final Launcher<LanguageClient> launcher = LSPLauncher.createServerLauncher(
server,
socket.getInputStream(),
@@ -82,7 +83,7 @@ public final class TcpLspServerHost {
launcher.startListening().get();
} catch (Exception exception) {
if (!closed && !socket.isClosed()) throw new IllegalStateException("LSP client failed", exception);
} finally { clients.remove(socket); }
} finally { server.disconnected(); clients.remove(socket); }
}
public synchronized java.util.Optional<p.studio.lsp.messages.LspServerEndpoint> endpoint() {
@@ -97,6 +98,7 @@ public final class TcpLspServerHost {
return;
}
closed = true;
externalSources.close();
if (serverSocket != null) {
serverSocket.close();
}
@@ -42,6 +42,79 @@ import java.util.*;
import java.util.function.Function;
public final class CompilerLanguageServiceBridge implements LanguageServiceBridge {
public boolean supportsExternalSources(final LspProjectContext context) {
return frontendProvider(context).languageService()
.map(p.studio.compiler.services.FrontendLanguageService::supportsExternalSources).orElse(false);
}
public Optional<p.studio.compiler.services.FrontendSourceDocument> currentSource(
final LspProjectContext context, final Path path) {
return editorialDocument(context, path.toUri().toString(), null).flatMap(document ->
frontendProvider(context).languageService().orElseThrow().sourceDocument(
new FrontendDocumentRequest(context.projectRoot(), path, document.text()),
document.editorialContext(), path));
}
public BaselineHover externalHover(final LspProjectContext context, final String uri,
final int line, final int character, final ExternalSourceRegistry registry, final String consumer) {
final var source = registry.source(consumer, uri);
return frontendProvider(context).languageService().orElseThrow().hover(
new FrontendDocumentRequest(context.projectRoot(), source.path(), source.text()), source.context(),
new DocumentPositionMapper(source.text()).byteOffsetOf(line, character))
.map(symbol -> new BaselineHover(formatHoverMarkdown(symbol)))
.orElseGet(() -> new BaselineHover("No symbol information."));
}
public BaselineSemanticTokens externalSemanticTokens(final LspProjectContext context, final String uri,
final ExternalSourceRegistry registry, final String consumer) {
final var source = registry.source(consumer, uri);
final var provider = frontendProvider(context);
final var tokens = provider.languageService().orElseThrow().semanticTokens(
new FrontendDocumentRequest(context.projectRoot(), source.path(), source.text()), source.context());
final var mapper = new DocumentPositionMapper(source.text());
final var mapped = new ArrayList<BaselineSemanticToken>();
for (var token : tokens) {
final var start = mapper.positionOf(token.startOffset());
final var end = mapper.positionOf(token.endOffset());
if (start.line() == end.line()) mapped.add(new BaselineSemanticToken(start.line(), start.character(),
Math.max(1, end.character() - start.character()), token.semanticKey()));
}
return new BaselineSemanticTokens(provider.specification().getSemanticPresentation().semanticKeys(), mapped);
}
public BaselineDefinition navigation(final LspProjectContext context, final String uri, final String text,
final int line, final int character, final ExternalSourceRegistry registry, final String consumer) {
final var service = frontendProvider(context).languageService().orElseThrow();
final EditorialDocument document;
final Path path;
if (uri.startsWith("prometeu-source:")) {
final var source = registry.source(consumer, uri);
document = new EditorialDocument(source.text(), source.context());
path = source.path();
} else {
final var result = editorialDocument(context, uri, text);
if (result.isEmpty()) return BaselineDefinition.empty();
document = result.orElseThrow();
path = normalizeDocumentPath(uri);
}
final var request = new FrontendDocumentRequest(context.projectRoot(), path, document.text());
final var locations = service.definition(request, document.editorialContext(),
new DocumentPositionMapper(document.text()).byteOffsetOf(line, character));
final var mapped = new ArrayList<BaselineDefinitionLocation>();
for (var location : locations) {
final var source = location.source();
if (source == null) {
mapped.addAll(mapDefinitionLocations(List.of(location), path, document.text()));
continue;
}
final String targetUri = source.readOnly() ? registry.register(consumer, source) : source.path().toUri().toString();
final var mapper = new DocumentPositionMapper(source.text());
final var start = mapper.positionOf(location.startOffset());
final var end = mapper.positionOf(location.endOffset());
mapped.add(new BaselineDefinitionLocation(targetUri, start.line(), start.character(), end.line(), end.character()));
}
return new BaselineDefinition(List.copyOf(mapped));
}
private final AssetSurfaceContextLoader assetSurfaceContextLoader = new AssetSurfaceContextLoader();
private final Function<String, FrontendProvider> frontendProviderResolver;
@@ -203,7 +276,7 @@ public final class CompilerLanguageServiceBridge implements LanguageServiceBridg
document.editorialContext(),
offset);
return new BaselineDefinition(mapDefinitionLocations(
locations,
locations.stream().filter(location -> location.source() == null || !location.source().readOnly()).toList(),
request.documentPath(),
document.text()));
})
@@ -1197,7 +1270,11 @@ public final class CompilerLanguageServiceBridge implements LanguageServiceBridg
}
final ArrayList<BaselineDefinitionLocation> mapped = new ArrayList<>();
for (final FrontendDefinitionLocation location : locations) {
final String targetText = textForDefinitionTarget(location.path(), currentDocumentPath, currentDocumentText);
// Legacy physical-only surfaces (references/symbols) do not inherit
// external-document coverage from the enriched definition DTO.
if (location.source() != null && !Files.isRegularFile(location.path())) continue;
final String targetText = location.source() != null ? location.source().text()
: textForDefinitionTarget(location.path(), currentDocumentPath, currentDocumentText);
if (targetText == null) {
continue;
}
@@ -0,0 +1,165 @@
package p.studio.lsp.services.compiler;
import p.studio.compiler.services.FrontendSourceDocument;
import java.nio.file.Path;
import java.util.*;
import java.util.function.Function;
/** Owned by one project host, never by the shared compiler bridge. */
public final class ExternalSourceRegistry implements AutoCloseable {
public record Descriptor(String uri, String revision, String origin, String name,
String languageId, boolean readOnly) {}
public record Content(Descriptor descriptor, String text) {}
private static final class Entry {
final Descriptor descriptor;
final Path path;
FrontendSourceDocument source;
final Set<String> readers = new HashSet<>();
Entry(Descriptor descriptor, FrontendSourceDocument source) {
this.descriptor = descriptor;
this.path = source.path();
this.source = source;
}
}
private static final class Consumer {
final boolean persistent;
final Set<String> grants = new HashSet<>();
final Set<String> retained = new HashSet<>();
final Set<String> validated = new HashSet<>();
boolean connected = true;
Consumer(boolean persistent) { this.persistent = persistent; }
}
private final String session = UUID.randomUUID().toString();
private final Map<String, Consumer> consumers = new HashMap<>();
private final Map<String, Entry> entries = new HashMap<>();
private boolean closed;
public synchronized String connect(String existing, boolean persistent) {
if (closed) throw unavailable();
if (existing != null && !existing.isBlank()) {
consumer(existing).connected = true;
return existing;
}
final String id = UUID.randomUUID().toString();
consumers.put(id, new Consumer(persistent));
return id;
}
public synchronized String register(String consumerId, FrontendSourceDocument source) {
final var consumer = activeConsumer(consumerId);
if (!source.readOnly()) throw new IllegalArgumentException("external source must be read-only");
Entry entry = entries.values().stream().filter(e -> sameSnapshot(e.source, source)).findFirst().orElse(null);
if (entry == null) {
// Only unreserved URI characters: VS Code and LSP URI serializers
// must not change the opaque identity by normalizing escaped slashes.
final String uri = "prometeu-source://" + session + "/" + UUID.randomUUID() + "/"
+ source.revision() + "/" + source.name().replaceAll("[^A-Za-z0-9._-]", "-");
entry = new Entry(new Descriptor(uri, source.revision(), source.origin(), source.name(), source.languageId(), true), source);
entries.put(uri, entry);
}
consumer.grants.add(entry.descriptor.uri());
consumer.validated.add(entry.descriptor.uri());
entry.readers.add(consumerId);
return entry.descriptor.uri();
}
private static boolean sameSnapshot(FrontendSourceDocument left, FrontendSourceDocument right) {
return left == right || left != null && left.path().equals(right.path())
&& left.context().projectSurface() != null
&& left.context().projectSurface() == right.context().projectSurface()
&& left.text().equals(right.text());
}
public synchronized FrontendSourceDocument source(String consumerId, String uri) {
final Entry entry = admitted(consumerId, uri);
if (entry.source == null || !entry.readers.contains(consumerId)
|| !activeConsumer(consumerId).validated.contains(uri)) throw unavailable();
return entry.source;
}
public synchronized Content read(String consumerId, String uri) {
final var source = source(consumerId, uri);
activeConsumer(consumerId).retained.add(uri);
return new Content(entries.get(uri).descriptor, source.text());
}
public synchronized Content retain(String consumerId, String uri) {
return read(consumerId, uri); // Navigation already grants a coalesced consumer use.
}
public synchronized void release(String consumerId, String uri) {
final Consumer consumer = activeConsumer(consumerId);
if (uri == null) {
for (String granted : List.copyOf(consumer.grants)) release(consumerId, granted);
consumers.remove(consumerId);
return;
}
if (!consumer.grants.remove(uri)) return;
consumer.retained.remove(uri);
consumer.validated.remove(uri);
final Entry entry = entries.get(uri);
if (entry != null) {
entry.readers.remove(consumerId);
if (entry.readers.isEmpty()) entry.source = null;
if (consumers.values().stream().noneMatch(c -> c.grants.contains(uri))) entries.remove(uri);
}
}
public synchronized void disconnect(String consumerId) {
final Consumer consumer = consumers.get(consumerId);
if (consumer == null) return;
consumer.connected = false;
consumer.validated.clear();
for (String uri : List.copyOf(consumer.grants)) {
final Entry entry = entries.get(uri);
if (consumer.persistent && consumer.retained.contains(uri)) continue;
if (!consumer.retained.contains(uri)) consumer.grants.remove(uri);
if (entry != null) {
entry.readers.remove(consumerId);
if (entry.readers.isEmpty()) entry.source = null;
if (consumers.values().stream().noneMatch(c -> c.grants.contains(uri))) entries.remove(uri);
}
}
}
public synchronized Content revalidate(String consumerId, String uri,
Function<Path, Optional<FrontendSourceDocument>> resolve) {
final Entry entry = admitted(consumerId, uri);
activeConsumer(consumerId).validated.remove(uri);
final var current = resolve.apply(entry.path).orElseThrow(ExternalSourceRegistry::unavailable);
if (!current.readOnly() || !current.revision().equals(entry.descriptor.revision())
|| !current.origin().equals(entry.descriptor.origin())) throw unavailable();
// Existing readers keep their original semantic snapshot. Otherwise bind a
// newly validated snapshot of identical content, never replacement text.
if (entry.source == null) entry.source = current;
entry.readers.add(consumerId);
activeConsumer(consumerId).validated.add(uri);
return read(consumerId, uri);
}
private Entry admitted(String consumerId, String uri) {
if (!activeConsumer(consumerId).grants.contains(uri)) throw unavailable();
final Entry entry = entries.get(uri);
if (entry == null) throw unavailable();
return entry;
}
private Consumer consumer(String id) {
final Consumer result = consumers.get(id);
if (closed || result == null) throw unavailable();
return result;
}
private Consumer activeConsumer(String id) {
final Consumer result = consumer(id);
if (!result.connected) throw unavailable();
return result;
}
public static IllegalStateException unavailable() {
return new IllegalStateException("External source unavailable; navigate again after reconnecting.");
}
@Override public synchronized void close() {
closed = true;
entries.clear();
consumers.clear();
}
}
@@ -0,0 +1,14 @@
package p.studio.lsp.services.protocol;
import org.eclipse.lsp4j.jsonrpc.services.JsonRequest;
import org.eclipse.lsp4j.services.LanguageServer;
import p.studio.lsp.services.compiler.ExternalSourceRegistry.Content;
import java.util.concurrent.CompletableFuture;
public interface ExternalSourceLanguageServer extends LanguageServer {
record Request(String consumerId, String uri) {}
@JsonRequest("prometeu/readExternalSource") CompletableFuture<Content> readExternalSource(Request request);
@JsonRequest("prometeu/retainExternalSource") CompletableFuture<Content> retainExternalSource(Request request);
@JsonRequest("prometeu/releaseExternalSource") CompletableFuture<Void> releaseExternalSource(Request request);
@JsonRequest("prometeu/revalidateExternalSource") CompletableFuture<Content> revalidateExternalSource(Request request);
}
@@ -13,7 +13,9 @@ import p.studio.lsp.services.protocol.mapping.ProtocolMessageMapper;
import java.util.Objects;
import java.util.concurrent.CompletableFuture;
public final class PrometeuLanguageServer implements LanguageServer, LanguageClientAware {
public final class PrometeuLanguageServer implements ExternalSourceLanguageServer, LanguageClientAware {
private p.studio.lsp.services.compiler.ExternalSourceRegistry externalSources;
private String consumerId;
private final LspProjectContext project;
private final LanguageServiceBridge languageServiceBridge;
private final ProtocolMessageMapper protocolMessageMapper;
@@ -32,6 +34,47 @@ public final class PrometeuLanguageServer implements LanguageServer, LanguageCli
null);
}
public PrometeuLanguageServer(final LspProjectContext project,
final CompilerLanguageServiceBridge bridge,
final p.studio.lsp.services.compiler.ExternalSourceRegistry registry) {
this(project, bridge);
this.externalSources = registry;
}
public void disconnected() {
if (externalSources != null && consumerId != null) externalSources.disconnect(consumerId);
}
private void requireConsumer(Request request) {
if (consumerId == null || request == null || !consumerId.equals(request.consumerId()))
throw p.studio.lsp.services.compiler.ExternalSourceRegistry.unavailable();
}
private <T> CompletableFuture<T> external(Request request, java.util.function.Supplier<T> operation) {
try {
requireConsumer(request);
return CompletableFuture.completedFuture(operation.get());
} catch (RuntimeException failure) {
return CompletableFuture.failedFuture(new org.eclipse.lsp4j.jsonrpc.ResponseErrorException(
new org.eclipse.lsp4j.jsonrpc.messages.ResponseError(
org.eclipse.lsp4j.jsonrpc.messages.ResponseErrorCode.InvalidRequest,
failure.getMessage(), null)));
}
}
@Override public CompletableFuture<p.studio.lsp.services.compiler.ExternalSourceRegistry.Content> readExternalSource(Request request) {
return external(request, () -> externalSources.read(consumerId, request.uri()));
}
@Override public CompletableFuture<p.studio.lsp.services.compiler.ExternalSourceRegistry.Content> retainExternalSource(Request request) {
return external(request, () -> externalSources.retain(consumerId, request.uri()));
}
@Override public CompletableFuture<Void> releaseExternalSource(Request request) {
return external(request, () -> { externalSources.release(consumerId, request.uri()); return null; });
}
@Override public CompletableFuture<p.studio.lsp.services.compiler.ExternalSourceRegistry.Content> revalidateExternalSource(Request request) {
return external(request, () -> externalSources.revalidate(consumerId, request.uri(),
path -> ((CompilerLanguageServiceBridge) languageServiceBridge).currentSource(project, path)));
}
PrometeuLanguageServer(
final LspProjectContext project,
final LanguageServiceBridge languageServiceBridge,
@@ -69,8 +112,25 @@ public final class PrometeuLanguageServer implements LanguageServer, LanguageCli
}
return CompletableFuture.failedFuture(runtimeException);
}
return CompletableFuture.completedFuture(protocolMessageMapper
.mapInitializeResult(languageServiceBridge.describeServer(project)));
final var result = protocolMessageMapper.mapInitializeResult(languageServiceBridge.describeServer(project));
final var gson = new com.google.gson.Gson();
final var capability = gson.toJsonTree(params.getCapabilities() == null ? null : params.getCapabilities().getExperimental());
if (externalSources != null && languageServiceBridge instanceof CompilerLanguageServiceBridge bridge
&& bridge.supportsExternalSources(project) && capability.isJsonObject()
&& capability.getAsJsonObject().has("prometeuExternalSources")
&& capability.getAsJsonObject().get("prometeuExternalSources").getAsBoolean()) {
final var rawOptions = gson.toJsonTree(params.getInitializationOptions());
final var options = rawOptions.isJsonObject() ? rawOptions.getAsJsonObject() : new com.google.gson.JsonObject();
final String previous = options.has("prometeuExternalConsumerId") ? options.get("prometeuExternalConsumerId").getAsString() : null;
final boolean persistent = options.has("prometeuExternalPersistentConsumer") && options.get("prometeuExternalPersistentConsumer").getAsBoolean();
consumerId = externalSources.connect(previous, persistent);
final var experimental = gson.toJsonTree(result.getCapabilities().getExperimental()).getAsJsonObject();
experimental.addProperty("prometeuExternalSources", true);
experimental.addProperty("prometeuExternalConsumerId", consumerId);
result.getCapabilities().setExperimental(experimental);
((PrometeuTextDocumentService) textDocumentService).externalSources(externalSources, consumerId);
}
return CompletableFuture.completedFuture(result);
}
@Override
@@ -29,6 +29,43 @@ public final class PrometeuTextDocumentService implements TextDocumentService {
private final ProtocolMessageMapper protocolMessageMapper;
private final ConcurrentMap<String, String> documentTextByUri = new ConcurrentHashMap<>();
private volatile LanguageClient client;
private p.studio.lsp.services.compiler.ExternalSourceRegistry externalSources;
private String externalConsumer;
void externalSources(p.studio.lsp.services.compiler.ExternalSourceRegistry registry, String consumer) {
externalSources = registry;
externalConsumer = consumer;
}
private static boolean external(String uri) { return uri.startsWith("prometeu-source:"); }
private p.studio.lsp.services.compiler.CompilerLanguageServiceBridge compiler() {
return (p.studio.lsp.services.compiler.CompilerLanguageServiceBridge) languageServiceBridge;
}
private static ResponseErrorException refused(String message) {
return new ResponseErrorException(new ResponseError(ResponseErrorCode.InvalidRequest, message, null));
}
private void requireExternal(String uri) {
if (externalSources == null || externalConsumer == null) throw refused("External source support was not negotiated.");
try { externalSources.source(externalConsumer, uri); }
catch (IllegalStateException unavailable) { throw refused(unavailable.getMessage()); }
}
private void requireEditable(String uri) {
if (external(uri)) throw readOnly();
if (languageServiceBridge instanceof p.studio.lsp.services.compiler.CompilerLanguageServiceBridge bridge) {
final var source = bridge.currentSource(project, java.nio.file.Path.of(java.net.URI.create(uri)));
if (source.isEmpty() || source.orElseThrow().readOnly()) throw readOnly();
}
}
private static ResponseErrorException readOnly() {
return new ResponseErrorException(new ResponseError(-32010, "Source is not an editable project document.", null));
}
private void validateEdit(WorkspaceEdit edit) {
if (edit == null) return;
if (edit.getChanges() != null) edit.getChanges().keySet().forEach(this::requireEditable);
if (edit.getDocumentChanges() != null) for (var change : edit.getDocumentChanges()) {
if (!change.isLeft()) throw refused("File operations are not supported.");
requireEditable(change.getLeft().getTextDocument().getUri());
}
}
public PrometeuTextDocumentService(
final LspProjectContext project,
@@ -46,7 +83,12 @@ public final class PrometeuTextDocumentService implements TextDocumentService {
@Override
public void didOpen(final DidOpenTextDocumentParams params) {
final String uri = params.getTextDocument().getUri();
final String text = params.getTextDocument().getText();
if (external(uri)) { requireExternal(uri); externalSources.retain(externalConsumer, uri); return; }
String text = params.getTextDocument().getText();
if (languageServiceBridge instanceof p.studio.lsp.services.compiler.CompilerLanguageServiceBridge bridge) {
final var known = bridge.currentSource(project, java.nio.file.Path.of(java.net.URI.create(uri)));
if (known.isPresent() && known.orElseThrow().readOnly()) text = known.orElseThrow().text();
}
documentTextByUri.put(uri, text);
publishAnalysis(uri, text);
}
@@ -54,6 +96,7 @@ public final class PrometeuTextDocumentService implements TextDocumentService {
@Override
public void didChange(final DidChangeTextDocumentParams params) {
final String uri = params.getTextDocument().getUri();
requireEditable(uri);
final String text = params.getContentChanges().isEmpty()
? ""
: params.getContentChanges().getFirst().getText();
@@ -63,6 +106,9 @@ public final class PrometeuTextDocumentService implements TextDocumentService {
@Override
public void didClose(final DidCloseTextDocumentParams params) {
if (external(params.getTextDocument().getUri())) {
if (externalSources != null) externalSources.release(externalConsumer, params.getTextDocument().getUri()); return;
}
documentTextByUri.remove(params.getTextDocument().getUri());
final LanguageClient currentClient = client;
if (currentClient == null) {
@@ -73,6 +119,7 @@ public final class PrometeuTextDocumentService implements TextDocumentService {
@Override
public void didSave(final DidSaveTextDocumentParams params) {
requireEditable(params.getTextDocument().getUri());
final LanguageClient currentClient = client;
if (currentClient == null) {
return;
@@ -84,6 +131,7 @@ public final class PrometeuTextDocumentService implements TextDocumentService {
@Override
public CompletableFuture<Either<List<CompletionItem>, CompletionList>> completion(final CompletionParams params) {
final String uri = params.getTextDocument().getUri();
if (external(uri)) return CompletableFuture.completedFuture(Either.forLeft(List.of()));
final String text = documentTextByUri.get(uri);
return CompletableFuture.completedFuture(Either.forRight(protocolMessageMapper.mapCompletion(
languageServiceBridge.completion(
@@ -97,6 +145,9 @@ public final class PrometeuTextDocumentService implements TextDocumentService {
@Override
public CompletableFuture<Hover> hover(final HoverParams params) {
final String uri = params.getTextDocument().getUri();
if (external(uri)) requireExternal(uri);
if (external(uri)) return CompletableFuture.completedFuture(protocolMessageMapper.mapHover(
compiler().externalHover(project, uri, params.getPosition().getLine(), params.getPosition().getCharacter(), externalSources, externalConsumer)));
final String text = documentTextByUri.get(uri);
return CompletableFuture.completedFuture(protocolMessageMapper.mapHover(languageServiceBridge.hover(
project,
@@ -110,6 +161,9 @@ public final class PrometeuTextDocumentService implements TextDocumentService {
public CompletableFuture<Either<List<? extends Location>, List<? extends LocationLink>>> definition(
final DefinitionParams params) {
final String uri = params.getTextDocument().getUri();
if (external(uri)) requireExternal(uri);
if (externalSources != null) return CompletableFuture.completedFuture(Either.forLeft(protocolMessageMapper.mapDefinition(
compiler().navigation(project, uri, documentTextByUri.get(uri), params.getPosition().getLine(), params.getPosition().getCharacter(), externalSources, externalConsumer))));
final String text = documentTextByUri.get(uri);
final List<Location> locations = protocolMessageMapper.mapDefinition(languageServiceBridge.definition(
project,
@@ -123,6 +177,7 @@ public final class PrometeuTextDocumentService implements TextDocumentService {
@Override
public CompletableFuture<List<? extends Location>> references(final ReferenceParams params) {
final String uri = params.getTextDocument().getUri();
if (external(uri)) return CompletableFuture.completedFuture(List.of());
final String text = documentTextByUri.get(uri);
final boolean includeDeclaration = params.getContext() != null
&& Boolean.TRUE.equals(params.getContext().isIncludeDeclaration());
@@ -140,6 +195,7 @@ public final class PrometeuTextDocumentService implements TextDocumentService {
public CompletableFuture<Either3<Range, PrepareRenameResult, PrepareRenameDefaultBehavior>> prepareRename(
final PrepareRenameParams params) {
final String uri = params.getTextDocument().getUri();
requireEditable(uri);
final String text = documentTextByUri.get(uri);
return CompletableFuture.completedFuture(protocolMessageMapper.mapPrepareRename(
languageServiceBridge.prepareRename(
@@ -153,6 +209,7 @@ public final class PrometeuTextDocumentService implements TextDocumentService {
@Override
public CompletableFuture<WorkspaceEdit> rename(final RenameParams params) {
final String uri = params.getTextDocument().getUri();
requireEditable(uri);
final String text = documentTextByUri.get(uri);
final var result = languageServiceBridge.rename(
project,
@@ -168,12 +225,15 @@ public final class PrometeuTextDocumentService implements TextDocumentService {
null);
return CompletableFuture.failedFuture(new ResponseErrorException(error));
}
return CompletableFuture.completedFuture(protocolMessageMapper.mapRename(result));
final var edit = protocolMessageMapper.mapRename(result);
validateEdit(edit);
return CompletableFuture.completedFuture(edit);
}
@Override
public CompletableFuture<List<CallHierarchyItem>> prepareCallHierarchy(final CallHierarchyPrepareParams params) {
final String uri = params.getTextDocument().getUri();
if (external(uri)) return CompletableFuture.completedFuture(List.of());
final String text = documentTextByUri.get(uri);
return CompletableFuture.completedFuture(protocolMessageMapper.mapCallHierarchyItems(
languageServiceBridge.prepareCallHierarchy(
@@ -199,7 +259,7 @@ public final class PrometeuTextDocumentService implements TextDocumentService {
}
private List<BaselineCallSite> directedCallSites(final CallHierarchyItem item, final boolean incoming) {
if (item == null || item.getUri() == null || item.getSelectionRange() == null) {
if (item == null || item.getUri() == null || external(item.getUri()) || item.getSelectionRange() == null) {
return List.of();
}
final String text = documentTextByUri.get(item.getUri());
@@ -219,6 +279,7 @@ public final class PrometeuTextDocumentService implements TextDocumentService {
@Override
public CompletableFuture<List<? extends TextEdit>> formatting(final DocumentFormattingParams params) {
final String uri = params.getTextDocument().getUri();
requireEditable(uri);
final String text = documentTextByUri.get(uri);
return CompletableFuture.completedFuture(protocolMessageMapper.mapFormatting(
languageServiceBridge.formatDocument(project, uri, text)));
@@ -227,6 +288,7 @@ public final class PrometeuTextDocumentService implements TextDocumentService {
@Override
public CompletableFuture<List<FoldingRange>> foldingRange(final FoldingRangeRequestParams params) {
final String uri = params.getTextDocument().getUri();
if (external(uri)) return CompletableFuture.completedFuture(List.of());
final String text = documentTextByUri.get(uri);
return CompletableFuture.completedFuture(protocolMessageMapper.mapFoldingRanges(
languageServiceBridge.foldingRanges(project, uri, text)));
@@ -235,6 +297,7 @@ public final class PrometeuTextDocumentService implements TextDocumentService {
@Override
public CompletableFuture<List<SelectionRange>> selectionRange(final SelectionRangeParams params) {
final String uri = params.getTextDocument().getUri();
if (external(uri)) return CompletableFuture.completedFuture(List.of());
final String text = documentTextByUri.get(uri);
final ArrayList<DocumentPosition> positions = new ArrayList<>();
if (params.getPositions() != null) {
@@ -252,6 +315,7 @@ public final class PrometeuTextDocumentService implements TextDocumentService {
@Override
public CompletableFuture<List<DocumentLink>> documentLink(final DocumentLinkParams params) {
final String uri = params.getTextDocument().getUri();
if (external(uri)) return CompletableFuture.completedFuture(List.of());
final String text = documentTextByUri.get(uri);
return CompletableFuture.completedFuture(protocolMessageMapper.mapDocumentLinks(
languageServiceBridge.documentLinks(project, uri, text)));
@@ -259,6 +323,7 @@ public final class PrometeuTextDocumentService implements TextDocumentService {
@Override
public CompletableFuture<List<Either<Command, CodeAction>>> codeAction(final CodeActionParams params) {
requireEditable(params.getTextDocument().getUri());
if (!quickFixRequested(params.getContext())) {
return CompletableFuture.completedFuture(List.of());
}
@@ -268,15 +333,21 @@ public final class PrometeuTextDocumentService implements TextDocumentService {
|| params.getContext().getDiagnostics() == null
? List.of()
: params.getContext().getDiagnostics();
return CompletableFuture.completedFuture(protocolMessageMapper.mapCodeActions(
final var actions = protocolMessageMapper.mapCodeActions(
languageServiceBridge.codeActions(project, uri, text, baselineDiagnostics(contextDiagnostics)),
contextDiagnostics));
contextDiagnostics);
for (var action : actions) {
if (action.isLeft()) throw refused("Executable actions are not supported.");
validateEdit(action.getRight().getEdit());
}
return CompletableFuture.completedFuture(actions);
}
@Override
public CompletableFuture<List<Either<SymbolInformation, DocumentSymbol>>> documentSymbol(
final DocumentSymbolParams params) {
final String uri = params.getTextDocument().getUri();
if (external(uri)) return CompletableFuture.completedFuture(List.of());
final String text = documentTextByUri.get(uri);
final List<Either<SymbolInformation, DocumentSymbol>> symbols = new ArrayList<>();
for (final DocumentSymbol symbol : protocolMessageMapper.mapDocumentSymbols(
@@ -289,6 +360,7 @@ public final class PrometeuTextDocumentService implements TextDocumentService {
@Override
public CompletableFuture<SignatureHelp> signatureHelp(final SignatureHelpParams params) {
final String uri = params.getTextDocument().getUri();
if (external(uri)) return CompletableFuture.completedFuture(null);
final String text = documentTextByUri.get(uri);
return CompletableFuture.completedFuture(protocolMessageMapper.mapSignatureHelp(
languageServiceBridge.signatureHelp(
@@ -302,6 +374,9 @@ public final class PrometeuTextDocumentService implements TextDocumentService {
@Override
public CompletableFuture<SemanticTokens> semanticTokensFull(final SemanticTokensParams params) {
final String uri = params.getTextDocument().getUri();
if (external(uri)) requireExternal(uri);
if (external(uri)) return CompletableFuture.completedFuture(protocolMessageMapper.mapSemanticTokens(
compiler().externalSemanticTokens(project, uri, externalSources, externalConsumer)));
final String text = documentTextByUri.getOrDefault(uri, "");
return CompletableFuture.completedFuture(protocolMessageMapper.mapSemanticTokens(
languageServiceBridge.semanticTokens(project, uri, text)));
@@ -0,0 +1,63 @@
package p.studio.lsp.services;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable;
import org.junit.jupiter.api.io.TempDir;
import p.studio.lsp.messages.*;
import p.studio.lsp.services.compiler.CompilerLanguageServiceBridge;
import java.nio.file.*;
import java.util.concurrent.TimeUnit;
import static org.junit.jupiter.api.Assertions.*;
/** Opt-in actual VS Code test against the development classpath (never installDist). */
@EnabledIfEnvironmentVariable(named = "PROMETEU_VSCODE_DEV_TEST", matches = "1")
class ExternalSourceDevelopmentHostTest {
@TempDir Path temporary;
@Test void realEditorReadsBundledSourceWithoutMaterializingIt() throws Exception {
Path repository = Path.of("").toAbsolutePath();
while (!Files.isDirectory(repository.resolve("tools/vscode-extension"))) repository = repository.getParent();
final Path root = Files.createDirectories(temporary.resolve("project")).toRealPath();
Files.createDirectories(root.resolve("src"));
Files.createDirectories(root.resolve(".vscode"));
Files.writeString(root.resolve("prometeu.json"), """
{"name":"app","version":"1.0.0","language":"pbs","stdlib":"1","target":"Game","dependencies":[{"path":".workspace/repos/lib"}]}
""");
Files.writeString(root.resolve("src/main.pbs"), "import { Gfx } from @sdk:gfx;\nimport { answer } from @lib:shared;\nfn main() -> void { Gfx.clear(0); answer(); }\n");
Files.writeString(root.resolve("src/mod.barrel"), "pub fn main() -> void;\n");
final Path library = Files.createDirectories(root.resolve(".workspace/repos/lib/src")).getParent();
Files.createDirectories(library.resolve("src/shared"));
Files.writeString(library.resolve("prometeu.json"), """
{"name":"lib","version":"1.0.0","language":"pbs","stdlib":"1","target":"Game","dependencies":[]}
""");
Files.writeString(root.resolve(".workspace/repos/registry.json"), "{}");
final String libraryText = "// á 😀\r\nfn answer() -> int { return helper(); }\r\nfn helper() -> int { return 42; }\r\n";
Files.writeString(library.resolve("src/shared/main.pbs"), libraryText);
Files.writeString(library.resolve("src/shared/mod.barrel"), "pub fn answer() -> int;\n");
final var host = new TcpLspServerHost(LspServerConfiguration.builder()
.endpoint(new LspServerEndpoint("127.0.0.1", 0)).build(), new LspProjectContext("dev", "pbs", root),
new CompilerLanguageServiceBridge());
host.start();
try {
Files.writeString(root.resolve(".vscode/settings.json"), "{\"prometeu.studio.port\":" + host.endpoint().orElseThrow().port() + "}");
final String executable = System.getenv().getOrDefault("PROMETEU_VSCODE_EXECUTABLE", "/Applications/Visual Studio Code.app/Contents/MacOS/Code");
final Path extension = repository.resolve("tools/vscode-extension");
final var builder = new ProcessBuilder(executable, "--no-sandbox", "--disable-extensions", "--disable-workspace-trust",
"--skip-welcome", "--skip-release-notes", "--user-data-dir=" + temporary.resolve("vscode-user"),
"--extensions-dir=" + temporary.resolve("vscode-extensions"), "--extensionDevelopmentPath=" + extension,
"--extensionTestsPath=" + extension.resolve("out/test/externalSources.js"), root.toString());
builder.environment().remove("ELECTRON_RUN_AS_NODE");
final Path log = Path.of("/tmp/pln141-vscode-development.log");
final var process = builder.redirectErrorStream(true).redirectOutput(log.toFile()).start();
try {
assertTrue(process.waitFor(90, TimeUnit.SECONDS), "VS Code test timed out: " + log);
assertEquals(0, process.exitValue(), () -> read(log));
} finally { process.destroyForcibly(); }
assertEquals(libraryText, Files.readString(library.resolve("src/shared/main.pbs")));
try (var directories = Files.list(root.resolve(".workspace"))) {
assertEquals(java.util.List.of("repos"), directories.map(p -> p.getFileName().toString()).toList(), "No editorial SDK cache");
}
} finally { host.close(); }
}
private static String read(Path path) { try { return Files.readString(path); } catch (Exception e) { return e.toString(); } }
}
@@ -28,6 +28,82 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
class CompilerLanguageServiceBridgeTest {
@Test
void retainedDependencyUsesOriginalSemanticSnapshotAfterDiskChanges(@TempDir Path temporary) throws Exception {
final Path root = temporary.toRealPath();
final Path library = Files.createDirectories(root.resolve(".workspace/repos/lib/src")).getParent();
Files.createDirectories(root.resolve("src"));
Files.writeString(root.resolve("prometeu.json"), """
{"name":"app","version":"1.0.0","language":"pbs","stdlib":"1","target":"Game",
"dependencies":[{"path":".workspace/repos/lib"}]}
""");
Files.createDirectories(library.resolve("src/shared"));
Files.writeString(library.resolve("prometeu.json"), """
{"name":"lib","version":"1.0.0","language":"pbs","stdlib":"1","target":"Game","dependencies":[]}
""");
Files.writeString(root.resolve(".workspace/repos/registry.json"), "{}");
final String projectText = "import { answer } from @lib:shared;\nfn main() -> int { return answer(); }\n";
final Path projectFile = Files.writeString(root.resolve("src/main.pbs"), projectText);
final String old = "// á 😀\r\nfn answer() -> int { return original(); }\r\nfn original() -> int { return 1; }\r\n";
final Path libraryFile = Files.writeString(library.resolve("src/shared/main.pbs"), old);
Files.writeString(library.resolve("src/shared/mod.barrel"), "pub fn answer() -> int;\n");
final var bridge = new CompilerLanguageServiceBridge();
final var context = new LspProjectContext("snapshot", "pbs", root);
try (var registry = new ExternalSourceRegistry()) {
final String consumer = registry.connect(null, false);
final String uri = bridge.navigation(context, projectFile.toUri().toString(), projectText, 1, 26, registry, consumer)
.locations().getFirst().uri();
final var retained = registry.source(consumer, uri);
assertEquals(old, registry.read(consumer, uri).text());
Files.writeString(libraryFile, "// different revision\n" + old.replace("original", "replacement"));
final var target = bridge.navigation(context, uri, null, 1, 28, registry, consumer).locations().getFirst();
assertEquals(2, target.startLine());
assertEquals(old, registry.read(consumer, target.uri()).text());
assertTrue(bridge.externalHover(context, uri, 1, 28, registry, consumer).markdown().contains("original"));
assertTrue(retained.context() == registry.source(consumer, uri).context());
registry.disconnect(consumer);
registry.connect(consumer, false);
org.junit.jupiter.api.Assertions.assertThrows(IllegalStateException.class,
() -> registry.revalidate(consumer, uri, path -> bridge.currentSource(context, path)));
org.junit.jupiter.api.Assertions.assertThrows(IllegalStateException.class, () -> registry.source(consumer, uri));
}
}
@Test
void externalNavigationRetainsBundledTextAndContinuesIntoHostDeclarations() {
final Path root = findRepoRoot(Path.of("").toAbsolutePath()).resolve("test-projects/main");
final var context = new LspProjectContext("main", "pbs", root);
final var bridge = new CompilerLanguageServiceBridge();
final String source = "import { Gfx } from @sdk:gfx;\nfn frame() -> void { Gfx.clear(0); }\n";
final var position = new DocumentPositionMapper(source).positionOf(source.indexOf("clear"));
try (var registry = new ExternalSourceRegistry()) {
final String consumer = registry.connect(null, false);
final var locations = bridge.navigation(context, root.resolve("src/main.pbs").toUri().toString(), source,
position.line(), position.character(), registry, consumer).locations();
assertEquals(1, locations.size());
final String uri = locations.getFirst().uri();
assertTrue(uri.startsWith("prometeu-source:"));
final var content = registry.read(consumer, uri);
assertEquals("bundled", content.descriptor().origin());
assertTrue(content.descriptor().readOnly());
assertTrue(content.text().contains("LowGfx.clear"));
final int call = content.text().indexOf("LowGfx.clear") + "LowGfx.".length();
final var hostUse = new DocumentPositionMapper(content.text()).positionOf(call);
assertTrue(bridge.externalHover(context, uri, hostUse.line(), hostUse.character(), registry, consumer)
.markdown().contains("clear"));
final var host = bridge.navigation(context, uri, null, hostUse.line(), hostUse.character(), registry, consumer)
.locations().getFirst();
final var hostContent = registry.read(consumer, host.uri());
final String[] lines = hostContent.text().split("\n");
assertTrue(lines[host.startLine()].contains("clear"), lines[host.startLine()]);
assertFalse(bridge.externalSemanticTokens(context, uri, registry, consumer).tokens().isEmpty());
final var colorUse = new DocumentPositionMapper(content.text()).positionOf(content.text().indexOf("color: Color") + 7);
final String coreUri = bridge.navigation(context, uri, null, colorUse.line(), colorUse.character(), registry, consumer)
.locations().getFirst().uri();
assertTrue(registry.read(consumer, coreUri).descriptor().name().replace('\\', '/').contains("core/color"));
}
}
@Test
void editorialEndpointsReturnNeutralResponsesWhenLanguageServiceIsAbsent() {
final var provider = new CompileOnlyFrontendProvider();
@@ -0,0 +1,77 @@
package p.studio.lsp.services.compiler;
import org.junit.jupiter.api.Test;
import p.studio.compiler.services.FrontendEditorialContext;
import p.studio.compiler.services.FrontendSourceDocument;
import java.nio.file.Path;
import java.util.Optional;
import static org.junit.jupiter.api.Assertions.*;
class ExternalSourceRegistryTest {
private FrontendSourceDocument source(String text) {
return new FrontendSourceDocument(Path.of("/virtual/stdlib/sdk/main.pbs"), text, "bundled", "sdk/main.pbs", "pbs", true,
new FrontendEditorialContext(new Object(), null, new Object()));
}
@Test void readersShareRevisionWithoutSharingReleaseAndUnknownIdentitiesAreRejected() {
try (var registry = new ExternalSourceRegistry(); var otherProject = new ExternalSourceRegistry()) {
final var source = source("// á 😀\r\nfn f() {}\r\n");
final String one = registry.connect(null, false), two = registry.connect(null, false);
final String uri = registry.register(one, source);
assertEquals(uri, registry.register(two, source));
registry.retain(one, uri);
registry.release(one, uri);
assertThrows(IllegalStateException.class, () -> registry.read(one, uri));
assertSame(source.context(), registry.source(two, uri).context());
assertEquals(source.text(), registry.read(two, uri).text());
assertThrows(IllegalStateException.class, () -> otherProject.read(otherProject.connect(null, false), uri));
assertThrows(IllegalStateException.class, () -> registry.read(two, "file:///etc/passwd"));
registry.release(two, uri);
assertThrows(IllegalStateException.class, () -> registry.read(two, uri));
}
}
@Test void disconnectedDocumentsRequireRevalidationAndChangedRevisionCannotReplaceText() {
try (var registry = new ExternalSourceRegistry()) {
final String consumer = registry.connect(null, false);
final var old = source("old");
final String uri = registry.register(consumer, old);
registry.retain(consumer, uri);
registry.disconnect(consumer);
assertThrows(IllegalStateException.class, () -> registry.read(consumer, uri));
registry.connect(consumer, false);
assertThrows(IllegalStateException.class, () -> registry.read(consumer, uri));
assertThrows(IllegalStateException.class, () -> registry.revalidate(consumer, uri, p -> Optional.of(source("new"))));
assertEquals("old", registry.revalidate(consumer, uri, p -> Optional.of(source("old"))).text());
}
}
@Test void taskConsumerOutlivesTransportButNotTaskOrProject() {
final var registry = new ExternalSourceRegistry();
final String consumer = registry.connect(null, true);
final var snapshot = source("source");
final String uri = registry.register(consumer, snapshot);
registry.retain(consumer, uri);
registry.disconnect(consumer);
registry.connect(consumer, true);
assertThrows(IllegalStateException.class, () -> registry.source(consumer, uri));
registry.revalidate(consumer, uri, p -> Optional.of(source("source")));
assertSame(snapshot, registry.source(consumer, uri));
registry.release(consumer, null);
assertThrows(IllegalStateException.class, () -> registry.connect(consumer, true));
final String next = registry.connect(null, true);
registry.register(next, snapshot);
registry.close();
assertThrows(IllegalStateException.class, () -> registry.read(next, uri));
}
@Test void cancelledOrUnopenedNavigationDoesNotRetainASnapshot() {
try (var registry = new ExternalSourceRegistry()) {
final String consumer = registry.connect(null, true);
final String uri = registry.register(consumer, source("unused"));
registry.disconnect(consumer);
registry.connect(consumer, true);
assertThrows(IllegalStateException.class, () -> registry.revalidate(consumer, uri, p -> Optional.of(source("unused"))));
}
}
}
@@ -0,0 +1,33 @@
package p.studio.lsp.services.protocol;
import org.eclipse.lsp4j.*;
import org.eclipse.lsp4j.jsonrpc.ResponseErrorException;
import org.junit.jupiter.api.Test;
import p.studio.lsp.messages.LspProjectContext;
import p.studio.lsp.services.compiler.CompilerLanguageServiceBridge;
import p.studio.lsp.services.protocol.mapping.Lsp4jProtocolMessageMapper;
import java.nio.file.Path;
import java.util.List;
import static org.junit.jupiter.api.Assertions.*;
class ExternalWriteBoundaryTest {
@Test void externalEditsAreRefusedEvenWithoutARegisteredConsumer() {
final var service = new PrometeuTextDocumentService(new LspProjectContext("test", "pbs", Path.of(".")),
new CompilerLanguageServiceBridge(), new Lsp4jProtocolMessageMapper());
final String uri = "prometeu-source://session/revision/main.pbs";
final var id = new TextDocumentIdentifier(uri);
final var versioned = new VersionedTextDocumentIdentifier(uri, 2);
final var position = new Position(0, 0);
final List<org.junit.jupiter.api.function.Executable> attempts = List.of(
() -> service.didChange(new DidChangeTextDocumentParams(versioned, List.of(new TextDocumentContentChangeEvent("changed")))),
() -> service.didSave(new DidSaveTextDocumentParams(id)),
() -> service.formatting(new DocumentFormattingParams(id, new FormattingOptions(4, true))),
() -> service.rename(new RenameParams(id, position, "changed")),
() -> service.prepareRename(new PrepareRenameParams(id, position)),
() -> service.codeAction(new CodeActionParams(id, new Range(position, position), new CodeActionContext(List.of()))));
for (var attempt : attempts) assertEquals(-32010, assertThrows(ResponseErrorException.class, attempt).getResponseError().getCode());
assertTrue(service.references(new ReferenceParams(id, position, new ReferenceContext(true))).join().isEmpty());
assertTrue(service.documentLink(new DocumentLinkParams(id)).join().isEmpty());
assertTrue(service.prepareCallHierarchy(new CallHierarchyPrepareParams(id, position)).join().isEmpty());
}
}
@@ -4,10 +4,15 @@ import p.studio.api.operation.OperationSubscription;
import java.nio.file.Path;
import java.util.Optional;
/** Connection assistance only. Copying credentials never grants project authority. */
/** Connection assistance only. Preparation never grants project authority. */
public interface AgentConnectionGuide {
enum State { UNAVAILABLE, WAITING_FOR_ACCESS, CONNECTED, RECONNECTING }
default boolean supportsPreparation() { return false; }
default State state(Path root) { return endpoint().isPresent() ? State.WAITING_FOR_ACCESS : State.UNAVAILABLE; }
default AgentIntegrationPreparation.Result prepare(Path root) { return new AgentIntegrationPreparation.Result(false, "Preparation unavailable"); }
default AgentIntegrationPreparation.Result preparationStatus(Path root) { return new AgentIntegrationPreparation.Result(false, ""); }
Optional<String> endpoint();
/** Explicit secret-bearing export for the clipboard; never persist or log this string. */
/** Permanent registration guidance only; never returns credentials. */
String configuration(Path openProjectRoot);
OperationSubscription subscribe(Runnable changed);
@@ -0,0 +1,13 @@
package p.studio.api.automation;
import java.nio.file.Path;
/** Machine-local client setup, independent of granting project authority. */
public interface AgentIntegrationPreparation {
Result prepare(Path projectRoot);
default Result status(Path projectRoot) { return new Result(false, "Prepare the assistant for this project."); }
record Result(boolean ready, String message) { }
static AgentIntegrationPreparation unavailable() {
return root -> new Result(false, "Prepare the assistant from an installed Studio.");
}
}
@@ -0,0 +1,28 @@
package p.studio.api.automation;
import java.nio.file.Path;
/** Required grant participant. Preparation/publication may do IO; activation/invalidation must not. */
public interface AutomationConnectionLifecycle {
Publication prepare(Path projectRoot) throws Exception;
final class OwnershipConflict extends Exception {
public OwnershipConflict() { super("Another Studio instance owns this project's connection. Reclaim or close it before granting here."); }
}
interface Publication extends AutoCloseable {
void publish() throws Exception;
void activate();
void invalidate();
@Override void close() throws Exception;
}
static AutomationConnectionLifecycle none() {
return root -> new Publication() {
public void publish() { }
public void activate() { }
public void invalidate() { }
public void close() { }
};
}
}
@@ -1,6 +1,6 @@
package p.studio.api.automation;
public record ControlResult(Status status, TaskIdentity task, String diagnostic) {
public enum Status { GRANTED, ACQUIRED, RETURNED, BUSY, DIRTY_DOCUMENTS, SAVE_FAILED, NOT_GRANTED, INVALID_TASK, CLOSED, CLEANUP_FAILED }
public enum Status { GRANTED, ACQUIRED, RETURNED, BUSY, DIRTY_DOCUMENTS, SAVE_FAILED, CONNECTION_FAILED, CONNECTION_CONFLICT, NOT_GRANTED, INVALID_TASK, CLOSED, CLEANUP_FAILED }
public boolean success() { return status == Status.GRANTED || status == Status.ACQUIRED || status == Status.RETURNED; }
public static ControlResult of(Status status, String message) { return new ControlResult(status, null, message); }
}
@@ -2,14 +2,23 @@ package p.studio.api.project;
public record ProjectLocalStudioSetup(
String prometeuRuntimePath,
EditorIndentationSetup editorIndentation) {
EditorIndentationSetup editorIndentation,
AgentIntegrationSetup agentIntegration) {
public ProjectLocalStudioSetup(String runtimePath, EditorIndentationSetup indentation) {
this(runtimePath, indentation, AgentIntegrationSetup.defaults());
}
public ProjectLocalStudioSetup {
agentIntegration = agentIntegration == null ? AgentIntegrationSetup.defaults() : agentIntegration;
prometeuRuntimePath = normalizeText(prometeuRuntimePath);
editorIndentation = editorIndentation == null
? EditorIndentationSetup.defaults()
: editorIndentation.normalize();
}
public record AgentIntegrationSetup(int schemaVersion, boolean enabled, String clientProfile) {
public static AgentIntegrationSetup defaults() { return new AgentIntegrationSetup(1, true, "codex"); }
}
public static ProjectLocalStudioSetup defaults() {
return new ProjectLocalStudioSetup(null, EditorIndentationSetup.defaults());
}
@@ -23,8 +23,15 @@ public final class ProjectCatalogService implements ProjectCatalog {
private final Path projectsRoot;
private final ObjectMapper mapper;
private final ProjectLocalStudioSetupStore setupStore;
private final p.studio.api.automation.AgentIntegrationPreparation integration;
public ProjectCatalogService(Path projectsRoot, ObjectMapper mapper, ProjectLocalStudioSetupStore setupStore) {
this(projectsRoot, mapper, setupStore, p.studio.api.automation.AgentIntegrationPreparation.unavailable());
}
public ProjectCatalogService(Path projectsRoot, ObjectMapper mapper, ProjectLocalStudioSetupStore setupStore,
p.studio.api.automation.AgentIntegrationPreparation integration) {
this.integration = Objects.requireNonNull(integration);
this.projectsRoot = Objects.requireNonNull(projectsRoot, "projectsRoot").toAbsolutePath().normalize();
this.mapper = Objects.requireNonNull(mapper, "mapper").copy()
.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
@@ -103,6 +110,7 @@ public final class ProjectCatalogService implements ProjectCatalog {
} catch (IOException exception) {
throw new UncheckedIOException(exception);
}
integration.prepare(root); // Readiness is queried by DEV; project creation remains usable on setup failure.
return openProject(root);
}
@@ -11,6 +11,9 @@ import java.util.function.Consumer;
public final class DefaultAutomationSession implements AutomationSession {
private final Path root;
private final OperationExecutor executor;
private final AutomationConnectionLifecycle connections;
private AutomationConnectionLifecycle.Publication connection;
private CompletableFuture<Void> publicationIdle = CompletableFuture.completedFuture(null);
private final List<Consumer<AutomationSnapshot>> listeners = new CopyOnWriteArrayList<>();
private final List<DocumentHandoff> documents = new CopyOnWriteArrayList<>();
private final Deque<String> calls = new ArrayDeque<>();
@@ -34,8 +37,13 @@ public final class DefaultAutomationSession implements AutomationSession {
private CompletableFuture<Void> manualIdle = CompletableFuture.completedFuture(null);
public DefaultAutomationSession(Path root, OperationExecutor executor) {
this(root, executor, AutomationConnectionLifecycle.none());
}
public DefaultAutomationSession(Path root, OperationExecutor executor, AutomationConnectionLifecycle connections) {
this.root = root.toAbsolutePath().normalize();
this.executor = Objects.requireNonNull(executor);
this.connections = Objects.requireNonNull(connections);
}
public synchronized ManualLease enterManual() {
@@ -101,15 +109,7 @@ public final class DefaultAutomationSession implements AutomationSession {
if (found && !save) return result(ControlResult.Status.DIRTY_DOCUMENTS, "Save all and grant, or cancel");
CompletionStage<Void> saved = CompletableFuture.completedFuture(null);
if (found) for (var participant : participants) saved = saved.thenCompose(v -> participant.saveAll());
return saved.thenCompose(v -> verifySaved(participants)).thenApply(v -> {
synchronized (this) {
if (closed || generation != attempt) return ControlResult.of(ControlResult.Status.CLOSED, "Grant invalidated");
if (manualOperations != 0) return ControlResult.of(ControlResult.Status.BUSY, "Manual work is still active");
state = ControlState.WAITING_FOR_AGENT;
record("grant");
return ControlResult.of(ControlResult.Status.GRANTED, "");
}
});
return saved.thenCompose(v -> verifySaved(participants)).thenApplyAsync(v -> publishGrant(attempt));
}).exceptionally(f -> ControlResult.of(ControlResult.Status.SAVE_FAILED, message(f)))
.thenApply(outcome -> {
synchronized (this) {
@@ -121,6 +121,39 @@ public final class DefaultAutomationSession implements AutomationSession {
});
}
private ControlResult publishGrant(long attempt) {
AutomationConnectionLifecycle.Publication prepared = null;
boolean committed = false;
CompletableFuture<Void> publishing = null;
try {
synchronized (this) {
if (closed || generation != attempt) return ControlResult.of(ControlResult.Status.CLOSED, "Grant invalidated");
publishing = publicationIdle = new CompletableFuture<>();
}
prepared = connections.prepare(root);
prepared.publish();
synchronized (this) {
if (closed || generation != attempt) return ControlResult.of(ControlResult.Status.CLOSED, "Grant invalidated");
if (manualOperations != 0) return ControlResult.of(ControlResult.Status.BUSY, "Manual work is still active");
prepared.activate();
connection = prepared; committed = true;
state = ControlState.WAITING_FOR_AGENT;
record("grant");
return ControlResult.of(ControlResult.Status.GRANTED, "");
}
} catch (AutomationConnectionLifecycle.OwnershipConflict conflict) {
return ControlResult.of(ControlResult.Status.CONNECTION_CONFLICT, conflict.getMessage());
} catch (Exception failure) {
return ControlResult.of(ControlResult.Status.CONNECTION_FAILED, "Assistant connection could not be published: check project access, installation and publication conflicts.");
} finally {
if (!committed && prepared != null) {
prepared.invalidate();
try { prepared.close(); } catch (Exception ignored) { /* Credential is already invalid. */ }
}
if (publishing != null) publishing.complete(null);
}
}
private CompletionStage<Void> verifySaved(List<DocumentHandoff> participants) {
CompletionStage<Void> check = CompletableFuture.completedFuture(null);
for (var p : participants) check = check.thenCompose(v -> p.hasUnsavedChanges().thenAccept(dirty -> {
@@ -131,7 +164,7 @@ public final class DefaultAutomationSession implements AutomationSession {
@Override public synchronized ControlResult acquire() {
if (closed) return ControlResult.of(ControlResult.Status.CLOSED, "Project closed");
if (state != ControlState.WAITING_FOR_AGENT) return ControlResult.of(ControlResult.Status.NOT_GRANTED, "Human grant required");
if (state != ControlState.WAITING_FOR_AGENT || handoffPending) return ControlResult.of(ControlResult.Status.NOT_GRANTED, "Human grant required");
task = new TaskIdentity(root, UUID.randomUUID().toString());
state = ControlState.AGENT_WORKING; record("acquire"); publish();
return new ControlResult(ControlResult.Status.ACQUIRED, task, "");
@@ -155,23 +188,29 @@ public final class DefaultAutomationSession implements AutomationSession {
final ManagedHeadlessSession ownedRuntime;
final List<Runnable> cancellations;
final List<DocumentHandoff> participants;
final CompletableFuture<Void> idle;
final CompletableFuture<Void> idle, publisherIdle;
final List<Runnable> cleanups;
final AutomationConnectionLifecycle.Publication publication;
synchronized (this) {
if (requireIdentity && !valid(identity)) return result(ControlResult.Status.INVALID_TASK, "Task identity is not current");
if (closing) closed = true;
if (returning != null && !returning.isDone()) return returning;
if (!closing && state == ControlState.MANUAL) return result(ControlResult.Status.RETURNED, "");
if (!closing && state == ControlState.MANUAL && !handoffPending) return result(ControlResult.Status.RETURNED, "");
state = ControlState.RETURNING_CONTROL; task = null; generation++; handoffPending = false;
record(closing ? "close" : "reclaim"); stale = capture != null;
result = returning = new CompletableFuture<>();
operation = active; ownedRuntime = runtime; idle = manualIdle;
operation = active; ownedRuntime = runtime; idle = manualIdle; publisherIdle = publicationIdle;
cancellations = closing ? List.copyOf(manualCancellation) : List.of();
participants = closing ? List.of() : List.copyOf(documents);
cleanups = List.copyOf(taskCleanup); taskCleanup.clear();
publication = connection; connection = null;
if (publication != null) publication.invalidate();
publish();
}
// Never call another service while holding the authority monitor: Debug owns its own lock.
CompletionStage<Void> publicationCleanup;
try { if (publication != null) publication.close(); publicationCleanup = CompletableFuture.completedFuture(null); }
catch (Exception failure) { publicationCleanup = CompletableFuture.failedFuture(new IllegalStateException("Connection cleanup failed; access is revoked")); }
CompletionStage<Void> cleanup;
try {
for (var cancellation : cancellations) cancellation.run();
@@ -179,14 +218,14 @@ public final class DefaultAutomationSession implements AutomationSession {
CompletionStage<Void> stopped = operation == null ? CompletableFuture.completedFuture(null) : operation.termination();
CompletionStage<Void> shutdown = CompletableFuture.completedFuture(null);
if (ownedRuntime != null) { ownedRuntime.cancel(); shutdown = ownedRuntime.shutdown(); }
cleanup = CompletableFuture.allOf(stopped.toCompletableFuture(), shutdown.toCompletableFuture(), idle);
cleanup = CompletableFuture.allOf(stopped.toCompletableFuture(), shutdown.toCompletableFuture(), idle, publisherIdle, publicationCleanup.toCompletableFuture());
cleanup = cleanup.whenComplete((v, failure) -> cleanups.forEach(Runnable::run));
// Closing disposes documents; an explicit return must refresh them before unlocking.
for (var p : participants) cleanup = cleanup.thenCompose(v -> {
synchronized (this) { if (closed) return CompletableFuture.completedFuture(null); }
return p.refreshFromDisk();
});
} catch (RuntimeException failure) { cleanup = CompletableFuture.failedFuture(failure); }
} catch (Exception failure) { cleanup = CompletableFuture.failedFuture(failure); }
cleanup.whenComplete((v, failure) -> {
synchronized (this) {
if (failure == null) {
@@ -17,15 +17,35 @@ public final class DefaultProjectSessionFactory implements ProjectSessionFactory
private final LspLifecyclePort lsp;
private final p.studio.core.project.ProjectAccessRegistry access;
private final p.studio.api.operation.OperationExecutor operations;
private final p.studio.api.automation.AutomationConnectionLifecycle connections;
private final p.studio.api.automation.AgentIntegrationPreparation preparation;
public DefaultProjectSessionFactory(ProjectLocalStudioStateStore stateStore,
ProjectLocalStudioSetupStore setupStore, LspLifecyclePort lsp,
p.studio.core.project.ProjectAccessRegistry access, p.studio.api.operation.OperationExecutor operations) {
this(stateStore, setupStore, lsp, access, operations, p.studio.api.automation.AutomationConnectionLifecycle.none());
}
public DefaultProjectSessionFactory(ProjectLocalStudioStateStore stateStore,
ProjectLocalStudioSetupStore setupStore, LspLifecyclePort lsp,
p.studio.core.project.ProjectAccessRegistry access, p.studio.api.operation.OperationExecutor operations,
p.studio.api.automation.AutomationConnectionLifecycle connections) {
this(stateStore, setupStore, lsp, access, operations, connections,
p.studio.api.automation.AgentIntegrationPreparation.unavailable());
}
public DefaultProjectSessionFactory(ProjectLocalStudioStateStore stateStore,
ProjectLocalStudioSetupStore setupStore, LspLifecyclePort lsp,
p.studio.core.project.ProjectAccessRegistry access, p.studio.api.operation.OperationExecutor operations,
p.studio.api.automation.AutomationConnectionLifecycle connections,
p.studio.api.automation.AgentIntegrationPreparation preparation) {
this.preparation = Objects.requireNonNull(preparation);
this.stateStore = Objects.requireNonNull(stateStore, "stateStore");
this.setupStore = Objects.requireNonNull(setupStore, "setupStore");
this.lsp = Objects.requireNonNull(lsp, "lsp");
this.access = Objects.requireNonNull(access);
this.operations = Objects.requireNonNull(operations);
this.connections = Objects.requireNonNull(connections);
}
@Override
@@ -33,8 +53,10 @@ public final class DefaultProjectSessionFactory implements ProjectSessionFactory
if (closed) throw new IllegalStateException("Project sessions are closing");
final ProjectReference project = Objects.requireNonNull(projectReference, "projectReference");
final var setup = setupStore.load(project);
// Preparation reports readiness independently; opening never grants agent authority.
if (setup.agentIntegration().enabled()) preparation.prepare(project.rootPath());
final var state = stateStore.load(project);
var automation = new DefaultAutomationSession(project.rootPath(), operations);
var automation = new DefaultAutomationSession(project.rootPath(), operations, connections);
var ready = new java.util.concurrent.atomic.AtomicBoolean();
var registration = access.register(project.rootPath(), automation::enterManual,
() -> ready.get() && !automation.snapshot().closed(), automation);
@@ -18,6 +18,46 @@ class DefaultAutomationSessionTest {
ControlResult await(CompletionStage<ControlResult> result) { return result.toCompletableFuture().join(); }
TaskIdentity start(DefaultAutomationSession s) { assertEquals(GRANTED, await(s.grant(false)).status()); return s.acquire().task(); }
@Test void publicationIsRequiredAndCloseWaitsForAbortedPublicationWithoutHoldingMonitor() throws Exception {
var entered = new CountDownLatch(1); var proceed = new CountDownLatch(1);
var active = new java.util.concurrent.atomic.AtomicBoolean(); var cleaned = new java.util.concurrent.atomic.AtomicBoolean();
var s = new DefaultAutomationSession(root, operations, ignored -> new AutomationConnectionLifecycle.Publication() {
public void publish() throws Exception { entered.countDown(); assertTrue(proceed.await(5, TimeUnit.SECONDS)); }
public void activate() { active.set(true); }
public void invalidate() { active.set(false); }
public void close() { cleaned.set(true); }
});
var grant = s.grant(false).toCompletableFuture();
assertTrue(entered.await(5, TimeUnit.SECONDS));
assertEquals(NOT_GRANTED, s.acquire().status());
var closing = s.closeAsync().toCompletableFuture();
assertFalse(closing.isDone()); assertTrue(s.snapshot().closed());
proceed.countDown();
assertEquals(CLOSED, grant.get(5, TimeUnit.SECONDS).status());
assertEquals(RETURNED, closing.get(5, TimeUnit.SECONDS).status());
assertTrue(cleaned.get()); assertFalse(active.get());
}
@Test void failedPublicationCannotGrantAndCleanupFailureStillCancelsWork() {
var s = new DefaultAutomationSession(root, operations, ignored -> { throw new java.io.IOException("private details"); });
assertEquals(CONNECTION_FAILED, await(s.grant(false)).status());
assertTrue(s.snapshot().manualAllowed()); assertEquals(NOT_GRANTED, s.acquire().status());
assertFalse(s.snapshot().diagnostics().toString().contains("private details"));
var active = new java.util.concurrent.atomic.AtomicBoolean();
var next = new DefaultAutomationSession(root, operations, ignored -> new AutomationConnectionLifecycle.Publication() {
public void publish() { }
public void activate() { active.set(true); }
public void invalidate() { active.set(false); }
public void close() throws Exception { throw new java.io.IOException("file failure"); }
});
var task = start(next);
next.submit(task, "running", () -> new AutomationOutcome(AutomationOutcome.Kind.SUCCEEDED, 0, 0, List.of(), null));
var returned = next.reclaim().toCompletableFuture();
assertFalse(active.get()); assertTrue(operations.last.cancelled); assertFalse(returned.isDone());
operations.last.finish();
assertEquals(CLEANUP_FAILED, returned.join().status());
assertTrue(await(next.reclaim()).success());
}
@Test void terminationObserversCanSubmitTheNextOperation() {
var s = session(); var task = start(s);
var first = s.submit(task, "first", () -> new AutomationOutcome(AutomationOutcome.Kind.SUCCEEDED, 0, 0, List.of(), null));
@@ -107,6 +107,40 @@ final class DefaultProjectSessionTest {
registration.unsubscribe();
}
@Test void openingPreparesIntegrationAndRemainsManualEvenWhenPreparationIsIncomplete() {
var mapper = new ObjectMapper(); var calls = new java.util.ArrayList<Path>();
var published = new java.util.concurrent.atomic.AtomicInteger();
try (var factory = new DefaultProjectSessionFactory(new ProjectLocalStudioStateStore(mapper),
new ProjectLocalStudioSetupStore(mapper), new RecordingLsp(), new p.studio.core.project.ProjectAccessRegistry(),
new p.studio.core.support.ControlledOperations(), root -> {
published.incrementAndGet(); throw new AssertionError("Opening must not publish credentials");
}, root -> {
calls.add(root); return new p.studio.api.automation.AgentIntegrationPreparation.Result(false, "Installation missing");
})) {
var first = factory.open(project());
assertEquals(java.util.List.of(project().rootPath()), calls);
assertTrue(first.automation().snapshot().manualAllowed());
assertNull(first.automation().snapshot().task()); assertEquals(0, published.get());
first.close();
var reopened = factory.open(project());
assertEquals(2, calls.size()); assertTrue(reopened.automation().snapshot().manualAllowed());
}
}
@Test void explicitDisabledIntegrationIsPreservedOnOpen() {
var mapper = new ObjectMapper(); var setup = new ProjectLocalStudioSetupStore(mapper);
setup.save(project(), new p.studio.api.project.ProjectLocalStudioSetup(null, null,
new p.studio.api.project.ProjectLocalStudioSetup.AgentIntegrationSetup(1, false, "codex")));
try (var factory = new DefaultProjectSessionFactory(new ProjectLocalStudioStateStore(mapper), setup,
new RecordingLsp(), new p.studio.core.project.ProjectAccessRegistry(), new p.studio.core.support.ControlledOperations(),
p.studio.api.automation.AutomationConnectionLifecycle.none(), root -> {
throw new AssertionError("Disabled integration must not be prepared automatically");
})) {
assertTrue(factory.open(project()).automation().snapshot().manualAllowed());
assertFalse(setup.load(project()).agentIntegration().enabled());
}
}
private static final class RecordingLsp implements LspLifecyclePort {
int boots;
int shutdowns;
@@ -4,6 +4,7 @@ import lombok.Getter;
public enum I18n {
WORKSPACE_DEV("workspace.dev"),
DEV_MCP_WAITING("dev.mcpWaiting"), DEV_MCP_CONNECTED("dev.mcpConnected"), DEV_MCP_RECONNECTING("dev.mcpReconnecting"),
DEV_GRANT("dev.grant"), DEV_RECLAIM("dev.reclaim"), DEV_COPY_CONFIG("dev.copyConfig"),
DEV_MCP_UNAVAILABLE("dev.mcpUnavailable"), DEV_EXTERNAL_WARNING("dev.externalWarning"),
DEV_MCP_INSTRUCTIONS("dev.mcpInstructions"), DEV_CONFIG_COPIED("dev.configCopied"), DEV_CONFIG_FAILED("dev.configFailed"),
@@ -33,6 +33,7 @@ public final class DevWorkspace extends Workspace {
private OperationSubscription subscription;
private long generation;
private CanonicalCapture rendered;
private boolean preparing;
private final javafx.beans.value.ChangeListener<java.util.Locale> localeListener;
public DevWorkspace(ProjectReference project, AutomationSession automation, I18nService i18n, StudioEventBus events) {
@@ -53,7 +54,7 @@ public final class DevWorkspace extends Workspace {
reclaim.setOnAction(e -> automation.reclaim());
configuration.setId("dev-mcp-config");
configuration.textProperty().bind(i18n.bind(I18n.DEV_COPY_CONFIG));
configuration.setOnAction(e -> copyConfiguration());
configuration.setOnAction(e -> prepareConfiguration());
availability.setId("dev-mcp-endpoint"); availability.setWrapText(true);
copyStatus.setId("dev-mcp-copy-status");
Label instructions = new Label(); instructions.setWrapText(true);
@@ -82,12 +83,17 @@ public final class DevWorkspace extends Workspace {
if (subscription != null) return;
i18n.localeProperty().addListener(localeListener);
long subscribed = ++generation;
java.util.concurrent.CompletableFuture.supplyAsync(() -> connectionGuide.preparationStatus(projectRoot))
.whenComplete((result, failure) -> Platform.runLater(() -> {
if (generation == subscribed && !preparing && copyStatus.getText().isEmpty())
copyStatus.setText(failure == null ? result.message() : i18n.text(I18n.DEV_CONFIG_FAILED));
}));
subscription = automation.subscribe(snapshot -> {
Runnable update = () -> { if (generation == subscribed) apply(snapshot); };
if (Platform.isFxApplicationThread()) update.run(); else Platform.runLater(update);
});
connectionSubscription = connectionGuide.subscribe(() -> {
Runnable update = () -> { if (generation == subscribed) { copyStatus.setText(""); updateConnection(); } };
Runnable update = () -> { if (generation == subscribed) { updateConnection(); } };
if (Platform.isFxApplicationThread()) update.run(); else Platform.runLater(update);
});
}
@@ -127,20 +133,25 @@ public final class DevWorkspace extends Workspace {
}
}
private void updateConnection() {
var endpoint = connectionGuide.endpoint();
configuration.setDisable(automation.snapshot().closed() || endpoint.isEmpty());
availability.setText(endpoint.orElseGet(() -> i18n.text(I18n.DEV_MCP_UNAVAILABLE)));
configuration.setDisable(preparing || automation.snapshot().closed() || !connectionGuide.supportsPreparation());
availability.setText(i18n.text(switch (connectionGuide.state(projectRoot)) {
case UNAVAILABLE -> I18n.DEV_MCP_UNAVAILABLE;
case WAITING_FOR_ACCESS -> I18n.DEV_MCP_WAITING;
case CONNECTED -> I18n.DEV_MCP_CONNECTED;
case RECONNECTING -> I18n.DEV_MCP_RECONNECTING;
}));
}
private void copyConfiguration() {
try {
if (automation.snapshot().closed()) throw new IllegalStateException("Project closed");
var content = new javafx.scene.input.ClipboardContent();
content.putString(connectionGuide.configuration(projectRoot));
boolean copied = javafx.scene.input.Clipboard.getSystemClipboard().setContent(content);
copyStatus.setText(i18n.text(copied ? I18n.DEV_CONFIG_COPIED : I18n.DEV_CONFIG_FAILED));
} catch (RuntimeException unavailable) {
// Never render exception payloads or credential-bearing configuration in diagnostics.
copyStatus.setText(i18n.text(I18n.DEV_CONFIG_FAILED)); updateConnection();
}
private void prepareConfiguration() {
if (preparing) return;
preparing = true;
long requested = generation;
configuration.setDisable(true);
java.util.concurrent.CompletableFuture.supplyAsync(() -> connectionGuide.prepare(projectRoot))
.whenComplete((result, failure) -> Platform.runLater(() -> {
preparing = false;
if (generation != requested) return;
copyStatus.setText(failure == null ? result.message() : i18n.text(I18n.DEV_CONFIG_FAILED));
updateConnection();
}));
}
}
@@ -360,11 +360,11 @@ workspace.debug=Debug
workspace.dev=DEV
dev.grant=Grant control to AI
dev.reclaim=Interrupt and reclaim control
dev.copyConfig=Copy MCP configuration
dev.copyConfig=Prepare assistant
dev.mcpUnavailable=MCP connection is unavailable.
dev.mcpInstructions=Copy the connection descriptor into your external client's MCP setup (adapt its format if needed). Connect → read project/language references → acquire after a human grant → edit saved files and validate with LSP/build → release. Copying does not grant control. Keep the token private and out of versioned files; recopy after restarting Studio. Only listed tools are available.
dev.mcpInstructions=Prepare the assistant once for this project. Start the agent here, then grant access in DEV. Studio discovers the connection automatically, including after restart and a new grant.
dev.configCopied=Connection descriptor and project instructions copied. Contains a private token.
dev.configFailed=Could not copy the current connection configuration.
dev.configFailed=Assistant preparation failed. Check the installation and project settings.
dev.externalWarning=Reclaiming control stops Studio-managed work, not direct writes by your external agent. Stop that client separately. Existing edits are preserved.
dev.manual=Manual control
dev.waiting=Waiting for agent — project control granted
@@ -377,3 +377,6 @@ dev.history=Recent Studio calls
dev.noFrame=No runtime capture
dev.staleFrame=Stale capture — previous build or execution
dev.currentFrame=Canonical runtime capture
dev.mcpWaiting=Assistant connection: waiting for access or connection
dev.mcpConnected=Assistant connected
dev.mcpReconnecting=Assistant reconnecting
@@ -31,11 +31,11 @@ workspace.debug.status.stopped=Parado
workspace.dev=DEV
dev.grant=Ceder controle à IA
dev.reclaim=Interromper e retomar controle
dev.copyConfig=Copiar configuração MCP
dev.copyConfig=Preparar assistente
dev.mcpUnavailable=A conexão MCP está indisponível.
dev.mcpInstructions=Copie o descritor de conexão para a configuração MCP do cliente externo (adapte o formato se necessário). Conecte → consulte projeto/linguagens/referências → adquira após cessão humana → edite arquivos salvos e valide com LSP/build → devolva. Copiar não cede controle. Mantenha o token privado e fora de arquivos versionados; copie novamente após reiniciar o Studio. Somente as ferramentas listadas estão disponíveis.
dev.mcpInstructions=Prepare o assistente uma vez neste projeto. Inicie o agente aqui e conceda acesso no DEV. A conexão é descoberta automaticamente, inclusive após reiniciar e conceder acesso novamente.
dev.configCopied=Descritor de conexão e instruções do projeto copiados. Contém um token privado.
dev.configFailed=Não foi possível copiar a configuração atual de conexão.
dev.configFailed=Falha ao preparar assistente. Confira a instalação e as configurações do projeto.
dev.externalWarning=Retomar controle encerra o trabalho gerenciado pelo Studio, não as escritas diretas do agente externo. Pare esse cliente separadamente. As alterações existentes são preservadas.
dev.manual=Controle manual
dev.waiting=Aguardando agente — controle do projeto cedido
@@ -48,3 +48,6 @@ dev.history=Chamadas recentes ao Studio
dev.noFrame=Nenhuma captura do runtime
dev.staleFrame=Captura desatualizada — build ou execução anterior
dev.currentFrame=Captura canônica do runtime
dev.mcpWaiting=Conexão do assistente: aguardando acesso ou conexão
dev.mcpConnected=Assistente conectado
dev.mcpReconnecting=Assistente reconectando
+4 -2
View File
@@ -2,7 +2,9 @@
node_modules/
# Build output
out/
out/*
!out/extension.js
!out/externalSources.js
dist/
# VS Code package output
@@ -35,4 +37,4 @@ Thumbs.db
.vscode/*.log
# AI
debug
debug
+28
View File
@@ -153,3 +153,31 @@ The extension currently provides only the minimal LSP client bridge:
* receives LSP messages from the Java/LSP4J server
The Studio remains the source of trut
## Reading SDK/core and libraries
F12 opens bundled SDK/core and admitted dependency declarations as read-only
`prometeu-source:` documents. Hover, continued F12 and semantic highlighting work
inside them. Files in the editable project keep normal `file:` editing. A library
under `.workspace` is still external. SDK/core are never copied to an editorial
folder or cache. Formatting, rename and code actions cannot change external sources;
a proposal touching both project and dependency files is refused in full.
An open external document keeps its source revision. Disconnect leaves its text
visible, with queries unavailable until reconnection and revalidation. If the
source changed, navigate again from the project to obtain new text and positions.
The status bar indicates when an active external source is unavailable.
Compile with `npm run compile` before running the extension. Development acceptance
can launch an isolated real VS Code host against the test LSP classpath:
```sh
PROMETEU_VSCODE_DEV_TEST=1 ./gradlew :prometeu-lsp:prometeu-lsp-v1:test --tests '*ExternalSourceDevelopmentHostTest' --console=plain
```
Run that Gradle command from the repository root. Set `PROMETEU_VSCODE_EXECUTABLE`
when VS Code is not installed at the default macOS application path. The test covers
read-only typing, declaration ranges, hover/F12, highlighting, dependency sources
with Unicode/CRLF, reconnection and normal project editing. It does not validate a
packaged Studio distribution or installed JAR. Dependencies must already exist on
disk; dependency management remains a separate product task.
+29 -2
View File
@@ -37,6 +37,7 @@ exports.activate = activate;
exports.deactivate = deactivate;
const net = __importStar(require("node:net"));
const vscode = __importStar(require("vscode"));
const externalSources_1 = require("./externalSources");
const node_1 = require("vscode-languageclient/node");
let client;
let output;
@@ -44,12 +45,14 @@ let reconnectTimer;
let reconnectContext;
let stoppingClient = false;
let lastAppliedThemeSignature;
const externalSources = new externalSources_1.ExternalSources();
const RECONNECT_DELAY_MS = 2000;
const VSCODE_HOST_ID = "vscode";
function activate(context) {
reconnectContext = context;
output = vscode.window.createOutputChannel("Prometeu LSP");
output.appendLine("Prometeu VS Code extension activated.");
context.subscriptions.push(externalSources, vscode.workspace.registerTextDocumentContentProvider(externalSources_1.externalScheme, externalSources), vscode.window.onDidChangeActiveTextEditor(() => externalSources.refreshStatus()), vscode.workspace.onDidOpenTextDocument(document => void externalSources.opened(document)), vscode.workspace.onDidCloseTextDocument(document => void externalSources.closeDocument(document)));
const connectCommand = vscode.commands.registerCommand("prometeu.connectStudioLsp", async () => {
await startClient(context);
});
@@ -61,7 +64,12 @@ function activate(context) {
void startClient(context);
}
async function deactivate() {
await stopClient();
try {
await externalSources.shutdown();
}
finally {
await stopClient();
}
}
async function startClient(context) {
clearReconnectTimer();
@@ -113,7 +121,7 @@ async function startClient(context) {
{
scheme: "file",
language: "pbs"
}
}, { scheme: externalSources_1.externalScheme, language: "pbs" }
],
synchronize: {
fileEvents: [
@@ -121,10 +129,20 @@ async function startClient(context) {
]
},
initializationOptions: {
...externalSources.initializationOptions,
clientKind: "vscode",
prometeuClientVersion: context.extension.packageJSON.version
},
outputChannel: output,
middleware: {
prepareRename: (document, position, token, next) => document.uri.scheme === externalSources_1.externalScheme ? null : next(document, position, token),
provideRenameEdits: (document, position, name, token, next) => document.uri.scheme === externalSources_1.externalScheme ? null : next(document, position, name, token),
provideDocumentFormattingEdits: (document, options, token, next) => document.uri.scheme === externalSources_1.externalScheme ? [] : next(document, options, token),
provideCodeActions: (document, range, context, token, next) => document.uri.scheme === externalSources_1.externalScheme ? [] : next(document, range, context, token),
provideHover: (document, position, token, next) => externalSources.canQuery(document) ? next(document, position, token) : null,
provideDefinition: (document, position, token, next) => externalSources.canQuery(document) ? next(document, position, token) : null,
provideDocumentSemanticTokens: (document, token, next) => externalSources.canQuery(document) ? next(document, token) : null
},
errorHandler: {
error: (error) => {
output.appendLine(`Prometeu LSP transport error: ${error.message}`);
@@ -138,11 +156,18 @@ async function startClient(context) {
};
const nextClient = new node_1.LanguageClient("prometeuStudioLsp", "Prometeu Studio LSP", serverOptions, clientOptions);
client = nextClient;
nextClient.registerFeature({
fillClientCapabilities(capabilities) {
capabilities.experimental = { ...capabilities.experimental, prometeuExternalSources: true };
},
initialize() { }, clear() { }, getState() { return { kind: "static" }; }
});
nextClient.onDidChangeState((event) => {
output.appendLine(`Prometeu LSP state changed: ${node_1.State[event.oldState]} -> ${node_1.State[event.newState]}`);
if (event.newState !== node_1.State.Stopped) {
return;
}
externalSources.disconnected();
if (client === nextClient) {
client = undefined;
}
@@ -152,11 +177,13 @@ async function startClient(context) {
});
try {
await nextClient.start();
await externalSources.connected(nextClient);
await applyPrometeuVisualTheme(nextClient.initializeResult);
output.appendLine("Prometeu Studio LSP client started.");
vscode.window.showInformationMessage("Connected to Prometeu Studio LSP.");
}
catch (error) {
externalSources.resetSession();
if (client === nextClient) {
client = undefined;
}
@@ -0,0 +1,146 @@
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
var ownKeys = function(o) {
ownKeys = Object.getOwnPropertyNames || function (o) {
var ar = [];
for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
return ar;
};
return ownKeys(o);
};
return function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
__setModuleDefault(result, mod);
return result;
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.ExternalSources = exports.externalScheme = void 0;
const vscode = __importStar(require("vscode"));
exports.externalScheme = "prometeu-source";
/** Immutable virtual documents. No filesystem provider and no content-change events. */
class ExternalSources {
client;
consumerId;
documents = new Map();
available = new Set();
closed = new Set();
status = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Right, 10);
refreshStatus() {
const document = vscode.window.activeTextEditor?.document;
if (document?.uri.scheme === exports.externalScheme && !this.canQuery(document)) {
this.status.text = "Prometeu: external source unavailable";
this.status.tooltip = "Reconnect to Studio or navigate again to obtain the current source revision.";
this.status.show();
}
else
this.status.hide();
}
get initializationOptions() {
return this.consumerId ? { prometeuExternalConsumerId: this.consumerId } : {};
}
canQuery(document) {
const uri = document.uri;
if (uri.scheme !== exports.externalScheme)
return true;
const content = this.documents.get(uri.toString());
return !!this.client && this.available.has(uri.toString()) && !!content
&& document.getText().replace(/\r\n?/g, "\n") === content.text.replace(/\r\n?/g, "\n");
}
async connected(client) {
const experimental = client.initializeResult?.capabilities.experimental;
if (!experimental?.prometeuExternalSources)
return;
this.client = client;
this.consumerId = experimental.prometeuExternalConsumerId;
for (const uri of this.closed)
await this.release(uri);
this.closed.clear();
for (const [uri, old] of this.documents) {
try {
const current = await this.request("revalidateExternalSource", uri);
if (current.descriptor.revision === old.descriptor.revision && current.text === old.text)
this.available.add(uri);
}
catch { /* Keep displayed text; fresh navigation is required. */ }
}
this.refreshStatus();
}
disconnected() { this.client = undefined; this.available.clear(); this.refreshStatus(); }
resetSession() { this.disconnected(); this.consumerId = undefined; }
request(operation, uri) {
if (!this.client || !this.consumerId)
return Promise.reject(new Error("External source unavailable: reconnect to Studio."));
return this.client.sendRequest(`prometeu/${operation}`, { consumerId: this.consumerId, uri });
}
async provideTextDocumentContent(uri, token) {
const key = uri.toString();
const old = this.documents.get(key);
if (old)
return old.text;
const content = await this.request("readExternalSource", key);
if (token.isCancellationRequested) {
await this.release(key);
throw new Error("External source read cancelled.");
}
if (!content.descriptor.readOnly || content.descriptor.uri !== key)
throw new Error("Invalid external source descriptor.");
this.documents.set(key, content);
this.available.add(key);
this.refreshStatus();
return content.text;
}
async opened(document) {
if (document.uri.scheme !== exports.externalScheme)
return;
const content = this.documents.get(document.uri.toString());
if (content && content.descriptor.languageId !== document.languageId)
await vscode.languages.setTextDocumentLanguage(document, content.descriptor.languageId);
}
async closeDocument(document) {
const uri = document.uri.toString();
if (!this.documents.has(uri))
return;
// Changing language also fires close/open; retain while VS Code still owns the document.
await new Promise(resolve => setTimeout(resolve, 0));
if (vscode.workspace.textDocuments.some(open => open.uri.toString() === uri && !open.isClosed))
return;
this.documents.delete(uri);
this.available.delete(uri);
if (this.client)
await this.release(uri);
else
this.closed.add(uri);
}
async release(uri) {
if (this.client && this.consumerId)
await this.client.sendRequest("prometeu/releaseExternalSource", { consumerId: this.consumerId, uri });
}
async shutdown() {
if (this.client && this.consumerId)
await this.client.sendRequest("prometeu/releaseExternalSource", { consumerId: this.consumerId, uri: null });
this.resetSession();
this.documents.clear();
}
dispose() { this.disconnected(); this.documents.clear(); this.status.dispose(); }
}
exports.ExternalSources = ExternalSources;
//# sourceMappingURL=externalSources.js.map
+29 -2
View File
@@ -1,5 +1,6 @@
import * as net from "node:net";
import * as vscode from "vscode";
import { ExternalSources, externalScheme } from "./externalSources";
import {
CloseAction,
@@ -17,6 +18,7 @@ let reconnectTimer: NodeJS.Timeout | undefined;
let reconnectContext: vscode.ExtensionContext | undefined;
let stoppingClient = false;
let lastAppliedThemeSignature: string | undefined;
const externalSources = new ExternalSources();
const RECONNECT_DELAY_MS = 2000;
@@ -76,6 +78,11 @@ export function activate(context: vscode.ExtensionContext): void {
reconnectContext = context;
output = vscode.window.createOutputChannel("Prometeu LSP");
output.appendLine("Prometeu VS Code extension activated.");
context.subscriptions.push(externalSources,
vscode.workspace.registerTextDocumentContentProvider(externalScheme, externalSources),
vscode.window.onDidChangeActiveTextEditor(() => externalSources.refreshStatus()),
vscode.workspace.onDidOpenTextDocument(document => void externalSources.opened(document)),
vscode.workspace.onDidCloseTextDocument(document => void externalSources.closeDocument(document)));
const connectCommand = vscode.commands.registerCommand(
"prometeu.connectStudioLsp",
@@ -98,7 +105,8 @@ export function activate(context: vscode.ExtensionContext): void {
}
export async function deactivate(): Promise<void> {
await stopClient();
try { await externalSources.shutdown(); }
finally { await stopClient(); }
}
async function startClient(context: vscode.ExtensionContext): Promise<void> {
@@ -167,7 +175,7 @@ async function startClient(context: vscode.ExtensionContext): Promise<void> {
{
scheme: "file",
language: "pbs"
}
}, { scheme: externalScheme, language: "pbs" }
],
synchronize: {
fileEvents: [
@@ -175,10 +183,20 @@ async function startClient(context: vscode.ExtensionContext): Promise<void> {
]
},
initializationOptions: {
...externalSources.initializationOptions,
clientKind: "vscode",
prometeuClientVersion: context.extension.packageJSON.version
},
outputChannel: output,
middleware: {
prepareRename: (document, position, token, next) => document.uri.scheme === externalScheme ? null : next(document, position, token),
provideRenameEdits: (document, position, name, token, next) => document.uri.scheme === externalScheme ? null : next(document, position, name, token),
provideDocumentFormattingEdits: (document, options, token, next) => document.uri.scheme === externalScheme ? [] : next(document, options, token),
provideCodeActions: (document, range, context, token, next) => document.uri.scheme === externalScheme ? [] : next(document, range, context, token),
provideHover: (document, position, token, next) => externalSources.canQuery(document) ? next(document, position, token) : null,
provideDefinition: (document, position, token, next) => externalSources.canQuery(document) ? next(document, position, token) : null,
provideDocumentSemanticTokens: (document, token, next) => externalSources.canQuery(document) ? next(document, token) : null
},
errorHandler: {
error: (error) => {
output.appendLine(`Prometeu LSP transport error: ${error.message}`);
@@ -198,11 +216,18 @@ async function startClient(context: vscode.ExtensionContext): Promise<void> {
clientOptions
);
client = nextClient;
nextClient.registerFeature({
fillClientCapabilities(capabilities) {
capabilities.experimental = { ...capabilities.experimental, prometeuExternalSources: true };
},
initialize() {}, clear() {}, getState() { return { kind: "static" }; }
});
nextClient.onDidChangeState((event) => {
output.appendLine(`Prometeu LSP state changed: ${State[event.oldState]} -> ${State[event.newState]}`);
if (event.newState !== State.Stopped) {
return;
}
externalSources.disconnected();
if (client === nextClient) {
client = undefined;
}
@@ -213,11 +238,13 @@ async function startClient(context: vscode.ExtensionContext): Promise<void> {
try {
await nextClient.start();
await externalSources.connected(nextClient);
await applyPrometeuVisualTheme(nextClient.initializeResult);
output.appendLine("Prometeu Studio LSP client started.");
vscode.window.showInformationMessage("Connected to Prometeu Studio LSP.");
} catch (error) {
externalSources.resetSession();
if (client === nextClient) {
client = undefined;
}
@@ -0,0 +1,106 @@
import * as vscode from "vscode";
import { LanguageClient } from "vscode-languageclient/node";
export const externalScheme = "prometeu-source";
export type ExternalContent = {
descriptor: { uri: string; revision: string; origin: string; name: string; languageId: string; readOnly: true };
text: string;
};
/** Immutable virtual documents. No filesystem provider and no content-change events. */
export class ExternalSources implements vscode.TextDocumentContentProvider, vscode.Disposable {
private client?: LanguageClient;
private consumerId?: string;
private readonly documents = new Map<string, ExternalContent>();
private readonly available = new Set<string>();
private readonly closed = new Set<string>();
private readonly status = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Right, 10);
refreshStatus(): void {
const document = vscode.window.activeTextEditor?.document;
if (document?.uri.scheme === externalScheme && !this.canQuery(document)) {
this.status.text = "Prometeu: external source unavailable";
this.status.tooltip = "Reconnect to Studio or navigate again to obtain the current source revision.";
this.status.show();
} else this.status.hide();
}
get initializationOptions(): object {
return this.consumerId ? { prometeuExternalConsumerId: this.consumerId } : {};
}
canQuery(document: vscode.TextDocument): boolean {
const uri = document.uri;
if (uri.scheme !== externalScheme) return true;
const content = this.documents.get(uri.toString());
return !!this.client && this.available.has(uri.toString()) && !!content
&& document.getText().replace(/\r\n?/g, "\n") === content.text.replace(/\r\n?/g, "\n");
}
async connected(client: LanguageClient): Promise<void> {
const experimental = client.initializeResult?.capabilities.experimental;
if (!experimental?.prometeuExternalSources) return;
this.client = client;
this.consumerId = experimental.prometeuExternalConsumerId;
for (const uri of this.closed) await this.release(uri);
this.closed.clear();
for (const [uri, old] of this.documents) {
try {
const current = await this.request("revalidateExternalSource", uri);
if (current.descriptor.revision === old.descriptor.revision && current.text === old.text) this.available.add(uri);
} catch { /* Keep displayed text; fresh navigation is required. */ }
}
this.refreshStatus();
}
disconnected(): void { this.client = undefined; this.available.clear(); this.refreshStatus(); }
resetSession(): void { this.disconnected(); this.consumerId = undefined; }
private request(operation: string, uri: string): Promise<ExternalContent> {
if (!this.client || !this.consumerId) return Promise.reject(new Error("External source unavailable: reconnect to Studio."));
return this.client.sendRequest<ExternalContent>(`prometeu/${operation}`, { consumerId: this.consumerId, uri });
}
async provideTextDocumentContent(uri: vscode.Uri, token: vscode.CancellationToken): Promise<string> {
const key = uri.toString();
const old = this.documents.get(key);
if (old) return old.text;
const content = await this.request("readExternalSource", key);
if (token.isCancellationRequested) { await this.release(key); throw new Error("External source read cancelled."); }
if (!content.descriptor.readOnly || content.descriptor.uri !== key) throw new Error("Invalid external source descriptor.");
this.documents.set(key, content);
this.available.add(key);
this.refreshStatus();
return content.text;
}
async opened(document: vscode.TextDocument): Promise<void> {
if (document.uri.scheme !== externalScheme) return;
const content = this.documents.get(document.uri.toString());
if (content && content.descriptor.languageId !== document.languageId)
await vscode.languages.setTextDocumentLanguage(document, content.descriptor.languageId);
}
async closeDocument(document: vscode.TextDocument): Promise<void> {
const uri = document.uri.toString();
if (!this.documents.has(uri)) return;
// Changing language also fires close/open; retain while VS Code still owns the document.
await new Promise(resolve => setTimeout(resolve, 0));
if (vscode.workspace.textDocuments.some(open => open.uri.toString() === uri && !open.isClosed)) return;
this.documents.delete(uri);
this.available.delete(uri);
if (this.client) await this.release(uri); else this.closed.add(uri);
}
private async release(uri: string): Promise<void> {
if (this.client && this.consumerId)
await this.client.sendRequest("prometeu/releaseExternalSource", { consumerId: this.consumerId, uri });
}
async shutdown(): Promise<void> {
if (this.client && this.consumerId)
await this.client.sendRequest("prometeu/releaseExternalSource", { consumerId: this.consumerId, uri: null });
this.resetSession();
this.documents.clear();
}
dispose(): void { this.disconnected(); this.documents.clear(); this.status.dispose(); }
}
@@ -0,0 +1,105 @@
import * as assert from "node:assert/strict";
import * as vscode from "vscode";
import { ExternalSources, ExternalContent } from "../externalSources";
import type { LanguageClient } from "vscode-languageclient/node";
async function providerLifecycle(): Promise<void> {
const provider = new ExternalSources();
const uri = vscode.Uri.parse("prometeu-source://test/revision/main.pbs");
let content: ExternalContent = { descriptor: { uri: uri.toString(), revision: "one", origin: "dependency", name: "main.pbs", languageId: "pbs", readOnly: true }, text: "// á 😀\r\nfn f() {}\r\n" };
const requests: string[] = [];
const fake = { initializeResult: { capabilities: { experimental: { prometeuExternalSources: true, prometeuExternalConsumerId: "consumer" } } },
sendRequest: async (method: string) => { requests.push(method); return content; } } as unknown as LanguageClient;
await provider.connected(fake);
const cancellation = new vscode.CancellationTokenSource();
const original = await provider.provideTextDocumentContent(uri, cancellation.token);
const document = { uri, getText: () => original.replace(/\r\n/g, "\n") } as vscode.TextDocument;
assert.equal(provider.canQuery(document), true);
provider.disconnected();
assert.equal(provider.canQuery(document), false);
assert.equal(await provider.provideTextDocumentContent(uri, cancellation.token), original);
await provider.connected(fake);
assert.equal(provider.canQuery(document), true);
provider.disconnected();
content = { descriptor: { ...content.descriptor, revision: "two" }, text: "different" };
await provider.connected(fake);
assert.equal(provider.canQuery(document), false);
assert.equal(await provider.provideTextDocumentContent(uri, cancellation.token), original);
await provider.closeDocument(document);
assert.ok(requests.includes("prometeu/releaseExternalSource"));
cancellation.cancel();
await assert.rejects(provider.provideTextDocumentContent(uri, cancellation.token), /cancelled/);
await provider.shutdown();
provider.dispose();
cancellation.dispose();
}
async function eventually<T>(query: () => PromiseLike<T>, accept: (value: T) => boolean): Promise<T> {
const deadline = Date.now() + 20000;
while (true) {
const value = await query();
if (accept(value)) return value;
if (Date.now() >= deadline) throw new Error("Timed out waiting for development LSP");
await new Promise(resolve => setTimeout(resolve, 100));
}
}
/** Executed by the real Extension Development Host; no packaged Studio involved. */
export async function run(): Promise<void> {
await providerLifecycle();
const root = vscode.workspace.workspaceFolders![0].uri;
const project = await vscode.workspace.openTextDocument(vscode.Uri.joinPath(root, "src/main.pbs"));
await vscode.window.showTextDocument(project);
const use = project.positionAt(project.getText().indexOf("Gfx.clear") + 4);
const definitions = await eventually(
() => vscode.commands.executeCommand<vscode.Location[]>("vscode.executeDefinitionProvider", project.uri, use),
result => !!result?.length);
assert.equal(definitions[0].uri.scheme, "prometeu-source");
const external = await vscode.workspace.openTextDocument(definitions[0].uri);
const editor = await vscode.window.showTextDocument(external, { selection: definitions[0].range });
await eventually(async () => external.languageId, language => language === "pbs");
assert.equal(external.isUntitled, false);
assert.equal(external.isDirty, false);
const original = external.getText();
assert.ok(external.getText(definitions[0].range).includes("clear"));
await vscode.commands.executeCommand("type", { text: "changed" });
assert.equal(external.getText(), original);
assert.equal(external.isDirty, false);
const call = external.positionAt(original.indexOf("LowGfx.clear") + 7);
const hover = await eventually(
() => vscode.commands.executeCommand<vscode.Hover[]>("vscode.executeHoverProvider", external.uri, call),
result => !!result?.length);
assert.ok(hover.flatMap(item => item.contents).some(content => (typeof content === "string" ? content : content.value).includes("clear")));
const host = await vscode.commands.executeCommand<vscode.Location[]>("vscode.executeDefinitionProvider", external.uri, call);
assert.ok(host.length);
const primitive = await vscode.workspace.openTextDocument(host[0].uri);
assert.ok(primitive.getText(host[0].range).includes("clear"));
const tokens = await eventually(
() => vscode.commands.executeCommand<vscode.SemanticTokens>("vscode.provideDocumentSemanticTokens", external.uri),
result => !!result?.data.length);
assert.ok(tokens.data.length > 0);
const libraryUse = project.positionAt(project.getText().lastIndexOf("answer()"));
const libraryDefinitions = await vscode.commands.executeCommand<vscode.Location[]>("vscode.executeDefinitionProvider", project.uri, libraryUse);
assert.equal(libraryDefinitions[0].uri.scheme, "prometeu-source");
const library = await vscode.workspace.openTextDocument(libraryDefinitions[0].uri);
await vscode.window.showTextDocument(library, { selection: libraryDefinitions[0].range });
assert.ok(library.getText(libraryDefinitions[0].range).includes("answer"));
assert.equal(libraryDefinitions[0].range.start.line, 1);
const nestedUse = library.positionAt(library.getText().indexOf("helper();"));
const nested = await eventually(
() => vscode.commands.executeCommand<vscode.Location[]>("vscode.executeDefinitionProvider", library.uri, nestedUse),
result => !!result?.length);
assert.equal(nested[0].range.start.line, 2);
await vscode.commands.executeCommand("prometeu.restartStudioLsp");
assert.equal(external.getText(), original);
const afterReconnect = await eventually(
() => vscode.commands.executeCommand<vscode.Hover[]>("vscode.executeHoverProvider", external.uri, call),
result => !!result?.length);
assert.ok(afterReconnect.flatMap(item => item.contents).some(content => (typeof content === "string" ? content : content.value).includes("clear")));
// Project editing remains functional in the same editor session.
const projectEditor = await vscode.window.showTextDocument(project);
assert.equal(await projectEditor.edit(edit => edit.insert(new vscode.Position(0, 0), "// editable\n")), true);
await vscode.commands.executeCommand("workbench.action.revertAndCloseActiveEditor");
await vscode.commands.executeCommand("workbench.action.closeAllEditors");
console.log("PLN-0141 VS Code development acceptance passed: readonly, syntax, positions, hover, continued definition, project editing.");
}