crow-central-agency 0.24.0

package/dist/_shared/schemas/agent.schema.js

@@ -0,0 +1,209 @@
+import { z } from "zod";
+import { DiscordConfigSchema } from "./discord-config.schema.js";
+import { DayOfWeekSchema, SchedulerTimeSchema, TIME_MODE, TimeModeSchema } from "./scheduler.schema.js";
+export const CLAUDE_MODELS = {
+    HAIKU: "claude-haiku-4-5",
+    SONNET: "claude-sonnet-4-6",
+    SONNET_4_5: "claude-sonnet-4-5",
+    OPUS: "claude-opus-4-7",
+    OPUS_4_6: "claude-opus-4-6",
+    OPUS_4_5: "claude-opus-4-5",
+};
+export const CLAUDE_CODE_MODEL_OPTIONS = [
+    { value: CLAUDE_MODELS.SONNET, label: "Claude Sonnet 4.6" },
+    { value: CLAUDE_MODELS.OPUS, label: "Claude Opus 4.7" },
+    { value: CLAUDE_MODELS.HAIKU, label: "Claude Haiku 4.5" },
+];
+/** Default model for new agents */
+export const DEFAULT_MODEL = CLAUDE_MODELS.SONNET;
+/**
+ * Tool configuration modes for agent tool availability.
+ */
+export const TOOL_MODE = {
+    /** All tools available - pass undefined to SDK */
+    UNRESTRICTED: "unrestricted",
+    /** User-selected tool subset - pass explicit string[] to SDK */
+    RESTRICTED: "restricted",
+};
+/** The SDK tool name used to launch a subagent */
+export const SUBAGENT_TOOL_NAME = "Agent";
+/**
+ * Default available tools for new agent creation.
+ */
+export const DEFAULT_AVAILABLE_TOOLS = [
+    "AskUserQuestion",
+    "Bash",
+    "Glob",
+    "Grep",
+    "Read",
+    "Edit",
+    "Write",
+    "WebFetch",
+    "WebSearch",
+    "Task",
+    "TaskOutput",
+    "TaskStop",
+    "TodoWrite",
+    "NotebookEdit",
+    "Skill",
+    "EnterPlanMode",
+    "ExitPlanMode",
+    "EnterWorktree",
+    "ExitWorktree",
+    "CronCreate",
+    "CronDelete",
+    "CronList",
+    "ToolSearch",
+];
+/**
+ * Setting sources matching SDK SettingSource type.
+ * Controls which SDK configuration sources are included in agent queries.
+ */
+export const SETTING_SOURCE = {
+    USER: "user",
+    PROJECT: "project",
+    LOCAL: "local",
+};
+/** Default setting sources for new agent creation */
+export const DEFAULT_SETTING_SOURCES = [
+    SETTING_SOURCE.USER,
+    SETTING_SOURCE.PROJECT,
+    SETTING_SOURCE.LOCAL,
+];
+/**
+ * Permission modes matching SDK PermissionMode type.
+ * Controls how tool permissions are handled during agent execution.
+ */
+export const PERMISSION_MODE = {
+    DEFAULT: "default",
+    ACCEPT_EDITS: "acceptEdits",
+    BYPASS_PERMISSIONS: "bypassPermissions",
+    PLAN: "plan",
+    DONT_ASK: "dontAsk",
+};
+export const AGENT_TYPE = {
+    CLAUDE_CODE: "CLAUDE_CODE",
+};
+export const AgentIdSchema = z.uuid();
+/** Maximum number of time entries allowed in a loop config */
+export const MAX_LOOP_TIMES = 6;
+/** Loop configuration */
+export const LoopConfigSchema = z.object({
+    enabled: z.boolean().default(false),
+    daysOfWeek: z.array(DayOfWeekSchema).default([]),
+    timeMode: TimeModeSchema.default(TIME_MODE.EVERY),
+    times: z.array(SchedulerTimeSchema).min(1).max(MAX_LOOP_TIMES).default([{}]),
+    prompt: z.string(),
+});
+export const ConfiguredFeedSchema = z.object({
+    feedId: z.string(),
+    isNotify: z.boolean().optional(),
+});
+export const PermissionModeSchema = z.enum([
+    PERMISSION_MODE.DEFAULT,
+    PERMISSION_MODE.ACCEPT_EDITS,
+    PERMISSION_MODE.BYPASS_PERMISSIONS,
+    PERMISSION_MODE.PLAN,
+    PERMISSION_MODE.DONT_ASK,
+]);
+export const SettingSourceSchema = z.enum([SETTING_SOURCE.USER, SETTING_SOURCE.PROJECT, SETTING_SOURCE.LOCAL]);
+/**
+ * Tool configuration for agent
+ */
+export const ToolConfigSchema = z.object({
+    mode: z.enum([TOOL_MODE.UNRESTRICTED, TOOL_MODE.RESTRICTED]).default(TOOL_MODE.UNRESTRICTED),
+    tools: z.array(z.string()).optional(),
+    autoApprovedTools: z.array(z.string()).optional(),
+    disallowedTools: z.array(z.string()).optional(),
+});
+/**
+ * Full agent configuration - persisted to disk in agents.json
+ */
+export const AgentConfigSchema = z.object({
+    id: AgentIdSchema,
+    type: z.enum([AGENT_TYPE.CLAUDE_CODE]),
+    name: z.string().min(1).max(64),
+    description: z.string().optional(),
+    workspace: z.string().min(1).optional(),
+    persona: z.string().optional(),
+    model: z.string().default(DEFAULT_MODEL),
+    permissionMode: PermissionModeSchema.default(PERMISSION_MODE.DEFAULT),
+    settingSources: z.array(SettingSourceSchema).default([...DEFAULT_SETTING_SOURCES]),
+    availableTools: z.array(z.string()).optional(),
+    toolConfig: ToolConfigSchema.default({ mode: TOOL_MODE.UNRESTRICTED }),
+    /** IDs of user-configured MCP servers enabled for this agent */
+    mcpServerIds: z.array(z.string()).optional(),
+    configuredFeeds: z.array(ConfiguredFeedSchema).optional(),
+    sensorIds: z.array(z.string()).optional(),
+    loop: LoopConfigSchema.optional(),
+    discordConfig: DiscordConfigSchema.optional(),
+    persistSession: z.boolean().optional(),
+    isPinned: z.boolean().optional(),
+    excludeClaudeCodeSystemPrompt: z.boolean().optional(),
+    /** System agents are built-in and cannot be edited, deleted, or persisted */
+    isSystemAgent: z.boolean().optional(),
+    /** Background agents does not show up in the list */
+    isBackgroundAgent: z.boolean().optional(),
+    createdAt: z.iso.datetime({ offset: true }),
+    updatedAt: z.iso.datetime({ offset: true }),
+});
+/**
+ * Input for creating a new agent - only required fields
+ */
+export const CreateAgentInputSchema = z.object({
+    name: z.string().min(1).max(50),
+    description: z.string().optional(),
+    workspace: z.string().min(1).optional(),
+    persona: z.string().optional(),
+    model: z.string().optional(),
+    permissionMode: PermissionModeSchema.optional(),
+    settingSources: z.array(SettingSourceSchema).optional(),
+    toolConfig: ToolConfigSchema.optional(),
+    mcpServerIds: z.array(z.string()).optional(),
+    configuredFeeds: z.array(ConfiguredFeedSchema).optional(),
+    sensorIds: z.array(z.string()).optional(),
+    loop: LoopConfigSchema.optional(),
+    discordConfig: DiscordConfigSchema.optional(),
+    excludeClaudeCodeSystemPrompt: z.boolean().optional(),
+    agentMd: z.string().optional(),
+});
+/**
+ * Input for updating an existing agent - all fields optional
+ */
+export const UpdateAgentInputSchema = z.object({
+    name: z.string().min(1).max(50).optional(),
+    description: z.string().optional(),
+    workspace: z.string().optional(),
+    persona: z.string().optional(),
+    model: z.string().optional(),
+    permissionMode: PermissionModeSchema.optional(),
+    settingSources: z.array(SettingSourceSchema).optional(),
+    toolConfig: ToolConfigSchema.optional(),
+    mcpServerIds: z.array(z.string()).optional(),
+    configuredFeeds: z.array(ConfiguredFeedSchema).optional(),
+    sensorIds: z.array(z.string()).optional(),
+    loop: LoopConfigSchema.optional(),
+    discordConfig: DiscordConfigSchema.optional(),
+    isPinned: z.boolean().optional(),
+    excludeClaudeCodeSystemPrompt: z.boolean().optional(),
+    agentMd: z.string().optional(),
+});
+export const AgentConfigTemplateSchema = AgentConfigSchema.pick({
+    description: true,
+    workspace: true,
+    persona: true,
+    model: true,
+    permissionMode: true,
+    settingSources: true,
+    availableTools: true,
+    toolConfig: true,
+    mcpServerIds: true,
+    configuredFeeds: true,
+    sensorIds: true,
+    loop: true,
+}).extend({
+    templateId: z.uuid(),
+    templateName: z.string().min(1).max(64),
+    agentMd: z.string().optional(),
+});
+//# sourceMappingURL=agent.schema.js.map

