@deepseek-ai/dsh-client-connection 0.1.1-rc.2 → 0.1.2-alpha.3

package/lib/types/rpc.d.ts

@@ -1,40 +1,160 @@
 /** Generic unary RPC contracts shared by the Host and Client Connection halves. */
-import type { RpcResult } from '@deepseek-ai/dsh-host-apiproxy/api';
-/** Trust fence applied before a Host RPC channel reaches its handler. */
-export type ConnectionRpcAuthority = 'trusted-host' | 'loopback';
-/** Registration policy for one logical RPC channel. */
-export interface ConnectionRpcHandlerOptions {
-    /** Browser authority accepted by every endpoint in this channel. */
-    readonly authority: ConnectionRpcAuthority;
+import type { Branded } from '@deepseek-ai/dsh-brand';
+/** Correlation id minted by a caller and echoed by the Connection response. */
+export type RpcId = Branded<'rpc-id'>;
+/**
+ * Brand one validated string as a Connection correlation id.
+ * @param id - validated wire identity.
+ * @returns the same string with the correlation-id brand.
+ */
+export declare function RpcId(id: string): RpcId;
+/** Carrier-neutral failure returned by one logical RPC endpoint. */
+export interface ConnectionRpcFailure {
+    readonly code: string;
+    readonly message: string;
+    readonly details: object;
+}
+/** Carrier-neutral result returned by one logical RPC endpoint. */
+export type ConnectionRpcResult<T> = {
+    readonly ok: true;
+    readonly value: T;
+} | {
+    readonly ok: false;
+    readonly error: ConnectionRpcFailure;
+};
+/** Historical short name for a generic Connection result. */
+export type RpcResult<T> = ConnectionRpcResult<T>;
+/**
+ * Convert a rejected transport operation into a generic failure result.
+ * @param error - rejected transport value.
+ * @returns an `internal` failure preserving the available message.
+ */
+export declare function transportError<T>(error: unknown): RpcResult<T>;
+/** Narrow request form used by direct fixture adapters. */
+export interface RpcRequest<P> {
+    readonly rpcId: RpcId;
+    readonly payload: P;
+}
+/** Narrow response form used by direct fixture adapters. */
+export interface RpcResponse<T> {
+    readonly rpcId: RpcId;
+    readonly result: RpcResult<T>;
+}
+/** Full request envelope carried by Connection RPC transports. */
+export interface ClientRequest {
+    readonly type: 'client-request';
+    readonly rpcId: RpcId;
+    readonly method: string;
+    readonly payload: unknown;
+}
+/** Full response envelope carried by Connection RPC transports. */
+export interface ServerResponse {
+    readonly type: 'server-response';
+    readonly rpcId: RpcId;
+    readonly result: ConnectionRpcResult<unknown>;
+}
+/** Complete Connection RPC envelope union. */
+export type RpcMessage = ClientRequest | ServerResponse;
+/** HTTP request facts consumed by browser trust and authentication. */
+export interface ConnectionTrustRequest {
+    /** Request headers supplied by either the Fetch or node:http representation. */
+    readonly headers: Headers | Readonly<Record<string, string | readonly string[] | undefined>>;
+}
+/** HTTP status returned before dispatch, or undefined when the request may proceed. */
+export type ConnectionRequestRejection = 401 | 403 | undefined;
+/** Root/index request facts used by the browser-token exchange. */
+export interface ConnectionIndexRequest extends ConnectionTrustRequest {
+    readonly method?: string | undefined;
+    readonly url?: string | undefined;
+}
+/** Root/index response operations owned by the browser-token exchange. */
+export interface ConnectionIndexResponse {
+    writeHead(status: number, headers?: Readonly<Record<string, string>>): unknown;
+    end(body?: string): unknown;
 }
 /** Handler invoked after Connection has decoded the transport envelope. */
-export type ConnectionRpcHandler = (endpoint: string, payload: unknown, signal: AbortSignal) => Promise<RpcResult<unknown>>;
+export type ConnectionRpcHandler = (endpoint: string, payload: unknown, signal: AbortSignal) => Promise<ConnectionRpcResult<unknown>>;
 /** Synchronous ownership test for one endpoint on a shared RPC channel. */
 export type ConnectionRpcEndpointMatcher = (endpoint: string) => boolean;
+/** HTTP methods supported by exact Fetch routes on the shared API channel. */
+export type ConnectionFetchMethod = 'GET' | 'HEAD';
+/** One exact, transport-independent Fetch route owned by a Host feature. */
+export interface ConnectionFetchRoute {
+    /** Absolute path below `/api`; query parameters remain available on the request URL. */
+    readonly path: string;
+    /** Methods this route owns. Other methods continue through normal shared-channel dispatch. */
+    readonly methods: readonly ConnectionFetchMethod[];
+    /** Handle one request after the physical carrier has applied its trust and authentication policy. */
+    readonly fetch: (request: Request) => Promise<Response>;
+}
+/** Host registry for exact Fetch routes that cannot use JSON Remote invocation. */
+export interface HostConnectionFetch {
+    /**
+     * Register one exact route on the shared API channel.
+     * @param route - path, methods, and Fetch-shaped implementation.
+     * @returns asynchronous disposer removing this exact contribution.
+     */
+    register(route: ConnectionFetchRoute): () => Promise<void>;
+}
 /** Host registry for logical RPC channels carried by the current transport. */
 export interface HostConnectionRpc {
     /**
-     * Register one absolute channel prefix and its trust policy.
+     * Register one authenticated absolute channel prefix.
      * @param channel - absolute logical channel such as `/rpc`.
      * @param handler - decoded endpoint handler returning the existing RPC result shape.
-     * @param options - channel trust policy.
      * @returns asynchronous disposer removing the channel and its physical route.
      */
-    handle(channel: string, handler: ConnectionRpcHandler, options: ConnectionRpcHandlerOptions): () => Promise<void>;
+    handle(channel: string, handler: ConnectionRpcHandler): () => Promise<void>;
     /**
      * Intercept owned endpoints on the shared `/api` channel before its fallback.
      * @param channel - reserved shared channel; currently `/api`.
      * @param matches - synchronous endpoint ownership test.
      * @param handler - decoded endpoint handler returning the existing RPC result shape.
-     * @param options - trust policy for every endpoint claimed by this interceptor.
      * @returns asynchronous disposer removing the interceptor.
      */
-    intercept(channel: '/api', matches: ConnectionRpcEndpointMatcher, handler: ConnectionRpcHandler, options: ConnectionRpcHandlerOptions): () => Promise<void>;
+    intercept(channel: '/api', matches: ConnectionRpcEndpointMatcher, handler: ConnectionRpcHandler): () => Promise<void>;
 }
 /** Host `ctx.connection` shape consumed by transport-independent adapters. */
 export interface HostConnectionHandle {
     /** Generic RPC channel registry. */
     readonly rpc: HostConnectionRpc;
+    /** Exact Fetch routes for streaming or browser-native responses. */
+    readonly fetch: HostConnectionFetch;
+    /**
+     * Compose exact Fetch routes and the shared-channel RPC interceptor.
+     * @param channel - shared channel mounted by Connection.
+     * @returns Fetch handler for trusted, authenticated requests.
+     */
+    createSharedFetchHandler(channel: '/api'): ConnectionFetchHandler;
+    /**
+     * Apply Connection's Host/Origin checks and browser authentication to
+     * another Web route.
+     * @param request - request headers from the HTTP or upgrade request.
+     * @returns rejection status, or undefined when the route may accept the request.
+     */
+    requestRejection(request: ConnectionTrustRequest): ConnectionRequestRejection;
+    /**
+     * Authenticate one frontend index request, owning a token redirect or 401.
+     * @param request - root or configured-index HTTP request.
+     * @param response - response owned when the result is false.
+     * @returns true only when the frontend may serve index.html.
+     */
+    authorizeIndex(request: ConnectionIndexRequest, response: ConnectionIndexResponse): boolean;
+    /**
+     * Add the fresh process token to an ordinary Web application URL.
+     * @param baseUrl - clean canonical browser origin.
+     * @returns root URL accepted by {@link authorizeIndex} for initial login.
+     */
+    authenticatedUrl(baseUrl: string): string;
+}
+/** Transport-independent Fetch handler used by HTTP and worker carriers. */
+export interface ConnectionFetchHandler {
+    /**
+     * Dispatch one already-authenticated request.
+     * @param request - Fetch request below the shared channel.
+     * @returns the registered response or a 404 response.
+     */
+    fetch(request: Request): Promise<Response>;
 }
 /** Client caller for logical RPC channels carried by the current transport. */
 export interface ClientConnectionRpc {
@@ -44,8 +164,18 @@ export interface ClientConnectionRpc {
      * @param endpoint - channel-relative endpoint such as `goals/create`.
      * @param payload - channel-owned request payload.
      * @param signal - optional caller cancellation.
-     * @returns the existing RPC success/error result; correlation stays inside Connection.
+     * @returns the endpoint-owned success/error result; correlation stays inside Connection.
+     */
+    call(channel: string, endpoint: string, payload: unknown, signal?: AbortSignal): Promise<ConnectionRpcResult<unknown>>;
+    /**
+     * Open an in-process logical stream when the selected carrier supplies one.
+     * Browser transports omit this method; API Gateway owns their WebSocket mux.
+     * @param channel - absolute logical channel such as `/api`.
+     * @param endpoint - channel-relative endpoint such as `session/follow`.
+     * @param payload - channel-owned request payload.
+     * @param signal - caller cancellation for this logical stream.
+     * @returns decoded stream values from the in-process carrier.
      */
-    call(channel: string, endpoint: string, payload: unknown, signal?: AbortSignal): Promise<RpcResult<unknown>>;
+    readonly open?: (channel: string, endpoint: string, payload: unknown, signal: AbortSignal) => AsyncIterable<unknown>;
 }
 //# sourceMappingURL=rpc.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@deepseek-ai/dsh-client-connection",
-  "description": "Wire consumer layer: HTTP-up/WebSocket-down client, ConnectionController dual streams with reconnect, and fixture api",
-  "version": "0.1.1-rc.2",
+  "description": "Authenticated RPC transport, generation lifecycle, and browser fixture",
+  "version": "0.1.2-alpha.3",
   "publishConfig": {
     "access": "public"
   },
@@ -38,8 +38,9 @@
   },
   "license": "MIT",
   "dependencies": {
-    "ws": "^8.21.0",
-    "@deepseek-ai/schemastery": "^3.18.1"
+    "zod": "^4.4.3",
+    "@deepseek-ai/dsh-credentials": "^0.1.2-alpha.3",
+    "@deepseek-ai/schemastery": "^3.18.2"
   },
   "files": [
     "lib/index.js",
@@ -48,26 +49,20 @@
     "lib/types/**/*.d.ts"
   ],
   "peerDependencies": {
-    "@deepseek-ai/dsh-host-webserver": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-invariants": "^0.1.1-rc.2",
-    "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-host-apiproxy": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-commands": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-llm": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-session": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-tools": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-attachment": "^0.1.1-rc.2"
+    "@deepseek-ai/cordis": "^4.0.2"
   },
   "devDependencies": {
-    "@types/ws": "^8.18.1",
-    "@deepseek-ai/dsh-invariants": "^0.1.1-rc.2",
-    "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-host-webserver": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-attachment": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-llm": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-commands": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-session": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-tools": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-host-apiproxy": "^0.1.1-rc.2"
+    "@deepseek-ai/cordis": "^4.0.2",
+    "@deepseek-ai/dsh-attachment": "^0.1.2-alpha.3",
+    "@deepseek-ai/dsh-brand": "^0.1.2-alpha.3",
+    "@deepseek-ai/dsh-commands": "^0.1.2-alpha.3",
+    "@deepseek-ai/dsh-host-directory-picker": "^0.1.2-alpha.3",
+    "@deepseek-ai/dsh-host-webserver": "^0.1.2-alpha.3",
+    "@deepseek-ai/dsh-llm": "^0.1.2-alpha.3",
+    "@deepseek-ai/dsh-invariants": "^0.1.2-alpha.3",
+    "@deepseek-ai/dsh-settings": "^0.1.2-alpha.3",
+    "@deepseek-ai/dsh-session": "^0.1.2-alpha.3",
+    "@deepseek-ai/dsh-tool-todo": "^0.1.2-alpha.3",
+    "@deepseek-ai/dsh-util-values": "^0.1.2-alpha.3"
   }
 }

