Skip to content

A desktop coding agent with free access to frontier models.

TypeScript
13.4 KB
Raw Blame
import { and, desc, eq, isNull, isNotNull } from "@omnirush-ee/den-db/drizzle"
import { ArtifactViewRevisionTable, ArtifactViewTable, DashboardAppTable } from "@omnirush-ee/den-db/schema"
import { createDenTypeId, normalizeDenTypeId, type DenTypeId } from "@omnirush-ee/utils/typeid"
import type { GeneratedArtifactView, GeneratedArtifactViewRevision } from "@omnirush/types/workflows"
import { db } from "./db.js"
import { getWorkflowDetail } from "./workflows.js"
import { buildGeneratedArtifactView } from "./generated-artifact-view-builder.js"
import type { PluginArchActorContext } from "./routes/org/plugin-system/access.js"
import { artifactViewResourceUri } from "./artifact-view-resource.js"

const ARTIFACT_VIEW_LIST_LIMIT = 50
const ARTIFACT_VIEW_REVISION_LIST_LIMIT = 50

type ArtifactViewId = DenTypeId<"artifactView">
type ArtifactViewRevisionId = DenTypeId<"artifactViewRevision">
type ArtifactViewRow = typeof ArtifactViewTable.$inferSelect
type ArtifactViewRevisionRow = typeof ArtifactViewRevisionTable.$inferSelect

function parseViewId(value: string): ArtifactViewId {
  return normalizeDenTypeId("artifactView", value)
}

function parseRevisionId(value: string): ArtifactViewRevisionId {
  return normalizeDenTypeId("artifactViewRevision", value)
}

function serializeRevision(row: ArtifactViewRevisionRow): GeneratedArtifactViewRevision {
  return {
    id: row.id,
    artifactViewId: row.artifact_view_id,
    resourceUri: artifactViewResourceUri(row.artifact_view_id, row.id),
    buildStatus: row.build_status,
    sourceDigest: row.source_digest,
    resourceDigest: row.resource_digest,
    outputSchemaDigest: row.output_schema_digest,
    csp: row.csp,
    diagnostics: row.build_diagnostics,
    compilerName: row.compiler_name,
    compilerVersion: row.compiler_version,
    reactVersion: row.react_version,
    compiledHtmlBytes: row.compiled_html_bytes,
    retiredAt: row.retired_at?.toISOString() ?? null,
    createdAt: row.created_at.toISOString(),
  }
}

function serializeView(row: ArtifactViewRow, revisions: ArtifactViewRevisionRow[]): GeneratedArtifactView {
  return {
    id: row.id,
    configObjectId: row.config_object_id,
    title: row.title,
    description: row.description,
    status: row.status,
    activeRevisionId: row.active_revision_id,
    useInWorkflow: row.use_in_workflow,
    revisions: revisions.map(serializeRevision),
    createdAt: row.created_at.toISOString(),
    updatedAt: row.updated_at.toISOString(),
  }
}

async function accessibleView(input: {
  context: PluginArchActorContext
  artifactViewId: string
  role: "viewer" | "manager"
}): Promise<ArtifactViewRow> {
  const viewId = parseViewId(input.artifactViewId)
  const rows = await db.select().from(ArtifactViewTable).where(and(
    eq(ArtifactViewTable.id, viewId),
    eq(ArtifactViewTable.organization_id, input.context.organizationContext.organization.id),
  )).limit(1)
  const row = rows[0]
  if (!row) throw new Error("artifact_view_not_found")
  const script = await getWorkflowDetail({ context: input.context, configObjectId: row.config_object_id })
  if (input.role === "manager" && !script.canManage) throw new Error("artifact_view_not_found")
  return row
}

async function revisionRows(artifactViewId: ArtifactViewId): Promise<ArtifactViewRevisionRow[]> {
  return db.select().from(ArtifactViewRevisionTable).where(eq(
    ArtifactViewRevisionTable.artifact_view_id,
    artifactViewId,
  )).orderBy(desc(ArtifactViewRevisionTable.created_at), desc(ArtifactViewRevisionTable.id))
    .limit(ARTIFACT_VIEW_REVISION_LIST_LIMIT)
}

export async function listArtifactViews(input: {
  context: PluginArchActorContext
  activeOnly?: boolean
  savedOnly?: boolean
}): Promise<GeneratedArtifactView[]> {
  const conditions = [eq(ArtifactViewTable.organization_id, input.context.organizationContext.organization.id)]
  if (input.activeOnly) {
    conditions.push(eq(ArtifactViewTable.status, "active"))
  }
  if (input.savedOnly) conditions.push(isNotNull(ArtifactViewTable.active_revision_id))
  const rows = await db.select().from(ArtifactViewTable)
    .where(and(...conditions))
    .orderBy(desc(ArtifactViewTable.updated_at), desc(ArtifactViewTable.id))
    .limit(ARTIFACT_VIEW_LIST_LIMIT)
  const accessible = await Promise.all(rows.map(async (row) => {
    try {
      await getWorkflowDetail({ context: input.context, configObjectId: row.config_object_id })
      return serializeView(row, await revisionRows(row.id))
    } catch {
      return null
    }
  }))
  return accessible.filter((view): view is GeneratedArtifactView => view !== null)
}

