@openparachute/agent 0.1.2 → 0.2.2

package/src/mcp/tools/approvals.ts

@@ -1,122 +0,0 @@
-/**
- * MCP tools for the approval queue. `decide-approval` flows through the
- * same `handleApprovalsResponse` dispatcher the chat-card path uses, so
- * the row-update + module-action + agent-notify behaviour is identical
- * regardless of whether the operator decides via DM or via this tool.
- *
- * Caller identity: `decide-approval` records the decider as the JWT `sub`
- * for HTTP transport, or `mcp:stdio` for stdio. Approval factory pattern
- * lets us thread the subject in at server-build time without leaking
- * transport details to individual handlers.
- */
-import { getAgentGroup } from '../../db/agent-groups.js';
-import { getApproval, listPendingApprovals } from '../../db/sessions.js';
-import { handleApprovalsResponse } from '../../modules/approvals/response-handler.js';
-import type { ActionApprovalBody, Approval } from '../../types.js';
-import type { ToolDef } from '../types.js';
-
-interface ApprovalView {
-  id: string;
-  agentGroupId: string;
-  agentGroupName: string | null;
-  kind: string;
-  actionPayload: Record<string, unknown>;
-  status: 'pending' | 'approved' | 'rejected' | 'expired';
-  requestedAt: string;
-  decidedAt: string | null;
-  requestedBy: string;
-}
-
-function approvalToView(approval: Approval): ApprovalView | null {
-  if (!approval.agent_group_id) return null;
-  let agentGroupName: string | null = null;
-  try {
-    const group = getAgentGroup(approval.agent_group_id);
-    if (group) agentGroupName = group.name;
-  } catch {
-    // tolerate FK miss
-  }
-  const body = approval.body as ActionApprovalBody;
-  const actionPayload = (body.payload ?? {}) as Record<string, unknown>;
-  const status =
-    (['pending', 'approved', 'rejected', 'expired'] as const).find((s) => s === approval.status) ?? 'pending';
-  return {
-    id: approval.id,
-    agentGroupId: approval.agent_group_id,
-    agentGroupName,
-    kind: approval.kind,
-    actionPayload,
-    status,
-    requestedAt: approval.created_at,
-    decidedAt: approval.decided_at,
-    requestedBy: approval.session_id ?? '',
-  };
-}
-
-function listPending(): ApprovalView[] {
-  const rows = listPendingApprovals({ excludeKinds: ['question'] });
-  return rows.flatMap((r) => {
-    const v = approvalToView(r);
-    return v ? [v] : [];
-  });
-}
-
-function getOne(approvalId: string): ApprovalView | null {
-  const approval = getApproval(approvalId);
-  if (!approval) return null;
-  if (approval.kind === 'question') return null;
-  return approvalToView(approval);
-}
-
-export function buildApprovalTools(getCallerSubject: () => string): ToolDef[] {
-  return [
-    {
-      name: 'list-approvals',
-      description:
-        'List pending approvals — agent-requested actions awaiting human consent (install_packages, add_mcp_server, …).',
-      scope: 'agent:read',
-      inputSchema: { type: 'object', properties: {}, additionalProperties: false },
-      handler: async () => ({ approvals: listPending() }),
-    },
-    {
-      name: 'decide-approval',
-      description:
-        "Decide a pending approval. Routes through the same dispatcher the chat-card path uses, so the side effects (row delete, module-action run, agent notify) are identical. The deciding userId is recorded as the caller's JWT sub (or 'mcp:stdio' for stdio).",
-      scope: 'agent:admin',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          id: { type: 'string', description: 'Approval id.' },
-          decision: { type: 'string', enum: ['approve', 'reject'] },
-        },
-        required: ['id', 'decision'],
-        additionalProperties: false,
-      },
-      handler: async (args) => {
-        const id = String(args.id ?? '');
-        const decision = args.decision === 'approve' || args.decision === 'reject' ? args.decision : null;
-        if (!id) throw new Error('id is required');
-        if (!decision) throw new Error("decision must be 'approve' or 'reject'");
-        const before = getOne(id);
-        if (!before) throw new Error(`approval not found: ${id}`);
-        if (before.status !== 'pending') throw new Error(`approval already ${before.status}`);
-        const handled = await handleApprovalsResponse({
-          questionId: id,
-          value: decision,
-          userId: getCallerSubject(),
-          channelType: 'mcp',
-          platformId: 'parachute-agent-mcp',
-          threadId: null,
-        });
-        if (!handled) throw new Error('approval was decided by another path before our update landed');
-        return {
-          approval: {
-            ...before,
-            status: decision === 'approve' ? 'approved' : 'rejected',
-            decidedAt: new Date().toISOString(),
-          },
-        };
-      },
-    },
-  ];
-}

