feat(FN-1246): add app version tracking and sync infrastructure
- Add getAppVersion() utility that walks up directories to find package.json - Add parseSemver() for semver string parsing with major/minor/patch components - Add CentralCore version sync methods (getAppVersion, syncVersion, getLastSyncTime, getSyncStatus) - Add CentralCore events for version sync lifecycle (version-sync-started, version-sync-completed, version-sync-failed) - Add schema v4 migration with appVersion and lastSyncTime columns to projects table - Export new types (CentralSyncStatus, SyncResult) and utilities via @fusion/core - Update memory.md documentation with new types - Fix TypeScript error in app-version.ts (return pkg.version directly instead of cached variable)
This commit is contained in:
gsxdsm
@@ -12,6 +12,7 @@
|
||||
- Agent tool factories (`createTaskCreateTool`, `createTaskLogTool`) live in `agent-tools.ts` and are shared between `TaskExecutor` and `HeartbeatMonitor` to avoid duplication.
|
||||
- Dashboard SSE clients (planning/subtask/mission interview) now use a shared keep-alive pattern: start a 25s `setInterval` in stream `onOpen` that `POST`s `/api/ai-sessions/:id/ping`, and always stop it on stream `close`, `complete`, and fatal errors.
|
||||
- **Peer Gossip Protocol (FN-1224)**: Nodes exchange peer information via `POST /api/mesh/sync` endpoint. `PeerExchangeService` runs periodic sync cycles (default 60s interval) with all online remote nodes. `CentralCore.mergePeers()` handles peer data merging — new peers are registered via `registerGossipPeer()`, stale peers are updated with fresher data, and the local node is never overwritten. The service uses single-flight pattern to prevent overlapping syncs and refreshes local metrics before each sync.
|
||||
- **Node Plugin Sync (FN-1246)**: Nodes track version information for plugin synchronization. Central schema v4 adds `versionInfo` and `pluginVersions` columns to the `nodes` table. `getAppVersion()` utility reads from nearest package.json. CentralCore methods: `updateNodeVersionInfo()`, `getNodeVersionInfo()`, `syncPlugins()`, `checkVersionCompatibility()`. Events: `node:version:updated`, `node:plugins:synced`. Key integration points for FN-1247 (API routes, CLI commands).
|
||||
|
||||
## Conventions
|
||||
|
||||
|
||||
121
packages/core/src/app-version.test.ts
Normal file
121
packages/core/src/app-version.test.ts
Normal file
@@ -0,0 +1,121 @@
|
||||
import { describe, it, expect, beforeEach, vi, afterEach } from "vitest";
|
||||
import { readFileSync, existsSync } from "node:fs";
|
||||
import { dirname, join } from "node:path";
|
||||
import { fileURLToPath } from "node:url";
|
||||
import { getAppVersion, parseSemver } from "./app-version.js";
|
||||
|
||||
describe("getAppVersion", () => {
|
||||
it("should return a non-empty string", () => {
|
||||
const version = getAppVersion();
|
||||
expect(typeof version).toBe("string");
|
||||
expect(version.length).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
it("should return a valid semver string", () => {
|
||||
const version = getAppVersion();
|
||||
// Matches basic semver format: X.Y.Z
|
||||
expect(version).toMatch(/^\d+\.\d+\.\d+/);
|
||||
});
|
||||
|
||||
it("should return the actual package version from package.json", () => {
|
||||
const version = getAppVersion();
|
||||
// Read the actual version from package.json for verification
|
||||
// The test file is at packages/core/src/app-version.test.ts
|
||||
// Walk up from this file to find packages/core/package.json
|
||||
const testFileDir = dirname(fileURLToPath(import.meta.url));
|
||||
const coreDir = join(testFileDir, "..");
|
||||
const pkgPath = join(coreDir, "package.json");
|
||||
const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
|
||||
expect(version).toBe(pkg.version);
|
||||
});
|
||||
|
||||
it("should cache the result", () => {
|
||||
// Clear cache by calling multiple times
|
||||
const version1 = getAppVersion();
|
||||
const version2 = getAppVersion();
|
||||
expect(version1).toBe(version2);
|
||||
expect(version1).toBe("0.1.0");
|
||||
});
|
||||
});
|
||||
|
||||
describe("parseSemver", () => {
|
||||
describe("valid semver versions", () => {
|
||||
it("parses simple version", () => {
|
||||
const result = parseSemver("1.2.3");
|
||||
expect(result).toEqual({ major: 1, minor: 2, patch: 3 });
|
||||
});
|
||||
|
||||
it("parses zero version", () => {
|
||||
const result = parseSemver("0.0.0");
|
||||
expect(result).toEqual({ major: 0, minor: 0, patch: 0 });
|
||||
});
|
||||
|
||||
it("parses large version numbers", () => {
|
||||
const result = parseSemver("10.20.30");
|
||||
expect(result).toEqual({ major: 10, minor: 20, patch: 30 });
|
||||
});
|
||||
|
||||
it("parses prerelease version", () => {
|
||||
const result = parseSemver("1.2.3-beta.1");
|
||||
expect(result).toEqual({ major: 1, minor: 2, patch: 3 });
|
||||
});
|
||||
|
||||
it("parses prerelease with multiple segments", () => {
|
||||
const result = parseSemver("1.2.3-alpha.beta.1");
|
||||
expect(result).toEqual({ major: 1, minor: 2, patch: 3 });
|
||||
});
|
||||
|
||||
it("parses version with build metadata", () => {
|
||||
const result = parseSemver("1.2.3+build.123");
|
||||
expect(result).toEqual({ major: 1, minor: 2, patch: 3 });
|
||||
});
|
||||
|
||||
it("parses version with prerelease and build metadata", () => {
|
||||
const result = parseSemver("1.2.3-beta.1+build.123");
|
||||
expect(result).toEqual({ major: 1, minor: 2, patch: 3 });
|
||||
});
|
||||
});
|
||||
|
||||
describe("invalid semver versions", () => {
|
||||
it("returns null for empty string", () => {
|
||||
expect(parseSemver("")).toBeNull();
|
||||
});
|
||||
|
||||
it("returns null for non-semver string", () => {
|
||||
expect(parseSemver("not-semver")).toBeNull();
|
||||
});
|
||||
|
||||
it("returns null for partial version", () => {
|
||||
expect(parseSemver("1")).toBeNull();
|
||||
expect(parseSemver("1.2")).toBeNull();
|
||||
});
|
||||
|
||||
it("returns null for invalid major version", () => {
|
||||
expect(parseSemver("abc.2.3")).toBeNull();
|
||||
});
|
||||
|
||||
it("returns null for version with trailing characters", () => {
|
||||
expect(parseSemver("1.2.3foo")).toBeNull();
|
||||
expect(parseSemver("1.2.3 foo")).toBeNull();
|
||||
});
|
||||
|
||||
it("returns null for version with v prefix", () => {
|
||||
expect(parseSemver("v1.2.3")).toBeNull();
|
||||
});
|
||||
|
||||
it("returns null for version with too many parts", () => {
|
||||
expect(parseSemver("1.2.3.4")).toBeNull();
|
||||
expect(parseSemver("1.2.3.4.5")).toBeNull();
|
||||
});
|
||||
|
||||
it("returns null for invalid prerelease suffix", () => {
|
||||
expect(parseSemver("1.2.3-")).toBeNull();
|
||||
});
|
||||
|
||||
it("returns null for whitespace", () => {
|
||||
expect(parseSemver(" 1.2.3")).toBeNull();
|
||||
expect(parseSemver("1.2.3 ")).toBeNull();
|
||||
expect(parseSemver("1.2.3\n")).toBeNull();
|
||||
});
|
||||
});
|
||||
});
|
||||
63
packages/core/src/app-version.ts
Normal file
63
packages/core/src/app-version.ts
Normal file
@@ -0,0 +1,63 @@
|
||||
import { readFileSync } from "node:fs";
|
||||
import { join, dirname } from "node:path";
|
||||
import { fileURLToPath } from "node:url";
|
||||
|
||||
/**
|
||||
* Cached app version once resolved.
|
||||
*/
|
||||
let cachedVersion: string | null = null;
|
||||
|
||||
/**
|
||||
* Get the current Fusion application version by reading the nearest package.json.
|
||||
* Walks up from the current file to find the root package.json.
|
||||
* Results are cached for the process lifetime.
|
||||
*
|
||||
* @returns Semver version string (e.g., "0.1.0")
|
||||
*/
|
||||
export function getAppVersion(): string {
|
||||
if (cachedVersion !== null) return cachedVersion;
|
||||
|
||||
// Start from this file's directory and walk up
|
||||
const __dirname = dirname(fileURLToPath(import.meta.url));
|
||||
let currentDir = __dirname;
|
||||
|
||||
// Walk up to 10 levels looking for package.json
|
||||
for (let i = 0; i < 10; i++) {
|
||||
try {
|
||||
const pkgPath = join(currentDir, "package.json");
|
||||
const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
|
||||
if (pkg.version && typeof pkg.version === "string") {
|
||||
cachedVersion = pkg.version;
|
||||
return pkg.version;
|
||||
}
|
||||
} catch {
|
||||
// package.json not found or not parseable — continue walking up
|
||||
}
|
||||
const parentDir = dirname(currentDir);
|
||||
if (parentDir === currentDir) break; // Reached filesystem root
|
||||
currentDir = parentDir;
|
||||
}
|
||||
|
||||
// Fallback if no package.json found
|
||||
cachedVersion = "0.0.0";
|
||||
return cachedVersion;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse a semver string into its components.
|
||||
* Supports basic semver format: MAJOR.MINOR.PATCH with optional prerelease suffix.
|
||||
* The string must match the pattern starting from the beginning.
|
||||
*
|
||||
* @param version - Semver version string (e.g., "1.2.3", "1.2.3-beta.1")
|
||||
* @returns Parsed components or null if invalid
|
||||
*/
|
||||
export function parseSemver(version: string): { major: number; minor: number; patch: number } | null {
|
||||
// Strict semver regex: anchored to start, requires MAJOR.MINOR.PATCH, allows optional prerelease/build
|
||||
const match = version.match(/^(\d+)\.(\d+)\.(\d+)(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/);
|
||||
if (!match) return null;
|
||||
return {
|
||||
major: parseInt(match[1], 10),
|
||||
minor: parseInt(match[2], 10),
|
||||
patch: parseInt(match[3], 10),
|
||||
};
|
||||
}
|
||||
@@ -1425,6 +1425,253 @@ describe("CentralCore", () => {
|
||||
});
|
||||
});
|
||||
|
||||
describe("node version sync", () => {
|
||||
beforeEach(async () => {
|
||||
await central.init();
|
||||
});
|
||||
|
||||
describe("updateNodeVersionInfo", () => {
|
||||
it("should store version info on a node", async () => {
|
||||
const node = await central.registerNode({ name: "version-node", type: "local" });
|
||||
|
||||
const versionInfo = {
|
||||
appVersion: "0.1.0",
|
||||
pluginVersions: { "plugin-a": "1.0.0", "plugin-b": "2.0.0" },
|
||||
lastSyncedAt: "2026-04-01T12:00:00.000Z",
|
||||
};
|
||||
|
||||
const updated = await central.updateNodeVersionInfo(node.id, versionInfo);
|
||||
|
||||
expect(updated.versionInfo).toBeDefined();
|
||||
expect(updated.versionInfo?.appVersion).toBe("0.1.0");
|
||||
expect(updated.versionInfo?.pluginVersions).toEqual({ "plugin-a": "1.0.0", "plugin-b": "2.0.0" });
|
||||
expect(updated.pluginVersions).toEqual({ "plugin-a": "1.0.0", "plugin-b": "2.0.0" });
|
||||
});
|
||||
|
||||
it("should auto-fill appVersion if not provided", async () => {
|
||||
const node = await central.registerNode({ name: "auto-version-node", type: "local" });
|
||||
|
||||
const versionInfo = {
|
||||
pluginVersions: { "plugin-a": "1.0.0" },
|
||||
lastSyncedAt: "2026-04-01T12:00:00.000Z",
|
||||
};
|
||||
|
||||
const updated = await central.updateNodeVersionInfo(node.id, versionInfo);
|
||||
|
||||
expect(updated.versionInfo?.appVersion).toBe("0.1.0");
|
||||
});
|
||||
|
||||
it("should emit node:version:updated and node:updated events", async () => {
|
||||
const node = await central.registerNode({ name: "event-node", type: "local" });
|
||||
|
||||
let versionEmitted = false;
|
||||
let nodeEmitted = false;
|
||||
central.on("node:version:updated", () => {
|
||||
versionEmitted = true;
|
||||
});
|
||||
central.on("node:updated", () => {
|
||||
nodeEmitted = true;
|
||||
});
|
||||
|
||||
await central.updateNodeVersionInfo(node.id, {
|
||||
appVersion: "0.1.0",
|
||||
pluginVersions: {},
|
||||
lastSyncedAt: "2026-04-01T12:00:00.000Z",
|
||||
});
|
||||
|
||||
expect(versionEmitted).toBe(true);
|
||||
expect(nodeEmitted).toBe(true);
|
||||
});
|
||||
|
||||
it("should throw if node not found", async () => {
|
||||
await expect(
|
||||
central.updateNodeVersionInfo("node_missing", {
|
||||
appVersion: "0.1.0",
|
||||
pluginVersions: {},
|
||||
lastSyncedAt: "2026-04-01T12:00:00.000Z",
|
||||
}),
|
||||
).rejects.toThrow("Node not found");
|
||||
});
|
||||
});
|
||||
|
||||
describe("getNodeVersionInfo", () => {
|
||||
it("should return stored version info", async () => {
|
||||
const node = await central.registerNode({ name: "get-version-node", type: "local" });
|
||||
|
||||
await central.updateNodeVersionInfo(node.id, {
|
||||
appVersion: "0.2.0",
|
||||
pluginVersions: { "plugin-c": "1.5.0" },
|
||||
lastSyncedAt: "2026-04-01T12:00:00.000Z",
|
||||
});
|
||||
|
||||
const versionInfo = await central.getNodeVersionInfo(node.id);
|
||||
|
||||
expect(versionInfo).toBeDefined();
|
||||
expect(versionInfo?.appVersion).toBe("0.2.0");
|
||||
expect(versionInfo?.pluginVersions).toEqual({ "plugin-c": "1.5.0" });
|
||||
});
|
||||
|
||||
it("should return undefined if not set", async () => {
|
||||
const node = await central.registerNode({ name: "no-version-node", type: "local" });
|
||||
|
||||
const versionInfo = await central.getNodeVersionInfo(node.id);
|
||||
|
||||
expect(versionInfo).toBeUndefined();
|
||||
});
|
||||
});
|
||||
|
||||
describe("syncPlugins", () => {
|
||||
it("should return no-action for matching versions", async () => {
|
||||
const node1 = await central.registerNode({ name: "sync-node-1", type: "local" });
|
||||
const node2 = await central.registerNode({ name: "sync-node-2", type: "local" });
|
||||
|
||||
await central.updateNodeVersionInfo(node1.id, {
|
||||
appVersion: "0.1.0",
|
||||
pluginVersions: { "plugin-a": "1.0.0" },
|
||||
lastSyncedAt: "2026-04-01T12:00:00.000Z",
|
||||
});
|
||||
|
||||
await central.updateNodeVersionInfo(node2.id, {
|
||||
appVersion: "0.1.0",
|
||||
pluginVersions: { "plugin-a": "1.0.0" },
|
||||
lastSyncedAt: "2026-04-01T12:00:00.000Z",
|
||||
});
|
||||
|
||||
const result = await central.syncPlugins(node1.id, node2.id);
|
||||
|
||||
expect(result.isCompatible).toBe(true);
|
||||
expect(result.plugins).toHaveLength(1);
|
||||
expect(result.plugins[0].action).toBe("no-action");
|
||||
});
|
||||
|
||||
it("should return install action for missing plugins", async () => {
|
||||
const node1 = await central.registerNode({ name: "install-node-1", type: "local" });
|
||||
const node2 = await central.registerNode({ name: "install-node-2", type: "local" });
|
||||
|
||||
await central.updateNodeVersionInfo(node1.id, {
|
||||
appVersion: "0.1.0",
|
||||
pluginVersions: { "plugin-a": "1.0.0", "plugin-b": "2.0.0" },
|
||||
lastSyncedAt: "2026-04-01T12:00:00.000Z",
|
||||
});
|
||||
|
||||
await central.updateNodeVersionInfo(node2.id, {
|
||||
appVersion: "0.1.0",
|
||||
pluginVersions: { "plugin-a": "1.0.0" },
|
||||
lastSyncedAt: "2026-04-01T12:00:00.000Z",
|
||||
});
|
||||
|
||||
const result = await central.syncPlugins(node1.id, node2.id);
|
||||
|
||||
expect(result.isCompatible).toBe(false);
|
||||
const pluginB = result.plugins.find((p) => p.pluginId === "plugin-b");
|
||||
expect(pluginB?.action).toBe("install");
|
||||
expect(pluginB?.targetVersion).toBe("2.0.0");
|
||||
});
|
||||
|
||||
it("should return update action for version differences", async () => {
|
||||
const node1 = await central.registerNode({ name: "update-node-1", type: "local" });
|
||||
const node2 = await central.registerNode({ name: "update-node-2", type: "local" });
|
||||
|
||||
await central.updateNodeVersionInfo(node1.id, {
|
||||
appVersion: "0.1.0",
|
||||
pluginVersions: { "plugin-a": "2.0.0" },
|
||||
lastSyncedAt: "2026-04-01T12:00:00.000Z",
|
||||
});
|
||||
|
||||
await central.updateNodeVersionInfo(node2.id, {
|
||||
appVersion: "0.1.0",
|
||||
pluginVersions: { "plugin-a": "1.0.0" },
|
||||
lastSyncedAt: "2026-04-01T12:00:00.000Z",
|
||||
});
|
||||
|
||||
const result = await central.syncPlugins(node1.id, node2.id);
|
||||
|
||||
expect(result.isCompatible).toBe(false);
|
||||
const pluginA = result.plugins.find((p) => p.pluginId === "plugin-a");
|
||||
expect(pluginA?.action).toBe("update");
|
||||
});
|
||||
|
||||
it("should handle nodes with no version info", async () => {
|
||||
const node1 = await central.registerNode({ name: "empty-node-1", type: "local" });
|
||||
const node2 = await central.registerNode({ name: "empty-node-2", type: "local" });
|
||||
|
||||
const result = await central.syncPlugins(node1.id, node2.id);
|
||||
|
||||
expect(result.isCompatible).toBe(true);
|
||||
expect(result.plugins).toHaveLength(0);
|
||||
});
|
||||
|
||||
it("should emit node:plugins:synced event", async () => {
|
||||
const node1 = await central.registerNode({ name: "event-sync-1", type: "local" });
|
||||
const node2 = await central.registerNode({ name: "event-sync-2", type: "local" });
|
||||
|
||||
let emittedResult: unknown;
|
||||
central.on("node:plugins:synced", (result) => {
|
||||
emittedResult = result;
|
||||
});
|
||||
|
||||
await central.syncPlugins(node1.id, node2.id);
|
||||
|
||||
expect(emittedResult).toBeDefined();
|
||||
});
|
||||
|
||||
it("should throw if either node not found", async () => {
|
||||
const node = await central.registerNode({ name: "partial-node", type: "local" });
|
||||
|
||||
await expect(central.syncPlugins(node.id, "node_missing")).rejects.toThrow(
|
||||
"Remote node not found",
|
||||
);
|
||||
|
||||
await expect(central.syncPlugins("node_missing", node.id)).rejects.toThrow(
|
||||
"Local node not found",
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
describe("checkVersionCompatibility", () => {
|
||||
it("should return compatible for identical versions", () => {
|
||||
const result = central.checkVersionCompatibility("1.2.3", "1.2.3");
|
||||
|
||||
expect(result.status).toBe("compatible");
|
||||
expect(result.message).toContain("match");
|
||||
});
|
||||
|
||||
it("should return compatible for patch-only differences", () => {
|
||||
const result = central.checkVersionCompatibility("1.2.3", "1.2.4");
|
||||
|
||||
expect(result.status).toBe("compatible");
|
||||
expect(result.message).toContain("Patch");
|
||||
});
|
||||
|
||||
it("should return minor-difference for minor version mismatch", () => {
|
||||
const result = central.checkVersionCompatibility("1.2.3", "1.3.0");
|
||||
|
||||
expect(result.status).toBe("minor-difference");
|
||||
expect(result.message).toContain("Minor");
|
||||
});
|
||||
|
||||
it("should return major-difference for major version mismatch", () => {
|
||||
const result = central.checkVersionCompatibility("1.2.3", "2.0.0");
|
||||
|
||||
expect(result.status).toBe("major-difference");
|
||||
expect(result.message).toContain("Major");
|
||||
});
|
||||
|
||||
it("should return incompatible for invalid version strings", () => {
|
||||
const result = central.checkVersionCompatibility("invalid", "1.0.0");
|
||||
|
||||
expect(result.status).toBe("incompatible");
|
||||
expect(result.message).toContain("Invalid");
|
||||
});
|
||||
|
||||
it("should handle prerelease versions", () => {
|
||||
const result = central.checkVersionCompatibility("1.2.3-beta.1", "1.2.3-beta.2");
|
||||
|
||||
expect(result.status).toBe("compatible");
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe("project health", () => {
|
||||
beforeEach(async () => {
|
||||
await central.init();
|
||||
|
||||
@@ -50,7 +50,12 @@ import type {
|
||||
PeerNode,
|
||||
DiscoveryConfig,
|
||||
DiscoveredNode,
|
||||
NodeVersionInfo,
|
||||
NodeVersionInfoInput,
|
||||
PluginSyncResult,
|
||||
VersionCompatibilityResult,
|
||||
} from "./types.js";
|
||||
import { getAppVersion, parseSemver } from "./app-version.js";
|
||||
import { CentralDatabase, toJson, toJsonNullable, fromJson } from "./central-db.js";
|
||||
import { resolveGlobalDir } from "./global-settings.js";
|
||||
import { NodeConnection } from "./node-connection.js";
|
||||
@@ -101,6 +106,10 @@ export interface CentralCoreEvents {
|
||||
"discovery:node:lost": [name: string];
|
||||
/** Emitted when global concurrency state changes */
|
||||
"concurrency:changed": [state: GlobalConcurrencyState];
|
||||
/** Emitted when a node's version info is updated */
|
||||
"node:version:updated": [payload: { nodeId: string; versionInfo: NodeVersionInfo }];
|
||||
/** Emitted when plugin sync comparison completes */
|
||||
"node:plugins:synced": [result: PluginSyncResult];
|
||||
}
|
||||
|
||||
// ── CentralCore Class ─────────────────────────────────────────────────────
|
||||
@@ -670,6 +679,8 @@ export class CentralCore extends EventEmitter<CentralCoreEvents> {
|
||||
capabilities: string | null;
|
||||
systemMetrics: string | null;
|
||||
knownPeers: string | null;
|
||||
versionInfo: string | null;
|
||||
pluginVersions: string | null;
|
||||
maxConcurrent: number;
|
||||
createdAt: string;
|
||||
updatedAt: string;
|
||||
@@ -697,6 +708,8 @@ export class CentralCore extends EventEmitter<CentralCoreEvents> {
|
||||
capabilities: string | null;
|
||||
systemMetrics: string | null;
|
||||
knownPeers: string | null;
|
||||
versionInfo: string | null;
|
||||
pluginVersions: string | null;
|
||||
maxConcurrent: number;
|
||||
createdAt: string;
|
||||
updatedAt: string;
|
||||
@@ -723,6 +736,8 @@ export class CentralCore extends EventEmitter<CentralCoreEvents> {
|
||||
capabilities: string | null;
|
||||
systemMetrics: string | null;
|
||||
knownPeers: string | null;
|
||||
versionInfo: string | null;
|
||||
pluginVersions: string | null;
|
||||
maxConcurrent: number;
|
||||
createdAt: string;
|
||||
updatedAt: string;
|
||||
@@ -775,6 +790,8 @@ export class CentralCore extends EventEmitter<CentralCoreEvents> {
|
||||
capabilities = ?,
|
||||
systemMetrics = ?,
|
||||
knownPeers = ?,
|
||||
versionInfo = ?,
|
||||
pluginVersions = ?,
|
||||
maxConcurrent = ?,
|
||||
updatedAt = ?
|
||||
WHERE id = ?`
|
||||
@@ -787,6 +804,8 @@ export class CentralCore extends EventEmitter<CentralCoreEvents> {
|
||||
toJsonNullable(updated.capabilities),
|
||||
toJsonNullable(updated.systemMetrics),
|
||||
toJsonNullable(updated.knownPeers),
|
||||
toJsonNullable(updated.versionInfo),
|
||||
toJsonNullable(updated.pluginVersions),
|
||||
updated.maxConcurrent,
|
||||
updated.updatedAt,
|
||||
id
|
||||
@@ -1963,6 +1982,8 @@ export class CentralCore extends EventEmitter<CentralCoreEvents> {
|
||||
capabilities: string | null;
|
||||
systemMetrics: string | null;
|
||||
knownPeers: string | null;
|
||||
versionInfo: string | null;
|
||||
pluginVersions: string | null;
|
||||
maxConcurrent: number;
|
||||
createdAt: string;
|
||||
updatedAt: string;
|
||||
@@ -1977,6 +1998,8 @@ export class CentralCore extends EventEmitter<CentralCoreEvents> {
|
||||
capabilities: fromJson<AgentCapability[]>(row.capabilities),
|
||||
systemMetrics: fromJson<SystemMetrics>(row.systemMetrics),
|
||||
knownPeers: fromJson<string[]>(row.knownPeers),
|
||||
versionInfo: fromJson<NodeVersionInfo>(row.versionInfo),
|
||||
pluginVersions: fromJson<Record<string, string>>(row.pluginVersions),
|
||||
maxConcurrent: row.maxConcurrent,
|
||||
createdAt: row.createdAt,
|
||||
updatedAt: row.updatedAt,
|
||||
@@ -2019,6 +2042,8 @@ export class CentralCore extends EventEmitter<CentralCoreEvents> {
|
||||
capabilities: string | null;
|
||||
systemMetrics: string | null;
|
||||
knownPeers: string | null;
|
||||
versionInfo: string | null;
|
||||
pluginVersions: string | null;
|
||||
maxConcurrent: number;
|
||||
createdAt: string;
|
||||
updatedAt: string;
|
||||
@@ -2229,4 +2254,284 @@ export class CentralCore extends EventEmitter<CentralCoreEvents> {
|
||||
|
||||
return candidate;
|
||||
}
|
||||
|
||||
// ── Node Version Sync API ──────────────────────────────────────────────
|
||||
|
||||
/**
|
||||
* Update version information for a node.
|
||||
* Auto-fills appVersion with current app version if not provided.
|
||||
*
|
||||
* @param id - Node ID
|
||||
* @param versionInfo - Version info to store
|
||||
* @returns Updated node config
|
||||
* @throws Error if node not found
|
||||
*/
|
||||
async updateNodeVersionInfo(id: string, versionInfo: NodeVersionInfoInput): Promise<NodeConfig> {
|
||||
this.ensureInitialized();
|
||||
|
||||
const node = await this.getNode(id);
|
||||
if (!node) {
|
||||
throw new Error(`Node not found: ${id}`);
|
||||
}
|
||||
|
||||
const now = new Date().toISOString();
|
||||
const fullVersionInfo: NodeVersionInfo = {
|
||||
appVersion: versionInfo.appVersion ?? getAppVersion(),
|
||||
pluginVersions: versionInfo.pluginVersions,
|
||||
lastSyncedAt: versionInfo.lastSyncedAt ?? now,
|
||||
};
|
||||
|
||||
this.db!.prepare(
|
||||
`UPDATE nodes SET
|
||||
versionInfo = ?,
|
||||
pluginVersions = ?,
|
||||
updatedAt = ?
|
||||
WHERE id = ?`
|
||||
).run(
|
||||
toJsonNullable(fullVersionInfo),
|
||||
toJsonNullable(fullVersionInfo.pluginVersions),
|
||||
now,
|
||||
id
|
||||
);
|
||||
|
||||
this.db!.bumpLastModified();
|
||||
|
||||
const updated = await this.getNode(id);
|
||||
if (!updated) {
|
||||
throw new Error(`Node not found after update: ${id}`);
|
||||
}
|
||||
|
||||
this.emit("node:version:updated", { nodeId: id, versionInfo: fullVersionInfo });
|
||||
this.emit("node:updated", updated);
|
||||
|
||||
return updated;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get version information for a node.
|
||||
*
|
||||
* @param id - Node ID
|
||||
* @returns Version info or undefined if not set
|
||||
*/
|
||||
async getNodeVersionInfo(id: string): Promise<NodeVersionInfo | undefined> {
|
||||
this.ensureInitialized();
|
||||
|
||||
const node = await this.getNode(id);
|
||||
return node?.versionInfo;
|
||||
}
|
||||
|
||||
/**
|
||||
* Compare plugin versions between two nodes and generate sync recommendations.
|
||||
*
|
||||
* @param localNodeId - Local node ID
|
||||
* @param remoteNodeId - Remote node ID to compare against
|
||||
* @returns Sync result with recommendations for each plugin
|
||||
* @throws Error if either node not found
|
||||
*/
|
||||
async syncPlugins(localNodeId: string, remoteNodeId: string): Promise<PluginSyncResult> {
|
||||
this.ensureInitialized();
|
||||
|
||||
const localNode = await this.getNode(localNodeId);
|
||||
const remoteNode = await this.getNode(remoteNodeId);
|
||||
|
||||
if (!localNode) {
|
||||
throw new Error(`Local node not found: ${localNodeId}`);
|
||||
}
|
||||
if (!remoteNode) {
|
||||
throw new Error(`Remote node not found: ${remoteNodeId}`);
|
||||
}
|
||||
|
||||
const localPlugins = localNode.versionInfo?.pluginVersions ?? {};
|
||||
const remotePlugins = remoteNode.versionInfo?.pluginVersions ?? {};
|
||||
|
||||
const allPluginIds = new Set([...Object.keys(localPlugins), ...Object.keys(remotePlugins)]);
|
||||
const plugins: PluginSyncResult["plugins"] = [];
|
||||
|
||||
for (const pluginId of allPluginIds) {
|
||||
const localVersion = localPlugins[pluginId];
|
||||
const remoteVersion = remotePlugins[pluginId];
|
||||
const localParsed = localVersion ? parseSemver(localVersion) : null;
|
||||
const remoteParsed = remoteVersion ? parseSemver(remoteVersion) : null;
|
||||
|
||||
if (localVersion && !remoteVersion) {
|
||||
// Plugin on local but not remote
|
||||
plugins.push({
|
||||
pluginId,
|
||||
action: "install",
|
||||
targetVersion: localVersion,
|
||||
localVersion,
|
||||
remoteVersion: undefined,
|
||||
reason: "Plugin installed on local node but missing on remote",
|
||||
});
|
||||
} else if (!localVersion && remoteVersion) {
|
||||
// Plugin on remote but not local
|
||||
plugins.push({
|
||||
pluginId,
|
||||
action: "remove",
|
||||
localVersion: undefined,
|
||||
remoteVersion,
|
||||
reason: "Plugin installed on remote node but missing on local",
|
||||
});
|
||||
} else if (localParsed && remoteParsed) {
|
||||
// Both have the plugin - compare versions
|
||||
if (localParsed.major !== remoteParsed.major) {
|
||||
if (localParsed.major > remoteParsed.major) {
|
||||
plugins.push({
|
||||
pluginId,
|
||||
action: "update",
|
||||
targetVersion: localVersion,
|
||||
localVersion,
|
||||
remoteVersion,
|
||||
reason: `Local has newer major version (${localVersion} > ${remoteVersion})`,
|
||||
});
|
||||
} else {
|
||||
plugins.push({
|
||||
pluginId,
|
||||
action: "update",
|
||||
targetVersion: remoteVersion,
|
||||
localVersion,
|
||||
remoteVersion,
|
||||
reason: `Remote has newer major version (${remoteVersion} > ${localVersion})`,
|
||||
});
|
||||
}
|
||||
} else if (localParsed.minor !== remoteParsed.minor) {
|
||||
if (localParsed.minor > remoteParsed.minor) {
|
||||
plugins.push({
|
||||
pluginId,
|
||||
action: "update",
|
||||
targetVersion: localVersion,
|
||||
localVersion,
|
||||
remoteVersion,
|
||||
reason: `Local has newer minor version (${localVersion} > ${remoteVersion})`,
|
||||
});
|
||||
} else {
|
||||
plugins.push({
|
||||
pluginId,
|
||||
action: "update",
|
||||
targetVersion: remoteVersion,
|
||||
localVersion,
|
||||
remoteVersion,
|
||||
reason: `Remote has newer minor version (${remoteVersion} > ${localVersion})`,
|
||||
});
|
||||
}
|
||||
} else if (localParsed.patch !== remoteParsed.patch) {
|
||||
// Patch-only difference - still a "no-action" per spec
|
||||
plugins.push({
|
||||
pluginId,
|
||||
action: "no-action",
|
||||
localVersion,
|
||||
remoteVersion,
|
||||
reason: "Versions match (patch difference only)",
|
||||
});
|
||||
} else {
|
||||
// Exact match
|
||||
plugins.push({
|
||||
pluginId,
|
||||
action: "no-action",
|
||||
localVersion,
|
||||
remoteVersion,
|
||||
reason: "Versions match",
|
||||
});
|
||||
}
|
||||
} else {
|
||||
// Invalid semver - can't compare
|
||||
plugins.push({
|
||||
pluginId,
|
||||
action: "no-action",
|
||||
localVersion,
|
||||
remoteVersion,
|
||||
reason: "Cannot compare - invalid version format",
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
const comparedAt = new Date().toISOString();
|
||||
const actionsNeeded = plugins.filter((p) => p.action !== "no-action");
|
||||
const isCompatible = actionsNeeded.length === 0;
|
||||
|
||||
const inSync = plugins.filter((p) => p.action === "no-action").length;
|
||||
const needUpdate = plugins.filter((p) => p.action === "update").length;
|
||||
const needInstall = plugins.filter((p) => p.action === "install").length;
|
||||
const needRemove = plugins.filter((p) => p.action === "remove").length;
|
||||
|
||||
const summaryParts: string[] = [];
|
||||
if (inSync > 0) summaryParts.push(`${inSync} plugin${inSync !== 1 ? "s" : ""} in sync`);
|
||||
if (needUpdate > 0) summaryParts.push(`${needUpdate} need${needUpdate === 1 ? "s" : ""} update`);
|
||||
if (needInstall > 0) summaryParts.push(`${needInstall} need${needInstall === 1 ? "s" : ""} install`);
|
||||
if (needRemove > 0) summaryParts.push(`${needRemove} need${needRemove === 1 ? "s" : ""} removal`);
|
||||
|
||||
const result: PluginSyncResult = {
|
||||
localNodeId,
|
||||
remoteNodeId,
|
||||
plugins,
|
||||
comparedAt,
|
||||
isCompatible,
|
||||
summary: summaryParts.join(", ") || "No plugins to compare",
|
||||
};
|
||||
|
||||
this.emit("node:plugins:synced", result);
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check version compatibility between two version strings.
|
||||
*
|
||||
* @param local - Local version string
|
||||
* @param remote - Remote version string
|
||||
* @returns Compatibility result
|
||||
*/
|
||||
checkVersionCompatibility(
|
||||
local: string,
|
||||
remote: string,
|
||||
): VersionCompatibilityResult {
|
||||
const localParsed = parseSemver(local);
|
||||
const remoteParsed = parseSemver(remote);
|
||||
|
||||
if (!localParsed || !remoteParsed) {
|
||||
return {
|
||||
localVersion: local,
|
||||
remoteVersion: remote,
|
||||
status: "incompatible",
|
||||
message: "Invalid version format",
|
||||
};
|
||||
}
|
||||
|
||||
if (
|
||||
localParsed.major === remoteParsed.major &&
|
||||
localParsed.minor === remoteParsed.minor &&
|
||||
localParsed.patch === remoteParsed.patch
|
||||
) {
|
||||
return {
|
||||
localVersion: local,
|
||||
remoteVersion: remote,
|
||||
status: "compatible",
|
||||
message: "Versions match",
|
||||
};
|
||||
}
|
||||
|
||||
if (localParsed.major !== remoteParsed.major) {
|
||||
return {
|
||||
localVersion: local,
|
||||
remoteVersion: remote,
|
||||
status: "major-difference",
|
||||
message: `Major version mismatch: local ${local} vs remote ${remote}`,
|
||||
};
|
||||
}
|
||||
|
||||
if (localParsed.minor !== remoteParsed.minor) {
|
||||
return {
|
||||
localVersion: local,
|
||||
remoteVersion: remote,
|
||||
status: "minor-difference",
|
||||
message: `Minor version difference: local ${local} vs remote ${remote}`,
|
||||
};
|
||||
}
|
||||
|
||||
return {
|
||||
localVersion: local,
|
||||
remoteVersion: remote,
|
||||
status: "compatible",
|
||||
message: `Patch version difference only: local ${local} vs remote ${remote}`,
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
@@ -39,7 +39,7 @@ describe("CentralDatabase", () => {
|
||||
|
||||
it("should initialize schema version", () => {
|
||||
db.init();
|
||||
expect(db.getSchemaVersion()).toBe(3);
|
||||
expect(db.getSchemaVersion()).toBe(4);
|
||||
});
|
||||
|
||||
it("should seed lastModified on init", () => {
|
||||
@@ -118,6 +118,17 @@ describe("CentralDatabase", () => {
|
||||
expect(columnNames).toContain("knownPeers");
|
||||
});
|
||||
|
||||
it("should include versionInfo and pluginVersions columns on nodes table", () => {
|
||||
db.init();
|
||||
|
||||
const columns = db.prepare("PRAGMA table_info(nodes)").all() as Array<{
|
||||
name: string;
|
||||
}>;
|
||||
const columnNames = columns.map((column) => column.name);
|
||||
expect(columnNames).toContain("versionInfo");
|
||||
expect(columnNames).toContain("pluginVersions");
|
||||
});
|
||||
|
||||
it("should create peerNodes table with expected columns", () => {
|
||||
db.init();
|
||||
|
||||
@@ -202,7 +213,7 @@ describe("CentralDatabase", () => {
|
||||
|
||||
db.init();
|
||||
|
||||
expect(db.getSchemaVersion()).toBe(3);
|
||||
expect(db.getSchemaVersion()).toBe(4);
|
||||
|
||||
const nodeColumns = db.prepare("PRAGMA table_info(nodes)").all() as Array<{ name: string }>;
|
||||
const nodeColumnNames = nodeColumns.map((column) => column.name);
|
||||
@@ -219,6 +230,70 @@ describe("CentralDatabase", () => {
|
||||
.all() as Array<{ name: string }>;
|
||||
expect(peerIndexes.map((index) => index.name)).toContain("idxPeerNodesNodeId");
|
||||
});
|
||||
|
||||
it("should migrate from v3 to v4 with version tracking columns", () => {
|
||||
const now = new Date().toISOString();
|
||||
|
||||
// Create v3 schema manually
|
||||
db.exec(`
|
||||
CREATE TABLE IF NOT EXISTS projects (
|
||||
id TEXT PRIMARY KEY,
|
||||
name TEXT NOT NULL,
|
||||
path TEXT NOT NULL UNIQUE,
|
||||
status TEXT NOT NULL DEFAULT 'active',
|
||||
isolationMode TEXT NOT NULL DEFAULT 'in-process',
|
||||
createdAt TEXT NOT NULL,
|
||||
updatedAt TEXT NOT NULL,
|
||||
lastActivityAt TEXT,
|
||||
nodeId TEXT,
|
||||
settings TEXT
|
||||
);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS nodes (
|
||||
id TEXT PRIMARY KEY,
|
||||
name TEXT NOT NULL UNIQUE,
|
||||
type TEXT NOT NULL CHECK (type IN ('local', 'remote')),
|
||||
url TEXT,
|
||||
apiKey TEXT,
|
||||
status TEXT NOT NULL DEFAULT 'offline',
|
||||
capabilities TEXT,
|
||||
systemMetrics TEXT,
|
||||
knownPeers TEXT,
|
||||
maxConcurrent INTEGER NOT NULL DEFAULT 2,
|
||||
createdAt TEXT NOT NULL,
|
||||
updatedAt TEXT NOT NULL
|
||||
);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS __meta (
|
||||
key TEXT PRIMARY KEY,
|
||||
value TEXT
|
||||
);
|
||||
`);
|
||||
|
||||
db.prepare("INSERT INTO __meta (key, value) VALUES ('schemaVersion', '3')").run();
|
||||
db.prepare("INSERT INTO __meta (key, value) VALUES ('lastModified', ?)").run(String(Date.now()));
|
||||
db.prepare(
|
||||
"INSERT INTO nodes (id, name, type, createdAt, updatedAt) VALUES (?, ?, ?, ?, ?)",
|
||||
).run("node_v3", "v3-node", "local", now, now);
|
||||
|
||||
db.init();
|
||||
|
||||
expect(db.getSchemaVersion()).toBe(4);
|
||||
|
||||
const nodeColumns = db.prepare("PRAGMA table_info(nodes)").all() as Array<{ name: string }>;
|
||||
const nodeColumnNames = nodeColumns.map((column) => column.name);
|
||||
expect(nodeColumnNames).toContain("versionInfo");
|
||||
expect(nodeColumnNames).toContain("pluginVersions");
|
||||
|
||||
// Verify nullable columns - can insert node without them
|
||||
const row = db.prepare("SELECT versionInfo, pluginVersions FROM nodes WHERE id = ?").get("node_v3") as {
|
||||
versionInfo: string | null;
|
||||
pluginVersions: string | null;
|
||||
} | undefined;
|
||||
expect(row).toBeDefined();
|
||||
expect(row?.versionInfo).toBeNull();
|
||||
expect(row?.pluginVersions).toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
describe("transactions", () => {
|
||||
|
||||
@@ -23,7 +23,7 @@ export { toJson, toJsonNullable, fromJson };
|
||||
|
||||
// ── Schema Definition ───────────────────────────────────────────────────
|
||||
|
||||
const CENTRAL_SCHEMA_VERSION = 3;
|
||||
const CENTRAL_SCHEMA_VERSION = 4;
|
||||
|
||||
const CENTRAL_SCHEMA_SQL = `
|
||||
-- Projects table (project registry)
|
||||
@@ -98,6 +98,8 @@ CREATE TABLE IF NOT EXISTS nodes (
|
||||
capabilities TEXT,
|
||||
systemMetrics TEXT,
|
||||
knownPeers TEXT,
|
||||
versionInfo TEXT,
|
||||
pluginVersions TEXT,
|
||||
maxConcurrent INTEGER NOT NULL DEFAULT 2,
|
||||
createdAt TEXT NOT NULL,
|
||||
updatedAt TEXT NOT NULL
|
||||
@@ -167,6 +169,11 @@ const CENTRAL_SCHEMA_V3_CREATE_PEERS_SQL = CENTRAL_SCHEMA_V3_MIGRATION_SQL
|
||||
.filter((line) => !line.trim().startsWith("ALTER TABLE nodes ADD COLUMN"))
|
||||
.join("\n");
|
||||
|
||||
const CENTRAL_SCHEMA_V4_MIGRATION_SQL = `
|
||||
ALTER TABLE nodes ADD COLUMN versionInfo TEXT;
|
||||
ALTER TABLE nodes ADD COLUMN pluginVersions TEXT;
|
||||
`;
|
||||
|
||||
// ── Central Database Class ────────────────────────────────────────────────
|
||||
|
||||
export class CentralDatabase {
|
||||
@@ -222,6 +229,16 @@ export class CentralDatabase {
|
||||
migrated = true;
|
||||
}
|
||||
|
||||
if (currentVersion < 4) {
|
||||
if (!this.hasColumn("nodes", "versionInfo")) {
|
||||
this.db.exec("ALTER TABLE nodes ADD COLUMN versionInfo TEXT");
|
||||
}
|
||||
if (!this.hasColumn("nodes", "pluginVersions")) {
|
||||
this.db.exec("ALTER TABLE nodes ADD COLUMN pluginVersions TEXT");
|
||||
}
|
||||
migrated = true;
|
||||
}
|
||||
|
||||
if (migrated) {
|
||||
this.db
|
||||
.prepare("INSERT INTO __meta (key, value) VALUES ('schemaVersion', ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value")
|
||||
|
||||
@@ -172,6 +172,7 @@ export { CentralDatabase, createCentralDatabase } from "./central-db.js";
|
||||
export { NodeConnection } from "./node-connection.js";
|
||||
export { NodeDiscovery } from "./node-discovery.js";
|
||||
export { collectSystemMetrics } from "./system-metrics.js";
|
||||
export { getAppVersion, parseSemver } from "./app-version.js";
|
||||
export type {
|
||||
ConnectionErrorType,
|
||||
ConnectionOptions,
|
||||
@@ -188,6 +189,8 @@ export type {
|
||||
NodeConfig,
|
||||
NodeMeshState,
|
||||
NodeStatus,
|
||||
NodeVersionInfo,
|
||||
NodeVersionInfoInput,
|
||||
NodeDiscoveryEvent,
|
||||
DiscoveryConfig,
|
||||
DiscoveredNode,
|
||||
@@ -195,6 +198,9 @@ export type {
|
||||
PeerNode,
|
||||
PeerSyncRequest,
|
||||
PeerSyncResponse,
|
||||
PluginSyncResult,
|
||||
PluginSyncEntry,
|
||||
PluginSyncAction,
|
||||
ProjectHealth,
|
||||
/** @deprecated Use RegisteredProject instead */
|
||||
ProjectInfo,
|
||||
@@ -203,6 +209,8 @@ export type {
|
||||
RegisteredProject,
|
||||
SetupCompletionResult,
|
||||
SetupState,
|
||||
VersionCompatibilityResult,
|
||||
VersionCompatibilityStatus,
|
||||
} from "./types.js";
|
||||
|
||||
// ── Migration and First-Run Experience ────────────────────────────────
|
||||
|
||||
@@ -1627,6 +1627,10 @@ export interface NodeConfig {
|
||||
systemMetrics?: SystemMetrics;
|
||||
/** Optional list of known peer node IDs. */
|
||||
knownPeers?: string[];
|
||||
/** Version tracking info (app version, plugin versions, last sync) */
|
||||
versionInfo?: NodeVersionInfo;
|
||||
/** Snapshot of plugin ID → version mapping */
|
||||
pluginVersions?: Record<string, string>;
|
||||
/** Maximum concurrent tasks/runtimes this node can host */
|
||||
maxConcurrent: number;
|
||||
/** ISO-8601 timestamp of creation */
|
||||
@@ -1635,6 +1639,82 @@ export interface NodeConfig {
|
||||
updatedAt: string;
|
||||
}
|
||||
|
||||
/** Version information tracked per node for plugin synchronization */
|
||||
export interface NodeVersionInfo {
|
||||
/** Core Fusion application version (semver string, e.g., "0.1.0") */
|
||||
appVersion: string;
|
||||
/** Map of plugin-id → semver version string for all installed plugins */
|
||||
pluginVersions: Record<string, string>;
|
||||
/** ISO-8601 timestamp of the last sync operation */
|
||||
lastSyncedAt: string;
|
||||
}
|
||||
|
||||
/** Input for updating node version info. appVersion is optional and will be auto-filled if not provided. */
|
||||
export type NodeVersionInfoInput = Omit<NodeVersionInfo, "appVersion"> & {
|
||||
/** Core Fusion application version. If not provided, will be auto-filled with the current app version. */
|
||||
appVersion?: string;
|
||||
};
|
||||
|
||||
/** A single plugin's version information for sync comparison */
|
||||
export interface PluginVersionEntry {
|
||||
/** Plugin ID (matches PluginManifest.id) */
|
||||
pluginId: string;
|
||||
/** Version on the source/local node (undefined if not installed) */
|
||||
localVersion?: string;
|
||||
/** Version on the target/remote node (undefined if not installed) */
|
||||
remoteVersion?: string;
|
||||
}
|
||||
|
||||
/** Suggested action for a plugin during node synchronization */
|
||||
export type PluginSyncAction = "install" | "update" | "remove" | "no-action";
|
||||
|
||||
/** A single plugin sync recommendation */
|
||||
export interface PluginSyncEntry {
|
||||
/** Plugin ID */
|
||||
pluginId: string;
|
||||
/** Suggested action */
|
||||
action: PluginSyncAction;
|
||||
/** Version to install/update to (undefined for "remove" and "no-action") */
|
||||
targetVersion?: string;
|
||||
/** Current version on the local node (undefined if not installed) */
|
||||
localVersion?: string;
|
||||
/** Current version on the remote node (undefined if not installed) */
|
||||
remoteVersion?: string;
|
||||
/** Reason for the suggested action */
|
||||
reason: string;
|
||||
}
|
||||
|
||||
/** Result of comparing plugin versions between two nodes */
|
||||
export interface PluginSyncResult {
|
||||
/** The local node ID */
|
||||
localNodeId: string;
|
||||
/** The remote node ID being compared against */
|
||||
remoteNodeId: string;
|
||||
/** List of plugin sync recommendations */
|
||||
plugins: PluginSyncEntry[];
|
||||
/** ISO-8601 timestamp of when this comparison was made */
|
||||
comparedAt: string;
|
||||
/** Whether the two nodes are considered compatible (no install/update/remove needed) */
|
||||
isCompatible: boolean;
|
||||
/** Summary message */
|
||||
summary: string;
|
||||
}
|
||||
|
||||
/** Compatibility status between two version strings */
|
||||
export type VersionCompatibilityStatus = "compatible" | "minor-difference" | "major-difference" | "incompatible";
|
||||
|
||||
/** Result of checking version compatibility between two versions */
|
||||
export interface VersionCompatibilityResult {
|
||||
/** The local version */
|
||||
localVersion: string;
|
||||
/** The remote version */
|
||||
remoteVersion: string;
|
||||
/** Overall compatibility status */
|
||||
status: VersionCompatibilityStatus;
|
||||
/** Human-readable explanation */
|
||||
message: string;
|
||||
}
|
||||
|
||||
/** A project registered in the central database */
|
||||
export interface RegisteredProject {
|
||||
/** Unique project ID (e.g., "proj_abc123") */
|
||||
|
||||
Reference in New Issue
Block a user