dsh-sansheng-liubu/ds-bot/src/host/folders.js

231 lines
12 KiB
JavaScript

// Working folders: where a Bot's Sessions run. A group's folder holds for every member
// there, else a Bot works in its own folder, else in the team workspace. A Session's
// folder is fixed when it is made, so a change moves the conversation on to a fresh
// part (parts.js).
import { mkdir, realpath, stat } from 'node:fs/promises'
import { homedir } from 'node:os'
import { basename, dirname, isAbsolute, join, resolve, sep } from 'node:path'
import { unquote } from './text.js'
const PICK_TIMEOUT_MS = 10 * 60_000
export const within = (inner, outer) => inner === outer || inner.startsWith(outer.endsWith(sep) ? outer : outer + sep)
const expandHome = text => (text === '~' ? homedir() : /^~[\\/]/.test(text) ? join(homedir(), text.slice(2)) : text)
// Read as DSH reads it, so the team's data and the guarded folder are where DSH keeps
// its own: a blank value counts as unset.
export const dshHomeOf = value => resolve(expandHome(value?.trim() ? value : join(homedir(), '.dsh')))
export function install(rt) {
const { ctx, state } = rt
const teamFolder = () => ctx.workspaceRegistry.get?.(state.workspaceId)?.path
// The desktop app names the folder the user chose for the Bots' files.
const defaultTeamFolder = () => rt.config.workspace ?? (process.env.DS_BOT_WORKSPACE?.trim() || join(rt.home, 'workspace'))
// A member's own pick inside one group, made with working_directory there: a path,
// or null for the team workspace, which a missing entry would read as the Bot's
// folder. A group's folder outranks it; without one the Bot's folder is the default.
const workDirOf = ({ botId, roomId } = {}) => {
const room = rt.roomOf(roomId)
if (room?.workDir !== undefined) return room.workDir
if (room !== undefined && botId !== undefined && Object.hasOwn(room.memberDirs ?? {}, botId)) return room.memberDirs[botId] ?? undefined
return rt.botOf(botId)?.workDir
}
const isFolder = path => stat(path).then(info => info.isDirectory(), () => false)
const real = path => realpath(path).catch(() => resolve(path))
// The real path of the deepest part that exists, with the rest after it.
const realBeyond = async (path) => {
const rest = []
for (let at = path; ; at = dirname(at)) {
const found = await realpath(at).catch(() => undefined)
if (found !== undefined) return join(found, ...rest)
if (dirname(at) === at) return path
rest.unshift(basename(at))
}
}
// The registry keeps the team workspace as it was given; folders compare as real paths.
const realTeam = async () => {
const team = teamFolder()
return team === undefined ? undefined : real(team)
}
// Where `input` leads from `base`, as a real path, the way DSH's working_directory resolves
// a change; undefined when nothing is there.
const folderAt = (base, input) => realpath(resolve(base, input)).catch(() => undefined)
// Where a Session works: the folder DSH has for it, else the one DS Bot made it for.
const sessionFolder = (session) => {
const reported = session?.header === undefined ? undefined : ctx.get?.('workingDirectory')?.get?.(session) ?? session.header.cwd
if (reported !== undefined) return reported
const id = session?.id
const room = rt.roomOf(id)
if (room !== undefined) return workDirOf({ roomId: room.id }) ?? teamFolder()
return workDirOf({ botId: rt.selfOf?.(id), roomId: rt.groupOwners?.get(id)?.roomId }) ?? teamFolder()
}
// The desktop app runs its own DSH and names the user's, which Bots must not write either.
const dataRoots = () => [rt.dshHome, rt.home, process.env.DS_BOT_USER_DSH_HOME?.trim()].filter(Boolean)
// A Bot that could write where DSH or the team keeps its data could change its own
// permissions or the team, so neither those folders nor one that holds them is allowed.
// The workspace exception covers only a workspace lying inside the data root (the
// plugin's default does): one that holds or is a data root does not open it up.
async function guarded(path) {
const team = await realTeam()
for (const root of dataRoots()) {
const data = await real(root)
if (within(data, path)) return true
if (within(path, data) && !(team !== undefined && within(path, team) && team !== data && within(team, data))) return true
}
return false
}
// A file a Bot names to read into the team, such as a photo, may not come from DSH's or
// the team's data; the team workspace, which can lie in it, is the exception, for the
// same reason as in guarded().
async function inData(path) {
const team = await realTeam()
for (const root of dataRoots()) {
const data = await real(root)
if (within(path, data) && !(team !== undefined && within(path, team) && team !== data && within(team, data))) return true
}
return false
}
// Saved as the real path, which is what a Session's cwd shows. Undefined means the
// team workspace.
async function cleanWorkDir(input) {
const text = unquote(input)
if (text === '') return undefined
const expanded = expandHome(text)
if (!isAbsolute(expanded)) throw new Error(`Give the full path of the folder, not ${text}`)
let path
try {
path = await realpath(expanded)
} catch {
throw new Error(`There is no folder at ${text}`)
}
if (!(await isFolder(path))) throw new Error(`${text} is a file, not a folder`)
return workFolder(path)
}
// A folder, as a real path, as a working folder: undefined for the team workspace.
async function workFolder(path) {
if (await guarded(path)) throw new Error(`${path} holds DeepSeek Harness data, so Bots cannot work there`)
return path === await realTeam() ? undefined : path
}
// The user moves the team workspace. Bots and groups without a folder of their own move on
// to a fresh part there at their next turn, as for any other change of folder; the old
// folder and its files stay as they are.
async function setTeamWorkspace(input) {
const text = unquote(input)
const expanded = expandHome(text)
if (text === '' || !isAbsolute(expanded)) throw new Error(`Give the full path of the folder, not ${text}`)
// The plugin's own default lies in DSH's data, and going back to it stays possible: that
// folder itself, not where a link put in its place leads.
const fallback = resolve(defaultTeamFolder())
const own = join(await realBeyond(dirname(fallback)), basename(fallback))
const holdsData = async (path) => {
const roots = await Promise.all(dataRoots().map(real))
if (roots.some(data => within(data, path))) return true
if (path === own && await realBeyond(fallback) === own) return false
return roots.some(data => within(path, data))
}
// A folder to be made counts where it would be made: a link above it can lead into the data.
if (await holdsData(await realBeyond(resolve(expanded)))) throw new Error(`${text} holds DeepSeek Harness data, so it cannot be the team workspace`)
await mkdir(expanded, { recursive: true })
const path = await realpath(expanded)
if (!(await isFolder(path))) throw new Error(`${text} is a file, not a folder`)
if (await holdsData(path)) throw new Error(`${text} holds DeepSeek Harness data, so it cannot be the team workspace`)
if (path === await realTeam()) return path
const clash = await rt.privateClash(path)
if (clash) throw new Error(`${text} is in or around the folder of ${clash.name}, a private Bot, so it cannot be the team workspace`)
const workspace = await ctx.workspaceRegistry.resolveByPath(path) ?? await ctx.workspaceRegistry.create(path, 'DS Bot')
state.workspaceId = workspace.id
await rt.save()
return path
}
// Every Session of a Bot: its own chat and its conversation in each of its groups.
const sessionsOfBot = botId => [rt.chatOf(botId), ...Object.values(state.rooms)
.filter(room => room.members.includes(botId)).map(room => room.sessions?.[botId])].filter(Boolean)
// A folder outside the team workspace widens where a Bot may write, so a Bot that
// sets one for Bots whose writes are bounded by their folder asks the user first.
// `sessions` are the Sessions that would work there; the default policy counts too,
// since the Sessions made there later start under it. Throws when it is not allowed.
async function approveFolder(exec, { path, sessions = [], who }) {
const team = await realTeam()
const policy = ctx.get?.('sandboxPolicy')
if (path === undefined || (team !== undefined && within(path, team))) return
if (policy !== undefined) {
const agents = await Promise.all(sessions.map(id => rt.resolveAgent(id)))
const modes = [policy.resolve(), ...agents.map(agent => policy.resolve({ session: agent.session }))].map(entry => entry.mode)
if (!modes.includes('workspace-write')) return
}
// With no policy service a Session's bounds cannot be checked, so a folder outside
// the workspace asks like a bounded one would; when nobody can be asked it throws.
const approval = ctx.get?.('approval')
const agent = exec.agent
if (approval === undefined || agent?.session === undefined) throw new Error(`Working in ${path} needs the user's approval, and there is no way to ask for it here, so nothing changed. The user can make this change in the settings.`)
const outcome = await approval.request({
agent,
toolName: exec.name,
...(exec.callId !== undefined ? { callId: exec.callId } : {}),
reason: `Let ${who.en} work in ${path}? Files there can then be changed.`,
displayReason: { en: `Let ${who.en} work in ${path}? Files there can then be changed.`, zh: `允许${who.zh}在 ${path} 中工作吗?之后可以修改这个文件夹里的文件。` },
...(exec.signal ? { signal: exec.signal } : {}),
})
if (outcome === 'allowed-once') return
// An approval policy that never asks answers 'rejected' as well.
throw new Error(outcome === 'rejected' ? `Working in ${path} was not allowed, so nothing changed. The user can make this change in the settings.`
: outcome === 'cancelled' ? 'The approval was cancelled, so nothing changed.'
: `Working in ${path} needs the user's approval, and no one could answer, so nothing changed. The user can make this change in the settings.`)
}
const picker = () => {
try {
return ctx.get?.('directoryPicker')?.capability()
} catch {
return undefined
}
}
async function folderEndpoint(endpoint, body, signal) {
switch (endpoint) {
case 'folders': {
// A copied team has its workspace registered at its first turn; until then it is the default.
const team = teamFolder() ?? resolve(defaultTeamFolder())
const known = new Map()
for (const workspace of ctx.workspaceRegistry.list?.() ?? []) {
if (workspace.path !== team) known.set(workspace.path, workspace.title)
}
for (const entry of [...Object.values(state.bots), ...Object.values(state.rooms)]) {
if (entry.workDir && !known.has(entry.workDir)) known.set(entry.workDir, basename(entry.workDir) || entry.workDir)
}
const present = await Promise.all([...known].map(async ([path, title]) => (await isFolder(path) ? { path, title } : undefined)))
const kind = picker()?.kind
return {
team,
picker: kind === 'native' || kind === 'browse' ? kind : null,
folders: present.filter(Boolean),
}
}
case 'folder-pick': {
const native = picker()
if (native?.kind !== 'native') throw new Error('This DeepSeek Harness has no folder chooser')
return await native.pick(AbortSignal.any([signal, AbortSignal.timeout(PICK_TIMEOUT_MS)].filter(Boolean)))
}
case 'folder-list': {
const browse = picker()
if (browse?.kind !== 'browse') throw new Error('This DeepSeek Harness cannot list folders')
const listing = await browse.list(typeof body.path === 'string' && body.path !== '' ? body.path : undefined, signal)
return { path: listing.path, home: listing.home, crumbs: listing.crumbs, entries: listing.entries, truncated: listing.truncated }
}
default:
throw new Error(`Unknown endpoint ${endpoint}`)
}
}
Object.assign(rt, { teamFolder, defaultTeamFolder, workDirOf, sessionFolder, isFolder, real, realBeyond, folderAt, cleanWorkDir, workFolder, inData, setTeamWorkspace, sessionsOfBot, approveFolder, folderEndpoint })
}