package/src/mcp/tools/channels.test.ts

@@ -1,126 +0,0 @@
-/**
- * MCP-path coverage for `update-channel-wire`. The MCP SDK does not enforce
- * a tool's `inputSchema` against `tools/call` arguments before dispatching
- * to the handler (see comment on `ToolDef.inputSchema` in src/mcp/types.ts),
- * so the handler must defensively gate enum-typed fields itself. Without
- * the gate, a stale-schema client (cached pre-rc.6 senderScope vocabulary,
- * or a hand-rolled call) would fall through the if/else patch-construction
- * and silently no-op the column update — exactly the silent-coerce class
- * paraclaw#94 set out to close.
- */
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-
-import { closeDb, initTestDb, runMigrations } from '../../db/index.js';
-import { createAgentGroup } from '../../db/agent-groups.js';
-import {
-  createMessagingGroup,
-  createMessagingGroupAgent,
-  getMessagingGroupAgent,
-} from '../../db/messaging-groups.js';
-import type { ToolHandlerContext } from '../types.js';
-import { channelTools } from './channels.js';
-
-const updateTool = channelTools.find((t) => t.name === 'update-channel-wire')!;
-
-const ctx: ToolHandlerContext = { effectiveScope: 'agent:admin', callerSubject: 'mcp:stdio' };
-
-const now = (): string => new Date().toISOString();
-
-function seedWire(over: { sender_scope?: 'all' | 'known' } = {}): void {
-  createAgentGroup({
-    id: 'ag_mcp',
-    name: 'MCP test',
-    folder: 'mcp-test',
-    agent_provider: null,
-    secret_mode: 'all',
-    created_at: now(),
-  });
-  createMessagingGroup({
-    id: 'mg_mcp',
-    channel_type: 'telegram',
-    platform_id: 'telegram:99:88',
-    name: null,
-    is_group: 0,
-    unknown_sender_policy: 'request_approval',
-    created_at: now(),
-  });
-  createMessagingGroupAgent({
-    id: 'mga_mcp',
-    messaging_group_id: 'mg_mcp',
-    agent_group_id: 'ag_mcp',
-    engage_mode: 'mention',
-    engage_pattern: null,
-    sender_scope: over.sender_scope ?? 'known',
-    ignored_message_policy: 'drop',
-    session_mode: 'shared',
-    priority: 0,
-    created_at: now(),
-  });
-}
-
-beforeEach(() => {
-  const db = initTestDb();
-  runMigrations(db);
-});
-
-afterEach(() => {
-  closeDb();
-});
-
-describe('mcp update-channel-wire — paraclaw#94 senderScope vocabulary', () => {
-  it("round-trips senderScope='unrestricted' → DB sender_scope='all' → response 'unrestricted'", async () => {
-    seedWire({ sender_scope: 'known' });
-
-    const result = (await updateTool.handler({ id: 'mga_mcp', senderScope: 'unrestricted' }, ctx)) as {
-      wire: { senderScope: string };
-    };
-
-    expect(result.wire.senderScope).toBe('unrestricted');
-    expect(getMessagingGroupAgent('mga_mcp')!.sender_scope).toBe('all');
-  });
-
-  it("rejects the legacy wire literal senderScope='all' instead of silent no-op", async () => {
-    // The bug shape: pre-fix, the handler's if/else pair only matched
-    // 'allowlist' and 'unrestricted'; legacy 'all' fell through and
-    // `patch.sender_scope` was never assigned, so updateMessagingGroupAgent
-    // ran with no sender_scope key and the column kept its previous value
-    // — server returned success, client believed the field changed,
-    // operator saw no error. Pin that the gate now refuses it.
-    seedWire({ sender_scope: 'known' });
-
-    await expect(updateTool.handler({ id: 'mga_mcp', senderScope: 'all' }, ctx)).rejects.toThrow(
-      /invalid senderScope: all/,
-    );
-
-    // And critically — the column was NOT silently mutated.
-    expect(getMessagingGroupAgent('mga_mcp')!.sender_scope).toBe('known');
-  });
-
-  it("rejects the legacy DB-side literal ignoredMessagePolicy='accumulate'", async () => {
-    // Same silent-coerce class on a sibling field — the DB stores
-    // 'accumulate' but the wire vocabulary is 'silent'. Pre-gate, sending
-    // 'accumulate' on the wire fell through both if-branches.
-    seedWire();
-
-    await expect(
-      updateTool.handler({ id: 'mga_mcp', ignoredMessagePolicy: 'accumulate' }, ctx),
-    ).rejects.toThrow(/invalid ignoredMessagePolicy: accumulate/);
-
-    expect(getMessagingGroupAgent('mga_mcp')!.ignored_message_policy).toBe('drop');
-  });
-
-  it('rejects an unknown engageMode instead of silent no-op via the engagePattern fallback', async () => {
-    // engageMode's if/else chain has a fourth branch that fires when the
-    // mode is unrecognized but engagePattern is present — so a typo'd
-    // engageMode used to silently update only the pattern. Pin the gate.
-    seedWire();
-
-    await expect(
-      updateTool.handler({ id: 'mga_mcp', engageMode: 'wave-hands', engagePattern: 'whatever' }, ctx),
-    ).rejects.toThrow(/invalid engageMode: wave-hands/);
-
-    const persisted = getMessagingGroupAgent('mga_mcp')!;
-    expect(persisted.engage_mode).toBe('mention');
-    expect(persisted.engage_pattern).toBeNull();
-  });
-});

