@nextclaw/ui 0.12.20-beta.0 → 0.12.20-beta.1

package/src/shared/lib/api/services/server-path.service.ts

@@ -0,0 +1,16 @@
+import { nextclawClient } from './client.service';
+import type { ServerPathBrowseView, ServerPathReadView } from '@/shared/lib/api/types';
+
+export async function fetchServerPathBrowse(params?: {
+  path?: string | null;
+  includeFiles?: boolean;
+}): Promise<ServerPathBrowseView> {
+  return await nextclawClient.serverPaths.browse(params);
+}
+
+export async function fetchServerPathRead(params: {
+  path: string;
+  basePath?: string | null;
+}): Promise<ServerPathReadView> {
+  return await nextclawClient.serverPaths.read(params);
+}

package/src/shared/lib/transport/index.ts

@@ -1,4 +1,5 @@
 export { appClient } from './app-client.service';
+export { requestRawApiResponse } from './request-raw-api-response.utils';
 export type {
   AppEvent,
   AppTransport,

package/src/shared/lib/transport/local-transport.service.ts

@@ -1,5 +1,6 @@
 import { systemStatusManager } from '@/features/system-status';
 import type { AppEvent, AppTransport, RequestInput, StreamInput, StreamSession } from './transport.types';
+import { requestRawApiResponse } from './request-raw-api-response.utils';
 import { readSseStreamResult } from './sse-stream.utils';
 import { resolveTransportWebSocketUrl } from './transport-websocket-url.utils';
 
@@ -139,13 +140,14 @@ export class LocalAppTransport implements AppTransport {
     const timeoutId = timeoutMs
       ? window.setTimeout(() => controller?.abort(`Request timed out after ${timeoutMs}ms: ${input.method} ${input.path}`), timeoutMs)
       : null;
+    const requestBody = normalizeRequestBody(input.body);
 
     try {
-      const { requestRawApiResponse } = await import('@/shared/lib/api');
-      const response = await requestRawApiResponse<T>(input.path, {
+      const response = await requestRawApiResponse<T>(this.apiBase, input.path, {
         method: input.method,
-        ...(input.body !== undefined ? { body: JSON.stringify(input.body) } : {}),
-        ...(controller ? { signal: controller.signal } : {})
+        ...(requestBody !== undefined ? { body: requestBody } : {}),
+        ...(input.headers ? { headers: input.headers } : {}),
+        signal: controller?.signal ?? input.signal
       });
       if (!response.ok) {
         throw createTransportError(response, `Request failed for ${input.method} ${input.path}`);
@@ -228,3 +230,21 @@ export class LocalAppTransport implements AppTransport {
     return this.realtimeGateway.subscribe(handler);
   };
 }
+
+function normalizeRequestBody(body: unknown): BodyInit | undefined {
+  if (body === undefined) {
+    return undefined;
+  }
+  if (
+    body instanceof FormData ||
+    body instanceof URLSearchParams ||
+    body instanceof Blob ||
+    body instanceof ArrayBuffer
+  ) {
+    return body;
+  }
+  if (typeof body === 'string') {
+    return body;
+  }
+  return JSON.stringify(body);
+}

package/src/shared/lib/transport/remote-transport.service.ts

@@ -1,4 +1,4 @@
-import type { ApiError } from '@/shared/lib/api';
+import type { ApiError } from '@nextclaw/server';
 import type { AppEvent, AppTransport, RemoteRuntimeInfo, RequestInput, StreamInput, StreamSession } from './transport.types';
 import { resolveTransportWebSocketUrl } from './transport-websocket-url.utils';
 

package/src/shared/lib/transport/request-raw-api-response.utils.ts

@@ -0,0 +1,133 @@
+import type { ApiResponse } from '@nextclaw/server';
+import { systemStatusManager } from '@/features/system-status';
+
+function compactSnippet(text: string) {
+  return text.replace(/\s+/g, ' ').trim().slice(0, 200);
+}
+
+function inferNonJsonHint(endpoint: string, status: number): string | undefined {
+  if (
+    status === 404 &&
+    endpoint.startsWith('/api/config/providers/') &&
+    endpoint.endsWith('/test')
+  ) {
+    return 'Provider test endpoint is missing. This usually means nextclaw runtime version is outdated.';
+  }
+  if (status === 401 || status === 403) {
+    return 'Authentication failed. Check apiKey and custom headers.';
+  }
+  if (status === 429) {
+    return 'Rate limited by upstream provider. Retry later or switch model/provider.';
+  }
+  if (status >= 500) {
+    return 'Upstream service error. Retry later and inspect server logs if it persists.';
+  }
+  return undefined;
+}
+
+function formatUnknownFetchError(error: unknown): {
+  summary: string;
+  details: Record<string, unknown>;
+} {
+  if (error instanceof Error) {
+    const name = error.name?.trim() || 'Error';
+    const message = error.message?.trim() || 'Unknown error';
+    return {
+      summary: `${name}: ${message}`,
+      details: {
+        errorName: name,
+        errorMessage: message,
+        ...(error.stack?.trim() ? { errorStack: error.stack.trim() } : {})
+      }
+    };
+  }
+  return {
+    summary: String(error ?? 'Unknown error'),
+    details: {
+      errorName: 'NonError',
+      errorMessage: String(error ?? 'Unknown error')
+    }
+  };
+}
+
+export async function requestRawApiResponse<T>(
+  apiBase: string,
+  endpoint: string,
+  options: RequestInit = {}
+): Promise<ApiResponse<T>> {
+  const url = `${apiBase}${endpoint}`;
+  const method = (options.method || 'GET').toUpperCase();
+
+  let response: Response;
+  try {
+    const headers = new Headers(options.headers);
+    if (!(options.body instanceof FormData) && !headers.has('Content-Type')) {
+      headers.set('Content-Type', 'application/json');
+    }
+    response = await fetch(url, {
+      credentials: 'include',
+      headers,
+      ...options
+    });
+  } catch (error) {
+    const formatted = formatUnknownFetchError(error);
+    systemStatusManager.reportTransportFailure(formatted.summary);
+    return {
+      ok: false,
+      error: {
+        code: 'NETWORK_ERROR',
+        message: `Fetch failed on ${method} ${endpoint} | ${formatted.summary}`,
+        details: {
+          method,
+          endpoint,
+          url,
+          ...formatted.details
+        }
+      }
+    };
+  }
+
+  const text = await response.text();
+  let data: ApiResponse<T> | null = null;
+  if (text) {
+    try {
+      data = JSON.parse(text) as ApiResponse<T>;
+    } catch {
+      // fall through to build a synthetic error response
+    }
+  }
+
+  if (!data) {
+    const snippet = text ? compactSnippet(text) : '';
+    const hint = inferNonJsonHint(endpoint, response.status);
+    const parts = [`Non-JSON response (${response.status} ${response.statusText}) on ${method} ${endpoint}`];
+    if (snippet) {
+      parts.push(`body=${snippet}`);
+    }
+    if (hint) {
+      parts.push(`hint=${hint}`);
+    }
+    return {
+      ok: false,
+      error: {
+        code: 'INVALID_RESPONSE',
+        message: parts.join(' | '),
+        details: {
+          status: response.status,
+          statusText: response.statusText,
+          method,
+          endpoint,
+          url,
+          bodySnippet: snippet || undefined,
+          hint
+        }
+      }
+    };
+  }
+
+  if (!response.ok) {
+    return data as ApiResponse<T>;
+  }
+
+  return data as ApiResponse<T>;
+}

package/src/shared/lib/transport/transport.types.ts

@@ -1,4 +1,4 @@
-import type { WsEvent } from '@/shared/lib/api';
+import type { UiServerEvent } from '@nextclaw/server';
 
 export type RequestMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
 
@@ -6,6 +6,8 @@ export type RequestInput = {
   method: RequestMethod;
   path: string;
   body?: unknown;
+  headers?: Record<string, string>;
+  signal?: AbortSignal;
   timeoutMs?: number;
 };
 
@@ -27,7 +29,11 @@ export type StreamSession<TFinal = unknown> = {
   cancel: () => void;
 };
 
-export type AppEvent = WsEvent;
+export type AppEvent =
+  | UiServerEvent
+  | { type: 'connection.open'; payload?: Record<string, never> }
+  | { type: 'connection.close'; payload?: Record<string, never> }
+  | { type: 'connection.error'; payload?: { message?: string } };
 
 export type AppTransport = {
   request<T>(input: RequestInput): Promise<T>;