fuli-context 0.4.0 → 0.7.2

package/src/setup/setup.js

@@ -4,27 +4,41 @@ import { connectAgent, discoverAgents } from './agents.js';
 import { resolveSetupPaths } from './paths.js';
 import { ensureGraphRuntime } from './graph-runtime.js';
 import { installSessionSkill } from './session-skill.js';
+import {
+  DEFAULT_RUNTIME_SETTINGS,
+  readRuntimeSettings,
+  runtimeSettingsWithOverrides
+} from '../system/runtime-settings.js';
 
 export function planLocalSetup(options, {
   env = process.env,
   resolvePaths = resolveSetupPaths,
   discover = discoverAgents,
   inspectInstallations = inspectAgentInstallations,
+  readSettings = readRuntimeSettings,
   nodePath = process.execPath
 } = {}) {
   const paths = resolvePaths({ dataDir: options.dataDir, env });
+  const savedRuntimeSettings = paths.runtimeSettingsPath
+    ? readSettings(paths.runtimeSettingsPath)
+    : DEFAULT_RUNTIME_SETTINGS;
+  const runtimeSettings = runtimeSettingsWithOverrides(savedRuntimeSettings, {
+    consolePort: options.port
+  });
   const discovered = options.skipAgents ? [] : discover({ env });
   const agents = options.codexOnly
     ? discovered.filter(({ id }) => id === 'codex')
     : discovered;
   return {
     paths,
+    runtimeSettings,
     agents: inspectInstallations(agents, {
       nodePath,
       mcpServerPath: paths.mcpServerPath,
       runtimeConfigPath: paths.graphRuntimeConfigPath,
       sessionSkillPath: paths.sessionSkillPath,
-      projectSkillPath: paths.projectSkillPath
+      projectSkillPath: paths.projectSkillPath,
+      reviewSkillPath: paths.reviewSkillPath
     })
   };
 }
