feat(notifications): scheduled tasks and desktop notifications

[kooksee]

Summary

• Add scheduled tasks: create timed checks against workspace pages, with optional conditions (single rule, AND group, or no filter for pure reminders).
• Add in-app notification inbox with read/delete, relative timestamps, and click-through to matched pages or scheduled task settings.
• Wire desktop system notifications with click-to-navigate, in-app toast fallback when focused, and ad-hoc signing for local macOS builds.

Test plan

• Create a pure reminder task (no page filter), Run now → in-app notification + macOS system notification (desktop, non-silent)
• Create a conditional task (field equals/contains, date due, AND rules) → notifies only when pages match
• Run now on same-day pure reminder → still notifies (forceNotify bypasses daily dedup)
• Scheduled auto-run → pure reminder deduped to once per local day
• Delete notification from sidebar
• Click system notification → app focuses and navigates to page or scheduled tasks
• CI passes

Made with Cursor

[gemini-code-assist]

Code Review

This pull request introduces a comprehensive scheduled tasks and notifications system, Markdown import/export capabilities, and Mermaid diagram rendering support. It adds database tables and services for scheduled tasks and notifications, Electron IPC plumbing for desktop notifications, and Tiptap editor extensions for Markdown and Mermaid. The review feedback highlights several key improvement opportunities, including resolving a timezone mismatch when parsing date-only strings, utilizing js-yaml for robust frontmatter serialization, preventing crashes from corrupted page attributes, avoiding duplicate focused notifications, ensuring proper macOS window focusing, allowing empty page exports, removing redundant observers and queries, and handling invalid date strings gracefully.

Important

The consumer version of Gemini Code Assist on GitHub is being sunset. Starting June 18, 2026, new organization installations will be blocked, and all code review activity will officially cease on July 17, 2026.
For more details on the timeline and next steps, please review the Help Documentation.

[gemini-code-assist]

Parsing date-only strings (like "YYYY-MM-DD") with new Date(raw) treats them as UTC midnight, whereas new Date() (reference) is created in local time. This timezone mismatch causes tasks to be considered due a day early in negative timezone offsets (e.g., US timezones). Parsing "YYYY-MM-DD" explicitly as a local date fixes this issue.

const parseFieldDate = (fieldValue: unknown): Date | null => {
  if (!fieldValue || typeof fieldValue !== 'object' || !('value' in fieldValue)) {
    return null;
  }

  const raw = (fieldValue as { value: unknown }).value;
  if (typeof raw !== 'string' || raw.length === 0) {
    return null;
  }

  if (/^\d{4}-\d{2}-\d{2}$/.test(raw)) {
    const parts = raw.split('-');
    const date = new Date(Number(parts[0]), Number(parts[1]) - 1, Number(parts[2]));
    return Number.isNaN(date.getTime()) ? null : date;
  }

  const date = new Date(raw);
  if (Number.isNaN(date.getTime())) {
    return null;
  }

  return date;
};

[gemini-code-assist]

Using manual string concatenation and a custom yamlScalar function is prone to syntax errors when page titles or field values contain special YAML characters (like [, ], {, }, -, etc.). Since js-yaml is already a dependency of the project, using yaml.dump is 100% robust, handles all escaping and edge cases perfectly, and simplifies the code significantly.

import { Editor } from '@tiptap/core';
import yaml from 'js-yaml';

import { buildEditorContent } from '@colanode/client/lib/editor';
import { LocalPageNode } from '@colanode/client/types';
import {
  type FieldAttributes,
  type FieldValue,
  type RichTextContent,
} from '@colanode/core';
import { getDocumentMarkdownExtensions } from '@colanode/ui/lib/document-markdown-extensions';
import { normalizeExportedMarkdown } from '@colanode/ui/lib/markdown-export-normalize';

export interface PageMarkdownExportInput {
  page: LocalPageNode;
  content: RichTextContent | null | undefined;
  metaTypeName?: string | null;
  fieldDefinitions?: Record<string, FieldAttributes>;
}

