agent-sin 0.1.0

package/dist/core/memory.js

@@ -0,0 +1,72 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+const VERSION_KEY = "__version";
+const CURRENT_SCHEMA_VERSION = 1;
+export function skillMemoryAccess(manifest) {
+    return {
+        namespace: manifest.memory?.namespace || manifest.id,
+        canRead: manifest.memory?.read === true,
+        canWrite: manifest.memory?.write === true,
+    };
+}
+export async function loadSkillMemory(config, manifest) {
+    const access = skillMemoryAccess(manifest);
+    if (!access.canRead) {
+        return {};
+    }
+    const stored = await loadExistingMemory(memoryFile(config, access.namespace));
+    return stripVersion(stored);
+}
+export async function saveSkillMemoryUpdates(config, manifest, updates) {
+    const access = skillMemoryAccess(manifest);
+    if (!access.canWrite || Object.keys(updates).length === 0) {
+        return undefined;
+    }
+    const file = memoryFile(config, access.namespace);
+    const current = await loadExistingMemory(file);
+    const next = {
+        [VERSION_KEY]: CURRENT_SCHEMA_VERSION,
+        ...stripVersion(current),
+        ...updates,
+    };
+    await mkdir(path.dirname(file), { recursive: true });
+    await writeFile(file, JSON.stringify(next, null, 2), "utf8");
+    return file;
+}
+function memoryFile(config, namespace) {
+    return path.join(config.memory_dir, "skill-memory", `${safeName(namespace)}.json`);
+}
+async function loadExistingMemory(file) {
+    try {
+        const parsed = JSON.parse(await readFile(file, "utf8"));
+        if (!isPlainObject(parsed)) {
+            return {};
+        }
+        return migrateSkillMemory(parsed);
+    }
+    catch {
+        return {};
+    }
+}
+function migrateSkillMemory(raw) {
+    const version = typeof raw[VERSION_KEY] === "number" ? raw[VERSION_KEY] : 1;
+    // Future migrations branch on `version` here. For now we only support v1.
+    if (version > CURRENT_SCHEMA_VERSION) {
+        // Newer-than-known data: pass through untouched so we don't lose fields.
+        return raw;
+    }
+    return { [VERSION_KEY]: CURRENT_SCHEMA_VERSION, ...stripVersion(raw) };
+}
+function stripVersion(value) {
+    if (!(VERSION_KEY in value)) {
+        return value;
+    }
+    const { [VERSION_KEY]: _omit, ...rest } = value;
+    return rest;
+}
+function safeName(value) {
+    return value.replace(/[^a-zA-Z0-9_.-]/g, "_");
+}
+function isPlainObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}

package/dist/core/message-utils.d.ts

@@ -0,0 +1,13 @@
+export declare function cleanAttachmentText(text: string, maxChars: number): string;
+export declare function indentAttachmentContent(text: string): string;
+export declare function formatBytes(value: number): string;
+export declare function isTextLikeFile(contentType: string | undefined, filename: string | undefined): boolean;
+export declare function isImageLikeFile(contentType: string | undefined, filename: string | undefined): boolean;
+export declare function guessImageMimeType(filename: string | undefined): string;
+export declare function formatAttachmentLabel(input: {
+    name: string | undefined;
+    fallback: string;
+    contentType?: string;
+    size?: number;
+}): string;
+export declare function chunkText(text: string, max: number): string[];

package/dist/core/message-utils.js

