sentinelayer-cli 0.30.13 → 0.30.14

package/src/mcp/cli-registry.js

@@ -0,0 +1,231 @@
+import { buildCliProgram } from "../cli.js";
+import { MCP_TOOL_REGISTRY_SCHEMA_VERSION } from "./registry.js";
+
+const CLI_TOOL_PREFIX = "sl";
+const CLI_TOOL_TIMEOUT_MS = 60_000;
+const CLI_TOOL_MAX_CALLS_PER_RUN = 5;
+
+function normalizeDescription(value, fallback) {
+  const normalized = String(value || "").trim();
+  return normalized || fallback;
+}
+
+function toTitle(value) {
+  return String(value || "")
+    .split(/[\s_.:-]+/g)
+    .filter(Boolean)
+    .map((part) => part.slice(0, 1).toUpperCase() + part.slice(1))
+    .join(" ");
+}
+
+function optionPropertyName(option) {
+  if (typeof option.attributeName === "function") {
+    return option.attributeName();
+  }
+  const long = String(option.long || option.flags || "")
+    .split(/[ ,|]+/g)
+    .find((part) => part.startsWith("--"));
+  return String(long || "")
+    .replace(/^--no-/, "")
+    .replace(/^--/, "")
+    .replace(/-([a-zA-Z0-9])/g, (_, char) => char.toUpperCase());
+}
+
+function schemaForArgument(argument) {
+  const description = normalizeDescription(argument.description, "");
+  if (argument.variadic) {
+    return {
+      type: "array",
+      items: { type: "string" },
+      ...(description ? { description } : {}),
+    };
+  }
+  return {
+    type: "string",
+    ...(description ? { description } : {}),
+  };
+}
+
+function optionTakesValue(option) {
+  return Boolean(option.required || option.optional || option.variadic);
+}
+
+function schemaForOption(option) {
+  const description = normalizeDescription(option.description, "");
+  let schema;
+  if (option.variadic) {
+    schema = {
+      type: "array",
+      items: { type: "string" },
+    };
+  } else if (optionTakesValue(option)) {
+    schema = { type: "string" };
+  } else {
+    schema = { type: "boolean" };
+  }
+
+  if (description) {
+    schema.description = description;
+  }
+  if (
+    option.defaultValue !== undefined &&
+    ["string", "number", "boolean"].includes(typeof option.defaultValue)
+  ) {
+    schema.default = option.defaultValue;
+  }
+  return schema;
+}
+
+function summarizeArgument(argument) {
+  return {
+    name: argument.name(),
+    required: Boolean(argument.required),
+    variadic: Boolean(argument.variadic),
+  };
+}
+
+function summarizeOption(option) {
+  return {
+    name: optionPropertyName(option),
+    flags: option.flags,
+    required: Boolean(option.mandatory),
+    takes_value: optionTakesValue(option),
+    variadic: Boolean(option.variadic),
+    negated: Boolean(option.negate),
+  };
+}
+
+function isHiddenCommand(command) {
+  return Boolean(command.hidden);
+}
+
+function commandPath(command) {
+  const names = [];
+  let current = command;
+  while (current && current.parent) {
+    names.unshift(current.name());
+    current = current.parent;
+  }
+  return names;
+}
+
+function collectLeafCommands(command, { includeHidden = false } = {}) {
+  const leaves = [];
+  for (const child of command.commands || []) {
+    if (!includeHidden && isHiddenCommand(child)) {
+      continue;
+    }
+    if (child.commands && child.commands.length > 0) {
+      leaves.push(...collectLeafCommands(child, { includeHidden }));
+      continue;
+    }
+    leaves.push(child);
+  }
+  return leaves;
+}
+
+function buildToolInputSchema(command) {
+  const properties = {};
+  const required = [];
+
+  for (const argument of command.registeredArguments || []) {
+    const name = argument.name();
+    properties[name] = schemaForArgument(argument);
+    if (argument.required) {
+      required.push(name);
+    }
+  }
+
+  for (const option of command.options || []) {
+    const name = optionPropertyName(option);
+    if (!name || properties[name]) {
+      continue;
+    }
+    properties[name] = schemaForOption(option);
+    if (option.mandatory) {
+      required.push(name);
+    }
+  }
+
+  return {
+    type: "object",
+    additionalProperties: false,
+    ...(required.length > 0 ? { required } : {}),
+    properties,
+  };
+}
+
+function buildCliTool(command) {
+  const pathParts = commandPath(command);
+  const commandName = pathParts.join(" ");
+  const dottedName = pathParts.join(".");
+  const toolName = `${CLI_TOOL_PREFIX}.${dottedName}`;
+  return {
+    name: toolName,
+    title: toTitle(toolName),
+    description: normalizeDescription(
+      command.description(),
+      `Run sentinelayer-cli ${commandName}.`
+    ),
+    input_schema: buildToolInputSchema(command),
+    transport: {
+      type: "bridge",
+      method: "POST",
+      url: `sentinelayer://cli/${dottedName}`,
+      timeout_ms: CLI_TOOL_TIMEOUT_MS,
+      auth: { mode: "none" },
+    },
+    budgets: {
+      max_calls_per_run: CLI_TOOL_MAX_CALLS_PER_RUN,
+      max_runtime_ms: CLI_TOOL_TIMEOUT_MS,
+    },
+    security: {
+      requires_human_approval: true,
+      kill_switch: "enabled",
+      scopes: ["cli:execute"],
+    },
+    metadata: {
+      provider: "sentinelayer",
+      adapter: "sentinelayer-cli",
+      command: commandName,
+      argv: pathParts,
+      generated_from: "commander",
+      execution: "bridge",
+      arguments: (command.registeredArguments || []).map(summarizeArgument),
+      options: (command.options || []).map(summarizeOption),
+    },
+  };
+}
+
+/**
+ * Build an MCP tool registry for the installed SentinelLayer CLI command tree.
+ *
+ * The generated registry is intentionally execution-policy-first: every tool is
+ * marked as requiring human approval because this is the full CLI surface.
+ *
+ * @param {{ generatedAt?: string, program?: import("commander").Command, includeHidden?: boolean }} [options]
+ * @returns {Promise<Record<string, any>>}
+ */
+export async function buildSentinelayerCliRegistryTemplate({
+  generatedAt = new Date().toISOString(),
+  program = null,
+  includeHidden = false,
+} = {}) {
+  const cliProgram =
+    program ||
+    (await buildCliProgram({
+      invokeLegacy: async () => {},
+    }));
+  const tools = collectLeafCommands(cliProgram, { includeHidden }).map(buildCliTool);
+  return {
+    version: MCP_TOOL_REGISTRY_SCHEMA_VERSION,
+    generated_at: generatedAt,
+    tools,
+  };
+}
+
+export const __cliRegistryInternals = Object.freeze({
+  collectLeafCommands,
+  buildToolInputSchema,
+  optionPropertyName,
+});

