276 lines
12 KiB
TypeScript
276 lines
12 KiB
TypeScript
import { computed, ref } from "vue";
|
|
import * as api from "@/lib/backend/api";
|
|
import { currentLocale } from "@/i18n";
|
|
import { buildMarketplacePluginListings, pluginSourceChange, type MarketplacePluginListing } from "@/lib/plugins/pluginMarketplace";
|
|
import { mcpUpdateAvailability } from "@/lib/mcp/mcpUpdateStatus";
|
|
import { useSettingsStore } from "@/stores/settingsStore";
|
|
import { isUpdatePreviewMockEnabled, previewDriverUpdates, previewJdbcUpdate, previewMcpUpdate, previewPluginUpdates } from "@/lib/updates/updatePreviewMock";
|
|
import type { ComponentUpdateCategory } from "@/lib/updates/componentUpdateOrchestration";
|
|
import type { AgentDriverInfo, AgentUpdateBlocker, McpServerStatus } from "@/lib/backend/tauri";
|
|
import type { JdbcPluginStatus } from "@/types/database";
|
|
|
|
export type { ComponentUpdateCategory } from "@/lib/updates/componentUpdateOrchestration";
|
|
|
|
export type PluginUpdateBlock = { pluginName: string; reason: "connections"; connections: string } | { pluginName: string; reason: "operations" | "inProgress" };
|
|
|
|
export interface ComponentUpdateResult {
|
|
drivers: number;
|
|
jdbc: boolean;
|
|
mcp: boolean;
|
|
plugins: number;
|
|
skippedDrivers: number;
|
|
blockedDrivers: AgentUpdateBlocker[];
|
|
failed: string[];
|
|
blockedPlugins: PluginUpdateBlock[];
|
|
}
|
|
|
|
interface ComponentUpdateRefreshOptions {
|
|
force?: boolean;
|
|
}
|
|
|
|
function emptyResult(): ComponentUpdateResult {
|
|
return { drivers: 0, jdbc: false, mcp: false, plugins: 0, skippedDrivers: 0, blockedDrivers: [], failed: [], blockedPlugins: [] };
|
|
}
|
|
|
|
function pluginUpdateBlock(pluginName: string, message: string): PluginUpdateBlock | null {
|
|
const connectionsPrefix = "Plugin update blocked by active connections: ";
|
|
if (message.startsWith(connectionsPrefix)) {
|
|
return { pluginName, reason: "connections", connections: message.slice(connectionsPrefix.length) };
|
|
}
|
|
if (message === "Plugin update blocked by active operations. Please wait for them to finish.") {
|
|
return { pluginName, reason: "operations" };
|
|
}
|
|
if (message === "Plugin update is in progress. Please try again after it finishes.") {
|
|
return { pluginName, reason: "inProgress" };
|
|
}
|
|
return null;
|
|
}
|
|
|
|
export function useComponentUpdates(options: { isDesktop: boolean }) {
|
|
const settingsStore = useSettingsStore();
|
|
const drivers = ref<AgentDriverInfo[]>([]);
|
|
const jdbcPluginStatus = ref<JdbcPluginStatus | null>(null);
|
|
const mcpStatus = ref<McpServerStatus | null>(null);
|
|
const pluginListings = ref<MarketplacePluginListing[]>([]);
|
|
const loading = ref(false);
|
|
const updating = ref(false);
|
|
const updatingCategory = ref<ComponentUpdateCategory | null>(null);
|
|
const lastError = ref("");
|
|
|
|
const driverUpdates = computed(() => drivers.value.filter((driver) => driver.update_available));
|
|
const pluginUpdates = computed(() => pluginListings.value.filter((listing) => listing.status === "update"));
|
|
const driverUpdateCount = computed(() => driverUpdates.value.length);
|
|
const jdbcUpdateAvailable = computed(() => jdbcPluginStatus.value?.update_available === true);
|
|
const mcpUpdateAvailable = computed(() => (mcpStatus.value ? mcpUpdateAvailability(mcpStatus.value) === true : false));
|
|
const pluginUpdateCount = computed(() => pluginUpdates.value.length);
|
|
const totalUpdateCount = computed(() => driverUpdateCount.value + (jdbcUpdateAvailable.value ? 1 : 0) + (mcpUpdateAvailable.value ? 1 : 0) + pluginUpdateCount.value);
|
|
|
|
let refreshPromise: Promise<boolean> | null = null;
|
|
let refreshVersion = 0;
|
|
let activeUpdatePromise: Promise<ComponentUpdateResult> | null = null;
|
|
|
|
function startRefresh(): Promise<boolean> {
|
|
if (!options.isDesktop) return Promise.resolve(false);
|
|
const version = ++refreshVersion;
|
|
refreshPromise = Promise.resolve().then(async () => {
|
|
loading.value = true;
|
|
lastError.value = "";
|
|
try {
|
|
if (isUpdatePreviewMockEnabled()) {
|
|
if (version !== refreshVersion) return false;
|
|
drivers.value = previewDriverUpdates();
|
|
jdbcPluginStatus.value = previewJdbcUpdate();
|
|
mcpStatus.value = previewMcpUpdate();
|
|
pluginListings.value = previewPluginUpdates();
|
|
return true;
|
|
}
|
|
const [agentResult, jdbcResult, mcpResult, installedPluginsResult, catalogsResult] = await Promise.allSettled([api.listInstalledAgents(), api.jdbcPluginStatus(), api.checkMcpServerStatus(), api.listPlugins(), api.fetchPluginMarketplaceCatalogs()]);
|
|
if (version !== refreshVersion) return false;
|
|
const errors: string[] = [];
|
|
if (agentResult.status === "fulfilled") drivers.value = agentResult.value;
|
|
else {
|
|
drivers.value = [];
|
|
errors.push(`drivers: ${agentResult.reason instanceof Error ? agentResult.reason.message : String(agentResult.reason)}`);
|
|
}
|
|
if (jdbcResult.status === "fulfilled") jdbcPluginStatus.value = jdbcResult.value;
|
|
else {
|
|
jdbcPluginStatus.value = null;
|
|
errors.push(`JDBC: ${jdbcResult.reason instanceof Error ? jdbcResult.reason.message : String(jdbcResult.reason)}`);
|
|
}
|
|
if (mcpResult.status === "fulfilled") mcpStatus.value = mcpResult.value;
|
|
else {
|
|
mcpStatus.value = null;
|
|
errors.push(`MCP: ${mcpResult.reason instanceof Error ? mcpResult.reason.message : String(mcpResult.reason)}`);
|
|
}
|
|
if (installedPluginsResult.status === "fulfilled" && catalogsResult.status === "fulfilled") {
|
|
pluginListings.value = buildMarketplacePluginListings(catalogsResult.value, installedPluginsResult.value, currentLocale());
|
|
} else {
|
|
pluginListings.value = [];
|
|
if (installedPluginsResult.status === "rejected") errors.push(`plugins: ${installedPluginsResult.reason instanceof Error ? installedPluginsResult.reason.message : String(installedPluginsResult.reason)}`);
|
|
if (catalogsResult.status === "rejected") errors.push(`plugin catalog: ${catalogsResult.reason instanceof Error ? catalogsResult.reason.message : String(catalogsResult.reason)}`);
|
|
}
|
|
lastError.value = errors.join("; ");
|
|
return errors.length === 0;
|
|
} catch (error) {
|
|
if (version !== refreshVersion) return false;
|
|
lastError.value = error instanceof Error ? error.message : String(error);
|
|
return false;
|
|
} finally {
|
|
if (version === refreshVersion) {
|
|
loading.value = false;
|
|
refreshPromise = null;
|
|
}
|
|
}
|
|
});
|
|
return refreshPromise;
|
|
}
|
|
|
|
function refresh(refreshOptions: ComponentUpdateRefreshOptions = {}) {
|
|
if (!refreshOptions.force && refreshPromise) return refreshPromise;
|
|
return startRefresh();
|
|
}
|
|
|
|
async function updateDrivers(result: ComponentUpdateResult) {
|
|
const updatable = driverUpdates.value.map((driver) => driver.db_type);
|
|
if (!updatable.length) return;
|
|
if (isUpdatePreviewMockEnabled()) {
|
|
result.drivers += updatable.length;
|
|
return;
|
|
}
|
|
const blockers = await api.checkAgentUpdateBlockers(updatable);
|
|
if (blockers.length) {
|
|
result.skippedDrivers = blockers.length;
|
|
result.blockedDrivers = blockers;
|
|
return;
|
|
}
|
|
const upgraded = await api.upgradeAllAgents();
|
|
result.drivers += upgraded.upgraded;
|
|
if (upgraded.failed.length) result.failed.push(...upgraded.failed.map((item) => `${item.db_type}: ${item.error}`));
|
|
}
|
|
|
|
async function updateJdbc(result: ComponentUpdateResult) {
|
|
if (!jdbcUpdateAvailable.value) return;
|
|
if (isUpdatePreviewMockEnabled()) {
|
|
result.jdbc = true;
|
|
return;
|
|
}
|
|
await api.installJdbcPlugin();
|
|
result.jdbc = true;
|
|
}
|
|
|
|
async function updateMcp(result: ComponentUpdateResult) {
|
|
if (!mcpUpdateAvailable.value) return;
|
|
if (isUpdatePreviewMockEnabled()) {
|
|
result.mcp = true;
|
|
return;
|
|
}
|
|
await api.installMcpServer();
|
|
result.mcp = true;
|
|
}
|
|
|
|
async function updatePlugins(result: ComponentUpdateResult) {
|
|
// Listings whose recorded provenance differs from the offering repository/publisher/key need an
|
|
// explicit confirmation, which the automatic path cannot give: keep them visible in the update
|
|
// center (they still count) but let the user confirm them in the Plugin Center instead.
|
|
const updatable = pluginUpdates.value.filter((item) => item.artifact && !pluginSourceChange(item));
|
|
if (isUpdatePreviewMockEnabled()) {
|
|
result.plugins += updatable.length;
|
|
return;
|
|
}
|
|
for (const listing of updatable) {
|
|
try {
|
|
await api.installMarketplacePlugin({
|
|
repositoryId: listing.repository.id,
|
|
pluginId: listing.plugin.id,
|
|
version: listing.plugin.latestVersion,
|
|
});
|
|
result.plugins += 1;
|
|
} catch (error) {
|
|
const message = error instanceof Error ? error.message : String(error);
|
|
const block = pluginUpdateBlock(listing.name, message);
|
|
if (block) result.blockedPlugins.push(block);
|
|
result.failed.push(`${listing.name}: ${message}`);
|
|
}
|
|
}
|
|
}
|
|
|
|
function categoryLabel(category: ComponentUpdateCategory): string {
|
|
return category === "jdbc" ? "JDBC" : category === "mcp" ? "MCP" : category;
|
|
}
|
|
|
|
async function runCategory(category: ComponentUpdateCategory, result: ComponentUpdateResult) {
|
|
updatingCategory.value = category;
|
|
try {
|
|
if (category === "drivers") await updateDrivers(result);
|
|
else if (category === "jdbc") await updateJdbc(result);
|
|
else if (category === "mcp") await updateMcp(result);
|
|
else await updatePlugins(result);
|
|
} catch (error) {
|
|
result.failed.push(`${categoryLabel(category)}: ${error instanceof Error ? error.message : String(error)}`);
|
|
}
|
|
}
|
|
|
|
async function runUpdateOperation(categories: ComponentUpdateCategory[]): Promise<ComponentUpdateResult> {
|
|
const result = emptyResult();
|
|
if (!options.isDesktop) return result;
|
|
if (activeUpdatePromise) return activeUpdatePromise;
|
|
updating.value = true;
|
|
const operation = (async () => {
|
|
await refresh();
|
|
const initialCheckError = lastError.value;
|
|
if (initialCheckError) result.failed.push(initialCheckError);
|
|
for (const category of categories) await runCategory(category, result);
|
|
await refresh();
|
|
if (lastError.value && lastError.value !== initialCheckError) result.failed.push(lastError.value);
|
|
return result;
|
|
})();
|
|
activeUpdatePromise = operation;
|
|
try {
|
|
return await operation;
|
|
} finally {
|
|
if (activeUpdatePromise === operation) activeUpdatePromise = null;
|
|
updating.value = false;
|
|
updatingCategory.value = null;
|
|
}
|
|
}
|
|
|
|
function installCategory(category: ComponentUpdateCategory): Promise<ComponentUpdateResult> {
|
|
return runUpdateOperation([category]);
|
|
}
|
|
|
|
function installCategories(categories: ComponentUpdateCategory[]): Promise<ComponentUpdateResult> {
|
|
return runUpdateOperation([...new Set(categories)]);
|
|
}
|
|
|
|
function autoUpdateEnabledComponents(): Promise<ComponentUpdateResult> {
|
|
const categories: ComponentUpdateCategory[] = [];
|
|
if (settingsStore.editorSettings.autoUpdateDrivers) categories.push("drivers");
|
|
if (settingsStore.editorSettings.autoUpdateJdbc) categories.push("jdbc");
|
|
if (settingsStore.editorSettings.autoUpdateMcp) categories.push("mcp");
|
|
if (settingsStore.editorSettings.autoUpdatePlugins) categories.push("plugins");
|
|
return runUpdateOperation(categories);
|
|
}
|
|
|
|
return {
|
|
drivers,
|
|
driverUpdates,
|
|
jdbcPluginStatus,
|
|
mcpStatus,
|
|
pluginListings,
|
|
pluginUpdates,
|
|
loading,
|
|
updating,
|
|
updatingCategory,
|
|
lastError,
|
|
driverUpdateCount,
|
|
jdbcUpdateAvailable,
|
|
mcpUpdateAvailable,
|
|
pluginUpdateCount,
|
|
totalUpdateCount,
|
|
refresh,
|
|
installCategory,
|
|
installCategories,
|
|
autoUpdateEnabledComponents,
|
|
};
|
|
}
|