Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
import { createMutation } from "@tanstack/solid-query";
import { invoke } from "@tauri-apps/api/core";
import { listen } from "@tauri-apps/api/event";
import { getCurrentWindow } from "@tauri-apps/api/window";
import { onOpenUrl } from "@tauri-apps/plugin-deep-link";
import * as shell from "@tauri-apps/plugin-shell";
import { z } from "zod";
import callbackTemplate from "~/components/callback.template";
import { authStore, generalSettingsStore } from "~/store";
import { identifyUser, trackEvent } from "./analytics";
import { clientEnv } from "./env";
import { shouldUseLocalServerSessionForUrl } from "./server-url-routing";
import { commands } from "./tauri";
const paramsValidator = z.union([
z.object({
type: z.literal("api_key"),
api_key: z.string(),
user_id: z.string(),
}),
z.object({
token: z.string(),
user_id: z.string(),
expires: z.coerce.number(),
}),
]);
type AuthParams = z.infer<typeof paramsValidator>;
export function createSignInMutation() {
return createMutation(() => ({
mutationFn: async (abort: AbortController) => {
const session = (await shouldUseLocalServerSession())
? await createLocalServerSession(abort.signal)
: await createHybridDesktopSession(abort.signal);
await shell.open(session.url.toString());
const res = await session.complete();
if (res) await processAuthData(res);
getCurrentWindow().setFocus();
},
}));
}
async function getConfiguredServerUrl() {
return (
(await generalSettingsStore.get())?.serverUrl ?? clientEnv.VITE_SERVER_URL
);
}
async function shouldUseLocalServerSession() {
const serverUrl = await getConfiguredServerUrl();
return shouldUseLocalServerSessionForUrl(
serverUrl,
clientEnv.VITE_SERVER_URL,
import.meta.env.DEV,
);
}
async function createSessionRequestUrl(
port: string | null,
platform: "web" | "desktop",
) {
const serverUrl = await getConfiguredServerUrl();
const callbackUrl = new URL(
`/api/desktop/session/request?type=api_key`,
serverUrl,
);
if (port !== null) callbackUrl.searchParams.set("port", port);
callbackUrl.searchParams.set("platform", platform);
return callbackUrl;
}
async function createLocalServerSession(signal: AbortSignal) {
const localCallback = await startLocalCallbackSession(signal);
return {
url: await createSessionRequestUrl(localCallback.port, "web"),
complete: async () => {
const result = await localCallback.complete;
await localCallback.dispose();
if (!result) return null;
if (signal.aborted) throw new Error("Sign in aborted");
return result;
},
};
}
async function createHybridDesktopSession(signal: AbortSignal) {
const deepLink = await startDeepLinkSession(signal);
const localCallback = await startLocalCallbackSession(signal);
return {
url: await createSessionRequestUrl(localCallback.port, "desktop"),
complete: async () => {
const result = await Promise.race([
deepLink.complete.then((data) => ({
source: "deep-link" as const,
data,
})),
localCallback.complete.then((data) => ({
source: "local" as const,
data,
})),
]);
await deepLink.dispose();
await localCallback.dispose();
if (!result.data) return null;
if (signal.aborted) throw new Error("Sign in aborted");
return result.data;
},
};
}
async function startLocalCallbackSession(signal: AbortSignal) {
await invoke("plugin:oauth|stop").catch(() => {});
const port: string = await invoke("plugin:oauth|start", {
config: {
response: callbackTemplate,
headers: {
"Content-Type": "text/html; charset=utf-8",
"Cache-Control": "no-store, no-cache, must-revalidate",
Pragma: "no-cache",
},
cleanup: true,
},
});
let settled = false;
let stopListening: (() => void) | undefined;
let resolvePromise: (data: AuthParams | null) => void = () => {};
const complete = new Promise<AuthParams | null>((resolve) => {
resolvePromise = resolve;
});
const settle = (value: AuthParams | null) => {
if (settled) return;
settled = true;
resolvePromise(value);
};
stopListening = await listen("oauth://url", (data: { payload: string }) => {
if (!(data.payload.includes("token") || data.payload.includes("api_key"))) {
return;
}
settle(parseAuthParams(new URL(data.payload)));
});
const dispose = async () => {
stopListening?.();
stopListening = undefined;
settle(null);
await invoke("plugin:oauth|stop").catch(() => {});
};
signal.addEventListener("abort", () => void dispose(), { once: true });
return { port, complete, dispose };
}
async function startDeepLinkSession(signal: AbortSignal) {
let settled = false;
let stopListening: (() => void) | undefined;
let resolvePromise: (data: AuthParams | null) => void = () => {};
const complete = new Promise<AuthParams | null>((resolve) => {
resolvePromise = resolve;
});
const settle = (value: AuthParams | null) => {
if (settled) return;
settled = true;
resolvePromise(value);
};
stopListening = await onOpenUrl(async (urls) => {
for (const urlString of urls) {
if (signal.aborted) return;
settle(parseAuthParams(new URL(urlString)));
}
});
const dispose = async () => {
stopListening?.();
stopListening = undefined;
settle(null);
};
signal.addEventListener("abort", () => void dispose(), { once: true });
return { complete, dispose };
}
function parseAuthParams(url: URL) {
return paramsValidator.parse(
[...url.searchParams].reduce(
(acc, [key, value]) => {
acc[key] = value;
return acc;
},
{} as Record<string, string>,
),
);
}
async function processAuthData(data: AuthParams) {
identifyUser(data.user_id);
trackEvent("user_signed_in", { platform: "desktop" });
await authStore.set({
secret:
"api_key" in data
? { api_key: data.api_key }
: { token: data.token, expires: data.expires },
user_id: data.user_id,
plan: null,
});
await commands.updateAuthPlan();
}