spawnfile 0.1.1 → 0.1.3

package/dist/cli/runCli.d.ts

@@ -1,16 +1,23 @@
 import { importClaudeCodeAuth, importCodexAuth, importEnvFile, requireAuthProfile } from "../auth/index.js";
-import { addAgentProject, addProjectModelFallback, addSubagentProject, addTeamProject, buildCompilePlan, buildProject, clearProjectModelFallbacks, compileProject, initProject, runProject, setProjectPrimaryModel, syncProjectAuth } from "../compiler/index.js";
+import { addAgentProject, addProjectSurface, addProjectModelFallback, addSubagentProject, addTeamProject, buildOrganizationView, buildCompilePlan, buildProject, clearProjectModelFallbacks, compileProject, initProject, removeProjectSurface, runProject, setProjectPrimaryModel, setProjectRuntime, setProjectSurfaceAccess, showProjectSurfaces, syncProjectAuth } from "../compiler/index.js";
 import { listRuntimeAdapters } from "../runtime/index.js";
 export interface CliStreams {
     stderr: (message: string) => void;
     stdout: (message: string) => void;
 }
+export interface CliRenderEnvironment {
+    ci: boolean;
+    noColor: boolean;
+    stdoutIsTty: boolean;
+}
 export interface CliHandlers {
     buildCompilePlan: typeof buildCompilePlan;
+    buildOrganizationView: typeof buildOrganizationView;
     buildProject: typeof buildProject;
     compileProject: typeof compileProject;
     addAgentProject: typeof addAgentProject;
     addProjectModelFallback: typeof addProjectModelFallback;
+    addProjectSurface: typeof addProjectSurface;
     addSubagentProject: typeof addSubagentProject;
     addTeamProject: typeof addTeamProject;
     clearProjectModelFallbacks: typeof clearProjectModelFallbacks;
@@ -19,9 +26,23 @@ export interface CliHandlers {
     importEnvFile: typeof importEnvFile;
     initProject: typeof initProject;
     listRuntimeAdapters: typeof listRuntimeAdapters;
+    removeProjectSurface: typeof removeProjectSurface;
     requireAuthProfile: typeof requireAuthProfile;
     runProject: typeof runProject;
     setProjectPrimaryModel: typeof setProjectPrimaryModel;
+    setProjectRuntime: typeof setProjectRuntime;
+    setProjectSurfaceAccess: typeof setProjectSurfaceAccess;
+    showProjectSurfaces: typeof showProjectSurfaces;
     syncProjectAuth: typeof syncProjectAuth;
 }
-export declare const runCli: (argv: string[], streams?: CliStreams, handlerOverrides?: Partial<CliHandlers>) => Promise<number>;
+export interface RunCliOptions {
+    handlers?: Partial<CliHandlers>;
+    renderEnvironment?: CliRenderEnvironment;
+    streams?: CliStreams;
+}
+type RunCli = {
+    (argv: string[], options?: RunCliOptions): Promise<number>;
+    (argv: string[], streams?: CliStreams, handlerOverrides?: Partial<CliHandlers>): Promise<number>;
+};
+export declare const runCli: RunCli;
+export {};

package/dist/cli/runCli.js

@@ -1,31 +1,60 @@
 import { Command } from "commander";
 import { importClaudeCodeAuth, importCodexAuth, importEnvFile, requireAuthProfile } from "../auth/index.js";
-import { addAgentProject, addProjectModelFallback, addSubagentProject, addTeamProject, buildCompilePlan, buildProject, clearProjectModelFallbacks, compileProject, initProject, runProject, setProjectPrimaryModel, syncProjectAuth } from "../compiler/index.js";
+import { addAgentProject, addProjectSurface, addProjectModelFallback, addSubagentProject, addTeamProject, buildOrganizationView, buildCompilePlan, buildProject, clearProjectModelFallbacks, compileProject, initProject, removeProjectSurface, runProject, setProjectPrimaryModel, setProjectRuntime, setProjectSurfaceAccess, showProjectSurfaces, syncProjectAuth } from "../compiler/index.js";
 import { isSpawnfileError } from "../shared/index.js";
 import { listRuntimeAdapters } from "../runtime/index.js";
+import { registerModelCommands } from "./modelCommands.js";
+import { registerRuntimeCommands } from "./runtimeCommands.js";
+import { registerSurfaceCommands } from "./surfaceCommands.js";
+import { registerViewCommand } from "./viewCommand.js";
 const createDefaultStreams = () => ({
     stderr: (message) => process.stderr.write(`${message}\n`),
     stdout: (message) => process.stdout.write(`${message}\n`)
 });
+const createDefaultRenderEnvironment = () => ({
+    ci: process.env.CI !== undefined && process.env.CI !== "" && process.env.CI !== "0",
+    noColor: process.env.NO_COLOR !== undefined && process.env.NO_COLOR !== "",
+    stdoutIsTty: process.stdout.isTTY === true
+});
 const createDefaultHandlers = () => ({
-    buildCompilePlan,
-    buildProject,
-    compileProject,
-    addAgentProject,
-    addProjectModelFallback,
-    addSubagentProject,
-    addTeamProject,
-    clearProjectModelFallbacks,
-    importClaudeCodeAuth,
-    importCodexAuth,
-    importEnvFile,
-    initProject,
-    listRuntimeAdapters,
-    requireAuthProfile,
-    runProject,
-    setProjectPrimaryModel,
-    syncProjectAuth
+    buildCompilePlan, buildOrganizationView, buildProject, compileProject,
+    addAgentProject, addProjectModelFallback, addProjectSurface,
+    addSubagentProject, addTeamProject, clearProjectModelFallbacks,
+    importClaudeCodeAuth, importCodexAuth, importEnvFile,
+    initProject, listRuntimeAdapters, removeProjectSurface, requireAuthProfile,
+    runProject, setProjectPrimaryModel, setProjectRuntime,
+    setProjectSurfaceAccess, showProjectSurfaces, syncProjectAuth
 });
+const isCliStreams = (value) => {
+    const candidate = value;
+    return typeof candidate?.stderr === "function" && typeof candidate.stdout === "function";
+};
+const normalizeRunCliOptions = (optionsOrStreams, handlerOverrides = {}) => isCliStreams(optionsOrStreams)
+    ? {
+        handlers: handlerOverrides,
+        renderEnvironment: createDefaultRenderEnvironment(),
+        streams: optionsOrStreams
+    }
+    : {
+        handlers: optionsOrStreams?.handlers ?? handlerOverrides,
+        renderEnvironment: optionsOrStreams?.renderEnvironment ?? createDefaultRenderEnvironment(),
+        streams: optionsOrStreams?.streams ?? createDefaultStreams()
+    };
+const writeCommanderOutput = (write, message) => {
+    const normalized = message.replace(/\n$/, "");
+    if (normalized.length > 0) {
+        write(normalized);
+    }
+};
+const isCommanderError = (error) => {
+    if (typeof error !== "object" || error === null) {
+        return false;
+    }
+    const candidate = error;
+    return typeof candidate.code === "string"
+        && candidate.code.startsWith("commander.")
+        && typeof candidate.exitCode === "number";
+};
 const formatPlanSummary = (plan) => [
     `root: ${plan.root}`,
     `nodes: ${plan.nodes.length}`,
@@ -40,10 +69,20 @@ const formatAuthProfileSummary = (profile) => {
         `imports: ${importedKinds.length > 0 ? importedKinds.join(", ") : "none"}`
     ];
 };
-export const runCli = async (argv, streams = createDefaultStreams(), handlerOverrides = {}) => {
-    const handlers = { ...createDefaultHandlers(), ...handlerOverrides };
+const emitLines = (streams, lines) => lines.forEach((line) => streams.stdout(line));
+const emitFileLines = (streams, label, filePaths) => emitLines(streams, filePaths.map((filePath) => `${label} ${filePath}`));
+export const runCli = async (argv, optionsOrStreams, handlerOverrides = {}) => {
+    const cliOptions = normalizeRunCliOptions(optionsOrStreams, handlerOverrides);
+    const streams = cliOptions.streams;
+    const handlers = { ...createDefaultHandlers(), ...cliOptions.handlers };
     const program = new Command();
     program.name("spawnfile").description("Spawnfile v0.1 compiler");
+    program.exitOverride();
+    program.configureOutput({
+        outputError: (message, write) => write(message),
+        writeErr: (message) => writeCommanderOutput(streams.stderr, message),
+        writeOut: (message) => writeCommanderOutput(streams.stdout, message)
+    });
     program
         .command("compile")
         .argument("[path]", "Project directory or Spawnfile path", process.cwd())
@@ -100,9 +139,7 @@ export const runCli = async (argv, streams = createDefaultStreams(), handlerOver
             team: options.team
         });
         streams.stdout(`initialized ${result.directory}`);
-        for (const filePath of result.createdFiles) {
-            streams.stdout(`created ${filePath}`);
-        }
+        emitFileLines(streams, "created", result.createdFiles);
     });
     const addCommand = program.command("add").description("Add children to an existing Spawnfile project");
     addCommand
