import type { PluginManifest } from "obsidian"; import { apiVersion, Notice, normalizePath, Platform, requireApiVersion, } from "obsidian"; import { compare as compareVersions, coerce as semverCoerce } from "semver"; import { confirm } from "src/ui/ConfirmModal"; import { ProviderRateLimitError, ProviderResponseError, } from "src/providers/ProviderErrors"; import type { ParsedRepo, PluginProvider, Release } from "src/providers/PluginProvider"; import { parseWithProvider } from "src/providers/index"; import { addBetaPluginToList } from "src/settings"; import type BratPlugin from "../main"; import AddNewPluginModal from "../ui/AddNewPluginModal"; import { isConnectedToInternet } from "../utils/internetconnection"; import { toastMessage } from "../utils/notifications"; import type { ReleaseFiles } from "./BetaPluginsTypes"; interface PluginManifestEx extends PluginManifest { brat: { isIncompatible?: boolean; isDesktopOnlyOriginal?: boolean; minAppVersionOriginal?: string; }; } /** * Primary handler for adding, updating, deleting beta plugins tracked by this plugin. * * Uses a provider abstraction (GitHubProvider / GiteaProvider) so that * plugins hosted on any git forge with releases & assets can be installed. */ export default class BetaPlugins { plugin: BratPlugin; constructor(plugin: BratPlugin) { this.plugin = plugin; } /** * Resolve the provider and parsed repo for a given repository path. * Supports GitHub (bare `user/repo` or `github.com/user/repo`) * and Gitea (`https://git.example.com/user/repo`) URLs. */ private resolveProvider(repoPath: string): { provider: PluginProvider; parsed: ParsedRepo; } { return parseWithProvider(repoPath); } /** * Token to send for a repository: its own secret if one is set, otherwise * the global token, which is a GitHub token and is never sent to other hosts. */ resolveToken(parsed: ParsedRepo, secretName = ""): string { const { secretStorage } = this.plugin.app; if (secretName.trim() !== "") { return secretStorage.getSecret(secretName) ?? ""; } const { globalTokenName } = this.plugin.settings; if (parsed.isGitHub && globalTokenName) { return secretStorage.getSecret(globalTokenName) ?? ""; } return ""; } /** * opens the AddNewPluginModal to get info for a new beta plugin * @param openSettingsTabAfterwards - will open settings screen afterwards. Used when this command is called from settings tab * @param useFrozenVersion - install the plugin using frozen version. * @param prefillRepo - prefill the repository field in the modal. * @param prefillVersion - prefill the version field in the modal. * @param prefillSecretName - prefill the secret name field in the modal (name of secret in SecretStorage). */ displayAddNewPluginModal( openSettingsTabAfterwards = false, useFrozenVersion = false, prefillRepo = "", prefillVersion = "", prefillSecretName = "", ): void { const newPlugin = new AddNewPluginModal( this.plugin, this, openSettingsTabAfterwards, useFrozenVersion, prefillRepo, prefillVersion, prefillSecretName, ); newPlugin.open(); } /** * Validates a repository to determine if it contains a valid Obsidian plugin. * * Works with both GitHub and Gitea repositories. Auto-detects the provider * from the repository URL. */ async validateRepository( repositoryPath: string, getBetaManifest = false, reportIssues = false, specifyVersion = "", privateApiKey = "", ): Promise { const noticeTimeout = 15; const { provider, parsed } = this.resolveProvider(repositoryPath); const token = privateApiKey; try { // Check if the repository is private const repoInfo = await provider.getRepoInfo(parsed, token); // Grab the manifest.json for the latest release from the repository const release: Release | null = await provider.getRelease( parsed, specifyVersion || undefined, getBetaManifest, token, ); if (!release) { if (reportIssues) { toastMessage( this.plugin, `${repositoryPath}\nThis does not seem to be an obsidian plugin with valid releases, as there are no releases available.`, noticeTimeout, ); console.error("BRAT: validateRepository", repositoryPath); } return null; } const rawManifest = await provider.getAsset( release, "manifest.json", repoInfo.isPrivate, token, ); if (!rawManifest) { if (reportIssues) { toastMessage( this.plugin, `${repositoryPath}\nThis does not seem to be an obsidian plugin, as there is no manifest.json file in the release.`, noticeTimeout, ); } return null; } const manifestJson = JSON.parse(rawManifest) as PluginManifest; if (!("id" in manifestJson)) { if (reportIssues) toastMessage( this.plugin, `${repositoryPath}\nThe plugin id attribute is missing from the manifest file`, noticeTimeout, ); return null; } if (!("version" in manifestJson)) { if (reportIssues) toastMessage( this.plugin, `${repositoryPath}\nThe version attribute is missing from the manifest file`, noticeTimeout, ); return null; } // Improve robustness: if semver coercion fails, compare raw versions. const expectedVersion = semverCoerce(release.tag_name, { includePrerelease: true, loose: true, }); const manifestVersion = semverCoerce(manifestJson.version, { includePrerelease: true, loose: true, }); const hasVersionMismatch = expectedVersion && manifestVersion ? compareVersions(expectedVersion.version, manifestVersion.version) !== 0 : expectedVersion !== null && manifestJson.version !== release.tag_name; if (hasVersionMismatch && expectedVersion) { if (reportIssues) toastMessage( this.plugin, `${repositoryPath}\nVersion mismatch: release tag '${release.tag_name}' vs manifest '${manifestJson.version}'. Using release version.`, noticeTimeout, ); manifestJson.version = expectedVersion.version; } return manifestJson; } catch (error) { if (error instanceof ProviderRateLimitError) { const msg = `${parsed.host} API rate limit exceeded. Reset in ${error.getMinutesToReset()} minutes.`; if (reportIssues) toastMessage(this.plugin, msg, noticeTimeout); console.error(`BRAT: validateRepository ${error}`); toastMessage( this.plugin, `${error.message} Consider adding a personal access token in BRAT settings for higher limits.`, 20, ); throw error; } if (error instanceof ProviderResponseError) { if (reportIssues) { if (error.status === 401) { toastMessage( this.plugin, `${repositoryPath}\nAuthentication error. Verify that your access token is valid.`, noticeTimeout, ); } else { toastMessage( this.plugin, `${repositoryPath}\nAPI error ${error.status}: ${error.message}`, noticeTimeout, ); } } console.error(`BRAT: validateRepository ${error}`); throw error; } if (reportIssues) toastMessage( this.plugin, `${repositoryPath}\nUnspecified error: ${String(error)}. Enable debug for more info.`, noticeTimeout, ); return null; } } /** * Gets all the release files based on the version number in the manifest */ async getAllReleaseFiles( repositoryPath: string, getManifest: boolean, specifyVersion = "", tokenValue = "", ): Promise { const { provider, parsed } = this.resolveProvider(repositoryPath); const repoInfo = await provider.getRepoInfo(parsed, tokenValue); const isPrivate = repoInfo.isPrivate; const release = await provider.getRelease( parsed, specifyVersion || undefined, getManifest, tokenValue, ); if (!release) { throw new Error("No release found"); } const reallyGetManifestOrNot = getManifest || specifyVersion !== ""; if (this.plugin.settings.debuggingMode) console.debug({ reallyGetManifestOrNot, version: release.tag_name }); return { mainJs: await provider.getAsset( release, "main.js", isPrivate, tokenValue, ), manifest: reallyGetManifestOrNot ? await provider.getAsset( release, "manifest.json", isPrivate, tokenValue, ) : "", styles: await provider.getAsset( release, "styles.css", isPrivate, tokenValue, ), }; } /** * Writes the plugin release files to the local obsidian .plugins folder */ async writeReleaseFilesToPluginFolder( betaPluginId: string, relFiles: ReleaseFiles, ): Promise { const pluginTargetFolderPath = `${normalizePath(`${this.plugin.app.vault.configDir}/plugins/${betaPluginId}`)}/`; const { adapter } = this.plugin.app.vault; if (!(await adapter.exists(pluginTargetFolderPath))) { await adapter.mkdir(pluginTargetFolderPath); } await adapter.write( `${pluginTargetFolderPath}main.js`, relFiles.mainJs ?? "", ); await adapter.write( `${pluginTargetFolderPath}manifest.json`, relFiles.manifest ?? "", ); if (relFiles.styles) await adapter.write( `${pluginTargetFolderPath}styles.css`, relFiles.styles, ); } /** * Primary function for adding a new beta plugin to Obsidian. * Works with GitHub and Gitea. */ async addPlugin( repositoryPath: string, updatePluginFiles = false, seeIfUpdatedOnly = false, reportIfNotUpdated = false, specifyVersion = "", forceReinstall = false, enableAfterInstall = this.plugin.settings.enableAfterInstall, secretName = "", ): Promise { try { if (this.plugin.settings.debuggingMode) { console.debug( "BRAT: addPlugin", repositoryPath, updatePluginFiles, seeIfUpdatedOnly, reportIfNotUpdated, specifyVersion, forceReinstall, enableAfterInstall, secretName ? "with secret" : "public", ); } const { parsed } = this.resolveProvider(repositoryPath); // Retrieve token const tokenValue = this.resolveToken(parsed, secretName); if (secretName.trim() !== "" && !tokenValue) { toastMessage( this.plugin, `Secret not found for token name: ${secretName}. Please add it to SecretStorage or clear the token name for this plugin.`, 10, ); } const noticeTimeout = 10; // Attempt to get manifest (check for beta/pre-release first) let primaryManifest = await this.validateRepository( repositoryPath, true, true, specifyVersion, tokenValue, ); const usingBetaManifest: boolean = !!primaryManifest; if (!usingBetaManifest) primaryManifest = await this.validateRepository( repositoryPath, false, true, specifyVersion, tokenValue, ); if (primaryManifest === null) { const msg = `${repositoryPath}\nA manifest.json file does not exist in the latest release. This plugin cannot be installed.`; await this.plugin.log(msg, true); toastMessage(this.plugin, msg, noticeTimeout); return false; } if (!Object.hasOwn(primaryManifest, "version")) { const msg = `${repositoryPath}\nThe manifest.json does not have a version number. Cannot install.`; await this.plugin.log(msg, true); toastMessage(this.plugin, msg, noticeTimeout); return false; } let isIncompatible = false; // Check minAppVersion if (Object.hasOwn(primaryManifest, "minAppVersion")) { if (!requireApiVersion(primaryManifest.minAppVersion)) { if ( specifyVersion === "" || specifyVersion === "latest" || !this.plugin.settings.allowIncompatiblePlugins ) { const msg = `Plugin: ${repositoryPath}\n\nRequires Obsidian ${primaryManifest.minAppVersion}, but you have ${apiVersion}. Update Obsidian or contact the developer.`; await this.plugin.log(msg, true); toastMessage(this.plugin, msg, 30); return false; } const confirmResult = await confirm({ app: this.plugin.app, message: createFragment((f) => { f.appendText("Plugin: "); f.createEl("code", { text: repositoryPath }); f.createEl("br"); f.appendText("The manifest requires Obsidian "); f.createEl("code", { text: primaryManifest.minAppVersion }); f.appendText(", but you have "); f.createEl("code", { text: apiVersion }); f.appendText(". Install at your own risk?"); }), }); if (!confirmResult) return false; isIncompatible = true; } } const getRelease = async () => { const rFiles = await this.getAllReleaseFiles( repositoryPath, usingBetaManifest, specifyVersion, tokenValue, ); if (usingBetaManifest || rFiles.manifest === "") rFiles.manifest = JSON.stringify(primaryManifest); const manifestObj = JSON.parse( rFiles.manifest ?? "", ) as PluginManifestEx; if (isIncompatible) { manifestObj.brat = { isIncompatible: true, minAppVersionOriginal: manifestObj.minAppVersion, }; manifestObj.minAppVersion = apiVersion; } if (Platform.isMobile && manifestObj.isDesktopOnly) { if (this.plugin.settings.allowIncompatiblePlugins) { const confirmResult = await confirm({ app: this.plugin.app, message: createFragment((f) => { f.appendText("Plugin: "); f.createEl("code", { text: repositoryPath }); f.createEl("br"); f.appendText("This plugin is desktop-only, but you are on mobile."); f.createEl("br"); f.appendText("Install at your own risk?"); }), }); if (!confirmResult) return null; manifestObj.isDesktopOnly = false; manifestObj.brat ??= {}; manifestObj.brat.isDesktopOnlyOriginal = true; manifestObj.brat.isIncompatible = true; isIncompatible = true; } else { const msg = `Plugin: ${repositoryPath}\nCannot install desktop-only plugin on mobile.`; await this.plugin.log(msg, true); toastMessage(this.plugin, msg, 30); return null; } } if (isIncompatible) { rFiles.manifest = JSON.stringify(manifestObj); } if (rFiles.mainJs === null) { const msg = `${repositoryPath}\nmain.js is missing from the release.`; await this.plugin.log(msg, true); toastMessage(this.plugin, msg, noticeTimeout); return null; } return rFiles; }; if (!updatePluginFiles || forceReinstall) { const releaseFiles = await getRelease(); if (releaseFiles === null) return false; await this.writeReleaseFilesToPluginFolder( primaryManifest.id, releaseFiles, ); addBetaPluginToList( this.plugin, repositoryPath, specifyVersion, isIncompatible, secretName, ); if (enableAfterInstall) { // @ts-expect-error const { plugins } = this.plugin.app; const pluginTargetFolderPath = normalizePath( `${plugins.getPluginFolder()}/${primaryManifest.id}`, ); await plugins.loadManifest(pluginTargetFolderPath); await plugins.enablePluginAndSave(primaryManifest.id); } // @ts-expect-error await this.plugin.app.plugins.loadManifests(); if (forceReinstall) { await this.reloadPlugin(primaryManifest.id); await this.plugin.log(`${repositoryPath} reinstalled`, true); toastMessage( this.plugin, `${repositoryPath}\nPlugin reinstalled (version ${primaryManifest.version})`, noticeTimeout, ); } else { const versionText = specifyVersion === "" ? "" : ` (version: ${specifyVersion})`; let msg = `${repositoryPath}${versionText}\nPlugin registered with BRAT.`; if (!enableAfterInstall) { msg += " You may need to enable it in Community Plugins."; } await this.plugin.log(msg, true); toastMessage(this.plugin, msg, noticeTimeout); } } else { // Update existing plugin const pluginTargetFolderPath = `${this.plugin.app.vault.configDir}/plugins/${primaryManifest.id}/`; const localManifestPath = `${pluginTargetFolderPath}manifest.json`; const vaultAdapter = this.plugin.app.vault.adapter; if (!(await vaultAdapter.exists(localManifestPath))) { // Plugin folder is empty/missing (deleted by sync, by hand, ...). if (seeIfUpdatedOnly) { const msg = `${repositoryPath}\nPlugin folder is missing; run "Check for updates and update" to reinstall it.`; await this.plugin.log(msg, true); toastMessage(this.plugin, msg, 30); return false; } // Reinstall it. updatePlugin() hard-codes enableAfterInstall=false // for plain updates, which here would leave the plugin installed // but disabled, so use the user's setting instead. return await this.addPlugin( repositoryPath, false, false, false, specifyVersion, false, this.plugin.settings.enableAfterInstall, secretName, ); } const localManifestContents = await vaultAdapter.read(localManifestPath); if (specifyVersion !== "" && specifyVersion !== "latest") { toastMessage( this.plugin, `${repositoryPath} version is frozen, not updating.`, 3, ); return false; } const localManifestJson = JSON.parse(localManifestContents) as PluginManifest; const localVersion = semverCoerce(localManifestJson.version, { includePrerelease: true, loose: true, }); const remoteVersion = semverCoerce(primaryManifest.version, { includePrerelease: true, loose: true, }); const hasNewerRemote = localVersion && remoteVersion ? compareVersions(localVersion.version, remoteVersion.version) === -1 : localManifestJson.version !== primaryManifest.version; if (hasNewerRemote) { const releaseNotesUrl = `${parsed.webUrl}/releases/tag/${primaryManifest.version}`; const releaseFiles = await getRelease(); if (releaseFiles === null) return false; if (seeIfUpdatedOnly) { const msg = `Update available for ${primaryManifest.id}: ${localManifestJson.version} → ${primaryManifest.version}. `; await this.plugin.log(msg, true); toastMessage(this.plugin, msg, 30, () => { window.open(releaseNotesUrl); }); return false; } await this.writeReleaseFilesToPluginFolder( primaryManifest.id, releaseFiles, ); // @ts-expect-error await this.plugin.app.plugins.loadManifests(); const reloaded = await this.reloadPlugin(primaryManifest.id); const msg = reloaded ? `${primaryManifest.id}\nUpdated: ${localManifestJson.version} → ${primaryManifest.version}. ` : `${primaryManifest.id}\nUpdated files to ${primaryManifest.version}, but the plugin failed to load (see the developer console). Re-enable it in Community Plugins.`; await this.plugin.log(msg, true); toastMessage(this.plugin, msg, reloaded ? 30 : 0, () => { window.open(releaseNotesUrl); }); return reloaded; } if (reportIfNotUpdated) { toastMessage(this.plugin, `No update for ${repositoryPath}`, 3); } return true; } } catch (error) { console.error(`BRAT: Error adding plugin ${repositoryPath}:`, error); const errorMessage = error instanceof Error ? error.message : "Unknown error"; await this.plugin.log( `Error ${updatePluginFiles ? "updating" : "adding"} plugin ${repositoryPath}: ${errorMessage}`, true, ); return false; } return true; } /** * Disables then re-enables a plugin so its new files are loaded. * * Obsidian's enablePlugin() resolves to false when the plugin fails to * load (its onload throws) instead of throwing. enablePluginAndSave() then * reports true for the same broken plugin, so its result can't prove a * reload: it only keeps the plugin in the saved enabled list, so it is * retried at the next start. Any failure returns false. */ async reloadPlugin(pluginName: string): Promise { // @ts-expect-error const { plugins } = this.plugin.app; let failure: string; try { await plugins.disablePlugin(pluginName); if ((await plugins.enablePlugin(pluginName)) === true) return true; failure = "the plugin failed to load"; } catch (e) { failure = e instanceof Error ? e.message : String(e); console.error(`BRAT: Failed to reload plugin ${pluginName}`, e); } await this.plugin.log( `Failed to reload ${pluginName} after update: ${failure}`, true, ); try { await plugins.enablePluginAndSave(pluginName); } catch (e2) { console.error(`BRAT: Could not keep ${pluginName} enabled`, e2); } return false; } async updatePlugin( repositoryPath: string, onlyCheckDontUpdate = false, reportIfNotUpdated = false, forceReinstall = false, secretName = "", ): Promise { const result = await this.addPlugin( repositoryPath, true, onlyCheckDontUpdate, reportIfNotUpdated, "", forceReinstall, false, secretName, ); if (!result && !onlyCheckDontUpdate) toastMessage(this.plugin, `${repositoryPath}\nUpdate failed.`); return result; } async checkForPluginUpdatesAndInstallUpdates( showInfo = false, onlyCheckDontUpdate = false, ): Promise { if (!(await isConnectedToInternet())) { console.debug("BRAT: No internet detected."); return; } let newNotice: Notice | undefined; const msg1 = "Checking for plugin updates STARTED"; await this.plugin.log(msg1, true); if (showInfo && this.plugin.settings.notificationsEnabled) newNotice = new Notice(`BRAT\n${msg1}`, 30000); const frozenVersions = new Map( this.plugin.settings.pluginSubListFrozenVersion.map((f) => [ f.repo, f.version, ]), ); const repoTokens = new Map( this.plugin.settings.pluginSubListFrozenVersion.map((f) => [ f.repo, f.tokenName || "", ]), ); for (const bp of this.plugin.settings.pluginList) { const version = frozenVersions.get(bp); if (version && version !== "latest") continue; await this.updatePlugin( bp, onlyCheckDontUpdate, false, false, repoTokens.get(bp) || "", ); } const msg2 = "Checking for plugin updates COMPLETED"; await this.plugin.log(msg2, true); if (showInfo) { if (newNotice) newNotice.hide(); toastMessage(this.plugin, msg2, 10); } } deletePlugin(repositoryPath: string): void { const msg = `Removed ${repositoryPath} from BRAT plugin list`; void this.plugin.log(msg, true); this.plugin.settings.pluginList = this.plugin.settings.pluginList.filter( (b) => b !== repositoryPath, ); this.plugin.settings.pluginSubListFrozenVersion = this.plugin.settings.pluginSubListFrozenVersion.filter( (b) => b.repo !== repositoryPath, ); void this.plugin.saveSettings(); } getEnabledDisabledPlugins(enabled: boolean): PluginManifest[] { // @ts-expect-error const pl = this.plugin.app.plugins; const manifests: PluginManifest[] = Object.values(pl.manifests); const enabledPlugins: PluginManifest[] = Object.values(pl.plugins).map( // @ts-expect-error (p) => p.manifest, ); return enabled ? manifests.filter((manifest) => enabledPlugins.find( (pluginName) => manifest.id === pluginName.id, ), ) : manifests.filter( (manifest) => !enabledPlugins.find( (pluginName) => manifest.id === pluginName.id, ), ); } checkIncompatiblePlugins(): void { const incompatiblePluginIds = this.plugin.settings.pluginSubListFrozenVersion .filter((p) => p.isIncompatible) .map((p) => p.repo); if (incompatiblePluginIds.length > 0) { toastMessage( this.plugin, `The following incompatible plugins were forcefully installed and may not work as expected:\n${incompatiblePluginIds.join("\n")}`, 30, ); } } }