package/dist/_shared/schemas/api-response.schema.js

@@ -0,0 +1,19 @@
+import { z } from "zod";
+/**
+ * Standard API success response wrapper
+ */
+export const createApiSuccessSchema = (dataSchema) => z.object({
+    success: z.literal(true),
+    data: dataSchema,
+});
+/**
+ * Standard API error response
+ */
+export const ApiErrorSchema = z.object({
+    success: z.literal(false),
+    error: z.object({
+        code: z.string(),
+        message: z.string(),
+    }),
+});
+//# sourceMappingURL=api-response.schema.js.map

package/dist/_shared/schemas/artifact.schema.js

@@ -0,0 +1,49 @@
+import { z } from "zod";
+import { EntityTypeSchema } from "./agent-circle.schema.js";
+import { AgentTaskSourceSchema } from "./agent-task.schema.js";
+/**
+ * TODO: layered memory system via artifacts.
+ */
+export const ARTIFACT_TYPE = {
+    STANDARD: "STANDARD",
+    TEMPORARY: "TEMPORARY",
+    STRONG: "STRONG",
+    NEAR: "NEAR",
+    LOOSE: "LOOSE",
+    USER: "USER",
+};
+export const ARTIFACT_CONTENT_TYPE = {
+    TEXT: "TEXT",
+    BINARY: "BINARY",
+    IMAGE: "IMAGE",
+    AUDIO: "AUDIO",
+};
+export const ArtifactTypeSchema = z.enum([
+    ARTIFACT_TYPE.STANDARD,
+    ARTIFACT_TYPE.TEMPORARY,
+    ARTIFACT_TYPE.STRONG,
+    ARTIFACT_TYPE.NEAR,
+    ARTIFACT_TYPE.LOOSE,
+    ARTIFACT_TYPE.USER,
+]);
+export const ArtifactContentTypeSchema = z.enum([
+    ARTIFACT_CONTENT_TYPE.TEXT,
+    ARTIFACT_CONTENT_TYPE.BINARY,
+    ARTIFACT_CONTENT_TYPE.IMAGE,
+    ARTIFACT_CONTENT_TYPE.AUDIO,
+]);
+/**
+ * Schema for artifact file metadata
+ */
+export const ArtifactMetadataSchema = z.object({
+    filename: z.string(),
+    type: ArtifactTypeSchema,
+    contentType: ArtifactContentTypeSchema,
+    entityId: z.string(),
+    entityType: EntityTypeSchema,
+    size: z.number(),
+    createdTimestamp: z.number(),
+    updatedTimestamp: z.number(),
+    createdBy: AgentTaskSourceSchema,
+});
+//# sourceMappingURL=artifact.schema.js.map

