233 lines
9.5 KiB
JavaScript
233 lines
9.5 KiB
JavaScript
import { createHash } from 'node:crypto';
|
|
import { gzipSync } from 'node:zlib';
|
|
import {
|
|
existsSync,
|
|
readFileSync,
|
|
readdirSync,
|
|
writeFileSync,
|
|
} from 'node:fs';
|
|
import { dirname, join, resolve } from 'node:path';
|
|
import { fileURLToPath } from 'node:url';
|
|
import { runInNewContext } from 'node:vm';
|
|
|
|
const repositoryRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
|
|
const widgetsRoot = join(repositoryRoot, 'plugins', 'shd-mcp-plugin', 'widgets');
|
|
const templatePath = join(widgetsRoot, '_shared', 'universal-widget.html');
|
|
const configPath = join(widgetsRoot, '_shared', 'universal-widget-config.json');
|
|
const bootstrapPath = join(widgetsRoot, 'airbase-preview', 'v1', 'index.html');
|
|
const moduleToken = '__SHD_WIDGET_MODULE__';
|
|
const configToken = '__SHD_WIDGET_CONFIG__';
|
|
const engineName = 'shd-universal-v1';
|
|
const checkOnly = process.argv.includes('--check');
|
|
const extractConfigOnly = process.argv.includes('--extract-config');
|
|
const migrateTemplate = process.argv.includes('--migrate-template');
|
|
const excludedWidgets = new Set(['active-projects', 'controller-observability']);
|
|
const runtimeModuleByArtifact = new Map([
|
|
['pdf-scheme-editor-progress', 'schemes-progress'],
|
|
]);
|
|
|
|
function fail(message) {
|
|
throw new Error(`[widget-artifacts] ${message}`);
|
|
}
|
|
|
|
function ensureCanonicalTemplate() {
|
|
if (existsSync(templatePath)) return;
|
|
if (checkOnly) fail(`canonical template is missing: ${templatePath}`);
|
|
if (!existsSync(bootstrapPath)) fail(`bootstrap widget is missing: ${bootstrapPath}`);
|
|
|
|
const source = readFileSync(bootstrapPath, 'utf8');
|
|
const template = source
|
|
.replace(
|
|
'data-widget-module="airbase-preview"',
|
|
`data-shd-widget-engine="${engineName}" data-widget-module="${moduleToken}"`,
|
|
)
|
|
.replace(
|
|
"var DEFAULT_MODULE='airbase-preview'",
|
|
`var DEFAULT_MODULE='${moduleToken}'`,
|
|
);
|
|
if (template === source || !template.includes(moduleToken)) {
|
|
fail('could not bootstrap the universal template from airbase-preview');
|
|
}
|
|
writeFileSync(templatePath, template);
|
|
}
|
|
|
|
function isRecord(value) {
|
|
return value && typeof value === 'object' && !Array.isArray(value);
|
|
}
|
|
|
|
function extractWidgetConfig(template) {
|
|
const start = template.indexOf(' var M=');
|
|
const end = template.indexOf(' var pending=', start);
|
|
if (start < 0 || end < 0 || end <= start) {
|
|
fail('could not locate the legacy M/S configuration block in the canonical template');
|
|
}
|
|
|
|
const block = template.slice(start, end);
|
|
let extracted;
|
|
try {
|
|
extracted = runInNewContext(`(() => { ${block}; return { copy: M, defaults: S }; })()`);
|
|
} catch (error) {
|
|
fail(`could not evaluate the legacy M/S configuration block: ${error instanceof Error ? error.message : String(error)}`);
|
|
}
|
|
if (!isRecord(extracted) || !isRecord(extracted.copy) || !isRecord(extracted.defaults)) {
|
|
fail('legacy M/S configuration block did not produce copy/defaults objects');
|
|
}
|
|
return extracted;
|
|
}
|
|
|
|
function readWidgetConfig() {
|
|
if (!existsSync(configPath)) return null;
|
|
let config;
|
|
try {
|
|
config = JSON.parse(readFileSync(configPath, 'utf8'));
|
|
} catch (error) {
|
|
fail(`widget config is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
|
|
}
|
|
if (!isRecord(config)) fail('widget config must be a JSON object');
|
|
if (config.engine !== engineName) fail(`widget config engine must be ${engineName}`);
|
|
if (!isRecord(config.copy) || !isRecord(config.defaults)) {
|
|
fail('widget config must contain copy and defaults objects');
|
|
}
|
|
return config;
|
|
}
|
|
|
|
function ensureWidgetConfig(template) {
|
|
const existing = readWidgetConfig();
|
|
if (existing) return existing;
|
|
if (checkOnly) fail(`widget config is missing: ${configPath}`);
|
|
|
|
const extracted = extractWidgetConfig(template);
|
|
const config = {
|
|
version: 1,
|
|
engine: engineName,
|
|
copy: extracted.copy,
|
|
defaults: extracted.defaults,
|
|
};
|
|
writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`);
|
|
return config;
|
|
}
|
|
|
|
function migrateCanonicalTemplate(template) {
|
|
if (template.includes(configToken)) return template;
|
|
if (!migrateTemplate) {
|
|
fail(`canonical template must contain ${configToken}; run with --migrate-template once`);
|
|
}
|
|
|
|
const start = template.indexOf(' var M=');
|
|
const end = template.indexOf(' var pending=', start);
|
|
if (start < 0 || end < 0 || end <= start) {
|
|
fail('could not locate the legacy M/S configuration block for migration');
|
|
}
|
|
const replacement = [
|
|
' var MODULE_CONFIG=__SHD_WIDGET_CONFIG__;',
|
|
' var M=MODULE_CONFIG.copy;',
|
|
' var S=MODULE_CONFIG.defaults;',
|
|
].join('\n') + '\n';
|
|
const migrated = `${template.slice(0, start)}${replacement}${template.slice(end)}`;
|
|
writeFileSync(templatePath, migrated);
|
|
return migrated;
|
|
}
|
|
|
|
function readUniversalWidgets() {
|
|
return readdirSync(widgetsRoot, { withFileTypes: true })
|
|
.filter((entry) => entry.isDirectory() && !excludedWidgets.has(entry.name) && entry.name !== '_shared')
|
|
.map((entry) => entry.name)
|
|
.filter((name) => existsSync(join(widgetsRoot, name, 'v1', 'index.html')))
|
|
.sort();
|
|
}
|
|
|
|
function expectedArtifact(path, content) {
|
|
if (checkOnly) {
|
|
const current = existsSync(path) ? readFileSync(path, 'utf8') : null;
|
|
if (current !== content) fail(`generated file is stale: ${path}`);
|
|
return;
|
|
}
|
|
if (!existsSync(path) || readFileSync(path, 'utf8') !== content) writeFileSync(path, content);
|
|
}
|
|
|
|
function renderHtml(template, module, config) {
|
|
const serializedConfig = JSON.stringify({ copy: config.copy, defaults: config.defaults })
|
|
.replaceAll('<', '\\u003c');
|
|
const html = template
|
|
.replaceAll(moduleToken, module)
|
|
.replaceAll(configToken, serializedConfig);
|
|
if (html.includes(moduleToken)) fail(`unresolved module token for ${module}`);
|
|
if (html.includes(configToken)) fail(`unresolved config token for ${module}`);
|
|
if (!html.includes(`data-shd-widget-engine="${engineName}"`)) fail(`engine marker is missing for ${module}`);
|
|
if (!html.includes(`data-widget-module="${module}"`)) fail(`module marker is missing for ${module}`);
|
|
if (!html.includes(`var DEFAULT_MODULE='${module}'`)) fail(`default module is missing for ${module}`);
|
|
return html;
|
|
}
|
|
|
|
function manifestFor(widgetPath, html, module) {
|
|
const manifestPath = join(widgetPath, 'manifest.json');
|
|
if (!existsSync(manifestPath)) fail(`manifest is missing: ${manifestPath}`);
|
|
const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
|
|
const resource = Array.isArray(manifest.resources)
|
|
? manifest.resources.find((item) => item?.file === 'index.html')
|
|
: null;
|
|
if (!resource) fail(`index.html resource is missing from ${manifestPath}`);
|
|
|
|
const bytes = Buffer.byteLength(html, 'utf8');
|
|
const digest = createHash('sha256').update(html, 'utf8').digest('hex');
|
|
resource.bytes = bytes;
|
|
resource.gzipBytes = gzipSync(Buffer.from(html, 'utf8'), { mtime: 0 }).length;
|
|
resource.sha256 = digest;
|
|
manifest.source = {
|
|
...(manifest.source || {}),
|
|
path: 'plugins/shd-mcp-plugin/widgets/_shared/universal-widget.html',
|
|
config: 'plugins/shd-mcp-plugin/widgets/_shared/universal-widget-config.json',
|
|
generatedBy: 'scripts/generate-widget-artifacts.mjs',
|
|
engine: engineName,
|
|
};
|
|
if (manifest.source.module && manifest.source.module !== module) delete manifest.source.module;
|
|
return { manifest, resource, digest };
|
|
}
|
|
|
|
function upstreamFor(widgetPath, resource) {
|
|
const upstreamPath = join(widgetPath, 'UPSTREAM.md');
|
|
const existing = existsSync(upstreamPath) ? readFileSync(upstreamPath, 'utf8') : '';
|
|
const heading = existing.match(/^# .+$/m)?.[0] || '# SHD widget';
|
|
const code = String.fromCharCode(96);
|
|
return `${heading}\n\nThis artifact is served by the SHD MCP backend as ${resource.uri}.\n\nThe standalone HTML is generated from ${code}widgets/_shared/universal-widget.html${code} and ${code}widgets/_shared/universal-widget-config.json${code} by ${code}scripts/generate-widget-artifacts.mjs${code} using the ${code}${engineName}${code} engine. It uses the MCP Apps bridge first and keeps ${code}window.openai${code} as a compatibility extension; it has no external script or network dependency. The module supplies its data and view configuration through the render-tool metadata.\n`;
|
|
}
|
|
|
|
function main() {
|
|
ensureCanonicalTemplate();
|
|
let template = readFileSync(templatePath, 'utf8');
|
|
const configExisted = existsSync(configPath);
|
|
const config = ensureWidgetConfig(template);
|
|
if (extractConfigOnly) {
|
|
console.log(`${configExisted ? 'checked' : 'extracted'} widget config: ${configPath}`);
|
|
return;
|
|
}
|
|
template = migrateCanonicalTemplate(template);
|
|
if (!template.includes(moduleToken)) fail(`canonical template must contain ${moduleToken}`);
|
|
if (!template.includes(configToken)) fail(`canonical template must contain ${configToken}`);
|
|
|
|
const widgets = readUniversalWidgets();
|
|
if (widgets.length === 0) fail('no universal widget artifacts found');
|
|
let generated = 0;
|
|
for (const artifactName of widgets) {
|
|
const module = runtimeModuleByArtifact.get(artifactName) || artifactName;
|
|
const widgetPath = join(widgetsRoot, artifactName, 'v1');
|
|
const html = renderHtml(template, module, config);
|
|
const { manifest, resource, digest } = manifestFor(widgetPath, html, module);
|
|
const manifestText = `${JSON.stringify(manifest, null, 2)}\n`;
|
|
expectedArtifact(join(widgetPath, 'index.html'), html);
|
|
expectedArtifact(join(widgetPath, 'manifest.json'), manifestText);
|
|
expectedArtifact(join(widgetPath, 'SHA256SUMS'), `${digest} index.html\n`);
|
|
expectedArtifact(join(widgetPath, 'UPSTREAM.md'), upstreamFor(widgetPath, resource));
|
|
generated += 1;
|
|
}
|
|
|
|
console.log(`${checkOnly ? 'checked' : 'generated'} ${generated} universal widget artifacts; engine=${engineName}`);
|
|
}
|
|
|
|
try {
|
|
main();
|
|
} catch (error) {
|
|
console.error(error instanceof Error ? error.message : String(error));
|
|
process.exitCode = 1;
|
|
}
|