root
963 lines
44 KiB
TypeScript
963 lines
44 KiB
TypeScript
import { createHash, randomUUID } from "node:crypto";
|
|
import { readFile } from "node:fs/promises";
|
|
import path from "node:path";
|
|
|
|
import { mutateMdtodoDocument, readMdtodoTaskDetail } from "./mdtodo.ts";
|
|
import { createMdtodoSourceAdapter, normalizeProjectSourceInput, sourceProjection } from "./source-adapter.ts";
|
|
|
|
const contractVersion = "project-management-v1";
|
|
const serviceId = "hwlab-project-management";
|
|
|
|
export function createProjectManagementApp(options = {}) {
|
|
const env = options.env ?? process.env;
|
|
const store = options.store;
|
|
const logger = options.logger ?? console;
|
|
const sourceRoot = path.resolve(String(options.sourceRoot ?? env.HWLAB_PROJECT_MANAGEMENT_SOURCE_ROOT ?? process.cwd()));
|
|
const sourceId = safeToken(options.sourceId ?? env.HWLAB_PROJECT_MANAGEMENT_SOURCE_ID, "default-mdtodo");
|
|
const projectId = safeToken(options.projectId ?? env.HWLAB_PROJECT_MANAGEMENT_PROJECT_ID, "project_hwlab_v03");
|
|
const displayName = String(options.displayName ?? env.HWLAB_PROJECT_MANAGEMENT_SOURCE_NAME ?? "HWLAB MDTODO").trim() || "HWLAB MDTODO";
|
|
const maxFiles = positiveInteger(options.maxFiles ?? env.HWLAB_PROJECT_MANAGEMENT_MDTODO_MAX_FILES, 300);
|
|
const taskMaxLimit = positiveInteger(options.taskMaxLimit ?? env.HWLAB_PROJECT_MANAGEMENT_MDTODO_TASK_MAX_LIMIT, 500);
|
|
const taskDefaultLimit = Math.min(taskMaxLimit, positiveInteger(options.taskDefaultLimit ?? env.HWLAB_PROJECT_MANAGEMENT_MDTODO_TASK_DEFAULT_LIMIT, 200));
|
|
const sourceAdapter = options.sourceAdapter ?? createMdtodoSourceAdapter({ env, hwpodNodeOpsHandler: options.hwpodNodeOpsHandler, fetchImpl: options.fetchImpl });
|
|
const defaultSource = normalizeProjectSourceInput({
|
|
sourceId,
|
|
sourceKind: "local-file-tree",
|
|
displayName,
|
|
projectId,
|
|
rootRef: sourceRoot,
|
|
mdtodoRootRef: ".",
|
|
maxFiles
|
|
}, { projectId, displayName, rootRef: sourceRoot, maxFiles }).source;
|
|
let initialized = false;
|
|
let lastProjection = null;
|
|
let lastError = null;
|
|
let initializing = null;
|
|
|
|
async function initialize() {
|
|
if (initialized) return lastProjection;
|
|
if (initializing) return initializing;
|
|
initializing = (async () => {
|
|
const startedAt = new Date().toISOString();
|
|
await store.ensureSchema();
|
|
const bootstrapSources = await projectManagementBootstrapSources({ env, projectId, displayName, sourceRoot, maxFiles });
|
|
const sources = dedupeProjectSources([defaultSource, ...bootstrapSources]);
|
|
const projections = [];
|
|
for (const source of sources) {
|
|
await store.upsertSource(source);
|
|
try {
|
|
const documents = await sourceAdapter.discover(source);
|
|
await store.replaceProjection(source, documents);
|
|
projections.push({ ...sourceProjection(source, documents), status: "ready" });
|
|
} catch (error) {
|
|
if (source.sourceId === defaultSource.sourceId) throw error;
|
|
const blocker = { code: error?.code ?? "project_source_projection_failed", message: error?.message ?? String(error) };
|
|
projections.push({ ...sourceProjection(source, []), status: "blocked", blocker });
|
|
logger.warn?.(JSON.stringify({ event: "project-management-bootstrap-source-projection-failed", serviceId, sourceId: source.sourceId, sourceKind: source.sourceKind, ...blocker }));
|
|
}
|
|
}
|
|
lastProjection = summarizeProjectManagementProjection(projections, startedAt);
|
|
initialized = true;
|
|
lastError = null;
|
|
logger.info?.(JSON.stringify({ event: "project-management-projection-ready", serviceId, ...lastProjection }));
|
|
return lastProjection;
|
|
})();
|
|
try {
|
|
return await initializing;
|
|
} catch (error) {
|
|
lastError = error;
|
|
initialized = false;
|
|
throw error;
|
|
} finally {
|
|
initializing = null;
|
|
}
|
|
}
|
|
|
|
async function fetchHandler(request) {
|
|
const url = new URL(request.url);
|
|
try {
|
|
if (url.pathname === "/health/live" || url.pathname === "/live") {
|
|
return json(200, healthPayload("live", { initialized, lastProjection, lastError }));
|
|
}
|
|
if (url.pathname === "/health/ready" || url.pathname === "/health") {
|
|
try {
|
|
const projection = await initialize();
|
|
return json(200, healthPayload("ready", { initialized: true, lastProjection: projection, lastError: null }));
|
|
} catch (error) {
|
|
return json(503, healthPayload("ready", { initialized: false, lastProjection, lastError: error }));
|
|
}
|
|
}
|
|
|
|
if (!url.pathname.startsWith("/v1/project-management")) return jsonError(404, "not_found", "Project management route is not implemented");
|
|
if (url.pathname === "/v1/project-management/workbench-links" && request.method === "POST") {
|
|
await initialize();
|
|
return await handleCreateWorkbenchLink(request, store);
|
|
}
|
|
if (url.pathname === "/v1/project-management/mdtodo/sources" && request.method === "POST") {
|
|
await initialize();
|
|
return await handleUpsertMdtodoSource(request, store, { mode: "create" });
|
|
}
|
|
const sourceAction = matchSourceAction(url.pathname);
|
|
if (sourceAction && request.method === "PATCH" && !sourceAction.action) {
|
|
await initialize();
|
|
return await handleUpsertMdtodoSource(request, store, { mode: "update", sourceId: sourceAction.sourceId });
|
|
}
|
|
if (sourceAction?.action === "probe" && request.method === "POST") {
|
|
await initialize();
|
|
return await handleProbeMdtodoSource(store, sourceAdapter, sourceAction.sourceId, actorFromRequest(request));
|
|
}
|
|
if (sourceAction?.action === "reindex" && request.method === "POST") {
|
|
await initialize();
|
|
return await handleReindexMdtodoSource(store, sourceAdapter, sourceAction.sourceId, actorFromRequest(request));
|
|
}
|
|
const fileContent = matchFileContent(url.pathname);
|
|
if (fileContent && request.method === "PATCH") {
|
|
await initialize();
|
|
return await handleWriteMdtodoFile(request, url, store, sourceAdapter, fileContent.fileRef, actorFromRequest(request));
|
|
}
|
|
const taskAction = matchTaskAction(url.pathname);
|
|
if (url.pathname === "/v1/project-management/mdtodo/tasks" && request.method === "POST") {
|
|
await initialize();
|
|
return await handleCreateMdtodoTask(request, store, sourceAdapter, actorFromRequest(request));
|
|
}
|
|
if (taskAction && request.method === "PATCH") {
|
|
await initialize();
|
|
return await handlePatchMdtodoTask(request, store, sourceAdapter, taskAction.taskRef, actorFromRequest(request));
|
|
}
|
|
if (taskAction && request.method === "DELETE") {
|
|
await initialize();
|
|
return await handleDeleteMdtodoTask(request, store, sourceAdapter, taskAction.taskRef, actorFromRequest(request));
|
|
}
|
|
if (request.method !== "GET" && request.method !== "HEAD") return jsonError(405, "method_not_allowed", "Project management API only accepts read requests plus Workbench link writes");
|
|
|
|
await initialize();
|
|
if (url.pathname === "/v1/project-management" || url.pathname === "/v1/project-management/navigation") {
|
|
return json(200, envelope({ navigation: navigationPayload(actorFromRequest(request)), projection: lastProjection }));
|
|
}
|
|
if (url.pathname === "/v1/project-management/projects") {
|
|
const sources = await store.listSources();
|
|
return json(200, envelope({ projects: projectsFromSources(sources) }));
|
|
}
|
|
if (url.pathname === "/v1/project-management/mdtodo/sources") {
|
|
return json(200, envelope({ sources: await store.listSources() }));
|
|
}
|
|
if (url.pathname === "/v1/project-management/mdtodo/files") {
|
|
return json(200, envelope({ files: await store.listDocuments({ sourceId: queryToken(url, "sourceId") }) }));
|
|
}
|
|
if (fileContent) {
|
|
return await handleReadMdtodoFile(url, store, sourceAdapter, fileContent.fileRef);
|
|
}
|
|
if (url.pathname === "/v1/project-management/mdtodo/launch-context") {
|
|
return await handleReadMdtodoLaunchContext(url, store);
|
|
}
|
|
if (url.pathname === "/v1/project-management/mdtodo/task-detail") {
|
|
return await handleReadMdtodoTaskDetail(url, store, sourceAdapter);
|
|
}
|
|
if (url.pathname === "/v1/project-management/mdtodo/report-preview") {
|
|
return await handleReadMdtodoReportPreview(url, store, sourceAdapter);
|
|
}
|
|
if (url.pathname === "/v1/project-management/mdtodo/tasks") {
|
|
const taskFilters = {
|
|
taskRef: queryOpaque(url, "taskRef"),
|
|
sourceId: queryToken(url, "sourceId"),
|
|
fileRef: queryToken(url, "fileRef"),
|
|
projectId: queryToken(url, "projectId"),
|
|
parentTaskRef: queryOpaque(url, "parentTaskRef"),
|
|
status: queryToken(url, "status"),
|
|
search: querySearch(url, "search")
|
|
};
|
|
const page = taskListPage(url, { defaultLimit: taskDefaultLimit, maxLimit: taskMaxLimit });
|
|
const [total, tasks] = await Promise.all([
|
|
store.countTasks(taskFilters),
|
|
store.listTasks({ ...taskFilters, limit: page.limit, offset: page.offset })
|
|
]);
|
|
return json(200, envelope({
|
|
tasks,
|
|
page: { ...page, total, hasMore: page.offset + tasks.length < total }
|
|
}));
|
|
}
|
|
if (url.pathname === "/v1/project-management/workbench-links") {
|
|
return json(200, envelope({
|
|
links: await store.listWorkbenchLinks({
|
|
taskRef: queryOpaque(url, "taskRef"),
|
|
projectId: queryToken(url, "projectId"),
|
|
sessionId: queryOpaque(url, "sessionId")
|
|
})
|
|
}));
|
|
}
|
|
return jsonError(404, "not_found", "Project management route is not implemented");
|
|
} catch (error) {
|
|
logger.error?.(JSON.stringify({ event: "project-management-request-failed", serviceId, path: url.pathname, code: error?.code ?? "project_management_error", message: error?.message ?? String(error) }));
|
|
return jsonError(error?.statusCode ?? 500, error?.code ?? "project_management_error", error?.message ?? "Project management request failed");
|
|
}
|
|
}
|
|
|
|
return {
|
|
initialize,
|
|
fetch: fetchHandler,
|
|
async close() {
|
|
if (typeof store?.close === "function") await store.close();
|
|
}
|
|
};
|
|
}
|
|
|
|
async function projectManagementBootstrapSources({ env, projectId, displayName, sourceRoot, maxFiles }) {
|
|
const inputs = await readProjectManagementBootstrapSourceInputs(env);
|
|
return inputs.map((input, index) => {
|
|
const normalized = normalizeProjectSourceInput(input, { projectId, displayName, rootRef: sourceRoot, maxFiles });
|
|
if (!normalized.ok) {
|
|
const error = Object.assign(new Error(`bootstrap source[${index}] invalid: ${normalized.message}`), {
|
|
code: normalized.code,
|
|
statusCode: normalized.status
|
|
});
|
|
throw error;
|
|
}
|
|
return normalized.source;
|
|
});
|
|
}
|
|
|
|
async function readProjectManagementBootstrapSourceInputs(env) {
|
|
const pathValue = String(env.HWLAB_PROJECT_MANAGEMENT_BOOTSTRAP_SOURCES_PATH ?? "").trim();
|
|
const inlineValue = String(env.HWLAB_PROJECT_MANAGEMENT_BOOTSTRAP_SOURCES_JSON ?? "").trim();
|
|
if (!pathValue && !inlineValue) return [];
|
|
const text = pathValue ? await readFile(pathValue, "utf8") : inlineValue;
|
|
const parsed = JSON.parse(text);
|
|
if (Array.isArray(parsed)) return parsed;
|
|
if (Array.isArray(parsed?.sources)) return parsed.sources;
|
|
const error = Object.assign(new Error("Project management bootstrap sources must be a JSON array or an object with a sources array"), {
|
|
code: "invalid_project_management_bootstrap_sources",
|
|
statusCode: 400
|
|
});
|
|
throw error;
|
|
}
|
|
|
|
function dedupeProjectSources(sources) {
|
|
const byId = new Map();
|
|
for (const source of sources) byId.set(source.sourceId, source);
|
|
return [...byId.values()];
|
|
}
|
|
|
|
function summarizeProjectManagementProjection(projections, startedAt) {
|
|
if (projections.length === 1) return { ...projections[0], startedAt };
|
|
return {
|
|
sourceId: projections[0]?.sourceId ?? "project-management",
|
|
sourceCount: projections.length,
|
|
sources: projections,
|
|
documentCount: projections.reduce((sum, item) => sum + Number(item.documentCount ?? 0), 0),
|
|
taskCount: projections.reduce((sum, item) => sum + Number(item.taskCount ?? 0), 0),
|
|
projectedAt: new Date().toISOString(),
|
|
startedAt,
|
|
valuesRedacted: true
|
|
};
|
|
}
|
|
|
|
function healthPayload(mode, state) {
|
|
const blockers = state.lastError ? [{ code: state.lastError.code ?? "project_management_not_ready", message: state.lastError.message ?? String(state.lastError) }] : [];
|
|
return {
|
|
contractVersion,
|
|
serviceId,
|
|
status: blockers.length ? "blocked" : "ok",
|
|
ready: mode === "live" ? true : blockers.length === 0 && state.initialized === true,
|
|
mode,
|
|
projection: state.lastProjection,
|
|
blockers,
|
|
valuesRedacted: true
|
|
};
|
|
}
|
|
|
|
function envelope(payload) {
|
|
return {
|
|
contractVersion,
|
|
serviceId,
|
|
ok: true,
|
|
...payload,
|
|
valuesRedacted: true
|
|
};
|
|
}
|
|
|
|
function navigationPayload(actor) {
|
|
return {
|
|
id: "project-management",
|
|
label: "Project Management",
|
|
actor,
|
|
items: [
|
|
{ id: "projects", label: "Projects", apiRoute: "/v1/project-management/projects" },
|
|
{ id: "mdtodo", label: "MDTODO", apiRoute: "/v1/project-management/mdtodo/tasks" }
|
|
],
|
|
capabilities: {
|
|
mdtodoProjection: true,
|
|
workbenchLaunch: true,
|
|
workbenchLinks: true,
|
|
sourceOfTruth: "markdown-files"
|
|
}
|
|
};
|
|
}
|
|
|
|
function projectsFromSources(sources) {
|
|
const projects = new Map();
|
|
for (const source of sources) {
|
|
const projectId = source.projectId || "project_hwlab_v03";
|
|
if (!projects.has(projectId)) {
|
|
projects.set(projectId, {
|
|
projectId,
|
|
name: source.displayName || projectId,
|
|
sourceIds: [],
|
|
sourceOfTruth: "markdown-files",
|
|
status: source.status || "active"
|
|
});
|
|
}
|
|
projects.get(projectId).sourceIds.push(source.sourceId);
|
|
}
|
|
return [...projects.values()];
|
|
}
|
|
|
|
function actorFromRequest(request) {
|
|
const actorId = request.headers.get("x-hwlab-actor-id") || null;
|
|
if (!actorId) return null;
|
|
return {
|
|
id: actorId,
|
|
role: request.headers.get("x-hwlab-actor-role") || null,
|
|
authMethod: request.headers.get("x-hwlab-auth-method") || null
|
|
};
|
|
}
|
|
|
|
async function readJsonObject(request, maxBytes = 32768) {
|
|
const text = await request.text();
|
|
if (text.length > maxBytes) return { ok: false, code: "body_too_large", message: "Project management request body is too large" };
|
|
try {
|
|
const value = text ? JSON.parse(text) : {};
|
|
if (!value || typeof value !== "object" || Array.isArray(value)) return { ok: false, code: "invalid_params", message: "body must be a JSON object" };
|
|
return { ok: true, value };
|
|
} catch (error) {
|
|
return { ok: false, code: "parse_error", message: "Invalid JSON body", reason: error?.message ?? String(error) };
|
|
}
|
|
}
|
|
|
|
async function handleCreateWorkbenchLink(request, store) {
|
|
const body = await readJsonObject(request);
|
|
if (!body.ok) return jsonError(400, body.code, body.message);
|
|
const normalized = normalizeWorkbenchLinkInput(body.value, actorFromRequest(request));
|
|
if (!normalized.ok) return jsonError(400, normalized.code, normalized.message);
|
|
const link = await store.upsertWorkbenchLink(normalized.link);
|
|
return json(201, envelope({ link }));
|
|
}
|
|
|
|
async function handleUpsertMdtodoSource(request, store, options = {}) {
|
|
const body = await readJsonObject(request);
|
|
if (!body.ok) return jsonError(400, body.code, body.message);
|
|
const existing = options.mode === "update" ? await getSource(store, options.sourceId) : null;
|
|
if (options.mode === "update" && !existing) return jsonError(404, "source_not_found", "MDTODO source was not found");
|
|
const normalized = normalizeProjectSourceInput({ ...(existing ?? {}), ...body.value, sourceId: options.sourceId ?? body.value.sourceId }, existing ?? {});
|
|
if (!normalized.ok) return jsonError(normalized.status ?? 400, normalized.code, normalized.message);
|
|
await store.upsertSource(normalized.source);
|
|
await recordAuditEvent(store, request, {
|
|
action: options.mode === "update" ? "mdtodo.source.update" : "mdtodo.source.create",
|
|
targetType: "mdtodo_source",
|
|
targetId: normalized.source.sourceId,
|
|
outcome: "accepted",
|
|
sourceKind: normalized.source.sourceKind
|
|
});
|
|
return json(options.mode === "update" ? 200 : 201, envelope({ source: normalized.source }));
|
|
}
|
|
|
|
async function handleProbeMdtodoSource(store, sourceAdapter, sourceId, actor) {
|
|
const source = await getSource(store, sourceId);
|
|
if (!source) return jsonError(404, "source_not_found", "MDTODO source was not found");
|
|
const probe = await sourceAdapter.probe(source);
|
|
await recordAuditEvent(store, { actor }, { action: "mdtodo.source.probe", targetType: "mdtodo_source", targetId: source.sourceId, outcome: "succeeded", sourceKind: source.sourceKind });
|
|
return json(200, envelope({ probe }));
|
|
}
|
|
|
|
async function handleReindexMdtodoSource(store, sourceAdapter, sourceId, actor) {
|
|
const source = await getSource(store, sourceId);
|
|
if (!source) return jsonError(404, "source_not_found", "MDTODO source was not found");
|
|
const documents = await sourceAdapter.discover(source);
|
|
await store.replaceProjection(source, documents);
|
|
const projection = sourceProjection(source, documents);
|
|
await recordAuditEvent(store, { actor }, { action: "mdtodo.source.reindex", targetType: "mdtodo_source", targetId: source.sourceId, outcome: "succeeded", documentCount: projection.documentCount, taskCount: projection.taskCount });
|
|
return json(200, envelope({ projection }));
|
|
}
|
|
|
|
async function handleReadMdtodoFile(url, store, sourceAdapter, fileRef) {
|
|
const sourceId = queryToken(url, "sourceId");
|
|
if (!sourceId) return jsonError(400, "source_id_required", "sourceId is required");
|
|
const { source, document, error } = await resolveMdtodoDocument(store, sourceId, fileRef);
|
|
if (error) return error;
|
|
const file = await sourceAdapter.readFile(source, document.relativePath);
|
|
return json(200, envelope({ file }));
|
|
}
|
|
|
|
async function handleReadMdtodoTaskDetail(url, store, sourceAdapter) {
|
|
const taskRef = queryOpaque(url, "taskRef");
|
|
if (!taskRef) return jsonError(400, "task_ref_required", "taskRef is required");
|
|
const detail = await loadTaskDetail({ store, sourceAdapter, taskRef, allowProjectedFallback: true });
|
|
if (detail.error) return detail.error;
|
|
if (detail.availability?.state === "unavailable") {
|
|
return json(200, envelope({
|
|
status: "partial",
|
|
task: detail.task,
|
|
detail: null,
|
|
file: fileSummary(detail.document),
|
|
detailAuthority: detail.availability
|
|
}));
|
|
}
|
|
return json(200, envelope({
|
|
status: "ready",
|
|
task: { ...detail.task, bodyPreview: detail.detail.bodyPreview, linkCount: detail.detail.links.length },
|
|
detail: detail.detail,
|
|
file: fileSummary(detail.file),
|
|
detailAuthority: taskDetailAuthority("ready", detail.source)
|
|
}));
|
|
}
|
|
|
|
async function handleReadMdtodoLaunchContext(url, store) {
|
|
const taskRef = queryOpaque(url, "taskRef");
|
|
if (!taskRef) return jsonError(400, "task_ref_required", "taskRef is required");
|
|
const task = await getTaskByRef(store, taskRef);
|
|
if (!task) return jsonError(404, "task_not_found", "MDTODO task was not found");
|
|
const source = await getSource(store, task.sourceId);
|
|
if (!source) return jsonError(404, "source_not_found", "MDTODO source was not found");
|
|
const executionContext = buildMdtodoExecutionContext({ task, source });
|
|
if (!executionContext.ok) return jsonError(executionContext.status, executionContext.code, executionContext.message);
|
|
const launchContext = buildMdtodoLaunchContext({ task, source, executionContext: executionContext.context });
|
|
return json(200, envelope({ task, source: sourceSummary(source), executionContext: executionContext.context, launchContext }));
|
|
}
|
|
|
|
async function handleReadMdtodoReportPreview(url, store, sourceAdapter) {
|
|
const taskRef = queryOpaque(url, "taskRef");
|
|
const linkId = queryToken(url, "linkId");
|
|
if (!taskRef) return jsonError(400, "task_ref_required", "taskRef is required");
|
|
if (!linkId) return jsonError(400, "link_id_required", "linkId is required");
|
|
let detail;
|
|
try {
|
|
detail = await loadTaskDetail({ store, sourceAdapter, taskRef });
|
|
} catch (error) {
|
|
if (isHwpodAvailabilityError(error)) return hwpodAvailabilityError(error);
|
|
throw error;
|
|
}
|
|
if (detail.error) return detail.error;
|
|
const link = detail.detail.links.find((item) => item.linkId === linkId);
|
|
if (!link) return jsonError(404, "report_link_not_found", "MDTODO report link was not found");
|
|
if (link.kind !== "markdown-report" || !link.relativePath) return jsonError(400, "unsupported_report_link", "Only safe relative Markdown report links can be previewed");
|
|
let report;
|
|
try {
|
|
report = await sourceAdapter.readLinkedMarkdown(detail.source, detail.document.relativePath, link.href);
|
|
} catch (error) {
|
|
if (isHwpodAvailabilityError(error)) return hwpodAvailabilityError(error);
|
|
throw error;
|
|
}
|
|
return json(200, envelope({
|
|
task: detail.task,
|
|
link,
|
|
report: {
|
|
...report,
|
|
linkId: link.linkId,
|
|
label: link.label,
|
|
href: link.href,
|
|
valuesRedacted: false
|
|
},
|
|
file: fileSummary(detail.file)
|
|
}));
|
|
}
|
|
|
|
async function loadTaskDetail({ store, sourceAdapter, taskRef, allowProjectedFallback = false }) {
|
|
const task = await getTaskByRef(store, taskRef);
|
|
if (!task) return { error: jsonError(404, "task_not_found", "MDTODO task was not found") };
|
|
const { source, document, error } = await resolveMdtodoDocument(store, task.sourceId, task.fileRef);
|
|
if (error) return { error };
|
|
let file;
|
|
try {
|
|
file = await sourceAdapter.readFile(source, document.relativePath);
|
|
} catch (readError) {
|
|
if (allowProjectedFallback && source.sourceKind === "hwpod-workspace" && isHwpodAvailabilityError(readError)) {
|
|
return {
|
|
source,
|
|
document,
|
|
file: null,
|
|
task,
|
|
detail: null,
|
|
availability: taskDetailAuthority("unavailable", source, readError)
|
|
};
|
|
}
|
|
throw readError;
|
|
}
|
|
const detail = readMdtodoTaskDetail(file.content, {
|
|
sourceId: source.sourceId,
|
|
fileRef: document.fileRef,
|
|
relativePath: document.relativePath,
|
|
projectId: document.projectId,
|
|
taskRef: task.taskRef,
|
|
rxxId: task.taskId
|
|
});
|
|
if (!detail) return { error: jsonError(404, "task_detail_not_found", "MDTODO task detail was not found in source Markdown") };
|
|
return { source, document, file, task, detail };
|
|
}
|
|
|
|
function isHwpodAvailabilityError(error) {
|
|
const statusCode = Number(error?.statusCode);
|
|
return error?.sourceKind === "hwpod-workspace" && [502, 503, 504].includes(statusCode);
|
|
}
|
|
|
|
function hwpodAvailabilityError(error) {
|
|
return jsonError(
|
|
Number(error?.statusCode),
|
|
safeToken(error?.code, "hwpod_source_unavailable"),
|
|
"HWPOD 源当前不可读；报告预览需等待 Node 恢复。"
|
|
);
|
|
}
|
|
|
|
function taskDetailAuthority(state, source, error = null) {
|
|
const unavailable = state === "unavailable";
|
|
return {
|
|
state,
|
|
authority: unavailable ? "project-management-projection" : "source-markdown",
|
|
sourceKind: source?.sourceKind ?? null,
|
|
code: unavailable ? safeToken(error?.code, "hwpod_source_unavailable") : null,
|
|
message: unavailable
|
|
? "HWPOD 源当前不可读；页面继续展示最近一次项目投影，正文编辑和报告预览需等待 Node 恢复。"
|
|
: null,
|
|
retryable: unavailable,
|
|
valuesRedacted: true
|
|
};
|
|
}
|
|
|
|
async function handleWriteMdtodoFile(request, url, store, sourceAdapter, fileRef, actor) {
|
|
const body = await readJsonObject(request, 1024 * 1024 + 4096);
|
|
if (!body.ok) return jsonError(body.code === "body_too_large" ? 413 : 400, body.code, body.message);
|
|
const sourceId = safeToken(body.value.sourceId, queryToken(url, "sourceId"));
|
|
if (!sourceId) return jsonError(400, "source_id_required", "sourceId is required");
|
|
if (typeof body.value.content !== "string") return jsonError(400, "content_required", "content must be a string");
|
|
const expectedFingerprint = safeOpaqueValue(body.value.expectedFingerprint ?? body.value.revision);
|
|
if (!expectedFingerprint) return jsonError(400, "expected_fingerprint_required", "expectedFingerprint is required for MDTODO writes");
|
|
const { source, document, error } = await resolveMdtodoDocument(store, sourceId, fileRef);
|
|
if (error) return error;
|
|
const file = await sourceAdapter.writeFile(source, document.relativePath, body.value.content, expectedFingerprint);
|
|
const documents = await sourceAdapter.discover(source);
|
|
await store.replaceProjection(source, documents);
|
|
const projection = sourceProjection(source, documents);
|
|
await recordAuditEvent(store, { actor }, { action: "mdtodo.file.write", targetType: "mdtodo_file", targetId: `${source.sourceId}:${fileRef}`, outcome: "succeeded", sourceKind: source.sourceKind, fileRef, revision: file.revision });
|
|
return json(200, envelope({ file, projection }));
|
|
}
|
|
|
|
async function handlePatchMdtodoTask(request, store, sourceAdapter, taskRef, actor) {
|
|
const body = await readJsonObject(request, 256 * 1024);
|
|
if (!body.ok) return jsonError(body.code === "body_too_large" ? 413 : 400, body.code, body.message);
|
|
const task = await getTaskByRef(store, taskRef);
|
|
if (!task) return jsonError(404, "task_not_found", "MDTODO task was not found");
|
|
const expectedFingerprint = safeOpaqueValue(body.value.expectedFingerprint ?? body.value.revision ?? body.value.expectedRevision);
|
|
if (!expectedFingerprint) return jsonError(400, "expected_fingerprint_required", "expectedFingerprint is required for MDTODO task writes");
|
|
const operations = [];
|
|
if (typeof body.value.title === "string") operations.push({ type: "updateTitle", rxxId: task.taskId, title: body.value.title });
|
|
if (typeof body.value.status === "string") operations.push({ type: "updateStatus", rxxId: task.taskId, status: body.value.status });
|
|
if (typeof body.value.body === "string") operations.push({ type: "updateBody", rxxId: task.taskId, body: body.value.body });
|
|
if (operations.length === 0) return jsonError(400, "mutation_required", "At least one MDTODO task field is required");
|
|
return mutateTaskDocument({ store, sourceAdapter, sourceId: task.sourceId, fileRef: task.fileRef, expectedFingerprint, operations, auditAction: "mdtodo.task.update", targetTaskRef: taskRef, actor, status: 200 });
|
|
}
|
|
|
|
async function handleCreateMdtodoTask(request, store, sourceAdapter, actor) {
|
|
const body = await readJsonObject(request, 256 * 1024);
|
|
if (!body.ok) return jsonError(body.code === "body_too_large" ? 413 : 400, body.code, body.message);
|
|
const expectedFingerprint = safeOpaqueValue(body.value.expectedFingerprint ?? body.value.revision ?? body.value.expectedRevision);
|
|
if (!expectedFingerprint) return jsonError(400, "expected_fingerprint_required", "expectedFingerprint is required for MDTODO task writes");
|
|
const title = shortText(body.value.title, 500);
|
|
if (!title) return jsonError(400, "title_required", "title is required for MDTODO task creation");
|
|
const parentTask = body.value.parentTaskRef ? await getTaskByRef(store, safeOpaqueValue(body.value.parentTaskRef)) : null;
|
|
const afterTask = body.value.afterTaskRef ? await getTaskByRef(store, safeOpaqueValue(body.value.afterTaskRef)) : null;
|
|
if (body.value.parentTaskRef && !parentTask) return jsonError(404, "parent_task_not_found", "Parent MDTODO task was not found");
|
|
if (body.value.afterTaskRef && !afterTask) return jsonError(404, "after_task_not_found", "Continuation MDTODO task was not found");
|
|
const sourceId = parentTask?.sourceId ?? afterTask?.sourceId ?? safeToken(body.value.sourceId, null);
|
|
const fileRef = parentTask?.fileRef ?? afterTask?.fileRef ?? safeToken(body.value.fileRef, null);
|
|
if (!sourceId || !fileRef) return jsonError(400, "task_target_required", "sourceId and fileRef are required for root MDTODO task creation");
|
|
const operation = {
|
|
type: "addTask",
|
|
title,
|
|
status: body.value.status ?? "open",
|
|
body: typeof body.value.body === "string" ? body.value.body : "",
|
|
parentRxxId: parentTask?.taskId ?? null,
|
|
afterRxxId: afterTask?.taskId ?? null
|
|
};
|
|
return mutateTaskDocument({ store, sourceAdapter, sourceId, fileRef, expectedFingerprint, operations: [operation], auditAction: "mdtodo.task.create", targetTaskRef: parentTask?.taskRef ?? afterTask?.taskRef ?? `${sourceId}:${fileRef}`, actor, status: 201 });
|
|
}
|
|
|
|
async function handleDeleteMdtodoTask(request, store, sourceAdapter, taskRef, actor) {
|
|
const body = await readJsonObject(request, 32768);
|
|
if (!body.ok) return jsonError(400, body.code, body.message);
|
|
const task = await getTaskByRef(store, taskRef);
|
|
if (!task) return jsonError(404, "task_not_found", "MDTODO task was not found");
|
|
const expectedFingerprint = safeOpaqueValue(body.value.expectedFingerprint ?? body.value.revision ?? body.value.expectedRevision);
|
|
if (!expectedFingerprint) return jsonError(400, "expected_fingerprint_required", "expectedFingerprint is required for MDTODO task writes");
|
|
return mutateTaskDocument({ store, sourceAdapter, sourceId: task.sourceId, fileRef: task.fileRef, expectedFingerprint, operations: [{ type: "deleteTask", rxxId: task.taskId }], auditAction: "mdtodo.task.delete", targetTaskRef: taskRef, actor, status: 200 });
|
|
}
|
|
|
|
async function mutateTaskDocument({ store, sourceAdapter, sourceId, fileRef, expectedFingerprint, operations, auditAction, targetTaskRef, actor, status }) {
|
|
const { source, document, error } = await resolveMdtodoDocument(store, sourceId, fileRef);
|
|
if (error) return error;
|
|
const current = await sourceAdapter.readFile(source, document.relativePath);
|
|
let markdown = current.content;
|
|
let mutation = null;
|
|
for (const operation of operations) {
|
|
mutation = mutateMdtodoDocument(markdown, { ...operation, expectedFingerprint: mutation ? null : expectedFingerprint }, { sourceId: source.sourceId, relativePath: document.relativePath, projectId: document.projectId });
|
|
if (!mutation.ok) return jsonError(mutation.conflict ? 409 : 400, mutation.code ?? "mdtodo_mutation_failed", mutation.message ?? "MDTODO task mutation failed");
|
|
markdown = mutation.markdown;
|
|
}
|
|
const file = await sourceAdapter.writeFile(source, document.relativePath, markdown, expectedFingerprint);
|
|
const documents = await sourceAdapter.discover(source);
|
|
await store.replaceProjection(source, documents);
|
|
const projection = sourceProjection(source, documents);
|
|
const tasks = await store.listTasks({ sourceId: source.sourceId, fileRef });
|
|
const changedTaskRef = mutation?.changedTaskId ? `mdtodo:${source.sourceId}:${fileRef}:${mutation.changedTaskId}` : null;
|
|
const task = changedTaskRef ? tasks.find((item) => item.taskRef === changedTaskRef) ?? null : null;
|
|
await recordAuditEvent(store, { actor }, { action: auditAction, targetType: "mdtodo_task", targetId: targetTaskRef, outcome: "succeeded", sourceKind: source.sourceKind, fileRef, revision: file.revision, changedTaskId: mutation?.changedTaskId ?? null, affectedTaskIds: mutation?.affectedTaskIds ?? [] });
|
|
return json(status, envelope({ task, affectedTaskIds: mutation?.affectedTaskIds ?? [], changedTaskId: mutation?.changedTaskId ?? null, file: fileSummary(file), projection }));
|
|
}
|
|
|
|
async function getTaskByRef(store, taskRef) {
|
|
const safeTaskRef = safeOpaqueValue(taskRef);
|
|
if (!safeTaskRef) return null;
|
|
if (typeof store.getTask === "function") return store.getTask(safeTaskRef);
|
|
return (await store.listTasks({ taskRef: safeTaskRef, limit: 1 }))[0] ?? null;
|
|
}
|
|
|
|
function fileSummary(file) {
|
|
return {
|
|
sourceId: file.sourceId,
|
|
fileRef: file.fileRef,
|
|
relativePath: file.relativePath,
|
|
fingerprint: file.fingerprint,
|
|
revision: file.revision,
|
|
parserMode: file.parserMode,
|
|
taskCount: file.taskCount,
|
|
valuesRedacted: true
|
|
};
|
|
}
|
|
|
|
async function resolveMdtodoDocument(store, sourceId, fileRef) {
|
|
const source = await getSource(store, sourceId);
|
|
if (!source) return { error: jsonError(404, "source_not_found", "MDTODO source was not found") };
|
|
const documents = await store.listDocuments({ sourceId });
|
|
const document = documents.find((item) => item.fileRef === fileRef);
|
|
if (!document) return { error: jsonError(404, "file_not_found", "MDTODO file was not found") };
|
|
return { source, document };
|
|
}
|
|
|
|
async function getSource(store, sourceId) {
|
|
if (!sourceId) return null;
|
|
if (typeof store.getSource === "function") return store.getSource(sourceId);
|
|
return (await store.listSources()).find((source) => source.sourceId === sourceId) ?? null;
|
|
}
|
|
|
|
function normalizeWorkbenchLinkInput(input, actor) {
|
|
const projectId = safeToken(input.projectId, null);
|
|
const taskRef = safeOpaqueValue(input.taskRef);
|
|
const sessionId = safeOpaqueValue(input.sessionId);
|
|
if (!projectId) return { ok: false, code: "project_id_required", message: "ProjectWorkbenchLink requires projectId" };
|
|
if (!taskRef) return { ok: false, code: "task_ref_required", message: "ProjectWorkbenchLink requires taskRef" };
|
|
if (!sessionId) return { ok: false, code: "session_id_required", message: "ProjectWorkbenchLink requires sessionId" };
|
|
const traceId = safeOpaqueValue(input.traceId);
|
|
const role = safeToken(input.role, "launch");
|
|
const link = sanitizeLinkJson(input.link);
|
|
return {
|
|
ok: true,
|
|
link: {
|
|
linkId: safeToken(input.linkId, stableLinkId({ projectId, taskRef, sessionId })),
|
|
projectId,
|
|
taskRef,
|
|
sessionId,
|
|
traceId,
|
|
createdBy: safeOpaqueValue(input.createdBy) ?? actor?.id ?? null,
|
|
role,
|
|
link
|
|
}
|
|
};
|
|
}
|
|
|
|
function sanitizeLinkJson(value) {
|
|
const input = value && typeof value === "object" && !Array.isArray(value) ? value : {};
|
|
const context = input.launchContext && typeof input.launchContext === "object" && !Array.isArray(input.launchContext) ? input.launchContext : {};
|
|
const execution = sanitizeExecutionContext(context.executionContext ?? context.execution);
|
|
return {
|
|
launchContext: {
|
|
source: "project-management",
|
|
projectId: safeToken(context.projectId, null),
|
|
taskRef: safeOpaqueValue(context.taskRef),
|
|
sourceId: safeToken(context.sourceId, null),
|
|
sourceKind: safeToken(context.sourceKind, null),
|
|
fileRef: safeToken(context.fileRef, null),
|
|
relativePath: safeRelativePath(context.relativePath),
|
|
taskId: safeToken(context.taskId, null),
|
|
title: shortText(context.title, 220),
|
|
status: safeToken(context.status, null),
|
|
hwpodId: execution?.hwpodId ?? safeOpaqueValue(context.hwpodId),
|
|
nodeId: execution?.nodeId ?? safeOpaqueValue(context.nodeId),
|
|
mdtodoRootRef: execution?.mdtodoRootRef ?? safeRelativePath(context.mdtodoRootRef),
|
|
workspaceRootRef: execution?.workspaceRootRef ?? safeWorkspaceRef(context.workspaceRootRef),
|
|
workspaceRootHash: execution?.workspaceRootHash ?? safeOpaqueValue(context.workspaceRootHash),
|
|
workspaceRootLabel: execution?.workspaceRootLabel ?? shortText(context.workspaceRootLabel, 180),
|
|
hwpodWorkspaceArgs: execution?.hwpodWorkspaceArgs ?? shortText(context.hwpodWorkspaceArgs, 500),
|
|
contextFingerprint: execution?.contextFingerprint ?? safeOpaqueValue(context.contextFingerprint),
|
|
capabilities: sanitizeCapabilities(context.capabilities),
|
|
executionContext: execution,
|
|
route: "/projects/mdtodo",
|
|
valuesRedacted: true
|
|
},
|
|
workbenchUrl: safeWorkbenchUrl(input.workbenchUrl),
|
|
valuesRedacted: true
|
|
};
|
|
}
|
|
|
|
function buildMdtodoLaunchContext({ task, source, executionContext }) {
|
|
return {
|
|
source: "project-management",
|
|
projectId: task.projectId,
|
|
taskRef: task.taskRef,
|
|
sourceId: task.sourceId,
|
|
sourceKind: source.sourceKind ?? source.kind ?? null,
|
|
fileRef: task.fileRef,
|
|
relativePath: safeRelativePath(task.relativePath),
|
|
taskId: task.taskId,
|
|
title: shortText(task.title, 220),
|
|
status: safeToken(task.status, null),
|
|
hwpodId: executionContext.hwpodId,
|
|
nodeId: executionContext.nodeId,
|
|
workspaceRootRef: executionContext.workspaceRootRef,
|
|
workspaceRootHash: executionContext.workspaceRootHash,
|
|
workspaceRootLabel: executionContext.workspaceRootLabel,
|
|
mdtodoRootRef: executionContext.mdtodoRootRef,
|
|
hwpodWorkspaceArgs: executionContext.hwpodWorkspaceArgs,
|
|
contextFingerprint: executionContext.contextFingerprint,
|
|
capabilities: executionContext.capabilities,
|
|
executionContext,
|
|
route: "/projects/mdtodo",
|
|
valuesRedacted: true
|
|
};
|
|
}
|
|
|
|
function buildMdtodoExecutionContext({ task, source }) {
|
|
const sourceKind = safeToken(source.sourceKind ?? source.kind, null);
|
|
const projectId = safeToken(task.projectId ?? source.projectId, null);
|
|
const taskRef = safeOpaqueValue(task.taskRef);
|
|
const sourceId = safeToken(task.sourceId ?? source.sourceId, null);
|
|
const fileRef = safeToken(task.fileRef, null);
|
|
if (!projectId || !taskRef || !sourceId || !fileRef) return { ok: false, status: 409, code: "mdtodo_launch_context_incomplete", message: "MDTODO launch context is missing task identity." };
|
|
const base = {
|
|
sourceId,
|
|
sourceKind,
|
|
projectId,
|
|
taskRef,
|
|
fileRef,
|
|
relativePath: safeRelativePath(task.relativePath),
|
|
taskId: safeToken(task.taskId, null),
|
|
valuesRedacted: true
|
|
};
|
|
if (sourceKind !== "hwpod-workspace") {
|
|
const context = { ...base, capabilities: sanitizeCapabilities(source.capabilities), contextFingerprint: contextFingerprint(base) };
|
|
return { ok: true, context };
|
|
}
|
|
const hwpodId = safeOpaqueValue(source.hwpodId);
|
|
const nodeId = safeOpaqueValue(source.nodeId);
|
|
const workspaceRootRef = safeWorkspaceRef(source.workspaceRootRef);
|
|
const mdtodoRootRef = safeRelativePath(source.mdtodoRootRef) ?? ".";
|
|
if (!hwpodId || !nodeId || !workspaceRootRef) {
|
|
return { ok: false, status: 409, code: "hwpod_launch_context_missing", message: "HWPOD MDTODO source is missing hwpodId, nodeId or workspaceRootRef." };
|
|
}
|
|
const hwpodWorkspaceArgs = `--hwpod-id ${hwpodId} --workspace-path ${promptShellArg(workspaceRootRef)}`;
|
|
const contextBase = {
|
|
...base,
|
|
hwpodId,
|
|
nodeId,
|
|
workspaceRootRef,
|
|
workspaceRootHash: hashText(workspaceRootRef),
|
|
workspaceRootLabel: workspaceRootLabel(workspaceRootRef),
|
|
mdtodoRootRef,
|
|
hwpodWorkspaceArgs,
|
|
capabilities: sanitizeCapabilities(source.capabilities),
|
|
valuesRedacted: true
|
|
};
|
|
return { ok: true, context: { ...contextBase, contextFingerprint: contextFingerprint(contextBase) } };
|
|
}
|
|
|
|
function sourceSummary(source) {
|
|
return {
|
|
sourceId: source.sourceId,
|
|
sourceKind: source.sourceKind ?? source.kind ?? null,
|
|
projectId: source.projectId ?? null,
|
|
hwpodId: safeOpaqueValue(source.hwpodId),
|
|
nodeId: safeOpaqueValue(source.nodeId),
|
|
mdtodoRootRef: safeRelativePath(source.mdtodoRootRef),
|
|
workspaceRootHash: source.workspaceRootRef ? hashText(source.workspaceRootRef) : null,
|
|
workspaceRootLabel: source.workspaceRootRef ? workspaceRootLabel(source.workspaceRootRef) : null,
|
|
valuesRedacted: true
|
|
};
|
|
}
|
|
|
|
function sanitizeExecutionContext(value) {
|
|
const input = value && typeof value === "object" && !Array.isArray(value) ? value : null;
|
|
if (!input) return null;
|
|
const sourceId = safeToken(input.sourceId, null);
|
|
const taskRef = safeOpaqueValue(input.taskRef);
|
|
return {
|
|
sourceId,
|
|
sourceKind: safeToken(input.sourceKind, null),
|
|
projectId: safeToken(input.projectId, null),
|
|
taskRef,
|
|
fileRef: safeToken(input.fileRef, null),
|
|
relativePath: safeRelativePath(input.relativePath),
|
|
taskId: safeToken(input.taskId, null),
|
|
hwpodId: safeOpaqueValue(input.hwpodId),
|
|
nodeId: safeOpaqueValue(input.nodeId),
|
|
workspaceRootRef: safeWorkspaceRef(input.workspaceRootRef),
|
|
workspaceRootHash: safeOpaqueValue(input.workspaceRootHash),
|
|
workspaceRootLabel: shortText(input.workspaceRootLabel, 180),
|
|
mdtodoRootRef: safeRelativePath(input.mdtodoRootRef),
|
|
hwpodWorkspaceArgs: shortText(input.hwpodWorkspaceArgs, 500),
|
|
contextFingerprint: safeOpaqueValue(input.contextFingerprint),
|
|
capabilities: sanitizeCapabilities(input.capabilities),
|
|
valuesRedacted: true
|
|
};
|
|
}
|
|
|
|
function sanitizeCapabilities(value) {
|
|
const input = value && typeof value === "object" && !Array.isArray(value) ? value : {};
|
|
const out = {};
|
|
for (const [key, item] of Object.entries(input)) {
|
|
if (!/^[A-Za-z0-9_.:-]{1,80}$/u.test(key)) continue;
|
|
if (["string", "number", "boolean"].includes(typeof item) || item === null) out[key] = item;
|
|
}
|
|
return out;
|
|
}
|
|
|
|
function contextFingerprint(value) {
|
|
return `ctx_${hashText(JSON.stringify(value)).slice(0, 24)}`;
|
|
}
|
|
|
|
function hashText(value) {
|
|
return createHash("sha256").update(String(value ?? "")).digest("hex");
|
|
}
|
|
|
|
function promptShellArg(value) {
|
|
return `'${String(value ?? "").replace(/'/gu, `'\\''`)}'`;
|
|
}
|
|
|
|
function workspaceRootLabel(value) {
|
|
const normalized = String(value ?? "").replace(/\\/gu, "/").replace(/\/+$/u, "");
|
|
return normalized.split("/").filter(Boolean).pop() || normalized || null;
|
|
}
|
|
|
|
function stableLinkId({ projectId, taskRef, sessionId }) {
|
|
return `lnk_${createHash("sha256").update(`${projectId}\n${taskRef}\n${sessionId}`).digest("hex").slice(0, 24)}`;
|
|
}
|
|
|
|
async function recordAuditEvent(store, requestOrContext, event) {
|
|
if (typeof store.recordAuditEvent !== "function") return;
|
|
const actor = requestOrContext instanceof Request ? actorFromRequest(requestOrContext) : requestOrContext?.actor ?? null;
|
|
await store.recordAuditEvent({
|
|
eventId: `aud_${randomUUID()}`,
|
|
actorId: actor?.id ?? null,
|
|
action: event.action,
|
|
targetType: event.targetType,
|
|
targetId: event.targetId,
|
|
outcome: event.outcome,
|
|
event,
|
|
valuesRedacted: true
|
|
});
|
|
}
|
|
|
|
function matchSourceAction(pathname) {
|
|
const match = /^\/v1\/project-management\/mdtodo\/sources\/([A-Za-z0-9_.:-]{1,160})(?:\/(probe|reindex))?$/u.exec(pathname);
|
|
return match ? { sourceId: match[1], action: match[2] ?? null } : null;
|
|
}
|
|
|
|
function matchFileContent(pathname) {
|
|
const match = /^\/v1\/project-management\/mdtodo\/files\/([A-Za-z0-9_.:-]{1,160})\/content$/u.exec(pathname);
|
|
return match ? { fileRef: match[1] } : null;
|
|
}
|
|
|
|
function matchTaskAction(pathname) {
|
|
const match = /^\/v1\/project-management\/mdtodo\/tasks\/(.+)$/u.exec(pathname);
|
|
return match ? { taskRef: decodeURIComponent(match[1]) } : null;
|
|
}
|
|
|
|
function safeOpaqueValue(value) {
|
|
const text = String(value ?? "").trim();
|
|
return /^[A-Za-z0-9_.:/#_-]{1,360}$/u.test(text) ? text : null;
|
|
}
|
|
|
|
function safeWorkbenchUrl(value) {
|
|
const text = String(value ?? "").trim();
|
|
return /^\/workbench\/sessions\/[^/?#]+$/u.test(text) ? text : null;
|
|
}
|
|
|
|
function safeRelativePath(value) {
|
|
const text = String(value ?? "").replace(/\\/gu, "/").trim().replace(/^\/+|\/+$/gu, "");
|
|
if (!text) return null;
|
|
if (text === ".") return ".";
|
|
if (text.includes("..") || /(^|\/)\./u.test(text)) return null;
|
|
return /^[\p{L}\p{N}_./ -]{1,360}$/u.test(text) ? text : null;
|
|
}
|
|
|
|
function safeWorkspaceRef(value) {
|
|
const text = String(value ?? "").trim();
|
|
if (!text || text.includes("\0") || text.length > 500) return null;
|
|
return /^[\p{L}\p{N}_:./\\ -]+$/u.test(text) ? text : null;
|
|
}
|
|
|
|
function shortText(value, max) {
|
|
const text = String(value ?? "").replace(/\s+/gu, " ").trim();
|
|
return text ? text.slice(0, max) : null;
|
|
}
|
|
|
|
function json(status, payload) {
|
|
return new Response(`${JSON.stringify(payload)}\n`, {
|
|
status,
|
|
headers: {
|
|
"content-type": "application/json; charset=utf-8",
|
|
"cache-control": "no-store"
|
|
}
|
|
});
|
|
}
|
|
|
|
function jsonError(status, code, message) {
|
|
return json(status, { ok: false, contractVersion, serviceId, error: { code, message, status }, valuesRedacted: true });
|
|
}
|
|
|
|
function queryToken(url, name) {
|
|
const value = url.searchParams.get(name);
|
|
return /^[A-Za-z0-9_.:-]{1,160}$/u.test(String(value ?? "")) ? value : null;
|
|
}
|
|
|
|
function queryOpaque(url, name) {
|
|
const value = url.searchParams.get(name);
|
|
return /^[A-Za-z0-9_.:/#_-]{1,320}$/u.test(String(value ?? "")) ? value : null;
|
|
}
|
|
|
|
function querySearch(url, name) {
|
|
const value = url.searchParams.get(name);
|
|
if (value === null) return null;
|
|
const text = shortText(value, 120);
|
|
return text && /^[\p{L}\p{N}\s_.:/#-]{1,120}$/u.test(text) ? text : null;
|
|
}
|
|
|
|
function safeToken(value, fallback) {
|
|
const text = String(value ?? "").trim();
|
|
return /^[A-Za-z0-9_.:-]{1,96}$/u.test(text) ? text : fallback;
|
|
}
|
|
|
|
function positiveInteger(value, fallback) {
|
|
const number = Number(value);
|
|
return Number.isInteger(number) && number > 0 ? number : fallback;
|
|
}
|
|
|
|
function nonNegativeInteger(value, fallback) {
|
|
const number = Number(value);
|
|
return Number.isInteger(number) && number >= 0 ? number : fallback;
|
|
}
|
|
|
|
function taskListPage(url, options) {
|
|
const limit = Math.min(options.maxLimit, positiveInteger(url.searchParams.get("limit"), options.defaultLimit));
|
|
return {
|
|
offset: nonNegativeInteger(url.searchParams.get("offset"), 0),
|
|
limit,
|
|
maxLimit: options.maxLimit
|
|
};
|
|
}
|