@brftech/filex-core 0.19.0 → 0.20.0

package/src/composables/useS3Keys.ts

@@ -0,0 +1,175 @@
+/**
+ * useS3Keys — the one client for the S3 access-key surface.
+ *
+ * It goes through `useFileApi`, the same auth plumbing the explorer uses, so
+ * the desktop app's function-token, the web app's cookie and an embedder's
+ * bearer all work here without this file knowing which is which.
+ *
+ * ⚠ Every surface mounts THIS, not a copy. The keys panel, the guide and the
+ * copy buttons exist once in `packages/core`; the web app and the desktop app
+ * render the same component. That is the standing rule ("never write
+ * surface-specific behaviour") applied to a credential surface, where a
+ * divergence would mean one surface handing out keys the other cannot revoke.
+ */
+
+import { computed, ref, shallowRef } from 'vue';
+import type { ExplorerConfig } from '../types/ExplorerConfig';
+import type { S3AccessKey, S3Connection, S3KeyCreated, S3KeyRequest } from '../types/S3Keys';
+import { connectionsBase } from './useConnections';
+import { useFileApi } from './useFileApi';
+
+export function useS3Keys(config: ExplorerConfig) {
+  const api = useFileApi(config);
+  const base = connectionsBase(config);
+  const url = (path: string) => `${base}${path}`;
+
+  const keys = shallowRef<S3AccessKey[]>([]);
+  const connection = ref<S3Connection | null>(null);
+  const loading = ref(false);
+  const loaded = ref(false);
+  const error = ref<string | null>(null);
+  /**
+   * null until the first load answers. False means the caller may not mint
+   * keys (anonymous, or a token without the right to) — the guide is still
+   * worth showing, so this is a fact rather than an error.
+   */
+  const canMint = ref<boolean | null>(null);
+
+  /** The secret, held in memory for exactly as long as the user is looking. */
+  const revealed = ref<S3KeyCreated | null>(null);
+
+  function messageOf(e: unknown): string {
+    const err = e as { message?: string; detail?: string } | null;
+    // The backend's own words beat a status line: "access keys are not
+    // available on this install" tells an operator what to fix; "503" does not.
+    if (err?.detail) {
+      try {
+        const parsed = JSON.parse(err.detail) as { error?: string };
+        if (parsed?.error) return parsed.error;
+      } catch {
+        /* not JSON — fall through */
+      }
+    }
+    return err?.message || String(e);
+  }
+
+  function statusOf(e: unknown): number | undefined {
+    return (e as { status?: number } | null)?.status;
+  }
+
+  async function load(): Promise<void> {
+    loading.value = true;
+    error.value = null;
+    try {
+      const body = await api.jsonFetch<{ keys: S3AccessKey[] } & S3Connection>(
+        url('/api/auth/s3-keys'),
+      );
+      keys.value = Array.isArray(body?.keys) ? body.keys : [];
+      connection.value = {
+        endpoint: body?.endpoint ?? '',
+        enabled: body?.enabled !== false,
+        path_style: body?.path_style !== false,
+      };
+      canMint.value = true;
+    } catch (e) {
+      keys.value = [];
+      const st = statusOf(e);
+      if (st === 401 || st === 403) {
+        canMint.value = false;
+      } else {
+        canMint.value = false;
+        error.value = messageOf(e);
+      }
+    } finally {
+      loading.value = false;
+      loaded.value = true;
+    }
+  }
+
+  /**
+   * Mint a key. The secret comes back once and is held in `revealed` until
+   * the caller dismisses it — there is no second chance, so the UI must not
+   * navigate away from it on its own.
+   */
+  async function create(req: S3KeyRequest): Promise<S3KeyCreated | null> {
+    error.value = null;
+    try {
+      const body = await api.jsonFetch<S3KeyCreated>(url('/api/auth/s3-keys'), {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(req),
+      });
+      revealed.value = body;
+      if (body?.endpoint) {
+        connection.value = {
+          endpoint: body.endpoint,
+          enabled: body.enabled !== false,
+          path_style: body.path_style !== false,
+        };
+      }
+      await load();
+      return body;
+    } catch (e) {
+      error.value = messageOf(e);
+      return null;
+    }
+  }
+
+  async function setDisabled(id: number, disabled: boolean): Promise<void> {
+    error.value = null;
+    try {
+      await api.jsonFetch(url(`/api/auth/s3-keys/${id}/state`), {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ disabled }),
+      });
+      await load();
+    } catch (e) {
+      error.value = messageOf(e);
+    }
+  }
+
+  async function remove(id: number): Promise<void> {
+    error.value = null;
+    try {
+      await api.jsonFetch(url(`/api/auth/s3-keys/${id}`), { method: 'DELETE' });
+      // A revealed secret belonging to the key just revoked must go with it.
+      if (revealed.value?.key?.id === id) revealed.value = null;
+      await load();
+    } catch (e) {
+      error.value = messageOf(e);
+    }
+  }
+
+  function dismissSecret() {
+    revealed.value = null;
+  }
+
+  /**
+   * The key a guide should be rendered with: the one just minted, else the
+   * newest usable one. A guide showing a DISABLED key's id would produce a
+   * paste that authenticates as nothing.
+   */
+  const guideKey = computed<S3AccessKey | null>(() => {
+    if (revealed.value?.key) return revealed.value.key;
+    const usable = keys.value.filter((k) => !k.disabled_at);
+    if (!usable.length) return null;
+    return usable.reduce((a, b) => (a.created_at >= b.created_at ? a : b));
+  });
+
+  return {
+    keys,
+    connection,
+    loading,
+    loaded,
+    error,
+    canMint,
+    revealed,
+    guideKey,
+    load,
+    create,
+    setDisabled,
+    remove,
+    dismissSecret,
+  };
+}

