Finish task deep link work

Author: charlesvien

apps/array/src/main/services/task-link/service.ts

@@ -17,6 +17,12 @@ export interface TaskLinkEvents {
 
 @injectable()
 export class TaskLinkService extends TypedEventEmitter<TaskLinkEvents> {
+  /**
+   * Pending task ID that was received before renderer was ready.
+   * This handles the case where the app is launched via deep link.
+   */
+  private pendingTaskId: string | null = null;
+
   constructor(
     @inject(MAIN_TOKENS.DeepLinkService)
     private readonly deepLinkService: DeepLinkService,
@@ -38,8 +44,17 @@ export class TaskLinkService extends TypedEventEmitter<TaskLinkEvents> {
       return false;
     }
 
-    log.info(`Emitting task link event: ${taskId}`);
-    this.emit(TaskLinkEvent.OpenTask, { taskId });
+    // Check if renderer is ready (has any listeners)
+    const hasListeners = this.listenerCount(TaskLinkEvent.OpenTask) > 0;
+
+    if (hasListeners) {
+      log.info(`Emitting task link event: ${taskId}`);
+      this.emit(TaskLinkEvent.OpenTask, { taskId });
+    } else {
+      // Renderer not ready yet - queue it for later
+      log.info(`Queueing task link (renderer not ready): ${taskId}`);
+      this.pendingTaskId = taskId;
+    }
 
     // Focus the window
     const mainWindow = getMainWindow();
@@ -52,4 +67,17 @@ export class TaskLinkService extends TypedEventEmitter<TaskLinkEvents> {
 
     return true;
   }
+
+  /**
+   * Get and clear any pending task ID.
+   * Called by renderer on mount to handle deep links that arrived before it was ready.
+   */
+  public consumePendingTaskId(): string | null {
+    const taskId = this.pendingTaskId;
+    this.pendingTaskId = null;
+    if (taskId) {
+      log.info(`Consumed pending task link: ${taskId}`);
+    }
+    return taskId;
+  }
 }

apps/array/src/main/services/types.ts

@@ -3,3 +3,4 @@
  * This file is auto-generated by vite-plugin-auto-services.ts
  */
 
+

apps/array/src/main/trpc/routers/deep-link.ts

@@ -19,8 +19,21 @@ export const deepLinkRouter = router({
   onOpenTask: publicProcedure.subscription(async function* (opts) {
     const service = getService();
     const options = opts.signal ? { signal: opts.signal } : undefined;
-    for await (const [payload] of on(service, TaskLinkEvent.OpenTask, options)) {
+    for await (const [payload] of on(
+      service,
+      TaskLinkEvent.OpenTask,
+      options,
+    )) {
       yield payload as TaskLinkEvents[typeof TaskLinkEvent.OpenTask];
     }
   }),
+
+  /**
+   * Get any pending task ID that arrived before renderer was ready.
+   * This handles the case where the app is launched via deep link.
+   */
+  getPendingTaskId: publicProcedure.query(() => {
+    const service = getService();
+    return service.consumePendingTaskId();
+  }),
 });

apps/array/src/renderer/components/MainLayout.tsx

@@ -20,16 +20,21 @@ import { useNavigationStore } from "@stores/navigationStore";
 import { useCallback, useEffect, useState } from "react";
 import { useHotkeys } from "react-hotkeys-hook";
 import { Toaster } from "sonner";
+import { useTaskDeepLink } from "../hooks/useTaskDeepLink";
 
 export function MainLayout() {
   const { view, toggleSettings, navigateToTaskInput, goBack, goForward } =
     useNavigationStore();
   const clearAllLayouts = usePanelLayoutStore((state) => state.clearAllLayouts);
   const toggleLeftSidebar = useSidebarStore((state) => state.toggle);
   const toggleRightSidebar = useRightSidebarStore((state) => state.toggle);
-  useIntegrations();
+
   const [commandMenuOpen, setCommandMenuOpen] = useState(false);
 
+  // Initialize integrations
+  useIntegrations();
+  useTaskDeepLink();
+
   const handleOpenSettings = useCallback(() => {
     toggleSettings();
   }, [toggleSettings]);

apps/array/src/renderer/hooks/useTaskDeepLink.ts

@@ -0,0 +1,109 @@
+import { useAuthStore } from "@features/auth/stores/authStore";
+import { useTaskViewedStore } from "@features/sidebar/stores/taskViewedStore";
+import { get } from "@renderer/di/container";
+import { RENDERER_TOKENS } from "@renderer/di/tokens";
+import { logger } from "@renderer/lib/logger";
+import type { TaskService } from "@renderer/services/task/service";
+import { useNavigationStore } from "@stores/navigationStore";
+import { trpcReact, trpcVanilla } from "@renderer/trpc";
+import type { Task } from "@shared/types";
+import { useQueryClient } from "@tanstack/react-query";
+import { useCallback, useEffect, useRef } from "react";
+import { toast } from "sonner";
+
+const log = logger.scope("task-deep-link");
+
+const taskKeys = {
+  all: ["tasks"] as const,
+  lists: () => [...taskKeys.all, "list"] as const,
+  list: (filters?: { repository?: string }) =>
+    [...taskKeys.lists(), filters] as const,
+};
+
+/**
+ * Hook that subscribes to deep link events and handles opening tasks.
+ * Uses TaskService to fetch task and set up workspace via the saga pattern.
+ */
+export function useTaskDeepLink() {
+  const navigateToTask = useNavigationStore((state) => state.navigateToTask);
+  const markAsViewed = useTaskViewedStore((state) => state.markAsViewed);
+  const queryClient = useQueryClient();
+  const isAuthenticated = useAuthStore((state) => state.isAuthenticated);
+  const hasFetchedPending = useRef(false);
+
+  const handleOpenTask = useCallback(
+    async (taskId: string) => {
+      log.info(`Opening task from deep link: ${taskId}`);
+
+      try {
+        const taskService = get<TaskService>(RENDERER_TOKENS.TaskService);
+        const result = await taskService.openTask(taskId);
+
+        if (!result.success) {
+          log.error("Failed to open task from deep link", {
+            taskId,
+            error: result.error,
+            failedStep: result.failedStep,
+          });
+          toast.error(`Failed to open task: ${result.error}`);
+          return;
+        }
+
+        const { task } = result.data;
+
+        // Add task to query cache so it shows in sidebar
+        queryClient.setQueryData<Task[]>(taskKeys.list(), (old) => {
+          if (!old) return [task];
+          const existingIndex = old.findIndex((t) => t.id === task.id);
+          if (existingIndex >= 0) {
+            const updated = [...old];
+            updated[existingIndex] = task;
+            return updated;
+          }
+          return [task, ...old];
+        });
+
+        // Invalidate to ensure sync with server
+        queryClient.invalidateQueries({ queryKey: taskKeys.lists() });
+
+        // Mark as viewed and navigate
+        markAsViewed(taskId);
+        navigateToTask(task);
+
+        log.info(`Successfully opened task from deep link: ${taskId}`);
+      } catch (error) {
+        log.error("Unexpected error opening task from deep link:", error);
+        toast.error("Failed to open task");
+      }
+    },
+    [navigateToTask, markAsViewed, queryClient],
+  );
+
+  // Check for pending deep link on mount (for cold start via deep link)
+  useEffect(() => {
+    if (!isAuthenticated || hasFetchedPending.current) return;
+
+    const fetchPending = async () => {
+      hasFetchedPending.current = true;
+      try {
+        const pendingTaskId = await trpcVanilla.deepLink.getPendingTaskId.query();
+        if (pendingTaskId) {
+          log.info(`Found pending deep link task: ${pendingTaskId}`);
+          handleOpenTask(pendingTaskId);
+        }
+      } catch (error) {
+        log.error("Failed to check for pending deep link:", error);
+      }
+    };
+
+    fetchPending();
+  }, [isAuthenticated, handleOpenTask]);
+
+  // Subscribe to deep link events (for warm start via deep link)
+  trpcReact.deepLink.onOpenTask.useSubscription(undefined, {
+    onData: (data) => {
+      log.info(`Received deep link event for task: ${data.taskId}`);
+      handleOpenTask(data.taskId);
+    },
+  });
+}