spawnfile 0.1.1 → 0.1.3

package/dist/compiler/teamRosterEntries.js

@@ -0,0 +1,230 @@
+import { resolveTeamRepresentatives } from "./moltnetResolution.js";
+const SURFACE_ORDER = ["moltnet", "slack", "discord", "telegram", "whatsapp"];
+const findNode = (plan, source) => plan.nodes.find((node) => node.value.source === source)?.value ?? null;
+const findAgent = (plan, source) => {
+    const node = findNode(plan, source);
+    return node?.kind === "agent" ? node : null;
+};
+const findTeam = (plan, source) => {
+    const node = findNode(plan, source);
+    return node?.kind === "team" ? node : null;
+};
+const lookupDescription = (source, plan) => findNode(plan, source)?.description ?? "";
+const getContextRoomIds = (contextTeamSource, attachment) => {
+    const contextRooms = attachment.contextRooms?.[contextTeamSource];
+    if (contextRooms) {
+        return [...contextRooms].sort();
+    }
+    if (attachment.teamSource === contextTeamSource) {
+        return Object.keys(attachment.rooms ?? {}).sort();
+    }
+    return [];
+};
+const createMoltnetAddresses = (agent, contextTeamSource, memberId) => {
+    const addresses = {};
+    for (const attachment of agent.surfaces?.moltnet ?? []) {
+        if (attachment.memberId !== memberId) {
+            continue;
+        }
+        const rooms = getContextRoomIds(contextTeamSource, attachment);
+        if (rooms.length === 0 && attachment.teamSource !== contextTeamSource) {
+            continue;
+        }
+        addresses[attachment.network] = {
+            fqid: `molt://${attachment.network}/agents/${memberId}`,
+            rooms
+        };
+    }
+    return addresses;
+};
+const createIdentityAddresses = (surfaces) => ({
+    ...(surfaces?.slack?.identity
+        ? { slack: { user_id: surfaces.slack.identity.userId } }
+        : {}),
+    ...(surfaces?.discord?.identity
+        ? { discord: { user_id: surfaces.discord.identity.userId } }
+        : {}),
+    ...(surfaces?.telegram?.identity
+        ? {
+            telegram: {
+                ...(surfaces.telegram.identity.userId
+                    ? { user_id: surfaces.telegram.identity.userId }
+                    : {}),
+                ...(surfaces.telegram.identity.username
+                    ? { username: surfaces.telegram.identity.username }
+                    : {})
+            }
+        }
+        : {}),
+    ...(surfaces?.whatsapp?.identity
+        ? { whatsapp: { phone: surfaces.whatsapp.identity.phone } }
+        : {})
+});
+const createConcreteEntry = (plan, agentSource, memberId, role, contextTeamSource, delegateRole) => {
+    const agent = findAgent(plan, agentSource);
+    const moltnet = agent
+        ? createMoltnetAddresses(agent, contextTeamSource, memberId)
+        : {};
+    const identity = createIdentityAddresses(agent?.surfaces);
+    const addresses = {
+        ...identity,
+        ...(Object.keys(moltnet).length > 0 ? { moltnet } : {})
+    };
+    const surfaces = SURFACE_ORDER.filter((surface) => {
+        if (surface === "moltnet") {
+            return Object.keys(moltnet).length > 0;
+        }
+        return Boolean(agent?.surfaces?.[surface]);
+    });
+    return {
+        addresses,
+        ...(delegateRole ? { delegate_role: delegateRole } : {}),
+        description: agent?.description ?? "",
+        role,
+        surfaces
+    };
+};
+const createCardPath = (contextKey, memberId) => `.spawnfile/team-cards/${contextKey}/${memberId}.md`;
+const createTeamEntry = (plan, teamNode, member, contextKey, contextTeamSource) => {
+    const childTeam = findTeam(plan, member.nodeSource);
+    const representatives = childTeam
+        ? resolveTeamRepresentatives(plan, childTeam)
+        : [];
+    const isLead = member.id === teamNode.lead;
+    const delegateRole = isLead ? "lead" : "representative";
+    return {
+        addresses: {},
+        card: {
+            path: createCardPath(contextKey, member.id),
+            summary: lookupDescription(member.nodeSource, plan)
+        },
+        description: lookupDescription(member.nodeSource, plan),
+        ...(isLead ? { is_lead: true } : {}),
+        representatives: Object.fromEntries(representatives.map((representative) => {
+            const entry = createConcreteEntry(plan, representative.agentSource, representative.memberId, delegateRole === "lead" ? "lead" : "member", contextTeamSource, delegateRole);
+            const { role: _role, ...representativeEntry } = entry;
+            return [representative.memberId, representativeEntry];
+        })),
+        role: "team",
+        surfaces: []
+    };
+};
+export const getVisibleTeamMembers = (teamNode, selfMemberId, delegateRole, representedSlotId) => {
+    const excluded = representedSlotId ?? selfMemberId;
+    if (teamNode.mode === "swarm") {
+        return teamNode.members.filter((member) => member.id !== excluded);
+    }
+    const hasLeadVisibility = selfMemberId === teamNode.lead || delegateRole === "lead";
+    if (hasLeadVisibility) {
+        return teamNode.members.filter((member) => member.id !== excluded);
+    }
+    const lead = teamNode.lead
+        ? teamNode.members.find((member) => member.id === teamNode.lead)
+        : undefined;
+    return lead && lead.id !== excluded ? [lead] : [];
+};
+export const createRosterEntry = (plan, teamNode, member, options) => {
+    if (member.kind === "team") {
+        return createTeamEntry(plan, teamNode, member, options.contextKey, options.teamSource);
+    }
+    return createConcreteEntry(plan, member.nodeSource, member.id, member.id === teamNode.lead ? "lead" : "member", options.teamSource);
+};
+export const collectConcreteParticipants = (plan, teamNode, selfMemberId, visibleMembers, representedSlotId) => {
+    const selfMember = representedSlotId
+        ? null
+        : teamNode.members.find((member) => member.id === selfMemberId && member.kind === "agent");
+    const participants = selfMember
+        ? [{ agentSource: selfMember.nodeSource, id: selfMember.id }]
+        : [];
+    if (representedSlotId) {
+        const representedMember = teamNode.members.find((member) => member.id === representedSlotId);
+        if (representedMember?.kind === "team") {
+            const childTeam = findTeam(plan, representedMember.nodeSource);
+            const representative = childTeam
+                ? resolveTeamRepresentatives(plan, childTeam).find((entry) => entry.memberId === selfMemberId)
+                : undefined;
+            if (representative) {
+                participants.push({
+                    agentSource: representative.agentSource,
+                    id: representative.memberId
+                });
+            }
+        }
+    }
+    for (const member of visibleMembers) {
+        if (member.kind === "agent") {
+            participants.push({ agentSource: member.nodeSource, id: member.id });
+            continue;
+        }
+        const childTeam = findTeam(plan, member.nodeSource);
+        if (!childTeam) {
+            continue;
+        }
+        for (const representative of resolveTeamRepresentatives(plan, childTeam)) {
+            participants.push({
+                agentSource: representative.agentSource,
+                id: representative.memberId
+            });
+        }
+    }
+    return participants;
+};
+const getCoordinationBindings = (plan, participant, contextTeamSource) => {
+    const agent = findAgent(plan, participant.agentSource);
+    if (!agent) {
+        return [];
+    }
+    const bindings = new Set();
+    for (const surface of ["slack", "discord", "telegram", "whatsapp"]) {
+        if (agent.surfaces?.[surface]) {
+            bindings.add(surface);
+        }
+    }
+    for (const attachment of agent.surfaces?.moltnet ?? []) {
+        if (attachment.memberId !== participant.id) {
+            continue;
+        }
+        for (const roomId of getContextRoomIds(contextTeamSource, attachment)) {
+            bindings.add(`moltnet:${attachment.network}:${roomId}`);
+        }
+    }
+    return [...bindings].sort();
+};
+export const createCoordinationDiagnostics = (plan, teamNode, participants, contextTeamSource) => {
+    if (participants.length <= 1) {
+        return [];
+    }
+    const bindingsByParticipant = new Map(participants.map((participant) => [
+        participant.id,
+        getCoordinationBindings(plan, participant, contextTeamSource)
+    ]));
+    const connected = new Set();
+    let edgeCount = 0;
+    for (let index = 0; index < participants.length; index += 1) {
+        for (let other = index + 1; other < participants.length; other += 1) {
+            const left = participants[index];
+            const right = participants[other];
+            const leftBindings = new Set(bindingsByParticipant.get(left.id) ?? []);
+            const hasSharedBinding = (bindingsByParticipant.get(right.id) ?? []).some((binding) => leftBindings.has(binding));
+            if (hasSharedBinding) {
+                edgeCount += 1;
+                connected.add(left.id);
+                connected.add(right.id);
+            }
+        }
+    }
+    return [
+        ...(edgeCount === 0
+            ? [{
+                    level: "warn",
+                    message: `Team ${teamNode.name} context has no shared coordination surface between visible participants`
+                }]
+            : []),
+        ...participants
+            .filter((participant) => !connected.has(participant.id))
+            .map((participant) => ({
+            level: "warn",
+            message: `Team ${teamNode.name} member ${participant.id} has no shared coordination surface with any visible teammate`
+        }))
+    ];
+};

