// 输入区 / 任务文件面板 / 上传 / 抽屉与滑动手势(拆自 index.html 内联脚本,纯搬运不改逻辑)
'use strict';
// ---------- 输入区 ----------
const ta = $('msg-input');
function autosize() { ta.style.height = 'auto'; ta.style.height = Math.min(ta.scrollHeight, 120) + 'px'; }
// 输入内容变化直接影响发送键两态:运行中一旦有字就恢复「发送」(可插话),清空后又变回「停止」
ta.addEventListener('input', () => { autosize(); updateSendBtn(); });
// 触屏设备(手机/平板)上:Enter 走默认行为(插入 \n),发消息靠发送按钮,
// 避免软键盘的回车键直接被吞走导致连换行都打不出来。桌面/笔记本继续走 Enter=发送。
// 用 (hover:none)&&(pointer:coarse) 判定「以触摸为主」的设备,标准且不依赖 UA 字符串。
const isTouchPrimary = window.matchMedia('(hover: none) and (pointer: coarse)').matches;
ta.addEventListener('keydown', e => {
// 输入法组合中(包括拼音输入法「确认英文上屏」那次 Enter)不拦截,
// 让 IME 自行处理。e.isComposing 是标准信号;旧版 Chrome 等环境下
// keyCode 恒为 229,作为兜底。
if (e.isComposing || e.keyCode === 229) return;
if (e.key !== 'Enter') return;
// 触屏:Enter 走默认(换行),不拦截、不发送。
if (isTouchPrimary) return;
// 桌面:Ctrl/⌘/Shift+Enter 在光标处换行;普通 Enter 发送
if (e.ctrlKey || e.metaKey || e.shiftKey) {
e.preventDefault();
if (!document.execCommand('insertText', false, '\n')) {
const i = ta.selectionStart;
ta.setRangeText('\n', i, ta.selectionEnd, 'end');
}
autosize();
} else {
e.preventDefault();
send();
}
});
// 发送键四职:语音 / 键盘(语音模式)/ 停止 / 发送,由 data-state 决定点击含义。
// 400ms 内重复点击忽略:防双击重复 abort(服务端 status 事件回来前按钮仍是停止态)。
let stopClickAt = 0;
$('send-btn').addEventListener('click', () => {
const st = $('send-btn').dataset.state;
if (st === 'voice' && window.AgentVoice) { window.AgentVoice.enter(); return; }
if (st === 'keyboard' && window.AgentVoice) { window.AgentVoice.exit(true); return; }
if (stopModeActive()) {
if (Date.now() - stopClickAt < 400) return;
stopClickAt = Date.now();
stopSession();
return;
}
send();
});
// 深度思考开关:每次发消息随 body 传给后端,后端会合并该模型的 thinking_params
$('deep-think-btn').addEventListener('click', () => {
state.deepThink = !state.deepThink;
$('deep-think-btn').classList.toggle('on', state.deepThink);
toast(state.deepThink ? '深度思考已开启' : '深度思考已关闭');
});
// ---------- 任务文件面板(底部浮层:点输入行右侧文件夹按钮展开,遮罩盖住输入区) ----------
function setFilesPanel(open) {
const panel = $('files-panel');
if (open) {
filesCurDir = ''; // 每次弹出回到根目录
filesShowHidden = false; // 隐藏文件彩蛋态不跨次记忆,每次打开从干净视图开始
applyFilesPanelH(); // 沿用上次拖拽高度(会话内),无则用 CSS 默认
loadFiles();
// 弹出面板时收起软键盘,避免顶起布局
if (document.activeElement && document.activeElement.blur) document.activeElement.blur();
}
panel.classList.toggle('open', open);
$('files-mask').classList.toggle('show', open);
$('files-btn').classList.toggle('active', open);
}
async function toggleFilesPanel() {
const panel = $('files-panel');
const open = !panel.classList.contains('open');
if (open && !state.sessionId) {
// 新建会话页不再静默建档:没有会话就没有任务目录,无从查看文件,只轻提示一下
toast('尚未开始会话,暂无任务文件可查看');
return;
}
setFilesPanel(open);
}
$('files-btn').addEventListener('click', toggleFilesPanel);
// 附件(回形针)按钮:只弹文件选择器,不预建会话;选中文件后由 change 处理器
// 写入当前会话任务目录(无会话时先建档再传,见下方);取消选择则什么都不发生。
$('attach-btn').addEventListener('click', () => {
$('file-input').click();
});
$('files-mask').addEventListener('click', () => setFilesPanel(false)); // 点遮罩收起
// ---------- 面板拖拽调高(底部抽屉):拽顶部手柄上拉放大、下拉缩高,拉到最低后继续下拉→整块下滑收起 ----------
// CSS 默认高 46%(min 240px / max 85% 视口);拖拽结果记入 filesPanelH 会话内沿用,重新打开即恢复。
const FP_MIN_H = 240, FP_MAX_RATIO = 0.85, FP_CLOSE_PULL = 90;
let filesPanelH = 0; // 0 = 跟随 CSS 默认高度
function filesPanelMaxH() { return Math.round(window.innerHeight * FP_MAX_RATIO); }
function applyFilesPanelH() {
const panel = $('files-panel');
if (filesPanelH) {
filesPanelH = Math.min(Math.max(filesPanelH, FP_MIN_H), filesPanelMaxH());
panel.style.height = filesPanelH + 'px';
} else {
panel.style.height = ''; // 回 CSS 默认,切目录高度始终稳定
}
}
(function bindFilesPanelDrag() {
const panel = $('files-panel');
const handle = $('files-drag-handle');
let drag = null; // {startY, startH}
function endDrag(close) {
if (!drag) return;
drag = null;
panel.style.transition = ''; // 恢复开合动画
panel.style.transform = '';
if (close) { filesPanelH = 0; panel.style.height = ''; setFilesPanel(false); }
}
handle.addEventListener('pointerdown', e => {
drag = { startY: e.clientY, startH: panel.offsetHeight };
try { handle.setPointerCapture(e.pointerId); } catch (_) {}
panel.style.transition = 'none'; // 拖拽期间不走 transform 动画,不跟手
e.preventDefault();
});
handle.addEventListener('pointermove', e => {
if (!drag) return;
const raw = drag.startH + (drag.startY - e.clientY); // 上拉为正 → 变高
const h = Math.min(Math.max(raw, FP_MIN_H), filesPanelMaxH());
filesPanelH = h;
panel.style.height = h + 'px';
const over = Math.max(0, FP_MIN_H - raw); // 拉过 minHeight → 整块向下跟随,预告即收起
panel.style.transform = over ? 'translateY(' + over + 'px)' : '';
if (over > FP_CLOSE_PULL) endDrag(true);
});
handle.addEventListener('pointerup', () => endDrag(false));
handle.addEventListener('pointercancel', () => endDrag(false));
// 转屏/窗口变化时按新视口重新限制到 min/max 区间
window.addEventListener('resize', () => {
if (panel.classList.contains('open')) applyFilesPanelH();
});
})();
// 任务文件面板多选状态:Set 保留当前选中的文件路径(全选范围 = 当前浏览目录,见 filesVisiblePaths)。
// 文件夹作为整体选中项存储(键加 d: 前缀),下载时由后端打包成 zip。
const DIR_SEL_PREFIX = 'd:';
const fileSelected = new Set();
let filesTreeRoot = null; // 最近一次拉取构建的目录树(单层列表渲染与全选/有效性计算都基于它)
let filesDirSizes = new Map(); // 目录路径('' = 根) → 其下文件递归总字节;按未过滤原始列表聚合(含隐藏的 .tmp/.venv)
let filesCurDir = ''; // 当前浏览目录(相对任务根;'' = 根)。面包屑 + 单层列表的游标
let filesShowHidden = false; // 彩蛋:点面板标题旁总大小文本切换 dot 项显隐(后端 ?hidden=1,连 .tmp/.venv 一起放出)
const dirSelKey = p => DIR_SEL_PREFIX + p;
const isDirSelKey = k => k.startsWith(DIR_SEL_PREFIX);
const selDirPath = k => k.slice(DIR_SEL_PREFIX.length);
// 文件是否被整体勾选的祖先目录覆盖
function isPathInDirSel(p) {
for (const k of fileSelected) {
if (isDirSelKey(k) && p.startsWith(selDirPath(k) + '/')) return true;
}
return false;
}
// 文件是否被选中:自身被勾,或其某个祖先目录被整体勾选
function isFileEffectivelySelected(p) {
return fileSelected.has(p) || isPathInDirSel(p);
}
// 目录节点内所有文件的相对路径(递归)
function filesUnderDir(node) {
let out = node.files.map(f => f.filename);
for (const d of node.dirs.values()) out = out.concat(filesUnderDir(d));
return out;
}
// 全选的作用域 = 当前浏览目录下的全部文件(递归含其子文件夹,等价于逐个勾选这些文件夹行)。
// 不能再用全任务树的扁平列表:在子文件夹里点全选会把根下其它文件也选上,批量删除会清空整个任务目录。
function filesVisiblePaths() {
const node = filesNodeAt(filesCurDir);
return node ? filesUnderDir(node) : [];
}
// 树中全部目录节点(父在前),附各自包含的文件列表
function collectDirNodes(node, out) {
out = out || [];
node = node || filesTreeRoot;
if (!node) return out;
for (const d of node.dirs.values()) {
out.push({ path: d.path, files: filesUnderDir(d) });
collectDirNodes(d, out);
}
return out;
}
// 把选中集归一化为执行列表 [{path, isDir}]:
// 1) 去掉已被整体勾选目录覆盖的单项文件;
// 2) 目录内文件全部选中时折叠为目录项(父目录优先,避免重复打包)。
function effectiveSelection() {
const dirs = []; const files = [];
for (const k of fileSelected) {
if (isDirSelKey(k)) dirs.push(selDirPath(k)); else files.push(k);
}
const covered = p => dirs.some(d => p.startsWith(d + '/'));
const kept = files.filter(p => !covered(p));
for (const dn of collectDirNodes()) { // 父在前
if (dirs.includes(dn.path)) continue;
if (dirs.some(d => dn.path.startsWith(d + '/'))) continue; // 祖先已选
if (dn.files.length && dn.files.every(p => fileSelected.has(p) || covered(p))) {
for (let i = dirs.length - 1; i >= 0; i--) if (dirs[i].startsWith(dn.path + '/')) dirs.splice(i, 1);
dirs.push(dn.path);
for (let i = kept.length - 1; i >= 0; i--) if (kept[i].startsWith(dn.path + '/')) kept.splice(i, 1);
}
}
return dirs.map(path => ({ path, isDir: true })).concat(kept.map(path => ({ path, isDir: false })));
}
// 重算面板内(或指定范围内)文件行/目录行勾选框的视觉状态:统一按选中集推导,
// 避免各处手写 DOM 同步漏掉嵌套目录。目录勾选态 = 显式整选,或内部文件全部被覆盖。
function refreshFileSelStates(scope) {
scope = scope || $('files-list');
scope.querySelectorAll('.file-row').forEach(r => {
const p = r.dataset.path;
const sel = !!p && isFileEffectivelySelected(p);
r.classList.toggle('selected', sel);
const ck = r.querySelector('.file-check');
if (ck) ck.setAttribute('aria-checked', sel ? 'true' : 'false');
});
scope.querySelectorAll('.file-dir-head').forEach(h => {
const dp = h.dataset.dir;
const ck = h.querySelector(':scope > .file-check');
if (!dp || !ck) return;
const node = filesNodeAt(dp);
const under = node ? filesUnderDir(node) : [];
const sel = fileSelected.has(dirSelKey(dp)) ||
(under.length > 0 && under.every(isFileEffectivelySelected));
h.classList.toggle('selected', sel);
ck.setAttribute('aria-checked', sel ? 'true' : 'false');
});
}
function updateFilesFooter() {
const n = fileSelected.size;
const vis = filesVisiblePaths();
const total = vis.length; // 全选按钮只看当前目录:无文件则禁用
const effCount = effectiveSelection().length;
const countEl = $('files-count');
const dlBtn = $('files-bulk-download');
const delBtn = $('files-bulk-delete');
const togBtn = $('files-toggle-all');
if (countEl) countEl.textContent = effCount ? '已选择 ' + effCount + ' 项' : '未选择文件';
if (dlBtn) dlBtn.disabled = n === 0;
if (delBtn) delBtn.disabled = n === 0;
// 全选按钮:没有文件时禁用;全部选中=打勾态;部分选中=减号态;都未选=加号态
if (togBtn) {
// span 没有 disabled 属性,用 aria-disabled + tabindex 控制交互能力
const disabled = total === 0;
togBtn.setAttribute('aria-disabled', disabled ? 'true' : 'false');
togBtn.tabIndex = disabled ? -1 : 0;
let state = 'none';
if (total > 0 && vis.every(isFileEffectivelySelected)) state = 'all';
else if (vis.some(isFileEffectivelySelected)) state = 'some';
togBtn.dataset.state = state;
togBtn.setAttribute('aria-checked', state === 'all' ? 'true' : (state === 'some' ? 'mixed' : 'false'));
togBtn.title = state === 'all' ? '取消全选' : '全选';
togBtn.setAttribute('aria-label', state === 'all' ? '取消全选' : '全选');
}
}
// 全选 / 取消全选:只作用于当前浏览目录(递归含子文件夹)。全部选中 → 取消;否则 → 选中全部。
// 取消时仅清除与本目录相关的选中项:目录内的单项/子目录键,以及整体覆盖本目录的祖先勾选键。
function toggleSelectAll() {
const vis = filesVisiblePaths();
if (vis.length === 0) return;
const togBtn = $('files-toggle-all');
if (togBtn && togBtn.getAttribute('aria-disabled') === 'true') return;
if (vis.every(isFileEffectivelySelected)) {
const prefix = filesCurDir ? filesCurDir + '/' : '';
for (const k of Array.from(fileSelected)) {
const p = isDirSelKey(k) ? selDirPath(k) : k;
// p 在本目录内(单项文件或被勾选的子目录),或 p 是覆盖本目录的祖先整选键(如进入 sub 前勾了 d:sub)
if (p.startsWith(prefix) || (prefix && prefix.startsWith(p + '/'))) fileSelected.delete(k);
}
} else {
for (const p of vis) fileSelected.add(p);
}
// 同步文件行与目录头勾选框的视觉状态
refreshFileSelStates();
updateFilesFooter();
}
// ---------- 目录浏览:后端返回扁平列表(路径可含子目录),前端组树后按「面包屑 + 单层列表」展示 ----------
// 规则:主体只渲染当前目录的直接子项,目录在上、文件在下;同级目录按名称排序,同级文件按时间倒序(新的在前)。
// filesCurDir 为当前浏览目录('' = 任务根);顶部面包屑(/ > a > b)点任意节点回跳,点目录行进一层;无折叠态。
function fileTimeOf(f) { return f.mtime || f.ctime || 0; }
function sortFilesByTime(arr) {
arr.sort(function (a, b) {
const d = fileTimeOf(b) - fileTimeOf(a); // 时间缺失的排最后,与原逻辑一致
if (d) return d;
return a.filename < b.filename ? -1 : a.filename > b.filename ? 1 : 0;
});
return arr;
}
function sortDirsByName(arr) {
arr.sort(function (a, b) { return a.name < b.name ? -1 : a.name > b.name ? 1 : 0; });
return arr;
}
// 扁平文件列表 → 树节点 { name, path, dirs: Map, files: [] }
// 目录标记行(?dirs=1:filename 以 '/' 结尾 + dir:true)只沿途铺设路径节点、不入任何 files[],
// 不含文件的空夹子因此也能渲染;与同名文件路径铺出的节点经 dirs Map 天然去重。
function buildFilesTree(files) {
const root = { name: '', path: '', dirs: new Map(), files: [] };
for (const f of files) {
const isDir = f.dir === true || /\/$/.test(String(f.filename));
const name = isDir ? String(f.filename).replace(/\/+$/, '') : String(f.filename);
if (!name) continue;
const segs = name.split('/');
let node = root, rel = '';
const dirDepth = isDir ? segs.length : segs.length - 1; // 文件:末段是文件名;目录:全是路径段
for (let i = 0; i < dirDepth; i++) {
const seg = segs[i];
rel = rel ? rel + '/' + seg : seg;
if (!node.dirs.has(seg)) node.dirs.set(seg, { name: seg, path: rel, dirs: new Map(), files: [] });
node = node.dirs.get(seg);
}
if (!isDir) node.files.push(f);
}
return root;
}
// 目录(含子目录)内文件总数,用于目录头计数
function countDirFiles(node) {
let n = node.files.length;
for (const d of node.dirs.values()) n += countDirFiles(d);
return n;
}
function fileRowHtml(f) {
// 预览策略:所有文件点击一律进预览窗(preview.js openFilePreview);此处仅决定图标(可预览=眼睛,其余=文档)
const low = f.filename.toLowerCase();
const fsPv = /\.(md|txt|html?|pdf|png|jpe?g|gif|webp|svg|docx|xlsx|pptx|csv|tsv|json|jsonl|xml|yml|yaml|toml|ini|conf|cfg|properties|env|log|py|pyw|js|mjs|cjs|ts|tsx|jsx|java|kt|c|h|cpp|hpp|cc|cs|go|rs|rb|php|swift|sh|bash|zsh|bat|ps1|sql|lua|r|dart|vue|css|less|scss|srt|vtt)$/.test(low);
const ico = fsPv
? ''
: '';
const name = esc(String(f.filename).split('/').pop() || f.filename);
const ftime = fmtTime(f.mtime || f.ctime);
const sel = isFileEffectivelySelected(f.filename);
return '
' +
'
' +
'
' +
'
' + name + '
' +
'
' + ico + '' + fmtSize(f.size) + '' +
(ftime ? '' + ftime + '' : '') + '
' +
'
' +
'
';
}
// 目录行(带勾选框):整个文件夹作为一个选中项(下载时后端打包成 zip);
// 点行其余区域进入该目录(单层列表,不再有折叠/展开)。
function dirRowHtml(node) {
const under = filesUnderDir(node);
const checked = fileSelected.has(dirSelKey(node.path)) ||
(under.length > 0 && under.every(isFileEffectivelySelected));
return '' +
'
' +
'
' +
'
' + esc(node.name) + '' +
'
' + countDirFiles(node) + ' 个文件' +
'
' +
'
';
}
// 按相对路径取树节点('' = 根);路径不存在(如删除后重拉)返回 null
function filesNodeAt(path) {
let node = filesTreeRoot;
if (!node) return null;
if (!path) return node;
for (const seg of String(path).split('/')) {
node = node.dirs.get(seg);
if (!node) return null;
}
return node;
}
// 渲染当前目录:顶部面包屑(根目录(home) › a › b,点任意节点回跳)+ 单层列表(目录在前、文件在后)。
// 面包屑常显:根目录时只亮「根目录」当前层;进入子目录后逐级铺开。
function renderFilesDir() {
const el = $('files-list');
const crumbEl = $('files-crumbs');
let node = filesNodeAt(filesCurDir);
if (!node) { filesCurDir = ''; node = filesNodeAt(''); } // 当前目录已被删除 → 退回根
const sizeEl = $('files-panel-size');
if (!node) { el.innerHTML = ''; if (sizeEl) sizeEl.textContent = ''; return; }
// 标题旁总大小:按未过滤的聚合表取当前目录递归总量(关彩蛋时服务端不返回 dot 项;开彩蛋时含 .imgcache/.tmp/.venv 全计)
if (sizeEl) {
const total = filesDirSizes.get(filesCurDir) || 0;
sizeEl.textContent = total > 0 ? fmtSize(total) : '';
}
// 根节点:home 图标 + 「根目录」,比一个孤悬的「/」醒目得多;在根时它是当前层,纯文本不可点
const homeIc = '';
let html = filesCurDir
? '' + homeIc + '根目录'
: '' + homeIc + '根目录';
if (filesCurDir) {
let acc = '';
const segs = filesCurDir.split('/');
segs.forEach(function (seg, i) {
acc = acc ? acc + '/' + seg : seg;
html += '›';
html += (i === segs.length - 1)
? '' + esc(seg) + '' // 当前层纯文本不可点
: '' + esc(seg) + '';
});
}
crumbEl.innerHTML = html;
crumbEl.classList.remove('hidden');
const dirs = sortDirsByName(Array.from(node.dirs.values()));
sortFilesByTime(node.files);
if (!dirs.length && !node.files.length) {
el.innerHTML = '' + (filesCurDir ? '该文件夹为空' : '还没有文件,在对话框上传或让 AI 生成') + '
';
return;
}
el.innerHTML = dirs.map(dirRowHtml).join('') + node.files.map(fileRowHtml).join('');
}
async function loadFiles() {
if (!state.sessionId) return;
// 重新拉取前清空旧选择,避免脏数据遗留
fileSelected.clear();
filesTreeRoot = null;
updateFilesFooter();
try {
// 彩蛋开启时后端连 dot 项一起列,且不再滤 .tmp/.venv(全量放出)
const hiddenQ = filesShowHidden ? '&hidden=1' : '';
const files = await req('GET', '/api/sessions/' + state.sessionId + '/files?dirs=1' + hiddenQ);
// 会话级 .tmp(executor 的共享 /tmp 落盘处)与 .venv(Python 虚拟环境)不属于任务产物:默认隐藏(老后端兼容兑底;新版关彩蛋时服务端已不返回 dot 项)
const shown = filesShowHidden ? files : files.filter(f => !/^(\.tmp|\.venv)(\/|$)/.test(String(f.filename)));
// 重建目录树后只渲染当前目录这一层(后端已按时间倒序,组内再排一次防旧排序缓存)
filesTreeRoot = buildFilesTree(shown);
// 总大小按原始列表(含 .tmp/.venv)聚合:目录标记行无字节量跳过;文件把 size 记到每一级祖先目录(根 = '')
filesDirSizes = new Map([['', 0]]);
for (const f of files) {
if (f.dir === true || /\/$/.test(String(f.filename))) continue;
const sz = Number(f.size) || 0;
if (!sz) continue;
filesDirSizes.set('', (filesDirSizes.get('') || 0) + sz);
const segs = String(f.filename).split('/');
segs.pop(); // 末段是文件名,其余是祖先目录
let acc = '';
for (const seg of segs) {
acc = acc ? acc + '/' + seg : seg;
filesDirSizes.set(acc, (filesDirSizes.get(acc) || 0) + sz);
}
}
renderFilesDir(); // filesCurDir 失效时自动退回根目录
// 重新渲染后刷新底部计数与按钮状态
updateFilesFooter();
} catch (e) { toast('读取文件失败:' + e.message); }
}
// 造一个「相对资源 → 任务根相对路径」解析器:以 refPath 所在目录为基准解析 p(md 图片、html 预览共用)。
// 外链/内联/页面内跳转返回 null(不改写)。
// 关键:marked 会把 img src 里的中文/空格预先百分号编码成 %XX,这里必须先解码回真实路径,
// 否则最后 encodeURIComponent 会把 % 再编码成 %25(双重编码),服务端解码一次后得到含字面 %XX
// 的假文件名 → 磁盘上不存在 → 404(中文/空格文件名图片显示不出来的根因)。
function makeAssetResolver(refPath) {
// refPath 所在目录(任务根下无子目录时为 '')
const baseSegs = refPath.includes('/') ? refPath.split('/').slice(0, -1) : [];
return function (p) {
p = String(p || '').trim();
if (!p || /^(https?:)?\/\//i.test(p) || /^(data|blob|about|javascript|mailto|tel):/i.test(p)) return null; // 已是外链/内联
let raw = p;
try { raw = decodeURIComponent(raw); } catch (_) { /* 文件名本身含裸 % 会抛,保留原文 */ }
const hash = raw.indexOf('#');
if (hash >= 0) raw = raw.slice(0, hash); // 资源加载不关心片段锚点
const segs = raw.startsWith('/') ? [] : baseSegs.slice(); // 以 / 开头视为任务根下
for (const part of raw.split('/')) {
if (!part || part === '.') continue;
if (part === '..') { if (segs.length) segs.pop(); continue; }
segs.push(part);
}
return segs.join('/');
};
}
const assetDownloadUrl = function (rel) {
return '/api/sessions/' + state.sessionId + '/files/download?path=' + encodeURIComponent(rel);
};
// 把渲染好的 Markdown HTML 里的相对图片路径重写成下载接口地址:
// 预览在浏览器里以应用页面为基准解析相对 src,而图片其实在任务目录里,直接写相对路径会 404。
function rewriteMdImageSrcs(html, mdPath) {
const resolve = makeAssetResolver(mdPath);
const host = document.createElement('div');
host.innerHTML = html;
host.querySelectorAll('img').forEach(function (im) {
const rel = resolve(im.getAttribute('src'));
if (!rel) return;
im.setAttribute('src', assetDownloadUrl(rel));
});
return host.innerHTML;
}
// HTML 预览小修:srcdoc 的基准 URL 是 about:srcdoc,相对资源路径全都解析失败。
// 把 img/script/link(stylesheet)/source 等常见资源引用改写成绝对下载地址;
// CSS url() 内部、JS fetch 的相对路径覆盖不了(那需要后端目录级 inline 访问,暂不做)。
function rewriteHtmlDocSrcs(html, filePath) {
const resolve = makeAssetResolver(filePath);
const doc = new DOMParser().parseFromString(html, 'text/html'); // 不用 div:保留 head/body 结构
const fix = function (sel, attr) {
doc.querySelectorAll(sel).forEach(function (el) {
const rel = resolve(el.getAttribute(attr));
if (rel) el.setAttribute(attr, assetDownloadUrl(rel));
});
};
fix('img[src]', 'src');
fix('script[src]', 'src');
fix('source[src]', 'src');
fix('video[src]', 'src');
fix('video[poster]', 'poster');
fix('audio[src]', 'src');
fix('embed[src]', 'src');
fix('track[src]', 'src');
fix('input[type="image"][src]', 'src');
fix('use[href]', 'href');
doc.querySelectorAll('link[href]').forEach(function (el) {
if (!/(stylesheet|icon)/i.test(String(el.getAttribute('rel') || ''))) return; // 只动样式/图标,不碰页面跳转
const rel = resolve(el.getAttribute('href'));
if (rel) el.setAttribute('href', assetDownloadUrl(rel));
});
return '\n' + doc.documentElement.outerHTML;
}
// 预览路由已迁至 js/preview.js(openFilePreview):office 走 /preview 预览服务;其余类型桌面进 #pv-pane、移动端进 #fs-viewer。
async function downloadFile(name) {
if (!state.sessionId) return;
try {
const r = await req('GET', '/api/sessions/' + state.sessionId + '/files/download-token?path=' + encodeURIComponent(name));
window.location.href = r.url; // 原生导航下载:同源自动带登录 cookie,文件名不乱
} catch (e) { toast('下载失败:' + e.message); }
}
async function deleteFile(name) {
if (!await confirmModal('删除文件', '删除文件 ' + name + ' ?', '删除', true)) return;
try {
await req('DELETE', '/api/sessions/' + state.sessionId + '/files?path=' + encodeURIComponent(name));
loadFiles();
} catch (e) { toast('删除失败:' + e.message); }
}
// 列表事件委托(单层列表,目录不再有折叠/展开):
// 1) 目录行勾选框:整体选中/取消该文件夹(下载时后端打包成 zip);点行其余区域:进入该目录;
// 2) 点击文件行勾选框:仅选中状态,不触发预览/下载;
// 3) 一旦处于多选模式(Set 非空),整行点击仅切换选中状态,不再预览/下载;
// 4) 未进入多选模式时,点击文件名/图标根据 row.dataset.preview 决定预览或下载。
$('files-list').addEventListener('click', e => {
// 目录行:勾选框切换整选,其余区域进入该目录
const head = e.target.closest('.file-dir-head');
if (head) {
const dp = head.dataset.dir;
if (!dp || !state.sessionId) return;
if (e.target.closest('.file-check')) { toggleDirSelect(dp); return; }
filesCurDir = dp;
renderFilesDir();
updateFilesFooter(); // 全选作用域随浏览目录变化,刷新底部勾选态
return;
}
const row = e.target.closest('.file-row');
if (!row || !state.sessionId) return;
const path = row.dataset.path;
if (!path) return;
const isCheck = !!e.target.closest('.file-check');
// 多选模式下:任何点击(仅选框/文件名/其他)都只切换选中
if (isCheck || fileSelected.size > 0) {
// 已被整体勾选文件夹覆盖的行:点选无效,选中与否由文件夹勾选框决定
if (isPathInDirSel(path)) return;
if (fileSelected.has(path)) { fileSelected.delete(path); }
else { fileSelected.add(path); }
// 同步本行与所在目录链的勾选态(目录可能因内部全选/取消全选而变)
refreshFileSelStates();
updateFilesFooter();
return;
}
// 默认模式:所有文件一律进预览窗(不支持类型窗内展示占位与下载入口),不再直接下载
openFilePreview(path, row.dataset.size || '');
});
// 整体选中/取消一个文件夹:目录作为单条选中项(d: 前缀),行视觉态由 refreshFileSelStates 重算。
// 整体勾选时取消内部单项/子目录勾选(已被覆盖,避免重复计入);取消勾选时子项恢复未选。
function toggleDirSelect(dirPath) {
const key = dirSelKey(dirPath);
const on = !fileSelected.has(key);
if (on) {
fileSelected.add(key);
// 整体勾选后,内部单项文件/子目录勾选都被覆盖,直接移除避免重复计入
const prefix = dirPath + '/';
for (const k of Array.from(fileSelected)) {
if (k === key) continue;
const p = isDirSelKey(k) ? selDirPath(k) : k;
if (p.startsWith(prefix)) fileSelected.delete(k);
}
} else {
fileSelected.delete(key);
}
// 目录行/文件行勾选态统一按选中集重算
refreshFileSelStates();
updateFilesFooter();
}
// 面包屑点击:回跳到任意祖先层级(当前层节点无 data-path,不可点)
$('files-crumbs').addEventListener('click', e => {
const c = e.target.closest('.crumb[data-path]');
if (!c) return;
filesCurDir = c.dataset.path;
renderFilesDir();
updateFilesFooter(); // 同上:面包屑回跳也重算全选态
});
// 彩蛋:点面板标题旁的总大小文本 = 切换隐藏文件(dot 项含 .tmp/.venv)显隐。
// 故意不加任何光标/文案提示,也不限层级(子目录里点同样生效)。
$('files-panel-size').addEventListener('click', () => {
filesShowHidden = !filesShowHidden;
loadFiles();
});
// 批量下载:选中项含文件夹(含全选后整目录被覆盖的情况)时,整个选择交给后端打包成
// 一个 zip 一次下载;纯文件选择保持逐文件直链下载。zip 同样走签名直链(与单文件同链路)。
async function bulkZipDownload(paths) {
try {
const r = await req('GET', '/api/sessions/' + state.sessionId + '/files/zip-token?paths=' + encodeURIComponent(JSON.stringify(paths)));
if (!r || !r.url) throw new Error('未拿到打包链接');
const a = document.createElement('a');
a.href = r.url;
a.download = r.name || 'archive.zip';
a.style.display = 'none';
document.body.appendChild(a);
a.click();
setTimeout(() => { try { a.remove(); } catch (_) {} }, 1000);
} catch (e) { toast('打包下载失败:' + e.message); }
}
// 批量下载:先把所有 download-token 拿完,再用服务器直链逐个触发下载。
// 两个历史坑:
// 1) 边拿 token 边 location.href:首个下载导航会打断后续 fetch(第 2 个报失败);
// → 先批量拿完 token 再触发。
// 2) fetch+blob 方案:手机浏览器不认 blob 文件名(变编号/.bin),
// 套壳 WebView 不处理 blob: 下载请求(点了没反应);
// → 回到服务器原始直链(文件名跟 Content-Disposition),与单文件下载同一条链路。
async function bulkDownload() {
if (!state.sessionId || fileSelected.size === 0) return;
const eff = effectiveSelection();
if (eff.some(x => x.isDir)) { bulkZipDownload(eff.map(x => x.path)); return; }
const names = eff.map(x => x.path);
// 第一阶段:全部 token 先拿到手(此时还没发生任何导航,fetch 不会被打断)
const items = [];
for (const name of names) {
try {
const r = await req('GET', '/api/sessions/' + state.sessionId + '/files/download-token?path=' + encodeURIComponent(name));
if (!r || !r.url) throw new Error('未拿到下载链接');
items.push({ url: r.url, name: String(name).split('/').pop() || name });
} catch (e) { toast('下载失败:' + name + ' ' + e.message); }
}
// 第二阶段:隐藏 + 服务器直链逐个触发;download 属性作手机端文件名兜底,
// 小间隔避免移动端拦截连续多次下载
for (const it of items) {
const a = document.createElement('a');
a.href = it.url;
a.download = it.name;
a.style.display = 'none';
document.body.appendChild(a);
a.click();
setTimeout(() => { try { a.remove(); } catch (_) {} }, 1000);
await new Promise(res => setTimeout(res, 350));
}
}
async function bulkDelete() {
if (!state.sessionId || fileSelected.size === 0) return;
const names = effectiveSelection().map(x => x.path); // 目录整体删除(后端 rm -r,含子项)
if (!await confirmModal('批量删除', '确认删除选中的 ' + names.length + ' 项(文件夹会连同内部文件一起删除)?', '删除', true)) return;
let ok = 0, fail = 0;
for (const name of names) {
try {
await req('DELETE', '/api/sessions/' + state.sessionId + '/files?path=' + encodeURIComponent(name));
ok++;
} catch (e) { fail++; toast('删除失败:' + name + ' ' + e.message); }
}
if (ok) toast('已删除 ' + ok + ' 项');
loadFiles(); // 重新拉取并重置选中
}
$('files-bulk-download').addEventListener('click', bulkDownload);
$('files-bulk-delete').addEventListener('click', bulkDelete);
const togEl = $('files-toggle-all');
togEl.addEventListener('click', toggleSelectAll);
togEl.addEventListener('keydown', e => {
if (e.key === 'Enter' || e.key === ' ') { e.preventDefault(); toggleSelectAll(); }
});
// ---------- 大图上传前压缩(同步 v1:阈值/参数由 /api/system/status 透出) ----------
const DEFAULT_UPLOAD_CFG = { image_compress_threshold_kb: 1536, image_max_dim: 2000, image_quality: 0.85, confirm_size_mb: 10, paste_to_file_threshold_chars: 2000 };
// 后端 multer 单文件硬限(routes/files.js limits.filesize),前端预检对齐它,超了直接拒掉不发起上传
const UPLOAD_HARD_LIMIT = 50 * 1024 * 1024;
let uploadCfgCache = null;
async function getUploadCfg() {
if (!uploadCfgCache) {
uploadCfgCache = Object.assign({}, DEFAULT_UPLOAD_CFG);
try {
const s = await req('GET', '/api/system/status');
uploadCfgCache = Object.assign(uploadCfgCache, (s && s.upload) || {});
} catch (_) { /* 取不到配置就用默认阈值 */ }
}
return uploadCfgCache;
}
function loadImageEl(file) {
return new Promise(function (resolve, reject) {
const fr = new FileReader();
fr.onload = function () {
const im = new Image();
im.onload = function () { resolve(im); };
im.onerror = function () { reject(new Error('图片解码失败')); };
im.src = fr.result;
};
fr.onerror = function () { reject(new Error('读取文件失败')); };
fr.readAsDataURL(file);
});
}
// 上传前逐文件预处理(串行,模态弹窗不能并行),返回待上传 File 或 null(用户放弃该文件):
// 1) 大图(>image_compress_threshold_kb):三选一——「压缩」本地压后传 / 「直接上传」原样传 /
// 右上 X、点遮罩关闭 = 放弃该文件(不上传,也就不触发建会话);
// 2) 最终体积 >50M(后端 multer 硬限):直接拒掉,不发起上传;
// 3) 预处理后仍 >confirm_size_mb(默认 10M,不限类型):二次确认「继续上传」,
// 取消/X/遮罩一律放弃。
// 压缩失败/无收益按原文件继续后续流程。
async function prepareUploadFile(file) {
const cfg = await getUploadCfg();
const isImg = /^image\//.test(file.type || '') || /\.(png|jpe?g|gif|bmp|webp)$/i.test(file.name || '');
const threshold = Number(cfg.image_compress_threshold_kb || 1536) * 1024;
const maxDim = Number(cfg.image_max_dim || 2000);
const quality = Number(cfg.image_quality || 0.85);
if (isImg && file.size > threshold) {
// confirmModal resolve: true=压缩 / false=直接上传 / null=X或遮罩=放弃
const ans = await confirmModal('图片文件过大',
'「' + file.name + '」有 ' + fmtSize(file.size) + ',超过 ' + fmtSize(threshold) +
'。建议在浏览器本地压缩为 JPEG(长边≤' + maxDim + 'px)后再上传;也可原样直接上传。',
'压缩', false, { cancelText: '直接上传' });
if (ans === null) return null;
if (ans) {
try {
const img = await loadImageEl(file);
const iw = img.naturalWidth || img.width, ih = img.naturalHeight || img.height;
if (!iw || !ih) throw new Error('无法读取图片尺寸');
const scale = Math.min(1, maxDim / Math.max(iw, ih));
const w = Math.max(1, Math.round(iw * scale)), h = Math.max(1, Math.round(ih * scale));
const canvas = document.createElement('canvas');
canvas.width = w; canvas.height = h;
const ctx = canvas.getContext('2d');
// 透明底(PNG)转 JPEG 前先铺白,避免变黑
ctx.fillStyle = '#fff'; ctx.fillRect(0, 0, w, h);
ctx.drawImage(img, 0, 0, w, h);
const blob = await new Promise(function (res) { canvas.toBlob(function (b) { res(b); }, 'image/jpeg', quality); });
if (!blob || blob.size >= file.size) {
toast('压缩无收益,按原文件上传');
} else {
const newName = String(file.name || 'image').replace(/\.[^.]+$/, '') + '.jpg';
toast('已压缩 ' + fmtSize(file.size) + ' → ' + fmtSize(blob.size));
file = new File([blob], newName, { type: 'image/jpeg' });
}
} catch (e) {
toast('压缩失败(' + (e && e.message || e) + '),按原文件上传');
}
}
}
// 后端 multer 单文件硬限 50M:压缩后仍超限、或选了「直接上传」的超限大图、非图片超限文件,
// 都在这里拒掉(返回 null,与其他「放弃」同一条路径),免得传完一个 500 才知道原因
if (file.size > UPLOAD_HARD_LIMIT) {
toast('「' + file.name + '」有 ' + fmtSize(file.size) + ',超过 50M 上限,无法上传' + (isImg ? ',可尝试选「压缩」后上传' : ''));
return null;
}
// 最终体积仍超大盘阈值的文件(含非图片、含压缩后仍超限):用户确认后才传
const bigLimit = Number(cfg.confirm_size_mb || 10) * 1024 * 1024;
if (file.size > bigLimit) {
const go = await confirmModal('文件过大',
'「' + file.name + '」有 ' + fmtSize(file.size) + ',超过 ' + fmtSize(bigLimit) + '。确认继续上传?',
'继续上传');
if (go !== true) return null; // 取消/X/遮罩:不传该文件
}
return file;
}
// ---------- 上传文件卡片(嵌在输入框内部顶端,随卡片数撑高输入框;新卡插最前,图标 + 文件名/类型大小,逐卡上传进度遮罩;过多横向滚动) ----------
function uploadTypeLabel(name) {
const m = /\.([A-Za-z0-9]{1,8})$/.exec(name || '');
return m ? m[1].toUpperCase() : '文件';
}
function uploadIconSvg(name) {
// 与文件面板同款图标语言:图片用图、其余用文档
return /\.(png|jpe?g|gif|webp|bmp|svg)$/i.test(name || '')
? ''
: '';
}
function addUploadCard(file) {
const row = $('up-cards');
row.classList.remove('hidden');
const card = document.createElement('div');
card.className = 'up-card';
card.dataset.name = file.name; // 发送时按名字在正文前拼告知行
card.innerHTML =
'' + uploadIconSvg(file.name) + '
' +
'' +
'
' + esc(file.name) + '
' +
'
' + uploadTypeLabel(file.name) + ' · ' + fmtSize(file.size) + '
' +
'
' +
'' +
'0%
';
const mask = card.querySelector('.up-mask');
const pctEl = card.querySelector('.up-pct');
const closeBtn = card.querySelector('.up-x');
// ×掉卡片 = 从 DOM 移除;send() 按现存 data-done 卡片实时拼告知行,自然不再包含该文件(文件本身仍在任务目录)
closeBtn.addEventListener('click', () => {
card.remove();
if (!row.children.length) row.classList.add('hidden');
});
// 倒序:最后上传的排最前;新卡入位后横向滚回左端保证可见
row.prepend(card);
row.scrollTo({ left: 0, behavior: 'smooth' });
return {
setPct(p) {
const v = Math.max(0, Math.min(100, Math.round(p)));
pctEl.textContent = v + '%';
card.style.setProperty('--up-p', v + '%');
},
done() {
mask.remove();
card.classList.add('done');
card.dataset.done = '1'; // 仅成功上传的卡片参与发送时的告知行
closeBtn.classList.remove('hidden');
},
// 服务端重名会加 -1/-2:告知行必须用真实落盘名,否则模型读不到/读到旧文件
rename(name) {
card.dataset.name = name;
const el = card.querySelector('.up-name');
if (el) { el.textContent = name; el.title = name; }
},
fail() {
card.classList.add('err');
mask.innerHTML = '上传失败';
closeBtn.classList.remove('hidden');
},
};
}
function clearUploadCards() {
const row = $('up-cards');
row.innerHTML = '';
row.classList.add('hidden');
}
// 文件选择统一入口:先逐文件预处理(大图压缩询问/大文件确认,X或遮罩=放弃该文件),
// 只要还剩至少一个待传文件才自动建档(welcome 无会话时)并走即传路径(多文件并行上传+总进度条+逐卡进度);
// 全部放弃或取消选择都不上传、不新建会话。拖拽 drop 也走这里。
// 并发批次共用一个总进度条:各自登记 {loaded,total},绘制时求和,避免后一批把前一批的进度冲掉。
const uploadBatches = new Set();
async function uploadFilesNow(files) {
// 逐个串行预处理(模态弹窗不能并行)
const ready = [];
for (const f of files) {
const r = await prepareUploadFile(f);
if (r) ready.push(r);
}
if (!ready.length) return; // 用户全放弃了:不上传也不建档
if (!state.sessionId) {
try {
await ensureSession();
} catch (er) {
toast('创建会话失败:' + er.message);
return;
}
}
// 每张卡对应一个文件的上传进度(输入区上方;面板内总进度条保留不变)
const cards = ready.map(f => addUploadCard(f));
// ---- 并行上传 + 实时进度 ----
const progWrap = $('fp-progress'), progBar = $('fp-progress-bar'), progPct = $('fp-progress-pct');
const batch = { loaded: 0, total: ready.reduce((s, f) => s + f.size, 0) };
uploadBatches.add(batch);
let done = 0, errCount = 0;
function paintProg() {
let loaded = 0, total = 0;
uploadBatches.forEach(b => { loaded += b.loaded; total += b.total; });
const pct = total ? Math.min(100, Math.round(loaded / total * 100)) : 0;
progBar.style.width = pct + '%';
progPct.textContent = pct + '%';
}
progWrap.classList.remove('hidden');
paintProg();
const tasks = ready.map((f, i) => new Promise(resolve => {
const card = cards[i];
const fd = new FormData(); fd.append('files', f, f.name);
const xhr = new XMLHttpRequest();
xhr.open('POST', '/api/sessions/' + state.sessionId + '/files');
let lastLoaded = 0;
xhr.upload.onprogress = function (ev) {
if (!ev.lengthComputable) return;
// ev.loaded 是本文件累计已发字节,汇总时取本次增量避免多计
batch.loaded += ev.loaded - lastLoaded;
lastLoaded = ev.loaded;
paintProg();
card.setPct(ev.loaded / ev.total * 100);
};
xhr.onload = function () {
if (xhr.status === 200) {
done++;
try {
const u = (JSON.parse(xhr.responseText || '{}').uploaded || [])[0];
if (u && u.filename) card.rename(u.filename);
} catch (_) { /* 响应体异常不影响上传成功态 */ }
card.done();
} else { errCount++; card.fail(); }
// 终态补齐(可能没收到最后一帧 100%)
if (lastLoaded < f.size) { batch.loaded += f.size - lastLoaded; paintProg(); }
resolve();
};
xhr.onerror = function () { errCount++; card.fail(); resolve(); };
xhr.send(fd);
}));
await Promise.all(tasks);
if (batch.loaded < batch.total) batch.loaded = batch.total;
uploadBatches.delete(batch);
paintProg();
// 全部成功不再弹提示(卡片已完成态即反馈);有失败才提醒
if (errCount) toast('已上传 ' + done + ' 个,失败 ' + errCount + ' 个');
loadFiles();
// 桌面端左栏文件树是新的浏览入口,上传后要同步(旧面板只在手机端用)
if (typeof window.refreshFileTree === 'function') window.refreshFileTree();
// 1.2s 后收起进度条(还有别的批次在传就不收)
setTimeout(() => {
if (uploadBatches.size) return;
progWrap.classList.add('hidden'); progBar.style.width = '0%';
}, 1200);
}
$('file-input').addEventListener('change', e => {
const input = e.target;
const files = Array.prototype.slice.call(input.files || []); // 先快照再清空,FileList 是实时的
input.value = '';
if (files.length) uploadFilesNow(files).catch(er => toast('上传失败:' + (er && er.message || er)));
});
// ---------- 拖拽文件到页面即上传(仅桌面浏览器,触屏没有 drag 事件) ----------
// 必须挂在 window 上:文件落到输入框/面板/抽屉等任何位置,若没有 drop 处理,
// 浏览器默认行为是导航去打开它,当前草稿和正在流式的回合会一起丢失。
function pickDroppedFiles(dt) {
// dataTransfer 只在事件回调内有效,这里同步取完;目录在 files 里是 0 字节条目,必须跳过
const items = dt.items ? Array.prototype.slice.call(dt.items) : [];
if (!items.length) return { files: Array.prototype.slice.call(dt.files || []), dirs: 0 };
const files = [];
let dirs = 0;
for (const it of items) {
if (it.kind !== 'file') continue;
let entry = null;
try { entry = it.webkitGetAsEntry && it.webkitGetAsEntry(); } catch (_) {}
if (entry && entry.isDirectory) { dirs++; continue; }
const f = it.getAsFile();
if (f) files.push(f);
}
return { files, dirs };
}
(function bindDropUpload() {
const overlay = $('drop-overlay');
if (!overlay) return;
let depth = 0, resetTimer = 0;
// 拖动页面内选中的文字也会触发 dragenter,只认带 Files 的拖拽
function hasFiles(e) {
const types = e.dataTransfer && e.dataTransfer.types;
return !!types && Array.prototype.indexOf.call(types, 'Files') !== -1;
}
function show() {
clearTimeout(resetTimer);
depth = 1;
overlay.classList.remove('hidden');
}
function reset() {
depth = 0;
clearTimeout(resetTimer);
overlay.classList.add('hidden');
}
window.addEventListener('dragenter', e => {
if (!hasFiles(e)) return;
e.preventDefault(); // 旧版 Chrome/Safari 需要它才让区域接受拖放
if (!depth) depth = 1;
clearTimeout(resetTimer);
overlay.classList.remove('hidden');
});
window.addEventListener('dragover', e => {
if (!hasFiles(e)) return;
e.preventDefault(); // 缺这一步 drop 永远不会触发
e.dataTransfer.dropEffect = 'copy';
if (overlay.classList.contains('hidden')) show();
});
window.addEventListener('dragleave', e => {
if (!hasFiles(e)) return;
// 拖出窗口时浏览器不保证再配对一次 dragenter,relatedTarget 为 null 直接收干净
if (!e.relatedTarget) { reset(); return; }
depth = Math.max(0, depth - 1);
if (depth) return;
resetTimer = setTimeout(reset, 150);
});
window.addEventListener('dragend', reset);
window.addEventListener('drop', e => {
if (!hasFiles(e)) return;
e.preventDefault(); // 阻止浏览器默认的“打开文件”
reset();
const picked = pickDroppedFiles(e.dataTransfer);
if (picked.files.length) {
uploadFilesNow(picked.files).catch(er => toast('上传失败:' + (er && er.message || er)));
}
if (picked.dirs) toast('暂不支持拖入文件夹' + (picked.files.length ? ',已忽略' : ''));
});
})();
// ---------- 粘贴超长文本自动转 .txt 附件 ----------
// 延迟到发送时上传:粘贴不建档、不落盘,chip 可随时撤掉;阈值由 upload 配置下发(0=关闭)。
let pasteThreshold = Number(DEFAULT_UPLOAD_CFG.paste_to_file_threshold_chars) || 2000;
getUploadCfg().then(function (cfg) {
const n = Number(cfg.paste_to_file_threshold_chars);
if (Number.isFinite(n) && n >= 0) pasteThreshold = Math.floor(n);
}).catch(function () { /* 取不到配置就用默认阈值 */ });
function pastedTextName() {
const d = new Date(), p = function (n) { return String(n).padStart(2, '0'); };
return 'pasted-text-' + d.getFullYear() + p(d.getMonth() + 1) + p(d.getDate()) + '-' +
p(d.getHours()) + p(d.getMinutes()) + p(d.getSeconds()) + '.txt';
}
function addAttachmentFiles(files, titleSeed) {
for (const f of files) {
// 同名同大小视为同一次粘贴的重复表示(剪贴板可能给多份)
if (state.attachments.some(a => a.name === f.name && a.file && a.file.size === f.size)) continue;
state.attachments.push({ file: f, name: f.name, size: f.size, titleSeed: titleSeed || '' });
}
renderAttachChips();
updateSendBtn();
}
ta.addEventListener('paste', e => {
if (!pasteThreshold || !e.clipboardData) return; // 0 = 关闭捕获,走浏览器默认粘贴
// clipboardData 只在事件回调内有效:文本与文件都必须同步取完
const text = e.clipboardData.getData('text/plain') || '';
const files = [];
const items = e.clipboardData.items ? Array.prototype.slice.call(e.clipboardData.items) : [];
for (const it of items) {
if (it.kind !== 'file') continue;
const f = it.getAsFile();
if (f) files.push(f);
}
// 部分浏览器(iOS)只给 files 不给 items
if (!items.length && e.clipboardData.files) {
Array.prototype.push.apply(files, Array.prototype.slice.call(e.clipboardData.files));
}
const trimmed = text.trim();
if (trimmed.length <= pasteThreshold) {
// 文本不长:保持默认可编辑粘贴;纯文件剪贴板则拦掉浏览器插入文件名的行为
if (files.length) {
if (!trimmed.length) e.preventDefault();
addAttachmentFiles(files);
}
return;
}
// 超阈值:输入框不再灌大段文本;原文(不 trim,保留首尾空白与行尾)包成 .txt
e.preventDefault();
addAttachmentFiles([new File([text], pastedTextName(), { type: 'text/plain' })], trimmed.slice(0, 24));
// 同时带文件时文本已保住内容,只补非图片文件(Word/PPT 里的附件);图片多为排版噪音,略过
const extra = files.filter(f => !/^image\//.test(f.type || ''));
if (extra.length) addAttachmentFiles(extra);
toast('长文本已转为附件,发送时一并上传');
});
function renderAttachChips() {
const row = $('attach-chips');
row.classList.toggle('hidden', !state.attachments.length);
row.innerHTML = state.attachments.map((f, i) =>
'' + esc(f.name) + '' +
'').join('');
}
$('attach-chips').addEventListener('click', e => {
const rm = e.target.closest('.rm');
if (rm) { state.attachments.splice(+rm.dataset.i, 1); renderAttachChips(); }
});
// ---------- 抽屉 ----------
// 桌面端(≥960px):侧边栏常驻左侧列(由 body.drawer-open 驱动会话区偏移),不用遮罩;
// 移动端(<960px):仍为浮层抽屉 + 遮罩。
const drawerMQ = window.matchMedia('(min-width: 960px)');
function openDrawer(open) {
// 清掉手势拖动遗留的内联位移/透明度,改由 CSS transition 负责开合动画
const drawer = $('drawer'), scrim = $('scrim');
drawer.style.transform = ''; drawer.style.transition = '';
scrim.style.opacity = '';
drawer.classList.toggle('open', open);
scrim.classList.toggle('show', open && !drawerMQ.matches);
document.body.classList.toggle('drawer-open', open);
}
$('menu-btn').addEventListener('click', () => {
const open = !$('drawer').classList.contains('open');
openDrawer(open);
if (open) loadSessionList();
});
$('scrim').addEventListener('click', () => openDrawer(false));
let searchTimer = null;
$('search-input').addEventListener('input', () => {
clearTimeout(searchTimer);
searchTimer = setTimeout(loadSessionList, 250);
});
$('drawer-list').addEventListener('click', e => {
// 桌面端 hover 删除按钮:先于打开会话处理,点击弹删除确认 modal
const delBtn = e.target.closest('.conv-del');
if (delBtn) { e.stopPropagation(); deleteSession(delBtn.dataset.del); return; }
const item = e.target.closest('.conv-item');
if (!item) return;
// 设置页现在保留左栏(可在设置中看会话/文件):点会话即退出设置页回到对话。
if (typeof closeSettings === 'function' && !$('settings-page').classList.contains('hidden')) closeSettings();
openSession(item.dataset.id);
if (!drawerMQ.matches) openDrawer(false); // 桌面端侧栏常驻,选完会话不收起来
});
// ---------- 移动端右滑会话行露出删除按钮(iOS 风格) ----------
(function bindSwipeToDelete() {
const list = $('drawer-list');
const THRESHOLD = 60; // 滑过这个距离开
let g = null; // {x0, y0, t0, wrap, item, horiz, lastX, wasSwiped}
function onDown(e) {
if (e.touches.length !== 1) { g = null; return; }
const t = e.touches[0];
const item = e.target.closest('.conv-item');
const wrap = e.target.closest('.conv-wrap');
if (!item || !wrap) { g = null; return; }
// 关闭 transform 动画,保证跟手不粘滞
item.style.transition = 'none';
g = { x0: t.clientX, y0: t.clientY, t0: Date.now(), wrap, item, horiz: false, lastX: t.clientX };
}
function onMove(e) {
if (!g) return;
const t = e.touches[0];
const dx = t.clientX - g.x0;
const dy = t.clientY - g.y0;
// 先判断为横向手势才接管
if (!g.horiz) {
if (Math.abs(dx) < 8 && Math.abs(dy) < 8) return;
if (Math.abs(dy) > Math.abs(dx) + 6) { g = null; g.item.style.transition = ''; return; } // 竖向滚动,不接管
g.horiz = true;
}
// 跟手 clamp 到 [-60, 0]:负值左滑,正值右滑
const off = Math.max(-60, Math.min(0, dx));
g.item.style.transform = 'translateX(' + off + 'px)';
g.lastX = t.clientX;
}
function onUp(e) {
if (!g) return;
const t = (e.changedTouches && e.changedTouches[0]) || null;
const dx = t ? t.clientX - g.x0 : (g.lastX - g.x0);
const moved = Math.abs(dx);
// 恢复 transition(为 snap 提供动画)
g.item.style.transition = '';
if (g.horiz) {
if (moved >= THRESHOLD && dx < 0) {
// 左滑到位:弹删除确认 modal(不露 conv-del)
g.wrap.classList.remove('swiped');
g.item.style.transform = '';
deleteSession(g.item.dataset.id);
} else {
// 右滑到位 或 未达阈值:弹回
g.wrap.classList.remove('swiped');
g.item.style.transform = '';
}
} else {
// 未识别为横向:不动(交给 click 委派处理打开)
g.item.style.transform = '';
}
g = null;
}
list.addEventListener('touchstart', onDown, { passive: true });
list.addEventListener('touchmove', onMove, { passive: true });
list.addEventListener('touchend', onUp, { passive: true });
list.addEventListener('touchcancel', onUp, { passive: true });
})();
// 会话页左缘右滑 → 拉出历史抽屉:跟随手指平移,超过阈值/快速右滑松手即打开。
(function bindEdgeSwipe() {
const drawer = $('drawer'), scrim = $('scrim');
const EDGE = 160; // 触发识别的左缘宽度(px)
const MAX_OPACITY = 0.4; // 与 #scrim.show 背景一致
let g = null; // 当前手势 {x0,y0,t0,horiz,cancelled,off}
function uiBlocked() {
if (!$('settings-page').classList.contains('hidden')) return true;
if (!$('img-viewer').classList.contains('hidden')) return true;
if (!$('fs-viewer').classList.contains('hidden')) return true;
if ($('files-panel').classList.contains('open')) return true; // 文件面板展开时不响应
return !!document.querySelector('.modal-overlay:not(.hidden)');
}
function reset() {
drawer.style.transform = ''; drawer.style.transition = '';
scrim.style.opacity = '';
drawer.classList.remove('open');
scrim.classList.remove('show');
}
document.addEventListener('touchstart', e => {
if (drawer.classList.contains('open') || uiBlocked() || e.touches.length !== 1) { g = null; return; }
const t = e.touches[0];
if (t.clientX > EDGE) { g = null; return; } // 仅左缘起手
g = { x0: t.clientX, y0: t.clientY, t0: Date.now(), horiz: false, cancelled: false, off: 0 };
}, { passive: true });
document.addEventListener('touchmove', e => {
if (!g || g.cancelled) return;
const t = e.touches[0];
const dx = t.clientX - g.x0, dy = t.clientY - g.y0;
if (!g.horiz) {
if (Math.abs(dx) < 8 && Math.abs(dy) < 8) return; // 方向未定,等待
// 主轴判定带 6px 死区:明确右滑才接管,明确纵向/向左才放弃,模糊时继续观察。
// 两点教训:
// 1) 必须用绝对值比较——手指上滑时 dy 为负,有符号的 dy > dx 会把「上滑+几像素
// 右偏」误判成横向手势并 preventDefault,导致左缘向上滚动被接管卡死;
// 2) 拇指甩动轨迹天然带弧度,单帧 |dx| 略大不代表横向意图——一锤定音会误抢
// 斜向上滑动,故模糊区间不表态,等后续位移把方向差拉开再判。
if (dx > Math.abs(dy) + 6) g.horiz = true; // 明确右滑 → 接管
else if (dx < -6 || Math.abs(dy) > Math.abs(dx) + 6) { g.cancelled = true; return; } // 明确向左/纵向 → 放弃
else return; // 死区内,继续观察
}
e.preventDefault(); // 手势归属抽屉:阻止页面滚动/系统返回
const w = drawer.offsetWidth || 300;
g.off = Math.max(0, Math.min(dx, w));
if (!drawer.style.transition) drawer.style.transition = 'none'; // 跟手时不走 CSS 动画
drawer.classList.remove('open');
scrim.classList.add('show');
drawer.style.transform = 'translateX(calc(-102% + ' + g.off + 'px))';
scrim.style.opacity = (g.off / w) * MAX_OPACITY;
}, { passive: false });
function endDrag(e, commit) {
if (!g) return;
const w = drawer.offsetWidth || 300;
const dist = g.horiz ? g.off : 0;
const dt = Date.now() - g.t0;
const speed = dt > 0 ? dist / dt : 0; // px/ms
const open = commit && g.horiz && (dist >= 60 || dist / w >= 0.35 || (dist >= 24 && speed > 0.8));
reset();
if (open) {
openDrawer(true);
loadSessionList();
}
g = null;
}
document.addEventListener('touchend', e => endDrag(e, true), { passive: true });
document.addEventListener('touchcancel', e => endDrag(e, false), { passive: true });
})();
// 抽屉底部图标操作栏:文件树 / 预览 / 设置。
// 「文件树」是侧栏两个互斥面板的切换开关:不在文件页 → 切到文件树(高亮),
// 再点一次 → 回会话列表(不亮)。预览与设置不占用侧栏,高亮由 preview.js / settings.js 同步。
function setDrawerPane(files) {
// 窄屏没有文件树(只有输入行右侧的旧文件面板),任何调用方都不允许切过去
if (files && !drawerMQ.matches) return;
// 还没开始会话 = 没有任务目录:不切过去(否则只能切出一个写着「尚未开始会话」的空面板)
if (files && !state.sessionId) return;
// 文件树模块没加载成功时不要把一个空面板切出来
if (files && typeof window.showFileTree !== 'function') return;
const drawer = $('drawer');
const changed = drawer.classList.contains('drawer-mode-files') !== files;
drawer.classList.toggle('drawer-mode-files', files);
$('da-files').classList.toggle('active', files);
// 重复点当前项不重干活(不重拉列表/不重渲树),避免白掉请求和滚动位置
if (!changed) return;
if (files) window.showFileTree();
else loadSessionList();
}
$('da-files').addEventListener('click', () => {
setDrawerPane(!$('drawer').classList.contains('drawer-mode-files'));
});
// 窄屏只保留输入行右侧的旧「任务文件」面板,左栏不再提供文件树(按钮也已 CSS 隐藏)。
// 宽屏缩到窄屏时如果正停在文件页,先退回会话列表,避免出现两套文件 UI。
drawerMQ.addEventListener('change', (e) => { if (!e.matches) setDrawerPane(false); });
// 预览没有独立按钮:桌面端只在文件树里点文件时开窗(关窗走预览栏自己的关闭钮 / Esc)。
$('da-settings').addEventListener('click', () => {
if (typeof showSettings !== 'function') return;
const page = $('settings-page');
// 再点一次返回(关设置页);否则打开。不看当前在设置栈的第几层,都当"退出设置"
if (page && !page.classList.contains('hidden')) { closeSettings(); return; }
if (!drawerMQ.matches) openDrawer(false); // 移动端设置页整屏,抽屉先收起
showSettings();
});
// ---------- 顶栏 ----------