crow-central-agency 0.27.0 → 0.27.2

package/README.md

@@ -95,6 +95,7 @@ See `.env.example` for the full list, including:
 - `HOST` / `PORT` — server bind address (defaults: `localhost:3101`). Keep `HOST=localhost` and front the server with a secure tunnel for remote access rather than binding to `0.0.0.0`.
 - `CORS_ORIGINS` — only needed when the frontend is served from a different origin (e.g. during frontend dev). Single-box deployments can leave it unset.
 - `LOG_LEVEL` — log verbosity (defaults to `debug` in development, `info` otherwise).
+- `LOG_PRETTY` — force human-readable, colorized logs (pino-pretty) even in production. Enabled automatically in development.
 - `CROW_SYSTEM_PATH` — directory for Crow's file-based storage. Defaults to `~/.crow`.
 - `CROW_SYSTEM_AGENT_NAME` — display name for the built-in Crow system agent (default: `Crow`).
 - `CROW_SYSTEM_AGENT_PROVIDER` — provider backing the built-in system agents: `claude` or `copilot` (default: `claude`). Forced to `claude` when `DISABLE_GITHUB_COPILOT` is set.

package/dist/_shared/auto-approve/auto-approve-rule-set.js

@@ -1,3 +1,4 @@
+import { SUBCOMMAND_MATCH_MODE } from "./command-decomposition.js";
 import { parseRule } from "./rule-format.js";
 import { getRuleStrategy } from "./rule-strategy-registry.js";
 /**
@@ -23,8 +24,8 @@ export class AutoApproveRuleSet {
             }
         }
     }
-    matches(toolName, input) {
-        return getRuleStrategy(toolName).matches(toolName, input, this.parsed);
+    matches(toolName, input, mode = SUBCOMMAND_MATCH_MODE.ALL) {
+        return getRuleStrategy(toolName).matches(toolName, input, this.parsed, mode);
     }
 }
 //# sourceMappingURL=auto-approve-rule-set.js.map

package/dist/_shared/auto-approve/command-decomposition.js

@@ -1,6 +1,14 @@
 import { matchesSpecifier, WORD_BOUNDARY_SUFFIX } from "./rule-format.js";
-/** Prefix depth for derived rules (first N tokens of a subcommand). */
-export const DEFAULT_PREFIX_DEPTH = 2;
+/** Number of non-flag tokens a derived prefix keeps before wildcarding the rest. */
+export const DEFAULT_PREFIX_DEPTH = 3;
+/**
+ * How a compound command aggregates per-subcommand matches. `ALL` (approve) requires every
+ * subcommand to match a specifier; `ANY` (deny) fires when a single subcommand matches.
+ */
+export const SUBCOMMAND_MATCH_MODE = {
+    ALL: "all",
+    ANY: "any",
+};
 /** Maximum number of rules derived from a single compound command, mirroring the SDK cap. */
 export const MAX_DERIVED_RULES = 5;
 /**
@@ -16,29 +24,7 @@ export const SINGLE_CHAR_SEPARATORS = [";", "|", "&", "\n", "\r"];
 export const PROCESS_WRAPPERS = new Set(["timeout", "time", "nice", "nohup", "stdbuf"]);
 const WRAPPERS_WITH_NUMERIC_ARG = new Set(["timeout", "nice"]);
 const XARGS_WRAPPER = "xargs";
-/**
- * Read-only shell builtins that run with no prompt. `cd` and `git` are handled separately
- * (in-cwd `cd` only; read-only `git` subcommands only).
- */
-export const READ_ONLY_BUILTINS = new Set([
-    "ls",
-    "cat",
-    "echo",
-    "pwd",
-    "head",
-    "tail",
-    "grep",
-    "find",
-    "wc",
-    "which",
-    "diff",
-    "stat",
-    "du",
-]);
-const CD_COMMAND = "cd";
-const IN_CWD_CD_ARGS = new Set([".", "./"]);
-const GIT_COMMAND = "git";
-const READ_ONLY_GIT_SUBCOMMANDS = new Set(["status", "log", "diff", "show"]);
+const OPTION_PREFIX = "-";
 const SINGLE_QUOTE = "'";
 const DOUBLE_QUOTE = '"';
 const REDIRECT_CHAR = ">";
