@uniqueli/openwork 0.1.0

package/out/preload/index.js

@@ -0,0 +1,170 @@
+"use strict";
+const electron = require("electron");
+const electronAPI = {
+  ipcRenderer: {
+    send: (channel, ...args) => electron.ipcRenderer.send(channel, ...args),
+    on: (channel, listener) => {
+      electron.ipcRenderer.on(channel, (_event, ...args) => listener(...args));
+      return () => electron.ipcRenderer.removeListener(channel, listener);
+    },
+    once: (channel, listener) => {
+      electron.ipcRenderer.once(channel, (_event, ...args) => listener(...args));
+    },
+    invoke: (channel, ...args) => electron.ipcRenderer.invoke(channel, ...args)
+  },
+  process: {
+    platform: process.platform,
+    versions: process.versions
+  }
+};
+const api = {
+  agent: {
+    // Send message and receive events via callback
+    invoke: (threadId, message, onEvent) => {
+      const channel = `agent:stream:${threadId}`;
+      const handler = (_, data) => {
+        onEvent(data);
+        if (data.type === "done" || data.type === "error") {
+          electron.ipcRenderer.removeListener(channel, handler);
+        }
+      };
+      electron.ipcRenderer.on(channel, handler);
+      electron.ipcRenderer.send("agent:invoke", { threadId, message });
+      return () => {
+        electron.ipcRenderer.removeListener(channel, handler);
+      };
+    },
+    // Stream agent events for useStream transport
+    streamAgent: (threadId, message, command, onEvent) => {
+      const channel = `agent:stream:${threadId}`;
+      const handler = (_, data) => {
+        onEvent(data);
+        if (data.type === "done" || data.type === "error") {
+          electron.ipcRenderer.removeListener(channel, handler);
+        }
+      };
+      electron.ipcRenderer.on(channel, handler);
+      if (command) {
+        electron.ipcRenderer.send("agent:resume", { threadId, command });
+      } else {
+        electron.ipcRenderer.send("agent:invoke", { threadId, message });
+      }
+      return () => {
+        electron.ipcRenderer.removeListener(channel, handler);
+      };
+    },
+    interrupt: (threadId, decision, onEvent) => {
+      const channel = `agent:stream:${threadId}`;
+      const handler = (_, data) => {
+        onEvent?.(data);
+        if (data.type === "done" || data.type === "error") {
+          electron.ipcRenderer.removeListener(channel, handler);
+        }
+      };
+      electron.ipcRenderer.on(channel, handler);
+      electron.ipcRenderer.send("agent:interrupt", { threadId, decision });
+      return () => {
+        electron.ipcRenderer.removeListener(channel, handler);
+      };
+    },
+    cancel: (threadId) => {
+      return electron.ipcRenderer.invoke("agent:cancel", { threadId });
+    }
+  },
+  threads: {
+    list: () => {
+      return electron.ipcRenderer.invoke("threads:list");
+    },
+    get: (threadId) => {
+      return electron.ipcRenderer.invoke("threads:get", threadId);
+    },
+    create: (metadata) => {
+      return electron.ipcRenderer.invoke("threads:create", metadata);
+    },
+    update: (threadId, updates) => {
+      return electron.ipcRenderer.invoke("threads:update", { threadId, updates });
+    },
+    delete: (threadId) => {
+      return electron.ipcRenderer.invoke("threads:delete", threadId);
+    },
+    getHistory: (threadId) => {
+      return electron.ipcRenderer.invoke("threads:history", threadId);
+    },
+    generateTitle: (message) => {
+      return electron.ipcRenderer.invoke("threads:generateTitle", message);
+    }
+  },
+  models: {
+    list: () => {
+      return electron.ipcRenderer.invoke("models:list");
+    },
+    listProviders: () => {
+      return electron.ipcRenderer.invoke("models:listProviders");
+    },
+    getDefault: () => {
+      return electron.ipcRenderer.invoke("models:getDefault");
+    },
+    setDefault: (modelId) => {
+      return electron.ipcRenderer.invoke("models:setDefault", modelId);
+    },
+    setApiKey: (provider, apiKey) => {
+      return electron.ipcRenderer.invoke("models:setApiKey", { provider, apiKey });
+    },
+    getApiKey: (provider) => {
+      return electron.ipcRenderer.invoke("models:getApiKey", provider);
+    },
+    deleteApiKey: (provider) => {
+      return electron.ipcRenderer.invoke("models:deleteApiKey", provider);
+    },
+    getCustomApiConfig: () => {
+      return electron.ipcRenderer.invoke("models:getCustomApiConfig");
+    },
+    setCustomApiConfig: (config) => {
+      return electron.ipcRenderer.invoke("models:setCustomApiConfig", config);
+    },
+    deleteCustomApiConfig: () => {
+      return electron.ipcRenderer.invoke("models:deleteCustomApiConfig");
+    }
+  },
+  workspace: {
+    get: (threadId) => {
+      return electron.ipcRenderer.invoke("workspace:get", threadId);
+    },
+    set: (threadId, path) => {
+      return electron.ipcRenderer.invoke("workspace:set", { threadId, path });
+    },
+    select: (threadId) => {
+      return electron.ipcRenderer.invoke("workspace:select", threadId);
+    },
+    loadFromDisk: (threadId) => {
+      return electron.ipcRenderer.invoke("workspace:loadFromDisk", { threadId });
+    },
+    readFile: (threadId, filePath) => {
+      return electron.ipcRenderer.invoke("workspace:readFile", { threadId, filePath });
+    },
+    readBinaryFile: (threadId, filePath) => {
+      return electron.ipcRenderer.invoke("workspace:readBinaryFile", { threadId, filePath });
+    },
+    // Listen for file changes in the workspace
+    onFilesChanged: (callback) => {
+      const handler = (_, data) => {
+        callback(data);
+      };
+      electron.ipcRenderer.on("workspace:files-changed", handler);
+      return () => {
+        electron.ipcRenderer.removeListener("workspace:files-changed", handler);
+      };
+    }
+  }
+};
+if (process.contextIsolated) {
+  try {
+    electron.contextBridge.exposeInMainWorld("electron", electronAPI);
+    electron.contextBridge.exposeInMainWorld("api", api);
+  } catch (error) {
+    console.error(error);
+  }
+} else {
+  window.electron = electronAPI;
+  window.api = api;
+}