package/dist/_shared/schemas/discord-config.schema.js

@@ -0,0 +1,21 @@
+import { z } from "zod";
+/**
+ * Discord bot configuration for an agent.
+ * When present on an agent config, a discord.js bot is created for that agent.
+ * By default (no channelIds), the bot only responds to direct messages.
+ */
+export const DiscordConfigSchema = z.object({
+    /** Whether the Discord bot is active */
+    enabled: z.boolean().default(false),
+    /** Discord bot token from the Discord Developer Portal */
+    botToken: z.string().optional(),
+    /** Optional guild channel IDs the bot listens in. If omitted, bot only responds to DMs. */
+    channelIds: z.array(z.string().min(1)).optional(),
+    /** Optional Discord user IDs allowed to interact. If omitted, any user can interact. */
+    allowedUserIds: z.array(z.string().min(1)).optional(),
+    /** When true, the bot only responds when @mentioned in guild channels (does not affect DMs). */
+    respondToMentionsOnly: z.boolean().default(false),
+    /** When true, sync the Discord bot username to match the agent name. */
+    syncBotName: z.boolean().default(false),
+});
+//# sourceMappingURL=discord-config.schema.js.map

package/dist/_shared/schemas/feed.schema.js

@@ -0,0 +1,10 @@
+import { z } from "zod";
+/** Input schema for adding a new feed by URL */
+export const AddFeedInputSchema = z.object({
+    feedUrl: z.url(),
+});
+/** Input schema for detecting feeds advertised on a page */
+export const DetectFeedsInputSchema = z.object({
+    url: z.url(),
+});
+//# sourceMappingURL=feed.schema.js.map