package/src/composables/useSSHKeys.ts

@@ -0,0 +1,119 @@
+/**
+ * useSSHKeys — the one client for the SSH key surface.
+ *
+ * Same shape as useS3Keys and for the same reason: the panel, the guide and
+ * the buttons exist once in `packages/core`, and the desktop app and the web
+ * app mount the same component. A credential surface with two implementations
+ * eventually hands out access one of them cannot take back.
+ *
+ * ⚠ There is no secret to reveal here. The user pastes the PUBLIC half; the
+ * private key never touches filex, which is the entire point of preferring
+ * keys over a password on a file server.
+ */
+
+import { computed, ref, shallowRef } from 'vue';
+import type { ExplorerConfig } from '../types/ExplorerConfig';
+import type { SSHConnection, SSHPublicKey } from '../types/SSHKeys';
+import { connectionsBase } from './useConnections';
+import { useFileApi } from './useFileApi';
+
+export function useSSHKeys(config: ExplorerConfig) {
+  const api = useFileApi(config);
+  const base = connectionsBase(config);
+  const url = (path: string) => `${base}${path}`;
+
+  const keys = shallowRef<SSHPublicKey[]>([]);
+  const connection = ref<SSHConnection | null>(null);
+  const loading = ref(false);
+  const loaded = ref(false);
+  const error = ref<string | null>(null);
+  const canAdd = ref<boolean | null>(null);
+
+  function messageOf(e: unknown): string {
+    const err = e as { message?: string; detail?: string } | null;
+    if (err?.detail) {
+      try {
+        const parsed = JSON.parse(err.detail) as { error?: string };
+        if (parsed?.error) return parsed.error;
+      } catch {
+        /* not JSON */
+      }
+    }
+    return err?.message || String(e);
+  }
+
+  function statusOf(e: unknown): number | undefined {
+    return (e as { status?: number } | null)?.status;
+  }
+
+  async function load(): Promise<void> {
+    loading.value = true;
+    error.value = null;
+    try {
+      const body = await api.jsonFetch<{ keys: SSHPublicKey[] } & SSHConnection>(
+        url('/api/auth/ssh-keys'),
+      );
+      keys.value = Array.isArray(body?.keys) ? body.keys : [];
+      connection.value = {
+        enabled: body?.enabled !== false,
+        host: body?.host ?? '',
+        port: body?.port ?? 2022,
+        login: body?.login ?? '',
+        ftps: body?.ftps,
+      };
+      canAdd.value = true;
+    } catch (e) {
+      keys.value = [];
+      canAdd.value = false;
+      if (statusOf(e) !== 401 && statusOf(e) !== 403) error.value = messageOf(e);
+    } finally {
+      loading.value = false;
+      loaded.value = true;
+    }
+  }
+
+  async function add(key: string, name?: string): Promise<boolean> {
+    error.value = null;
+    try {
+      await api.jsonFetch(url('/api/auth/ssh-keys'), {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ key, name }),
+      });
+      await load();
+      return true;
+    } catch (e) {
+      error.value = messageOf(e);
+      return false;
+    }
+  }
+
+  async function setDisabled(id: number, disabled: boolean): Promise<void> {
+    error.value = null;
+    try {
+      await api.jsonFetch(url(`/api/auth/ssh-keys/${id}/state`), {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ disabled }),
+      });
+      await load();
+    } catch (e) {
+      error.value = messageOf(e);
+    }
+  }
+
+  async function remove(id: number): Promise<void> {
+    error.value = null;
+    try {
+      await api.jsonFetch(url(`/api/auth/ssh-keys/${id}`), { method: 'DELETE' });
+      await load();
+    } catch (e) {
+      error.value = messageOf(e);
+    }
+  }
+
+  /** True when at least one key can actually be used to sign in. */
+  const hasUsableKey = computed(() => keys.value.some((k) => !k.disabled_at));
+
+  return { keys, connection, loading, loaded, error, canAdd, hasUsableKey, load, add, setDisabled, remove };
+}

package/src/composables/useThumbs.ts

