dsh-file-activity 0.4.6

package/lib/client.src.js

@@ -0,0 +1,65 @@
+/**
+ * dsh-file-activity — client half (browser).
+ *
+ * Extends dsh-better-sidebar with a "文件活动 / File Activity" tab:
+ *  - recent file access history (agent + sidebar operations),
+ *  - per-file create/modify/read counts flattened by folder, with multi-level
+ *    folders shown as dotted paths (a.b.c.d) and their files indented below,
+ *  - clicking any file opens a FLOATING preview that reuses the sidebar's
+ *    NATIVE viewer via `ctx.betterSidebar.matchFileViewer(path)` — its own
+ *    `component` is mounted (built-in markdown / code / image / pdf / html
+ *    renderers), so code gets syntax highlighting and markdown gets rendered
+ *    with no hand-rolled preview; clicking outside / Esc / × closes it,
+ *  - auto-opens once per session by default (toggleable in the sidebar
+ *    settings, enabled by default).
+ *
+ * Data source: the plugin host half (fs/observed for agent tools) + this
+ * half's fetch interception for sidebar file operations (fs.read / fs.write /
+ * /sidebar/file media opens), both persisted host-side; the tab polls
+ * /file-activity/api/stats.
+ *
+ * Styling follows the dsh-better-sidebar design language: all colors ride the
+ * DSH semantic tokens (--dsw-alias-*), typography rides the font roles
+ * (--dsw-font-*), motion rides --ds-*. Flat surfaces (no box-shadow), hairline
+ * borders, 28px circular icon controls with hover fills, and 8px-radius rows
+ * with hover fills. The stylesheet is injected once per activation and torn
+ * down with the fiber, so HMR/disable leaves no residue.
+ *
+ * BUILD NOTE: this file is the SOURCE TEMPLATE. scripts/build.mjs splices the
+ * `lib/parts/*.part.js` pieces into the PART placeholder markers below (each
+ * piece is plain function-declaration text sharing this factory scope; the
+ * browser ModuleLoader does not support relative-path require) and writes
+ * lib/client.js — the file actually served by DSH, which MUST be committed
+ * (CI runs node --check + tests against it, not against this template).
+ */
+window.__ModuleLoader__.load({
+  id: 'dsh-file-activity',
+  factory: (require) => {
+    var module = { exports: {} }
+    var exports = module.exports
+    Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
+    const { createElement, useEffect, useMemo, useState, useSyncExternalStore } = require('react')
+
+    const TAB_ID = 'file-activity:recent'
+    const AUTO_OPEN_KEY = 'dsh-file-activity:auto-opened:'
+    const POLL_MS = 6000
+
+    // ── parts (injected by scripts/build.mjs; keep this exact order — the
+    //    const initializers below run in splice order) ─────────────────────
+    __PART_I18N__
+    __PART_FORMAT__
+    __PART_TREE__
+    __PART_STORE__
+    __PART_API__
+    __PART_INTERCEPTOR__
+    __PART_AUTO_OPEN__
+    __PART_ICONS__
+    __PART_STYLES__
+    __PART_ROWS__
+    __PART_VIEW__
+    __PART_PREVIEW__
+    __PART_APPLY__
+
+    return module.exports
+  },
+})

package/lib/fence.js