package/dist/_shared/schemas/graph.schema.js

@@ -0,0 +1,28 @@
+import { z } from "zod";
+import { EntityTypeSchema, RelationshipTypeSchema } from "./agent-circle.schema.js";
+import { AGENT_STATUS } from "./agent-runtime-state.schema.js";
+/** A node in the relationship graph — represents either an agent or a circle */
+export const GraphNodeSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    entityType: EntityTypeSchema,
+    isSystemAgent: z.boolean().optional(),
+    isPinned: z.boolean().optional(),
+    isSystemCircle: z.boolean().optional(),
+    status: z
+        .enum([AGENT_STATUS.IDLE, AGENT_STATUS.ACTIVATING, AGENT_STATUS.STREAMING, AGENT_STATUS.COMPACTING])
+        .optional(),
+});
+/** An edge in the relationship graph — represents a membership relationship */
+export const GraphEdgeSchema = z.object({
+    id: z.string(),
+    source: z.string(),
+    target: z.string(),
+    relationshipType: RelationshipTypeSchema,
+});
+/** Complete graph data returned by GET /api/graph */
+export const GraphDataSchema = z.object({
+    nodes: z.array(GraphNodeSchema),
+    edges: z.array(GraphEdgeSchema),
+});
+//# sourceMappingURL=graph.schema.js.map

package/dist/_shared/schemas/mcp-config.schema.js

