@consiliency/agent-board-schema 1.2.0

package/tests/agent_board_auth_schema.test.sql

@@ -0,0 +1,411 @@
+create extension if not exists pgtap with schema extensions;
+set search_path = extensions, public, agent_board;
+
+begin;
+
+select plan(20);
+
+select has_column('agent_board', 'agents', 'auth_user_id', 'agents exposes auth_user_id');
+select has_column('agent_board', 'agents', 'owner_user_id', 'agents exposes owner_user_id');
+select col_type_is('agent_board', 'agents', 'kind', 'agent_board.agent_kind', 'agents.kind uses the frozen enum type');
+
+select has_table('agent_board', 'agent_credentials', 'agent_credentials table exists');
+select has_column('agent_board', 'agent_credentials', 'refresh_token_hash', 'agent_credentials stores hashed refresh-token references');
+select has_column('agent_board', 'agent_credentials', 'hash_version', 'agent_credentials stores hash version metadata');
+select has_column('agent_board', 'agent_credentials', 'credential_label', 'agent_credentials stores a human-readable label');
+select has_column('agent_board', 'agent_credentials', 'expires_at', 'agent_credentials stores expiry metadata');
+select has_column('agent_board', 'agent_credentials', 'last_used_at', 'agent_credentials stores last-used metadata');
+select has_column('agent_board', 'agent_credentials', 'replaced_by_credential_id', 'agent_credentials stores replacement lineage');
+select has_column('agent_board', 'agent_credentials', 'replaces_credential_id', 'agent_credentials stores reverse rotation lineage');
+
+select has_function('agent_board', 'current_agent_id', array[]::text[], 'current_agent_id resolver exists');
+
+select ok(
+  (
+    select p.prosecdef and p.provolatile = 's'
+      from pg_proc p
+      join pg_namespace n on n.oid = p.pronamespace
+     where n.nspname = 'agent_board'
+       and p.proname = 'current_agent_id'
+  ),
+  'current_agent_id is security definer and stable'
+);
+
+select ok(
+  (
+    select count(distinct grantee) = 2
+      from information_schema.routine_privileges
+     where specific_schema = 'agent_board'
+       and routine_name = 'current_agent_id'
+       and privilege_type = 'EXECUTE'
+       and grantee in ('authenticated', 'service_role')
+  ),
+  'current_agent_id is executable by authenticated and service_role'
+);
+
+do $$
+declare
+  v_owner_user uuid;
+  v_rotated_user uuid;
+  v_duplicate_user uuid;
+  v_human_agent uuid;
+  v_agent_principal uuid;
+  v_thread uuid := gen_random_uuid();
+  v_task uuid;
+  v_message uuid;
+  v_conflict uuid;
+  v_escalation uuid;
+  v_delivery_recipient uuid;
+  v_inbox_item uuid;
+  v_endpoint uuid;
+  v_subscription uuid;
+  v_credential_old uuid;
+  v_credential_new uuid;
+begin
+  v_owner_user := public.ensure_github_user(
+    'agent-board-auth-owner',
+    'agent-board-auth-owner@example.test',
+    'agent-board-auth-owner',
+    'Agent Board Auth Owner'
+  );
+  v_rotated_user := public.ensure_github_user(
+    'agent-board-auth-rotated',
+    'agent-board-auth-rotated@example.test',
+    'agent-board-auth-rotated',
+    'Agent Board Auth Rotated'
+  );
+  v_duplicate_user := public.ensure_github_user(
+    'agent-board-auth-duplicate',
+    'agent-board-auth-duplicate@example.test',
+    'agent-board-auth-duplicate',
+    'Agent Board Auth Duplicate'
+  );
+
+  insert into agent_board.agents(id, agent_type, handle, display_name, owner_user_id, auth_user_id)
+  values (
+    gen_random_uuid(),
+    'human',
+    'test_authschema_human',
+    'Auth Human',
+    v_owner_user,
+    v_owner_user
+  )
+  returning id into v_human_agent;
+
+  insert into agent_board.agents(id, agent_type, handle, display_name, owner_user_id)
+  values (
+    gen_random_uuid(),
+    'agent',
+    'test_authschema_agent',
+    'Auth Agent',
+    v_owner_user
+  )
+  returning id into v_agent_principal;
+
+  if (select kind::text from agent_board.agents where id = v_human_agent) is distinct from 'human' then
+    raise exception 'legacy human insert did not backfill kind';
+  end if;
+
+  if (select kind::text from agent_board.agents where id = v_agent_principal) is distinct from 'agent' then
+    raise exception 'legacy agent insert did not backfill kind';
+  end if;
+
+  update agent_board.agents
+     set agent_type = 'human'
+   where id = v_agent_principal;
+
+  if (select kind::text from agent_board.agents where id = v_agent_principal) is distinct from 'human' then
+    raise exception 'agent_type update did not keep kind in sync';
+  end if;
+
+  update agent_board.agents
+     set auth_user_id = null
+   where id = v_agent_principal;
+
+  insert into agent_board.threads(id, thread_type, created_by_agent_id, subject)
+  values (v_thread, 'coordination', v_human_agent, 'Auth schema thread');
+
+  select task_id
+    into v_task
+    from agent_board.create_task(
+      v_thread,
+      v_human_agent,
+      'Auth schema task',
+      'Auth schema task details',
+      v_human_agent,
+      null,
+      'high',
+      'distributed',
+      '{}'::jsonb
+    );
+
+  insert into agent_board.messages(id, thread_id, author_agent_id, task_id, message_sequence, message_type, body)
+  values (gen_random_uuid(), v_thread, v_human_agent, v_task, 1, 'comment', 'Auth schema message')
+  returning id into v_message;
+
+  insert into agent_board.claims(task_id, thread_id, agent_id, resource_kind, resource_key, lease_expires_at)
+  values (v_task, v_thread, v_human_agent, 'repo_file', 'authschema.sql', now() + interval '10 minutes');
+
+  insert into agent_board.conflicts(thread_id, task_id, raised_by_agent_id, summary)
+  values (v_thread, v_task, v_human_agent, 'Auth conflict')
+  returning id into v_conflict;
+
+  insert into agent_board.escalations(thread_id, task_id, raised_by_agent_id, summary)
+  values (v_thread, v_task, v_human_agent, 'Auth escalation')
+  returning id into v_escalation;
+
+  insert into agent_board.delivery_recipients(delivery_mode, recipient_agent_id, source_kind, source_message_id)
+  values ('direct', v_human_agent, 'message', v_message)
+  returning id into v_delivery_recipient;
+
+  insert into agent_board.inbox_items(
+    delivery_recipient_id,
+    recipient_agent_id,
+    delivery_mode,
+    source_kind,
+    source_message_id,
+    subject,
+    preview,
+    priority,
+    action_state,
+    visible_in_inbox,
+    visible_in_board_feed,
+    fetch_descriptor
+  )
+  values (
+    v_delivery_recipient,
+    v_human_agent,
+    'direct',
+    'message',
+    v_message,
+    'Auth schema subject',
+    'Auth schema preview',
+    'high',
+    'new',
+    true,
+    false,
+    jsonb_build_object('surface', 'thread', 'targetId', v_thread::text, 'view', 'agent_board.v_thread_feed', 'filters', jsonb_build_object(), 'reason', 'auth schema')
+  )
+  returning id into v_inbox_item;
+
+  insert into agent_board.callback_endpoints(owner_agent_id, endpoint_url, endpoint_status, verification_requested_at, verified_at)
+  values (v_human_agent, 'https://example.test/authschema', 'verified', now(), now())
+  returning id into v_endpoint;
+
+  insert into agent_board.callback_subscriptions(endpoint_id, agent_id, subscription_scope, event_category, subscription_status)
+  values (v_endpoint, v_human_agent, 'own_inbox', 'inbox.item.delivered', 'active')
+  returning id into v_subscription;
+
+  insert into agent_board.agent_credentials(
+    agent_id,
+    refresh_token_hash,
+    hash_version,
+    credential_label,
+    expires_at
+  )
+  values (
+    v_human_agent,
+    decode(repeat('01', 32), 'hex'),
+    1,
+    'primary',
+    now() + interval '30 days'
+  )
+  returning id into v_credential_old;
+
+  insert into agent_board.agent_credentials(
+    agent_id,
+    refresh_token_hash,
+    hash_version,
+    credential_label,
+    expires_at,
+    replaces_credential_id
+  )
+  values (
+    v_human_agent,
+    decode(repeat('02', 32), 'hex'),
+    1,
+    'rotated',
+    now() + interval '60 days',
+    v_credential_old
+  )
+  returning id into v_credential_new;
+
+  update agent_board.agent_credentials
+     set replaced_by_credential_id = v_credential_new,
+         revoked_at = now(),
+         rotated_at = now()
+   where id = v_credential_old;
+
+  perform set_config('request.jwt.claim.sub', gen_random_uuid()::text, true);
+  if agent_board.current_agent_id() is not null then
+    raise exception 'unknown JWT unexpectedly resolved an agent principal';
+  end if;
+
+  perform set_config('request.jwt.claim.sub', v_owner_user::text, true);
+  if agent_board.current_agent_id() is distinct from v_human_agent then
+    raise exception 'known JWT did not resolve the expected agent principal';
+  end if;
+
+  update agent_board.agents
+     set auth_user_id = v_rotated_user
+   where id = v_human_agent;
+
+  perform set_config('request.jwt.claim.sub', v_owner_user::text, true);
+  if agent_board.current_agent_id() is not null then
+    raise exception 'rotated auth principal still resolved from the old user id';
+  end if;
+
+  perform set_config('request.jwt.claim.sub', v_rotated_user::text, true);
+  if agent_board.current_agent_id() is distinct from v_human_agent then
+    raise exception 'rotated auth principal did not resolve from the new user id';
+  end if;
+
+  if (select count(*) from agent_board.messages where author_agent_id = v_human_agent) <> 1 then
+    raise exception 'message history was orphaned by auth rotation';
+  end if;
+
+  if (select count(*) from agent_board.tasks where created_by_agent_id = v_human_agent or assigned_agent_id = v_human_agent) <> 1 then
+    raise exception 'task history was orphaned by auth rotation';
+  end if;
+
+  if (select count(*) from agent_board.claims where agent_id = v_human_agent) <> 1 then
+    raise exception 'claim history was orphaned by auth rotation';
+  end if;
+
+  if (select count(*) from agent_board.conflicts where id = v_conflict and raised_by_agent_id = v_human_agent) <> 1 then
+    raise exception 'conflict history was orphaned by auth rotation';
+  end if;
+
+  if (select count(*) from agent_board.escalations where id = v_escalation and raised_by_agent_id = v_human_agent) <> 1 then
+    raise exception 'escalation history was orphaned by auth rotation';
+  end if;
+
+  if (select count(*) from agent_board.inbox_items where id = v_inbox_item and recipient_agent_id = v_human_agent) <> 1 then
+    raise exception 'inbox history was orphaned by auth rotation';
+  end if;
+
+  if (select count(*) from agent_board.callback_endpoints where id = v_endpoint and owner_agent_id = v_human_agent) <> 1 then
+    raise exception 'callback endpoint history was orphaned by auth rotation';
+  end if;
+
+  if (select count(*) from agent_board.callback_subscriptions where id = v_subscription and agent_id = v_human_agent) <> 1 then
+    raise exception 'callback subscription history was orphaned by auth rotation';
+  end if;
+
+  begin
+    insert into agent_board.agents(id, agent_type, handle, display_name, owner_user_id, auth_user_id)
+    values (
+      gen_random_uuid(),
+      'human',
+      'test_authschema_duplicate_auth',
+      'Duplicate Auth User',
+      v_duplicate_user,
+      v_rotated_user
+    );
+    raise exception 'duplicate active auth_user_id insert unexpectedly succeeded';
+  exception
+    when unique_violation then
+      null;
+  end;
+
+  begin
+    insert into agent_board.agent_credentials(
+      agent_id,
+      refresh_token_hash,
+      hash_version,
+      credential_label,
+      expires_at
+    )
+    values (
+      v_human_agent,
+      decode(repeat('02', 32), 'hex'),
+      1,
+      'duplicate-hash',
+      now() + interval '1 day'
+    );
+    raise exception 'duplicate refresh_token_hash unexpectedly succeeded';
+  exception
+    when unique_violation then
+      null;
+  end;
+end
+$$;
+
+select ok(
+  exists (
+    select 1
+      from pg_indexes
+     where schemaname = 'agent_board'
+       and tablename = 'agents'
+       and indexname = 'idx_agent_board_agents_auth_user_id_active_unique'
+  ),
+  'agents has a single-active-principal unique index on auth_user_id'
+);
+
+select ok(
+  exists (
+    select 1
+      from pg_indexes
+     where schemaname = 'agent_board'
+       and tablename = 'agent_credentials'
+       and indexname = 'idx_agent_board_agent_credentials_refresh_token_hash'
+  ),
+  'agent_credentials has a unique index on refresh_token_hash'
+);
+
+select is(
+  (
+    select kind::text
+      from agent_board.agents
+     where handle = 'test_authschema_human'
+  ),
+  'human',
+  'legacy agent_type writers continue to produce a valid kind value'
+);
+
+select is(
+  (
+    select count(*)::int
+      from agent_board.agents
+     where auth_user_id = (
+       select auth_user_id
+         from agent_board.agents
+        where handle = 'test_authschema_human'
+     )
+       and status = 'active'
+  ),
+  1,
+  'one auth_user_id resolves to at most one active agent principal'
+);
+
+select is(
+  (
+    select count(*)::int
+      from agent_board.agent_credentials
+     where agent_id = (
+       select id
+         from agent_board.agents
+        where handle = 'test_authschema_human'
+     )
+       and replaced_by_credential_id is not null
+       and revoked_at is not null
+  ),
+  1,
+  'credential rotation preserves durable replacement lineage'
+);
+
+select throws_ok(
+  $$insert into agent_board.agent_credentials(agent_id, refresh_token_hash, hash_version, credential_label)
+    values (
+      (select id from agent_board.agents where handle = 'test_authschema_human'),
+      decode(repeat('03', 32), 'hex'),
+      1,
+      'missing-expiry'
+    )$$,
+  '23502',
+  null,
+  'agent_credentials requires expiry metadata'
+);
+
+select finish();
+rollback;