@@ -0,0 +1,57 @@
+/**
+ * Trust fence for /file-activity routes: only loopback / explicitly trusted
+ * hosts may call the plugin's HTTP endpoints (same behavioral contract as the
+ * /api gateway). 403-refuses everything else, including cross-site requests.
+ */
+function header(headers, name) {
+  const value = headers[name]
+  return typeof value === 'string' ? value : undefined
+}
+
+function parseAuthority(authority) {
+  try {
+    return new URL(`http://${authority}`)
+  } catch {
+    return undefined
+  }
+}
+
+function isLoopbackHostname(hostname) {
+  if (hostname === 'localhost' || hostname === '[::1]') return true
+  const parts = hostname.split('.')
+  return parts.length === 4
+    && parts[0] === '127'
+    && parts.every((part) => /^\d{1,3}$/.test(part) && Number(part) <= 255)
+}
+
+function canonicalAuthority(entry, entryUrl) {
+  const port = entryUrl.port !== '' ? entryUrl.port : new URL(`https://${entry}`).port
+  return port === '' ? entryUrl.hostname : `${entryUrl.hostname}:${port}`
+}
+
+function isTrustedAuthority(hostUrl, trustedHosts) {
+  return trustedHosts.some((entry) => {
+    const entryUrl = parseAuthority(entry)
+    if (entryUrl === undefined) return false
+    return canonicalAuthority(entry, entryUrl) === entryUrl.hostname
+      ? entryUrl.hostname === hostUrl.hostname
+      : entryUrl.host === hostUrl.host
+  })
+}
+
+/** Host-header trust fence (same behavioral contract as the /api gateway). */
+export function isTrustedApiRequest(request, trustedHosts) {
+  const host = header(request.headers, 'host')
+  if (host === undefined) return false
+  const hostUrl = parseAuthority(host)
+  if (hostUrl === undefined) return false
+  if (!isLoopbackHostname(hostUrl.hostname) && !isTrustedAuthority(hostUrl, trustedHosts)) return false
+  if (header(request.headers, 'sec-fetch-site') === 'cross-site') return false
+  const origin = header(request.headers, 'origin')
+  if (origin === undefined) return true
+  try {
+    return new URL(origin).host === hostUrl.host
+  } catch {
+    return false
+  }
+}

package/lib/http.js

@@ -0,0 +1,34 @@
+/**
+ * HTTP helpers shared by the /file-activity routes: bounded JSON body
+ * reading, JSON responses, and session working-directory resolution.
+ */
+
+/** Read a JSON request body (bounded). */
+export async function readJsonBody(request) {
+  let body = ''
+  for await (const chunk of request) {
+    body += chunk
+    if (body.length > 1_000_000) throw new Error('request body too large')
+  }
+  if (body === '') return {}
+  return JSON.parse(body)
+}
+
+export function writeJson(response, status, value) {
+  const payload = JSON.stringify(value)
+  response.writeHead(status, { 'content-type': 'application/json', 'cache-control': 'no-cache' })
+  response.end(payload)
+}
+
+export function writeError(response, error) {
+  const message = error instanceof Error ? error.message : String(error)
+  writeJson(response, 400, { ok: false, error: { message } })
+}
+
+/** Session working directory, mirroring better-sidebar's resolution. */
+export function sessionCwdOf(ctx, sessionId) {
+  const session = ctx.sessions.get(sessionId)
+  const headerCwd = session?.header?.cwd
+  if (typeof headerCwd === 'string' && headerCwd !== '') return headerCwd
+  return process.cwd()
+}

package/lib/index.js

@@ -0,0 +1,50 @@
+/**
+ * dsh-file-activity — host half.
+ *
+ * Tracks file activity for dsh-better-sidebar:
+ *  - agent tool file operations arrive as `fs/observed` events (read / write /
+ *    edit / str_replace_editor / read_image ...), with the tool execution as
+ *    the actor (name + parsed arguments + owning agent).
+ *  - sidebar operations (files opened / saved through the better-sidebar
+ *    explorer & editor) are reported by our client half through the
+ *    `/file-activity/api/record` route.
+ *
+ * State (recent history + per-file counts) is kept per session and persisted
+ * to $DSH_HOME/file-activity.json (atomic tmp+rename, debounced).
+ */
+import { isTrustedApiRequest } from './fence.js'
+import { createApiHandler } from './api-route.js'
+import { createMediaHandler } from './media-route.js'
+import { createFsObserver } from './observer.js'
+import { createStore } from './store.js'
+
+export const name = 'dsh-file-activity'
+
+export const inject = ['webServer', 'sessions', 'webRuntime']
+
+export function apply(ctx) {
+  const store = createStore(ctx)
+
+  // ── agent-side file operations ──────────────────────────────────────────
+  ctx.on('fs/observed', createFsObserver(store.record))
+
+  // ── routes ──────────────────────────────────────────────────────────────
+  const fence = (request) => isTrustedApiRequest(request, ctx.webRuntime.trustedHosts)
+
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'prefix',
+    path: '/file-activity/api',
+    handler: createApiHandler({ ctx, store, fence }),
+  }), 'dsh-file-activity: /file-activity/api routes')
+
+  // Media route for the floating preview (see media-route.js for the
+  // authorization model: recorded paths only, same trust fence).
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'prefix',
+    path: '/file-activity/file',
+    handler: createMediaHandler({ ctx, store, fence }),
+  }), 'dsh-file-activity: /file-activity/file media route')
+
+  // Tear down on unload: flush pending persistence.
+  ctx.effect(() => store.dispose, 'dsh-file-activity: persistence teardown')
+}