package/src/mcp/tools/channels.ts

@@ -1,134 +0,0 @@
-/**
- * MCP tools for channel-wire CRUD. Mirrors `/api/channels`.
- *
- * The wire-shape <-> DB-shape translator + patch validator now live in
- * `src/channels/api-translator.ts` (paraclaw#123) and are shared with the
- * HTTP route. See that module for the enum translation contract; this
- * file owns the MCP tool plumbing only.
- *
- * The MCP SDK does NOT enforce `inputSchema` against `tools/call` args
- * before dispatch (see ToolDef.inputSchema in src/mcp/types.ts), so the
- * shared `validatePatchInput` doubles as the defensive gate this handler
- * relied on inline before. paraclaw#94 / PR #122 closed the same
- * silent-coerce class on the HTTP side; #123 brings the MCP side onto
- * the same canonical validator.
- */
-import {
-  apiToDbPatch,
-  type ChannelWireView,
-  rowToView,
-  validatePatchInput,
-  type WireJoinRow,
-} from '../../channels/api-translator.js';
-import { getAgentGroup } from '../../db/agent-groups.js';
-import { getDb } from '../../db/connection.js';
-import {
-  deleteMessagingGroupAgent,
-  getMessagingGroup,
-  getMessagingGroupAgent,
-  updateMessagingGroupAgent,
-} from '../../db/messaging-groups.js';
-import type { ToolDef } from '../types.js';
-
-function listAllWires(): ChannelWireView[] {
-  return (
-    getDb()
-      .prepare<WireJoinRow>(
-        `SELECT mga.*,
-                mg.channel_type AS mg_channel_type,
-                mg.platform_id  AS mg_platform_id,
-                mg.name         AS mg_name,
-                ag.folder       AS ag_folder,
-                ag.name         AS ag_name
-           FROM messaging_group_agents mga
-           JOIN messaging_groups mg ON mg.id = mga.messaging_group_id
-           JOIN agent_groups ag     ON ag.id = mga.agent_group_id
-          ORDER BY mga.created_at DESC`,
-      )
-      .all() as WireJoinRow[]
-  ).map(rowToView);
-}
-
-function getWireView(id: string): ChannelWireView | null {
-  const mga = getMessagingGroupAgent(id);
-  if (!mga) return null;
-  const mg = getMessagingGroup(mga.messaging_group_id);
-  const ag = getAgentGroup(mga.agent_group_id);
-  if (!mg || !ag) return null;
-  return rowToView({
-    ...mga,
-    mg_channel_type: mg.channel_type,
-    mg_platform_id: mg.platform_id,
-    mg_name: mg.name,
-    ag_folder: ag.folder,
-    ag_name: ag.name,
-  });
-}
-
-export const channelTools: ToolDef[] = [
-  {
-    name: 'list-channels',
-    description:
-      'List every channel wire in the install — each row is a (messaging-group → agent-group) routing rule with its engage/sender/policy/priority settings.',
-    scope: 'agent:read',
-    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
-    handler: async () => ({ wires: listAllWires() }),
-  },
-  {
-    name: 'delete-channel-wire',
-    description: 'Delete a channel wire by id. The agent_destinations row created at wire time is left in place.',
-    scope: 'agent:admin',
-    inputSchema: {
-      type: 'object',
-      properties: { id: { type: 'string', description: 'Channel wire id.' } },
-      required: ['id'],
-      additionalProperties: false,
-    },
-    handler: async (args) => {
-      const id = String(args.id ?? '');
-      if (!id) throw new Error('id is required');
-      const current = getMessagingGroupAgent(id);
-      if (!current) throw new Error(`channel wire not found: ${id}`);
-      deleteMessagingGroupAgent(id);
-      return { id, deleted: true };
-    },
-  },
-  {
-    name: 'update-channel-wire',
-    description:
-      'Update a channel wire by id. Any subset of engageMode, engagePattern, senderScope, ignoredMessagePolicy, priority can be supplied.',
-    scope: 'agent:admin',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        id: { type: 'string' },
-        engageMode: { type: 'string', enum: ['mention', 'pattern', 'all'] },
-        engagePattern: { type: ['string', 'null'] },
-        senderScope: { type: 'string', enum: ['allowlist', 'unrestricted'] },
-        ignoredMessagePolicy: { type: 'string', enum: ['drop', 'silent'] },
-        priority: { type: 'number' },
-      },
-      required: ['id'],
-      additionalProperties: false,
-    },
-    handler: async (args) => {
-      const id = String(args.id ?? '');
-      const current = getMessagingGroupAgent(id);
-      if (!current) throw new Error(`channel wire not found: ${id}`);
-
-      // validatePatchInput inspects only the fields it knows; `id` and any
-      // future-compat keys are ignored. On `ok: false`, throw the reason —
-      // the HTTP route does the same translation on its end (400 + JSON
-      // error). Both surfaces now share the same rejection contract,
-      // including the engagePattern='.' sentinel guard.
-      const validated = validatePatchInput(args);
-      if (!validated.ok) throw new Error(validated.reason);
-
-      const patch = apiToDbPatch(validated.input, current);
-      updateMessagingGroupAgent(id, patch);
-      const after = getWireView(id);
-      if (!after) throw new Error(`channel wire ${id} disappeared after update`);
-      return { wire: after };
-    },
-  },
-];

