@ccslabs/xtend 0.1.0-rc.1

package/security/trusted-dom-policy.js

@@ -0,0 +1,316 @@
+const TRUSTED_DOM_POLICY_CONTRACT = 'xtend.security.trusted-dom-policy.v1';
+const SANITIZING_BOUNDARY_CONTRACT = 'xtend.security.sanitizing-boundary.v1';
+const MARKUP_CLASSIFICATION_CONTRACT = 'xtend.security.markup-classification.v1';
+const TRUSTED_DOM_SINK_CONTRACT = 'xtend.security.trusted-dom-sink.v1';
+const TRUSTED_DOM_SANITIZER_CONTRACT = 'xtend.security.trusted-dom-sanitizer.v1';
+
+const MARKUP_CLASSES = {
+  text: {
+    trust: 'content-trusted-dom-safe',
+    defaultSink: 'textContent',
+    sanitizerRequired: false,
+    description: 'Plain text from docs, RMT records or component props.'
+  },
+  attribute: {
+    trust: 'value-untrusted-until-validated',
+    defaultSink: 'setAttribute',
+    sanitizerRequired: false,
+    description: 'Attribute values, including ARIA labels, slot names and local hrefs.'
+  },
+  structuredTemplate: {
+    trust: 'authoring-trusted-dom-safe-after-validation',
+    defaultSink: 'replaceChildren',
+    sanitizerRequired: false,
+    description: 'RMT dom_descriptor or host-built component trees.'
+  },
+  htmlFragment: {
+    trust: 'dom-untrusted-until-sanitized',
+    defaultSink: 'trustedDomBoundary',
+    sanitizerRequired: true,
+    description: 'RMT html_fragment records and other authored HTML strings.'
+  },
+  parsedownHtml: {
+    trust: 'dom-untrusted-until-sanitized',
+    defaultSink: 'trustedDomBoundary',
+    sanitizerRequired: true,
+    description: 'HTML emitted by Parsedown for the docs app, even when SafeMode is enabled.'
+  }
+};
+
+const DOM_SINKS = {
+  textContent: {
+    status: 'allowed',
+    accepts: ['text'],
+    requiredBoundary: 'none'
+  },
+  setAttribute: {
+    status: 'allowed-with-validation',
+    accepts: ['attribute'],
+    requiredBoundary: 'attribute-allowlist-and-url-policy'
+  },
+  classList: {
+    status: 'allowed',
+    accepts: ['attribute'],
+    requiredBoundary: 'tokenized-class-values'
+  },
+  dataset: {
+    status: 'allowed-with-validation',
+    accepts: ['attribute'],
+    requiredBoundary: 'no-secrets-no-code-values'
+  },
+  append: {
+    status: 'allowed',
+    accepts: ['structuredTemplate'],
+    requiredBoundary: 'node-only'
+  },
+  replaceChildren: {
+    status: 'allowed',
+    accepts: ['structuredTemplate'],
+    requiredBoundary: 'node-only'
+  },
+  innerHTML: {
+    status: 'restricted',
+    accepts: ['htmlFragment', 'parsedownHtml'],
+    requiredBoundary: 'trusted-dom-boundary'
+  },
+  insertAdjacentHTML: {
+    status: 'restricted',
+    accepts: ['htmlFragment', 'parsedownHtml'],
+    requiredBoundary: 'trusted-dom-boundary'
+  },
+  templateInnerHTML: {
+    status: 'restricted',
+    accepts: ['htmlFragment'],
+    requiredBoundary: 'trusted-dom-boundary'
+  },
+  scriptSrc: {
+    status: 'forbidden-by-default',
+    accepts: [],
+    requiredBoundary: 'loader-import-policy'
+  },
+  eval: {
+    status: 'forbidden',
+    accepts: [],
+    requiredBoundary: 'never'
+  },
+  newFunction: {
+    status: 'forbidden',
+    accepts: [],
+    requiredBoundary: 'never'
+  }
+};
+
+const URL_ATTRIBUTE_POLICY = {
+  allowedAttributes: ['href', 'src', 'action', 'poster'],
+  allowedProtocols: ['self', 'relative', 'http:', 'https:', 'mailto:', 'tel:'],
+  disallowedProtocols: ['javascript:', 'data:text/html', 'data:text/javascript', 'vbscript:'],
+  dataUrlException: 'data:image/* only after explicit sanitizer decision'
+};
+
+const RMT_TEMPLATE_POLICY = {
+  domDescriptorMode: {
+    markupClass: 'structuredTemplate',
+    preferred: true,
+    sink: 'replaceChildren'
+  },
+  htmlFragmentMode: {
+    markupClass: 'htmlFragment',
+    preferred: false,
+    sink: 'innerHTML',
+    requiredBoundary: SANITIZING_BOUNDARY_CONTRACT
+  },
+  eventBindings: {
+    allowed: ['actionRef', 'commandName', 'routeRef', 'payload'],
+    forbidden: ['inlineHandler', 'javascriptString', 'eval', 'new Function']
+  }
+};
+
+const PARSEDOWN_DOCS_POLICY = {
+  source: 'docs/*.md',
+  adapter: 'docs.parsedown',
+  parsedownSafeModeRequired: true,
+  outputMarkupClass: 'parsedownHtml',
+  requiredBoundary: SANITIZING_BOUNDARY_CONTRACT,
+  allowedSink: 'trustedDomBoundary',
+  rmtSchedulingBoundary: 'RMT may schedule Parsedown work, but the docs host owns parsing and sanitizing.'
+};
+
+const TRUSTED_DOM_SANITIZER_POLICY = {
+  schema: TRUSTED_DOM_SANITIZER_CONTRACT,
+  boundary: SANITIZING_BOUNDARY_CONTRACT,
+  removesElements: ['script', 'iframe', 'object', 'embed', 'link', 'meta', 'base', 'form'],
+  removesAttributes: ['/^on/i', 'srcdoc'],
+  validatesUrlAttributes: ['href', 'src', 'action', 'poster'],
+  disallowedProtocols: URL_ATTRIBUTE_POLICY.disallowedProtocols,
+  dataUrlException: URL_ATTRIBUTE_POLICY.dataUrlException,
+  diagnostics: [
+    'xtend.security.sanitizer.element_removed',
+    'xtend.security.sanitizer.attribute_removed',
+    'xtend.security.sanitizer.url_removed'
+  ]
+};
+
+function clone(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+function normalizeMarkupClass(markupClass) {
+  if (markupClass === 'structured-template' || markupClass === 'dom_descriptor') {
+    return 'structuredTemplate';
+  }
+  if (markupClass === 'html_fragment') {
+    return 'htmlFragment';
+  }
+  if (markupClass === 'parsedown-html') {
+    return 'parsedownHtml';
+  }
+  return markupClass || 'text';
+}
+
+function getTrustedDomPolicy() {
+  return clone({
+    schema: TRUSTED_DOM_POLICY_CONTRACT,
+    sanitizingBoundary: SANITIZING_BOUNDARY_CONTRACT,
+    markupClassification: MARKUP_CLASSIFICATION_CONTRACT,
+    sinkContract: TRUSTED_DOM_SINK_CONTRACT,
+    markupClasses: MARKUP_CLASSES,
+    sinks: DOM_SINKS,
+    urlAttributes: URL_ATTRIBUTE_POLICY,
+    rmtTemplates: RMT_TEMPLATE_POLICY,
+    parsedownDocs: PARSEDOWN_DOCS_POLICY,
+    sanitizer: TRUSTED_DOM_SANITIZER_POLICY,
+    diagnostics: [
+      'xtend.security.trusted_dom.required',
+      'xtend.security.sanitizer.missing',
+      'xtend.security.sink.refused',
+      'xtend.security.attribute.refused',
+      'xtend.security.event.refused'
+    ]
+  });
+}
+
+function isAllowedTrustedDomUrl(value) {
+  const normalized = String(value || '').trim().replace(/[\u0000-\u001F\u007F\s]+/g, '').toLowerCase();
+  if (!normalized) return true;
+  if (normalized.startsWith('#') || normalized.startsWith('/') || normalized.startsWith('./') || normalized.startsWith('../')) return true;
+  if (normalized.startsWith('data:')) return normalized.startsWith('data:image/');
+  return !URL_ATTRIBUTE_POLICY.disallowedProtocols.some((protocol) => normalized.startsWith(protocol));
+}
+
+function sanitizeTrustedDomHtml(html, options = {}) {
+  let output = String(html || '');
+  const removed = [];
+  const markupClass = normalizeMarkupClass(options.markupClass || 'htmlFragment');
+
+  TRUSTED_DOM_SANITIZER_POLICY.removesElements.forEach((tagName) => {
+    const paired = new RegExp(`<\\s*${tagName}\\b[^>]*>[\\s\\S]*?<\\s*\\/\\s*${tagName}\\s*>`, 'gi');
+    output = output.replace(paired, (match) => {
+      removed.push({ type: 'element', name: tagName, sample: match.slice(0, 80) });
+      return '';
+    });
+
+    const single = new RegExp(`<\\s*${tagName}\\b[^>]*\\/?\\s*>`, 'gi');
+    output = output.replace(single, (match) => {
+      removed.push({ type: 'element', name: tagName, sample: match.slice(0, 80) });
+      return '';
+    });
+  });
+
+  output = output.replace(/\s+on[a-z0-9_-]+\s*=\s*(?:"[^"]*"|'[^']*'|[^\s>]+)/gi, (match) => {
+    removed.push({ type: 'attribute', name: match.trim().split('=')[0] });
+    return '';
+  });
+
+  output = output.replace(/\s+srcdoc\s*=\s*(?:"[^"]*"|'[^']*'|[^\s>]+)/gi, (match) => {
+    removed.push({ type: 'attribute', name: 'srcdoc' });
+    return '';
+  });
+
+  output = output.replace(/\s+(href|src|action|poster)\s*=\s*("[^"]*"|'[^']*'|[^\s>]+)/gi, (match, name, rawValue) => {
+    const unquoted = String(rawValue || '').replace(/^['"]|['"]$/g, '');
+    if (!isAllowedTrustedDomUrl(unquoted)) {
+      removed.push({ type: 'url', name, value: unquoted });
+      return '';
+    }
+    return match;
+  });
+
+  return {
+    schema: TRUSTED_DOM_SANITIZER_CONTRACT,
+    ok: true,
+    sanitized: true,
+    boundary: SANITIZING_BOUNDARY_CONTRACT,
+    markupClass,
+    html: output,
+    removed,
+    removedCount: removed.length
+  };
+}
+
+function getMarkupClass(markupClass) {
+  const key = normalizeMarkupClass(markupClass);
+  return MARKUP_CLASSES[key] ? clone(MARKUP_CLASSES[key]) : null;
+}
+
+function getSinkPolicy(sink) {
+  return DOM_SINKS[sink] ? clone(DOM_SINKS[sink]) : null;
+}
+
+function classifyTrustedDomUse(input = {}) {
+  const markupKey = normalizeMarkupClass(input.markupClass || input.mode || input.type);
+  const markup = MARKUP_CLASSES[markupKey] || MARKUP_CLASSES.text;
+  const sinkName = input.sink || markup.defaultSink;
+  const sink = DOM_SINKS[sinkName] || {
+    status: 'unknown',
+    accepts: [],
+    requiredBoundary: 'explicit-review'
+  };
+  const acceptedBySink = sink.accepts.includes(markupKey);
+  const restricted = sink.status === 'restricted';
+  const forbidden = sink.status === 'forbidden' || sink.status === 'forbidden-by-default';
+  const requiresSanitizer = markup.sanitizerRequired || restricted;
+  const hasBoundary = input.boundary === SANITIZING_BOUNDARY_CONTRACT || input.sanitized === true;
+  const ok = !forbidden && (acceptedBySink || sink.status === 'allowed-with-validation') && (!requiresSanitizer || hasBoundary);
+  const diagnostics = [];
+
+  if (forbidden) {
+    diagnostics.push('xtend.security.sink.refused');
+  }
+  if (!acceptedBySink && sink.status !== 'allowed-with-validation') {
+    diagnostics.push('xtend.security.trusted_dom.required');
+  }
+  if (requiresSanitizer && !hasBoundary) {
+    diagnostics.push('xtend.security.sanitizer.missing');
+  }
+
+  return {
+    schema: MARKUP_CLASSIFICATION_CONTRACT,
+    ok,
+    markupClass: markupKey,
+    sink: sinkName,
+    trust: markup.trust,
+    requiresSanitizer,
+    requiredBoundary: requiresSanitizer ? SANITIZING_BOUNDARY_CONTRACT : sink.requiredBoundary,
+    diagnostics
+  };
+}
+
+module.exports = {
+  DOM_SINKS,
+  MARKUP_CLASSES,
+  MARKUP_CLASSIFICATION_CONTRACT,
+  PARSEDOWN_DOCS_POLICY,
+  RMT_TEMPLATE_POLICY,
+  SANITIZING_BOUNDARY_CONTRACT,
+  TRUSTED_DOM_SANITIZER_CONTRACT,
+  TRUSTED_DOM_SANITIZER_POLICY,
+  TRUSTED_DOM_POLICY_CONTRACT,
+  TRUSTED_DOM_SINK_CONTRACT,
+  URL_ATTRIBUTE_POLICY,
+  classifyTrustedDomUse,
+  getMarkupClass,
+  getSinkPolicy,
+  getTrustedDomPolicy,
+  isAllowedTrustedDomUrl,
+  sanitizeTrustedDomHtml
+};