@@ -116,12 +153,8 @@ export const runCli = async (argv, streams = createDefaultStreams(), handlerOver
             path: inputPath,
             runtime: options.runtime
         });
-        for (const filePath of result.updatedFiles) {
-            streams.stdout(`updated ${filePath}`);
-        }
-        for (const filePath of result.createdFiles) {
-            streams.stdout(`created ${filePath}`);
-        }
+        emitFileLines(streams, "updated", result.updatedFiles);
+        emitFileLines(streams, "created", result.createdFiles);
     });
     addCommand
         .command("subagent")
@@ -132,12 +165,8 @@ export const runCli = async (argv, streams = createDefaultStreams(), handlerOver
             id,
             path: inputPath
         });
-        for (const filePath of result.updatedFiles) {
-            streams.stdout(`updated ${filePath}`);
-        }
-        for (const filePath of result.createdFiles) {
-            streams.stdout(`created ${filePath}`);
-        }
+        emitFileLines(streams, "updated", result.updatedFiles);
+        emitFileLines(streams, "created", result.createdFiles);
     });
     addCommand
         .command("team")
@@ -148,79 +177,13 @@ export const runCli = async (argv, streams = createDefaultStreams(), handlerOver
             id,
             path: inputPath
         });
-        for (const filePath of result.updatedFiles) {
-            streams.stdout(`updated ${filePath}`);
-        }
-        for (const filePath of result.createdFiles) {
-            streams.stdout(`created ${filePath}`);
-        }
-    });
-    const modelCommand = program
-        .command("model")
-        .description("Edit primary and fallback model declarations");
-    modelCommand
-        .command("set")
-        .argument("<provider>", "Model provider")
-        .argument("<name>", "Model name")
-        .argument("[path]", "Project directory or Spawnfile path", process.cwd())
-        .option("--auth <method>", "Model auth method")
-        .option("--key <env>", "Environment variable for api_key auth")
-        .option("--compat <compatibility>", "Endpoint compatibility for custom/local models")
-        .option("--base-url <url>", "Endpoint base URL for custom/local models")
-        .option("--recursive", "Update the target project and its descendants")
-        .action(async (provider, name, inputPath, options) => {
-        const result = await handlers.setProjectPrimaryModel({
-            authKey: options.key,
-            authMethod: options.auth,
-            endpointBaseUrl: options.baseUrl,
-            endpointCompatibility: options.compat,
-            name,
-            path: inputPath,
-            provider,
-            recursive: options.recursive
-        });
-        for (const filePath of result.updatedFiles) {
-            streams.stdout(`updated ${filePath}`);
-        }
-    });
-    modelCommand
-        .command("add-fallback")
-        .argument("<provider>", "Model provider")
-        .argument("<name>", "Model name")
-        .argument("[path]", "Project directory or Spawnfile path", process.cwd())
-        .option("--auth <method>", "Model auth method")
-        .option("--key <env>", "Environment variable for api_key auth")
-        .option("--compat <compatibility>", "Endpoint compatibility for custom/local models")
-        .option("--base-url <url>", "Endpoint base URL for custom/local models")
-        .option("--recursive", "Update the target project and its descendants")
-        .action(async (provider, name, inputPath, options) => {
-        const result = await handlers.addProjectModelFallback({
-            authKey: options.key,
-            authMethod: options.auth,
-            endpointBaseUrl: options.baseUrl,
-            endpointCompatibility: options.compat,
-            name,
-            path: inputPath,
-            provider,
-            recursive: options.recursive
-        });
-        for (const filePath of result.updatedFiles) {
-            streams.stdout(`updated ${filePath}`);
-        }
-    });
-    modelCommand
-        .command("clear-fallbacks")
-        .argument("[path]", "Project directory or Spawnfile path", process.cwd())
-        .option("--recursive", "Update the target project and its descendants")
-        .action(async (inputPath, options) => {
-        const result = await handlers.clearProjectModelFallbacks({
-            path: inputPath,
-            recursive: options.recursive
-        });
-        for (const filePath of result.updatedFiles) {
-            streams.stdout(`updated ${filePath}`);
-        }
+        emitFileLines(streams, "updated", result.updatedFiles);
+        emitFileLines(streams, "created", result.createdFiles);
     });
