agent-relay 1.3.2 → 1.3.3

package/dist/dashboard-server/start.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+/**
+ * Standalone dashboard starter for local development
+ */
+export {};
+//# sourceMappingURL=start.d.ts.map

package/dist/dashboard-server/start.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+/**
+ * Standalone dashboard starter for local development
+ */
+import { startDashboard } from './server.js';
+import { getProjectPaths } from '../utils/project-namespace.js';
+const port = parseInt(process.env.DASHBOARD_PORT || '3888', 10);
+const paths = getProjectPaths();
+console.log(`Starting dashboard for project: ${paths.projectRoot}`);
+console.log(`Data dir: ${paths.dataDir}`);
+console.log(`Database: ${paths.dbPath}`);
+startDashboard(port, paths.dataDir, paths.teamDir, paths.dbPath).catch(console.error);
+//# sourceMappingURL=start.js.map

package/dist/dashboard-server/user-bridge.d.ts

@@ -0,0 +1,103 @@
+/**
+ * User Bridge - Bridges dashboard WebSocket users to the relay daemon.
+ *
+ * This module allows human users connected via WebSocket to:
+ * - Register as "user" entities in the relay daemon
+ * - Join/leave channels
+ * - Send/receive messages through the relay daemon
+ * - Communicate with agents and other users
+ */
+import type { WebSocket } from 'ws';
+/**
+ * Relay client interface (subset of RelayClient for dependency injection)
+ */
+export interface IRelayClient {
+    connect(): Promise<void>;
+    disconnect(): void;
+    state: string;
+    sendMessage(to: string, body: string, kind?: string, data?: unknown, thread?: string): boolean;
+    onMessage?: (from: string, payload: any, messageId: string, meta?: any, originalTo?: string) => void;
+}
+/**
+ * Factory function type for creating relay clients
+ */
+export type RelayClientFactory = (options: {
+    socketPath: string;
+    agentName: string;
+    entityType: 'user';
+    displayName?: string;
+    avatarUrl?: string;
+}) => Promise<IRelayClient>;
+/**
+ * Options for creating a UserBridge
+ */
+export interface UserBridgeOptions {
+    socketPath: string;
+    createRelayClient: RelayClientFactory;
+}
+/**
+ * Message options for sending
+ */
+export interface SendMessageOptions {
+    thread?: string;
+    data?: Record<string, unknown>;
+}
+/**
+ * UserBridge manages the connection between dashboard WebSocket users
+ * and the relay daemon.
+ */
+export declare class UserBridge {
+    private readonly socketPath;
+    private readonly createRelayClient;
+    private readonly users;
+    constructor(options: UserBridgeOptions);
+    /**
+     * Register a user with the relay daemon.
+     * Creates a relay client connection for the user.
+     */
+    registerUser(username: string, webSocket: WebSocket, options?: {
+        avatarUrl?: string;
+        displayName?: string;
+    }): Promise<void>;
+    /**
+     * Unregister a user and disconnect their relay client.
+     */
+    unregisterUser(username: string): void;
+    /**
+     * Check if a user is registered.
+     */
+    isUserRegistered(username: string): boolean;
+    /**
+     * Get list of all registered users.
+     */
+    getRegisteredUsers(): string[];
+    /**
+     * Join a channel.
+     */
+    joinChannel(username: string, channel: string): Promise<boolean>;
+    /**
+     * Leave a channel.
+     */
+    leaveChannel(username: string, channel: string): Promise<boolean>;
+    /**
+     * Get channels a user has joined.
+     */
+    getUserChannels(username: string): string[];
+    /**
+     * Send a message to a channel.
+     */
+    sendChannelMessage(username: string, channel: string, body: string, options?: SendMessageOptions): Promise<boolean>;
+    /**
+     * Send a direct message to another user or agent.
+     */
+    sendDirectMessage(fromUsername: string, toName: string, body: string, options?: SendMessageOptions): Promise<boolean>;
+    /**
+     * Handle incoming message from relay daemon.
+     */
+    private handleIncomingMessage;
+    /**
+     * Dispose of all user sessions.
+     */
+    dispose(): void;
+}
+//# sourceMappingURL=user-bridge.d.ts.map

package/dist/dashboard-server/user-bridge.js