package/src/mcp/registry.js

@@ -500,6 +500,266 @@ export function buildSentinelayerSessionRegistryTemplate({ generatedAt = new Dat
           server: "sentinelayer-session-mcp",
         },
       },
+      {
+        name: "session_action",
+        title: "Record Senti Session Action",
+        description:
+          "Record a low-noise message action such as ack, working_on, disregard, view, like, dislike, or reply against a target session event.",
+        input_schema: {
+          type: "object",
+          additionalProperties: false,
+          required: ["sessionId", "agentId", "actionType"],
+          properties: {
+            sessionId: { type: "string" },
+            agentId: { type: "string" },
+            actionType: {
+              type: "string",
+              enum: ["ack", "working_on", "reply", "like", "dislike", "disregard", "view"],
+            },
+            targetSequenceId: { type: "integer", minimum: 1 },
+            targetCursor: { type: "string" },
+            targetActionId: { type: "string" },
+            note: { type: "string" },
+            idempotencyKey: { type: "string" },
+            timeoutMs: { type: "integer", minimum: 1 },
+            dryRun: { type: "boolean" },
+          },
+        },
+        transport: {
+          type: "internal",
+          method: "POST",
+          url: "sentinelayer://session/session_action",
+          timeout_ms: 15000,
+          auth: { mode: "none" },
+        },
+        budgets: {
+          max_calls_per_run: 40,
+          max_runtime_ms: 15000,
+        },
+        security: {
+          requires_human_approval: false,
+          kill_switch: "enabled",
+          scopes: ["session:write", "session:action"],
+        },
+        metadata: {
+          provider: "sentinelayer",
+          adapter: "sentinelayer-cli",
+          server: "sentinelayer-session-mcp",
+        },
+      },
+      {
+        name: "session_react",
+        title: "React To Senti Message",
+        description:
+          "Acknowledge or react to a target session event with ack, like, or dislike.",
+        input_schema: {
+          type: "object",
+          additionalProperties: false,
+          required: ["sessionId", "agentId", "reaction"],
+          properties: {
+            sessionId: { type: "string" },
+            agentId: { type: "string" },
+            reaction: { type: "string", enum: ["ack", "like", "dislike"] },
+            targetSequenceId: { type: "integer", minimum: 1 },
+            targetCursor: { type: "string" },
+            targetActionId: { type: "string" },
+            idempotencyKey: { type: "string" },
+            timeoutMs: { type: "integer", minimum: 1 },
+            dryRun: { type: "boolean" },
+          },
+        },
+        transport: {
+          type: "internal",
+          method: "POST",
+          url: "sentinelayer://session/session_react",
+          timeout_ms: 15000,
+          auth: { mode: "none" },
+        },
+        budgets: {
+          max_calls_per_run: 60,
+          max_runtime_ms: 15000,
+        },
+        security: {
+          requires_human_approval: false,
+          kill_switch: "enabled",
+          scopes: ["session:write", "session:action"],
+        },
+        metadata: {
+          provider: "sentinelayer",
+          adapter: "sentinelayer-cli",
+          server: "sentinelayer-session-mcp",
+        },
+      },
+      {
+        name: "session_reply",
+        title: "Reply In Senti Thread",
+        description:
+          "Add a threaded reply/comment under a specific session event using the session action channel.",
+        input_schema: {
+          type: "object",
+          additionalProperties: false,
+          required: ["sessionId", "agentId", "targetSequenceId", "message"],
+          properties: {
+            sessionId: { type: "string" },
+            agentId: { type: "string" },
+            targetSequenceId: { type: "integer", minimum: 1 },
+            targetCursor: { type: "string" },
+            targetActionId: { type: "string" },
+            message: { type: "string" },
+            idempotencyKey: { type: "string" },
+            timeoutMs: { type: "integer", minimum: 1 },
+            dryRun: { type: "boolean" },
+          },
+        },
+        transport: {
+          type: "internal",
+          method: "POST",
+          url: "sentinelayer://session/session_reply",
+          timeout_ms: 15000,
+          auth: { mode: "none" },
+        },
+        budgets: {
+          max_calls_per_run: 40,
+          max_runtime_ms: 15000,
+        },
+        security: {
+          requires_human_approval: false,
+          kill_switch: "enabled",
+          scopes: ["session:write", "session:action"],
+        },
+        metadata: {
+          provider: "sentinelayer",
+          adapter: "sentinelayer-cli",
+          server: "sentinelayer-session-mcp",
+        },
+      },
+      {
+        name: "session_lock",
+        title: "Lock Senti Files",
+        description:
+          "Claim session-scoped file locks before editing files, using the same fail-closed lock registry as the CLI.",
+        input_schema: {
+          type: "object",
+          additionalProperties: false,
+          required: ["sessionId", "agentId", "files"],
+          properties: {
+            sessionId: { type: "string" },
+            agentId: { type: "string" },
+            files: {
+              anyOf: [
+                { type: "string" },
+                { type: "array", items: { type: "string" }, minItems: 1 },
+              ],
+            },
+            intent: { type: "string" },
+            ttlSeconds: { type: "integer", minimum: 1 },
+            syncRemote: { type: "boolean" },
+            awaitRemoteSync: { type: "boolean" },
+          },
+        },
+        transport: {
+          type: "internal",
+          method: "POST",
+          url: "sentinelayer://session/session_lock",
+          timeout_ms: 15000,
+          auth: { mode: "none" },
+        },
+        budgets: {
+          max_calls_per_run: 20,
+          max_runtime_ms: 15000,
+        },
+        security: {
+          requires_human_approval: false,
+          kill_switch: "enabled",
+          scopes: ["session:lock"],
+        },
+        metadata: {
+          provider: "sentinelayer",
+          adapter: "sentinelayer-cli",
+          server: "sentinelayer-session-mcp",
+        },
+      },
+      {
+        name: "session_unlock",
+        title: "Unlock Senti Files",
+        description:
+          "Release session-scoped file locks held by an agent.",
+        input_schema: {
+          type: "object",
+          additionalProperties: false,
+          required: ["sessionId", "agentId", "files"],
+          properties: {
+            sessionId: { type: "string" },
+            agentId: { type: "string" },
+            files: {
+              anyOf: [
+                { type: "string" },
+                { type: "array", items: { type: "string" }, minItems: 1 },
+              ],
+            },
+            reason: { type: "string" },
+            force: { type: "boolean" },
+            syncRemote: { type: "boolean" },
+            awaitRemoteSync: { type: "boolean" },
+          },
+        },
+        transport: {
+          type: "internal",
+          method: "POST",
+          url: "sentinelayer://session/session_unlock",
+          timeout_ms: 15000,
+          auth: { mode: "none" },
+        },
+        budgets: {
+          max_calls_per_run: 20,
+          max_runtime_ms: 15000,
+        },
+        security: {
+          requires_human_approval: false,
+          kill_switch: "enabled",
+          scopes: ["session:lock"],
+        },
+        metadata: {
+          provider: "sentinelayer",
+          adapter: "sentinelayer-cli",
+          server: "sentinelayer-session-mcp",
+        },
+      },
+      {
+        name: "session_locks",
+        title: "List Senti File Locks",
+        description:
+          "List active file locks for a session.",
+        input_schema: {
+          type: "object",
+          additionalProperties: false,
+          required: ["sessionId"],
+          properties: {
+            sessionId: { type: "string" },
+          },
+        },
+        transport: {
+          type: "internal",
+          method: "POST",
+          url: "sentinelayer://session/session_locks",
+          timeout_ms: 15000,
+          auth: { mode: "none" },
+        },
+        budgets: {
+          max_calls_per_run: 20,
+          max_runtime_ms: 15000,
+        },
+        security: {
+          requires_human_approval: false,
+          kill_switch: "enabled",
+          scopes: ["session:lock"],
+        },
+        metadata: {
+          provider: "sentinelayer",
+          adapter: "sentinelayer-cli",
+          server: "sentinelayer-session-mcp",
+        },
+      },
       {
         name: "attention_request",
         title: "Request Senti Attention",