A desktop coding agent with free access to frontier models.
TypeScript
import type { DenCloudInstance, DenCloudStartupFailure } from "@/app/lib/den";
export function cloudWorkspaceFailureLogFields(failure: DenCloudStartupFailure) {
return {
failure_code: failure.code,
failure_stage: failure.stage,
failure_reference: failure.reference,
failure_occurred_at: failure.occurredAt,
};
}
export type CloudWorkspacePillVariant =
| "ready"
| "stale"
| "waking"
| "provisioning"
| "updating"
| "access-required"
| "unavailable"
| "failed";
export type CloudWorkspaceViewModel = {
variant: CloudWorkspacePillVariant;
label: string;
tone: "neutral" | "amber";
statusLine: string;
computerLine: string | null;
versionLine: string;
latestLine: string;
backupsLine: string;
updateAvailable: boolean;
showUpdate: boolean;
showRetry: boolean;
pollMs: number | null;
};
export type CloudWorkspaceMainContentDecision = "takeover" | "error" | "content";
export type CloudWorkspaceBootStageState = "done" | "active" | "pending";
export type CloudWorkspaceBootStage = {
id: string;
label: string;
state: CloudWorkspaceBootStageState;
};
/**
* Boot progress is derived from the status we already poll rather than from a
* timer, so the ladder can never claim more progress than we can prove. Each
* variant tells us which checkpoint the sandbox is standing on: a provisioning
* sandbox is still being reserved, while a waking or updating one demonstrably
* exists already.
*/
const BOOT_STAGES: Partial<
Record<CloudWorkspacePillVariant, { labels: readonly [string, string, string]; activeIndex: number }>
> = {
provisioning: {
labels: ["Reserving your computer", "Restoring your files", "Connecting the app"],
activeIndex: 0,
},
waking: {
labels: ["Reserving your computer", "Restoring your files", "Connecting the app"],
activeIndex: 1,
},
updating: {
labels: ["Saving your session", "Applying the latest image", "Reconnecting the app"],
activeIndex: 1,
},
};
export function cloudWorkspaceBootStages(variant: CloudWorkspacePillVariant): CloudWorkspaceBootStage[] {
const stages = BOOT_STAGES[variant];
if (!stages) return [];
return stages.labels.map((label, index) => ({
id: `${variant}-${index}`,
label,
state: index < stages.activeIndex ? "done" : index === stages.activeIndex ? "active" : "pending",
}));
}
/** Past this point "usually under a minute" stops being true, so the copy and the actions change. */
export const CLOUD_WORKSPACE_SLOW_BOOT_MS = 45_000;
export function cloudWorkspaceBootIsSlow(elapsedMs: number): boolean {
return elapsedMs >= CLOUD_WORKSPACE_SLOW_BOOT_MS;
}
export function formatCloudWorkspaceElapsed(elapsedMs: number): string {
const totalSeconds = Math.max(0, Math.floor(elapsedMs / 1000));
if (totalSeconds < 60) return `${totalSeconds}s elapsed`;
const minutes = Math.floor(totalSeconds / 60);
const seconds = totalSeconds % 60;
return `${minutes}m ${seconds.toString().padStart(2, "0")}s elapsed`;
}
export function cloudWorkspaceTakeoverCopy(input: {
variant: CloudWorkspacePillVariant;
slow: boolean;
}): { title: string; body: string } {
if (input.variant === "access-required") {
return {
title: "omnirush.ai Web needs an active plan",
body: "Your organization does not have an active omnirush.ai Web subscription or complimentary access. Get omnirush.ai Web in Den to start your cloud workspace.",
};
}
if (input.variant === "failed") {
return {
title: "Workspace needs attention",
body: "We couldn’t start the sandbox. Retry, or sign out and reconnect.",
};
}
if (input.variant === "unavailable") {
return {
title: "Couldn’t check your workspace",
body: "omnirush.ai Cloud didn’t answer. Your sandbox may still be running, so try checking again.",
};
}
if (input.slow) {
return {
title: "Still working on it…",
body: "This is taking longer than usual. You can keep waiting or check again.",
};
}
if (input.variant === "provisioning") {
return {
title: "Starting your workspace…",
body: "Usually under a minute. We’ll open it the moment it’s ready.",
};
}
if (input.variant === "updating") {
return {
title: "Updating your workspace…",
body: "We’re applying the latest omnirush.ai image. Your files and sessions come along.",
};
}
return {
title: "Waking your workspace…",
body: "Your sandbox is coming back online. We’ll open it as soon as it’s ready.",
};
}
export function formatCloudWorkspaceVersion(version: string | null): string | null {
const trimmed = version?.trim() ?? "";
if (!trimmed) return null;
const omnirushPrefix = "omnirush-";
if (!trimmed.toLowerCase().startsWith(omnirushPrefix)) return trimmed;
const withoutPrefix = trimmed.slice(omnirushPrefix.length);
return withoutPrefix.toLowerCase().startsWith("v") ? withoutPrefix : `v${withoutPrefix}`;
}
export function cloudWorkspaceUpdateAvailable(instance: DenCloudInstance | null): boolean {
if (!instance?.latestVersion) return false;
return instance.imageVersion === null || instance.imageVersion !== instance.latestVersion;
}
// Stopped instances already recycle on wake; this only nudges running stale instances,
// skips while any client-visible run is active, and attempts once per target version so
// failed or already_current attempts cannot retry-loop.
export function shouldAutoUpdateCloudWorkspace(input: {
gatewayMode: boolean;
visible: boolean;
status: "provisioning" | "waking" | "ready" | "failed" | null;
updateAvailable: boolean;
updating: boolean;
requestFailed: boolean;
hasActiveRun: boolean;
latestVersion: string | null;
lastAttemptedVersion: string | null;
}): boolean {
return input.gatewayMode
&& input.visible
&& input.status === "ready"
&& input.updateAvailable
&& !input.updating
&& !input.requestFailed
&& !input.hasActiveRun
&& input.latestVersion !== null
&& input.latestVersion !== input.lastAttemptedVersion;
}
export function cloudWorkspaceStatusHasReadyContent(variant: CloudWorkspacePillVariant): boolean {
return variant === "ready" || variant === "stale";
}
/**
* Gateway boot is owned by the workspace takeover. Showing the generic overlay
* at the same time stacks two wait indicators on first load.
*/
export function shouldSuppressBootOverlayForGateway(input: {
gatewayMode: boolean;
signedIn: boolean;
variant: CloudWorkspacePillVariant;
}): boolean {
return input.gatewayMode && input.signedIn && !cloudWorkspaceStatusHasReadyContent(input.variant);
}
export function shouldShowCloudWorkspaceStatusPill(input: {
variant: CloudWorkspacePillVariant;
hasInstance: boolean;
requestFailed: boolean;
}): boolean {
if (!input.hasInstance && !input.requestFailed) return false;
return input.variant === "waking"
|| input.variant === "provisioning"
|| input.variant === "unavailable"
|| input.variant === "failed";
}
export function mapCloudWorkspaceMainContentDecision(input: {
status: CloudWorkspacePillVariant;
hasWorkspaces: boolean;
gatewayMode: boolean;
}): CloudWorkspaceMainContentDecision {
if (!input.gatewayMode) return "content";
if (input.status === "failed" || input.status === "access-required") return "takeover";
if (!cloudWorkspaceStatusHasReadyContent(input.status)) {
return input.hasWorkspaces ? "content" : "takeover";
}
return input.hasWorkspaces ? "content" : "error";
}
export function shouldRefetchCloudWorkspaceOnReadyTransition(input: {
previousStatus: CloudWorkspacePillVariant | null;
nextStatus: CloudWorkspacePillVariant;
gatewayMode: boolean;
}): boolean {
if (!input.gatewayMode || input.previousStatus === null) return false;
if (cloudWorkspaceStatusHasReadyContent(input.previousStatus)) return false;
return cloudWorkspaceStatusHasReadyContent(input.nextStatus);
}
function versionDisplay(instance: DenCloudInstance | null) {
return formatCloudWorkspaceVersion(instance?.imageVersion ?? null) ?? "Legacy workspace";
}
function latestDisplay(instance: DenCloudInstance | null) {
return formatCloudWorkspaceVersion(instance?.latestVersion ?? null) ?? "Not available";
}
function connectedStatusLine(instance: DenCloudInstance, updateAvailable: boolean) {
const version = formatCloudWorkspaceVersion(instance.imageVersion) ?? "legacy workspace";
const latest = formatCloudWorkspaceVersion(instance.latestVersion);
if (updateAvailable) return latest ? `Connected · ${version} -> ${latest}` : `Connected · ${version}`;
return `Connected · ${version} (latest)`;
}
function baseLines(instance: DenCloudInstance | null, updateAvailable: boolean) {
const version = versionDisplay(instance);
const latest = latestDisplay(instance);
const latestSuffix = !updateAvailable && instance?.latestVersion ? " (up to date)" : "";
const instanceName = instance?.instanceName?.trim() ?? "";
return {
computerLine: instanceName ? `Computer: ${instanceName}` : null,
versionLine: `Version: ${version}`,
latestLine: `Latest: ${latest}${latestSuffix}`,
backupsLine: "Backups on",
};
}
export function mapCloudWorkspaceState(input: {
instance: DenCloudInstance | null;
updating: boolean;
accessRequired: boolean;
requestFailed?: boolean;
}): CloudWorkspaceViewModel {
const updateAvailable = cloudWorkspaceUpdateAvailable(input.instance);
const lines = baseLines(input.instance, updateAvailable);
if (input.accessRequired) {
return {
variant: "access-required",
label: "omnirush.ai Web plan required",
tone: "amber",
statusLine: "omnirush.ai Web plan required",
...lines,
updateAvailable,
showUpdate: false,
showRetry: true,
pollMs: null,
};
}
if (input.requestFailed) {
return {
variant: "unavailable",
label: "Couldn’t check workspace",
tone: "amber",
statusLine: "Couldn’t check workspace status",
...lines,
updateAvailable,
showUpdate: false,
showRetry: true,
pollMs: 5_000,
};
}
if (input.instance?.status === "failed") {
return {
variant: "failed",
label: "Workspace needs attention",
tone: "amber",
statusLine: "Workspace needs attention",
...lines,
updateAvailable,
showUpdate: false,
showRetry: true,
pollMs: 5_000,
};
}
if (input.updating) {
return {
variant: "updating",
label: "Updating your workspace…",
tone: "neutral",
statusLine: "Updating your workspace…",
...lines,
updateAvailable,
showUpdate: false,
showRetry: false,
pollMs: 5_000,
};
}
if (!input.instance || input.instance.status === "waking") {
return {
variant: "waking",
label: "Waking your workspace…",
tone: "neutral",
statusLine: "Waking your workspace…",
...lines,
updateAvailable,
showUpdate: false,
showRetry: false,
pollMs: 5_000,
};
}
if (input.instance.status === "provisioning") {
return {
variant: "provisioning",
label: "Provisioning your workspace…",
tone: "neutral",
statusLine: "Provisioning your workspace…",
...lines,
updateAvailable,
showUpdate: false,
showRetry: false,
pollMs: 5_000,
};
}
if (updateAvailable) {
return {
variant: "stale",
label: "Update available",
tone: "neutral",
statusLine: connectedStatusLine(input.instance, true),
...lines,
updateAvailable,
showUpdate: true,
showRetry: false,
pollMs: 60_000,
};
}
const version = formatCloudWorkspaceVersion(input.instance.imageVersion) ?? formatCloudWorkspaceVersion(input.instance.latestVersion);
return {
variant: "ready",
label: version ? `Cloud · ${version}` : "Cloud",
tone: "neutral",
statusLine: connectedStatusLine(input.instance, false),
...lines,
updateAvailable,
showUpdate: false,
showRetry: false,
pollMs: 60_000,
};
}