diff --git a/vendor/dsh-brain/lib/api.js b/vendor/dsh-brain/lib/api.js new file mode 100644 index 0000000..57ffb5b --- /dev/null +++ b/vendor/dsh-brain/lib/api.js @@ -0,0 +1,319 @@ +/** + * Derive the dashboard auth root (`/api/auth`) from the memory base URL + * (`.../api/longmemory`): login and token minting live one segment over. + */ +function authBase(baseUrl) { + try { + const url = new URL(baseUrl); + const prefix = url.pathname.replace(/\/longmemory\/?$/i, ''); + return `${url.origin}${prefix}/auth`; + } + catch { + return ''; + } +} +/** True when sending a password to this URL is safe (TLS, or loopback). */ +export function isSecureLoginTarget(baseUrl) { + try { + const url = new URL(baseUrl); + if (url.protocol === 'https:') + return true; + return url.protocol === 'http:' && ['127.0.0.1', 'localhost', '[::1]'].includes(url.hostname); + } + catch { + return false; + } +} +/** Pull the first cookie pair out of one or more Set-Cookie headers. */ +function sessionCookieOf(headers) { + // `getSetCookie` exists on undici/Node 18.14+ but is not in every Headers type. + const withCookies = headers; + const list = typeof withCookies.getSetCookie === 'function' ? withCookies.getSetCookie() : [headers.get('set-cookie') ?? '']; + for (const entry of list) { + if (entry === '') + continue; + const pair = entry.split(';', 1)[0]; + if (pair !== undefined && pair.includes('=') && !pair.startsWith('=')) + return pair.trim(); + } + return ''; +} +/** Map one HTTP error body onto a {@link CloudError}. */ +function errorFromBody(status, raw, retryAfterHeader) { + let code = `http_${status}`; + let message = raw.slice(0, 300); + try { + const parsed = JSON.parse(raw); + if (parsed !== null && typeof parsed === 'object') { + const body = parsed; + if (typeof body.error === 'string') + code = body.error; + else if (body.error !== null && typeof body.error === 'object') { + const nested = body.error; + if (typeof nested.code === 'string') + code = nested.code; + if (typeof nested.message === 'string') + message = nested.message; + } + if (typeof body.message === 'string') + message = body.message; + } + } + catch { + // Non-JSON error (proxy HTML page, empty body): keep the text snippet. + } + const error = { status, code, message: message === '' ? code : message }; + if (status === 429) { + const header = retryAfterHeader === null ? Number.NaN : Number(retryAfterHeader); + error.retryAfterMs = Number.isFinite(header) && header > 0 ? header * 1000 : 900_000; + } + return error; +} +/** + * One cloud endpoint handle. Instances are cheap: construct per call site and + * keep the live settings behind closures so a settings edit applies at once. + */ +export class CloudClient { + options; + constructor(options) { + this.options = options; + } + async request(method, path, body, tokenOverride) { + const token = tokenOverride ?? this.options.token(); + const base = this.options.baseUrl(); + const url = `${base}${path}`; + const headers = { Accept: 'application/json' }; + if (token !== '') + headers.Authorization = `Bearer ${token}`; + const init = { method, headers, signal: AbortSignal.timeout(this.options.timeoutMs()) }; + if (body !== undefined) { + headers['Content-Type'] = 'application/json'; + init.body = JSON.stringify(body); + } + let response; + try { + response = await fetch(url, init); + } + catch (error) { + const reason = error instanceof Error ? error.message : String(error); + return { ok: false, error: { status: 0, code: 'network_error', message: `${method} ${path}: ${reason}` } }; + } + const text = await response.text().catch(() => ''); + if (!response.ok) { + return { ok: false, error: errorFromBody(response.status, text, response.headers.get('retry-after')) }; + } + if (text.trim() === '') + return { ok: true, status: response.status, data: {} }; + try { + return { ok: true, status: response.status, data: JSON.parse(text) }; + } + catch { + return { ok: false, error: { status: response.status, code: 'invalid_json', message: 'response was not JSON' } }; + } + } + /** Report one conversation turn (activity:write token). */ + reportTurn(payload, token) { + return this.request('POST', '/activity/turn', payload, token); + } + /** + * Read-only reachability probe: any HTTP answer (even 401 or 404) proves the + * host is up. This is what separates "服务不可达" from "令牌无效" in the card, + * and it never sends a credential. + */ + async reach() { + try { + const response = await fetch(`${this.options.baseUrl()}/status`, { + method: 'GET', + headers: { Accept: 'application/json' }, + signal: AbortSignal.timeout(this.options.timeoutMs()), + }); + return { ok: true, status: response.status, message: `服务可达(HTTP ${response.status})` }; + } + catch (error) { + const reason = error instanceof Error ? error.message : String(error); + return { ok: false, status: 0, message: `服务不可达:${reason}` }; + } + } + /** Stage one turn summary as pending proposals (summary:write token). */ + submitSummary(payload, token) { + return this.request('POST', '/activity/summary', payload, token); + } + /** + * Verify a summary token without staging anything. + * + * The endpoint authenticates before it validates the body, so an empty + * object coming back `400 invalid_input` proves the scope is right. + */ + async probeSummary(token) { + const result = await this.request('POST', '/activity/summary', {}, token); + if (result.ok) + return { ok: true, status: result.status, data: { authenticated: true } }; + if (result.error.status === 400) + return { ok: true, status: 400, data: { authenticated: true } }; + return { ok: false, error: result.error }; + } + /** + * Verify an activity token without recording anything. + * + * `/activity/turn` validates auth before the payload, so an empty body that + * comes back `400 invalid_event` proves the token carries `activity:write`. + * A 401/403 is a token problem; anything else is reported verbatim. + */ + async probeActivity(token) { + const result = await this.request('POST', '/activity/turn', {}, token); + if (result.ok) + return { ok: true, status: result.status, data: { authenticated: true } }; + // 400 means the credentials were accepted and only the body was rejected. + if (result.error.status === 400) { + return { ok: true, status: 400, data: { authenticated: true } }; + } + return { ok: false, error: result.error }; + } + /** Keyword search over stored memories (memory token). */ + async search(query, k, project) { + const body = { query, k }; + if (project !== undefined && project !== '') + body.filters = { project_id: project }; + return this.request('POST', '/memory/query', body); + } + /** Read one memory by id (memory token). */ + read(id) { + return this.request('GET', `/memory/${encodeURIComponent(id)}`); + } + /** List memories with optional paging filters (memory token). */ + list(options = {}) { + const params = new URLSearchParams(); + if (options.limit !== undefined) + params.set('limit', String(options.limit)); + if (options.offset !== undefined) + params.set('offset', String(options.offset)); + if (options.project !== undefined && options.project !== '') + params.set('project_id', options.project); + const suffix = params.toString() === '' ? '' : `?${params.toString()}`; + return this.request('GET', `/memory/all${suffix}`); + } + /** Store one memory; `operationId` makes the write idempotent (memory token). */ + add(input) { + const body = { + operation_id: input.operationId, + content: input.content, + }; + if (input.tags !== undefined && input.tags.length > 0) + body.tags = input.tags; + if (input.project !== undefined && input.project !== '') + body.project_id = input.project; + if (input.sector !== undefined && input.sector !== '') + body.metadata = { primary_sector: input.sector }; + return this.request('POST', '/memory/add', body); + } + /** List the account's projects (memory token). */ + projects() { + return this.request('GET', '/dashboard/projects'); + } + /** Storage configuration state (memory token). */ + storageStatus() { + return this.request('GET', '/storage/status'); + } + /** List the cloud skill center inventory (memory token). */ + listSkills() { + return this.request('GET', '/skills'); + } + /** Fetch one skill bundle with hashed, base64-carried files (memory token). */ + skillBundle(name) { + return this.request('GET', `/skills/${encodeURIComponent(name)}/bundle`); + } + /** Create one skill in the center; `expected_revision` must be 0 (memory token). */ + createSkill(body) { + return this.request('POST', '/skills', body); + } + /** Replace one skill's files/description at an expected revision (memory token). */ + updateSkill(name, body) { + return this.request('PATCH', `/skills/${encodeURIComponent(name)}`, body); + } + /** + * One call against the dashboard auth surface (`/api/auth/*`). + * + * These endpoints authorize by session cookie, not by Bearer token, and they + * reject any non-GET without a matching `Origin` (the server's CSRF gate), so + * the origin of the configured base URL is sent explicitly — that is a header + * only a non-browser client can set, which is exactly what this is. + */ + async authFetch(method, path, body, cookie) { + const baseUrl = this.options.baseUrl(); + const base = authBase(baseUrl); + if (base === '') + return { ok: false, error: { status: 0, code: 'invalid_base_url', message: '服务地址无效,无法登录' } }; + const headers = { Accept: 'application/json' }; + try { + headers.Origin = new URL(baseUrl).origin; + } + catch { + return { ok: false, error: { status: 0, code: 'invalid_base_url', message: '服务地址无效,无法登录' } }; + } + if (cookie !== undefined && cookie !== '') + headers.Cookie = cookie; + const init = { method, headers, signal: AbortSignal.timeout(this.options.timeoutMs()) }; + if (body !== undefined) { + headers['Content-Type'] = 'application/json'; + init.body = JSON.stringify(body); + } + let response; + try { + response = await fetch(`${base}${path}`, init); + } + catch (error) { + const reason = error instanceof Error ? error.message : String(error); + return { ok: false, error: { status: 0, code: 'network_error', message: `${method} /auth${path}: ${reason}` } }; + } + const text = await response.text().catch(() => ''); + if (!response.ok) { + return { ok: false, error: errorFromBody(response.status, text, response.headers.get('retry-after')) }; + } + let parsed = {}; + if (text.trim() !== '') { + try { + parsed = JSON.parse(text); + } + catch { + parsed = {}; + } + } + return { ok: true, status: response.status, body: parsed, headers: response.headers }; + } + /** + * Password login against the dashboard. + * + * The password is used once, in this call, and never stored: what comes back + * is a short-lived session cookie that the caller immediately spends on + * {@link CloudClient.mintToken} and then drops. + */ + async login(username, password) { + const sent = await this.authFetch('POST', '/login', { username, password }); + if (!sent.ok) + return sent; + const cookie = sessionCookieOf(sent.headers); + if (cookie === '') { + return { ok: false, error: { status: sent.status, code: 'no_session', message: '登录成功,但服务端没有下发会话' } }; + } + const body = sent.body; + return { ok: true, status: sent.status, data: { user: body.user ?? {}, sessionCookie: cookie } }; + } + /** Mint one scoped API token using a live session cookie. */ + async mintToken(sessionCookie, scope, label) { + const sent = await this.authFetch('POST', '/tokens', { scope, label }, sessionCookie); + if (!sent.ok) + return sent; + const body = sent.body; + const issued = body.token; + if (issued === undefined || typeof issued.token !== 'string' || issued.token === '') { + return { ok: false, error: { status: sent.status, code: 'no_token', message: '服务端没有返回令牌' } }; + } + return { ok: true, status: sent.status, data: issued }; + } +} +/** Render a {@link CloudError} as one display line. */ +export function describeError(error) { + if (error.status === 0) + return `网络不可用:${error.message}`; + return `HTTP ${error.status} ${error.code}:${error.message}`; +}