hjess/iLSP
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
cb914dd990c706379c555620ec803652422124b4
iLSP/ilsp/server.py

491 lines
15 KiB
Python
Raw Normal View History

feat: initial iLSP project scaffolding - Python LSP (pylsp + pylsp_i80 plugin): i80 pypi package completions - Bicep LSP (asyncio TCP proxy → Bicep.LangServer.dll): LRU module injection - Health HTTP endpoint (:2089) for Consul/Nomad checks - Startup catalog fetch from pypi-server.i80.dk + DevOpsMCP (no volume needed) - Multi-stage Dockerfile: downloads Bicep LS at build time, dotnet-runtime-8.0 + python3.12 - Nomad job: static TCP ports 2087/2088, health check on 2089 - Gitea Actions CI: build + push + deploy pipeline - Editor configs: Helix / nvim / LSP4IJ / VS Code
2026-05-10 12:23:05 +02:00
"""
iLSP main entrypoint.
refactor: single HTTP port, WebSocket proxy for LSP endpoints - Remove static ports 2087/2088/2089 from Nomad; use one dynamic port - pylsp and Bicep LS stay on localhost inside container (not exposed) - aiohttp adds /python and /bicep WebSocket routes bridging to localhost LSPs - Nomad env: HTTP_PORT=$NOMAD_PORT_http, internal ports fixed at 2087/2088 - Editors connect via ws://ilsp.i80.dk/python and ws://ilsp.i80.dk/bicep - Traefik routes ilsp.i80.dk → single dynamic HTTP port
2026-05-10 14:44:33 +02:00
Starts all services in one container:
- pylsp on localhost:2087 (internal only — Python LSP + i80 completions)
- Bicep proxy on localhost:2088 (internal only — Bicep LS wrapper + LRU modules)
- aiohttp HTTP on $HTTP_PORT (exposed — health, reload, WebSocket proxies)
Only the HTTP port is exposed to Traefik/Nomad. Editors connect via:
ws://ilsp.i80.dk/python → pylsp
ws://ilsp.i80.dk/bicep → Bicep LS
feat: initial iLSP project scaffolding - Python LSP (pylsp + pylsp_i80 plugin): i80 pypi package completions - Bicep LSP (asyncio TCP proxy → Bicep.LangServer.dll): LRU module injection - Health HTTP endpoint (:2089) for Consul/Nomad checks - Startup catalog fetch from pypi-server.i80.dk + DevOpsMCP (no volume needed) - Multi-stage Dockerfile: downloads Bicep LS at build time, dotnet-runtime-8.0 + python3.12 - Nomad job: static TCP ports 2087/2088, health check on 2089 - Gitea Actions CI: build + push + deploy pipeline - Editor configs: Helix / nvim / LSP4IJ / VS Code
2026-05-10 12:23:05 +02:00
"""
import asyncio
import logging
import os
import signal
feat: bake bicep catalog into image; fix dict-based modules parsing - Remove all DevOpsMCP/aiohttp runtime deps from BicepModuleCatalog - BicepModuleCatalog.load() reads bicep_modules_catalog.json from disk at startup (sync) - Fix _load_catalog: catalog uses dict {path: {versions, schema}} not a list - server.py: call BicepModuleCatalog.load() synchronously, not via asyncio.gather - Dockerfile: COPY bicep_modules_catalog.json into both builder + runtime stages - Health endpoint now reports bicep_modules: 27 Verified locally: make run-quick → health returns pypi_packages:40 bicep_modules:27
2026-05-10 13:40:48 +02:00
import subprocess
import sys
fix: replace asyncio subprocess proxy with thread-based Popen proxy asyncio subprocess PIPE unreliable for long-lived stdio bridging. Use Popen + threads instead. Also fix smoke_test.sh stdin handling.
2026-05-10 13:02:52 +02:00
import threading
feat: initial iLSP project scaffolding - Python LSP (pylsp + pylsp_i80 plugin): i80 pypi package completions - Bicep LSP (asyncio TCP proxy → Bicep.LangServer.dll): LRU module injection - Health HTTP endpoint (:2089) for Consul/Nomad checks - Startup catalog fetch from pypi-server.i80.dk + DevOpsMCP (no volume needed) - Multi-stage Dockerfile: downloads Bicep LS at build time, dotnet-runtime-8.0 + python3.12 - Nomad job: static TCP ports 2087/2088, health check on 2089 - Gitea Actions CI: build + push + deploy pipeline - Editor configs: Helix / nvim / LSP4IJ / VS Code
2026-05-10 12:23:05 +02:00
from aiohttp import web
from .python_lsp.catalog import PypiCatalog
feat: bake bicep catalog into image; fix dict-based modules parsing - Remove all DevOpsMCP/aiohttp runtime deps from BicepModuleCatalog - BicepModuleCatalog.load() reads bicep_modules_catalog.json from disk at startup (sync) - Fix _load_catalog: catalog uses dict {path: {versions, schema}} not a list - server.py: call BicepModuleCatalog.load() synchronously, not via asyncio.gather - Dockerfile: COPY bicep_modules_catalog.json into both builder + runtime stages - Health endpoint now reports bicep_modules: 27 Verified locally: make run-quick → health returns pypi_packages:40 bicep_modules:27
2026-05-10 13:40:48 +02:00
from .bicep_lsp.modules import BicepModuleCatalog
feat: initial iLSP project scaffolding - Python LSP (pylsp + pylsp_i80 plugin): i80 pypi package completions - Bicep LSP (asyncio TCP proxy → Bicep.LangServer.dll): LRU module injection - Health HTTP endpoint (:2089) for Consul/Nomad checks - Startup catalog fetch from pypi-server.i80.dk + DevOpsMCP (no volume needed) - Multi-stage Dockerfile: downloads Bicep LS at build time, dotnet-runtime-8.0 + python3.12 - Nomad job: static TCP ports 2087/2088, health check on 2089 - Gitea Actions CI: build + push + deploy pipeline - Editor configs: Helix / nvim / LSP4IJ / VS Code
2026-05-10 12:23:05 +02:00
from .bicep_lsp.proxy import serve_bicep
feat: YAML pipeline template autocomplete (AzDO + GHA) - Add scripts/sync_pipeline_templates.py — scans LRU AzDO and GHA template repos; outputs unified pipeline_templates_catalog.json (48 templates: 45 AzDO + 3 GHA) - Add scripts/template_sources.yml — source config (AzDO alias, GHA org) - Add pipeline_templates_catalog.json — baked catalog (49 KB) - Add ilsp/yaml_lsp/catalog.py — PipelineTemplateCatalog with completion item generators for template paths, param names, allowed values, GHA inputs - Add ilsp/yaml_lsp/proxy.py — async WS↔TCP bridge with LSP frame buffering, per-connection document tracking, AzDO/GHA context detection, and completion injection (LRU items sortText 0_, standard items downgraded to 9_) - Wire yaml_ws_handler into server.py (replaces raw _ws_proxy call) - Load PipelineTemplateCatalog at startup; reload + health report template count - Update push_catalogs.sh to push pipeline_templates_catalog.json - Update Dockerfile to bake pipeline_templates_catalog.json as image fallback - Add tests/test_yaml_catalog.py (14 tests) + tests/test_yaml_proxy.py (18 tests) All 67 tests green
2026-05-10 15:59:37 +02:00
from .yaml_lsp.catalog import PipelineTemplateCatalog
from .yaml_lsp.proxy import yaml_ws_handler
feat: initial iLSP project scaffolding - Python LSP (pylsp + pylsp_i80 plugin): i80 pypi package completions - Bicep LSP (asyncio TCP proxy → Bicep.LangServer.dll): LRU module injection - Health HTTP endpoint (:2089) for Consul/Nomad checks - Startup catalog fetch from pypi-server.i80.dk + DevOpsMCP (no volume needed) - Multi-stage Dockerfile: downloads Bicep LS at build time, dotnet-runtime-8.0 + python3.12 - Nomad job: static TCP ports 2087/2088, health check on 2089 - Gitea Actions CI: build + push + deploy pipeline - Editor configs: Helix / nvim / LSP4IJ / VS Code
2026-05-10 12:23:05 +02:00
logger = logging.getLogger(__name__)
PYTHON_LSP_PORT = int(os.getenv("PYTHON_LSP_PORT", "2087"))
BICEP_LSP_PORT = int(os.getenv("BICEP_LSP_PORT", "2088"))
refactor: single HTTP port, WebSocket proxy for LSP endpoints - Remove static ports 2087/2088/2089 from Nomad; use one dynamic port - pylsp and Bicep LS stay on localhost inside container (not exposed) - aiohttp adds /python and /bicep WebSocket routes bridging to localhost LSPs - Nomad env: HTTP_PORT=$NOMAD_PORT_http, internal ports fixed at 2087/2088 - Editors connect via ws://ilsp.i80.dk/python and ws://ilsp.i80.dk/bicep - Traefik routes ilsp.i80.dk → single dynamic HTTP port
2026-05-10 14:44:33 +02:00
HTTP_PORT = int(os.getenv("HTTP_PORT", "8000"))
_CHUNK = 65536
feat: initial iLSP project scaffolding - Python LSP (pylsp + pylsp_i80 plugin): i80 pypi package completions - Bicep LSP (asyncio TCP proxy → Bicep.LangServer.dll): LRU module injection - Health HTTP endpoint (:2089) for Consul/Nomad checks - Startup catalog fetch from pypi-server.i80.dk + DevOpsMCP (no volume needed) - Multi-stage Dockerfile: downloads Bicep LS at build time, dotnet-runtime-8.0 + python3.12 - Nomad job: static TCP ports 2087/2088, health check on 2089 - Gitea Actions CI: build + push + deploy pipeline - Editor configs: Helix / nvim / LSP4IJ / VS Code
2026-05-10 12:23:05 +02:00
feat: bake bicep catalog into image; fix dict-based modules parsing - Remove all DevOpsMCP/aiohttp runtime deps from BicepModuleCatalog - BicepModuleCatalog.load() reads bicep_modules_catalog.json from disk at startup (sync) - Fix _load_catalog: catalog uses dict {path: {versions, schema}} not a list - server.py: call BicepModuleCatalog.load() synchronously, not via asyncio.gather - Dockerfile: COPY bicep_modules_catalog.json into both builder + runtime stages - Health endpoint now reports bicep_modules: 27 Verified locally: make run-quick → health returns pypi_packages:40 bicep_modules:27
2026-05-10 13:40:48 +02:00
def _serve_python_lsp(port: int) -> None:
refactor: single HTTP port, WebSocket proxy for LSP endpoints - Remove static ports 2087/2088/2089 from Nomad; use one dynamic port - pylsp and Bicep LS stay on localhost inside container (not exposed) - aiohttp adds /python and /bicep WebSocket routes bridging to localhost LSPs - Nomad env: HTTP_PORT=$NOMAD_PORT_http, internal ports fixed at 2087/2088 - Editors connect via ws://ilsp.i80.dk/python and ws://ilsp.i80.dk/bicep - Traefik routes ilsp.i80.dk → single dynamic HTTP port
2026-05-10 14:44:33 +02:00
"""Start pylsp in TCP mode on localhost only; restart on unexpected exit."""
feat: bake bicep catalog into image; fix dict-based modules parsing - Remove all DevOpsMCP/aiohttp runtime deps from BicepModuleCatalog - BicepModuleCatalog.load() reads bicep_modules_catalog.json from disk at startup (sync) - Fix _load_catalog: catalog uses dict {path: {versions, schema}} not a list - server.py: call BicepModuleCatalog.load() synchronously, not via asyncio.gather - Dockerfile: COPY bicep_modules_catalog.json into both builder + runtime stages - Health endpoint now reports bicep_modules: 27 Verified locally: make run-quick → health returns pypi_packages:40 bicep_modules:27
2026-05-10 13:40:48 +02:00
while True:
proc = subprocess.Popen(
refactor: single HTTP port, WebSocket proxy for LSP endpoints - Remove static ports 2087/2088/2089 from Nomad; use one dynamic port - pylsp and Bicep LS stay on localhost inside container (not exposed) - aiohttp adds /python and /bicep WebSocket routes bridging to localhost LSPs - Nomad env: HTTP_PORT=$NOMAD_PORT_http, internal ports fixed at 2087/2088 - Editors connect via ws://ilsp.i80.dk/python and ws://ilsp.i80.dk/bicep - Traefik routes ilsp.i80.dk → single dynamic HTTP port
2026-05-10 14:44:33 +02:00
[sys.executable, "-m", "pylsp", "--tcp", "--host", "127.0.0.1", "--port", str(port)],
feat: bake bicep catalog into image; fix dict-based modules parsing - Remove all DevOpsMCP/aiohttp runtime deps from BicepModuleCatalog - BicepModuleCatalog.load() reads bicep_modules_catalog.json from disk at startup (sync) - Fix _load_catalog: catalog uses dict {path: {versions, schema}} not a list - server.py: call BicepModuleCatalog.load() synchronously, not via asyncio.gather - Dockerfile: COPY bicep_modules_catalog.json into both builder + runtime stages - Health endpoint now reports bicep_modules: 27 Verified locally: make run-quick → health returns pypi_packages:40 bicep_modules:27
2026-05-10 13:40:48 +02:00
)
refactor: single HTTP port, WebSocket proxy for LSP endpoints - Remove static ports 2087/2088/2089 from Nomad; use one dynamic port - pylsp and Bicep LS stay on localhost inside container (not exposed) - aiohttp adds /python and /bicep WebSocket routes bridging to localhost LSPs - Nomad env: HTTP_PORT=$NOMAD_PORT_http, internal ports fixed at 2087/2088 - Editors connect via ws://ilsp.i80.dk/python and ws://ilsp.i80.dk/bicep - Traefik routes ilsp.i80.dk → single dynamic HTTP port
2026-05-10 14:44:33 +02:00
logger.info("pylsp listening on localhost:%d PID=%d", port, proc.pid)
feat: bake bicep catalog into image; fix dict-based modules parsing - Remove all DevOpsMCP/aiohttp runtime deps from BicepModuleCatalog - BicepModuleCatalog.load() reads bicep_modules_catalog.json from disk at startup (sync) - Fix _load_catalog: catalog uses dict {path: {versions, schema}} not a list - server.py: call BicepModuleCatalog.load() synchronously, not via asyncio.gather - Dockerfile: COPY bicep_modules_catalog.json into both builder + runtime stages - Health endpoint now reports bicep_modules: 27 Verified locally: make run-quick → health returns pypi_packages:40 bicep_modules:27
2026-05-10 13:40:48 +02:00
proc.wait()
logger.warning("pylsp exited (code %s) — restarting", proc.returncode)
refactor: single HTTP port, WebSocket proxy for LSP endpoints - Remove static ports 2087/2088/2089 from Nomad; use one dynamic port - pylsp and Bicep LS stay on localhost inside container (not exposed) - aiohttp adds /python and /bicep WebSocket routes bridging to localhost LSPs - Nomad env: HTTP_PORT=$NOMAD_PORT_http, internal ports fixed at 2087/2088 - Editors connect via ws://ilsp.i80.dk/python and ws://ilsp.i80.dk/bicep - Traefik routes ilsp.i80.dk → single dynamic HTTP port
2026-05-10 14:44:33 +02:00
async def _pipe(reader: asyncio.StreamReader, writer) -> None:
"""Pipe bytes from reader to writer until EOF."""
try:
while True:
data = await reader.read(_CHUNK)
if not data:
break
writer.write(data)
if hasattr(writer, "drain"):
await writer.drain()
else:
await writer.send_bytes(data)
except Exception:
pass
async def _ws_proxy(request: web.Request, host: str, port: int) -> web.WebSocketResponse:
"""Bridge an incoming WebSocket connection to an internal TCP LSP server."""
ws = web.WebSocketResponse()
await ws.prepare(request)
try:
fix: add 3s timeout to LSP backend connection (handles CI firewall drops) asyncio.open_connection hangs indefinitely when backend port is silently dropped. Add wait_for(timeout=3.0) so the WS close frame is always sent within the test's 5s window.
2026-05-10 15:13:03 +02:00
tcp_reader, tcp_writer = await asyncio.wait_for(
asyncio.open_connection(host, port), timeout=3.0
)
except (OSError, asyncio.TimeoutError) as exc:
refactor: single HTTP port, WebSocket proxy for LSP endpoints - Remove static ports 2087/2088/2089 from Nomad; use one dynamic port - pylsp and Bicep LS stay on localhost inside container (not exposed) - aiohttp adds /python and /bicep WebSocket routes bridging to localhost LSPs - Nomad env: HTTP_PORT=$NOMAD_PORT_http, internal ports fixed at 2087/2088 - Editors connect via ws://ilsp.i80.dk/python and ws://ilsp.i80.dk/bicep - Traefik routes ilsp.i80.dk → single dynamic HTTP port
2026-05-10 14:44:33 +02:00
logger.error("Cannot connect to LSP on %s:%d — %s", host, port, exc)
fix: backend unavailable test — use free port + ws.close(timeout=2s) - Use _free_port() instead of hardcoded 19999 (avoids CI port conflicts) - Add timeout=2.0 to ws.close() so close handshake never blocks >2s
2026-05-10 15:16:55 +02:00
await ws.close(code=1011, message=b"LSP backend unavailable", timeout=2.0)
refactor: single HTTP port, WebSocket proxy for LSP endpoints - Remove static ports 2087/2088/2089 from Nomad; use one dynamic port - pylsp and Bicep LS stay on localhost inside container (not exposed) - aiohttp adds /python and /bicep WebSocket routes bridging to localhost LSPs - Nomad env: HTTP_PORT=$NOMAD_PORT_http, internal ports fixed at 2087/2088 - Editors connect via ws://ilsp.i80.dk/python and ws://ilsp.i80.dk/bicep - Traefik routes ilsp.i80.dk → single dynamic HTTP port
2026-05-10 14:44:33 +02:00
return ws
async def ws_to_tcp():
try:
async for msg in ws:
if msg.type == web.WSMsgType.BINARY:
tcp_writer.write(msg.data)
await tcp_writer.drain()
elif msg.type == web.WSMsgType.TEXT:
tcp_writer.write(msg.data.encode())
await tcp_writer.drain()
except Exception:
pass
finally:
tcp_writer.close()
async def tcp_to_ws():
try:
while True:
data = await tcp_reader.read(_CHUNK)
if not data:
break
await ws.send_bytes(data)
except Exception:
pass
finally:
await ws.close()
await asyncio.gather(ws_to_tcp(), tcp_to_ws(), return_exceptions=True)
return ws
feat: add landing page at / Clean HTML page describing iLSP, what LSP is, the WebSocket endpoints, and setup instructions for Neovim, IntelliJ and VS Code. Live stats (Bicep modules, pipeline templates, PyPI packages) are rendered from the in-memory catalog at request time. No emojis. Minimal CSS, no external dependencies.
2026-05-10 18:17:14 +02:00
_INDEX_HTML = """\
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>iLSP — Language Server Proxy</title>
<style>
*, *::before, *::after {{ box-sizing: border-box; }}
:root {{
--bg: #ffffff;
--surface: #f6f7f9;
--border: #e2e4e8;
--text: #1a1d23;
--muted: #6b7280;
--accent: #2563eb;
--accent-light: #eff6ff;
--code-bg: #f1f3f5;
--green: #16a34a;
font-size: 16px;
}}
body {{
margin: 0;
font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
background: var(--bg);
color: var(--text);
line-height: 1.6;
}}
header {{
border-bottom: 1px solid var(--border);
padding: 1.5rem 2rem;
display: flex;
align-items: baseline;
gap: 1rem;
}}
header h1 {{
margin: 0;
font-size: 1.4rem;
font-weight: 700;
letter-spacing: -0.02em;
}}
header span {{
color: var(--muted);
font-size: 0.9rem;
}}
.badge {{
display: inline-block;
background: var(--accent-light);
color: var(--accent);
font-size: 0.75rem;
font-weight: 600;
padding: 0.15rem 0.5rem;
border-radius: 999px;
border: 1px solid #bfdbfe;
}}
main {{
max-width: 860px;
margin: 0 auto;
padding: 2.5rem 2rem 4rem;
}}
h2 {{
font-size: 1.05rem;
font-weight: 700;
margin: 2.5rem 0 0.75rem;
border-bottom: 1px solid var(--border);
padding-bottom: 0.4rem;
letter-spacing: -0.01em;
}}
p {{ margin: 0.5rem 0 0.75rem; color: var(--text); }}
.intro {{ color: var(--muted); margin-top: 0; }}
table {{
width: 100%;
border-collapse: collapse;
font-size: 0.9rem;
margin: 1rem 0;
}}
th {{
text-align: left;
font-weight: 600;
font-size: 0.78rem;
text-transform: uppercase;
letter-spacing: 0.05em;
color: var(--muted);
border-bottom: 2px solid var(--border);
padding: 0.5rem 0.75rem;
}}
td {{
padding: 0.55rem 0.75rem;
border-bottom: 1px solid var(--border);
vertical-align: top;
}}
tr:last-child td {{ border-bottom: none; }}
td:first-child {{ font-family: ui-monospace, "SFMono-Regular", Menlo, monospace; font-size: 0.85rem; white-space: nowrap; }}
code {{
font-family: ui-monospace, "SFMono-Regular", Menlo, monospace;
font-size: 0.85em;
background: var(--code-bg);
padding: 0.15em 0.35em;
border-radius: 4px;
}}
pre {{
background: var(--surface);
border: 1px solid var(--border);
border-radius: 6px;
padding: 1rem 1.25rem;
overflow-x: auto;
font-size: 0.85rem;
line-height: 1.5;
margin: 0.75rem 0 1.25rem;
}}
pre code {{ background: none; padding: 0; font-size: inherit; }}
.status-row {{
display: flex;
gap: 1.5rem;
flex-wrap: wrap;
margin: 1rem 0;
}}
.stat {{
background: var(--surface);
border: 1px solid var(--border);
border-radius: 8px;
padding: 0.75rem 1.25rem;
min-width: 140px;
}}
.stat .num {{
font-size: 1.6rem;
font-weight: 700;
line-height: 1;
color: var(--accent);
}}
.stat .lbl {{
font-size: 0.78rem;
color: var(--muted);
margin-top: 0.2rem;
}}
.note {{
background: var(--accent-light);
border-left: 3px solid var(--accent);
border-radius: 0 6px 6px 0;
padding: 0.75rem 1rem;
font-size: 0.88rem;
color: #1e3a8a;
margin: 1rem 0;
}}
footer {{
text-align: center;
font-size: 0.8rem;
color: var(--muted);
padding: 2rem;
border-top: 1px solid var(--border);
}}
a {{ color: var(--accent); text-decoration: none; }}
a:hover {{ text-decoration: underline; }}
</style>
</head>
<body>
<header>
<h1>iLSP</h1>
<span>Language Server Proxy</span>
<span class="badge">self-hosted</span>
</header>
<main>
<p class="intro">
iLSP is a WebSocket gateway that exposes language server protocol (LSP)
backends over a single HTTP endpoint. Editors connect via WebSocket and
receive code intelligence — completions, hover, diagnostics — for Bicep,
YAML pipelines, and Python, enriched with organisation-specific catalogs.
</p>
<h2>What is LSP</h2>
<p>
The <a href="https://microsoft.github.io/language-server-protocol/">Language Server Protocol</a>
is a standard protocol between editors and language analysis tools.
An editor sends requests (go-to-definition, completion, hover) and receives
structured responses without knowing anything about the language itself.
Any editor that speaks LSP — IntelliJ, Neovim, VS Code, Helix — works
with any LSP server.
</p>
<p>
iLSP wraps existing language servers (Bicep Language Server,
yaml-language-server, pylsp) and injects completion items from
internal catalogs before responses are returned to the editor.
</p>
<h2>Live status</h2>
<div class="status-row">
<div class="stat"><div class="num">{bicep_modules}</div><div class="lbl">Bicep modules</div></div>
<div class="stat"><div class="num">{pipeline_templates}</div><div class="lbl">Pipeline templates</div></div>
<div class="stat"><div class="num">{pypi_packages}</div><div class="lbl">Python packages</div></div>
<div class="stat"><div class="num">254</div><div class="lbl">AzDO tasks</div></div>
</div>
<p style="font-size:0.82rem;color:var(--muted)">
Full JSON status: <a href="/health">/health</a>
</p>
<h2>WebSocket endpoints</h2>
<table>
<thead><tr><th>Endpoint</th><th>Language server</th><th>Extra completions</th></tr></thead>
<tbody>
<tr>
<td>wss://ilsp.i80.dk/bicep</td>
<td>Bicep Language Server</td>
<td>ACR module paths, versions, params</td>
</tr>
<tr>
<td>wss://ilsp.i80.dk/yaml</td>
<td>yaml-language-server</td>
<td>AzDO task schema (254 tasks), pipeline templates</td>
</tr>
<tr>
<td>wss://ilsp.i80.dk/python</td>
<td>pylsp (Jedi)</td>
<td>Internal PyPI package stubs</td>
</tr>
</tbody>
</table>
<h2>Editor setup</h2>
<p><strong>Neovim</strong> — add to your LSP config (<code>init.lua</code>):</p>
<pre><code>-- Bicep
vim.lsp.start({{
name = "ilsp-bicep",
cmd = {{ "websocat", "wss://ilsp.i80.dk/bicep" }},
filetypes = {{ "bicep" }},
}})
-- YAML pipelines
vim.lsp.start({{
name = "ilsp-yaml",
cmd = {{ "websocat", "wss://ilsp.i80.dk/yaml" }},
filetypes = {{ "yaml" }},
}})</code></pre>
<p>
<strong>IntelliJ IDEA / Rider</strong> — install the
<a href="https://plugins.jetbrains.com/plugin/10209-lsp-client">LSP client plugin</a>,
then add a server under <em>Settings &rarr; Languages &amp; Frameworks &rarr; Language Servers</em>:
</p>
<pre><code>Name: iLSP Bicep
Command: websocat wss://ilsp.i80.dk/bicep
Pattern: *.bicep
Name: iLSP YAML
Command: websocat wss://ilsp.i80.dk/yaml
Pattern: azure-pipelines.yml, *.yaml</code></pre>
<div class="note">
<a href="https://github.com/vi/websocat">websocat</a> bridges a WebSocket to
stdio so editors that expect a local process can connect to a remote LSP.
Install with <code>brew install websocat</code> or
<code>cargo install websocat</code>.
</div>
<p><strong>VS Code</strong> — use the
<a href="https://marketplace.visualstudio.com/items?itemName=mesonbuild.mesonlsp">LSP client</a>
or configure the built-in
<code>vscode-languageclient</code> in a workspace extension, pointing
<code>serverOptions.command</code> at <code>websocat wss://ilsp.i80.dk/bicep</code>.
</p>
<h2>Updating the catalogs</h2>
<p>
Catalogs are baked into the Docker image at build time and can also be
refreshed at runtime without restarting. Run the sync scripts from the
iLSP repository and call the reload endpoint:
</p>
<pre><code># Sync Bicep module catalog from ACR and push
python3 scripts/sync_push_catalogs.py
# Trigger a hot reload without container restart
curl -X POST https://ilsp.i80.dk/reload</code></pre>
</main>
<footer>
iLSP &mdash; <a href="https://gea.i80.dk/hjess/iLSP">source</a> &mdash;
<a href="/health">health</a>
</footer>
</body>
</html>
"""
refactor: single HTTP port, WebSocket proxy for LSP endpoints - Remove static ports 2087/2088/2089 from Nomad; use one dynamic port - pylsp and Bicep LS stay on localhost inside container (not exposed) - aiohttp adds /python and /bicep WebSocket routes bridging to localhost LSPs - Nomad env: HTTP_PORT=$NOMAD_PORT_http, internal ports fixed at 2087/2088 - Editors connect via ws://ilsp.i80.dk/python and ws://ilsp.i80.dk/bicep - Traefik routes ilsp.i80.dk → single dynamic HTTP port
2026-05-10 14:44:33 +02:00
async def _build_app() -> web.Application:
feat: initial iLSP project scaffolding - Python LSP (pylsp + pylsp_i80 plugin): i80 pypi package completions - Bicep LSP (asyncio TCP proxy → Bicep.LangServer.dll): LRU module injection - Health HTTP endpoint (:2089) for Consul/Nomad checks - Startup catalog fetch from pypi-server.i80.dk + DevOpsMCP (no volume needed) - Multi-stage Dockerfile: downloads Bicep LS at build time, dotnet-runtime-8.0 + python3.12 - Nomad job: static TCP ports 2087/2088, health check on 2089 - Gitea Actions CI: build + push + deploy pipeline - Editor configs: Helix / nvim / LSP4IJ / VS Code
2026-05-10 12:23:05 +02:00
app = web.Application()
feat: add landing page at / Clean HTML page describing iLSP, what LSP is, the WebSocket endpoints, and setup instructions for Neovim, IntelliJ and VS Code. Live stats (Bicep modules, pipeline templates, PyPI packages) are rendered from the in-memory catalog at request time. No emojis. Minimal CSS, no external dependencies.
2026-05-10 18:17:14 +02:00
async def index(_: web.Request) -> web.Response:
html = _INDEX_HTML.format(
bicep_modules=len(BicepModuleCatalog._modules),
pipeline_templates=PipelineTemplateCatalog.template_count(),
pypi_packages=len(PypiCatalog._packages),
)
return web.Response(text=html, content_type="text/html", charset="utf-8")
feat: initial iLSP project scaffolding - Python LSP (pylsp + pylsp_i80 plugin): i80 pypi package completions - Bicep LSP (asyncio TCP proxy → Bicep.LangServer.dll): LRU module injection - Health HTTP endpoint (:2089) for Consul/Nomad checks - Startup catalog fetch from pypi-server.i80.dk + DevOpsMCP (no volume needed) - Multi-stage Dockerfile: downloads Bicep LS at build time, dotnet-runtime-8.0 + python3.12 - Nomad job: static TCP ports 2087/2088, health check on 2089 - Gitea Actions CI: build + push + deploy pipeline - Editor configs: Helix / nvim / LSP4IJ / VS Code
2026-05-10 12:23:05 +02:00
async def health(_: web.Request) -> web.Response:
feat: YAML LSP (/yaml endpoint) + IAC source catalog enrichment - Add yaml-language-server (Node.js) to Dockerfile stage 3 - Add YAML_LSP_PORT=2090 env var (Dockerfile + ilsp.nomad) - Start yaml-language-server in background thread (_serve_yaml_lsp) - Expose /yaml WebSocket endpoint (same WS→TCP proxy as /python and /bicep) - Load iac_source_catalog.json alongside bicep_modules_catalog.json - Enrich param_completion_items() with descriptions + required flag from IAC source - Required params sorted first (sortText 0_lru_param_0_...) and marked with * - detail field shows * prefix for required params - Update /health to report iac_source_modules + yaml_lsp fields - Rewrite EDITOR_SETUP.md: WebSocket URLs, YAML schemas config for all editors (Helix, Neovim, PyCharm, VS Code) with azure-pipelines + gitea actions schemas - All 35 tests pass
2026-05-10 15:40:13 +02:00
import shutil
feat: add landing page at / Clean HTML page describing iLSP, what LSP is, the WebSocket endpoints, and setup instructions for Neovim, IntelliJ and VS Code. Live stats (Bicep modules, pipeline templates, PyPI packages) are rendered from the in-memory catalog at request time. No emojis. Minimal CSS, no external dependencies.
2026-05-10 18:17:14 +02:00
from .yaml_lsp.proxy import _AZDO_SCHEMA_PATH
feat: initial iLSP project scaffolding - Python LSP (pylsp + pylsp_i80 plugin): i80 pypi package completions - Bicep LSP (asyncio TCP proxy → Bicep.LangServer.dll): LRU module injection - Health HTTP endpoint (:2089) for Consul/Nomad checks - Startup catalog fetch from pypi-server.i80.dk + DevOpsMCP (no volume needed) - Multi-stage Dockerfile: downloads Bicep LS at build time, dotnet-runtime-8.0 + python3.12 - Nomad job: static TCP ports 2087/2088, health check on 2089 - Gitea Actions CI: build + push + deploy pipeline - Editor configs: Helix / nvim / LSP4IJ / VS Code
2026-05-10 12:23:05 +02:00
return web.json_response({
"status": "ok",
feat: bake bicep catalog into image; fix dict-based modules parsing - Remove all DevOpsMCP/aiohttp runtime deps from BicepModuleCatalog - BicepModuleCatalog.load() reads bicep_modules_catalog.json from disk at startup (sync) - Fix _load_catalog: catalog uses dict {path: {versions, schema}} not a list - server.py: call BicepModuleCatalog.load() synchronously, not via asyncio.gather - Dockerfile: COPY bicep_modules_catalog.json into both builder + runtime stages - Health endpoint now reports bicep_modules: 27 Verified locally: make run-quick → health returns pypi_packages:40 bicep_modules:27
2026-05-10 13:40:48 +02:00
"pypi_packages": len(PypiCatalog._packages),
"bicep_modules": len(BicepModuleCatalog._modules),
feat: YAML LSP (/yaml endpoint) + IAC source catalog enrichment - Add yaml-language-server (Node.js) to Dockerfile stage 3 - Add YAML_LSP_PORT=2090 env var (Dockerfile + ilsp.nomad) - Start yaml-language-server in background thread (_serve_yaml_lsp) - Expose /yaml WebSocket endpoint (same WS→TCP proxy as /python and /bicep) - Load iac_source_catalog.json alongside bicep_modules_catalog.json - Enrich param_completion_items() with descriptions + required flag from IAC source - Required params sorted first (sortText 0_lru_param_0_...) and marked with * - detail field shows * prefix for required params - Update /health to report iac_source_modules + yaml_lsp fields - Rewrite EDITOR_SETUP.md: WebSocket URLs, YAML schemas config for all editors (Helix, Neovim, PyCharm, VS Code) with azure-pipelines + gitea actions schemas - All 35 tests pass
2026-05-10 15:40:13 +02:00
"iac_source_modules": len(BicepModuleCatalog._iac),
"yaml_lsp": bool(shutil.which("yaml-language-server")),
feat: YAML pipeline template autocomplete (AzDO + GHA) - Add scripts/sync_pipeline_templates.py — scans LRU AzDO and GHA template repos; outputs unified pipeline_templates_catalog.json (48 templates: 45 AzDO + 3 GHA) - Add scripts/template_sources.yml — source config (AzDO alias, GHA org) - Add pipeline_templates_catalog.json — baked catalog (49 KB) - Add ilsp/yaml_lsp/catalog.py — PipelineTemplateCatalog with completion item generators for template paths, param names, allowed values, GHA inputs - Add ilsp/yaml_lsp/proxy.py — async WS↔TCP bridge with LSP frame buffering, per-connection document tracking, AzDO/GHA context detection, and completion injection (LRU items sortText 0_, standard items downgraded to 9_) - Wire yaml_ws_handler into server.py (replaces raw _ws_proxy call) - Load PipelineTemplateCatalog at startup; reload + health report template count - Update push_catalogs.sh to push pipeline_templates_catalog.json - Update Dockerfile to bake pipeline_templates_catalog.json as image fallback - Add tests/test_yaml_catalog.py (14 tests) + tests/test_yaml_proxy.py (18 tests) All 67 tests green
2026-05-10 15:59:37 +02:00
"pipeline_templates": PipelineTemplateCatalog.template_count(),
feat: add landing page at / Clean HTML page describing iLSP, what LSP is, the WebSocket endpoints, and setup instructions for Neovim, IntelliJ and VS Code. Live stats (Bicep modules, pipeline templates, PyPI packages) are rendered from the in-memory catalog at request time. No emojis. Minimal CSS, no external dependencies.
2026-05-10 18:17:14 +02:00
"azdo_pipeline_schema": _AZDO_SCHEMA_PATH.exists(),
feat: initial iLSP project scaffolding - Python LSP (pylsp + pylsp_i80 plugin): i80 pypi package completions - Bicep LSP (asyncio TCP proxy → Bicep.LangServer.dll): LRU module injection - Health HTTP endpoint (:2089) for Consul/Nomad checks - Startup catalog fetch from pypi-server.i80.dk + DevOpsMCP (no volume needed) - Multi-stage Dockerfile: downloads Bicep LS at build time, dotnet-runtime-8.0 + python3.12 - Nomad job: static TCP ports 2087/2088, health check on 2089 - Gitea Actions CI: build + push + deploy pipeline - Editor configs: Helix / nvim / LSP4IJ / VS Code
2026-05-10 12:23:05 +02:00
})
feat: volume-based catalog refresh with hot-reload - modules.py: check /data/ volume first, then baked-in /bicep_modules_catalog.json - server.py: add POST /reload endpoint — reloads catalogs without restart - ilsp.nomad: add 'ilsp-data' host volume mounted at /data - Makefile: add push-catalogs, health-prod, run-with-data targets; DEVOPS_MCP_REPO var - scripts/push_catalogs.sh: SCP both catalogs to autobox + call /reload Workflow: sync scripts on Mac → make push-catalogs → completions live in <5s
2026-05-10 13:51:01 +02:00
async def reload(_: web.Request) -> web.Response:
feat: YAML pipeline template autocomplete (AzDO + GHA) - Add scripts/sync_pipeline_templates.py — scans LRU AzDO and GHA template repos; outputs unified pipeline_templates_catalog.json (48 templates: 45 AzDO + 3 GHA) - Add scripts/template_sources.yml — source config (AzDO alias, GHA org) - Add pipeline_templates_catalog.json — baked catalog (49 KB) - Add ilsp/yaml_lsp/catalog.py — PipelineTemplateCatalog with completion item generators for template paths, param names, allowed values, GHA inputs - Add ilsp/yaml_lsp/proxy.py — async WS↔TCP bridge with LSP frame buffering, per-connection document tracking, AzDO/GHA context detection, and completion injection (LRU items sortText 0_, standard items downgraded to 9_) - Wire yaml_ws_handler into server.py (replaces raw _ws_proxy call) - Load PipelineTemplateCatalog at startup; reload + health report template count - Update push_catalogs.sh to push pipeline_templates_catalog.json - Update Dockerfile to bake pipeline_templates_catalog.json as image fallback - Add tests/test_yaml_catalog.py (14 tests) + tests/test_yaml_proxy.py (18 tests) All 67 tests green
2026-05-10 15:59:37 +02:00
before_bicep = len(BicepModuleCatalog._modules)
before_tmpl = PipelineTemplateCatalog.template_count()
feat: volume-based catalog refresh with hot-reload - modules.py: check /data/ volume first, then baked-in /bicep_modules_catalog.json - server.py: add POST /reload endpoint — reloads catalogs without restart - ilsp.nomad: add 'ilsp-data' host volume mounted at /data - Makefile: add push-catalogs, health-prod, run-with-data targets; DEVOPS_MCP_REPO var - scripts/push_catalogs.sh: SCP both catalogs to autobox + call /reload Workflow: sync scripts on Mac → make push-catalogs → completions live in <5s
2026-05-10 13:51:01 +02:00
BicepModuleCatalog.load()
feat: YAML pipeline template autocomplete (AzDO + GHA) - Add scripts/sync_pipeline_templates.py — scans LRU AzDO and GHA template repos; outputs unified pipeline_templates_catalog.json (48 templates: 45 AzDO + 3 GHA) - Add scripts/template_sources.yml — source config (AzDO alias, GHA org) - Add pipeline_templates_catalog.json — baked catalog (49 KB) - Add ilsp/yaml_lsp/catalog.py — PipelineTemplateCatalog with completion item generators for template paths, param names, allowed values, GHA inputs - Add ilsp/yaml_lsp/proxy.py — async WS↔TCP bridge with LSP frame buffering, per-connection document tracking, AzDO/GHA context detection, and completion injection (LRU items sortText 0_, standard items downgraded to 9_) - Wire yaml_ws_handler into server.py (replaces raw _ws_proxy call) - Load PipelineTemplateCatalog at startup; reload + health report template count - Update push_catalogs.sh to push pipeline_templates_catalog.json - Update Dockerfile to bake pipeline_templates_catalog.json as image fallback - Add tests/test_yaml_catalog.py (14 tests) + tests/test_yaml_proxy.py (18 tests) All 67 tests green
2026-05-10 15:59:37 +02:00
PipelineTemplateCatalog.load()
after_bicep = len(BicepModuleCatalog._modules)
after_tmpl = PipelineTemplateCatalog.template_count()
logger.info(
"Catalog reloaded: bicep %d→%d templates %d→%d",
before_bicep, after_bicep, before_tmpl, after_tmpl,
)
feat: volume-based catalog refresh with hot-reload - modules.py: check /data/ volume first, then baked-in /bicep_modules_catalog.json - server.py: add POST /reload endpoint — reloads catalogs without restart - ilsp.nomad: add 'ilsp-data' host volume mounted at /data - Makefile: add push-catalogs, health-prod, run-with-data targets; DEVOPS_MCP_REPO var - scripts/push_catalogs.sh: SCP both catalogs to autobox + call /reload Workflow: sync scripts on Mac → make push-catalogs → completions live in <5s
2026-05-10 13:51:01 +02:00
return web.json_response({
"status": "reloaded",
feat: YAML pipeline template autocomplete (AzDO + GHA) - Add scripts/sync_pipeline_templates.py — scans LRU AzDO and GHA template repos; outputs unified pipeline_templates_catalog.json (48 templates: 45 AzDO + 3 GHA) - Add scripts/template_sources.yml — source config (AzDO alias, GHA org) - Add pipeline_templates_catalog.json — baked catalog (49 KB) - Add ilsp/yaml_lsp/catalog.py — PipelineTemplateCatalog with completion item generators for template paths, param names, allowed values, GHA inputs - Add ilsp/yaml_lsp/proxy.py — async WS↔TCP bridge with LSP frame buffering, per-connection document tracking, AzDO/GHA context detection, and completion injection (LRU items sortText 0_, standard items downgraded to 9_) - Wire yaml_ws_handler into server.py (replaces raw _ws_proxy call) - Load PipelineTemplateCatalog at startup; reload + health report template count - Update push_catalogs.sh to push pipeline_templates_catalog.json - Update Dockerfile to bake pipeline_templates_catalog.json as image fallback - Add tests/test_yaml_catalog.py (14 tests) + tests/test_yaml_proxy.py (18 tests) All 67 tests green
2026-05-10 15:59:37 +02:00
"bicep_modules_before": before_bicep,
"bicep_modules_after": after_bicep,
"pipeline_templates_before": before_tmpl,
"pipeline_templates_after": after_tmpl,
feat: volume-based catalog refresh with hot-reload - modules.py: check /data/ volume first, then baked-in /bicep_modules_catalog.json - server.py: add POST /reload endpoint — reloads catalogs without restart - ilsp.nomad: add 'ilsp-data' host volume mounted at /data - Makefile: add push-catalogs, health-prod, run-with-data targets; DEVOPS_MCP_REPO var - scripts/push_catalogs.sh: SCP both catalogs to autobox + call /reload Workflow: sync scripts on Mac → make push-catalogs → completions live in <5s
2026-05-10 13:51:01 +02:00
})
refactor: single HTTP port, WebSocket proxy for LSP endpoints - Remove static ports 2087/2088/2089 from Nomad; use one dynamic port - pylsp and Bicep LS stay on localhost inside container (not exposed) - aiohttp adds /python and /bicep WebSocket routes bridging to localhost LSPs - Nomad env: HTTP_PORT=$NOMAD_PORT_http, internal ports fixed at 2087/2088 - Editors connect via ws://ilsp.i80.dk/python and ws://ilsp.i80.dk/bicep - Traefik routes ilsp.i80.dk → single dynamic HTTP port
2026-05-10 14:44:33 +02:00
async def python_ws(request: web.Request) -> web.WebSocketResponse:
return await _ws_proxy(request, "127.0.0.1", PYTHON_LSP_PORT)
async def bicep_ws(request: web.Request) -> web.WebSocketResponse:
return await _ws_proxy(request, "127.0.0.1", BICEP_LSP_PORT)
feat: YAML LSP (/yaml endpoint) + IAC source catalog enrichment - Add yaml-language-server (Node.js) to Dockerfile stage 3 - Add YAML_LSP_PORT=2090 env var (Dockerfile + ilsp.nomad) - Start yaml-language-server in background thread (_serve_yaml_lsp) - Expose /yaml WebSocket endpoint (same WS→TCP proxy as /python and /bicep) - Load iac_source_catalog.json alongside bicep_modules_catalog.json - Enrich param_completion_items() with descriptions + required flag from IAC source - Required params sorted first (sortText 0_lru_param_0_...) and marked with * - detail field shows * prefix for required params - Update /health to report iac_source_modules + yaml_lsp fields - Rewrite EDITOR_SETUP.md: WebSocket URLs, YAML schemas config for all editors (Helix, Neovim, PyCharm, VS Code) with azure-pipelines + gitea actions schemas - All 35 tests pass
2026-05-10 15:40:13 +02:00
async def yaml_ws(request: web.Request) -> web.WebSocketResponse:
fix: yaml stdio per-connection, iac catalog path, makefile port - yaml-language-server: rewrite to stdio per WebSocket (fixes crash loop) vscode-jsonrpc v9 createServerSocketTransport is a TCP client, not server now spawns yaml-language-server --stdio per connection via asyncio subprocess - bicep/modules.py: add /iac_source_catalog.json as first path in _IAC_SOURCE_PATHS Dockerfile copies to /iac_source_catalog.json but path wasn't listed - server.py: remove YAML_LSP_PORT daemon (no longer needed with stdio mode) - Makefile: add -e HTTP_PORT=$(HEALTH_PORT) to all docker run commands server defaulted to :8000 but Makefile exposed :2089 with no override
2026-05-10 16:37:42 +02:00
return await yaml_ws_handler(request)
feat: YAML LSP (/yaml endpoint) + IAC source catalog enrichment - Add yaml-language-server (Node.js) to Dockerfile stage 3 - Add YAML_LSP_PORT=2090 env var (Dockerfile + ilsp.nomad) - Start yaml-language-server in background thread (_serve_yaml_lsp) - Expose /yaml WebSocket endpoint (same WS→TCP proxy as /python and /bicep) - Load iac_source_catalog.json alongside bicep_modules_catalog.json - Enrich param_completion_items() with descriptions + required flag from IAC source - Required params sorted first (sortText 0_lru_param_0_...) and marked with * - detail field shows * prefix for required params - Update /health to report iac_source_modules + yaml_lsp fields - Rewrite EDITOR_SETUP.md: WebSocket URLs, YAML schemas config for all editors (Helix, Neovim, PyCharm, VS Code) with azure-pipelines + gitea actions schemas - All 35 tests pass
2026-05-10 15:40:13 +02:00
feat: add landing page at / Clean HTML page describing iLSP, what LSP is, the WebSocket endpoints, and setup instructions for Neovim, IntelliJ and VS Code. Live stats (Bicep modules, pipeline templates, PyPI packages) are rendered from the in-memory catalog at request time. No emojis. Minimal CSS, no external dependencies.
2026-05-10 18:17:14 +02:00
app.router.add_get("/", index)
feat: initial iLSP project scaffolding - Python LSP (pylsp + pylsp_i80 plugin): i80 pypi package completions - Bicep LSP (asyncio TCP proxy → Bicep.LangServer.dll): LRU module injection - Health HTTP endpoint (:2089) for Consul/Nomad checks - Startup catalog fetch from pypi-server.i80.dk + DevOpsMCP (no volume needed) - Multi-stage Dockerfile: downloads Bicep LS at build time, dotnet-runtime-8.0 + python3.12 - Nomad job: static TCP ports 2087/2088, health check on 2089 - Gitea Actions CI: build + push + deploy pipeline - Editor configs: Helix / nvim / LSP4IJ / VS Code
2026-05-10 12:23:05 +02:00
app.router.add_get("/health", health)
feat: volume-based catalog refresh with hot-reload - modules.py: check /data/ volume first, then baked-in /bicep_modules_catalog.json - server.py: add POST /reload endpoint — reloads catalogs without restart - ilsp.nomad: add 'ilsp-data' host volume mounted at /data - Makefile: add push-catalogs, health-prod, run-with-data targets; DEVOPS_MCP_REPO var - scripts/push_catalogs.sh: SCP both catalogs to autobox + call /reload Workflow: sync scripts on Mac → make push-catalogs → completions live in <5s
2026-05-10 13:51:01 +02:00
app.router.add_post("/reload", reload)
refactor: single HTTP port, WebSocket proxy for LSP endpoints - Remove static ports 2087/2088/2089 from Nomad; use one dynamic port - pylsp and Bicep LS stay on localhost inside container (not exposed) - aiohttp adds /python and /bicep WebSocket routes bridging to localhost LSPs - Nomad env: HTTP_PORT=$NOMAD_PORT_http, internal ports fixed at 2087/2088 - Editors connect via ws://ilsp.i80.dk/python and ws://ilsp.i80.dk/bicep - Traefik routes ilsp.i80.dk → single dynamic HTTP port
2026-05-10 14:44:33 +02:00
app.router.add_get("/python", python_ws)
app.router.add_get("/bicep", bicep_ws)
feat: YAML LSP (/yaml endpoint) + IAC source catalog enrichment - Add yaml-language-server (Node.js) to Dockerfile stage 3 - Add YAML_LSP_PORT=2090 env var (Dockerfile + ilsp.nomad) - Start yaml-language-server in background thread (_serve_yaml_lsp) - Expose /yaml WebSocket endpoint (same WS→TCP proxy as /python and /bicep) - Load iac_source_catalog.json alongside bicep_modules_catalog.json - Enrich param_completion_items() with descriptions + required flag from IAC source - Required params sorted first (sortText 0_lru_param_0_...) and marked with * - detail field shows * prefix for required params - Update /health to report iac_source_modules + yaml_lsp fields - Rewrite EDITOR_SETUP.md: WebSocket URLs, YAML schemas config for all editors (Helix, Neovim, PyCharm, VS Code) with azure-pipelines + gitea actions schemas - All 35 tests pass
2026-05-10 15:40:13 +02:00
app.router.add_get("/yaml", yaml_ws)
feat: initial iLSP project scaffolding - Python LSP (pylsp + pylsp_i80 plugin): i80 pypi package completions - Bicep LSP (asyncio TCP proxy → Bicep.LangServer.dll): LRU module injection - Health HTTP endpoint (:2089) for Consul/Nomad checks - Startup catalog fetch from pypi-server.i80.dk + DevOpsMCP (no volume needed) - Multi-stage Dockerfile: downloads Bicep LS at build time, dotnet-runtime-8.0 + python3.12 - Nomad job: static TCP ports 2087/2088, health check on 2089 - Gitea Actions CI: build + push + deploy pipeline - Editor configs: Helix / nvim / LSP4IJ / VS Code
2026-05-10 12:23:05 +02:00
return app
async def main_async() -> None:
logging.basicConfig(
level=logging.INFO,
format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
)
logger.info("Pre-warming catalogs…")
feat: bake bicep catalog into image; fix dict-based modules parsing - Remove all DevOpsMCP/aiohttp runtime deps from BicepModuleCatalog - BicepModuleCatalog.load() reads bicep_modules_catalog.json from disk at startup (sync) - Fix _load_catalog: catalog uses dict {path: {versions, schema}} not a list - server.py: call BicepModuleCatalog.load() synchronously, not via asyncio.gather - Dockerfile: COPY bicep_modules_catalog.json into both builder + runtime stages - Health endpoint now reports bicep_modules: 27 Verified locally: make run-quick → health returns pypi_packages:40 bicep_modules:27
2026-05-10 13:40:48 +02:00
BicepModuleCatalog.load()
feat: YAML pipeline template autocomplete (AzDO + GHA) - Add scripts/sync_pipeline_templates.py — scans LRU AzDO and GHA template repos; outputs unified pipeline_templates_catalog.json (48 templates: 45 AzDO + 3 GHA) - Add scripts/template_sources.yml — source config (AzDO alias, GHA org) - Add pipeline_templates_catalog.json — baked catalog (49 KB) - Add ilsp/yaml_lsp/catalog.py — PipelineTemplateCatalog with completion item generators for template paths, param names, allowed values, GHA inputs - Add ilsp/yaml_lsp/proxy.py — async WS↔TCP bridge with LSP frame buffering, per-connection document tracking, AzDO/GHA context detection, and completion injection (LRU items sortText 0_, standard items downgraded to 9_) - Wire yaml_ws_handler into server.py (replaces raw _ws_proxy call) - Load PipelineTemplateCatalog at startup; reload + health report template count - Update push_catalogs.sh to push pipeline_templates_catalog.json - Update Dockerfile to bake pipeline_templates_catalog.json as image fallback - Add tests/test_yaml_catalog.py (14 tests) + tests/test_yaml_proxy.py (18 tests) All 67 tests green
2026-05-10 15:59:37 +02:00
PipelineTemplateCatalog.load()
feat: bake bicep catalog into image; fix dict-based modules parsing - Remove all DevOpsMCP/aiohttp runtime deps from BicepModuleCatalog - BicepModuleCatalog.load() reads bicep_modules_catalog.json from disk at startup (sync) - Fix _load_catalog: catalog uses dict {path: {versions, schema}} not a list - server.py: call BicepModuleCatalog.load() synchronously, not via asyncio.gather - Dockerfile: COPY bicep_modules_catalog.json into both builder + runtime stages - Health endpoint now reports bicep_modules: 27 Verified locally: make run-quick → health returns pypi_packages:40 bicep_modules:27
2026-05-10 13:40:48 +02:00
await PypiCatalog.start_background_refresh()
feat: initial iLSP project scaffolding - Python LSP (pylsp + pylsp_i80 plugin): i80 pypi package completions - Bicep LSP (asyncio TCP proxy → Bicep.LangServer.dll): LRU module injection - Health HTTP endpoint (:2089) for Consul/Nomad checks - Startup catalog fetch from pypi-server.i80.dk + DevOpsMCP (no volume needed) - Multi-stage Dockerfile: downloads Bicep LS at build time, dotnet-runtime-8.0 + python3.12 - Nomad job: static TCP ports 2087/2088, health check on 2089 - Gitea Actions CI: build + push + deploy pipeline - Editor configs: Helix / nvim / LSP4IJ / VS Code
2026-05-10 12:23:05 +02:00
refactor: single HTTP port, WebSocket proxy for LSP endpoints - Remove static ports 2087/2088/2089 from Nomad; use one dynamic port - pylsp and Bicep LS stay on localhost inside container (not exposed) - aiohttp adds /python and /bicep WebSocket routes bridging to localhost LSPs - Nomad env: HTTP_PORT=$NOMAD_PORT_http, internal ports fixed at 2087/2088 - Editors connect via ws://ilsp.i80.dk/python and ws://ilsp.i80.dk/bicep - Traefik routes ilsp.i80.dk → single dynamic HTTP port
2026-05-10 14:44:33 +02:00
# LSP servers run internally on localhost — not exposed outside the container
feat: bake bicep catalog into image; fix dict-based modules parsing - Remove all DevOpsMCP/aiohttp runtime deps from BicepModuleCatalog - BicepModuleCatalog.load() reads bicep_modules_catalog.json from disk at startup (sync) - Fix _load_catalog: catalog uses dict {path: {versions, schema}} not a list - server.py: call BicepModuleCatalog.load() synchronously, not via asyncio.gather - Dockerfile: COPY bicep_modules_catalog.json into both builder + runtime stages - Health endpoint now reports bicep_modules: 27 Verified locally: make run-quick → health returns pypi_packages:40 bicep_modules:27
2026-05-10 13:40:48 +02:00
threading.Thread(target=_serve_python_lsp, args=(PYTHON_LSP_PORT,), daemon=True).start()
threading.Thread(target=serve_bicep, args=(BICEP_LSP_PORT,), daemon=True).start()
fix: yaml stdio per-connection, iac catalog path, makefile port - yaml-language-server: rewrite to stdio per WebSocket (fixes crash loop) vscode-jsonrpc v9 createServerSocketTransport is a TCP client, not server now spawns yaml-language-server --stdio per connection via asyncio subprocess - bicep/modules.py: add /iac_source_catalog.json as first path in _IAC_SOURCE_PATHS Dockerfile copies to /iac_source_catalog.json but path wasn't listed - server.py: remove YAML_LSP_PORT daemon (no longer needed with stdio mode) - Makefile: add -e HTTP_PORT=$(HEALTH_PORT) to all docker run commands server defaulted to :8000 but Makefile exposed :2089 with no override
2026-05-10 16:37:42 +02:00
# yaml-language-server is spawned per-connection in yaml_ws_handler (--stdio mode)
fix: replace asyncio subprocess proxy with thread-based Popen proxy asyncio subprocess PIPE unreliable for long-lived stdio bridging. Use Popen + threads instead. Also fix smoke_test.sh stdin handling.
2026-05-10 13:02:52 +02:00
refactor: single HTTP port, WebSocket proxy for LSP endpoints - Remove static ports 2087/2088/2089 from Nomad; use one dynamic port - pylsp and Bicep LS stay on localhost inside container (not exposed) - aiohttp adds /python and /bicep WebSocket routes bridging to localhost LSPs - Nomad env: HTTP_PORT=$NOMAD_PORT_http, internal ports fixed at 2087/2088 - Editors connect via ws://ilsp.i80.dk/python and ws://ilsp.i80.dk/bicep - Traefik routes ilsp.i80.dk → single dynamic HTTP port
2026-05-10 14:44:33 +02:00
app = await _build_app()
runner = web.AppRunner(app)
feat: initial iLSP project scaffolding - Python LSP (pylsp + pylsp_i80 plugin): i80 pypi package completions - Bicep LSP (asyncio TCP proxy → Bicep.LangServer.dll): LRU module injection - Health HTTP endpoint (:2089) for Consul/Nomad checks - Startup catalog fetch from pypi-server.i80.dk + DevOpsMCP (no volume needed) - Multi-stage Dockerfile: downloads Bicep LS at build time, dotnet-runtime-8.0 + python3.12 - Nomad job: static TCP ports 2087/2088, health check on 2089 - Gitea Actions CI: build + push + deploy pipeline - Editor configs: Helix / nvim / LSP4IJ / VS Code
2026-05-10 12:23:05 +02:00
await runner.setup()
refactor: single HTTP port, WebSocket proxy for LSP endpoints - Remove static ports 2087/2088/2089 from Nomad; use one dynamic port - pylsp and Bicep LS stay on localhost inside container (not exposed) - aiohttp adds /python and /bicep WebSocket routes bridging to localhost LSPs - Nomad env: HTTP_PORT=$NOMAD_PORT_http, internal ports fixed at 2087/2088 - Editors connect via ws://ilsp.i80.dk/python and ws://ilsp.i80.dk/bicep - Traefik routes ilsp.i80.dk → single dynamic HTTP port
2026-05-10 14:44:33 +02:00
site = web.TCPSite(runner, "0.0.0.0", HTTP_PORT)
feat: initial iLSP project scaffolding - Python LSP (pylsp + pylsp_i80 plugin): i80 pypi package completions - Bicep LSP (asyncio TCP proxy → Bicep.LangServer.dll): LRU module injection - Health HTTP endpoint (:2089) for Consul/Nomad checks - Startup catalog fetch from pypi-server.i80.dk + DevOpsMCP (no volume needed) - Multi-stage Dockerfile: downloads Bicep LS at build time, dotnet-runtime-8.0 + python3.12 - Nomad job: static TCP ports 2087/2088, health check on 2089 - Gitea Actions CI: build + push + deploy pipeline - Editor configs: Helix / nvim / LSP4IJ / VS Code
2026-05-10 12:23:05 +02:00
await site.start()
feat: YAML LSP (/yaml endpoint) + IAC source catalog enrichment - Add yaml-language-server (Node.js) to Dockerfile stage 3 - Add YAML_LSP_PORT=2090 env var (Dockerfile + ilsp.nomad) - Start yaml-language-server in background thread (_serve_yaml_lsp) - Expose /yaml WebSocket endpoint (same WS→TCP proxy as /python and /bicep) - Load iac_source_catalog.json alongside bicep_modules_catalog.json - Enrich param_completion_items() with descriptions + required flag from IAC source - Required params sorted first (sortText 0_lru_param_0_...) and marked with * - detail field shows * prefix for required params - Update /health to report iac_source_modules + yaml_lsp fields - Rewrite EDITOR_SETUP.md: WebSocket URLs, YAML schemas config for all editors (Helix, Neovim, PyCharm, VS Code) with azure-pipelines + gitea actions schemas - All 35 tests pass
2026-05-10 15:40:13 +02:00
logger.info(
"iLSP HTTP on http://0.0.0.0:%d (ws://.../python ws://.../bicep ws://.../yaml)",
HTTP_PORT,
)
feat: initial iLSP project scaffolding - Python LSP (pylsp + pylsp_i80 plugin): i80 pypi package completions - Bicep LSP (asyncio TCP proxy → Bicep.LangServer.dll): LRU module injection - Health HTTP endpoint (:2089) for Consul/Nomad checks - Startup catalog fetch from pypi-server.i80.dk + DevOpsMCP (no volume needed) - Multi-stage Dockerfile: downloads Bicep LS at build time, dotnet-runtime-8.0 + python3.12 - Nomad job: static TCP ports 2087/2088, health check on 2089 - Gitea Actions CI: build + push + deploy pipeline - Editor configs: Helix / nvim / LSP4IJ / VS Code
2026-05-10 12:23:05 +02:00
feat: bake bicep catalog into image; fix dict-based modules parsing - Remove all DevOpsMCP/aiohttp runtime deps from BicepModuleCatalog - BicepModuleCatalog.load() reads bicep_modules_catalog.json from disk at startup (sync) - Fix _load_catalog: catalog uses dict {path: {versions, schema}} not a list - server.py: call BicepModuleCatalog.load() synchronously, not via asyncio.gather - Dockerfile: COPY bicep_modules_catalog.json into both builder + runtime stages - Health endpoint now reports bicep_modules: 27 Verified locally: make run-quick → health returns pypi_packages:40 bicep_modules:27
2026-05-10 13:40:48 +02:00
await asyncio.Event().wait()
feat: initial iLSP project scaffolding - Python LSP (pylsp + pylsp_i80 plugin): i80 pypi package completions - Bicep LSP (asyncio TCP proxy → Bicep.LangServer.dll): LRU module injection - Health HTTP endpoint (:2089) for Consul/Nomad checks - Startup catalog fetch from pypi-server.i80.dk + DevOpsMCP (no volume needed) - Multi-stage Dockerfile: downloads Bicep LS at build time, dotnet-runtime-8.0 + python3.12 - Nomad job: static TCP ports 2087/2088, health check on 2089 - Gitea Actions CI: build + push + deploy pipeline - Editor configs: Helix / nvim / LSP4IJ / VS Code
2026-05-10 12:23:05 +02:00
def main() -> None:
loop = asyncio.new_event_loop()
for sig in (signal.SIGTERM, signal.SIGINT):
loop.add_signal_handler(sig, loop.stop)
loop.run_until_complete(main_async())
Reference in New Issue Copy Permalink