Free, open-source screen sharing for private live streams with friends. Watch together in a browser or self-host Piik. 免费开源的私密屏幕共享,支持游戏直播、一起看电影与自部署。
import { compare, major, valid } from "semver";
export const DEFAULT_RELEASE_API_URL =
"https://api.github.com/repos/TNTcraftHIM/Piik/releases/latest";
export const MIRROR_RELEASE_API_URL = "https://api.atomgit.com/api/v5/repos/TNTcraftHIM/Piik/releases";
const RELEASE_PAGE = "https://github.com/TNTcraftHIM/Piik/releases/tag/";
const MIRROR_RELEASE_PAGE = "https://atomgit.com/TNTcraftHIM/Piik/releases";
export interface ReleaseIdentity {
version: string;
revision: string;
}
export interface AppReleaseIdentity extends ReleaseIdentity {
packageTarget?: string;
}
interface PublishedRelease {
version: string;
revision: string | null;
url: string;
releaseURL: string;
publishedAt?: string;
}
export interface ReleaseUpdateNotice extends PublishedRelease {
kind: "update-available" | "major-update" | "different-build" | "official-release";
}
export function normalizeReleaseRevision(value: unknown): string | null {
const revision = typeof value === "string" ? value.trim().toLowerCase() : "";
return /^[0-9a-f]{40}$/.test(revision) ? revision : null;
}
function normalizeVersion(value: unknown): string | null {
const version = typeof value === "string" ? valid(value) : null;
return version ? `v${version}` : null;
}
function packageDownloadURL(release: PublishedRelease, assets: unknown, target?: string): string {
if (!target || !/^[a-z0-9]+-[a-z0-9]+$/.test(target) || !Array.isArray(assets)) return release.url;
const extension = target === "android-universal" ? "apk" : "zip";
const mirror = release.releaseURL === MIRROR_RELEASE_PAGE;
const names = [`piik-app-${target}.${extension}`];
if (release.revision && extension === "zip") names.push(`piik-app-${target}-${release.revision.slice(0, 7)}.zip`);
for (const name of names) {
const matches = assets.filter(asset => asset?.name === name);
if (!matches.length) continue;
const asset = matches[0];
const expectedURL = mirror ? `${MIRROR_RELEASE_PAGE}/download/${release.version}/${name}`
: `${release.releaseURL.replace("/releases/tag/", "/releases/download/")}/${name}`;
return matches.length === 1 && (mirror ? asset.type === "attach" :
(Number.isSafeInteger(asset.size) && asset.size > 0 && asset.state === "uploaded")) &&
asset.browser_download_url === expectedURL ? asset.browser_download_url : release.url;
}
return release.url;
}
export function parseReleaseMetadata(value: unknown, packageTarget?: string): PublishedRelease | null {
if (!value || typeof value !== "object" || Array.isArray(value)) return null;
const release = value as Record<string, unknown>;
if ((release.draft !== undefined && release.draft !== false) ||
(release.prerelease !== undefined && release.prerelease !== false)) return null;
const version = normalizeVersion(release.tag_name);
if (!version || version !== release.tag_name || !/^v\d+\.\d+\.\d+$/.test(version) ||
release.html_url !== RELEASE_PAGE + version) return null;
const publishedTime = typeof release.published_at === "string" && /^\d{4}-\d{2}-\d{2}T/.test(release.published_at)
? Date.parse(release.published_at) : NaN;
const normalized = {
version,
// GitHub permits a branch here; only our publisher's full SHA is provenance.
revision: normalizeReleaseRevision(release.target_commitish),
url: RELEASE_PAGE + version,
releaseURL: RELEASE_PAGE + version,
...(Number.isFinite(publishedTime) ? { publishedAt: new Date(publishedTime).toISOString() } : {}),
};
return { ...normalized, url: packageDownloadURL(normalized, release.assets, packageTarget) };
}
export function parseMirrorReleaseMetadata(value: unknown, packageTarget?: string): PublishedRelease | null {
if (!value || typeof value !== "object" || Array.isArray(value)) return null;
const release = value as Record<string, unknown>;
if (release.prerelease !== false || typeof release.body !== "string") return null;
const sources = [...release.body.matchAll(/^<!-- piik-source: ([0-9a-f]{40}) -->\r?$/gm)];
if (sources.length !== 1) return null;
// The mirror tag identifies its README commit, never the original Piik source.
const normalized = parseReleaseMetadata({
tag_name: release.tag_name, html_url: RELEASE_PAGE + String(release.tag_name),
target_commitish: sources[0][1],
});
if (!normalized) return null;
const mirror = { ...normalized, url: MIRROR_RELEASE_PAGE,
releaseURL: MIRROR_RELEASE_PAGE };
return { ...mirror, url: packageDownloadURL(mirror, release.assets, packageTarget) };
}
export function releaseUpdateNotice(
current: ReleaseIdentity,
latest: PublishedRelease,
): ReleaseUpdateNotice | null {
const version = normalizeVersion(current.version);
const revision = normalizeReleaseRevision(current.revision);
if (version) {
const order = compare(latest.version, version);
if (order > 0) return { ...latest,
kind: major(latest.version) > major(version) ? "major-update" : "update-available" };
if (order === 0 && revision && latest.revision && revision !== latest.revision) {
return { ...latest, kind: "different-build" };
}
return null;
}
return revision && latest.revision && revision !== latest.revision
? { ...latest, kind: "official-release" }
: null;
}
export async function checkReleaseUpdate(
current: ReleaseIdentity,
options: {
apiURL?: string;
mirrorAPIURL?: string;
fetchImpl?: typeof fetch;
timeoutMs?: number;
packageTarget?: string;
} = {},
): Promise<ReleaseUpdateNotice | null> {
if (!normalizeVersion(current.version) && !normalizeReleaseRevision(current.revision)) return null;
const fetchImpl = options.fetchImpl ?? globalThis.fetch;
if (typeof fetchImpl !== "function") return null;
const sources = [
{ url: options.apiURL ?? DEFAULT_RELEASE_API_URL, mirror: false },
{ url: options.mirrorAPIURL ?? (options.apiURL ? undefined : MIRROR_RELEASE_API_URL), mirror: true },
];
for (const source of sources) {
if (!source.url) continue;
const controller = new AbortController();
const timer = globalThis.setTimeout(() => controller.abort(), options.timeoutMs ?? 3_000);
try {
const endpoint = new URL(source.url);
if (endpoint.protocol !== "https:" && endpoint.protocol !== "http:") continue;
let latest: PublishedRelease | null = null;
// Bound both time and pages. Never treat a truncated mirror list as latest.
for (let page = 1; page <= 10; page++) {
if (source.mirror) {
endpoint.searchParams.set("per_page", "100");
endpoint.searchParams.set("page", String(page));
endpoint.searchParams.set("direction", "desc");
}
const response = await fetchImpl(endpoint.toString(), {
cache: "no-store", credentials: "omit", redirect: "error", signal: controller.signal,
headers: source.mirror ? { Accept: "application/json" } :
{ Accept: "application/vnd.github+json", "X-GitHub-Api-Version": "2022-11-28" },
});
if (!response.ok) break;
const data: unknown = await response.json();
if (!source.mirror) {
latest = parseReleaseMetadata(data, options.packageTarget);
if (latest) return releaseUpdateNotice(current, latest);
break;
}
if (!Array.isArray(data) || data.length > 100) break;
for (const value of data) {
const candidate = parseMirrorReleaseMetadata(value, options.packageTarget);
if (candidate && (!latest || compare(candidate.version, latest.version) > 0)) latest = candidate;
}
if (data.length < 100) {
if (latest) return releaseUpdateNotice(current, latest);
break;
}
}
} catch {
// A blocked, timed-out or malformed provider leaves the next source usable.
} finally {
globalThis.clearTimeout(timer);
}
}
return null;
}