@nordbyte/nordrelay 0.6.0 → 0.8.0

package/dist/remote-prompt.js

@@ -0,0 +1,98 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+export async function peerPromptProxyPayload(prompt) {
+    if (typeof prompt.input === "string") {
+        return {
+            method: "POST",
+            path: "/api/prompt",
+            body: { text: prompt.input },
+        };
+    }
+    const files = await remoteUploadFiles(prompt);
+    if (files.length > 0) {
+        return {
+            method: "POST",
+            path: "/api/prompt/upload",
+            body: {
+                text: prompt.input.text ?? "",
+                files,
+            },
+        };
+    }
+    return {
+        method: "POST",
+        path: "/api/prompt",
+        body: { text: prompt.input.text || prompt.description },
+    };
+}
+async function remoteUploadFiles(prompt) {
+    if (typeof prompt.input === "string") {
+        return [];
+    }
+    const candidates = new Map();
+    for (const imagePath of prompt.input.imagePaths ?? []) {
+        candidates.set(imagePath, {
+            name: path.basename(imagePath),
+            mimeType: mimeTypeFromPath(imagePath),
+            localPath: imagePath,
+        });
+    }
+    for (const file of parseStagedFileInstructions(prompt.input.stagedFileInstructions)) {
+        candidates.set(file.localPath, file);
+    }
+    const files = [];
+    for (const file of candidates.values()) {
+        const data = await readFile(file.localPath);
+        files.push({
+            name: file.name,
+            mimeType: file.mimeType,
+            dataBase64: data.toString("base64"),
+        });
+    }
+    return files;
+}
+function parseStagedFileInstructions(text) {
+    if (!text) {
+        return [];
+    }
+    const files = [];
+    for (const line of text.split(/\r?\n/)) {
+        const match = line.match(/^- (.+?) \(([^,]+), [^)]+\) → (.+)$/);
+        if (!match)
+            continue;
+        files.push({
+            name: match[1] || path.basename(match[3] ?? "upload"),
+            mimeType: match[2],
+            localPath: match[3] ?? "",
+        });
+    }
+    return files.filter((file) => file.localPath);
+}
+function mimeTypeFromPath(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (ext === ".jpg" || ext === ".jpeg")
+        return "image/jpeg";
+    if (ext === ".png")
+        return "image/png";
+    if (ext === ".gif")
+        return "image/gif";
+    if (ext === ".webp")
+        return "image/webp";
+    if (ext === ".pdf")
+        return "application/pdf";
+    if (ext === ".txt" || ext === ".md" || ext === ".log")
+        return "text/plain";
+    if (ext === ".json")
+        return "application/json";
+    if (ext === ".csv")
+        return "text/csv";
+    if (ext === ".mp3")
+        return "audio/mpeg";
+    if (ext === ".wav")
+        return "audio/wav";
+    if (ext === ".ogg")
+        return "audio/ogg";
+    if (ext === ".webm")
+        return "audio/webm";
+    return undefined;
+}

package/dist/settings-wizard-test.js