export async function listArtifactViewsForScript(input: {
  context: PluginArchActorContext
  configObjectId: string
}): Promise<GeneratedArtifactView[]> {
  const script = await getWorkflowDetail({ context: input.context, configObjectId: input.configObjectId })
  const rows = await db.select().from(ArtifactViewTable).where(and(
    eq(ArtifactViewTable.organization_id, input.context.organizationContext.organization.id),
    eq(ArtifactViewTable.config_object_id, normalizeDenTypeId("configObject", script.configObjectId)),
  )).orderBy(desc(ArtifactViewTable.updated_at), desc(ArtifactViewTable.id))
  return Promise.all(rows.map(async (row) => serializeView(row, await revisionRows(row.id))))
}

export async function loadArtifactViewRevision(input: {
  context: PluginArchActorContext
  artifactViewId: string
  revisionId: string
}): Promise<{
  view: ArtifactViewRow
  revision: ArtifactViewRevisionRow
}> {
  const view = await accessibleView({ context: input.context, artifactViewId: input.artifactViewId, role: "viewer" })
  const revisionId = parseRevisionId(input.revisionId)
  const rows = await db.select().from(ArtifactViewRevisionTable).where(and(
    eq(ArtifactViewRevisionTable.id, revisionId),
    eq(ArtifactViewRevisionTable.artifact_view_id, view.id),
    eq(ArtifactViewRevisionTable.organization_id, view.organization_id),
  )).limit(1)
  const revision = rows[0]
  if (!revision) throw new Error("artifact_view_revision_not_found")
  return { view, revision }
}

export async function getGeneratedArtifactViewRevision(input: {
  context: PluginArchActorContext
  artifactViewId: string
  revisionId: string
}) {
  const { view, revision } = await loadArtifactViewRevision(input)
  return {
    view: serializeView(view, [revision]),
    revision: serializeRevision(revision),
  }
}

export async function saveArtifactViewRevision(input: {
  context: PluginArchActorContext
  artifactViewId?: string
  configObjectId: string
  title: string
  description?: string
  reactSource: string
  cssSource?: string
}): Promise<GeneratedArtifactView> {
  const script = await getWorkflowDetail({ context: input.context, configObjectId: input.configObjectId })
  if (!script.canManage) throw new Error("artifact_view_not_found")
  if (!script.currentVersion.outputSchema || !script.currentVersion.outputSchemaDigest) {
    throw new Error("artifact_view_output_schema_required")
  }
  const outputSchemaDigest = script.currentVersion.outputSchemaDigest

  const existing = input.artifactViewId
    ? await accessibleView({ context: input.context, artifactViewId: input.artifactViewId, role: "manager" })
    : null
  if (existing && existing.config_object_id !== script.configObjectId) {
    throw new Error("artifact_view_script_binding_immutable")
  }

  const artifactViewId = existing?.id ?? createDenTypeId("artifactView")
  const revisionId = createDenTypeId("artifactViewRevision")
  const title = input.title.trim()
  const description = input.description?.trim() || null
  const reactSource = input.reactSource.trim()
  const cssSource = input.cssSource?.trim() ?? ""
  const build = await buildGeneratedArtifactView({
    reactSource,
    cssSource,
    outputSchema: script.currentVersion.outputSchema,
    title,
    description,
  })

  await db.transaction(async (tx) => {
    if (existing) {
      if (existing.active_revision_id === null) {
        await tx.update(ArtifactViewTable).set({ title, description })
          .where(eq(ArtifactViewTable.id, existing.id))
      }
    } else {
      await tx.insert(ArtifactViewTable).values({
        id: artifactViewId,
        organization_id: input.context.organizationContext.organization.id,
        config_object_id: normalizeDenTypeId("configObject", script.configObjectId),
        owner_member_id: input.context.organizationContext.currentMember.id,
        title,
        description,
        status: "active",
        active_revision_id: null,
        use_in_workflow: false,
      })
    }
    await tx.insert(ArtifactViewRevisionTable).values({
      id: revisionId,
      organization_id: input.context.organizationContext.organization.id,
      artifact_view_id: artifactViewId,
      created_by_member_id: input.context.organizationContext.currentMember.id,
      react_source: reactSource,
      css_source: cssSource,
      ...(build.ok ? { compiled_html: build.html } : {}),
      build_diagnostics: build.diagnostics,
      build_status: build.ok ? "ready" : "failed",
      source_digest: build.sourceDigest,
      ...(build.ok ? { resource_digest: build.resourceDigest } : {}),
      output_schema_digest: outputSchemaDigest,
      output_schema: script.currentVersion.outputSchema,
      csp: build.csp,
      compiler_name: build.compilerName,
      compiler_version: build.compilerVersion,
      react_version: build.reactVersion,
      ...(build.ok ? { compiled_html_bytes: build.htmlBytes } : {}),
    })
  })

  const rows = await db.select().from(ArtifactViewTable).where(eq(ArtifactViewTable.id, artifactViewId)).limit(1)
  const view = rows[0]
  if (!view) throw new Error("artifact_view_not_found")
  return serializeView(view, await revisionRows(view.id))
}

