agent-sin 0.1.12 → 0.1.16

package/dist/core/image-attachments.d.ts

@@ -0,0 +1,31 @@
+export interface LocalFileAttachment {
+    path: string;
+    filename: string;
+    mimeType: string;
+    size: number;
+    isImage: boolean;
+}
+export interface LocalImageAttachment extends LocalFileAttachment {
+    isImage: true;
+}
+export interface CollectLocalFileAttachmentOptions {
+    paths?: string[];
+    cwd?: string;
+    allowedRoots?: string[];
+    maxFiles?: number;
+    maxBytes?: number;
+}
+export interface CollectLocalImageAttachmentOptions extends CollectLocalFileAttachmentOptions {
+    text?: string;
+}
+interface LocalCandidate {
+    value: string;
+    trusted: boolean;
+}
+export declare function collectLocalFileAttachments(options: CollectLocalFileAttachmentOptions): Promise<LocalFileAttachment[]>;
+export declare function collectLocalImageAttachments(options: CollectLocalImageAttachmentOptions): Promise<LocalImageAttachment[]>;
+export declare function extractLocalImageCandidates(text: string): LocalCandidate[];
+export declare function detectImageMimeTypeFromBuffer(buffer: Buffer, fallback?: string): string;
+export declare function imageExtensionForMimeType(mimeType: string): string;
+export declare function guessFileMimeType(filePath: string): string;
+export {};

package/dist/core/image-attachments.js

