bosun 0.42.6 → 0.43.1

package/bench/harness-load-bench.mjs

@@ -0,0 +1,281 @@
+#!/usr/bin/env node
+
+import { performance } from "node:perf_hooks";
+
+import { createInternalHarnessSession } from "../agent/internal-harness-runtime.mjs";
+import { createProviderKernel } from "../agent/provider-kernel.mjs";
+import { createBosunSessionManager } from "../agent/session-manager.mjs";
+import { createToolOrchestrator } from "../agent/tool-orchestrator.mjs";
+import {
+  createHarnessObservabilitySpine,
+  resetHarnessObservabilitySpinesForTests,
+} from "../infra/session-telemetry.mjs";
+
+const SESSION_COUNT = Math.max(4, Number.parseInt(process.env.BOSUN_HARNESS_LOAD_SESSIONS || "18", 10) || 18);
+const ABORT_EVERY = Math.max(0, Number.parseInt(process.env.BOSUN_HARNESS_LOAD_ABORT_EVERY || "6", 10) || 6);
+const STAGE_DELAY_MS = Math.max(1, Number.parseInt(process.env.BOSUN_HARNESS_LOAD_STAGE_DELAY_MS || "12", 10) || 12);
+
+function percentile(values = [], ratio = 0.95) {
+  if (!values.length) return 0;
+  const sorted = values.slice().sort((a, b) => a - b);
+  const index = Math.max(0, Math.min(sorted.length - 1, Math.ceil(sorted.length * ratio) - 1));
+  return Number(sorted[index].toFixed(2));
+}
+
+function sleepWithSignal(ms, signal) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(resolve, ms);
+    if (!signal) return;
+    if (signal.aborted) {
+      clearTimeout(timer);
+      const error = new Error("aborted");
+      error.name = "AbortError";
+      reject(error);
+      return;
+    }
+    signal.addEventListener("abort", () => {
+      clearTimeout(timer);
+      const error = new Error("aborted");
+      error.name = "AbortError";
+      reject(error);
+    }, { once: true });
+  });
+}
+
+function createLoadRuntime() {
+  const providerKernel = createProviderKernel({
+    adapters: {
+      "bench-sdk": {
+        name: "bench-sdk",
+        provider: "BENCH",
+        exec: async (message, options = {}) => ({
+          finalResponse: `load:${message}`,
+          sessionId: options.sessionId || null,
+          threadId: options.threadId || null,
+          providerId: options.provider || null,
+          usage: {
+            inputTokens: 18,
+            outputTokens: 9,
+            totalTokens: 27,
+          },
+        }),
+      },
+    },
+    config: {
+      providers: {
+        defaultProvider: "openai-compatible",
+        openaiCompatible: {
+          enabled: true,
+          defaultModel: "bench-model",
+          baseUrl: "http://127.0.0.1:11434/v1",
+        },
+      },
+    },
+    env: {},
+  });
+  const toolOrchestrator = createToolOrchestrator({
+    toolSources: [{
+      source: "bench",
+      definitions: [{
+        id: "load_echo",
+        handler: async (args = {}) => ({
+          ok: true,
+          sessionId: args.sessionId,
+        }),
+      }],
+    }],
+  });
+  return { providerKernel, toolOrchestrator };
+}
+
+function createProfile() {
+  return {
+    agentId: "bosun-harness-load-bench",
+    entryStageId: "plan",
+    provider: "openai-compatible",
+    stages: [
+      {
+        id: "plan",
+        type: "prompt",
+        prompt: "Plan the benchmark action.",
+        transitions: [{ on: "success", to: "apply" }],
+      },
+      {
+        id: "apply",
+        type: "prompt",
+        prompt: "Apply the benchmark action.",
+        transitions: [{ on: "success", to: "finalize" }],
+      },
+      {
+        id: "finalize",
+        type: "finalize",
+        prompt: "Finalize the benchmark response.",
+      },
+    ],
+  };
+}
+
+async function runLoadSession(index, telemetry) {
+  const sessionManager = createBosunSessionManager();
+  const { providerKernel, toolOrchestrator } = createLoadRuntime();
+  const profile = createProfile();
+  const sessionId = `load-session-${index}`;
+  const abortController = new AbortController();
+  const shouldAbort = ABORT_EVERY > 0 && index > 0 && index % ABORT_EVERY === 0;
+
+  sessionManager.beginExternalSession({
+    sessionId,
+    threadId: `${sessionId}:root`,
+    scope: index % 2 === 0 ? "tui:bench" : "workflow:bench",
+    sessionType: index % 2 === 0 ? "tui" : "workflow",
+    taskKey: `TASK-LOAD-${index}`,
+    cwd: process.cwd(),
+    source: "load-bench",
+  });
+  sessionManager.registerExecution(sessionId, {
+    sessionType: index % 2 === 0 ? "tui" : "workflow",
+    taskKey: `TASK-LOAD-${index}`,
+    threadId: `${sessionId}:root`,
+    cwd: process.cwd(),
+    status: "running",
+    scope: index % 2 === 0 ? "tui:bench" : "workflow:bench",
+    metadata: {
+      benchmark: "load",
+    },
+  });
+
+  const session = createInternalHarnessSession(profile, {
+    runId: `load-run-${index}`,
+    sessionId,
+    taskKey: `TASK-LOAD-${index}`,
+    surface: index % 2 === 0 ? "tui" : "workflow",
+    channel: index % 2 === 0 ? "tui:bench" : "workflow:bench",
+    requestedBy: "harness-load-bench",
+    abortController,
+    onEvent: (event) => {
+      telemetry.recordEvent({
+        timestamp: event.timestamp || new Date().toISOString(),
+        eventType: event.type || "harness:event",
+        source: "internal-harness-runtime",
+        category: "harness",
+        sessionId,
+        runId: `load-run-${index}`,
+        taskId: `TASK-LOAD-${index}`,
+        status: event.status || null,
+        summary: event.summary || event.type || null,
+      });
+    },
+    executeTurn: async ({ stage, signal }) => {
+      await toolOrchestrator.execute("load_echo", {
+        sessionId,
+        stageId: stage.id,
+      }, {
+        sessionId,
+        turnId: `${sessionId}:${stage.id}`,
+        approval: { mode: "auto" },
+      });
+      await sleepWithSignal(STAGE_DELAY_MS, signal);
+      const providerSession = providerKernel.createExecutionSession({
+        adapterName: "bench-sdk",
+        selectionId: "openai-compatible",
+        sessionId,
+        threadId: `${sessionId}:${stage.id}`,
+        model: "bench-model",
+      });
+      const providerResult = await providerSession.runTurn(stage.prompt, {
+        sessionId,
+        threadId: `${sessionId}:${stage.id}`,
+        model: "bench-model",
+      });
+      return {
+        success: true,
+        outcome: "success",
+        status: "completed",
+        output: providerResult.finalResponse,
+        sessionId: providerResult.sessionId,
+        threadId: providerResult.threadId,
+        providerId: providerResult.providerId,
+      };
+    },
+  });
+
+  let abortScheduledAt = null;
+  if (shouldAbort) {
+    const timer = setTimeout(() => {
+      abortScheduledAt = performance.now();
+      abortController.abort("bench-abort");
+    }, Math.max(1, Math.floor(STAGE_DELAY_MS / 2)));
+  }
+
+  const startedAt = performance.now();
+  const result = await session.run().catch((error) => ({
+    success: false,
+    status: error?.name === "AbortError" ? "aborted" : "failed",
+    error: error?.message || String(error),
+  }));
+  const finishedAt = performance.now();
+
+  sessionManager.finalizeExternalExecution(sessionId, {
+    success: result.success,
+    status: result.status,
+    error: result.error || null,
+    threadId: `${sessionId}:final`,
+    result,
+  });
+
+  return {
+    sessionId,
+    status: result.status,
+    durationMs: finishedAt - startedAt,
+    cancellationLatencyMs: abortScheduledAt == null ? null : finishedAt - abortScheduledAt,
+  };
+}
+
+async function main() {
+  resetHarnessObservabilitySpinesForTests();
+  const telemetry = createHarnessObservabilitySpine({
+    persist: false,
+    maxInMemoryEvents: SESSION_COUNT * 18,
+  });
+
+  const startedAt = performance.now();
+  const results = await Promise.all(
+    Array.from({ length: SESSION_COUNT }, (_, index) => runLoadSession(index + 1, telemetry)),
+  );
+  const flushStartedAt = performance.now();
+  await telemetry.flush();
+  const flushDurationMs = performance.now() - flushStartedAt;
+  const totalDurationMs = performance.now() - startedAt;
+
+  const completed = results.filter((entry) => entry.status === "completed");
+  const aborted = results.filter((entry) => entry.status === "aborted");
+  const failed = results.filter((entry) => entry.status === "failed");
+  const durations = results.map((entry) => entry.durationMs);
+  const cancellationLatencies = aborted
+    .map((entry) => entry.cancellationLatencyMs)
+    .filter((value) => Number.isFinite(value));
+
+  console.log(JSON.stringify({
+    benchmark: "harness-load",
+    sessions: SESSION_COUNT,
+    completed: completed.length,
+    aborted: aborted.length,
+    failed: failed.length,
+    totalDurationMs: Number(totalDurationMs.toFixed(2)),
+    throughputSessionsPerSecond: Number(((SESSION_COUNT / totalDurationMs) * 1000).toFixed(2)),
+    latency: {
+      p50Ms: percentile(durations, 0.5),
+      p95Ms: percentile(durations, 0.95),
+      p99Ms: percentile(durations, 0.99),
+    },
+    cancellationLatency: {
+      count: cancellationLatencies.length,
+      p50Ms: percentile(cancellationLatencies, 0.5),
+      p95Ms: percentile(cancellationLatencies, 0.95),
+    },
+    projectionFreshnessMs: Number(flushDurationMs.toFixed(2)),
+    telemetry: telemetry.getSummary(),
+  }, null, 2));
+}
+
+await main();