package/lib/media-route.js

@@ -0,0 +1,93 @@
+/**
+ * /file-activity/file media route: serves recorded file bytes (images / PDFs)
+ * for the floating preview. The sidebar's own /sidebar/file route refuses
+ * every path outside the session working directory (isWithin(cwd, …)), but
+ * file activity records files the agent touched ANYWHERE — /tmp scratch files,
+ * sibling repos, … — so images/PDFs outside the workspace resolve to a broken
+ * <img>. This route serves the bytes with the same trust fence, swapping the
+ * "inside the session cwd" boundary for "paths this session actually
+ * recorded".
+ */
+import { readFile, stat } from 'node:fs/promises'
+import { basename, isAbsolute, join } from 'node:path'
+import { sessionCwdOf, writeJson } from './http.js'
+import { isRecordedPath } from './state.js'
+
+/** Cap for the plugin's own media route (bytes): images / PDFs only. */
+const MEDIA_LIMIT = 64 * 1024 * 1024
+
+/** Content types served by /file-activity/file (mirrors the sidebar's set). */
+const MEDIA_TYPES = {
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif',
+  '.webp': 'image/webp',
+  '.svg': 'image/svg+xml',
+  '.bmp': 'image/bmp',
+  '.ico': 'image/x-icon',
+  '.avif': 'image/avif',
+  '.pdf': 'application/pdf',
+}
+
+function mediaTypeForPath(path) {
+  const dot = path.lastIndexOf('.')
+  const ext = dot === -1 ? '' : path.slice(dot).toLowerCase()
+  return MEDIA_TYPES[ext] ?? 'application/octet-stream'
+}
+
+/** Error carrying an HTTP status, for the media route's catch-all. */
+function mediaError(status, message) {
+  const error = new Error(message)
+  error.status = status
+  return error
+}
+
+export function createMediaHandler({ ctx, store, fence }) {
+  return async (request, response) => {
+    if (!fence(request)) {
+      writeJson(response, 403, { ok: false, error: { code: 'forbidden', message: 'forbidden' } })
+      return
+    }
+    if (request.method !== 'GET') {
+      writeJson(response, 405, { ok: false, error: { message: 'method not allowed' } })
+      return
+    }
+    try {
+      const url = new URL(request.url ?? '/', 'http://dsh.internal')
+      const sessionId = url.searchParams.get('sessionId')
+      const raw = url.searchParams.get('path')
+      assertMediaParams(sessionId, raw)
+      if (!isRecordedPath(store.state, sessionId, raw)) throw mediaError(403, 'path is not in this session\'s file activity')
+      const abs = isAbsolute(raw) ? raw : join(sessionCwdOf(ctx, sessionId), raw)
+      await serveMedia(response, abs, url)
+    } catch (error) {
+      const status = typeof error?.status === 'number' ? error.status : 400
+      writeJson(response, status, { ok: false, error: { message: error instanceof Error ? error.message : String(error) } })
+    }
+  }
+}
+
+/** Both query parameters are required for a media request. */
+function assertMediaParams(sessionId, raw) {
+  if (sessionId === null || raw === null || raw === '') throw mediaError(400, 'sessionId and path are required')
+}
+
+/** stat + read + respond with the file's bytes (bounded by MEDIA_LIMIT). */
+async function serveMedia(response, abs, url) {
+  let info
+  try {
+    info = await stat(abs)
+  } catch {
+    throw mediaError(404, 'file not found')
+  }
+  if (!info.isFile()) throw mediaError(400, 'not a file')
+  if (info.size > MEDIA_LIMIT) throw mediaError(413, 'file too large')
+  const body = await readFile(abs)
+  const headers = { 'content-type': mediaTypeForPath(abs), 'cache-control': 'no-cache' }
+  if (url.searchParams.get('download') === '1') {
+    headers['content-disposition'] = `attachment; filename*=UTF-8''${encodeURIComponent(basename(abs))}`
+  }
+  response.writeHead(200, headers)
+  response.end(body)
+}

