@cryptiklemur/lattice 4.0.1 → 5.0.0

package/src/server/handlers/attachment.ts

@@ -1,189 +0,0 @@
-import type { Attachment } from "#shared";
-import type { AttachmentChunkMessage, AttachmentCompleteMessage, ClientMessage } from "#shared";
-import { registerHandler } from "../ws/router";
-import { sendTo } from "../ws/broadcast";
-
-var MAX_ATTACHMENT_SIZE = 10 * 1024 * 1024;
-
-interface PendingUpload {
-  chunks: Map<number, Buffer>;
-  totalChunks: number;
-  receivedCount: number;
-  totalBytes: number;
-  createdAt: number;
-}
-
-var stores = new Map<string, Map<string, PendingUpload>>();
-var completed = new Map<string, Map<string, Attachment>>();
-
-var TTL_MS = 5 * 60 * 1000;
-var CLEANUP_INTERVAL_MS = 60 * 1000;
-
-function getClientStore(clientId: string): Map<string, PendingUpload> {
-  var store = stores.get(clientId);
-  if (!store) {
-    store = new Map();
-    stores.set(clientId, store);
-  }
-  return store;
-}
-
-function getClientCompleted(clientId: string): Map<string, Attachment> {
-  var store = completed.get(clientId);
-  if (!store) {
-    store = new Map();
-    completed.set(clientId, store);
-  }
-  return store;
-}
-
-registerHandler("attachment", function (clientId: string, message: ClientMessage) {
-  if (message.type === "attachment:chunk") {
-    var msg = message as AttachmentChunkMessage;
-    var store = getClientStore(clientId);
-
-    var pending = store.get(msg.attachmentId);
-    if (!pending) {
-      pending = {
-        chunks: new Map(),
-        totalChunks: msg.totalChunks,
-        receivedCount: 0,
-        totalBytes: 0,
-        createdAt: Date.now(),
-      };
-      store.set(msg.attachmentId, pending);
-    }
-
-    if (pending.chunks.has(msg.chunkIndex)) {
-      sendTo(clientId, {
-        type: "attachment:error",
-        attachmentId: msg.attachmentId,
-        error: "Duplicate chunk index: " + msg.chunkIndex,
-      });
-      return;
-    }
-
-    var chunkBuffer = Buffer.from(msg.data, "base64");
-    if (pending.totalBytes + chunkBuffer.length > MAX_ATTACHMENT_SIZE) {
-      store.delete(msg.attachmentId);
-      sendTo(clientId, {
-        type: "attachment:error",
-        attachmentId: msg.attachmentId,
-        error: "Attachment exceeds maximum size of " + (MAX_ATTACHMENT_SIZE / 1024 / 1024) + "MB",
-      });
-      return;
-    }
-
-    pending.chunks.set(msg.chunkIndex, chunkBuffer);
-    pending.receivedCount++;
-    pending.totalBytes += chunkBuffer.length;
-
-    sendTo(clientId, {
-      type: "attachment:progress",
-      attachmentId: msg.attachmentId,
-      received: pending.receivedCount,
-      total: pending.totalChunks,
-    });
-    return;
-  }
-
-  if (message.type === "attachment:complete") {
-    var completeMsg = message as AttachmentCompleteMessage;
-    var completeStore = getClientStore(clientId);
-    var completePending = completeStore.get(completeMsg.attachmentId);
-
-    if (!completePending) {
-      sendTo(clientId, {
-        type: "attachment:error",
-        attachmentId: completeMsg.attachmentId,
-        error: "No chunks received for this attachment",
-      });
-      return;
-    }
-
-    if (completePending.receivedCount !== completePending.totalChunks) {
-      sendTo(clientId, {
-        type: "attachment:error",
-        attachmentId: completeMsg.attachmentId,
-        error: "Missing chunks: received " + completePending.receivedCount + " of " + completePending.totalChunks,
-      });
-      return;
-    }
-
-    var buffers: Buffer[] = [];
-    for (var ci = 0; ci < completePending.totalChunks; ci++) {
-      var chunk = completePending.chunks.get(ci);
-      if (!chunk) {
-        sendTo(clientId, {
-          type: "attachment:error",
-          attachmentId: completeMsg.attachmentId,
-          error: "Missing chunk at index " + ci,
-        });
-        return;
-      }
-      buffers.push(chunk);
-    }
-
-    var assembled = Buffer.concat(buffers);
-    var isText = completeMsg.attachmentType === "paste" || isTextMimeType(completeMsg.mimeType);
-    var content = isText ? assembled.toString("utf-8") : assembled.toString("base64");
-
-    var attachment: Attachment = {
-      type: completeMsg.attachmentType,
-      name: completeMsg.name,
-      content,
-      mimeType: completeMsg.mimeType,
-      size: completeMsg.size,
-      lineCount: completeMsg.lineCount,
-    };
-
-    var finishedStore = getClientCompleted(clientId);
-    finishedStore.set(completeMsg.attachmentId, attachment);
-    completeStore.delete(completeMsg.attachmentId);
-    return;
-  }
-});
-
-function isTextMimeType(mime: string): boolean {
-  if (mime.startsWith("text/")) return true;
-  var textTypes = [
-    "application/json",
-    "application/xml",
-    "application/javascript",
-    "application/typescript",
-    "application/x-yaml",
-    "application/yaml",
-    "image/svg+xml",
-  ];
-  return textTypes.indexOf(mime) !== -1;
-}
-
-export function getAttachments(clientId: string, ids: string[]): Attachment[] {
-  var store = getClientCompleted(clientId);
-  var result: Attachment[] = [];
-  for (var i = 0; i < ids.length; i++) {
-    var att = store.get(ids[i]);
-    if (att) {
-      result.push(att);
-      store.delete(ids[i]);
-    }
-  }
-  return result;
-}
-
-export function cleanupClient(clientId: string): void {
-  stores.delete(clientId);
-  completed.delete(clientId);
-}
-
-var ttlCleanupInterval = setInterval(function () {
-  var now = Date.now();
-  stores.forEach(function (store) {
-    store.forEach(function (pending, id) {
-      if (now - pending.createdAt > TTL_MS) {
-        store.delete(id);
-      }
-    });
-  });
-}, CLEANUP_INTERVAL_MS);
-ttlCleanupInterval.unref();