@@ -0,0 +1,237 @@
+import { realpath, stat } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { guessImageMimeType, isImageLikeFile } from "./message-utils.js";
+const DEFAULT_MAX_FILES = 4;
+const DEFAULT_MAX_BYTES = 20 * 1024 * 1024;
+const IMAGE_EXT_PATTERN = /\.(png|jpe?g|gif|webp|bmp|heic|heif)(?=$|[?#])/i;
+const MARKDOWN_IMAGE_PATTERN = /!\[[^\]\n]*\]\(([^)\n]+)\)/g;
+const MARKDOWN_LINK_PATTERN = /\[[^\]\n]*\]\(([^)\n]+)\)/g;
+const CODE_PATH_PATTERN = /`([^`\n]+\.(?:png|jpe?g|gif|webp|bmp|heic|heif)(?:[?#][^`\n]*)?)`/gi;
+const RAW_PATH_PATTERN = /(^|[\s(["'])((?:~\/|\.{1,2}\/|\/|[A-Za-z]:[\\/])[^<>"'`()\s]+\.(?:png|jpe?g|gif|webp|bmp|heic|heif)(?:[?#][^<>"'`()\s]*)?)/gi;
+const FILE_MIME_TYPES = {
+    ".txt": "text/plain",
+    ".text": "text/plain",
+    ".md": "text/markdown",
+    ".markdown": "text/markdown",
+    ".json": "application/json",
+    ".jsonl": "application/x-ndjson",
+    ".csv": "text/csv",
+    ".tsv": "text/tab-separated-values",
+    ".yaml": "application/yaml",
+    ".yml": "application/yaml",
+    ".xml": "application/xml",
+    ".html": "text/html",
+    ".htm": "text/html",
+    ".css": "text/css",
+    ".js": "text/javascript",
+    ".mjs": "text/javascript",
+    ".ts": "text/typescript",
+    ".pdf": "application/pdf",
+    ".zip": "application/zip",
+    ".gz": "application/gzip",
+    ".tar": "application/x-tar",
+    ".mp3": "audio/mpeg",
+    ".wav": "audio/wav",
+    ".mp4": "video/mp4",
+    ".mov": "video/quicktime",
+};
+export async function collectLocalFileAttachments(options) {
+    return collectLocalAttachments((options.paths || []).map((value) => ({ value, trusted: true })), options, { requireImage: false });
+}
+export async function collectLocalImageAttachments(options) {
+    const candidates = [
+        ...(options.paths || []).map((value) => ({ value, trusted: true })),
+        ...extractLocalImageCandidates(options.text || ""),
+    ];
+    const attachments = await collectLocalAttachments(candidates, options, { requireImage: true });
+    return attachments.filter((attachment) => attachment.isImage);
+}
+async function collectLocalAttachments(candidates, options, collectOptions) {
+    const cwd = options.cwd || process.cwd();
+    const maxFiles = options.maxFiles ?? DEFAULT_MAX_FILES;
+    const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+    const allowedRoots = await resolveAllowedRoots(options.allowedRoots || []);
+    const attachments = [];
+    const seen = new Set();
+    for (const candidate of candidates) {
+        if (attachments.length >= maxFiles)
+            break;
+        const resolved = resolveLocalPathCandidate(candidate.value, cwd);
+        if (!resolved)
+            continue;
+        const attachment = await inspectLocalAttachment(resolved, {
+            trusted: candidate.trusted,
+            allowedRoots,
+            maxBytes,
+            requireImage: collectOptions.requireImage,
+        });
+        if (!attachment || seen.has(attachment.path))
+            continue;
+        seen.add(attachment.path);
+        attachments.push(attachment);
+    }
+    return attachments;
+}
+export function extractLocalImageCandidates(text) {
+    const candidates = [];
+    const add = (value) => {
+        const cleaned = cleanCandidateRef(value);
+        if (!cleaned || !IMAGE_EXT_PATTERN.test(cleaned))
+            return;
+        candidates.push({ value: cleaned, trusted: false });
+    };
+    for (const match of text.matchAll(MARKDOWN_IMAGE_PATTERN)) {
+        add(match[1]);
+    }
+    for (const match of text.matchAll(MARKDOWN_LINK_PATTERN)) {
+        add(match[1]);
+    }
+    for (const match of text.matchAll(CODE_PATH_PATTERN)) {
+        add(match[1]);
+    }
+    for (const match of text.matchAll(RAW_PATH_PATTERN)) {
+        add(match[2]);
+    }
+    return candidates;
+}
+export function detectImageMimeTypeFromBuffer(buffer, fallback = "image/png") {
+    if (buffer.length >= 8 && buffer.subarray(0, 8).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]))) {
+        return "image/png";
+    }
+    if (buffer.length >= 3 && buffer[0] === 0xff && buffer[1] === 0xd8 && buffer[2] === 0xff) {
+        return "image/jpeg";
+    }
+    if (buffer.length >= 6 && (buffer.subarray(0, 6).toString("ascii") === "GIF87a" || buffer.subarray(0, 6).toString("ascii") === "GIF89a")) {
+        return "image/gif";
+    }
+    if (buffer.length >= 12 &&
+        buffer.subarray(0, 4).toString("ascii") === "RIFF" &&
+        buffer.subarray(8, 12).toString("ascii") === "WEBP") {
+        return "image/webp";
+    }
+    if (buffer.length >= 2 && buffer[0] === 0x42 && buffer[1] === 0x4d) {
+        return "image/bmp";
+    }
+    return fallback;
+}
+export function imageExtensionForMimeType(mimeType) {
+    const normalized = mimeType.toLowerCase().split(";")[0].trim();
+    if (normalized === "image/jpeg")
+        return ".jpg";
+    if (normalized === "image/gif")
+        return ".gif";
+    if (normalized === "image/webp")
+        return ".webp";
+    if (normalized === "image/bmp")
+        return ".bmp";
+    if (normalized === "image/heic")
+        return ".heic";
+    if (normalized === "image/heif")
+        return ".heif";
+    return ".png";
+}
+export function guessFileMimeType(filePath) {
+    if (isImageLikeFile(undefined, filePath)) {
+        return guessImageMimeType(filePath);
+    }
+    const ext = path.extname(filePath).toLowerCase();
+    return FILE_MIME_TYPES[ext] || "application/octet-stream";
+}
+function cleanCandidateRef(value) {
+    let ref = value.trim();
+    const titleMatch = ref.match(/^<([^>]+)>/);
+    if (titleMatch) {
+        ref = titleMatch[1];
+    }
+    else {
+        ref = ref.replace(/\s+["'][^"']*["']\s*$/, "");
+    }
+    ref = ref.replace(/^['"<]+/, "").replace(/[)'">.,;:]+$/g, "");
+    return ref.trim();
+}
+function resolveLocalPathCandidate(value, cwd) {
+    let ref = cleanCandidateRef(value);
+    if (!ref)
+        return null;
+    if (/^(https?|data|attachment):/i.test(ref))
+        return null;
+    if (ref.startsWith("sandbox:")) {
+        ref = ref.slice("sandbox:".length);
+    }
+    if (ref.startsWith("file://")) {
+        try {
+            ref = fileURLToPath(ref);
+        }
+        catch {
+            return null;
+        }
+    }
+    try {
+        ref = decodeURIComponent(ref);
+    }
+    catch {
+        // Keep the original string if it was not URI-encoded.
+    }
+    if (ref.startsWith("~/")) {
+        ref = path.join(os.homedir(), ref.slice(2));
+    }
+    if (!path.isAbsolute(ref)) {
+        ref = path.resolve(cwd, ref);
+    }
+    return ref;
+}
+async function resolveAllowedRoots(roots) {
+    const out = [];
+    for (const root of roots) {
+        if (!root)
+            continue;
+        try {
+            out.push(await realpath(root));
+        }
+        catch {
+            out.push(path.resolve(root));
+        }
+    }
+    return out;
+}
+async function inspectLocalAttachment(filePath, options) {
+    let real;
+    try {
+        real = await realpath(filePath);
+    }
+    catch {
+        return null;
+    }
+    if (!options.trusted && options.allowedRoots.length > 0 && !isUnderAllowedRoot(real, options.allowedRoots)) {
+        return null;
+    }
+    let info;
+    try {
+        info = await stat(real);
+    }
+    catch {
+        return null;
+    }
+    if (!info.isFile() || info.size <= 0 || info.size > options.maxBytes) {
+        return null;
+    }
+    const isImage = isImageLikeFile(undefined, real);
+    if (options.requireImage && !isImage) {
+        return null;
+    }
+    return {
+        path: real,
+        filename: path.basename(real),
+        mimeType: guessFileMimeType(real),
+        size: info.size,
+        isImage,
+    };
+}
+function isUnderAllowedRoot(filePath, roots) {
+    return roots.some((root) => {
+        const relative = path.relative(root, filePath);
+        return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+    });
+}

package/dist/core/logger.d.ts

@@ -19,7 +19,7 @@ export interface RunLogRecord {
     }>;
 }
 export type EventLogLevel = "info" | "warn" | "error";
-export type EventLogSource = "cli" | "chat" | "skill" | "setup" | "build" | "schedule" | "discord" | "telegram";
+export type EventLogSource = "cli" | "chat" | "skill" | "setup" | "build" | "schedule" | "discord" | "telegram" | "g2";
 export interface EventLogEntry {
     ts?: string;
     level: EventLogLevel;
@@ -55,6 +55,7 @@ export interface ConversationLogEntry {
 export declare function appendConversationLog(config: AppConfig, entry: ConversationLogEntry): Promise<void>;
 export declare function dailyConversationMemoryFile(config: AppConfig, date?: Date): string;
 export declare function pruneOldLogs(config: AppConfig): Promise<void>;
+export declare function pruneOrphanAttachments(config: AppConfig): Promise<void>;
 export declare function readEventLog(config: AppConfig, options?: ReadEventLogOptions): Promise<ReadEventLogResult[]>;
 export declare function listRunLogs(config: AppConfig, skillId?: string): Promise<RunLogRecord[]>;
 export declare function readRunLog(config: AppConfig, runId: string): Promise<RunLogRecord>;

package/dist/core/logger.js

@@ -64,7 +64,16 @@ async function appendDailyConversationMemory(config, entry) {
 function formatConversationMarkdownEntry(entry) {
     const label = [entry.source, entry.role].filter(Boolean).join(" ");
     const content = entry.content.trim() || "(empty)";
-    return [`## ${entry.ts} ${label}`, "", content].join("\n");
+    return [`## ${formatConversationDisplayTime(entry.ts)} ${label}`, "", content].join("\n");
+}
+function formatConversationDisplayTime(timestamp) {
+    const date = new Date(timestamp);
+    if (Number.isNaN(date.getTime())) {
+        return timestamp;
+    }
+    const HH = String(date.getHours()).padStart(2, "0");
+    const mm = String(date.getMinutes()).padStart(2, "0");
+    return `${HH}:${mm}`;
 }
 async function readTextIfExists(file) {
     try {
@@ -111,6 +120,73 @@ export async function pruneOldLogs(config) {
             return head ? Date.parse(head) : NaN;
         });
     }
+    await pruneOrphanAttachments(config);
+}
+const ATTACHMENT_RETENTION_DAYS = 7;
+const ATTACHMENT_REFERENCE_PATTERN = /!\[[^\]]*\]\(([^)]+)\)/g;
+export async function pruneOrphanAttachments(config) {
+    const attachmentsDir = path.join(config.memory_dir, "attachments");
+    let attachmentEntries;
+    try {
+        attachmentEntries = (await readdir(attachmentsDir, { recursive: true }));
+    }
+    catch {
+        return;
+    }
+    const cutoff = Date.now() - ATTACHMENT_RETENTION_DAYS * 24 * 60 * 60 * 1000;
+    // 参照元は daily memory (memory_dir) と user-facing memo (notes_dir) の両方を見る。
+    const referenced = new Set();
+    for (const base of [config.memory_dir, config.notes_dir]) {
+        for (const name of await collectReferencedAttachmentBasenames(base)) {
+            referenced.add(name);
+        }
+    }
+    for (const rel of attachmentEntries) {
+        const full = path.join(attachmentsDir, rel);
+        try {
+            const info = await stat(full);
+            if (!info.isFile())
+                continue;
+            if (info.mtimeMs >= cutoff)
+                continue;
+            if (referenced.has(path.basename(full)))
+                continue;
+            await rm(full, { force: true });
+        }
+        catch {
+            // ignore
+        }
+    }
+}
+async function collectReferencedAttachmentBasenames(rootDir) {
+    const referenced = new Set();
+    let entries;
+    try {
+        entries = (await readdir(rootDir, { recursive: true }));
+    }
+    catch {
+        return referenced;
+    }
+    for (const rel of entries) {
+        if (!rel.endsWith(".md"))
+            continue;
+        if (rel === "attachments" || rel.startsWith(`attachments${path.sep}`))
+            continue;
+        let raw;
+        try {
+            raw = await readFile(path.join(rootDir, rel), "utf8");
+        }
+        catch {
+            continue;
+        }
+        for (const match of raw.matchAll(ATTACHMENT_REFERENCE_PATTERN)) {
+            const ref = match[1].trim();
+            const base = path.basename(ref);
+            if (base)
+                referenced.add(base);
+        }
+    }
+    return referenced;
 }
 async function pruneLinesByLeadingTimestamp(file, cutoff, extractTime) {
     let raw;

package/dist/core/memo-migration.d.ts

@@ -0,0 +1,3 @@
+import type { AppConfig } from "./config.js";
+export declare function migrateMemoFlatStructure(config: AppConfig): Promise<void>;
+export declare function formatLocalDateTime(date: Date): string;