+    registerModelCommands(program, handlers, streams);
+    registerRuntimeCommands(program, handlers, streams);
+    registerSurfaceCommands(program, handlers, streams);
+    registerViewCommand(program, handlers, streams, cliOptions.renderEnvironment);
     program
         .command("validate")
         .argument("[path]", "Project directory or Spawnfile path", process.cwd())
@@ -247,9 +210,7 @@ export const runCli = async (argv, streams = createDefaultStreams(), handlerOver
         .option("-p, --profile <name>", "Auth profile name", "default")
         .action(async (filePath, options) => {
         const profile = await handlers.importEnvFile(options.profile, filePath);
-        for (const line of formatAuthProfileSummary(profile)) {
-            streams.stdout(line);
-        }
+        emitLines(streams, formatAuthProfileSummary(profile));
     });
     authImportCommand
         .command("claude-code")
@@ -257,9 +218,7 @@ export const runCli = async (argv, streams = createDefaultStreams(), handlerOver
         .option("--from <directory>", "Source Claude Code config directory")
         .action(async (options) => {
         const profile = await handlers.importClaudeCodeAuth(options.profile, options.from);
-        for (const line of formatAuthProfileSummary(profile)) {
-            streams.stdout(line);
-        }
+        emitLines(streams, formatAuthProfileSummary(profile));
     });
     authImportCommand
         .command("codex")
@@ -267,9 +226,7 @@ export const runCli = async (argv, streams = createDefaultStreams(), handlerOver
         .option("--from <directory>", "Source Codex config directory")
         .action(async (options) => {
         const profile = await handlers.importCodexAuth(options.profile, options.from);
-        for (const line of formatAuthProfileSummary(profile)) {
-            streams.stdout(line);
-        }
+        emitLines(streams, formatAuthProfileSummary(profile));
     });
     authCommand
         .command("sync")
@@ -285,24 +242,23 @@ export const runCli = async (argv, streams = createDefaultStreams(), handlerOver
             envFilePath: options.envFile,
             profileName: options.profile
         });
-        for (const line of formatAuthProfileSummary(profile)) {
-            streams.stdout(line);
-        }
+        emitLines(streams, formatAuthProfileSummary(profile));
     });
     authCommand
         .command("show")
         .option("-p, --profile <name>", "Auth profile name", "default")
         .action(async (options) => {
         const profile = await handlers.requireAuthProfile(options.profile);
-        for (const line of formatAuthProfileSummary(profile)) {
-            streams.stdout(line);
-        }
+        emitLines(streams, formatAuthProfileSummary(profile));
     });
     try {
         await program.parseAsync(argv, { from: "user" });
         return 0;
     }
     catch (error) {
+        if (isCommanderError(error)) {
+            return error.exitCode === 0 ? 0 : 1;
+        }
         const message = isSpawnfileError(error)
             ? `${error.code}: ${error.message}`
             : error instanceof Error

package/dist/cli/runtimeCommands.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+import type { CliHandlers, CliStreams } from "./runCli.js";
+export declare const registerRuntimeCommands: (program: Command, handlers: CliHandlers, streams: CliStreams) => void;

package/dist/cli/runtimeCommands.js

@@ -0,0 +1,20 @@
+export const registerRuntimeCommands = (program, handlers, streams) => {
+    const runtimeCommand = program
+        .command("runtime")
+        .description("Edit runtime declarations");
+    runtimeCommand
+        .command("set")
+        .argument("<name>", "Runtime name")
+        .argument("[path]", "Project directory or Spawnfile path", process.cwd())
+        .option("--recursive", "Update the target project and its descendants")
+        .action(async (runtime, inputPath, options) => {
+        const result = await handlers.setProjectRuntime({
+            path: inputPath,
+            recursive: options.recursive,
+            runtime
+        });
+        for (const filePath of result.updatedFiles) {
+            streams.stdout(`updated ${filePath}`);
+        }
+    });
+};

package/dist/cli/surfaceCommands.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+import type { CliHandlers, CliStreams } from "./runCli.js";
+export declare const registerSurfaceCommands: (program: Command, handlers: CliHandlers, streams: CliStreams) => void;

package/dist/cli/surfaceCommands.js

@@ -0,0 +1,98 @@
+import YAML from "yaml";
+import { resolvePortableSurfaceName } from "../compiler/index.js";
+const collectStringOption = (value, previous) => [...previous, value];
+const emitSurfaceSummaries = (streams, entries) => {
+    entries.forEach((entry, index) => {
+        if (index > 0) {
+            streams.stdout("");
+        }
+        streams.stdout(`path: ${entry.manifestPath}`);
+        streams.stdout(`kind: ${entry.kind}`);
+        streams.stdout(`name: ${entry.name}`);
+        if (!entry.surfaces) {
+            streams.stdout("surfaces: none");
+            return;
+        }
+        streams.stdout(YAML.stringify({ surfaces: entry.surfaces }).trimEnd());
+    });
+};
+export const registerSurfaceCommands = (program, handlers, streams) => {
+    const surfaceCommand = program
+        .command("surface")
+        .description("Edit agent surfaces");
+    surfaceCommand
+        .command("add")
+        .argument("<surface>", "Surface name")
+        .argument("[path]", "Project directory or Spawnfile path", process.cwd())
+        .option("--bot-token-secret <env>", "Override the bot token env var name")
+        .option("--app-token-secret <env>", "Override the Slack app token env var name")
+        .option("--recursive", "Update the target project and its descendants")
+        .action(async (surface, inputPath, options) => {
+        const surfaceName = resolvePortableSurfaceName(surface);
+        const result = await handlers.addProjectSurface({
+            appTokenSecret: options.appTokenSecret,
+            botTokenSecret: options.botTokenSecret,
+            path: inputPath,
+            recursive: options.recursive,
+            surface: surfaceName
+        });
+        for (const filePath of result.updatedFiles) {
+            streams.stdout(`updated ${filePath}`);
+        }
+    });
+    surfaceCommand
+        .command("remove")
+        .argument("<surface>", "Surface name")
+        .argument("[path]", "Project directory or Spawnfile path", process.cwd())
+        .option("--recursive", "Update the target project and its descendants")
+        .action(async (surface, inputPath, options) => {
+        const surfaceName = resolvePortableSurfaceName(surface);
+        const result = await handlers.removeProjectSurface({
+            path: inputPath,
+            recursive: options.recursive,
+            surface: surfaceName
+        });
+        for (const filePath of result.updatedFiles) {
+            streams.stdout(`updated ${filePath}`);
+        }
+    });
+    surfaceCommand
+        .command("set-access")
+        .argument("<surface>", "Surface name")
+        .argument("[path]", "Project directory or Spawnfile path", process.cwd())
+        .requiredOption("--mode <mode>", "Access mode")
+        .option("--user <id>", "Allowlisted user id", collectStringOption, [])
+        .option("--channel <id>", "Allowlisted channel id", collectStringOption, [])
+        .option("--guild <id>", "Allowlisted guild id", collectStringOption, [])
+        .option("--chat <id>", "Allowlisted chat id", collectStringOption, [])
+        .option("--group <id>", "Allowlisted group id", collectStringOption, [])
+        .option("--recursive", "Update the target project and its descendants")
+        .action(async (surface, inputPath, options) => {
+        const surfaceName = resolvePortableSurfaceName(surface);
+        const result = await handlers.setProjectSurfaceAccess({
+            channels: options.channel,
+            chats: options.chat,
+            groups: options.group,
+            guilds: options.guild,
+            mode: options.mode,
+            path: inputPath,
+            recursive: options.recursive,
+            surface: surfaceName,
+            users: options.user
+        });
+        for (const filePath of result.updatedFiles) {
+            streams.stdout(`updated ${filePath}`);
+        }
+    });
+    surfaceCommand
+        .command("show")
+        .argument("[path]", "Project directory or Spawnfile path", process.cwd())
+        .option("--recursive", "Show descendant agent surfaces too")
+        .action(async (inputPath, options) => {
+        const result = await handlers.showProjectSurfaces({
+            path: inputPath,
+            recursive: options.recursive
+        });
+        emitSurfaceSummaries(streams, result.entries);
+    });
+};

package/dist/cli/viewCommand.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+import type { CliHandlers, CliRenderEnvironment, CliStreams } from "./runCli.js";
+export declare const registerViewCommand: (program: Command, handlers: CliHandlers, streams: CliStreams, renderEnvironment: CliRenderEnvironment) => void;

package/dist/cli/viewCommand.js

@@ -0,0 +1,87 @@
+import { stat } from "node:fs/promises";
+import path from "node:path";
+import { Option } from "commander";
+import { renderOrganizationNetworks, renderOrganizationTree } from "../compiler/index.js";
+import { SpawnfileError } from "../shared/index.js";
+const VIEW_MODES = ["tree", "networks"];
+const VIEW_SHOW_OPTIONS = ["paths", "declared"];
+const VIEW_COLOR_OPTIONS = ["auto", "always", "never"];
+const isViewMode = (value) => VIEW_MODES.includes(value);
+const isViewShow = (value) => VIEW_SHOW_OPTIONS.includes(value);
+const manifestPathFor = (inputPath) => path.basename(inputPath) === "Spawnfile"
+    ? path.resolve(inputPath)
+    : path.resolve(inputPath, "Spawnfile");
+const hasResolvedSpawnfile = async (inputPath) => {
+    try {
+        return (await stat(manifestPathFor(inputPath))).isFile();
+    }
+    catch {
+        return false;
+    }
+};
+const suggestModeOptionForPathToken = async (inputPath) => {
+    if (!inputPath || !isViewMode(inputPath) || await hasResolvedSpawnfile(inputPath)) {
+        return;
+    }
+    throw new SpawnfileError("validation_error", `No Spawnfile found for path "${inputPath}". Did you mean "spawnfile view --mode ${inputPath}"?`);
+};
+const resolveColor = (color, environment) => {
+    if (color === "always") {
+        return true;
+    }
+    if (color === "never") {
+        return false;
+    }
+    return environment.stdoutIsTty && !environment.ci && !environment.noColor;
+};
+const parseShowLayers = (value) => {
+    const layers = new Set();
+    if (!value) {
+        return layers;
+    }
+    for (const layer of value.split(",")) {
+        const normalized = layer.trim();
+        if (!isViewShow(normalized)) {
+            throw new SpawnfileError("validation_error", `Unsupported view detail layer "${normalized}". Supported layers: paths, declared.`);
+        }
+        layers.add(normalized);
+    }
+    return layers;
+};
+const toRenderOptions = (options, environment) => {
+    const showLayers = parseShowLayers(options.show);
+    if (options.paths) {
+        showLayers.add("paths");
+    }
+    return {
+        ascii: options.ascii,
+        color: resolveColor(options.color, environment),
+        declared: showLayers.has("declared"),
+        paths: showLayers.has("paths")
+    };
+};
+const emitRenderedView = (streams, output) => {
+    for (const line of output.split("\n")) {
+        streams.stdout(line);
+    }
+};
+export const registerViewCommand = (program, handlers, streams, renderEnvironment) => {
+    program
+        .command("view")
+        .description("Render a read-only organization view")
+        .argument("[path]", "Project directory or Spawnfile path")
+        .addOption(new Option("--mode <mode>", "View mode").choices(VIEW_MODES).default("tree"))
+        .option("--show <show>", "Comma-separated additional details")
+        .option("--ascii", "Use ASCII tree connectors")
+        .addOption(new Option("--color <when>", "Color output").choices(VIEW_COLOR_OPTIONS).default("auto"))
+        .option("--paths", "Show source paths")
+        .action(async (inputPath, options) => {
+        await suggestModeOptionForPathToken(inputPath);
+        const renderOptions = toRenderOptions(options, renderEnvironment);
+        const view = await handlers.buildOrganizationView(inputPath ?? process.cwd());
+        const output = options.mode === "networks"
+            ? renderOrganizationNetworks(view, renderOptions)
+            : renderOrganizationTree(view, renderOptions);
+        emitRenderedView(streams, output);
+    });
+};

package/dist/compiler/agentSurfaces.js

@@ -5,6 +5,7 @@ export const resolveAgentSurfaces = (surfaces) => {
     }
     const resolved = {};
     if (surfaces.discord) {
+        const identity = surfaces.discord.identity;
         resolved.discord = {
             ...(surfaces.discord.access
                 ? {
@@ -16,10 +17,41 @@ export const resolveAgentSurfaces = (surfaces) => {
                     }
                 }
                 : {}),
-            botTokenSecret: surfaces.discord.bot_token_secret ?? DEFAULT_DISCORD_BOT_TOKEN_SECRET
+            botTokenSecret: surfaces.discord.bot_token_secret ?? DEFAULT_DISCORD_BOT_TOKEN_SECRET,
+            ...(identity ? { identity: { userId: identity.user_id } } : {})
         };
     }
+    if (surfaces.moltnet) {
+        resolved.moltnet = surfaces.moltnet.map((attachment) => ({
+            ...(attachment.dms
+                ? {
+                    dms: {
+                        enabled: attachment.dms.enabled,
+                        ...(attachment.dms.read ? { read: attachment.dms.read } : {}),
+                        ...(attachment.dms.reply ? { reply: attachment.dms.reply } : {})
+                    }
+                }
+                : {}),
+            memberId: null,
+            network: attachment.network,
+            ...(attachment.rooms
+                ? {
+                    rooms: Object.fromEntries(Object.entries(attachment.rooms)
+                        .sort(([left], [right]) => left.localeCompare(right))
+                        .map(([roomId, behavior]) => [
+                        roomId,
+                        {
+                            ...(behavior.read ? { read: behavior.read } : {}),
+                            ...(behavior.reply ? { reply: behavior.reply } : {})
+                        }
+                    ]))
+                }
+                : {}),
+            teamSource: null
+        }));
+    }
     if (surfaces.telegram) {
+        const identity = surfaces.telegram.identity;
         resolved.telegram = {
             ...(surfaces.telegram.access
                 ? {
@@ -30,21 +62,34 @@ export const resolveAgentSurfaces = (surfaces) => {
                     }
                 }
                 : {}),
-            botTokenSecret: surfaces.telegram.bot_token_secret ?? DEFAULT_TELEGRAM_BOT_TOKEN_SECRET
+            botTokenSecret: surfaces.telegram.bot_token_secret ?? DEFAULT_TELEGRAM_BOT_TOKEN_SECRET,
+            ...(identity
+                ? {
+                    identity: {
+                        ...(identity.user_id ? { userId: identity.user_id } : {}),
+                        ...(identity.username ? { username: identity.username } : {})
+                    }
+                }
+                : {})
         };
     }
     if (surfaces.whatsapp) {
+        const identity = surfaces.whatsapp.identity;
         resolved.whatsapp = surfaces.whatsapp.access
             ? {
                 access: {
                     groups: [...(surfaces.whatsapp.access.groups ?? [])],
                     mode: surfaces.whatsapp.access.mode ?? "allowlist",
                     users: [...(surfaces.whatsapp.access.users ?? [])]
-                }
+                },
+                ...(identity ? { identity: { phone: identity.phone } } : {})
             }
-            : {};
+            : {
+                ...(identity ? { identity: { phone: identity.phone } } : {})
+            };
     }
     if (surfaces.slack) {
+        const identity = surfaces.slack.identity;
         resolved.slack = {
             ...(surfaces.slack.access
                 ? {
@@ -56,7 +101,8 @@ export const resolveAgentSurfaces = (surfaces) => {
                 }
                 : {}),
             appTokenSecret: surfaces.slack.app_token_secret ?? DEFAULT_SLACK_APP_TOKEN_SECRET,
-            botTokenSecret: surfaces.slack.bot_token_secret ?? DEFAULT_SLACK_BOT_TOKEN_SECRET
+            botTokenSecret: surfaces.slack.bot_token_secret ?? DEFAULT_SLACK_BOT_TOKEN_SECRET,
+            ...(identity ? { identity: { userId: identity.user_id } } : {})
         };
     }
     return Object.keys(resolved).length > 0 ? resolved : undefined;