@@ -0,0 +1,49 @@
+import { z } from "zod";
+/** MCP server configuration transport types */
+export const MCP_CONFIG_TYPE = {
+    STDIO: "stdio",
+    SSE: "sse",
+    HTTP: "http",
+};
+/** Zod schema for local (stdio) MCP server config */
+const LocalMcpConfigSchema = z.object({
+    type: z.literal(MCP_CONFIG_TYPE.STDIO),
+    id: z.uuid(),
+    name: z.string().min(1).max(64),
+    description: z.string().optional(),
+    isDisabled: z.boolean().optional(),
+    /** When true, this server is automatically available to the Crow system agent */
+    enableForCrow: z.boolean().optional(),
+    command: z.string().min(1),
+    args: z.array(z.string()).optional(),
+    env: z.record(z.string(), z.string()).optional(),
+});
+/** Zod schema for remote (SSE/HTTP) MCP server config */
+const RemoteMcpConfigSchema = z.object({
+    type: z.enum([MCP_CONFIG_TYPE.SSE, MCP_CONFIG_TYPE.HTTP]),
+    id: z.uuid(),
+    name: z.string().min(1).max(64),
+    description: z.string().optional(),
+    isDisabled: z.boolean().optional(),
+    /** When true, this server is automatically available to the Crow system agent */
+    enableForCrow: z.boolean().optional(),
+    url: z.url(),
+    headers: z.record(z.string(), z.string()).optional(),
+});
+/** Discriminated union schema for any MCP server config */
+export const McpServerConfigSchema = z.discriminatedUnion("type", [LocalMcpConfigSchema, RemoteMcpConfigSchema]);
+/** Input for creating a new MCP config - id is generated server-side */
+const CreateLocalMcpConfigInputSchema = LocalMcpConfigSchema.omit({ id: true });
+const CreateRemoteMcpConfigInputSchema = RemoteMcpConfigSchema.omit({ id: true });
+export const CreateMcpConfigInputSchema = z.discriminatedUnion("type", [
+    CreateLocalMcpConfigInputSchema,
+    CreateRemoteMcpConfigInputSchema,
+]);
+/** Input for updating an existing MCP config - partial fields, type required for discrimination */
+const UpdateLocalMcpConfigInputSchema = CreateLocalMcpConfigInputSchema.partial().required({ type: true });
+const UpdateRemoteMcpConfigInputSchema = CreateRemoteMcpConfigInputSchema.partial().required({ type: true });
+export const UpdateMcpConfigInputSchema = z.discriminatedUnion("type", [
+    UpdateLocalMcpConfigInputSchema,
+    UpdateRemoteMcpConfigInputSchema,
+]);
+//# sourceMappingURL=mcp-config.schema.js.map

package/dist/_shared/schemas/message-source.schema.js

@@ -0,0 +1,30 @@
+import { z } from "zod";
+/** Source type identifiers for messages */
+export const MESSAGE_SOURCE_TYPE = {
+    USER: "USER",
+    LOOP: "LOOP",
+    AGENT: "AGENT",
+    TASK: "TASK",
+    TASK_RESULT: "TASK_RESULT",
+    RECOVERY: "RECOVERY",
+    NOTIFICATION: "NOTIFICATION",
+    DISCORD: "DISCORD",
+};
+/** Zod schema for message source — identifies who originated a message */
+export const MessageSourceSchema = z.discriminatedUnion("sourceType", [
+    z.object({ sourceType: z.literal(MESSAGE_SOURCE_TYPE.USER) }),
+    z.object({ sourceType: z.literal(MESSAGE_SOURCE_TYPE.LOOP) }),
+    z.object({ sourceType: z.literal(MESSAGE_SOURCE_TYPE.AGENT), agentId: z.string() }),
+    z.object({ sourceType: z.literal(MESSAGE_SOURCE_TYPE.TASK), taskId: z.string() }),
+    z.object({ sourceType: z.literal(MESSAGE_SOURCE_TYPE.TASK_RESULT), taskId: z.string() }),
+    z.object({ sourceType: z.literal(MESSAGE_SOURCE_TYPE.RECOVERY) }),
+    z.object({ sourceType: z.literal(MESSAGE_SOURCE_TYPE.NOTIFICATION) }),
+    z.object({
+        sourceType: z.literal(MESSAGE_SOURCE_TYPE.DISCORD),
+        channelId: z.string(),
+        discordUserId: z.string(),
+        discordUsername: z.string(),
+        isDm: z.boolean(),
+    }),
+]);
+//# sourceMappingURL=message-source.schema.js.map

package/dist/_shared/schemas/permission.schema.js