@@ -0,0 +1,216 @@
+export async function runSettingsWizardTest(channel, settings) {
+    const parsedChannel = parseSettingsWizardChannel(channel);
+    const checks = parsedChannel === "telegram"
+        ? await testTelegram(settings)
+        : parsedChannel === "discord"
+            ? await testDiscord(settings)
+            : await testSlack(settings);
+    return { channel: parsedChannel, checkedAt: new Date().toISOString(), checks };
+}
+export function mergeSettingsWizardTestSettings(activeSettings, submittedSettings) {
+    const merged = {};
+    for (const [key, value] of Object.entries(activeSettings)) {
+        if (value !== undefined) {
+            merged[key] = value;
+        }
+    }
+    for (const [key, value] of Object.entries(submittedSettings)) {
+        if (typeof value !== "string" || isMaskedSecret(value)) {
+            continue;
+        }
+        merged[key] = value;
+    }
+    return merged;
+}
+function parseSettingsWizardChannel(value) {
+    if (value === "telegram" || value === "discord" || value === "slack") {
+        return value;
+    }
+    throw new Error("Invalid settings wizard channel.");
+}
+async function testTelegram(settings) {
+    const token = settings.TELEGRAM_BOT_TOKEN ?? "";
+    const transport = settings.TELEGRAM_TRANSPORT || "polling";
+    const checks = [
+        tokenCheck("Telegram bot token", token, /^[0-9]{5,}:[A-Za-z0-9_-]{20,}$/),
+        {
+            label: "Telegram transport",
+            status: transport === "polling" || transport === "webhook" ? "ok" : "error",
+            detail: transport === "webhook" ? "Webhook mode selected." : "Polling mode selected.",
+        },
+    ];
+    if (transport === "webhook") {
+        checks.push({
+            label: "Webhook public URL",
+            status: /^https:\/\//.test(settings.TELEGRAM_WEBHOOK_URL ?? "") ? "ok" : "error",
+            detail: settings.TELEGRAM_WEBHOOK_URL ? "HTTPS URL configured." : "Webhook mode requires a public HTTPS URL.",
+        }, {
+            label: "Webhook bind endpoint",
+            status: settings.TELEGRAM_WEBHOOK_HOST && Number.isFinite(Number(settings.TELEGRAM_WEBHOOK_PORT)) && String(settings.TELEGRAM_WEBHOOK_PATH ?? "").startsWith("/") ? "ok" : "error",
+            detail: "Host, port, and path must describe the local webhook listener.",
+        });
+    }
+    if (isUsableSecret(token, /^[0-9]{5,}:[A-Za-z0-9_-]{20,}$/)) {
+        checks.push(await fetchTelegramIdentity(token));
+    }
+    return checks;
+}
+async function testDiscord(settings) {
+    const token = settings.DISCORD_BOT_TOKEN ?? "";
+    const clientId = settings.DISCORD_CLIENT_ID ?? "";
+    const commandMode = settings.DISCORD_COMMAND_MODE || "both";
+    const checks = [
+        tokenCheck("Discord bot token", token, /^.{20,}$/),
+        {
+            label: "Discord client ID",
+            status: isSnowflake(clientId) ? "ok" : "error",
+            detail: isSnowflake(clientId) ? "Application ID looks valid." : "Copy Application ID from Discord Developer Portal > General Information.",
+        },
+        listCheck("Discord guild IDs", settings.DISCORD_GUILD_IDS, isSnowflake),
+        listCheck("Allowed Discord guilds", settings.DISCORD_ALLOWED_GUILD_IDS, isSnowflake),
+        listCheck("Allowed Discord channels", settings.DISCORD_ALLOWED_CHANNEL_IDS, isSnowflake),
+        {
+            label: "Discord command mode",
+            status: commandMode === "slash" || commandMode === "message" || commandMode === "both" ? "ok" : "error",
+            detail: "Supported values are slash, message, or both.",
+        },
+    ];
+    if ((commandMode === "message" || commandMode === "both") && !truthy(settings.DISCORD_MESSAGE_CONTENT_ENABLED)) {
+        checks.push({
+            label: "Message Content Intent",
+            status: "warn",
+            detail: "Message command mode needs Message Content Intent enabled in the Discord Developer Portal.",
+        });
+    }
+    if (isUsableSecret(token, /^.{20,}$/)) {
+        checks.push(await fetchDiscordIdentity(token));
+    }
+    return checks;
+}
+async function testSlack(settings) {
+    const botToken = settings.SLACK_BOT_TOKEN ?? "";
+    const appToken = settings.SLACK_APP_TOKEN ?? "";
+    const socketMode = truthy(settings.SLACK_SOCKET_MODE);
+    const checks = [
+        tokenCheck("Slack bot token", botToken, /^xoxb-/),
+        {
+            label: "Slack command",
+            status: !settings.SLACK_COMMAND || settings.SLACK_COMMAND.startsWith("/") ? "ok" : "error",
+            detail: settings.SLACK_COMMAND || "/nordrelay",
+        },
+        listCheck("Allowed Slack teams", settings.SLACK_ALLOWED_TEAM_IDS, isSlackId),
+        listCheck("Allowed Slack channels", settings.SLACK_ALLOWED_CHANNEL_IDS, isSlackId),
+    ];
+    if (socketMode) {
+        checks.push(tokenCheck("Slack app token", appToken, /^xapp-/));
+    }
+    else {
+        checks.push({
+            label: "Slack signing secret",
+            status: settings.SLACK_SIGNING_SECRET ? "ok" : "error",
+            detail: settings.SLACK_SIGNING_SECRET ? "Signing secret configured." : "HTTP Events mode requires the Slack signing secret.",
+        }, {
+            label: "Slack HTTP port",
+            status: Number.isFinite(Number(settings.SLACK_PORT)) ? "ok" : "error",
+            detail: settings.SLACK_PORT || "Not configured.",
+        });
+    }
+    if (isUsableSecret(botToken, /^xoxb-/)) {
+        checks.push(await fetchSlackIdentity(botToken));
+    }
+    return checks;
+}
+function tokenCheck(label, value, pattern) {
+    if (!value) {
+        return { label, status: "error", detail: "Required value is missing." };
+    }
+    if (isMaskedSecret(value)) {
+        return { label, status: "warn", detail: "Secret is already configured. Paste the real value to run a live API test." };
+    }
+    return pattern.test(value)
+        ? { label, status: "ok", detail: "Format looks valid." }
+        : { label, status: "error", detail: "Value does not match the expected format." };
+}
+function listCheck(label, value, predicate) {
+    const items = parseList(value);
+    const invalid = items.filter((item) => !predicate(item));
+    if (invalid.length > 0) {
+        return { label, status: "error", detail: `Invalid values: ${invalid.join(", ")}` };
+    }
+    return { label, status: "ok", detail: items.length ? `${items.length} value(s) configured.` : "No allow-list configured." };
+}
+async function fetchTelegramIdentity(token) {
+    try {
+        const data = await fetchJson(`https://api.telegram.org/bot${token}/getMe`);
+        if (data.ok === true) {
+            const result = data.result;
+            return { label: "Telegram API", status: "ok", detail: `Bot reachable: ${result?.username ?? result?.first_name ?? "configured bot"}.` };
+        }
+        return { label: "Telegram API", status: "error", detail: String(data.description ?? "Telegram rejected the token.") };
+    }
+    catch (error) {
+        return { label: "Telegram API", status: "warn", detail: `Live check failed: ${errorText(error)}` };
+    }
+}
+async function fetchDiscordIdentity(token) {
+    try {
+        const data = await fetchJson("https://discord.com/api/v10/users/@me", {
+            headers: { authorization: `Bot ${token}` },
+        });
+        if (typeof data.id === "string") {
+            return { label: "Discord API", status: "ok", detail: `Bot reachable: ${data.username ?? data.id}.` };
+        }
+        return { label: "Discord API", status: "error", detail: String(data.message ?? "Discord rejected the bot token.") };
+    }
+    catch (error) {
+        return { label: "Discord API", status: "warn", detail: `Live check failed: ${errorText(error)}` };
+    }
+}
+async function fetchSlackIdentity(token) {
+    try {
+        const data = await fetchJson("https://slack.com/api/auth.test", {
+            headers: { authorization: `Bearer ${token}` },
+        });
+        if (data.ok === true) {
+            return { label: "Slack API", status: "ok", detail: `Bot reachable in ${data.team ?? "workspace"} as ${data.user ?? data.bot_id ?? "bot"}.` };
+        }
+        return { label: "Slack API", status: "error", detail: String(data.error ?? "Slack rejected the bot token.") };
+    }
+    catch (error) {
+        return { label: "Slack API", status: "warn", detail: `Live check failed: ${errorText(error)}` };
+    }
+}
+async function fetchJson(url, init = {}) {
+    const response = await fetch(url, {
+        ...init,
+        signal: AbortSignal.timeout(5_000),
+    });
+    const text = await response.text();
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return { ok: response.ok, status: response.status, description: text.slice(0, 200) };
+    }
+}
+function isUsableSecret(value, pattern) {
+    return Boolean(value) && !isMaskedSecret(value) && pattern.test(value);
+}
+function isMaskedSecret(value) {
+    return /^\*+$/.test(value) || value.includes("...");
+}
+function parseList(value) {
+    return String(value ?? "").split(",").map((item) => item.trim()).filter(Boolean);
+}
+function isSnowflake(value) {
+    return /^[0-9]{5,32}$/.test(value);
+}
+function isSlackId(value) {
+    return /^[A-Z0-9]{2,64}$/.test(value);
+}
+function truthy(value) {
+    return ["true", "1", "yes", "on"].includes(String(value ?? "").toLowerCase());
+}
+function errorText(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/slack-artifacts.js

@@ -0,0 +1,165 @@
+import { collectRecentWorkspaceArtifacts, createArtifactZipBundle, formatArtifactSummary, listRecentArtifactReports } from "./artifacts.js";
+import { filterArtifactReports as filterArtifactReportsForCommand } from "./bot-rendering.js";
+import { renderArtifactReportsAction } from "./channel-actions.js";
+import { deliverChannelAction } from "./channel-runtime.js";
+export function createSlackArtifactCommandHandler(deps) {
+    return async (request, argument) => {
+        const session = await deps.getSession(request, { deferThreadStart: true });
+        const [action, turnId] = argument.trim().split(/\s+/, 2);
+        const info = session.getInfo();
+        const workspace = info.workspace;
+        const reports = await listRecentArtifactReports(workspace, 10, deps.config.maxFileSize);
+        if (reports.length === 0) {
+            await deps.reply(request, "No generated artifacts found for this workspace.");
+            return;
+        }
+        if (action) {
+            if (action.toLowerCase() === "delete" && turnId) {
+                const selected = findArtifactReport(reports, turnId);
+                if (!selected) {
+                    await deps.reply(request, `No artifact turn found for "${turnId}".`);
+                    return;
+                }
+                const removed = await deps.artifactService.delete(workspace, selected.turnId);
+                deps.appendActivity(request, {
+                    status: removed ? "info" : "failed",
+                    type: "artifact_deleted",
+                    threadId: info.threadId,
+                    workspace,
+                    agentId: info.agentId,
+                    detail: selected.turnId,
+                });
+                await deps.reply(request, removed ? `Deleted artifact turn: ${selected.turnId}` : `Artifact turn not found: ${selected.turnId}`);
+                return;
+            }
+            const filtered = filterArtifactReportsForCommand(reports, argument);
+            if (filtered) {
+                if (filtered.length === 0) {
+                    await deps.reply(request, `No artifacts matched "${argument}".`);
+                    return;
+                }
+                await deliverChannelAction(deps.runtime, request.context, renderSlackArtifactReports(request.contextKey, filtered));
+                return;
+            }
+            const normalizedAction = action.toLowerCase();
+            const shouldZip = normalizedAction === "zip";
+            const shouldSend = normalizedAction === "send";
+            const selected = findArtifactReport(reports, shouldZip || shouldSend ? turnId : action);
+            if (!selected) {
+                await deps.reply(request, `No artifact turn found for "${argument}".`);
+                return;
+            }
+            deps.appendActivity(request, {
+                status: "info",
+                type: shouldZip ? "artifact_zip_sent" : "artifacts_sent",
+                threadId: info.threadId,
+                workspace,
+                agentId: info.agentId,
+                detail: selected.turnId,
+            });
+            if (shouldZip) {
+                await deliverSlackArtifactZip(deps, request, selected);
+            }
+            else {
+                await deliverSlackArtifactReport(deps, request, selected);
+            }
+            return;
+        }
+        await deliverChannelAction(deps.runtime, request.context, renderSlackArtifactReports(request.contextKey, reports));
+    };
+}
+export async function sendRecentSlackArtifacts(deps, request, session, since, turnId) {
+    const report = await collectRecentWorkspaceArtifacts(session.getInfo().workspace, {
+        since,
+        until: new Date(),
+        maxFileSize: deps.config.maxFileSize,
+        limit: 5,
+    });
+    if (report.artifacts.length === 0) {
+        return;
+    }
+    await deps.reply(request, `${report.artifacts.length} artifacts generated.`);
+    for (const artifact of report.artifacts.slice(0, 5)) {
+        await sendSlackArtifactFile(deps, request, artifact);
+    }
+    deps.appendActivity(request, {
+        status: "info",
+        type: "artifacts_sent",
+        detail: `${report.artifacts.length} artifacts for ${turnId}`,
+        threadId: session.getInfo().threadId,
+        workspace: session.getInfo().workspace,
+        agentId: session.getInfo().agentId,
+    });
+}
+function renderSlackArtifactReports(contextKey, reports) {
+    const rendered = renderArtifactReportsAction(reports);
+    return {
+        ...rendered,
+        buttons: reports.slice(0, 5).map((report, index) => [
+            { label: `${index + 1} Send`, action: `slack_artifact_send:${contextKey}:${report.turnId}` },
+            { label: `${index + 1} ZIP`, action: `slack_artifact_zip:${contextKey}:${report.turnId}` },
+            { label: `${index + 1} Delete`, action: `slack_artifact_delete:${contextKey}:${report.turnId}` },
+        ]),
+    };
+}
+function findArtifactReport(reports, requested) {
+    const value = requested?.trim();
+    if (!value || value.toLowerCase() === "latest") {
+        return reports[0];
+    }
+    return reports.find((report) => report.turnId === value || report.turnId.startsWith(value));
+}
+async function deliverSlackArtifactZip(deps, request, report) {
+    const bundle = await createArtifactZipBundle(report.artifacts, report.outDir, {
+        maxFileSize: deps.config.maxFileSize,
+        bundleName: `nordrelay-artifacts-${report.turnId}.zip`,
+    });
+    if (!bundle) {
+        await deps.reply(request, "Could not create a ZIP bundle for this artifact turn.");
+        return;
+    }
+    if (!deps.runtime.sendFile) {
+        await deps.reply(request, "This Slack runtime cannot send artifact files.");
+        return;
+    }
+    await deps.runtime.sendFile(request.context, { localPath: bundle.localPath, name: bundle.name });
+    await deps.reply(request, `Sent ZIP artifact bundle: ${bundle.name}`);
+}
+async function deliverSlackArtifactReport(deps, request, report) {
+    if (report.artifacts.length === 0 && report.skippedCount === 0 && !report.omittedCount) {
+        await deps.reply(request, "No generated artifacts found for this turn.");
+        return;
+    }
+    let failedCount = 0;
+    let bundledArtifact = null;
+    if (report.artifacts.length > 5) {
+        bundledArtifact = await createArtifactZipBundle(report.artifacts, report.outDir, {
+            maxFileSize: deps.config.maxFileSize,
+        });
+    }
+    const delivered = bundledArtifact ? [bundledArtifact] : report.artifacts;
+    for (const artifact of delivered) {
+        if (!await sendSlackArtifactFile(deps, request, artifact)) {
+            failedCount += 1;
+        }
+    }
+    const summary = formatArtifactSummary(report.artifacts, report.skippedCount + failedCount, report.omittedCount);
+    if (summary) {
+        const bundleNote = bundledArtifact ? `\nSent as ZIP: ${bundledArtifact.name}` : "";
+        await deps.reply(request, `${summary}${bundleNote}`);
+    }
+}
+async function sendSlackArtifactFile(deps, request, artifact) {
+    if (!deps.runtime.sendFile) {
+        await deps.reply(request, "This Slack runtime cannot send artifact files.");
+        return false;
+    }
+    try {
+        await deps.runtime.sendFile(request.context, { localPath: artifact.localPath, name: artifact.name });
+        return true;
+    }
+    catch (error) {
+        console.error(`Failed to send Slack artifact ${artifact.name}:`, error);
+        return false;
+    }
+}