85bf1341f3
Frontend Enhancements: - Complete React TypeScript frontend with modern UI components - Distributed workflows management interface with real-time updates - Socket.IO integration for live agent status monitoring - Agent management dashboard with cluster visualization - Project management interface with metrics and task tracking - Responsive design with proper error handling and loading states Backend Infrastructure: - Distributed coordinator for multi-agent workflow orchestration - Cluster management API with comprehensive agent operations - Enhanced database models for agents and projects - Project service for filesystem-based project discovery - Performance monitoring and metrics collection - Comprehensive API documentation and error handling Documentation: - Complete distributed development guide (README_DISTRIBUTED.md) - Comprehensive development report with architecture insights - System configuration templates and deployment guides The platform now provides a complete web interface for managing the distributed AI cluster with real-time monitoring, workflow orchestration, and agent coordination capabilities. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>
339 lines
12 KiB
JavaScript
339 lines
12 KiB
JavaScript
/**
|
|
* @license React
|
|
* react-refresh-runtime.development.js
|
|
*
|
|
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
|
*
|
|
* This source code is licensed under the MIT license found in the
|
|
* LICENSE file in the root directory of this source tree.
|
|
*/
|
|
|
|
"use strict";
|
|
"production" !== process.env.NODE_ENV &&
|
|
(function () {
|
|
function computeFullKey(signature) {
|
|
if (null !== signature.fullKey) return signature.fullKey;
|
|
var fullKey = signature.ownKey;
|
|
try {
|
|
var hooks = signature.getCustomHooks();
|
|
} catch (err) {
|
|
return (signature.forceReset = !0), (signature.fullKey = fullKey);
|
|
}
|
|
for (var i = 0; i < hooks.length; i++) {
|
|
var hook = hooks[i];
|
|
if ("function" !== typeof hook)
|
|
return (signature.forceReset = !0), (signature.fullKey = fullKey);
|
|
hook = allSignaturesByType.get(hook);
|
|
if (void 0 !== hook) {
|
|
var nestedHookKey = computeFullKey(hook);
|
|
hook.forceReset && (signature.forceReset = !0);
|
|
fullKey += "\n---\n" + nestedHookKey;
|
|
}
|
|
}
|
|
return (signature.fullKey = fullKey);
|
|
}
|
|
function resolveFamily(type) {
|
|
return updatedFamiliesByType.get(type);
|
|
}
|
|
function cloneMap(map) {
|
|
var clone = new Map();
|
|
map.forEach(function (value, key) {
|
|
clone.set(key, value);
|
|
});
|
|
return clone;
|
|
}
|
|
function cloneSet(set) {
|
|
var clone = new Set();
|
|
set.forEach(function (value) {
|
|
clone.add(value);
|
|
});
|
|
return clone;
|
|
}
|
|
function getProperty(object, property) {
|
|
try {
|
|
return object[property];
|
|
} catch (err) {}
|
|
}
|
|
function register(type, id) {
|
|
if (
|
|
!(
|
|
null === type ||
|
|
("function" !== typeof type && "object" !== typeof type) ||
|
|
allFamiliesByType.has(type)
|
|
)
|
|
) {
|
|
var family = allFamiliesByID.get(id);
|
|
void 0 === family
|
|
? ((family = { current: type }), allFamiliesByID.set(id, family))
|
|
: pendingUpdates.push([family, type]);
|
|
allFamiliesByType.set(type, family);
|
|
if ("object" === typeof type && null !== type)
|
|
switch (getProperty(type, "$$typeof")) {
|
|
case REACT_FORWARD_REF_TYPE:
|
|
register(type.render, id + "$render");
|
|
break;
|
|
case REACT_MEMO_TYPE:
|
|
register(type.type, id + "$type");
|
|
}
|
|
}
|
|
}
|
|
function setSignature(type, key) {
|
|
var forceReset =
|
|
2 < arguments.length && void 0 !== arguments[2] ? arguments[2] : !1,
|
|
getCustomHooks = 3 < arguments.length ? arguments[3] : void 0;
|
|
allSignaturesByType.has(type) ||
|
|
allSignaturesByType.set(type, {
|
|
forceReset: forceReset,
|
|
ownKey: key,
|
|
fullKey: null,
|
|
getCustomHooks:
|
|
getCustomHooks ||
|
|
function () {
|
|
return [];
|
|
}
|
|
});
|
|
if ("object" === typeof type && null !== type)
|
|
switch (getProperty(type, "$$typeof")) {
|
|
case REACT_FORWARD_REF_TYPE:
|
|
setSignature(type.render, key, forceReset, getCustomHooks);
|
|
break;
|
|
case REACT_MEMO_TYPE:
|
|
setSignature(type.type, key, forceReset, getCustomHooks);
|
|
}
|
|
}
|
|
function collectCustomHooksForSignature(type) {
|
|
type = allSignaturesByType.get(type);
|
|
void 0 !== type && computeFullKey(type);
|
|
}
|
|
var REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"),
|
|
REACT_MEMO_TYPE = Symbol.for("react.memo"),
|
|
PossiblyWeakMap = "function" === typeof WeakMap ? WeakMap : Map,
|
|
allFamiliesByID = new Map(),
|
|
allFamiliesByType = new PossiblyWeakMap(),
|
|
allSignaturesByType = new PossiblyWeakMap(),
|
|
updatedFamiliesByType = new PossiblyWeakMap(),
|
|
pendingUpdates = [],
|
|
helpersByRendererID = new Map(),
|
|
helpersByRoot = new Map(),
|
|
mountedRoots = new Set(),
|
|
failedRoots = new Set(),
|
|
rootElements = "function" === typeof WeakMap ? new WeakMap() : null,
|
|
isPerformingRefresh = !1;
|
|
exports._getMountedRootCount = function () {
|
|
return mountedRoots.size;
|
|
};
|
|
exports.collectCustomHooksForSignature = collectCustomHooksForSignature;
|
|
exports.createSignatureFunctionForTransform = function () {
|
|
var savedType,
|
|
hasCustomHooks,
|
|
didCollectHooks = !1;
|
|
return function (type, key, forceReset, getCustomHooks) {
|
|
if ("string" === typeof key)
|
|
return (
|
|
savedType ||
|
|
((savedType = type),
|
|
(hasCustomHooks = "function" === typeof getCustomHooks)),
|
|
null == type ||
|
|
("function" !== typeof type && "object" !== typeof type) ||
|
|
setSignature(type, key, forceReset, getCustomHooks),
|
|
type
|
|
);
|
|
!didCollectHooks &&
|
|
hasCustomHooks &&
|
|
((didCollectHooks = !0), collectCustomHooksForSignature(savedType));
|
|
};
|
|
};
|
|
exports.getFamilyByID = function (id) {
|
|
return allFamiliesByID.get(id);
|
|
};
|
|
exports.getFamilyByType = function (type) {
|
|
return allFamiliesByType.get(type);
|
|
};
|
|
exports.hasUnrecoverableErrors = function () {
|
|
return !1;
|
|
};
|
|
exports.injectIntoGlobalHook = function (globalObject) {
|
|
var hook = globalObject.__REACT_DEVTOOLS_GLOBAL_HOOK__;
|
|
if (void 0 === hook) {
|
|
var nextID = 0;
|
|
globalObject.__REACT_DEVTOOLS_GLOBAL_HOOK__ = hook = {
|
|
renderers: new Map(),
|
|
supportsFiber: !0,
|
|
inject: function () {
|
|
return nextID++;
|
|
},
|
|
onScheduleFiberRoot: function () {},
|
|
onCommitFiberRoot: function () {},
|
|
onCommitFiberUnmount: function () {}
|
|
};
|
|
}
|
|
if (hook.isDisabled)
|
|
console.warn(
|
|
"Something has shimmed the React DevTools global hook (__REACT_DEVTOOLS_GLOBAL_HOOK__). Fast Refresh is not compatible with this shim and will be disabled."
|
|
);
|
|
else {
|
|
var oldInject = hook.inject;
|
|
hook.inject = function (injected) {
|
|
var id = oldInject.apply(this, arguments);
|
|
"function" === typeof injected.scheduleRefresh &&
|
|
"function" === typeof injected.setRefreshHandler &&
|
|
helpersByRendererID.set(id, injected);
|
|
return id;
|
|
};
|
|
hook.renderers.forEach(function (injected, id) {
|
|
"function" === typeof injected.scheduleRefresh &&
|
|
"function" === typeof injected.setRefreshHandler &&
|
|
helpersByRendererID.set(id, injected);
|
|
});
|
|
var oldOnCommitFiberRoot = hook.onCommitFiberRoot,
|
|
oldOnScheduleFiberRoot = hook.onScheduleFiberRoot || function () {};
|
|
hook.onScheduleFiberRoot = function (id, root, children) {
|
|
isPerformingRefresh ||
|
|
(failedRoots.delete(root),
|
|
null !== rootElements && rootElements.set(root, children));
|
|
return oldOnScheduleFiberRoot.apply(this, arguments);
|
|
};
|
|
hook.onCommitFiberRoot = function (
|
|
id,
|
|
root,
|
|
maybePriorityLevel,
|
|
didError
|
|
) {
|
|
var helpers = helpersByRendererID.get(id);
|
|
if (void 0 !== helpers) {
|
|
helpersByRoot.set(root, helpers);
|
|
helpers = root.current;
|
|
var alternate = helpers.alternate;
|
|
null !== alternate
|
|
? ((alternate =
|
|
null != alternate.memoizedState &&
|
|
null != alternate.memoizedState.element &&
|
|
mountedRoots.has(root)),
|
|
(helpers =
|
|
null != helpers.memoizedState &&
|
|
null != helpers.memoizedState.element),
|
|
!alternate && helpers
|
|
? (mountedRoots.add(root), failedRoots.delete(root))
|
|
: (alternate && helpers) ||
|
|
(alternate && !helpers
|
|
? (mountedRoots.delete(root),
|
|
didError
|
|
? failedRoots.add(root)
|
|
: helpersByRoot.delete(root))
|
|
: alternate ||
|
|
helpers ||
|
|
(didError && failedRoots.add(root))))
|
|
: mountedRoots.add(root);
|
|
}
|
|
return oldOnCommitFiberRoot.apply(this, arguments);
|
|
};
|
|
}
|
|
};
|
|
exports.isLikelyComponentType = function (type) {
|
|
switch (typeof type) {
|
|
case "function":
|
|
if (null != type.prototype) {
|
|
if (type.prototype.isReactComponent) return !0;
|
|
var ownNames = Object.getOwnPropertyNames(type.prototype);
|
|
if (
|
|
1 < ownNames.length ||
|
|
"constructor" !== ownNames[0] ||
|
|
type.prototype.__proto__ !== Object.prototype
|
|
)
|
|
return !1;
|
|
}
|
|
type = type.name || type.displayName;
|
|
return "string" === typeof type && /^[A-Z]/.test(type);
|
|
case "object":
|
|
if (null != type)
|
|
switch (getProperty(type, "$$typeof")) {
|
|
case REACT_FORWARD_REF_TYPE:
|
|
case REACT_MEMO_TYPE:
|
|
return !0;
|
|
}
|
|
return !1;
|
|
default:
|
|
return !1;
|
|
}
|
|
};
|
|
exports.performReactRefresh = function () {
|
|
if (0 === pendingUpdates.length || isPerformingRefresh) return null;
|
|
isPerformingRefresh = !0;
|
|
try {
|
|
var staleFamilies = new Set(),
|
|
updatedFamilies = new Set(),
|
|
updates = pendingUpdates;
|
|
pendingUpdates = [];
|
|
updates.forEach(function (_ref) {
|
|
var family = _ref[0];
|
|
_ref = _ref[1];
|
|
var prevType = family.current;
|
|
updatedFamiliesByType.set(prevType, family);
|
|
updatedFamiliesByType.set(_ref, family);
|
|
family.current = _ref;
|
|
(prevType.prototype && prevType.prototype.isReactComponent) ||
|
|
(_ref.prototype && _ref.prototype.isReactComponent)
|
|
? (_ref = !1)
|
|
: ((prevType = allSignaturesByType.get(prevType)),
|
|
(_ref = allSignaturesByType.get(_ref)),
|
|
(_ref =
|
|
(void 0 === prevType && void 0 === _ref) ||
|
|
(void 0 !== prevType &&
|
|
void 0 !== _ref &&
|
|
computeFullKey(prevType) === computeFullKey(_ref) &&
|
|
!_ref.forceReset)
|
|
? !0
|
|
: !1));
|
|
_ref ? updatedFamilies.add(family) : staleFamilies.add(family);
|
|
});
|
|
var update = {
|
|
updatedFamilies: updatedFamilies,
|
|
staleFamilies: staleFamilies
|
|
};
|
|
helpersByRendererID.forEach(function (helpers) {
|
|
helpers.setRefreshHandler(resolveFamily);
|
|
});
|
|
var didError = !1,
|
|
firstError = null,
|
|
failedRootsSnapshot = cloneSet(failedRoots),
|
|
mountedRootsSnapshot = cloneSet(mountedRoots),
|
|
helpersByRootSnapshot = cloneMap(helpersByRoot);
|
|
failedRootsSnapshot.forEach(function (root) {
|
|
var helpers = helpersByRootSnapshot.get(root);
|
|
if (void 0 === helpers)
|
|
throw Error(
|
|
"Could not find helpers for a root. This is a bug in React Refresh."
|
|
);
|
|
failedRoots.has(root);
|
|
if (null !== rootElements && rootElements.has(root)) {
|
|
var element = rootElements.get(root);
|
|
try {
|
|
helpers.scheduleRoot(root, element);
|
|
} catch (err) {
|
|
didError || ((didError = !0), (firstError = err));
|
|
}
|
|
}
|
|
});
|
|
mountedRootsSnapshot.forEach(function (root) {
|
|
var helpers = helpersByRootSnapshot.get(root);
|
|
if (void 0 === helpers)
|
|
throw Error(
|
|
"Could not find helpers for a root. This is a bug in React Refresh."
|
|
);
|
|
mountedRoots.has(root);
|
|
try {
|
|
helpers.scheduleRefresh(root, update);
|
|
} catch (err) {
|
|
didError || ((didError = !0), (firstError = err));
|
|
}
|
|
});
|
|
if (didError) throw firstError;
|
|
return update;
|
|
} finally {
|
|
isPerformingRefresh = !1;
|
|
}
|
|
};
|
|
exports.register = register;
|
|
exports.setSignature = setSignature;
|
|
})();
|