@@ -109,7 +95,7 @@ function stripWrappers(tokens) {
         if (head === XARGS_WRAPPER) {
             // Only bare `xargs` (no flags) is transparent; flagged xargs stays and simply won't match.
             const next = remaining[1];
-            if (next !== undefined && next.startsWith("-")) {
+            if (next !== undefined && next.startsWith(OPTION_PREFIX)) {
                 break;
             }
             remaining = remaining.slice(1);
@@ -119,7 +105,7 @@ function stripWrappers(tokens) {
             break;
         }
         remaining = remaining.slice(1);
-        while (remaining.length > 0 && remaining[0].startsWith("-")) {
+        while (remaining.length > 0 && remaining[0].startsWith(OPTION_PREFIX)) {
             remaining = remaining.slice(1);
         }
         if (WRAPPERS_WITH_NUMERIC_ARG.has(head) && remaining.length > 0 && /^[0-9]/.test(remaining[0])) {
@@ -174,26 +160,31 @@ export function splitSubcommands(command) {
     }
     return subcommands;
 }
-/** Whether a normalized subcommand is a read-only builtin, in-cwd `cd`, or read-only `git`. */
-export function isReadOnlyCommand(subcommand) {
-    const tokens = tokenize(subcommand);
-    const head = tokens[0];
-    if (head === undefined) {
-        return false;
-    }
-    if (head === CD_COMMAND) {
-        const target = tokens[1];
-        return target === undefined || IN_CWD_CD_ARGS.has(target);
-    }
-    if (head === GIT_COMMAND) {
-        const gitSubcommand = tokens[1];
-        return gitSubcommand !== undefined && READ_ONLY_GIT_SUBCOMMANDS.has(gitSubcommand);
+function derivePrefixTokens(tokens, depth) {
+    const prefix = [];
+    let counted = 0;
+    let index = 0;
+    while (index < tokens.length && counted < depth) {
+        const token = tokens[index];
+        if (token.startsWith(OPTION_PREFIX)) {
+            prefix.push(token);
+            index += 1;
+            if (index < tokens.length && !tokens[index].startsWith(OPTION_PREFIX)) {
+                prefix.push(tokens[index]);
+                index += 1;
+            }
+            continue;
+        }
+        prefix.push(token);
+        counted += 1;
+        index += 1;
     }
-    return READ_ONLY_BUILTINS.has(head);
+    return counted === 0 ? undefined : prefix;
 }
 /**
- * Capture side: derive one prefix-`depth` specifier per non-read-only subcommand (in-cwd `cd` and
- * read-only builtins contribute nothing), deduped and capped at {@link MAX_DERIVED_RULES}.
+ * Capture side: derive one flag-aware prefix specifier per subcommand, deduped and capped at
+ * {@link MAX_DERIVED_RULES}. A subcommand with no non-flag token (e.g. a lone `--flag`) contributes
+ * nothing. User config is the only auto-approve authority — there is no read-only skip.
  */
 export function deriveRules(command, depth = DEFAULT_PREFIX_DEPTH) {
     const specifiers = [];
@@ -201,15 +192,11 @@ export function deriveRules(command, depth = DEFAULT_PREFIX_DEPTH) {
         if (specifiers.length >= MAX_DERIVED_RULES) {
             break;
         }
-        if (isReadOnlyCommand(subcommand)) {
-            continue;
-        }
-        const tokens = tokenize(subcommand);
-        if (tokens.length === 0) {
+        const prefixTokens = derivePrefixTokens(tokenize(subcommand), depth);
+        if (prefixTokens === undefined) {
             continue;
         }
-        const prefix = tokens.slice(0, depth).join(" ");
-        const specifier = `${prefix}${WORD_BOUNDARY_SUFFIX}`;
+        const specifier = `${prefixTokens.join(" ")}${WORD_BOUNDARY_SUFFIX}`;
         if (!specifiers.includes(specifier)) {
             specifiers.push(specifier);
         }
@@ -217,22 +204,19 @@ export function deriveRules(command, depth = DEFAULT_PREFIX_DEPTH) {
     return specifiers;
 }
 /**
- * Match side: fails closed. Every subcommand must be a read-only builtin or match one of the
- * specifiers. Empty/unparseable input yields `false`.
+ * Match side: fails closed. Each raw subcommand is matched against the specifiers via literal-prefix
+ * `matchesSpecifier` (no flag logic on this side). `ALL` (approve) requires every subcommand to
+ * match; `ANY` (deny) fires when a single subcommand matches. Empty/unparseable input yields `false`
+ * in both modes.
  */
-export function matchesRules(command, specifiers) {
+export function matchesRules(command, specifiers, mode = SUBCOMMAND_MATCH_MODE.ALL) {
     const subcommands = splitSubcommands(command);
     if (subcommands.length === 0) {
         return false;
     }
-    for (const subcommand of subcommands) {
-        if (isReadOnlyCommand(subcommand)) {
-            continue;
-        }
-        if (!specifiers.some((specifier) => matchesSpecifier(subcommand, specifier))) {
-            return false;
-        }
-    }
-    return true;
+    const subcommandMatches = (subcommand) => specifiers.some((specifier) => matchesSpecifier(subcommand, specifier));
+    return mode === SUBCOMMAND_MATCH_MODE.ANY
+        ? subcommands.some(subcommandMatches)
+        : subcommands.every(subcommandMatches);
 }
 //# sourceMappingURL=command-decomposition.js.map

package/dist/_shared/auto-approve/rule-strategies.js

@@ -12,20 +12,22 @@ const COMMAND_TOOL_BASE_NAMES = new Set([
     CLAUDE_CODE_TOOL.POWER_SHELL.toLowerCase(),
 ]);
 /**
- * Whole-tool matching, preserving the legacy `isToolAutoApproved` behavior: exact tool-name match,
- * plus a trailing `*` (including a bare `*` and MCP prefixes like `mcp__crow-artifacts__*`) as a
- * prefix match.
+ * Whole-tool matching: case-insensitive exact tool-name match, plus a trailing `*` (including a bare
+ * `*` and MCP prefixes like `mcp__crow-artifacts__*`) as a prefix match. Case-insensitivity aligns
+ * with the command strategy (which lowercases the tool name) so a `Bash` rule covers Copilot's
+ * `bash`, for both allow and deny.
  */
 function wholeToolMatches(toolName, rules) {
+    const targetTool = toolName.toLowerCase();
     for (const rule of rules) {
         if (rule.specifier !== undefined) {
             continue;
         }
-        const pattern = rule.tool;
-        if (pattern === toolName) {
+        const pattern = rule.tool.toLowerCase();
+        if (pattern === targetTool) {
             return true;
         }
-        if (pattern.endsWith(GLOB_STAR) && toolName.startsWith(pattern.slice(0, -GLOB_STAR.length))) {
+        if (pattern.endsWith(GLOB_STAR) && targetTool.startsWith(pattern.slice(0, -GLOB_STAR.length))) {
             return true;
         }
     }
@@ -51,7 +53,7 @@ export const commandRuleStrategy = {
         }
         return deriveCommandRules(command).map((specifier) => formatRule({ tool: toolName, specifier }));
     },
-    matches: (toolName, input, rules) => {
+    matches: (toolName, input, rules, mode) => {
         if (wholeToolMatches(toolName, rules)) {
             return true;
         }
@@ -66,7 +68,7 @@ export const commandRuleStrategy = {
                 specifiers.push(rule.specifier);
             }
         }
-        return matchesCommandRules(command, specifiers);
+        return matchesCommandRules(command, specifiers, mode);
     },
 };
 //# sourceMappingURL=rule-strategies.js.map

package/dist/_shared/index.js

@@ -24,11 +24,12 @@ export { CreateFragmentAssociationInputSchema, FRAGMENT_KIND, FRAGMENT_FIRST_LEV
 export { REFLECTION_AGENT_REF, REFLECTION_TEMP_PREFIX, REFLECTION_OP, ReflectionOpSchema, ReflectionPlanSchema, } from "./schemas/fragment-reflection.schema.js";
 export { MESSAGE_SOURCE_TYPE, MessageSourceSchema, } from "./schemas/message-source.schema.js";
 export { AGENT_COMMAND, AgentCommandSchema } from "./schemas/agent-command.schema.js";
-export { GraphNodeSchema, GraphEdgeSchema, GraphDataSchema, } from "./schemas/graph.schema.js";
+export { GraphNodePositionSchema, GraphNodeSchema, GraphEdgeSchema, GraphDataSchema, } from "./schemas/graph.schema.js";
 export { ConnectorConnectionSchema, ConnectorInfoSchema, ConnectConnectorResponseSchema, } from "./schemas/connector.schema.js";
 export { parseRule, parseRules, formatRule, matchesSpecifier, GLOB_STAR, WORD_BOUNDARY_SUFFIX, PREFIX_STAR_SUFFIX, } from "./auto-approve/rule-format.js";
-export { splitSubcommands, deriveRules, matchesRules, isReadOnlyCommand, DEFAULT_PREFIX_DEPTH, MAX_DERIVED_RULES, READ_ONLY_BUILTINS, PROCESS_WRAPPERS, } from "./auto-approve/command-decomposition.js";
+export { splitSubcommands, deriveRules, matchesRules, DEFAULT_PREFIX_DEPTH, MAX_DERIVED_RULES, PROCESS_WRAPPERS, SUBCOMMAND_MATCH_MODE, } from "./auto-approve/command-decomposition.js";
 export { defaultRuleStrategy, commandRuleStrategy } from "./auto-approve/rule-strategies.js";
 export { getRuleStrategy } from "./auto-approve/rule-strategy-registry.js";
 export { AutoApproveRuleSet } from "./auto-approve/auto-approve-rule-set.js";
+export { normalizeMcpName } from "./utils/mcp-utils.js";
 //# sourceMappingURL=index.js.map

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

@@ -2,6 +2,12 @@ import { z } from "zod";
 import { EntityTypeSchema, RelationshipTypeSchema } from "./agent-circle.schema.js";
 import { AGENT_STATUS } from "./agent-runtime-state.schema.js";
 import { FragmentKindSchema } from "./fragment.schema.js";
+/** A user-authored layout position for a graph node; `id` is the node's entity id */
+export const GraphNodePositionSchema = z.object({
+    id: z.string(),
+    x: z.number(),
+    y: z.number(),
+});
 /** A node in the relationship graph — represents an agent, a circle, or a fragment */
 export const GraphNodeSchema = z.object({
     id: z.string(),
@@ -14,6 +20,8 @@ export const GraphNodeSchema = z.object({
     status: z
         .enum([AGENT_STATUS.IDLE, AGENT_STATUS.ACTIVATING, AGENT_STATUS.STREAMING, AGENT_STATUS.COMPACTING])
         .optional(),
+    x: z.number().optional(),
+    y: z.number().optional(),
 });
 /** An edge in the relationship graph — represents a membership relationship */
 export const GraphEdgeSchema = z.object({

package/dist/_shared/utils/mcp-utils.js

@@ -0,0 +1,4 @@
+export function normalizeMcpName(name) {
+    return name.toLowerCase().replaceAll(" ", "_");
+}
+//# sourceMappingURL=mcp-utils.js.map

package/dist/bootstrap.js

@@ -181,7 +181,7 @@ export async function bootstrap(options) {
     await registerSensorRoutes(server, sensorManager);
     await registerCircleRoutes(server, circleManager, registry);
     await registerFragmentRoutes(server, fragmentManager, registry);
-    await registerGraphRoutes(server, circleManager, registry, runtimeManager, fragmentManager);
+    await registerGraphRoutes(server, circleManager, registry, runtimeManager, fragmentManager, relationshipManager);
     await registerFeedRoutes(server, feedManager);
     await registerSystemSettingsRoutes(server, systemSettingsManager);
     await registerConnectorsRoutes(server, connectorManager);

package/dist/config/env.js

@@ -48,6 +48,7 @@ export const env = {
     NODE_ENV: nodeEnv,
     IS_DEV: isDev,
     LOG_LEVEL: getOptional("LOG_LEVEL") ?? (isDev ? "debug" : "info"),
+    LOG_PRETTY: getBoolean("LOG_PRETTY"),
     HOST: host,
     PORT: port,
     CORS_ORIGINS: corsOrigins.split(",").map((origin) => origin.trim()),

package/dist/feed/simply-feed-manager.js

@@ -446,8 +446,7 @@ export class SimplyFeedManager extends EventBus {
             const feeds = await this.getFeeds();
             for (const feed of feeds) {
                 try {
-                    const items = await this.refreshFeed(feed.id, false);
-                    log.info({ feedId: feed.id, feedName: feed.title, newItemsCount: items.length }, "Refreshed feed");
+                    await this.refreshFeed(feed.id, false);
                 }
                 catch (error) {
                     log.error({ feedId: feed.id, feedName: feed.title, error }, "Failed to refresh feed");

package/dist/mcp/artifacts/write-artifact.js

@@ -27,6 +27,9 @@ export function getWriteArtifactToolConfig(agentId, artifactManager, sensorManag
         const filename = rawFilename.trim();
         try {
             const isBinary = content_type && content_type !== ARTIFACT_CONTENT_TYPE.TEXT;
+            if (!isBinary && !content.trim()) {
+                throw new Error("Artifact content must not be empty. Provide content, or use delete_artifact if you meant to remove it.");
+            }
             const artifactContent = isBinary ? Buffer.from(content, "base64") : content;
             const metadata = await artifactManager.writeArtifact(agentId, filename, artifactContent, {
                 type,

package/dist/mcp/artifacts/write-circle-artifact.js

@@ -31,6 +31,9 @@ export function getWriteCircleArtifactToolConfig(agentId, artifactManager, senso
         const filename = rawFilename.trim();
         try {
             const isBinary = content_type && content_type !== ARTIFACT_CONTENT_TYPE.TEXT;
+            if (!isBinary && !content.trim()) {
+                throw new Error("Artifact content must not be empty. Provide content, or use delete_circle_artifact if you meant to remove it.");
+            }
             const artifactContent = isBinary ? Buffer.from(content, "base64") : content;
             const metadata = await artifactManager.writeCircleArtifact(circle_id, filename, artifactContent, {
                 type,

package/dist/mcp/crow-mcp-manager.js

@@ -1,4 +1,4 @@
-import { McpServerConfigSchema, CreateMcpConfigInputSchema, UpdateMcpConfigInputSchema, MCP_CONFIG_TYPE, CROW_SYSTEM_AGENT_ID, AGENT_TYPE, } from "../_shared/index.js";
+import { McpServerConfigSchema, CreateMcpConfigInputSchema, UpdateMcpConfigInputSchema, MCP_CONFIG_TYPE, CROW_SYSTEM_AGENT_ID, AGENT_TYPE, normalizeMcpName, } from "../_shared/index.js";
 import { logger } from "../utils/logger.js";
 import { AppError } from "../core/error/app-error.js";
 import { APP_ERROR_CODES } from "../core/error/app-error.types.js";
@@ -79,7 +79,7 @@ export class CrowMcpManager {
                 return (isCrowSystemAgent(agentId) && config.enableForCrow) || configuredMcpIds.has(config.id);
             });
             for (const config of userMcpConfigs) {
-                const name = this.normalizeMcpName(config.name);
+                const name = normalizeMcpName(config.name);
                 if (serverConfigMap.has(name)) {
                     log.warn({ configId: config.id, name }, "User MCP config name collides with an internal server, skipping");
                     continue;
@@ -194,9 +194,6 @@ export class CrowMcpManager {
         await this.store.delete(MCP_CONFIG_STORE_TABLE, configId);
         log.info({ configId, name: existing.name }, "MCP config deleted");
     }
-    normalizeMcpName(name) {
-        return name.toLowerCase().replaceAll(" ", "_");
-    }
     /** Map a persisted user MCP config to a Crow MCP transport. */
     toTransport(config) {
         if (config.type === MCP_CONFIG_TYPE.STDIO) {