@nordbyte/nordrelay 0.7.0 → 0.8.0

package/dist/peer-readiness.js

@@ -0,0 +1,77 @@
+import net from "node:net";
+export async function buildPeerReadiness(config) {
+    const listenUrl = peerListenUrl(config);
+    const localListening = await checkLocalPort(config.peerHost, config.peerPort);
+    const loopbackOnly = isLoopbackUrl(listenUrl);
+    const bindLoopbackOnly = isLoopbackHost(config.peerHost);
+    const warnings = [];
+    if (!config.peerEnabled) {
+        warnings.push("Peer server is disabled. Invites can be created, but pairing will fail until NORDRELAY_PEER_ENABLED=true and NordRelay is restarted.");
+    }
+    if (config.peerEnabled && !localListening) {
+        warnings.push(`Peer server is enabled, but no listener was detected on ${connectHostForBindHost(config.peerHost)}:${config.peerPort}.`);
+    }
+    if (loopbackOnly) {
+        warnings.push("Listen URL uses a loopback host. Other machines cannot reach this URL unless they run on the same host.");
+    }
+    if (bindLoopbackOnly && !loopbackOnly) {
+        warnings.push("Peer server is bound to loopback. Remote access requires a local tunnel, reverse proxy, or port forward to this host.");
+    }
+    if (!config.peerTlsEnabled && (!loopbackOnly || !bindLoopbackOnly)) {
+        warnings.push("Peer TLS is disabled. Use TLS for non-loopback or internet-reachable peer endpoints.");
+    }
+    return {
+        enabled: config.peerEnabled,
+        listenUrl,
+        bindHost: config.peerHost,
+        port: config.peerPort,
+        tlsEnabled: config.peerTlsEnabled,
+        requireTls: config.peerRequireTls,
+        localListening,
+        loopbackOnly,
+        bindLoopbackOnly,
+        manualCheckCommand: `nordrelay peer check ${listenUrl}`,
+        warnings,
+    };
+}
+export function peerListenUrl(config) {
+    if (config.peerPublicUrl)
+        return config.peerPublicUrl;
+    const scheme = config.peerTlsEnabled ? "https" : "http";
+    const host = config.peerHost === "0.0.0.0" || config.peerHost === "::" ? "127.0.0.1" : config.peerHost;
+    const displayHost = host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;
+    return `${scheme}://${displayHost}:${config.peerPort}`;
+}
+function checkLocalPort(host, port) {
+    return new Promise((resolve) => {
+        const socket = net.createConnection({ host: connectHostForBindHost(host), port });
+        const finish = (ok) => {
+            socket.removeAllListeners();
+            socket.destroy();
+            resolve(ok);
+        };
+        socket.setTimeout(1_500);
+        socket.once("connect", () => finish(true));
+        socket.once("timeout", () => finish(false));
+        socket.once("error", () => finish(false));
+    });
+}
+function connectHostForBindHost(host) {
+    if (!host || host === "0.0.0.0")
+        return "127.0.0.1";
+    if (host === "::")
+        return "::1";
+    return host;
+}
+function isLoopbackUrl(value) {
+    try {
+        return isLoopbackHost(new URL(value).hostname);
+    }
+    catch {
+        return false;
+    }
+}
+function isLoopbackHost(host) {
+    const normalized = host.replace(/^\[|\]$/g, "").toLowerCase();
+    return normalized === "localhost" || normalized === "::1" || normalized === "0:0:0:0:0:0:0:1" || normalized.startsWith("127.");
+}

package/dist/peer-runtime-service.js

@@ -6,6 +6,7 @@ import { permissionForWebRequest } from "./access-control.js";
 import { listChannelDescriptors } from "./channel-adapter.js";
 import { friendlyErrorText } from "./error-messages.js";
 import { getPackageVersion } from "./operations.js";
