Electron

npm install @ade-dev/sdk

import path from "node:path";
import { app, BrowserWindow, ipcMain } from "electron";
import { createAdeChat } from "@ade-dev/sdk";
import { registerAdeIpc } from "@ade-dev/sdk/electron";

const client = await createAdeChat({
  home: path.join(app.getPath("userData"), "ade"),
});

const disposeIpc = registerAdeIpc(ipcMain, client, {
  /** Channel namespace. Defaults to "ade", giving `ade:invoke` and `ade:event`. */
  channelPrefix: "ade",
  /** Runs before every call. Return false and the SDK is never reached. */
  authorize: (event, method, args) => isTrustedFrame(event.sender),
  /** A thread key carries MCP servers and a permission policy. Pin it. */
  allowThreadKey: (key) => key === "main",
  /** Main decides how a key opens. The renderer's options are ignored. */
  openOptions: (key) => ({
    provider: "claude",
    model: "claude-sonnet-4-5",
    permissions: { allowedTools: ["mcp:app:*"], fallback: "deny" },
  }),
  /** Which models a renderer may pick. */
  allowModel: (key, { modelId }) => modelId.startsWith("claude-"),
});

const window = new BrowserWindow({
  webPreferences: {
    preload: require.resolve("@ade-dev/sdk/electron/preload-auto"),   // see "Preload" below
    contextIsolation: true,
    nodeIntegration: false,
    sandbox: true,
  },
});

app.on("before-quit", async () => {
  disposeIpc();          // drop the bridge before the client
  await client.dispose();
});

// renderer
<AdeChat
  client={client}
  threadKey="main"
  onLinkClick={(href, { source }) => window.app.openExternal(href, source)}
/>

// main
window.webContents.setWindowOpenHandler(() => ({ action: "deny" }));

ipcMain.handle("app:open-external", (_event, href: string) => {
  const url = new URL(href);
  if (url.protocol === "https:" && ALLOWED_HOSTS.has(url.host)) return shell.openExternal(href);
});

const catalog = new Set(await loadChatKeys());   // your own chat list

registerAdeIpc(ipcMain, client, {
  authorize: (event) => isTrustedFrame(event.sender),
  allowThreadKey: (key) => catalog.has(key),
});

allowThreadKey: async (key) => key === "new-chat" || (await client.threads.get(key)) !== null,

registerAdeIpc(ipcMain, () => currentClient(), {
  // …
  onThreadRemoved: (key, kind) => {
    if (kind === "deleted") catalog.delete(key);
    else catalog.markArchived(key);
  },
});

authorize: (event, method) => isTrustedFrame(event.sender) && method !== "threads.delete",

webPreferences: {
  preload: require.resolve("@ade-dev/sdk/electron/preload-auto"),
  sandbox: true,
}

// preload.js — safe under sandbox: true. Requires nothing but "electron".
const { contextBridge, ipcRenderer } = require("electron");

const PREFIX = "ade"; // must equal registerAdeIpc's channelPrefix
const INVOKE = `${PREFIX}:invoke`;
const EVENT = `${PREFIX}:event`;

contextBridge.exposeInMainWorld("ade", {
  invoke(method, args) {
    return ipcRenderer.invoke(INVOKE, { method, args });
  },
  onEvent(listener) {
    const handler = (_event, payload) => listener(payload);
    ipcRenderer.on(EVENT, handler);
    return () => ipcRenderer.removeListener(EVENT, handler);
  },
});

import { checkAdeBridge } from "@ade-dev/sdk/electron";

// Run the bridge part of your preload with fakes, and compare it with the SDK's own.
await checkAdeBridge((contextBridge, ipcRenderer) => exposeMyBridge(contextBridge, ipcRenderer));

import "@ade-dev/sdk/electron/global"; // types window.ade
import { createAdeIpcClient } from "@ade-dev/sdk/electron/renderer";
import { adaptSdkClient, AdeChat } from "@ade-dev/chat-ui";

const client = adaptSdkClient(createAdeIpcClient(window.ade), {
  providerFilter: ["claude", "codex"],
});

export function App() {
  return <AdeChat client={client} threadKey="main" />;
}

// src/preload.ts
import { contextBridge, ipcRenderer } from "electron";
import { exposeAdeBridge } from "@ade-dev/sdk/electron/preload";

exposeAdeBridge(contextBridge, ipcRenderer); // key "ade", channel prefix "ade"

esbuild src/preload.ts --bundle --platform=node --format=cjs \
  --external:electron --outfile=dist/preload.js

registerAdeIpc(ipcMain, client, {
  allowThreadKey: (key) => catalog.has(key),
  openOptions: async (key, rendererOptions) => {
    const chat = await loadChat(key);      // your own catalog
    return {
      provider: chat.provider,
      model: chat.model,
      cwd: chat.cwd,
      permissions: { allowedTools: ["mcp:app:*"], fallback: "deny" },
      mcpServers: appMcpServers(),
      refresh: { mcpServers: appMcpServers() },   // current token on every open
    };
  },
});

openOptions: async (key, _rendererOptions, { exists, summary }) => {
  if (exists) return { refresh: { mcpServers: appMcpServers() } };   // resume: stored record applies
  return {                                                             // create, or recreate
    provider: "claude",
    model: await pickModel(),
    permissions: lockedPolicy,
    mcpServers: appMcpServers(),
  };
},

allowModel: (key, { modelId }) => allowedModels.has(modelId),

ipcMain.handle("app:pick-file", async () => {
  const result = await dialog.showOpenDialog({ properties: ["openFile"] });
  return result.filePaths[0] ?? null;
});

try {
  await thread.setModel(next);
} catch (error) {
  if (error.code === "turn_in_flight") showBusyHint();
}

if (error.code === "turn_in_flight") showHint("Wait for the reply to finish, then try again.");

const ipcClient = createAdeIpcClient(window.ade);

ipcClient.on("exit", ({ code, signal, error }) => showBanner("Chat stopped", error));
ipcClient.on("restart", ({ attempt, ok, final }) => {
  if (ok) reloadTranscript();
  else if (final) showBanner("Chat could not restart");   // no more attempts
});
ipcClient.on("transport", ({ state }) => setOnline(state === "reconnected"));
ipcClient.on("threadLifecycle", ({ key, change }) => refreshChatList(key, change));

let current = await createAdeChat({ home: homeFor(account) });

registerAdeIpc(ipcMain, () => current, { allowThreadKey, openOptions });

async function switchAccount(next) {
  const previous = current;
  current = await createAdeChat({ home: homeFor(next) });   // the bridge now serves this one
  await previous.dispose();
}