@dxos/shell 0.6.13-main.548ca8d → 0.6.13-main.ed424a1

package/src/panels/IdentityPanel/useEdgeAgentsHandlers.ts

@@ -0,0 +1,96 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { useEffect, useState } from 'react';
+
+import { type CancellableInvitation } from '@dxos/client-protocol';
+import { invariant } from '@dxos/invariant';
+import { QueryAgentStatusResponse } from '@dxos/protocols/proto/dxos/client/services';
+import { useClient } from '@dxos/react-client';
+import { type Identity } from '@dxos/react-client/halo';
+
+import { type AgentFormProps } from '../../components';
+
+export const useEdgeAgentHandlers = ({
+  identity,
+}: {
+  invitations: CancellableInvitation[];
+  identity: Identity | null;
+}): AgentFormProps => {
+  const [validationMessage, setValidationMessage] = useState('');
+  const [lastReceivedStatus, setLastReceivedStatus] = useState<QueryAgentStatusResponse.AgentStatus>(
+    QueryAgentStatusResponse.AgentStatus.UNKNOWN,
+  );
+  const [agentStatus, setAgentStatus] = useState<AgentFormProps['agentStatus']>('getting');
+  const client = useClient();
+  const agentHostingEnabled = Boolean(client.config.values.runtime?.client?.edgeFeatures?.agents);
+
+  const handleStatus = (status: QueryAgentStatusResponse.AgentStatus) => {
+    switch (status) {
+      case QueryAgentStatusResponse.AgentStatus.ACTIVE:
+      case QueryAgentStatusResponse.AgentStatus.INACTIVE:
+        setAgentStatus('created');
+        break;
+      case QueryAgentStatusResponse.AgentStatus.NOT_FOUND:
+        setAgentStatus('creatable');
+        break;
+      case QueryAgentStatusResponse.AgentStatus.UNKNOWN:
+        setAgentStatus('getting');
+        break;
+    }
+  };
+
+  useEffect(() => {
+    const stream = client.services.services.EdgeAgentService?.queryAgentStatus();
+    stream?.subscribe(({ status }) => {
+      setLastReceivedStatus(status);
+      handleStatus(status);
+    });
+    return () => {
+      void stream?.close().catch(() => {});
+    };
+  }, []);
+
+  const onAgentCreate = async () => {
+    invariant(identity, 'Identity not found');
+    const service = client.services.services.EdgeAgentService;
+    if (!service) {
+      setAgentStatus('error');
+      setValidationMessage('Agent service not initialized.');
+      return;
+    }
+    if (!agentHostingEnabled) {
+      setAgentStatus('error');
+      setValidationMessage('Edge agents are disabled in config.');
+      return;
+    }
+    setAgentStatus('creating');
+    setValidationMessage('');
+    try {
+      await service.createAgent();
+      setAgentStatus('created');
+    } catch (err: any) {
+      setAgentStatus('error');
+      setValidationMessage(`Error creating an agent: ${err.message}`);
+    }
+  };
+
+  const onAgentDestroy = async () => {
+    setValidationMessage('Agents are non-destructible.');
+  };
+
+  const onAgentRefresh = async () => {
+    setValidationMessage('');
+    handleStatus(lastReceivedStatus);
+  };
+
+  return {
+    onAgentCreate,
+    onAgentDestroy,
+    onAgentRefresh,
+    validationMessage,
+    agentStatus,
+    agentHostingEnabled,
+  };
+};

package/src/panels/IdentityPanel/useKubeAgentHandlers.ts