package/tools/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@ccslabs/xtend-compiler",
+  "version": "0.1.0-rc.1",
+  "private": false,
+  "description": "XTendRMT compiler, parser, linter and language tooling.",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/konnilabs/xtend.git",
+    "directory": "tools"
+  },
+  "keywords": [
+    "ccslabs",
+    "xtend",
+    "rmt",
+    "compiler",
+    "parser"
+  ],
+  "main": "./rmt-language/vnext-compiler.js",
+  "types": "./rmt-language/vnext-compiler.d.ts",
+  "bin": {
+    "xtend-rmt-lint": "./rmt-linter/cli.js"
+  },
+  "files": [
+    "rmt-language",
+    "rmt-linter",
+    "rmt-language-server",
+    "package.json"
+  ],
+  "exports": {
+    ".": {
+      "types": "./rmt-language/vnext-compiler.d.ts",
+      "default": "./rmt-language/vnext-compiler.js"
+    },
+    "./rmt-language/vnext-compiler": {
+      "types": "./rmt-language/vnext-compiler.d.ts",
+      "default": "./rmt-language/vnext-compiler.js"
+    },
+    "./rmt-language/vnext-parser": {
+      "types": "./rmt-language/vnext-parser.d.ts",
+      "default": "./rmt-language/vnext-parser.js"
+    },
+    "./rmt-language/parser": {
+      "types": "./rmt-language/parser.d.ts",
+      "default": "./rmt-language/parser.js"
+    },
+    "./rmt-language/source-model": {
+      "types": "./rmt-language/source-model.d.ts",
+      "default": "./rmt-language/source-model.js"
+    },
+    "./rmt-language/diagnostics": {
+      "types": "./rmt-language/diagnostics.d.ts",
+      "default": "./rmt-language/diagnostics.js"
+    },
+    "./rmt-linter/cli": {
+      "types": "./rmt-linter/cli.d.ts",
+      "default": "./rmt-linter/cli.js"
+    },
+    "./rmt-language-server/server": {
+      "types": "./rmt-language-server/server.d.ts",
+      "default": "./rmt-language-server/server.js"
+    },
+    "./rmt-language-server/protocol": {
+      "types": "./rmt-language-server/protocol.d.ts",
+      "default": "./rmt-language-server/protocol.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true,
+    "tag": "next"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/tools/rmt-editor/vscode/README.md

@@ -0,0 +1,33 @@
+# XTendRMT VS Code Bridge Stub
+
+- Schema: `xtend.rmt.editor.vscode-bridge.v1`
+- Workpackage: `WP-E14-12`
+- Language ID: `rmt`
+- Primary extension: `.rmt`
+
+This folder is intentionally a thin bridge. It contributes the native `.rmt` language id, grammar, snippets and a command that prints the Language Server command.
+
+The RMT Language Server remains the only source of truth for diagnostics, completion, hover, symbols, definitions and code actions. This stub does not implement RMT analysis and does not import XTend UI runtime modules.
+
+## VSIX Packaging
+
+The packaged VSIX includes a local copy of `snippets/rmt.code-snippets` because VS Code extension contributions must resolve inside the installed extension directory. The canonical snippet source remains `tools/rmt-language/snippets/rmt.code-snippets`.
+
+Build locally with:
+
+```bash
+npx --yes @vscode/vsce package --allow-missing-repository --out xtend-rmt-language-0.1.0-rc.1.vsix
+```
+
+## Language Server
+
+Use a generic VS Code LSP client with:
+
+```json
+{
+  "command": "node",
+  "args": ["tools/rmt-language-server/server.js"]
+}
+```
+
+The packaged LanguageClient wrapper can be added later without changing the RMT language layer.

package/tools/rmt-editor/vscode/extension.d.ts

@@ -0,0 +1,9 @@
+export * from '../../rmt-language/rmt-tooling-public-types';
+import type { RmtToolingConstant, RmtToolingFactory, RmtToolingFunction } from '../../rmt-language/rmt-tooling-public-types';
+
+export declare const activate: RmtToolingFunction;
+export declare const createServerCommand: RmtToolingFactory;
+export declare const deactivate: RmtToolingFunction;
+export declare const resolveServerModule: RmtToolingFactory;
+export declare const RMT_VSCODE_BRIDGE_SCHEMA: RmtToolingConstant;
+export declare const RMT_VSCODE_BRIDGE_WORKPACKAGE: RmtToolingConstant;

package/tools/rmt-editor/vscode/extension.js

@@ -0,0 +1,55 @@
+const path = require('path');
+
+const RMT_VSCODE_BRIDGE_SCHEMA = 'xtend.rmt.editor.vscode-bridge.v1';
+const RMT_VSCODE_BRIDGE_WORKPACKAGE = 'WP-E14-12';
+const DEFAULT_SERVER_RELATIVE_PATH = '../../rmt-language-server/server.js';
+
+function resolveServerModule(context = {}, options = {}) {
+  if (options.serverModule) {
+    return path.resolve(options.serverModule);
+  }
+
+  const extensionPath = context.extensionPath || __dirname;
+  return path.resolve(extensionPath, DEFAULT_SERVER_RELATIVE_PATH);
+}
+
+function createServerCommand(context = {}, options = {}) {
+  return {
+    schema: RMT_VSCODE_BRIDGE_SCHEMA,
+    workpackage: RMT_VSCODE_BRIDGE_WORKPACKAGE,
+    command: options.command || 'node',
+    args: [resolveServerModule(context, options)],
+    transport: 'stdio-json-rpc',
+    languageId: 'rmt',
+    sourceOfTruth: 'tools/rmt-language-server/server.js',
+    networkRequired: false,
+    kernelBoundary: 'no-rmt-kernel-import-of-xtend-types'
+  };
+}
+
+function activate(context) {
+  const vscode = require('vscode');
+  const output = vscode.window.createOutputChannel('XTendRMT');
+  const serverCommand = createServerCommand(context);
+  const disposable = vscode.commands.registerCommand('xtendRmt.showLanguageServerCommand', () => {
+    output.clear();
+    output.appendLine('XTendRMT Language Server');
+    output.appendLine(`${serverCommand.command} ${serverCommand.args.join(' ')}`);
+    output.appendLine('Use this command with a generic LSP client until a packaged VS Code LanguageClient is added.');
+    output.show(true);
+  });
+
+  context.subscriptions.push(output, disposable);
+  return serverCommand;
+}
+
+function deactivate() {}
+
+module.exports = {
+  RMT_VSCODE_BRIDGE_SCHEMA,
+  RMT_VSCODE_BRIDGE_WORKPACKAGE,
+  activate,
+  createServerCommand,
+  deactivate,
+  resolveServerModule
+};

package/tools/rmt-editor/vscode/language-configuration.json

@@ -0,0 +1,28 @@
+{
+  "comments": {
+    "lineComment": ""
+  },
+  "brackets": [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"]
+  ],
+  "autoClosingPairs": [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"],
+    ["\"", "\""]
+  ],
+  "surroundingPairs": [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"],
+    ["\"", "\""]
+  ],
+  "folding": {
+    "markers": {
+      "start": "^\\s*//\\s*#?region\\b",
+      "end": "^\\s*//\\s*#?endregion\\b"
+    }
+  }
+}

package/tools/rmt-editor/vscode/package.json

@@ -0,0 +1,83 @@
+{
+  "name": "xtend-rmt-language",
+  "displayName": "XTendRMT Language Support",
+  "description": "Thin VS Code bridge for native .rmt authoring through the XTendRMT Language Server.",
+  "version": "0.1.0-rc.1",
+  "private": false,
+  "publisher": "CCS Networks",
+  "license": "Apache-2.0",
+  "engines": {
+    "vscode": "^1.90.0"
+  },
+  "categories": [
+    "Programming Languages",
+    "Snippets",
+    "Linters"
+  ],
+  "activationEvents": [
+    "onLanguage:rmt",
+    "onCommand:xtendRmt.showLanguageServerCommand"
+  ],
+  "main": "./extension.js",
+  "files": [
+    "extension.js",
+    "language-configuration.json",
+    "syntaxes/**",
+    "snippets/**",
+    "README.md"
+  ],
+  "contributes": {
+    "languages": [
+      {
+        "id": "rmt",
+        "aliases": [
+          "RMT",
+          "XTendRMT"
+        ],
+        "extensions": [
+          ".rmt"
+        ],
+        "configuration": "./language-configuration.json"
+      }
+    ],
+    "grammars": [
+      {
+        "language": "rmt",
+        "scopeName": "source.rmt",
+        "path": "./syntaxes/rmt.tmLanguage.json"
+      }
+    ],
+    "snippets": [
+      {
+        "language": "rmt",
+        "path": "./snippets/rmt.code-snippets"
+      }
+    ],
+    "commands": [
+      {
+        "command": "xtendRmt.showLanguageServerCommand",
+        "title": "XTendRMT: Show Language Server Command"
+      }
+    ],
+    "configuration": {
+      "title": "XTendRMT",
+      "properties": {
+        "xtendRmt.languageServer.command": {
+          "type": "string",
+          "default": "node",
+          "description": "Command used by generic LSP clients to start the XTendRMT Language Server."
+        },
+        "xtendRmt.languageServer.args": {
+          "type": "array",
+          "default": [
+            "${workspaceFolder}/tools/rmt-language-server/server.js"
+          ],
+          "items": {
+            "type": "string"
+          },
+          "description": "Arguments used by generic LSP clients to start the XTendRMT Language Server."
+        }
+      }
+    }
+  }
+}