package/lib/observer.js

@@ -0,0 +1,41 @@
+/**
+ * fs/observed event listener factory: filters noise (absent observations,
+ * missing actors / session ids / tool names), resolves the touched path
+ * (backend displayPath preferred, falling back to the file_path argument)
+ * and records it through the store's record().
+ */
+import { mapOp } from './state.js'
+
+export function createFsObserver(record) {
+  return (target, observation, actor) => {
+    // Only authoritative PRESENT observations mean a file was actually
+    // touched; absent observations (e.g. a failed read of a missing file)
+    // are noise.
+    if (!isPresentObservation(observation)) return
+    if (!isValidActor(actor)) return
+    const sessionId = actor.agent?.id
+    if (typeof sessionId !== 'string' || sessionId === '') return
+    // Prefer the backend-resolved absolute path; fall back to the raw argument.
+    const rawPath = resolveObservedPath(target, actor)
+    if (rawPath === '') return
+    record(sessionId, rawPath, mapOp(actor.name), Date.now())
+  }
+}
+
+/** A PRESENT observation is the only authoritative "file was touched" signal. */
+function isPresentObservation(observation) {
+  return observation !== undefined && observation !== null && observation.kind === 'present'
+}
+
+/** The actor must exist and carry a non-empty string tool name. */
+function isValidActor(actor) {
+  return actor !== undefined && actor !== null && typeof actor.name === 'string' && actor.name !== ''
+}
+
+/** Resolve the touched path: backend displayPath preferred, else file_path. */
+function resolveObservedPath(target, actor) {
+  if (typeof target?.displayPath === 'string' && target.displayPath !== '') return target.displayPath
+  const args = actor.arguments
+  if (args !== null && typeof args === 'object' && typeof args.file_path === 'string') return args.file_path
+  return ''
+}

package/lib/parts/api.part.js

@@ -0,0 +1,45 @@
+    // ── data access (host routes) ─────────────────────────────────────────
+    async function fetchStats(sessionId) {
+      const response = await fetch(`/file-activity/api/stats?sessionId=${encodeURIComponent(sessionId)}`)
+      const json = await response.json()
+      if (json === null || typeof json !== 'object' || json.ok !== true) return null
+      return json.value
+    }
+
+    /** Resolve the session working directory through the sidebar's native API. */
+    async function fetchSessionCwd(sessionId) {
+      try {
+        const response = await fetch('/sidebar/api/session.cwd', {
+          method: 'POST',
+          headers: { 'content-type': 'application/json' },
+          body: JSON.stringify({ sessionId }),
+        })
+        const json = await response.json()
+        const cwd = json?.value?.cwd
+        return typeof cwd === 'string' && cwd !== '' ? cwd : ''
+      } catch {
+        return ''
+      }
+    }
+
+    function postRecord(sessionId, path, op) {
+      if (typeof sessionId !== 'string' || sessionId === '' || typeof path !== 'string' || path === '') return
+      void fetch('/file-activity/api/record', {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ sessionId, path, op }),
+      }).catch(() => {})
+    }
+
+    function postClear(sessionId) {
+      void fetch('/file-activity/api/clear', {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ sessionId }),
+      }).catch(() => {})
+    }
+
+    /** Plugin media route URL for a recorded path (authorized per session). */
+    function mediaUrlOf(sessionId, path) {
+      return `/file-activity/file?${new URLSearchParams({ sessionId, path })}`
+    }

package/lib/parts/apply.part.js

