>;
+
+ private _webServerUrl?: string;
+ public get webServerUrl() { return this._webServerUrl; }
+
+ private socketIoServer: SocketIoServer | undefined;
+
+ async bootWsServer() {
+ // TODO: we could wait until the workspace info is loaded only
+ if (!this.configLoader) throw new Error('no configLoader');
+ await this.configLoader.isReady;
+
+ const uwsServerListeningDeferred = createDeferredPromise();
+
+ const certDir = `${this.configLoader.workspaceRootPath}/.dmno/certs`;
+ this.certs = await loadOrCreateTlsCerts('localhost', certDir);
+
+
+ const devUiPath = path.resolve(`${__dirname}/../dev-ui-dist/`);
+
+ // ensure the dev ui dist files actually exist (should only be a problem during local dev)
+ let devUiIndexHtml: string;
+ if (this.opts?.enableWebUi) {
+ try {
+ devUiIndexHtml = await fs.promises.readFile(path.join(devUiPath, '/index.html'), 'utf-8');
+ } catch (err) {
+ throw new Error(`dev ui dist files not found @ ${devUiPath}`);
+ }
+ }
+
+ this.uwsServer = uWS.SSLApp({
+ cert_file_name: path.join(certDir, 'SERVER.crt'),
+ key_file_name: path.join(certDir, 'SERVER_key.pem'),
+ ca_file_name: path.join(certDir, 'CA.crt'),
+ // passphrase: '1234',
+ })
+ .any('/api/:requestName', async (res, req) => {
+ /* Can't return or yield from here without responding or attaching an abort handler */
+ res.onAborted(() => {
+ res.aborted = true;
+ });
+
+ if (!uwsValidateClientCert(res, this.certs!.caCert)) return;
+
+ const reqName = req.getParameter(0) || '';
+ if (!(reqName in this.commands)) {
+ res.writeStatus('404');
+ res.end(JSON.stringify({ error: 'Not found!' }));
+ return;
+ }
+
+ // parse the body to get function args
+ let args;
+ if (req.getMethod() === 'post') {
+ try {
+ args = await uwsBodyParser(res);
+ } catch (err) {
+ res.writeStatus('400');
+ console.log(err);
+ res.end(JSON.stringify({ error: 'body parsing failed' }));
+ return;
+ }
+ } else if (req.getMethod() === 'get') {
+ args = [];
+ } else {
+ res.writeStatus('404');
+ res.end(JSON.stringify({ error: 'unsupported method' }));
+ return;
+ }
+
+
+ // @ts-ignore
+ const rawResponse = await this.commands[reqName].call(this, ...args);
+
+ /* If we were aborted, you cannot respond */
+ if (!res.aborted) {
+ res.cork(() => {
+ res.end(JSON.stringify(rawResponse));
+ });
+ }
+ })
+ .any('/*', async (res, req) => {
+ res.onAborted(() => {
+ res.aborted = true;
+ });
+
+ if (!uwsValidateClientCert(res, this.certs!.caCert)) return;
+
+ if (!this.opts?.enableWebUi) {
+ res.writeStatus('404');
+ res.writeHeader('content-type', 'text/html');
+ res.end('dmno web ui is disabled
Run `dmno dev` to boot the web dashboard
');
+ return;
+ }
+
+ // have to use .any for the route matching to work properly
+ if (req.getMethod() !== 'get') {
+ res.writeStatus('404');
+ res.end(JSON.stringify({ error: 'method not supported' }));
+ }
+
+
+ let reqPath = req.getUrl();
+ if (!reqPath || reqPath === '/') reqPath = '/index.html';
+ // debugWeb('http request', reqPath);
+
+
+ const fullPath = path.join(devUiPath, reqPath);
+ const extension = fullPath.split('.').pop();
+
+ let fileContents = devUiIndexHtml;
+ let contentType = 'text/html';
+
+ try {
+ fileContents = await fs.promises.readFile(fullPath, 'utf-8');
+ contentType = (MIME_TYPES_BY_EXT as any)[extension || ''];
+ } catch (err) {
+ if ((err as any).code === 'ENOENT') {
+ if (reqPath.startsWith('/assets/')) {
+ res.writeStatus('404');
+ res.writeHeader('content-type', 'text/html');
+ res.end('oops! file does not exist
');
+ return;
+ }
+ } else {
+ throw err;
+ }
+ }
+
+ if (!res.aborted) {
+ res.cork(() => {
+ res.writeStatus('200');
+ res.writeHeader('content-type', contentType);
+ res.end(fileContents);
+ });
+ }
+ })
+ .listen(this.uwsPort, (token) => {
+ this.uwsPort = uWS.us_socket_local_port(token);
+ this._webServerUrl = `https://localhost:${this.uwsPort}`;
+ if (token) {
+ console.log(`Listening to port ${this.uwsPort}`);
+ } else {
+ console.log('Failed finding available port');
+ }
+ uwsServerListeningDeferred.resolve();
+ });
+
+ process.on('exit', (code) => {
+ // TODO: can be smarter about tracking what needs to be shut down
+ try {
+ this.uwsServer?.close();
+ } catch (err) {
+
+ }
+ });
+
+ await uwsServerListeningDeferred.promise;
+
+ if (this.opts?.enableWebUi) {
+ await this.initSocketIoServer();
+ }
+ }
+
+ async initSocketIoServer() {
+ if (!this.configLoader) throw new Error('configLoader not found');
+
+ const debugWeb = Debug('dmno:webserver');
+
+ this.socketIoServer = new SocketIoServer({
+ path: '/ws',
+ serveClient: false,
+ // allowRequest: (req, callback) => {
+ // console.log('checking', req);
+ // callback(null, true);
+ // },
+ cors: { origin: '*' },
+ });
+ this.socketIoServer.attachApp(this.uwsServer);
+ this.socketIoServer.on('connection', (socket) => {
+ debugWeb('socket connection');
+ // let handshake = socket.handshake;
+
+ socket.on('reload', async () => {
+ const workspace = await this.configLoader?.getWorkspace();
+ socket.emit('workspace-update', workspace);
+ });
+
+ socket.on('launch-editor', async (fileUrl) => {
+ launchEditor(fileUrl);
+ });
+
+ socket.onAny((event, args) => {
+ debugWeb('socket event!', event, args);
+ });
+
+ socket.on('request', async (message) => {
+ debugWeb('received request over websocket', message);
+
+ await this.configLoader!.isReady;
+
+ const result = await this.makeRequest(message.requestType, ...message.args);
+
+ socket.emit('request-response', {
+ requestId: message.requestId,
+ response: result,
+ });
+ });
+
+ debugWeb('connected!');
+ });
+ }
+
+
+ shutdown() {
+ this.uwsServer?.close();
+ this.configLoader?.shutdown().catch(() => {
+ console.log('error shutting down dmno vite dev server');
+ });
+ }
+
+ async makeRequest<
+ K extends keyof typeof this.commands,
+ >(
+ requestName: K,
+ ...args: Parameters
+ ): Promise> {
+ console.log('make request', requestName);
+ // have to wait for server to be ready before we can send a request
+ await this.webServerReady;
+
+ // In theory, we could check if we are currently in the parent server
+ // and if so skip communicating over http/uws
+ // but the overhead seems negligible?
+
+ // if not a child, we will wait for the config loader to finish loading
+ if (!this.isChildServer) {
+ await this.configLoader?.isReady;
+ console.timeEnd('init configloader');
+
+ // we can bypass the http request if this is not a child server
+ // but the overhead is very minimal, so we will re-enable this later
+ // return (this.commands[requestName] as any).apply(this, args);
+ }
+
+ const rawResult = await this.mTlsFetchHelper(`/api/${requestName}`, args);
+ const result = JSON.parse(rawResult as any);
+ // const result = await rawResult.json();
+ return result;
+ }
+
+ private async mTlsFetchHelper(urlPath: string, data?: any) {
+ const deferred = createDeferredPromise();
+ if (!this.certs) throw new Error('missing certs!');
+
+ const postData = JSON.stringify(data);
+
+ const clientOptions = {
+ hostname: 'localhost',
+ port: this.uwsPort,
+ path: urlPath,
+ method: 'POST',
+ ...data !== undefined && {
+ headers: {
+ 'Content-Type': 'application/json',
+ 'Content-Length': Buffer.byteLength(postData),
+ },
+ },
+ key: this.certs.clientKey,
+ cert: this.certs.clientCert,
+ ca: [this.certs.caCert],
+ rejectUnauthorized: false,
+ };
+
+ const req = https.request(clientOptions, (res) => {
+ let data = '';
+ res.on('data', (chunk) => {
+ data += chunk;
+ });
+ res.on('end', () => {
+ // console.log('Response from server:', data);
+ deferred.resolve(data);
+ });
+ });
+
+ req.on('error', (e) => {
+ // console.error('errp', e);
+ deferred.reject(e);
+ });
+
+ if (data !== undefined) req.write(postData);
+ req.end();
+
+ return deferred.promise;
+ }
+
+
+
+ setCacheMode(cacheMode: CacheMode) {
+ if (this.configLoader) {
+ this.configLoader.cacheMode = cacheMode;
+ }
+ }
+ enableWatchMode(onReload: () => void | Promise) {
+ if (this.configLoader) {
+ console.log('enable watch mode');
+ this.configLoader.devMode = true;
+ this.configLoader.onReload = async () => {
+ console.log('configLoader triggered reload handler');
+ await onReload();
+
+ if (this.socketIoServer) {
+ const workspace = await this.configLoader?.getWorkspace();
+ this.socketIoServer.emit('workspace-update', workspace);
+ }
+ };
+ }
+ }
+
+ // ~ external facing functions to interact with config
+ commands = {
+ ping() {
+ return { pong: true };
+ },
+ loadFullSchema: async () => {
+ console.time('get workspace');
+ const workspace = await this.configLoader?.getWorkspace()!;
+ console.timeEnd('get workspace');
+
+ console.time('resolve');
+ await workspace.resolveConfig();
+ console.timeEnd('resolve');
+ return workspace.toJSON();
+ },
+ getInjectedJson: async (serviceId: string) => {
+ const workspace = await this.configLoader?.getWorkspace()!;
+ const service = workspace.getService(serviceId);
+ return service.getInjectedEnvJSON();
+ },
+ clearCache: async () => {
+ const workspace = await this.configLoader?.getWorkspace()!;
+ const cacheFilePath = workspace.configraph.cacheProvider.cacheFilePath;
+
+ let wasDeleted = false;
+ if (await pathExists(cacheFilePath)) {
+ await workspace.configraph.cacheProvider.reset();
+ wasDeleted = true;
+ }
+
+ return {
+ cacheFilePath,
+ wasDeleted,
+ };
+ },
+ };
+
+ async getWorkspace() {
+ return this.makeRequest('loadFullSchema');
+ }
+
+ // TODO: this isnt necessarily in the right place
+ // but the logic was moved from ConfigServerClient and it is convenient to have
+ // this within whatever will be imported and used within integrations (vite plugins)
+ async getCurrentPackageConfig() {
+ const packageName = getCurrentPackageName();
+ if (packageName === '') {
+ throw new Error('To use dmno, you must set a package "name" in your package.json file');
+ }
+ // what to do if we can't figure out a package name?
+
+ const workspace = await this.getWorkspace();
+ const service = Object.values(workspace.services).find((s) => s.packageName === packageName);
+ if (!service) {
+ throw new Error(`Unable to select service - ${packageName}`);
+ }
+
+ const injectedEnv = await this.makeRequest('getInjectedJson', service.serviceName);
+
+ return {
+ serviceDetails: service,
+ injectedEnv,
+ };
+ }
+}
+
diff --git a/packages/core/src/config-loader/find-services.ts b/packages/core/src/config-loader/find-services.ts
index 5b611a32..f4f3efe9 100644
--- a/packages/core/src/config-loader/find-services.ts
+++ b/packages/core/src/config-loader/find-services.ts
@@ -1,6 +1,5 @@
import fs from 'node:fs';
import path from 'node:path';
-import { fileURLToPath } from 'node:url';
import _ from 'lodash-es';
import readYamlFile from 'read-yaml-file';
import { fdir } from 'fdir';
@@ -11,8 +10,12 @@ import { pathExists } from '../lib/fs-utils';
const debug = Debug('dmno:find-services');
+const jsonFileCache: Record = {};
export async function readJsonFile(path: string) {
- return JSON.parse(await fs.promises.readFile(path, 'utf8'));
+ if (jsonFileCache[path]) return jsonFileCache[path];
+ const packageJsonObj = JSON.parse(await fs.promises.readFile(path, 'utf8'));
+ jsonFileCache[path] = packageJsonObj;
+ return packageJsonObj;
}
@@ -56,7 +59,7 @@ const WORKSPACE_SETTINGS_LOCATIONS = [
// { file: 'deno.jsonc', path: 'workspace', optional: true },
];
-export async function findDmnoServices(includeUnitialized = true): Promise {
+export async function findDmnoServices(includeUnitialized = false): Promise {
const startAt = new Date();
let gitRootPath: string | undefined;
@@ -134,14 +137,17 @@ export async function findDmnoServices(includeUnitialized = true): Promise path.join(dmnoWorkspaceRootPath, gi));
- const packageGlobs = fullPackagePatterns.filter((s) => s.includes('*'));
- const packageDirs = fullPackagePatterns.filter((s) => !s.includes('*'));
+ const patternsByType = _.groupBy(
+ fullPackagePatterns,
+ (s) => (s.includes('*') ? 'globs' : 'dirs'),
+ );
+
const expandedPathsFromGlobs = await (
// tried a few different libs here (tiny-glob being the other main contender) and this is WAY faster especially with some tuning :)
new fdir() // eslint-disable-line new-cap
.withBasePath()
.onlyDirs()
- .glob(...packageGlobs)
+ .glob(...patternsByType.globs || [])
.exclude((dirName, _dirPath) => {
// this helps speed things up since it stops recursing into these directories
return (
@@ -156,7 +162,7 @@ export async function findDmnoServices(includeUnitialized = true): Promise p.replace(/\/$/, '')); // remove trailing slash
packagePaths = _.uniq(packagePaths);
diff --git a/packages/core/src/config-loader/ipc-requests.ts b/packages/core/src/config-loader/ipc-requests.ts
deleted file mode 100644
index 47e74722..00000000
--- a/packages/core/src/config-loader/ipc-requests.ts
+++ /dev/null
@@ -1,20 +0,0 @@
-import { InjectedDmnoEnv } from '../config-engine/config-engine';
-import { SerializedService, SerializedWorkspace } from './serialization-types';
-
-export type ConfigLoaderRequestMap = {
- 'load-full-schema': {
- payload: undefined | { resolve?: boolean },
- response: SerializedWorkspace,
- },
- 'get-resolved-config': {
- payload: {
- serviceName?: string,
- packageName?: string,
- },
- response: { serviceDetails: SerializedService, injectedEnv: InjectedDmnoEnv },
- },
- 'generate-types': {
- payload: { serviceName?: string },
- response: { tsSrc: string },
- },
-};
diff --git a/packages/core/src/config-loader/serialization-types.ts b/packages/core/src/config-loader/serialization-types.ts
index ab5e0bda..10c85a7a 100644
--- a/packages/core/src/config-loader/serialization-types.ts
+++ b/packages/core/src/config-loader/serialization-types.ts
@@ -83,6 +83,7 @@ ConfigraphDataTypeDefinition,
export type SerializedDmnoPlugin =
Omit & {
+ cliPath?: string,
inputNodes: Record
};
diff --git a/packages/core/src/config-loader/vite-server.ts b/packages/core/src/config-loader/vite-server.ts
index 07f1f3a1..86283175 100644
--- a/packages/core/src/config-loader/vite-server.ts
+++ b/packages/core/src/config-loader/vite-server.ts
@@ -1,8 +1,18 @@
+import { fileURLToPath } from 'url';
import { HmrContext, Plugin, createServer } from 'vite';
import { ViteNodeRunner } from 'vite-node/client';
import { ViteNodeServer } from 'vite-node/server';
import { installSourcemapsSupport } from 'vite-node/source-map';
import MagicString from 'magic-string';
+import buildEsmResolver from 'esm-resolve';
+
+// this lets us detect what is the current executing dmno
+// const esmResolver = buildEsmResolver(process.cwd(), {
+// isDir: true,
+// constraints: 'node',
+// resolveToAbsolute: true,
+// });
+// const currentDmnoPath = esmResolver('dmno');
export async function setupViteServer(opts: {
workspaceRootPath: string,
@@ -28,6 +38,7 @@ export async function setupViteServer(opts: {
// pointing at dist/index is hard-coded...
// we could extract the main entry point from the resolution instead?
id: `${opts.workspaceRootPath}/node_modules/dmno/dist/index.js`,
+ // id: currentDmnoPath,
external: 'absolute',
};
}
@@ -38,7 +49,7 @@ export async function setupViteServer(opts: {
// TODO: we probably should limit which files this applies in
const fixedCode = new MagicString(code);
if (!code.includes("import { getResolverCtx } from 'dmno'")) {
- fixedCode.prepend('import { getResolverCtx } from \'dmno\';\n');
+ fixedCode.prepend("import { getResolverCtx } from 'dmno';\n");
}
fixedCode.replaceAll(/DMNO_CONFIG\.([\w\d.]+)/g, 'getResolverCtx().get(\'$1\')');
@@ -58,8 +69,9 @@ export async function setupViteServer(opts: {
// ignore updates to the generated type files
if (ctx.file.includes('/.dmno/.typegen/')) return;
- // TODO: not too sure about this, but we shouldn't be reloading the config when the user's app code is updated
// ignore files outside of the .dmno folder(s)?
+ // generally, we shouldn't be reloading the config when the user's app code is updated
+ // maybe there are exceptions (package.json? something else?)
if (!ctx.file.includes('/.dmno/')) return;
// console.log('hot reload in vite plugin', ctx);
@@ -95,11 +107,12 @@ export async function setupViteServer(opts: {
// },
// ssr: true,
},
+ // TODO: when watch is enabled, maybe we can we narrow down which files?
...!opts.enableWatch && { server: { watch: null } },
});
// console.log(server.config);
- // this is need to initialize the plugins
+ // required for plugins
await server.pluginContainer.buildStart({});
// create vite-node server
@@ -122,18 +135,17 @@ export async function setupViteServer(opts: {
debug: true,
root: server.config.root,
base: server.config.base,
- // when having the server and runner in a different context,
- // you will need to handle the communication between them
- // and pass to this function
+ // when having the server and runner in a different context
+ // you will need to handle the communication between them and pass to this function
async fetchModule(id) {
- // console.log('fetch module', id);
+ // console.log('fetch module', id);
return node.fetchModule(id);
},
async resolveId(id, importer) {
- // console.log('resolve id', id, importer);
+ // console.log('resolve id', id, importer);
return node.resolveId(id, importer);
},
});
- return { viteRunner };
+ return { viteRunner, viteServer: server };
}
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
index bf77293b..fdcd44ec 100644
--- a/packages/core/src/index.ts
+++ b/packages/core/src/index.ts
@@ -4,9 +4,12 @@ export * from './config-engine/authoring-utils';
export * from './config-engine/configraph-adapter';
export * from './config-engine/dmno-plugin';
export * from './config-engine/data-types';
-export * from './config-loader/config-server-client';
+export * from './config-engine/check-errors-helpers';
+export * from './config-loader/dmno-server';
export * from './globals-injector/injector';
+
+
export * from './config-loader/serialization-types';
// used by 1pass plugin - will likely extract eventually
diff --git a/packages/core/src/lib/certs.ts b/packages/core/src/lib/certs.ts
index 745273f9..9c148350 100644
--- a/packages/core/src/lib/certs.ts
+++ b/packages/core/src/lib/certs.ts
@@ -1,53 +1,347 @@
+// many mTLS examples led to certs that did not actually work in the browser
+// this code was heavily inspired by https://github.com/BenEdridge/mutual-tls
+// which actually gives good complete examples that work
+
import fs from 'node:fs';
import path from 'node:path';
-import { createCA, createCert } from 'mkcert';
+import forge from 'node-forge';
import { pathExists } from './fs-utils';
-export async function createLocalSslCert(domain: string, certDirPath: string = '') {
- const certPath = path.join(certDirPath, 'local.crt');
- const keyPath = path.join(certDirPath, 'local.key');
- let cert: string | undefined;
- let key: string | undefined;
+const { pki } = forge;
+
+type CertSubjects = Array;
+type CertConfig = {
+ attrs: CertSubjects,
+ extensions?: Array,
+};
+
+const CERT_KEYSIZE = 2048;
+// TODO: do we want to let you use a non localhost host?
+const CERT_HOST = 'localhost';
+// TODO: do we want to let the user pick the password? Or use none?
+const CERT_PASS = 'password';
+
+async function loadCertPem(certDirPath: string, prefix: string, isKey = false) {
+ return fs.promises.readFile(path.join(certDirPath, `${prefix}${isKey ? '_key.pem' : '.crt'}`), 'utf8');
+}
+
+export async function loadOrCreateTlsCerts(domain: string, certDirPath: string) {
+ try {
+ const clientKey = await loadCertPem(certDirPath, 'CLIENT', true);
+ const clientCert = await loadCertPem(certDirPath, 'CLIENT', false);
+ const serverKey = await loadCertPem(certDirPath, 'SERVER', true);
+ const serverCert = await loadCertPem(certDirPath, 'SERVER', false);
+ const caCert = await loadCertPem(certDirPath, 'CA', false);
- if (certDirPath) {
- try {
- cert = await fs.promises.readFile(certPath, 'utf-8');
- key = await fs.promises.readFile(keyPath, 'utf-8');
- } catch (err) {
- // console.log('error...?', err);
- }
+ // console.log('loaded existing tls certs');
+ return {
+ clientKey,
+ clientCert,
+ serverKey,
+ serverCert,
+ caCert,
+ };
+ } catch (err) {
+ // console.log('generating new tls certs');
+ return createTlsCerts(domain, certDirPath);
}
+}
+
+const CA: CertConfig = Object.freeze({
+ attrs: [
+ {
+ name: 'commonName',
+ value: 'DMNO Local Certificate Authority',
+ },
+ {
+ name: 'countryName',
+ value: 'US',
+ },
+ {
+ shortName: 'ST',
+ value: 'Virginia',
+ },
+ {
+ name: 'localityName',
+ value: 'Blacksburg',
+ },
+ {
+ name: 'organizationName',
+ value: 'CA LTD',
+ },
+ {
+ shortName: 'OU',
+ value: 'Local Cert Auth',
+ },
+ ],
+ extensions: [
+ {
+ name: 'basicConstraints',
+ cA: true,
+ },
+ {
+ name: 'keyUsage',
+ keyCertSign: true,
+ digitalSignature: true,
+ nonRepudiation: true,
+ keyEncipherment: true,
+ dataEncipherment: true,
+ },
+ {
+ name: 'extKeyUsage',
+ serverAuth: true,
+ clientAuth: true,
+ codeSigning: true,
+ emailProtection: true,
+ timeStamping: true,
+ },
+ {
+ name: 'nsCertType',
+ client: true,
+ server: true,
+ email: true,
+ objsign: true,
+ sslCA: true,
+ emailCA: true,
+ objCA: true,
+ },
+ {
+ name: 'subjectAltName',
+ altNames: [
+ {
+ type: 6, // URI
+ value: 'http://localhost',
+ },
+ {
+ type: 7, // IP
+ ip: '127.0.0.1',
+ },
+ ],
+ },
+ {
+ name: 'subjectKeyIdentifier',
+ },
+ ],
+});
+
+const SERVER: CertConfig = Object.freeze({
+ attrs: [{
+ name: 'commonName',
+ value: CERT_HOST,
+ }, {
+ name: 'countryName',
+ value: 'US',
+ }, {
+ shortName: 'ST',
+ value: 'Virginia',
+ }, {
+ name: 'localityName',
+ value: 'Blacksburg',
+ }, {
+ name: 'organizationName',
+ value: CERT_HOST,
+ }, {
+ shortName: 'OU',
+ value: CERT_HOST,
+ }],
+ extensions: [
+ {
+ name: 'basicConstraints',
+ cA: true,
+ },
+ {
+ name: 'keyUsage',
+ keyCertSign: true,
+ digitalSignature: true,
+ nonRepudiation: true,
+ keyEncipherment: true,
+ dataEncipherment: true,
+ },
+ {
+ name: 'extKeyUsage',
+ serverAuth: true,
+ clientAuth: true,
+ codeSigning: true,
+ emailProtection: true,
+ timeStamping: true,
+ },
+ {
+ name: 'nsCertType',
+ client: true,
+ server: true,
+ email: true,
+ objsign: true,
+ sslCA: true,
+ emailCA: true,
+ objCA: true,
+ },
+ {
+ name: 'subjectAltName',
+ altNames: [
+ {
+ type: 6, // URI
+ value: 'http://localhost',
+ },
+ {
+ type: 7, // IP
+ ip: '127.0.0.1',
+ },
+ ],
+ },
+ {
+ name: 'subjectKeyIdentifier',
+ },
+ ],
+});
+
+const CLIENT = Object.freeze({
+ attrs: [{
+ name: 'commonName',
+ value: 'dmno.dev local client cert',
+ }, {
+ name: 'countryName',
+ value: 'US',
+ }, {
+ shortName: 'ST',
+ value: 'Virginia',
+ }, {
+ name: 'localityName',
+ value: 'Blacksburg',
+ }, {
+ name: 'organizationName',
+ value: 'test client',
+ }, {
+ shortName: 'OU',
+ value: 'dmno.dev local client cert',
+ }],
+});
- if (!cert) {
- const ca = await createCA({
- organization: 'DMNO',
- countryCode: 'CA',
- state: 'Toronto',
- locality: 'Canada',
- validity: 365,
- });
-
- const certPair = await createCert({
- ca: { key: ca.key, cert: ca.cert },
- domains: [domain],
- validity: 365,
- });
- cert = certPair.cert;
- key = certPair.key;
-
- if (certDirPath) {
- if (!await pathExists(certDirPath)) {
- await fs.promises.mkdir(certDirPath);
- }
- await fs.promises.writeFile(certPath, cert);
- await fs.promises.writeFile(keyPath, key);
- console.log('Generated local SSL cert');
- }
+
+
+let counter = 1;
+function buildCert(
+ certDirPath: string,
+ prefix: string,
+ config: CertConfig,
+ issuer?: CertConfig,
+ signer?: forge.pki.rsa.KeyPair,
+) {
+ console.log('Building ', prefix, ' ...');
+ const kp = pki.rsa.generateKeyPair(CERT_KEYSIZE);
+ const cert = pki.createCertificate();
+ cert.publicKey = kp.publicKey;
+
+ // NOTE: serialNumber is the hex encoded value of an ASN.1 INTEGER.
+ // Conforming CAs should ensure serialNumber is: no more than 20 octets, non-negative (prefix a '00' if your value starts with a '1' bit)
+ // cert.serialNumber = `00${crypto.randomBytes(4).toString('hex')}`;
+ cert.serialNumber = `00${counter++}`;
+
+ cert.validity.notBefore = new Date();
+ cert.validity.notAfter = new Date();
+ cert.validity.notAfter.setFullYear(cert.validity.notBefore.getFullYear() + 1);
+
+ cert.setSubject(config.attrs);
+
+ // Set the CA.attrs as an issuer for both server and client
+ if (issuer) {
+ cert.setIssuer(CA.attrs);
+ } else {
+ cert.setIssuer(config.attrs);
+ }
+
+ if (config.extensions) {
+ cert.setExtensions(config.extensions);
}
+ /* optionally add more extensions
+ extensions.push.apply(extensions, [{
+ name: 'basicConstraints',
+ cA: true
+ }, {
+ name: 'keyUsage',
+ keyCertSign: true,
+ digitalSignature: true,
+ nonRepudiation: true,
+ keyEncipherment: true,
+ dataEncipherment: true
+ }]);
+ cert.setExtensions(extensions);
+ */
+
+ signCert(cert, kp, issuer, signer);
+ writeToFile(certDirPath, prefix, cert, kp);
+
+ return { keyPair: kp, certificate: cert };
+}
+
+
+
+
+function signCert(
+ cert: forge.pki.Certificate,
+ keyPair: forge.pki.rsa.KeyPair,
+ issuer?: CertConfig,
+ signer?: forge.pki.rsa.KeyPair,
+) {
+ if (!issuer && !signer) {
+ cert.sign(keyPair.privateKey, forge.md.sha256.create());
+ } else if (signer) {
+ cert.sign(signer.privateKey, forge.md.sha256.create());
+ } else {
+ throw new Error('signer not set');
+ }
+}
+
+function writeToFile(
+ certDirPath: string,
+ prefix: string,
+ cert: forge.pki.Certificate,
+ keyPair: forge.pki.rsa.KeyPair,
+) {
+ const pem = pki.certificateToPem(cert);
+ try {
+ fs.writeFileSync(`${certDirPath}/${prefix}.crt`, pem, 'utf8');
+ fs.writeFileSync(`${certDirPath}/${prefix}_key.pem`, pki.privateKeyToPem(keyPair.privateKey), 'utf8');
+ } catch (e) {
+ console.error('Error writing files out', e);
+ }
+ console.log('Output files', `${certDirPath}/${prefix}.crt`, ' and ', `${certDirPath}/${prefix}_key.pem`);
+}
+
+function buildAndWriteP12(
+ certDirPath: string,
+ prefix: string,
+ privateKey: forge.pki.rsa.PrivateKey,
+ cert: forge.pki.Certificate,
+ password: string | null = null,
+) {
+ console.log('Building P12', prefix, ' ...');
+ // generate a p12 that can be imported by Chrome/Firefox/iOS
+ // (requires the use of Triple DES instead of AES)
+ const p12Asn1 = forge.pkcs12.toPkcs12Asn1(privateKey, cert, password, { algorithm: '3des' });
+ const der = forge.asn1.toDer(p12Asn1).getBytes();
+ fs.writeFileSync(`${certDirPath}/${prefix}.p12`, der, 'binary');
+ console.log(`Output file: ${certDirPath}/${prefix}.p12 with PASSWORD: ${password}`);
+}
+
+
+export async function createTlsCerts(domain: string, certDirPath: string) {
+ if (!await pathExists(certDirPath)) {
+ await fs.promises.mkdir(certDirPath);
+ }
+
+ const ca = buildCert(certDirPath, 'CA', CA);
+ const client = buildCert(certDirPath, 'CLIENT', CLIENT, CA, ca.keyPair);
+ const server = buildCert(certDirPath, 'SERVER', SERVER, CA, ca.keyPair);
+
+ buildAndWriteP12(certDirPath, 'CLIENT', client.keyPair.privateKey, client.certificate, CERT_PASS);
return {
- key, cert,
+ clientKey: pki.privateKeyToPem(client.keyPair.privateKey),
+ clientCert: pki.certificateToPem(client.certificate),
+ serverKey: pki.privateKeyToPem(server.keyPair.privateKey),
+ serverCert: pki.certificateToPem(server.certificate),
+ caCert: pki.certificateToPem(ca.certificate),
};
}
diff --git a/packages/core/src/lib/env-vars.ts b/packages/core/src/lib/env-vars.ts
index 15463e58..88da88f2 100644
--- a/packages/core/src/lib/env-vars.ts
+++ b/packages/core/src/lib/env-vars.ts
@@ -1,5 +1,7 @@
import _ from 'lodash-es';
+let _originalProcessEnv: NodeJS.ProcessEnv;
+
/**
* parse env vars into an object, using a special separator to denote nesting.
* This idea comes from https://www.npmjs.com/package/nconf
@@ -11,11 +13,16 @@ export function getConfigFromEnvVars(
/** separator to interpret as nesting, defaults to "__" */
separator = '__',
) {
- const config = {} as Record;
+ // when we are reloading within the same process
+ // we must ignore any _new_ process.env vars that dmno injected
+ if (_originalProcessEnv) return _originalProcessEnv;
+
+ const configFromProcessEnv = {} as Record;
_.each(process.env, (val, key) => {
const path = key.replaceAll(separator, '.');
// _.set deals with initializing objects when necessary
- _.set(config, path, val);
+ _.set(configFromProcessEnv, path, val);
});
- return config;
+ _originalProcessEnv = configFromProcessEnv;
+ return configFromProcessEnv;
}
diff --git a/packages/core/src/lib/uws-utils.ts b/packages/core/src/lib/uws-utils.ts
new file mode 100644
index 00000000..f0be3b6a
--- /dev/null
+++ b/packages/core/src/lib/uws-utils.ts
@@ -0,0 +1,69 @@
+import crypto from 'node:crypto';
+import uWS from 'uWebSockets.js';
+
+const MAX_BODY_SIZE = 1024;
+
+export const MIME_TYPES_BY_EXT = {
+ js: 'text/javascript',
+ html: 'text/html',
+ css: 'text/css',
+ ico: 'image/x-icon',
+ // TODO: will need more for images
+};
+
+export function uwsBodyParser(res: uWS.HttpResponse): Promise<{ [key: string]: any } | null> {
+ return new Promise((resolve, reject) => {
+ let buffer: Buffer = Buffer.alloc(0);
+ let totalSize = 0;
+
+ res.onData((ab, isLast) => {
+ try {
+ if (res.aborted) {
+ reject(new Error('Request aborted'));
+ return;
+ }
+
+ if (ab.byteLength > 0) { // I found some non-last onData with 0 byte length
+ // Immediately copy the ArrayBuffer into a Buffer, every return of onData neuters the ArrayBuffer
+ // const copy = copyArrayBuffer(ab);
+ const copy = ab;
+ totalSize += copy.byteLength;
+ buffer = Buffer.concat([buffer, Buffer.from(copy)]);
+ }
+
+ if (totalSize > MAX_BODY_SIZE) { // define your allowed max size if it applies to you
+ reject(new Error('Request body too large: max 4MB allowed'));
+ return;
+ }
+
+ if (isLast) {
+ // If this is the last chunk, process the final buffer
+ // Convert the buffer to a string and parse it as JSON
+ // this will fail if the buffer doesn't contain a valid JSON (e.g. length = 0)
+ const resolveValue = JSON.parse(buffer.toString());
+ resolve(resolveValue);
+ }
+ } catch (err: any) {
+ reject(new Error(`Failed to parse JSON: ${err.message}`));
+ }
+ });
+ });
+}
+
+export function uwsValidateClientCert(res: uWS.HttpResponse, caCert: string) {
+ // validate client certs (mTLS)
+ try {
+ const clientCert = res.getX509Certificate();
+ const x509 = new crypto.X509Certificate(clientCert);
+ if (!x509.verify(crypto.createPublicKey(caCert))) {
+ res.writeStatus('401');
+ res.end(JSON.stringify({ error: 'Unauthorized!' }));
+ return false;
+ }
+ return true;
+ } catch (err) {
+ res.writeStatus('401');
+ res.end('Unauthorized!');
+ return false;
+ }
+}
diff --git a/packages/core/tsup.config.ts b/packages/core/tsup.config.ts
index c22ac80f..259cf298 100644
--- a/packages/core/tsup.config.ts
+++ b/packages/core/tsup.config.ts
@@ -16,10 +16,6 @@ export default defineConfig({
// imported as TS directly, so we have to tell tsup to compile it instead of leaving it external
noExternal: [
'@dmno/ts-lib', '@dmno/encryption-lib',
-
- // yarn was having issues with finding the strong-type package for some reason
- // so we'll just bundle them in as a short term solution
- 'node-ipc', '@achrinza/node-ipc', '@achrinza/event-pubsub', '@achrinza/strong-type'
],
external: [
// mark self-imports as external so it will leave them as-is
diff --git a/packages/integrations/astro/src/index.ts b/packages/integrations/astro/src/index.ts
index 477dddeb..6f65c75f 100644
--- a/packages/integrations/astro/src/index.ts
+++ b/packages/integrations/astro/src/index.ts
@@ -3,7 +3,8 @@ import fs from 'node:fs';
import { fileURLToPath } from 'url';
import Debug from 'debug';
import {
- ConfigServerClient, injectDmnoGlobals,
+ checkServiceIsValid,
+ DmnoServer, injectDmnoGlobals,
} from 'dmno';
import type { AstroIntegration } from 'astro';
@@ -19,7 +20,7 @@ let dmnoHasTriggeredReload = false;
let enableDynamicPublicClientLoading = false;
let configItemKeysAccessed: Record = {};
let dmnoConfigValid = true;
-let dmnoConfigClient: ConfigServerClient;
+let dmnoServer: DmnoServer;
let dmnoInjectionResult: ReturnType;
let ssrOutputDirPath: string;
@@ -33,15 +34,15 @@ async function reloadDmnoConfig() {
dmnoInjectionResult = injectDmnoGlobals();
} else {
debug('using injected dmno config server');
- (process as any).dmnoConfigClient ||= new ConfigServerClient();
- dmnoConfigClient = (process as any).dmnoConfigClient;
- const resolvedService = await dmnoConfigClient.getServiceConfig();
+ (process as any).dmnoServer ||= new DmnoServer({ watch: true });
+ dmnoServer = (process as any).dmnoServer;
+ const resolvedService = await dmnoServer.getCurrentPackageConfig();
const injectedConfig = resolvedService.injectedEnv;
dmnoConfigValid = resolvedService.serviceDetails.isValid;
configItemKeysAccessed = {};
// shows nicely formatted errors in the terminal
- ConfigServerClient.checkServiceIsValid(resolvedService.serviceDetails);
+ checkServiceIsValid(resolvedService.serviceDetails);
dmnoInjectionResult = injectDmnoGlobals({
injectedConfig,
@@ -127,9 +128,9 @@ function dmnoAstroIntegration(dmnoIntegrationOpts?: DmnoAstroIntegrationOptions)
...astroCommand === 'dev' && {
async configureServer(server) {
- if (!isRestart && !!dmnoConfigClient) {
+ if (!isRestart && !!dmnoServer) {
debug('initializing dmno reload > astro restart trigger');
- dmnoConfigClient.eventBus.on('reload', () => {
+ dmnoServer.enableWatchMode(() => {
opts.logger.info('š« dmno config updated - restarting astro server');
// eslint-disable-next-line @typescript-eslint/no-floating-promises
server.restart();
diff --git a/packages/integrations/remix/src/index.ts b/packages/integrations/remix/src/index.ts
index 9d7e3d3d..10cd79c8 100644
--- a/packages/integrations/remix/src/index.ts
+++ b/packages/integrations/remix/src/index.ts
@@ -3,7 +3,7 @@ import { fileURLToPath } from 'url';
import _ from 'lodash-es';
import Debug from 'debug';
-import { ConfigServerClient, injectDmnoGlobals } from 'dmno';
+import { checkServiceIsValid, DmnoServer, injectDmnoGlobals } from 'dmno';
import type { Plugin } from 'vite';
import type {
@@ -13,7 +13,7 @@ import type {
const debug = Debug('dmno:remix-integration');
const __dirname = dirname(fileURLToPath(import.meta.url));
-let firstLoad = !(process as any).dmnoConfigClient;
+let firstLoad = !(process as any).dmnoServer;
debug('dmno remix+vite plugin loaded. first load = ', firstLoad);
@@ -21,7 +21,7 @@ let isDevMode: boolean;
let dmnoHasTriggeredReload = false;
let configItemKeysAccessed: Record = {};
let dmnoConfigValid = true;
-let dmnoConfigClient: ConfigServerClient;
+let dmnoServer: DmnoServer;
let dmnoInjectionResult: ReturnType;
let enableDynamicPublicClientLoading = false;
@@ -33,15 +33,15 @@ async function reloadDmnoConfig() {
dmnoInjectionResult = injectDmnoGlobals();
} else {
debug('using injected dmno config server');
- (process as any).dmnoConfigClient ||= new ConfigServerClient();
- dmnoConfigClient = (process as any).dmnoConfigClient;
- const resolvedService = await dmnoConfigClient.getServiceConfig();
+ (process as any).dmnoServer ||= new DmnoServer({ watch: true });
+ dmnoServer = (process as any).dmnoServer;
+ const resolvedService = await dmnoServer.getCurrentPackageConfig();
const injectedConfig = resolvedService.injectedEnv;
dmnoConfigValid = resolvedService.serviceDetails.isValid;
configItemKeysAccessed = {};
// shows nicely formatted errors in the terminal
- ConfigServerClient.checkServiceIsValid(resolvedService.serviceDetails);
+ checkServiceIsValid(resolvedService.serviceDetails);
dmnoInjectionResult = injectDmnoGlobals({
injectedConfig,
@@ -63,7 +63,7 @@ type DmnoPluginOptions = {
};
export function dmnoRemixVitePlugin(dmnoOptions?: DmnoPluginOptions) {
- const dmnoConfigClient: ConfigServerClient = (process as any).dmnoConfigClient;
+ const dmnoServer: DmnoServer = (process as any).dmnoServer;
// detect if we need to build the resolved config into the output
// which is needed when running on external platforms where we dont have ability to use `dmno run`
@@ -121,7 +121,7 @@ export function dmnoRemixVitePlugin(dmnoOptions?: DmnoPluginOptions) {
// adjust vite's setting so it doesnt bury the error messages
config.clearScreen = false;
} else {
- dmnoConfigClient.shutdown();
+ dmnoServer.shutdown();
console.log('š„ DMNO config validation failed š„');
// throwing an error spits out a big useless stack trace... so better to just exit?
process.exit(1);
@@ -139,7 +139,7 @@ export function dmnoRemixVitePlugin(dmnoOptions?: DmnoPluginOptions) {
// there are 2 vite servers running, we need to trigger the reload on the non "spa" one
if (firstLoad && server.config.command === 'serve' && server.config.appType !== 'spa') {
firstLoad = false;
- dmnoConfigClient.eventBus.on('reload', () => {
+ dmnoServer.enableWatchMode(() => {
debug('dmno config client received reload event - restarting vite server');
// eslint-disable-next-line @typescript-eslint/no-floating-promises
server.restart();
diff --git a/packages/integrations/vite/src/index.ts b/packages/integrations/vite/src/index.ts
index b2065676..a906dbd3 100644
--- a/packages/integrations/vite/src/index.ts
+++ b/packages/integrations/vite/src/index.ts
@@ -1,11 +1,11 @@
import _ from 'lodash-es';
import Debug from 'debug';
-import { ConfigServerClient, injectDmnoGlobals } from 'dmno';
+import { checkServiceIsValid, DmnoServer, injectDmnoGlobals } from 'dmno';
import type { Plugin } from 'vite';
const debug = Debug('dmno:vite-integration');
-let firstLoad = !(process as any).dmnoConfigClient;
+let firstLoad = !(process as any).dmnoServer;
debug('dmno vite plugin loaded. first load = ', firstLoad);
@@ -13,7 +13,7 @@ let isDevMode: boolean;
let dmnoHasTriggeredReload = false;
let configItemKeysAccessed: Record = {};
let dmnoConfigValid = true;
-let dmnoConfigClient: ConfigServerClient;
+let dmnoServer: DmnoServer;
let dmnoInjectionResult: ReturnType;
async function reloadDmnoConfig() {
@@ -24,15 +24,15 @@ async function reloadDmnoConfig() {
dmnoInjectionResult = injectDmnoGlobals();
} else {
debug('using injected dmno config server');
- (process as any).dmnoConfigClient ||= new ConfigServerClient();
- dmnoConfigClient = (process as any).dmnoConfigClient;
- const resolvedService = await dmnoConfigClient.getServiceConfig();
+ (process as any).dmnoServer ||= new DmnoServer({ watch: true });
+ dmnoServer = (process as any).dmnoServer;
+ const resolvedService = await dmnoServer.getCurrentPackageConfig();
const injectedConfig = resolvedService.injectedEnv;
dmnoConfigValid = resolvedService.serviceDetails.isValid;
configItemKeysAccessed = {};
// shows nicely formatted errors in the terminal
- ConfigServerClient.checkServiceIsValid(resolvedService.serviceDetails);
+ checkServiceIsValid(resolvedService.serviceDetails);
dmnoInjectionResult = injectDmnoGlobals({
injectedConfig,
@@ -56,7 +56,7 @@ export function injectDmnoConfigVitePlugin(
injectSensitiveConfig: boolean,
},
): Plugin {
- const dmnoConfigClient: ConfigServerClient = (process as any).dmnoConfigClient;
+ const dmnoServer: DmnoServer = (process as any).dmnoServer;
return {
name: 'inject-dmno-config',
@@ -85,7 +85,7 @@ export function injectDmnoConfigVitePlugin(
// adjust vite's setting so it doesnt bury the error messages
config.clearScreen = false;
} else {
- dmnoConfigClient.shutdown();
+ dmnoServer.shutdown();
console.log('š„ DMNO config validation failed š„');
// throwing an error spits out a big useless stack trace... so better to just exit?
process.exit(1);
@@ -96,7 +96,7 @@ export function injectDmnoConfigVitePlugin(
// not sure about this...
if (firstLoad && server.config.command === 'serve') {
firstLoad = false;
- dmnoConfigClient.eventBus.on('reload', () => {
+ dmnoServer.enableWatchMode(() => {
// console.log('vite config received reload event');
// eslint-disable-next-line @typescript-eslint/no-floating-promises
server.restart();
@@ -166,7 +166,7 @@ export function injectDmnoConfigVitePlugin(
// console.log('hot update', file);
// },
buildEnd() {
- if (!isDevMode) dmnoConfigClient.shutdown();
+ if (!isDevMode) dmnoServer.shutdown();
},
};
}
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index c73d5d17..65fd1da5 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -30,9 +30,6 @@ catalogs:
lodash-es:
specifier: ^4.17.21
version: 4.17.21
- mitt:
- specifier: ^3.0.1
- version: 3.0.1
svgo:
specifier: ^3.2.0
version: 3.3.2
@@ -72,8 +69,8 @@ importers:
specifier: ^2.1.0
version: 2.1.0
turbo:
- specifier: ^1.13.3
- version: 1.13.3
+ specifier: ^2.2.3
+ version: 2.2.3
typescript:
specifier: 'catalog:'
version: 5.5.4
@@ -92,9 +89,6 @@ importers:
lodash-es:
specifier: 'catalog:'
version: 4.17.21
- mitt:
- specifier: 'catalog:'
- version: 3.0.1
svgo:
specifier: 'catalog:'
version: 3.3.2
@@ -174,9 +168,6 @@ importers:
diff:
specifier: ^5.2.0
version: 5.2.0
- dotenv:
- specifier: ^16.4.5
- version: 16.4.5
esm-resolve:
specifier: ^1.0.11
version: 1.0.11
@@ -207,18 +198,12 @@ importers:
magic-string:
specifier: ^0.30.12
version: 0.30.12
- mitt:
- specifier: 'catalog:'
- version: 3.0.1
- mkcert:
- specifier: ^3.2.0
- version: 3.2.0
modern-async:
specifier: ^2.0.0
version: 2.0.0
- node-ipc:
- specifier: npm:@achrinza/node-ipc@^10.1.10
- version: '@achrinza/node-ipc@10.1.10'
+ node-forge:
+ specifier: ^1.3.1
+ version: 1.3.1
outdent:
specifier: ^0.8.0
version: 0.8.0
@@ -237,6 +222,9 @@ importers:
typescript:
specifier: 'catalog:'
version: 5.5.4
+ uWebSockets.js:
+ specifier: github:uNetworking/uWebSockets.js#semver:^20.49.0
+ version: https://codeload.github.com/uNetworking/uWebSockets.js/tar.gz/442087c0a01bf146acb7386910739ec81df06700
validate-npm-package-name:
specifier: ^5.0.0
version: 5.0.0
@@ -280,9 +268,9 @@ importers:
'@types/node':
specifier: 'catalog:'
version: 20.14.12
- '@types/node-ipc':
- specifier: ^9.2.3
- version: 9.2.3
+ '@types/node-forge':
+ specifier: ^1.3.11
+ version: 1.3.11
'@types/picomatch':
specifier: ^3.0.1
version: 3.0.1
@@ -1013,22 +1001,6 @@ packages:
resolution: {integrity: sha512-1Yjs2SvM8TflER/OD3cOjhWWOZb58A2t7wpE2S9XfBYTiIl+XFhQG2bjy4Pu1I+EAlCNUzRDYDdFwFYUKvXcIA==}
engines: {node: '>=0.10.0'}
- '@achrinza/event-pubsub@5.0.9':
- resolution: {integrity: sha512-49RyPP7w4abKMsLRHKgB9neAH085mdHQtv+0H5TnJeOq3oK57qQRd/JD9K5Z5D3vFODsvBODiBjYkRQZKdqiAA==}
- engines: {node: 13 || 14 || 16 || 17 || 18 || 19 || 20}
-
- '@achrinza/node-ipc@10.1.10':
- resolution: {integrity: sha512-eBP/YMdiaxFHQ5OlKfYpnarMtuMmdtv+iI21UeXL1yATZEGEvRm2gqPsnio6SRlarLt9/IxTQJl0b/6S5yX+1g==}
- engines: {node: 14 || 16 || 17 || 18 || 19 || 20 || 21}
-
- '@achrinza/strong-type@0.1.11':
- resolution: {integrity: sha512-35Ou0jcGHGKQS8a6lgdan+u3BajmL315ZpDhH2/WSRNgG1jPpizhe87epgLaotN4uY3kXaEbfRU56sBPMdR5LA==}
- engines: {node: 12 || 13 || 14 || 15 || 16 || 17 || 18 || 19 || 20}
-
- '@achrinza/strong-type@1.1.8':
- resolution: {integrity: sha512-ub/mgPRjbqZmwhU3rGya745IMn9znh3cm4g2iGepzvzhZUlKhLRfdkVoUD+H1NLaHE30pRp/FQHEoHTAVcleBQ==}
- engines: {node: ^12.21.0 || 14 || 15 || 16 || 17 || 18 || 19 || 20 || 21}
-
'@ampproject/remapping@2.3.0':
resolution: {integrity: sha512-30iZtAPgz+LTIYoeivqYo853f02jBYSd5uGnGpkFV0M3xOt9aN73erkgYAmZU43x4VfqcnLxW9Kpg3R5LC4YYw==}
engines: {node: '>=6.0.0'}
@@ -3111,10 +3083,6 @@ packages:
cpu: [x64]
os: [win32]
- '@node-ipc/js-queue@2.0.3':
- resolution: {integrity: sha512-fL1wpr8hhD5gT2dA1qifeVaoDFlQR5es8tFuKqjHX+kdOtdNHnxkVZbtIrR2rxnMFvehkjaZRNV2H/gPXlb0hw==}
- engines: {node: '>=1.0.0'}
-
'@nodelib/fs.scandir@2.1.5':
resolution: {integrity: sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==}
engines: {node: '>= 8'}
@@ -3844,8 +3812,8 @@ packages:
'@types/nlcst@2.0.3':
resolution: {integrity: sha512-vSYNSDe6Ix3q+6Z7ri9lyWqgGhJTmzRjZRqyq15N0Z/1/UnVsno9G/N40NBijoYx2seFDIl0+B2mgAb9mezUCA==}
- '@types/node-ipc@9.2.3':
- resolution: {integrity: sha512-/MvSiF71fYf3+zwqkh/zkVkZj1hl1Uobre9EMFy08mqfJNAmpR0vmPgOUdEIDVgifxHj6G1vYMPLSBLLxoDACQ==}
+ '@types/node-forge@1.3.11':
+ resolution: {integrity: sha512-FQx220y22OKNTqaByeBGqHWYz4cl94tpcxeFdvBo3wjG6XPBuZ0BNgNZRV5J5TFmmcsJ4IzsLkmGRiQbnYsBEQ==}
'@types/node@12.20.55':
resolution: {integrity: sha512-J8xLz7q2OFulZ2cyGTLE1TbbZcjpno7FaN6zdJNrgAdrJ+DZzh/uFR6YrTb4C+nXakvud8Q4+rbhoIWlYQbUFQ==}
@@ -5218,10 +5186,6 @@ packages:
resolution: {integrity: sha512-y4Mg2tXshplEbSGzx7amzPwKKOCGuoSRP/CjEdwwk0FOGlUbq6lKuoyDZTNZkmxHdJtp54hdfY/JUrdL7Xfdug==}
engines: {node: '>=14'}
- commander@11.1.0:
- resolution: {integrity: sha512-yPVavfyCcRhmorC7rWlkHn15b4wDVgVmBA7kV4QVBsF7kv/9TKJAbAXVTxvTnwP8HHKjRCJDClKbciiYS7p0DQ==}
- engines: {node: '>=16'}
-
commander@12.0.0:
resolution: {integrity: sha512-MwVNWlYjDTtOjX5PiD7o5pK0UrFU/OYgcJfjjK4RaHZETNtjJqrZa9Y9ds88+A+f+d5lv+561eZ+yCKoS3gbAA==}
engines: {node: '>=18'}
@@ -5776,10 +5740,6 @@ packages:
eastasianwidth@0.2.0:
resolution: {integrity: sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==}
- easy-stack@1.0.1:
- resolution: {integrity: sha512-wK2sCs4feiiJeFXn3zvY0p41mdU5VUgbgs1rNsc/y5ngFUijdWd+iIN8eoyuZHKB8xN6BL4PdWmzqFmxNg6V2w==}
- engines: {node: '>=6.0.0'}
-
ecdsa-sig-formatter@1.0.11:
resolution: {integrity: sha512-nagl3RYrbNv6kQkeJIpt6NJZy8twLB/2vtz6yN9Z4vRKHN4/QZJIEbqohALSgwKdnksuY3k5Addp5lg8sVoVcQ==}
@@ -7540,10 +7500,6 @@ packages:
resolution: {integrity: sha512-34wB/Y7MW7bzjKRjUKTa46I2Z7eV62Rkhva+KkopW7Qvv/OSWBqvkSY7vusOPrNuZcUG3tApvdVgNB8POj3SPw==}
engines: {node: '>=10'}
- js-message@1.0.7:
- resolution: {integrity: sha512-efJLHhLjIyKRewNS9EGZ4UpI8NguuL6fKkhRxVuMmrGV2xN/0APGdQYwLFky5w9naebSZ0OwAGp0G6/2Cg90rA==}
- engines: {node: '>=0.6.0'}
-
js-string-escape@1.0.1:
resolution: {integrity: sha512-Smw4xcfIQ5LVjAOuJCvN/zIodzA/BBSsluuoSykP+lUvScIi4U6RJLfwHet5cxFnCswUjISV8oAXaqaJDY3chg==}
engines: {node: '>= 0.8'}
@@ -8439,11 +8395,6 @@ packages:
resolution: {integrity: sha512-5H76ANWinB1H3twpJ6JY8uvAtpmFvHNArpilJAjXRKXSDDLPIMoZArw5SH0q9z+lLs8IrMw7Q2VWpWimFKFT1Q==}
engines: {node: '>= 8.0.0'}
- mkcert@3.2.0:
- resolution: {integrity: sha512-026Eivq9RoOjOuLJGzbhGwXUAjBxRX11Z7Jbm4/7lqT/Av+XNy9SPrJte6+UpEt7i+W3e/HZYxQqlQcqXZWSzg==}
- engines: {node: '>=16'}
- hasBin: true
-
mkdirp-classic@0.5.3:
resolution: {integrity: sha512-gKLcREMhtuZRwRAfqP3RFW+TK4JqApVBtOIftVgjuABpAtpxhPGaDcfvbhNvD0B8iD1oUr/txX35NjcaY6Ns/A==}
@@ -10782,41 +10733,41 @@ packages:
tunnel-agent@0.6.0:
resolution: {integrity: sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w==}
- turbo-darwin-64@1.13.3:
- resolution: {integrity: sha512-glup8Qx1qEFB5jerAnXbS8WrL92OKyMmg5Hnd4PleLljAeYmx+cmmnsmLT7tpaVZIN58EAAwu8wHC6kIIqhbWA==}
+ turbo-darwin-64@2.2.3:
+ resolution: {integrity: sha512-Rcm10CuMKQGcdIBS3R/9PMeuYnv6beYIHqfZFeKWVYEWH69sauj4INs83zKMTUiZJ3/hWGZ4jet9AOwhsssLyg==}
cpu: [x64]
os: [darwin]
- turbo-darwin-arm64@1.13.3:
- resolution: {integrity: sha512-/np2xD+f/+9qY8BVtuOQXRq5f9LehCFxamiQnwdqWm5iZmdjygC5T3uVSYuagVFsZKMvX3ycySwh8dylGTl6lg==}
+ turbo-darwin-arm64@2.2.3:
+ resolution: {integrity: sha512-+EIMHkuLFqUdJYsA3roj66t9+9IciCajgj+DVek+QezEdOJKcRxlvDOS2BUaeN8kEzVSsNiAGnoysFWYw4K0HA==}
cpu: [arm64]
os: [darwin]
- turbo-linux-64@1.13.3:
- resolution: {integrity: sha512-G+HGrau54iAnbXLfl+N/PynqpDwi/uDzb6iM9hXEDG+yJnSJxaHMShhOkXYJPk9offm9prH33Khx2scXrYVW1g==}
+ turbo-linux-64@2.2.3:
+ resolution: {integrity: sha512-UBhJCYnqtaeOBQLmLo8BAisWbc9v9daL9G8upLR+XGj6vuN/Nz6qUAhverN4Pyej1g4Nt1BhROnj6GLOPYyqxQ==}
cpu: [x64]
os: [linux]
- turbo-linux-arm64@1.13.3:
- resolution: {integrity: sha512-qWwEl5VR02NqRyl68/3pwp3c/olZuSp+vwlwrunuoNTm6JXGLG5pTeme4zoHNnk0qn4cCX7DFrOboArlYxv0wQ==}
+ turbo-linux-arm64@2.2.3:
+ resolution: {integrity: sha512-hJYT9dN06XCQ3jBka/EWvvAETnHRs3xuO/rb5bESmDfG+d9yQjeTMlhRXKrr4eyIMt6cLDt1LBfyi+6CQ+VAwQ==}
cpu: [arm64]
os: [linux]
turbo-stream@2.2.0:
resolution: {integrity: sha512-FKFg7A0To1VU4CH9YmSMON5QphK0BXjSoiC7D9yMh+mEEbXLUP9qJ4hEt1qcjKtzncs1OpcnjZO8NgrlVbZH+g==}
- turbo-windows-64@1.13.3:
- resolution: {integrity: sha512-Nudr4bRChfJzBPzEmpVV85VwUYRCGKecwkBFpbp2a4NtrJ3+UP1VZES653ckqCu2FRyRuS0n03v9euMbAvzH+Q==}
+ turbo-windows-64@2.2.3:
+ resolution: {integrity: sha512-NPrjacrZypMBF31b4HE4ROg4P3nhMBPHKS5WTpMwf7wydZ8uvdEHpESVNMOtqhlp857zbnKYgP+yJF30H3N2dQ==}
cpu: [x64]
os: [win32]
- turbo-windows-arm64@1.13.3:
- resolution: {integrity: sha512-ouJCgsVLd3icjRLmRvHQDDZnmGzT64GBupM1Y+TjtYn2LVaEBoV6hicFy8x5DUpnqdLy+YpCzRMkWlwhmkX7sQ==}
+ turbo-windows-arm64@2.2.3:
+ resolution: {integrity: sha512-fnNrYBCqn6zgKPKLHu4sOkihBI/+0oYFr075duRxqUZ+1aLWTAGfHZLgjVeLh3zR37CVzuerGIPWAEkNhkWEIw==}
cpu: [arm64]
os: [win32]
- turbo@1.13.3:
- resolution: {integrity: sha512-n17HJv4F4CpsYTvKzUJhLbyewbXjq1oLCi90i5tW1TiWDz16ML1eDG7wi5dHaKxzh5efIM56SITnuVbMq5dk4g==}
+ turbo@2.2.3:
+ resolution: {integrity: sha512-5lDvSqIxCYJ/BAd6rQGK/AzFRhBkbu4JHVMLmGh/hCb7U3CqSnr5Tjwfy9vc+/5wG2DJ6wttgAaA7MoCgvBKZQ==}
hasBin: true
type-check@0.4.0:
@@ -10913,6 +10864,10 @@ packages:
engines: {node: '>=14.17'}
hasBin: true
+ uWebSockets.js@https://codeload.github.com/uNetworking/uWebSockets.js/tar.gz/442087c0a01bf146acb7386910739ec81df06700:
+ resolution: {tarball: https://codeload.github.com/uNetworking/uWebSockets.js/tar.gz/442087c0a01bf146acb7386910739ec81df06700}
+ version: 20.49.0
+
ufo@1.5.3:
resolution: {integrity: sha512-Y7HYmWaFwPUmkoQCUIAYpKqkOf+SbVj/2fJJZ4RJMCfZp0rTGwRbzQD+HghfnhKOjL9E01okqz+ncJskGYfBNw==}
@@ -11982,21 +11937,6 @@ snapshots:
'@aashutoshrathi/word-wrap@1.2.6': {}
- '@achrinza/event-pubsub@5.0.9':
- dependencies:
- '@achrinza/strong-type': 0.1.11
-
- '@achrinza/node-ipc@10.1.10':
- dependencies:
- '@achrinza/event-pubsub': 5.0.9
- '@achrinza/strong-type': 1.1.8
- '@node-ipc/js-queue': 2.0.3
- js-message: 1.0.7
-
- '@achrinza/strong-type@0.1.11': {}
-
- '@achrinza/strong-type@1.1.8': {}
-
'@ampproject/remapping@2.3.0':
dependencies:
'@jridgewell/gen-mapping': 0.3.5
@@ -14418,10 +14358,6 @@ snapshots:
'@next/swc-win32-x64-msvc@14.2.3':
optional: true
- '@node-ipc/js-queue@2.0.3':
- dependencies:
- easy-stack: 1.0.1
-
'@nodelib/fs.scandir@2.1.5':
dependencies:
'@nodelib/fs.stat': 2.0.5
@@ -15182,7 +15118,7 @@ snapshots:
dependencies:
'@types/unist': 3.0.2
- '@types/node-ipc@9.2.3':
+ '@types/node-forge@1.3.11':
dependencies:
'@types/node': 20.14.12
@@ -17134,8 +17070,6 @@ snapshots:
commander@10.0.1: {}
- commander@11.1.0: {}
-
commander@12.0.0: {}
commander@2.20.3: {}
@@ -17652,8 +17586,6 @@ snapshots:
eastasianwidth@0.2.0: {}
- easy-stack@1.0.1: {}
-
ecdsa-sig-formatter@1.0.11:
dependencies:
safe-buffer: 5.2.1
@@ -19979,8 +19911,6 @@ snapshots:
joycon@3.1.1: {}
- js-message@1.0.7: {}
-
js-string-escape@1.0.1: {}
js-stringify@1.0.2: {}
@@ -21381,11 +21311,6 @@ snapshots:
mixme@0.5.10: {}
- mkcert@3.2.0:
- dependencies:
- commander: 11.1.0
- node-forge: 1.3.1
-
mkdirp-classic@0.5.3: {}
mkdirp@0.5.6:
@@ -24385,34 +24310,34 @@ snapshots:
dependencies:
safe-buffer: 5.2.1
- turbo-darwin-64@1.13.3:
+ turbo-darwin-64@2.2.3:
optional: true
- turbo-darwin-arm64@1.13.3:
+ turbo-darwin-arm64@2.2.3:
optional: true
- turbo-linux-64@1.13.3:
+ turbo-linux-64@2.2.3:
optional: true
- turbo-linux-arm64@1.13.3:
+ turbo-linux-arm64@2.2.3:
optional: true
turbo-stream@2.2.0: {}
- turbo-windows-64@1.13.3:
+ turbo-windows-64@2.2.3:
optional: true
- turbo-windows-arm64@1.13.3:
+ turbo-windows-arm64@2.2.3:
optional: true
- turbo@1.13.3:
+ turbo@2.2.3:
optionalDependencies:
- turbo-darwin-64: 1.13.3
- turbo-darwin-arm64: 1.13.3
- turbo-linux-64: 1.13.3
- turbo-linux-arm64: 1.13.3
- turbo-windows-64: 1.13.3
- turbo-windows-arm64: 1.13.3
+ turbo-darwin-64: 2.2.3
+ turbo-darwin-arm64: 2.2.3
+ turbo-linux-64: 2.2.3
+ turbo-linux-arm64: 2.2.3
+ turbo-windows-64: 2.2.3
+ turbo-windows-arm64: 2.2.3
type-check@0.4.0:
dependencies:
@@ -24506,6 +24431,8 @@ snapshots:
typescript@5.5.4: {}
+ uWebSockets.js@https://codeload.github.com/uNetworking/uWebSockets.js/tar.gz/442087c0a01bf146acb7386910739ec81df06700: {}
+
ufo@1.5.3: {}
uid-safe@2.1.5:
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
index 227c90f5..2fd12ff2 100644
--- a/pnpm-workspace.yaml
+++ b/pnpm-workspace.yaml
@@ -10,7 +10,6 @@ catalog:
"debug": "^4.3.4"
"kleur": "^4.1.5"
"lodash-es": "^4.17.21"
- "mitt": "^3.0.1"
"svgo": "^3.2.0"
"tsup": "^8.2.4"
"typescript": "^5.5.4"
diff --git a/turbo.json b/turbo.json
index 805f818d..fbb6018c 100644
--- a/turbo.json
+++ b/turbo.json
@@ -1,11 +1,10 @@
{
"$schema": "https://turbo.build/schema.json",
- "pipeline": {
+ "tasks": {
"build": {
"dependsOn": [ "^build" ],
"inputs": [ "tsconfig.json", "tsconfig.*.json", "tsup.config.ts", "src/**" ],
- "outputs": [ "dist/**" ],
- "outputMode": "new-only"
+ "outputs": [ "dist/**" ]
},
"build:tarball": {
"dependsOn": [ "^build" ],