TypeScript
import { squashAtomCommandFailure } from "@t3tools/client-runtime/state/runtime";
import type { DesktopAppActivationRequest } from "@t3tools/contracts";
import { useEffect, useEffectEvent, useRef } from "react";
import { handleDesktopAppActivationRequest } from "../../desktopAppActivation";
import { useNewThreadHandler } from "../../hooks/useHandleNewThread";
import {
findProjectByPath,
inferProjectTitleFromPath,
} from "@t3tools/client-runtime/state/projects";
import { newProjectId } from "../../lib/utils";
import { readProjects, waitForProject } from "../../state/entities";
import { usePrimaryEnvironment } from "../../state/environments";
import { projectEnvironment } from "../../state/projects";
import { useEnvironmentShellHasSnapshot } from "../../state/shell";
import { useAtomCommand } from "../../state/use-atom-command";
import { useOrchestrationCommand } from "../../state/use-orchestration-command";
import { reportProjectFailure } from "../../hooks/useProjectGroupUpdate";
export function DesktopAppActivationCoordinator() {
const primaryEnvironment = usePrimaryEnvironment();
const createProject = useAtomCommand(projectEnvironment.create, { reportFailure: false });
const updateProject = useOrchestrationCommand(projectEnvironment.update, {
label: "project unarchive",
});
const openThread = useNewThreadHandler();
const queueRef = useRef(Promise.resolve());
const activation = window.desktopBridge?.appActivation;
const shellHasSnapshot = useEnvironmentShellHasSnapshot(
primaryEnvironment?.environmentId ?? null,
);
const ready =
activation !== undefined &&
primaryEnvironment?.connection.phase === "connected" &&
primaryEnvironment.serverConfig !== null &&
shellHasSnapshot;
const processRequest = useEffectEvent(async (request: DesktopAppActivationRequest) =>
handleDesktopAppActivationRequest(request, {
getTarget: () => {
if (
primaryEnvironment?.connection.phase !== "connected" ||
primaryEnvironment.serverConfig === null
) {
return null;
}
return {
environmentId: primaryEnvironment.environmentId,
platform: primaryEnvironment.serverConfig.environment.platform.os,
};
},
findProject: (environmentId, workspaceRoot) =>
findProjectByPath(
readProjects().filter((project) => project.environmentId === environmentId),
workspaceRoot,
) ?? null,
createProject: async (environmentId, workspaceRoot) => {
const projectId = newProjectId();
const result = await createProject({
environmentId,
input: {
projectId,
title: inferProjectTitleFromPath(workspaceRoot),
workspaceRoot,
createWorkspaceRootIfMissing: false,
defaultModelSelection: null,
},
});
if (result._tag === "Failure") {
const error = squashAtomCommandFailure(result);
throw error instanceof Error ? error : new Error("T3 Code could not add the project.");
}
return projectId;
},
waitForProject: async (projectRef) => {
await waitForProject(projectRef);
},
openThread: (projectRef) => {
const project = readProjects().find(
(candidate) =>
candidate.environmentId === projectRef.environmentId &&
candidate.id === projectRef.projectId,
);
// Opening an archived project's folder again brings the project back.
if (project?.archivedAt != null) {
void updateProject({
environmentId: projectRef.environmentId,
input: { projectId: projectRef.projectId, archived: false },
}).then((result) => reportProjectFailure("Failed to unarchive project", result));
}
return openThread(projectRef);
},
}),
);
// oxlint-disable-next-line t3code/no-unreasoned-state-sync -- subscribes to desktop activation requests over the bridge and marks the renderer ready
useEffect(() => {
if (!ready || activation === undefined) return;
let subscribed = true;
const unsubscribe = activation.onRequest((request) => {
queueRef.current = queueRef.current.then(async () => {
const response = await processRequest(request);
await activation.complete(response);
});
queueRef.current = queueRef.current.catch(() => undefined);
});
// Skip readiness if React runs cleanup before this subscription can receive requests.
queueMicrotask(() => {
if (subscribed) void activation.setReady(true).catch(() => undefined);
});
return () => {
subscribed = false;
void activation.setReady(false).catch(() => undefined);
unsubscribe();
};
}, [activation, ready]);
return null;
}