@@ -0,0 +1,76 @@
+    // ── plugin body ───────────────────────────────────────────────────────
+    /**
+     * The stylesheet is pure static CSS and must NOT depend on the
+     * betterSidebar service: inject it first, unconditionally. If it lived
+     * behind the `service === undefined` early return, an HMR rebuild or
+     * service reload could leave the already-rendered tab WITHOUT its
+     * stylesheet — the raw white-text list you see when the CSS is gone.
+     * Each fiber owns its own <style> element and the disposer removes
+     * only that element, so a rebuild always keeps at least one copy.
+     */
+    function injectStyles(ctx) {
+      ctx.effect(() => {
+        if (typeof document === 'undefined' || document === null || typeof document.head === 'undefined') return () => {}
+        const style = document.createElement('style')
+        style.setAttribute('data-dsh-file-activity', 'styles')
+        style.textContent = STYLES
+        document.head.appendChild(style)
+        return () => {
+          if (style.parentNode) style.parentNode.removeChild(style)
+        }
+      }, 'dsh-file-activity: styles')
+    }
+
+    /** Mount probe: report client activation to the host state (synthetic
+     *  session id, invisible in the UI — confirms the client half actually
+     *  loaded after a page refresh). */
+    function mountProbe() {
+      void fetch('/file-activity/api/record', {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ sessionId: '__probe__', path: 'mounted', op: 'read' }),
+      }).catch(() => {})
+    }
+
+    /** Register the tab (enabled by default in the Side card settings). */
+    function registerTab(ctx, dataStore) {
+      const service = ctx.betterSidebar
+      ctx.effect(() => service.registerTab({
+        id: TAB_ID,
+        title: () => strings.title(),
+        icon: (size) => icon.clock(size),
+        order: 15,
+        single: true,
+        settings: {
+          pluginToggles: [{
+            key: 'autoOpen',
+            title: () => (isZh() ? '会话开始时自动打开' : 'Auto-open on session start'),
+            desc: () => (isZh() ? '每个会话首次打开时自动显示本页（可在侧边栏设置中关闭）' : 'Opens this tab once per session by default (turn off here)'),
+            type: 'switch',
+          }],
+        },
+        component: (props) => createElement(FileActivityView, { ...props, dataStore }),
+      }), 'dsh-file-activity: tab registration')
+    }
+
+    exports.inject = ['betterSidebar']
+
+    exports.apply = function apply(ctx) {
+      // Stylesheet first, unconditionally (HMR pitfall — see injectStyles).
+      injectStyles(ctx)
+      const service = ctx.betterSidebar
+      if (service === undefined) return
+
+      // Per-session data store: { bySession: { [sessionId]: { recent, counts, loading } }, preview }
+      // Each conversation reads/writes only its own bucket, so switching
+      // sessions never leaks another session's file activity into the view.
+      const dataStore = createStore({ bySession: {}, preview: null })
+      mountProbe()
+
+      // sidebar operations → host record route
+      ctx.effect(() => installFetchInterceptor(), 'dsh-file-activity: sidebar fetch observation')
+      registerTab(ctx, dataStore)
+
+      // auto-open once per session (default on)
+      ctx.effect(() => installAutoOpen(ctx, TAB_ID), 'dsh-file-activity: auto-open')
+    }

package/lib/parts/auto-open.part.js

