@enactprotocol/api 2.0.0

package/src/search.ts

@@ -0,0 +1,147 @@
+/**
+ * Tool search functionality
+ * Implements semantic search via registry API
+ */
+
+import type { EnactApiClient } from "./client";
+import type { ToolSearchResult } from "./types";
+
+/**
+ * Search options
+ */
+export interface SearchOptions {
+  /** Search query (semantic) */
+  query: string;
+  /** Filter by tags (comma-separated or array) */
+  tags?: string | string[] | undefined;
+  /** Maximum results (default: 20, max: 100) */
+  limit?: number | undefined;
+  /** Pagination offset */
+  offset?: number | undefined;
+}
+
+/**
+ * Single search result with parsed data (v2)
+ */
+export interface SearchResult {
+  /** Tool name */
+  name: string;
+  /** Tool description */
+  description: string;
+  /** Tool tags */
+  tags: string[];
+  /** Latest version */
+  version: string;
+  /** Author */
+  author: {
+    username: string;
+    avatarUrl?: string | undefined;
+  };
+  /** Download count */
+  downloads: number;
+  /** Trust status */
+  trustStatus?:
+    | {
+        auditorCount: number;
+      }
+    | undefined;
+}
+
+/**
+ * Search response with pagination info
+ */
+export interface SearchResponse {
+  /** Search results */
+  results: SearchResult[];
+  /** Total matching tools */
+  total: number;
+  /** Results limit used */
+  limit: number;
+  /** Results offset used */
+  offset: number;
+  /** Whether more results are available */
+  hasMore: boolean;
+}
+
+/**
+ * Raw API search response v2
+ */
+interface RawSearchResponse {
+  tools: ToolSearchResult[];
+  total: number;
+  limit: number;
+  offset: number;
+}
+
+/**
+ * Convert raw API result to clean SearchResult
+ */
+function toSearchResult(raw: ToolSearchResult): SearchResult {
+  return {
+    name: raw.name,
+    description: raw.description,
+    tags: raw.tags,
+    version: raw.version,
+    author: {
+      username: raw.author.username,
+      avatarUrl: raw.author.avatar_url,
+    },
+    downloads: raw.downloads,
+    trustStatus: raw.trust_status
+      ? {
+          auditorCount: raw.trust_status.auditor_count,
+        }
+      : undefined,
+  };
+}
+
+/**
+ * Search for tools in the registry
+ *
+ * @param client - API client instance
+ * @param options - Search options
+ * @returns Search results with pagination
+ *
+ * @example
+ * ```ts
+ * const client = createApiClient();
+ * const results = await searchTools(client, {
+ *   query: "pdf extraction",
+ *   tags: ["ai", "document"],
+ *   limit: 10
+ * });
+ * ```
+ */
+export async function searchTools(
+  client: EnactApiClient,
+  options: SearchOptions
+): Promise<SearchResponse> {
+  const params = new URLSearchParams();
+
+  params.set("q", options.query);
+
+  if (options.tags) {
+    const tagsStr = Array.isArray(options.tags) ? options.tags.join(",") : options.tags;
+    params.set("tags", tagsStr);
+  }
+
+  if (options.limit !== undefined) {
+    params.set("limit", String(Math.min(options.limit, 100)));
+  }
+
+  if (options.offset !== undefined) {
+    params.set("offset", String(options.offset));
+  }
+
+  const response = await client.get<RawSearchResponse>(`/tools/search?${params.toString()}`);
+
+  const results = response.data.tools.map(toSearchResult);
+
+  return {
+    results,
+    total: response.data.total,
+    limit: response.data.limit,
+    offset: response.data.offset,
+    hasMore: response.data.offset + results.length < response.data.total,
+  };
+}

package/src/trust.ts

