Merge branch 'main' into posthog-code/autoresearch-task-switch-latency

Author: MattPua

apps/code/runtime-dependencies.ts

@@ -37,8 +37,8 @@ export const requiredNativeModules = [
   "better-sqlite3",
 ];
 
-// file-icon (and its p-map dependency) is only used on macOS.
-export const macOnlyNativeModules = ["file-icon", "p-map"];
+// file-icon is only used on macOS.
+export const macOnlyNativeModules = ["file-icon"];
 
 // The subset that ships compiled .node binaries and must be unpacked from asar.
 const asarUnpackModules = [

apps/code/src/main/platform-adapters/electron-file-icon.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, it } from "vitest";
+import { resolveMacFileIconBinary } from "./electron-file-icon";
+
+describe("resolveMacFileIconBinary", () => {
+  it("resolves the packaged extractor outside the ASAR", () => {
+    expect(
+      resolveMacFileIconBinary(
+        "/Applications/PostHog Code.app/Contents/Resources/app.asar",
+        true,
+        "/unused/node_modules/file-icon/index.js",
+      ),
+    ).toBe(
+      "/Applications/PostHog Code.app/Contents/Resources/app.asar.unpacked/node_modules/file-icon/file-icon",
+    );
+  });
+});

apps/code/src/main/platform-adapters/electron-file-icon.ts

@@ -1,19 +1,29 @@
+import { execFile } from "node:child_process";
+import path from "node:path";
 import type { IFileIcon } from "@posthog/platform/file-icon";
 import { app } from "electron";
 import { injectable } from "inversify";
 
