@openparachute/agent 0.1.2 → 0.2.2

package/web/ui/src/routes/ChannelsList.tsx

@@ -1,158 +0,0 @@
-/**
- * /channels — global view of every channel wiring.
- *
- * A "wiring" binds a messaging-platform thread (a Discord DM, a Telegram
- * chat, a CLI client) to an agent group with routing rules: how the
- * agent decides whether to engage on a given inbound message
- * (engageMode + engagePattern), who's allowed to talk to it
- * (senderScope), what to do with messages it ignores
- * (ignoredMessagePolicy), and a tie-break priority when multiple wirings
- * could match.
- *
- * Per-wire actions:
- *   - Routing rules → opens /channels/mga/:id, the per-wire detail page
- *                     (engage mode editor, sender scope, ignored policy,
- *                     priority, hard-delete).
- *   - Group settings → opens /channels/mg/:id, the messaging-group page
- *                      (unknown-sender policy + denied-channel banner).
- *
- * New wirings are created by the setup wizard — there's no "+ new wire"
- * button here, by design. The wizard owns the channel-token-validate +
- * platform-id-capture dance; doing it here would just duplicate that
- * surface.
- */
-import { useCallback, useEffect, useState } from 'react';
-import { Link } from 'react-router-dom';
-import { listChannelWires, type ChannelWireView } from '../lib/api.ts';
-
-export function ChannelsList() {
-  const [state, setState] = useState<
-    { kind: 'loading' } | { kind: 'ok'; wires: ChannelWireView[] } | { kind: 'error'; message: string }
-  >({ kind: 'loading' });
-  const [reloadKey, setReloadKey] = useState(0);
-
-  const reload = useCallback(() => setReloadKey((k) => k + 1), []);
-
-  useEffect(() => {
-    let cancelled = false;
-    listChannelWires()
-      .then((wires) => !cancelled && setState({ kind: 'ok', wires }))
-      .catch((err) => {
-        if (!cancelled) {
-          setState({
-            kind: 'error',
-            message: err instanceof Error ? err.message : String(err),
-          });
-        }
-      });
-    return () => {
-      cancelled = true;
-    };
-  }, [reloadKey]);
-
-  if (state.kind === 'loading') {
-    return (
-      <div>
-        <h2>Channels</h2>
-        <ul className="skeleton-list" aria-busy="true">
-          <li className="skeleton skeleton-row" />
-          <li className="skeleton skeleton-row" />
-        </ul>
-      </div>
-    );
-  }
-
-  if (state.kind === 'error') {
-    return (
-      <div>
-        <h2>Channels</h2>
-        <div className="error-banner">
-          Couldn't load channels: <code>{state.message}</code>
-        </div>
-        <div className="actions" style={{ marginTop: '1rem' }}>
-          <button onClick={reload}>Retry</button>
-        </div>
-      </div>
-    );
-  }
-
-  return (
-    <div>
-      <div className="list-header">
-        <h2>Channel wirings ({state.wires.length})</h2>
-        <Link to="/channels/new">
-          <button className="secondary">+ Wire a new channel</button>
-        </Link>
-      </div>
-
-      <p className="muted">
-        Each wire binds a messaging thread (DM, channel, chat) to an agent group with routing rules. New wirings go
-        through the <Link to="/channels/new">wire-channel page</Link> so the channel token can be validated and the
-        platform id captured.
-      </p>
-
-      {state.wires.length === 0 && (
-        <div className="empty empty-rich" style={{ marginTop: '1rem' }}>
-          <p className="empty-headline">No channels wired yet.</p>
-          <p className="muted">
-            <Link to="/channels/new">Wire a new channel</Link> to route Discord or Telegram DMs into an agent group.
-          </p>
-        </div>
-      )}
-
-      {state.wires.map((w) => (
-        <ChannelRow key={w.id} wire={w} />
-      ))}
-    </div>
-  );
-}
-
-function ChannelRow({ wire }: { wire: ChannelWireView }) {
-  return (
-    <div
-      style={{
-        background: 'white',
-        border: '1px solid var(--border)',
-        borderRadius: '8px',
-        padding: '1rem 1.25rem',
-        marginBottom: '0.75rem',
-      }}
-    >
-      <div style={{ display: 'flex', alignItems: 'center', gap: '0.5rem', flexWrap: 'wrap' }}>
-        <strong style={{ textTransform: 'capitalize' }}>{wire.channelType}</strong>
-        <span className="dim">→</span>
-        <Link to={`/groups/${encodeURIComponent(wire.agentGroupFolder)}`}>{wire.agentGroupName}</Link>
-        <span className="tag muted">priority {wire.priority}</span>
-      </div>
-      <div className="kv" style={{ marginTop: '0.6rem' }}>
-        <div>platform id</div>
-        <div>
-          <code>{wire.platformId}</code>
-          {wire.displayName && <span className="dim"> · {wire.displayName}</span>}
-        </div>
-        <div>engage</div>
-        <div>
-          {wire.engageMode}
-          {wire.engagePattern && (
-            <>
-              {' '}
-              · pattern <code>{wire.engagePattern}</code>
-            </>
-          )}
-        </div>
-        <div>senders</div>
-        <div>{wire.senderScope}</div>
-        <div>ignored</div>
-        <div>{wire.ignoredMessagePolicy}</div>
-      </div>
-      <div className="actions" style={{ marginTop: '0.75rem' }}>
-        <Link to={`/channels/mga/${encodeURIComponent(wire.id)}`}>
-          <button className="secondary">Routing rules →</button>
-        </Link>
-        <Link to={`/channels/mg/${encodeURIComponent(wire.messagingGroupId)}`}>
-          <button className="secondary">Group settings →</button>
-        </Link>
-      </div>
-    </div>
-  );
-}