@@ -0,0 +1,104 @@
+import { l } from "./i18n.js";
+const TEXT_EXT_PATTERN = /\.(txt|md|markdown|json|jsonl|csv|tsv|yaml|yml|xml|html|css|js|jsx|ts|tsx|mjs|cjs|py|rb|php|java|kt|go|rs|swift|c|cc|cpp|h|hpp|sh|bash|zsh|fish|sql|toml|ini|env|log)$/i;
+const IMAGE_EXT_PATTERN = /\.(png|jpe?g|gif|webp|bmp|heic|heif)$/i;
+const TEXT_CONTENT_TYPES = new Set([
+    "application/json",
+    "application/ld+json",
+    "application/xml",
+    "application/yaml",
+    "application/x-yaml",
+    "application/javascript",
+    "application/typescript",
+    "application/x-sh",
+    "application/sql",
+    "application/csv",
+    "application/vnd.ms-excel",
+]);
+export function cleanAttachmentText(text, maxChars) {
+    const cleaned = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\u0000/g, "").trim();
+    if (cleaned.length <= maxChars) {
+        return cleaned;
+    }
+    return `${cleaned.slice(0, maxChars).trimEnd()}\n${l("... (omitted because it is long)", "...（長いため省略）")}`;
+}
+export function indentAttachmentContent(text) {
+    return text
+        .split("\n")
+        .map((line) => `   ${line}`)
+        .join("\n");
+}
+export function formatBytes(value) {
+    if (!Number.isFinite(value) || value < 0) {
+        return "";
+    }
+    if (value < 1024) {
+        return `${value} B`;
+    }
+    const kb = value / 1024;
+    if (kb < 1024) {
+        return `${kb.toFixed(kb >= 10 ? 0 : 1)} KB`;
+    }
+    const mb = kb / 1024;
+    return `${mb.toFixed(mb >= 10 ? 0 : 1)} MB`;
+}
+export function isTextLikeFile(contentType, filename) {
+    const normalizedType = (contentType || "").toLowerCase().split(";")[0].trim();
+    if (normalizedType.startsWith("text/")) {
+        return true;
+    }
+    if (TEXT_CONTENT_TYPES.has(normalizedType)) {
+        return true;
+    }
+    return TEXT_EXT_PATTERN.test((filename || "").toLowerCase());
+}
+export function isImageLikeFile(contentType, filename) {
+    const normalizedType = (contentType || "").toLowerCase().split(";")[0].trim();
+    if (normalizedType.startsWith("image/")) {
+        return true;
+    }
+    return IMAGE_EXT_PATTERN.test((filename || "").toLowerCase());
+}
+export function guessImageMimeType(filename) {
+    const normalized = (filename || "").toLowerCase();
+    if (normalized.endsWith(".jpg") || normalized.endsWith(".jpeg"))
+        return "image/jpeg";
+    if (normalized.endsWith(".gif"))
+        return "image/gif";
+    if (normalized.endsWith(".webp"))
+        return "image/webp";
+    if (normalized.endsWith(".bmp"))
+        return "image/bmp";
+    if (normalized.endsWith(".heic"))
+        return "image/heic";
+    if (normalized.endsWith(".heif"))
+        return "image/heif";
+    return "image/png";
+}
+export function formatAttachmentLabel(input) {
+    const name = cleanAttachmentText(input.name || input.fallback, 200);
+    const meta = [
+        input.contentType ? cleanAttachmentText(input.contentType, 120) : "",
+        typeof input.size === "number" ? formatBytes(input.size) : "",
+    ].filter(Boolean);
+    return meta.length > 0 ? `${name} (${meta.join(", ")})` : name;
+}
+export function chunkText(text, max) {
+    if (text.length <= max) {
+        return [text];
+    }
+    const chunks = [];
+    let remaining = text;
+    while (remaining.length > 0) {
+        if (remaining.length <= max) {
+            chunks.push(remaining);
+            break;
+        }
+        let cut = remaining.lastIndexOf("\n", max);
+        if (cut < Math.floor(max / 2)) {
+            cut = max;
+        }
+        chunks.push(remaining.slice(0, cut).trimEnd());
+        remaining = remaining.slice(cut).replace(/^\s+/, "");
+    }
+    return chunks;
+}

package/dist/core/notifier.d.ts

@@ -0,0 +1,17 @@
+export type NotifyChannel = "macos" | "windows" | "discord" | "telegram" | "slack" | "mail" | "stderr";
+export interface NotifyOptions {
+    title: string;
+    body: string;
+    subtitle?: string;
+    sound?: boolean;
+    channel?: NotifyChannel | "auto";
+    to?: string;
+    discordThreadId?: string;
+    telegramThreadId?: string;
+}
+export interface NotifyResult {
+    channel: NotifyChannel;
+    ok: boolean;
+    detail?: string;
+}
+export declare function notify(options: NotifyOptions): Promise<NotifyResult>;