package/dist/compiler/teamRosterTypes.d.ts

@@ -0,0 +1,45 @@
+import type { DiagnosticReport } from "../report/index.js";
+import type { ResolvedMemberRef } from "./types.js";
+export interface RosterRepresentativeEntry {
+    addresses: Record<string, unknown>;
+    delegate_role?: "lead" | "representative";
+    description: string;
+    surfaces: string[];
+}
+export interface RosterEntry {
+    addresses: Record<string, unknown>;
+    card?: {
+        path: string;
+        summary: string;
+    };
+    description: string;
+    is_lead?: boolean;
+    representatives?: Record<string, RosterRepresentativeEntry>;
+    role: "lead" | "member" | "team";
+    surfaces: string[];
+}
+export interface Roster {
+    context_kind?: "direct" | "representative";
+    lead: string | null;
+    members: Record<string, RosterEntry>;
+    mode: "hierarchical" | "swarm";
+    represents?: {
+        delegate_role: "lead" | "representative";
+        representative: string;
+        slot: string;
+    };
+    self: string;
+    team: string;
+}
+export interface GenerateTeamRosterOptions {
+    contextKey: string;
+    delegateRole?: "lead" | "representative";
+    representedSlotId?: string;
+    selfMemberId: string;
+    teamSource: string;
+}
+export interface GeneratedTeamRoster {
+    diagnostics: DiagnosticReport[];
+    roster: string;
+    visibleMembers: ResolvedMemberRef[];
+}

