@dev.fast/whiteboard 0.0.0-stage → 0.2.0

package/dist/sharing/index.js

@@ -0,0 +1,2 @@
+import { a as sharedReviewId, c as verifyShareRepository, i as SharedReviewStore, l as exportShare, n as ShareClient, o as validateShareBundle } from "../client-DFoh50W3.js";
+export { ShareClient, SharedReviewStore, exportShare, sharedReviewId, validateShareBundle, verifyShareRepository };

package/dist/src-CGP5ytbV.js

@@ -0,0 +1,283 @@
+import { z } from "zod";
+//#region ../trace-protocol/src/contracts.ts
+const sessionIdSchema = z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{7,127}$/);
+const commitShaSchema = z.string().regex(/^[0-9a-f]{40,64}$/);
+const byCommitSchema = z.object({
+	commit: commitShaSchema,
+	sessions: z.array(sessionIdSchema),
+	repo: z.string(),
+	pr: z.number().int().nullable(),
+	branch: z.string().nullable(),
+	indexed_by: z.enum(["hook", "ci"]),
+	ts: z.string()
+});
+const sessionMetaSchema = z.object({
+	session: sessionIdSchema,
+	repo: z.string().nullable(),
+	branch: z.string().nullable(),
+	pr: z.number().int().nullable(),
+	commits: z.array(commitShaSchema),
+	author: z.string().nullable(),
+	ts: z.string()
+});
+const nonBlankString = z.string({ error: "must be a string" }).refine((value) => value.trim().length > 0, "must be a string");
+const anyString = z.string({ error: "must be a string" });
+const ReviewAgentTraceEventSchema = z.discriminatedUnion("kind", [
+	z.strictObject({
+		kind: z.literal("user"),
+		text: anyString,
+		at: z.string().optional()
+	}),
+	z.strictObject({
+		kind: z.literal("assistant"),
+		markdown: anyString,
+		thinking: z.boolean().optional(),
+		at: z.string().optional()
+	}),
+	z.strictObject({
+		kind: z.literal("tool"),
+		tool: nonBlankString,
+		verb: nonBlankString,
+		title: anyString,
+		filePath: z.string().optional(),
+		additions: z.number().optional(),
+		deletions: z.number().optional(),
+		command: z.string().optional(),
+		input: z.string().optional(),
+		output: z.string().optional(),
+		error: z.boolean().optional(),
+		at: z.string().optional()
+	}),
+	z.strictObject({
+		kind: z.literal("separator"),
+		label: nonBlankString
+	})
+]);
+const ReviewAgentTraceSessionSchema = z.strictObject({
+	sessionId: nonBlankString,
+	title: z.string().optional(),
+	harness: z.enum([
+		"claude-code",
+		"codex",
+		"opencode",
+		"pi",
+		"unknown"
+	]),
+	available: z.boolean(),
+	source: z.enum(["r2"]).nullable(),
+	notSynced: z.boolean().optional(),
+	subagents: z.array(nonBlankString).optional(),
+	commits: z.array(z.strictObject({
+		sha: nonBlankString,
+		subject: anyString
+	}))
+});
+//#endregion
+//#region ../trace-protocol/src/store-api.ts
+const TRACE_STORE_API_PREFIX = "/api/trace/v1";
+const TRACE_STORE_CLIENT_ID = "review-cli";
+/** Largest single trace object the store accepts. */
+const MAX_TRACE_OBJECT_BYTES = 268435456;
+const nameSegment = z.string().regex(/^[A-Za-z0-9_.-]{1,100}$/);
+/** A branch or author label a client attaches to a publication. */
+const sessionLabelSchema = z.string().max(200).nullable();
+const traceHarnessSchema = z.enum([
+	"claude",
+	"codex",
+	"opencode",
+	"pi"
+]);
+const traceObjectNameSchema = z.string().regex(/^(main\.jsonl\.gz|subagents\/[A-Za-z0-9_.-]{1,100}\.jsonl\.gz)$/);
+const sha256HexSchema = z.string().regex(/^[0-9a-f]{64}$/);
+/**
+* A store instance or an upload. The server mints one per onboarding and one
+* per begin call; neither value is ever reused.
+*/
+const storeIdSchema = z.string().regex(/^[0-9a-f]{32}$/);
+const uploadIdSchema = storeIdSchema;
+z.object({
+	owner: nameSegment,
+	name: nameSegment
+});
+const storeResponseSchema = z.object({
+	repositoryId: z.number().int().positive(),
+	/** The current store instance. Deleting a store retires its id. */
+	storeId: storeIdSchema,
+	displayName: z.string(),
+	status: z.enum(["active", "deleting"]),
+	createdAt: z.string(),
+	created: z.boolean().optional(),
+	/** Bytes of every completed upload in this store instance. Absent from older servers. */
+	bytesStored: z.number().int().nonnegative().optional()
+});
+/**
+* Deletion is logical. The store stops every read and write at once; an
+* operator removes the objects later, after outstanding URLs expire.
+*/
+const deleteStoreResponseSchema = z.object({
+	repositoryId: z.number().int().positive(),
+	storeId: storeIdSchema,
+	status: z.literal("deleting"),
+	deletedAt: z.string()
+});
+const declaredObjectSchema = z.object({
+	name: traceObjectNameSchema,
+	size: z.number().int().positive().max(MAX_TRACE_OBJECT_BYTES),
+	sha256: sha256HexSchema
+});
+/** The complete object set of one upload. Names are unique. */
+const uploadManifestSchema = z.array(declaredObjectSchema).min(1).max(64).superRefine((objects, context) => {
+	const seen = /* @__PURE__ */ new Set();
+	let total = 0;
+	for (const object of objects) {
+		if (seen.has(object.name)) context.addIssue({
+			code: "custom",
+			message: `Object ${object.name} is declared twice.`
+		});
+		seen.add(object.name);
+		total += object.size;
+	}
+	if (total > 1073741824) context.addIssue({
+		code: "custom",
+		message: "Declared upload exceeds the session limit."
+	});
+});
+z.object({
+	harness: traceHarnessSchema,
+	objects: uploadManifestSchema
+});
+const presignedUploadSchema = z.object({
+	name: traceObjectNameSchema,
+	url: z.string().url(),
+	headers: z.record(z.string(), z.string()),
+	expiresAt: z.string()
+});
+const beginUploadResponseSchema = z.object({
+	/** Names this upload in every later call. */
+	uploadId: uploadIdSchema,
+	storeId: storeIdSchema,
+	/**
+	* The session generation this upload replaces. Zero means the session has
+	* no published upload. Completion fails with `stale_upload` when another
+	* upload publishes first.
+	*/
+	baseGeneration: z.number().int().nonnegative(),
+	uploads: z.array(presignedUploadSchema)
+});
+z.object({
+	commits: z.array(commitShaSchema).max(200).default([]).refine((commits) => new Set(commits).size === commits.length, { message: "A commit is listed twice." }),
+	/** The checkout branch and author at publication, kept with the upload. */
+	branch: sessionLabelSchema.optional(),
+	author: sessionLabelSchema.optional()
+});
+const storedObjectSchema = z.object({
+	name: traceObjectNameSchema,
+	size: z.number().int().nonnegative(),
+	sha256: sha256HexSchema
+});
+/**
+* The receipt of one completed upload. Repeating a completion returns the
+* same receipt; it never moves the session to an older upload.
+*/
+const completeUploadResponseSchema = z.object({
+	sessionId: sessionIdSchema,
+	uploadId: uploadIdSchema,
+	generation: z.number().int().positive(),
+	objects: z.array(storedObjectSchema),
+	commits: z.array(commitShaSchema)
+});
+z.object({
+	commit: commitShaSchema.optional(),
+	session: sessionIdSchema.optional(),
+	/** Page size; the server caps it at MAX_TRACE_SESSIONS_PAGE. */
+	limit: z.coerce.number().int().min(1).max(200).optional(),
+	/** The last session id of the previous page. */
+	cursor: sessionIdSchema.optional()
+});
+const sessionDownloadSchema = z.object({
+	sessionId: sessionIdSchema,
+	harness: traceHarnessSchema,
+	/** The published upload. Clients key caches by it and by each checksum. */
+	uploadId: uploadIdSchema,
+	generation: z.number().int().positive(),
+	updatedAt: z.string(),
+	commits: z.array(commitShaSchema),
+	branch: sessionLabelSchema.optional(),
+	author: sessionLabelSchema.optional(),
+	objects: z.array(storedObjectSchema.extend({
+		url: z.string().url(),
+		expiresAt: z.string()
+	}))
+});
+const listSessionsResponseSchema = z.object({
+	sessions: z.array(sessionDownloadSchema),
+	/** Present when another page follows; pass it back as `cursor`. */
+	nextCursor: sessionIdSchema.optional()
+});
+/** Operational receipts only. The server always filters by authenticated creator. */
+const listUploadsQuerySchema = z.object({
+	session: sessionIdSchema.optional(),
+	limit: z.coerce.number().int().min(1).max(200).optional(),
+	cursor: z.string().min(1).max(2048).optional()
+}).strict();
+const uploadStatusSchema = z.object({
+	sessionId: sessionIdSchema,
+	uploadId: uploadIdSchema,
+	createdAt: z.string().datetime(),
+	completedAt: z.string().datetime().nullable(),
+	status: z.enum(["pending", "complete"]),
+	current: z.boolean()
+});
+const listUploadsResponseSchema = z.object({
+	storeId: storeIdSchema,
+	uploads: z.array(uploadStatusSchema),
+	nextCursor: z.string().optional()
+});
+const storeErrorCodeSchema = z.enum([
+	"unauthorized",
+	"repository_authorization_required",
+	"forbidden",
+	"not_found",
+	"invalid_request",
+	"payload_too_large",
+	"github_unavailable",
+	"upload_incomplete",
+	"stale_upload",
+	"store_deleted",
+	"upgrade_required",
+	"internal"
+]);
+const storeErrorEnvelopeSchema = z.object({ error: z.object({
+	code: storeErrorCodeSchema,
+	message: z.string()
+}) });
+/**
+* Why a begin response does not match the manifest it answers, or null when
+* every declared object has exactly one presigned upload and nothing else.
+*/
+function uploadManifestMismatch(manifest, uploads) {
+	const declared = new Set(manifest.map((object) => object.name));
+	const seen = /* @__PURE__ */ new Set();
+	for (const upload of uploads) {
+		if (!declared.has(upload.name)) return `The store offered an upload this session did not declare: ${upload.name}.`;
+		if (seen.has(upload.name)) return `The store offered ${upload.name} twice.`;
+		seen.add(upload.name);
+	}
+	for (const name of declared) if (!seen.has(name)) return `The store offered no upload for ${name}.`;
+	return null;
+}
+//#endregion
+//#region ../trace-protocol/src/store-routes.ts
+const DEVICE_CODE_PATH = "/api/auth/device/code";
+const DEVICE_TOKEN_PATH = "/api/auth/device/token";
+const SESSION_PATH = "/api/auth/get-session";
+const storeRoutes = {
+	ownUploads: (repositoryId) => `${TRACE_STORE_API_PREFIX}/stores/${repositoryId}/uploads`,
+	stores: () => `${TRACE_STORE_API_PREFIX}/stores`,
+	store: (repositoryId) => `${TRACE_STORE_API_PREFIX}/stores/${repositoryId}`,
+	sessions: (repositoryId) => `${TRACE_STORE_API_PREFIX}/stores/${repositoryId}/sessions`,
+	uploads: (repositoryId, sessionId) => `${TRACE_STORE_API_PREFIX}/stores/${repositoryId}/sessions/${encodeURIComponent(sessionId)}/uploads`,
+	uploadComplete: (repositoryId, sessionId, uploadId) => `${storeRoutes.uploads(repositoryId, sessionId)}/${encodeURIComponent(uploadId)}/complete`
+};
+//#endregion
+export { sessionMetaSchema as S, ReviewAgentTraceEventSchema as _, TRACE_STORE_CLIENT_ID as a, commitShaSchema as b, deleteStoreResponseSchema as c, listUploadsResponseSchema as d, storeErrorCodeSchema as f, uploadManifestMismatch as g, traceObjectNameSchema as h, storeRoutes as i, listSessionsResponseSchema as l, storeResponseSchema as m, DEVICE_TOKEN_PATH as n, beginUploadResponseSchema as o, storeErrorEnvelopeSchema as p, SESSION_PATH as r, completeUploadResponseSchema as s, DEVICE_CODE_PATH as t, listUploadsQuerySchema as u, ReviewAgentTraceSessionSchema as v, sessionIdSchema as x, byCommitSchema as y };