const sanitizeFileName = (name: string): string => {
  const trimmed = name.trim() || 'Untitled';
  return trimmed.replace(/[\\/:*?"<>|]/g, '-');
};

const fieldValueToYaml = (value: FieldValue): string | number | boolean | string[] | null => {
  switch (value.type) {
    case 'boolean':
    case 'number':
      return value.value;
    case 'string':
    case 'text':
      return value.value;
    case 'string_array':
      return value.value.length > 0 ? value.value : null;
    default: 
      return null;
  }
};

export const buildPageFrontmatter = ({
  page,
  metaTypeName,
  fieldDefinitions = {},
}: Omit<PageMarkdownExportInput, 'content'>): string => {
  const data: Record<string, any> = {
    title: page.name,
  };

  if (metaTypeName) {
    data.metaType = metaTypeName;
  }

  data.colanode = {
    pageId: page.id,
    metaTypeId: page.metaTypeId,
  };

  const fields = page.fields ?? {};
  for (const [fieldId, fieldValue] of Object.entries(fields)) {
    const definition = fieldDefinitions[fieldId];
    const key = definition?.name?.trim() || fieldId;
    const yamlValue = fieldValueToYaml(fieldValue);
    if (yamlValue === null || yamlValue === '') {
      continue;
    }

    data[key] = yamlValue;
  }

  return `---\n${yaml.dump(data)}---\n`;
};

[gemini-code-assist]

If a single page has corrupted or missing attributes, JSON.parse(row.attributes) will throw an unhandled exception, failing the entire scheduled task. Wrapping the parsing and matching logic in a try-catch block ensures that a single corrupted page doesn't prevent other valid pages from being checked.

  for (const row of rows) {
    try {
      const attributes = JSON.parse(row.attributes) as PageAttributes;
      const operator = check.operator ?? 'equals';
      if (!pageMatchesFieldValue(attributes, check.fieldId, check.value, operator)) {
        continue;
      }

      matchedPageIds.push(row.id);
      matchedPageNames.push(attributes.name);
    } catch (error) {
      console.error(`Failed to parse attributes for page ${row.id}:`, error);
    }
  }

[gemini-code-assist]

Currently, if the main window is focused, the app shows both the system notification and the in-app fallback toast. To avoid duplicate notifications and provide a better user experience, the system notification should be suppressed when the app is already focused.

Suggested change

	desktopNotification.show();
	const mainWindow = this.getMainWindow();
	if (mainWindow?.isFocused()) {
	this.sendFallbackToast(notification);
	}
	const mainWindow = this.getMainWindow();
	if (mainWindow?.isFocused()) {
	this.sendFallbackToast(notification);
	} else {
	desktopNotification.show();
	}

[gemini-code-assist]

On macOS, calling mainWindow.focus() alone might not bring the application to the foreground if another app currently has focus. Calling app.focus({ steal: true }) ensures that the application is successfully brought to the front when the user clicks on a notification.

  private focusMainWindow(): BrowserWindow | null {
    const mainWindow = this.getMainWindow();
    if (!mainWindow || mainWindow.isDestroyed()) {
      return null;
    }

    const { app } = require('electron');
    app.focus({ steal: true });

    if (mainWindow.isMinimized()) {
      mainWindow.restore();
    }

    if (!mainWindow.isVisible()) {
      mainWindow.show();
    }

    mainWindow.focus();
    return mainWindow;
  }

[gemini-code-assist]

If a page is newly created and has no content yet, fetchDocumentRichTextContent returns null. Currently, this triggers an error toast and aborts the export. Since buildPageMarkdown and serializeRichTextToMarkdown are already designed to handle null content, we should allow exporting empty pages by passing content ?? null instead of aborting.

      const markdown = buildPageMarkdown({
        page,
        content: content ?? null,
        metaTypeName: metaType?.name,
        fieldDefinitions: metaType?.fields,
      });

      downloadMarkdownFile(exportPageMarkdownFileName(page.name), markdown);

[gemini-code-assist]

Instead of manually managing autoUpdate with useEffect, requestAnimationFrame, and custom cleanup logic, you can use @floating-ui/react's built-in whileElementsMounted: autoUpdate option. This is the standard, idiomatic way to handle floating element updates and completely eliminates the complex manual synchronization logic.

  const { refs, floatingStyles } = useFloating({
    placement: 'left',
    middleware: [offset(-10), shift()],
    strategy: 'fixed',
    whileElementsMounted: autoUpdate,
  });

  useEffect(() => {
    if (!menuState.show || !menuState.domNode || !editor) {
      return;
    }

    const domNode = menuState.domNode;
    const editorDom = editor.view.dom;
    const virtualReference = createMenuReference(domNode, editorDom);

    refs.setPositionReference(virtualReference);
  }, [menuState.show, menuState.domNode, editor]);

[gemini-code-assist]

This MutationObserver is redundant because the ResizeObserver in the first useEffect already detects any size changes of the container (including those caused by theme changes). If the theme change does not affect the container's width, updating containerWidth state is unnecessary. You can safely remove this entire useEffect block.

[gemini-code-assist]

Since useLiveQuery is already querying the node reactively from the local database, the manual useEffect with window.colanode.executeQuery is redundant and causes duplicate database queries on every metaTypeId change. You can completely remove the fetchedMetaType state and the useEffect block, and rely solely on metaTypeNodeQuery.data.

  const metaTypeNodeQuery = useLiveQuery(
    (q) =>
      q
        .from({ nodes: workspace.collections.nodes })
        .where(({ nodes }) => eq(nodes.id, metaTypeId))
        .findOne(),
    [metaTypeId, workspace.userId]
  );

  return useMemo(() => {
    const liveNode =
      metaTypeNodeQuery.data?.type === 'database'
        ? (metaTypeNodeQuery.data as LocalDatabaseNode)
        : null;

    return pickRicherMetaType(
      liveNode,
      metaTypes.find((metaType) => metaType.id === metaTypeId) ?? null
    );
  }, [metaTypeNodeQuery.data, metaTypes, metaTypeId]);

[gemini-code-assist]

If value is an invalid date string, new Date(value) returns an invalid date, but it does not throw an error. The subsequent calculations result in NaN, and date.toLocaleString() returns "Invalid Date" to the user. Checking Number.isNaN(date.getTime()) early ensures we gracefully fall back to the raw string value.

const formatTimestamp = (value: string): string => {
  try {
    const date = new Date(value);
    if (Number.isNaN(date.getTime())) {
      return value;
    }

    const now = new Date();
    const diffMs = now.getTime() - date.getTime();
    const diffSec = Math.floor(diffMs / 1000);

    if (diffSec < 60) {
      return 'Just now';
    }

    const diffMin = Math.floor(diffSec / 60);
    if (diffMin < 60) {
      return `${diffMin}m ago`;
    }

    const diffHour = Math.floor(diffMin / 60);
    if (diffHour < 24) {
      return `${diffHour}h ago`;
    }

    return date.toLocaleString([], {
      month: 'numeric',
      day: 'numeric',
      hour: '2-digit',
      minute: '2-digit',
    });
  } catch {
    return value;
  }
};