A desktop coding agent with free access to frontier models.
TypeScript
import { afterAll, afterEach, beforeAll, describe, expect, mock, test } from "bun:test"
import { Tool } from "@omnirush/codemode"
import { and, eq, inArray } from "@omnirush-ee/den-db/drizzle"
import {
AuthUserTable,
WorkflowRunTable,
ConfigObjectAccessGrantTable,
ConfigObjectTable,
ConfigObjectVersionTable,
MarketplaceAccessGrantTable,
MarketplacePluginTable,
MarketplaceTable,
MemberTable,
PluginAccessGrantTable,
PluginConfigObjectTable,
PluginTable,
OrganizationTable,
} from "@omnirush-ee/den-db/schema"
import { createDenTypeId, type DenTypeId } from "@omnirush-ee/utils/typeid"
import { Effect } from "effect"
import { Hono } from "hono"
import type { PluginArchActorContext } from "../src/routes/org/plugin-system/access.js"
function seedRequiredEnv() {
process.env.DATABASE_URL = process.env.DATABASE_URL ?? "mysql://root:[email protected]:3306/omnirush_test_codemode_scripts"
process.env.DEN_DB_ENCRYPTION_KEY = process.env.DEN_DB_ENCRYPTION_KEY ?? "x".repeat(32)
process.env.BETTER_AUTH_SECRET = process.env.BETTER_AUTH_SECRET ?? "y".repeat(32)
process.env.BETTER_AUTH_URL = process.env.BETTER_AUTH_URL ?? "http://127.0.0.1:8790"
process.env.CORS_ORIGINS = process.env.CORS_ORIGINS ?? "http://127.0.0.1:8790"
}
type Db = typeof import("../src/db.js").db
type MarketplaceCapabilities = typeof import("../src/mcp/marketplace-capabilities.js")
type CapabilityRegistry = typeof import("../src/mcp/capability-registry.js")
type PluginStore = typeof import("../src/routes/org/plugin-system/store.js")
type Workflows = typeof import("../src/workflows.js")
type WorkflowRuns = typeof import("../src/workflow-runs.js")
type WorkflowLibrary = typeof import("../src/workflow-library.js")
type SeededScript = {
configObjectId: DenTypeId<"configObject">
member: { orgMembershipId: DenTypeId<"member">; teamIds: [] }
organizationId: DenTypeId<"organization">
pluginId: DenTypeId<"plugin">
}
let db: Db
let marketplaceCapabilities: MarketplaceCapabilities
let capabilityRegistry: CapabilityRegistry
let pluginStore: PluginStore
let workflows: Workflows
let workflowRuns: WorkflowRuns
let workflowLibrary: WorkflowLibrary
const createdOrganizationIds: DenTypeId<"organization">[] = []
const createdUserIds: DenTypeId<"user">[] = []
beforeAll(async () => {
seedRequiredEnv()
mock.restore()
db = (await import("@omnirush-ee/den-db")).createDenDb({
databaseUrl: process.env.DATABASE_URL,
mode: "mysql",
}).db
mock.module("../src/db.js", () => ({ db }))
pluginStore = await import("../src/routes/org/plugin-system/store.js")
marketplaceCapabilities = await import("../src/mcp/marketplace-capabilities.js")
workflows = await import("../src/workflows.js")
workflowRuns = await import("../src/workflow-runs.js")
workflowLibrary = await import("../src/workflow-library.js")
capabilityRegistry = await import("../src/mcp/capability-registry.js")
})
afterAll(() => {
mock.restore()
})
afterEach(async () => {
if (createdOrganizationIds.length > 0) {
await db.delete(WorkflowRunTable).where(inArray(WorkflowRunTable.organization_id, createdOrganizationIds))
await db.delete(ConfigObjectVersionTable).where(inArray(ConfigObjectVersionTable.organizationId, createdOrganizationIds))
await db.delete(ConfigObjectAccessGrantTable).where(inArray(ConfigObjectAccessGrantTable.organizationId, createdOrganizationIds))
await db.delete(PluginConfigObjectTable).where(inArray(PluginConfigObjectTable.organizationId, createdOrganizationIds))
await db.delete(PluginAccessGrantTable).where(inArray(PluginAccessGrantTable.organizationId, createdOrganizationIds))
await db.delete(MarketplacePluginTable).where(inArray(MarketplacePluginTable.organizationId, createdOrganizationIds))
await db.delete(MarketplaceAccessGrantTable).where(inArray(MarketplaceAccessGrantTable.organizationId, createdOrganizationIds))
await db.delete(ConfigObjectTable).where(inArray(ConfigObjectTable.organizationId, createdOrganizationIds))
await db.delete(PluginTable).where(inArray(PluginTable.organizationId, createdOrganizationIds))
await db.delete(MarketplaceTable).where(inArray(MarketplaceTable.organizationId, createdOrganizationIds))
await db.delete(MemberTable).where(inArray(MemberTable.organizationId, createdOrganizationIds))
await db.delete(OrganizationTable).where(inArray(OrganizationTable.id, createdOrganizationIds))
}
if (createdUserIds.length > 0) {
await db.delete(AuthUserTable).where(inArray(AuthUserTable.id, createdUserIds))
}
createdOrganizationIds.length = 0
createdUserIds.length = 0
})
async function seedScript(input: {
code: string
objectType?: "script" | "workflow"
payload: Record<string, unknown>
title: string
}): Promise<SeededScript> {
const organizationId = createDenTypeId("organization")
const userId = createDenTypeId("user")
const memberId = createDenTypeId("member")
const marketplaceId = createDenTypeId("marketplace")
const now = new Date()
createdOrganizationIds.push(organizationId)
createdUserIds.push(userId)
await db.insert(AuthUserTable).values({ id: userId, name: "Script Tester", email: `${userId}@scripts.test.local` })
await db.insert(OrganizationTable).values({ id: organizationId, name: "Script Test Org", slug: `scripts-${organizationId}` })
await db.insert(MemberTable).values({ id: memberId, organizationId, userId, role: "owner" })
await db.insert(MarketplaceTable).values({
id: marketplaceId,
organizationId,
name: "Script Marketplace",
description: "Saved script tests",
status: "active",
createdByOrgMembershipId: memberId,
})
await db.insert(MarketplaceAccessGrantTable).values({
id: createDenTypeId("marketplaceAccessGrant"),
organizationId,
marketplaceId,
orgMembershipId: memberId,
teamId: null,
orgWide: false,
role: "manager",
createdByOrgMembershipId: memberId,
})
const context: PluginArchActorContext = {
memberTeams: [],
organizationContext: {
organization: {
id: organizationId,
name: "Script Test Org",
slug: `scripts-${organizationId}`,
logo: null,
allowedEmailDomains: null,
metadata: null,
createdAt: now,
updatedAt: now,
},
currentMember: {
id: memberId,
userId,
role: "owner",
createdAt: now,
joinedAt: now,
isOwner: true,
},
invitations: [],
members: [],
roles: [],
teams: [],
},
session: { createdAt: now },
}
const plugin = await pluginStore.createPluginBundle({
components: [{
type: input.objectType ?? "workflow",
value: {
metadata: { title: input.title, description: `${input.title} description` },
normalizedPayloadJson: input.payload,
rawSourceText: input.code,
},
}],
context,
marketplaceId,
name: `${input.title} Plugin`,
orgWide: true,
})
const memberships = await db
.select({ configObjectId: PluginConfigObjectTable.configObjectId })
.from(PluginConfigObjectTable)
.where(eq(PluginConfigObjectTable.pluginId, plugin.id))
const configObjectId = memberships[0]?.configObjectId
if (!configObjectId) throw new Error("Workflow Plugin has no config object")
return {
configObjectId,
member: { orgMembershipId: memberId, teamIds: [] },
organizationId,
pluginId: plugin.id,
}
}
function executeScript(seeded: SeededScript, input: {
body?: unknown
buildTools?: Parameters<MarketplaceCapabilities["executeMarketplaceCapability"]>[0]["buildTools"]
validateScriptOutput?: boolean
} = {}) {
return marketplaceCapabilities.executeMarketplaceCapability({
body: input.body,
buildTools: input.buildTools,
validateScriptOutput: input.validateScriptOutput,
configObjectId: seeded.configObjectId,
enabled: true,
member: seeded.member,
organizationId: seeded.organizationId,
pluginId: seeded.pluginId,
})
}
describe("saved marketplace Workflows", () => {
test("promotes a successful run using strict public capability references", async () => {
const seeded = await seedScript({
title: "Promotion Fixture",
code: "return null",
payload: { language: "codemode-js", requiredCapabilities: [] },
})
const code = "return { briefing: await tools.reports.echo({ text: input.topic }) }"
const now = new Date()
await db.insert(WorkflowRunTable).values({
id: createDenTypeId("workflowRun"),
organization_id: seeded.organizationId,
org_membership_id: seeded.member.orgMembershipId,
source: "mcp",
code_digest: workflowRuns.codemodeCodeDigest(code),
status: "succeeded",
tool_calls: [{ name: "tools.reports.echo" }],
tool_call_count: 1,
duration_ms: 5,
started_at: now,
finished_at: now,
})
const saved = await workflows.saveWorkflow({
organizationId: seeded.organizationId,
ownerMemberId: seeded.member.orgMembershipId,
workflow: {
name: "Promoted briefing",
code,
currentInput: { topic: "launch" },
inputSchema: {
type: "object",
properties: { topic: { type: "string" } },
required: ["topic"],
},
},
buildTools: async () => ({
tools: {},
manifest: [{
capabilityName: "reports.echo",
scriptPath: "tools.reports.echo",
readOnly: true,
authority: "external",
}],
}),
})
const versions = await db.select().from(ConfigObjectVersionTable)
.where(eq(ConfigObjectVersionTable.id, saved.configObjectVersionId))
expect(versions[0]?.normalizedPayloadJson).toMatchObject({
language: "codemode-js",
requiredCapabilities: [{
capabilityName: "reports.echo",
scriptPath: "tools.reports.echo",
}],
})
expect(versions[0]?.normalizedPayloadJson).not.toHaveProperty("requiredCapabilities.0.readOnly")
expect(versions[0]?.normalizedPayloadJson).not.toHaveProperty("requiredCapabilities.0.unattendedApproved")
})
test("saves a Workflow directly into a chosen existing Plugin", async () => {
const seeded = await seedScript({
title: "Chosen Plugin Fixture",
code: "return null",
payload: { language: "codemode-js", requiredCapabilities: [] },
})
const code = "return { shared: true }"
const now = new Date()
await db.insert(WorkflowRunTable).values({
id: createDenTypeId("workflowRun"),
organization_id: seeded.organizationId,
org_membership_id: seeded.member.orgMembershipId,
source: "mcp",
code_digest: workflowRuns.codemodeCodeDigest(code),
status: "succeeded",
tool_calls: [],
tool_call_count: 0,
duration_ms: 5,
started_at: now,
finished_at: now,
})
const context: PluginArchActorContext = {
memberTeams: [],
organizationContext: {
organization: {
id: seeded.organizationId,
name: "Script Test Org",
slug: `scripts-${seeded.organizationId}`,
logo: null,
allowedEmailDomains: null,
metadata: null,
createdAt: now,
updatedAt: now,
},
currentMember: {
id: seeded.member.orgMembershipId,
userId: createDenTypeId("user"),
role: "owner",
createdAt: now,
joinedAt: now,
isOwner: true,
},
invitations: [],
members: [],
roles: [],
teams: [],
},
session: { createdAt: now },
}
const saved = await workflows.saveWorkflow({
organizationId: seeded.organizationId,
ownerMemberId: seeded.member.orgMembershipId,
context,
workflow: { pluginId: seeded.pluginId, name: "Shared Workflow", code },
buildTools: async () => ({ tools: {}, manifest: [] }),
})
expect(saved.pluginId).toBe(seeded.pluginId)
const memberships = await db.select().from(PluginConfigObjectTable).where(and(
eq(PluginConfigObjectTable.pluginId, seeded.pluginId),
eq(PluginConfigObjectTable.configObjectId, saved.configObjectId),
))
expect(memberships).toHaveLength(1)
})
test("does not let a Plugin editor replace an existing Workflow version", async () => {
const seeded = await seedScript({
title: "Manager-owned Workflow",
code: "return { owner: true }",
payload: { language: "codemode-js", requiredCapabilities: [] },
})
const editorUserId = createDenTypeId("user")
const editorMemberId = createDenTypeId("member")
const now = new Date()
const code = "return { replaced: true }"
createdUserIds.push(editorUserId)
await db.insert(AuthUserTable).values({
id: editorUserId,
name: "Workflow Editor",
email: `${editorUserId}@scripts.test.local`,
})
await db.insert(MemberTable).values({
id: editorMemberId,
organizationId: seeded.organizationId,
userId: editorUserId,
role: "member",
})
await db.insert(PluginAccessGrantTable).values({
id: createDenTypeId("pluginAccessGrant"),
organizationId: seeded.organizationId,
pluginId: seeded.pluginId,
orgMembershipId: editorMemberId,
teamId: null,
orgWide: false,
role: "editor",
createdByOrgMembershipId: seeded.member.orgMembershipId,
})
await db.insert(WorkflowRunTable).values({
id: createDenTypeId("workflowRun"),
organization_id: seeded.organizationId,
org_membership_id: editorMemberId,
source: "mcp",
code_digest: workflowRuns.codemodeCodeDigest(code),
status: "succeeded",
tool_calls: [],
tool_call_count: 0,
duration_ms: 5,
started_at: now,
finished_at: now,
})
const context: PluginArchActorContext = {
memberTeams: [],
organizationContext: {
organization: {
id: seeded.organizationId,
name: "Script Test Org",
slug: `scripts-${seeded.organizationId}`,
logo: null,
allowedEmailDomains: null,
metadata: null,
createdAt: now,
updatedAt: now,
},
currentMember: {
id: editorMemberId,
userId: editorUserId,
role: "member",
createdAt: now,
joinedAt: now,
isOwner: false,
},
invitations: [],
members: [],
roles: [],
teams: [],
},
session: { createdAt: now },
}
await expect(workflows.saveWorkflow({
organizationId: seeded.organizationId,
ownerMemberId: editorMemberId,
context,
workflow: { pluginId: seeded.pluginId, name: "Manager-owned Workflow", code },
buildTools: async () => ({ tools: {}, manifest: [] }),
})).rejects.toThrow("Missing manager access for config object.")
const versions = await db.select().from(ConfigObjectVersionTable).where(eq(
ConfigObjectVersionTable.configObjectId,
seeded.configObjectId,
))
expect(versions).toHaveLength(1)
})
test("does not disclose an inaccessible parent Plugin through a direct Workflow grant", async () => {
const seeded = await seedScript({
title: "Directly shared Workflow",
code: "return { shared: true }",
payload: {
language: "codemode-js",
exampleInput: { token: "viewer-authoring-secret" },
requiredCapabilities: [],
},
})
const viewerUserId = createDenTypeId("user")
const viewerMemberId = createDenTypeId("member")
const now = new Date()
createdUserIds.push(viewerUserId)
await db.insert(AuthUserTable).values({
id: viewerUserId,
name: "Direct Workflow Viewer",
email: `${viewerUserId}@scripts.test.local`,
})
await db.insert(MemberTable).values({
id: viewerMemberId,
organizationId: seeded.organizationId,
userId: viewerUserId,
role: "member",
})
await db.update(PluginAccessGrantTable).set({ removedAt: now }).where(and(
eq(PluginAccessGrantTable.pluginId, seeded.pluginId),
eq(PluginAccessGrantTable.orgWide, true),
))
await db.update(ConfigObjectAccessGrantTable).set({ removedAt: now }).where(and(
eq(ConfigObjectAccessGrantTable.configObjectId, seeded.configObjectId),
eq(ConfigObjectAccessGrantTable.orgWide, true),
))
await db.insert(ConfigObjectAccessGrantTable).values({
id: createDenTypeId("configObjectAccessGrant"),
organizationId: seeded.organizationId,
configObjectId: seeded.configObjectId,
orgMembershipId: viewerMemberId,
teamId: null,
orgWide: false,
role: "viewer",
createdByOrgMembershipId: seeded.member.orgMembershipId,
})
const context: PluginArchActorContext = {
memberTeams: [],
organizationContext: {
organization: {
id: seeded.organizationId,
name: "Script Test Org",
slug: `scripts-${seeded.organizationId}`,
logo: null,
allowedEmailDomains: null,
metadata: null,
createdAt: now,
updatedAt: now,
},
currentMember: {
id: viewerMemberId,
userId: viewerUserId,
role: "member",
createdAt: now,
joinedAt: now,
isOwner: false,
},
invitations: [],
members: [],
roles: [],
teams: [],
},
session: { createdAt: now },
}
const detail = await workflowLibrary.getWorkflowLibraryDetail({
context,
configObjectId: seeded.configObjectId,
})
expect(detail.workflow.plugin).toBeNull()
expect(detail.script.currentVersion.code).toBeNull()
expect(detail.script.currentVersion.exampleInput).toBeNull()
expect(JSON.stringify(detail)).not.toContain("viewer-authoring-secret")
expect(JSON.stringify(detail)).not.toContain("return { shared: true }")
expect(JSON.stringify(detail.workflow)).not.toContain("Directly shared Workflow Plugin")
const library = await workflowLibrary.listWorkflowLibraryItems({ context })
expect(library).toHaveLength(1)
expect(library[0]?.plugin).toBeNull()
expect(library[0]).not.toHaveProperty("code")
expect(library[0]).not.toHaveProperty("data")
expect(library[0]).not.toHaveProperty("html")
expect(library[0]).not.toHaveProperty("compiledHtml")
})
test("executes a createPluginBundle Workflow with typed input binding", async () => {
const seeded = await seedScript({
title: "Summarize Account",
code: "return { account: input.account, doubled: input.count * 2 }",
payload: {
language: "codemode-js",
inputSchema: {
type: "object",
additionalProperties: false,
properties: { account: { type: "string" }, count: { type: "number" } },
required: ["account", "count"],
},
requiredCapabilities: [],
},
})
const result = await executeScript(seeded, { body: { account: "Acme", count: 4 } })
if (!result.ok) throw new Error(result.message)
expect(result.result).toMatchObject({
kind: "workflow",
status: "executed",
value: { account: "Acme", doubled: 8 },
toolCalls: [],
})
const matches = await marketplaceCapabilities.searchMarketplaceCapabilities({
enabled: true,
member: seeded.member,
organizationId: seeded.organizationId,
query: "summarize account",
})
expect(matches[0]).toMatchObject({ kind: "workflow", hasBody: true })
expect(matches[0]?.path).toStartWith("plugin://")
})
test("executes a legacy script object through the canonical Workflow capability", async () => {
const seeded = await seedScript({
title: "Legacy Script",
code: "return { migrated: input.value }",
objectType: "script",
payload: { language: "codemode-js", requiredCapabilities: [] },
})
const stored = await db.select({ objectType: ConfigObjectTable.objectType })
.from(ConfigObjectTable)
.where(eq(ConfigObjectTable.id, seeded.configObjectId))
expect(stored[0]?.objectType).toBe("script")
const matches = await marketplaceCapabilities.searchMarketplaceCapabilities({
enabled: true,
member: seeded.member,
organizationId: seeded.organizationId,
query: "legacy script",
})
expect(matches[0]).toMatchObject({ kind: "workflow", hasBody: true })
const result = await executeScript(seeded, { body: { value: "compatible" } })
if (!result.ok) throw new Error(result.message)
expect(result.result).toMatchObject({
kind: "workflow",
status: "executed",
value: { migrated: "compatible" },
})
})
test("keeps saved scripts discoverable and executable without any rollout flag", async () => {
const seeded = await seedScript({
title: "Hidden Script",
code: "return 1",
payload: { language: "codemode-js", requiredCapabilities: [] },
})
const matches = await marketplaceCapabilities.searchMarketplaceCapabilities({
enabled: true,
member: seeded.member,
organizationId: seeded.organizationId,
query: "hidden script",
})
expect(matches[0]).toMatchObject({ kind: "workflow" })
const result = await executeScript(seeded)
if (!result.ok) throw new Error(result.message)
expect(result.result).toMatchObject({ kind: "workflow", status: "executed", value: 1 })
})
test("fails closed before running when a declared capability is unavailable", async () => {
let invocations = 0
const available = Tool.make({
description: "Available test tool",
input: { type: "object" },
run: () => Effect.sync(() => {
invocations += 1
return "called"
}),
})
const seeded = await seedScript({
title: "Missing Capability Script",
code: "return await tools.den.available({})",
payload: {
language: "codemode-js",
requiredCapabilities: [{ capabilityName: "missingCapability", scriptPath: "tools.den.missingCapability" }],
},
})
const result = await executeScript(seeded, {
buildTools: () => Promise.resolve({
tools: { den: { available } },
manifest: [{ capabilityName: "available", scriptPath: "tools.den.available" }],
}),
})
expect(result).toMatchObject({
ok: false,
error: "capability_unavailable",
providerCallAttempted: false,
missing: [{ capabilityName: "missingCapability", scriptPath: "tools.den.missingCapability" }],
})
expect(invocations).toBe(0)
})
test("keeps saved scripts and execute_capability_script out of the composable tree", async () => {
const seeded = await seedScript({
title: "Recursive Script",
code: "return 'must not run'",
payload: { language: "codemode-js", requiredCapabilities: [] },
})
const capabilityName = marketplaceCapabilities.buildMarketplaceCapabilityName(seeded.pluginId, seeded.configObjectId)
const requiredCapabilities = [
{ capabilityName, scriptPath: `tools.marketplace[${JSON.stringify(capabilityName)}]` },
{ capabilityName: "execute_capability_script", scriptPath: "tools.den.execute_capability_script" },
]
await db.update(ConfigObjectVersionTable)
.set({ normalizedPayloadJson: { language: "codemode-js", requiredCapabilities } })
.where(eq(ConfigObjectVersionTable.configObjectId, seeded.configObjectId))
let platformAdmin: Promise<boolean> | undefined
const context: Parameters<CapabilityRegistry["buildCapabilityToolTree"]>[0] = {
app: new Hono(),
env: undefined,
catalog: [],
principal: {
userId: createDenTypeId("user"),
organizationId: seeded.organizationId,
scopes: new Set(["mcp:read", "mcp:write"]),
payload: {},
},
organizationId: seeded.organizationId,
member: seeded.member,
redirectUriBase: "http://127.0.0.1:8790",
externalMcpConnectionsEnabled: true,
resolvePlatformAdmin: () => {
platformAdmin ??= Promise.resolve(false)
return platformAdmin
},
resolveNamespaceContext: () => Promise.resolve({
nativeProviderEntries: [],
externalMcpConnections: [],
codemodeNativeProviderEntries: [],
codemodeExternalMcpConnections: [],
namespaces: { native: new Map(), externalMcp: new Map() },
}),
}
const built = await capabilityRegistry.buildCapabilityToolTree(context)
expect(built.manifest).not.toContainEqual(expect.objectContaining({ capabilityName }))
expect(built.manifest).not.toContainEqual(expect.objectContaining({ capabilityName: "execute_capability_script" }))
const result = await executeScript(seeded, {
buildTools: () => capabilityRegistry.buildCapabilityToolTree(context),
})
expect(result).toMatchObject({
ok: false,
error: "capability_unavailable",
providerCallAttempted: false,
missing: requiredCapabilities,
})
if (result.ok) throw new Error("Expected Workflow recursion to be blocked")
expect(result.message).toContain("is unavailable or disabled")
})
test("rejects input that does not match the saved inputSchema", async () => {
const seeded = await seedScript({
title: "Typed Script",
code: "return input.name",
payload: {
language: "codemode-js",
inputSchema: {
type: "object",
properties: { name: { type: "string" } },
required: ["name"],
},
requiredCapabilities: [],
},
})
const result = await executeScript(seeded, { body: { name: 42 } })
expect(result).toMatchObject({
ok: false,
error: "invalid_capability_arguments",
sameArgumentsRetryable: false,
retry: { action: "correct_arguments", searchRequired: false },
})
if (result.ok || result.error !== "invalid_capability_arguments") throw new Error("Expected invalid script arguments")
expect(result.issues.length).toBeGreaterThan(0)
})
test("validates saved script output before returning an artifact-ready result", async () => {
const seeded = await seedScript({
title: "Typed Result Script",
code: "return { count: 'not-a-number' }",
payload: {
language: "codemode-js",
outputSchema: {
type: "object",
properties: { count: { type: "number" } },
required: ["count"],
},
requiredCapabilities: [],
},
})
const legacyResult = await executeScript(seeded)
if (!legacyResult.ok) throw new Error(legacyResult.message)
expect(legacyResult.result).toMatchObject({ status: "executed", value: { count: "not-a-number" } })
const result = await executeScript(seeded, { validateScriptOutput: true })
expect(result).toMatchObject({
ok: false,
error: "invalid_capability_arguments",
sameArgumentsRetryable: false,
})
})
test("lists accessible Workflows with exact versions and artifact schemas", async () => {
const seeded = await seedScript({
title: "Artifact Script",
code: "return { briefing: input.topic }",
payload: {
language: "codemode-js",
inputSchema: { type: "object", properties: { topic: { type: "string" } }, required: ["topic"] },
outputSchema: { type: "object", properties: { briefing: { type: "string" } }, required: ["briefing"] },
requiredCapabilities: [],
},
})
const accessibleWorkflows = await marketplaceCapabilities.listAccessibleWorkflows({
member: seeded.member,
organizationId: seeded.organizationId,
})
expect(accessibleWorkflows).toHaveLength(1)
expect(accessibleWorkflows[0]).toMatchObject({
pluginId: seeded.pluginId,
configObjectId: seeded.configObjectId,
title: "Artifact Script",
inputSchema: { type: "object" },
outputSchema: { type: "object" },
})
expect(accessibleWorkflows[0]?.configObjectVersionId).toStartWith("cov_")
})
})