@@ -0,0 +1,75 @@
+    // ── auto-open (enabled by default) ────────────────────────────────────
+    function findTabIn(state, tabId) {
+      const leaves = (node) => (node.kind === 'leaf' ? [node] : (node.children ?? []).flatMap(leaves))
+      for (const node of [state?.splits, state?.bottomSplits]) {
+        if (node === undefined || node === null) continue
+        for (const leaf of leaves(node)) {
+          if ((leaf.tabs ?? []).some((tab) => tab.type === tabId)) return true
+        }
+      }
+      return false
+    }
+
+    /** Current sidebar snapshot, or null when the service is not ready. */
+    function sidebarSnapshot(service) {
+      try {
+        return service.getSnapshot?.()
+      } catch {
+        return null
+      }
+    }
+
+    /** The user disabled auto-open for this tab in the sidebar settings. */
+    function isAutoOpenDisabled(snapshot, tabId) {
+      const settings = snapshot.prefs?.pluginSettings?.[tabId]
+      return settings !== undefined && settings.autoOpen === false
+    }
+
+    /** Whether this session was already auto-opened (localStorage marker). */
+    function isAutoOpenMarked(sessionId) {
+      try {
+        return Boolean(window.localStorage.getItem(AUTO_OPEN_KEY + sessionId))
+      } catch {
+        return true
+      }
+    }
+
+    /** Persist the auto-opened marker for this session. */
+    function markAutoOpened(sessionId) {
+      try {
+        window.localStorage.setItem(AUTO_OPEN_KEY + sessionId, '1')
+      } catch {
+        // ignore
+      }
+    }
+
+    /** Open the tab once per session unless disabled in the plugin settings. */
+    function tryAutoOpen(service, tabId) {
+      const snapshot = sidebarSnapshot(service)
+      if (snapshot === undefined || snapshot === null || snapshot.sessionId === undefined || snapshot.state === undefined) return
+      const sessionId = snapshot.sessionId
+      if (isAutoOpenDisabled(snapshot, tabId)) return
+      if (isAutoOpenMarked(sessionId)) return
+      if (findTabIn(snapshot.state, tabId)) {
+        markAutoOpened(sessionId)
+        return
+      }
+      try {
+        service.openTab({ type: tabId, title: strings.title(), path: '' })
+        markAutoOpened(sessionId)
+      } catch (error) {
+        console.error('[dsh-file-activity] auto-open failed:', error)
+      }
+    }
+
+    function installAutoOpen(ctx, tabId) {
+      const service = ctx.betterSidebar
+      tryAutoOpen(service, tabId)
+      let off = () => {}
+      try {
+        off = service.subscribeState?.(() => tryAutoOpen(service, tabId)) ?? off
+      } catch {
+        // service may lack subscribeState on older versions
+      }
+      return off
+    }

package/lib/parts/format.part.js

@@ -0,0 +1,28 @@
+    // ── path / time formatting helpers ────────────────────────────────────
+    function basenameOf(path) {
+      const norm = path.split('\\').join('/')
+      const idx = norm.lastIndexOf('/')
+      return idx === -1 ? norm : norm.slice(idx + 1)
+    }
+
+    /** Compact relative time: 刚刚 / N 分钟前 / N 小时前 / N 天前 / MM/DD. */
+    function formatRelative(time) {
+      if (typeof time !== 'number' || !Number.isFinite(time)) return ''
+      const diff = Date.now() - time
+      if (diff < 30_000) return strings.justNow()
+      const minutes = Math.floor(diff / 60_000)
+      if (minutes < 60) return strings.minutesAgo(minutes)
+      const hours = Math.floor(minutes / 60)
+      if (hours < 24) return strings.hoursAgo(hours)
+      const days = Math.floor(hours / 24)
+      if (days < 7) return strings.daysAgo(days)
+      const date = new Date(time)
+      return `${date.getMonth() + 1}/${date.getDate()}`
+    }
+
+    /** Local wall-clock HH:MM:SS (used in tooltips; full precision). */
+    function formatTime(time) {
+      const date = new Date(time)
+      const pad = (n) => String(n).padStart(2, '0')
+      return `${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`
+    }

package/lib/parts/i18n.part.js