@@ -0,0 +1,128 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { useCallback, useEffect, useState } from 'react';
+
+import { type CancellableInvitation } from '@dxos/client-protocol';
+import { invariant } from '@dxos/invariant';
+import { log } from '@dxos/log';
+import { useClient, useAgentHostingClient } from '@dxos/react-client';
+import { type Identity } from '@dxos/react-client/halo';
+import { Invitation, InvitationEncoder } from '@dxos/react-client/invitations';
+
+import { type AgentFormProps } from '../../components';
+
+export const useKubeAgentHandlers = ({
+  invitations,
+  identity,
+}: {
+  invitations: CancellableInvitation[];
+  identity: Identity | null;
+}): AgentFormProps => {
+  const [validationMessage, setValidationMessage] = useState('');
+  const [agentStatus, setAgentStatus] = useState<AgentFormProps['agentStatus']>('getting');
+  const agentHostingProviderClient = useAgentHostingClient();
+  const client = useClient();
+
+  const updateAgentStatus = async () => {
+    // TODO(nf): if agent exists, subscribe to updates instead of oneshot status
+    if (agentHostingProviderClient) {
+      setAgentStatus('getting');
+      try {
+        const agentId = await agentHostingProviderClient?.getAgent(identity?.identityKey.truncate() ?? 'never');
+        if (agentId) {
+          setAgentStatus('created');
+        } else {
+          setAgentStatus('creatable');
+        }
+      } catch (err: any) {
+        setAgentStatus('error');
+        setValidationMessage(`Couldn’t check agent status: ${err.message}`);
+      }
+    } else {
+      setAgentStatus('error');
+      setValidationMessage('No agent provider configured.');
+    }
+  };
+
+  const createAgent = async (invitationCode: string) => {
+    invariant(identity, 'Identity not found');
+    if (agentHostingProviderClient) {
+      setAgentStatus('creating');
+      setValidationMessage('');
+      try {
+        const agentId = await agentHostingProviderClient?.createAgent(invitationCode, identity.identityKey.truncate());
+        if (agentId) {
+          setAgentStatus('created');
+        } else {
+          setAgentStatus('creatable');
+          setValidationMessage('Error creating agent.');
+        }
+      } catch (err: any) {
+        setValidationMessage(`Error creating agent: ${err.message}`);
+        return updateAgentStatus();
+      }
+    } else {
+      setAgentStatus('error');
+      setValidationMessage('No agent provider configured.');
+    }
+  };
+
+  const destroyAgent = async () => {
+    invariant(identity, 'Identity not found');
+    if (agentHostingProviderClient) {
+      setAgentStatus('destroying');
+      setValidationMessage('');
+      try {
+        await agentHostingProviderClient?.destroyAgent(identity.identityKey.truncate());
+        setAgentStatus('creatable');
+      } catch (err: any) {
+        setValidationMessage(`Error destroying agent: ${err.message}`);
+        return updateAgentStatus();
+      }
+    } else {
+      setAgentStatus('error');
+      setValidationMessage('No agent provider configured.');
+    }
+  };
+
+  useEffect(() => {
+    void updateAgentStatus();
+  }, []);
+
+  const handleAgentCreate = useCallback(async (invitation: Invitation) => {
+    const invitationCode = InvitationEncoder.encode(invitation);
+    if (invitation.state === Invitation.State.CONNECTING) {
+      log.info(JSON.stringify({ invitationCode, authCode: invitation.authCode }));
+      return createAgent(invitationCode);
+    }
+  }, []);
+
+  const onAgentCreate = async () => {
+    invitations.forEach((invitation) => invitation.cancel());
+
+    // TODO(nf): do this work in the hosting provider client?
+    const invitation = client.halo.share({
+      type: Invitation.Type.INTERACTIVE,
+      authMethod: Invitation.AuthMethod.NONE,
+      multiUse: true,
+    });
+
+    invitation.subscribe(handleAgentCreate);
+  };
+
+  const onAgentRefresh = async () => {
+    setValidationMessage('');
+    await updateAgentStatus();
+  };
+
+  return {
+    onAgentCreate,
+    onAgentDestroy: destroyAgent,
+    onAgentRefresh,
+    validationMessage,
+    agentStatus,
+    agentHostingEnabled: !!agentHostingProviderClient,
+  };
+};