package/src/server/handlers/bookmarks.ts

@@ -1,50 +0,0 @@
-import type {
-  ClientMessage,
-  BookmarkListMessage,
-  BookmarkAddMessage,
-  BookmarkRemoveMessage,
-} from "#shared";
-import { registerHandler } from "../ws/router";
-import { sendTo } from "../ws/broadcast";
-import { listBookmarks, addBookmark, removeBookmark } from "../project/bookmarks";
-
-registerHandler("bookmark", function (clientId: string, message: ClientMessage) {
-  if (message.type === "bookmark:list") {
-    var listMsg = message as BookmarkListMessage;
-    var isSessionScoped = Boolean(listMsg.sessionId);
-    sendTo(clientId, {
-      type: "bookmark:list_result",
-      scope: isSessionScoped ? "session" : "all",
-      bookmarks: listBookmarks(listMsg.projectSlug, listMsg.sessionId),
-    });
-    return;
-  }
-
-  if (message.type === "bookmark:add") {
-    var addMsg = message as BookmarkAddMessage;
-    addBookmark({
-      sessionId: addMsg.sessionId,
-      projectSlug: addMsg.projectSlug,
-      messageUuid: addMsg.messageUuid,
-      messageText: addMsg.messageText,
-      messageType: addMsg.messageType,
-    });
-    sendTo(clientId, {
-      type: "bookmark:list_result",
-      scope: "session",
-      bookmarks: listBookmarks(addMsg.projectSlug, addMsg.sessionId),
-    });
-    return;
-  }
-
-  if (message.type === "bookmark:remove") {
-    var removeMsg = message as BookmarkRemoveMessage;
-    removeBookmark(removeMsg.id);
-    sendTo(clientId, {
-      type: "bookmark:list_result",
-      scope: "all",
-      bookmarks: listBookmarks(),
-    });
-    return;
-  }
-});