@@ -0,0 +1,189 @@
+/**
+ * User Bridge - Bridges dashboard WebSocket users to the relay daemon.
+ *
+ * This module allows human users connected via WebSocket to:
+ * - Register as "user" entities in the relay daemon
+ * - Join/leave channels
+ * - Send/receive messages through the relay daemon
+ * - Communicate with agents and other users
+ */
+/**
+ * UserBridge manages the connection between dashboard WebSocket users
+ * and the relay daemon.
+ */
+export class UserBridge {
+    socketPath;
+    createRelayClient;
+    users = new Map();
+    constructor(options) {
+        this.socketPath = options.socketPath;
+        this.createRelayClient = options.createRelayClient;
+    }
+    /**
+     * Register a user with the relay daemon.
+     * Creates a relay client connection for the user.
+     */
+    async registerUser(username, webSocket, options) {
+        // If user already registered, unregister first
+        if (this.users.has(username)) {
+            this.unregisterUser(username);
+        }
+        // Create relay client for this user
+        const relayClient = await this.createRelayClient({
+            socketPath: this.socketPath,
+            agentName: username,
+            entityType: 'user',
+            displayName: options?.displayName,
+            avatarUrl: options?.avatarUrl,
+        });
+        // Connect to daemon
+        await relayClient.connect();
+        // Set up message handler to forward messages to WebSocket
+        relayClient.onMessage = (from, payload, _messageId, _meta, _originalTo) => {
+            const body = typeof payload === 'object' && payload !== null && 'body' in payload
+                ? payload.body
+                : String(payload);
+            this.handleIncomingMessage(username, from, body, payload);
+        };
+        // Create session
+        const session = {
+            username,
+            relayClient,
+            webSocket,
+            channels: new Set(),
+            avatarUrl: options?.avatarUrl,
+        };
+        this.users.set(username, session);
+        // Set up WebSocket close handler
+        webSocket.on('close', () => {
+            this.unregisterUser(username);
+        });
+        console.log(`[user-bridge] User ${username} registered with relay daemon`);
+    }
+    /**
+     * Unregister a user and disconnect their relay client.
+     */
+    unregisterUser(username) {
+        const session = this.users.get(username);
+        if (!session)
+            return;
+        session.relayClient.disconnect();
+        this.users.delete(username);
+        console.log(`[user-bridge] User ${username} unregistered from relay daemon`);
+    }
+    /**
+     * Check if a user is registered.
+     */
+    isUserRegistered(username) {
+        return this.users.has(username);
+    }
+    /**
+     * Get list of all registered users.
+     */
+    getRegisteredUsers() {
+        return Array.from(this.users.keys());
+    }
+    /**
+     * Join a channel.
+     */
+    async joinChannel(username, channel) {
+        const session = this.users.get(username);
+        if (!session) {
+            console.warn(`[user-bridge] Cannot join channel - user ${username} not registered`);
+            return false;
+        }
+        // Send channel join via relay client
+        session.relayClient.sendMessage(channel, '', 'channel_join');
+        // Track membership
+        session.channels.add(channel);
+        console.log(`[user-bridge] User ${username} joined channel ${channel}`);
+        return true;
+    }
+    /**
+     * Leave a channel.
+     */
+    async leaveChannel(username, channel) {
+        const session = this.users.get(username);
+        if (!session) {
+            console.warn(`[user-bridge] Cannot leave channel - user ${username} not registered`);
+            return false;
+        }
+        // Send channel leave via relay client
+        session.relayClient.sendMessage(channel, '', 'channel_leave');
+        // Update membership
+        session.channels.delete(channel);
+        console.log(`[user-bridge] User ${username} left channel ${channel}`);
+        return true;
+    }
+    /**
+     * Get channels a user has joined.
+     */
+    getUserChannels(username) {
+        const session = this.users.get(username);
+        return session ? Array.from(session.channels) : [];
+    }
+    /**
+     * Send a message to a channel.
+     */
+    async sendChannelMessage(username, channel, body, options) {
+        const session = this.users.get(username);
+        if (!session) {
+            console.warn(`[user-bridge] Cannot send - user ${username} not registered`);
+            return false;
+        }
+        return session.relayClient.sendMessage(channel, body, 'message', options?.data, options?.thread);
+    }
+    /**
+     * Send a direct message to another user or agent.
+     */
+    async sendDirectMessage(fromUsername, toName, body, options) {
+        const session = this.users.get(fromUsername);
+        if (!session) {
+            console.warn(`[user-bridge] Cannot send DM - user ${fromUsername} not registered`);
+            return false;
+        }
+        return session.relayClient.sendMessage(toName, body, 'message', options?.data, options?.thread);
+    }
+    /**
+     * Handle incoming message from relay daemon.
+     */
+    handleIncomingMessage(username, from, body, envelope) {
+        const session = this.users.get(username);
+        if (!session)
+            return;
+        const ws = session.webSocket;
+        if (ws.readyState !== 1)
+            return; // Not OPEN
+        // Determine message type from envelope
+        const env = envelope;
+        if (env.type === 'CHANNEL_MESSAGE') {
+            // Channel message
+            ws.send(JSON.stringify({
+                type: 'channel_message',
+                channel: env.payload?.channel,
+                from,
+                body: env.payload?.body || body,
+                timestamp: new Date().toISOString(),
+            }));
+        }
+        else {
+            // Direct message (DELIVER)
+            ws.send(JSON.stringify({
+                type: 'direct_message',
+                from,
+                body: env.payload?.body || body,
+                timestamp: new Date().toISOString(),
+            }));
+        }
+    }
+    /**
+     * Dispose of all user sessions.
+     */
+    dispose() {
+        for (const [username] of this.users) {
+            this.unregisterUser(username);
+        }
+        console.log('[user-bridge] Disposed all user sessions');
+    }
+}
+//# sourceMappingURL=user-bridge.js.map

