npm - @nextclaw/ui - Versions diffs - 0.9.11 → 0.9.12 - Mend

@nextclaw/ui 0.9.11 → 0.9.12

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (58) hide show

package/dist/index.html CHANGED Viewed

@@ -6,9 +6,9 @@
   <link rel="icon" type="image/svg+xml" href="/logo.svg" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
   <title>NextClaw - 系统配置</title>
-  <script type="module" crossorigin src="/assets/index-ClLy_7T2.js"></script>
-  <link rel="modulepreload" crossorigin href="/assets/vendor-CmQZsDAE.js">
-  <link rel="stylesheet" crossorigin href="/assets/index-DfEAJJsA.css">
+  <script type="module" crossorigin src="/assets/index-BOhlxC12.js"></script>
+  <link rel="modulepreload" crossorigin href="/assets/vendor-TJ2hy_Lv.js">
+  <link rel="stylesheet" crossorigin href="/assets/index-SGSkQCPi.css">
 </head>
 <body>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@nextclaw/ui",
-  "version": "0.9.11",
+  "version": "0.9.12",
   "private": false,
   "type": "module",
   "license": "MIT",
@@ -27,11 +27,11 @@
     "tailwind-merge": "^2.5.4",
     "zod": "^3.23.8",
     "zustand": "^5.0.2",
-    "@nextclaw/ncp-http-agent-client": "0.3.1",
-    "@nextclaw/agent-chat": "0.1.1",
     "@nextclaw/ncp": "0.3.1",
+    "@nextclaw/ncp-http-agent-client": "0.3.1",
     "@nextclaw/agent-chat-ui": "0.2.1",
