@gguf/claw
Version:
Multi-channel AI gateway with extensible messaging integrations
127 lines (125 loc) • 6.15 kB
JavaScript
import { c as expandHomePrefix, s as resolveStateDir, u as resolveRequiredHomeDir } from "./paths-Bp5uKvNR.js";
import { l as normalizeAgentId, n as DEFAULT_AGENT_ID } from "./session-key-CgcjHuX_.js";
import path from "node:path";
import os from "node:os";
//#region src/config/sessions/paths.ts
function resolveAgentSessionsDir(agentId, env = process.env, homedir = () => resolveRequiredHomeDir(env, os.homedir)) {
const root = resolveStateDir(env, homedir);
const id = normalizeAgentId(agentId ?? DEFAULT_AGENT_ID);
return path.join(root, "agents", id, "sessions");
}
function resolveSessionTranscriptsDirForAgent(agentId, env = process.env, homedir = () => resolveRequiredHomeDir(env, os.homedir)) {
return resolveAgentSessionsDir(agentId, env, homedir);
}
function resolveDefaultSessionStorePath(agentId) {
return path.join(resolveAgentSessionsDir(agentId), "sessions.json");
}
function resolveSessionFilePathOptions(params) {
const agentId = params.agentId?.trim();
const storePath = params.storePath?.trim();
if (storePath) {
const sessionsDir = path.dirname(path.resolve(storePath));
return agentId ? {
sessionsDir,
agentId
} : { sessionsDir };
}
if (agentId) return { agentId };
}
const SAFE_SESSION_ID_RE = /^[a-z0-9][a-z0-9._-]{0,127}$/i;
function validateSessionId(sessionId) {
const trimmed = sessionId.trim();
if (!SAFE_SESSION_ID_RE.test(trimmed)) throw new Error(`Invalid session ID: ${sessionId}`);
return trimmed;
}
function resolveSessionsDir(opts) {
const sessionsDir = opts?.sessionsDir?.trim();
if (sessionsDir) return path.resolve(sessionsDir);
return resolveAgentSessionsDir(opts?.agentId);
}
function resolvePathFromAgentSessionsDir(agentSessionsDir, candidateAbsPath) {
const agentBase = path.resolve(agentSessionsDir);
const relative = path.relative(agentBase, candidateAbsPath);
if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) return;
return path.resolve(agentBase, relative);
}
function resolveSiblingAgentSessionsDir(baseSessionsDir, agentId) {
const resolvedBase = path.resolve(baseSessionsDir);
if (path.basename(resolvedBase) !== "sessions") return;
const baseAgentDir = path.dirname(resolvedBase);
const baseAgentsDir = path.dirname(baseAgentDir);
if (path.basename(baseAgentsDir) !== "agents") return;
const rootDir = path.dirname(baseAgentsDir);
return path.join(rootDir, "agents", normalizeAgentId(agentId), "sessions");
}
function extractAgentIdFromAbsoluteSessionPath(candidateAbsPath) {
const parts = path.normalize(path.resolve(candidateAbsPath)).split(path.sep).filter(Boolean);
const sessionsIndex = parts.lastIndexOf("sessions");
if (sessionsIndex < 2 || parts[sessionsIndex - 2] !== "agents") return;
return parts[sessionsIndex - 1] || void 0;
}
function resolvePathWithinSessionsDir(sessionsDir, candidate, opts) {
const trimmed = candidate.trim();
if (!trimmed) throw new Error("Session file path must not be empty");
const resolvedBase = path.resolve(sessionsDir);
const normalized = path.isAbsolute(trimmed) ? path.relative(resolvedBase, trimmed) : trimmed;
if (normalized.startsWith("..") && path.isAbsolute(trimmed)) {
const tryAgentFallback = (agentId) => {
const normalizedAgentId = normalizeAgentId(agentId);
const siblingSessionsDir = resolveSiblingAgentSessionsDir(resolvedBase, normalizedAgentId);
if (siblingSessionsDir) {
const siblingResolved = resolvePathFromAgentSessionsDir(siblingSessionsDir, trimmed);
if (siblingResolved) return siblingResolved;
}
return resolvePathFromAgentSessionsDir(resolveAgentSessionsDir(normalizedAgentId), trimmed);
};
const explicitAgentId = opts?.agentId?.trim();
if (explicitAgentId) {
const resolvedFromAgent = tryAgentFallback(explicitAgentId);
if (resolvedFromAgent) return resolvedFromAgent;
}
const extractedAgentId = extractAgentIdFromAbsoluteSessionPath(trimmed);
if (extractedAgentId) {
const resolvedFromPath = tryAgentFallback(extractedAgentId);
if (resolvedFromPath) return resolvedFromPath;
return path.resolve(trimmed);
}
}
if (!normalized || normalized.startsWith("..") || path.isAbsolute(normalized)) throw new Error("Session file path must be within sessions directory");
return path.resolve(resolvedBase, normalized);
}
function resolveSessionTranscriptPathInDir(sessionId, sessionsDir, topicId) {
const safeSessionId = validateSessionId(sessionId);
const safeTopicId = typeof topicId === "string" ? encodeURIComponent(topicId) : typeof topicId === "number" ? String(topicId) : void 0;
return resolvePathWithinSessionsDir(sessionsDir, safeTopicId !== void 0 ? `${safeSessionId}-topic-${safeTopicId}.jsonl` : `${safeSessionId}.jsonl`);
}
function resolveSessionTranscriptPath(sessionId, agentId, topicId) {
return resolveSessionTranscriptPathInDir(sessionId, resolveAgentSessionsDir(agentId), topicId);
}
function resolveSessionFilePath(sessionId, entry, opts) {
const sessionsDir = resolveSessionsDir(opts);
const candidate = entry?.sessionFile?.trim();
if (candidate) return resolvePathWithinSessionsDir(sessionsDir, candidate, { agentId: opts?.agentId });
return resolveSessionTranscriptPathInDir(sessionId, sessionsDir);
}
function resolveStorePath(store, opts) {
const agentId = normalizeAgentId(opts?.agentId ?? DEFAULT_AGENT_ID);
if (!store) return resolveDefaultSessionStorePath(agentId);
if (store.includes("{agentId}")) {
const expanded = store.replaceAll("{agentId}", agentId);
if (expanded.startsWith("~")) return path.resolve(expandHomePrefix(expanded, {
home: resolveRequiredHomeDir(process.env, os.homedir),
env: process.env,
homedir: os.homedir
}));
return path.resolve(expanded);
}
if (store.startsWith("~")) return path.resolve(expandHomePrefix(store, {
home: resolveRequiredHomeDir(process.env, os.homedir),
env: process.env,
homedir: os.homedir
}));
return path.resolve(store);
}
//#endregion
export { resolveSessionTranscriptPathInDir as a, resolveSessionTranscriptPath as i, resolveSessionFilePath as n, resolveSessionTranscriptsDirForAgent as o, resolveSessionFilePathOptions as r, resolveStorePath as s, resolveDefaultSessionStorePath as t };