2087 lines
70 KiB
TypeScript
2087 lines
70 KiB
TypeScript
import { readFile, readdir } from "node:fs/promises";
|
|
import path from "node:path";
|
|
import { and, asc, desc, eq, getTableColumns, gte, lte, ne, or } from "drizzle-orm";
|
|
import type { Db } from "@paperclipai/db";
|
|
import {
|
|
agents,
|
|
companies,
|
|
companySkills,
|
|
costEvents,
|
|
documentRevisions,
|
|
documents,
|
|
feedbackExports,
|
|
feedbackVotes,
|
|
heartbeatRunEvents,
|
|
heartbeatRuns,
|
|
instanceSettings,
|
|
issueComments,
|
|
issueDocuments,
|
|
issues,
|
|
} from "@paperclipai/db";
|
|
import { readPaperclipSkillSyncPreference } from "@paperclipai/adapter-utils/server-utils";
|
|
import { claudeConfigDir, parseClaudeStreamJson } from "@paperclipai/adapter-claude-local/server";
|
|
import { codexHomeDir, parseCodexJsonl } from "@paperclipai/adapter-codex-local/server";
|
|
import { parseOpenCodeJsonl } from "@paperclipai/adapter-opencode-local/server";
|
|
import {
|
|
DEFAULT_FEEDBACK_DATA_SHARING_PREFERENCE,
|
|
DEFAULT_FEEDBACK_DATA_SHARING_TERMS_VERSION,
|
|
instanceGeneralSettingsSchema,
|
|
type FeedbackTargetType,
|
|
type FeedbackTraceBundle,
|
|
type FeedbackTraceBundleCaptureStatus,
|
|
type FeedbackTraceBundleFile,
|
|
type FeedbackTrace,
|
|
type FeedbackTraceStatus,
|
|
type FeedbackTraceTargetSummary,
|
|
type FeedbackVoteValue,
|
|
} from "@paperclipai/shared";
|
|
import { resolveHomeAwarePath, resolvePaperclipInstanceRoot } from "../home-paths.js";
|
|
import { notFound, unprocessable } from "../errors.js";
|
|
import { agentInstructionsService } from "./agent-instructions.js";
|
|
import {
|
|
createFeedbackRedactionState,
|
|
finalizeFeedbackRedactionSummary,
|
|
sanitizeFeedbackText,
|
|
sanitizeFeedbackValue,
|
|
sha256Digest,
|
|
} from "./feedback-redaction.js";
|
|
import { getRunLogStore } from "./run-log-store.js";
|
|
|
|
const FEEDBACK_SCHEMA_VERSION = "paperclip-feedback-envelope-v2";
|
|
const FEEDBACK_BUNDLE_VERSION = "paperclip-feedback-bundle-v2";
|
|
const FEEDBACK_PAYLOAD_VERSION = "paperclip-feedback-v1";
|
|
const FEEDBACK_DESTINATION = "paperclip_labs_feedback_v1";
|
|
const FEEDBACK_CONTEXT_WINDOW = 3;
|
|
const MAX_EXCERPT_CHARS = 200;
|
|
const MAX_PRIMARY_CONTENT_CHARS = 8_000;
|
|
const MAX_CONTEXT_ITEM_BODY_CHARS = 3_000;
|
|
const MAX_TOTAL_CONTEXT_CHARS = 12_000;
|
|
const MAX_DESCRIPTION_CHARS = 1_200;
|
|
const MAX_INSTRUCTIONS_BODY_CHARS = 8_000;
|
|
const MAX_PATH_CHARS = 600;
|
|
const MAX_SKILLS = 20;
|
|
const MAX_INSTRUCTION_FILES = 20;
|
|
const MAX_TRACE_FILE_CHARS = 10_000_000;
|
|
const DEFAULT_INSTANCE_SETTINGS_SINGLETON_KEY = "default";
|
|
const FEEDBACK_EXPORT_BACKEND_NOT_CONFIGURED = "Feedback export backend is not configured";
|
|
|
|
type FeedbackTraceRow = typeof feedbackExports.$inferSelect & {
|
|
issueIdentifier: string | null;
|
|
issueTitle: string;
|
|
};
|
|
|
|
type PendingFeedbackExportRow = typeof feedbackExports.$inferSelect;
|
|
|
|
type IssueFeedbackContext = {
|
|
id: string;
|
|
companyId: string;
|
|
projectId: string | null;
|
|
identifier: string | null;
|
|
title: string;
|
|
description: string | null;
|
|
};
|
|
|
|
type FeedbackTargetRecord = {
|
|
targetType: FeedbackTargetType;
|
|
targetId: string;
|
|
label: string;
|
|
body: string;
|
|
createdAt: Date;
|
|
authorAgentId: string | null;
|
|
authorUserId: string | null;
|
|
createdByRunId: string | null;
|
|
documentId: string | null;
|
|
documentKey: string | null;
|
|
documentTitle: string | null;
|
|
revisionNumber: number | null;
|
|
issuePath: string | null;
|
|
targetPath: string | null;
|
|
};
|
|
|
|
type ResolvedFeedbackTarget = FeedbackTargetRecord & {
|
|
payloadTarget: Record<string, unknown>;
|
|
};
|
|
|
|
const feedbackExportColumns = getTableColumns(feedbackExports);
|
|
const instructionsSvc = agentInstructionsService();
|
|
|
|
type FeedbackTraceShareClient = {
|
|
uploadTraceBundle(bundle: FeedbackTraceBundle): Promise<{ objectKey: string }>;
|
|
};
|
|
|
|
type FeedbackServiceOptions = {
|
|
shareClient?: FeedbackTraceShareClient;
|
|
};
|
|
|
|
function asRecord(value: unknown): Record<string, unknown> | null {
|
|
if (!value || typeof value !== "object" || Array.isArray(value)) return null;
|
|
return value as Record<string, unknown>;
|
|
}
|
|
|
|
function asString(value: unknown) {
|
|
if (typeof value !== "string") return null;
|
|
const trimmed = value.trim();
|
|
return trimmed.length > 0 ? trimmed : null;
|
|
}
|
|
|
|
function asNumber(value: unknown) {
|
|
if (typeof value !== "number" || !Number.isFinite(value)) return null;
|
|
return value;
|
|
}
|
|
|
|
function asBoolean(value: unknown) {
|
|
return typeof value === "boolean" ? value : null;
|
|
}
|
|
|
|
function uniqueNonEmpty(values: Array<string | null | undefined>) {
|
|
return Array.from(new Set(values.map((value) => value?.trim() ?? "").filter(Boolean)));
|
|
}
|
|
|
|
function truncateExcerpt(text: string, max = MAX_EXCERPT_CHARS) {
|
|
const normalized = text.replace(/\s+/g, " ").trim();
|
|
if (!normalized) return null;
|
|
return normalized.length <= max ? normalized : `${normalized.slice(0, max - 1)}...`;
|
|
}
|
|
|
|
function contentTypeForPath(filePath: string) {
|
|
const lower = filePath.toLowerCase();
|
|
if (lower.endsWith(".jsonl") || lower.endsWith(".ndjson")) return "application/x-ndjson";
|
|
if (lower.endsWith(".json")) return "application/json";
|
|
if (lower.endsWith(".md")) return "text/markdown; charset=utf-8";
|
|
return "text/plain; charset=utf-8";
|
|
}
|
|
|
|
function normalizeInstanceGeneralSettings(raw: unknown) {
|
|
const parsed = instanceGeneralSettingsSchema.safeParse(raw ?? {});
|
|
if (parsed.success) return parsed.data;
|
|
return {
|
|
censorUsernameInLogs: false,
|
|
feedbackDataSharingPreference: DEFAULT_FEEDBACK_DATA_SHARING_PREFERENCE,
|
|
};
|
|
}
|
|
|
|
function buildIssuePath(identifier: string | null) {
|
|
if (!identifier) return null;
|
|
const prefix = identifier.split("-")[0]?.trim();
|
|
if (!prefix) return null;
|
|
return `/${prefix}/issues/${identifier}`;
|
|
}
|
|
|
|
function buildTargetSummary(input: {
|
|
label: string;
|
|
excerpt: string | null;
|
|
authorAgentId: string | null;
|
|
authorUserId: string | null;
|
|
createdAt: Date | null;
|
|
documentKey?: string | null;
|
|
documentTitle?: string | null;
|
|
revisionNumber?: number | null;
|
|
}): FeedbackTraceTargetSummary {
|
|
return {
|
|
label: input.label,
|
|
excerpt: input.excerpt,
|
|
authorAgentId: input.authorAgentId,
|
|
authorUserId: input.authorUserId,
|
|
createdAt: input.createdAt,
|
|
documentKey: input.documentKey ?? null,
|
|
documentTitle: input.documentTitle ?? null,
|
|
revisionNumber: input.revisionNumber ?? null,
|
|
};
|
|
}
|
|
|
|
function normalizeReason(vote: FeedbackVoteValue, reason: string | null | undefined) {
|
|
if (vote !== "down" || typeof reason !== "string") return null;
|
|
const trimmed = reason.trim();
|
|
return trimmed.length > 0 ? trimmed : null;
|
|
}
|
|
|
|
function normalizeSkillReference(value: string) {
|
|
return value.trim().toLowerCase();
|
|
}
|
|
|
|
function matchesSkillReference(
|
|
skill: typeof companySkills.$inferSelect,
|
|
reference: string,
|
|
) {
|
|
const normalized = normalizeSkillReference(reference);
|
|
if (!normalized) return false;
|
|
if (skill.key.toLowerCase() === normalized) return true;
|
|
if (skill.slug.toLowerCase() === normalized) return true;
|
|
if (skill.name.toLowerCase() === normalized) return true;
|
|
const keyTail = skill.key.split("/").pop()?.toLowerCase();
|
|
return keyTail === normalized;
|
|
}
|
|
|
|
function buildExportId(feedbackVoteId: string, sharedAt: Date) {
|
|
return `fbexp_${sha256Digest(`${feedbackVoteId}:${sharedAt.toISOString()}`).slice(0, 24)}`;
|
|
}
|
|
|
|
function resolveSourceRunId(payloadSnapshot: Record<string, unknown> | null) {
|
|
const targetRunId = asString(asRecord(payloadSnapshot?.target)?.createdByRunId);
|
|
if (targetRunId) return targetRunId;
|
|
|
|
const bundle = asRecord(payloadSnapshot?.bundle);
|
|
const agentContext = asRecord(bundle?.agentContext);
|
|
const runtime = asRecord(agentContext?.runtime);
|
|
return asString(asRecord(runtime?.sourceRun)?.id);
|
|
}
|
|
|
|
function makeBundleFile(input: {
|
|
path: string;
|
|
contentType: string;
|
|
source: FeedbackTraceBundleFile["source"];
|
|
contents: string;
|
|
}) {
|
|
return {
|
|
path: input.path,
|
|
contentType: input.contentType,
|
|
encoding: "utf8" as const,
|
|
byteLength: Buffer.byteLength(input.contents, "utf8"),
|
|
sha256: sha256Digest(input.contents),
|
|
source: input.source,
|
|
contents: input.contents,
|
|
} satisfies FeedbackTraceBundleFile;
|
|
}
|
|
|
|
function appendNote(notes: string[], note: string) {
|
|
if (note.trim().length === 0 || notes.includes(note)) return;
|
|
notes.push(note);
|
|
}
|
|
|
|
async function readTextFileIfPresent(
|
|
filePath: string | null,
|
|
state: ReturnType<typeof createFeedbackRedactionState>,
|
|
fieldPath: string,
|
|
) {
|
|
if (!filePath) return null;
|
|
const raw = await readFile(filePath, "utf8").catch(() => null);
|
|
if (raw == null) return null;
|
|
return sanitizeFeedbackText(raw, state, fieldPath, MAX_TRACE_FILE_CHARS);
|
|
}
|
|
|
|
async function listChildFiles(dirPath: string) {
|
|
const entries = await readdir(dirPath, { withFileTypes: true }).catch(() => []);
|
|
return entries
|
|
.filter((entry) => entry.isFile())
|
|
.map((entry) => path.join(dirPath, entry.name))
|
|
.sort((left, right) => left.localeCompare(right));
|
|
}
|
|
|
|
async function listNestedFiles(dirPath: string, maxDepth = 4): Promise<string[]> {
|
|
async function walk(currentPath: string, depth: number): Promise<string[]> {
|
|
const entries = await readdir(currentPath, { withFileTypes: true }).catch(() => []);
|
|
const files = entries
|
|
.filter((entry) => entry.isFile())
|
|
.map((entry) => path.join(currentPath, entry.name))
|
|
.sort((left, right) => left.localeCompare(right));
|
|
if (depth >= maxDepth) return files;
|
|
|
|
const childDirs = entries
|
|
.filter((entry) => entry.isDirectory())
|
|
.map((entry) => path.join(currentPath, entry.name))
|
|
.sort((left, right) => left.localeCompare(right));
|
|
const nested = await Promise.all(childDirs.map((childDir) => walk(childDir, depth + 1)));
|
|
return [...files, ...nested.flat()];
|
|
}
|
|
|
|
return walk(dirPath, 0);
|
|
}
|
|
|
|
async function findMatchingFile(
|
|
rootDir: string,
|
|
matcher: (absolutePath: string, name: string) => boolean,
|
|
maxDepth = 5,
|
|
): Promise<string | null> {
|
|
async function search(dirPath: string, depth: number): Promise<string | null> {
|
|
const entries = await readdir(dirPath, { withFileTypes: true }).catch(() => []);
|
|
for (const entry of entries) {
|
|
const absolutePath = path.join(dirPath, entry.name);
|
|
if (entry.isFile() && matcher(absolutePath, entry.name)) {
|
|
return absolutePath;
|
|
}
|
|
}
|
|
if (depth >= maxDepth) return null;
|
|
for (const entry of entries) {
|
|
if (!entry.isDirectory()) continue;
|
|
const found = await search(path.join(dirPath, entry.name), depth + 1);
|
|
if (found) return found;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
return search(rootDir, 0);
|
|
}
|
|
|
|
async function readFullRunLog(run: {
|
|
logStore: string | null;
|
|
logRef: string | null;
|
|
}) {
|
|
if (run.logStore !== "local_file" || !run.logRef) return null;
|
|
const store = getRunLogStore();
|
|
let offset = 0;
|
|
let combined = "";
|
|
|
|
while (true) {
|
|
const result = await store.read({ store: "local_file", logRef: run.logRef }, {
|
|
offset,
|
|
limitBytes: 512_000,
|
|
}).catch(() => null);
|
|
if (!result) return combined || null;
|
|
combined += result.content;
|
|
if (result.nextOffset == null) break;
|
|
offset = result.nextOffset;
|
|
}
|
|
|
|
return combined || null;
|
|
}
|
|
|
|
function parseRunLogEntries(logText: string | null) {
|
|
if (!logText) return [];
|
|
const entries: Array<{ ts: string; stream: string; chunk: string }> = [];
|
|
for (const rawLine of logText.split(/\r?\n/)) {
|
|
const line = rawLine.trim();
|
|
if (!line) continue;
|
|
try {
|
|
const parsed = JSON.parse(line) as { ts?: unknown; stream?: unknown; chunk?: unknown };
|
|
const ts = asString(parsed.ts) ?? new Date(0).toISOString();
|
|
const stream = asString(parsed.stream) ?? "stdout";
|
|
const chunk = typeof parsed.chunk === "string" ? parsed.chunk : "";
|
|
entries.push({ ts, stream, chunk });
|
|
} catch {
|
|
// Keep malformed lines out of the normalized bundle but preserve the raw log file separately.
|
|
}
|
|
}
|
|
return entries;
|
|
}
|
|
|
|
function captureStatusFromFiles(files: FeedbackTraceBundleFile[]): FeedbackTraceBundleCaptureStatus {
|
|
const sources = new Set(files.map((file) => file.source));
|
|
if (sources.has("codex_session")) return "full";
|
|
if (sources.has("claude_project_session") || sources.has("claude_debug_log")) return "full";
|
|
if (
|
|
sources.has("opencode_session") &&
|
|
sources.has("opencode_message") &&
|
|
sources.has("opencode_message_part")
|
|
) {
|
|
return "full";
|
|
}
|
|
|
|
const hasAdapterFiles = files.some((file) =>
|
|
file.source !== "paperclip_run" &&
|
|
file.source !== "paperclip_run_events" &&
|
|
file.source !== "paperclip_run_log",
|
|
);
|
|
if (hasAdapterFiles) return "partial";
|
|
return files.length > 0 ? "partial" : "unavailable";
|
|
}
|
|
|
|
async function buildCodexTraceFiles(input: {
|
|
companyId: string;
|
|
sessionId: string | null;
|
|
state: ReturnType<typeof createFeedbackRedactionState>;
|
|
notes: string[];
|
|
}) {
|
|
const files: FeedbackTraceBundleFile[] = [];
|
|
if (!input.sessionId) {
|
|
appendNote(input.notes, "codex_session_id_missing");
|
|
return { files, raw: null as Record<string, unknown> | null, normalized: null as Record<string, unknown> | null };
|
|
}
|
|
|
|
const managedRoot = path.join(
|
|
resolvePaperclipInstanceRoot(),
|
|
"companies",
|
|
input.companyId,
|
|
"codex-home",
|
|
"sessions",
|
|
);
|
|
const sharedRoot = path.join(codexHomeDir(), "sessions");
|
|
const sessionFile =
|
|
await findMatchingFile(managedRoot, (_absolutePath, name) => name.includes(input.sessionId!), 6) ??
|
|
await findMatchingFile(sharedRoot, (_absolutePath, name) => name.includes(input.sessionId!), 6);
|
|
|
|
const sessionText = await readTextFileIfPresent(sessionFile, input.state, "bundle.rawAdapterTrace.codex.session");
|
|
if (!sessionText) {
|
|
appendNote(input.notes, "codex_session_file_missing");
|
|
return { files, raw: null as Record<string, unknown> | null, normalized: null as Record<string, unknown> | null };
|
|
}
|
|
|
|
files.push(makeBundleFile({
|
|
path: "adapter/codex/session.jsonl",
|
|
contentType: "application/x-ndjson",
|
|
source: "codex_session",
|
|
contents: sessionText,
|
|
}));
|
|
|
|
return {
|
|
files,
|
|
raw: {
|
|
adapterType: "codex_local",
|
|
sessionId: input.sessionId,
|
|
sessionFile: sessionFile ? path.basename(sessionFile) : null,
|
|
},
|
|
normalized: sanitizeFeedbackValue(
|
|
{
|
|
adapterType: "codex_local",
|
|
sessionId: input.sessionId,
|
|
summary: parseCodexJsonl(sessionText),
|
|
},
|
|
input.state,
|
|
"bundle.normalizedAdapterTrace.codex",
|
|
MAX_TRACE_FILE_CHARS,
|
|
) as Record<string, unknown>,
|
|
};
|
|
}
|
|
|
|
async function buildClaudeTraceFiles(input: {
|
|
sessionId: string | null;
|
|
stdoutText: string;
|
|
state: ReturnType<typeof createFeedbackRedactionState>;
|
|
notes: string[];
|
|
}) {
|
|
const files: FeedbackTraceBundleFile[] = [];
|
|
const sanitizedStdout = sanitizeFeedbackText(
|
|
input.stdoutText,
|
|
input.state,
|
|
"bundle.rawAdapterTrace.claude.stdout",
|
|
MAX_TRACE_FILE_CHARS,
|
|
);
|
|
if (sanitizedStdout.trim().length > 0) {
|
|
files.push(makeBundleFile({
|
|
path: "adapter/claude/stream-json.ndjson",
|
|
contentType: "application/x-ndjson",
|
|
source: "claude_stream_json",
|
|
contents: sanitizedStdout,
|
|
}));
|
|
}
|
|
|
|
const projectsRoot = path.join(claudeConfigDir(), "projects");
|
|
const projectSessionFile = input.sessionId
|
|
? await findMatchingFile(projectsRoot, (_absolutePath, name) => name === `${input.sessionId}.jsonl`, 6)
|
|
: null;
|
|
const projectSessionText = await readTextFileIfPresent(
|
|
projectSessionFile,
|
|
input.state,
|
|
"bundle.rawAdapterTrace.claude.projectSession",
|
|
);
|
|
if (projectSessionText) {
|
|
files.push(makeBundleFile({
|
|
path: "adapter/claude/session.jsonl",
|
|
contentType: "application/x-ndjson",
|
|
source: "claude_project_session",
|
|
contents: projectSessionText,
|
|
}));
|
|
} else if (input.sessionId) {
|
|
appendNote(input.notes, "claude_project_session_missing");
|
|
}
|
|
|
|
const projectSessionArtifactsDir = projectSessionFile
|
|
? path.join(path.dirname(projectSessionFile), input.sessionId ?? "")
|
|
: null;
|
|
const projectSessionArtifactFiles = projectSessionArtifactsDir
|
|
? await listNestedFiles(projectSessionArtifactsDir, 4)
|
|
: [];
|
|
for (const filePath of projectSessionArtifactFiles) {
|
|
const relativePath = path.relative(projectSessionArtifactsDir!, filePath).split(path.sep).join("/");
|
|
const fileText = await readTextFileIfPresent(
|
|
filePath,
|
|
input.state,
|
|
`bundle.rawAdapterTrace.claude.projectArtifacts.${relativePath}`,
|
|
);
|
|
if (!fileText) continue;
|
|
files.push(makeBundleFile({
|
|
path: `adapter/claude/session/${relativePath}`,
|
|
contentType: contentTypeForPath(filePath),
|
|
source: "claude_project_artifact",
|
|
contents: fileText,
|
|
}));
|
|
}
|
|
|
|
const debugLogText = await readTextFileIfPresent(
|
|
input.sessionId ? path.join(claudeConfigDir(), "debug", `${input.sessionId}.txt`) : null,
|
|
input.state,
|
|
"bundle.rawAdapterTrace.claude.debugLog",
|
|
);
|
|
if (debugLogText) {
|
|
files.push(makeBundleFile({
|
|
path: "adapter/claude/debug.txt",
|
|
contentType: "text/plain; charset=utf-8",
|
|
source: "claude_debug_log",
|
|
contents: debugLogText,
|
|
}));
|
|
}
|
|
|
|
const taskDir = input.sessionId ? path.join(claudeConfigDir(), "tasks", input.sessionId) : null;
|
|
const taskFiles = taskDir ? await listChildFiles(taskDir) : [];
|
|
const metadataPieces: string[] = [];
|
|
for (const filePath of taskFiles) {
|
|
const fileText = await readTextFileIfPresent(
|
|
filePath,
|
|
input.state,
|
|
`bundle.rawAdapterTrace.claude.taskMetadata.${path.basename(filePath)}`,
|
|
);
|
|
if (!fileText) continue;
|
|
metadataPieces.push(`# ${path.basename(filePath)}\n${fileText}`);
|
|
}
|
|
if (metadataPieces.length > 0) {
|
|
files.push(makeBundleFile({
|
|
path: "adapter/claude/task-metadata.txt",
|
|
contentType: "text/plain; charset=utf-8",
|
|
source: "claude_task_metadata",
|
|
contents: `${metadataPieces.join("\n\n")}\n`,
|
|
}));
|
|
} else if (input.sessionId) {
|
|
appendNote(input.notes, "claude_task_metadata_missing");
|
|
}
|
|
|
|
if (files.length === 0) {
|
|
appendNote(input.notes, "claude_stream_trace_missing");
|
|
}
|
|
|
|
return {
|
|
files,
|
|
raw: {
|
|
adapterType: "claude_local",
|
|
sessionId: input.sessionId,
|
|
projectSessionFound: Boolean(projectSessionText),
|
|
projectArtifactsCount: projectSessionArtifactFiles.length,
|
|
debugLogFound: Boolean(debugLogText),
|
|
taskDirPresent: taskFiles.length > 0,
|
|
},
|
|
normalized: sanitizeFeedbackValue(
|
|
{
|
|
adapterType: "claude_local",
|
|
sessionId: input.sessionId,
|
|
summary: parseClaudeStreamJson(input.stdoutText),
|
|
},
|
|
input.state,
|
|
"bundle.normalizedAdapterTrace.claude",
|
|
MAX_TRACE_FILE_CHARS,
|
|
) as Record<string, unknown>,
|
|
};
|
|
}
|
|
|
|
async function buildOpenCodeTraceFiles(input: {
|
|
sessionId: string | null;
|
|
stdoutText: string;
|
|
state: ReturnType<typeof createFeedbackRedactionState>;
|
|
notes: string[];
|
|
}) {
|
|
const files: FeedbackTraceBundleFile[] = [];
|
|
if (!input.sessionId) {
|
|
appendNote(input.notes, "opencode_session_id_missing");
|
|
return {
|
|
files,
|
|
raw: null as Record<string, unknown> | null,
|
|
normalized: sanitizeFeedbackValue(
|
|
{
|
|
adapterType: "opencode_local",
|
|
summary: parseOpenCodeJsonl(input.stdoutText),
|
|
},
|
|
input.state,
|
|
"bundle.normalizedAdapterTrace.opencode",
|
|
MAX_TRACE_FILE_CHARS,
|
|
) as Record<string, unknown>,
|
|
};
|
|
}
|
|
|
|
const opencodeRoot = resolveHomeAwarePath(
|
|
process.env.PAPERCLIP_OPENCODE_STORAGE_DIR ?? "~/.local/share/opencode",
|
|
);
|
|
const sessionRoot = path.join(opencodeRoot, "storage", "session");
|
|
const diffRoot = path.join(opencodeRoot, "storage", "session_diff");
|
|
const messageRoot = path.join(opencodeRoot, "storage", "message");
|
|
const partRoot = path.join(opencodeRoot, "storage", "part");
|
|
const todoRoot = path.join(opencodeRoot, "storage", "todo");
|
|
const projectRoot = path.join(opencodeRoot, "storage", "project");
|
|
const sessionFile = await findMatchingFile(
|
|
sessionRoot,
|
|
(_absolutePath, name) => name === `${input.sessionId}.json`,
|
|
6,
|
|
);
|
|
const diffFile = path.join(diffRoot, `${input.sessionId}.json`);
|
|
|
|
const sessionRaw = sessionFile ? await readFile(sessionFile, "utf8").catch(() => null) : null;
|
|
const sessionText =
|
|
sessionRaw == null
|
|
? null
|
|
: sanitizeFeedbackText(sessionRaw, input.state, "bundle.rawAdapterTrace.opencode.session", MAX_TRACE_FILE_CHARS);
|
|
if (sessionText) {
|
|
files.push(makeBundleFile({
|
|
path: "adapter/opencode/session.json",
|
|
contentType: "application/json",
|
|
source: "opencode_session",
|
|
contents: sessionText,
|
|
}));
|
|
} else {
|
|
appendNote(input.notes, "opencode_session_file_missing");
|
|
}
|
|
|
|
const diffText = await readTextFileIfPresent(
|
|
diffFile,
|
|
input.state,
|
|
"bundle.rawAdapterTrace.opencode.sessionDiff",
|
|
);
|
|
if (diffText) {
|
|
files.push(makeBundleFile({
|
|
path: "adapter/opencode/session-diff.json",
|
|
contentType: "application/json",
|
|
source: "opencode_session_diff",
|
|
contents: diffText,
|
|
}));
|
|
}
|
|
|
|
const messageFiles = await listChildFiles(path.join(messageRoot, input.sessionId));
|
|
const messageIds: string[] = [];
|
|
for (const filePath of messageFiles) {
|
|
const messageText = await readTextFileIfPresent(
|
|
filePath,
|
|
input.state,
|
|
`bundle.rawAdapterTrace.opencode.messages.${path.basename(filePath)}`,
|
|
);
|
|
if (!messageText) continue;
|
|
messageIds.push(path.basename(filePath, path.extname(filePath)));
|
|
files.push(makeBundleFile({
|
|
path: `adapter/opencode/messages/${path.basename(filePath)}`,
|
|
contentType: "application/json",
|
|
source: "opencode_message",
|
|
contents: messageText,
|
|
}));
|
|
}
|
|
if (messageFiles.length === 0) {
|
|
appendNote(input.notes, "opencode_message_files_missing");
|
|
}
|
|
|
|
let partFilesCount = 0;
|
|
for (const messageId of messageIds) {
|
|
const partFiles = await listChildFiles(path.join(partRoot, messageId));
|
|
for (const filePath of partFiles) {
|
|
const partText = await readTextFileIfPresent(
|
|
filePath,
|
|
input.state,
|
|
`bundle.rawAdapterTrace.opencode.parts.${messageId}.${path.basename(filePath)}`,
|
|
);
|
|
if (!partText) continue;
|
|
partFilesCount += 1;
|
|
files.push(makeBundleFile({
|
|
path: `adapter/opencode/parts/${messageId}/${path.basename(filePath)}`,
|
|
contentType: "application/json",
|
|
source: "opencode_message_part",
|
|
contents: partText,
|
|
}));
|
|
}
|
|
}
|
|
if (messageIds.length > 0 && partFilesCount === 0) {
|
|
appendNote(input.notes, "opencode_message_parts_missing");
|
|
}
|
|
|
|
const parsedSession = (() => {
|
|
if (!sessionRaw) return null;
|
|
try {
|
|
return JSON.parse(sessionRaw) as Record<string, unknown>;
|
|
} catch {
|
|
return null;
|
|
}
|
|
})();
|
|
const projectId = asString(parsedSession?.projectID) ?? asString(parsedSession?.projectId);
|
|
const projectText = await readTextFileIfPresent(
|
|
projectId ? path.join(projectRoot, `${projectId}.json`) : null,
|
|
input.state,
|
|
"bundle.rawAdapterTrace.opencode.project",
|
|
);
|
|
if (projectText) {
|
|
files.push(makeBundleFile({
|
|
path: "adapter/opencode/project.json",
|
|
contentType: "application/json",
|
|
source: "opencode_project",
|
|
contents: projectText,
|
|
}));
|
|
}
|
|
|
|
const todoText = await readTextFileIfPresent(
|
|
path.join(todoRoot, `${input.sessionId}.json`),
|
|
input.state,
|
|
"bundle.rawAdapterTrace.opencode.todo",
|
|
);
|
|
if (todoText) {
|
|
files.push(makeBundleFile({
|
|
path: "adapter/opencode/todo.json",
|
|
contentType: "application/json",
|
|
source: "opencode_todo",
|
|
contents: todoText,
|
|
}));
|
|
}
|
|
|
|
return {
|
|
files,
|
|
raw: {
|
|
adapterType: "opencode_local",
|
|
sessionId: input.sessionId,
|
|
sessionFileFound: Boolean(sessionText),
|
|
sessionDiffFound: Boolean(diffText),
|
|
messageFilesCount: messageFiles.length,
|
|
partFilesCount,
|
|
projectFound: Boolean(projectText),
|
|
todoFound: Boolean(todoText),
|
|
},
|
|
normalized: sanitizeFeedbackValue(
|
|
{
|
|
adapterType: "opencode_local",
|
|
sessionId: input.sessionId,
|
|
summary: parseOpenCodeJsonl(input.stdoutText),
|
|
},
|
|
input.state,
|
|
"bundle.normalizedAdapterTrace.opencode",
|
|
MAX_TRACE_FILE_CHARS,
|
|
) as Record<string, unknown>,
|
|
};
|
|
}
|
|
|
|
function truncateFailureReason(error: unknown) {
|
|
const message = error instanceof Error ? error.message : String(error);
|
|
return message.trim().slice(0, 1_000) || "Feedback export failed";
|
|
}
|
|
|
|
function mapTraceRow(row: FeedbackTraceRow, includePayload: boolean): FeedbackTrace {
|
|
const targetSummary = asRecord(row.targetSummary) as unknown as FeedbackTraceTargetSummary | null;
|
|
return {
|
|
id: row.id,
|
|
companyId: row.companyId,
|
|
feedbackVoteId: row.feedbackVoteId,
|
|
issueId: row.issueId,
|
|
projectId: row.projectId ?? null,
|
|
issueIdentifier: row.issueIdentifier,
|
|
issueTitle: row.issueTitle,
|
|
authorUserId: row.authorUserId,
|
|
targetType: row.targetType as FeedbackTargetType,
|
|
targetId: row.targetId,
|
|
vote: row.vote as FeedbackVoteValue,
|
|
status: row.status as FeedbackTraceStatus,
|
|
destination: row.destination ?? null,
|
|
exportId: row.exportId ?? null,
|
|
consentVersion: row.consentVersion ?? null,
|
|
schemaVersion: row.schemaVersion,
|
|
bundleVersion: row.bundleVersion,
|
|
payloadVersion: row.payloadVersion,
|
|
payloadDigest: row.payloadDigest ?? null,
|
|
payloadSnapshot: includePayload ? asRecord(row.payloadSnapshot) : null,
|
|
targetSummary: targetSummary ?? buildTargetSummary({
|
|
label: row.targetType,
|
|
excerpt: null,
|
|
authorAgentId: null,
|
|
authorUserId: null,
|
|
createdAt: null,
|
|
}),
|
|
redactionSummary: asRecord(row.redactionSummary),
|
|
attemptCount: row.attemptCount,
|
|
lastAttemptedAt: row.lastAttemptedAt ?? null,
|
|
exportedAt: row.exportedAt ?? null,
|
|
failureReason: row.failureReason ?? null,
|
|
createdAt: row.createdAt,
|
|
updatedAt: row.updatedAt,
|
|
};
|
|
}
|
|
|
|
async function resolveFeedbackTarget(
|
|
db: Pick<Db, "select">,
|
|
issue: IssueFeedbackContext,
|
|
targetType: FeedbackTargetType,
|
|
targetId: string,
|
|
): Promise<ResolvedFeedbackTarget> {
|
|
const issuePath = buildIssuePath(issue.identifier);
|
|
|
|
if (targetType === "issue_comment") {
|
|
const targetComment = await db
|
|
.select({
|
|
id: issueComments.id,
|
|
issueId: issueComments.issueId,
|
|
companyId: issueComments.companyId,
|
|
authorAgentId: issueComments.authorAgentId,
|
|
authorUserId: issueComments.authorUserId,
|
|
createdByRunId: issueComments.createdByRunId,
|
|
body: issueComments.body,
|
|
createdAt: issueComments.createdAt,
|
|
})
|
|
.from(issueComments)
|
|
.where(eq(issueComments.id, targetId))
|
|
.then((rows) => rows[0] ?? null);
|
|
|
|
if (!targetComment || targetComment.issueId !== issue.id || targetComment.companyId !== issue.companyId) {
|
|
throw notFound("Feedback target not found");
|
|
}
|
|
if (!targetComment.authorAgentId) {
|
|
throw unprocessable("Feedback voting is only available on agent-authored issue comments");
|
|
}
|
|
|
|
const record: ResolvedFeedbackTarget = {
|
|
targetType,
|
|
targetId,
|
|
label: "Comment",
|
|
body: targetComment.body,
|
|
createdAt: targetComment.createdAt,
|
|
authorAgentId: targetComment.authorAgentId,
|
|
authorUserId: targetComment.authorUserId,
|
|
createdByRunId: targetComment.createdByRunId ?? null,
|
|
documentId: null,
|
|
documentKey: null,
|
|
documentTitle: null,
|
|
revisionNumber: null,
|
|
issuePath,
|
|
targetPath: issuePath ? `${issuePath}#comment-${targetComment.id}` : null,
|
|
payloadTarget: {
|
|
type: targetType,
|
|
id: targetComment.id,
|
|
createdAt: targetComment.createdAt.toISOString(),
|
|
authorAgentId: targetComment.authorAgentId,
|
|
authorUserId: targetComment.authorUserId,
|
|
createdByRunId: targetComment.createdByRunId ?? null,
|
|
issuePath,
|
|
targetPath: issuePath ? `${issuePath}#comment-${targetComment.id}` : null,
|
|
},
|
|
};
|
|
return record;
|
|
}
|
|
|
|
if (targetType === "issue_document_revision") {
|
|
const targetRevision = await db
|
|
.select({
|
|
id: documentRevisions.id,
|
|
companyId: documentRevisions.companyId,
|
|
documentId: documentRevisions.documentId,
|
|
revisionNumber: documentRevisions.revisionNumber,
|
|
body: documentRevisions.body,
|
|
createdByAgentId: documentRevisions.createdByAgentId,
|
|
createdByUserId: documentRevisions.createdByUserId,
|
|
createdByRunId: documentRevisions.createdByRunId,
|
|
createdAt: documentRevisions.createdAt,
|
|
issueId: issueDocuments.issueId,
|
|
key: issueDocuments.key,
|
|
title: documents.title,
|
|
})
|
|
.from(documentRevisions)
|
|
.innerJoin(documents, eq(documentRevisions.documentId, documents.id))
|
|
.innerJoin(issueDocuments, eq(issueDocuments.documentId, documents.id))
|
|
.where(eq(documentRevisions.id, targetId))
|
|
.then((rows) => rows.find((row) => row.issueId === issue.id) ?? null);
|
|
|
|
if (!targetRevision || targetRevision.companyId !== issue.companyId) {
|
|
throw notFound("Feedback target not found");
|
|
}
|
|
if (!targetRevision.createdByAgentId) {
|
|
throw unprocessable("Feedback voting is only available on agent-authored document revisions");
|
|
}
|
|
|
|
const record: ResolvedFeedbackTarget = {
|
|
targetType,
|
|
targetId,
|
|
label: `${targetRevision.key} rev ${targetRevision.revisionNumber}`,
|
|
body: targetRevision.body,
|
|
createdAt: targetRevision.createdAt,
|
|
authorAgentId: targetRevision.createdByAgentId,
|
|
authorUserId: targetRevision.createdByUserId,
|
|
createdByRunId: targetRevision.createdByRunId ?? null,
|
|
documentId: targetRevision.documentId,
|
|
documentKey: targetRevision.key,
|
|
documentTitle: targetRevision.title ?? null,
|
|
revisionNumber: targetRevision.revisionNumber,
|
|
issuePath,
|
|
targetPath: issuePath ? `${issuePath}#document-${encodeURIComponent(targetRevision.key)}` : null,
|
|
payloadTarget: {
|
|
type: targetType,
|
|
id: targetRevision.id,
|
|
documentId: targetRevision.documentId,
|
|
documentKey: targetRevision.key,
|
|
documentTitle: targetRevision.title ?? null,
|
|
revisionNumber: targetRevision.revisionNumber,
|
|
createdAt: targetRevision.createdAt.toISOString(),
|
|
authorAgentId: targetRevision.createdByAgentId,
|
|
authorUserId: targetRevision.createdByUserId,
|
|
createdByRunId: targetRevision.createdByRunId ?? null,
|
|
issuePath,
|
|
targetPath: issuePath ? `${issuePath}#document-${encodeURIComponent(targetRevision.key)}` : null,
|
|
},
|
|
};
|
|
return record;
|
|
}
|
|
|
|
throw unprocessable("Unsupported feedback target type");
|
|
}
|
|
|
|
async function listIssueContextItems(
|
|
db: Pick<Db, "select">,
|
|
issue: IssueFeedbackContext,
|
|
) {
|
|
const [commentRows, revisionRows] = await Promise.all([
|
|
db
|
|
.select({
|
|
targetId: issueComments.id,
|
|
body: issueComments.body,
|
|
createdAt: issueComments.createdAt,
|
|
authorAgentId: issueComments.authorAgentId,
|
|
authorUserId: issueComments.authorUserId,
|
|
createdByRunId: issueComments.createdByRunId,
|
|
})
|
|
.from(issueComments)
|
|
.where(and(eq(issueComments.companyId, issue.companyId), eq(issueComments.issueId, issue.id))),
|
|
db
|
|
.select({
|
|
targetId: documentRevisions.id,
|
|
body: documentRevisions.body,
|
|
createdAt: documentRevisions.createdAt,
|
|
authorAgentId: documentRevisions.createdByAgentId,
|
|
authorUserId: documentRevisions.createdByUserId,
|
|
createdByRunId: documentRevisions.createdByRunId,
|
|
documentId: documentRevisions.documentId,
|
|
documentKey: issueDocuments.key,
|
|
documentTitle: documents.title,
|
|
revisionNumber: documentRevisions.revisionNumber,
|
|
})
|
|
.from(documentRevisions)
|
|
.innerJoin(documents, eq(documentRevisions.documentId, documents.id))
|
|
.innerJoin(issueDocuments, eq(issueDocuments.documentId, documents.id))
|
|
.where(and(eq(documentRevisions.companyId, issue.companyId), eq(issueDocuments.issueId, issue.id))),
|
|
]);
|
|
|
|
const issuePath = buildIssuePath(issue.identifier);
|
|
|
|
const items: FeedbackTargetRecord[] = [
|
|
...commentRows.map((row) => ({
|
|
targetType: "issue_comment" as const,
|
|
targetId: row.targetId,
|
|
label: "Comment",
|
|
body: row.body,
|
|
createdAt: row.createdAt,
|
|
authorAgentId: row.authorAgentId,
|
|
authorUserId: row.authorUserId,
|
|
createdByRunId: row.createdByRunId ?? null,
|
|
documentId: null,
|
|
documentKey: null,
|
|
documentTitle: null,
|
|
revisionNumber: null,
|
|
issuePath,
|
|
targetPath: issuePath ? `${issuePath}#comment-${row.targetId}` : null,
|
|
})),
|
|
...revisionRows.map((row) => ({
|
|
targetType: "issue_document_revision" as const,
|
|
targetId: row.targetId,
|
|
label: `${row.documentKey} rev ${row.revisionNumber}`,
|
|
body: row.body,
|
|
createdAt: row.createdAt,
|
|
authorAgentId: row.authorAgentId,
|
|
authorUserId: row.authorUserId,
|
|
createdByRunId: row.createdByRunId ?? null,
|
|
documentId: row.documentId,
|
|
documentKey: row.documentKey,
|
|
documentTitle: row.documentTitle ?? null,
|
|
revisionNumber: row.revisionNumber,
|
|
issuePath,
|
|
targetPath: issuePath ? `${issuePath}#document-${encodeURIComponent(row.documentKey)}` : null,
|
|
})),
|
|
];
|
|
|
|
return items.sort((left, right) => {
|
|
const byDate = left.createdAt.getTime() - right.createdAt.getTime();
|
|
if (byDate !== 0) return byDate;
|
|
return left.targetId.localeCompare(right.targetId);
|
|
});
|
|
}
|
|
|
|
async function buildIssueContext(
|
|
db: Pick<Db, "select">,
|
|
issue: IssueFeedbackContext,
|
|
target: ResolvedFeedbackTarget,
|
|
state: ReturnType<typeof createFeedbackRedactionState>,
|
|
) {
|
|
const items = await listIssueContextItems(db, issue);
|
|
const targetIndex = items.findIndex((item) => item.targetType === target.targetType && item.targetId === target.targetId);
|
|
const before = targetIndex >= 0
|
|
? items.slice(Math.max(0, targetIndex - FEEDBACK_CONTEXT_WINDOW), targetIndex)
|
|
: [];
|
|
const after = targetIndex >= 0
|
|
? items.slice(targetIndex + 1, targetIndex + 1 + FEEDBACK_CONTEXT_WINDOW)
|
|
: [];
|
|
|
|
let remainingChars = MAX_TOTAL_CONTEXT_CHARS;
|
|
const serializedItems = [...before, ...after].map((item, index) => {
|
|
const relation = index < before.length ? "before" : "after";
|
|
if (remainingChars <= 0) {
|
|
state.omittedFields.add("bundle.issueContext.items");
|
|
return null;
|
|
}
|
|
const maxChars = Math.min(MAX_CONTEXT_ITEM_BODY_CHARS, remainingChars);
|
|
const body = sanitizeFeedbackText(
|
|
item.body,
|
|
state,
|
|
`bundle.issueContext.items.${index}.body`,
|
|
maxChars,
|
|
);
|
|
remainingChars -= body.length;
|
|
return {
|
|
type: item.targetType,
|
|
id: item.targetId,
|
|
label: item.label,
|
|
relation,
|
|
createdAt: item.createdAt.toISOString(),
|
|
authorAgentId: item.authorAgentId,
|
|
authorUserId: item.authorUserId,
|
|
createdByRunId: item.createdByRunId,
|
|
documentKey: item.documentKey,
|
|
documentTitle: item.documentTitle,
|
|
revisionNumber: item.revisionNumber,
|
|
targetPath: item.targetPath,
|
|
body,
|
|
excerpt: truncateExcerpt(body),
|
|
};
|
|
}).filter((item): item is NonNullable<typeof item> => item !== null);
|
|
|
|
const descriptionExcerpt = issue.description
|
|
? sanitizeFeedbackText(issue.description, state, "bundle.issueContext.issue.description", MAX_DESCRIPTION_CHARS)
|
|
: null;
|
|
|
|
return {
|
|
issue: {
|
|
id: issue.id,
|
|
identifier: issue.identifier,
|
|
title: issue.title,
|
|
projectId: issue.projectId,
|
|
path: buildIssuePath(issue.identifier),
|
|
descriptionExcerpt: descriptionExcerpt ? truncateExcerpt(descriptionExcerpt, MAX_DESCRIPTION_CHARS) : null,
|
|
},
|
|
items: serializedItems,
|
|
};
|
|
}
|
|
|
|
async function buildAgentContext(
|
|
db: Pick<Db, "select">,
|
|
companyId: string,
|
|
authorAgentId: string | null,
|
|
createdByRunId: string | null,
|
|
state: ReturnType<typeof createFeedbackRedactionState>,
|
|
) {
|
|
if (!authorAgentId) {
|
|
state.notes.add("author_agent_missing");
|
|
return null;
|
|
}
|
|
|
|
const agent = await db
|
|
.select({
|
|
id: agents.id,
|
|
companyId: agents.companyId,
|
|
name: agents.name,
|
|
role: agents.role,
|
|
title: agents.title,
|
|
status: agents.status,
|
|
adapterType: agents.adapterType,
|
|
adapterConfig: agents.adapterConfig,
|
|
runtimeConfig: agents.runtimeConfig,
|
|
})
|
|
.from(agents)
|
|
.where(eq(agents.id, authorAgentId))
|
|
.then((rows) => rows[0] ?? null);
|
|
|
|
if (!agent || agent.companyId !== companyId) {
|
|
state.notes.add("author_agent_unavailable");
|
|
return null;
|
|
}
|
|
|
|
const adapterConfig = asRecord(agent.adapterConfig) ?? {};
|
|
const runtimeConfig = asRecord(agent.runtimeConfig) ?? {};
|
|
const desiredSkillRefs = uniqueNonEmpty(readPaperclipSkillSyncPreference(adapterConfig).desiredSkills).slice(0, MAX_SKILLS);
|
|
const availableSkills = desiredSkillRefs.length === 0
|
|
? []
|
|
: await db
|
|
.select()
|
|
.from(companySkills)
|
|
.where(eq(companySkills.companyId, companyId));
|
|
const matchedSkills = availableSkills
|
|
.filter((skill) => desiredSkillRefs.some((reference) => matchesSkillReference(skill, reference)))
|
|
.slice(0, MAX_SKILLS);
|
|
const unresolvedSkillRefs = desiredSkillRefs.filter(
|
|
(reference) => !matchedSkills.some((skill) => matchesSkillReference(skill, reference)),
|
|
);
|
|
|
|
if (availableSkills.length > MAX_SKILLS || desiredSkillRefs.length > MAX_SKILLS) {
|
|
state.omittedFields.add("bundle.agentContext.skills");
|
|
}
|
|
|
|
const run = createdByRunId
|
|
? await db
|
|
.select({
|
|
id: heartbeatRuns.id,
|
|
companyId: heartbeatRuns.companyId,
|
|
agentId: heartbeatRuns.agentId,
|
|
invocationSource: heartbeatRuns.invocationSource,
|
|
status: heartbeatRuns.status,
|
|
startedAt: heartbeatRuns.startedAt,
|
|
finishedAt: heartbeatRuns.finishedAt,
|
|
usageJson: heartbeatRuns.usageJson,
|
|
sessionIdBefore: heartbeatRuns.sessionIdBefore,
|
|
sessionIdAfter: heartbeatRuns.sessionIdAfter,
|
|
externalRunId: heartbeatRuns.externalRunId,
|
|
})
|
|
.from(heartbeatRuns)
|
|
.where(eq(heartbeatRuns.id, createdByRunId))
|
|
.then((rows) => rows[0] ?? null)
|
|
: null;
|
|
const runCosts = run
|
|
? await db
|
|
.select({
|
|
provider: costEvents.provider,
|
|
biller: costEvents.biller,
|
|
billingType: costEvents.billingType,
|
|
model: costEvents.model,
|
|
inputTokens: costEvents.inputTokens,
|
|
cachedInputTokens: costEvents.cachedInputTokens,
|
|
outputTokens: costEvents.outputTokens,
|
|
costCents: costEvents.costCents,
|
|
})
|
|
.from(costEvents)
|
|
.where(and(eq(costEvents.companyId, companyId), eq(costEvents.heartbeatRunId, run.id)))
|
|
: [];
|
|
|
|
const usage = asRecord(run?.usageJson) ?? {};
|
|
const runtime = {
|
|
configuredModel: asString(adapterConfig.model),
|
|
configuredInstructionsBundleMode: asString(adapterConfig.instructionsBundleMode),
|
|
configuredInstructionsEntryFile: asString(adapterConfig.instructionsEntryFile),
|
|
configuredInstructionsFilePath: asString(adapterConfig.instructionsFilePath),
|
|
configuredInstructionsRootPath: asString(adapterConfig.instructionsRootPath),
|
|
heartbeatPolicy: sanitizeFeedbackValue(runtimeConfig.heartbeat ?? null, state, "bundle.agentContext.runtime.heartbeatPolicy", 400),
|
|
provenanceMode: run ? "source_run" : "vote_time_snapshot",
|
|
sourceRun: run
|
|
? sanitizeFeedbackValue({
|
|
id: run.id,
|
|
invocationSource: run.invocationSource,
|
|
status: run.status,
|
|
startedAt: run.startedAt?.toISOString() ?? null,
|
|
finishedAt: run.finishedAt?.toISOString() ?? null,
|
|
externalRunId: run.externalRunId ?? null,
|
|
sessionIdBefore: run.sessionIdBefore ?? null,
|
|
sessionIdAfter: run.sessionIdAfter ?? null,
|
|
usage: {
|
|
provider: asString(usage.provider),
|
|
biller: asString(usage.biller),
|
|
billingType: asString(usage.billingType),
|
|
model: asString(usage.model),
|
|
inputTokens: asNumber(usage.inputTokens) ?? asNumber(usage.rawInputTokens),
|
|
cachedInputTokens: asNumber(usage.cachedInputTokens) ?? asNumber(usage.rawCachedInputTokens),
|
|
outputTokens: asNumber(usage.outputTokens) ?? asNumber(usage.rawOutputTokens),
|
|
costUsd: asNumber(usage.costUsd),
|
|
usageSource: asString(usage.usageSource),
|
|
sessionReused: asBoolean(usage.sessionReused),
|
|
taskSessionReused: asBoolean(usage.taskSessionReused),
|
|
freshSession: asBoolean(usage.freshSession),
|
|
sessionRotated: asBoolean(usage.sessionRotated),
|
|
sessionRotationReason: asString(usage.sessionRotationReason),
|
|
},
|
|
}, state, "bundle.agentContext.runtime.sourceRun", 400)
|
|
: null,
|
|
costSummary: runCosts.length > 0
|
|
? {
|
|
providers: uniqueNonEmpty(runCosts.map((row) => row.provider)),
|
|
billers: uniqueNonEmpty(runCosts.map((row) => row.biller)),
|
|
billingTypes: uniqueNonEmpty(runCosts.map((row) => row.billingType)),
|
|
models: uniqueNonEmpty(runCosts.map((row) => row.model)),
|
|
inputTokens: runCosts.reduce((sum, row) => sum + row.inputTokens, 0),
|
|
cachedInputTokens: runCosts.reduce((sum, row) => sum + row.cachedInputTokens, 0),
|
|
outputTokens: runCosts.reduce((sum, row) => sum + row.outputTokens, 0),
|
|
costCents: runCosts.reduce((sum, row) => sum + row.costCents, 0),
|
|
}
|
|
: null,
|
|
};
|
|
|
|
const instructionsBundle = await instructionsSvc.getBundle({
|
|
id: agent.id,
|
|
companyId: agent.companyId,
|
|
name: agent.name,
|
|
adapterConfig: agent.adapterConfig,
|
|
}).catch(() => null);
|
|
|
|
let entryDigest: string | null = null;
|
|
let entryBody: string | null = null;
|
|
if (instructionsBundle) {
|
|
const readableEntryPath =
|
|
instructionsBundle.files.find((file) => file.path === instructionsBundle.entryFile)?.path
|
|
?? instructionsBundle.files[0]?.path
|
|
?? null;
|
|
if (readableEntryPath) {
|
|
const entryFile = await instructionsSvc.readFile({
|
|
id: agent.id,
|
|
companyId: agent.companyId,
|
|
name: agent.name,
|
|
adapterConfig: agent.adapterConfig,
|
|
}, readableEntryPath).catch(() => null);
|
|
if (entryFile) {
|
|
entryDigest = sha256Digest(entryFile.content);
|
|
entryBody = sanitizeFeedbackText(
|
|
entryFile.content,
|
|
state,
|
|
"bundle.agentContext.instructions.entryBody",
|
|
MAX_INSTRUCTIONS_BODY_CHARS,
|
|
);
|
|
}
|
|
}
|
|
if (instructionsBundle.files.length > MAX_INSTRUCTION_FILES) {
|
|
state.omittedFields.add("bundle.agentContext.instructions.files");
|
|
}
|
|
}
|
|
|
|
return {
|
|
agent: {
|
|
id: agent.id,
|
|
name: agent.name,
|
|
role: agent.role,
|
|
title: agent.title,
|
|
status: agent.status,
|
|
adapterType: agent.adapterType,
|
|
},
|
|
runtime: sanitizeFeedbackValue(runtime, state, "bundle.agentContext.runtime", 400),
|
|
skills: {
|
|
desiredRefs: desiredSkillRefs,
|
|
unresolvedRefs: unresolvedSkillRefs,
|
|
items: matchedSkills.map((skill, index) => ({
|
|
key: skill.key,
|
|
slug: skill.slug,
|
|
name: skill.name,
|
|
sourceType: skill.sourceType,
|
|
sourceLocator: skill.sourceLocator == null
|
|
? null
|
|
: skill.sourceType === "github" || skill.sourceType === "skills_sh" || skill.sourceType === "url"
|
|
? skill.sourceLocator
|
|
: sanitizeFeedbackText(
|
|
skill.sourceLocator,
|
|
state,
|
|
`bundle.agentContext.skills.items.${index}.sourceLocator`,
|
|
MAX_PATH_CHARS,
|
|
),
|
|
sourceRef: skill.sourceRef,
|
|
trustLevel: skill.trustLevel,
|
|
compatibility: skill.compatibility,
|
|
fileInventory: skill.fileInventory,
|
|
})),
|
|
},
|
|
instructions: instructionsBundle
|
|
? {
|
|
mode: instructionsBundle.mode,
|
|
entryFile: instructionsBundle.entryFile,
|
|
resolvedEntryPath: instructionsBundle.resolvedEntryPath
|
|
? sanitizeFeedbackText(
|
|
instructionsBundle.resolvedEntryPath,
|
|
state,
|
|
"bundle.agentContext.instructions.resolvedEntryPath",
|
|
MAX_PATH_CHARS,
|
|
)
|
|
: null,
|
|
warnings: instructionsBundle.warnings.map((warning, index) =>
|
|
sanitizeFeedbackText(
|
|
warning,
|
|
state,
|
|
`bundle.agentContext.instructions.warnings.${index}`,
|
|
400,
|
|
)),
|
|
legacyPromptTemplateActive: instructionsBundle.legacyPromptTemplateActive,
|
|
legacyBootstrapPromptTemplateActive: instructionsBundle.legacyBootstrapPromptTemplateActive,
|
|
fileCount: instructionsBundle.files.length,
|
|
files: instructionsBundle.files.slice(0, MAX_INSTRUCTION_FILES).map((file) => ({
|
|
path: file.path,
|
|
size: file.size,
|
|
language: file.language,
|
|
markdown: file.markdown,
|
|
isEntryFile: file.isEntryFile,
|
|
virtual: file.virtual,
|
|
})),
|
|
entryDigest,
|
|
entryBody,
|
|
}
|
|
: null,
|
|
paperclip: {
|
|
schemaVersion: FEEDBACK_SCHEMA_VERSION,
|
|
bundleVersion: FEEDBACK_BUNDLE_VERSION,
|
|
},
|
|
};
|
|
}
|
|
|
|
async function buildPayloadArtifacts(
|
|
db: Pick<Db, "select">,
|
|
input: {
|
|
issue: IssueFeedbackContext;
|
|
target: ResolvedFeedbackTarget;
|
|
voteId: string;
|
|
vote: FeedbackVoteValue;
|
|
reason: string | null;
|
|
authorUserId: string;
|
|
consentVersion: string | null;
|
|
sharedWithLabs: boolean;
|
|
now: Date;
|
|
},
|
|
) {
|
|
const state = createFeedbackRedactionState();
|
|
const primaryBody = sanitizeFeedbackText(
|
|
input.target.body,
|
|
state,
|
|
"bundle.primaryContent.body",
|
|
MAX_PRIMARY_CONTENT_CHARS,
|
|
);
|
|
const primaryContent = {
|
|
type: input.target.targetType,
|
|
id: input.target.targetId,
|
|
label: input.target.label,
|
|
createdAt: input.target.createdAt.toISOString(),
|
|
authorAgentId: input.target.authorAgentId,
|
|
authorUserId: input.target.authorUserId,
|
|
createdByRunId: input.target.createdByRunId,
|
|
documentId: input.target.documentId,
|
|
documentKey: input.target.documentKey,
|
|
documentTitle: input.target.documentTitle,
|
|
revisionNumber: input.target.revisionNumber,
|
|
targetPath: input.target.targetPath,
|
|
body: primaryBody,
|
|
excerpt: truncateExcerpt(primaryBody),
|
|
};
|
|
const targetSummary = buildTargetSummary({
|
|
label: input.target.label,
|
|
excerpt: primaryContent.excerpt,
|
|
authorAgentId: input.target.authorAgentId,
|
|
authorUserId: input.target.authorUserId,
|
|
createdAt: input.target.createdAt,
|
|
documentKey: input.target.documentKey,
|
|
documentTitle: input.target.documentTitle,
|
|
revisionNumber: input.target.revisionNumber,
|
|
});
|
|
|
|
const basePayload = {
|
|
schemaVersion: FEEDBACK_SCHEMA_VERSION,
|
|
bundleVersion: FEEDBACK_BUNDLE_VERSION,
|
|
sourceApp: "paperclip",
|
|
capturedAt: input.now.toISOString(),
|
|
consentVersion: input.consentVersion,
|
|
vote: {
|
|
id: input.voteId,
|
|
value: input.vote,
|
|
reason: input.reason,
|
|
authorUserId: input.authorUserId,
|
|
sharedWithLabs: input.sharedWithLabs,
|
|
sharedAt: input.sharedWithLabs ? input.now.toISOString() : null,
|
|
},
|
|
target: input.target.payloadTarget,
|
|
} satisfies Record<string, unknown>;
|
|
|
|
if (!input.sharedWithLabs) {
|
|
state.notes.add("local_only_trace_stores_metadata_only");
|
|
const payloadSnapshot = {
|
|
...basePayload,
|
|
exportId: null,
|
|
exportEligible: false,
|
|
bundle: null,
|
|
};
|
|
const redactionSummary = finalizeFeedbackRedactionSummary(state);
|
|
return {
|
|
exportId: null,
|
|
targetSummary,
|
|
redactionSummary,
|
|
payloadSnapshot: {
|
|
...payloadSnapshot,
|
|
redactionSummary,
|
|
},
|
|
payloadDigest: sha256Digest({
|
|
...payloadSnapshot,
|
|
redactionSummary,
|
|
}),
|
|
};
|
|
}
|
|
|
|
const exportId = buildExportId(input.voteId, input.now);
|
|
const [issueContext, agentContext] = await Promise.all([
|
|
buildIssueContext(db, input.issue, input.target, state),
|
|
buildAgentContext(db, input.issue.companyId, input.target.authorAgentId, input.target.createdByRunId, state),
|
|
]);
|
|
|
|
const payloadSnapshot = {
|
|
...basePayload,
|
|
exportId,
|
|
exportEligible: true,
|
|
bundle: {
|
|
primaryContent,
|
|
issueContext,
|
|
agentContext,
|
|
},
|
|
};
|
|
const redactionSummary = finalizeFeedbackRedactionSummary(state);
|
|
const payloadWithSummary = {
|
|
...payloadSnapshot,
|
|
redactionSummary,
|
|
};
|
|
return {
|
|
exportId,
|
|
targetSummary,
|
|
redactionSummary,
|
|
payloadSnapshot: payloadWithSummary,
|
|
payloadDigest: sha256Digest(payloadWithSummary),
|
|
};
|
|
}
|
|
|
|
async function buildFeedbackTraceBundleFromRow(
|
|
db: Db,
|
|
row: FeedbackTraceRow,
|
|
): Promise<FeedbackTraceBundle> {
|
|
const trace = mapTraceRow(row, true);
|
|
const payloadSnapshot = asRecord(trace.payloadSnapshot);
|
|
const notes: string[] = [];
|
|
const state = createFeedbackRedactionState();
|
|
const files: FeedbackTraceBundleFile[] = [];
|
|
const sourceRunId = resolveSourceRunId(payloadSnapshot);
|
|
|
|
let paperclipRun: Record<string, unknown> | null = null;
|
|
let rawAdapterTrace: Record<string, unknown> | null = null;
|
|
let normalizedAdapterTrace: Record<string, unknown> | null = null;
|
|
let adapterType: string | null = null;
|
|
|
|
if (!sourceRunId) {
|
|
appendNote(notes, "source_run_missing");
|
|
} else {
|
|
const run = await db
|
|
.select({
|
|
id: heartbeatRuns.id,
|
|
companyId: heartbeatRuns.companyId,
|
|
agentId: heartbeatRuns.agentId,
|
|
invocationSource: heartbeatRuns.invocationSource,
|
|
status: heartbeatRuns.status,
|
|
startedAt: heartbeatRuns.startedAt,
|
|
finishedAt: heartbeatRuns.finishedAt,
|
|
createdAt: heartbeatRuns.createdAt,
|
|
updatedAt: heartbeatRuns.updatedAt,
|
|
error: heartbeatRuns.error,
|
|
errorCode: heartbeatRuns.errorCode,
|
|
usageJson: heartbeatRuns.usageJson,
|
|
resultJson: heartbeatRuns.resultJson,
|
|
sessionIdBefore: heartbeatRuns.sessionIdBefore,
|
|
sessionIdAfter: heartbeatRuns.sessionIdAfter,
|
|
externalRunId: heartbeatRuns.externalRunId,
|
|
contextSnapshot: heartbeatRuns.contextSnapshot,
|
|
logStore: heartbeatRuns.logStore,
|
|
logRef: heartbeatRuns.logRef,
|
|
logBytes: heartbeatRuns.logBytes,
|
|
logSha256: heartbeatRuns.logSha256,
|
|
agentName: agents.name,
|
|
agentRole: agents.role,
|
|
agentTitle: agents.title,
|
|
adapterType: agents.adapterType,
|
|
})
|
|
.from(heartbeatRuns)
|
|
.innerJoin(agents, eq(heartbeatRuns.agentId, agents.id))
|
|
.where(eq(heartbeatRuns.id, sourceRunId))
|
|
.then((rows) => rows[0] ?? null);
|
|
|
|
if (!run || run.companyId !== row.companyId) {
|
|
appendNote(notes, "source_run_unavailable");
|
|
} else {
|
|
adapterType = run.adapterType;
|
|
const events = await db
|
|
.select()
|
|
.from(heartbeatRunEvents)
|
|
.where(eq(heartbeatRunEvents.runId, run.id))
|
|
.orderBy(asc(heartbeatRunEvents.seq));
|
|
const logText = await readFullRunLog(run);
|
|
const logEntries = parseRunLogEntries(logText);
|
|
const stdoutText = logEntries
|
|
.filter((entry) => entry.stream === "stdout")
|
|
.map((entry) => entry.chunk)
|
|
.join("");
|
|
|
|
paperclipRun = sanitizeFeedbackValue(
|
|
{
|
|
id: run.id,
|
|
companyId: run.companyId,
|
|
agentId: run.agentId,
|
|
agentName: run.agentName,
|
|
agentRole: run.agentRole,
|
|
agentTitle: run.agentTitle,
|
|
adapterType: run.adapterType,
|
|
invocationSource: run.invocationSource,
|
|
status: run.status,
|
|
startedAt: run.startedAt?.toISOString() ?? null,
|
|
finishedAt: run.finishedAt?.toISOString() ?? null,
|
|
createdAt: run.createdAt.toISOString(),
|
|
updatedAt: run.updatedAt.toISOString(),
|
|
error: run.error,
|
|
errorCode: run.errorCode,
|
|
usage: asRecord(run.usageJson),
|
|
result: asRecord(run.resultJson),
|
|
sessionIdBefore: run.sessionIdBefore,
|
|
sessionIdAfter: run.sessionIdAfter,
|
|
externalRunId: run.externalRunId,
|
|
contextSnapshot: asRecord(run.contextSnapshot),
|
|
logStore: run.logStore,
|
|
logRef: run.logRef,
|
|
logBytes: run.logBytes,
|
|
logSha256: run.logSha256,
|
|
eventCount: events.length,
|
|
},
|
|
state,
|
|
"bundle.paperclipRun",
|
|
MAX_TRACE_FILE_CHARS,
|
|
) as Record<string, unknown>;
|
|
|
|
files.push(makeBundleFile({
|
|
path: "paperclip/run.json",
|
|
contentType: "application/json",
|
|
source: "paperclip_run",
|
|
contents: `${JSON.stringify(paperclipRun, null, 2)}\n`,
|
|
}));
|
|
|
|
const sanitizedEvents = sanitizeFeedbackValue(
|
|
events,
|
|
state,
|
|
"bundle.paperclipRun.events",
|
|
MAX_TRACE_FILE_CHARS,
|
|
);
|
|
files.push(makeBundleFile({
|
|
path: "paperclip/run-events.json",
|
|
contentType: "application/json",
|
|
source: "paperclip_run_events",
|
|
contents: `${JSON.stringify(sanitizedEvents, null, 2)}\n`,
|
|
}));
|
|
|
|
if (logText) {
|
|
files.push(makeBundleFile({
|
|
path: "paperclip/run-log.ndjson",
|
|
contentType: "application/x-ndjson",
|
|
source: "paperclip_run_log",
|
|
contents: `${sanitizeFeedbackText(logText, state, "bundle.paperclipRun.log", MAX_TRACE_FILE_CHARS)}\n`,
|
|
}));
|
|
} else {
|
|
appendNote(notes, "run_log_missing");
|
|
}
|
|
|
|
if (run.adapterType === "codex_local") {
|
|
const adapter = await buildCodexTraceFiles({
|
|
companyId: row.companyId,
|
|
sessionId: run.sessionIdAfter ?? run.sessionIdBefore,
|
|
state,
|
|
notes,
|
|
});
|
|
files.push(...adapter.files);
|
|
rawAdapterTrace = adapter.raw;
|
|
normalizedAdapterTrace = adapter.normalized;
|
|
} else if (run.adapterType === "claude_local") {
|
|
const adapter = await buildClaudeTraceFiles({
|
|
sessionId: run.sessionIdAfter ?? run.sessionIdBefore,
|
|
stdoutText,
|
|
state,
|
|
notes,
|
|
});
|
|
files.push(...adapter.files);
|
|
rawAdapterTrace = adapter.raw;
|
|
normalizedAdapterTrace = adapter.normalized;
|
|
} else if (run.adapterType === "opencode_local") {
|
|
const adapter = await buildOpenCodeTraceFiles({
|
|
sessionId: run.sessionIdAfter ?? run.sessionIdBefore,
|
|
stdoutText,
|
|
state,
|
|
notes,
|
|
});
|
|
files.push(...adapter.files);
|
|
rawAdapterTrace = adapter.raw;
|
|
normalizedAdapterTrace = adapter.normalized;
|
|
} else {
|
|
appendNote(notes, "adapter_specific_trace_not_supported");
|
|
}
|
|
}
|
|
}
|
|
|
|
const privacy = {
|
|
...(asRecord(trace.redactionSummary) ?? {}),
|
|
bundleRedactionSummary: finalizeFeedbackRedactionSummary(state),
|
|
};
|
|
const captureStatus = captureStatusFromFiles(files);
|
|
if (captureStatus !== "full" && files.length > 0) {
|
|
appendNote(notes, "adapter_trace_partial");
|
|
}
|
|
|
|
const envelope = sanitizeFeedbackValue(
|
|
{
|
|
traceId: trace.id,
|
|
exportId: trace.exportId,
|
|
companyId: trace.companyId,
|
|
feedbackVoteId: trace.feedbackVoteId,
|
|
issueId: trace.issueId,
|
|
issueIdentifier: trace.issueIdentifier,
|
|
issueTitle: trace.issueTitle,
|
|
projectId: trace.projectId,
|
|
authorUserId: trace.authorUserId,
|
|
targetType: trace.targetType,
|
|
targetId: trace.targetId,
|
|
vote: trace.vote,
|
|
status: trace.status,
|
|
destination: trace.destination,
|
|
consentVersion: trace.consentVersion,
|
|
schemaVersion: trace.schemaVersion,
|
|
bundleVersion: trace.bundleVersion,
|
|
payloadVersion: trace.payloadVersion,
|
|
payloadDigest: trace.payloadDigest,
|
|
createdAt: trace.createdAt.toISOString(),
|
|
exportedAt: trace.exportedAt?.toISOString() ?? null,
|
|
},
|
|
state,
|
|
"bundle.envelope",
|
|
MAX_TRACE_FILE_CHARS,
|
|
) as Record<string, unknown>;
|
|
|
|
const surface = sanitizeFeedbackValue(
|
|
{
|
|
target: asRecord(payloadSnapshot?.target),
|
|
summary: trace.targetSummary,
|
|
},
|
|
state,
|
|
"bundle.surface",
|
|
MAX_TRACE_FILE_CHARS,
|
|
) as Record<string, unknown>;
|
|
|
|
const bundle: FeedbackTraceBundle = {
|
|
traceId: trace.id,
|
|
exportId: trace.exportId,
|
|
companyId: trace.companyId,
|
|
issueId: trace.issueId,
|
|
issueIdentifier: trace.issueIdentifier,
|
|
adapterType,
|
|
captureStatus,
|
|
notes,
|
|
envelope,
|
|
surface,
|
|
paperclipRun,
|
|
rawAdapterTrace,
|
|
normalizedAdapterTrace,
|
|
privacy,
|
|
integrity: {
|
|
payloadDigest: trace.payloadDigest,
|
|
bundleDigest: sha256Digest({
|
|
traceId: trace.id,
|
|
files: files.map((file) => ({
|
|
path: file.path,
|
|
source: file.source,
|
|
sha256: file.sha256,
|
|
})),
|
|
captureStatus,
|
|
}),
|
|
},
|
|
files,
|
|
};
|
|
|
|
return bundle;
|
|
}
|
|
|
|
export function feedbackService(db: Db, options: FeedbackServiceOptions = {}) {
|
|
return {
|
|
listIssueVotesForUser: async (issueId: string, authorUserId: string) =>
|
|
db
|
|
.select()
|
|
.from(feedbackVotes)
|
|
.where(and(eq(feedbackVotes.issueId, issueId), eq(feedbackVotes.authorUserId, authorUserId))),
|
|
|
|
listFeedbackTraces: async (input: {
|
|
companyId: string;
|
|
issueId?: string;
|
|
projectId?: string;
|
|
targetType?: FeedbackTargetType;
|
|
vote?: FeedbackVoteValue;
|
|
status?: FeedbackTraceStatus;
|
|
from?: Date;
|
|
to?: Date;
|
|
sharedOnly?: boolean;
|
|
includePayload?: boolean;
|
|
}) => {
|
|
const filters = [eq(feedbackExports.companyId, input.companyId)];
|
|
if (input.issueId) filters.push(eq(feedbackExports.issueId, input.issueId));
|
|
if (input.projectId) filters.push(eq(feedbackExports.projectId, input.projectId));
|
|
if (input.targetType) filters.push(eq(feedbackExports.targetType, input.targetType));
|
|
if (input.vote) filters.push(eq(feedbackExports.vote, input.vote));
|
|
if (input.status) filters.push(eq(feedbackExports.status, input.status));
|
|
if (input.sharedOnly) filters.push(ne(feedbackExports.status, "local_only"));
|
|
if (input.from) filters.push(gte(feedbackExports.createdAt, input.from));
|
|
if (input.to) filters.push(lte(feedbackExports.createdAt, input.to));
|
|
|
|
const rows = await db
|
|
.select({
|
|
...feedbackExportColumns,
|
|
issueIdentifier: issues.identifier,
|
|
issueTitle: issues.title,
|
|
})
|
|
.from(feedbackExports)
|
|
.innerJoin(issues, eq(feedbackExports.issueId, issues.id))
|
|
.where(and(...filters))
|
|
.orderBy(desc(feedbackExports.createdAt));
|
|
|
|
return rows.map((row) => mapTraceRow(row, input.includePayload === true));
|
|
},
|
|
|
|
getFeedbackTraceById: async (traceId: string, includePayload = true) => {
|
|
const row = await db
|
|
.select({
|
|
...feedbackExportColumns,
|
|
issueIdentifier: issues.identifier,
|
|
issueTitle: issues.title,
|
|
})
|
|
.from(feedbackExports)
|
|
.innerJoin(issues, eq(feedbackExports.issueId, issues.id))
|
|
.where(eq(feedbackExports.id, traceId))
|
|
.then((rows) => rows[0] ?? null);
|
|
return row ? mapTraceRow(row, includePayload) : null;
|
|
},
|
|
|
|
getFeedbackTraceBundle: async (traceId: string) => {
|
|
const row = await db
|
|
.select({
|
|
...feedbackExportColumns,
|
|
issueIdentifier: issues.identifier,
|
|
issueTitle: issues.title,
|
|
})
|
|
.from(feedbackExports)
|
|
.innerJoin(issues, eq(feedbackExports.issueId, issues.id))
|
|
.where(eq(feedbackExports.id, traceId))
|
|
.then((rows) => rows[0] ?? null);
|
|
return row ? buildFeedbackTraceBundleFromRow(db, row) : null;
|
|
},
|
|
|
|
flushPendingFeedbackTraces: async (input?: {
|
|
companyId?: string;
|
|
traceId?: string;
|
|
limit?: number;
|
|
now?: Date;
|
|
}) => {
|
|
const shareClient = options.shareClient;
|
|
if (!shareClient) {
|
|
const filters = [eq(feedbackExports.status, "pending")];
|
|
if (input?.companyId) {
|
|
filters.push(eq(feedbackExports.companyId, input.companyId));
|
|
}
|
|
if (input?.traceId) {
|
|
filters.push(eq(feedbackExports.id, input.traceId));
|
|
}
|
|
|
|
const rows = await db
|
|
.select({
|
|
id: feedbackExports.id,
|
|
attemptCount: feedbackExports.attemptCount,
|
|
})
|
|
.from(feedbackExports)
|
|
.where(and(...filters))
|
|
.orderBy(asc(feedbackExports.createdAt), asc(feedbackExports.id))
|
|
.limit(Math.max(1, Math.min(input?.limit ?? 25, 200)));
|
|
|
|
const attemptAt = input?.now ?? new Date();
|
|
for (const row of rows) {
|
|
await db
|
|
.update(feedbackExports)
|
|
.set({
|
|
status: "failed",
|
|
attemptCount: row.attemptCount + 1,
|
|
lastAttemptedAt: attemptAt,
|
|
failureReason: FEEDBACK_EXPORT_BACKEND_NOT_CONFIGURED,
|
|
updatedAt: attemptAt,
|
|
})
|
|
.where(eq(feedbackExports.id, row.id));
|
|
}
|
|
|
|
return {
|
|
attempted: rows.length,
|
|
sent: 0,
|
|
failed: rows.length,
|
|
};
|
|
}
|
|
|
|
const limit = Math.max(1, Math.min(input?.limit ?? 25, 200));
|
|
const filters = [
|
|
or(eq(feedbackExports.status, "pending"), eq(feedbackExports.status, "failed")),
|
|
];
|
|
if (input?.companyId) {
|
|
filters.push(eq(feedbackExports.companyId, input.companyId));
|
|
}
|
|
if (input?.traceId) {
|
|
filters.push(eq(feedbackExports.id, input.traceId));
|
|
}
|
|
|
|
const rows = await db
|
|
.select({
|
|
...feedbackExportColumns,
|
|
issueIdentifier: issues.identifier,
|
|
issueTitle: issues.title,
|
|
})
|
|
.from(feedbackExports)
|
|
.innerJoin(issues, eq(feedbackExports.issueId, issues.id))
|
|
.where(and(...filters))
|
|
.orderBy(asc(feedbackExports.createdAt), asc(feedbackExports.id))
|
|
.limit(limit);
|
|
|
|
let attempted = 0;
|
|
let sent = 0;
|
|
let failed = 0;
|
|
|
|
for (const row of rows) {
|
|
const attemptAt = input?.now ?? new Date();
|
|
attempted += 1;
|
|
|
|
try {
|
|
const bundle = await buildFeedbackTraceBundleFromRow(db, row);
|
|
await shareClient.uploadTraceBundle(bundle);
|
|
|
|
await db
|
|
.update(feedbackExports)
|
|
.set({
|
|
status: "sent",
|
|
attemptCount: row.attemptCount + 1,
|
|
lastAttemptedAt: attemptAt,
|
|
exportedAt: attemptAt,
|
|
failureReason: null,
|
|
updatedAt: attemptAt,
|
|
})
|
|
.where(eq(feedbackExports.id, row.id));
|
|
sent += 1;
|
|
} catch (error) {
|
|
await db
|
|
.update(feedbackExports)
|
|
.set({
|
|
status: "failed",
|
|
attemptCount: row.attemptCount + 1,
|
|
lastAttemptedAt: attemptAt,
|
|
failureReason: truncateFailureReason(error),
|
|
updatedAt: attemptAt,
|
|
})
|
|
.where(eq(feedbackExports.id, row.id));
|
|
failed += 1;
|
|
}
|
|
}
|
|
|
|
return {
|
|
attempted,
|
|
sent,
|
|
failed,
|
|
};
|
|
},
|
|
|
|
saveIssueVote: async (input: {
|
|
issueId: string;
|
|
targetType: FeedbackTargetType;
|
|
targetId: string;
|
|
vote: FeedbackVoteValue;
|
|
authorUserId: string;
|
|
reason?: string | null;
|
|
allowSharing?: boolean;
|
|
}) =>
|
|
db.transaction(async (tx) => {
|
|
const issue = await tx
|
|
.select({
|
|
id: issues.id,
|
|
companyId: issues.companyId,
|
|
projectId: issues.projectId,
|
|
identifier: issues.identifier,
|
|
title: issues.title,
|
|
description: issues.description,
|
|
})
|
|
.from(issues)
|
|
.where(eq(issues.id, input.issueId))
|
|
.then((rows) => rows[0] ?? null);
|
|
if (!issue) throw notFound("Issue not found");
|
|
|
|
const target = await resolveFeedbackTarget(tx, issue, input.targetType, input.targetId);
|
|
|
|
const existingCompany = await tx
|
|
.select({
|
|
feedbackDataSharingEnabled: companies.feedbackDataSharingEnabled,
|
|
feedbackDataSharingTermsVersion: companies.feedbackDataSharingTermsVersion,
|
|
})
|
|
.from(companies)
|
|
.where(eq(companies.id, issue.companyId))
|
|
.then((rows) => rows[0] ?? null);
|
|
if (!existingCompany) throw notFound("Company not found");
|
|
|
|
const now = new Date();
|
|
const normalizedReason = normalizeReason(input.vote, input.reason);
|
|
const sharedWithLabs = input.allowSharing === true;
|
|
let consentEnabledNow = false;
|
|
let consentVersion = existingCompany.feedbackDataSharingTermsVersion ?? null;
|
|
let persistedSharingPreference: "allowed" | "not_allowed" | null = null;
|
|
|
|
if (sharedWithLabs && !existingCompany.feedbackDataSharingEnabled) {
|
|
consentEnabledNow = true;
|
|
consentVersion = DEFAULT_FEEDBACK_DATA_SHARING_TERMS_VERSION;
|
|
await tx
|
|
.update(companies)
|
|
.set({
|
|
feedbackDataSharingEnabled: true,
|
|
feedbackDataSharingConsentAt: now,
|
|
feedbackDataSharingConsentByUserId: input.authorUserId,
|
|
feedbackDataSharingTermsVersion: consentVersion,
|
|
updatedAt: now,
|
|
})
|
|
.where(eq(companies.id, issue.companyId));
|
|
}
|
|
|
|
const existingInstanceSettings = await tx
|
|
.select({
|
|
id: instanceSettings.id,
|
|
general: instanceSettings.general,
|
|
})
|
|
.from(instanceSettings)
|
|
.where(eq(instanceSettings.singletonKey, DEFAULT_INSTANCE_SETTINGS_SINGLETON_KEY))
|
|
.then((rows) => rows[0] ?? null);
|
|
|
|
const currentInstanceSettings =
|
|
existingInstanceSettings ??
|
|
(await tx
|
|
.insert(instanceSettings)
|
|
.values({
|
|
singletonKey: DEFAULT_INSTANCE_SETTINGS_SINGLETON_KEY,
|
|
general: {},
|
|
experimental: {},
|
|
createdAt: now,
|
|
updatedAt: now,
|
|
})
|
|
.onConflictDoUpdate({
|
|
target: [instanceSettings.singletonKey],
|
|
set: {
|
|
updatedAt: now,
|
|
},
|
|
})
|
|
.returning({
|
|
id: instanceSettings.id,
|
|
general: instanceSettings.general,
|
|
})
|
|
.then((rows) => rows[0] ?? null));
|
|
|
|
const currentGeneral = normalizeInstanceGeneralSettings(currentInstanceSettings?.general);
|
|
if (currentInstanceSettings && currentGeneral.feedbackDataSharingPreference === "prompt") {
|
|
const nextSharingPreference = sharedWithLabs ? "allowed" : "not_allowed";
|
|
const currentGeneralRaw = asRecord(currentInstanceSettings.general) ?? {};
|
|
await tx
|
|
.update(instanceSettings)
|
|
.set({
|
|
general: {
|
|
...currentGeneralRaw,
|
|
censorUsernameInLogs: currentGeneral.censorUsernameInLogs,
|
|
feedbackDataSharingPreference: nextSharingPreference,
|
|
},
|
|
updatedAt: now,
|
|
})
|
|
.where(eq(instanceSettings.id, currentInstanceSettings.id));
|
|
persistedSharingPreference = nextSharingPreference;
|
|
}
|
|
|
|
const [savedVote] = await tx
|
|
.insert(feedbackVotes)
|
|
.values({
|
|
companyId: issue.companyId,
|
|
issueId: issue.id,
|
|
targetType: input.targetType,
|
|
targetId: input.targetId,
|
|
authorUserId: input.authorUserId,
|
|
vote: input.vote,
|
|
reason: normalizedReason,
|
|
sharedWithLabs,
|
|
sharedAt: sharedWithLabs ? now : null,
|
|
consentVersion: sharedWithLabs ? (consentVersion ?? DEFAULT_FEEDBACK_DATA_SHARING_TERMS_VERSION) : null,
|
|
redactionSummary: null,
|
|
updatedAt: now,
|
|
})
|
|
.onConflictDoUpdate({
|
|
target: [
|
|
feedbackVotes.companyId,
|
|
feedbackVotes.targetType,
|
|
feedbackVotes.targetId,
|
|
feedbackVotes.authorUserId,
|
|
],
|
|
set: {
|
|
vote: input.vote,
|
|
reason: normalizedReason,
|
|
sharedWithLabs,
|
|
sharedAt: sharedWithLabs ? now : null,
|
|
consentVersion: sharedWithLabs ? (consentVersion ?? DEFAULT_FEEDBACK_DATA_SHARING_TERMS_VERSION) : null,
|
|
redactionSummary: null,
|
|
updatedAt: now,
|
|
},
|
|
})
|
|
.returning();
|
|
|
|
const artifacts = await buildPayloadArtifacts(tx, {
|
|
issue,
|
|
target,
|
|
voteId: savedVote.id,
|
|
vote: input.vote,
|
|
reason: normalizedReason,
|
|
authorUserId: input.authorUserId,
|
|
consentVersion: sharedWithLabs ? (consentVersion ?? DEFAULT_FEEDBACK_DATA_SHARING_TERMS_VERSION) : null,
|
|
sharedWithLabs,
|
|
now,
|
|
});
|
|
|
|
await tx
|
|
.update(feedbackVotes)
|
|
.set({
|
|
redactionSummary: artifacts.redactionSummary,
|
|
updatedAt: now,
|
|
})
|
|
.where(eq(feedbackVotes.id, savedVote.id));
|
|
|
|
const [savedTrace] = await tx
|
|
.insert(feedbackExports)
|
|
.values({
|
|
companyId: issue.companyId,
|
|
feedbackVoteId: savedVote.id,
|
|
issueId: issue.id,
|
|
projectId: issue.projectId,
|
|
authorUserId: input.authorUserId,
|
|
targetType: input.targetType,
|
|
targetId: input.targetId,
|
|
vote: input.vote,
|
|
status: sharedWithLabs ? "pending" : "local_only",
|
|
destination: sharedWithLabs ? FEEDBACK_DESTINATION : null,
|
|
exportId: artifacts.exportId,
|
|
consentVersion: sharedWithLabs ? (consentVersion ?? DEFAULT_FEEDBACK_DATA_SHARING_TERMS_VERSION) : null,
|
|
schemaVersion: FEEDBACK_SCHEMA_VERSION,
|
|
bundleVersion: FEEDBACK_BUNDLE_VERSION,
|
|
payloadVersion: FEEDBACK_PAYLOAD_VERSION,
|
|
payloadDigest: artifacts.payloadDigest,
|
|
payloadSnapshot: artifacts.payloadSnapshot,
|
|
targetSummary: artifacts.targetSummary,
|
|
redactionSummary: artifacts.redactionSummary,
|
|
updatedAt: now,
|
|
})
|
|
.onConflictDoUpdate({
|
|
target: [feedbackExports.feedbackVoteId],
|
|
set: {
|
|
issueId: issue.id,
|
|
projectId: issue.projectId,
|
|
authorUserId: input.authorUserId,
|
|
targetType: input.targetType,
|
|
targetId: input.targetId,
|
|
vote: input.vote,
|
|
status: sharedWithLabs ? "pending" : "local_only",
|
|
destination: sharedWithLabs ? FEEDBACK_DESTINATION : null,
|
|
exportId: artifacts.exportId,
|
|
consentVersion: sharedWithLabs ? (consentVersion ?? DEFAULT_FEEDBACK_DATA_SHARING_TERMS_VERSION) : null,
|
|
schemaVersion: FEEDBACK_SCHEMA_VERSION,
|
|
bundleVersion: FEEDBACK_BUNDLE_VERSION,
|
|
payloadVersion: FEEDBACK_PAYLOAD_VERSION,
|
|
payloadDigest: artifacts.payloadDigest,
|
|
payloadSnapshot: artifacts.payloadSnapshot,
|
|
targetSummary: artifacts.targetSummary,
|
|
redactionSummary: artifacts.redactionSummary,
|
|
failureReason: null,
|
|
updatedAt: now,
|
|
},
|
|
})
|
|
.returning({
|
|
id: feedbackExports.id,
|
|
});
|
|
|
|
return {
|
|
vote: {
|
|
...savedVote,
|
|
redactionSummary: artifacts.redactionSummary,
|
|
},
|
|
traceId: savedTrace?.id ?? null,
|
|
consentEnabledNow,
|
|
persistedSharingPreference,
|
|
sharingEnabled: sharedWithLabs,
|
|
};
|
|
}),
|
|
};
|
|
}
|