@adecore/agents 0.39.0 → 0.40.1

package/src/chat/attachment-store.ts

@@ -22,14 +22,19 @@ const SAFE_EXTENSION = /^[A-Za-z0-9]{1,8}$/;
 /* What the file is called on disk: the id, plus an extension the agent's tools can recognize. */
 export function extensionFor(name: string, mime: string): string {
     const own = extname(name).slice(1).toLowerCase();
+
     if (SAFE_EXTENSION.test(own)) {
         return own;
     }
+
     const known = EXTENSIONS[mime.toLowerCase()];
+
     if (known) {
         return known;
     }
+
     const subtype = mime.split('/')[1]?.replace(/\+.*$/, '') ?? '';
+
     return SAFE_EXTENSION.test(subtype) ? subtype.toLowerCase() : 'bin';
 }
 
@@ -54,6 +59,7 @@ export class AttachmentStore {
         await mkdir(folder, { recursive: true, mode: 0o700 });
         const path = join(folder, `${id}.${extensionFor(upload.name, mime)}`);
         await writeFile(path, bytes, { mode: 0o600 });
+
         return { id, name: upload.name, mime, size: bytes.byteLength, path };
     }
 
@@ -64,8 +70,10 @@ export class AttachmentStore {
         await mkdir(folder, { recursive: true, mode: 0o700 });
         const path = join(folder, `${id}.${extensionFor('', upload.mime)}`);
         const temporary = join(folder, `.${id}-${randomBytes(8).toString('hex')}.tmp`);
+
         try {
             await writeFile(temporary, bytes, { mode: 0o600, flag: 'wx' });
+
             try {
                 // Publish complete bytes without replacing an image another replay has already saved.
                 await link(temporary, path);
@@ -73,7 +81,9 @@ export class AttachmentStore {
                 if ((error as NodeJS.ErrnoException).code !== 'EEXIST') {
                     throw error;
                 }
+
                 const previous = await readFile(path);
+
                 if (!previous.equals(bytes)) {
                     throw new Error('The generated image id already belongs to another image');
                 }
@@ -81,6 +91,7 @@ export class AttachmentStore {
         } finally {
             await rm(temporary, { force: true });
         }
+
         return { id, name: upload.name, mime: upload.mime, size: bytes.byteLength, path };
     }
 
@@ -90,6 +101,7 @@ export class AttachmentStore {
         await mkdir(folder, { recursive: true, mode: 0o700 });
         const path = join(folder, `${createHash('sha256').update(attachment.id).digest('hex')}.${extensionFor(attachment.name, attachment.mime)}`);
         await writeFile(path, bytes, { mode: 0o600 });
+
         return { ...attachment, path };
     }
 
@@ -102,6 +114,7 @@ export class AttachmentStore {
     folderOf(chatId: string): string {
         // `encodeURIComponent` leaves `.` and `..` as they are, and those would name this folder or the host's own.
         const segment = chatId === '.' || chatId === '..' ? chatId.replaceAll('.', '%2E') : encodeURIComponent(chatId);
+
         return join(this.dir, segment);
     }
 }
@@ -118,26 +131,34 @@ function isInline(value: unknown): value is { name: string; mediaType: string; d
  */
 export async function migrateInlineAttachments(chatId: string, record: unknown, store: AttachmentStore): Promise<unknown | null> {
     const items = isRecord(record) && Array.isArray(record.items) ? record.items : null;
+
     if (!items) {
         return null;
     }
+
     let migrated = false;
+
     const next = await Promise.all(
         items.map(async (item) => {
             if (!isRecord(item) || !Array.isArray(item.attachments) || !item.attachments.some(isInline)) {
                 return item;
             }
+
             const attachments = await Promise.all(
                 item.attachments.map(async (attachment) => {
                     if (!isInline(attachment)) {
                         return attachment;
                     }
+
                     migrated = true;
+
                     return await store.save(chatId, { name: attachment.name, mime: attachment.mediaType, data: attachment.data });
                 })
             );
+
             return { ...item, attachments };
         })
     );
+
     return migrated ? { ...(record as Record<string, unknown>), items: next } : null;
 }

package/src/chat/backend.ts

@@ -22,7 +22,6 @@ import type { SpawnChatProcess } from './chat-process.ts';
  */
 
 export interface BackendLaunch {
-    // A test points this at a fake CLI.
     command: string[];
     cwd: string;
     env: Record<string, string>;
@@ -55,7 +54,6 @@ export interface BackendLaunch {
     folders?: readonly string[];
     // False keeps the CLI from loading configuration out of `cwd` (settings, hooks, MCP servers); absent loads it.
     projectConfig?: boolean;
-    // How the CLI is started; a test runs a fake in the same process, everything else spawns it.
     spawn?: SpawnChatProcess;
     saveGeneratedImage?(ref: string, upload: ChatAttachmentUpload): Promise<ChatAttachment>;
 }

package/src/chat/bookmark-store.ts

@@ -24,11 +24,13 @@ export type BookmarkListener = (chatId: string, bookmarks: ChatBookmark[]) => vo
 /* A name as it is kept: trimmed, and none at all when nothing is left. */
 function cleanName(name: string | undefined): string | undefined {
     const trimmed = name === undefined ? undefined : clipText(name.trim(), CHAT_BOOKMARK_LIMITS.name);
+
     return trimmed === undefined || trimmed === '' ? undefined : trimmed;
 }
 
 function named(bookmark: ChatBookmark, name: string | undefined): ChatBookmark {
     const { name: _previous, ...rest } = bookmark;
+
     return name === undefined ? rest : { ...rest, name };
 }
 
@@ -49,6 +51,7 @@ export class BookmarkStore {
 
     listen(listener: BookmarkListener): () => void {
         this.listeners.add(listener);
+
         return () => {
             this.listeners.delete(listener);
         };
@@ -64,13 +67,17 @@ export class BookmarkStore {
         return this.change(chatId, (bookmarks) => {
             const name = cleanName(input.name);
             const existing = bookmarks.find((bookmark) => bookmark.itemId === input.itemId);
+
             if (existing) {
                 return name === undefined ? null : bookmarks.map((bookmark) => (bookmark === existing ? named(bookmark, name) : bookmark));
             }
+
             if (bookmarks.length >= CHAT_BOOKMARK_LIMITS.perChat) {
                 throw new ChatError('too-many-bookmarks', `This chat already keeps ${CHAT_BOOKMARK_LIMITS.perChat} bookmarks; remove one first`);
             }
+
             const excerpt = clipText(input.excerpt, CHAT_BOOKMARK_LIMITS.excerpt);
+
             return [...bookmarks, named({ itemId: input.itemId, excerpt, createdAt: now }, name)];
         });
     }
@@ -80,6 +87,7 @@ export class BookmarkStore {
             if (!bookmarks.some((bookmark) => bookmark.itemId === itemId)) {
                 throw new ChatError('bookmark-not-found', `This chat has no bookmark on ${itemId}`);
             }
+
             return bookmarks.map((bookmark) => (bookmark.itemId === itemId ? named(bookmark, cleanName(name)) : bookmark));
         });
     }
@@ -97,7 +105,9 @@ export class BookmarkStore {
                 (bookmarks) => bookmarks.length > 0,
                 () => true
             );
+
             await rm(join(this.dir, bookmarkFileName(chatId)), { force: true });
+
             if (had) {
                 this.tell(chatId, []);
             }
@@ -107,9 +117,11 @@ export class BookmarkStore {
     /* A fork keeps the bookmarks on the messages it copied, which are the ones up to where it was cut. */
     async copyChat(fromChatId: string, toChatId: string, keep: (itemId: string) => boolean): Promise<void> {
         const kept = (await this.read(fromChatId)).filter((bookmark) => keep(bookmark.itemId));
+
         if (kept.length === 0) {
             return;
         }
+
         await this.writes.run(toChatId, async () => {
             await this.writeFile(toChatId, kept);
             this.tell(toChatId, kept);
@@ -121,11 +133,14 @@ export class BookmarkStore {
         return this.writes.run(chatId, async () => {
             const bookmarks = await this.readFile(chatId);
             const next = decide(bookmarks);
+
             if (next === null) {
                 return bookmarks;
             }
+
             await this.writeFile(chatId, next);
             this.tell(chatId, next);
+
             return next;
         });
     }
@@ -138,28 +153,36 @@ export class BookmarkStore {
 
     private async readFile(chatId: string): Promise<ChatBookmark[]> {
         let raw: string;
+
         try {
             raw = await readFile(join(this.dir, bookmarkFileName(chatId)), 'utf8');
         } catch (e) {
             if (isNotFound(e)) {
                 return [];
             }
+
             throw e;
         }
+
         // A file that does not parse is refused rather than read as empty, which the next write would make true.
         const parsed = BookmarkFileSchema.safeParse(JSON.parse(raw));
+
         if (!parsed.success) {
             throw new Error(`The bookmarks file of chat ${chatId} is not valid: ${parsed.error.issues[0]?.message ?? 'unknown problem'}`);
         }
+
         return parsed.data.bookmarks;
     }
 
     private async writeFile(chatId: string, bookmarks: readonly ChatBookmark[]): Promise<void> {
         const path = join(this.dir, bookmarkFileName(chatId));
+
         if (bookmarks.length === 0) {
             await rm(path, { force: true });
+
             return;
         }
+
         await mkdir(this.dir, { recursive: true, mode: 0o700 });
         await writeAtomic(path, JSON.stringify({ version: 1, bookmarks }));
     }