Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS
JavaScript ai-agentsdashboarddeveloper-toolsdigital-twinquantified-selfsecond-brainself-hostedtailscale
import {
buildCapabilityRows,
summarizeCapabilities,
summarizeSetupCapabilities,
} from '../lib/capabilityMap.js';
import { getAllProviders, getProviderById } from './providers.js';
import { getProviderPrerequisiteReadinessMap } from './providerPrerequisites.js';
import { getProviderReadinessMap } from './providerReadiness.js';
import { getAllProviderStatuses } from './providerStatus.js';
import { listAccounts as listCalendarAccounts } from './calendarAccounts.js';
import { listAccounts as listMessageAccounts } from './messageAccounts.js';
import { countMemories } from './memoryBackend.js';
import { getConfig as getCosConfig } from './cosState.js';
import { getVoiceConfig } from './voice/config.js';
import { getNetworkExposureSetupStatus } from '../lib/networkExposure.js';
import { getGenomeSummary } from './genome.js';
import { getSettings } from './settings.js';
import * as telegram from './telegram.js';
import * as telegramBridge from './telegramBridge.js';
import { getAppStatusSummary } from './appProcessStatus.js';
// Resolve whether a memory-embedding provider is actually reachable-by-config
// (mirrors memoryEmbeddings.initConfig) without firing the live LM Studio probe
// — the probe auto-loads a model as a side effect, which a read-only status
// page must not trigger.
async function resolveEmbeddingProviderConfigured() {
const cosConfig = await getCosConfig();
const providerId = cosConfig?.embeddingProviderId || 'lmstudio';
const provider = await getProviderById(providerId);
// Mirror memoryEmbeddings.initConfig exactly: it keys off `endpoint` alone and
// does NOT gate on `enabled`, so embeddings still generate from a disabled-but-
// endpoint'd provider. Checking `enabled` here would misreport that as "off".
return !!provider?.endpoint;
}
async function resolveTelegram() {
const settings = await getSettings();
const method = settings?.telegram?.method || 'manual';
if (method === 'mcp-bridge') {
const status = telegramBridge.getStatus();
return { method, hasToken: status.hasBotToken, hasChatId: status.hasChatId, connected: status.connected };
}
const status = telegram.getStatus();
return {
method,
hasToken: !!settings?.secrets?.telegram?.token,
hasChatId: !!settings?.telegram?.chatId,
connected: status.connected,
};
}
// GET /api/capabilities — capability map of every connected system.
export async function getCapabilitiesSnapshot() {
const unavailable = new Set();
const failed = (id, fallback) => () => {
unavailable.add(id);
return fallback;
};
const providersPromise = getAllProviders().catch(failed('providers', { providers: [] }));
const providerPrerequisiteReadinessPromise = providersPromise.then((data) => {
const providers = Array.isArray(data?.providers) ? data.providers : [];
const enabled = providers.filter((provider) => provider?.enabled !== false);
return getProviderPrerequisiteReadinessMap(providers, { candidates: enabled });
}).catch(failed('providers', null));
const providerLocalReadinessPromise = providersPromise.then((data) => {
const providers = Array.isArray(data?.providers) ? data.providers : [];
const enabled = providers.filter((provider) => provider?.enabled !== false);
return getProviderReadinessMap(enabled);
}).catch(() => null);
const [
providersData,
providerPrerequisiteReadiness,
providerLocalReadiness,
providerStatuses,
calendarAccounts,
messageAccounts,
memoryCount,
embeddingProviderConfigured,
voiceConfig,
genome,
telegramStatus,
appSummary,
network,
settings,
] = await Promise.all([
providersPromise,
providerPrerequisiteReadinessPromise,
providerLocalReadinessPromise,
Promise.resolve().then(() => getAllProviderStatuses()).catch(failed('providers', {})),
listCalendarAccounts().catch(failed('calendar', [])),
listMessageAccounts().catch(failed('messages', [])),
countMemories({ status: 'active' }).catch(failed('brain', 0)),
resolveEmbeddingProviderConfigured().catch(failed('brain', false)),
getVoiceConfig().catch(failed('voice', {})),
getGenomeSummary().catch(failed('genome', { uploaded: false })),
resolveTelegram().catch(failed('telegram', {})),
getAppStatusSummary().catch(failed('apps', { total: 0 })),
getNetworkExposureSetupStatus().catch(failed('network', {})),
getSettings(),
]);
const rows = buildCapabilityRows({
providers: providersData?.providers ?? [],
providerPrerequisiteReadiness,
providerLocalReadiness,
providerStatuses,
calendarAccounts,
messageAccounts,
memoryCount: Number(memoryCount) || 0,
embeddingProviderConfigured,
voiceConfig,
network,
genome,
telegram: telegramStatus,
appSummary,
}).map(row => unavailable.has(row.id)
? { ...row, status: 'warn', summary: 'Readiness unavailable — probe failed', setupComplete: false }
: row);
return {
timestamp: new Date().toISOString(),
summary: summarizeCapabilities(rows),
optionalSummary: summarizeCapabilities(rows.filter((row) => row.setupRequired !== true && row.id !== 'network')),
setup: summarizeSetupCapabilities(rows),
capabilities: rows,
network,
networkSetupPreference: settings.networkSetupPreference || null,
};
}