@ref0/sdk 0.0.0-stage → 0.5.0

package/dist/browser.d.mts

@@ -0,0 +1,29 @@
+import { t as Browser } from "./browse-DBqoeS-u.mjs";
+import { BrowserContext, BrowserContext as BrowserContext$1, BrowserContextOptions, Locator, Page, Page as Page$1, Request, Response } from "@cloudflare/playwright";
+import { expect as expect$1 } from "@cloudflare/playwright/test";
+//#region src/browser-stub.d.ts
+declare module '@ref0/sdk/browser' {
+  /**
+   * ref0's `Browser`, as `sb.browse` hands it to a check: Playwright's, pinned, connected through
+   * the browse's `BrowserLink`, with ref0's hooks on every context before it's handed out. It's a
+   * convenience, not a boundary: whoever holds the link drives the whole session, so ref0's host
+   * and Browser Run hold what the browser reaches.
+   *
+   * One limit they don't hold: the page has UDP egress through WebRTC. Browser Run's guardrails
+   * cover only HTTP, HTTPS and WebSocket. ref0 takes WebRTC's constructors from every frame and
+   * popup, and reports a frame that reaches for one, but that's a guard against accidents, not a
+   * wall, so a check's verdict mustn't depend on what the page can or can't reach over UDP.
+   */
+  interface Browser {
+    /** A context whose user agent names the browser's real Chrome version, unless one is set. */
+    readonly newContext: (options?: BrowserContextOptions) => Promise<BrowserContext$1>;
+    /** A page in a context of its own, closed with it. */
+    readonly newPage: (options?: BrowserContextOptions) => Promise<Page$1>;
+    readonly contexts: () => Promise<ReadonlyArray<BrowserContext$1>>;
+  }
+}
+/** Playwright's `expect`, which runs only in ref0's browser module: here, each part throws. */
+export declare const expect: typeof expect$1;
+//#endregion
+export type { Browser, BrowserContext, Locator, Page, Request, Response };
+//# sourceMappingURL=browser.d.mts.map

package/dist/browser.mjs

@@ -0,0 +1,28 @@
+//#region src/browser-stub.ts
+const unavailable = () => {
+	throw new Error("expect runs only on ref0, which loads its own @ref0/sdk/browser beside a check that imports it");
+};
+const asymmetric = {
+	any: unavailable,
+	anything: unavailable,
+	arrayContaining: unavailable,
+	arrayOf: unavailable,
+	closeTo: unavailable,
+	objectContaining: unavailable,
+	stringContaining: unavailable,
+	stringMatching: unavailable
+};
+/** Playwright's `expect`, which runs only in ref0's browser module: here, each part throws. */
+const expect = Object.assign(() => unavailable(), {
+	...asymmetric,
+	soft: unavailable,
+	poll: unavailable,
+	extend: unavailable,
+	configure: unavailable,
+	getState: unavailable,
+	not: asymmetric
+});
+//#endregion
+export { expect };
+
+//# sourceMappingURL=browser.mjs.map

package/dist/client.d.mts

