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>
593 lines
22 KiB
JavaScript
593 lines
22 KiB
JavaScript
System.register([], (function (exports) {
|
|
'use strict';
|
|
return {
|
|
execute: (function () {
|
|
|
|
exports("createJSONStorage", createJSONStorage);
|
|
|
|
const reduxImpl = (reducer, initial) => (set, _get, api) => {
|
|
api.dispatch = (action) => {
|
|
set((state) => reducer(state, action), false, action);
|
|
return action;
|
|
};
|
|
api.dispatchFromDevtools = true;
|
|
return { dispatch: (...a) => api.dispatch(...a), ...initial };
|
|
};
|
|
const redux = exports("redux", reduxImpl);
|
|
|
|
const trackedConnections = /* @__PURE__ */ new Map();
|
|
const getTrackedConnectionState = (name) => {
|
|
const api = trackedConnections.get(name);
|
|
if (!api) return {};
|
|
return Object.fromEntries(
|
|
Object.entries(api.stores).map(([key, api2]) => [key, api2.getState()])
|
|
);
|
|
};
|
|
const extractConnectionInformation = (store, extensionConnector, options) => {
|
|
if (store === void 0) {
|
|
return {
|
|
type: "untracked",
|
|
connection: extensionConnector.connect(options)
|
|
};
|
|
}
|
|
const existingConnection = trackedConnections.get(options.name);
|
|
if (existingConnection) {
|
|
return { type: "tracked", store, ...existingConnection };
|
|
}
|
|
const newConnection = {
|
|
connection: extensionConnector.connect(options),
|
|
stores: {}
|
|
};
|
|
trackedConnections.set(options.name, newConnection);
|
|
return { type: "tracked", store, ...newConnection };
|
|
};
|
|
const devtoolsImpl = (fn, devtoolsOptions = {}) => (set, get, api) => {
|
|
const { enabled, anonymousActionType, store, ...options } = devtoolsOptions;
|
|
let extensionConnector;
|
|
try {
|
|
extensionConnector = (enabled != null ? enabled : true) && window.__REDUX_DEVTOOLS_EXTENSION__;
|
|
} catch (_e) {
|
|
}
|
|
if (!extensionConnector) {
|
|
if (enabled) {
|
|
console.warn(
|
|
"[zustand devtools middleware] Please install/enable Redux devtools extension"
|
|
);
|
|
}
|
|
return fn(set, get, api);
|
|
}
|
|
const { connection, ...connectionInformation } = extractConnectionInformation(store, extensionConnector, options);
|
|
let isRecording = true;
|
|
api.setState = (state, replace, nameOrAction) => {
|
|
const r = set(state, replace);
|
|
if (!isRecording) return r;
|
|
const action = nameOrAction === void 0 ? { type: anonymousActionType || "anonymous" } : typeof nameOrAction === "string" ? { type: nameOrAction } : nameOrAction;
|
|
if (store === void 0) {
|
|
connection == null ? void 0 : connection.send(action, get());
|
|
return r;
|
|
}
|
|
connection == null ? void 0 : connection.send(
|
|
{
|
|
...action,
|
|
type: `${store}/${action.type}`
|
|
},
|
|
{
|
|
...getTrackedConnectionState(options.name),
|
|
[store]: api.getState()
|
|
}
|
|
);
|
|
return r;
|
|
};
|
|
const setStateFromDevtools = (...a) => {
|
|
const originalIsRecording = isRecording;
|
|
isRecording = false;
|
|
set(...a);
|
|
isRecording = originalIsRecording;
|
|
};
|
|
const initialState = fn(api.setState, get, api);
|
|
if (connectionInformation.type === "untracked") {
|
|
connection == null ? void 0 : connection.init(initialState);
|
|
} else {
|
|
connectionInformation.stores[connectionInformation.store] = api;
|
|
connection == null ? void 0 : connection.init(
|
|
Object.fromEntries(
|
|
Object.entries(connectionInformation.stores).map(([key, store2]) => [
|
|
key,
|
|
key === connectionInformation.store ? initialState : store2.getState()
|
|
])
|
|
)
|
|
);
|
|
}
|
|
if (api.dispatchFromDevtools && typeof api.dispatch === "function") {
|
|
let didWarnAboutReservedActionType = false;
|
|
const originalDispatch = api.dispatch;
|
|
api.dispatch = (...a) => {
|
|
if (a[0].type === "__setState" && !didWarnAboutReservedActionType) {
|
|
console.warn(
|
|
'[zustand devtools middleware] "__setState" action type is reserved to set state from the devtools. Avoid using it.'
|
|
);
|
|
didWarnAboutReservedActionType = true;
|
|
}
|
|
originalDispatch(...a);
|
|
};
|
|
}
|
|
connection.subscribe((message) => {
|
|
var _a;
|
|
switch (message.type) {
|
|
case "ACTION":
|
|
if (typeof message.payload !== "string") {
|
|
console.error(
|
|
"[zustand devtools middleware] Unsupported action format"
|
|
);
|
|
return;
|
|
}
|
|
return parseJsonThen(
|
|
message.payload,
|
|
(action) => {
|
|
if (action.type === "__setState") {
|
|
if (store === void 0) {
|
|
setStateFromDevtools(action.state);
|
|
return;
|
|
}
|
|
if (Object.keys(action.state).length !== 1) {
|
|
console.error(
|
|
`
|
|
[zustand devtools middleware] Unsupported __setState action format.
|
|
When using 'store' option in devtools(), the 'state' should have only one key, which is a value of 'store' that was passed in devtools(),
|
|
and value of this only key should be a state object. Example: { "type": "__setState", "state": { "abc123Store": { "foo": "bar" } } }
|
|
`
|
|
);
|
|
}
|
|
const stateFromDevtools = action.state[store];
|
|
if (stateFromDevtools === void 0 || stateFromDevtools === null) {
|
|
return;
|
|
}
|
|
if (JSON.stringify(api.getState()) !== JSON.stringify(stateFromDevtools)) {
|
|
setStateFromDevtools(stateFromDevtools);
|
|
}
|
|
return;
|
|
}
|
|
if (!api.dispatchFromDevtools) return;
|
|
if (typeof api.dispatch !== "function") return;
|
|
api.dispatch(action);
|
|
}
|
|
);
|
|
case "DISPATCH":
|
|
switch (message.payload.type) {
|
|
case "RESET":
|
|
setStateFromDevtools(initialState);
|
|
if (store === void 0) {
|
|
return connection == null ? void 0 : connection.init(api.getState());
|
|
}
|
|
return connection == null ? void 0 : connection.init(getTrackedConnectionState(options.name));
|
|
case "COMMIT":
|
|
if (store === void 0) {
|
|
connection == null ? void 0 : connection.init(api.getState());
|
|
return;
|
|
}
|
|
return connection == null ? void 0 : connection.init(getTrackedConnectionState(options.name));
|
|
case "ROLLBACK":
|
|
return parseJsonThen(message.state, (state) => {
|
|
if (store === void 0) {
|
|
setStateFromDevtools(state);
|
|
connection == null ? void 0 : connection.init(api.getState());
|
|
return;
|
|
}
|
|
setStateFromDevtools(state[store]);
|
|
connection == null ? void 0 : connection.init(getTrackedConnectionState(options.name));
|
|
});
|
|
case "JUMP_TO_STATE":
|
|
case "JUMP_TO_ACTION":
|
|
return parseJsonThen(message.state, (state) => {
|
|
if (store === void 0) {
|
|
setStateFromDevtools(state);
|
|
return;
|
|
}
|
|
if (JSON.stringify(api.getState()) !== JSON.stringify(state[store])) {
|
|
setStateFromDevtools(state[store]);
|
|
}
|
|
});
|
|
case "IMPORT_STATE": {
|
|
const { nextLiftedState } = message.payload;
|
|
const lastComputedState = (_a = nextLiftedState.computedStates.slice(-1)[0]) == null ? void 0 : _a.state;
|
|
if (!lastComputedState) return;
|
|
if (store === void 0) {
|
|
setStateFromDevtools(lastComputedState);
|
|
} else {
|
|
setStateFromDevtools(lastComputedState[store]);
|
|
}
|
|
connection == null ? void 0 : connection.send(
|
|
null,
|
|
// FIXME no-any
|
|
nextLiftedState
|
|
);
|
|
return;
|
|
}
|
|
case "PAUSE_RECORDING":
|
|
return isRecording = !isRecording;
|
|
}
|
|
return;
|
|
}
|
|
});
|
|
return initialState;
|
|
};
|
|
const devtools = exports("devtools", devtoolsImpl);
|
|
const parseJsonThen = (stringified, f) => {
|
|
let parsed;
|
|
try {
|
|
parsed = JSON.parse(stringified);
|
|
} catch (e) {
|
|
console.error(
|
|
"[zustand devtools middleware] Could not parse the received json",
|
|
e
|
|
);
|
|
}
|
|
if (parsed !== void 0) f(parsed);
|
|
};
|
|
|
|
const subscribeWithSelectorImpl = (fn) => (set, get, api) => {
|
|
const origSubscribe = api.subscribe;
|
|
api.subscribe = (selector, optListener, options) => {
|
|
let listener = selector;
|
|
if (optListener) {
|
|
const equalityFn = (options == null ? void 0 : options.equalityFn) || Object.is;
|
|
let currentSlice = selector(api.getState());
|
|
listener = (state) => {
|
|
const nextSlice = selector(state);
|
|
if (!equalityFn(currentSlice, nextSlice)) {
|
|
const previousSlice = currentSlice;
|
|
optListener(currentSlice = nextSlice, previousSlice);
|
|
}
|
|
};
|
|
if (options == null ? void 0 : options.fireImmediately) {
|
|
optListener(currentSlice, currentSlice);
|
|
}
|
|
}
|
|
return origSubscribe(listener);
|
|
};
|
|
const initialState = fn(set, get, api);
|
|
return initialState;
|
|
};
|
|
const subscribeWithSelector = exports("subscribeWithSelector", subscribeWithSelectorImpl);
|
|
|
|
const combine = exports("combine", (initialState, create) => (...a) => Object.assign({}, initialState, create(...a)));
|
|
|
|
function createJSONStorage(getStorage, options) {
|
|
let storage;
|
|
try {
|
|
storage = getStorage();
|
|
} catch (_e) {
|
|
return;
|
|
}
|
|
const persistStorage = {
|
|
getItem: (name) => {
|
|
var _a;
|
|
const parse = (str2) => {
|
|
if (str2 === null) {
|
|
return null;
|
|
}
|
|
return JSON.parse(str2, options == null ? void 0 : options.reviver);
|
|
};
|
|
const str = (_a = storage.getItem(name)) != null ? _a : null;
|
|
if (str instanceof Promise) {
|
|
return str.then(parse);
|
|
}
|
|
return parse(str);
|
|
},
|
|
setItem: (name, newValue) => storage.setItem(
|
|
name,
|
|
JSON.stringify(newValue, options == null ? void 0 : options.replacer)
|
|
),
|
|
removeItem: (name) => storage.removeItem(name)
|
|
};
|
|
return persistStorage;
|
|
}
|
|
const toThenable = (fn) => (input) => {
|
|
try {
|
|
const result = fn(input);
|
|
if (result instanceof Promise) {
|
|
return result;
|
|
}
|
|
return {
|
|
then(onFulfilled) {
|
|
return toThenable(onFulfilled)(result);
|
|
},
|
|
catch(_onRejected) {
|
|
return this;
|
|
}
|
|
};
|
|
} catch (e) {
|
|
return {
|
|
then(_onFulfilled) {
|
|
return this;
|
|
},
|
|
catch(onRejected) {
|
|
return toThenable(onRejected)(e);
|
|
}
|
|
};
|
|
}
|
|
};
|
|
const oldImpl = (config, baseOptions) => (set, get, api) => {
|
|
let options = {
|
|
getStorage: () => localStorage,
|
|
serialize: JSON.stringify,
|
|
deserialize: JSON.parse,
|
|
partialize: (state) => state,
|
|
version: 0,
|
|
merge: (persistedState, currentState) => ({
|
|
...currentState,
|
|
...persistedState
|
|
}),
|
|
...baseOptions
|
|
};
|
|
let hasHydrated = false;
|
|
const hydrationListeners = /* @__PURE__ */ new Set();
|
|
const finishHydrationListeners = /* @__PURE__ */ new Set();
|
|
let storage;
|
|
try {
|
|
storage = options.getStorage();
|
|
} catch (_e) {
|
|
}
|
|
if (!storage) {
|
|
return config(
|
|
(...args) => {
|
|
console.warn(
|
|
`[zustand persist middleware] Unable to update item '${options.name}', the given storage is currently unavailable.`
|
|
);
|
|
set(...args);
|
|
},
|
|
get,
|
|
api
|
|
);
|
|
}
|
|
const thenableSerialize = toThenable(options.serialize);
|
|
const setItem = () => {
|
|
const state = options.partialize({ ...get() });
|
|
let errorInSync;
|
|
const thenable = thenableSerialize({ state, version: options.version }).then(
|
|
(serializedValue) => storage.setItem(options.name, serializedValue)
|
|
).catch((e) => {
|
|
errorInSync = e;
|
|
});
|
|
if (errorInSync) {
|
|
throw errorInSync;
|
|
}
|
|
return thenable;
|
|
};
|
|
const savedSetState = api.setState;
|
|
api.setState = (state, replace) => {
|
|
savedSetState(state, replace);
|
|
void setItem();
|
|
};
|
|
const configResult = config(
|
|
(...args) => {
|
|
set(...args);
|
|
void setItem();
|
|
},
|
|
get,
|
|
api
|
|
);
|
|
let stateFromStorage;
|
|
const hydrate = () => {
|
|
var _a;
|
|
if (!storage) return;
|
|
hasHydrated = false;
|
|
hydrationListeners.forEach((cb) => cb(get()));
|
|
const postRehydrationCallback = ((_a = options.onRehydrateStorage) == null ? void 0 : _a.call(options, get())) || void 0;
|
|
return toThenable(storage.getItem.bind(storage))(options.name).then((storageValue) => {
|
|
if (storageValue) {
|
|
return options.deserialize(storageValue);
|
|
}
|
|
}).then((deserializedStorageValue) => {
|
|
if (deserializedStorageValue) {
|
|
if (typeof deserializedStorageValue.version === "number" && deserializedStorageValue.version !== options.version) {
|
|
if (options.migrate) {
|
|
return options.migrate(
|
|
deserializedStorageValue.state,
|
|
deserializedStorageValue.version
|
|
);
|
|
}
|
|
console.error(
|
|
`State loaded from storage couldn't be migrated since no migrate function was provided`
|
|
);
|
|
} else {
|
|
return deserializedStorageValue.state;
|
|
}
|
|
}
|
|
}).then((migratedState) => {
|
|
var _a2;
|
|
stateFromStorage = options.merge(
|
|
migratedState,
|
|
(_a2 = get()) != null ? _a2 : configResult
|
|
);
|
|
set(stateFromStorage, true);
|
|
return setItem();
|
|
}).then(() => {
|
|
postRehydrationCallback == null ? void 0 : postRehydrationCallback(stateFromStorage, void 0);
|
|
hasHydrated = true;
|
|
finishHydrationListeners.forEach((cb) => cb(stateFromStorage));
|
|
}).catch((e) => {
|
|
postRehydrationCallback == null ? void 0 : postRehydrationCallback(void 0, e);
|
|
});
|
|
};
|
|
api.persist = {
|
|
setOptions: (newOptions) => {
|
|
options = {
|
|
...options,
|
|
...newOptions
|
|
};
|
|
if (newOptions.getStorage) {
|
|
storage = newOptions.getStorage();
|
|
}
|
|
},
|
|
clearStorage: () => {
|
|
storage == null ? void 0 : storage.removeItem(options.name);
|
|
},
|
|
getOptions: () => options,
|
|
rehydrate: () => hydrate(),
|
|
hasHydrated: () => hasHydrated,
|
|
onHydrate: (cb) => {
|
|
hydrationListeners.add(cb);
|
|
return () => {
|
|
hydrationListeners.delete(cb);
|
|
};
|
|
},
|
|
onFinishHydration: (cb) => {
|
|
finishHydrationListeners.add(cb);
|
|
return () => {
|
|
finishHydrationListeners.delete(cb);
|
|
};
|
|
}
|
|
};
|
|
hydrate();
|
|
return stateFromStorage || configResult;
|
|
};
|
|
const newImpl = (config, baseOptions) => (set, get, api) => {
|
|
let options = {
|
|
storage: createJSONStorage(() => localStorage),
|
|
partialize: (state) => state,
|
|
version: 0,
|
|
merge: (persistedState, currentState) => ({
|
|
...currentState,
|
|
...persistedState
|
|
}),
|
|
...baseOptions
|
|
};
|
|
let hasHydrated = false;
|
|
const hydrationListeners = /* @__PURE__ */ new Set();
|
|
const finishHydrationListeners = /* @__PURE__ */ new Set();
|
|
let storage = options.storage;
|
|
if (!storage) {
|
|
return config(
|
|
(...args) => {
|
|
console.warn(
|
|
`[zustand persist middleware] Unable to update item '${options.name}', the given storage is currently unavailable.`
|
|
);
|
|
set(...args);
|
|
},
|
|
get,
|
|
api
|
|
);
|
|
}
|
|
const setItem = () => {
|
|
const state = options.partialize({ ...get() });
|
|
return storage.setItem(options.name, {
|
|
state,
|
|
version: options.version
|
|
});
|
|
};
|
|
const savedSetState = api.setState;
|
|
api.setState = (state, replace) => {
|
|
savedSetState(state, replace);
|
|
void setItem();
|
|
};
|
|
const configResult = config(
|
|
(...args) => {
|
|
set(...args);
|
|
void setItem();
|
|
},
|
|
get,
|
|
api
|
|
);
|
|
api.getInitialState = () => configResult;
|
|
let stateFromStorage;
|
|
const hydrate = () => {
|
|
var _a, _b;
|
|
if (!storage) return;
|
|
hasHydrated = false;
|
|
hydrationListeners.forEach((cb) => {
|
|
var _a2;
|
|
return cb((_a2 = get()) != null ? _a2 : configResult);
|
|
});
|
|
const postRehydrationCallback = ((_b = options.onRehydrateStorage) == null ? void 0 : _b.call(options, (_a = get()) != null ? _a : configResult)) || void 0;
|
|
return toThenable(storage.getItem.bind(storage))(options.name).then((deserializedStorageValue) => {
|
|
if (deserializedStorageValue) {
|
|
if (typeof deserializedStorageValue.version === "number" && deserializedStorageValue.version !== options.version) {
|
|
if (options.migrate) {
|
|
return [
|
|
true,
|
|
options.migrate(
|
|
deserializedStorageValue.state,
|
|
deserializedStorageValue.version
|
|
)
|
|
];
|
|
}
|
|
console.error(
|
|
`State loaded from storage couldn't be migrated since no migrate function was provided`
|
|
);
|
|
} else {
|
|
return [false, deserializedStorageValue.state];
|
|
}
|
|
}
|
|
return [false, void 0];
|
|
}).then((migrationResult) => {
|
|
var _a2;
|
|
const [migrated, migratedState] = migrationResult;
|
|
stateFromStorage = options.merge(
|
|
migratedState,
|
|
(_a2 = get()) != null ? _a2 : configResult
|
|
);
|
|
set(stateFromStorage, true);
|
|
if (migrated) {
|
|
return setItem();
|
|
}
|
|
}).then(() => {
|
|
postRehydrationCallback == null ? void 0 : postRehydrationCallback(stateFromStorage, void 0);
|
|
stateFromStorage = get();
|
|
hasHydrated = true;
|
|
finishHydrationListeners.forEach((cb) => cb(stateFromStorage));
|
|
}).catch((e) => {
|
|
postRehydrationCallback == null ? void 0 : postRehydrationCallback(void 0, e);
|
|
});
|
|
};
|
|
api.persist = {
|
|
setOptions: (newOptions) => {
|
|
options = {
|
|
...options,
|
|
...newOptions
|
|
};
|
|
if (newOptions.storage) {
|
|
storage = newOptions.storage;
|
|
}
|
|
},
|
|
clearStorage: () => {
|
|
storage == null ? void 0 : storage.removeItem(options.name);
|
|
},
|
|
getOptions: () => options,
|
|
rehydrate: () => hydrate(),
|
|
hasHydrated: () => hasHydrated,
|
|
onHydrate: (cb) => {
|
|
hydrationListeners.add(cb);
|
|
return () => {
|
|
hydrationListeners.delete(cb);
|
|
};
|
|
},
|
|
onFinishHydration: (cb) => {
|
|
finishHydrationListeners.add(cb);
|
|
return () => {
|
|
finishHydrationListeners.delete(cb);
|
|
};
|
|
}
|
|
};
|
|
if (!options.skipHydration) {
|
|
hydrate();
|
|
}
|
|
return stateFromStorage || configResult;
|
|
};
|
|
const persistImpl = (config, baseOptions) => {
|
|
if ("getStorage" in baseOptions || "serialize" in baseOptions || "deserialize" in baseOptions) {
|
|
{
|
|
console.warn(
|
|
"[DEPRECATED] `getStorage`, `serialize` and `deserialize` options are deprecated. Use `storage` option instead."
|
|
);
|
|
}
|
|
return oldImpl(config, baseOptions);
|
|
}
|
|
return newImpl(config, baseOptions);
|
|
};
|
|
const persist = exports("persist", persistImpl);
|
|
|
|
})
|
|
};
|
|
}));
|