+import { checkPeerEndpoint } from "./peer-client.js";
 export class PeerRuntimeService {
     config;
     runtime;
@@ -26,6 +27,10 @@ export class PeerRuntimeService {
             this.assertScope(peer, "inspect");
             return { ok: true, status: "online", version: await getPackageVersion(), at: new Date().toISOString() };
         }
+        if (request.type === "peer.probe") {
+            this.assertScope(peer, "inspect");
+            return await this.handlePeerProbe(peer, request.payload);
+        }
         throw new Error(`Unsupported peer RPC type: ${request.type}`);
     }
     subscribe(peer, sourceContextKey, send) {
@@ -333,6 +338,16 @@ export class PeerRuntimeService {
             return runtime.restartConnector(remoteActor);
         throw new Error(`Remote endpoint is not implemented: ${method} ${path}`);
     }
+    async handlePeerProbe(peer, payload) {
+        const requestedUrl = stringValue(objectRecord(payload).url);
+        if (!peer.url) {
+            throw new Error("Remote probe refused because this peer has no registered URL. Pair with --public-url or set the peer URL first.");
+        }
+        if (requestedUrl && normalizePeerUrl(requestedUrl) !== normalizePeerUrl(peer.url)) {
+            throw new Error("Remote probe refused because the requested URL does not match this peer's registered URL.");
+        }
+        return await checkPeerEndpoint(peer.url, { expectedTlsFingerprint: peer.tlsFingerprint });
+    }
     assertScope(peer, permission) {
         if (!peer.scopes.includes(permission)) {
             throw new Error(`Peer permission denied: ${permission}`);
@@ -545,6 +560,13 @@ function normalizePath(value) {
     }
     return path;
 }
+function normalizePeerUrl(value) {
+    const url = new URL(value);
+    url.pathname = "";
+    url.search = "";
+    url.hash = "";
+    return url.toString().replace(/\/$/, "");
+}
 function objectRecord(value) {
     return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }

package/dist/peer-store.js

@@ -21,6 +21,7 @@ export class PeerStore {
             enabled: options.enabled,
             listenUrl: options.listenUrl,
             requireTls: options.requireTls,
+            readiness: options.readiness,
             peers: payload.peers.map(publicPeer),
             invitations: payload.invitations.map(publicInvitation),
         };
@@ -180,6 +181,18 @@ export class PeerStore {
         });
         return removed;
     }
+    deleteInvitation(id) {
+        let removed = null;
+        this.mutatePayload((payload) => {
+            const index = payload.invitations.findIndex((invitation) => invitation.id === id);
+            if (index < 0) {
+                return;
+            }
+            const [invitation] = payload.invitations.splice(index, 1);
+            removed = invitation;
+        });
+        return removed ? publicInvitation(removed) : null;
+    }
     patchPeer(id, patch) {
         this.mutatePayload((payload) => {
             const peer = payload.peers.find((candidate) => candidate.id === id || candidate.nodeId === id);

package/dist/relay-runtime-helpers.js

@@ -131,7 +131,9 @@ export function promptActivityToUnifiedJob(event) {
             ? "Telegram"
             : event.source === "discord"
                 ? "Discord"
-                : "CLI";
+                : event.source === "slack"
+                    ? "Slack"
+                    : "CLI";
     const promptKey = event.threadId ?? event.contextKey ?? event.id;
     return {
         id: `prompt:${event.source}:${promptKey}:${event.id}`,

package/dist/relay-runtime.js

@@ -29,6 +29,8 @@ import { activeSessionPriority, activityToUnifiedJob, agentUpdateStatusToUnified
 import { renderSessionInfoPlain, renderSessionUsageRows } from "./session-format.js";
 import { SessionLockStore } from "./session-locks.js";
 import { SessionRegistry } from "./session-registry.js";
+import { collectSlackDiagnostics } from "./slack-diagnostics.js";
+import { getSlackRateLimitMetrics } from "./slack-rate-limit.js";
 import { createSupportBundle } from "./support-bundle.js";
 import { transcribeAudio } from "./voice.js";
 import { WebActivityStore, WebChatStore, } from "./web-state.js";
@@ -330,6 +332,11 @@ export class RelayRuntime {
                     queuePaused: this.queueService.isPaused(),
                     externalMirror: this.externalActivityMonitor.snapshot(),
                     agentDiagnostics: getAgentDiagnostics(session, this.config),
+                    slackDiagnostics: await collectSlackDiagnostics({
+                        config: this.config,
+                        timeoutMs: 2_500,
+                        rateLimit: getSlackRateLimitMetrics(),
+                    }),
                 },
             };
         });

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;
+    }
+}