package/dist/wrapper/base-wrapper.d.ts

@@ -60,6 +60,10 @@ export interface BaseWrapperConfig {
     idleBeforeInjectMs?: number;
     /** Confidence threshold for idle detection (0-1, default: 0.7) */
     idleConfidenceThreshold?: number;
+    /** Skip initial instruction injection (when using --append-system-prompt) */
+    skipInstructions?: boolean;
+    /** Skip continuity loading (for spawned agents that don't need session recovery) */
+    skipContinuity?: boolean;
 }
 /**
  * Abstract base class for agent wrappers

package/dist/wrapper/base-wrapper.js

@@ -63,8 +63,10 @@ export class BaseWrapper extends EventEmitter {
             workingDirectory: config.cwd,
             quiet: true,
         });
-        // Initialize continuity manager
-        this.continuity = getContinuityManager({ defaultCli: this.cliType });
+        // Initialize continuity manager (skip for spawned agents that don't need session recovery)
+        if (!config.skipContinuity) {
+            this.continuity = getContinuityManager({ defaultCli: this.cliType });
+        }
         // Initialize universal idle detector for robust injection timing
         this.idleDetector = new UniversalIdleDetector({
             minSilenceMs: config.idleBeforeInjectMs ?? DEFAULT_IDLE_BEFORE_INJECT_MS,
@@ -186,9 +188,15 @@ export class BaseWrapper extends EventEmitter {
                 this.sentMessageHashes.delete(oldest);
         }
         // Only send if client ready
-        if (this.client.state !== 'READY')
+        if (this.client.state !== 'READY') {
+            console.error(`[base-wrapper] Skipped message to ${cmd.to} - client not ready (state: ${this.client.state})`);
             return;
-        this.client.sendMessage(cmd.to, cmd.body, cmd.kind, cmd.data, cmd.thread);
+        }
+        console.log(`[base-wrapper] Sending message to ${cmd.to}: "${cmd.body.substring(0, 50)}..."`);
+        const sent = this.client.sendMessage(cmd.to, cmd.body, cmd.kind, cmd.data, cmd.thread);
+        if (!sent) {
+            console.error(`[base-wrapper] Failed to send message to ${cmd.to} - sendMessage returned false`);
+        }
     }
     // =========================================================================
     // Spawn/release handling

package/dist/wrapper/client.js

@@ -417,6 +417,7 @@ export class RelayClient {
         }
     }
     handleDeliver(envelope) {
+        console.log(`[relay-client:${this.config.agentName}] Received DELIVER from ${envelope.from}: "${envelope.payload.body?.substring(0, 40)}..."`);
         // Send ACK
         this.send({
             v: PROTOCOL_VERSION,
@@ -430,6 +431,7 @@ export class RelayClient {
         });
         const duplicate = this.markDelivered(envelope.id);
         if (duplicate) {
+            console.log(`[relay-client:${this.config.agentName}] Duplicate delivery, skipping`);
             return;
         }
         // Notify handler
@@ -437,6 +439,9 @@ export class RelayClient {
         if (this.onMessage && envelope.from) {
             this.onMessage(envelope.from, envelope.payload, envelope.id, envelope.payload_meta, envelope.delivery.originalTo);
         }
+        else {
+            console.log(`[relay-client:${this.config.agentName}] No onMessage handler or no from field`);
+        }
     }
     handlePing(envelope) {
         this.send({

package/dist/wrapper/parser.js

@@ -811,12 +811,12 @@ export class OutputParser {
     shouldFilterFencedInline(target, body) {
         // Check for placeholder target names
         if (isPlaceholderTarget(target)) {
-            console.error(`[parser] Filtered message - placeholder target: ${target}`);
+            // Silently filter placeholder targets (common in documentation)
             return true;
         }
         // Check for instructional body content
         if (isInstructionalText(body)) {
-            console.error(`[parser] Filtered message to ${target} - instructional text detected. Body preview: ${body.substring(0, 100)}`);
+            // Silently filter instructional text (common in system prompts)
             return true;
         }
         return false;

package/dist/wrapper/pty-wrapper.d.ts

@@ -230,9 +230,15 @@ export declare class PtyWrapper extends BaseWrapper {
     protected parseSpawnReleaseCommands(content: string): void;
     /**
      * Execute spawn via API or callback.
-     * Overrides BaseWrapper to add PTY-specific logging and API path.
+     * After spawning, waits for the agent to come online and sends the task via relay.
      */
     protected executeSpawn(name: string, cli: string, task: string): Promise<void>;