@@ -0,0 +1,203 @@
+/**
+ * Trust configuration management (v2)
+ * Functions for managing user trust settings
+ */
+
+import type { EnactApiClient } from "./client";
+import type { UpdateTrustConfigRequest, UpdateTrustConfigResponse, UserTrustConfig } from "./types";
+
+/**
+ * Get a user's trust configuration (v2)
+ *
+ * This is public information - anyone can see which auditors a user trusts.
+ *
+ * @param client - API client instance
+ * @param username - Username to look up
+ * @returns User's trust configuration
+ *
+ * @example
+ * ```ts
+ * const trustConfig = await getUserTrust(client, "alice");
+ * console.log(`Alice trusts ${trustConfig.trusted_auditors.length} auditors`);
+ * ```
+ */
+export async function getUserTrust(
+  client: EnactApiClient,
+  username: string
+): Promise<UserTrustConfig> {
+  const response = await client.get<UserTrustConfig>(`/users/${username}/trust`);
+  return response.data;
+}
+
+/**
+ * Update current user's trust configuration (v2)
+ *
+ * Replace the entire list of trusted auditors.
+ *
+ * @param client - API client instance (must be authenticated)
+ * @param trustedAuditors - Array of auditor emails to trust
+ * @returns Updated trust configuration
+ *
+ * @example
+ * ```ts
+ * const updated = await updateMyTrust(client, [
+ *   "security@example.com",
+ *   "bob@github.com",
+ *   "audit-team@company.com"
+ * ]);
+ * console.log(`Now trusting ${updated.trusted_auditors.length} auditors`);
+ * ```
+ */
+export async function updateMyTrust(
+  client: EnactApiClient,
+  trustedAuditors: string[]
+): Promise<{
+  trustedAuditors: Array<{
+    identity: string;
+    addedAt: Date;
+  }>;
+  updatedAt: Date;
+}> {
+  const response = await client.put<UpdateTrustConfigResponse>("/users/me/trust", {
+    trusted_auditors: trustedAuditors,
+  } as UpdateTrustConfigRequest);
+
+  return {
+    trustedAuditors: response.data.trusted_auditors.map((ta) => ({
+      identity: ta.identity,
+      addedAt: new Date(ta.added_at),
+    })),
+    updatedAt: new Date(response.data.updated_at),
+  };
+}
+
+/**
+ * Add an auditor to the current user's trust list
+ *
+ * This is a convenience wrapper that fetches current trust config,
+ * adds the auditor if not already present, and updates.
+ *
+ * @param client - API client instance (must be authenticated)
+ * @param auditorEmail - Auditor email to trust
+ * @returns Updated trust configuration
+ *
+ * @example
+ * ```ts
+ * await addTrustedAuditor(client, "new-auditor@example.com");
+ * ```
+ */
+export async function addTrustedAuditor(
+  client: EnactApiClient,
+  auditorEmail: string
+): Promise<{
+  trustedAuditors: Array<{
+    identity: string;
+    addedAt: Date;
+  }>;
+  updatedAt: Date;
+}> {
+  // First get current user to know their username
+  const currentUser = await client.get<{ username: string }>("/auth/me");
+  const username = currentUser.data.username;
+
+  // Get current trust config
+  const currentTrust = await getUserTrust(client, username);
+
+  // Add new auditor if not already present
+  const currentAuditors = currentTrust.trusted_auditors.map((ta) => ta.identity);
+  if (!currentAuditors.includes(auditorEmail)) {
+    currentAuditors.push(auditorEmail);
+  }
+
+  // Update trust config
+  return updateMyTrust(client, currentAuditors);
+}
+
+/**
+ * Remove an auditor from the current user's trust list
+ *
+ * This is a convenience wrapper that fetches current trust config,
+ * removes the auditor if present, and updates.
+ *
+ * @param client - API client instance (must be authenticated)
+ * @param auditorEmail - Auditor email to remove
+ * @returns Updated trust configuration
+ *
+ * @example
+ * ```ts
+ * await removeTrustedAuditor(client, "old-auditor@example.com");
+ * ```
+ */
+export async function removeTrustedAuditor(
+  client: EnactApiClient,
+  auditorEmail: string
+): Promise<{
+  trustedAuditors: Array<{
+    identity: string;
+    addedAt: Date;
+  }>;
+  updatedAt: Date;
+}> {
+  // First get current user to know their username
+  const currentUser = await client.get<{ username: string }>("/auth/me");
+  const username = currentUser.data.username;
+
+  // Get current trust config
+  const currentTrust = await getUserTrust(client, username);
+
+  // Remove auditor
+  const updatedAuditors = currentTrust.trusted_auditors
+    .map((ta) => ta.identity)
+    .filter((email) => email !== auditorEmail);
+
+  // Update trust config
+  return updateMyTrust(client, updatedAuditors);
+}
+
+/**
+ * Check if a user trusts a specific auditor
+ *
+ * @param client - API client instance
+ * @param username - Username to check
+ * @param auditorEmail - Auditor email to check
+ * @returns True if the user trusts this auditor
+ *
+ * @example
+ * ```ts
+ * const trusts = await userTrustsAuditor(client, "alice", "security@example.com");
+ * if (trusts) {
+ *   console.log("Alice trusts this auditor");
+ * }
+ * ```
+ */
+export async function userTrustsAuditor(
+  client: EnactApiClient,
+  username: string,
+  auditorEmail: string
+): Promise<boolean> {
+  const trustConfig = await getUserTrust(client, username);
+  return trustConfig.trusted_auditors.some((ta) => ta.identity === auditorEmail);
+}
+
+/**
+ * Get list of auditors trusted by the current user
+ *
+ * @param client - API client instance (must be authenticated)
+ * @returns Array of trusted auditor emails
+ *
+ * @example
+ * ```ts
+ * const auditors = await getMyTrustedAuditors(client);
+ * console.log(`You trust: ${auditors.join(", ")}`);
+ * ```
+ */
+export async function getMyTrustedAuditors(client: EnactApiClient): Promise<string[]> {
+  // First get current user to know their username
+  const currentUser = await client.get<{ username: string }>("/auth/me");
+  const username = currentUser.data.username;
+
+  // Get trust config
+  const trustConfig = await getUserTrust(client, username);
+
+  return trustConfig.trusted_auditors.map((ta) => ta.identity);
+}