package/bench/harness-parity-bench.mjs

@@ -0,0 +1,214 @@
+#!/usr/bin/env node
+
+import { performance } from "node:perf_hooks";
+
+import { createInternalHarnessSession } from "../agent/internal-harness-runtime.mjs";
+import { createProviderKernel } from "../agent/provider-kernel.mjs";
+import { createBosunSessionManager } from "../agent/session-manager.mjs";
+import { createToolOrchestrator } from "../agent/tool-orchestrator.mjs";
+
+const ITERATIONS = Math.max(1, Number.parseInt(process.env.BOSUN_HARNESS_PARITY_ITERATIONS || "3", 10) || 3);
+const SURFACES = Object.freeze([
+  { surface: "chat", scope: "primary", sessionType: "primary" },
+  { surface: "workflow", scope: "workflow:bench", sessionType: "workflow" },
+  { surface: "tui", scope: "tui:bench", sessionType: "tui" },
+  { surface: "web-ui", scope: "web-ui:bench", sessionType: "web-ui" },
+  { surface: "telegram", scope: "telegram:bench", sessionType: "telegram" },
+]);
+
+function percentile(values = [], ratio = 0.95) {
+  if (!values.length) return 0;
+  const sorted = values.slice().sort((a, b) => a - b);
+  const index = Math.max(0, Math.min(sorted.length - 1, Math.ceil(sorted.length * ratio) - 1));
+  return Number(sorted[index].toFixed(2));
+}
+
+function createBenchRuntime() {
+  const providerKernel = createProviderKernel({
+    adapters: {
+      "bench-sdk": {
+        name: "bench-sdk",
+        provider: "BENCH",
+        exec: async (message, options = {}) => ({
+          finalResponse: `[${options.provider}] ${message}`,
+          sessionId: options.sessionId || null,
+          threadId: options.threadId || null,
+          providerId: options.provider || null,
+          usage: {
+            inputTokens: 10,
+            outputTokens: 6,
+            totalTokens: 16,
+          },
+        }),
+      },
+    },
+    config: {
+      providers: {
+        defaultProvider: "openai-compatible",
+        openaiCompatible: {
+          enabled: true,
+          defaultModel: "bench-model",
+          baseUrl: "http://127.0.0.1:11434/v1",
+        },
+      },
+    },
+    env: {},
+  });
+
+  const toolOrchestrator = createToolOrchestrator({
+    toolSources: [{
+      source: "bench",
+      definitions: [{
+        id: "surface_echo",
+        handler: async (args = {}) => ({
+          ok: true,
+          surface: args.surface,
+          stageId: args.stageId,
+        }),
+      }],
+    }],
+  });
+
+  return { providerKernel, toolOrchestrator };
+}
+
+function createProfile() {
+  return {
+    agentId: "bosun-harness-parity-bench",
+    entryStageId: "plan",
+    provider: "openai-compatible",
+    stages: [
+      {
+        id: "plan",
+        type: "prompt",
+        prompt: "Plan the next action.",
+        transitions: [{ on: "success", to: "finalize" }],
+      },
+      {
+        id: "finalize",
+        type: "finalize",
+        prompt: "Finalize the response.",
+      },
+    ],
+  };
+}
+
+async function runSurfaceIteration(surfaceEntry, iteration) {
+  const sessionManager = createBosunSessionManager();
+  const { providerKernel, toolOrchestrator } = createBenchRuntime();
+  const sessionId = `bench-${surfaceEntry.surface}-${iteration}`;
+  const profile = createProfile();
+
+  sessionManager.beginExternalSession({
+    sessionId,
+    scope: surfaceEntry.scope,
+    sessionType: surfaceEntry.sessionType,
+    taskKey: `task-${surfaceEntry.surface}-${iteration}`,
+    cwd: process.cwd(),
+    source: surfaceEntry.surface,
+  });
+  sessionManager.registerExecution(sessionId, {
+    scope: surfaceEntry.scope,
+    sessionType: surfaceEntry.sessionType,
+    taskKey: `task-${surfaceEntry.surface}-${iteration}`,
+    cwd: process.cwd(),
+    status: "running",
+    threadId: `${sessionId}:bootstrap`,
+    providerSelection: "openai-compatible",
+    adapterName: "bench-sdk",
+  });
+
+  const session = createInternalHarnessSession(profile, {
+    runId: `run-${surfaceEntry.surface}-${iteration}`,
+    sessionId,
+    taskKey: `task-${surfaceEntry.surface}-${iteration}`,
+    surface: surfaceEntry.surface,
+    channel: surfaceEntry.scope,
+    requestedBy: "harness-parity-bench",
+    executeTurn: async ({ stage }) => {
+      const toolResult = await toolOrchestrator.execute("surface_echo", {
+        surface: surfaceEntry.surface,
+        stageId: stage.id,
+      }, {
+        sessionId,
+        turnId: `${sessionId}:${stage.id}`,
+        approval: { mode: "auto" },
+      });
+      const providerSession = providerKernel.createExecutionSession({
+        adapterName: "bench-sdk",
+        selectionId: "openai-compatible",
+        sessionId,
+        threadId: `${sessionId}:${stage.id}`,
+        model: "bench-model",
+      });
+      const providerResult = await providerSession.runTurn(
+        `${surfaceEntry.surface}:${stage.prompt}`,
+        {
+          sessionId,
+          threadId: `${sessionId}:${stage.id}`,
+          model: "bench-model",
+        },
+      );
+      return {
+        success: true,
+        outcome: "success",
+        status: "completed",
+        output: `${providerResult.finalResponse} :: ${toolResult.surface}`,
+        sessionId: providerResult.sessionId,
+        threadId: providerResult.threadId,
+        providerId: providerResult.providerId,
+      };
+    },
+  });
+
+  const startedAt = performance.now();
+  const result = await session.run();
+  const durationMs = performance.now() - startedAt;
+
+  sessionManager.finalizeExternalExecution(sessionId, {
+    success: result.success,
+    status: result.status,
+    threadId: `${sessionId}:final`,
+    result,
+  });
+
+  return {
+    surface: surfaceEntry.surface,
+    durationMs,
+    status: result.status,
+    providerId: session.getState().provider,
+    events: session.getState().events.length,
+  };
+}
+
+async function main() {
+  const results = [];
+  for (let iteration = 0; iteration < ITERATIONS; iteration += 1) {
+    for (const surface of SURFACES) {
+      results.push(await runSurfaceIteration(surface, iteration));
+    }
+  }
+
+  const bySurface = Object.fromEntries(
+    SURFACES.map(({ surface }) => {
+      const surfaceResults = results.filter((entry) => entry.surface === surface);
+      const durations = surfaceResults.map((entry) => entry.durationMs);
+      return [surface, {
+        iterations: surfaceResults.length,
+        avgDurationMs: Number((durations.reduce((sum, value) => sum + value, 0) / Math.max(1, durations.length)).toFixed(2)),
+        p95DurationMs: percentile(durations, 0.95),
+        statuses: [...new Set(surfaceResults.map((entry) => entry.status))],
+        providerIds: [...new Set(surfaceResults.map((entry) => entry.providerId))],
+        minEvents: Math.min(...surfaceResults.map((entry) => entry.events)),
+      }];
+    }),
+  );
+
+  console.log(JSON.stringify({
+    benchmark: "harness-parity",
+    iterations: ITERATIONS,
+    surfaces: bySurface,
+  }, null, 2));
+}
+
+await main();