@@ -0,0 +1,40 @@
+    // ── i18n ──────────────────────────────────────────────────────────────
+    function isZh() {
+      try {
+        const lang = (navigator.language || 'en').toLowerCase()
+        return lang.startsWith('zh')
+      } catch {
+        return false
+      }
+    }
+
+    const strings = {
+      title: () => (isZh() ? '文件活动' : 'File Activity'),
+      recent: () => (isZh() ? '最近访问' : 'Recent'),
+      stats: () => (isZh() ? '文件统计' : 'File Stats'),
+      empty: () => (isZh() ? '暂无文件活动记录' : 'No file activity yet'),
+      emptyHint: () => (isZh()
+        ? '在侧边栏打开文件、编辑保存，或让 agent 读写文件（创建/读取/修改），都会记录在这里。点击任意文件将在侧边栏内用原生预览打开（代码高亮 / Markdown 渲染 / 图片 / PDF…）。'
+        : 'Opening files in the sidebar, editing, or agent file operations (create/read/modify) are recorded here. Click any file to open it in the sidebar with native preview (syntax highlighting / Markdown rendering / images / PDF…).'),
+      refresh: () => (isZh() ? '刷新' : 'Refresh'),
+      clear: () => (isZh() ? '清空' : 'Clear'),
+      clearConfirm: () => (isZh() ? '确定清空当前会话的全部文件活动记录？' : 'Clear all file activity for this session?'),
+      read: () => (isZh() ? '读取' : 'read'),
+      create: () => (isZh() ? '新增' : 'create'),
+      modify: () => (isZh() ? '修改' : 'modify'),
+      readShort: () => (isZh() ? '读' : 'R'),
+      createShort: () => (isZh() ? '增' : 'C'),
+      modifyShort: () => (isZh() ? '改' : 'M'),
+      loadError: () => (isZh() ? '加载失败' : 'Load failed'),
+      created: () => (isZh() ? '创建' : 'Created'),
+      lastSeen: () => (isZh() ? '最近访问' : 'Last seen'),
+      justNow: () => (isZh() ? '刚刚' : 'just now'),
+      minutesAgo: (m) => (isZh() ? `${m} 分钟前` : `${m}m ago`),
+      hoursAgo: (h) => (isZh() ? `${h} 小时前` : `${h}h ago`),
+      daysAgo: (d) => (isZh() ? `${d} 天前` : `${d}d ago`),
+      closePreview: () => (isZh() ? '关闭预览' : 'Close preview'),
+      loading: () => (isZh() ? '加载中…' : 'Loading…'),
+      previewUnsupported: () => (isZh() ? '该文件类型暂不支持预览' : 'This file type cannot be previewed yet'),
+      previewFailed: () => (isZh() ? '预览加载失败' : 'Preview failed to load'),
+      downloadToView: () => (isZh() ? '下载查看' : 'download to view'),
+    }

package/lib/parts/icons.part.js

@@ -0,0 +1,48 @@
+    // ── icons (inline, stroke=currentColor, matching better-sidebar) ──────
+    const ICON_STROKE = 1.8
+    const iconSvg = (children, size) =>
+      createElement('svg', {
+        width: size, height: size, viewBox: '0 0 24 24', fill: 'none',
+        stroke: 'currentColor', strokeWidth: ICON_STROKE, strokeLinecap: 'round', strokeLinejoin: 'round',
+        'aria-hidden': 'true',
+      }, children.map((child, i) => (child === null || child === undefined || typeof child === 'boolean')
+        ? child
+        : createElement(child.type, { key: i, ...child.props })))
+
+    const icon = {
+      clock: (size = 16) => iconSvg([
+        createElement('circle', { cx: 12, cy: 12, r: 9 }),
+        createElement('path', { d: 'M12 7v5l3 2' }),
+      ], size),
+      refresh: (size = 16) => iconSvg([
+        createElement('path', { d: 'M21 12a9 9 0 1 1-2.64-6.36' }),
+        createElement('polyline', { points: '21 3 21 9 15 9' }),
+      ], size),
+      trash: (size = 16) => iconSvg([
+        createElement('path', { d: 'M3 6h18' }),
+        createElement('path', { d: 'M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6' }),
+        createElement('path', { d: 'M8 6V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2' }),
+      ], size),
+      chevronRight: (size = 14) => iconSvg([
+        createElement('polyline', { points: '9 6 15 12 9 18' }),
+      ], size),
+      chevronDown: (size = 14) => iconSvg([
+        createElement('polyline', { points: '6 9 12 15 18 9' }),
+      ], size),
+      file: (size = 16) => iconSvg([
+        createElement('path', { d: 'M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z' }),
+        createElement('path', { d: 'M14 2v6h6' }),
+      ], size),
+      folder: (size = 16) => iconSvg([
+        createElement('path', { d: 'M3 7a2 2 0 0 1 2-2h4l2 2h8a2 2 0 0 1 2 2v9a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z' }),
+      ], size),
+      external: (size = 15) => iconSvg([
+        createElement('path', { d: 'M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6' }),
+        createElement('polyline', { points: '15 3 21 3 21 9' }),
+        createElement('line', { x1: 10, y1: 14, x2: 21, y2: 3 }),
+      ], size),
+      close: (size = 15) => iconSvg([
+        createElement('line', { x1: 18, y1: 6, x2: 6, y2: 18 }),
+        createElement('line', { x1: 6, y1: 6, x2: 18, y2: 18 }),
+      ], size),
+    }