修复urdf上传和加载
This commit is contained in:
@@ -9,6 +9,9 @@
|
||||
@media(max-width:820px){.cad-nav{padding:0 16px;gap:12px}.cad-nav-links{display:none}.cad-main{padding:28px 20px}.cad-heading{align-items:flex-start}.cad-editor .cad-project-name,.cad-editor .cad-save-state{display:none}.cad-state{padding:24px}.cad-editor .cad-nav{flex-wrap:nowrap}}
|
||||
@media(prefers-reduced-motion:reduce){.cad-page *{scroll-behavior:auto!important;transition:none!important;animation-duration:.01ms!important}}
|
||||
.cad-page .sr-only{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0}
|
||||
.cad-loading{z-index:90;background:var(--cad-bg)}
|
||||
.cad-loading .cad-loading-status{font-family:var(--font);letter-spacing:normal;color:var(--cad-muted)}
|
||||
.cad-loading-cancel{position:absolute;top:max(20px,env(safe-area-inset-top));right:max(24px,env(safe-area-inset-right));min-height:44px!important;padding:0 16px}
|
||||
.cad-page .cad-card{border-radius:8px}
|
||||
.cad-card-art img{display:block;width:100%;height:100%;min-height:0;object-fit:contain}
|
||||
.cad-editor .cad-save-state[data-state=coverFailed],.cad-editor .cad-save-state[data-state=coverUnavailable]{color:#ffb870}
|
||||
|
||||
+1
-1
@@ -37,7 +37,7 @@
|
||||
## 三、3D 模型
|
||||
|
||||
已改为后端字段 `urdfMainUrl`:有值就在项目页、工作台显示 3D,没有就不显示(不再读取仓库里的 robot.json)。
|
||||
网格按 URDF 里的相对路径从 `urdfBaseUrl` 读取;`package://包名/…` 按资源包根目录处理。
|
||||
相对网格路径按 `urdfMainUrl` 所在目录解析;`package://包名/…` 优先匹配主文件所在的同名 ROS 包目录,同时兼容 `urdfBaseUrl` 下的旧版扁平上传。管理端上传前按文件清单改写 URDF 的网格和贴图引用,避免嵌套包目录丢失。2026-11-12 的公开资源排查见 [URDF 资源检查](urdf-resource-audit-2026-11-12.md)。
|
||||
|
||||
## 四、AI 助手
|
||||
|
||||
|
||||
@@ -0,0 +1,55 @@
|
||||
# URDF 上传资源检查(2026-11-12)
|
||||
|
||||
检查正式环境公开社区接口列出的全部 86 个项目,其中 79 个已绑定 URDF、7 个未绑定。79 个主文件均可读取并解析。按项目对 URDF 的 mesh/texture filename 去重,共检查 1,972 条网格引用、3 条贴图引用,包含 visual 和 collision。
|
||||
|
||||
资源检查使用 HTTP HEAD,按前台实际顺序尝试候选地址,只在 404/410 后换路径。检查了修复前后的全部 1,975 条引用;修复后的成功项是 1,973 条,没有将原有成功引用改坏。此检查不覆盖 DAE/GLTF/OBJ 文件内部的二级材质、贴图和二进制引用,也不涵盖未发布项目。
|
||||
|
||||
| 项目 | 修复前失败 | 修复后失败 | 原因及处理 |
|
||||
| --- | ---: | ---: | --- |
|
||||
| AlexBot(d1qa612t7pc1) | 11 | 0 | `package://Alexbot_simple_urdf/` 被映射到批次根目录,丢失 `urdf_pkg/Alexbot_simple_urdf/`;前台现在保留包名并根据主文件位置匹配包根目录 |
|
||||
| Poppy Humanoid(7hwzszajfvp0) | 10 | 0 | 10 个 collision 网格引用 `.STL`,实际对象使用 `.stl`;前台增加扩展名兼容,管理端按真实清单修正大小写。这些引用不影响当前仅加载 visual 的前台展示 |
|
||||
| OpenPodcar(f8nbcn5ek18r) | 1 | 1 | `../../kinect/meshes/kinect.dae` 未找到可访问的上传资源;需补齐 Kinect 网格或修正源 URDF 引用 |
|
||||
| Talos(m2vpg4t8nn5y) | 1 | 1 | `package://pal_urdf_utils/meshes/camera/orbbec.STL` 未找到可访问的上传资源;需补齐外部 ROS 包中的相机网格或修正源 URDF 引用 |
|
||||
| 其余 75 个已绑定 URDF 的项目 | 0 | 0 | 本次直接引用检查通过 |
|
||||
| 合计 | 23 | 2 | 修复 21 条引用的路径或扩展名兼容问题 |
|
||||
|
||||
## AlexBot 的验证
|
||||
|
||||
URDF:
|
||||
|
||||
```text
|
||||
https://linkerbot.oss-cn-beijing.aliyuncs.com/vibemake/urdf/d1qa612t7pc1/61043f35d64f4c4e96ce5f209bb1ebf6/urdf_pkg/Alexbot_simple_urdf/urdf/Alexbot_simple_urdf.urdf
|
||||
```
|
||||
|
||||
正确网格位置(以 base_link 为例):
|
||||
|
||||
```text
|
||||
https://linkerbot.oss-cn-beijing.aliyuncs.com/vibemake/urdf/d1qa612t7pc1/61043f35d64f4c4e96ce5f209bb1ebf6/urdf_pkg/Alexbot_simple_urdf/meshes/base_link.STL
|
||||
```
|
||||
|
||||
另外使用浏览器、本地资源代理、正式 OSS 原始文件和实际 `RobotViewer.build()` / URDFLoader 完成读取及解码:12 次资源请求全部 200,得到 11 个 link、10 个 joint、11 个网格、149,104 个三角面,无浏览器运行错误。此验证确认文件读取、解析与几何体构建,不包含 WebGL 画面检查。
|
||||
|
||||
## 管理端上传修复
|
||||
|
||||
`vibemake-admin` 的项目上传和迁移上传都在申请签名前,按所选文件清单解析 package、相对路径、Windows 导出路径和唯一的大小写匹配,将 URDF 的 mesh/texture 引用改为相对主文件的真实路径。ROS 包名用于区分不同包中的同名资源。网格、材质和贴图文件本身及上传目录结构保持原样。
|
||||
|
||||
签名清单、OSS 上传文件与确认清单使用同一份改写结果及字节数。无效 URDF、缺失资源或无法唯一匹配的引用会在签名前报错,避免继续绑定不完整的资源包。
|
||||
|
||||
修改的是本地代码和构建产物,未改写线上 OSS 对象或项目绑定;前台发布后可兼容 AlexBot 已上传的这批文件,无需重新上传。
|
||||
|
||||
## 验证命令
|
||||
|
||||
在 `vibemake` 中:
|
||||
|
||||
```sh
|
||||
node --test tests/urdf-paths.test.js tests/resource-loading.test.js scripts/model-assets.test.mjs
|
||||
node --test tests/urdf-loading.browser.mjs
|
||||
node scripts/build.mjs
|
||||
```
|
||||
|
||||
在 `vibemake-admin` 中:
|
||||
|
||||
```sh
|
||||
npx playwright test tests/urdf.spec.ts
|
||||
npm run build:prod
|
||||
```
|
||||
@@ -137,6 +137,12 @@ export class CadApi {
|
||||
return capabilities;
|
||||
}
|
||||
|
||||
async aiKnowledge(body, signal) {
|
||||
const result = await this.call(AI + '/knowledge', { method: 'POST', body, signal });
|
||||
if (!result || typeof result.status !== 'string' || !Array.isArray(result.documents)) throw cadError('BAD_RESPONSE');
|
||||
return result;
|
||||
}
|
||||
|
||||
async aiChat(body, signal, onStart) {
|
||||
this.assertIdentity();
|
||||
if (!body || typeof body !== 'object' || Array.isArray(body)) throw cadError('BAD_REQUEST');
|
||||
|
||||
+77
-8
@@ -162,8 +162,48 @@ function message(key, hint, action, actionLabel = 'retry') {
|
||||
main.querySelector('[data-action]')?.addEventListener('click', action);
|
||||
}
|
||||
function stage(key, progress) {
|
||||
message(key, null, openingProject ? cancelOpening : null, 'cancel');
|
||||
const p = main.querySelector('h1'); if (progress) p.textContent += ` ${progress}`;
|
||||
if (!editor) {
|
||||
message(key, null, openingProject ? cancelOpening : null, 'cancel');
|
||||
const p = main.querySelector('h1'); if (progress) p.textContent += ` ${progress}`;
|
||||
return;
|
||||
}
|
||||
main.hidden = false;
|
||||
let loading = main.querySelector('.cad-loading');
|
||||
if (!loading) {
|
||||
main.innerHTML = `<section class="splash cad-loading" aria-busy="true">
|
||||
<div class="splash-inner"><div class="splash-mark" role="progressbar" aria-labelledby="cad-loading-status" aria-valuemin="0" aria-valuemax="100">
|
||||
<img class="splash-logo splash-logo-base" fetchpriority="high" src="/assets/brand/make-web-768.png" srcset="/assets/brand/make-web-256.png 256w, /assets/brand/make-web-384.png 384w, /assets/brand/make-web-512.png 512w, /assets/brand/make-web-768.png 768w" sizes="240px" width="240" height="90" alt="">
|
||||
<img class="splash-logo splash-logo-fill" fetchpriority="high" src="/assets/brand/make-web-768.png" srcset="/assets/brand/make-web-256.png 256w, /assets/brand/make-web-384.png 384w, /assets/brand/make-web-512.png 512w, /assets/brand/make-web-768.png 768w" sizes="240px" width="240" height="90" alt="">
|
||||
</div></div>
|
||||
<div class="splash-foot"><span class="cad-loading-status" id="cad-loading-status" role="status"></span><span class="splash-pct" aria-hidden="true"></span></div>
|
||||
<button type="button" class="btn btn-ghost cad-loading-cancel" data-action>${esc(t('cancel'))}</button>
|
||||
</section>`;
|
||||
loading = main.querySelector('.cad-loading');
|
||||
loading.querySelector('[data-action]').addEventListener('click', cancelOpening);
|
||||
}
|
||||
loading.dataset.stage = key;
|
||||
const meter = loading.querySelector('[role="progressbar"]');
|
||||
const label = loading.querySelector('#cad-loading-status');
|
||||
const detail = typeof progress === 'string' ? progress : '';
|
||||
const parts = detail.match(/^(\d+)\s*\/\s*(\d+)$/);
|
||||
let fraction = progress?.total > 0 ? progress.loaded / progress.total
|
||||
: /^\d+%$/.test(detail) ? Number.parseInt(detail, 10) / 100
|
||||
: parts && Number(parts[2]) > 0 ? Number(parts[1]) / Number(parts[2]) : null;
|
||||
if (progress?.phase === 'initialize') fraction = null;
|
||||
if (progress?.phase === 'ready') fraction = 1;
|
||||
const caption = t(key) + (detail && !detail.endsWith('%') ? ` ${detail}` : '');
|
||||
if (label.textContent !== caption) label.textContent = caption;
|
||||
const pct = loading.querySelector('.splash-pct');
|
||||
if (Number.isFinite(fraction)) {
|
||||
const percent = Math.floor(Math.max(0, Math.min(1, fraction)) * 100);
|
||||
loading.style.setProperty('--splash-unrevealed', `${100 - percent}%`);
|
||||
meter.setAttribute('aria-valuenow', String(percent));
|
||||
pct.textContent = String(percent).padStart(3, '0') + '%';
|
||||
} else {
|
||||
meter.removeAttribute('aria-valuenow');
|
||||
pct.textContent = '';
|
||||
}
|
||||
loading.querySelector('[data-action]').hidden = !openingProject;
|
||||
}
|
||||
async function cancelOpening() {
|
||||
++epoch; request?.abort();
|
||||
@@ -193,7 +233,10 @@ async function bindAssistant() {
|
||||
const ctx = context();
|
||||
assistantRequest?.abort(); assistantRequest = new AbortController();
|
||||
const capabilityRequest = assistantRequest;
|
||||
if (window.__VIBEMAKE_CAD__) window.__VIBEMAKE_CAD__.agentChat = null;
|
||||
if (window.__VIBEMAKE_CAD__) {
|
||||
window.__VIBEMAKE_CAD__.agentChat = null;
|
||||
window.__VIBEMAKE_CAD__.agentKnowledge = null;
|
||||
}
|
||||
let capabilities = null;
|
||||
try {
|
||||
capabilities = await api.aiCapabilities(capabilityRequest.signal);
|
||||
@@ -209,21 +252,40 @@ async function bindAssistant() {
|
||||
const client = api, engine = bridge, documentContext = context();
|
||||
const host = window.__VIBEMAKE_CAD__;
|
||||
if (host) {
|
||||
const requestRevisions = new WeakMap();
|
||||
host.agentChat = capabilities?.enabled ? async (requestBody, signal, onStart) => {
|
||||
assertContext(documentContext, true);
|
||||
const current = await engine.getState();
|
||||
const documentRevision = await agentRevision(current.revision);
|
||||
let documentRevision = requestRevisions.get(requestBody);
|
||||
if (documentRevision === undefined) {
|
||||
const current = await engine.getState();
|
||||
documentRevision = await agentRevision(current.revision);
|
||||
}
|
||||
assertContext(documentContext, true);
|
||||
requestRevisions.set(requestBody, documentRevision);
|
||||
const request = {
|
||||
...requestBody,
|
||||
cadProjectCode: project.id,
|
||||
context: { ...requestBody.context, documentRevision },
|
||||
context: { ...requestBody.context, documentRevision, engineBuild: host.buildId },
|
||||
};
|
||||
return client.aiChat(request, signal, () => {
|
||||
assertContext(documentContext, true);
|
||||
onStart?.();
|
||||
});
|
||||
} : null;
|
||||
host.agentKnowledge = capabilities?.enabled && capabilities.knowledgeProtocol === 'cad-knowledge-v1'
|
||||
&& capabilities.knowledgeMode !== 'off' ? async (argumentsBody, signal) => {
|
||||
assertContext(documentContext, true);
|
||||
if (signal?.aborted) throw signal.reason;
|
||||
const result = await client.aiKnowledge({
|
||||
cadProjectCode: project.id,
|
||||
documentSessionCode: session,
|
||||
engineBuild: host.buildId,
|
||||
arguments: argumentsBody,
|
||||
}, signal);
|
||||
assertContext(documentContext, true);
|
||||
if (signal?.aborted) throw signal.reason;
|
||||
return result;
|
||||
} : null;
|
||||
}
|
||||
await bridge.setAgentContext({
|
||||
userId: boundUser,
|
||||
@@ -238,7 +300,10 @@ async function bindAssistant() {
|
||||
async function clearAssistant() {
|
||||
assistantRequest?.abort(); assistantRequest = null;
|
||||
if (typeof bridge?.setAgentContext === 'function') await bridge.setAgentContext(null).catch(() => {});
|
||||
if (window.__VIBEMAKE_CAD__) window.__VIBEMAKE_CAD__.agentChat = null;
|
||||
if (window.__VIBEMAKE_CAD__) {
|
||||
window.__VIBEMAKE_CAD__.agentChat = null;
|
||||
window.__VIBEMAKE_CAD__.agentKnowledge = null;
|
||||
}
|
||||
}
|
||||
async function validateIdentity() {
|
||||
if (!auth.token) return false;
|
||||
@@ -340,7 +405,11 @@ async function openEditor(current) {
|
||||
stage('metadata');
|
||||
project = await client.get(projectId, control.signal); check();
|
||||
stage('engine'); viewport.hidden = false; viewport.style.visibility = 'hidden';
|
||||
try { bridge = await loadEngine(); } catch (error) { if (error.code === 'FONT_UNAVAILABLE') { bridge = window.vibemakeCad; showFontError(error); } throw error; }
|
||||
try {
|
||||
bridge = await loadEngine({ signal: control.signal, onProgress: (progress) => {
|
||||
if (current === epoch && !control.signal.aborted) stage(progress.phase === 'download' ? 'engine' : 'engineStarting', progress);
|
||||
} });
|
||||
} catch (error) { if (error.code === 'FONT_UNAVAILABLE') { bridge = window.vibemakeCad; showFontError(error); } throw error; }
|
||||
check();
|
||||
const engineReady = await bridge.ready(); check();
|
||||
assistantAvailable = engineReady.capabilities?.assistant === true && typeof bridge.setAgentContext === 'function';
|
||||
|
||||
+58
-8
@@ -1,24 +1,74 @@
|
||||
import { CAD } from './config.js';
|
||||
import { cadError } from './api.js';
|
||||
import { locale } from './i18n.js';
|
||||
let engine, workerRegistration;
|
||||
export function loadEngine() {
|
||||
return engine ??= start().catch((error) => { engine = null; throw error; });
|
||||
let engine, workerRegistration, initializedBuild;
|
||||
let engineProgress = { phase: 'download', loaded: 0, total: null };
|
||||
const progressListeners = new Set();
|
||||
function reportProgress(phase, loaded, total) {
|
||||
engineProgress = { phase, loaded, total };
|
||||
for (const listener of progressListeners) listener(engineProgress);
|
||||
}
|
||||
export function loadEngine({ onProgress, signal } = {}) {
|
||||
if (signal?.aborted) return Promise.reject(signal.reason);
|
||||
if (!engine) engineProgress = { phase: 'download', loaded: 0, total: null };
|
||||
if (onProgress) { progressListeners.add(onProgress); onProgress(engineProgress); }
|
||||
// Loading is shared across retries. Cancelling an opening detaches its observer,
|
||||
// while the engine can finish safely for the next opening.
|
||||
const pending = engine ??= start().catch((error) => { engine = null; throw error; });
|
||||
return new Promise((resolve, reject) => {
|
||||
const cleanup = () => { progressListeners.delete(onProgress); signal?.removeEventListener('abort', abort); };
|
||||
const abort = () => { cleanup(); reject(signal.reason); };
|
||||
signal?.addEventListener('abort', abort, { once: true });
|
||||
pending.then((value) => { cleanup(); resolve(value); }, (error) => { cleanup(); reject(error); });
|
||||
});
|
||||
}
|
||||
async function start() {
|
||||
const response = await fetch(CAD.engineManifest, { cache: 'no-store' });
|
||||
if (!response.ok) throw cadError('ENGINE_MISSING');
|
||||
const manifest = await response.json();
|
||||
const manifestResponse = await fetch(CAD.engineManifest, { cache: 'no-store' });
|
||||
if (!manifestResponse.ok) throw cadError('ENGINE_MISSING');
|
||||
const manifest = await manifestResponse.json();
|
||||
if (manifest.bridgeVersion !== CAD.bridgeVersion || !/^[a-zA-Z0-9_-]+$/.test(manifest.buildId)) throw cadError('FORMAT_UNSUPPORTED');
|
||||
const prefix = `/cad/_assets/${manifest.buildId}/`;
|
||||
for (const key of ['js', 'wasm', 'chineseFont']) if (!manifest[key]?.startsWith(prefix) || /[?#]|\.\./.test(manifest[key])) throw cadError('BAD_RESPONSE');
|
||||
const sizeOf = (path) => {
|
||||
const size = Array.isArray(manifest.files) ? manifest.files.find((file) => file.path === path)?.size : null;
|
||||
return Number.isSafeInteger(size) && size > 0 ? size : null;
|
||||
};
|
||||
const jsSize = sizeOf(manifest.js), wasmSize = sizeOf(manifest.wasm);
|
||||
const total = jsSize && wasmSize ? jsSize + wasmSize : null;
|
||||
let loaded = 0;
|
||||
// Set before WASM starts. Standalone engine builds keep their original behaviour.
|
||||
window.__VIBEMAKE_CAD__ = { bridgeVersion: 1, buildId: manifest.buildId, locale: locale(), assetBase: prefix, chineseFont: manifest.chineseFont };
|
||||
const { default: init } = await import(manifest.js);
|
||||
await init({ module_or_path: manifest.wasm });
|
||||
if (initializedBuild !== manifest.buildId) {
|
||||
reportProgress('download', loaded, total);
|
||||
const [{ default: init }, response] = await Promise.all([
|
||||
import(manifest.js).then((module) => { loaded += jsSize || 0; reportProgress('download', loaded, total); return module; }),
|
||||
fetch(manifest.wasm).then((response) => { if (!response.ok) throw cadError('ENGINE_MISSING'); return response; }),
|
||||
]);
|
||||
let wasmResponse = response;
|
||||
if (response.body) {
|
||||
const headers = new Headers(response.headers);
|
||||
// Fetch chunks are decoded bytes, like manifest sizes, even on gzip/Brotli hosts.
|
||||
headers.delete('content-encoding'); headers.delete('content-length');
|
||||
const body = response.body.pipeThrough(new TransformStream({
|
||||
transform(chunk, controller) {
|
||||
loaded += chunk.byteLength;
|
||||
reportProgress('download', loaded, total);
|
||||
controller.enqueue(chunk);
|
||||
},
|
||||
flush() { reportProgress('initialize', loaded, total); },
|
||||
}));
|
||||
// Keep streaming compilation and the module's original import.meta.url.
|
||||
wasmResponse = new Response(body, { headers, status: response.status, statusText: response.statusText });
|
||||
}
|
||||
await init({ module_or_path: wasmResponse });
|
||||
// Font failures can be retried without downloading an initialized WASM again.
|
||||
initializedBuild = manifest.buildId;
|
||||
}
|
||||
reportProgress('initialize', loaded, total);
|
||||
const deadline = performance.now() + 90000;
|
||||
while (!window.vibemakeCad) { if (performance.now() > deadline) throw cadError('ENGINE_TIMEOUT'); await new Promise((r) => setTimeout(r, 30)); }
|
||||
await window.vibemakeCad.ready();
|
||||
reportProgress('ready', loaded, total);
|
||||
if ('serviceWorker' in navigator) {
|
||||
workerRegistration = navigator.serviceWorker.register('/cad/worker.js', { scope: '/cad/', updateViaCache: 'none' }).then((registration) => {
|
||||
let notifiedBuild;
|
||||
|
||||
@@ -17,6 +17,7 @@ const messages = {
|
||||
logout: ['退出登录', 'Sign out'], home: ['返回首页', 'Home'], list: ['返回项目列表', 'Projects'], previous: ['上一页', 'Previous'], next: ['下一页', 'Next'],
|
||||
loading: ['加载中…', 'Loading…'], identity: ['验证账号…', 'Verifying account…'], metadata: ['读取项目…', 'Reading project…'],
|
||||
engine: ['加载编辑器…', 'Loading editor…'], download: ['下载工程…', 'Downloading design…'], rebuild: ['重建模型…', 'Rebuilding model…'],
|
||||
engineStarting: ['正在启动编辑器…', 'Starting editor…'],
|
||||
file: ['文件', 'File'], preferences: ['首选项', 'Preferences'], help: ['帮助', 'Help'], undo: ['撤销', 'Undo'], redo: ['重做', 'Redo'],
|
||||
save: ['保存', 'Save'], never: ['尚未保存到云端', 'Not saved to cloud'], saved: ['已保存到云端', 'Saved to cloud'], dirty: ['有未保存更改', 'Unsaved changes'],
|
||||
preparing: ['正在准备…', 'Preparing…'], uploading: ['正在上传…', 'Uploading…'], verifying: ['正在确认…', 'Confirming…'],
|
||||
|
||||
+7
-5
@@ -4,7 +4,7 @@
|
||||
// (data/community.json + robots/),保留最早的完整样子作参考。
|
||||
import * as api from './api.js';
|
||||
import { normalizeRobot } from './registry.js';
|
||||
import { meshUrlCandidates } from './urdf-paths.js';
|
||||
import { urdfResourceUrlCandidates } from './urdf-paths.js';
|
||||
import { modelUrlResolver } from './model-assets.js';
|
||||
|
||||
export const STATIC_HOSTS = ['127.0.0.1'];
|
||||
@@ -92,7 +92,7 @@ export function prefetchRoot(code) {
|
||||
const rootTree = (p) => prefetchRoot(p.code);
|
||||
|
||||
// ---------- 3D 模型:项目的 urdfMainUrl 字段(URDF 主文件的公开地址),没有就不显示 3D ----------
|
||||
// 网格按 URDF 里的相对路径从同一个资源目录(urdfBaseUrl)读取;package://包名/xxx 按资源包根目录处理
|
||||
// 相对路径按主文件目录解析;package:// 同时兼容嵌套 ROS 包和旧版扁平上传目录。
|
||||
export function ensureRobot(p) {
|
||||
if (p.robot !== undefined && p.robot !== null) return Promise.resolve(p.robot);
|
||||
p.robot = p.urdfMainUrl ? robotFromUrdf(p) : null;
|
||||
@@ -101,14 +101,16 @@ export function ensureRobot(p) {
|
||||
|
||||
function robotFromUrdf(p) {
|
||||
const base = (p.urdfBaseUrl || p.urdfMainUrl.replace(/[^/]*$/, '')).replace(/\/+$/, '');
|
||||
const candidates = (url) => urdfResourceUrlCandidates(base, url, p.urdfMainUrl);
|
||||
const resolveUrl = modelUrlResolver(base);
|
||||
return normalizeRobot({
|
||||
id: p.code,
|
||||
name: p.name,
|
||||
description: p.description,
|
||||
urdf: p.urdfMainUrl,
|
||||
resolveUrl: modelUrlResolver(base),
|
||||
resolveMeshUrls: (url) => meshUrlCandidates(base, url),
|
||||
packages: () => base,
|
||||
resolveUrl: (url) => resolveUrl(candidates(url)[0]),
|
||||
resolveMeshUrls: candidates,
|
||||
packages: (name) => `package://${name}`,
|
||||
archetype: 'generic', // 没有关节映射:演示时所有关节在限位内摆动
|
||||
source: { project: p.code },
|
||||
});
|
||||
|
||||
+58
-14
@@ -1,11 +1,11 @@
|
||||
const dirname = (path) => path.includes('/') ? path.slice(0, path.lastIndexOf('/')) : '';
|
||||
|
||||
function normalize(path) {
|
||||
function normalize(path, clamp = false) {
|
||||
const out = [];
|
||||
for (const seg of path.split('/')) {
|
||||
if (!seg || seg === '.') continue;
|
||||
if (seg === '..') {
|
||||
if (!out.length) return null;
|
||||
if (!out.length) { if (clamp) continue; return null; }
|
||||
out.pop();
|
||||
} else out.push(seg);
|
||||
}
|
||||
@@ -20,12 +20,13 @@ function relative(fromDir, to) {
|
||||
}
|
||||
|
||||
function localPath(filename, mainPath) {
|
||||
const value = String(filename).trim();
|
||||
const pkg = value.match(/^package:\/\/[^/]+\/(.*)$/i);
|
||||
if (pkg) return normalize(pkg[1]);
|
||||
const value = String(filename).trim().replace(/\\/g, '/');
|
||||
const pkg = value.match(/^package:\/\/[^/]*\/(.*)$/i);
|
||||
if (pkg) return normalize(pkg[1], true);
|
||||
if (/^https?:\/\//i.test(value) || /^(data|blob):/i.test(value)) return null;
|
||||
if (/^file:\/\//i.test(value)) return normalize(value.replace(/^file:\/+/i, ''));
|
||||
return normalize(value.startsWith('/') ? value.slice(1) : `${dirname(mainPath)}/${value}`);
|
||||
if (/^file:\/\//i.test(value)) return normalize(value.replace(/^file:\/+/i, ''), true);
|
||||
if (/^[a-z]:\//i.test(value)) return normalize(value.slice(3), true);
|
||||
return normalize(value.startsWith('/') ? value.slice(1) : `${dirname(mainPath)}/${value}`, true);
|
||||
}
|
||||
|
||||
export function meshUrlCandidates(base, url) {
|
||||
@@ -33,16 +34,49 @@ export function meshUrlCandidates(base, url) {
|
||||
const root = String(base).replace(/\/+$/, '');
|
||||
const prefix = `${root}/`;
|
||||
if (!value.startsWith(prefix)) return [value];
|
||||
const path = value.slice(prefix.length).split(/[?#]/, 1)[0];
|
||||
const rawPath = value.slice(prefix.length);
|
||||
const suffix = rawPath.match(/[?#].*$/)?.[0] || '';
|
||||
// Keep legacy references inside their upload batch, including ../ paths and
|
||||
// Windows exporter paths, before trying shorter uploaded directory prefixes.
|
||||
const path = normalize(rawPath.split(/[?#]/, 1)[0].replace(/\\/g, '/'), true);
|
||||
if (!path) return [value];
|
||||
const canonical = `${root}/${path}${suffix}`;
|
||||
const parts = path.split('/');
|
||||
if (parts.some((part) => !part || part === '.' || part === '..')) return [value];
|
||||
const resourceIndex = parts.findIndex((part, index) => index > 1 && (part === 'meshes' || part === 'qb_meshes'));
|
||||
const rootResource = parts[0] === 'robots' && resourceIndex > 1
|
||||
? `${root}/${parts.slice(resourceIndex).join('/')}`
|
||||
? `${root}/${parts.slice(resourceIndex).join('/')}${suffix}`
|
||||
: null;
|
||||
// Older uploads can retain source directories that are absent from the OSS batch.
|
||||
const fallbacks = parts.slice(1, 9).map((_, i) => `${root}/${parts.slice(i + 1).join('/')}`);
|
||||
return [...new Set([rootResource, value, ...fallbacks].filter(Boolean))];
|
||||
const fallbacks = parts.slice(1, 9).map((_, i) => `${root}/${parts.slice(i + 1).join('/')}${suffix}`);
|
||||
return [...new Set([rootResource, canonical, ...fallbacks].filter(Boolean))];
|
||||
}
|
||||
|
||||
// URDFLoader keeps the package URI intact until this step so different ROS
|
||||
// packages can resolve to different directories within the same upload batch.
|
||||
export function urdfResourceUrlCandidates(base, url, mainUrl) {
|
||||
const root = String(base).replace(/\/+$/, '');
|
||||
const value = String(url);
|
||||
const pkg = value.match(/^package:\/\/([^/]*)(?:\/(.*))?$/i);
|
||||
let candidates;
|
||||
if (pkg) {
|
||||
const [, name, path = ''] = pkg;
|
||||
const roots = [root];
|
||||
const main = String(mainUrl || '').split(/[?#]/, 1)[0];
|
||||
const dirs = main.startsWith(`${root}/`) ? main.slice(root.length + 1).split('/').slice(0, -1) : [];
|
||||
const index = dirs.lastIndexOf(name);
|
||||
if (name && index >= 0) roots.unshift(`${root}/${dirs.slice(0, index + 1).join('/')}`);
|
||||
if (name && name !== '.' && name !== '..') roots.push(`${root}/${name}`);
|
||||
const paths = [...new Set(roots)].map((dir) => `${dir}/${path}`);
|
||||
const first = meshUrlCandidates(root, paths[0]);
|
||||
candidates = [first[0], ...paths.slice(1), ...first.slice(1), ...paths.slice(1).flatMap((p) => meshUrlCandidates(root, p))];
|
||||
} else {
|
||||
const file = value.match(/(?:^|\/)file:\/+(.*)$/i);
|
||||
candidates = meshUrlCandidates(root, file ? `${root}/${file[1]}` : value);
|
||||
}
|
||||
candidates = [...new Set(candidates)];
|
||||
// Some older exports use .STL while the uploaded object ends in .stl.
|
||||
const lowerExtensions = candidates.map((p) => p.replace(/\.[A-Z\d]+(?=[?#]|$)/, (ext) => ext.toLowerCase()));
|
||||
return [...new Set([...candidates, ...lowerExtensions])];
|
||||
}
|
||||
|
||||
// Resolve references against the uploaded file manifest. A unique suffix match
|
||||
@@ -51,8 +85,11 @@ export function resolveUrdfResourcePath(filename, mainPath, availablePaths) {
|
||||
const target = localPath(filename, mainPath);
|
||||
if (!target) return null;
|
||||
|
||||
const available = [...new Set(availablePaths.map(normalize).filter(Boolean))];
|
||||
let match = available.includes(target) ? target : null;
|
||||
const available = [...new Set(availablePaths.map((path) => normalize(path)).filter(Boolean))];
|
||||
const pkg = String(filename).trim().replace(/\\/g, '/').match(/^package:\/\/([^/]+)\/(.*)$/i);
|
||||
const qualified = pkg && pkg[1] !== '..' ? normalize(`${pkg[1]}/${pkg[2]}`) : null;
|
||||
const packageMatches = qualified ? available.filter((path) => path === qualified || path.endsWith(`/${qualified}`)) : [];
|
||||
let match = packageMatches.length === 1 ? packageMatches[0] : available.includes(target) ? target : null;
|
||||
if (!match) {
|
||||
const targetParts = target.split('/');
|
||||
let bestScore = 1;
|
||||
@@ -73,6 +110,13 @@ export function resolveUrdfResourcePath(filename, mainPath, availablePaths) {
|
||||
}
|
||||
}
|
||||
|
||||
if (!match) {
|
||||
const lowerTarget = target.toLowerCase();
|
||||
const caseMatches = available.filter((path) => path.toLowerCase() === lowerTarget
|
||||
|| path.toLowerCase().endsWith(`/${lowerTarget}`));
|
||||
if (caseMatches.length === 1) match = caseMatches[0];
|
||||
}
|
||||
|
||||
return match ? relative(dirname(mainPath), match) : null;
|
||||
}
|
||||
|
||||
|
||||
@@ -14,6 +14,26 @@ const { errorText, setLocale } = await import('../../js/cad/i18n.js');
|
||||
|
||||
beforeEach(() => { storage.clear(); auth.set({ token: 'token-a', user: { userCode: 'owner-a' } }); });
|
||||
|
||||
test('CAD knowledge uses the authenticated cancellable endpoint and rejects stale identity', async () => {
|
||||
const control = new AbortController();
|
||||
const body = { cadProjectCode: 'project-a', documentSessionCode: 'session-a', engineBuild: 'build-a', arguments: { query: 'gear' } };
|
||||
const api = new CadApi({ fetcher: async (url, options) => {
|
||||
assert.equal(url, '/api/cad/ai/knowledge');
|
||||
assert.equal(options.method, 'POST');
|
||||
assert.equal(options.headers.Authorization, 'Bearer token-a');
|
||||
assert.equal(options.cache, 'no-store');
|
||||
assert.equal(options.signal, control.signal);
|
||||
assert.deepEqual(JSON.parse(options.body), body);
|
||||
return Response.json({ code: 'OK', data: { status: 'uncovered', documents: [] } });
|
||||
} });
|
||||
assert.equal((await api.aiKnowledge(body, control.signal)).status, 'uncovered');
|
||||
const stale = new CadApi({ fetcher: async () => {
|
||||
auth.set({ token: 'token-b', user: { userCode: 'owner-b' } });
|
||||
return Response.json({ code: 'OK', data: { status: 'matched', documents: [] } });
|
||||
} });
|
||||
await assert.rejects(stale.aiKnowledge(body), { code: 'STALE_IDENTITY' });
|
||||
});
|
||||
|
||||
test('CAD project covers use the documented signature and anonymous OSS form upload', async () => {
|
||||
const calls = [], bytes = new Uint8Array([137, 80, 78, 71]);
|
||||
const api = new CadApi({ fetcher: async (url, options) => {
|
||||
|
||||
@@ -2,6 +2,7 @@ import test from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { createServer } from 'node:http';
|
||||
import { readFile } from 'node:fs/promises';
|
||||
import { createGzip, constants } from 'node:zlib';
|
||||
import { chromium } from 'playwright';
|
||||
import { cadWorker } from '../../scripts/cad-engine.mjs';
|
||||
|
||||
@@ -38,6 +39,96 @@ self.addEventListener('activate',()=>{});
|
||||
self.addEventListener('fetch',event=>{const u=new URL(event.request.url);if(event.request.method!=='GET'||u.origin!==self.location.origin||u.search||!FILES.has(u.pathname))return;event.respondWith((async()=>{const cache=await caches.open(CACHE);const hit=await cache.match(event.request);if(hit)return hit;const response=await fetch(event.request);if(response.ok)await cache.put(event.request,response.clone());return response;})());});
|
||||
`;
|
||||
|
||||
test('CAD loading measures decoded bytes, waits for readiness and detaches cancelled openings', async (t) => {
|
||||
// A real, valid WASM with a custom section large enough to pause mid-download.
|
||||
const leb = (number) => { const bytes = []; do { const byte = number & 127; number >>>= 7; bytes.push(byte | (number ? 128 : 0)); } while (number); return bytes; };
|
||||
const padding = 256 * 1024;
|
||||
const wasm = Buffer.concat([Buffer.from([0, 97, 115, 109, 1, 0, 0, 0, 0, ...leb(padding), 0]), Buffer.alloc(padding - 1)]);
|
||||
const split = Math.floor(wasm.length / 2);
|
||||
const module = `export default async function({module_or_path}) {
|
||||
window.receivedResponse = module_or_path instanceof Response;
|
||||
await WebAssembly.instantiateStreaming(module_or_path);
|
||||
window.vibemakeCad = { ready: async () => {
|
||||
if (window.failFont) throw Object.assign(new Error('Font unavailable'), {code:'FONT_UNAVAILABLE'});
|
||||
await new Promise(resolve => { window.releaseReady = resolve; });
|
||||
return {};
|
||||
}};
|
||||
}`;
|
||||
const prefix = '/cad/_assets/progress-v1/';
|
||||
const manifest = { bridgeVersion: 1, buildId: 'progress-v1', js: prefix + 'engine.js', wasm: prefix + 'engine.wasm', chineseFont: prefix + 'font.otf',
|
||||
files: [{ path: prefix + 'engine.js', size: Buffer.byteLength(module) }, { path: prefix + 'engine.wasm', size: wasm.length }] };
|
||||
let releaseDownload, paused = true, failDownload = false, wasmRequests = 0;
|
||||
const html = `<!doctype html><script type="module">
|
||||
import {loadEngine} from '/js/cad/engine.js';
|
||||
window.beginLoad = () => {
|
||||
window.controller = new AbortController(); window.samples = []; window.engineReady = false; window.engineError = null;
|
||||
loadEngine({signal:controller.signal,onProgress:p=>samples.push(p)}).then(()=>{window.engineReady=true},error=>{window.engineError=typeof error.code==='string'?error.code:error.name});
|
||||
};
|
||||
window.harnessReady = true;
|
||||
</script>`;
|
||||
const server = createServer(async (req, res) => {
|
||||
const path = new URL(req.url, 'http://localhost').pathname;
|
||||
res.setHeader('Cache-Control', 'no-store');
|
||||
if (path === '/') res.writeHead(200, { 'Content-Type': 'text/html' }).end(html);
|
||||
else if (path === '/cad/engine.json') res.writeHead(200, { 'Content-Type': 'application/json' }).end(JSON.stringify(manifest));
|
||||
else if (path === manifest.js) res.writeHead(200, { 'Content-Type': 'text/javascript' }).end(module);
|
||||
else if (path === manifest.wasm) {
|
||||
wasmRequests++;
|
||||
if (failDownload) { res.writeHead(503).end(); return; }
|
||||
res.writeHead(200, { 'Content-Type': 'application/wasm', 'Content-Encoding': 'gzip' });
|
||||
const gzip = createGzip(); gzip.pipe(res);
|
||||
if (paused) { gzip.write(wasm.subarray(0, split)); gzip.flush(constants.Z_SYNC_FLUSH); releaseDownload = () => gzip.end(wasm.subarray(split)); }
|
||||
else gzip.end(wasm);
|
||||
} else if (path.startsWith('/js/')) {
|
||||
try { res.writeHead(200, { 'Content-Type': 'text/javascript' }).end(await readFile(new URL(path.slice(1), root))); }
|
||||
catch { res.writeHead(404).end(); }
|
||||
} else res.writeHead(404).end();
|
||||
});
|
||||
await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
|
||||
const browser = await chromium.launch({ headless: true });
|
||||
t.after(async () => { await browser.close(); server.closeAllConnections(); await new Promise((resolve) => server.close(resolve)); });
|
||||
const page = await browser.newPage();
|
||||
const openHarness = async () => { await page.goto(`http://127.0.0.1:${server.address().port}/`); await page.waitForFunction(() => window.harnessReady); };
|
||||
await openHarness();
|
||||
await page.evaluate(() => beginLoad());
|
||||
const partial = Buffer.byteLength(module) + split, total = Buffer.byteLength(module) + wasm.length;
|
||||
await page.waitForFunction((bytes) => samples.at(-1)?.loaded === bytes, partial);
|
||||
assert.equal(await page.evaluate(() => samples.at(-1).total), total);
|
||||
assert.equal(await page.evaluate(() => window.receivedResponse), true);
|
||||
await page.clock.install(); await page.clock.fastForward(12000);
|
||||
assert.equal(await page.evaluate(() => samples.at(-1).loaded), partial, 'elapsed time must not advance progress');
|
||||
await page.clock.resume();
|
||||
await page.evaluate(() => controller.abort());
|
||||
await page.waitForFunction(() => engineError === 'AbortError');
|
||||
const cancelledSamples = await page.evaluate(() => samples.length);
|
||||
releaseDownload();
|
||||
await page.waitForFunction(() => !!window.releaseReady);
|
||||
assert.equal(await page.evaluate(() => samples.length), cancelledSamples, 'cancelled progress observers must be detached');
|
||||
await page.evaluate(() => beginLoad());
|
||||
assert.deepEqual(await page.evaluate(() => samples.at(-1)), { phase: 'initialize', loaded: total, total });
|
||||
assert.equal(await page.evaluate(() => engineReady), false, 'download completion must still wait for fonts and the bridge');
|
||||
await page.evaluate(() => releaseReady());
|
||||
await page.waitForFunction(() => engineReady);
|
||||
assert.equal(wasmRequests, 1, 'retrying an opening must share its engine download');
|
||||
assert.equal(await page.evaluate(() => samples.at(-1).phase), 'ready');
|
||||
|
||||
// An HTTP failure is retryable and never reports successful initialization.
|
||||
await page.clock.resume();
|
||||
failDownload = true; paused = false;
|
||||
await openHarness(); await page.evaluate(() => beginLoad());
|
||||
await page.waitForFunction(() => engineError === 'ENGINE_MISSING');
|
||||
assert.equal(await page.evaluate(() => samples.some((p) => p.phase === 'ready')), false);
|
||||
failDownload = false;
|
||||
await page.evaluate(() => { window.failFont = true; beginLoad(); });
|
||||
await page.waitForFunction(() => engineError === 'FONT_UNAVAILABLE');
|
||||
const requestsBeforeFontRetry = wasmRequests;
|
||||
await page.evaluate(() => { window.failFont = false; window.releaseReady = null; beginLoad(); });
|
||||
await page.waitForFunction(() => !!window.releaseReady);
|
||||
await page.evaluate(() => releaseReady());
|
||||
await page.waitForFunction(() => engineReady);
|
||||
assert.equal(wasmRequests, requestsBeforeFontRetry, 'font retries must reuse initialized WASM');
|
||||
});
|
||||
|
||||
test('CAD engine updates complete without clearing browser data', async (t) => {
|
||||
let buildId = 'v1', legacy = false, workerUnavailable = false;
|
||||
const manifest = () => ({
|
||||
|
||||
@@ -43,6 +43,355 @@ async function until(page, predicate, message, timeoutMs = 30000) {
|
||||
throw new Error(`${message}: ${JSON.stringify(await chat(page)).slice(0, 2000)}`);
|
||||
}
|
||||
|
||||
async function modelRecoveryChecks(page, checks) {
|
||||
const endpoint = '**/api/cad/ai/chat';
|
||||
const event = (body, type, data, code = 'OK') => `event:${type}\ndata:${JSON.stringify({
|
||||
code, message: code, requestId: 'model-recovery-test',
|
||||
data: { documentSessionCode: body.documentSessionCode, turnCode: body.turnCode, ...data },
|
||||
})}\n\n`;
|
||||
const stream = (route, body) => route.fulfill({ status: 200, contentType: 'text/event-stream', body });
|
||||
const finish = (body, text) => event(body, 'completed', {
|
||||
finishReason: 'stop', output: [{ type: 'message', role: 'assistant', content: [{ type: 'text', text }] }], usage: null,
|
||||
});
|
||||
const error = (body, code, retryable) => event(body, 'error', { retryable }, code);
|
||||
const baseline = (await inspect(page)).bodies.length;
|
||||
await chat(page, { new_chat: true });
|
||||
const requests = [];
|
||||
const applied = { type: 'toolCall', callCode: 'recovery-applied', name: 'execute', arguments: {
|
||||
command: 'solid.box', params: { length: 2, width: 3, height: 4, body_name: 'RecoveryBox' },
|
||||
} };
|
||||
const ghost = { ...applied, callCode: 'recovery-never-applied' };
|
||||
await page.route(endpoint, async (route) => {
|
||||
const body = route.request().postDataJSON();
|
||||
requests.push(body);
|
||||
const step = requests.length;
|
||||
if (step === 1) return stream(route, event(body, 'tool_call', applied)
|
||||
+ event(body, 'completed', { finishReason: 'tool_calls', output: [applied], usage: null }));
|
||||
if (step === 2) {
|
||||
const before = (await page.evaluate(() => window.vibemakeCad.getState())).revision;
|
||||
await page.evaluate(() => window.solidcraft.execute('select.clear', {}));
|
||||
assert.notEqual((await page.evaluate(() => window.vibemakeCad.getState())).revision, before,
|
||||
'non-design selection changes exercise the host revision snapshot');
|
||||
return stream(route, event(body, 'text_delta', { text: 'DISCARDED_PARTIAL_RESPONSE' }) + event(body, 'tool_call', ghost));
|
||||
}
|
||||
if (step === 3) return stream(route, error(body, 'CAD_AI_PROVIDER_FAILURE', true));
|
||||
return stream(route, finish(body, 'RECOVERY_CONFIRMED'));
|
||||
});
|
||||
try {
|
||||
await chat(page, { send: 'Recover this task while keeping dimensions and applied geometry.', attach_view: false, attach_selection: false });
|
||||
const state = await until(page, (s) => !s.turn && s.items.some((i) => i.agent === 'RECOVERY_CONFIRMED'), 'temporary failures did not recover');
|
||||
assert.equal(requests.length, 4, 'one successful CAD step, two failed model attempts and one recovered response');
|
||||
assert.deepEqual(requests[2], requests[1]);
|
||||
assert.deepEqual(requests[3], requests[1], 'all retry input including history and runtime context is frozen');
|
||||
assert.ok(requests[1].history.some((i) => i.type === 'toolResult' && i.callCode === applied.callCode));
|
||||
assert.equal((await inspect(page)).bodies.length, baseline + 1, 'the already-applied box is never replayed');
|
||||
assert.equal(state.items.filter((i) => i.title === 'execute').length, 1, 'failed attempts leave no pending tool cards');
|
||||
assert.ok(!state.items.some((i) => i.agent?.includes('DISCARDED_PARTIAL_RESPONSE')));
|
||||
assert.ok(!state.items.some((i) => i.error));
|
||||
assert.equal(state.items.filter((i) => i.notice?.includes('正在恢复当前任务')).length, 2,
|
||||
'asynchronous recovery notices keep the current UI language');
|
||||
checks.push('model-recovery-preserves-full-request-applied-geometry-and-one-confirmed-response');
|
||||
if (process.env.VM_CAD_SCREENSHOT) await page.screenshot({ path: process.env.VM_CAD_SCREENSHOT.replace(/\.png$/, '-recovery.png') });
|
||||
await chat(page, { undo: true });
|
||||
assert.equal((await inspect(page)).bodies.length, baseline, 'recovered task stays one undo step');
|
||||
} finally { await page.unroute(endpoint); }
|
||||
|
||||
// A rejected model response never ran its announced tools. Only its diagnostic
|
||||
// is added to the next request; completed CAD calls stay in the original history.
|
||||
await chat(page, { new_chat: true });
|
||||
const protocolRequests = [];
|
||||
const firstProtocolCall = { ...applied, callCode: 'protocol-already-applied', arguments: {
|
||||
command: 'solid.box', params: { length: 2, width: 3, height: 4, body_name: 'ProtocolExistingBox' },
|
||||
} };
|
||||
const correctedProtocolCall = { ...applied, callCode: 'protocol-corrected', arguments: {
|
||||
command: 'solid.box', params: { length: 2, width: 3, height: 5, body_name: 'ProtocolCorrectedBox' },
|
||||
} };
|
||||
const rejectedProtocolCall = { ...applied, callCode: 'protocol-never-applied' };
|
||||
const correction = { tool: 'execute', rule: 'required', path: '$.params' };
|
||||
const toolCompletion = (body, calls) => calls.map((call) => event(body, 'tool_call', call)).join('')
|
||||
+ event(body, 'completed', { finishReason: 'tool_calls', output: calls, usage: null });
|
||||
const withoutCorrection = (body) => {
|
||||
const copy = structuredClone(body);
|
||||
delete copy.context.modelRecovery;
|
||||
return copy;
|
||||
};
|
||||
await page.route(endpoint, async (route) => {
|
||||
const body = route.request().postDataJSON();
|
||||
protocolRequests.push(body);
|
||||
if (protocolRequests.length === 1) return stream(route, toolCompletion(body, [firstProtocolCall]));
|
||||
if (protocolRequests.length === 2) return stream(route,
|
||||
event(body, 'text_delta', { text: 'PROTOCOL_DISCARDED_PARTIAL' })
|
||||
+ event(body, 'tool_call', rejectedProtocolCall)
|
||||
+ event(body, 'error', { retryable: true, correction }, 'CAD_AI_INVALID_MODEL_TOOL'));
|
||||
if (protocolRequests.length === 3) return stream(route, toolCompletion(body, [correctedProtocolCall]));
|
||||
return stream(route, finish(body, 'PROTOCOL_RECOVERY_CONFIRMED'));
|
||||
});
|
||||
try {
|
||||
await chat(page, { send: 'Continue this task after correcting invalid tool parameters, retaining every dimension.',
|
||||
attach_view: false, attach_selection: false });
|
||||
const state = await until(page, (s) => !s.turn && s.items.some((i) => i.agent === 'PROTOCOL_RECOVERY_CONFIRMED'),
|
||||
'model tool protocol error did not recover');
|
||||
assert.equal(protocolRequests.length, 4, 'completed step, rejected response, corrected step, final completion');
|
||||
assert.deepEqual(protocolRequests[2].context.modelRecovery, correction, 'exact safe validator feedback reaches the retry');
|
||||
assert.deepEqual(withoutCorrection(protocolRequests[2]), protocolRequests[1],
|
||||
'correction preserves the full history, model inputs and host document revision');
|
||||
assert.ok(protocolRequests[1].history.some((item) => item.type === 'toolResult' && item.callCode === firstProtocolCall.callCode));
|
||||
assert.equal(protocolRequests[3].context.modelRecovery, undefined, 'successful correction does not leak into the next model step');
|
||||
assert.ok(!protocolRequests[3].history.some((item) => item.callCode === rejectedProtocolCall.callCode));
|
||||
assert.equal((await inspect(page)).bodies.length, baseline + 2, 'each confirmed CAD step executes exactly once');
|
||||
assert.equal(state.items.filter((item) => item.title === 'execute').length, 2, 'the rejected attempt leaves no phantom tool card');
|
||||
assert.ok(!state.items.some((item) => item.agent?.includes('PROTOCOL_DISCARDED_PARTIAL')));
|
||||
assert.ok(!state.items.some((item) => item.error));
|
||||
assert.equal(state.items.filter((item) => item.notice && !item.error).length, 1, 'correction keeps the same task active');
|
||||
checks.push('model-protocol-recovery-preserves-inputs-applied-geometry-and-corrects-only-the-rejected-step');
|
||||
if (process.env.VM_CAD_SCREENSHOT) await page.screenshot({ path: process.env.VM_CAD_SCREENSHOT.replace(/\.png$/, '-protocol-recovery.png') });
|
||||
await chat(page, { undo: true });
|
||||
assert.equal((await inspect(page)).bodies.length, baseline, 'all confirmed steps in the recovered task remain one undo step');
|
||||
} finally { await page.unroute(endpoint); }
|
||||
|
||||
for (const scenario of ['legacy-tool', 'local-arguments', 'duplicate-call-code', 'completed-mismatch', 'completed-text', 'completed-output']) {
|
||||
await chat(page, { new_chat: true });
|
||||
const attempts = [];
|
||||
await page.route(endpoint, async (route) => {
|
||||
const body = route.request().postDataJSON();
|
||||
attempts.push(body);
|
||||
if (attempts.length > 1) return stream(route, finish(body, 'PROTOCOL_EDGE_RECOVERY_CONFIRMED'));
|
||||
if (scenario === 'legacy-tool') return stream(route, event(body, 'error', {}, 'CAD_AI_INVALID_MODEL_TOOL'));
|
||||
if (scenario === 'local-arguments') return stream(route, toolCompletion(body, [rejectedProtocolCall,
|
||||
{ ...correctedProtocolCall, arguments: { command: 17, params: {} } }]));
|
||||
if (scenario === 'duplicate-call-code') return stream(route, toolCompletion(body, [rejectedProtocolCall, rejectedProtocolCall]));
|
||||
if (scenario === 'completed-mismatch') return stream(route, event(body, 'tool_call', rejectedProtocolCall)
|
||||
+ event(body, 'completed', { finishReason: 'tool_calls', output: [correctedProtocolCall], usage: null }));
|
||||
if (scenario === 'completed-text') return stream(route, event(body, 'text_delta', { text: 'PROTOCOL_DISCARDED_PARTIAL' })
|
||||
+ finish(body, 'UNCONFIRMED_DIFFERENT_TEXT'));
|
||||
return stream(route, event(body, 'completed', { finishReason: 'tool_calls',
|
||||
output: [{ ...rejectedProtocolCall, arguments: [] }], usage: null }));
|
||||
});
|
||||
try {
|
||||
await chat(page, { send: `Recover ${scenario} without executing unconfirmed calls.`, attach_view: false, attach_selection: false });
|
||||
const state = await until(page, (s) => !s.turn && s.items.some((i) => i.agent === 'PROTOCOL_EDGE_RECOVERY_CONFIRMED'),
|
||||
`${scenario} was not corrected`);
|
||||
assert.equal(attempts.length, 2, `${scenario} retries only the rejected model response`);
|
||||
assert.deepEqual(withoutCorrection(attempts[1]), attempts[0], `${scenario} retains every original input`);
|
||||
assert.ok(attempts[1].context.modelRecovery?.rule, `${scenario} sends bounded correction data`);
|
||||
if (scenario === 'legacy-tool') assert.deepEqual(attempts[1].context.modelRecovery,
|
||||
{ tool: 'unknown', rule: 'invalid_tool', path: '$' }, 'older backends still receive safe correction guidance');
|
||||
assert.equal((await inspect(page)).bodies.length, baseline, `${scenario} cannot run a tool from the rejected response`);
|
||||
assert.equal(state.items.filter((item) => item.title).length, 0, `${scenario} cannot leave an unexecuted tool card`);
|
||||
assert.ok(!state.items.some((item) => item.error || item.agent?.includes('PROTOCOL_DISCARDED_PARTIAL')
|
||||
|| item.agent?.includes('UNCONFIRMED_DIFFERENT_TEXT')));
|
||||
checks.push(`model-protocol-recovery-${scenario}-regenerates-before-any-tool-executes`);
|
||||
} finally { await page.unroute(endpoint); }
|
||||
}
|
||||
|
||||
await chat(page, { new_chat: true });
|
||||
const reusedRequests = [];
|
||||
await page.route(endpoint, async (route) => {
|
||||
const body = route.request().postDataJSON();
|
||||
reusedRequests.push(body);
|
||||
if (reusedRequests.length <= 2) return stream(route, toolCompletion(body, [firstProtocolCall]));
|
||||
return stream(route, finish(body, 'REUSED_CALL_RECOVERY_CONFIRMED'));
|
||||
});
|
||||
try {
|
||||
await chat(page, { send: 'Recover a reused call code without repeating the completed operation.', attach_view: false, attach_selection: false });
|
||||
const state = await until(page, (s) => !s.turn && s.items.some((i) => i.agent === 'REUSED_CALL_RECOVERY_CONFIRMED'),
|
||||
'reused call code did not trigger model correction');
|
||||
assert.equal(reusedRequests.length, 3);
|
||||
assert.deepEqual(withoutCorrection(reusedRequests[2]), reusedRequests[1]);
|
||||
assert.ok(reusedRequests[2].context.modelRecovery?.rule);
|
||||
assert.equal((await inspect(page)).bodies.length, baseline + 1, 'a repeated call code cannot replay the first operation');
|
||||
assert.equal(state.items.filter((item) => item.title === 'execute').length, 1);
|
||||
assert.ok(!state.items.some((item) => item.error));
|
||||
checks.push('model-protocol-recovery-reused-call-code-preserves-the-original-operation-once');
|
||||
await chat(page, { undo: true });
|
||||
assert.equal((await inspect(page)).bodies.length, baseline);
|
||||
} finally { await page.unroute(endpoint); }
|
||||
|
||||
for (const scenario of ['exhausted', 'disabled', 'stop']) {
|
||||
await chat(page, { new_chat: true });
|
||||
if (scenario === 'disabled') await page.evaluate(() => window.solidcraft.request('ui.prefs', { agent_model_recovery: false }));
|
||||
let attempts = 0;
|
||||
await page.route(endpoint, async (route) => {
|
||||
const body = route.request().postDataJSON();
|
||||
attempts++;
|
||||
return stream(route, event(body, 'error', { retryable: true, correction }, 'CAD_AI_INVALID_MODEL_TOOL'));
|
||||
});
|
||||
try {
|
||||
await chat(page, { send: `Check protocol correction ${scenario}.`, attach_view: false, attach_selection: false });
|
||||
if (scenario === 'stop') {
|
||||
await until(page, (s) => s.turn && s.items.some((item) => item.notice && !item.error), 'protocol correction did not remain active');
|
||||
await chat(page, { cancel: true });
|
||||
await until(page, (s) => !s.turn, 'Stop did not cancel protocol correction');
|
||||
await page.waitForTimeout(1200);
|
||||
} else {
|
||||
const state = await until(page, (s) => !s.turn && s.state === 'ready', `${scenario} protocol task did not finish`);
|
||||
assert.ok(state.items.some((item) => item.error), 'unrecovered invalid tools still report the error');
|
||||
}
|
||||
assert.equal(attempts, scenario === 'exhausted' ? 3 : 1, `${scenario} applies the existing retry budget and controls`);
|
||||
assert.equal((await inspect(page)).bodies.length, baseline);
|
||||
checks.push(`model-protocol-recovery-${scenario}-respects-task-controls`);
|
||||
} finally {
|
||||
await page.unroute(endpoint);
|
||||
if (scenario === 'disabled') await page.evaluate(() => window.solidcraft.request('ui.prefs', { agent_model_recovery: true }));
|
||||
}
|
||||
}
|
||||
|
||||
for (const scenario of ['permanent', 'legacy', 'stale', 'exhausted', 'timeout', 'http', 'disabled', 'stop', 'edited']) {
|
||||
await chat(page, { new_chat: true });
|
||||
if (scenario === 'disabled') await page.evaluate(() => window.solidcraft.request('ui.prefs', { agent_model_recovery: false }));
|
||||
let attempts = 0;
|
||||
await page.route(endpoint, async (route) => {
|
||||
const body = route.request().postDataJSON();
|
||||
attempts++;
|
||||
if (['timeout', 'http'].includes(scenario) && attempts > 1) return stream(route, finish(body, 'RECOVERY_CONFIRMED'));
|
||||
if (scenario === 'permanent') return stream(route, error(body, 'CAD_AI_OUTPUT_LIMIT', true));
|
||||
if (scenario === 'legacy') return stream(route, error(body, 'CAD_AI_PROVIDER_FAILURE', false));
|
||||
if (scenario === 'stale') return stream(route, error({ ...body, turnCode: 'another-turn' }, 'CAD_AI_PROVIDER_FAILURE', true));
|
||||
if (scenario === 'timeout') return stream(route, error(body, 'CAD_AI_TIMEOUT', true));
|
||||
if (scenario === 'http') return route.fulfill({ status: 502, contentType: 'text/plain', body: 'temporary gateway failure' });
|
||||
return stream(route, error(body, 'CAD_AI_PROVIDER_FAILURE', true));
|
||||
});
|
||||
try {
|
||||
await chat(page, { send: `Check ${scenario} recovery.`, attach_view: false, attach_selection: false });
|
||||
if (scenario === 'stop' || scenario === 'edited') {
|
||||
await until(page, (s) => s.turn && s.items.some((i) => i.notice && !i.error), 'retry did not keep the task active');
|
||||
if (scenario === 'edited') {
|
||||
await page.evaluate(() => window.solidcraft.execute('solid.box', { length: 1, width: 2, height: 3, body_name: 'HumanEditDuringRecovery' }));
|
||||
} else {
|
||||
await chat(page, { cancel: true });
|
||||
}
|
||||
await until(page, (s) => !s.turn, 'Stop did not cancel recovery');
|
||||
await page.waitForTimeout(1200);
|
||||
} else {
|
||||
await until(page, (s) => !s.turn && s.state === 'ready', `${scenario} task did not finish`);
|
||||
}
|
||||
const expected = scenario === 'exhausted' ? 3 : ['timeout', 'http'].includes(scenario) ? 2 : 1;
|
||||
assert.equal(attempts, expected, `${scenario} retry count`);
|
||||
if (scenario === 'edited') {
|
||||
assert.equal((await inspect(page)).bodies.length, baseline + 1, 'manual edits are kept when they cancel recovery');
|
||||
await page.evaluate(() => window.solidcraft.execute('edit.undo', {}));
|
||||
}
|
||||
assert.equal((await inspect(page)).bodies.length, baseline, `${scenario} cannot change geometry`);
|
||||
checks.push(`model-recovery-${scenario}-respects-request-boundaries`);
|
||||
} finally {
|
||||
await page.unroute(endpoint);
|
||||
if (scenario === 'disabled') await page.evaluate(() => window.solidcraft.request('ui.prefs', { agent_model_recovery: true }));
|
||||
}
|
||||
}
|
||||
|
||||
// A late result from a cancelled request must not clear the next turn's abort slot.
|
||||
await chat(page, { new_chat: true });
|
||||
await page.evaluate(() => {
|
||||
window.recoveryOriginalChat = window.__VIBEMAKE_CAD__.agentChat;
|
||||
window.recoveryPending = [];
|
||||
window.__VIBEMAKE_CAD__.agentChat = (body, signal, onStart) => {
|
||||
onStart();
|
||||
return new Promise((resolve) => window.recoveryPending.push({ body, signal, resolve }));
|
||||
};
|
||||
});
|
||||
try {
|
||||
await chat(page, { send: 'First delayed response', attach_view: false, attach_selection: false });
|
||||
await page.waitForFunction(() => window.recoveryPending.length === 1);
|
||||
await chat(page, { cancel: true });
|
||||
await until(page, (s) => !s.turn, 'first delayed response did not cancel');
|
||||
await chat(page, { send: 'Second delayed response', attach_view: false, attach_selection: false });
|
||||
await page.waitForFunction(() => window.recoveryPending.length === 2);
|
||||
await page.evaluate(() => window.recoveryPending[0].resolve(new Response('', { headers: { 'Content-Type': 'text/event-stream' } })));
|
||||
await page.waitForTimeout(100);
|
||||
assert.ok((await chat(page)).turn, 'the late result cannot end the newer turn');
|
||||
await chat(page, { cancel: true });
|
||||
await until(page, (s) => !s.turn, 'newer request did not cancel');
|
||||
assert.equal(await page.evaluate(() => window.recoveryPending[1].signal.aborted), true,
|
||||
'the newer controller remains reachable after old-request cleanup');
|
||||
checks.push('model-recovery-late-old-response-cannot-detach-new-turn-cancellation');
|
||||
} finally {
|
||||
await page.evaluate(() => {
|
||||
window.__VIBEMAKE_CAD__.agentChat = window.recoveryOriginalChat;
|
||||
for (const request of window.recoveryPending) request.resolve(new Response(''));
|
||||
delete window.recoveryOriginalChat;
|
||||
delete window.recoveryPending;
|
||||
});
|
||||
}
|
||||
|
||||
await chat(page, { new_chat: true });
|
||||
await page.evaluate(() => {
|
||||
window.recoveryOriginalChat = window.__VIBEMAKE_CAD__.agentChat;
|
||||
window.recoverySignals = [];
|
||||
window.__VIBEMAKE_CAD__.agentChat = (body, signal, onStart) => {
|
||||
onStart();
|
||||
window.recoverySignals.push(signal);
|
||||
if (window.recoverySignals.length === 1) return Promise.reject(new TypeError('temporary network interruption'));
|
||||
return new Promise((resolve) => { window.recoveryResolve = resolve; });
|
||||
};
|
||||
});
|
||||
try {
|
||||
await chat(page, { send: 'Check fresh request cancellation', attach_view: false, attach_selection: false });
|
||||
await page.waitForFunction(() => window.recoverySignals.length === 2);
|
||||
assert.deepEqual(await page.evaluate(() => window.recoverySignals.map((signal) => signal.aborted)), [true, false]);
|
||||
await chat(page, { cancel: true });
|
||||
await until(page, (s) => !s.turn, 'retried request did not cancel');
|
||||
assert.deepEqual(await page.evaluate(() => window.recoverySignals.map((signal) => signal.aborted)), [true, true]);
|
||||
checks.push('model-recovery-creates-fresh-abort-signal-for-each-attempt');
|
||||
} finally {
|
||||
await page.evaluate(() => {
|
||||
window.__VIBEMAKE_CAD__.agentChat = window.recoveryOriginalChat;
|
||||
window.recoveryResolve?.(new Response(''));
|
||||
delete window.recoveryOriginalChat;
|
||||
delete window.recoverySignals;
|
||||
delete window.recoveryResolve;
|
||||
});
|
||||
}
|
||||
|
||||
// Shorten only the model deadline so the real WASM timeout callback is exercised.
|
||||
await chat(page, { new_chat: true });
|
||||
await page.evaluate(() => {
|
||||
window.recoveryOriginalChat = window.__VIBEMAKE_CAD__.agentChat;
|
||||
window.recoverySetTimeout = window.setTimeout;
|
||||
window.recoveryTimers = [];
|
||||
window.recoveryTimerFires = 0;
|
||||
window.recoveryTimerRequests = 0;
|
||||
window.setTimeout = (callback, ms, ...args) => {
|
||||
if (ms !== 60000) return window.recoverySetTimeout.call(window, callback, ms, ...args);
|
||||
const id = window.recoverySetTimeout.call(window, () => {
|
||||
window.recoveryTimerFires++;
|
||||
callback(...args);
|
||||
}, 75);
|
||||
window.recoveryTimers.push(id);
|
||||
return id;
|
||||
};
|
||||
window.__VIBEMAKE_CAD__.agentChat = (body, signal, onStart) => {
|
||||
onStart();
|
||||
if (++window.recoveryTimerRequests === 1) return new Promise((resolve, reject) => {
|
||||
signal.addEventListener('abort', () => reject(new DOMException('Aborted', 'AbortError')), { once: true });
|
||||
});
|
||||
const data = { documentSessionCode: body.documentSessionCode, turnCode: body.turnCode, finishReason: 'stop',
|
||||
output: [{ type: 'message', role: 'assistant', content: [{ type: 'text', text: 'TIMER_RECOVERY_CONFIRMED' }] }] };
|
||||
return Promise.resolve(new Response(`event:completed\ndata:${JSON.stringify({ code: 'OK', requestId: 'timer-test', data })}\n\n`,
|
||||
{ headers: { 'Content-Type': 'text/event-stream' } }));
|
||||
};
|
||||
});
|
||||
try {
|
||||
await chat(page, { send: 'Recover from the actual model deadline', attach_view: false, attach_selection: false });
|
||||
await until(page, (s) => !s.turn && s.items.some((i) => i.agent === 'TIMER_RECOVERY_CONFIRMED'), 'local request timeout did not recover');
|
||||
await page.waitForTimeout(125);
|
||||
assert.deepEqual(await page.evaluate(() => ({ attempts: window.recoveryTimerRequests, arms: window.recoveryTimers.length,
|
||||
unique: new Set(window.recoveryTimers).size, fires: window.recoveryTimerFires })),
|
||||
{ attempts: 2, arms: 2, unique: 2, fires: 1 }, 'each attempt arms a fresh timer and successful cleanup clears its timer');
|
||||
checks.push('model-recovery-real-local-timeout-rearms-and-cleans-up-each-deadline');
|
||||
} finally {
|
||||
await page.evaluate(() => {
|
||||
window.__VIBEMAKE_CAD__.agentChat = window.recoveryOriginalChat;
|
||||
window.setTimeout = window.recoverySetTimeout;
|
||||
for (const id of window.recoveryTimers) clearTimeout(id);
|
||||
delete window.recoveryOriginalChat;
|
||||
delete window.recoverySetTimeout;
|
||||
delete window.recoveryTimers;
|
||||
delete window.recoveryTimerFires;
|
||||
delete window.recoveryTimerRequests;
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
async function run(browser) {
|
||||
const checks = [], errors = [];
|
||||
const project = await (await fetch(`${base}/api/cad/workspace/projects`, {
|
||||
@@ -144,6 +493,95 @@ async function run(browser) {
|
||||
await page.evaluate(() => window.solidcraft.request('ui.prefs', { button: 'cancel' }));
|
||||
checks.push('platform-preferences-hide-local-assistant-configuration');
|
||||
|
||||
assert.equal((await chat(page, { permissions: 'ask' })).permissions, 'all', 'legacy permissions cannot reintroduce approval prompts');
|
||||
const composerHandles = await page.evaluate(() => window.solidcraft.request('ui.handles', { prefix: 'agent_chat:' }));
|
||||
assert.ok(composerHandles.some((handle) => handle.name === 'agent_chat:attachment'));
|
||||
for (const removed of ['add', 'add_file', 'paste_picture', 'upload_attachment', 'permissions']) {
|
||||
assert.ok(!composerHandles.some((handle) => handle.name === `agent_chat:${removed}`), `no obsolete ${removed} action`);
|
||||
}
|
||||
const pictureBase64 = await page.evaluate(() => {
|
||||
const canvas = document.createElement('canvas'); canvas.width = 160; canvas.height = 90;
|
||||
const paint = canvas.getContext('2d');
|
||||
paint.fillStyle = '#d9e2eb'; paint.fillRect(0, 0, 160, 90);
|
||||
paint.fillStyle = '#337db1'; paint.fillRect(30, 20, 22, 50); paint.fillRect(30, 55, 100, 15);
|
||||
return canvas.toDataURL('image/png').split(',')[1];
|
||||
});
|
||||
async function paste({ text = '', image = false, name = 'pasted-reference.png', outside = false } = {}) {
|
||||
await page.evaluate(({ text, image, name, outside, pictureBase64 }) => {
|
||||
const data = new DataTransfer();
|
||||
if (text) data.setData('text/plain', text);
|
||||
if (image) data.items.add(new File([Uint8Array.from(atob(pictureBase64), (c) => c.charCodeAt(0))], name, { type: 'image/png' }));
|
||||
let target = document.activeElement;
|
||||
if (outside) { target = document.createElement('input'); target.id = 'clipboard-test-outside'; document.body.append(target); target.focus(); }
|
||||
target.dispatchEvent(new ClipboardEvent('paste', { clipboardData: data, bubbles: true, cancelable: true }));
|
||||
}, { text, image, name, outside, pictureBase64 });
|
||||
}
|
||||
await page.bringToFront();
|
||||
await clickHandle(page, 'agent_chat:input');
|
||||
await page.keyboard.type('vm-test:read ', { delay: 20 });
|
||||
await paste({ text: '剪贴板文字' });
|
||||
await page.waitForTimeout(200);
|
||||
await page.evaluate(() => {
|
||||
window.__composerArrayBuffer = File.prototype.arrayBuffer;
|
||||
File.prototype.arrayBuffer = async function () {
|
||||
await new Promise((resolve) => setTimeout(resolve, 1500));
|
||||
return window.__composerArrayBuffer.call(this);
|
||||
};
|
||||
});
|
||||
await paste({ image: true });
|
||||
await page.waitForTimeout(150);
|
||||
await page.keyboard.press('ControlOrMeta+Enter');
|
||||
await page.waitForTimeout(250);
|
||||
assert.ok(!(await chat(page)).items.some((item) => item.user), 'sending waits for pasted image bytes');
|
||||
await until(page, (state) => state.attachments?.includes('pasted-reference.png'), 'image paste did not attach');
|
||||
await page.evaluate(() => { File.prototype.arrayBuffer = window.__composerArrayBuffer; delete window.__composerArrayBuffer; });
|
||||
await paste({ image: true, text: '和图片', name: 'mixed-reference.png' });
|
||||
await until(page, (state) => state.attachments?.length === 2, 'mixed text and image paste did not attach');
|
||||
await paste({ image: true, outside: true, name: 'outside.png' });
|
||||
await page.waitForTimeout(350);
|
||||
assert.equal((await chat(page)).attachments.length, 2, 'pasting outside the composer cannot attach a file');
|
||||
await page.evaluate(() => document.querySelector('#clipboard-test-outside')?.remove());
|
||||
const chooser = page.waitForEvent('filechooser');
|
||||
await clickHandle(page, 'agent_chat:attachment');
|
||||
await (await chooser).setFiles({ name: 'requirements.txt', mimeType: 'text/plain', buffer: Buffer.from('bracket requirement: thickness 1.5 mm') });
|
||||
await until(page, (state) => state.attachments?.length === 3 && state.loading?.length === 0, 'paperclip did not open the attachment picker');
|
||||
if (process.env.VM_CAD_SCREENSHOT) await page.screenshot({ path: process.env.VM_CAD_SCREENSHOT.replace(/\.png$/, '-composer.png') });
|
||||
await chat(page, { remove_file: 0 });
|
||||
assert.deepEqual((await chat(page)).attachments, ['mixed-reference.png', 'requirements.txt']);
|
||||
await clickHandle(page, 'agent_chat:input');
|
||||
await page.keyboard.press('Enter');
|
||||
const pasted = await until(page, (state) => !state.turn && state.items.some((item) => item.user), 'pasted prompt did not finish');
|
||||
assert.equal(pasted.items.find((item) => item.user).user, 'vm-test:read 剪贴板文字和图片');
|
||||
const pasteCall = (await agentCalls()).find((call) => call.path === '/cad/ai/chat' && call.body?.cadProjectCode === project.data.cadProjectCode
|
||||
&& call.body.history.some((item) => item.role === 'user' && item.content?.some((part) => part.text?.includes('剪贴板文字和图片'))));
|
||||
assert.ok(pasteCall?.body.history.some((item) => item.content?.some((part) => part.type === 'image')), 'pasted image reaches the model request');
|
||||
assert.ok(pasteCall?.body.history.some((item) => item.content?.some((part) => part.text?.includes('bracket requirement: thickness 1.5 mm'))), 'uploaded text reaches the same model request');
|
||||
checks.push('single-paperclip-uploads-files-and-direct-paste-retains-text-images-and-removal');
|
||||
checks.push('send-shortcut-waits-for-pasted-image-bytes-without-losing-the-prompt');
|
||||
checks.push('paste-outside-composer-does-not-attach-or-read-the-clipboard');
|
||||
|
||||
await chat(page, { new_chat: true });
|
||||
let release;
|
||||
const held = new Promise((resolve) => { release = resolve; });
|
||||
const holdChat = async (route) => { await held; await route.continue().catch(() => {}); };
|
||||
await page.route('**/api/cad/ai/chat', holdChat);
|
||||
try {
|
||||
await chat(page, { send: 'vm-test:read composer busy state', attach_view: false, attach_selection: false });
|
||||
await until(page, (state) => !!state.turn, 'turn did not start');
|
||||
await page.waitForFunction(async () => (await window.solidcraft.request('ui.handles', { prefix: 'agent_chat:stopturn' })).length === 1);
|
||||
const busyHandles = await page.evaluate(() => window.solidcraft.request('ui.handles', { prefix: 'agent_chat:' }));
|
||||
assert.ok(!busyHandles.some((handle) => handle.name === 'agent_chat:send'), 'queue button is absent while busy');
|
||||
assert.ok(!busyHandles.some((handle) => handle.name === 'agent_chat:permissions'));
|
||||
await clickHandle(page, 'agent_chat:stopturn');
|
||||
await until(page, (state) => !state.turn, 'stop button did not cancel');
|
||||
} finally { release(); await page.unroute('**/api/cad/ai/chat', holdChat); }
|
||||
checks.push('busy-composer-has-stop-without-queue-or-permission-controls');
|
||||
await chat(page, { new_chat: true });
|
||||
if (process.env.VM_CAD_AGENT_BROWSER_SUITE === 'composer') {
|
||||
assert.deepEqual(errors, []);
|
||||
return { checks, errors, url: page.url() };
|
||||
}
|
||||
|
||||
// Real browser IME events: the hidden text bridge must retain its native caret after
|
||||
// each commit, while the visible egui editor still supports insertion in the middle.
|
||||
await page.bringToFront();
|
||||
@@ -222,6 +660,12 @@ async function run(browser) {
|
||||
assert.equal((await inspect(page)).bodies[0].name, 'PlatformAIBox');
|
||||
checks.push('fragmented-sse-and-completed-output-authorize-tool-execution');
|
||||
|
||||
await modelRecoveryChecks(page, checks);
|
||||
if (process.env.VM_CAD_RECOVERY_ONLY) {
|
||||
assert.deepEqual(errors, []);
|
||||
return { checks, errors, url: page.url() };
|
||||
}
|
||||
|
||||
await chat(page, { new_chat: true });
|
||||
await chat(page, { send: 'vm-test:truncated', attach_view: false, attach_selection: false });
|
||||
await until(page, (state) => !state.turn && state.state === 'ready', 'truncated stream did not stop', 30000);
|
||||
|
||||
@@ -0,0 +1,97 @@
|
||||
import test from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { createServer } from 'node:http';
|
||||
import { readFile } from 'node:fs/promises';
|
||||
import { chromium } from 'playwright';
|
||||
|
||||
const triangle = 'solid test\nfacet normal 0 0 1\nouter loop\nvertex 0 0 0\nvertex 1 0 0\nvertex 0 1 0\nendloop\nendfacet\nendsolid test';
|
||||
const png = Buffer.from('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+aGasAAAAASUVORK5CYII=', 'base64');
|
||||
const root = new URL('../', import.meta.url);
|
||||
|
||||
test('uploaded URDFs load through the real viewer and URDFLoader', async (t) => {
|
||||
const assets = new Map();
|
||||
const requests = [];
|
||||
const server = createServer(async (req, res) => {
|
||||
const path = new URL(req.url, 'http://localhost').pathname;
|
||||
if (path === '/') {
|
||||
res.writeHead(200, { 'Content-Type': 'text/html' }).end(`<!doctype html><script type="importmap">{"imports":{
|
||||
"three":"/vendor/three/build/three.module.min.js",
|
||||
"three/addons/":"/vendor/three/examples/jsm/",
|
||||
"three/examples/jsm/":"/vendor/three/examples/jsm/",
|
||||
"urdf-loader":"/vendor/urdf-loader/src/URDFLoader.js",
|
||||
"urdf-loader/src/":"/vendor/urdf-loader/src/"
|
||||
}}</script>`);
|
||||
return;
|
||||
}
|
||||
if (path.startsWith('/uploads/')) {
|
||||
requests.push(path);
|
||||
const asset = assets.get(path);
|
||||
if (asset) res.writeHead(200, { 'Content-Type': asset.type }).end(asset.body);
|
||||
else res.writeHead(404).end();
|
||||
return;
|
||||
}
|
||||
try {
|
||||
const file = new URL(`.${path}`, root);
|
||||
if (!file.href.startsWith(root.href)) throw new Error('outside fixture');
|
||||
const body = await readFile(file);
|
||||
res.writeHead(200, { 'Content-Type': path.endsWith('.js') ? 'text/javascript' : 'application/octet-stream' }).end(body);
|
||||
} catch { res.writeHead(404).end(); }
|
||||
});
|
||||
await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
|
||||
const origin = `http://127.0.0.1:${server.address().port}`;
|
||||
const browser = await chromium.launch({ headless: true });
|
||||
t.after(async () => {
|
||||
await browser.close(); server.closeAllConnections();
|
||||
await new Promise((resolve) => server.close(resolve));
|
||||
});
|
||||
const page = await browser.newPage();
|
||||
await page.goto(origin);
|
||||
const add = (path, body, type = 'application/xml') => assets.set(path, { body, type });
|
||||
const load = (main) => page.evaluate(async ({ main, origin }) => {
|
||||
const { ensureRobot } = await import('/js/source.js');
|
||||
const { RobotViewer } = await import('/js/viewer.js');
|
||||
const config = await ensureRobot({ code: 'fixture', name: 'Fixture', urdfMainUrl: origin + main, urdfBaseUrl: origin + '/uploads/batch/' });
|
||||
// build() performs the complete production fetch/parse/material pipeline;
|
||||
// scene rendering and WebGL are independent of resource path resolution.
|
||||
const viewer = Object.create(RobotViewer.prototype);
|
||||
viewer.pendingBuilds = new Set(); viewer.opts = {};
|
||||
viewer.environmentReady = Promise.resolve();
|
||||
const robot = await viewer.build(config);
|
||||
let meshes = 0;
|
||||
robot.traverse((node) => { if (node.isMesh && node.geometry.attributes.position.count > 0) meshes++; });
|
||||
window.fixtureRobot = robot;
|
||||
return { meshes, links: Object.keys(robot.links).length };
|
||||
}, { main, origin });
|
||||
|
||||
await t.test('AlexBot layout loads all 11 nested package meshes without a 404', async () => {
|
||||
const names = ['base_link', ...Array.from({ length: 5 }, (_, i) => `leftlink${i + 1}`), ...Array.from({ length: 5 }, (_, i) => `rightlink${i + 1}`)];
|
||||
const links = names.map((name) => `<link name="${name}"><visual><geometry><mesh filename="package://Alexbot_simple_urdf/meshes/${name}.STL"/></geometry></visual></link>`);
|
||||
const joints = names.slice(1).map((name) => `<joint name="${name}_joint" type="fixed"><parent link="base_link"/><child link="${name}"/></joint>`);
|
||||
const main = '/uploads/batch/urdf_pkg/Alexbot_simple_urdf/urdf/robot.urdf';
|
||||
add(main, `<robot name="AlexBot">${links.join('')}${joints.join('')}</robot>`);
|
||||
for (const name of names) add(`/uploads/batch/urdf_pkg/Alexbot_simple_urdf/meshes/${name}.STL`, triangle);
|
||||
requests.length = 0;
|
||||
assert.deepEqual(await load(main), { meshes: 11, links: 11 });
|
||||
assert.equal(requests.length, 12);
|
||||
assert.ok(requests.every((path) => assets.has(path)));
|
||||
});
|
||||
|
||||
await t.test('legacy flattened meshes and nested package textures still load', async () => {
|
||||
const main = '/uploads/batch/urdf_pkg/Alexbot_simple_urdf/urdf/textured.urdf';
|
||||
add(main, `<robot name="mixed"><link name="base"><visual><geometry><mesh filename="package://example-robot-data/robots/legacy_description/meshes/body.STL"/></geometry><material name="body"><texture filename="package://Alexbot_simple_urdf/textures/body.png"/></material></visual></link></robot>`);
|
||||
add('/uploads/batch/meshes/body.stl', triangle);
|
||||
add('/uploads/batch/urdf_pkg/Alexbot_simple_urdf/textures/body.png', png, 'image/png');
|
||||
assert.deepEqual(await load(main), { meshes: 1, links: 1 });
|
||||
await page.waitForFunction(() => {
|
||||
let loaded = false;
|
||||
window.fixtureRobot.traverse((node) => { if (node.isMesh && node.material.map?.image?.naturalWidth > 0) loaded = true; });
|
||||
return loaded;
|
||||
});
|
||||
});
|
||||
|
||||
await t.test('a missing mesh rejects the model instead of accepting a partial robot', async () => {
|
||||
const main = '/uploads/batch/urdf/missing.urdf';
|
||||
add(main, '<robot name="missing"><link name="base"><visual><geometry><mesh filename="package://robot/meshes/missing.stl"/></geometry></visual></link></robot>');
|
||||
await assert.rejects(load(main), /1 个零件未能加载(missing.stl)/);
|
||||
});
|
||||
});
|
||||
@@ -1,6 +1,6 @@
|
||||
import test from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { meshUrlCandidates, resolveUrdfResourcePath } from '../js/urdf-paths.js';
|
||||
import { meshUrlCandidates, resolveUrdfResourcePath, urdfResourceUrlCandidates } from '../js/urdf-paths.js';
|
||||
|
||||
test('maps package references with a stale source directory prefix to uploaded paths', () => {
|
||||
assert.equal(
|
||||
@@ -55,3 +55,64 @@ test('keeps normal package mesh URLs first', () => {
|
||||
['https://oss.example/batch/meshes/body.stl', 'https://oss.example/batch/body.stl'],
|
||||
);
|
||||
});
|
||||
|
||||
const base = 'https://oss.example/batch';
|
||||
const alexMain = `${base}/urdf_pkg/Alexbot_simple_urdf/urdf/Alexbot_simple_urdf.urdf`;
|
||||
|
||||
test('loads an existing nested ROS package from its actual package directory', () => {
|
||||
assert.equal(urdfResourceUrlCandidates(base,
|
||||
'package://Alexbot_simple_urdf/meshes/base_link.STL', alexMain)[0],
|
||||
`${base}/urdf_pkg/Alexbot_simple_urdf/meshes/base_link.STL`);
|
||||
});
|
||||
|
||||
test('retains flattened legacy packages, including stale source prefixes', () => {
|
||||
assert.equal(urdfResourceUrlCandidates(base, 'package://robot/meshes/body.stl', `${base}/urdf/robot.urdf`)[0],
|
||||
`${base}/meshes/body.stl`);
|
||||
assert.equal(urdfResourceUrlCandidates(base,
|
||||
'package://example-robot-data/robots/asr_twodof_description/meshes/arm.dae', `${base}/urdf/robot.urdf`)[0],
|
||||
`${base}/meshes/arm.dae`);
|
||||
});
|
||||
|
||||
test('keeps a package-qualified fallback for other packages in the same upload', () => {
|
||||
assert.ok(urdfResourceUrlCandidates(base, 'package://camera/meshes/body.stl', alexMain)
|
||||
.slice(0, 9).includes(`${base}/camera/meshes/body.stl`));
|
||||
});
|
||||
|
||||
test('handles empty package names, file URIs and Windows exporter paths', () => {
|
||||
assert.equal(urdfResourceUrlCandidates(base, 'package:///antenna.stl', `${base}/robot.urdf`)[0], `${base}/antenna.stl`);
|
||||
assert.equal(urdfResourceUrlCandidates(base, `${base}/urdf/file:////meshes/body.stl`, alexMain)[0], `${base}/meshes/body.stl`);
|
||||
assert.ok(urdfResourceUrlCandidates(base, `${base}/urdfs/D:\\Data\\Robot/meshes/hand.stl`, alexMain)
|
||||
.slice(0, 9).includes(`${base}/meshes/hand.stl`));
|
||||
});
|
||||
|
||||
test('normalizes relative references within the upload batch and supports lowercase STL objects', () => {
|
||||
const candidates = urdfResourceUrlCandidates(base, `${base}/robots/../meshes/body.STL`, `${base}/robots/robot.urdf`);
|
||||
assert.equal(candidates[0], `${base}/meshes/body.STL`);
|
||||
assert.ok(candidates.slice(0, 9).includes(`${base}/meshes/body.stl`));
|
||||
assert.equal(urdfResourceUrlCandidates(base, `${base}/urdf/../../kinect/meshes/kinect.dae`, alexMain)[0],
|
||||
`${base}/kinect/meshes/kinect.dae`);
|
||||
});
|
||||
|
||||
test('keeps signed queries and external resources intact', () => {
|
||||
const url = `${base}/meshes/body.STL?Signature=x%2Fy&Expires=123`;
|
||||
assert.equal(urdfResourceUrlCandidates(base, url, alexMain)[0], url);
|
||||
assert.ok(urdfResourceUrlCandidates(base, url, alexMain).every((candidate) => candidate.endsWith('?Signature=x%2Fy&Expires=123')));
|
||||
const external = 'https://other.example/body.stl?Signature=external';
|
||||
assert.deepEqual(urdfResourceUrlCandidates(base, external, alexMain), [external]);
|
||||
});
|
||||
|
||||
test('rewrites nested uploads and disambiguates files belonging to different packages', () => {
|
||||
assert.equal(resolveUrdfResourcePath('package://Alexbot_simple_urdf/meshes/base_link.STL',
|
||||
'urdf_pkg/Alexbot_simple_urdf/urdf/robot.urdf', ['urdf_pkg/Alexbot_simple_urdf/meshes/base_link.STL']),
|
||||
'../meshes/base_link.STL');
|
||||
assert.equal(resolveUrdfResourcePath('package://camera/meshes/body.stl', 'robot/urdf/robot.urdf',
|
||||
['camera/meshes/body.stl', 'robot/meshes/body.stl', 'meshes/body.stl']),
|
||||
'../../camera/meshes/body.stl');
|
||||
});
|
||||
|
||||
test('matches exported Windows paths, empty packages and unique filename casing against the manifest', () => {
|
||||
assert.equal(resolveUrdfResourcePath('D:\\Data\\Robot\\meshes\\body.STL', 'urdf/robot.urdf', ['meshes/body.STL']), '../meshes/body.STL');
|
||||
assert.equal(resolveUrdfResourcePath('package:///body.stl', 'robot.urdf', ['body.stl']), 'body.stl');
|
||||
assert.equal(resolveUrdfResourcePath('../meshes/body.STL', 'robots/robot.urdf', ['meshes/body.stl']), '../meshes/body.stl');
|
||||
assert.equal(resolveUrdfResourcePath('meshes/body.STL', 'robot.urdf', ['meshes/BODY.stl', 'meshes/body.stl']), null);
|
||||
});
|
||||
|
||||
Reference in New Issue
Block a user