@whzxc/agent-design-gallery 0.0.0-stage → 0.7.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +69 -0
- package/README.md +218 -2
- package/package.json +43 -4
- package/public/access.css +10 -0
- package/public/app.js +1674 -0
- package/public/arrangement-worker.js +11 -0
- package/public/arrangement.js +49 -0
- package/public/assets.js +356 -0
- package/public/auth.js +69 -0
- package/public/favicon.svg +6 -0
- package/public/hub.css +67 -0
- package/public/hub.html +33 -0
- package/public/hub.js +165 -0
- package/public/icons.js +50 -0
- package/public/index.html +70 -0
- package/public/instance-actions.js +27 -0
- package/public/labels.js +122 -0
- package/public/layout.js +119 -0
- package/public/relationships.js +28 -0
- package/public/selection.js +20 -0
- package/public/style.css +194 -0
- package/public/switcher.css +37 -0
- package/public/switcher.js +176 -0
- package/public/token-catalog.js +129 -0
- package/public/tokens.css +61 -0
- package/public/view-route.js +66 -0
- package/src/cli-output.mjs +236 -0
- package/src/cli.mjs +176 -0
- package/src/http.mjs +38 -0
- package/src/hub/auth.mjs +41 -0
- package/src/hub/instances.mjs +99 -0
- package/src/hub/proxy.mjs +30 -0
- package/src/hub/registry.mjs +181 -0
- package/src/hub.mjs +128 -0
- package/src/lifecycle.mjs +109 -0
- package/src/link.mjs +55 -0
- package/src/open.mjs +61 -0
- package/src/perf.mjs +12 -0
- package/src/server.mjs +679 -0
- package/src/service.mjs +184 -0
- package/src/toolkit/arch-browser.mjs +40 -0
- package/src/toolkit/arch-git.mjs +55 -0
- package/src/toolkit/arch-overlay.mjs +225 -0
- package/src/toolkit/arch.mjs +221 -0
- package/src/toolkit/asset-rules.mjs +14 -0
- package/src/toolkit/browser.mjs +33 -0
- package/src/toolkit/build-store.mjs +266 -0
- package/src/toolkit/build-worker.mjs +35 -0
- package/src/toolkit/build.mjs +147 -0
- package/src/toolkit/commands.mjs +345 -0
- package/src/toolkit/compare.mjs +222 -0
- package/src/toolkit/config.mjs +136 -0
- package/src/toolkit/document.mjs +85 -0
- package/src/toolkit/migrate.mjs +85 -0
- package/src/toolkit/project.mjs +172 -0
- package/src/toolkit/results.mjs +44 -0
- package/src/toolkit/runtime.d.ts +14 -0
- package/src/toolkit/runtime.mjs +54 -0
- package/src/toolkit/text.mjs +12 -0
- package/src/toolkit/tokens.mjs +37 -0
- package/src/viewer-cache.mjs +85 -0
package/src/server.mjs
ADDED
|
@@ -0,0 +1,679 @@
|
|
|
1
|
+
// Adapted from ARC's MIT-licensed tooling/design-server.mjs.
|
|
2
|
+
import { randomUUID, createHash } from 'node:crypto';
|
|
3
|
+
import { directLocal, viewerFile, shell, json } from './http.mjs';
|
|
4
|
+
import { createServer } from "node:http";
|
|
5
|
+
import {
|
|
6
|
+
readFile,
|
|
7
|
+
writeFile,
|
|
8
|
+
mkdir,
|
|
9
|
+
readdir,
|
|
10
|
+
stat,
|
|
11
|
+
realpath,
|
|
12
|
+
} from "node:fs/promises";
|
|
13
|
+
import { watch, existsSync } from "node:fs";
|
|
14
|
+
import path from "node:path";
|
|
15
|
+
import os from "node:os";
|
|
16
|
+
import { perfSpan } from './perf.mjs';
|
|
17
|
+
|
|
18
|
+
import { createBuildStore } from './toolkit/build-store.mjs';
|
|
19
|
+
import { CliError, asCliError } from './cli-output.mjs';
|
|
20
|
+
import { cleanup } from './toolkit/results.mjs';
|
|
21
|
+
import { createViewerCache } from './viewer-cache.mjs';
|
|
22
|
+
import { refreshTypes, archFiles, isSourcePath, readGroups, sourceDirectories } from './toolkit/project.mjs';
|
|
23
|
+
import { loadConfig } from './toolkit/config.mjs';
|
|
24
|
+
import { parseTokens } from './toolkit/tokens.mjs';
|
|
25
|
+
import { sourceRelationships } from '../public/relationships.js';
|
|
26
|
+
import { resolveScope } from '../public/assets.js';
|
|
27
|
+
const digest = value => createHash('sha256').update(value).digest('hex');
|
|
28
|
+
const tokenFile = 'tokens.css';
|
|
29
|
+
function tokenSourcePath(directory, project) {
|
|
30
|
+
const base = project.design === directory ? project.root : path.dirname(directory);
|
|
31
|
+
return path.relative(base, path.join(directory, tokenFile)).split(path.sep).join('/');
|
|
32
|
+
}
|
|
33
|
+
const viewerVersion = Promise.all(['assets.js','layout.js','selection.js','arrangement.js','arrangement-worker.js'].map(file => readFile(new URL('../public/'+file,import.meta.url)))).then(parts => digest(Buffer.concat(parts)));
|
|
34
|
+
const defaultState = path.join(
|
|
35
|
+
process.env.XDG_STATE_HOME || path.join(os.homedir(), ".local/state"),
|
|
36
|
+
"agent-design-gallery",
|
|
37
|
+
);
|
|
38
|
+
export async function startServer({
|
|
39
|
+
directory,
|
|
40
|
+
port = 0,
|
|
41
|
+
stateDirectory = defaultState,
|
|
42
|
+
fixtures = null,
|
|
43
|
+
readOnly = false,
|
|
44
|
+
instanceId = randomUUID(),
|
|
45
|
+
onDiagnostic, onFatal, watchDirectory = watch,
|
|
46
|
+
} = {}) {
|
|
47
|
+
const endStartup = perfSpan('viewer-startup');
|
|
48
|
+
let state = { recent: [], views: {}, selections: {}, theme: "system" };
|
|
49
|
+
const statePath = path.join(stateDirectory, "state.json");
|
|
50
|
+
try {
|
|
51
|
+
state = { ...state, ...JSON.parse(await readFile(statePath, "utf8")) };
|
|
52
|
+
} catch (e) {
|
|
53
|
+
if (e.code !== "ENOENT")
|
|
54
|
+
throw new CliError(e instanceof SyntaxError ? 'STATE_INVALID' : 'IO_FAILED', `Cannot read preferences: ${e.message}`, { cause: e });
|
|
55
|
+
}
|
|
56
|
+
let root,
|
|
57
|
+
tokenSource = null,
|
|
58
|
+
sources = sourceDirectories(),
|
|
59
|
+
files = new Map(),
|
|
60
|
+
groups = [],
|
|
61
|
+
watcher, archWatcher, activeProject,
|
|
62
|
+
refreshTimer,
|
|
63
|
+
revision = 0,
|
|
64
|
+
closing = false,
|
|
65
|
+
buildStore, viewerCache, codePaths=new Set();
|
|
66
|
+
const overlayStores = new Map(), overlayHashes = new Set();
|
|
67
|
+
let resettingOverlays = false;
|
|
68
|
+
const knownBuilds = new Map(), legacyDependencies = new Map(), failedSources=new Set(), dirtyBuilds=new Set();
|
|
69
|
+
const describe=built=>({...built,css:undefined,frames:built.frames.map(({html,...frame})=>frame)});
|
|
70
|
+
const clients = new Set(),
|
|
71
|
+
svgCache = new Map(),
|
|
72
|
+
frameCounts = new Map(),
|
|
73
|
+
touched = new Set();
|
|
74
|
+
let writes = Promise.resolve();
|
|
75
|
+
const persist = () => {
|
|
76
|
+
if (fixtures) return Promise.resolve();
|
|
77
|
+
const data = JSON.stringify(state, null, 2);
|
|
78
|
+
writes = writes
|
|
79
|
+
.catch(() => {})
|
|
80
|
+
.then(async () => {
|
|
81
|
+
await mkdir(stateDirectory, { recursive: true });
|
|
82
|
+
await writeFile(statePath, data);
|
|
83
|
+
});
|
|
84
|
+
return writes;
|
|
85
|
+
};
|
|
86
|
+
const emit = (data) => {
|
|
87
|
+
for (const client of clients)
|
|
88
|
+
client.write(`data: ${JSON.stringify(data)}\n\n`);
|
|
89
|
+
};
|
|
90
|
+
const diagnostic = (error, name = null, fallback = 'SOURCE_BUILD_FAILED') => {
|
|
91
|
+
if (error.name === 'AbortError') return;
|
|
92
|
+
const at = error.location ?? error.errors?.[0]?.location ?? error.cause?.errors?.[0]?.location;
|
|
93
|
+
const source = name && activeProject ? (name.endsWith('.mmd') ? name : path.relative(activeProject.root,path.join(root,name)).split(path.sep).join('/')) : null;
|
|
94
|
+
onDiagnostic?.(asCliError(error,fallback),source ? {source,frame:null,theme:null,line:Number.isInteger(at?.line)&&at.line>0?at.line:null,column:Number.isInteger(at?.column)?at.column+1:null} : null);
|
|
95
|
+
};
|
|
96
|
+
const refreshError = error => {
|
|
97
|
+
if (error.name === 'AbortError') return;
|
|
98
|
+
emit({error:error.message}); diagnostic(error,null,'WATCH_FAILED');
|
|
99
|
+
};
|
|
100
|
+
const watcherError = (error,kind) => {
|
|
101
|
+
const failure = new CliError('WATCH_FAILED',`${kind} watcher: ${error.message}`,{cause:error});
|
|
102
|
+
emit({error:failure.message}); onFatal?.(failure);
|
|
103
|
+
};
|
|
104
|
+
async function closeOverlays() {
|
|
105
|
+
resettingOverlays = true;
|
|
106
|
+
try { await Promise.all([...overlayStores.values()].map(async pending=>(await pending).close())); }
|
|
107
|
+
finally { overlayStores.clear();overlayHashes.clear();resettingOverlays = false; }
|
|
108
|
+
}
|
|
109
|
+
async function overlayStore(base) {
|
|
110
|
+
if(closing || resettingOverlays)throw Object.assign(Error('Overlay build superseded; retry after refresh.'),{name:'AbortError'});
|
|
111
|
+
const key=base.sha+'\0'+base.rev;
|
|
112
|
+
if(!overlayStores.has(key)) {
|
|
113
|
+
const pending=createBuildStore({config:{...activeProject,design:root,sources,sourceFiles:[...codePaths].sort(),overlay:base},
|
|
114
|
+
cacheDirectory:path.join(stateDirectory,'cache',digest(root),'overlay',base.sha,digest(base.rev))}).then(async store=>{
|
|
115
|
+
for(const built of await store.metadata())overlayHashes.add(built.hash);
|
|
116
|
+
return store;
|
|
117
|
+
});
|
|
118
|
+
overlayStores.set(key,pending);
|
|
119
|
+
pending.catch(()=>{if(overlayStores.get(key)===pending)overlayStores.delete(key);});
|
|
120
|
+
}
|
|
121
|
+
return overlayStores.get(key);
|
|
122
|
+
}
|
|
123
|
+
async function invalidateBuilds(paths) {
|
|
124
|
+
const affected=new Set(buildStore?.invalidate(paths)??[]);
|
|
125
|
+
for(const pending of overlayStores.values())for(const name of (await pending).invalidate(paths))affected.add(name);
|
|
126
|
+
return [...affected];
|
|
127
|
+
}
|
|
128
|
+
async function overlayBuild(name,base) {
|
|
129
|
+
let built;
|
|
130
|
+
try { built=await (await overlayStore(base)).get(name); }
|
|
131
|
+
catch(error) { diagnostic(error,name); throw error; }
|
|
132
|
+
overlayHashes.add(built.hash);frameCounts.set(name,built.frames.length);
|
|
133
|
+
return built;
|
|
134
|
+
}
|
|
135
|
+
async function collect(base, relative = "", out = new Map(), sourceNames = sources, discoveredCode = new Set()) {
|
|
136
|
+
for (const entry of await readdir(path.join(base, relative), {
|
|
137
|
+
withFileTypes: true,
|
|
138
|
+
})) {
|
|
139
|
+
if (entry.name.startsWith(".") || entry.name === "node_modules" || (relative === "" && entry.name === "art" && !sourceNames.includes("art"))) continue;
|
|
140
|
+
const name = path.posix.join(relative, entry.name);
|
|
141
|
+
if (entry.isDirectory()) await collect(base, name, out, sourceNames, discoveredCode);
|
|
142
|
+
else if (entry.isFile()) {
|
|
143
|
+
if(/\.[jt]sx?$/.test(name))discoveredCode.add(name);
|
|
144
|
+
if(!(/\.svg$/i.test(name)||isSourcePath(name,sourceNames)))continue;
|
|
145
|
+
const info = await stat(path.join(base, name));
|
|
146
|
+
const version = `${info.mtimeMs}-${info.size}`;
|
|
147
|
+
const old = base === root ? files.get(name) : undefined;
|
|
148
|
+
out.set(
|
|
149
|
+
name,
|
|
150
|
+
old?.stamp === version
|
|
151
|
+
? old
|
|
152
|
+
: {
|
|
153
|
+
path: name,
|
|
154
|
+
name: path.basename(name, path.extname(name)),
|
|
155
|
+
version,
|
|
156
|
+
stamp: version,
|
|
157
|
+
size: info.size,
|
|
158
|
+
modifiedAt: info.mtimeMs,
|
|
159
|
+
},
|
|
160
|
+
);
|
|
161
|
+
}
|
|
162
|
+
}
|
|
163
|
+
return out;
|
|
164
|
+
}
|
|
165
|
+
async function collectProject(base, project, sourceNames, discoveredCode) {
|
|
166
|
+
const out=await collect(base,'',new Map(),sourceNames,discoveredCode);
|
|
167
|
+
if(project.design !== base) return out;
|
|
168
|
+
for(const file of archFiles(project.arch)) {
|
|
169
|
+
const name=path.relative(project.root,file).split(path.sep).join('/'),info=await stat(file),stamp=`${info.mtimeMs}-${info.size}`;
|
|
170
|
+
const old=files.get(name);
|
|
171
|
+
out.set(name,old?.stamp===stamp?old:{path:name,name:path.basename(name,'.mmd'),layer:'arch',version:stamp,stamp,size:info.size,modifiedAt:info.mtimeMs});
|
|
172
|
+
}
|
|
173
|
+
return out;
|
|
174
|
+
}
|
|
175
|
+
function watchArch(project,base) {
|
|
176
|
+
archWatcher?.close();archWatcher=null;
|
|
177
|
+
const directory=project.archDirectory;
|
|
178
|
+
if(project.design!==base || !directory || !existsSync(directory)) return;
|
|
179
|
+
archWatcher=watchDirectory(directory,{recursive:true},(_event,filename)=>{
|
|
180
|
+
if(!filename || !/\.(mmd|md)$/.test(String(filename)))return;
|
|
181
|
+
const file=path.join(directory,String(filename));
|
|
182
|
+
const dependency=path.relative(base,file).split(path.sep).join('/');
|
|
183
|
+
const name=path.relative(project.root,file).split(path.sep).join('/');
|
|
184
|
+
touched.add(dependency);touched.add(name);invalidateBuilds([dependency,name]).catch(refreshError);
|
|
185
|
+
clearTimeout(refreshTimer);refreshTimer=setTimeout(()=>refresh().catch(refreshError),80);
|
|
186
|
+
});
|
|
187
|
+
archWatcher.on('error',e=>watcherError(e,'Architecture'));
|
|
188
|
+
}
|
|
189
|
+
async function openDirectory(input) {
|
|
190
|
+
let next;
|
|
191
|
+
try { next = await realpath(path.resolve(input.replace(/^~(?=$|[\\/])/, os.homedir()))); }
|
|
192
|
+
catch (error) {
|
|
193
|
+
if (error.code === 'ENOENT' || error.code === 'ENOTDIR') throw new CliError('DIRECTORY_NOT_FOUND', `Directory not found: ${input}; choose an existing directory.`, { cause: error });
|
|
194
|
+
throw error;
|
|
195
|
+
}
|
|
196
|
+
if (!(await stat(next)).isDirectory())
|
|
197
|
+
throw new CliError('DIRECTORY_NOT_FOUND', "Choose a directory containing SVG files.");
|
|
198
|
+
const hasTokens = (await readdir(next)).includes(tokenFile);
|
|
199
|
+
if (hasTokens && !readOnly) refreshTypes({design:next});
|
|
200
|
+
const project = await loadConfig(next);
|
|
201
|
+
const nextSources = project.design === next ? project.sources : sourceDirectories({design:next});
|
|
202
|
+
const nextCode=new Set(), nextFiles = await collectProject(next, project, nextSources, nextCode),
|
|
203
|
+
nextGroups = await readGroups(next, nextSources);
|
|
204
|
+
|
|
205
|
+
const cacheBase=path.join(stateDirectory,'cache',digest(next));
|
|
206
|
+
const nextStore=await createBuildStore({config:{...project,design:next,sources:nextSources,sourceFiles:[...nextCode].sort()},cacheDirectory:path.join(cacheBase,'build')});
|
|
207
|
+
const nextViewerCache=await createViewerCache(path.join(cacheBase,'viewer'));
|
|
208
|
+
await buildStore?.close();await closeOverlays();await viewerCache?.close();
|
|
209
|
+
buildStore=nextStore;viewerCache=nextViewerCache;knownBuilds.clear();dirtyBuilds.clear();failedSources.clear();frameCounts.clear();
|
|
210
|
+
for(const built of await buildStore.metadata()) {
|
|
211
|
+
if(nextFiles.has(built.path)) {knownBuilds.set(built.path,built);Object.assign(nextFiles.get(built.path),{hash:built.hash,version:built.hash});frameCounts.set(built.path,built.frames.length);}
|
|
212
|
+
}
|
|
213
|
+
// Complete discovery before starting the watcher.
|
|
214
|
+
const nextWatcher = watchDirectory(next, { recursive: true }, (_event, filename) => {
|
|
215
|
+
if (filename && String(filename).split(path.sep).some(part => part.startsWith("."))) return;
|
|
216
|
+
if (filename) {
|
|
217
|
+
const name=String(filename).split(path.sep).join('/');
|
|
218
|
+
touched.add(name);
|
|
219
|
+
invalidateBuilds([name]).catch(refreshError);
|
|
220
|
+
}
|
|
221
|
+
clearTimeout(refreshTimer);
|
|
222
|
+
refreshTimer = setTimeout(
|
|
223
|
+
() => refresh().catch(refreshError),
|
|
224
|
+
80,
|
|
225
|
+
);
|
|
226
|
+
});
|
|
227
|
+
nextWatcher.on("error", (e) =>
|
|
228
|
+
watcherError(e,'File'),
|
|
229
|
+
);
|
|
230
|
+
watcher?.close();
|
|
231
|
+
watcher = nextWatcher;
|
|
232
|
+
activeProject=project;watchArch(project,next);
|
|
233
|
+
root = next;
|
|
234
|
+
tokenSource = hasTokens ? tokenSourcePath(next, project) : null;
|
|
235
|
+
codePaths=nextCode;
|
|
236
|
+
sources = nextSources;
|
|
237
|
+
touched.clear();
|
|
238
|
+
files = nextFiles;
|
|
239
|
+
groups = nextGroups;
|
|
240
|
+
revision++;
|
|
241
|
+
svgCache.clear();
|
|
242
|
+
state.recent = [root, ...state.recent.filter((p) => p !== root)].slice(
|
|
243
|
+
0,
|
|
244
|
+
12,
|
|
245
|
+
);
|
|
246
|
+
await persist();
|
|
247
|
+
emit({ revision });
|
|
248
|
+
}
|
|
249
|
+
let refreshing = false,
|
|
250
|
+
refreshAgain = false;
|
|
251
|
+
async function refresh() {
|
|
252
|
+
if(closing)return;
|
|
253
|
+
if (refreshing) {
|
|
254
|
+
refreshAgain = true;
|
|
255
|
+
return;
|
|
256
|
+
}
|
|
257
|
+
refreshing = true;
|
|
258
|
+
try {
|
|
259
|
+
const observed = [...touched];
|
|
260
|
+
touched.clear();
|
|
261
|
+
const base = root,
|
|
262
|
+
project = await loadConfig(base),
|
|
263
|
+
nextSources = project.design===base ? project.sources : sourceDirectories({design:base}),
|
|
264
|
+
nextCode=new Set(),
|
|
265
|
+
next = await collectProject(base,project,nextSources,nextCode),
|
|
266
|
+
nextGroups = await readGroups(base, nextSources);
|
|
267
|
+
const tokensChanged = observed.includes(tokenFile);
|
|
268
|
+
const hasTokens = tokensChanged ? (await readdir(base)).includes(tokenFile) : !!tokenSource;
|
|
269
|
+
const nextTokenSource = hasTokens ? tokenSourcePath(base, project) : null;
|
|
270
|
+
if (root !== base) return;
|
|
271
|
+
const stamps=[...new Set([...files.keys(),...next.keys()])].filter(name=>files.get(name)?.stamp!==next.get(name)?.stamp);
|
|
272
|
+
const grouping=JSON.stringify(groups)!==JSON.stringify(nextGroups);
|
|
273
|
+
const configChanged=JSON.stringify(sources)!==JSON.stringify(nextSources)||activeProject.arch!==project.arch;
|
|
274
|
+
const structural=configChanged || [...new Set([...codePaths,...nextCode])].some(name=>codePaths.has(name)!==nextCode.has(name));
|
|
275
|
+
if(structural){await closeOverlays();await buildStore.close();buildStore=await createBuildStore({config:{...project,design:base,sources:nextSources,sourceFiles:[...nextCode].sort()},cacheDirectory:path.join(stateDirectory,'cache',digest(base),'build')});}
|
|
276
|
+
const observedPaths=[...new Set([...observed,...stamps])];
|
|
277
|
+
const affected=new Set(await invalidateBuilds(structural?[...knownBuilds.keys(),...observedPaths]:observedPaths));
|
|
278
|
+
for(const name of failedSources)affected.add(name);
|
|
279
|
+
for(const name of stamps)if(/\.(tsx|mmd)$/.test(name)&&next.has(name))affected.add(name);
|
|
280
|
+
const legacyDirty=[...legacyDependencies.values()].some(dependencies=>dependencies.some(name=>observedPaths.includes(name)));
|
|
281
|
+
if(!stamps.length&&!affected.size&&!grouping&&!legacyDirty&&!configChanged&&!tokensChanged&&nextTokenSource===tokenSource)return;
|
|
282
|
+
const changed=[...new Set([...stamps,...affected])];
|
|
283
|
+
for (const name of affected) {
|
|
284
|
+
if (knownBuilds.delete(name)) dirtyBuilds.add(name);
|
|
285
|
+
frameCounts.delete(name);
|
|
286
|
+
if (!next.has(name)) { dirtyBuilds.delete(name); failedSources.delete(name); continue; }
|
|
287
|
+
if (!/\.(tsx|mmd)$/.test(name)) continue;
|
|
288
|
+
const entry = next.get(name);
|
|
289
|
+
next.set(name, {...entry, hash:undefined, version:`${entry.stamp}-${revision+1}`});
|
|
290
|
+
}
|
|
291
|
+
for (const [name,entry] of next) {
|
|
292
|
+
const built = knownBuilds.get(name);
|
|
293
|
+
if (built) Object.assign(entry,{hash:built.hash,version:built.hash});
|
|
294
|
+
}
|
|
295
|
+
const dirty=new Set(observedPaths);
|
|
296
|
+
for(const [name,dependencies] of legacyDependencies) {
|
|
297
|
+
if(!next.has(name)){legacyDependencies.delete(name);continue;}
|
|
298
|
+
if(dependencies.some(dependency=>dirty.has(dependency))) {
|
|
299
|
+
for(const theme of ['light','dark'])svgCache.delete(`${name}\0${theme}`);
|
|
300
|
+
next.set(name,{...next.get(name),version:`${next.get(name).stamp}-${revision+1}`});changed.push(name);
|
|
301
|
+
}
|
|
302
|
+
}
|
|
303
|
+
if(activeProject.arch!==project.arch)watchArch(project,base);
|
|
304
|
+
activeProject=project;
|
|
305
|
+
files = next;
|
|
306
|
+
tokenSource = nextTokenSource;
|
|
307
|
+
codePaths=nextCode;
|
|
308
|
+
sources = nextSources;
|
|
309
|
+
groups = nextGroups;
|
|
310
|
+
revision++;
|
|
311
|
+
emit({ revision, changed });
|
|
312
|
+
} finally {
|
|
313
|
+
refreshing = false;
|
|
314
|
+
if (refreshAgain && !closing) {
|
|
315
|
+
refreshAgain = false;
|
|
316
|
+
await refresh();
|
|
317
|
+
}
|
|
318
|
+
}
|
|
319
|
+
}
|
|
320
|
+
const baseManifest = () => ({
|
|
321
|
+
directory: root ?? null,
|
|
322
|
+
label: root
|
|
323
|
+
? path.basename(root) === "design" ? path.basename(path.dirname(root)) : path.basename(root)
|
|
324
|
+
: "Agent Design Gallery",
|
|
325
|
+
assets: [...files.values()].sort((a, b) => a.path.localeCompare(b.path)),
|
|
326
|
+
groups,
|
|
327
|
+
revision,
|
|
328
|
+
recent: state.recent,
|
|
329
|
+
theme: state.theme,
|
|
330
|
+
sidebar: state.sidebar ?? true,
|
|
331
|
+
inspector: false,
|
|
332
|
+
tokenSource,
|
|
333
|
+
});
|
|
334
|
+
const preferenceKey = (scope,base) => base ? JSON.stringify([root,scope??'all','base',base]) : !scope || scope === 'all' ? root : JSON.stringify([root, scope]);
|
|
335
|
+
function applyFixtureManifest(data,name) {
|
|
336
|
+
if (!fixtures || !name) return data;
|
|
337
|
+
if (Number.isFinite(fixtures.assetModifiedAt)) data.assets = data.assets.map(a => ({...a,modifiedAt:fixtures.assetModifiedAt}));
|
|
338
|
+
const preset = fixtures.states[name];
|
|
339
|
+
if (!preset) throw new Error(`Unknown fixture ${name}; choose a declared ADG fixture.`);
|
|
340
|
+
return { ...data, ...(preset.empty ? { directory: null, assets: [], groups: [] } : {}),
|
|
341
|
+
label: 'agent-remote-control', recent: fixtures.recent, view: null, theme: preset.themeChoice ?? preset.theme,
|
|
342
|
+
sidebar: preset.sidebar, inspector: !!preset.inspector, fixture: { name, ...preset } };
|
|
343
|
+
}
|
|
344
|
+
const contextFor=async url=>(await viewerVersion)+'|'+(url.searchParams.get('context')??'')+(url.searchParams.has('base')?'|base:'+url.searchParams.get('base'):'');
|
|
345
|
+
async function manifest(url) {
|
|
346
|
+
const data=baseManifest(),context=await contextFor(url), requested=url.searchParams.get('scope');
|
|
347
|
+
const fixtureScope=fixtures?.states[url.searchParams.get('fixture')]?.scope;
|
|
348
|
+
const desired = fixtureScope ?? requested ?? 'all';
|
|
349
|
+
if (desired === 'tokens' && data.tokenSource) {
|
|
350
|
+
// Keep the layer choices available without measuring or building any artboards.
|
|
351
|
+
const { layers } = resolveScope(data, sources, 'all');
|
|
352
|
+
const result = { ...data, scope: 'tokens', layers, assets: [] };
|
|
353
|
+
try {
|
|
354
|
+
const { light, dark } = parseTokens(await readFile(path.join(data.directory, tokenFile), 'utf8'));
|
|
355
|
+
result.tokens = [...light].map(([name, value]) => [name, value, dark.get(name) ?? null]);
|
|
356
|
+
} catch (error) {
|
|
357
|
+
result.tokenError = error.code ? `Cannot read ${data.tokenSource}.` : error.message;
|
|
358
|
+
diagnostic(new CliError('TOKENS_INVALID',error.message,{cause:error}));
|
|
359
|
+
}
|
|
360
|
+
return applyFixtureManifest(result, url.searchParams.get('fixture'));
|
|
361
|
+
}
|
|
362
|
+
const scoped=resolveScope(data,sources,desired === 'tokens' ? 'default' : desired);
|
|
363
|
+
if (url.searchParams.has('strict') && desired !== scoped.scope) throw Error('Design link target does not exist.');
|
|
364
|
+
Object.assign(data,scoped);
|
|
365
|
+
let base;
|
|
366
|
+
if(url.searchParams.has('base')&&data.assets.some(asset=>asset.path.endsWith('.mmd'))) {
|
|
367
|
+
base=await (await import('./toolkit/arch-git.mjs')).resolveBase(activeProject,url.searchParams.get('base'));
|
|
368
|
+
data.base={rev:base.rev,sha:base.sha};
|
|
369
|
+
const cached=new Map((await (await overlayStore(base)).metadata()).map(built=>[built.path,built]));
|
|
370
|
+
data.assets=data.assets.map(asset=>asset.path.endsWith('.mmd')?{...asset,hash:cached.get(asset.path)?.hash,version:cached.get(asset.path)?.hash??`${asset.stamp}-${base.sha}-${base.rev}`}:{...asset});
|
|
371
|
+
}
|
|
372
|
+
const key=preferenceKey(data.scope,url.searchParams.get('base'));
|
|
373
|
+
data.view=state.views[key] ?? null;
|
|
374
|
+
data.selection=state.selections[key] ?? null;
|
|
375
|
+
// Rehash previously built sources only when a viewer requests their scope.
|
|
376
|
+
// An unchanged result retains its measured metadata and cropped previews.
|
|
377
|
+
if (requested) {
|
|
378
|
+
const rebuild = data.assets.filter(asset=>dirtyBuilds.has(asset.path)&&!(base&&asset.path.endsWith('.mmd')));
|
|
379
|
+
let index=0;
|
|
380
|
+
await Promise.all(Array.from({length:Math.min(2,rebuild.length)},async()=>{
|
|
381
|
+
while(index<rebuild.length) {
|
|
382
|
+
const asset=rebuild[index++];
|
|
383
|
+
try {const built=await sourceBuild(asset.path);Object.assign(asset,{hash:built.hash,version:built.hash});}
|
|
384
|
+
catch(error) {if(error.name==='AbortError')throw error;dirtyBuilds.delete(asset.path);}
|
|
385
|
+
}
|
|
386
|
+
}));
|
|
387
|
+
}
|
|
388
|
+
data.sourceImports=Object.fromEntries([...knownBuilds].map(([name,built])=>[name,built.imports]));
|
|
389
|
+
const frameOnly = data.scope.startsWith('asset:') && url.searchParams.has('frame');
|
|
390
|
+
if(viewerCache && !frameOnly) {
|
|
391
|
+
const includeMetadata=url.searchParams.get('metadata')==='1';
|
|
392
|
+
const requestedTheme=url.searchParams.get('initial')==='1'&&['light','dark'].includes(state.theme)?state.theme:(url.searchParams.get('theme')==='light'?'light':'dark');
|
|
393
|
+
data.metadataTheme=requestedTheme;
|
|
394
|
+
data.assets=await Promise.all(data.assets.map(async asset=>{
|
|
395
|
+
if(!asset.hash)return {...asset};
|
|
396
|
+
const metadata={},metadataRefs={},previewIds={};
|
|
397
|
+
for(const theme of ['light','dark']) {
|
|
398
|
+
const reference=viewerCache.reference(asset.hash,theme,context);
|
|
399
|
+
if(reference){metadataRefs[theme]=true;previewIds[theme]=reference.previewIds;}
|
|
400
|
+
if(includeMetadata&&theme===requestedTheme&&reference){const saved=await viewerCache.get(asset.hash,theme,context);if(saved)metadata[theme]=saved.metadata;}
|
|
401
|
+
}
|
|
402
|
+
return {...asset,metadata,metadataRefs,previewIds};
|
|
403
|
+
}));
|
|
404
|
+
data.packing=(await viewerCache.get(digest('catalog'),'light',context))?.metadata.packing??[];
|
|
405
|
+
}
|
|
406
|
+
data.features={compactSources:1,persistedMetadata:1,incrementalHashes:1};
|
|
407
|
+
return applyFixtureManifest(data,url.searchParams.get('fixture'));
|
|
408
|
+
}
|
|
409
|
+
async function sourceBuild(name) {
|
|
410
|
+
const endBuild = perfSpan('build', name);
|
|
411
|
+
let built;
|
|
412
|
+
try{built=await buildStore.get(name);}catch(error){if(error.name!=='AbortError'){failedSources.add(name);diagnostic(error,name);}throw error;}
|
|
413
|
+
finally {endBuild?.();}
|
|
414
|
+
knownBuilds.set(name,describe(built));dirtyBuilds.delete(name);failedSources.delete(name);frameCounts.set(name,built.frames.length);
|
|
415
|
+
if(files.has(name))Object.assign(files.get(name),{hash:built.hash,version:built.hash});
|
|
416
|
+
return built;
|
|
417
|
+
}
|
|
418
|
+
async function svg(name, theme, chain = [], onlyFrame = null, base = null) {
|
|
419
|
+
if (chain.includes(name))
|
|
420
|
+
throw new Error(`Circular SVG reference: ${name}`);
|
|
421
|
+
const asset = files.get(name);
|
|
422
|
+
if (!asset) throw new Error(`Unknown SVG: ${name}`);
|
|
423
|
+
const key = `${name}\0${theme}`,
|
|
424
|
+
cached = svgCache.get(key);
|
|
425
|
+
if (cached?.version === asset.version) return cached;
|
|
426
|
+
if (/\.(tsx|mmd)$/.test(name)) {
|
|
427
|
+
const built=base&&name.endsWith('.mmd')?await overlayBuild(name,base):await sourceBuild(name);
|
|
428
|
+
const frames = onlyFrame ? built.frames.filter(frame => frame.name === onlyFrame) : built.frames;
|
|
429
|
+
if (!frames.length && onlyFrame) throw new CliError('FRAME_NOT_FOUND', `Frame ${onlyFrame} does not exist in ${name}.`);
|
|
430
|
+
return {version:built.hash,imports:built.imports,dependencies:built.dependencies,
|
|
431
|
+
body:JSON.stringify({format:'tsx',hash:built.hash,css:built.css,imports:built.imports,component:!onlyFrame && name.endsWith('.tsx') && !name.startsWith('surfaces/'),frames})};
|
|
432
|
+
}
|
|
433
|
+
let content = await readFile(path.join(root, name), "utf8");
|
|
434
|
+
content = content.replace(
|
|
435
|
+
/<svg\b([^>]*)>/,
|
|
436
|
+
(_, attrs) =>
|
|
437
|
+
`<svg${attrs.replace(/\sdata-theme\s*=\s*(['"]).*?\1/g, "")} data-theme="${theme}">`,
|
|
438
|
+
);
|
|
439
|
+
const dependencies = [name];
|
|
440
|
+
const matches = [
|
|
441
|
+
...content.matchAll(/\b(?:xlink:)?href\s*=\s*(["'])([^"']+)\1/g),
|
|
442
|
+
];
|
|
443
|
+
for (const match of matches) {
|
|
444
|
+
const target = match[2];
|
|
445
|
+
if (/^(?:#|data:|https?:|\/)/.test(target)) continue;
|
|
446
|
+
const [relative, fragment] = target.split("#");
|
|
447
|
+
const dependency = path.posix.normalize(
|
|
448
|
+
path.posix.join(path.posix.dirname(name), decodeURIComponent(relative)),
|
|
449
|
+
);
|
|
450
|
+
if (dependency.startsWith("../"))
|
|
451
|
+
throw new Error(`SVG reference leaves design directory: ${target}`);
|
|
452
|
+
let data, type;
|
|
453
|
+
if (/\.svg$/i.test(dependency)) {
|
|
454
|
+
const nested = await svg(dependency, theme, [...chain, name]);
|
|
455
|
+
data = nested.body;
|
|
456
|
+
type = "image/svg+xml";
|
|
457
|
+
dependencies.push(...nested.dependencies);
|
|
458
|
+
} else {
|
|
459
|
+
const resolved = await realpath(path.join(root, dependency));
|
|
460
|
+
if (!resolved.startsWith(root + path.sep))
|
|
461
|
+
throw new Error("Asset reference leaves design directory.");
|
|
462
|
+
data = await readFile(resolved);
|
|
463
|
+
dependencies.push(dependency);
|
|
464
|
+
type = {
|
|
465
|
+
".png": "image/png",
|
|
466
|
+
".jpg": "image/jpeg",
|
|
467
|
+
".jpeg": "image/jpeg",
|
|
468
|
+
".webp": "image/webp",
|
|
469
|
+
}[path.extname(dependency).toLowerCase()];
|
|
470
|
+
if (!type) continue;
|
|
471
|
+
}
|
|
472
|
+
content = content.replace(
|
|
473
|
+
match[0],
|
|
474
|
+
`href="data:${type};base64,${Buffer.from(data).toString("base64")}${fragment ? "#" + fragment : ""}"`,
|
|
475
|
+
);
|
|
476
|
+
}
|
|
477
|
+
const entry = {
|
|
478
|
+
version: asset.version,
|
|
479
|
+
body: Buffer.from(content),
|
|
480
|
+
dependencies: [...new Set(dependencies)],
|
|
481
|
+
};
|
|
482
|
+
legacyDependencies.set(name,entry.dependencies);
|
|
483
|
+
svgCache.delete(key);svgCache.set(key,entry);
|
|
484
|
+
let bytes=[...svgCache.values()].reduce((n,item)=>n+item.body.length,0);
|
|
485
|
+
while(svgCache.size>128||bytes>32*1024*1024){const first=svgCache.keys().next().value;bytes-=svgCache.get(first).body.length;svgCache.delete(first);}
|
|
486
|
+
return entry;
|
|
487
|
+
}
|
|
488
|
+
async function body(request,limit=16384,raw=false) {
|
|
489
|
+
const chunks=[];let size=0;
|
|
490
|
+
for await(const chunk of request){size+=chunk.length;if(size>limit)throw Error('Request too large.');chunks.push(chunk);}
|
|
491
|
+
const text=Buffer.concat(chunks).toString('utf8');
|
|
492
|
+
return raw?text:JSON.parse(text||'{}');
|
|
493
|
+
}
|
|
494
|
+
const server = createServer(async (request, response) => {
|
|
495
|
+
try {
|
|
496
|
+
const host = request.headers.host;
|
|
497
|
+
const url = new URL(request.url, 'http://localhost');
|
|
498
|
+
const file = ['GET', 'HEAD'].includes(request.method) && viewerFile(url.pathname);
|
|
499
|
+
if (file) return await shell(request, response, file, request.headers['x-adg-viewer-base']);
|
|
500
|
+
if (!directLocal(request)) return json(response, 401, { error: 'Unauthorized' });
|
|
501
|
+
if(url.pathname==='/api/cache-stats'&&request.method==='GET')return json(response,200,{process:process.memoryUsage(),builds:buildStore?.stats(),viewer:viewerCache?.stats()});
|
|
502
|
+
if (url.pathname === '/api/health' && request.method === 'GET') return json(response, 200, { id: instanceId, capabilities: { keyAuth: 1 } });
|
|
503
|
+
if (request.method === "POST") {
|
|
504
|
+
if (
|
|
505
|
+
request.headers.origin &&
|
|
506
|
+
request.headers.origin !== `http://${host}` && request.headers.origin !== `https://${host}`
|
|
507
|
+
) {
|
|
508
|
+
response.writeHead(403);
|
|
509
|
+
response.end("Cross-origin request refused.");
|
|
510
|
+
return;
|
|
511
|
+
}
|
|
512
|
+
const cacheRoute=url.pathname.match(/^\/(metadata|preview)\/([a-f0-9]{64})$/);
|
|
513
|
+
if(cacheRoute) {
|
|
514
|
+
const [,kind,hash]=cacheRoute,theme=url.searchParams.get('theme')==='dark'?'dark':'light',context=await contextFor(url);
|
|
515
|
+
if(![...knownBuilds.values()].some(built=>built.hash===hash)&&!overlayHashes.has(hash))return json(response,409,{error:'Source changed; reload its metadata.'});
|
|
516
|
+
if(kind==='metadata') {
|
|
517
|
+
const data=await body(request,32*1024*1024),metadata=data.metadata;
|
|
518
|
+
if(!metadata||!Array.isArray(metadata.parts)||!metadata.full||!Number.isFinite(metadata.full.width)||!Number.isFinite(metadata.full.height))throw Error('Invalid measured source metadata.');
|
|
519
|
+
await viewerCache.save(hash,theme,context,metadata);
|
|
520
|
+
} else {
|
|
521
|
+
const source=await body(request,32*1024*1024,true),crop=url.searchParams.get('crop')??'overview';
|
|
522
|
+
if(!/^\s*<svg\b/.test(source))throw Error('Expected an SVG preview.');
|
|
523
|
+
await viewerCache.savePreview(hash,theme,context,crop,source);
|
|
524
|
+
}
|
|
525
|
+
return json(response,200,{ok:true});
|
|
526
|
+
}
|
|
527
|
+
if(url.pathname==='/catalog') {
|
|
528
|
+
const data=await body(request,1024*1024),context=await contextFor(url);
|
|
529
|
+
if(!Array.isArray(data.packing)||data.packing.length>32)throw Error('Invalid packing cache.');
|
|
530
|
+
await viewerCache.save(digest('catalog'),'light',context,{packing:data.packing});
|
|
531
|
+
return json(response,200,{ok:true});
|
|
532
|
+
}
|
|
533
|
+
const data = await body(request);
|
|
534
|
+
if (url.pathname === "/preferences") {
|
|
535
|
+
if (typeof data.sidebar === "boolean") state.sidebar = data.sidebar;
|
|
536
|
+
const key = preferenceKey(data.scope,url.searchParams.get('base'));
|
|
537
|
+
if (["system", "light", "dark"].includes(data.theme))
|
|
538
|
+
state.theme = data.theme;
|
|
539
|
+
if (
|
|
540
|
+
root &&
|
|
541
|
+
data.view &&
|
|
542
|
+
["x", "y", "scale"].every((k) => Number.isFinite(data.view[k])) &&
|
|
543
|
+
data.view.scale > 0
|
|
544
|
+
)
|
|
545
|
+
state.views[key] = data.view;
|
|
546
|
+
if (root && data.selection &&
|
|
547
|
+
(data.selection.path === null || files.has(data.selection.path))) {
|
|
548
|
+
state.selections[key] = {
|
|
549
|
+
path: data.selection.path,
|
|
550
|
+
form: typeof data.selection.form === 'string' ? data.selection.form : null,
|
|
551
|
+
group: typeof data.selection.group === 'string' ? data.selection.group : null,
|
|
552
|
+
element: data.selection.element ?? null,
|
|
553
|
+
};
|
|
554
|
+
}
|
|
555
|
+
await persist();
|
|
556
|
+
} else {
|
|
557
|
+
response.writeHead(404);
|
|
558
|
+
response.end();
|
|
559
|
+
return;
|
|
560
|
+
}
|
|
561
|
+
return json(response, 200, { ok: true });
|
|
562
|
+
}
|
|
563
|
+
if (!["GET", "HEAD"].includes(request.method)) {
|
|
564
|
+
response.writeHead(405);
|
|
565
|
+
response.end();
|
|
566
|
+
return;
|
|
567
|
+
}
|
|
568
|
+
if (url.pathname === "/events") {
|
|
569
|
+
response.writeHead(200, {
|
|
570
|
+
"Content-Type": "text/event-stream",
|
|
571
|
+
"Cache-Control": "no-store",
|
|
572
|
+
});
|
|
573
|
+
response.write(`data: ${JSON.stringify({ revision })}\n\n`);
|
|
574
|
+
clients.add(response);
|
|
575
|
+
response.on("close", () => clients.delete(response));
|
|
576
|
+
return;
|
|
577
|
+
}
|
|
578
|
+
const metadataRoute=url.pathname.match(/^\/metadata\/([a-f0-9]{64})$/);
|
|
579
|
+
if(metadataRoute){const saved=await viewerCache?.get(metadataRoute[1],url.searchParams.get('theme')==='dark'?'dark':'light',await contextFor(url));return json(response,saved?200:404,saved??{error:'Source metadata is not cached.'});}
|
|
580
|
+
const previewRoute=url.pathname.match(/^\/preview\/([a-f0-9]{64})$/);
|
|
581
|
+
if(previewRoute) {
|
|
582
|
+
const content=await viewerCache?.preview(previewRoute[1],url.searchParams.get('theme')==='dark'?'dark':'light',await contextFor(url),url.searchParams.get('crop')??'overview');
|
|
583
|
+
if(!content){response.writeHead(404);response.end('Preview is not cached.');return;}
|
|
584
|
+
response.writeHead(200,{'Content-Type':'image/svg+xml','Cache-Control':'private, max-age=31536000, immutable','X-Content-Type-Options':'nosniff'});
|
|
585
|
+
response.end(request.method==='HEAD'?undefined:content);return;
|
|
586
|
+
}
|
|
587
|
+
let content, type, etag;
|
|
588
|
+
if (url.pathname === "/manifest") {
|
|
589
|
+
content = JSON.stringify(await manifest(url));
|
|
590
|
+
type = "application/json";
|
|
591
|
+
} else if (url.pathname === "/relationships") {
|
|
592
|
+
const assets = await Promise.all([...files.keys()].filter(name => /\.(tsx|mmd)$/.test(name)).map(async name => ({path:name, imports:(await sourceBuild(name)).imports})));
|
|
593
|
+
content = JSON.stringify(sourceRelationships(assets));
|
|
594
|
+
type = "application/json";
|
|
595
|
+
} else if (url.pathname.startsWith("/asset/")) {
|
|
596
|
+
const name = decodeURIComponent(url.pathname.slice(7));
|
|
597
|
+
if (!files.has(name)) {
|
|
598
|
+
response.writeHead(404);
|
|
599
|
+
response.end("Unknown SVG.");
|
|
600
|
+
return;
|
|
601
|
+
}
|
|
602
|
+
const theme =
|
|
603
|
+
url.searchParams.get("theme") === "dark" ? "dark" : "light";
|
|
604
|
+
const base=name.endsWith('.mmd')&&url.searchParams.has('base')?await (await import('./toolkit/arch-git.mjs')).resolveBase(activeProject,url.searchParams.get('base')):null;
|
|
605
|
+
const onlyFrame = url.searchParams.get('frame');
|
|
606
|
+
const variant = onlyFrame ? `-${digest(onlyFrame)}` : '';
|
|
607
|
+
etag = `"${files.get(name).version}-${theme}${variant}"`;
|
|
608
|
+
if (!base && request.headers["if-none-match"] === etag) {
|
|
609
|
+
response.writeHead(304);
|
|
610
|
+
response.end();
|
|
611
|
+
return;
|
|
612
|
+
}
|
|
613
|
+
const rendered=await svg(name,theme,[],onlyFrame,base);
|
|
614
|
+
content=rendered.body;etag=`"${rendered.version}-${theme}${variant}"`;
|
|
615
|
+
type = /\.(tsx|mmd)$/.test(name) ? "application/json" : "image/svg+xml";
|
|
616
|
+
} else {
|
|
617
|
+
response.writeHead(404); response.end('Not found.'); return;
|
|
618
|
+
}
|
|
619
|
+
response.writeHead(200, {
|
|
620
|
+
"Content-Type": `${type}; charset=utf-8`,
|
|
621
|
+
"Cache-Control": "no-cache",
|
|
622
|
+
"X-Content-Type-Options": "nosniff",
|
|
623
|
+
...(etag ? { ETag: etag } : {}),
|
|
624
|
+
});
|
|
625
|
+
response.end(request.method === "HEAD" ? undefined : content);
|
|
626
|
+
} catch (error) {
|
|
627
|
+
if (response.destroyed) return;
|
|
628
|
+
response.writeHead(error.name==='AbortError'?409:400, { "Content-Type": "application/json" });
|
|
629
|
+
response.end(JSON.stringify({ error: error.message }));
|
|
630
|
+
}
|
|
631
|
+
});
|
|
632
|
+
let closePromise;
|
|
633
|
+
const close = () => closePromise ??= (async () => {
|
|
634
|
+
closing = true;
|
|
635
|
+
clearTimeout(refreshTimer);
|
|
636
|
+
let primary;
|
|
637
|
+
for (const step of [
|
|
638
|
+
async () => { watcher?.close(); },
|
|
639
|
+
async () => { archWatcher?.close(); },
|
|
640
|
+
async () => {
|
|
641
|
+
for (const client of clients) client.end();
|
|
642
|
+
const disconnected = server.listening ? new Promise(resolve => server.close(resolve)) : Promise.resolve();
|
|
643
|
+
server.closeAllConnections(); await disconnected;
|
|
644
|
+
},
|
|
645
|
+
async () => { await writes; },
|
|
646
|
+
async () => { await buildStore?.close(); },
|
|
647
|
+
closeOverlays,
|
|
648
|
+
async () => { await viewerCache?.close(); },
|
|
649
|
+
]) {
|
|
650
|
+
try { await cleanup(step,primary); }
|
|
651
|
+
catch (error) { primary=error; }
|
|
652
|
+
}
|
|
653
|
+
if (primary) throw primary;
|
|
654
|
+
})();
|
|
655
|
+
try {
|
|
656
|
+
if (directory) await openDirectory(directory);
|
|
657
|
+
await new Promise((resolve,reject) => {
|
|
658
|
+
const startupError = error => { server.off('listening',listening); reject(error); };
|
|
659
|
+
const listening = () => {
|
|
660
|
+
server.off('error',startupError);
|
|
661
|
+
server.on('error',error => { if (!closing) onFatal?.(asCliError(error)); });
|
|
662
|
+
resolve();
|
|
663
|
+
};
|
|
664
|
+
server.once('error',startupError);
|
|
665
|
+
server.listen(port,'127.0.0.1',listening);
|
|
666
|
+
});
|
|
667
|
+
} catch (cause) {
|
|
668
|
+
const primary=asCliError(cause);
|
|
669
|
+
await cleanup(close,primary);
|
|
670
|
+
throw primary;
|
|
671
|
+
}
|
|
672
|
+
endStartup?.();
|
|
673
|
+
return { id: instanceId, directory: root, stateDirectory:path.resolve(stateDirectory), url: `http://127.0.0.1:${server.address().port}/`, port: server.address().port, close,
|
|
674
|
+
cacheStats:()=>({builds:buildStore?.stats(),viewer:viewerCache?.stats()}),
|
|
675
|
+
stats: () => {
|
|
676
|
+
const entries = [...files.keys()].filter(name => /\.(tsx|mmd)$/.test(name));
|
|
677
|
+
return { sourceCount: entries.length, frameCount: entries.every(name => frameCounts.has(name)) ? entries.reduce((n, name) => n + frameCounts.get(name), 0) : null };
|
|
678
|
+
} };
|
|
679
|
+
}
|