-type FileIconModule = typeof import("file-icon");
+const FILE_ICON_MAX_BUFFER_BYTES = 100 * 1024 * 1024;
+
+export function resolveMacFileIconBinary(
+  appPath: string,
+  isPackaged: boolean,
+  modulePath: string,
+): string {
+  const resolvedModulePath = isPackaged
+    ? path.join(`${appPath}.unpacked`, "node_modules", "file-icon", "index.js")
+    : modulePath;
+  return path.join(path.dirname(resolvedModulePath), "file-icon");
+}
 
 @injectable()
 export class ElectronFileIcon implements IFileIcon {
-  private fileIconModule: FileIconModule | undefined;
-
   public async getAsDataUrl(filePath: string): Promise<string | null> {
     try {
       if (process.platform === "darwin") {
-        const mod = await this.loadFileIconModule();
-        const uint8Array = await mod.fileIconToBuffer(filePath, { size: 64 });
-        const base64 = Buffer.from(uint8Array).toString("base64");
+        const buffer = await this.getMacFileIcon(filePath);
+        const base64 = buffer.toString("base64");
         return `data:image/png;base64,${base64}`;
       }
 
@@ -25,10 +35,27 @@ export class ElectronFileIcon implements IFileIcon {
     }
   }
 
-  private async loadFileIconModule(): Promise<FileIconModule> {
-    if (!this.fileIconModule) {
-      this.fileIconModule = await import("file-icon");
-    }
-    return this.fileIconModule;
+  private getMacFileIcon(filePath: string): Promise<Buffer> {
+    const binaryPath = resolveMacFileIconBinary(
+      app.getAppPath(),
+      app.isPackaged,
+      require.resolve("file-icon"),
+    );
+    const input = JSON.stringify([{ appOrPID: filePath, size: 64 }]);
+
+    return new Promise((resolve, reject) => {
+      execFile(
+        binaryPath,
+        [input],
+        { encoding: "buffer", maxBuffer: FILE_ICON_MAX_BUFFER_BYTES },
+        (error, stdout) => {
+          if (error) {
+            reject(error);
+            return;
+          }
+          resolve(Buffer.from(stdout));
+        },
+      );
+    });
   }
 }

packages/core/src/canvas/channelUnread.test.ts

@@ -0,0 +1,101 @@
+import {
+  latestActivityForChannel,
+  unreadChannelIds,
+} from "@posthog/core/canvas/channelUnread";
+import type { MentionActivityItem } from "@posthog/core/canvas/mentionActivity";
+import { describe, expect, it } from "vitest";
+
+function mention(
+  overrides: Partial<MentionActivityItem> & { createdAt: string },
+): MentionActivityItem {
+  return {
+    messageId: `m-${overrides.createdAt}`,
+    taskId: "t1",
+    taskTitle: "Task",
+    channelId: "c1",
+    channelName: "mobile",
+    author: null,
+    content: "hey @adam",
+    ...overrides,
+  };
+}
+
+describe("unreadChannelIds", () => {
+  const cases: {
+    name: string;
+    lastSeen: Record<string, string>;
+    expected: string[];
+  }[] = [
+    {
+      name: "a channel never seen is unread",
+      lastSeen: {},
+      expected: ["c1"],
+    },
+    {
+      name: "activity newer than the last visit is unread",
+      lastSeen: { c1: "2026-07-16T09:00:00.000Z" },
+      expected: ["c1"],
+    },
+    {
+      name: "activity older than the last visit is read",
+      lastSeen: { c1: "2026-07-16T11:00:00.000Z" },
+      expected: [],
+    },
+    {
+      name: "activity exactly at the last visit is read",
+      lastSeen: { c1: "2026-07-16T10:00:00.000Z" },
+      expected: [],
+    },
+  ];
+  it.each(cases)("$name", ({ lastSeen, expected }) => {
+    const items = [mention({ createdAt: "2026-07-16T10:00:00.000Z" })];
+    expect([...unreadChannelIds(items, lastSeen)]).toEqual(expected);
+  });
+
+  it("compares each channel against its own last visit", () => {
+    const items = [
+      mention({ channelId: "c1", createdAt: "2026-07-16T10:00:00.000Z" }),
+      mention({ channelId: "c2", createdAt: "2026-07-16T10:00:00.000Z" }),
+    ];
+    const unread = unreadChannelIds(items, {
+      c1: "2026-07-16T11:00:00.000Z",
+      c2: "2026-07-16T09:00:00.000Z",
+    });
+    expect([...unread]).toEqual(["c2"]);
+  });
+
+  it("uses the newest item in a channel, whatever the order", () => {
+    const items = [
+      mention({ messageId: "old", createdAt: "2026-07-16T08:00:00.000Z" }),
+      mention({ messageId: "new", createdAt: "2026-07-16T12:00:00.000Z" }),
+    ];
+    expect([
+      ...unreadChannelIds(items, { c1: "2026-07-16T10:00:00.000Z" }),
+    ]).toEqual(["c1"]);
+  });
+
+  it("ignores channel-less mentions", () => {
+    const items = [
+      mention({ channelId: null, createdAt: "2026-07-16T10:00Z" }),
+    ];
+    expect([...unreadChannelIds(items, {})]).toEqual([]);
+  });
+});
+
+describe("latestActivityForChannel", () => {
+  it("returns the newest timestamp for that channel only", () => {
+    const items = [
+      mention({ channelId: "c1", createdAt: "2026-07-16T08:00:00.000Z" }),
+      mention({ channelId: "c1", createdAt: "2026-07-16T12:00:00.000Z" }),
+      mention({ channelId: "c2", createdAt: "2026-07-16T13:00:00.000Z" }),
+    ];
+    expect(latestActivityForChannel(items, "c1")).toBe(
+      "2026-07-16T12:00:00.000Z",
+    );
+  });
+
+  it("is undefined for a channel with no activity, or no channel", () => {
+    expect(latestActivityForChannel([], "c1")).toBeUndefined();
+    expect(latestActivityForChannel([], undefined)).toBeUndefined();
+  });
+});

packages/core/src/canvas/channelUnread.ts

@@ -0,0 +1,66 @@
+import type { MentionActivityItem } from "@posthog/core/canvas/mentionActivity";
+
+/**
+ * Which channels have activity the viewer hasn't seen — the signal behind the
+ * sidebar's bold channel names.
+ *
+ * "Activity" is currently an @-mention: that's the only cross-channel,
+ * all-users feed the client has (the mentions index), and it's what
+ * "notification" means elsewhere in the app. The backend exposes no per-channel
+ * activity timestamp, so a broader "any new message" signal would mean polling
+ * every user's full task list — the app's heaviest poll, deliberately retired.
+ * If that timestamp lands, only `latestActivityByChannel` changes shape; the
+ * unread comparison and the seen bookkeeping stay as they are.
+ *
+ * Keyed by backend channel id rather than name, so renaming a channel doesn't
+ * silently mark it unread again.
+ */
+
+/** Newest activity per channel id. Ignores items with no channel. */
+export function latestActivityByChannel(
+  items: readonly MentionActivityItem[],
+): Map<string, string> {
+  const latest = new Map<string, string>();
+  for (const item of items) {
+    if (!item.channelId) continue;
+    const current = latest.get(item.channelId);
+    if (!current || item.createdAt > current) {
+      latest.set(item.channelId, item.createdAt);
+    }
+  }
+  return latest;
+}
+
+/**
+ * Channel ids whose newest activity postdates the viewer's last visit. A
+ * channel never visited is unread as soon as it has any activity.
+ */
+export function unreadChannelIds(
+  items: readonly MentionActivityItem[],
+  lastSeenByChannel: Readonly<Record<string, string>>,
+): Set<string> {
+  const unread = new Set<string>();
+  for (const [channelId, activityAt] of latestActivityByChannel(items)) {
+    const seenAt = lastSeenByChannel[channelId];
+    if (!seenAt || activityAt > seenAt) unread.add(channelId);
+  }
+  return unread;
+}
+
+/**
+ * The newest activity in one channel, for stamping it seen while it's open.
+ * Scans for the one channel rather than reusing `latestActivityByChannel`,
+ * which would build (and throw away) a map of every other channel to answer.
+ */
+export function latestActivityForChannel(
+  items: readonly MentionActivityItem[],
+  channelId: string | undefined,
+): string | undefined {
+  if (!channelId) return undefined;
+  let latest: string | undefined;
+  for (const item of items) {
+    if (item.channelId !== channelId) continue;
+    if (!latest || item.createdAt > latest) latest = item.createdAt;
+  }
+  return latest;
+}

packages/ui/src/features/canvas/components/ChannelHeader.tsx

@@ -2,6 +2,7 @@ import { HashIcon } from "@phosphor-icons/react";
 import { Button, cn } from "@posthog/quill";
 import { ChannelTabs } from "@posthog/ui/features/canvas/components/ChannelTabs";
 import { useChannels } from "@posthog/ui/features/canvas/hooks/useChannels";
+import { useMarkChannelSeen } from "@posthog/ui/features/canvas/hooks/useMarkChannelSeen";
 import { Text } from "@radix-ui/themes";
 import { useNavigate, useRouterState } from "@tanstack/react-router";
 
@@ -17,6 +18,9 @@ export function ChannelHeader({ channelId }: { channelId: string }) {
   const channelName = channels.find((c) => c.id === channelId)?.name;
   const pathname = useRouterState({ select: (s) => s.location.pathname });
   const isHome = pathname === `/website/${channelId}`;
+  // Every channel surface renders this header, so it is where "the viewer is
+  // in this channel" is known — and therefore where the channel is marked read.
+  useMarkChannelSeen(channelName);
 
   return (
     <div className="flex min-w-0 items-center gap-2">