+    /**
+     * Wait for a spawned agent to come online, then send the task via relay.
+     * Uses the wrapper's own relay client so the message comes "from" this agent,
+     * not from the dashboard's relay client.
+     */
+    private waitAndSendTask;
     /**
      * Execute release via API or callback.
      * Overrides BaseWrapper to add PTY-specific logging and API path.

package/dist/wrapper/pty-wrapper.js

@@ -220,6 +220,7 @@ export class PtyWrapper extends BaseWrapper {
                 this.injectInstructions();
             }
             this.readyForMessages = true;
+            console.log(`[pty:${this.config.name}] Agent ready for messages (queueLen=${this.messageQueue.length}, interactive=${this.config.interactive})`);
             // Process any messages that arrived while waiting (skip in interactive mode)
             if (!this.config.interactive) {
                 this.processMessageQueue();
@@ -228,6 +229,7 @@ export class PtyWrapper extends BaseWrapper {
             console.error(`[pty:${this.config.name}] Failed to wait for agent ready:`, err);
             // Fall back to marking ready anyway to avoid blocking forever
             this.readyForMessages = true;
+            console.log(`[pty:${this.config.name}] Agent ready for messages (fallback, queueLen=${this.messageQueue.length})`);
         });
     }
     /**
@@ -608,6 +610,14 @@ export class PtyWrapper extends BaseWrapper {
         // 500 chars is enough to capture most relay message headers
         const lookbackStart = Math.max(0, this.lastParsedLength - 500);
         const contentToParse = cleanContent.substring(lookbackStart);
+        // Debug: Check if content contains relay pattern
+        if (contentToParse.includes('->relay:')) {
+            const relayLines = contentToParse.split('\n').filter(l => l.includes('->relay:'));
+            console.log(`[pty:${this.config.name}] [RELAY-DEBUG] Found ${relayLines.length} lines with ->relay: pattern`);
+            relayLines.slice(0, 3).forEach((line, i) => {
+                console.log(`[pty:${this.config.name}] [RELAY-DEBUG] Line ${i}: "${line.substring(0, 80)}..."`);
+            });
+        }
         // First, try to find fenced multi-line messages: ->relay:Target <<<\n...\n>>>
         this.parseFencedMessages(contentToParse);
         // Then parse single-line messages
@@ -985,22 +995,24 @@ export class PtyWrapper extends BaseWrapper {
     }
     /**
      * Execute spawn via API or callback.
-     * Overrides BaseWrapper to add PTY-specific logging and API path.
+     * After spawning, waits for the agent to come online and sends the task via relay.
      */
     async executeSpawn(name, cli, task) {
         console.log(`[pty:${this.config.name}] [SPAWN-DEBUG] executeSpawn called: name=${name}, cli=${cli}, task="${task.substring(0, 50)}..."`);
         console.log(`[pty:${this.config.name}] [SPAWN-DEBUG] dashboardPort=${this.config.dashboardPort}, hasOnSpawn=${!!this.config.onSpawn}`);
+        let spawned = false;
         if (this.config.dashboardPort) {
             // Use dashboard API for spawning (works from spawned agents)
             try {
                 const response = await fetch(`http://localhost:${this.config.dashboardPort}/api/spawn`, {
                     method: 'POST',
                     headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ name, cli, task }),
+                    body: JSON.stringify({ name, cli }), // No task - we send it after agent is online
                 });
                 const result = await response.json();
                 if (result.success) {
                     console.log(`[pty:${this.config.name}] Spawned ${name} via API`);
+                    spawned = true;
                 }
                 else {
                     console.error(`[pty:${this.config.name}] Spawn failed: ${result.error}`);
@@ -1014,11 +1026,57 @@ export class PtyWrapper extends BaseWrapper {
             // Fall back to callback
             try {
                 await this.config.onSpawn(name, cli, task);
+                spawned = true;
             }
             catch (err) {
                 console.error(`[pty:${this.config.name}] Spawn failed: ${err.message}`);
             }
         }
+        // If spawn succeeded and we have a task, wait for agent to come online and send it
+        if (spawned && task && task.trim() && this.config.dashboardPort) {
+            await this.waitAndSendTask(name, task);
+        }
+    }
+    /**
+     * Wait for a spawned agent to come online, then send the task via relay.
+     * Uses the wrapper's own relay client so the message comes "from" this agent,
+     * not from the dashboard's relay client.
+     */
+    async waitAndSendTask(agentName, task) {
+        const maxWaitMs = 30000;
+        const pollIntervalMs = 500;
+        const startTime = Date.now();
+        console.log(`[pty:${this.config.name}] Waiting for ${agentName} to come online...`);
+        // Poll for agent to be online using dedicated status endpoint
+        while (Date.now() - startTime < maxWaitMs) {
+            try {
+                const response = await fetch(`http://localhost:${this.config.dashboardPort}/api/agents/${encodeURIComponent(agentName)}/online`);
+                const data = await response.json();
+                if (data.online) {
+                    console.log(`[pty:${this.config.name}] ${agentName} is online, sending task...`);
+                    // Send task directly via our relay client (not dashboard API)
+                    // This ensures the message comes "from" this agent, not from _DashboardUI
+                    if (this.client.state === 'READY') {
+                        const sent = this.client.sendMessage(agentName, task, 'message');
+                        if (sent) {
+                            console.log(`[pty:${this.config.name}] Task sent to ${agentName}`);
+                        }
+                        else {
+                            console.error(`[pty:${this.config.name}] Failed to send task to ${agentName}: sendMessage returned false`);
+                        }
+                    }
+                    else {
+                        console.error(`[pty:${this.config.name}] Failed to send task to ${agentName}: relay client not ready (state: ${this.client.state})`);
+                    }
+                    return;
+                }
+            }
+            catch (err) {
+                // Ignore poll errors, keep trying
+            }
+            await sleep(pollIntervalMs);
+        }
+        console.error(`[pty:${this.config.name}] Timeout waiting for ${agentName} to come online`);
     }
     /**
      * Execute release via API or callback.
@@ -1058,6 +1116,8 @@ export class PtyWrapper extends BaseWrapper {
      * Extends BaseWrapper to add PTY-specific behavior.
      */
     handleIncomingMessage(from, payload, messageId, meta, originalTo) {
+        const bodyPreview = payload.body.substring(0, 50).replace(/\n/g, '\\n');
+        console.log(`[pty:${this.config.name}] Message received from ${from}: "${bodyPreview}..." (readyForMessages=${this.readyForMessages}, queueLen=${this.messageQueue.length})`);
         // Call base class to handle deduplication and queuing
         super.handleIncomingMessage(from, payload, messageId, meta, originalTo);
         // PTY-specific: Process the message queue immediately
@@ -1114,6 +1174,8 @@ export class PtyWrapper extends BaseWrapper {
             this.isInjecting = false;
             return;
         }
+        const bodyPreview = msg.body.substring(0, 50).replace(/\n/g, '\\n');
+        console.log(`[pty:${this.config.name}] Processing message from ${msg.from}: "${bodyPreview}..." (remaining=${this.messageQueue.length})`);
         try {
             // Wait for output to stabilize before injecting
             await this.waitForOutputStable();
@@ -1152,9 +1214,21 @@ export class PtyWrapper extends BaseWrapper {
                     if (!this.ptyProcess || !this.running) {
                         throw new Error('PTY process not running');
                     }
-                    // Write message to PTY, then send Enter separately after a small delay
-                    this.ptyProcess.write(inj);
-                    await sleep(INJECTION_CONSTANTS.ENTER_DELAY_MS);
+                    // Use bracketed paste mode for CLIs that support it (claude, codex, gemini)
+                    // This prevents interleaving with CLI output and ensures clean input
+                    const useBracketedPaste = this.cliType === 'claude' || this.cliType === 'codex' || this.cliType === 'gemini';
+                    if (useBracketedPaste) {
+                        // Bracketed paste: \x1b[200~ starts paste, \x1b[201~ ends paste
+                        this.ptyProcess.write('\x1b[200~' + inj + '\x1b[201~');
+                    }
+                    else {
+                        this.ptyProcess.write(inj);
+                    }
+                    // Wait longer for CLI to process the pasted content before sending Enter.
+                    // The standard 50ms delay is too short for CLIs like Claude that need time
+                    // to process bracketed paste content before accepting Enter.
+                    await sleep(200);
+                    // Send Enter key - use \r for PTY (carriage return)
                     this.ptyProcess.write('\r');
                 },
                 log: (message) => console.log(`[pty:${this.config.name}] ${message}`),
@@ -1199,6 +1273,8 @@ export class PtyWrapper extends BaseWrapper {
     injectInstructions() {
         if (!this.running)
             return;
+        if (this.config.skipInstructions)
+            return;
         // Guard: Only inject once per session
         if (this.instructionsInjected) {
             console.log(`[pty:${this.config.name}] Init instructions already injected, skipping`);

package/dist/wrapper/shared.d.ts

@@ -53,7 +53,7 @@ export declare const INJECTION_CONSTANTS: {
     /** Timeout for injection verification (ms) */
     readonly VERIFICATION_TIMEOUT_MS: 2000;
     /** Delay between message and Enter key (ms) */
-    readonly ENTER_DELAY_MS: 50;
+    readonly ENTER_DELAY_MS: 100;
     /** Backoff multiplier for retries (ms per attempt) */
     readonly RETRY_BACKOFF_MS: 300;
     /** Delay between processing queued messages (ms) */

package/dist/wrapper/shared.js

@@ -19,7 +19,7 @@ export const INJECTION_CONSTANTS = {
     /** Timeout for injection verification (ms) */
     VERIFICATION_TIMEOUT_MS: 2000,
     /** Delay between message and Enter key (ms) */
-    ENTER_DELAY_MS: 50,
+    ENTER_DELAY_MS: 100,
     /** Backoff multiplier for retries (ms per attempt) */
     RETRY_BACKOFF_MS: 300,
     /** Delay between processing queued messages (ms) */

package/dist/wrapper/tmux-wrapper.d.ts

@@ -232,9 +232,16 @@ export declare class TmuxWrapper extends BaseWrapper {
      */
     private parseSessionEndAndClose;
     /**
-     * Execute spawn via API (if dashboardPort set) or callback
+     * Execute spawn via API (if dashboardPort set) or callback.
+     * After spawning, waits for the agent to come online and sends the task via relay.
      */
     protected executeSpawn(name: string, cli: string, task: string): Promise<void>;
+    /**
+     * Wait for a spawned agent to come online, then send the task via relay.
+     * Uses the wrapper's own relay client so the message comes "from" this agent,
+     * not from the dashboard's relay client.
+     */
+    private waitAndSendTask;
     /**
      * Execute release via API (if dashboardPort set) or callback
      */