export async function activateArtifactViewRevision(input: {
  context: PluginArchActorContext
  artifactViewId: string
  revisionId: string
  save?: { title: string; useInWorkflow: boolean; expectedActiveRevisionId: string | null }
}): Promise<GeneratedArtifactView> {
  const view = await accessibleView({ context: input.context, artifactViewId: input.artifactViewId, role: "manager" })
  const revisionId = parseRevisionId(input.revisionId)
  const revisions = await db.select().from(ArtifactViewRevisionTable).where(and(
    eq(ArtifactViewRevisionTable.id, revisionId),
    eq(ArtifactViewRevisionTable.artifact_view_id, view.id),
    eq(ArtifactViewRevisionTable.build_status, "ready"),
    isNull(ArtifactViewRevisionTable.retired_at),
  )).limit(1)
  const revision = revisions[0]
  if (!revision || !revision.compiled_html || !revision.resource_digest) throw new Error("artifact_view_revision_not_ready")
  const script = await getWorkflowDetail({ context: input.context, configObjectId: view.config_object_id })
  if (script.currentVersion.outputSchemaDigest !== revision.output_schema_digest) {
    throw new Error("artifact_view_schema_incompatible")
  }
  const saved = input.save
  const updated = await db.transaction(async (tx) => {
    const [current] = await tx.select().from(ArtifactViewTable)
      .where(eq(ArtifactViewTable.id, view.id)).limit(1).for("update")
    if (!current) throw new Error("artifact_view_not_found")
    if (saved && current.active_revision_id !== saved.expectedActiveRevisionId) {
      throw new Error("app_changed_since_preview")
    }
    const patch = {
      status: "active" as const,
      active_revision_id: revision.id,
      ...(saved ? { title: saved.title, use_in_workflow: saved.useInWorkflow } : {}),
    }
    await tx.update(ArtifactViewTable).set(patch).where(eq(ArtifactViewTable.id, view.id))
    if (saved) {
      // The existing private Workflow and exact app revision become one reusable
      // dashboard entry. A failed activation must not leave a dashboard card.
      await tx.insert(DashboardAppTable).values({
        organization_id: input.context.organizationContext.organization.id,
        member_id: input.context.organizationContext.currentMember.id,
        artifact_view_id: view.id,
      }).onDuplicateKeyUpdate({ set: { artifact_view_id: view.id } })
    }
    return { ...current, ...patch, updated_at: new Date() }
  })
  return serializeView(updated, await revisionRows(view.id))
}

export async function retireArtifactView(input: {
  context: PluginArchActorContext
  artifactViewId: string
}): Promise<GeneratedArtifactView> {
  const view = await accessibleView({ context: input.context, artifactViewId: input.artifactViewId, role: "manager" })
  await db.transaction(async (tx) => {
    await tx.update(ArtifactViewTable).set({ status: "retired", active_revision_id: null, use_in_workflow: false })
      .where(eq(ArtifactViewTable.id, view.id))
    await tx.delete(DashboardAppTable).where(and(
      eq(DashboardAppTable.organization_id, view.organization_id),
      eq(DashboardAppTable.artifact_view_id, view.id),
    ))
  })
  const updated = { ...view, status: "retired" as const, active_revision_id: null, use_in_workflow: false, updated_at: new Date() }
  return serializeView(updated, await revisionRows(view.id))
}

export async function getArtifactView(input: { context: PluginArchActorContext; artifactViewId: string }) {
  const view = await accessibleView({ ...input, role: "viewer" })
  return serializeView(view, await revisionRows(view.id))
}

export async function readArtifactViewSource(input: { context: PluginArchActorContext; artifactViewId: string }) {
  const view = await accessibleView({ ...input, role: "manager" })
  const revisions = await revisionRows(view.id)
  const latest = revisions[0]
  if (!latest) throw new Error("artifact_view_revision_not_found")
  return { view: serializeView(view, revisions), reactSource: latest.react_source, cssSource: latest.css_source }
}