@@ -2,7 +2,7 @@
 //
 // The backend emits `thumb_url` as a ROOT-RELATIVE path ("/api/files/thumb/{id}").
 // A plain `<img src>` only works for the native same-origin SPA: an embedded
-// webcomponent resolves it against the HOST page's origin (work.brf.sh → 404)
+// webcomponent resolves it against the HOST page's origin (work.example.com → 404)
 // and, even with the URL fixed, `<img>` cannot carry the bearer header a
 // proxied host (fishapp PWA) requires. So thumbs are fetched through the same
 // auth machinery as every API call (headers + credentials), cached as object

package/src/composables/useTokens.ts

@@ -0,0 +1,121 @@
+/**
+ * useTokens — the one client for the self-service API-token surface.
+ *
+ * It goes through `useFileApi`, the same auth plumbing the explorer uses, so
+ * the desktop app's function-token, the web app's cookie and an embedder's
+ * bearer all work here without this file knowing which is which.
+ *
+ * ⚠ `/api/tokens`, NOT `/api/admin/ai-tokens`. The admin route needs an admin;
+ * this one is open to every account and caps what it hands out to the caller's
+ * own role and grants. Pointing this at the admin route would put the panel on
+ * three surfaces and have it fail with 403 on two of them.
+ *
+ * ⚠ Every surface mounts THIS, not a copy — the standing rule applied to a
+ * credential surface, where a divergence would mean one surface minting
+ * tokens the other cannot see or revoke.
+ */
+
+import { ref, shallowRef } from 'vue';
+import type { ExplorerConfig } from '../types/ExplorerConfig';
+import type { ApiToken, ApiTokenCreated, ApiTokenRequest } from '../types/Tokens';
+import { connectionsBase } from './useConnections';
+import { useFileApi } from './useFileApi';
+
+export function useTokens(config: ExplorerConfig) {
+  const api = useFileApi(config);
+  const base = connectionsBase(config);
+  const url = (path: string) => `${base}${path}`;
+
+  const tokens = shallowRef<ApiToken[]>([]);
+  const loading = ref(false);
+  const loaded = ref(false);
+  const error = ref<string | null>(null);
+  /**
+   * null until the first load answers. False means the caller may not mint
+   * one (anonymous, or a share/proxy session) — the guide around it is still
+   * worth showing, so this is a fact rather than an error.
+   */
+  const canMint = ref<boolean | null>(null);
+
+  /** The secret, held in memory for exactly as long as the user is looking. */
+  const revealed = ref<ApiTokenCreated | null>(null);
+
+  function messageOf(e: unknown): string {
+    const err = e as { message?: string; detail?: string } | null;
+    // The backend's own words beat a status line: "scope 'admin' is not
+    // available here" tells the user what to change; "403" does not.
+    if (err?.detail) {
+      try {
+        const parsed = JSON.parse(err.detail) as { error?: string };
+        if (parsed?.error) return parsed.error;
+      } catch {
+        /* not JSON — fall through */
+      }
+    }
+    return err?.message || String(e);
+  }
+
+  function statusOf(e: unknown): number | undefined {
+    return (e as { status?: number } | null)?.status;
+  }
+
+  async function load(): Promise<void> {
+    loading.value = true;
+    error.value = null;
+    try {
+      const body = await api.jsonFetch<{ tokens: ApiToken[] }>(url('/api/tokens'));
+      tokens.value = Array.isArray(body?.tokens) ? body.tokens : [];
+      canMint.value = true;
+    } catch (e) {
+      tokens.value = [];
+      const st = statusOf(e);
+      canMint.value = false;
+      // 401/403 is "not for you", which the panel says in its own words. Any
+      // other status is a fault worth showing verbatim.
+      if (st !== 401 && st !== 403) error.value = messageOf(e);
+    } finally {
+      loading.value = false;
+      loaded.value = true;
+    }
+  }
+
+  /**
+   * Mint a token. The secret comes back once and is held in `revealed` until
+   * the caller dismisses it — there is no second chance, so the UI must not
+   * navigate away from it on its own.
+   */
+  async function create(req: ApiTokenRequest): Promise<ApiTokenCreated | null> {
+    error.value = null;
+    try {
+      const body = await api.jsonFetch<ApiTokenCreated>(url('/api/tokens'), {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(req),
+      });
+      revealed.value = body;
+      await load();
+      return body;
+    } catch (e) {
+      error.value = messageOf(e);
+      return null;
+    }
+  }
+
+  async function remove(id: number): Promise<void> {
+    error.value = null;
+    try {
+      await api.jsonFetch(url(`/api/tokens/${id}`), { method: 'DELETE' });
+      // A revealed secret belonging to the token just revoked goes with it.
+      if (revealed.value?.row?.id === id) revealed.value = null;
+      await load();
+    } catch (e) {
+      error.value = messageOf(e);
+    }
+  }
+
+  function dismiss(): void {
+    revealed.value = null;
+  }
+
+  return { tokens, loading, loaded, error, canMint, revealed, load, create, remove, dismiss };
+}