Skip to content

A desktop coding agent with free access to frontier models.

TypeScript
9.8 KB
Raw Blame
import { describe, expect, test } from "bun:test";

import {
  composeDiagnosticsBundleJson,
  type DiagnosticsBundleInputs,
} from "../src/app/lib/diagnostics-bundle";

function baseInputs(): DiagnosticsBundleInputs {
  return {
    capturedAt: "2026-07-06T00:00:00.000Z",
    desktopRuntime: false,
    appInfo: null,
    engineInfo: null,
    omnirushServerSettings: {},
    hostInfo: null,
    developerLogs: [],
    perfLogs: [],
    context: {
      anyActiveRuns: false,
      canReloadWorkspace: false,
      clientConnected: false,
      developerMode: false,
      hostConnectUrl: "",
      hostConnectUrlUsesMdns: false,
      omnirushServerStatus: "disconnected",
      omnirushServerUrl: "",
      runtimeWorkspaceId: null,
    },
  };
}

describe("diagnostics bundle", () => {
  test("redacts known token values while preserving token presence", () => {
    const settingsSecret = "settings-secret-token-1234";
    const settingsHostSecret = "settings-host-secret-1234";
    const clientSecret = "client-secret-1234";
    const ownerSecret = "owner-secret-1234";
    const hostSecret = "host-secret-1234";
    const opencodeSecret = "opencode-password-1234";
    const input = baseInputs();
    input.desktopRuntime = true;
    input.omnirushServerSettings = {
      urlOverride: "http://127.0.0.1:4096",
      token: settingsSecret,
      hostToken: settingsHostSecret,
    };
    input.hostInfo = {
      running: true,
      remoteAccessEnabled: true,
      host: "127.0.0.1",
      port: 4096,
      baseUrl: "http://127.0.0.1:4096",
      connectUrl: "http://127.0.0.1:4096",
      mdnsUrl: null,
      lanUrl: null,
      clientToken: clientSecret,
      ownerToken: ownerSecret,
      hostToken: hostSecret,
      managedOpencodeBinPath: null,
      managedOpencodeBinSource: null,
      pid: 111,
      lastStdout: null,
      lastStderr: `server leaked ${settingsSecret} ${settingsHostSecret} ${clientSecret} ${ownerSecret} ${hostSecret}`,
      managedOpencodeExecution: null,
    };
    input.engineInfo = {
      running: true,
      runtime: "direct",
      managedByServer: true,
      baseUrl: "http://127.0.0.1:4097",
      projectDir: "/tmp/omnirush",
      hostname: "127.0.0.1",
      port: 4097,
      opencodeUsername: "do-not-include-user",
      opencodePassword: opencodeSecret,
      opencodeBinPath: "/usr/local/bin/opencode",
      opencodeBinSource: "path",
      pid: 222,
      lastStdout: null,
      lastStderr: `engine leaked ${opencodeSecret}`,
      execution: null,
    };

    const json = composeDiagnosticsBundleJson(input);
    const parsed = JSON.parse(json);

    expect(json).toContain('"tokenPresent": true');
    expect(parsed.omnirushServer.settings.tokenPresent).toBe(true);
    expect(parsed.omnirushServer.host.lastStderr).toContain("[redacted]");
    expect(parsed.opencodeEngine.lastStderr).toContain("[redacted]");
    expect(json).not.toContain(settingsSecret);
    expect(json).not.toContain(settingsHostSecret);
    expect(json).not.toContain(clientSecret);
    expect(json).not.toContain(ownerSecret);
    expect(json).not.toContain(hostSecret);
    expect(json).not.toContain(opencodeSecret);
    expect(json).not.toContain("clientToken");
    expect(json).not.toContain("ownerToken");
    expect(json).not.toContain("hostToken");
    expect(json).not.toContain("opencodePassword");
    expect(json).not.toContain("do-not-include-user");
    expect(json).not.toContain("opencodeUsername");
  });

  test("reports built-in server restarts with reason, trigger and time", () => {
    const input = baseInputs();
    input.desktopRuntime = true;
    input.hostInfo = {
      running: true,
      generation: 3,
      remoteAccessEnabled: false,
      host: "127.0.0.1",
      port: 4096,
      baseUrl: "http://127.0.0.1:4096",
      connectUrl: null,
      mdnsUrl: null,
      lanUrl: null,
      clientToken: null,
      ownerToken: null,
      hostToken: null,
      managedOpencodeBinPath: null,
      managedOpencodeBinSource: null,
      logFilePath: null,
      pid: null,
      lastStdout: null,
      lastStderr: null,
      managedOpencodeExecution: null,
      restarts: [
        { at: "2026-09-24T07:11:02.000Z", kind: "server", action: "deferred", reason: "engine_reload_failed", source: "engine-reload", busySessions: 3 },
        { at: "2026-09-24T02:57:40.000Z", kind: "engine", action: "restarted", reason: "engine_unreachable:process_exited", source: "engine-pool-watchdog" },
      ],
      pendingRestart: { action: "engine-restart", reason: "engine_reload_failed", source: "engine-reload", requestedAt: "2026-09-24T07:11:02.000Z" },
    };

    const parsed = JSON.parse(composeDiagnosticsBundleJson(input));

    expect(parsed.omnirushServer.host.restarts).toHaveLength(2);
    expect(parsed.omnirushServer.host.restarts[0]).toMatchObject({ action: "deferred", reason: "engine_reload_failed", busySessions: 3 });
    expect(parsed.omnirushServer.host.pendingRestart.reason).toBe("engine_reload_failed");
  });

  test("produces valid JSON without desktop info", () => {
    const json = composeDiagnosticsBundleJson(baseInputs());
    const parsed = JSON.parse(json);

    expect(parsed.app).toBeNull();
    expect(parsed.opencodeEngine).toBeNull();
    expect(parsed.omnirushServer.host).toBeNull();
    expect(parsed.omnirushServer.settings.tokenPresent).toBe(false);
  });

  test("carries the focused session and selected workspace IDs for support", () => {
    const input = baseInputs();
    input.context = {
      ...input.context,
      runtimeWorkspaceId: "runtime-ws-1",
      focusedSession: { workspaceId: "ws-side-chat", sessionId: "ses_side_chat_1" },
      selectedWorkspaceId: "ws-diagnostics-1",
    };

    const parsed = JSON.parse(composeDiagnosticsBundleJson(input));

    expect(parsed.session).toEqual({ id: "ses_side_chat_1", workspaceId: "ws-side-chat" });
    expect(parsed.workspace.id).toBe("ws-diagnostics-1");
    expect(parsed.workspace.runtimeWorkspaceId).toBe("runtime-ws-1");
  });

  test("reports no session when none is focused", () => {
    const input = baseInputs();
    input.context = { ...input.context, focusedSession: null, selectedWorkspaceId: "" };

    const parsed = JSON.parse(composeDiagnosticsBundleJson(input));

    expect(parsed.session).toEqual({ id: null, workspaceId: null });
    expect(parsed.workspace.id).toBeNull();
  });

  test("includes sanitized Cloud health without Den or MCP tokens", () => {
    const input = baseInputs();
    input.cloudMcpHealth = {
      desired: {
        config: {
          headers: {
            Authorization: "Bearer owt_mcp_synthetic_secret",
          },
        },
        token: {
          present: true,
          metadata: {
            fingerprint: "sha256:abc123",
            expiresAt: "2026-07-20T00:00:00.000Z",
            scopes: "mcp:read mcp:write",
          },
        },
      },
      firstFailure: {
        details: "den token Bearer eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJzZWNyZXQifQ.signatureee leaked",
      },
      opaque: "owt_den_synthetic_secret",
    };

    const json = composeDiagnosticsBundleJson(input);
    const parsed = JSON.parse(json);

    expect(parsed.cloudMcp.desired.config.headers.Authorization).toBe("[REDACTED]");
    expect(JSON.stringify(parsed.cloudMcp)).toContain("sha256:abc123");
    expect(JSON.stringify(parsed.cloudMcp)).toContain("mcp:read mcp:write");
    expect(json).not.toContain("owt_mcp_synthetic_secret");
    expect(json).not.toContain("owt_den_synthetic_secret");
    expect(json).not.toContain("eyJhbGciOiJIUzI1NiJ9");
  });
  test("reports app version, platform and built-in server starts this launch", () => {
    const input = baseInputs();
    input.desktopRuntime = true;
    input.platform = "MacIntel";
    input.appInfo = { version: "1.1.1", gitSha: "abc1234", os: "win32", arch: "x64" };
    input.hostInfo = {
      running: true,
      generation: 3,
      remoteAccessEnabled: false,
      host: "127.0.0.1",
      port: 4096,
      baseUrl: "http://127.0.0.1:4096",
      connectUrl: null,
      mdnsUrl: null,
      lanUrl: null,
      clientToken: null,
      ownerToken: null,
      hostToken: null,
      managedOpencodeBinPath: null,
      managedOpencodeBinSource: null,
      logFilePath: "C:\\Users\\someone\\AppData\\Roaming\\ai.omnirush.desktop\\logs\\omnirush-server.log",
      pid: null,
      lastStdout: null,
      lastStderr: null,
      managedOpencodeExecution: null,
    };

    const json = composeDiagnosticsBundleJson(input);
    const parsed = JSON.parse(json);

    expect(parsed.app.version).toBe("1.1.1");
    expect(parsed.app.os).toBe("win32");
    expect(parsed.app.arch).toBe("x64");
    expect(parsed.runtime.platform).toBe("win32");
    expect(parsed.omnirushServer.host.generation).toBe(3);
    expect(parsed.omnirushServer.host.restartsThisLaunch).toBe(2);
    // The log file path names the user's home folder; the bundle never carries it.
    expect(json).not.toContain("omnirush-server.log");
    expect(json).not.toContain("someone");
  });

  test("falls back to the renderer platform and reports unknown server starts as null", () => {
    const input = baseInputs();
    input.platform = "Linux x86_64";
    input.hostInfo = {
      running: false,
      generation: null,
      remoteAccessEnabled: false,
      host: null,
      port: null,
      baseUrl: null,
      connectUrl: null,
      mdnsUrl: null,
      lanUrl: null,
      clientToken: null,
      ownerToken: null,
      hostToken: null,
      managedOpencodeBinPath: null,
      managedOpencodeBinSource: null,
      logFilePath: null,
      pid: null,
      lastStdout: null,
      lastStderr: null,
      managedOpencodeExecution: null,
    };

    const parsed = JSON.parse(composeDiagnosticsBundleJson(input));

    expect(parsed.runtime.platform).toBe("Linux x86_64");
    expect(parsed.omnirushServer.host.generation).toBeNull();
    expect(parsed.omnirushServer.host.restartsThisLaunch).toBeNull();
  });
});