package/dist/core/notifier.js

@@ -0,0 +1,424 @@
+import { spawn } from "node:child_process";
+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 subtitle = options.subtitle ? sanitize(options.subtitle) : undefined;
+    if (!title && !body) {
+        throw new Error(l("notify: title or body is required", "notify: title または body が必要です"));
+    }
+    const requested = options.channel || "auto";
+    const channel = requested === "auto" ? resolveAutoChannel() : requested;
+    if (process.env.AGENT_SIN_NOTIFY_BACKEND === "stderr") {
+        return notifyStderr(title, body, subtitle);
+    }
+    switch (channel) {
+        case "macos":
+            return notifyMacOs(title, body, subtitle, Boolean(options.sound));
+        case "windows":
+            return notifyWindows(title, body, subtitle);
+        case "discord":
+            return notifyDiscord(title, body, subtitle, options.discordThreadId);
+        case "telegram":
+            return notifyTelegram(title, body, subtitle, options.telegramThreadId);
+        case "slack":
+            return notifySlack(title, body, subtitle);
+        case "mail":
+            return notifyMail(title, body, subtitle, options.to);
+        case "stderr":
+            return notifyStderr(title, body, subtitle);
+        default:
+            return notifyStderr(title, body, subtitle);
+    }
+}
+function resolveAutoChannel() {
+    if (process.env.AGENT_SIN_NOTIFY_BACKEND === "stderr") {
+        return "stderr";
+    }
+    if (process.env.AGENT_SIN_DISCORD_WEBHOOK_URL || hasDiscordBotNotifyConfig()) {
+        return "discord";
+    }
+    if (hasTelegramNotifyConfig()) {
+        return "telegram";
+    }
+    if (process.env.AGENT_SIN_SLACK_WEBHOOK_URL) {
+        return "slack";
+    }
+    if (process.env.AGENT_SIN_SMTP_HOST && process.env.AGENT_SIN_MAIL_TO) {
+        return "mail";
+    }
+    if (process.platform === "darwin") {
+        return "macos";
+    }
+    if (process.platform === "win32") {
+        return "windows";
+    }
+    return "stderr";
+}
+function sanitize(value) {
+    return value.replace(/\r/g, "").slice(0, 4000);
+}
+function escapeAppleScript(value) {
+    return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+function notifyMacOs(title, body, subtitle, withSound) {
+    const parts = [
+        `display notification "${escapeAppleScript(body)}"`,
+        `with title "${escapeAppleScript(title)}"`,
+    ];
+    if (subtitle) {
+        parts.push(`subtitle "${escapeAppleScript(subtitle)}"`);
+    }
+    if (withSound) {
+        parts.push('sound name "Glass"');
+    }
+    return runChild("osascript", ["-e", parts.join(" ")], "macos");
+}
+function escapePowerShell(value) {
+    // Single-quoted PowerShell strings: doubled single quote escapes a literal '.
+    return value.replace(/'/g, "''");
+}
+async function notifyWindows(title, body, subtitle) {
+    const head = subtitle ? `${title} - ${subtitle}` : title;
+    // Windows 10/11 toast via Windows Runtime APIs in PowerShell.
+    // Falls back to stderr if PowerShell or WinRT is unavailable.
+    const script = [
+        "$ErrorActionPreference = 'Stop';",
+        "[void][Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType=WindowsRuntime];",
+        "[void][Windows.Data.Xml.Dom.XmlDocument, Windows.Data.Xml.Dom.XmlDocument, ContentType=WindowsRuntime];",
+        `$title = '${escapePowerShell(head)}';`,
+        `$body = '${escapePowerShell(body)}';`,
+        "$template = [Windows.UI.Notifications.ToastNotificationManager]::GetTemplateContent([Windows.UI.Notifications.ToastTemplateType]::ToastText02);",
+        "$nodes = $template.GetElementsByTagName('text');",
+        "$nodes.Item(0).AppendChild($template.CreateTextNode($title)) | Out-Null;",
+        "$nodes.Item(1).AppendChild($template.CreateTextNode($body)) | Out-Null;",
+        "$toast = [Windows.UI.Notifications.ToastNotification]::new($template);",
+        "[Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier('Agent-Sin').Show($toast);",
+    ].join(" ");
+    const result = await runChild("powershell.exe", ["-NoLogo", "-NoProfile", "-NonInteractive", "-Command", script], "windows");
+    if (result.ok)
+        return result;
+    // 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) {
+    const url = process.env.AGENT_SIN_DISCORD_WEBHOOK_URL;
+    const content = formatPlainTextMessage(title, body, subtitle);
+    const chunks = splitMessage(content, DISCORD_MESSAGE_LIMIT);
+    const rawThreadId = discordNotifyThreadId(threadIdOverride);
+    const threadId = normalizeDiscordSnowflake(rawThreadId);
+    if (rawThreadId && !threadId) {
+        return { channel: "discord", ok: false, detail: `invalid Discord thread id: ${rawThreadId}` };
+    }
+    if (url) {
+        const webhookUrl = discordWebhookUrl(url, threadId);
+        return postDiscordChunks(chunks, (chunk) => postWebhook(webhookUrl, { content: chunk }, "discord"));
+    }
+    const token = process.env.AGENT_SIN_DISCORD_BOT_TOKEN;
+    const targetId = threadId || discordNotifyChannelId();
+    if (token && targetId) {
+        return postDiscordChunks(chunks, (chunk) => postDiscordBotMessage(token, targetId, chunk));
+    }
+    return {
+        channel: "discord",
+        ok: false,
+        detail: "Discord notification config is not set",
+    };
+}
+async function notifySlack(title, body, subtitle) {
+    const url = process.env.AGENT_SIN_SLACK_WEBHOOK_URL;
+    if (!url) {
+        return { channel: "slack", ok: false, detail: "AGENT_SIN_SLACK_WEBHOOK_URL is not set" };
+    }
+    const text = formatPlainTextMessage(title, body, subtitle);
+    return postWebhook(url, { text }, "slack");
+}
+async function notifyTelegram(title, body, subtitle, threadIdOverride) {
+    const token = process.env.AGENT_SIN_TELEGRAM_BOT_TOKEN;
+    const chatId = telegramNotifyChatId();
+    if (!token) {
+        return { channel: "telegram", ok: false, detail: "AGENT_SIN_TELEGRAM_BOT_TOKEN is not set" };
+    }
+    if (!chatId) {
+        return { channel: "telegram", ok: false, detail: "Telegram chat id is not set" };
+    }
+    const rawThreadId = telegramNotifyThreadId(threadIdOverride);
+    const threadId = normalizeTelegramInteger(rawThreadId);
+    if (rawThreadId && !threadId) {
+        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));
+}
+async function notifyMail(title, body, subtitle, toOverride) {
+    const host = process.env.AGENT_SIN_SMTP_HOST;
+    const portRaw = process.env.AGENT_SIN_SMTP_PORT || "587";
+    const user = process.env.AGENT_SIN_SMTP_USER;
+    const pass = process.env.AGENT_SIN_SMTP_PASS;
+    const from = process.env.AGENT_SIN_MAIL_FROM || user;
+    const to = toOverride || process.env.AGENT_SIN_MAIL_TO;
+    const secure = (process.env.AGENT_SIN_SMTP_SECURE || "").toLowerCase() === "true";
+    if (!host) {
+        return { channel: "mail", ok: false, detail: "AGENT_SIN_SMTP_HOST is not set" };
+    }
+    if (!from) {
+        return { channel: "mail", ok: false, detail: "AGENT_SIN_MAIL_FROM (or AGENT_SIN_SMTP_USER) is not set" };
+    }
+    if (!to) {
+        return { channel: "mail", ok: false, detail: "mail recipient is not set (--to or AGENT_SIN_MAIL_TO)" };
+    }
+    const port = Number.parseInt(portRaw, 10);
+    if (!Number.isFinite(port) || port <= 0) {
+        return { channel: "mail", ok: false, detail: `invalid AGENT_SIN_SMTP_PORT: ${portRaw}` };
+    }
+    let createTransport;
+    try {
+        ({ createTransport } = await import("nodemailer"));
+    }
+    catch (error) {
+        return {
+            channel: "mail",
+            ok: false,
+            detail: `nodemailer not available: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+    const transporter = createTransport({
+        host,
+        port,
+        secure,
+        auth: user && pass ? { user, pass } : undefined,
+    });
+    const subject = subtitle ? `${title} - ${subtitle}` : title;
+    try {
+        const info = await transporter.sendMail({
+            from,
+            to,
+            subject,
+            text: body,
+        });
+        return { channel: "mail", ok: true, detail: info.messageId };
+    }
+    catch (error) {
+        return {
+            channel: "mail",
+            ok: false,
+            detail: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+function notifyStderr(title, body, subtitle) {
+    const head = subtitle ? `${title} - ${subtitle}` : title;
+    process.stderr.write(`[notify] ${head}: ${body}\n`);
+    return { channel: "stderr", ok: true };
+}
+function formatPlainTextMessage(title, body, subtitle) {
+    const head = subtitle ? `*${title}* — ${subtitle}` : `*${title}*`;
+    return body ? `${head}\n${body}` : head;
+}
+function hasDiscordBotNotifyConfig() {
+    return Boolean(process.env.AGENT_SIN_DISCORD_BOT_TOKEN && (discordNotifyThreadId() || discordNotifyChannelId()));
+}
+function hasTelegramNotifyConfig() {
+    return Boolean(process.env.AGENT_SIN_TELEGRAM_BOT_TOKEN && telegramNotifyChatId());
+}
+function discordNotifyChannelId() {
+    return (firstListValue(process.env.AGENT_SIN_DISCORD_NOTIFY_CHANNEL_ID) ||
+        firstListValue(process.env.AGENT_SIN_DISCORD_CHANNEL_ID) ||
+        firstListValue(process.env.AGENT_SIN_DISCORD_LISTEN_CHANNEL_IDS));
+}
+function discordNotifyThreadId(override) {
+    return (firstListValue(override) ||
+        firstListValue(process.env.AGENT_SIN_DISCORD_NOTIFY_THREAD_ID) ||
+        firstListValue(process.env.AGENT_SIN_DISCORD_THREAD_ID));
+}
+function telegramNotifyChatId() {
+    return (firstListValue(process.env.AGENT_SIN_TELEGRAM_NOTIFY_CHAT_ID) ||
+        firstListValue(process.env.AGENT_SIN_TELEGRAM_CHAT_ID) ||
+        firstListValue(process.env.AGENT_SIN_TELEGRAM_LISTEN_CHAT_IDS));
+}
+function telegramNotifyThreadId(override) {
+    return (firstListValue(override) ||
+        firstListValue(process.env.AGENT_SIN_TELEGRAM_NOTIFY_THREAD_ID) ||
+        firstListValue(process.env.AGENT_SIN_TELEGRAM_THREAD_ID));
+}
+function firstListValue(value) {
+    return (value || "")
+        .split(/[,\s]+/)
+        .map((item) => item.trim())
+        .find(Boolean) || "";
+}
+function normalizeDiscordSnowflake(value) {
+    const trimmed = value.trim();
+    return /^\d+$/.test(trimmed) ? trimmed : "";
+}
+function normalizeTelegramInteger(value) {
+    const trimmed = value.trim();
+    return /^-?\d+$/.test(trimmed) ? trimmed : "";
+}
+function discordWebhookUrl(url, threadId) {
+    if (!threadId) {
+        return url;
+    }
+    try {
+        const parsed = new URL(url);
+        parsed.searchParams.set("thread_id", threadId);
+        return parsed.toString();
+    }
+    catch {
+        const separator = url.includes("?") ? "&" : "?";
+        return `${url}${separator}thread_id=${encodeURIComponent(threadId)}`;
+    }
+}
+function splitMessage(text, maxLength) {
+    const trimmed = text.trim();
+    if (!trimmed)
+        return [""];
+    if (trimmed.length <= maxLength)
+        return [trimmed];
+    const chunks = [];
+    let current = "";
+    for (const line of trimmed.split(/\r?\n/)) {
+        if (current && current.length + line.length + 1 > maxLength) {
+            chunks.push(current);
+            current = "";
+        }
+        if (line.length > maxLength) {
+            for (let index = 0; index < line.length; index += maxLength) {
+                const piece = line.slice(index, index + maxLength);
+                if (current) {
+                    chunks.push(current);
+                    current = "";
+                }
+                chunks.push(piece);
+            }
+            continue;
+        }
+        current = current ? `${current}\n${line}` : line;
+    }
+    if (current)
+        chunks.push(current);
+    return chunks;
+}
+async function postDiscordChunks(chunks, send) {
+    let sent = 0;
+    for (const chunk of chunks) {
+        const result = await send(chunk);
+        if (!result.ok) {
+            return sent > 0
+                ? { channel: "discord", ok: false, detail: `sent ${sent}/${chunks.length}: ${result.detail || "failed"}` }
+                : result;
+        }
+        sent += 1;
+    }
+    return { channel: "discord", ok: true, detail: chunks.length > 1 ? `${chunks.length} messages` : undefined };
+}
+async function postDiscordBotMessage(token, channelId, content) {
+    try {
+        const response = await fetch(`${DISCORD_API_BASE}/channels/${channelId}/messages`, {
+            method: "POST",
+            headers: {
+                authorization: `Bot ${token}`,
+                "content-type": "application/json",
+            },
+            body: JSON.stringify({ content }),
+        });
+        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) {
+        const result = await send(chunk);
+        if (!result.ok) {
+            return sent > 0
+                ? { channel: "telegram", ok: false, detail: `sent ${sent}/${chunks.length}: ${result.detail || "failed"}` }
+                : result;
+        }
+        sent += 1;
+    }
+    return { channel: "telegram", ok: true, detail: chunks.length > 1 ? `${chunks.length} messages` : undefined };
+}
+async function postTelegramBotMessage(token, chatId, text, threadId) {
+    try {
+        const payload = {
+            chat_id: chatId,
+            text,
+            disable_web_page_preview: true,
+        };
+        if (threadId) {
+            payload.message_thread_id = Number.parseInt(threadId, 10);
+        }
+        const response = await fetch(`${TELEGRAM_API_BASE}/bot${token}/sendMessage`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(payload),
+        });
+        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),
+        };
+    }
+}
+async function postWebhook(url, payload, channel) {
+    try {
+        const response = await fetch(url, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(payload),
+        });
+        if (!response.ok) {
+            const detail = `HTTP ${response.status} ${response.statusText}`.trim();
+            return { channel, ok: false, detail };
+        }
+        return { channel, ok: true };
+    }
+    catch (error) {
+        return {
+            channel,
+            ok: false,
+            detail: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+function runChild(bin, args, channel) {
+    return new Promise((resolve) => {
+        const child = spawn(bin, args, { stdio: ["ignore", "pipe", "pipe"] });
+        const stderr = [];
+        child.stderr.on("data", (chunk) => stderr.push(chunk));
+        child.on("error", (error) => {
+            resolve({ channel, ok: false, detail: error.message });
+        });
+        child.on("close", (code) => {
+            if (code === 0) {
+                resolve({ channel, ok: true });
+                return;
+            }
+            const detail = Buffer.concat(stderr).toString("utf8").trim() || `exit ${code}`;
+            resolve({ channel, ok: false, detail });
+        });
+    });
+}

package/dist/core/output-writer.d.ts

@@ -0,0 +1,13 @@
+import type { AppConfig } from "./config.js";
+import type { SkillManifest, SkillOutputDefinition } from "./skill-registry.js";
+import type { SkillResult } from "../skills-sdk/types.js";
+export interface SavedOutput {
+    id: string;
+    type: string;
+    path: string;
+    append: boolean;
+    show_saved: boolean;
+}
+export declare function writeSkillOutputs(config: AppConfig, manifest: SkillManifest, result: SkillResult, date?: Date): Promise<SavedOutput[]>;
+export declare function resolveOutputFile(config: AppConfig, output: SkillOutputDefinition, date: Date): string;
+export declare function renderTemplate(template: string, date: Date): string;