package/tests/agent_board_authbound_boundary.test.sql

@@ -0,0 +1,148 @@
+create extension if not exists pgtap with schema extensions;
+set search_path = extensions, public, agent_board;
+
+begin;
+
+select plan(10);
+
+select has_function('agent_board', 'current_agent_id', array[]::text[], 'current_agent_id exists');
+select has_function('agent_board', '_signed_write_actor_id', array['jsonb', 'jsonb', 'text'], 'AUTHBOUND actor assertion helper exists');
+select table_privs_are('agent_board', 'agent_credentials', 'service_role', array['SELECT'], 'service_role can perform server-only credential exchange lookup');
+select ok(has_column_privilege('service_role', 'agent_board.agent_credentials', 'last_used_at', 'UPDATE'), 'service_role can update credential last_used_at');
+select ok(has_column_privilege('service_role', 'agent_board.agent_credentials', 'updated_at', 'UPDATE'), 'service_role can update credential updated_at');
+
+create temp table _agent_board_authbound_fixture (
+  user_id uuid,
+  agent_id uuid,
+  credential_id uuid,
+  signing_key_id uuid
+) on commit drop;
+
+grant all on table _agent_board_authbound_fixture to authenticated, service_role;
+
+do $$
+declare
+  v_suffix text := replace(substr(gen_random_uuid()::text, 1, 8), '-', '');
+  v_user uuid;
+  v_agent uuid := gen_random_uuid();
+  v_credential uuid := gen_random_uuid();
+  v_key uuid;
+begin
+  v_user := public.ensure_github_user(
+    'agent-board-authbound-' || v_suffix,
+    'agent-board-authbound-' || v_suffix || '@example.test',
+    'agent-board-authbound-' || v_suffix,
+    'Agent Board AUTHBOUND ' || v_suffix
+  );
+
+  insert into agent_board.agents(id, agent_type, kind, handle, display_name, status, auth_user_id, owner_user_id)
+  values (v_agent, 'agent', 'agent', 'authbound-' || v_suffix, 'AUTHBOUND Agent', 'active', v_user, v_user);
+
+  insert into agent_board.agent_credentials(id, agent_id, refresh_token_hash, hash_version, credential_label, expires_at)
+  values (v_credential, v_agent, extensions.digest('authbound-refresh-' || v_suffix, 'sha256'), 1, 'authbound', now() + interval '1 day');
+
+  insert into agent_board.agent_signing_keys(agent_id, key_id, key_version, public_key, public_key_format, fingerprint, status, proof_state)
+  values (v_agent, 'primary', 1, repeat('A', 43), 'raw_ed25519_base64url', 'sha256:' || repeat('A', 43), 'active', 'proven')
+  returning id into v_key;
+
+  insert into _agent_board_authbound_fixture(user_id, agent_id, credential_id, signing_key_id)
+  values (v_user, v_agent, v_credential, v_key);
+end
+$$;
+
+set local role authenticated;
+select set_config('request.jwt.claim.role', 'authenticated', true);
+
+do $$
+declare
+  v_fixture record;
+begin
+  select * into v_fixture from _agent_board_authbound_fixture;
+  perform set_config('request.jwt.claim.sub', v_fixture.user_id::text, true);
+  perform set_config('request.jwt.claim.agent_credential_id', v_fixture.credential_id::text, true);
+
+  if agent_board.current_agent_id() is distinct from v_fixture.agent_id then
+    raise exception 'credential-bound current_agent_id did not resolve active agent';
+  end if;
+end
+$$;
+
+reset role;
+
+do $$
+declare
+  v_fixture record;
+begin
+  select * into v_fixture from _agent_board_authbound_fixture;
+  update agent_board.agent_credentials
+     set revoked_at = now()
+   where id = v_fixture.credential_id;
+end
+$$;
+
+set local role authenticated;
+select set_config('request.jwt.claim.role', 'authenticated', true);
+
+do $$
+declare
+  v_fixture record;
+begin
+  select * into v_fixture from _agent_board_authbound_fixture;
+  perform set_config('request.jwt.claim.sub', v_fixture.user_id::text, true);
+  perform set_config('request.jwt.claim.agent_credential_id', v_fixture.credential_id::text, true);
+  if agent_board.current_agent_id() is not null then
+    raise exception 'revoked credential still resolved before JWT expiry';
+  end if;
+end
+$$;
+
+select pass('current_agent_id honors agent_credential_id revocation before JWT expiry');
+
+select throws_like(
+  $$select agent_board._signed_write_actor_id(
+    '{}'::jsonb,
+    '{}'::jsonb,
+    'p_actor_agent_id'
+  )$$,
+  '%actor_mismatch%',
+  'missing gateway actor fails closed'
+);
+
+select throws_like(
+  $$select agent_board._signed_write_actor_id(
+    jsonb_build_object('p_actor_agent_id', (select agent_id::text from _agent_board_authbound_fixture)),
+    jsonb_build_object('agent_id', gen_random_uuid()::text),
+    'p_actor_agent_id'
+  )$$,
+  '%actor_mismatch%',
+  'payload actor assertion mismatch fails closed'
+);
+
+select ok(
+  exists (
+    select 1
+      from pg_proc p
+      join pg_namespace n on n.oid = p.pronamespace
+     where n.nspname = 'agent_board'
+       and p.proname = '_record_signed_write_evidence'
+       and pg_get_functiondef(p.oid) like '%authbound%'
+       and pg_get_functiondef(p.oid) like '%metadata-safe%'
+  ),
+  'signed-write evidence records AUTHBOUND metadata-safe posture'
+);
+
+select ok(
+  exists (
+    select 1
+      from pg_proc p
+      join pg_namespace n on n.oid = p.pronamespace
+     where n.nspname = 'agent_board'
+       and p.proname = 'current_agent_id'
+       and pg_get_functiondef(p.oid) like '%agent_credential_id%'
+  ),
+  'current_agent_id records AUTHBOUND credential-claim boundary'
+);
+
+select finish();
+
+rollback;