@@ -34,10 +48,16 @@ export async function applyLocalSetup(plan, options, dependencies = {}) {
   const backupConfig = dependencies.backupConfig ?? backupAgentConfig;
   const connect = dependencies.connect ?? connectAgent;
   const installSkill = dependencies.installSkill ?? installSessionSkill;
+  const runtimeSettings = plan.runtimeSettings ?? runtimeSettingsWithOverrides(
+    DEFAULT_RUNTIME_SETTINGS,
+    { consolePort: options.port }
+  );
   const runtime = await ensureRuntime({
     paths: plan.paths,
     personalSpaceName: options.personalSpaceName,
-    port: options.port,
+    port: runtimeSettings.ports.console,
+    lan: runtimeSettings.lanAccess,
+    runtimeSettings,
     personalOnly: options.personalOnly,
     noStart: options.noStart,
     env: dependencies.env ?? process.env,
@@ -64,6 +84,10 @@ export async function applyLocalSetup(plan, options, dependencies = {}) {
         installSkill({ ...agent, skillPath: agent.projectSkillPath }, {
           sourcePath: plan.paths.projectSkillPath,
           backupDir: plan.paths.backupDir
+        }),
+        installSkill({ ...agent, skillPath: agent.reviewSkillPath }, {
+          sourcePath: plan.paths.reviewSkillPath,
+          backupDir: plan.paths.backupDir
         })
       ];
       agents.push({ ...connected, backupPath, skills });

package/src/setup/uninstall.js

@@ -20,7 +20,8 @@ export function planLocalUninstall(options, {
     (agent.globalInstructionsOverridePath &&
       fileExists(agent.globalInstructionsOverridePath)) ||
     (agent.skillPath && fileExists(agent.skillPath)) ||
-    (agent.projectSkillPath && fileExists(agent.projectSkillPath))
+    (agent.projectSkillPath && fileExists(agent.projectSkillPath)) ||
+    (agent.reviewSkillPath && fileExists(agent.reviewSkillPath))
   ));
   return { paths, agents };
 }
@@ -60,7 +61,8 @@ export async function applyLocalUninstall(plan, dependencies = {}) {
 
     for (const [skillPath, sourcePath] of [
       [agent.skillPath, plan.paths.sessionSkillPath],
-      [agent.projectSkillPath, plan.paths.projectSkillPath]
+      [agent.projectSkillPath, plan.paths.projectSkillPath],
+      [agent.reviewSkillPath, plan.paths.reviewSkillPath]
     ]) {
       try {
         skills.push(removeSkill({ ...agent, skillPath }, { sourcePath }));

package/src/system/resource-monitor.js

@@ -0,0 +1,317 @@
+import { execFile } from 'node:child_process';
+import { readdir, lstat, statfs } from 'node:fs/promises';
+import { freemem, totalmem } from 'node:os';
+import { join } from 'node:path';
+
+import { inspectContainerRuntime } from '../setup/container-runtime.js';
+
+const COMPOSE_PROJECT = 'fuli-graphiti';
+const DISK_CACHE_MS = 60_000;
+const PROCESS_TIMEOUT_MS = 8_000;
+const CONTAINER_LABELS = Object.freeze({
+  'personal-provider': 'Personal Provider',
+  'personal-neo4j': 'Personal Neo4j',
+  'workspace-provider': 'Workspace Provider',
+  'workspace-neo4j': 'Workspace Neo4j'
+});
+
+export function createResourceMonitor({
+  dataDir,
+  packageRoot,
+  now = () => new Date(),
+  processMemory = () => process.memoryUsage(),
+  hostMemory = () => ({ totalBytes: totalmem(), freeBytes: freemem() }),
+  containerRuntime = null,
+  inspectRuntime = inspectContainerRuntime,
+  run = runCommand,
+  directorySize = allocatedDirectorySize,
+  filesystemStats = hostFilesystemStats
+}) {
+  let resolvedRuntime = containerRuntime;
+  let diskCache = null;
+
+  async function sample() {
+    const sampledAt = now().toISOString();
+    const runtime = resolvedRuntime ??= inspectRuntime();
+    const containers = await containerMemory(runtime, run);
+    const localMemory = processMemory();
+    const host = hostMemory();
+    const disk = await diskSample({
+      runtime,
+      run,
+      dataDir,
+      packageRoot,
+      directorySize,
+      filesystemStats,
+      now,
+      cache: diskCache
+    });
+    diskCache = disk.cache;
+
+    const memoryComponents = [{
+      id: 'console',
+      label: 'Management service',
+      kind: 'process',
+      status: 'ready',
+      bytes: localMemory.rss
+    }, ...containers.components];
+    return {
+      sampledAt,
+      status: containers.complete && disk.value.complete ? 'ready' : 'partial',
+      memory: {
+        usedBytes: sumBytes(memoryComponents),
+        hostTotalBytes: host.totalBytes,
+        hostFreeBytes: host.freeBytes,
+        complete: containers.complete,
+        components: memoryComponents
+      },
+      disk: disk.value,
+      exclusions: ['browser-tab-memory', 'shared-container-vm-overhead']
+    };
+  }
+
+  return { sample };
+}
+
+async function containerMemory(runtime, run) {
+  if (runtime?.status !== 'ready') return { complete: false, components: [] };
+  try {
+    const containers = await listManagedContainers(runtime, run);
+    if (containers.length === 0) return { complete: false, components: [] };
+    const output = await runDocker(runtime, [
+      'stats', '--no-stream', '--format', '{{.ID}}\t{{.MemUsage}}',
+      ...containers.map(({ id }) => id)
+    ], run);
+    const usage = new Map(parseLines(output).map((line) => {
+      const [id, value] = line.split('\t');
+      return [id, parseDockerBytes(value.split('/', 1)[0].trim())];
+    }));
+    return {
+      complete: containers.every(({ id }) => usage.has(id)),
+      components: containers.flatMap(({ id, service }) => usage.has(id) ? [{
+        id: service,
+        label: CONTAINER_LABELS[service] ?? service,
+        kind: 'container',
+        status: 'ready',
+        bytes: usage.get(id)
+      }] : [])
+    };
+  } catch {
+    return { complete: false, components: [] };
+  }
+}
+
+async function diskSample(input) {
+  const timestamp = input.now().getTime();
+  if (input.cache && timestamp - input.cache.timestamp < DISK_CACHE_MS) {
+    return { value: input.cache.value, cache: input.cache };
+  }
+  const [applicationBytes, localDataBytes, filesystem, docker] = await Promise.all([
+    input.directorySize(input.packageRoot),
+    input.directorySize(input.dataDir),
+    input.filesystemStats(input.dataDir),
+    dockerDisk(input.runtime, input.run)
+  ]);
+  const components = [
+    diskComponent('application', 'Application files', applicationBytes),
+    diskComponent('localData', 'Local runtime data', localDataBytes),
+    ...docker.components
+  ].filter(Boolean);
+  const value = {
+    usedBytes: sumBytes(components),
+    hostTotalBytes: filesystem.totalBytes,
+    hostFreeBytes: filesystem.freeBytes,
+    complete: docker.complete && Number.isFinite(filesystem.totalBytes) &&
+      Number.isFinite(filesystem.freeBytes),
+    measuredAt: input.now().toISOString(),
+    temporaryBytes: docker.temporaryBytes,
+    components
+  };
+  return { value, cache: { timestamp, value } };
+}
+
+async function dockerDisk(runtime, run) {
+  if (runtime?.status !== 'ready') {
+    return { complete: false, components: [], temporaryBytes: null };
+  }
+  try {
+    const containers = await listManagedContainers(runtime, run);
+    if (containers.length === 0) {
+      return { complete: false, components: [], temporaryBytes: null };
+    }
+    const inspectOutput = await runDocker(runtime, [
+      'inspect', '--size', '--format', '{{.Id}}\t{{.SizeRw}}\t{{.Image}}',
+      ...containers.map(({ id }) => id)
+    ], run);
+    const inspected = parseLines(inspectOutput).map((line) => {
+      const [id, writable, imageId] = line.split('\t');
+      return { id, writableBytes: nonNegativeNumber(writable), imageId };
+    });
+    if (
+      inspected.length !== containers.length ||
+      inspected.some(({ id, imageId }) => !id || !imageId)
+    ) {
+      throw new TypeError('Docker container disk metrics are incomplete');
+    }
+    const imageIds = [...new Set(inspected.map(({ imageId }) => imageId).filter(Boolean))];
+    const imageOutput = imageIds.length === 0 ? '' : await runDocker(runtime, [
+      'image', 'inspect', '--format', '{{.Id}}\t{{.Size}}', ...imageIds
+    ], run);
+    const imageSizes = new Map(parseLines(imageOutput).map((line) => {
+      const [id, value] = line.split('\t');
+      return [id, nonNegativeNumber(value)];
+    }));
+    if (imageIds.some((id) => !imageSizes.has(id))) {
+      throw new TypeError('Docker image disk metrics are incomplete');
+    }
+    const imageBytes = imageIds.reduce((total, id) => total + imageSizes.get(id), 0);
+    const writableBytes = inspected.reduce(
+      (total, item) => total + item.writableBytes,
+      0
+    );
+    const volumeUsage = await managedVolumeUsage(runtime, containers, run);
+    return {
+      complete: true,
+      temporaryBytes: volumeUsage.temporaryBytes,
+      components: [
+        diskComponent('containerImages', 'Container images', imageBytes),
+        diskComponent('containerWritable', 'Container writable data', writableBytes),
+        diskComponent('neo4jData', 'Neo4j data', volumeUsage.dataBytes),
+        diskComponent('neo4jLogs', 'Neo4j logs', volumeUsage.logBytes)
+      ].filter(Boolean)
+    };
+  } catch {
+    return { complete: false, components: [], temporaryBytes: null };
+  }
+}
+
+async function managedVolumeUsage(runtime, containers, run) {
+  let dataBytes = 0;
+  let logBytes = 0;
+  let temporaryBytes = 0;
+  const neo4jContainers = containers.filter(({ service }) => service.endsWith('-neo4j'));
+  if (neo4jContainers.length === 0) {
+    throw new TypeError('No managed Neo4j container was available');
+  }
+  for (const container of neo4jContainers) {
+    const output = await runDocker(runtime, [
+      'exec', container.id, 'du', '-sk', '/data', '/logs', '/tmp'
+    ], run);
+    const usage = new Map();
+    for (const line of parseLines(output)) {
+      const [kib, path] = line.trim().split(/\s+/, 2);
+      if (['/data', '/logs', '/tmp'].includes(path)) {
+        usage.set(path, nonNegativeNumber(kib) * 1024);
+      }
+    }
+    if (['/data', '/logs', '/tmp'].some((path) => !usage.has(path))) {
+      throw new TypeError('Neo4j volume disk metrics are incomplete');
+    }
+    dataBytes += usage.get('/data');
+    logBytes += usage.get('/logs');
+    temporaryBytes += usage.get('/tmp');
+  }
+  return { dataBytes, logBytes, temporaryBytes };
+}
+
+async function listManagedContainers(runtime, run) {
+  const output = await runDocker(runtime, [
+    'ps', '--filter', `label=com.docker.compose.project=${COMPOSE_PROJECT}`,
+    '--format', '{{.ID}}\t{{.Label "com.docker.compose.service"}}'
+  ], run);
+  return parseLines(output).flatMap((line) => {
+    const [id, service] = line.split('\t');
+    return id && service && Object.hasOwn(CONTAINER_LABELS, service)
+      ? [{ id, service }]
+      : [];
+  });
+}
+
+function runDocker(runtime, args, run) {
+  return run(runtime.dockerCommand, args, { env: runtime.dockerEnvironment });
+}
+
+export async function allocatedDirectorySize(root) {
+  if (typeof root !== 'string' || !root) return 0;
+  let total = 0;
+  let entries;
+  try {
+    entries = await readdir(root, { withFileTypes: true });
+  } catch {
+    return 0;
+  }
+  for (const entry of entries) {
+    const path = join(root, entry.name);
+    if (entry.isSymbolicLink()) continue;
+    if (entry.isDirectory()) {
+      total += await allocatedDirectorySize(path);
+      continue;
+    }
+    try {
+      const stats = await lstat(path);
+      total += Number.isFinite(stats.blocks) ? stats.blocks * 512 : stats.size;
+    } catch {
+      // Files may be replaced while the snapshot is being collected.
+    }
+  }
+  return total;
+}
+
+async function hostFilesystemStats(path) {
+  try {
+    const stats = await statfs(path, { bigint: true });
+    return {
+      totalBytes: Number(stats.blocks * stats.bsize),
+      freeBytes: Number(stats.bavail * stats.bsize)
+    };
+  } catch {
+    return { totalBytes: null, freeBytes: null };
+  }
+}
+
+function runCommand(command, args, { env } = {}) {
+  return new Promise((resolve, reject) => {
+    execFile(command, args, {
+      encoding: 'utf8',
+      env,
+      timeout: PROCESS_TIMEOUT_MS,
+      windowsHide: true,
+      maxBuffer: 2 * 1024 * 1024
+    }, (error, stdout) => {
+      if (error) reject(error);
+      else resolve(stdout);
+    });
+  });
+}
+
+export function parseDockerBytes(value) {
+  const match = /^([0-9]+(?:\.[0-9]+)?)\s*([kmgtp]?i?b)$/i.exec(String(value).trim());
+  if (!match) throw new TypeError(`Unsupported Docker byte value: ${value}`);
+  const unit = match[2].toLowerCase();
+  const powers = { b: 0, kb: 1, kib: 1, mb: 2, mib: 2, gb: 3, gib: 3, tb: 4, tib: 4,
+    pb: 5, pib: 5 };
+  const base = unit.includes('i') ? 1024 : 1000;
+  return Math.round(Number(match[1]) * (base ** powers[unit]));
+}
+
+function diskComponent(id, label, bytes) {
+  return Number.isFinite(bytes) && bytes >= 0
+    ? { id, label, status: 'ready', bytes }
+    : null;
+}
+
+function sumBytes(components) {
+  return components.reduce((total, component) => total + component.bytes, 0);
+}
+
+function nonNegativeNumber(value) {
+  const number = Number(value);
+  if (!Number.isFinite(number) || number < 0) {
+    throw new TypeError(`Expected a non-negative number, received: ${value}`);
+  }
+  return number;
+}
+
+function parseLines(value) {
+  return String(value).split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+}

package/src/system/runtime-settings.js

@@ -0,0 +1,131 @@
+import { chmodSync } from 'node:fs';
+
+import { isFetchBlockedPort } from '../server/blocked-ports.js';
+import { readJsonFile, writeJsonFileAtomic } from '../storage/json-file.js';
+
+export const RUNTIME_SETTINGS_VERSION = 1;
+export const RESOURCE_REFRESH_OPTIONS = Object.freeze([5, 10, 30, 60]);
+export const PORT_KEYS = Object.freeze([
+  'console',
+  'personalProvider',
+  'personalNeo4jHttp',
+  'personalNeo4jBolt',
+  'workspaceProvider',
+  'workspaceNeo4jHttp',
+  'workspaceNeo4jBolt'
+]);
+
+export const DEFAULT_RUNTIME_SETTINGS = deepFreeze({
+  version: RUNTIME_SETTINGS_VERSION,
+  ports: {
+    console: 2727,
+    personalProvider: 8787,
+    personalNeo4jHttp: 8060,
+    personalNeo4jBolt: 7687,
+    workspaceProvider: 8788,
+    workspaceNeo4jHttp: 7475,
+    workspaceNeo4jBolt: 7688
+  },
+  lanAccess: false,
+  resourceRefreshSeconds: 5
+});
+
+export function readRuntimeSettings(path, {
+  fallback = DEFAULT_RUNTIME_SETTINGS,
+  read = readJsonFile
+} = {}) {
+  const stored = read(path, null);
+  return normalizeRuntimeSettings(stored ?? fallback, { base: fallback });
+}
+
+export function writeRuntimeSettings(path, input, {
+  write = writeJsonFileAtomic,
+  secure = (filePath) => chmodSync(filePath, 0o600)
+} = {}) {
+  const settings = normalizeRuntimeSettings(input, { strict: true });
+  write(path, settings);
+  secure(path);
+  return settings;
+}
+
+export function normalizeRuntimeSettings(input, {
+  base = DEFAULT_RUNTIME_SETTINGS,
+  strict = false
+} = {}) {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) {
+    throw new TypeError('Runtime settings must be an object');
+  }
+  if (input.version !== undefined && input.version !== RUNTIME_SETTINGS_VERSION) {
+    throw new TypeError('Unsupported runtime settings version');
+  }
+  const portsInput = input.ports;
+  if (strict && (!portsInput || typeof portsInput !== 'object' || Array.isArray(portsInput))) {
+    throw new TypeError('ports is required');
+  }
+  const ports = {};
+  for (const key of PORT_KEYS) {
+    const value = portsInput?.[key] ?? base.ports[key];
+    ports[key] = validPort(value, key);
+  }
+  const uniquePorts = new Set(Object.values(ports));
+  if (uniquePorts.size !== PORT_KEYS.length) {
+    throw new TypeError('Every FULI service must use a different port');
+  }
+  if (isFetchBlockedPort(ports.console)) {
+    throw new TypeError('The management UI port is blocked by web browsers');
+  }
+
+  const lanAccess = input.lanAccess ?? base.lanAccess;
+  if (typeof lanAccess !== 'boolean') throw new TypeError('lanAccess must be a boolean');
+  const resourceRefreshSeconds = input.resourceRefreshSeconds ?? base.resourceRefreshSeconds;
+  if (!RESOURCE_REFRESH_OPTIONS.includes(resourceRefreshSeconds)) {
+    throw new TypeError('resourceRefreshSeconds must be 5, 10, 30, or 60');
+  }
+  return {
+    version: RUNTIME_SETTINGS_VERSION,
+    ports,
+    lanAccess,
+    resourceRefreshSeconds
+  };
+}
+
+export function runtimeSettingsWithOverrides(settings, {
+  consolePort = null,
+  lanAccess = null
+} = {}) {
+  return normalizeRuntimeSettings({
+    ...settings,
+    ports: {
+      ...settings.ports,
+      ...(consolePort === null ? {} : { console: consolePort })
+    },
+    ...(lanAccess === null ? {} : { lanAccess })
+  });
+}
+
+export function managedProviderUrls(settings) {
+  return {
+    personal: `http://127.0.0.1:${settings.ports.personalProvider}`,
+    workspace: `http://127.0.0.1:${settings.ports.workspaceProvider}`
+  };
+}
+
+export function runtimeSettingsEqual(left, right) {
+  return JSON.stringify(normalizeRuntimeSettings(left)) ===
+    JSON.stringify(normalizeRuntimeSettings(right));
+}
+
+function validPort(value, key) {
+  if (typeof value !== 'number' || !Number.isInteger(value) || value < 1 || value > 65535) {
+    throw new TypeError(`${key} must be an integer between 1 and 65535`);
+  }
+  return value;
+}
+
+function deepFreeze(value) {
+  Object.freeze(value);
+  for (const child of Object.values(value)) {
+    if (child && typeof child === 'object' && !Object.isFrozen(child)) deepFreeze(child);
+  }
+  return value;
+}

package/src/system/system-service.js

@@ -0,0 +1,119 @@
+import { readJsonFile } from '../storage/json-file.js';
+import {
+  DEFAULT_RUNTIME_SETTINGS,
+  normalizeRuntimeSettings,
+  readRuntimeSettings,
+  runtimeSettingsEqual,
+  writeRuntimeSettings
+} from './runtime-settings.js';
+import { createResourceMonitor } from './resource-monitor.js';
+
+export function createSystemService({
+  paths,
+  packageRoot,
+  activePort,
+  activeLan,
+  readJson = readJsonFile,
+  readSettings = readRuntimeSettings,
+  writeSettings = writeRuntimeSettings,
+  resourceMonitor = createResourceMonitor({
+    dataDir: paths.dataDir,
+    packageRoot
+  })
+}) {
+  function activeSettings() {
+    const state = readJson(paths.graphRuntimeStatePath, null);
+    const graphConfig = readJson(paths.graphRuntimeConfigPath, null);
+    return settingsFromActiveRuntime({
+      state,
+      graphConfig,
+      activePort,
+      activeLan
+    });
+  }
+
+  function getSettings() {
+    const active = activeSettings();
+    const configured = readSettings(paths.runtimeSettingsPath, { fallback: active });
+    return settingsResult(configured, active);
+  }
+
+  function updateSettings(input) {
+    const configured = writeSettings(paths.runtimeSettingsPath, input);
+    return settingsResult(configured, activeSettings());
+  }
+
+  return {
+    getSettings,
+    updateSettings,
+    resources: () => resourceMonitor.sample()
+  };
+}
+
+export function settingsFromActiveRuntime({
+  state,
+  graphConfig,
+  activePort,
+  activeLan
+}) {
+  let settings = DEFAULT_RUNTIME_SETTINGS;
+  if (state?.runtimeSettings) {
+    try {
+      settings = normalizeRuntimeSettings(state.runtimeSettings);
+    } catch {
+      settings = DEFAULT_RUNTIME_SETTINGS;
+    }
+  }
+  const ports = { ...settings.ports };
+  const consolePort = integerPort(state?.port) ?? integerPort(activePort);
+  if (consolePort !== null) ports.console = consolePort;
+  const personalProvider = urlPort(graphConfig?.personal?.providerUrl);
+  if (personalProvider !== null) ports.personalProvider = personalProvider;
+  const managedWorkspace = (graphConfig?.workspaces ?? []).find((workspace) =>
+    workspace?.managedDevelopment === true || isLoopbackProvider(workspace?.providerUrl)
+  );
+  const workspaceProvider = urlPort(managedWorkspace?.providerUrl);
+  if (workspaceProvider !== null) ports.workspaceProvider = workspaceProvider;
+  return normalizeRuntimeSettings({
+    ...settings,
+    ports,
+    lanAccess: state?.lan === true || (state == null && activeLan === true)
+  });
+}
+
+function settingsResult(configured, active) {
+  return {
+    configured,
+    active,
+    restartRequired: !runtimeSettingsEqual(
+      { ...configured, resourceRefreshSeconds: active.resourceRefreshSeconds },
+      active
+    )
+  };
+}
+
+function integerPort(value) {
+  const port = Number(value);
+  return Number.isInteger(port) && port >= 1 && port <= 65535 ? port : null;
+}
+
+function urlPort(value) {
+  if (typeof value !== 'string') return null;
+  try {
+    const url = new URL(value);
+    return integerPort(url.port || (url.protocol === 'https:' ? 443 : 80));
+  } catch {
+    return null;
+  }
+}
+
+function isLoopbackProvider(value) {
+  if (typeof value !== 'string') return false;
+  try {
+    const url = new URL(value);
+    return url.protocol === 'http:' &&
+      ['127.0.0.1', 'localhost', '::1', '[::1]'].includes(url.hostname);
+  } catch {
+    return false;
+  }
+}

package/dist/web/assets/ConnectionsPage-CCKWm-6p.js

@@ -1 +0,0 @@
-import{C as e,D as t,E as n,F as r,J as i,K as a,N as o,U as s,a as c,b as l,d as u,n as d,t as f,v as p,w as m,x as h,y as g}from"./console-B_Ena2DS.js";import{i as _,r as v,t as y}from"./identity-CjBwYSMX.js";var b={class:`view connections-view`},x={class:`connection-intro`},S=[`aria-label`],C=[`data-status`],w={class:`service-state`},T=[`data-status`],E={class:`service-state`},D={key:0,class:`connection-subscriptions`},O={class:`section-title`},k={class:`subscription-list`},A=[`onClick`],j={key:0,class:`empty-state`},M={type:`submit`},N=t({__name:`ConnectionsPage`,setup(t){let N=f(),P=s(``),F=l(()=>N.state?.providers?.personal?.status===`ready`),I=l(()=>N.state?.providers?.workspaces??[]),L=l(()=>I.value.filter(({status:e})=>e===`ready`).length),R=l(()=>N.state?.subscriptions??[]),z=l(()=>new Set(R.value.map(({provider_url:e,project_id:t})=>`${e}::${t}`))),B=l(()=>(N.state?.projects??[]).filter(e=>!z.value.has(H(e)))),V=l(()=>B.value.map(e=>({value:H(e),label:e.name,meta:`#${y(e.id,26)}`,search:v(e.id)})));function H(e){return`${e.providerUrl}::${e.id}`}async function U(){let e=B.value.find(e=>H(e)===P.value);if(e)try{await c(`/api/subscriptions`,{personalSpaceId:N.activePersonalSpace?.id,projectId:e.id,providerUrl:e.providerUrl,projectName:e.name}),P.value=``,N.notify(u(`pages.connections.subscribed`,{name:e.name})),await N.refresh()}catch(e){N.reportError(e)}}async function W(e){try{let t=new URLSearchParams({personalSpaceId:N.activePersonalSpace?.id??``,providerUrl:e.provider_url});await d(`/api/subscriptions/${encodeURIComponent(e.project_id)}?${t}`),N.notify(u(`pages.connections.unsubscribed`,{name:e.project_name??e.project_id})),await N.refresh()}catch(e){N.reportError(e)}}return(t,s)=>(o(),m(`section`,b,[h(`div`,x,[h(`h3`,null,i(a(u)(`pages.connections.title`)),1),h(`p`,null,i(a(u)(`pages.connections.intro`)),1)]),h(`div`,{class:`service-connection-grid`,"aria-label":a(u)(`pages.connections.statusAria`)},[h(`article`,{class:`service-connection-card`,"data-status":F.value?`ready`:`error`},[h(`header`,null,[s[2]||=h(`span`,{class:`service-connection-icon local`,"aria-hidden":`true`},[h(`span`,{class:`nav-icon nav-icon-personal-project`})],-1),h(`div`,null,[s[1]||=h(`p`,null,`LOCAL KNOWLEDGE`,-1),h(`h3`,null,i(a(u)(`pages.connections.localGraphiti`)),1)]),h(`span`,w,i(F.value?a(u)(`common.status.connected`):a(u)(`common.status.connectionError`)),1)]),h(`p`,null,i(F.value?a(u)(`pages.connections.localReadyCopy`):a(u)(`pages.connections.localErrorCopy`)),1),h(`dl`,null,[h(`div`,null,[h(`dt`,null,i(a(u)(`pages.connections.storage`)),1),s[3]||=h(`dd`,null,`Neo4j`,-1)]),h(`div`,null,[h(`dt`,null,i(a(u)(`pages.connections.purpose`)),1),h(`dd`,null,i(a(u)(`pages.connections.localPurpose`)),1)])])],8,C),h(`article`,{class:`service-connection-card`,"data-status":a(N).publicRuntimeStatus},[h(`header`,null,[s[5]||=h(`span`,{class:`service-connection-icon public`,"aria-hidden":`true`},[h(`span`,{class:`nav-icon nav-icon-public-project`})],-1),h(`div`,null,[s[4]||=h(`p`,null,`PUBLIC PROVIDER`,-1),h(`h3`,null,i(a(u)(`pages.connections.publicService`)),1)]),h(`span`,E,i(a(N).publicRuntimeStatus===`ready`?a(u)(`common.status.connected`):a(N).publicRuntimeStatus===`error`?a(u)(`common.status.connectionError`):a(u)(`common.status.notConnected`)),1)]),h(`p`,null,i(a(N).publicRuntimeStatus===`ready`?a(u)(`pages.connections.publicReadyCopy`):a(N).publicRuntimeStatus===`error`?a(u)(`pages.connections.publicErrorCopy`):a(u)(`pages.connections.publicOfflineCopy`)),1),h(`dl`,null,[h(`div`,null,[h(`dt`,null,i(a(u)(`pages.connections.currentStatus`)),1),h(`dd`,null,i(a(N).publicRuntimeStatus===`ready`?a(u)(`pages.connections.sharedServicesReady`,{count:L.value||I.value.length}):a(u)(`pages.connections.notAvailable`)),1)]),h(`div`,null,[h(`dt`,null,i(a(u)(`pages.connections.purpose`)),1),h(`dd`,null,i(a(u)(`pages.connections.publicPurpose`)),1)])])],8,T)],8,S),a(N).state?.capabilities?.subscribeProject?(o(),m(`section`,D,[h(`div`,O,[h(`h3`,null,i(a(u)(`pages.connections.subscriptionsTitle`)),1),h(`p`,null,i(a(u)(`pages.connections.subscriptionsCopy`)),1)]),h(`div`,k,[(o(!0),m(g,null,r(R.value,e=>(o(),m(`div`,{key:`${e.provider_url}:${e.project_id}`,class:`subscription-row`},[s[6]||=h(`span`,null,`↗`,-1),h(`div`,null,[h(`strong`,null,i(e.project_name??e.project_id),1),h(`span`,null,i(a(u)(`pages.connections.sharedProject`)),1)]),h(`button`,{class:`secondary-action subscription-action`,type:`button`,onClick:t=>W(e)},i(a(u)(`pages.connections.unsubscribe`)),9,A)]))),128)),R.value.length?e(``,!0):(o(),m(`div`,j,i(a(u)(`pages.connections.noSubscriptions`)),1))]),h(`form`,{class:`subscription-form`,onSubmit:p(U,[`prevent`])},[n(_,{modelValue:P.value,"onUpdate:modelValue":s[0]||=e=>P.value=e,options:V.value,label:a(u)(`pages.connections.sharedProjectLabel`),placeholder:a(u)(`pages.connections.choosePublicProject`),searchable:``,required:``},null,8,[`modelValue`,`options`,`label`,`placeholder`]),h(`button`,M,i(a(u)(`pages.connections.subscribe`)),1)],32)])):e(``,!0)]))}});export{N as default};