dsh-brain/lib/api.js

320 lines
13 KiB
JavaScript
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/**
* 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}`;
}