package/src/mcp/tools/index.ts

@@ -1,27 +0,0 @@
-/**
- * One flat tool registry. The factory threads a `getCallerSubject` getter
- * through to handlers that need it (today: `decide-approval`). The getter
- * is closure-captured at server-build time — for HTTP that's per-request
- * (the JWT `sub` for that request); for stdio that's a constant
- * `mcp:stdio`.
- */
-import type { ToolDef } from '../types.js';
-import { activityTools } from './activity.js';
-import { agentGroupTools } from './agent-groups.js';
-import { buildApprovalTools } from './approvals.js';
-import { channelTools } from './channels.js';
-import { oauthTools } from './oauth.js';
-import { secretTools } from './secrets.js';
-import { sessionTools } from './sessions.js';
-
-export function buildAllTools(getCallerSubject: () => string): ToolDef[] {
-  return [
-    ...agentGroupTools,
-    ...sessionTools,
-    ...channelTools,
-    ...secretTools,
-    ...buildApprovalTools(getCallerSubject),
-    ...oauthTools,
-    ...activityTools,
-  ];
-}

package/src/mcp/tools/oauth.ts

@@ -1,48 +0,0 @@
-/**
- * OAuth-flow MCP tools — currently STUBS. The matching paraclaw-server
- * endpoints (`/api/integrations/*` + the OAuth callback scaffold) haven't
- * landed on this branch yet. Tools are advertised in the registry for
- * human introspection (so the team-lead can see the planned surface) but
- * filtered out of `tools/list` and refused on `tools/call` until then.
- */
-import type { ToolDef } from '../types.js';
-
-const PENDING = 'awaiting paraclaw-server: /api/integrations/* + OAuth callback scaffold not yet on this branch';
-
-export const oauthTools: ToolDef[] = [
-  {
-    name: 'start-oauth',
-    description:
-      'Kick off an OAuth flow against an external provider (Google, Slack, …). Returns the authorization URL the operator should visit. STUB — disabled until /api/integrations/start lands.',
-    scope: 'agent:admin',
-    disabled: { reason: PENDING },
-    inputSchema: {
-      type: 'object',
-      properties: {
-        provider: { type: 'string', description: 'Provider id, e.g. "google" or "slack".' },
-        agentGroupId: { type: 'string', description: 'Agent group to attach the resulting integration to.' },
-      },
-      required: ['provider', 'agentGroupId'],
-      additionalProperties: false,
-    },
-    handler: async () => {
-      throw new Error(`start-oauth disabled: ${PENDING}`);
-    },
-  },
-  {
-    name: 'revoke-integration',
-    description:
-      'Revoke an existing integration (deletes stored OAuth tokens, removes the MCP entry). STUB — disabled until /api/integrations/:id lands.',
-    scope: 'agent:admin',
-    disabled: { reason: PENDING },
-    inputSchema: {
-      type: 'object',
-      properties: { id: { type: 'string', description: 'Integration id.' } },
-      required: ['id'],
-      additionalProperties: false,
-    },
-    handler: async () => {
-      throw new Error(`revoke-integration disabled: ${PENDING}`);
-    },
-  },
-];