@@ -0,0 +1,94 @@
+import { $ as OwnerThreadView, A as ConnectionView, At as SignedIn, Bn as liveSocketUrl, Bt as TypedApprovalCode, C as ConnectChosen, D as ConnectionChanged, Dt as SentryRegion, Et as SentryOrg, F as EndpointName, Fn as connectEndpoint, Ft as ThreadId, G as LiveTrackName, H as ImportFailure, Hn as repoNameKey, Ht as Welcome, In as encodeSecret, It as ThreadStage, J as MirrorEntry, K as MachineConnected, Ln as hookTokenPrefix, Lt as TrackClosed, M as ConsentClient, N as ConsentProject, Nn as WrittenProject, O as ConnectionKind, Ot as SentryToken, P as CredentialView, Pn as commandLine, Pt as StatementView, Q as OwnerThreadPage, Rn as hookUrl, Rt as TrackSession, S as ConnectAgent, Tt as SecretHash, U as LiveTicket, Un as surfaceOf, V as Harness, Vn as projectParts, W as LiveTicketRequest, X as OwnerId, Y as MirrorView, Z as OwnerName, a as Api, b as ClientAccess, c as ApprovalPreview, ct as PreviewUnavailable, d as AttachmentFailed, dt as RanOf, et as OwnerTrackMessage, f as AttachmentRequestView, ft as ReadEvent, gt as RepoView, ht as RepoUrl, i as AgentView, j as ConsentAsked, jt as SocketUrl, k as ConnectionName, kt as SignInDestination, l as ApprovalState, lt as ProjectName, mt as RepoName, n as AgentPermissionChoice, nt as PasskeyCreated, o as ApiOrigin, ot as PasskeyRequestOptions, p as Authorization, q as MirrorChoice, r as AgentPermissionSetting, rt as PasskeyCreationOptions, s as ApprovalId, st as PreviewEcho, t as AgentHandle, tt as PasskeyAsserted, u as ApprovalView, ut as ProjectTrackMessage, w as ConnectableAgent, wn as WorkflowPreview, wt as ScopeAction, x as ClientGranted, zn as isRef0Path, zt as TrackThread } from "./index-Dns8tCkT.mjs";
+import { Effect, Layer, Option, Redacted, Schema, Stream } from "effect";
+import { HttpApi, HttpApiClient, HttpApiGroup, HttpApiMiddleware } from "effect/http-api";
+import { HttpBody, HttpClient } from "effect/http";
+//#region src/client/client.d.ts
+type ApiGroups = typeof Api extends HttpApi.HttpApi<infer _Id, infer Groups> ? Groups : never;
+/** The typed client for ref0's `/v1`, named because its full shape is too long to infer. */
+type Ref0Client = HttpApiClient.ForApi<typeof Api>;
+/**
+ * ref0's `/v1` as a typed client: every endpoint of the contracts' `Api`, its request encoded
+ * and its answer and errors decoded as they're declared. It needs an HTTP client and the
+ * credential it sends, a bearer token or a browser session.
+ */
+export declare const ref0Client: (origin?: ApiOrigin) => Effect.Effect<Ref0Client, never, HttpClient.HttpClient | HttpApiGroup.MiddlewareClient<ApiGroups>>;
+/** A bearer token: an agent's credential, sent with every request. */
+export declare const bearerCredential: (token: Redacted.Redacted<string>) => Layer.Layer<HttpApiMiddleware.ForClient<Authorization> | HttpApiMiddleware.ForClient<SignedIn>, never, never>;
+/** A browser session: the browser sends its cookie on ref0's own origin, so nothing is added. */
+export declare const browserCredential: Layer.Layer<HttpApiMiddleware.ForClient<Authorization> | HttpApiMiddleware.ForClient<SignedIn>, never, never>;
+/** No credential: a terminal asking its person, which sends nothing of theirs. */
+export declare const anonymousCredential: Layer.Layer<HttpApiMiddleware.ForClient<Authorization> | HttpApiMiddleware.ForClient<SignedIn>, never, never>;
+/** The platform's `fetch`, for a client in a browser or a Worker. */
+export declare const fetchTransport: Layer.Layer<HttpClient.HttpClient, never, never>;
+//#endregion
+//#region src/client/approvals.d.ts
+/**
+ * Following an approval until its command has run. Once its person says yes, ref0 runs the
+ * command as soon as it can, and again after a passing failure, so a yes can come back
+ * `approved`, or not come back at all, before the command has run. Whoever asked reads where it
+ * stands until it settles: run, refused, expired, or gone, which ref0 answers for a request that
+ * isn't the caller's or whose result's day is out. A read that fails or takes too long is read
+ * again, so following never stops on its own while the command may still run.
+ */
+/**
+ * Where an approval settles, for whoever asked, its command's endpoint named: what it ran to,
+ * read as that endpoint's answer or refusal; `unreadable`, one that isn't, such as another
+ * endpoint's; refused; expired; or gone.
+ */
+type SettledApproval<Name extends EndpointName> = {
+  readonly state: 'ran';
+  readonly status: number;
+  readonly result: RanOf<Name>;
+} | {
+  readonly state: 'unreadable';
+} | {
+  readonly state: 'refused';
+} | {
+  readonly state: 'expired';
+} | {
+  readonly state: 'gone';
+};
+/**
+ * Where an approval stands, as whoever asked for its endpoint's command reads it, if it has
+ * settled: what it ran to is read by that endpoint's schemas, so it's typed by them.
+ */
+export declare const settledOf: <Name extends EndpointName>(endpoint: Name, state: ApprovalState) => Option.Option<SettledApproval<Name>>;
+/** Where an approval for an endpoint's command settles, read again and again until it has. */
+export declare const followApproval: <Name extends EndpointName>(client: Ref0Client, approval: ApprovalId, endpoint: Name) => Effect.Effect<SettledApproval<Name>>;
+//#endregion
+//#region src/client/live.d.ts
+/**
+ * A live socket, as a page or the CLI hears it: the messages its track carries, decoded at the
+ * edge, as they come, until it closes. Opened with a one-use ticket, so the URL holds no token;
+ * anything on it that isn't one of the track's messages is dropped.
+ */
+/** What a socket opened at `url` hears, as `message` decodes it, ending when it closes. */
+export declare const liveMessages: <M>(url: SocketUrl, message: Schema.Codec<M, unknown>) => Stream.Stream<M>;
+//#endregion
+//#region src/client/request-id.d.ts
+/**
+ * A new delivery ID, for a request that changes something's `Idempotency-Key`: a UUIDv7 from the
+ * clock and ten random bytes, so a retry sends the same one and gets the first answer.
+ */
+export declare const newRequestId: Effect.Effect<`request_${string}` & import("effect/Brand").Brand<"RequestId">, never, never>;
+//#endregion
+//#region src/client/sign-in.d.ts
+/**
+ * Starts signing in with GitHub, from ref0's own pages: GitHub's address to go to, with the
+ * sign-in's state in a cookie the browser keeps. Coming back, the person lands on `welcome`, or
+ * on `failed` with what went wrong in its `error`.
+ */
+export declare const startGitHubSignIn: (landing: {
+  readonly welcome: SignInDestination;
+  readonly failed: SignInDestination;
+  readonly origin?: ApiOrigin;
+}) => Effect.Effect<string & import("effect/Brand").Brand<"NavigationUrl">, HttpBody.HttpBodyError | import("effect/http/HttpClientError").HttpClientError | Schema.SchemaError, HttpClient.HttpClient>;
+/**
+ * Signs this browser out: its session's credential revoked first, then its row, then its
+ * cookie cleared. Anything but success, such as ref0 not answering, is a failure to show: the
+ * session still works until it's done.
+ */
+export declare const signOut: (origin?: ApiOrigin) => Effect.Effect<void, import("effect/http/HttpClientError").HttpClientError, HttpClient.HttpClient>;
+//#endregion
+export { AgentHandle, type AgentPermissionChoice, type AgentPermissionSetting, type AgentView, ApiOrigin, type ApprovalId, type ApprovalPreview, type ApprovalState, type ApprovalView, AttachmentFailed, type AttachmentRequestView, ClientAccess, ClientGranted, type ConnectAgent, type ConnectChosen, type ConnectableAgent, ConnectionChanged, ConnectionKind, ConnectionName, type ConnectionView, type ConsentAsked, type ConsentClient, ConsentProject, type CredentialView, type Harness, type ImportFailure, type LiveTicket, type LiveTicketRequest, LiveTrackName, MachineConnected, type MirrorChoice, type MirrorEntry, type MirrorView, type OwnerId, OwnerName, type OwnerThreadPage, type OwnerThreadView, OwnerTrackMessage, PasskeyAsserted, PasskeyCreated, type PasskeyCreationOptions, type PasskeyRequestOptions, type PreviewEcho, PreviewUnavailable, ProjectName, ProjectTrackMessage, type ReadEvent, type Ref0Client, RepoName, RepoUrl, type RepoView, type ScopeAction, SecretHash, SentryOrg, SentryRegion, SentryToken, type SettledApproval, SignInDestination, type StatementView, ThreadId, ThreadStage, type TrackClosed, type TrackSession, type TrackThread, TypedApprovalCode, type Welcome, WorkflowPreview, WrittenProject, commandLine, connectEndpoint, encodeSecret, hookTokenPrefix, hookUrl, isRef0Path, liveSocketUrl, projectParts, repoNameKey, surfaceOf };
+//# sourceMappingURL=client.d.mts.map