Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.
import * as Effect from "effect/Effect";
import * as FileSystem from "effect/FileSystem";
import * as Path from "effect/Path";
import { type ProjectionThreadMessage } from "../../../persistence/Services/ProjectionThreadMessages.ts";
import { ServerConfig } from "../../../config.ts";
import {
attachmentRelativePath,
parseAttachmentIdFromRelativePath,
parseThreadSegmentFromAttachmentId,
toSafeThreadAttachmentSegment,
} from "../../../attachmentStore.ts";
import { type AttachmentSideEffects } from "./Definitions.ts";
export function collectThreadAttachmentRelativePaths(
threadId: string,
messages: ReadonlyArray<ProjectionThreadMessage>,
): Set<string> {
const threadSegment = toSafeThreadAttachmentSegment(threadId);
if (!threadSegment) {
return new Set();
}
const relativePaths = new Set<string>();
for (const message of messages) {
for (const attachment of message.attachments ?? []) {
const attachmentThreadSegment = parseThreadSegmentFromAttachmentId(attachment.id);
if (!attachmentThreadSegment || attachmentThreadSegment !== threadSegment) {
continue;
}
relativePaths.add(attachmentRelativePath(attachment));
}
}
return relativePaths;
}
export const runAttachmentSideEffects = Effect.fn("runAttachmentSideEffects")(function* (
sideEffects: AttachmentSideEffects,
) {
const serverConfig = yield* Effect.service(ServerConfig);
const fileSystem = yield* Effect.service(FileSystem.FileSystem);
const path = yield* Effect.service(Path.Path);
const attachmentsRootDir = serverConfig.attachmentsDir;
const readAttachmentRootEntries = fileSystem
.readDirectory(attachmentsRootDir, { recursive: false })
.pipe(Effect.orElseSucceed(() => Array<string>()));
const removeDeletedThreadAttachmentEntry = Effect.fn("removeDeletedThreadAttachmentEntry")(
function* (threadSegment: string, entry: string) {
const normalizedEntry = entry.replace(/^[/\\]+/, "").replace(/\\/g, "/");
if (normalizedEntry.length === 0 || normalizedEntry.includes("/")) {
return;
}
const attachmentId = parseAttachmentIdFromRelativePath(normalizedEntry);
if (!attachmentId) {
return;
}
const attachmentThreadSegment = parseThreadSegmentFromAttachmentId(attachmentId);
if (!attachmentThreadSegment || attachmentThreadSegment !== threadSegment) {
return;
}
yield* fileSystem.remove(path.join(attachmentsRootDir, normalizedEntry), {
force: true,
});
},
);
const deleteThreadAttachments = Effect.fn("deleteThreadAttachments")(function* (
threadId: string,
) {
const threadSegment = toSafeThreadAttachmentSegment(threadId);
if (!threadSegment) {
yield* Effect.logWarning("skipping attachment cleanup for unsafe thread id", {
threadId,
});
return;
}
const entries = yield* readAttachmentRootEntries;
yield* Effect.forEach(
entries,
(entry) => removeDeletedThreadAttachmentEntry(threadSegment, entry),
{
concurrency: 1,
},
);
});
const pruneThreadAttachmentEntry = Effect.fn("pruneThreadAttachmentEntry")(function* (
threadSegment: string,
keptThreadRelativePaths: Set<string>,
entry: string,
) {
const relativePath = entry.replace(/^[/\\]+/, "").replace(/\\/g, "/");
if (relativePath.length === 0 || relativePath.includes("/")) {
return;
}
const attachmentId = parseAttachmentIdFromRelativePath(relativePath);
if (!attachmentId) {
return;
}
const attachmentThreadSegment = parseThreadSegmentFromAttachmentId(attachmentId);
if (!attachmentThreadSegment || attachmentThreadSegment !== threadSegment) {
return;
}
const absolutePath = path.join(attachmentsRootDir, relativePath);
const fileInfo = yield* fileSystem.stat(absolutePath).pipe(Effect.orElseSucceed(() => null));
if (!fileInfo || fileInfo.type !== "File") {
return;
}
if (!keptThreadRelativePaths.has(relativePath)) {
yield* fileSystem.remove(absolutePath, { force: true });
}
});
const pruneThreadAttachments = Effect.fn("pruneThreadAttachments")(function* (
threadId: string,
keptThreadRelativePaths: Set<string>,
) {
if (sideEffects.deletedThreadIds.has(threadId)) {
return;
}
const threadSegment = toSafeThreadAttachmentSegment(threadId);
if (!threadSegment) {
yield* Effect.logWarning("skipping attachment prune for unsafe thread id", { threadId });
return;
}
const entries = yield* readAttachmentRootEntries;
yield* Effect.forEach(
entries,
(entry) => pruneThreadAttachmentEntry(threadSegment, keptThreadRelativePaths, entry),
{ concurrency: 1 },
);
});
yield* Effect.forEach(sideEffects.deletedThreadIds, deleteThreadAttachments, {
concurrency: 1,
});
yield* Effect.forEach(
sideEffects.prunedThreadRelativePaths.entries(),
([threadId, keptThreadRelativePaths]) =>
pruneThreadAttachments(threadId, keptThreadRelativePaths),
{ concurrency: 1 },
);
});