package/src/mcp/tools/secrets.ts

@@ -1,169 +0,0 @@
-/**
- * MCP tools for the secret store. Mirrors `/api/secrets` (and the matching
- * UI under `/agent/secrets`), with one important wrinkle: the MCP surface
- * NEVER returns plaintext values. Even on `put-secret`, the response only
- * carries the row id + metadata — the value flows in once over the
- * transport, lands in the encrypted DB column, and is read back only by
- * the container-runner at session-spawn time.
- */
-import { getAgentGroupSecretMode, getAgentGroupSecretModes, setAgentGroupSecretMode } from '../../db/agent-groups.js';
-import {
-  type AssignedMode,
-  type SecretKind,
-  type SecretRow,
-  deleteSecret,
-  listAssignments,
-  listSecrets,
-  putSecret,
-  replaceAssignments,
-} from '../../secrets/index.js';
-import type { SecretMode } from '../../types.js';
-import type { ToolDef } from '../types.js';
-
-const ALLOWED_KINDS: SecretKind[] = ['channel-token', 'api-key', 'generic'];
-const ALLOWED_MODES: AssignedMode[] = ['all', 'selective'];
-
-interface SecretView {
-  id: string;
-  name: string;
-  kind: SecretKind;
-  agentGroupId: string | null;
-  assignedMode: AssignedMode;
-  createdAt: string;
-  updatedAt: string;
-}
-
-// Per-secret `assignedMode` derives from the recipient agent group's
-// `secret_mode` (paraclaw#9). Globals report 'all' — a global is in-scope
-// for every group; the group's own mode gates injection. Callers projecting
-// a list pass `modes` (one batched read) instead of letting toView fan out
-// a per-row SELECT.
-function toView(r: SecretRow, modes?: Map<string, SecretMode>): SecretView {
-  const assignedMode: AssignedMode = r.agent_group_id
-    ? ((modes ? modes.get(r.agent_group_id) : getAgentGroupSecretMode(r.agent_group_id)) ?? 'selective')
-    : 'all';
-  return {
-    id: r.id,
-    name: r.name,
-    kind: r.kind,
-    agentGroupId: r.agent_group_id,
-    assignedMode,
-    createdAt: r.created_at,
-    updatedAt: r.updated_at,
-  };
-}
-
-export const secretTools: ToolDef[] = [
-  {
-    name: 'list-secrets',
-    description:
-      'List secret metadata. NEVER returns plaintext values. Optional `agentGroupId` filter: empty string = global only; non-empty = global + that scope.',
-    scope: 'agent:read',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        agentGroupId: { type: ['string', 'null'], description: 'Optional filter; empty/null = global only.' },
-      },
-      additionalProperties: false,
-    },
-    handler: async (args) => {
-      let scope: string | null | undefined = undefined;
-      if (args.agentGroupId === null || args.agentGroupId === '') scope = null;
-      else if (typeof args.agentGroupId === 'string') scope = args.agentGroupId;
-      const rows = listSecrets(scope);
-      const groupIds = [...new Set(rows.map((r) => r.agent_group_id).filter((x): x is string => !!x))];
-      const modes = getAgentGroupSecretModes(groupIds);
-      return { secrets: rows.map((r) => toView(r, modes)) };
-    },
-  },
-  {
-    name: 'put-secret',
-    description:
-      'Insert or update a secret by (name, agentGroupId). Returns the row metadata — never the plaintext. The value is AES-256-GCM encrypted in-process before landing in the DB.',
-    scope: 'agent:admin',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        name: { type: 'string' },
-        value: { type: 'string', description: 'Plaintext value. Encrypted before storage; never logged.' },
-        kind: { type: 'string', enum: ALLOWED_KINDS, description: 'Defaults to "generic".' },
-        agentGroupId: {
-          type: ['string', 'null'],
-          description: 'null = global; non-empty = scoped to that agent group.',
-        },
-        assignedMode: {
-          type: 'string',
-          enum: ALLOWED_MODES,
-          description:
-            '"all" = the recipient agent group injects every in-scope secret; "selective" = only those with an explicit assignment. Setting this on a scoped secret flips the parent group\'s secret_mode. No-op for globals.',
-        },
-      },
-      required: ['name', 'value'],
-      additionalProperties: false,
-    },
-    handler: async (args) => {
-      const name = String(args.name ?? '').trim();
-      const value = typeof args.value === 'string' ? args.value : '';
-      if (!name) throw new Error('name is required');
-      if (!value) throw new Error('value is required');
-      const kind = (typeof args.kind === 'string' ? args.kind : 'generic') as SecretKind;
-      if (!ALLOWED_KINDS.includes(kind)) throw new Error(`invalid kind: ${kind}`);
-      const mode = typeof args.assignedMode === 'string' ? (args.assignedMode as AssignedMode) : undefined;
-      if (mode !== undefined && !ALLOWED_MODES.includes(mode)) throw new Error(`invalid assignedMode: ${mode}`);
-      const agentGroupId = typeof args.agentGroupId === 'string' && args.agentGroupId.length ? args.agentGroupId : null;
-
-      const id = putSecret(name, value, { kind, agent_group_id: agentGroupId });
-      if (mode !== undefined && agentGroupId) setAgentGroupSecretMode(agentGroupId, mode);
-      const row = listSecrets(agentGroupId).find((r) => r.id === id);
-      if (!row) throw new Error(`secret ${id} disappeared after write`);
-      return { secret: toView(row) };
-    },
-  },
-  {
-    name: 'delete-secret',
-    description: 'Delete a secret by id. Returns { deleted: true } on success, throws on unknown id.',
-    scope: 'agent:admin',
-    inputSchema: {
-      type: 'object',
-      properties: { id: { type: 'string' } },
-      required: ['id'],
-      additionalProperties: false,
-    },
-    handler: async (args) => {
-      const id = String(args.id ?? '');
-      if (!id) throw new Error('id is required');
-      const ok = deleteSecret(id);
-      if (!ok) throw new Error(`secret not found: ${id}`);
-      return { id, deleted: true };
-    },
-  },
-  {
-    name: 'assign-secret',
-    description:
-      "Replace the agent-group assignment list for a 'selective' secret. Empty array revokes everything. Atomic; throws on unknown secret id. Returns the new assignment list.",
-    scope: 'agent:admin',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        id: { type: 'string', description: 'Secret id.' },
-        agentGroupIds: {
-          type: 'array',
-          items: { type: 'string' },
-          description: 'Agent group ids to inject the secret into. Empty array revokes all assignments.',
-        },
-      },
-      required: ['id', 'agentGroupIds'],
-      additionalProperties: false,
-    },
-    handler: async (args) => {
-      const id = String(args.id ?? '').trim();
-      if (!id) throw new Error('id is required');
-      const groupIds = Array.isArray(args.agentGroupIds) ? args.agentGroupIds : null;
-      if (!groupIds || !groupIds.every((x) => typeof x === 'string')) {
-        throw new Error('agentGroupIds must be a string[]');
-      }
-      replaceAssignments(id, groupIds as string[]);
-      return { secretId: id, agentGroupIds: listAssignments(id) };
-    },
-  },
-];