dsh-better-chat/lib/host.js

571 lines
18 KiB
JavaScript

import { existsSync, readFileSync } from "node:fs";
import { dirname, isAbsolute, join, posix, resolve, win32 } from "node:path";
import { fileURLToPath } from "node:url";
import { randomUUID } from "node:crypto";
import { spawn } from "node:child_process";
import { access, readdir } from "node:fs/promises";
import { homedir } from "node:os";
// src/flags.ts
const defaultFlags = { readerEnabled: true };
function locateFlags(start = dirname(fileURLToPath(import.meta.url))) {
let dir = start;
for (let depth = 0; depth < 6; depth += 1) {
const candidate = resolve(dir, "flags.json");
if (existsSync(candidate)) return candidate;
const parent = dirname(dir);
if (parent === dir) return void 0;
dir = parent;
}
}
function normalize(value) {
const record = value !== null && typeof value === "object" ? value : {};
return { readerEnabled: typeof record.readerEnabled === "boolean" ? record.readerEnabled : defaultFlags.readerEnabled };
}
function loadFlags(source) {
if (source !== void 0 && typeof source !== "string") return normalize(source);
try {
const path = typeof source === "string" ? source : locateFlags();
if (path === void 0 || !existsSync(path)) return { ...defaultFlags };
return normalize(JSON.parse(readFileSync(path, "utf8")));
} catch {
return { ...defaultFlags };
}
}
// src/log.ts
const REDACTED = "[REDACTED]";
const REQUEST_ID_HEADER = "x-request-id";
const REQUEST_ID_PATTERN = /^[A-Za-z0-9._:-]{1,200}$/;
const SECRET_KEYS = /* @__PURE__ */ new Set([
"authorization",
"proxyauthorization",
"cookie",
"setcookie",
"token",
"accesstoken",
"refreshtoken",
"idtoken",
"apikey",
"apisecret",
"secret",
"clientsecret",
"password",
"passwd",
"credential",
"credentials",
"signature",
"sig",
"jwt",
"bearer",
"privatekey",
"xapikey",
"xauthtoken",
"xaccesstoken",
"auth"
]);
function normalizeKey(key) {
return key.toLowerCase().replace(/[^a-z0-9]/g, "");
}
function isSecretKey(key) {
const normalized = normalizeKey(key);
if (SECRET_KEYS.has(normalized)) return true;
if (normalized === "requestid" || normalized === "xrequestid") return false;
return /(?:^|[^a-z])(?:token|secret|password|api[-_]?key)$/i.test(key);
}
function redactString(value) {
return value.replace(/([?&#])([^&#=]+)=([^&#]*)/g, (match, sep, rawKey) => {
let key;
try {
key = decodeURIComponent(rawKey.replace(/\+/g, " "));
} catch {
key = rawKey;
}
return isSecretKey(key) ? `${sep}${rawKey}=${REDACTED}` : match;
}).replace(/\b(Bearer|Basic)\s+\S+/gi, `$1 ${REDACTED}`).replace(/\b((?:access[_-]?token|refresh[_-]?token|id[_-]?token|api[_-]?key|client[_-]?secret|password|passwd|authorization|token|secret))(\s*[:=]\s*)([^\s&]+)/gi, `$1$2${REDACTED}`);
}
function redact(value) {
return redactValue(void 0, value, 0, /* @__PURE__ */ new WeakSet());
}
function redactValue(key, value, depth, seen) {
if (key !== void 0 && isSecretKey(key)) return REDACTED;
if (depth > 8) return REDACTED;
if (typeof value === "string") return redactString(value);
if (typeof value === "number" || typeof value === "boolean" || value === null || value === void 0) return value;
if (typeof value !== "object") return REDACTED;
if (value instanceof Date) return value.toISOString();
if (value instanceof Error) return redactValue(void 0, {
name: value.name,
message: value.message
}, depth + 1, seen);
if (seen.has(value)) return REDACTED;
seen.add(value);
if (Array.isArray(value)) return value.map((item) => redactValue(void 0, item, depth + 1, seen));
const output = {};
for (const [childKey, childValue] of Object.entries(value)) output[childKey] = redactValue(childKey, childValue, depth + 1, seen);
return output;
}
function createLogger(options = {}) {
const write = options.write ?? ((line) => {
console.log(line);
});
const clock = options.clock ?? (() => /* @__PURE__ */ new Date());
const emit = (level, msg, fields) => {
const details = redact({
...options.base,
...fields
});
const record = {
...details !== null && typeof details === "object" ? details : {},
time: clock().toISOString(),
level,
msg: redactString(msg)
};
try {
write(JSON.stringify(record));
} catch {
write(JSON.stringify({
time: record.time,
level,
msg: record.msg,
error: "log record was not serializable"
}));
}
};
return {
info: (msg, fields) => emit("info", msg, fields),
warn: (msg, fields) => emit("warn", msg, fields),
error: (msg, fields) => emit("error", msg, fields)
};
}
function requestIdOf(req) {
const raw = req.headers[REQUEST_ID_HEADER];
const value = Array.isArray(raw) ? raw[0] : raw;
if (typeof value === "string" && REQUEST_ID_PATTERN.test(value)) return value;
return randomUUID();
}
// src/metrics.ts
const ROUTE_REVEAL = "/better-display/reveal";
const ROUTE_SKILL_STATUS = "/better-display/skill-status";
const ROUTE_METRICS = "/better-display/metrics";
const ROUTE_HITS = [
ROUTE_REVEAL,
ROUTE_SKILL_STATUS,
ROUTE_METRICS
];
const hits = new Map(ROUTE_HITS.map((route) => [route, 0]));
const timings = new Map(ROUTE_HITS.map((route) => [route, {
count: 0,
totalMs: 0,
maxMs: 0
}]));
function snapshotHits() {
return Object.fromEntries(hits);
}
function snapshotTimings() {
return Object.fromEntries([...timings].map(([route, timing]) => [route, { ...timing }]));
}
function recordRouteHit(route) {
const next = (hits.get(route) ?? 0) + 1;
hits.set(route, next);
return next;
}
function recordRouteDuration(route, elapsedMs) {
const ms = Number.isFinite(elapsedMs) && elapsedMs > 0 ? Math.round(elapsedMs) : 0;
const current = timings.get(route) ?? {
count: 0,
totalMs: 0,
maxMs: 0
};
const next = {
count: current.count + 1,
totalMs: current.totalMs + ms,
maxMs: Math.max(current.maxMs, ms)
};
timings.set(route, next);
return next;
}
function metricsPayload() {
return {
counters: { dsh_better_display_route_hits_total: snapshotHits() },
timingsMs: snapshotTimings()
};
}
// src/workspace-path.ts
/** Absolute paths accepted by both POSIX and Windows hosts. */
function isAbsoluteWorkspacePath(path) {
return /^(?:\/|[A-Za-z]:[/\\]|\\\\)/.test(path);
}
// \0@oxc-project+runtime@0.158.0/helpers/esm/usingCtx.js
function _usingCtx() {
var r = "function" == typeof SuppressedError ? SuppressedError : function(r, e) {
var n = Error();
return n.name = "SuppressedError", n.error = r, n.suppressed = e, n;
}, e = {}, n = [];
function using(r, e) {
if (null != e) {
if (Object(e) !== e) throw new TypeError("using declarations can only be used with objects, functions, null, or undefined.");
if (r) var o = e[Symbol.asyncDispose || Symbol["for"]("Symbol.asyncDispose")];
if (void 0 === o && (o = e[Symbol.dispose || Symbol["for"]("Symbol.dispose")], r)) var t = o;
if ("function" != typeof o) throw new TypeError("Object is not disposable.");
t && (o = function o() {
try {
t.call(e);
} catch (r) {
return Promise.reject(r);
}
}), n.push({
v: e,
d: o,
a: r
});
} else r && n.push({
d: e,
a: r
});
return e;
}
return {
e,
u: using.bind(null, !1),
a: using.bind(null, !0),
d: function d() {
var o, t = this.e, s = 0;
function next() {
for (; o = n.pop();) try {
if (!o.a && 1 === s) return s = 0, n.push(o), Promise.resolve().then(next);
if (o.d) {
var r = o.d.call(o.v);
if (o.a) return s |= 2, Promise.resolve(r).then(next, err);
} else s |= 1;
} catch (r) {
return err(r);
}
if (1 === s) return t !== e ? Promise.reject(t) : Promise.resolve();
if (t !== e) throw t;
}
function err(n) {
return t = t !== e ? new r(n, t) : n, next();
}
return next();
}
};
}
// src/reveal.ts
async function revealRoots(ctx, sessionId) {
if (sessionId !== void 0) {
const cwd = (ctx.get?.("sessions"))?.get(sessionId)?.header.cwd;
if (cwd) return [cwd];
const query = ctx.get?.("sessionQuery");
if (query) try {
var _usingCtx$1 = _usingCtx();
const observation = _usingCtx$1.u(await query.observeSession(sessionId, { projectionMode: "none" }));
if (observation.header.cwd) return [observation.header.cwd];
} catch (_) {
_usingCtx$1.e = _;
} finally {
_usingCtx$1.d();
}
}
return ((ctx.get?.("workspaceRegistry"))?.list() ?? []).filter((workspace) => sessionId === void 0 || workspace.sessionIds.includes(sessionId)).map((workspace) => workspace.path);
}
function resolveRevealPath(path, roots, exists = existsSync) {
if (isAbsoluteWorkspacePath(path)) return path;
if (/^[A-Za-z]:|^\\/.test(path)) throw new Error("Path is not workspace-relative");
const matches = /* @__PURE__ */ new Set();
for (const root of roots) {
if (!isAbsoluteWorkspacePath(root)) continue;
const candidate = (/^[A-Za-z]:[/\\]|^\\\\/.test(root) ? win32 : posix).resolve(root, path);
if (exists(candidate)) matches.add(candidate);
}
if (matches.size !== 1) throw new Error(matches.size === 0 ? "Workspace path not found" : "Workspace path is ambiguous");
return [...matches][0];
}
function revealPath(path, platform = process.platform, spawnProcess = spawn) {
const options = {
detached: true,
stdio: "ignore"
};
if (platform === "darwin") spawnProcess("open", ["-R", path], options);
else if (platform === "win32") spawnProcess("explorer.exe", [`/select,"${path}"`], {
...options,
windowsVerbatimArguments: true
});
else spawnProcess("xdg-open", [path], options);
}
function createRevealHandler({ roots, reveal = revealPath }) {
return (req, res) => {
if (req.method !== "POST") {
res.statusCode = 405;
res.end();
return;
}
let body = "";
req.on("data", (chunk) => {
body += chunk;
});
req.on("end", async () => {
res.setHeader("Content-Type", "application/json");
try {
const data = JSON.parse(body);
const path = typeof data === "object" && data !== null && "path" in data && typeof data.path === "string" ? data.path.trim() : "";
if (!path) throw new Error("Empty path");
const sessionId = typeof data === "object" && data !== null && "sessionId" in data && typeof data.sessionId === "string" ? data.sessionId : void 0;
reveal(resolveRevealPath(path, isAbsoluteWorkspacePath(path) ? [] : await roots(sessionId)));
res.statusCode = 200;
res.end(JSON.stringify({ ok: true }));
} catch (err) {
res.statusCode = 400;
res.end(JSON.stringify({
ok: false,
error: String(err)
}));
}
});
};
}
// src/skill-status.ts
/** Shared generative-mcpapps identity. Plugin-tree presence is not installation. */
const GENERATIVE_MCPAPPS_SKILL = "generative-mcpapps";
/** Conventional relative roots only. Never expand $HOME or dump host `root.path`. */
const CONVENTIONAL_SKILL_ROOTS = [".dsh/skills", ".agents/skills"];
function skillNameMatches(name) {
return typeof name === "string" && name === "generative-mcpapps";
}
function skillListIncludes(entries) {
return Array.isArray(entries) && entries.some((entry) => skillNameMatches(entry?.name));
}
/** Directory bundle `name/SKILL.md` or flat `name.md` at a scanned root. */
function skillRootEntryMatches(entryName) {
return entryName === "generative-mcpapps" || entryName === `generative-mcpapps.md`;
}
function skillsFromListResult(result) {
if (Array.isArray(result)) return result;
if (result === null || typeof result !== "object") return [];
const record = result;
if (record.ok === false) return [];
if (Array.isArray(record.skills)) return record.skills;
if (record.value && typeof record.value === "object") {
const value = record.value;
if (Array.isArray(value.skills)) return value.skills;
if (Array.isArray(record.value)) return record.value;
}
return [];
}
function publicSkillRoots() {
return CONVENTIONAL_SKILL_ROOTS.map((path) => ({
source: "conventional",
path
}));
}
/**
* Strip host home / pack absolutes before anything user-facing (HTTP or Settings).
* Detection still uses the raw scan; this is the public face.
*/
function toPublicSkillStatus(status) {
return {
name: status.name,
installed: status.installed,
via: status.via,
roots: publicSkillRoots()
};
}
// src/skill-roots.ts
function expandHomePath(path, home = homedir()) {
if (path === "~") return home;
if (path.startsWith("~/") || path.startsWith("~\\")) return join(home, path.slice(2));
return path;
}
/** `$DSH_HOME` or `~/.dsh`, matching official `resolveDshHome`. */
function resolveDshHome(env = process.env, home = homedir()) {
const fromEnv = env.DSH_HOME;
const selected = fromEnv !== void 0 && fromEnv.trim().length > 0 ? fromEnv : join(home, ".dsh");
return resolve(expandHomePath(selected, home));
}
/** `$DSH_AGENTS_HOME` or `~/.agents`. */
function resolveAgentsHome(env = process.env, home = homedir()) {
const fromEnv = env.DSH_AGENTS_HOME;
const selected = fromEnv !== void 0 && fromEnv.trim().length > 0 ? fromEnv : join(home, ".agents");
return resolve(expandHomePath(selected, home));
}
function userSkillRoots(env = process.env, home = homedir()) {
return [{
source: "user-dsh",
path: join(resolveDshHome(env, home), "skills")
}, {
source: "user-agents",
path: join(resolveAgentsHome(env, home), "skills")
}];
}
function projectSkillRoots(projectRoot) {
return [{
source: "project-dsh",
path: join(projectRoot, ".dsh", "skills")
}, {
source: "project-agents",
path: join(projectRoot, ".agents", "skills")
}];
}
async function findProjectRoot(cwd) {
let current = resolve(cwd);
while (true) {
if (existsSync(join(current, ".git"))) return current;
const parent = dirname(current);
if (parent === current) return resolve(cwd);
current = parent;
}
}
async function rootHasGenerativeMcpapps(rootPath) {
let entries;
try {
entries = await readdir(rootPath, { withFileTypes: true });
} catch {
return false;
}
for (const entry of entries) {
if (entry.name === ".system") continue;
if (!skillRootEntryMatches(entry.name)) continue;
if (entry.isDirectory()) try {
await access(join(rootPath, entry.name, "SKILL.md"));
return true;
} catch {
continue;
}
if (entry.isFile()) return true;
}
return false;
}
/** Resolve the plugin-shipped pack. This path is never treated as a skill root. */
function pluginSkillPackPath(moduleUrl = import.meta.url) {
const here = dirname(fileURLToPath(moduleUrl));
return [
join(here, "../skills", GENERATIVE_MCPAPPS_SKILL),
join(here, "../../skills", GENERATIVE_MCPAPPS_SKILL),
join(here, "skills", GENERATIVE_MCPAPPS_SKILL)
].find((path) => existsSync(join(path, "SKILL.md")));
}
async function scanGenerativeMcpappsStatus(options = {}) {
const roots = [...userSkillRoots(options.env ?? process.env, options.home ?? homedir())];
const cwd = typeof options.cwd === "string" && options.cwd.trim().length > 0 ? isAbsolute(options.cwd) ? options.cwd : resolve(options.cwd) : void 0;
if (cwd !== void 0) roots.unshift(...projectSkillRoots(await findProjectRoot(cwd)));
const inspected = [];
let rootHit = false;
for (const root of roots) {
const present = await rootHasGenerativeMcpapps(root.path);
inspected.push({
...root,
present
});
if (present) rootHit = true;
}
let via = null;
let listHit = false;
if (options.listSkills) try {
listHit = skillListIncludes(await options.listSkills());
if (listHit) via = "skills.list";
} catch {}
if (!listHit && rootHit) via = "skill-root";
const packPath = options.packPath ?? pluginSkillPackPath();
return {
name: GENERATIVE_MCPAPPS_SKILL,
installed: listHit || rootHit,
via,
roots: inspected,
...packPath !== void 0 ? { packPath } : {}
};
}
// src/host.ts
const name = "dsh-better-chat";
const inject = ["webServer"];
const log = createLogger({ base: { plugin: name } });
function writeJson(res, status, body) {
res.setHeader("Content-Type", "application/json");
res.statusCode = status;
res.end(JSON.stringify(body));
}
function skillLister(ctx) {
const skills = ctx.get?.("skills");
if (typeof skills?.list !== "function") return void 0;
return async () => skillsFromListResult(await skills.list({}));
}
function beginRequest(req, res, route) {
const requestId = requestIdOf(req);
res.setHeader("X-Request-ID", requestId);
recordRouteHit(route);
const started = performance.now();
res.on("finish", () => {
recordRouteDuration(route, performance.now() - started);
});
log.info("http request", {
requestId,
route,
method: req.method ?? "",
url: req.url ?? "",
headers: req.headers
});
return requestId;
}
function apply(ctx, options) {
const flags = options?.flags ?? loadFlags();
log.info("[dsh-better-chat] loaded", { readerEnabled: flags.readerEnabled });
if (!flags.readerEnabled) {
log.info("route registration skipped", { readerEnabled: false });
return;
}
if (ctx.webServer) ctx.effect(() => {
const reveal = createRevealHandler({ roots: (sessionId) => revealRoots(ctx, sessionId) });
const disposeReveal = ctx.webServer.register({
kind: "exact",
path: ROUTE_REVEAL,
handler: (req, res) => {
beginRequest(req, res, ROUTE_REVEAL);
reveal(req, res);
}
});
const disposeSkill = ctx.webServer.register({
kind: "exact",
path: ROUTE_SKILL_STATUS,
handler: async (req, res) => {
const requestId = beginRequest(req, res, ROUTE_SKILL_STATUS);
if (req.method !== "GET") {
res.statusCode = 405;
res.end();
return;
}
try {
writeJson(res, 200, toPublicSkillStatus(await scanGenerativeMcpappsStatus({
cwd: new URL(req.url ?? "", "http://127.0.0.1").searchParams.get("cwd") ?? void 0,
listSkills: skillLister(ctx)
})));
} catch (err) {
log.error("skill-status failed", {
requestId,
error: err instanceof Error ? err.message : String(err)
});
writeJson(res, 500, {
ok: false,
error: String(err)
});
}
}
});
const disposeMetrics = ctx.webServer.register({
kind: "exact",
path: ROUTE_METRICS,
handler: (req, res) => {
beginRequest(req, res, ROUTE_METRICS);
if (req.method !== "GET") {
res.statusCode = 405;
res.end();
return;
}
writeJson(res, 200, metricsPayload());
}
});
return () => {
disposeReveal();
disposeSkill();
disposeMetrics();
};
}, "dsh-better-chat: reveal, skill-status, and metrics routes");
}
export { apply, inject, name };