package/web/ui/src/routes/GroupDetail.test.tsx

@@ -1,206 +0,0 @@
-/**
- * GroupDetail "Secrets" panel — paraclaw#104.
- *
- * Asserts the three contracts the panel must hold:
- *   1. Each row's `scope` field renders a visible badge (`scoped` / `assigned`
- *      / `global`). Drift between badge text and panel intent would defeat
- *      the entire point of #104.
- *   2. Empty state distinguishes between mode='selective' (read as "by
- *      design") and mode='all' (read as "create a secret").
- *   3. Click-through builds `/secrets?edit=<id>`. SecretsList's deep-link
- *      handler is exercised separately; we just check the link target.
- *
- * Tests mock the api module — no live server, no auth state needed.
- */
-import { fireEvent, render, screen, waitFor } from '@testing-library/react';
-import { MemoryRouter, Route, Routes } from 'react-router-dom';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-
-import * as api from '../lib/api.ts';
-import { GroupDetail } from './GroupDetail.tsx';
-
-vi.mock('../lib/api.ts', async () => {
-  const actual = await vi.importActual<typeof api>('../lib/api.ts');
-  return {
-    ...actual,
-    getGroup: vi.fn(),
-    getGroupAgentProvider: vi.fn(),
-    listGroupInjectableSecrets: vi.fn(),
-  };
-});
-
-function renderAt(path: string) {
-  return render(
-    <MemoryRouter initialEntries={[path]}>
-      <Routes>
-        <Route path="/groups/:folder" element={<GroupDetail />} />
-      </Routes>
-    </MemoryRouter>,
-  );
-}
-
-const baseGroup: api.AgentGroupView = {
-  id: 'g1',
-  name: 'research',
-  folder: 'research',
-  agent_provider: null,
-  secret_mode: 'all',
-  created_at: '2026-04-20T10:00:00Z',
-  vault: null,
-  status: null,
-};
-
-const emptyProvider: api.AgentProviderView = {
-  source: null,
-  hasApiKey: false,
-  serverUrl: null,
-  updatedAt: null,
-};
-
-beforeEach(() => {
-  vi.mocked(api.getGroupAgentProvider).mockResolvedValue({
-    agentGroupId: 'g1',
-    overridden: false,
-    override: emptyProvider,
-    effective: emptyProvider,
-  });
-});
-
-afterEach(() => {
-  vi.clearAllMocks();
-});
-
-describe('GroupDetail — Secrets panel (paraclaw#104)', () => {
-  it('renders one badge per scope (scoped / assigned / global)', async () => {
-    vi.mocked(api.getGroup).mockResolvedValue({ ...baseGroup, secret_mode: 'all' });
-    vi.mocked(api.listGroupInjectableSecrets).mockResolvedValue([
-      {
-        id: 'sec-scoped',
-        name: 'SCOPED_TOKEN',
-        kind: 'channel-token',
-        agentGroupId: 'g1',
-        scope: 'scoped',
-        createdAt: '2026-05-01T00:00:00Z',
-        updatedAt: '2026-05-01T00:00:00Z',
-      },
-      {
-        id: 'sec-assigned',
-        name: 'ASSIGNED_TOKEN',
-        kind: 'api-key',
-        agentGroupId: null,
-        scope: 'assigned',
-        createdAt: '2026-05-01T00:00:00Z',
-        updatedAt: '2026-05-01T00:00:00Z',
-      },
-      {
-        id: 'sec-global',
-        name: 'GLOBAL_TOKEN',
-        kind: 'generic',
-        agentGroupId: null,
-        scope: 'global',
-        createdAt: '2026-05-01T00:00:00Z',
-        updatedAt: '2026-05-01T00:00:00Z',
-      },
-    ]);
-
-    renderAt('/groups/research');
-
-    await waitFor(() => {
-      expect(screen.getByText('SCOPED_TOKEN')).toBeInTheDocument();
-    });
-
-    expect(screen.getByText('SCOPED_TOKEN')).toBeInTheDocument();
-    expect(screen.getByText('ASSIGNED_TOKEN')).toBeInTheDocument();
-    expect(screen.getByText('GLOBAL_TOKEN')).toBeInTheDocument();
-
-    // Each scope label appears exactly once — the badge text must match the
-    // wire `scope` field one-to-one.
-    expect(screen.getByText('scoped')).toBeInTheDocument();
-    expect(screen.getByText('assigned')).toBeInTheDocument();
-    expect(screen.getByText('global')).toBeInTheDocument();
-  });
-
-  it('click-through targets /secrets?edit=<id>', async () => {
-    vi.mocked(api.getGroup).mockResolvedValue({ ...baseGroup, secret_mode: 'all' });
-    vi.mocked(api.listGroupInjectableSecrets).mockResolvedValue([
-      {
-        id: 'sec-1',
-        name: 'TOKEN',
-        kind: 'generic',
-        agentGroupId: 'g1',
-        scope: 'scoped',
-        createdAt: '2026-05-01T00:00:00Z',
-        updatedAt: '2026-05-01T00:00:00Z',
-      },
-    ]);
-
-    renderAt('/groups/research');
-
-    await waitFor(() => {
-      expect(screen.getByText('TOKEN')).toBeInTheDocument();
-    });
-
-    const link = screen.getByText('TOKEN').closest('a');
-    expect(link).toHaveAttribute('href', '/secrets?edit=sec-1');
-  });
-
-  it('empty state under selective mode reads as by-design, not broken', async () => {
-    vi.mocked(api.getGroup).mockResolvedValue({ ...baseGroup, secret_mode: 'selective' });
-    vi.mocked(api.listGroupInjectableSecrets).mockResolvedValue([]);
-
-    renderAt('/groups/research');
-
-    await waitFor(() => {
-      expect(screen.getByText(/No secrets reach this group/)).toBeInTheDocument();
-    });
-
-    // selective-mode copy mentions assignment rows, not "create a secret".
-    expect(screen.getByText(/explicit assignment row/)).toBeInTheDocument();
-  });
-
-  it('empty state under mode=all suggests creating a secret', async () => {
-    vi.mocked(api.getGroup).mockResolvedValue({ ...baseGroup, secret_mode: 'all' });
-    vi.mocked(api.listGroupInjectableSecrets).mockResolvedValue([]);
-
-    renderAt('/groups/research');
-
-    await waitFor(() => {
-      expect(screen.getByText(/No secrets reach this group/)).toBeInTheDocument();
-    });
-
-    expect(screen.getByText(/Create a scoped secret/)).toBeInTheDocument();
-  });
-
-  it('error state surfaces a Retry button that re-invokes the fetch (paraclaw#128)', async () => {
-    vi.mocked(api.getGroup).mockResolvedValue({ ...baseGroup, secret_mode: 'all' });
-    vi.mocked(api.listGroupInjectableSecrets)
-      .mockRejectedValueOnce(new Error('boom: transient 500'))
-      .mockResolvedValueOnce([
-        {
-          id: 'sec-1',
-          name: 'TOKEN',
-          kind: 'generic',
-          agentGroupId: 'g1',
-          scope: 'scoped',
-          createdAt: '2026-05-01T00:00:00Z',
-          updatedAt: '2026-05-01T00:00:00Z',
-        },
-      ]);
-
-    renderAt('/groups/research');
-
-    await waitFor(() => {
-      expect(screen.getByText(/Couldn't load secrets/)).toBeInTheDocument();
-    });
-    expect(screen.getByText('boom: transient 500')).toBeInTheDocument();
-
-    const retry = screen.getByRole('button', { name: 'Retry' });
-    fireEvent.click(retry);
-
-    await waitFor(() => {
-      expect(screen.getByText('TOKEN')).toBeInTheDocument();
-    });
-    expect(screen.queryByText(/Couldn't load secrets/)).not.toBeInTheDocument();
-    expect(api.listGroupInjectableSecrets).toHaveBeenCalledTimes(2);
-  });
-});