@baochunli/flakes 0.0.4 → 0.0.6

package/dist/node_modules/@flakes/console/.output/server/_chunks/button.mjs

@@ -1,6 +1,464 @@
 import { c as require_jsx_runtime, i as Slot } from "../_libs/@radix-ui/react-arrow+[...].mjs";
-import { t as cva } from "../_libs/class-variance-authority+clsx.mjs";
-import { t as cn } from "./utils.mjs";
+import { t as createServerFn } from "../_libs/@tanstack/start-client-core+[...].mjs";
+import { i as useQuery, n as useMutation, o as useQueryClient, t as useInfiniteQuery } from "../_libs/tanstack__react-query.mjs";
+import { n as clsx, t as cva } from "../_libs/class-variance-authority+clsx.mjs";
+import { t as twMerge } from "../_libs/tailwind-merge.mjs";
+import { n as normalizeConsolePath } from "./paths.mjs";
+//#region src/api/server-functions.ts
+var consoleGetJson = createServerFn({ method: "GET" }).inputValidator(validatePathInput).handler(async ({ data }) => {
+	const { proxyJsonHandler } = await import("./server-runtime.mjs");
+	return proxyJsonHandler("GET", data);
+});
+var consoleGetText = createServerFn({ method: "GET" }).inputValidator(validatePathInput).handler(async ({ data }) => {
+	const { proxyTextHandler } = await import("./server-runtime.mjs");
+	return proxyTextHandler(data);
+});
+var consolePostJson = createServerFn({ method: "POST" }).inputValidator(validateJsonInput).handler(async ({ data }) => {
+	const { proxyJsonHandler } = await import("./server-runtime.mjs");
+	return proxyJsonHandler("POST", data);
+});
+var consolePutJson = createServerFn({ method: "POST" }).inputValidator(validateJsonInput).handler(async ({ data }) => {
+	const { proxyJsonHandler } = await import("./server-runtime.mjs");
+	return proxyJsonHandler("PUT", data);
+});
+var consoleDeleteJson = createServerFn({ method: "POST" }).inputValidator(validatePathInput).handler(async ({ data }) => {
+	const { proxyJsonHandler } = await import("./server-runtime.mjs");
+	return proxyJsonHandler("DELETE", data);
+});
+function validatePathInput(data) {
+	return { path: requireConsolePath(requireRecord(data, "path input").path) };
+}
+function validateJsonInput(data) {
+	const record = requireRecord(data, "json input");
+	return {
+		path: requireConsolePath(record.path),
+		...record.body === void 0 ? {} : { body: record.body }
+	};
+}
+function requireConsolePath(value) {
+	if (typeof value !== "string" || value.length === 0) throw new Error("path must be a non-empty string");
+	return normalizeConsolePath(value);
+}
+function requireRecord(value, label) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error(`${label} must be an object`);
+	return value;
+}
+//#endregion
+//#region src/api/client.ts
+/** Raised on 401/403 so views can redirect through user auth. */
+var AuthError = class extends Error {};
+/** Raised on 404 so views can render an explicit missing-resource state. */
+var NotFoundError = class extends Error {};
+/** Raised for non-auth API failures with the server-provided message. */
+var ApiError = class extends Error {
+	status;
+	details;
+	constructor(message, status, details) {
+		super(message);
+		this.status = status;
+		this.details = details;
+	}
+};
+/** GET through the TanStack Start server function layer. */
+async function apiGet(path) {
+	return unwrapResult(await consoleGetJson({ data: { path } }));
+}
+async function apiGetText(path) {
+	return unwrapResult(await consoleGetText({ data: { path } }));
+}
+/** POST JSON through the TanStack Start server function layer. */
+async function apiPost(path, body) {
+	return unwrapResult(await consolePostJson({ data: {
+		path,
+		body
+	} }));
+}
+/** PUT JSON through the TanStack Start server function layer. */
+async function apiPut(path, body) {
+	return unwrapResult(await consolePutJson({ data: {
+		path,
+		body
+	} }));
+}
+/** DELETE through the TanStack Start server function layer. */
+async function apiDelete(path) {
+	return unwrapResult(await consoleDeleteJson({ data: { path } }));
+}
+/**
+* Fetches a file through the TanStack Start server route and triggers a
+* browser download. The bearer token stays server-side in the console session.
+*/
+async function downloadFile(path, filename) {
+	const response = await fetch(`/console/api/download?path=${encodeURIComponent(path)}`);
+	if (response.status === 401 || response.status === 403) throw new AuthError(`auth failed (${response.status})`);
+	if (!response.ok) throw await apiError(response, path);
+	const blob = await response.blob();
+	const url = URL.createObjectURL(blob);
+	const anchor = document.createElement("a");
+	anchor.href = url;
+	anchor.download = filename;
+	document.body.appendChild(anchor);
+	anchor.click();
+	anchor.remove();
+	URL.revokeObjectURL(url);
+}
+async function apiError(response, path) {
+	let details;
+	let message = `${path} failed (${response.status})`;
+	try {
+		details = await response.clone().json();
+		if (isRecord$1(details) && typeof details.message === "string") message = details.message;
+		else if (isRecord$1(details) && typeof details.error === "string") message = details.error;
+	} catch {
+		try {
+			const text = await response.clone().text();
+			if (text.trim().length > 0) message = text.trim();
+		} catch {}
+	}
+	return new ApiError(message, response.status, details);
+}
+function unwrapResult(result) {
+	if (result.ok) return result.data;
+	if (result.status === 401 || result.status === 403) throw new AuthError(result.message);
+	if (result.status === 404) throw new NotFoundError(result.message);
+	throw new ApiError(result.message, result.status, result.details);
+}
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null;
+}
+//#endregion
+//#region src/lib/managed-sandbox-delete.ts
+var deletableStatuses = new Set([
+	"running",
+	"draining",
+	"stopping",
+	"stopped",
+	"failed",
+	"expired",
+	"cancelled"
+]);
+var blockerText = {
+	unsafe_status: "sandbox is not in a stale lifecycle state",
+	live_sandbox: "sandbox is live",
+	accepted_running_assignments: "sandbox has accepted running assignments",
+	provider_cleanup_required: "provider cleanup is required"
+};
+function canRequestManagedSandboxDelete(sandbox) {
+	return sandbox.sandboxStatus !== "active" && deletableStatuses.has(sandbox.status);
+}
+function managedSandboxDeleteAction(sandbox, pending, confirming) {
+	if (pending) return "pending";
+	if (!canRequestManagedSandboxDelete(sandbox)) return "hidden";
+	return confirming ? "confirm" : "request";
+}
+function applyManagedSandboxDeleteResult(sandboxes, result) {
+	if (result.status === "deleted") return sandboxes.filter((sandbox) => sandbox.sandboxId !== result.sandboxId);
+	return sandboxes.map((sandbox) => sandbox.sandboxId === result.sandboxId ? {
+		...sandbox,
+		status: "deleting"
+	} : sandbox);
+}
+function managedSandboxDeleteErrorMessage(error) {
+	if (error instanceof NotFoundError) return "Sandbox is unavailable or already deleted.";
+	if (error instanceof ApiError && error.status === 409) {
+		const blockers = deleteBlockers(error.details);
+		if (blockers.length > 0) return `Delete blocked: ${blockers.map(blockerMessage).join("; ")}.`;
+	}
+	return error instanceof Error ? error.message : "Failed to delete sandbox.";
+}
+function deleteBlockers(details) {
+	if (!isRecord(details) || !Array.isArray(details.blockers)) return [];
+	return details.blockers.filter((blocker) => typeof blocker === "string");
+}
+function blockerMessage(blocker) {
+	return blockerText[blocker] ?? blocker.replaceAll("_", " ");
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+//#endregion
+//#region src/lib/project-placement.ts
+function hostProjectWorkspaceRootPath(hostId) {
+	return `/v1/hosts/${encodeURIComponent(hostId)}/project-workspace-root`;
+}
+function hostProjectBindingsPath(hostId) {
+	return `/v1/hosts/${encodeURIComponent(hostId)}/project-bindings`;
+}
+function hostProjectBindingPath(hostId, projectKey) {
+	return `${hostProjectBindingsPath(hostId)}/${encodeURIComponent(projectKey)}`;
+}
+function hostProjectWorkspacePath(projectWorkspaceRoot, projectKey) {
+	const separator = projectWorkspaceRoot.includes("\\") && !projectWorkspaceRoot.includes("/") ? "\\" : "/";
+	return projectWorkspaceRoot.endsWith("/") || projectWorkspaceRoot.endsWith("\\") ? `${projectWorkspaceRoot}${projectKey}` : `${projectWorkspaceRoot}${separator}${projectKey}`;
+}
+function bindingValidationView(binding) {
+	if (binding === void 0) return {
+		tone: "idle",
+		label: "Not bound",
+		detail: "No host binding has been saved for this project."
+	};
+	if (binding.availability === "available") return {
+		tone: "available",
+		label: "Available",
+		detail: `Validated ${binding.lastValidatedAt ?? binding.updatedAt}.`
+	};
+	if (binding.availability === "unavailable") return {
+		tone: "unavailable",
+		label: "Unavailable",
+		detail: binding.validationReason ?? `Last rejected ${binding.lastValidatedAt ?? binding.updatedAt}.`
+	};
+	return {
+		tone: "pending",
+		label: "Pending validation",
+		detail: "Waiting for the host runtime to validate this binding."
+	};
+}
+function poolChoicesForBinding(pools, binding) {
+	const selected = new Set(binding?.poolKeys ?? []);
+	return pools.map((pool) => {
+		const status = pool.status ?? "available";
+		return {
+			poolKey: pool.poolKey,
+			selected: selected.has(pool.poolKey),
+			status,
+			statusLabel: status
+		};
+	});
+}
+//#endregion
+//#region src/api/hooks.ts
+var POLL_MS = 1e3;
+function useRuns(input) {
+	const state = typeof input === "string" ? input : input?.state;
+	const projectKey = typeof input === "string" ? void 0 : input?.projectKey;
+	return useInfiniteQuery({
+		queryKey: [
+			"runs",
+			state ?? null,
+			projectKey ?? null
+		],
+		initialPageParam: void 0,
+		queryFn: ({ pageParam }) => {
+			const params = new URLSearchParams();
+			if (state !== void 0) params.set("state", state);
+			if (projectKey !== void 0) params.set("projectKey", projectKey);
+			if (pageParam !== void 0) params.set("cursor", pageParam);
+			const query = params.toString();
+			return apiGet(`/v1/runs${query ? `?${query}` : ""}`);
+		},
+		getNextPageParam: (lastPage) => lastPage.nextCursor,
+		maxPages: 10,
+		refetchInterval: POLL_MS
+	});
+}
+function useProjects() {
+	return useQuery({
+		queryKey: ["projects"],
+		queryFn: () => apiGet("/v1/projects"),
+		refetchInterval: POLL_MS
+	});
+}
+function useHosts() {
+	return useQuery({
+		queryKey: ["hosts"],
+		queryFn: () => apiGet("/v1/hosts"),
+		refetchInterval: POLL_MS
+	});
+}
+function useHostPools(hostId) {
+	return useQuery({
+		queryKey: ["host-pools", hostId],
+		enabled: hostId !== null,
+		queryFn: () => apiGet(`/v1/hosts/${encodeURIComponent(requireHostId(hostId, "useHostPools"))}/pools`),
+		refetchInterval: POLL_MS
+	});
+}
+function useSandboxFleet() {
+	return useQuery({
+		queryKey: ["sandbox-fleet"],
+		queryFn: () => apiGet("/v1/sandboxes"),
+		refetchInterval: POLL_MS
+	});
+}
+function useDeleteManagedSandbox() {
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: (sandboxId) => apiDelete(`/v1/sandboxes/${encodeURIComponent(sandboxId)}`),
+		onSuccess: async (result) => {
+			queryClient.setQueryData(["sandbox-fleet"], (current) => current ? { sandboxes: applyManagedSandboxDeleteResult(current.sandboxes, result) } : current);
+			if (result.status === "deleted") queryClient.removeQueries({ queryKey: ["managed-sandbox", result.sandboxId] });
+			await Promise.all([queryClient.invalidateQueries({ queryKey: ["sandbox-fleet"] }), queryClient.invalidateQueries({ queryKey: ["managed-sandbox", result.sandboxId] })]);
+		}
+	});
+}
+function useHostProjectBindings(hostId, enabled = true) {
+	return useQuery({
+		queryKey: ["host-project-bindings", hostId],
+		enabled: hostId !== null && enabled,
+		queryFn: () => apiGet(hostProjectBindingsPath(requireHostId(hostId, "useHostProjectBindings"))),
+		refetchInterval: POLL_MS
+	});
+}
+function useSetHostProjectWorkspaceRoot() {
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: (input) => apiPut(hostProjectWorkspaceRootPath(input.hostId), { path: input.path }),
+		onSuccess: async (root) => {
+			await Promise.all([queryClient.invalidateQueries({ queryKey: ["hosts"] }), queryClient.invalidateQueries({ queryKey: ["host-project-bindings", root.hostId] })]);
+		}
+	});
+}
+function useUpsertHostProjectBinding() {
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: (input) => apiPut(hostProjectBindingPath(input.hostId, input.projectKey), { poolKeys: input.poolKeys }),
+		onSuccess: async (_binding, input) => {
+			await queryClient.invalidateQueries({ queryKey: ["host-project-bindings", input.hostId] });
+		}
+	});
+}
+function useRun(runId) {
+	return useQuery({
+		queryKey: ["run", runId],
+		queryFn: () => apiGet(`/v1/runs/${encodeURIComponent(runId)}`),
+		refetchInterval: POLL_MS
+	});
+}
+function useRunTasks(runId) {
+	return useQuery({
+		queryKey: ["run-tasks", runId],
+		queryFn: () => apiGet(`/v1/runs/${encodeURIComponent(runId)}/tasks`),
+		refetchInterval: POLL_MS
+	});
+}
+function useRunArtifacts(runId) {
+	return useQuery({
+		queryKey: ["run-artifacts", runId],
+		queryFn: () => apiGet(`/v1/runs/${encodeURIComponent(runId)}/artifacts`),
+		refetchInterval: POLL_MS
+	});
+}
+function useRunMetrics(runId) {
+	return useQuery({
+		queryKey: ["run-metrics", runId],
+		queryFn: () => apiGet(`/v1/runs/${encodeURIComponent(runId)}/metrics`),
+		refetchInterval: POLL_MS
+	});
+}
+function useRunFileReservations(runId) {
+	return useQuery({
+		queryKey: ["run-file-reservations", runId],
+		queryFn: () => apiGet(`/v1/runs/${encodeURIComponent(runId)}/file-reservations`),
+		refetchInterval: POLL_MS
+	});
+}
+function useDeleteRun() {
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: (runId) => apiDelete(`/v1/runs/${encodeURIComponent(runId)}`),
+		onSuccess: async (_data, runId) => {
+			queryClient.removeQueries({ queryKey: ["run", runId] });
+			queryClient.removeQueries({ queryKey: ["run-tasks", runId] });
+			queryClient.removeQueries({ queryKey: ["run-artifacts", runId] });
+			queryClient.removeQueries({ queryKey: ["run-metrics", runId] });
+			queryClient.removeQueries({ queryKey: ["run-file-reservations", runId] });
+			await queryClient.invalidateQueries({ queryKey: ["runs"] });
+		}
+	});
+}
+function useTaskPiSession(taskId, poll) {
+	return useQuery({
+		queryKey: ["task-pi-session", taskId],
+		enabled: taskId !== null,
+		queryFn: async () => {
+			const id = requireTaskId(taskId, "useTaskPiSession");
+			try {
+				return await apiGet(`/v1/tasks/${encodeURIComponent(id)}/pi-session`);
+			} catch (error) {
+				if (error instanceof NotFoundError) return null;
+				throw error;
+			}
+		},
+		refetchInterval: poll ? POLL_MS : false
+	});
+}
+function useTaskPiSessionRaw(taskId, enabled, poll) {
+	return useQuery({
+		queryKey: ["task-pi-session-raw", taskId],
+		enabled: taskId !== null && enabled,
+		queryFn: async () => {
+			const id = requireTaskId(taskId, "useTaskPiSessionRaw");
+			try {
+				return await apiGetText(`/v1/tasks/${encodeURIComponent(id)}/pi-session?format=raw`);
+			} catch (error) {
+				if (error instanceof NotFoundError) return null;
+				throw error;
+			}
+		},
+		refetchInterval: poll ? POLL_MS : false
+	});
+}
+function useSendTaskMessage(taskId) {
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: (input) => {
+			const id = requireTaskId(taskId, "useSendTaskMessage");
+			return apiPost(`/v1/tasks/${encodeURIComponent(id)}/messages`, input);
+		},
+		onSuccess: async () => {
+			await queryClient.invalidateQueries({ queryKey: ["task-pi-session", taskId] });
+			await queryClient.invalidateQueries({ queryKey: ["task-pi-session-raw", taskId] });
+			await queryClient.invalidateQueries({ queryKey: ["task-activity", taskId] });
+		}
+	});
+}
+function useTaskWorkpad(taskId, poll) {
+	return useQuery({
+		queryKey: ["task-workpad", taskId],
+		enabled: taskId !== null,
+		queryFn: () => apiGet(`/v1/tasks/${encodeURIComponent(requireTaskId(taskId, "useTaskWorkpad"))}/workpad`),
+		refetchInterval: poll ? POLL_MS : false
+	});
+}
+function useSaveTaskWorkpad(taskId) {
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: (input) => {
+			const id = requireTaskId(taskId, "useSaveTaskWorkpad");
+			return apiPut(`/v1/tasks/${encodeURIComponent(id)}/workpad`, input);
+		},
+		onSuccess: async (workpad) => {
+			queryClient.setQueryData(["task-workpad", taskId], workpad);
+			await queryClient.invalidateQueries({ queryKey: ["run-tasks", workpad.runId] });
+			await queryClient.invalidateQueries({ queryKey: ["task-activity", taskId] });
+		},
+		onSettled: async () => {
+			await queryClient.invalidateQueries({ queryKey: ["task-workpad", taskId] });
+		}
+	});
+}
+function useTaskActivity(taskId, poll) {
+	return useQuery({
+		queryKey: ["task-activity", taskId],
+		enabled: taskId !== null,
+		queryFn: () => apiGet(`/v1/tasks/${encodeURIComponent(requireTaskId(taskId, "useTaskActivity"))}/activity?limit=20`),
+		refetchInterval: poll ? POLL_MS : false
+	});
+}
+function requireTaskId(taskId, hookName) {
+	if (taskId === null) throw new Error(`${hookName} called without taskId`);
+	return taskId;
+}
+function requireHostId(hostId, hookName) {
+	if (hostId === null) throw new Error(`${hookName} called without hostId`);
+	return hostId;
+}
+//#endregion
+//#region src/lib/utils.ts
+function cn(...inputs) {
+	return twMerge(clsx(inputs));
+}
+//#endregion
 //#region src/components/ui/button.tsx
 var import_jsx_runtime = require_jsx_runtime();
 var buttonVariants = cva("inline-flex shrink-0 items-center justify-center gap-2 rounded-md text-sm font-medium whitespace-nowrap transition-all outline-none focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50 disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4", {
@@ -43,4 +501,4 @@ function Button({ className, variant = "default", size = "default", asChild = fa
 	});
 }
 //#endregion
-export { Button as t };
+export { downloadFile as A, useUpsertHostProjectBinding as C, managedSandboxDeleteAction as D, poolChoicesForBinding as E, managedSandboxDeleteErrorMessage as O, useTaskWorkpad as S, hostProjectWorkspacePath as T, useSendTaskMessage as _, useHostPools as a, useTaskPiSession as b, useProjects as c, useRunFileReservations as d, useRunMetrics as f, useSaveTaskWorkpad as g, useSandboxFleet as h, useDeleteRun as i, ApiError as k, useRun as l, useRuns as m, cn as n, useHostProjectBindings as o, useRunTasks as p, useDeleteManagedSandbox as r, useHosts as s, Button as t, useRunArtifacts as u, useSetHostProjectWorkspaceRoot as v, bindingValidationView as w, useTaskPiSessionRaw as x, useTaskActivity as y };

package/dist/node_modules/@flakes/console/.output/server/_chunks/card.mjs

@@ -1,5 +1,5 @@
 import { c as require_jsx_runtime } from "../_libs/@radix-ui/react-arrow+[...].mjs";
-import { t as cn } from "./utils.mjs";
+import { n as cn } from "./button.mjs";
 //#region src/components/ui/card.tsx
 var import_jsx_runtime = require_jsx_runtime();
 function Card({ className, ...props }) {

package/dist/node_modules/@flakes/console/.output/server/_chunks/project-navigation.mjs

@@ -0,0 +1,79 @@
+//#region src/lib/project-navigation.ts
+function splitProjectsByStatus(projects) {
+	const active = [];
+	const archived = [];
+	for (const project of projects) if (project.status === "archived") archived.push(project);
+	else active.push(project);
+	return {
+		active: sortProjects(active),
+		archived: sortProjects(archived)
+	};
+}
+function groupRunsByProject(projects, runs) {
+	const byProjectId = new Map(projects.map((project) => [project.projectId, project]));
+	const byProjectKey = new Map(projects.map((project) => [project.projectKey, project]));
+	const grouped = /* @__PURE__ */ new Map();
+	const unknown = /* @__PURE__ */ new Map();
+	const inbox = [];
+	for (const run of runs) {
+		const project = projectForRun(run, byProjectId, byProjectKey);
+		if (project !== null) {
+			const list = grouped.get(project.projectId) ?? [];
+			list.push(run);
+			grouped.set(project.projectId, list);
+			continue;
+		}
+		const unknownIdentity = run.projectId ?? run.projectKey;
+		if (unknownIdentity !== void 0 && unknownIdentity.length > 0) {
+			const id = `unknown:${unknownIdentity}`;
+			const group = unknown.get(id) ?? {
+				id,
+				label: run.projectKey ?? run.projectId ?? "Unknown project",
+				project: null,
+				runs: []
+			};
+			group.runs.push(run);
+			unknown.set(id, group);
+			continue;
+		}
+		inbox.push(run);
+	}
+	const groups = [];
+	const { active, archived } = splitProjectsByStatus(projects);
+	for (const project of [...active, ...archived]) {
+		const projectRuns = grouped.get(project.projectId);
+		if (projectRuns !== void 0 && projectRuns.length > 0) groups.push({
+			id: `project:${project.projectId}`,
+			label: project.name,
+			project,
+			runs: projectRuns
+		});
+	}
+	groups.push(...[...unknown.values()].sort((left, right) => left.label.localeCompare(right.label)));
+	if (inbox.length > 0) groups.push({
+		id: "inbox",
+		label: "Inbox",
+		project: null,
+		runs: inbox
+	});
+	return groups;
+}
+function projectMatchesRun(project, run) {
+	if (run.projectId !== void 0) return run.projectId === project.projectId;
+	return run.projectKey === project.projectKey;
+}
+function projectLabelForRun(projects, run) {
+	const project = projectForRun(run, new Map(projects.map((entry) => [entry.projectId, entry])), new Map(projects.map((entry) => [entry.projectKey, entry])));
+	if (project !== null) return `${project.name} (${project.projectKey})`;
+	return run.projectKey ?? run.projectId;
+}
+function projectForRun(run, byProjectId, byProjectKey) {
+	if (run.projectId !== void 0) return byProjectId.get(run.projectId) ?? null;
+	if (run.projectKey !== void 0) return byProjectKey.get(run.projectKey) ?? null;
+	return null;
+}
+function sortProjects(projects) {
+	return projects.sort((left, right) => left.projectKey.localeCompare(right.projectKey));
+}
+//#endregion
+export { splitProjectsByStatus as i, projectLabelForRun as n, projectMatchesRun as r, groupRunsByProject as t };