@@ -0,0 +1,24 @@
+import { z } from "zod";
+/** Valid decisions for a permission request */
+export const PERMISSION_DECISION = {
+    ALLOW: "allow",
+    DENY: "deny",
+};
+/**
+ * Schema for a permission request broadcast to clients
+ */
+export const PermissionRequestSchema = z.object({
+    requestId: z.string(),
+    agentId: z.string(),
+    toolName: z.string(),
+    input: z.record(z.string(), z.unknown()).optional(),
+    timestamp: z.iso.datetime({ offset: true }),
+});
+/**
+ * Schema for a permission response from a client
+ */
+export const PermissionResponseSchema = z.object({
+    requestId: z.string(),
+    decision: z.enum([PERMISSION_DECISION.ALLOW, PERMISSION_DECISION.DENY]),
+});
+//# sourceMappingURL=permission.schema.js.map

package/dist/_shared/schemas/scheduler.schema.js

@@ -0,0 +1,32 @@
+import { z } from "zod";
+export const DAY_OF_WEEK = {
+    MONDAY: "monday",
+    TUESDAY: "tuesday",
+    WEDNESDAY: "wednesday",
+    THURSDAY: "thursday",
+    FRIDAY: "friday",
+    SATURDAY: "saturday",
+    SUNDAY: "sunday",
+};
+/** Zod schema for DayOfWeek values */
+export const DayOfWeekSchema = z.enum([
+    DAY_OF_WEEK.MONDAY,
+    DAY_OF_WEEK.TUESDAY,
+    DAY_OF_WEEK.WEDNESDAY,
+    DAY_OF_WEEK.THURSDAY,
+    DAY_OF_WEEK.FRIDAY,
+    DAY_OF_WEEK.SATURDAY,
+    DAY_OF_WEEK.SUNDAY,
+]);
+/** Zod schema for TimeMode values */
+export const TimeModeSchema = z.enum(["AT", "EVERY"]);
+export const TIME_MODE = TimeModeSchema.enum;
+/**
+ * A single time point - hour and minute pair.
+ * Both are optional to allow partial specs (e.g. minute-only for "every N minutes").
+ */
+export const SchedulerTimeSchema = z.object({
+    hour: z.number().int().min(0).max(23).optional(),
+    minute: z.number().int().min(0).max(59).optional(),
+});
+//# sourceMappingURL=scheduler.schema.js.map

package/dist/_shared/schemas/sensor.schema.js

@@ -0,0 +1,7 @@
+import { z } from "zod";
+/** Lightweight sensor descriptor returned by GET /api/sensors */
+export const SensorInfoSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+});
+//# sourceMappingURL=sensor.schema.js.map

package/dist/_shared/schemas/system-settings.schema.js

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import { ConfiguredFeedSchema } from "./agent.schema.js";
+/** Settings scoped to the Super Crow system agent. */
+export const SuperCrowSettingsSchema = z.object({
+    configuredFeeds: z.array(ConfiguredFeedSchema).default([]),
+});
+/** Partial update payload for super-crow settings. */
+export const UpdateSuperCrowSettingsInputSchema = z.object({
+    configuredFeeds: z.array(ConfiguredFeedSchema).optional(),
+});
+/** Dashboard UX preferences — persisted user settings for the dashboard view. */
+export const DashboardSettingsSchema = z.object({
+    /**
+     * Per-circle custom agent ordering. Key = circleId, value = agentId[] in
+     * display order. Missing circles fall back to the backend-provided order.
+     * Ids that no longer belong to the circle are ignored at render time.
+     */
+    circleAgentOrder: z.record(z.string(), z.array(z.string())).default({}),
+    /**
+     * Custom ordering of pinned agents on the dashboard. Ids no longer pinned
+     * are ignored at render time; newly pinned agents append at the end.
+     */
+    pinnedAgentOrder: z.array(z.string()).default([]),
+});
+/** Partial update payload for dashboard settings. */
+export const UpdateDashboardSettingsInputSchema = z.object({
+    circleAgentOrder: z.record(z.string(), z.array(z.string())).optional(),
+    pinnedAgentOrder: z.array(z.string()).optional(),
+});
+//# sourceMappingURL=system-settings.schema.js.map