Initial Coworker app scaffold

apps/desktop/electron/main.ts

@@ -0,0 +1,416 @@
+import { app, BrowserWindow, dialog, ipcMain, shell } from "electron";
+import { createHash, randomBytes } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
+import { createServer, IncomingMessage, Server, ServerResponse } from "node:http";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  AppState,
+  BrainInput,
+  ModelProvider,
+  WebAccessSettings,
+  createBrainItem,
+  createPairedDevice,
+  createPairingChallenge,
+  createProvider,
+  isPairingChallengeValid,
+  nowIso,
+  probeOpenAiCompatibleProvider,
+  runAgent,
+  updateBrainItem
+} from "@coworker/core";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const rendererDir = path.resolve(__dirname, "../dist");
+const stateFile = () => path.join(app.getPath("userData"), "state.json");
+
+let mainWindow: BrowserWindow | undefined;
+let webServer: Server | undefined;
+let activePairing = createPairingChallenge(0);
+
+const defaultState: AppState = {
+  providers: [
+    createProvider("ollama", "Ollama", "http://localhost:11434/v1"),
+    createProvider("lmstudio", "LM Studio", "http://localhost:1234/v1")
+  ],
+  brain: [],
+  workspaces: [],
+  webAccess: {
+    enabled: false,
+    bindHost: "127.0.0.1",
+    port: 4789,
+    requirePairing: true
+  },
+  pairedDevices: []
+};
+
+async function readState(): Promise<AppState> {
+  try {
+    return { ...defaultState, ...JSON.parse(await readFile(stateFile(), "utf8")) };
+  } catch {
+    return defaultState;
+  }
+}
+
+async function writeState(state: AppState): Promise<AppState> {
+  await mkdir(path.dirname(stateFile()), { recursive: true });
+  await writeFile(stateFile(), JSON.stringify(state, null, 2), "utf8");
+  return state;
+}
+
+async function mutateState(mutator: (state: AppState) => AppState | Promise<AppState>): Promise<AppState> {
+  const current = await readState();
+  const next = await mutator(current);
+  return writeState(next);
+}
+
+function createWindow() {
+  mainWindow = new BrowserWindow({
+    width: 1320,
+    height: 860,
+    minWidth: 980,
+    minHeight: 680,
+    title: "Coworker",
+    backgroundColor: "#111317",
+    webPreferences: {
+      preload: path.join(__dirname, "preload.js"),
+      contextIsolation: true,
+      nodeIntegration: false
+    }
+  });
+
+  const devUrl = process.env.VITE_DEV_SERVER_URL;
+  if (devUrl) {
+    void mainWindow.loadURL(devUrl);
+  } else {
+    void mainWindow.loadFile(path.join(rendererDir, "index.html"));
+  }
+
+  mainWindow.webContents.setWindowOpenHandler(({ url }) => {
+    void shell.openExternal(url);
+    return { action: "deny" };
+  });
+}
+
+function registerIpc() {
+  ipcMain.handle("state:get", () => readState());
+
+  ipcMain.handle("providers:save", async (_event, provider: ModelProvider) => mutateState((state) => {
+    const next = { ...provider, baseUrl: provider.baseUrl.replace(/\/+$/, ""), updatedAt: nowIso() };
+    return {
+      ...state,
+      providers: state.providers.some((item) => item.id === next.id)
+        ? state.providers.map((item) => item.id === next.id ? next : item)
+        : [...state.providers, next]
+    };
+  }));
+
+  ipcMain.handle("providers:remove", async (_event, id: string) => mutateState((state) => ({
+    ...state,
+    providers: state.providers.filter((provider) => provider.id !== id)
+  })));
+
+  ipcMain.handle("providers:probe", async (_event, id: string) => {
+    const state = await readState();
+    const provider = state.providers.find((item) => item.id === id);
+    if (!provider) throw new Error("Provider not found.");
+    return probeOpenAiCompatibleProvider(provider);
+  });
+
+  ipcMain.handle("brain:add", async (_event, input: BrainInput) => mutateState((state) => ({
+    ...state,
+    brain: [createBrainItem(input), ...state.brain]
+  })));
+
+  ipcMain.handle("brain:update", async (_event, id: string, patch: Partial<BrainInput>) => mutateState((state) => ({
+    ...state,
+    brain: state.brain.map((item) => item.id === id ? updateBrainItem(item, patch) : item)
+  })));
+
+  ipcMain.handle("brain:remove", async (_event, id: string) => mutateState((state) => ({
+    ...state,
+    brain: state.brain.filter((item) => item.id !== id)
+  })));
+
+  ipcMain.handle("workspace:open", async () => {
+    const result = await dialog.showOpenDialog({ properties: ["openDirectory"] });
+    if (result.canceled || !result.filePaths[0]) return undefined;
+    const rootPath = result.filePaths[0];
+    const workspace = {
+      id: createHash("sha256").update(rootPath).digest("hex").slice(0, 16),
+      name: path.basename(rootPath),
+      rootPath,
+      openedAt: nowIso()
+    };
+    await mutateState((state) => ({
+      ...state,
+      workspaces: [workspace, ...state.workspaces.filter((item) => item.id !== workspace.id)]
+    }));
+    return workspace;
+  });
+
+  ipcMain.handle("workspace:list", async (_event, id: string) => {
+    const workspace = (await readState()).workspaces.find((item) => item.id === id);
+    if (!workspace) throw new Error("Workspace not found.");
+    const entries = await readdir(workspace.rootPath, { withFileTypes: true });
+    return Promise.all(entries.slice(0, 200).map(async (entry) => {
+      const absolute = path.join(workspace.rootPath, entry.name);
+      const info = await stat(absolute);
+      return {
+        path: entry.name,
+        type: entry.isDirectory() ? "directory" : "file",
+        size: entry.isFile() ? info.size : undefined,
+        modifiedAt: info.mtime.toISOString()
+      };
+    }));
+  });
+
+  ipcMain.handle("workspace:read", async (_event, id: string, relativePath: string) => {
+    const workspace = (await readState()).workspaces.find((item) => item.id === id);
+    if (!workspace) throw new Error("Workspace not found.");
+    const absolute = confinedPath(workspace.rootPath, relativePath);
+    const info = await stat(absolute);
+    if (!info.isFile() || info.size > 512 * 1024) throw new Error("File is not readable in preview.");
+    return readFile(absolute, "utf8");
+  });
+
+  ipcMain.handle("agent:run", async (_event, request) => {
+    const state = await readState();
+    const provider = request.providerId
+      ? state.providers.find((item) => item.id === request.providerId)
+      : state.providers.find((item) => item.enabled);
+    const model = request.model ?? provider?.defaults.coding ?? provider?.defaults.chat;
+    return runAgent(
+      {
+        prompt: String(request.prompt ?? ""),
+        workspace: request.workspace,
+        provider,
+        model,
+        messages: request.messages ?? [],
+        brain: state.brain
+      },
+      (messages) => completeWithProvider(provider, model, messages)
+    );
+  });
+
+  ipcMain.handle("web:settings", async (_event, settings: WebAccessSettings) => {
+    const state = await mutateState((current) => ({ ...current, webAccess: settings }));
+    await restartWebServer(state.webAccess);
+    return state;
+  });
+
+  ipcMain.handle("web:pairing:create", () => {
+    activePairing = createPairingChallenge();
+    return activePairing;
+  });
+}
+
+async function completeWithProvider(provider: ModelProvider | undefined, model: string | undefined, messages: { role: string; content: string }[]) {
+  if (!provider || !model) {
+    return "No model is configured yet. Add Ollama, LM Studio, or another OpenAI-compatible provider in Settings.";
+  }
+  const response = await fetch(`${provider.baseUrl.replace(/\/+$/, "")}/chat/completions`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...(provider.apiKey ? { Authorization: `Bearer ${provider.apiKey}` } : {})
+    },
+    body: JSON.stringify({
+      model,
+      messages: messages.map((message) => ({ role: message.role, content: message.content })),
+      temperature: 0.2
+    })
+  });
+  if (!response.ok) return `Model request failed with HTTP ${response.status}.`;
+  const body = await response.json() as { choices?: Array<{ message?: { content?: string } }> };
+  return body.choices?.[0]?.message?.content ?? "The model returned an empty response.";
+}
+
+function confinedPath(root: string, relativePath: string) {
+  const absolute = path.resolve(root, relativePath);
+  const normalizedRoot = path.resolve(root);
+  if (absolute !== normalizedRoot && !absolute.startsWith(`${normalizedRoot}${path.sep}`)) {
+    throw new Error("Path is outside the workspace.");
+  }
+  return absolute;
+}
+
+async function restartWebServer(settings: WebAccessSettings) {
+  if (webServer) {
+    await new Promise<void>((resolve) => webServer?.close(() => resolve()));
+    webServer = undefined;
+  }
+  if (!settings.enabled) return;
+  webServer = createServer(handleWebRequest);
+  await new Promise<void>((resolve, reject) => {
+    webServer?.listen(settings.port, settings.bindHost, resolve);
+    webServer?.on("error", reject);
+  });
+}
+
+async function handleWebRequest(req: IncomingMessage, res: ServerResponse) {
+  const url = new URL(req.url ?? "/", "http://coworker.local");
+  if (url.pathname === "/api/pair" && req.method === "POST") return handlePair(req, res);
+  if (url.pathname === "/api/state") return sendJson(res, await publicState(req));
+  if (url.pathname.startsWith("/api/") && !(await isAuthorized(req))) return sendJson(res, { error: "Pairing required." }, 401);
+  if (url.pathname === "/api/providers" && req.method === "POST") return handleWebProviderSave(req, res);
+  if (url.pathname.match(/^\/api\/providers\/[^/]+\/probe$/) && req.method === "POST") return handleWebProviderProbe(url, res);
+  if (url.pathname === "/api/brain" && req.method === "POST") return handleWebBrainAdd(req, res);
+  if (url.pathname.match(/^\/api\/brain\/[^/]+$/) && req.method === "DELETE") return handleWebBrainRemove(url, res);
+  if (url.pathname.match(/^\/api\/workspaces\/[^/]+\/files$/)) return handleWebWorkspaceList(url, res);
+  if (url.pathname.match(/^\/api\/workspaces\/[^/]+\/files\/.+$/)) return handleWebWorkspaceRead(url, res);
+  if (url.pathname === "/api/agent/run" && req.method === "POST") return handleWebAgent(req, res);
+  return serveStatic(url.pathname, res);
+}
+
+async function handlePair(req: IncomingMessage, res: ServerResponse) {
+  const body = await readJsonBody<{ code?: string; name?: string }>(req);
+  if (!isPairingChallengeValid(activePairing, body.code ?? "")) return sendJson(res, { error: "Invalid pairing code." }, 403);
+  const token = randomBytes(24).toString("hex");
+  const device = await createPairedDevice(body.name ?? "Mobile device", token, digest);
+  await mutateState((state) => ({ ...state, pairedDevices: [device, ...state.pairedDevices] }));
+  res.setHeader("Set-Cookie", `coworker_token=${token}; HttpOnly; SameSite=Lax; Path=/`);
+  sendJson(res, { token });
+}
+
+async function handleWebProviderSave(req: IncomingMessage, res: ServerResponse) {
+  const provider = await readJsonBody<ModelProvider>(req);
+  const state = await mutateState((current) => ({
+    ...current,
+    providers: current.providers.some((item) => item.id === provider.id)
+      ? current.providers.map((item) => item.id === provider.id ? { ...provider, updatedAt: nowIso() } : item)
+      : [...current.providers, { ...createProvider(provider.kind, provider.name, provider.baseUrl), ...provider, updatedAt: nowIso() }]
+  }));
+  sendJson(res, sanitizeState(state));
+}
+
+async function handleWebProviderProbe(url: URL, res: ServerResponse) {
+  const id = decodeURIComponent(url.pathname.split("/")[3]);
+  const provider = (await readState()).providers.find((item) => item.id === id);
+  if (!provider) return sendJson(res, { error: "Provider not found." }, 404);
+  sendJson(res, await probeOpenAiCompatibleProvider(provider));
+}
+
+async function handleWebBrainAdd(req: IncomingMessage, res: ServerResponse) {
+  const input = await readJsonBody<BrainInput>(req);
+  const state = await mutateState((current) => ({ ...current, brain: [createBrainItem(input), ...current.brain] }));
+  sendJson(res, sanitizeState(state));
+}
+
+async function handleWebBrainRemove(url: URL, res: ServerResponse) {
+  const id = decodeURIComponent(url.pathname.split("/")[3]);
+  const state = await mutateState((current) => ({ ...current, brain: current.brain.filter((item) => item.id !== id) }));
+  sendJson(res, sanitizeState(state));
+}
+
+async function handleWebWorkspaceList(url: URL, res: ServerResponse) {
+  const id = decodeURIComponent(url.pathname.split("/")[3]);
+  const workspace = (await readState()).workspaces.find((item) => item.id === id);
+  if (!workspace) return sendJson(res, { error: "Workspace not found." }, 404);
+  const entries = await readdir(workspace.rootPath, { withFileTypes: true });
+  const files = await Promise.all(entries.slice(0, 200).map(async (entry) => {
+    const absolute = path.join(workspace.rootPath, entry.name);
+    const info = await stat(absolute);
+    return {
+      path: entry.name,
+      type: entry.isDirectory() ? "directory" : "file",
+      size: entry.isFile() ? info.size : undefined,
+      modifiedAt: info.mtime.toISOString()
+    };
+  }));
+  sendJson(res, files);
+}
+
+async function handleWebWorkspaceRead(url: URL, res: ServerResponse) {
+  const parts = url.pathname.split("/");
+  const id = decodeURIComponent(parts[3]);
+  const relativePath = decodeURIComponent(parts.slice(5).join("/"));
+  const workspace = (await readState()).workspaces.find((item) => item.id === id);
+  if (!workspace) return sendJson(res, { error: "Workspace not found." }, 404);
+  const absolute = confinedPath(workspace.rootPath, relativePath);
+  const info = await stat(absolute);
+  if (!info.isFile() || info.size > 512 * 1024) return sendJson(res, { error: "File is not readable in preview." }, 400);
+  sendJson(res, { content: await readFile(absolute, "utf8") });
+}
+
+async function handleWebAgent(req: IncomingMessage, res: ServerResponse) {
+  const body = await readJsonBody<{ prompt?: string; messages?: unknown[]; providerId?: string; model?: string }>(req);
+  const state = await readState();
+  const provider = body.providerId ? state.providers.find((item) => item.id === body.providerId) : state.providers[0];
+  const result = await runAgent(
+    { prompt: body.prompt ?? "", messages: [], brain: state.brain, provider, model: body.model },
+    (messages) => completeWithProvider(provider, body.model ?? provider?.defaults.chat, messages)
+  );
+  sendJson(res, result);
+}
+
+async function publicState(req: IncomingMessage) {
+  const state = await readState();
+  const paired = await isAuthorized(req);
+  return {
+    paired,
+    webAccess: state.webAccess,
+    providers: paired ? state.providers.map(({ apiKey, ...provider }) => provider) : [],
+    brain: paired ? state.brain : [],
+    workspaces: paired ? state.workspaces : []
+  };
+}
+
+async function isAuthorized(req: IncomingMessage) {
+  const token = (req.headers.cookie ?? "").split(";").map((item) => item.trim()).find((item) => item.startsWith("coworker_token="))?.split("=")[1];
+  if (!token) return false;
+  const hash = await digest(token);
+  const state = await readState();
+  return state.pairedDevices.some((device) => !device.revokedAt && device.tokenHash === hash);
+}
+
+async function digest(value: string) {
+  return createHash("sha256").update(value).digest("hex");
+}
+
+function sanitizeState(state: AppState): AppState {
+  return {
+    ...state,
+    providers: state.providers.map(({ apiKey, ...provider }) => provider),
+    pairedDevices: state.pairedDevices.map((device) => ({ ...device, tokenHash: "" }))
+  };
+}
+
+async function readJsonBody<T>(req: IncomingMessage): Promise<T> {
+  const chunks: Buffer[] = [];
+  for await (const chunk of req) chunks.push(Buffer.from(chunk));
+  return JSON.parse(Buffer.concat(chunks).toString("utf8") || "{}") as T;
+}
+
+function sendJson(res: ServerResponse, data: unknown, status = 200) {
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(data));
+}
+
+function serveStatic(urlPath: string, res: ServerResponse) {
+  try {
+    const safePath = urlPath === "/" ? "index.html" : urlPath.replace(/^\/+/, "");
+    const absolute = confinedPath(rendererDir, safePath);
+    const finalPath = absolute.endsWith(path.sep) ? path.join(absolute, "index.html") : absolute;
+    createReadStream(finalPath)
+      .on("error", () => createReadStream(path.join(rendererDir, "index.html")).pipe(res))
+      .pipe(res);
+  } catch {
+    res.writeHead(403);
+    res.end("Forbidden");
+  }
+}
+
+app.whenReady().then(async () => {
+  registerIpc();
+  createWindow();
+  await restartWebServer((await readState()).webAccess);
+  app.on("activate", () => {
+    if (BrowserWindow.getAllWindows().length === 0) createWindow();
+  });
+});
+
+app.on("window-all-closed", () => {
+  if (process.platform !== "darwin") app.quit();
+});