agent-sin 0.1.11 → 0.1.15

package/dist/core/notifier.js

@@ -1,15 +1,18 @@
 import { spawn } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { collectLocalFileAttachments, } from "./image-attachments.js";
 import { l } from "./i18n.js";
 const DISCORD_API_BASE = "https://discord.com/api/v10";
 const DISCORD_MESSAGE_LIMIT = 1900;
 const TELEGRAM_API_BASE = "https://api.telegram.org";
 const TELEGRAM_MESSAGE_LIMIT = 3900;
 export async function notify(options) {
-    const title = sanitize(options.title);
-    const body = sanitize(options.body);
+    const title = sanitize(options.title || "");
+    const body = sanitize(options.body || "");
     const subtitle = options.subtitle ? sanitize(options.subtitle) : undefined;
-    if (!title && !body) {
-        throw new Error(l("notify: title or body is required", "notify: title または body が必要です"));
+    const attachmentPaths = normalizeAttachmentPaths(options);
+    if (!title && !body && attachmentPaths.length === 0) {
+        throw new Error(l("notify: title, body, or filePath is required", "notify: title、body、または filePath が必要です"));
     }
     const requested = options.channel || "auto";
     const channel = requested === "auto" ? resolveAutoChannel() : requested;
@@ -22,19 +25,30 @@ export async function notify(options) {
         case "windows":
             return notifyWindows(title, body, subtitle);
         case "discord":
-            return notifyDiscord(title, body, subtitle, options.discordThreadId);
+            return notifyDiscord(title, body, subtitle, options.discordThreadId, attachmentPaths, options.cwd);
         case "telegram":
-            return notifyTelegram(title, body, subtitle, options.telegramThreadId);
+            return notifyTelegram(title, body, subtitle, options.telegramThreadId, attachmentPaths, options.cwd);
         case "slack":
             return notifySlack(title, body, subtitle);
         case "mail":
             return notifyMail(title, body, subtitle, options.to);
+        case "g2":
+            return notifyG2(title, body, subtitle);
         case "stderr":
             return notifyStderr(title, body, subtitle);
         default:
             return notifyStderr(title, body, subtitle);
     }
 }
+function normalizeAttachmentPaths(options) {
+    const paths = [
+        options.filePath,
+        options.imagePath,
+        ...(Array.isArray(options.filePaths) ? options.filePaths : []),
+        ...(Array.isArray(options.imagePaths) ? options.imagePaths : []),
+    ].filter((item) => typeof item === "string" && item.trim().length > 0);
+    return [...new Set(paths)];
+}
 function resolveAutoChannel() {
     if (process.env.AGENT_SIN_NOTIFY_BACKEND === "stderr") {
         return "stderr";
@@ -105,10 +119,14 @@ async function notifyWindows(title, body, subtitle) {
     // Fallback: stderr so the message is not lost on systems without WinRT toast support.
     return notifyStderr(title, body, subtitle);
 }
-async function notifyDiscord(title, body, subtitle, threadIdOverride) {
+async function notifyDiscord(title, body, subtitle, threadIdOverride, attachmentPaths, attachmentCwd) {
     const url = process.env.AGENT_SIN_DISCORD_WEBHOOK_URL;
     const content = formatPlainTextMessage(title, body, subtitle);
-    const chunks = splitMessage(content, DISCORD_MESSAGE_LIMIT);
+    const chunks = content.trim() ? splitMessage(content, DISCORD_MESSAGE_LIMIT) : [];
+    const attachments = await collectLocalFileAttachments({ paths: attachmentPaths, cwd: attachmentCwd });
+    if (attachmentPaths.length > 0 && attachments.length === 0) {
+        return { channel: "discord", ok: false, detail: "No readable attachment file was found" };
+    }
     const rawThreadId = discordNotifyThreadId(threadIdOverride);
     const threadId = normalizeDiscordSnowflake(rawThreadId);
     if (rawThreadId && !threadId) {
@@ -116,12 +134,18 @@ async function notifyDiscord(title, body, subtitle, threadIdOverride) {
     }
     if (url) {
         const webhookUrl = discordWebhookUrl(url, threadId);
-        return postDiscordChunks(chunks, (chunk) => postWebhook(webhookUrl, { content: chunk }, "discord"));
+        const textResult = await postDiscordChunks(chunks, (chunk) => postWebhook(webhookUrl, { content: chunk }, "discord"));
+        if (!textResult.ok)
+            return textResult;
+        return postDiscordAttachments(attachments, (attachment) => postDiscordWebhookAttachment(webhookUrl, attachment));
     }
     const token = process.env.AGENT_SIN_DISCORD_BOT_TOKEN;
     const targetId = threadId || discordNotifyChannelId();
     if (token && targetId) {
-        return postDiscordChunks(chunks, (chunk) => postDiscordBotMessage(token, targetId, chunk));
+        const textResult = await postDiscordChunks(chunks, (chunk) => postDiscordBotMessage(token, targetId, chunk));
+        if (!textResult.ok)
+            return textResult;
+        return postDiscordAttachments(attachments, (attachment) => postDiscordBotAttachment(token, targetId, attachment));
     }
     return {
         channel: "discord",
@@ -137,7 +161,7 @@ async function notifySlack(title, body, subtitle) {
     const text = formatPlainTextMessage(title, body, subtitle);
     return postWebhook(url, { text }, "slack");
 }
-async function notifyTelegram(title, body, subtitle, threadIdOverride) {
+async function notifyTelegram(title, body, subtitle, threadIdOverride, attachmentPaths, attachmentCwd) {
     const token = process.env.AGENT_SIN_TELEGRAM_BOT_TOKEN;
     const chatId = telegramNotifyChatId();
     if (!token) {
@@ -152,8 +176,15 @@ async function notifyTelegram(title, body, subtitle, threadIdOverride) {
         return { channel: "telegram", ok: false, detail: `invalid Telegram thread id: ${rawThreadId}` };
     }
     const content = formatPlainTextMessage(title, body, subtitle);
-    const chunks = splitMessage(content, TELEGRAM_MESSAGE_LIMIT);
-    return postTelegramChunks(chunks, (chunk) => postTelegramBotMessage(token, chatId, chunk, threadId));
+    const chunks = content.trim() ? splitMessage(content, TELEGRAM_MESSAGE_LIMIT) : [];
+    const attachments = await collectLocalFileAttachments({ paths: attachmentPaths, cwd: attachmentCwd });
+    if (attachmentPaths.length > 0 && attachments.length === 0) {
+        return { channel: "telegram", ok: false, detail: "No readable attachment file was found" };
+    }
+    const textResult = await postTelegramChunks(chunks, (chunk) => postTelegramBotMessage(token, chatId, chunk, threadId));
+    if (!textResult.ok)
+        return textResult;
+    return postTelegramAttachments(attachments, (attachment) => postTelegramBotAttachment(token, chatId, attachment, threadId));
 }
 async function notifyMail(title, body, subtitle, toOverride) {
     const host = process.env.AGENT_SIN_SMTP_HOST;
@@ -211,14 +242,47 @@ async function notifyMail(title, body, subtitle, toOverride) {
         };
     }
 }
+async function notifyG2(title, body, subtitle) {
+    const url = process.env.AGENT_SIN_G2_NOTIFY_URL || defaultG2NotifyUrl();
+    const token = process.env.AGENT_SIN_G2_TOKEN || "";
+    const headers = { "content-type": "application/json" };
+    if (token) {
+        headers.authorization = `Bearer ${token}`;
+    }
+    try {
+        const response = await fetch(url, {
+            method: "POST",
+            headers,
+            body: JSON.stringify({ title, body, subtitle }),
+        });
+        if (!response.ok) {
+            return { channel: "g2", ok: false, detail: `HTTP ${response.status} ${response.statusText}`.trim() };
+        }
+        return { channel: "g2", ok: true };
+    }
+    catch (error) {
+        return {
+            channel: "g2",
+            ok: false,
+            detail: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+function defaultG2NotifyUrl() {
+    const port = process.env.AGENT_SIN_G2_PORT || "8765";
+    return `http://127.0.0.1:${port}/api/notify`;
+}
 function notifyStderr(title, body, subtitle) {
-    const head = subtitle ? `${title} - ${subtitle}` : title;
-    process.stderr.write(`[notify] ${head}: ${body}\n`);
+    const head = [title, subtitle].filter(Boolean).join(" - ");
+    const text = head && body ? `${head}: ${body}` : (body || head);
+    process.stderr.write(`[notify] ${text}\n`);
     return { channel: "stderr", ok: true };
 }
 function formatPlainTextMessage(title, body, subtitle) {
-    const head = subtitle ? `*${title}* — ${subtitle}` : `*${title}*`;
-    return body ? `${head}\n${body}` : head;
+    const head = title ? (subtitle ? `*${title}* - ${subtitle}` : `*${title}*`) : (subtitle || "");
+    if (head && body)
+        return `${head}\n${body}`;
+    return body || head;
 }
 function hasDiscordBotNotifyConfig() {
     return Boolean(process.env.AGENT_SIN_DISCORD_BOT_TOKEN && (discordNotifyThreadId() || discordNotifyChannelId()));
@@ -317,6 +381,19 @@ async function postDiscordChunks(chunks, send) {
     }
     return { channel: "discord", ok: true, detail: chunks.length > 1 ? `${chunks.length} messages` : undefined };
 }
+async function postDiscordAttachments(attachments, send) {
+    let sent = 0;
+    for (const attachment of attachments) {
+        const result = await send(attachment);
+        if (!result.ok) {
+            return sent > 0
+                ? { channel: "discord", ok: false, detail: `sent ${sent}/${attachments.length} attachments: ${result.detail || "failed"}` }
+                : result;
+        }
+        sent += 1;
+    }
+    return { channel: "discord", ok: true, detail: attachments.length > 1 ? `${attachments.length} attachments` : undefined };
+}
 async function postDiscordBotMessage(token, channelId, content) {
     try {
         const response = await fetch(`${DISCORD_API_BASE}/channels/${channelId}/messages`, {
@@ -341,6 +418,53 @@ async function postDiscordBotMessage(token, channelId, content) {
         };
     }
 }
+async function postDiscordBotAttachment(token, channelId, attachment) {
+    try {
+        const form = new FormData();
+        form.append("payload_json", JSON.stringify({ content: "" }));
+        form.append("files[0]", await blobFromLocalAttachment(attachment), attachment.filename);
+        const response = await fetch(`${DISCORD_API_BASE}/channels/${channelId}/messages`, {
+            method: "POST",
+            headers: { authorization: `Bot ${token}` },
+            body: form,
+        });
+        if (!response.ok) {
+            const detail = `HTTP ${response.status} ${response.statusText}`.trim();
+            return { channel: "discord", ok: false, detail };
+        }
+        return { channel: "discord", ok: true };
+    }
+    catch (error) {
+        return {
+            channel: "discord",
+            ok: false,
+            detail: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+async function postDiscordWebhookAttachment(url, attachment) {
+    try {
+        const form = new FormData();
+        form.append("payload_json", JSON.stringify({ content: "" }));
+        form.append("files[0]", await blobFromLocalAttachment(attachment), attachment.filename);
+        const response = await fetch(url, {
+            method: "POST",
+            body: form,
+        });
+        if (!response.ok) {
+            const detail = `HTTP ${response.status} ${response.statusText}`.trim();
+            return { channel: "discord", ok: false, detail };
+        }
+        return { channel: "discord", ok: true };
+    }
+    catch (error) {
+        return {
+            channel: "discord",
+            ok: false,
+            detail: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
 async function postTelegramChunks(chunks, send) {
     let sent = 0;
     for (const chunk of chunks) {
@@ -354,6 +478,19 @@ async function postTelegramChunks(chunks, send) {
     }
     return { channel: "telegram", ok: true, detail: chunks.length > 1 ? `${chunks.length} messages` : undefined };
 }
+async function postTelegramAttachments(attachments, send) {
+    let sent = 0;
+    for (const attachment of attachments) {
+        const result = await send(attachment);
+        if (!result.ok) {
+            return sent > 0
+                ? { channel: "telegram", ok: false, detail: `sent ${sent}/${attachments.length} attachments: ${result.detail || "failed"}` }
+                : result;
+        }
+        sent += 1;
+    }
+    return { channel: "telegram", ok: true, detail: attachments.length > 1 ? `${attachments.length} attachments` : undefined };
+}
 async function postTelegramBotMessage(token, chatId, text, threadId) {
     try {
         const payload = {
@@ -383,6 +520,43 @@ async function postTelegramBotMessage(token, chatId, text, threadId) {
         };
     }
 }
+async function postTelegramBotAttachment(token, chatId, attachment, threadId) {
+    const method = shouldSendTelegramAsPhoto(attachment) ? "sendPhoto" : "sendDocument";
+    const fileField = method === "sendPhoto" ? "photo" : "document";
+    try {
+        const form = new FormData();
+        form.append("chat_id", chatId);
+        if (threadId) {
+            form.append("message_thread_id", threadId);
+        }
+        form.append(fileField, await blobFromLocalAttachment(attachment), attachment.filename);
+        const response = await fetch(`${TELEGRAM_API_BASE}/bot${token}/${method}`, {
+            method: "POST",
+            body: form,
+        });
+        if (!response.ok) {
+            const detail = `HTTP ${response.status} ${response.statusText}`.trim();
+            return { channel: "telegram", ok: false, detail };
+        }
+        return { channel: "telegram", ok: true };
+    }
+    catch (error) {
+        return {
+            channel: "telegram",
+            ok: false,
+            detail: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+function shouldSendTelegramAsPhoto(attachment) {
+    return attachment.isImage && ["image/png", "image/jpeg", "image/webp"].includes(attachment.mimeType.toLowerCase());
+}
+async function blobFromLocalAttachment(attachment) {
+    const buffer = await readFile(attachment.path);
+    const bytes = new Uint8Array(buffer.length);
+    bytes.set(buffer);
+    return new Blob([bytes.buffer], { type: attachment.mimeType });
+}
 async function postWebhook(url, payload, channel) {
     try {
         const response = await fetch(url, {

package/dist/core/obsidian-vault.d.ts

@@ -0,0 +1,19 @@
+import type { AppConfig } from "./config.js";
+export interface ObsidianVaultLink {
+    name: string;
+    target: string;
+    created: boolean;
+    ok: boolean;
+}
+export interface ObsidianVaultSetupResult {
+    enabled: boolean;
+    vaultDir: string;
+    created: boolean;
+    links: ObsidianVaultLink[];
+    homeCreated: boolean;
+    configCreated: boolean;
+    symlinkError?: string;
+}
+export declare function defaultObsidianVaultDir(): string;
+export declare function resolvedObsidianVaultDir(config: AppConfig): string;
+export declare function ensureObsidianVault(config: AppConfig): Promise<ObsidianVaultSetupResult>;