package/bench/swebench/bosun-swebench.mjs

@@ -5,6 +5,7 @@ import { execFileSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import { taskCreate, taskList } from "../../task/task-cli.mjs";
 import { WorkflowEngine } from "../../workflow/workflow-engine.mjs";
+import "../../workflow/workflow-nodes.mjs";
 import { installTemplateSet } from "../../workflow/workflow-templates.mjs";
 
 const DEFAULT_SWEBENCH_TEMPLATE_IDS = Object.freeze(["template-task-lifecycle"]);

package/bosun-tui.mjs

@@ -5,7 +5,15 @@ import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
 import loadConfig from "./config/config.mjs";
-import { resolveWebSocketProtocol } from "./tui/lib/ws-bridge.mjs";
+import {
+  clearRemoteConnectionConfig,
+  defaultConfigDir,
+  normalizeHttpProtocol,
+  readRemoteConnectionConfig,
+  resolveTuiConnectionTarget,
+  saveRemoteConnectionConfig,
+  upsertRemoteConnection,
+} from "./tui/lib/connection-target.mjs";
 
 const MIN_COLUMNS = 120;
 const MIN_ROWS = 30;
@@ -25,8 +33,13 @@ function showHelp() {
     node bosun-tui.mjs [options]
 
   OPTIONS
+    --endpoint <url>    Connect to an existing Bosun server (example: https://host:4400)
     --host <host>       WebSocket host (default: 127.0.0.1)
-    --port <n>          WebSocket/UI port (default: TELEGRAM_UI_PORT or 3080)
+    --port <n>          WebSocket/UI port (default: configured local backend, TELEGRAM_UI_PORT, or 3080 fallback)
+    --protocol <proto>  Connection protocol (ws|wss|http|https)
+    --api-key <key>     API key for remote/existing Bosun server (BOSUN_API_KEY)
+    --save-connection   Persist endpoint + API key to remote-connection.json
+    --clear-connection  Clear the saved remote connection target
     --screen <name>     Initial screen (agents|tasks|logs|workflows|telemetry|settings|help)
     --help              Show this help
     --version           Show version
@@ -86,19 +99,51 @@ export async function runBosunTui(argv = process.argv.slice(2), options = {}) {
   globalThis.WebSocket = globalThis.WebSocket || (await import("ws")).WebSocket;
 
   const config = loadConfig([process.argv[0], __filename, ...args]);
-  const configDir = String(config?.configDir || process.env.BOSUN_DIR || resolve(process.cwd(), ".bosun")).trim();
-  const host = getArgValue(args, "--host", "127.0.0.1");
-  const port = Number(getArgValue(args, "--port", String(resolvePort(config)))) || resolvePort(config);
-  const protocol = getArgValue(
-    args,
-    "--protocol",
-    resolveWebSocketProtocol({ configDir }),
-  );
+  const configDir = String(config?.configDir || process.env.BOSUN_DIR || defaultConfigDir()).trim();
+  if (hasFlag(args, "--clear-connection")) {
+    clearRemoteConnectionConfig(configDir);
+    stdout.write(`[bosun-tui] Cleared saved remote connection in ${configDir}\\remote-connection.json\n`);
+    return 0;
+  }
+
+  const explicitEndpoint = getArgValue(args, "--endpoint", "");
+  const explicitHost = getArgValue(args, "--host", "");
+  const explicitPort = Number(getArgValue(args, "--port", "")) || 0;
+  const explicitProtocol = getArgValue(args, "--protocol", "");
+  const explicitApiKey = getArgValue(args, "--api-key", String(process.env.BOSUN_API_KEY || "").trim());
+  const target = resolveTuiConnectionTarget({
+    configDir,
+    config,
+    env: process.env,
+    endpoint: explicitEndpoint,
+    host: explicitHost,
+    port: explicitPort,
+    protocol: explicitProtocol,
+    apiKey: explicitApiKey,
+  });
+
+  if (hasFlag(args, "--save-connection")) {
+    const remoteEndpoint = explicitEndpoint
+      || `${normalizeHttpProtocol(target.protocol)}://${target.host}:${target.port}`;
+    const nextConfig = upsertRemoteConnection(readRemoteConnectionConfig(configDir), {
+      name: remoteEndpoint,
+      endpoint: remoteEndpoint,
+      apiKey: target.apiKey || explicitApiKey,
+      enabled: true,
+    });
+    saveRemoteConnectionConfig(nextConfig, configDir);
+    stdout.write(`[bosun-tui] Saved remote connection target ${remoteEndpoint}\n`);
+  }
+
+  const host = target.host || "127.0.0.1";
+  const port = Number(target.port || resolvePort(config)) || resolvePort(config);
+  const protocol = target.protocol || "ws";
+  const apiKey = target.apiKey || "";
   const initialScreen = getArgValue(args, "--screen", "agents");
 
   const React = await import("react");
   const ink = await import("ink");
-  const { default: App } = await import("./ui/tui/App.js");
+  const { default: App } = await import("./tui/app.mjs");
 
   let terminalSize = getTerminalSize(stdout);
   const props = {
@@ -107,8 +152,11 @@ export async function runBosunTui(argv = process.argv.slice(2), options = {}) {
     host,
     port,
     protocol,
+    apiKey,
     initialScreen,
     terminalSize,
+    connectionSource: target.source,
+    connectionEndpoint: target.endpoint,
   };
 
   const instance = ink.render(React.createElement(App, props), { exitOnCtrlC: true });
@@ -140,5 +188,3 @@ if (process.argv[1] && resolve(process.argv[1]) === __filename) {
       process.exit(1);
     });
 }
-
-