@openparachute/agent 0.1.1 → 0.2.0

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.ts

@@ -1,199 +0,0 @@
-/**
- * MCP tools for channel-wire CRUD. Mirrors `/api/channels`. The DB still
- * stores the pre-rebuild enum names (engage_mode = mention | pattern |
- * mention-sticky; sender_scope = all | known; ignored_message_policy = drop
- * | accumulate); the API contract these tools speak — same as the web API —
- * uses the new vocabulary (engageMode = mention | pattern | all; senderScope
- * = allowlist | all; ignoredMessagePolicy = drop | silent). The translator
- * is small so we inline it here rather than carving out a shared module
- * that would need its own seam through the route handler.
- */
-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 {
-  EngageMode as DbEngageMode,
-  IgnoredMessagePolicy as DbIgnoredMessagePolicy,
-  SenderScope as DbSenderScope,
-  MessagingGroupAgent,
-} from '../../types.js';
-import type { ToolDef } from '../types.js';
-
-type ApiEngageMode = 'mention' | 'pattern' | 'all';
-type ApiSenderScope = 'allowlist' | 'all';
-type ApiIgnoredMessagePolicy = 'drop' | 'silent';
-
-const ALL_PATTERN = '.';
-
-function dbToApiEngage(mode: DbEngageMode, pattern: string | null): ApiEngageMode {
-  if (mode === 'pattern') return pattern === ALL_PATTERN ? 'all' : 'pattern';
-  return 'mention';
-}
-function dbToApiSenderScope(s: DbSenderScope): ApiSenderScope {
-  return s === 'known' ? 'allowlist' : 'all';
-}
-function dbToApiIgnoredPolicy(p: DbIgnoredMessagePolicy): ApiIgnoredMessagePolicy {
-  return p === 'accumulate' ? 'silent' : 'drop';
-}
-
-interface WireRow extends MessagingGroupAgent {
-  mg_channel_type: string;
-  mg_platform_id: string;
-  mg_name: string | null;
-  ag_folder: string;
-  ag_name: string;
-}
-
-interface ChannelWireView {
-  id: string;
-  channelType: string;
-  messagingGroupId: string;
-  platformId: string;
-  displayName: string | null;
-  agentGroupId: string;
-  agentGroupFolder: string;
-  agentGroupName: string;
-  engageMode: ApiEngageMode;
-  engagePattern: string | null;
-  senderScope: ApiSenderScope;
-  ignoredMessagePolicy: ApiIgnoredMessagePolicy;
-  priority: number;
-  createdAt: string;
-}
-
-function rowToView(row: WireRow): ChannelWireView {
-  return {
-    id: row.id,
-    channelType: row.mg_channel_type,
-    messagingGroupId: row.messaging_group_id,
-    platformId: row.mg_platform_id,
-    displayName: row.mg_name,
-    agentGroupId: row.agent_group_id,
-    agentGroupFolder: row.ag_folder,
-    agentGroupName: row.ag_name,
-    engageMode: dbToApiEngage(row.engage_mode, row.engage_pattern),
-    engagePattern: row.engage_mode === 'pattern' && row.engage_pattern !== ALL_PATTERN ? row.engage_pattern : null,
-    senderScope: dbToApiSenderScope(row.sender_scope),
-    ignoredMessagePolicy: dbToApiIgnoredPolicy(row.ignored_message_policy),
-    priority: row.priority,
-    createdAt: row.created_at,
-  };
-}
-
-function listAllWires(): ChannelWireView[] {
-  return (
-    getDb()
-      .prepare<WireRow>(
-        `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 WireRow[]
-  ).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', 'all'] },
-        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}`);
-      const patch: Partial<MessagingGroupAgent> = {};
-      if (args.engageMode === 'all') {
-        patch.engage_mode = 'pattern';
-        patch.engage_pattern = ALL_PATTERN;
-      } else if (args.engageMode === 'pattern') {
-        patch.engage_mode = 'pattern';
-        if (typeof args.engagePattern === 'string' && args.engagePattern !== ALL_PATTERN) {
-          patch.engage_pattern = args.engagePattern;
-        }
-      } else if (args.engageMode === 'mention') {
-        patch.engage_mode = current.engage_mode === 'mention-sticky' ? 'mention-sticky' : 'mention';
-        patch.engage_pattern = null;
-      } else if (typeof args.engagePattern === 'string' || args.engagePattern === null) {
-        patch.engage_pattern = args.engagePattern as string | null;
-      }
-      if (args.senderScope === 'allowlist') patch.sender_scope = 'known';
-      else if (args.senderScope === 'all') patch.sender_scope = 'all';
-      if (args.ignoredMessagePolicy === 'silent') patch.ignored_message_policy = 'accumulate';
-      else if (args.ignoredMessagePolicy === 'drop') patch.ignored_message_policy = 'drop';
-      if (typeof args.priority === 'number' && Number.isFinite(args.priority)) patch.priority = args.priority;
-      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) };
-    },
-  },
-];