package/lib/types/client/web-api-client.d.ts

@@ -1,11 +0,0 @@
-/** Browser API carrier: HTTP upstream plus one WebSocket per downstream event stream. */
-import type { ApiProxy, HostFrame, MuxFrame, RpcRequest } from './api.ts';
-import { AbstractApiClient } from './api.ts';
-/** Browser platform subclass: unary/respond use fetch; mux/host use downlink-only WebSockets. */
-export declare class WebApiClient extends AbstractApiClient {
-    protected doFetch(input: URL, init?: RequestInit): Promise<Response>;
-    protected openMux(_payload: Parameters<ApiProxy['events']['mux']>[0]['payload'], signal: AbortSignal, onOpen?: () => void): AsyncIterable<RpcRequest<MuxFrame>>;
-    protected openHost(_payload: Parameters<ApiProxy['events']['host']>[0]['payload'], signal: AbortSignal, onOpen?: () => void): AsyncIterable<RpcRequest<HostFrame>>;
-    private readWebSocket;
-}
-//# sourceMappingURL=web-api-client.d.ts.map

package/lib/types/websocket-downlink.d.ts

@@ -1,43 +0,0 @@
-/** Host-side WebSocket carrier for the two server-to-browser event streams. */
-import type { IncomingMessage } from 'node:http';
-import type { Duplex } from 'node:stream';
-import type { ApiProxy } from '@deepseek-ai/dsh-host-apiproxy/api';
-/**
- * Owns WebSocket negotiation and frame pumping for the connection plugin's
- * two downlinks. Client messages are a protocol violation: upstream traffic
- * remains on HTTP.
- */
-export declare class WebSocketDownlinks {
-    private readonly api;
-    private readonly server;
-    private readonly pumps;
-    /** @param api - host API supplying the typed event streams. */
-    constructor(api: ApiProxy);
-    /**
-     * Upgrade one socket and pump the mux stream until either side closes.
-     * @param req - HTTP upgrade request.
-     * @param socket - Raw socket transferred by the HTTP server.
-     * @param head - Bytes already read after the upgrade headers.
-     */
-    handleMux(req: IncomingMessage, socket: Duplex, head: Buffer): void;
-    /**
-     * Upgrade one socket and pump the host stream until either side closes.
-     * @param req - HTTP upgrade request.
-     * @param socket - Raw socket transferred by the HTTP server.
-     * @param head - Bytes already read after the upgrade headers.
-     */
-    handleHost(req: IncomingMessage, socket: Duplex, head: Buffer): void;
-    /**
-     * Terminate owned sockets and await the no-server acceptor plus frame pumps.
-     * @returns A promise resolving after every socket and source iterator stops.
-     */
-    close(): Promise<void>;
-    private upgrade;
-    private pump;
-}
-/**
- * Reject an untrusted upgrade before protocol negotiation.
- * @param socket - Raw HTTP socket that remains owned by the caller.
- */
-export declare function rejectWebSocketUpgrade(socket: Duplex): void;
-//# sourceMappingURL=websocket-downlink.d.ts.map