package/dist/compiler/teamRosterTypes.js

@@ -0,0 +1 @@
+export {};

package/dist/compiler/types.d.ts

@@ -24,6 +24,9 @@ export interface ResolvedDiscordSurface {
         users: string[];
     };
     botTokenSecret: string;
+    identity?: {
+        userId: string;
+    };
 }
 export interface ResolvedTelegramSurface {
     access?: {
@@ -32,6 +35,10 @@ export interface ResolvedTelegramSurface {
         users: string[];
     };
     botTokenSecret: string;
+    identity?: {
+        userId?: string;
+        username?: string;
+    };
 }
 export interface ResolvedWhatsAppSurface {
     access?: {
@@ -39,6 +46,9 @@ export interface ResolvedWhatsAppSurface {
         mode: "allowlist" | "open" | "pairing";
         users: string[];
     };
+    identity?: {
+        phone: string;
+    };
 }
 export interface ResolvedSlackSurface {
     access?: {
@@ -48,13 +58,60 @@ export interface ResolvedSlackSurface {
     };
     appTokenSecret: string;
     botTokenSecret: string;
+    identity?: {
+        userId: string;
+    };
+}
+export interface ResolvedHttpSurface {
+    access?: {
+        mode: "open";
+    };
+    auth?: {
+        mode: "bearer";
+        tokenSecret?: string;
+    };
+    pathPrefix: string;
+    port?: number;
+}
+export interface ResolvedMoltnetRoomPolicy {
+    read?: "all" | "mentions" | "thread_only";
+    reply?: "auto" | "never";
+}
+export interface ResolvedMoltnetDMConfig extends ResolvedMoltnetRoomPolicy {
+    enabled: boolean;
+}
+export interface ResolvedMoltnetAttachment {
+    contextRooms?: Record<string, string[]>;
+    dms?: ResolvedMoltnetDMConfig;
+    memberId: string | null;
+    network: string;
+    rooms?: Record<string, ResolvedMoltnetRoomPolicy>;
+    teamSource: string | null;
+}
+export interface ResolvedWebhookSurface {
+    signingSecret?: string;
+    url: string;
 }
 export interface ResolvedAgentSurfaces {
     discord?: ResolvedDiscordSurface;
+    http?: ResolvedHttpSurface;
+    moltnet?: ResolvedMoltnetAttachment[];
     slack?: ResolvedSlackSurface;
     telegram?: ResolvedTelegramSurface;
+    webhook?: ResolvedWebhookSurface;
     whatsapp?: ResolvedWhatsAppSurface;
 }
+export interface ResolvedTeamNetworkRoom {
+    id: string;
+    members: string[];
+}
+export interface ResolvedTeamNetwork {
+    expose?: boolean;
+    id: string;
+    name: string;
+    provider: "moltnet";
+    rooms: ResolvedTeamNetworkRoom[];
+}
 export interface EffectiveModelTarget {
     auth: {
         key?: string;
@@ -75,9 +132,11 @@ export interface ResolvedMemberRef {
     runtimeName: string | null;
 }
 export interface ResolvedAgentNode {
+    description: string;
     docs: ResolvedDocument[];
     env: StringMap;
     execution: ExecutionBlock | undefined;
+    expose?: boolean;
     kind: "agent";
     mcpServers: McpServer[];
     name: string;
@@ -90,16 +149,17 @@ export interface ResolvedAgentNode {
     surfaces?: ResolvedAgentSurfaces;
     subagents: ResolvedSubagentRef[];
 }
-export interface ResolvedTeamStructure {
-    external: string[];
-    leader: string | null;
-    mode: "hierarchical" | "swarm";
-}
 export interface ResolvedTeamNode {
+    description: string;
     docs: ResolvedDocument[];
+    external: string[];
+    externalExplicit?: boolean;
     kind: "team";
+    lead: string | null;
     members: ResolvedMemberRef[];
+    mode: "hierarchical" | "swarm";
     name: string;
+    networks?: ResolvedTeamNetwork[];
     policyMode: string | null;
     policyOnDegrade: string | null;
     shared: {
@@ -109,7 +169,6 @@ export interface ResolvedTeamNode {
         skills: ResolvedSkill[];
     };
     source: string;
-    structure: ResolvedTeamStructure;
 }
 export interface CompilePlanEdge {
     from: string;
@@ -124,8 +183,33 @@ export interface CompilePlanNode {
     slug: string;
     value: ResolvedAgentNode | ResolvedTeamNode;
 }
+export interface ResolvedTeamMembershipContext {
+    agentSource: string;
+    memberId: string;
+    teamName: string;
+    teamSource: string;
+}
+export interface ResolvedMoltnetRoomMembership {
+    agentName: string;
+    agentSource: string;
+    concreteMemberId: string;
+    declaredSlot: string;
+    declaringTeamName: string;
+    declaringTeamSource: string;
+    directTeamName: string;
+    directTeamSource: string;
+    networkId: string;
+    policy?: ResolvedMoltnetRoomPolicy;
+    representedSlot?: string;
+    representedTeamName?: string;
+    representedTeamSource?: string;
+    representativePath?: string[];
+    roomId: string;
+}
 export interface CompilePlan {
     edges: CompilePlanEdge[];
+    memberships?: ResolvedTeamMembershipContext[];
+    moltnetRoomMemberships?: ResolvedMoltnetRoomMembership[];
     nodes: CompilePlanNode[];
     root: string;
     runtimes: Record<string, {

package/dist/compiler/updateProjectRuntime.d.ts

@@ -0,0 +1,9 @@
+export interface ProjectRuntimeOptions {
+    path?: string;
+    recursive?: boolean;
+    runtime: string;
+}
+export interface UpdateProjectRuntimeResult {
+    updatedFiles: string[];
+}
+export declare const setProjectRuntime: (options: ProjectRuntimeOptions) => Promise<UpdateProjectRuntimeResult>;

package/dist/compiler/updateProjectRuntime.js

@@ -0,0 +1,67 @@
+import path from "node:path";
+import { getCanonicalManifestPath, getManifestPath, getProjectRoot, writeUtf8File } from "../filesystem/index.js";
+import { loadManifest, renderSpawnfile } from "../manifest/index.js";
+import { assertRuntimeCanCompile } from "../runtime/index.js";
+import { SpawnfileError } from "../shared/index.js";
+import { assertRuntimeSupportsExecutionModelAuth } from "./modelAuth.js";
+import { validateAgentSurfaceSupport } from "./surfaceDefinitions.js";
+const TEAM_RUNTIME_COMMAND_ERROR = "spawnfile runtime commands only write agent manifests; use --recursive to update descendant agents of a team project";
+const resolveTargetManifestPath = (inputPath) => getManifestPath(path.resolve(inputPath ?? process.cwd()));
+const collectManifestPaths = async (manifestPath, recursive, visited = new Set()) => {
+    const canonicalPath = getCanonicalManifestPath(manifestPath);
+    if (visited.has(canonicalPath)) {
+        return [];
+    }
+    visited.add(canonicalPath);
+    if (!recursive) {
+        return [canonicalPath];
+    }
+    const loadedManifest = await loadManifest(canonicalPath);
+    const childRefs = loadedManifest.manifest.kind === "team"
+        ? loadedManifest.manifest.members.map((member) => member.ref)
+        : (loadedManifest.manifest.subagents ?? []).map((subagent) => subagent.ref);
+    const nestedPaths = await Promise.all(childRefs.map((ref) => collectManifestPaths(getManifestPath(path.resolve(getProjectRoot(canonicalPath), ref)), true, visited)));
+    return [canonicalPath, ...nestedPaths.flat()];
+};
+const manifestChanged = (current, next) => JSON.stringify(current) !== JSON.stringify(next);
+const assertRuntimeMutationAllowed = (manifest, recursive) => {
+    if (manifest.kind === "agent") {
+        return true;
+    }
+    if (recursive) {
+        return false;
+    }
+    throw new SpawnfileError("validation_error", TEAM_RUNTIME_COMMAND_ERROR);
+};
+const validateAgentRuntimeMutation = (manifest) => {
+    validateAgentSurfaceSupport(manifest);
+    const runtimeName = typeof manifest.runtime === "string" ? manifest.runtime : manifest.runtime?.name;
+    if (!runtimeName) {
+        return;
+    }
+    assertRuntimeSupportsExecutionModelAuth(runtimeName, manifest.execution, manifest.name);
+};
+export const setProjectRuntime = async (options) => {
+    await assertRuntimeCanCompile(options.runtime);
+    const recursive = options.recursive ?? false;
+    const manifestPaths = await collectManifestPaths(resolveTargetManifestPath(options.path), recursive);
+    const updatedFiles = [];
+    for (const manifestPath of manifestPaths) {
+        const loadedManifest = await loadManifest(manifestPath);
+        const manifest = loadedManifest.manifest;
+        if (!assertRuntimeMutationAllowed(manifest, recursive)) {
+            continue;
+        }
+        const nextManifest = {
+            ...manifest,
+            runtime: options.runtime
+        };
+        validateAgentRuntimeMutation(nextManifest);
+        if (!manifestChanged(manifest, nextManifest)) {
+            continue;
+        }
+        await writeUtf8File(manifestPath, renderSpawnfile(nextManifest));
+        updatedFiles.push(manifestPath);
+    }
+    return { updatedFiles };
+};

package/dist/compiler/updateProjectSurfaces.d.ts

@@ -0,0 +1,8 @@
+import { type AddProjectSurfaceOptions, type ProjectSurfaceSummariesResult, type RemoveProjectSurfaceOptions, type ShowProjectSurfacesOptions, type UpdateProjectSurfacesResult } from "./surfaceDefinitions.js";
+import type { ProjectSurfaceAccessOptions } from "./surfaceDefinitions.js";
+export { type AddProjectSurfaceOptions, type ProjectSurfaceAccessOptions, type ProjectSurfaceSummariesResult, type RemoveProjectSurfaceOptions, type ShowProjectSurfacesOptions, type UpdateProjectSurfacesResult, resolvePortableSurfaceName } from "./surfaceDefinitions.js";
+export type { ProjectSurfaceSummary, SurfaceAccessMode, SurfaceName } from "./surfaceDefinitions.js";
+export declare const addProjectSurface: (options: AddProjectSurfaceOptions) => Promise<UpdateProjectSurfacesResult>;
+export declare const setProjectSurfaceAccess: (options: ProjectSurfaceAccessOptions) => Promise<UpdateProjectSurfacesResult>;
+export declare const removeProjectSurface: (options: RemoveProjectSurfaceOptions) => Promise<UpdateProjectSurfacesResult>;
+export declare const showProjectSurfaces: (options?: ShowProjectSurfacesOptions) => Promise<ProjectSurfaceSummariesResult>;

package/dist/compiler/updateProjectSurfaces.js

@@ -0,0 +1,106 @@
+import path from "node:path";
+import { getCanonicalManifestPath, getManifestPath, getProjectRoot, writeUtf8File } from "../filesystem/index.js";
+import { loadManifest, renderSpawnfile } from "../manifest/index.js";
+import { assertSurfaceMutationAllowed, removeSurface, updateSurfaceAccess, upsertSurface, validateAgentSurfaceSupport } from "./surfaceDefinitions.js";
+const resolveTargetManifestPath = (inputPath) => getManifestPath(path.resolve(inputPath ?? process.cwd()));
+const collectManifestPaths = async (manifestPath, recursive, visited = new Set()) => {
+    const canonicalPath = getCanonicalManifestPath(manifestPath);
+    if (visited.has(canonicalPath)) {
+        return [];
+    }
+    visited.add(canonicalPath);
+    if (!recursive) {
+        return [canonicalPath];
+    }
+    const loadedManifest = await loadManifest(canonicalPath);
+    const childRefs = loadedManifest.manifest.kind === "team"
+        ? loadedManifest.manifest.members.map((member) => member.ref)
+        : (loadedManifest.manifest.subagents ?? []).map((subagent) => subagent.ref);
+    const nestedPaths = await Promise.all(childRefs.map((ref) => collectManifestPaths(getManifestPath(path.resolve(getProjectRoot(canonicalPath), ref)), true, visited)));
+    return [canonicalPath, ...nestedPaths.flat()];
+};
+const manifestChanged = (current, next) => JSON.stringify(current) !== JSON.stringify(next);
+const rewriteTouchedManifests = async (manifestPaths, mutate) => {
+    const rewrites = [];
+    for (const manifestPath of manifestPaths) {
+        const loadedManifest = await loadManifest(manifestPath);
+        const nextManifest = mutate(loadedManifest.manifest, manifestPath);
+        if (!nextManifest || !manifestChanged(loadedManifest.manifest, nextManifest)) {
+            continue;
+        }
+        if (nextManifest.kind === "agent") {
+            validateAgentSurfaceSupport(nextManifest);
+        }
+        rewrites.push({
+            manifest: nextManifest,
+            manifestPath
+        });
+    }
+    for (const rewrite of rewrites) {
+        await writeUtf8File(rewrite.manifestPath, renderSpawnfile(rewrite.manifest));
+    }
+    return {
+        updatedFiles: rewrites.map((rewrite) => rewrite.manifestPath)
+    };
+};
+export { resolvePortableSurfaceName } from "./surfaceDefinitions.js";
+export const addProjectSurface = async (options) => {
+    const recursive = options.recursive ?? false;
+    const manifestPaths = await collectManifestPaths(resolveTargetManifestPath(options.path), recursive);
+    return rewriteTouchedManifests(manifestPaths, (manifest) => {
+        if (!assertSurfaceMutationAllowed(manifest, recursive)) {
+            return null;
+        }
+        return {
+            ...manifest,
+            surfaces: upsertSurface(manifest.surfaces, options)
+        };
+    });
+};
+export const setProjectSurfaceAccess = async (options) => {
+    const recursive = options.recursive ?? false;
+    const manifestPaths = await collectManifestPaths(resolveTargetManifestPath(options.path), recursive);
+    return rewriteTouchedManifests(manifestPaths, (manifest, manifestPath) => {
+        if (!assertSurfaceMutationAllowed(manifest, recursive)) {
+            return null;
+        }
+        const nextSurfaces = updateSurfaceAccess(manifest.surfaces, options, manifestPath, recursive);
+        if (!nextSurfaces) {
+            return null;
+        }
+        return {
+            ...manifest,
+            surfaces: nextSurfaces
+        };
+    });
+};
+export const removeProjectSurface = async (options) => {
+    const recursive = options.recursive ?? false;
+    const manifestPaths = await collectManifestPaths(resolveTargetManifestPath(options.path), recursive);
+    return rewriteTouchedManifests(manifestPaths, (manifest) => {
+        if (!assertSurfaceMutationAllowed(manifest, recursive)) {
+            return null;
+        }
+        return {
+            ...manifest,
+            surfaces: removeSurface(manifest.surfaces, options.surface)
+        };
+    });
+};
+export const showProjectSurfaces = async (options = {}) => {
+    const manifestPaths = await collectManifestPaths(resolveTargetManifestPath(options.path), options.recursive ?? false);
+    const entries = [];
+    for (const manifestPath of manifestPaths) {
+        const loadedManifest = await loadManifest(manifestPath);
+        if (options.recursive && loadedManifest.manifest.kind !== "agent") {
+            continue;
+        }
+        entries.push({
+            kind: loadedManifest.manifest.kind,
+            manifestPath,
+            name: loadedManifest.manifest.name,
+            surfaces: loadedManifest.manifest.surfaces
+        });
+    }
+    return { entries };
+};

package/dist/compiler/view/buildOrganizationView.d.ts

@@ -0,0 +1,2 @@
+import type { OrganizationView } from "./types.js";
+export declare const buildOrganizationView: (inputPath: string) => Promise<OrganizationView>;