-    "@nextclaw/ncp-react": "0.3.2"
+    "@nextclaw/ncp-react": "0.3.2",
+    "@nextclaw/agent-chat": "0.1.1"
   },
   "devDependencies": {
     "@testing-library/react": "^16.3.0",

package/src/account/managers/account.manager.ts CHANGED Viewed

@@ -51,9 +51,16 @@ export class AccountManager {
     return false;
   };
-  startBrowserSignIn = async (params?: { apiBase?: string; status?: RemoteAccessView }) => {
+  startBrowserSignIn = async (params?: {
+    apiBase?: string;
+    status?: RemoteAccessView;
+    pendingAction?: AccountPendingAction;
+  }) => {
     try {
       const status = params?.status ?? (await ensureRemoteStatus());
+      if (params?.pendingAction) {
+        useAccountStore.getState().setPendingAction(params.pendingAction);
+      }
       const result = await startRemoteBrowserAuth({
         apiBase: resolveRemotePlatformApiBase(status, params?.apiBase)
       });

package/src/account/stores/account.store.ts CHANGED Viewed

@@ -4,6 +4,9 @@ export type AccountPendingAction =
   | {
       type: 'enable-remote';
     }
+  | {
+      type: 'repair-remote';
+    }
   | null;
 type AccountStoreState = {

package/src/api/api-base.ts ADDED Viewed

@@ -0,0 +1,16 @@
+const DEFAULT_API_BASE = 'http://127.0.0.1:55667';
+export const API_BASE = (() => {
+  const envBase = import.meta.env.VITE_API_BASE?.trim();
+  if (envBase) {
+    return envBase.replace(/\/$/, '');
+  }
+  if (typeof window !== 'undefined' && window.location?.origin) {
+    return window.location.origin;
+  }
+  return DEFAULT_API_BASE;
+})();
+if (import.meta.env.DEV && !import.meta.env.VITE_API_BASE) {
+  console.warn('VITE_API_BASE is not set; falling back to window origin.');
+}

package/src/api/client.test.ts ADDED Viewed

@@ -0,0 +1,69 @@
+import { api, requestApiResponse } from '@/api/client';
+const mocks = vi.hoisted(() => ({
+  request: vi.fn()
+}));
+vi.mock('@/transport', () => ({
+  appClient: {
+    request: mocks.request
+  }
+}));
+describe('api/client', () => {
+  beforeEach(() => {
+    mocks.request.mockReset();
+  });
+  it('routes GET requests through appClient.request', async () => {
+    mocks.request.mockResolvedValue({ ok: true });
+    const response = await api.get<{ ok: boolean }>('/api/config');
+    expect(mocks.request).toHaveBeenCalledWith({
+      method: 'GET',
+      path: '/api/config'
+    });
+    expect(response).toEqual({
+      ok: true,
+      data: { ok: true }
+    });
+  });
+  it('parses JSON request bodies before sending to appClient.request', async () => {
+    mocks.request.mockResolvedValue({ success: true });
+    const response = await requestApiResponse<{ success: boolean }>('/api/auth/login', {
+      method: 'POST',
+      body: JSON.stringify({ password: 'secret' })
+    });
+    expect(mocks.request).toHaveBeenCalledWith({
+      method: 'POST',
+      path: '/api/auth/login',
+      body: { password: 'secret' }
+    });
+    expect(response).toEqual({
+      ok: true,
+      data: { success: true }
+    });
+  });
+  it('wraps transport failures as ApiResponse errors', async () => {
+    mocks.request.mockRejectedValue(new Error('Invalid token'));
+    const response = await api.get('/api/auth/status');
+    expect(response).toEqual({
+      ok: false,
+      error: {
+        code: 'REQUEST_FAILED',
+        message: 'Invalid token',
+        details: {
+          method: 'GET',
+          endpoint: '/api/auth/status'
+        }
+      }
+    });
+  });
+});

package/src/api/client.ts CHANGED Viewed

@@ -1,106 +1,34 @@
+import { appClient } from '@/transport';
 import type { ApiResponse } from './types';
-const DEFAULT_API_BASE = 'http://127.0.0.1:55667';
-const API_BASE = (() => {
-  const envBase = import.meta.env.VITE_API_BASE?.trim();
-  if (envBase) {
-    return envBase.replace(/\/$/, '');
-  }
-  if (typeof window !== 'undefined' && window.location?.origin) {
-    return window.location.origin;
-  }
-  return DEFAULT_API_BASE;
-})();
-if (import.meta.env.DEV && !import.meta.env.VITE_API_BASE) {
-  console.warn('VITE_API_BASE is not set; falling back to window origin.');
-}
-export { API_BASE };
-function compactSnippet(text: string): 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;
-}
 export async function requestApiResponse<T>(
   endpoint: string,
   options: RequestInit = {}
 ): Promise<ApiResponse<T>> {
-  const url = `${API_BASE}${endpoint}`;
   const method = (options.method || 'GET').toUpperCase();
-  const response = await fetch(url, {
-    credentials: 'include',
-    headers: {
-      'Content-Type': 'application/json',
-      ...options.headers
-    },
-    ...options
-  });
-  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}`);
-    }
+  try {
+    const data = await appClient.request<T>({
+      method: method as 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE',
+      path: endpoint,
+      ...(options.body !== undefined ? { body: parseRequestBody(options.body) } : {})
+    });
+    return {
+      ok: true,
+      data
+    };
+  } catch (error) {
     return {
       ok: false,
       error: {
-        code: 'INVALID_RESPONSE',
-        message: parts.join(' | '),
+        code: 'REQUEST_FAILED',
+        message: error instanceof Error ? error.message : String(error),
         details: {
-          status: response.status,
-          statusText: response.statusText,
           method,
-          endpoint,
-          url,
-          bodySnippet: snippet || undefined,
-          hint
+          endpoint
         }
       }
     };
   }
-  if (!response.ok) {
-    return data as ApiResponse<T>;
-  }
-  return data as ApiResponse<T>;
 }
 export const api = {
@@ -120,3 +48,17 @@ export const api = {
       method: 'DELETE'
     })
 };
+function parseRequestBody(body: BodyInit | null | undefined): unknown {
+  if (body === undefined || body === null) {
+    return undefined;
+  }
+  if (typeof body === 'string') {
+    try {
+      return JSON.parse(body);
+    } catch {
+      return body;
+    }
+  }
+  return body;
+}

package/src/api/config.stream.test.ts ADDED Viewed

@@ -0,0 +1,115 @@
+import { sendChatTurnStream, streamChatRun } from '@/api/config';
+const mocks = vi.hoisted(() => ({
+  request: vi.fn(),
+  openStream: vi.fn()
+}));
+vi.mock('@/transport', () => ({
+  appClient: {
+    request: mocks.request,
+    openStream: mocks.openStream
+  }
+}));
+describe('api/config stream routing', () => {
+  beforeEach(() => {
+    mocks.request.mockReset();
+    mocks.openStream.mockReset();
+  });
+  it('routes sendChatTurnStream through appClient.openStream', async () => {
+    const onReady = vi.fn();
+    const onDelta = vi.fn();
+    const onSessionEvent = vi.fn();
+    mocks.openStream.mockImplementation(({ onEvent }) => {
+      onEvent({ name: 'ready', payload: { sessionKey: 's1' } });
+      onEvent({ name: 'delta', payload: { delta: 'hello' } });
+      onEvent({ name: 'session_event', payload: { type: 'session.updated' } });
+      onEvent({ name: 'final', payload: { sessionKey: 's1', reply: 'hello world' } });
+      return {
+        finished: Promise.resolve({ sessionKey: 's1', reply: 'hello world' }),
+        cancel: vi.fn()
+      };
+    });
+    const result = await sendChatTurnStream(
+      { message: 'hi' } as never,
+      { onReady, onDelta, onSessionEvent }
+    );
+    expect(mocks.openStream).toHaveBeenCalledWith({
+      method: 'POST',
+      path: '/api/chat/turn/stream',
+      body: { message: 'hi' },
+      signal: undefined,
+      onEvent: expect.any(Function)
+    });
+    expect(onReady).toHaveBeenCalledWith({ sessionKey: 's1' });
+    expect(onDelta).toHaveBeenCalledWith({ delta: 'hello' });
+    expect(onSessionEvent).toHaveBeenCalledWith({ data: { type: 'session.updated' } });
+    expect(result).toEqual({ sessionKey: 's1', reply: 'hello world' });
+  });
+  it('routes streamChatRun through appClient.openStream and preserves query params', async () => {
+    const onReady = vi.fn();
+    const onDelta = vi.fn();
+    const onSessionEvent = vi.fn();
+    mocks.openStream.mockImplementation(() => ({
+      finished: Promise.resolve({ sessionKey: 's1', reply: 'resumed' }),
+      cancel: vi.fn()
+    }));
+    const result = await streamChatRun(
+      { runId: 'run-1', fromEventIndex: 42 },
+      { onReady, onDelta, onSessionEvent }
+    );
+    expect(mocks.openStream).toHaveBeenCalledWith({
+      method: 'GET',
+      path: '/api/chat/runs/run-1/stream?fromEventIndex=42',
+      signal: undefined,
+      onEvent: expect.any(Function)
+    });
+    expect(onReady).not.toHaveBeenCalled();
+    expect(onDelta).not.toHaveBeenCalled();
+    expect(onSessionEvent).not.toHaveBeenCalled();
+    expect(result).toEqual({ sessionKey: 's1', reply: 'resumed' });
+  });
+  it('surfaces transport error events as rejected stream promises', async () => {
+    mocks.openStream.mockImplementation(({ onEvent }) => {
+      let resolveFinished!: () => void;
+      let rejectFinished!: (error: Error) => void;
+      const finished = new Promise<void>((resolve, reject) => {
+        resolveFinished = resolve;
+        rejectFinished = reject;
+      });
+      queueMicrotask(() => {
+        try {
+          onEvent({ name: 'error', payload: { message: 'chat stream failed' } });
+          resolveFinished();
+        } catch (error) {
+          rejectFinished(error instanceof Error ? error : new Error(String(error)));
+        }
+      });
+      return {
+        finished,
+        cancel: vi.fn()
+      };
+    });
+    await expect(
+      sendChatTurnStream(
+        { message: 'hi' } as never,
+        {
+          onReady: vi.fn(),
+          onDelta: vi.fn(),
+          onSessionEvent: vi.fn()
+        }
+      )
+    ).rejects.toThrow('chat stream failed');
+  });
+});

package/src/api/config.ts CHANGED Viewed

@@ -1,4 +1,5 @@
-import { api, API_BASE } from './client';
+import { api } from './client';
+import { appClient } from '@/transport';
 import type {
   AuthEnabledUpdateRequest,
   AuthLoginRequest,
@@ -376,32 +377,6 @@ export async function sendChatTurn(data: ChatTurnRequest): Promise<ChatTurnView>
   return response.data;
 }
-function parseSseFrame(frame: string): { event: string; data: string } | null {
-  const lines = frame.split('\n');
-  let event = '';
-  const dataLines: string[] = [];
-  for (const raw of lines) {
-    const line = raw.trimEnd();
-    if (!line || line.startsWith(':')) {
-      continue;
-    }
-    if (line.startsWith('event:')) {
-      event = line.slice(6).trim();
-      continue;
-    }
-    if (line.startsWith('data:')) {
-      dataLines.push(line.slice(5).trimStart());
-    }
-  }
-  if (!event) {
-    return null;
-  }
-  return {
-    event,
-    data: dataLines.join('\n')
-  };
-}
 async function readSseStream(params: {
   path: string;
   method: 'GET' | 'POST';
@@ -411,115 +386,68 @@ async function readSseStream(params: {
   onDelta: (event: ChatTurnStreamDeltaEvent) => void;
   onSessionEvent: (event: ChatTurnStreamSessionEvent) => void;
 }): Promise<{ sessionKey: string; reply: string }> {
-  const response = await fetch(`${API_BASE}${params.path}`, {
-    method: params.method,
-    credentials: 'include',
-    headers: {
-      'Content-Type': 'application/json',
-      Accept: 'text/event-stream'
-    },
-    ...(params.body !== undefined ? { body: JSON.stringify(params.body) } : {}),
-    ...(params.signal ? { signal: params.signal } : {})
-  });
-  if (!response.ok) {
-    const text = await response.text();
-    const fallback = `HTTP ${response.status}`;
-    const trimmed = text.trim();
-    throw new Error(trimmed || fallback);
-  }
-  const reader = response.body?.getReader();
-  if (!reader) {
-    throw new Error('SSE response body unavailable');
-  }
-  const decoder = new TextDecoder();
-  let buffer = '';
   let finalResult: { sessionKey: string; reply: string } | null = null;
-  let readySessionKey: string | null = null;
-  const consumeFrame = (frame: string) => {
-    const parsed = parseSseFrame(frame);
-    if (!parsed) {
-      return;
-    }
+  let readySessionKey = '';
-    let payload: unknown = undefined;
-    if (parsed.data) {
-      try {
-        payload = JSON.parse(parsed.data);
-      } catch {
-        payload = undefined;
+  const session = appClient.openStream<ChatTurnView>({
+    method: params.method,
+    path: params.path,
+    ...(params.body !== undefined ? { body: params.body } : {}),
+    signal: params.signal,
+    onEvent: (event) => {
+      if (event.name === 'ready') {
+        const ready = (event.payload ?? {}) as ChatTurnStreamReadyEvent;
+        if (typeof ready.sessionKey === 'string' && ready.sessionKey.trim()) {
+          readySessionKey = ready.sessionKey;
+        }
+        params.onReady(ready);
+        return;
       }
-    }
-    if (parsed.event === 'ready') {
-      const ready = (payload ?? {}) as ChatTurnStreamReadyEvent;
-      readySessionKey = typeof ready.sessionKey === 'string' && ready.sessionKey.trim() ? ready.sessionKey : readySessionKey;
-      params.onReady(ready);
-      return;
-    }
-    if (parsed.event === 'delta') {
-      params.onDelta((payload ?? { delta: '' }) as ChatTurnStreamDeltaEvent);
-      return;
-    }
-    if (parsed.event === 'session_event') {
-      params.onSessionEvent({ data: payload as ChatTurnStreamSessionEvent['data'] });
-      return;
-    }
+      if (event.name === 'delta') {
+        params.onDelta((event.payload ?? { delta: '' }) as ChatTurnStreamDeltaEvent);
+        return;
+      }
-    if (parsed.event === 'final') {
-      const result = payload as ChatTurnView;
-      finalResult = {
-        sessionKey: typeof result?.sessionKey === 'string' && result.sessionKey.trim()
-          ? result.sessionKey
-          : (readySessionKey ?? ''),
-        reply: typeof result?.reply === 'string' ? result.reply : ''
-      };
-      return;
-    }
+      if (event.name === 'session_event') {
+        params.onSessionEvent({ data: event.payload as ChatTurnStreamSessionEvent['data'] });
+        return;
+      }
-    if (parsed.event === 'error') {
-      const errorPayload = (payload ?? {}) as ChatTurnStreamErrorEvent;
-      throw new Error((errorPayload.message ?? '').trim() || 'chat stream failed');
-    }
-  };
-  try {
-    let isReading = true;
-    while (isReading) {
-      const { value, done } = await reader.read();
-      if (done) {
-        isReading = false;
-        continue;
+      if (event.name === 'final') {
+        const result = event.payload as ChatTurnView;
+        finalResult = {
+          sessionKey: typeof result?.sessionKey === 'string' && result.sessionKey.trim()
+            ? result.sessionKey
+            : readySessionKey,
+          reply: typeof result?.reply === 'string' ? result.reply : ''
+        };
+        return;
       }
-      buffer += decoder.decode(value, { stream: true });
-      let boundary = buffer.indexOf('\n\n');
-      while (boundary !== -1) {
-        const frame = buffer.slice(0, boundary);
-        buffer = buffer.slice(boundary + 2);
-        consumeFrame(frame);
-        boundary = buffer.indexOf('\n\n');
+      if (event.name === 'error') {
+        const errorPayload = (event.payload ?? {}) as ChatTurnStreamErrorEvent;
+        throw new Error((errorPayload.message ?? '').trim() || 'chat stream failed');
       }
     }
-    if (buffer.trim()) {
-      consumeFrame(buffer);
-    }
-  } finally {
-    reader.releaseLock();
-  }
+  });
+  const result = await session.finished;
   if (finalResult) {
     return finalResult;
   }
   if (readySessionKey) {
-    return { sessionKey: readySessionKey, reply: '' };
+    return {
+      sessionKey: readySessionKey,
+      reply: typeof result?.reply === 'string' ? result.reply : ''
+    };
+  }
+  if (typeof result?.sessionKey === 'string' && result.sessionKey.trim()) {
+    return {
+      sessionKey: result.sessionKey,
+      reply: typeof result?.reply === 'string' ? result.reply : ''
+    };
   }
   throw new Error('chat stream ended without final event');
 }