package/src/server/handlers/chat.ts

@@ -1,381 +0,0 @@
-import type { ChatSendMessage, ChatPermissionResponseMessage, ChatSetPermissionModeMessage, ChatPromptResponseMessage, ClientMessage } from "#shared";
-import { registerHandler } from "../ws/router";
-import { sendTo } from "../ws/broadcast";
-import { getProjectBySlug } from "../project/registry";
-import { loadConfig } from "../config";
-import { startChatStream, getPendingPermission, deletePendingPermission, addAutoApprovedTool, setSessionPermissionOverride, getActiveStream, getSessionStream, buildPermissionRule, getPendingElicitation, resolveElicitation } from "../project/sdk-bridge";
-import { getAttachments } from "./attachment";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { getDailySpend } from "../analytics/engine";
-import { log } from "../logger";
-
-function formatSdkRule(rule: { toolName: string; ruleContent?: string }): string {
-  if (!rule.ruleContent) return rule.toolName;
-  if (rule.toolName === "Bash") {
-    var firstWord = rule.ruleContent.split(/\s+/)[0].replace(/:.*$/, "");
-    if (firstWord === "curl" || firstWord === "wget") {
-      var urlMatch = rule.ruleContent.match(/https?:\/\/[^\s"']+/);
-      if (urlMatch) {
-        try {
-          var parsed = new URL(urlMatch[0]);
-          return rule.toolName + "(" + firstWord + ":" + parsed.hostname + ")";
-        } catch {}
-      }
-    }
-    return rule.toolName + "(" + firstWord + ":*)";
-  }
-  return rule.toolName + "(" + rule.ruleContent + ")";
-}
-
-function addProjectAllowRules(projectPath: string, suggestions: Array<{ type: string; rules?: Array<{ toolName: string; ruleContent?: string }>; directories?: string[]; behavior?: string }> | undefined, fallbackToolName: string, fallbackInput: Record<string, unknown>): void {
-  var claudeDir = join(projectPath, ".claude");
-  var settingsPath = join(claudeDir, "settings.json");
-
-  var settings: Record<string, unknown> = {};
-  if (existsSync(settingsPath)) {
-    try {
-      settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
-    } catch {
-      settings = {};
-    }
-  }
-
-  if (!settings.permissions) {
-    settings.permissions = {};
-  }
-  var permissions = settings.permissions as Record<string, unknown>;
-  if (!Array.isArray(permissions.allow)) {
-    permissions.allow = [];
-  }
-  if (!Array.isArray(permissions.additionalDirectories)) {
-    permissions.additionalDirectories = [];
-  }
-  var allowList = permissions.allow as string[];
-  var additionalDirs = permissions.additionalDirectories as string[];
-
-  if (suggestions && suggestions.length > 0) {
-    for (var si = 0; si < suggestions.length; si++) {
-      var suggestion = suggestions[si];
-      if (suggestion.type === "addRules" && suggestion.behavior === "allow" && suggestion.rules) {
-        for (var ri = 0; ri < suggestion.rules.length; ri++) {
-          var rule = formatSdkRule(suggestion.rules[ri]);
-          if (!allowList.includes(rule)) {
-            allowList.push(rule);
-          }
-          if (suggestion.rules[ri].ruleContent) {
-            var ruleDir = suggestion.rules[ri].ruleContent!.replace(/\/\*\*$/, "").replace(/^\//, "");
-            if (ruleDir.startsWith("/") && !additionalDirs.includes(ruleDir)) {
-              additionalDirs.push(ruleDir);
-            }
-          }
-        }
-      }
-      if (suggestion.type === "addDirectories" && suggestion.directories) {
-        for (var di = 0; di < suggestion.directories.length; di++) {
-          if (!additionalDirs.includes(suggestion.directories[di])) {
-            additionalDirs.push(suggestion.directories[di]);
-          }
-        }
-      }
-    }
-  } else {
-    var fallbackRule = buildPermissionRule(fallbackToolName, fallbackInput);
-    if (!allowList.includes(fallbackRule)) {
-      allowList.push(fallbackRule);
-    }
-  }
-
-  if (!existsSync(claudeDir)) {
-    mkdirSync(claudeDir, { recursive: true });
-  }
-  writeFileSync(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
-}
-
-var activeSessionByClient = new Map<string, { projectSlug: string; sessionId: string }>();
-var pendingBudgetOverride = new Map<string, { projectSlug: string; sessionId: string; sendMsg: ChatSendMessage; env: Record<string, string> | undefined; cwd: string; }>();
-
-export function sendBudgetStatus(clientId: string): void {
-  var config = loadConfig();
-  if (!config.costBudget) return;
-  var dailySpend = getDailySpend();
-  sendTo(clientId, {
-    type: "budget:status",
-    dailySpend: dailySpend,
-    dailyLimit: config.costBudget.dailyLimit,
-    enforcement: config.costBudget.enforcement,
-  } as never);
-}
-
-export function setActiveSession(clientId: string, projectSlug: string, sessionId: string): void {
-  activeSessionByClient.set(clientId, { projectSlug, sessionId });
-}
-
-export function clearActiveSession(clientId: string): void {
-  activeSessionByClient.delete(clientId);
-}
-
-export function getActiveSession(clientId: string): { projectSlug: string; sessionId: string } | undefined {
-  return activeSessionByClient.get(clientId);
-}
-
-registerHandler("budget", function (clientId: string, message: ClientMessage) {
-  if (message.type === "budget:override") {
-    var pending = pendingBudgetOverride.get(clientId);
-    if (!pending) return;
-    pendingBudgetOverride.delete(clientId);
-
-    var overrideAttachments = pending.sendMsg.attachmentIds
-      ? getAttachments(clientId, pending.sendMsg.attachmentIds)
-      : [];
-
-    startChatStream({
-      projectSlug: pending.projectSlug,
-      sessionId: pending.sessionId,
-      text: pending.sendMsg.text,
-      attachments: overrideAttachments,
-      clientId,
-      cwd: pending.cwd,
-      env: pending.env,
-      model: pending.sendMsg.model,
-      effort: pending.sendMsg.effort as "low" | "medium" | "high" | "max" | undefined,
-    });
-    return;
-  }
-});
-
-registerHandler("chat", function (clientId: string, message: ClientMessage) {
-  if (message.type === "chat:send") {
-    var sendMsg = message as ChatSendMessage;
-    var active = activeSessionByClient.get(clientId);
-
-    if (!active) {
-      sendTo(clientId, { type: "chat:error", message: "No active session. Activate a session first." });
-      return;
-    }
-
-    var project = getProjectBySlug(active.projectSlug);
-    if (!project) {
-      sendTo(clientId, { type: "chat:error", message: `Project not found: ${active.projectSlug}` });
-      return;
-    }
-
-    var config = loadConfig();
-    var env = Object.assign({}, config.globalEnv, project.env);
-
-    if (config.costBudget && config.costBudget.dailyLimit > 0) {
-      var dailySpend = getDailySpend();
-      if (dailySpend >= config.costBudget.dailyLimit) {
-        if (config.costBudget.enforcement === "hard-block") {
-          sendTo(clientId, { type: "chat:error", message: "Daily cost budget exceeded ($" + dailySpend.toFixed(2) + " / $" + config.costBudget.dailyLimit.toFixed(2) + "). Sending is blocked until tomorrow." });
-          return;
-        }
-        if (config.costBudget.enforcement === "soft-block") {
-          pendingBudgetOverride.set(clientId, {
-            projectSlug: active.projectSlug,
-            sessionId: active.sessionId,
-            sendMsg: sendMsg,
-            env: Object.keys(env).length > 0 ? env : undefined,
-            cwd: project.path,
-          });
-          sendTo(clientId, {
-            type: "budget:exceeded",
-            dailySpend: dailySpend,
-            dailyLimit: config.costBudget.dailyLimit,
-          } as never);
-          return;
-        }
-      }
-    }
-
-    var attachments = sendMsg.attachmentIds
-      ? getAttachments(clientId, sendMsg.attachmentIds)
-      : [];
-
-    startChatStream({
-      projectSlug: active.projectSlug,
-      sessionId: active.sessionId,
-      text: sendMsg.text,
-      attachments,
-      clientId,
-      cwd: project.path,
-      env: Object.keys(env).length > 0 ? env : undefined,
-      model: sendMsg.model,
-      effort: sendMsg.effort as "low" | "medium" | "high" | "max" | undefined,
-    });
-
-    return;
-  }
-
-  if (message.type === "chat:cancel") {
-    var active = activeSessionByClient.get(clientId);
-    if (!active) {
-      sendTo(clientId, { type: "chat:error", message: "No active session." });
-      return;
-    }
-    var stream = getActiveStream(active.sessionId);
-    if (!stream) {
-      sendTo(clientId, { type: "chat:error", message: "No active stream to cancel." });
-      return;
-    }
-    stream.interrupt().catch(function () {});
-    return;
-  }
-
-  if (message.type === "chat:permission_response") {
-    var permMsg = message as ChatPermissionResponseMessage;
-    var pending = getPendingPermission(permMsg.requestId);
-    if (!pending) {
-      return;
-    }
-
-    var active = activeSessionByClient.get(clientId);
-
-    if (permMsg.allow) {
-      if (permMsg.alwaysAllow && permMsg.alwaysAllowScope === "session" && active) {
-        addAutoApprovedTool(active.sessionId, pending.toolName);
-      }
-
-      if (permMsg.alwaysAllow && permMsg.alwaysAllowScope === "project" && active) {
-        var project = getProjectBySlug(active.projectSlug);
-        if (project) {
-          addProjectAllowRules(project.path, pending.suggestions as any, pending.toolName, pending.input);
-        }
-        pending.resolve({ behavior: "allow", updatedInput: pending.input, toolUseID: pending.toolUseID });
-      } else {
-        pending.resolve({ behavior: "allow", updatedInput: pending.input, toolUseID: pending.toolUseID });
-      }
-
-      var resolvedStatus = permMsg.alwaysAllow ? "always_allowed" : "allowed";
-      sendTo(clientId, { type: "chat:permission_resolved", requestId: permMsg.requestId, status: resolvedStatus });
-    } else {
-      pending.resolve({ behavior: "deny", message: "User denied this operation.", toolUseID: pending.toolUseID });
-      sendTo(clientId, { type: "chat:permission_resolved", requestId: permMsg.requestId, status: "denied" });
-    }
-
-    deletePendingPermission(permMsg.requestId);
-    return;
-  }
-
-  if (message.type === "chat:prompt_response") {
-    var promptRespMsg = message as ChatPromptResponseMessage;
-    var pendingPrompt = getPendingPermission(promptRespMsg.requestId);
-    if (!pendingPrompt || pendingPrompt.promptType !== "question") {
-      return;
-    }
-
-    var updatedInput = Object.assign({}, pendingPrompt.input, {
-      answers: promptRespMsg.answers,
-    });
-    if (promptRespMsg.annotations) {
-      (updatedInput as Record<string, unknown>).annotations = promptRespMsg.annotations;
-    }
-
-    pendingPrompt.resolve({
-      behavior: "allow",
-      updatedInput: updatedInput,
-      toolUseID: pendingPrompt.toolUseID,
-    });
-
-    sendTo(clientId, { type: "chat:prompt_resolved", requestId: promptRespMsg.requestId });
-    deletePendingPermission(promptRespMsg.requestId);
-    return;
-  }
-
-  if ((message as any).type === "chat:elicitation_response") {
-    var elicitMsg = message as { type: string; requestId: string; action: "accept" | "decline"; content?: Record<string, unknown> };
-    var pendingElicit = getPendingElicitation(elicitMsg.requestId);
-    if (!pendingElicit) return;
-    resolveElicitation(elicitMsg.requestId, {
-      action: elicitMsg.action,
-      content: elicitMsg.content || {},
-    });
-    return;
-  }
-
-  if ((message as any).type === "chat:rewind_preview") {
-    var rewindMsg = message as { type: string; messageUuid: string };
-    var activeForRewind = activeSessionByClient.get(clientId);
-    if (!activeForRewind) return;
-
-    var sessionStreamForRewind = getSessionStream(activeForRewind.sessionId);
-    if (!sessionStreamForRewind) {
-      sendTo(clientId, { type: "chat:rewind_preview_result", messageUuid: rewindMsg.messageUuid, canRewind: false, error: "No active stream for rewind" } as any);
-      return;
-    }
-
-    void sessionStreamForRewind.queryInstance.rewindFiles(rewindMsg.messageUuid, { dryRun: true }).then(function (result) {
-      sendTo(clientId, {
-        type: "chat:rewind_preview_result",
-        messageUuid: rewindMsg.messageUuid,
-        canRewind: result.canRewind,
-        error: result.error,
-        filesChanged: (result.filesChanged || []).length,
-        filesCreated: 0,
-        filesDeleted: 0,
-      } as any);
-    }).catch(function (err) {
-      sendTo(clientId, { type: "chat:rewind_preview_result", messageUuid: rewindMsg.messageUuid, canRewind: false, error: String(err) } as any);
-    });
-    return;
-  }
-
-  if ((message as any).type === "chat:rewind_execute") {
-    var execRewindMsg = message as { type: string; messageUuid: string; mode: string };
-    var activeForExec = activeSessionByClient.get(clientId);
-    if (!activeForExec) return;
-
-    var sessionStreamForExec = getSessionStream(activeForExec.sessionId);
-    if (!sessionStreamForExec) {
-      sendTo(clientId, { type: "chat:rewind_execute_result", messageUuid: execRewindMsg.messageUuid, success: false, error: "No active stream" } as any);
-      return;
-    }
-
-    if (execRewindMsg.mode === "files" || execRewindMsg.mode === "both") {
-      void sessionStreamForExec.queryInstance.rewindFiles(execRewindMsg.messageUuid, { dryRun: false }).then(function (result) {
-        sendTo(clientId, {
-          type: "chat:rewind_execute_result",
-          messageUuid: execRewindMsg.messageUuid,
-          success: result.canRewind,
-          error: result.error,
-        } as any);
-      }).catch(function (err) {
-        sendTo(clientId, { type: "chat:rewind_execute_result", messageUuid: execRewindMsg.messageUuid, success: false, error: String(err) } as any);
-      });
-    } else {
-      sendTo(clientId, { type: "chat:rewind_execute_result", messageUuid: execRewindMsg.messageUuid, success: true } as any);
-    }
-    return;
-  }
-
-  if ((message as any).type === "chat:set_model") {
-    var modelMsg = message as { type: string; model: string };
-    var activeSession = activeSessionByClient.get(clientId);
-    if (!activeSession) return;
-
-    var sessionStream = getSessionStream(activeSession.sessionId);
-    if (sessionStream) {
-      void sessionStream.queryInstance.setModel(modelMsg.model === "default" ? undefined : modelMsg.model).catch(function (err) {
-        log.chat("Failed to switch model: %O", err);
-      });
-      sessionStream.currentModel = modelMsg.model;
-    }
-    return;
-  }
-
-  if (message.type === "chat:set_permission_mode") {
-    var modeMsg = message as ChatSetPermissionModeMessage;
-    var activeSession = activeSessionByClient.get(clientId);
-    if (!activeSession) {
-      return;
-    }
-
-    var stream = getActiveStream(activeSession.sessionId);
-    if (stream) {
-      void stream.setPermissionMode(modeMsg.mode);
-    } else {
-      setSessionPermissionOverride(activeSession.sessionId, modeMsg.mode);
-    }
-    return;
-  }
-});

package/src/server/handlers/editor.ts

@@ -1,76 +0,0 @@
-import { execSync } from "node:child_process";
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import type { ClientMessage, EditorDetectMessage, EditorEnsureProjectMessage } from "#shared";
-import { registerHandler } from "../ws/router";
-import { sendTo } from "../ws/broadcast";
-import { loadConfig } from "../config";
-import { loadOrCreateIdentity } from "../identity";
-import { broadcast } from "../ws/broadcast";
-import { detectIdeProjectName } from "./settings";
-
-var binaryNames: Record<string, string[]> = {
-  "vscode": ["code"],
-  "vscode-insiders": ["code-insiders"],
-  "cursor": ["cursor"],
-  "webstorm": ["webstorm", "webstorm.sh", "wstorm"],
-  "intellij": ["idea", "idea.sh"],
-  "pycharm": ["pycharm", "pycharm.sh", "charm"],
-  "goland": ["goland", "goland.sh"],
-  "notepad++": ["notepad++"],
-  "sublime": ["subl", "sublime_text"],
-};
-
-function detectEditorPath(editorType: string): string | null {
-  var names = binaryNames[editorType];
-  if (!names) return null;
-
-  for (var i = 0; i < names.length; i++) {
-    try {
-      var result = execSync("which " + names[i], { encoding: "utf-8", timeout: 3000 }).trim();
-      if (result) return result;
-    } catch {
-      // not found
-    }
-  }
-  return null;
-}
-
-function ensureIdeaProject(projectPath: string, projectTitle: string): string {
-  var ideaDir = join(projectPath, ".idea");
-  if (!existsSync(ideaDir)) {
-    mkdirSync(ideaDir, { recursive: true });
-  }
-  var nameFile = join(ideaDir, ".name");
-  if (!existsSync(nameFile)) {
-    writeFileSync(nameFile, projectTitle, "utf-8");
-  }
-  return projectTitle;
-}
-
-registerHandler("editor", function (clientId: string, message: ClientMessage) {
-  if (message.type === "editor:detect") {
-    var detectMsg = message as EditorDetectMessage;
-    var detectedPath = detectEditorPath(detectMsg.editorType);
-    sendTo(clientId, { type: "editor:detect_result", editorType: detectMsg.editorType, path: detectedPath });
-    return;
-  }
-
-  if (message.type === "editor:ensure-project") {
-    var ensureMsg = message as EditorEnsureProjectMessage;
-    var config = loadConfig();
-    var project = config.projects.find(function (p: typeof config.projects[number]) { return p.slug === ensureMsg.projectSlug; });
-    if (project) {
-      var name = ensureIdeaProject(project.path, project.title);
-      sendTo(clientId, { type: "editor:ensure-project_result", projectSlug: ensureMsg.projectSlug, ideProjectName: name });
-      var identity = loadOrCreateIdentity();
-      broadcast({
-        type: "projects:list",
-        projects: config.projects.map(function (p: typeof config.projects[number]) {
-          return { slug: p.slug, path: p.path, title: p.title, nodeId: identity.id, nodeName: config.name, isRemote: false, ideProjectName: detectIdeProjectName(p.path) };
-        }),
-      });
-    }
-    return;
-  }
-});