@rdfc/js-runner 3.0.3 → 3.0.4-remote

package/lib/server.js

@@ -0,0 +1,459 @@
+import { createServer } from 'node:http';
+import { readFile } from 'node:fs/promises';
+import { resolve, relative } from 'node:path';
+import { Parser } from 'n3';
+import { extractShapes } from 'rdf-lens';
+import { start } from './client.js';
+import { State } from './state.js';
+const RDFC = 'https://w3id.org/rdf-connect#';
+const OWL_IMPORTS = 'http://www.w3.org/2002/07/owl#imports';
+const RDF_TYPE = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type';
+const RDFS_LABEL = 'http://www.w3.org/2000/01/rdf-schema#label';
+const RDFS_COMMENT = 'http://www.w3.org/2000/01/rdf-schema#comment';
+const CONFIG_SHAPE_TTL = `
+@prefix rdfc: <https://w3id.org/rdf-connect#>.
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#>.
+@prefix sh: <http://www.w3.org/ns/shacl#>.
+
+[] a sh:NodeShape;
+  sh:targetClass rdfc:JsRunnerServer;
+  sh:property [
+    sh:path rdfc:port;
+    sh:name "port";
+    sh:maxCount 1;
+    sh:datatype xsd:integer;
+  ], [
+    sh:path rdfc:processorConfig;
+    sh:name "processorConfigs";
+    sh:datatype xsd:string;
+  ].
+`;
+const { lenses } = extractShapes(new Parser().parse(CONFIG_SHAPE_TTL));
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        let body = '';
+        req.on('data', (chunk) => (body += chunk));
+        req.on('end', () => resolve(body));
+        req.on('error', reject);
+    });
+}
+export async function parseServerConfig(configPath) {
+    const absConfig = resolve(configPath);
+    const content = await readFile(absConfig, { encoding: 'utf8' });
+    const quads = new Parser({ baseIRI: 'file://' + absConfig }).parse(content);
+    const serverSubject = quads.find((q) => q.predicate.value === RDF_TYPE &&
+        q.object.value === RDFC + 'JsRunnerServer')?.subject;
+    if (!serverSubject) {
+        throw new Error(`No rdfc:JsRunnerServer found in ${absConfig}`);
+    }
+    const config = lenses[RDFC + 'JsRunnerServer'].execute({
+        id: serverSubject,
+        quads,
+    });
+    const port = config.port ?? 3000;
+    const processorPaths = (config.processorConfigs ?? []).map((val) => val.startsWith('file://') ? val.slice('file://'.length) : val);
+    return { port, processorPaths };
+}
+export async function buildWhitelist(processorPaths) {
+    const whitelist = new Set();
+    const done = new Set();
+    const todo = [...processorPaths];
+    while (todo.length > 0) {
+        const filePath = todo.pop();
+        if (done.has(filePath))
+            continue;
+        done.add(filePath);
+        whitelist.add(filePath);
+        let content;
+        try {
+            content = await readFile(filePath, { encoding: 'utf8' });
+        }
+        catch {
+            continue;
+        }
+        const baseIRI = 'file://' + filePath;
+        const quads = new Parser({ baseIRI }).parse(content);
+        for (const quad of quads) {
+            if (quad.subject.value === baseIRI &&
+                quad.predicate.value === OWL_IMPORTS) {
+                const importVal = quad.object.value;
+                if (importVal.startsWith('file://')) {
+                    todo.push(importVal.slice('file://'.length));
+                }
+            }
+        }
+    }
+    return whitelist;
+}
+async function extractProcessorDescriptions(processorPaths) {
+    const descriptions = [];
+    for (const filePath of processorPaths) {
+        let content;
+        try {
+            content = await readFile(filePath, { encoding: 'utf8' });
+        }
+        catch {
+            continue;
+        }
+        const baseIRI = 'file://' + filePath;
+        const quads = new Parser({ baseIRI }).parse(content);
+        const seen = new Set();
+        for (const quad of quads) {
+            if (quad.predicate.value !== RDFC + 'jsImplementationOf')
+                continue;
+            const uri = quad.subject.value;
+            if (seen.has(uri))
+                continue;
+            seen.add(uri);
+            const labelQuad = quads.find((q) => q.subject.value === uri && q.predicate.value === RDFS_LABEL);
+            const commentQuad = quads.find((q) => q.subject.value === uri && q.predicate.value === RDFS_COMMENT);
+            descriptions.push({
+                uri,
+                label: labelQuad?.object.value,
+                comment: commentQuad?.object.value,
+                sourceFile: filePath,
+            });
+        }
+    }
+    return descriptions;
+}
+export async function generateIndexTtl(processorPaths, cwd) {
+    const descriptions = await extractProcessorDescriptions(processorPaths);
+    const lines = `
+@prefix prov: <http://www.w3.org/ns/prov#>.
+@prefix sds: <https://w3id.org/sds#>.
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>.
+@prefix owl: <http://www.w3.org/2002/07/owl#>.
+@prefix rdfl: <https://w3id.org/rdf-lens/ontology#>.
+@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>.
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#>.
+@prefix sh: <http://www.w3.org/ns/shacl#>.
+@prefix rdfc: <https://w3id.org/rdf-connect#>.
+
+sds:Activity rdfs:subClassOf prov:Activity.
+rdfc:Processor rdfs:subClassOf sds:Activity.
+sds:implementationOf rdfs:subPropertyOf rdfs:subClassOf.
+rdfc:jsImplementationOf rdfs:subPropertyOf sds:implementationOf.
+[ ] a sh:NodeShape;
+  sh:targetSubjectsOf rdfc:jsImplementationOf;
+  sh:property [
+    sh:path rdfc:entrypoint;
+    sh:name "location";
+    sh:minCount 1;
+    sh:maxCount 1;
+    sh:datatype xsd:string;
+  ], [
+    sh:path rdfc:file;
+    sh:name "file";
+    sh:minCount 1;
+    sh:maxCount 1;
+    sh:datatype xsd:string;
+  ], [
+    sh:path rdfc:class;
+    sh:name "clazz";
+    sh:maxCount 1;
+    sh:datatype xsd:string;
+  ].
+
+<runner> a rdfc:HttpRunner;
+  rdfc:handlesSubjectsOf rdfc:jsImplementationOf;
+  rdfc:endpoint <./connect>.
+`.split('\n');
+    for (const desc of descriptions) {
+        const relPath = relative(cwd, desc.sourceFile);
+        lines.push(`<${desc.uri}> a rdfc:Processor;`);
+        if (desc.label) {
+            lines.push(`  rdfs:label "${desc.label.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}";`);
+        }
+        if (desc.comment) {
+            lines.push(`  rdfs:comment "${desc.comment.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}";`);
+        }
+        lines.push(`  rdfs:isDefinedBy <${relPath}>.`);
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+function dashboardHtml() {
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>js-runner dashboard</title>
+  <style>
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+    body { font-family: 'Courier New', monospace; background: #111; color: #ccc; padding: 1.5rem; }
+    h1 { color: #7ec8e3; margin-bottom: 1rem; font-size: 1.4rem; }
+    #updated { font-size: 0.75rem; color: #555; margin-bottom: 1.5rem; }
+    .runner { border: 1px solid #333; border-radius: 6px; padding: 1rem; margin-bottom: 1.25rem; }
+    .runner-meta { display: flex; flex-wrap: wrap; gap: 1.5rem; margin-bottom: 0.75rem; font-size: 0.85rem; }
+    .runner-meta span { color: #888; }
+    .runner-meta strong { color: #aaa; }
+    .status { font-weight: bold; }
+    .s-connecting { color: #f0a500; }
+    .s-running    { color: #4caf50; }
+    .s-done       { color: #666; }
+    .s-error      { color: #f44336; }
+    .g-IDLE              { color: #888; }
+    .g-CONNECTING        { color: #f0a500; }
+    .g-READY             { color: #4caf50; }
+    .g-TRANSIENT_FAILURE { color: #f44336; }
+    .g-SHUTDOWN          { color: #666; }
+    table { width: 100%; border-collapse: collapse; font-size: 0.8rem; }
+    th, td { border: 1px solid #2a2a2a; padding: 0.4rem 0.8rem; text-align: left; white-space: nowrap; }
+    th { background: #1a1a1a; color: #7ec8e3; }
+    td.uri { color: #aaa; max-width: 28rem; overflow: hidden; text-overflow: ellipsis; }
+    td.role-reader { color: #81c784; }
+    td.role-writer { color: #64b5f6; }
+    .empty { color: #555; font-size: 0.8rem; padding-top: 0.5rem; }
+    .no-runners { color: #555; }
+  </style>
+</head>
+<body>
+  <h1>js-runner dashboard</h1>
+  <div id="updated"></div>
+  <div id="content"><p class="no-runners">Loading…</p></div>
+  <script>
+    const throughputState = {}
+
+    function esc(s) {
+      return String(s).replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;')
+    }
+    function fmtBytes(b) {
+      if (b < 1024) return b + ' B'
+      if (b < 1048576) return (b/1024).toFixed(1) + ' KB'
+      return (b/1048576).toFixed(1) + ' MB'
+    }
+    function fmtAge(ms) {
+      if (!ms) return '-'
+      const s = Math.floor((Date.now() - ms) / 1000)
+      if (s < 5) return 'just now'
+      if (s < 60) return s + 's ago'
+      if (s < 3600) return Math.floor(s/60) + 'm ago'
+      return Math.floor(s/3600) + 'h ago'
+    }
+    function fmtDuration(ms) {
+      const s = Math.floor((Date.now() - ms) / 1000)
+      if (s < 60) return s + 's'
+      if (s < 3600) return Math.floor(s/60) + 'm ' + (s%60) + 's'
+      return Math.floor(s/3600) + 'h ' + Math.floor((s%3600)/60) + 'm'
+    }
+    function pct(arr, p) {
+      if (!arr || !arr.length) return '-'
+      const s = [...arr].sort((a,b) => a-b)
+      return s[Math.floor(p/100*s.length)] + 'ms'
+    }
+    function avg(arr) {
+      if (!arr || !arr.length) return '-'
+      return (arr.reduce((a,b)=>a+b,0)/arr.length).toFixed(1) + 'ms'
+    }
+    function throughput(key, count) {
+      const now = Date.now()
+      if (!throughputState[key]) { throughputState[key] = {count, time: now}; return '-' }
+      const dt = (now - throughputState[key].time) / 1000
+      const dc = count - throughputState[key].count
+      throughputState[key] = {count, time: now}
+      if (dt < 0.1) return '-'
+      return (dc / dt).toFixed(1) + '/s'
+    }
+
+    function renderChannels(runnerId, channels) {
+      const entries = Object.values(channels)
+      if (!entries.length) return '<p class="empty">No channels yet.</p>'
+      return \`<table>
+        <thead>
+          <tr>
+            <th>Channel URI</th>
+            <th>Role</th>
+            <th>Messages</th>
+            <th>Throughput</th>
+            <th>Bytes</th>
+            <th>Last msg</th>
+            <th>Avg latency</th>
+            <th>p50</th>
+            <th>p99</th>
+          </tr>
+        </thead>
+        <tbody>
+          \${entries.map(ch => {
+            const key = runnerId + ':' + ch.uri
+            const tp = throughput(key, ch.messageCount)
+            return \`<tr>
+              <td class="uri" title="\${esc(ch.uri)}">\${esc(ch.uri)}</td>
+              <td class="role-\${ch.role}">\${ch.role}</td>
+              <td>\${ch.messageCount}</td>
+              <td>\${tp}</td>
+              <td>\${fmtBytes(ch.bytesTotal)}</td>
+              <td>\${fmtAge(ch.lastMessageAt)}</td>
+              <td>\${ch.role === 'writer' ? avg(ch.latenciesMs) : '-'}</td>
+              <td>\${ch.role === 'writer' ? pct(ch.latenciesMs, 50) : '-'}</td>
+              <td>\${ch.role === 'writer' ? pct(ch.latenciesMs, 99) : '-'}</td>
+            </tr>\`
+          }).join('')}
+        </tbody>
+      </table>\`
+    }
+
+    function render(runners) {
+      const el = document.getElementById('content')
+      if (!runners.length) {
+        el.innerHTML = '<p class="no-runners">No runners registered yet.</p>'
+        return
+      }
+      el.innerHTML = runners.map(r => \`
+        <div class="runner">
+          <div class="runner-meta">
+            <span><strong>URI:</strong> \${esc(r.uri)}</span>
+            <span><strong>Host:</strong> \${esc(r.host)}</span>
+            <span><strong>Status:</strong> <span class="status s-\${r.status}">\${r.status}</span></span>
+            <span><strong>gRPC:</strong> <span class="g-\${r.grpcState}">\${r.grpcState}</span></span>
+            <span><strong>Uptime:</strong> \${fmtDuration(r.connectedAt)}</span>
+          </div>
+          \${renderChannels(r.id, r.channels)}
+        </div>
+      \`).join('')
+    }
+
+    async function refresh() {
+      try {
+        const res = await fetch('/api/state')
+        const data = await res.json()
+        render(data)
+        document.getElementById('updated').textContent =
+          'Last updated: ' + new Date().toLocaleTimeString()
+      } catch (e) {
+        document.getElementById('content').innerHTML =
+          '<p style="color:#f44336">Failed to fetch state: ' + esc(e.message) + '</p>'
+      }
+    }
+
+    refresh()
+    setInterval(refresh, 2000)
+  </script>
+</body>
+</html>`;
+}
+export async function serve(configPath) {
+    const absConfig = resolve(configPath);
+    const { port, processorPaths } = await parseServerConfig(absConfig);
+    const whitelist = await buildWhitelist(processorPaths);
+    const cwd = process.cwd();
+    const indexTtl = await generateIndexTtl(processorPaths, cwd);
+    const state = new State();
+    const activeConnections = new Set();
+    const shutdown = (signal) => {
+        console.log(`\nReceived ${signal}, closing ${activeConnections.size} active gRPC connection(s)...`);
+        for (const ctrl of activeConnections)
+            ctrl.abort();
+        server.close(() => process.exit(0));
+    };
+    process.on('SIGINT', () => shutdown('SIGINT'));
+    process.on('SIGTERM', () => shutdown('SIGTERM'));
+    const server = createServer(async (req, res) => {
+        const method = req.method ?? 'GET';
+        const url = req.url ?? '/';
+        if (method === 'GET' && url === '/health') {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                status: 'ok',
+                runners: state.snapshot().length,
+                activeConnections: activeConnections.size,
+            }));
+            return;
+        }
+        if (method === 'GET' && url === '/api/state') {
+            res.writeHead(200, {
+                'Content-Type': 'application/json',
+                'Cache-Control': 'no-store',
+            });
+            res.end(JSON.stringify(state.snapshot()));
+            return;
+        }
+        if (method === 'GET' && url === '/dashboard') {
+            res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+            res.end(dashboardHtml());
+            return;
+        }
+        if (method === 'GET' && url === '/') {
+            res.writeHead(200, { 'Content-Type': 'text/turtle' });
+            res.end(indexTtl);
+            return;
+        }
+        if (method === 'GET') {
+            const reqPath = url.startsWith('/') ? url.slice(1) : url;
+            const absPath = resolve(cwd, reqPath);
+            if (!whitelist.has(absPath)) {
+                res.writeHead(403, { 'Content-Type': 'text/plain' });
+                res.end('Forbidden');
+                return;
+            }
+            let content;
+            try {
+                content = await readFile(absPath, { encoding: 'utf8' });
+            }
+            catch {
+                res.writeHead(404, { 'Content-Type': 'text/plain' });
+                res.end('Not found');
+                return;
+            }
+            res.writeHead(200, { 'Content-Type': 'text/turtle' });
+            res.end(content);
+            return;
+        }
+        if (method === 'POST' && url === '/connect') {
+            let body;
+            try {
+                body = await readBody(req);
+            }
+            catch {
+                res.writeHead(400, { 'Content-Type': 'text/plain' });
+                res.end('Failed to read request body');
+                return;
+            }
+            let parsed;
+            try {
+                parsed = JSON.parse(body);
+            }
+            catch {
+                res.writeHead(400, { 'Content-Type': 'text/plain' });
+                res.end('Invalid JSON');
+                return;
+            }
+            const { host, uri } = parsed;
+            if (typeof host !== 'string' || typeof uri !== 'string') {
+                res.writeHead(400, { 'Content-Type': 'text/plain' });
+                res.end('Missing host or uri');
+                return;
+            }
+            const runnerId = state.registerRunner(host, uri);
+            const ctrl = new AbortController();
+            activeConnections.add(ctrl);
+            start(host, uri, absConfig, ctrl.signal, state, runnerId)
+                .catch((err) => {
+                console.error('gRPC connection error:', err);
+                state.markError(runnerId);
+            })
+                .finally(() => {
+                activeConnections.delete(ctrl);
+                state.deregisterRunner(runnerId);
+            });
+            res.writeHead(202, {
+                'Content-Type': 'application/json',
+                Location: '/dashboard',
+            });
+            res.end(JSON.stringify({ runnerId }));
+            return;
+        }
+        res.writeHead(404, { 'Content-Type': 'text/plain' });
+        res.end('Not found');
+    });
+    await new Promise((resolve) => {
+        server.listen(port, () => {
+            console.log(`js-runner server listening on port ${port}`);
+            console.log(`  Dashboard: http://localhost:${port}/dashboard`);
+            console.log(`  Health:    http://localhost:${port}/health`);
+            console.log(`  State API: http://localhost:${port}/api/state`);
+            resolve();
+        });
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"server.js","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"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","sourcesContent":["import { createServer, IncomingMessage } from 'node:http'\nimport { readFile } from 'node:fs/promises'\nimport { resolve, relative } from 'node:path'\nimport { Parser } from 'n3'\nimport { extractShapes } from 'rdf-lens'\nimport { start } from './client.js'\nimport { State } from './state.js'\n\nconst RDFC = 'https://w3id.org/rdf-connect#'\nconst OWL_IMPORTS = 'http://www.w3.org/2002/07/owl#imports'\nconst RDF_TYPE = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type'\nconst RDFS_LABEL = 'http://www.w3.org/2000/01/rdf-schema#label'\nconst RDFS_COMMENT = 'http://www.w3.org/2000/01/rdf-schema#comment'\n\n// SHACL shape for rdfc:JsRunnerServer config files\nconst CONFIG_SHAPE_TTL = `\n@prefix rdfc: <https://w3id.org/rdf-connect#>.\n@prefix xsd: <http://www.w3.org/2001/XMLSchema#>.\n@prefix sh: <http://www.w3.org/ns/shacl#>.\n\n[] a sh:NodeShape;\n  sh:targetClass rdfc:JsRunnerServer;\n  sh:property [\n    sh:path rdfc:port;\n    sh:name \"port\";\n    sh:maxCount 1;\n    sh:datatype xsd:integer;\n  ], [\n    sh:path rdfc:processorConfig;\n    sh:name \"processorConfigs\";\n    sh:datatype xsd:string;\n  ].\n`\n\nconst { lenses } = extractShapes(new Parser().parse(CONFIG_SHAPE_TTL))\n\ninterface ServerConfig {\n  port: number\n  processorPaths: string[]\n}\n\ninterface ProcessorDescription {\n  uri: string\n  label?: string\n  comment?: string\n  sourceFile: string\n}\n\nfunction readBody(req: IncomingMessage): Promise<string> {\n  return new Promise((resolve, reject) => {\n    let body = ''\n    req.on('data', (chunk) => (body += chunk))\n    req.on('end', () => resolve(body))\n    req.on('error', reject)\n  })\n}\n\nexport async function parseServerConfig(\n  configPath: string,\n): Promise<ServerConfig> {\n  const absConfig = resolve(configPath)\n  const content = await readFile(absConfig, { encoding: 'utf8' })\n  const quads = new Parser({ baseIRI: 'file://' + absConfig }).parse(content)\n\n  const serverSubject = quads.find(\n    (q) =>\n      q.predicate.value === RDF_TYPE &&\n      q.object.value === RDFC + 'JsRunnerServer',\n  )?.subject\n\n  if (!serverSubject) {\n    throw new Error(`No rdfc:JsRunnerServer found in ${absConfig}`)\n  }\n\n  const config = lenses[RDFC + 'JsRunnerServer'].execute({\n    id: serverSubject,\n    quads,\n  }) as { port?: number; processorConfigs?: string[] }\n\n  const port = config.port ?? 3000\n  const processorPaths = (config.processorConfigs ?? []).map((val) =>\n    val.startsWith('file://') ? val.slice('file://'.length) : val,\n  )\n\n  return { port, processorPaths }\n}\n\nexport async function buildWhitelist(\n  processorPaths: string[],\n): Promise<Set<string>> {\n  const whitelist = new Set<string>()\n  const done = new Set<string>()\n  const todo: string[] = [...processorPaths]\n\n  while (todo.length > 0) {\n    const filePath = todo.pop()!\n    if (done.has(filePath)) continue\n    done.add(filePath)\n    whitelist.add(filePath)\n\n    let content: string\n    try {\n      content = await readFile(filePath, { encoding: 'utf8' })\n    } catch {\n      continue\n    }\n\n    const baseIRI = 'file://' + filePath\n    const quads = new Parser({ baseIRI }).parse(content)\n\n    for (const quad of quads) {\n      if (\n        quad.subject.value === baseIRI &&\n        quad.predicate.value === OWL_IMPORTS\n      ) {\n        const importVal = quad.object.value\n        if (importVal.startsWith('file://')) {\n          todo.push(importVal.slice('file://'.length))\n        }\n      }\n    }\n  }\n\n  return whitelist\n}\n\nasync function extractProcessorDescriptions(\n  processorPaths: string[],\n): Promise<ProcessorDescription[]> {\n  const descriptions: ProcessorDescription[] = []\n\n  for (const filePath of processorPaths) {\n    let content: string\n    try {\n      content = await readFile(filePath, { encoding: 'utf8' })\n    } catch {\n      continue\n    }\n\n    const baseIRI = 'file://' + filePath\n    const quads = new Parser({ baseIRI }).parse(content)\n\n    const seen = new Set<string>()\n    for (const quad of quads) {\n      if (quad.predicate.value !== RDFC + 'jsImplementationOf') continue\n      const uri = quad.subject.value\n      if (seen.has(uri)) continue\n      seen.add(uri)\n\n      const labelQuad = quads.find(\n        (q) => q.subject.value === uri && q.predicate.value === RDFS_LABEL,\n      )\n      const commentQuad = quads.find(\n        (q) => q.subject.value === uri && q.predicate.value === RDFS_COMMENT,\n      )\n\n      descriptions.push({\n        uri,\n        label: labelQuad?.object.value,\n        comment: commentQuad?.object.value,\n        sourceFile: filePath,\n      })\n    }\n  }\n\n  return descriptions\n}\n\nexport async function generateIndexTtl(\n  processorPaths: string[],\n  cwd: string,\n): Promise<string> {\n  const descriptions = await extractProcessorDescriptions(processorPaths)\n\n  const lines = `\n@prefix prov: <http://www.w3.org/ns/prov#>.\n@prefix sds: <https://w3id.org/sds#>.\n@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>.\n@prefix owl: <http://www.w3.org/2002/07/owl#>.\n@prefix rdfl: <https://w3id.org/rdf-lens/ontology#>.\n@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>.\n@prefix xsd: <http://www.w3.org/2001/XMLSchema#>.\n@prefix sh: <http://www.w3.org/ns/shacl#>.\n@prefix rdfc: <https://w3id.org/rdf-connect#>.\n\nsds:Activity rdfs:subClassOf prov:Activity.\nrdfc:Processor rdfs:subClassOf sds:Activity.\nsds:implementationOf rdfs:subPropertyOf rdfs:subClassOf.\nrdfc:jsImplementationOf rdfs:subPropertyOf sds:implementationOf.\n[ ] a sh:NodeShape;\n  sh:targetSubjectsOf rdfc:jsImplementationOf;\n  sh:property [\n    sh:path rdfc:entrypoint;\n    sh:name \"location\";\n    sh:minCount 1;\n    sh:maxCount 1;\n    sh:datatype xsd:string;\n  ], [\n    sh:path rdfc:file;\n    sh:name \"file\";\n    sh:minCount 1;\n    sh:maxCount 1;\n    sh:datatype xsd:string;\n  ], [\n    sh:path rdfc:class;\n    sh:name \"clazz\";\n    sh:maxCount 1;\n    sh:datatype xsd:string;\n  ].\n\n<runner> a rdfc:HttpRunner;\n  rdfc:handlesSubjectsOf rdfc:jsImplementationOf;\n  rdfc:endpoint <./connect>.\n`.split('\\n')\n\n  for (const desc of descriptions) {\n    const relPath = relative(cwd, desc.sourceFile)\n    lines.push(`<${desc.uri}> a rdfc:Processor;`)\n    if (desc.label) {\n      lines.push(\n        `  rdfs:label \"${desc.label.replace(/\\\\/g, '\\\\\\\\').replace(/\"/g, '\\\\\"')}\";`,\n      )\n    }\n    if (desc.comment) {\n      lines.push(\n        `  rdfs:comment \"${desc.comment.replace(/\\\\/g, '\\\\\\\\').replace(/\"/g, '\\\\\"')}\";`,\n      )\n    }\n    lines.push(`  rdfs:isDefinedBy <${relPath}>.`)\n    lines.push('')\n  }\n\n  return lines.join('\\n')\n}\n\nfunction dashboardHtml(): string {\n  return `<!DOCTYPE html>\n<html lang=\"en\">\n<head>\n  <meta charset=\"UTF-8\">\n  <title>js-runner dashboard</title>\n  <style>\n    * { box-sizing: border-box; margin: 0; padding: 0; }\n    body { font-family: 'Courier New', monospace; background: #111; color: #ccc; padding: 1.5rem; }\n    h1 { color: #7ec8e3; margin-bottom: 1rem; font-size: 1.4rem; }\n    #updated { font-size: 0.75rem; color: #555; margin-bottom: 1.5rem; }\n    .runner { border: 1px solid #333; border-radius: 6px; padding: 1rem; margin-bottom: 1.25rem; }\n    .runner-meta { display: flex; flex-wrap: wrap; gap: 1.5rem; margin-bottom: 0.75rem; font-size: 0.85rem; }\n    .runner-meta span { color: #888; }\n    .runner-meta strong { color: #aaa; }\n    .status { font-weight: bold; }\n    .s-connecting { color: #f0a500; }\n    .s-running    { color: #4caf50; }\n    .s-done       { color: #666; }\n    .s-error      { color: #f44336; }\n    .g-IDLE              { color: #888; }\n    .g-CONNECTING        { color: #f0a500; }\n    .g-READY             { color: #4caf50; }\n    .g-TRANSIENT_FAILURE { color: #f44336; }\n    .g-SHUTDOWN          { color: #666; }\n    table { width: 100%; border-collapse: collapse; font-size: 0.8rem; }\n    th, td { border: 1px solid #2a2a2a; padding: 0.4rem 0.8rem; text-align: left; white-space: nowrap; }\n    th { background: #1a1a1a; color: #7ec8e3; }\n    td.uri { color: #aaa; max-width: 28rem; overflow: hidden; text-overflow: ellipsis; }\n    td.role-reader { color: #81c784; }\n    td.role-writer { color: #64b5f6; }\n    .empty { color: #555; font-size: 0.8rem; padding-top: 0.5rem; }\n    .no-runners { color: #555; }\n  </style>\n</head>\n<body>\n  <h1>js-runner dashboard</h1>\n  <div id=\"updated\"></div>\n  <div id=\"content\"><p class=\"no-runners\">Loading…</p></div>\n  <script>\n    const throughputState = {}\n\n    function esc(s) {\n      return String(s).replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;')\n    }\n    function fmtBytes(b) {\n      if (b < 1024) return b + ' B'\n      if (b < 1048576) return (b/1024).toFixed(1) + ' KB'\n      return (b/1048576).toFixed(1) + ' MB'\n    }\n    function fmtAge(ms) {\n      if (!ms) return '-'\n      const s = Math.floor((Date.now() - ms) / 1000)\n      if (s < 5) return 'just now'\n      if (s < 60) return s + 's ago'\n      if (s < 3600) return Math.floor(s/60) + 'm ago'\n      return Math.floor(s/3600) + 'h ago'\n    }\n    function fmtDuration(ms) {\n      const s = Math.floor((Date.now() - ms) / 1000)\n      if (s < 60) return s + 's'\n      if (s < 3600) return Math.floor(s/60) + 'm ' + (s%60) + 's'\n      return Math.floor(s/3600) + 'h ' + Math.floor((s%3600)/60) + 'm'\n    }\n    function pct(arr, p) {\n      if (!arr || !arr.length) return '-'\n      const s = [...arr].sort((a,b) => a-b)\n      return s[Math.floor(p/100*s.length)] + 'ms'\n    }\n    function avg(arr) {\n      if (!arr || !arr.length) return '-'\n      return (arr.reduce((a,b)=>a+b,0)/arr.length).toFixed(1) + 'ms'\n    }\n    function throughput(key, count) {\n      const now = Date.now()\n      if (!throughputState[key]) { throughputState[key] = {count, time: now}; return '-' }\n      const dt = (now - throughputState[key].time) / 1000\n      const dc = count - throughputState[key].count\n      throughputState[key] = {count, time: now}\n      if (dt < 0.1) return '-'\n      return (dc / dt).toFixed(1) + '/s'\n    }\n\n    function renderChannels(runnerId, channels) {\n      const entries = Object.values(channels)\n      if (!entries.length) return '<p class=\"empty\">No channels yet.</p>'\n      return \\`<table>\n        <thead>\n          <tr>\n            <th>Channel URI</th>\n            <th>Role</th>\n            <th>Messages</th>\n            <th>Throughput</th>\n            <th>Bytes</th>\n            <th>Last msg</th>\n            <th>Avg latency</th>\n            <th>p50</th>\n            <th>p99</th>\n          </tr>\n        </thead>\n        <tbody>\n          \\${entries.map(ch => {\n            const key = runnerId + ':' + ch.uri\n            const tp = throughput(key, ch.messageCount)\n            return \\`<tr>\n              <td class=\"uri\" title=\"\\${esc(ch.uri)}\">\\${esc(ch.uri)}</td>\n              <td class=\"role-\\${ch.role}\">\\${ch.role}</td>\n              <td>\\${ch.messageCount}</td>\n              <td>\\${tp}</td>\n              <td>\\${fmtBytes(ch.bytesTotal)}</td>\n              <td>\\${fmtAge(ch.lastMessageAt)}</td>\n              <td>\\${ch.role === 'writer' ? avg(ch.latenciesMs) : '-'}</td>\n              <td>\\${ch.role === 'writer' ? pct(ch.latenciesMs, 50) : '-'}</td>\n              <td>\\${ch.role === 'writer' ? pct(ch.latenciesMs, 99) : '-'}</td>\n            </tr>\\`\n          }).join('')}\n        </tbody>\n      </table>\\`\n    }\n\n    function render(runners) {\n      const el = document.getElementById('content')\n      if (!runners.length) {\n        el.innerHTML = '<p class=\"no-runners\">No runners registered yet.</p>'\n        return\n      }\n      el.innerHTML = runners.map(r => \\`\n        <div class=\"runner\">\n          <div class=\"runner-meta\">\n            <span><strong>URI:</strong> \\${esc(r.uri)}</span>\n            <span><strong>Host:</strong> \\${esc(r.host)}</span>\n            <span><strong>Status:</strong> <span class=\"status s-\\${r.status}\">\\${r.status}</span></span>\n            <span><strong>gRPC:</strong> <span class=\"g-\\${r.grpcState}\">\\${r.grpcState}</span></span>\n            <span><strong>Uptime:</strong> \\${fmtDuration(r.connectedAt)}</span>\n          </div>\n          \\${renderChannels(r.id, r.channels)}\n        </div>\n      \\`).join('')\n    }\n\n    async function refresh() {\n      try {\n        const res = await fetch('/api/state')\n        const data = await res.json()\n        render(data)\n        document.getElementById('updated').textContent =\n          'Last updated: ' + new Date().toLocaleTimeString()\n      } catch (e) {\n        document.getElementById('content').innerHTML =\n          '<p style=\"color:#f44336\">Failed to fetch state: ' + esc(e.message) + '</p>'\n      }\n    }\n\n    refresh()\n    setInterval(refresh, 2000)\n  </script>\n</body>\n</html>`\n}\n\nexport async function serve(configPath: string): Promise<void> {\n  const absConfig = resolve(configPath)\n  const { port, processorPaths } = await parseServerConfig(absConfig)\n  const whitelist = await buildWhitelist(processorPaths)\n  const cwd = process.cwd()\n  const indexTtl = await generateIndexTtl(processorPaths, cwd)\n  const state = new State()\n\n  const activeConnections = new Set<AbortController>()\n\n  const shutdown = (signal: string) => {\n    console.log(\n      `\\nReceived ${signal}, closing ${activeConnections.size} active gRPC connection(s)...`,\n    )\n    for (const ctrl of activeConnections) ctrl.abort()\n    server.close(() => process.exit(0))\n  }\n\n  process.on('SIGINT', () => shutdown('SIGINT'))\n  process.on('SIGTERM', () => shutdown('SIGTERM'))\n\n  const server = createServer(async (req, res) => {\n    const method = req.method ?? 'GET'\n    const url = req.url ?? '/'\n\n    // --- Health check ---\n    if (method === 'GET' && url === '/health') {\n      res.writeHead(200, { 'Content-Type': 'application/json' })\n      res.end(\n        JSON.stringify({\n          status: 'ok',\n          runners: state.snapshot().length,\n          activeConnections: activeConnections.size,\n        }),\n      )\n      return\n    }\n\n    // --- State API (JSON) ---\n    if (method === 'GET' && url === '/api/state') {\n      res.writeHead(200, {\n        'Content-Type': 'application/json',\n        'Cache-Control': 'no-store',\n      })\n      res.end(JSON.stringify(state.snapshot()))\n      return\n    }\n\n    // --- Dashboard (HTML) ---\n    if (method === 'GET' && url === '/dashboard') {\n      res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' })\n      res.end(dashboardHtml())\n      return\n    }\n\n    // --- Index Turtle ---\n    if (method === 'GET' && url === '/') {\n      res.writeHead(200, { 'Content-Type': 'text/turtle' })\n      res.end(indexTtl)\n      return\n    }\n\n    // --- Whitelisted processor files ---\n    if (method === 'GET') {\n      const reqPath = url.startsWith('/') ? url.slice(1) : url\n      const absPath = resolve(cwd, reqPath)\n\n      if (!whitelist.has(absPath)) {\n        res.writeHead(403, { 'Content-Type': 'text/plain' })\n        res.end('Forbidden')\n        return\n      }\n\n      let content: string\n      try {\n        content = await readFile(absPath, { encoding: 'utf8' })\n      } catch {\n        res.writeHead(404, { 'Content-Type': 'text/plain' })\n        res.end('Not found')\n        return\n      }\n\n      res.writeHead(200, { 'Content-Type': 'text/turtle' })\n      res.end(content)\n      return\n    }\n\n    // --- Connect: instantiate a new runner ---\n    if (method === 'POST' && url === '/connect') {\n      let body: string\n      try {\n        body = await readBody(req)\n      } catch {\n        res.writeHead(400, { 'Content-Type': 'text/plain' })\n        res.end('Failed to read request body')\n        return\n      }\n\n      let parsed: { host?: string; uri?: string }\n      try {\n        parsed = JSON.parse(body)\n      } catch {\n        res.writeHead(400, { 'Content-Type': 'text/plain' })\n        res.end('Invalid JSON')\n        return\n      }\n\n      const { host, uri } = parsed\n      if (typeof host !== 'string' || typeof uri !== 'string') {\n        res.writeHead(400, { 'Content-Type': 'text/plain' })\n        res.end('Missing host or uri')\n        return\n      }\n\n      const runnerId = state.registerRunner(host, uri)\n      const ctrl = new AbortController()\n      activeConnections.add(ctrl)\n\n      start(host, uri, absConfig, ctrl.signal, state, runnerId)\n        .catch((err) => {\n          console.error('gRPC connection error:', err)\n          state.markError(runnerId)\n        })\n        .finally(() => {\n          activeConnections.delete(ctrl)\n          state.deregisterRunner(runnerId)\n        })\n\n      res.writeHead(202, {\n        'Content-Type': 'application/json',\n        Location: '/dashboard',\n      })\n      res.end(JSON.stringify({ runnerId }))\n      return\n    }\n\n    res.writeHead(404, { 'Content-Type': 'text/plain' })\n    res.end('Not found')\n  })\n\n  await new Promise<void>((resolve) => {\n    server.listen(port, () => {\n      console.log(`js-runner server listening on port ${port}`)\n      console.log(`  Dashboard: http://localhost:${port}/dashboard`)\n      console.log(`  Health:    http://localhost:${port}/health`)\n      console.log(`  State API: http://localhost:${port}/api/state`)\n      resolve()\n    })\n  })\n}\n"]}

package/lib/state.d.ts

@@ -0,0 +1,32 @@
+export type RunnerStatus = 'connecting' | 'running' | 'done' | 'error';
+export interface ChannelStats {
+    uri: string;
+    role: 'reader' | 'writer';
+    messageCount: number;
+    bytesTotal: number;
+    lastMessageAt: number | null;
+    latenciesMs: number[];
+}
+export interface RunnerStats {
+    id: string;
+    host: string;
+    uri: string;
+    connectedAt: number;
+    status: RunnerStatus;
+    grpcState: string;
+    channels: Record<string, ChannelStats>;
+}
+export interface ChannelTracker {
+    recordMessage(bytes: number, latencyMs?: number): void;
+}
+export declare class State {
+    private readonly runners;
+    private nextId;
+    registerRunner(host: string, uri: string): string;
+    setStatus(id: string, status: RunnerStatus): void;
+    setGrpcState(id: string, state: string): void;
+    deregisterRunner(id: string): void;
+    markError(id: string): void;
+    trackChannel(runnerId: string, uri: string, role: 'reader' | 'writer'): ChannelTracker;
+    snapshot(): RunnerStats[];
+}

package/lib/state.js

@@ -0,0 +1,71 @@
+const MAX_LATENCY_SAMPLES = 100;
+export class State {
+    runners = new Map();
+    nextId = 1;
+    registerRunner(host, uri) {
+        const id = String(this.nextId++);
+        this.runners.set(id, {
+            id,
+            host,
+            uri,
+            connectedAt: Date.now(),
+            status: 'connecting',
+            grpcState: 'IDLE',
+            channels: {},
+        });
+        return id;
+    }
+    setStatus(id, status) {
+        const r = this.runners.get(id);
+        if (r)
+            r.status = status;
+    }
+    setGrpcState(id, state) {
+        const r = this.runners.get(id);
+        if (r)
+            r.grpcState = state;
+    }
+    deregisterRunner(id) {
+        const r = this.runners.get(id);
+        if (r && r.status !== 'error')
+            r.status = 'done';
+    }
+    markError(id) {
+        const r = this.runners.get(id);
+        if (r)
+            r.status = 'error';
+    }
+    trackChannel(runnerId, uri, role) {
+        const runner = this.runners.get(runnerId);
+        if (!runner)
+            return { recordMessage() { } };
+        if (!runner.channels[uri]) {
+            runner.channels[uri] = {
+                uri,
+                role,
+                messageCount: 0,
+                bytesTotal: 0,
+                lastMessageAt: null,
+                latenciesMs: [],
+            };
+        }
+        const channel = runner.channels[uri];
+        return {
+            recordMessage(bytes, latencyMs) {
+                channel.messageCount++;
+                channel.bytesTotal += bytes;
+                channel.lastMessageAt = Date.now();
+                if (latencyMs !== undefined) {
+                    channel.latenciesMs.push(latencyMs);
+                    if (channel.latenciesMs.length > MAX_LATENCY_SAMPLES) {
+                        channel.latenciesMs.shift();
+                    }
+                }
+            },
+        };
+    }
+    snapshot() {
+        return [...this.runners.values()];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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