Changeset 0.28.0.4 (#176)

server/store/postgres/audit.go

@@ -25,25 +25,28 @@ func (s *AuditStore) Log(ctx context.Context, entry *models.AuditEntry) error {
 }
 
 func (s *AuditStore) List(ctx context.Context, opts store.AuditListOptions) ([]models.AuditEntry, int, error) {
-	b := NewSelect("id, actor_id, action, resource_type, resource_id, metadata, ip_address, user_agent, created_at", "audit_log")
+	b := NewSelect(`al.id, al.actor_id, COALESCE(u.username, '') AS actor_name,
+		al.action, al.resource_type, al.resource_id, al.metadata,
+		al.ip_address, al.user_agent, al.created_at`, "audit_log al")
+	b.Join("LEFT JOIN users u ON al.actor_id = u.id")
 
 	if opts.ActorID != "" {
-		b.Where("actor_id = ?", opts.ActorID)
+		b.Where("al.actor_id = ?", opts.ActorID)
 	}
 	if opts.Action != "" {
-		b.Where("action = ?", opts.Action)
+		b.Where("al.action = ?", opts.Action)
 	}
 	if opts.ResourceType != "" {
-		b.Where("resource_type = ?", opts.ResourceType)
+		b.Where("al.resource_type = ?", opts.ResourceType)
 	}
 	if opts.ResourceID != "" {
-		b.Where("resource_id = ?", opts.ResourceID)
+		b.Where("al.resource_id = ?", opts.ResourceID)
 	}
 	if opts.Since != nil {
-		b.Where("created_at >= ?", *opts.Since)
+		b.Where("al.created_at >= ?", *opts.Since)
 	}
 	if opts.Until != nil {
-		b.Where("created_at <= ?", *opts.Until)
+		b.Where("al.created_at <= ?", *opts.Until)
 	}
 
 	// Count
@@ -53,7 +56,7 @@ func (s *AuditStore) List(ctx context.Context, opts store.AuditListOptions) ([]m
 
 	// Results
 	if opts.Sort == "" {
-		b.OrderBy("created_at", "DESC")
+		b.OrderBy("al.created_at", "DESC")
 	}
 	b.Paginate(opts.ListOptions)
 
@@ -67,16 +70,40 @@ func (s *AuditStore) List(ctx context.Context, opts store.AuditListOptions) ([]m
 	var result []models.AuditEntry
 	for rows.Next() {
 		var e models.AuditEntry
-		var actorID sql.NullString
+		var actorID, actorName sql.NullString
 		var metadataJSON []byte
-		err := rows.Scan(&e.ID, &actorID, &e.Action, &e.ResourceType, &e.ResourceID,
+		err := rows.Scan(&e.ID, &actorID, &actorName, &e.Action, &e.ResourceType, &e.ResourceID,
 			&metadataJSON, &e.IPAddress, &e.UserAgent, &e.CreatedAt)
 		if err != nil {
 			return nil, 0, err
 		}
 		e.ActorID = NullableStringPtr(actorID)
+		if actorName.Valid && actorName.String != "" {
+			e.ActorName = &actorName.String
+		}
 		json.Unmarshal(metadataJSON, &e.Metadata)
 		result = append(result, e)
 	}
 	return result, total, rows.Err()
 }
+
+func (s *AuditStore) ListActions(ctx context.Context) ([]string, error) {
+	rows, err := DB.QueryContext(ctx,
+		`SELECT DISTINCT action FROM audit_log ORDER BY action ASC`)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var actions []string
+	for rows.Next() {
+		var a string
+		if rows.Scan(&a) == nil {
+			actions = append(actions, a)
+		}
+	}
+	if actions == nil {
+		actions = []string{}
+	}
+	return actions, rows.Err()
+}

server/store/postgres/channel.go

@@ -414,3 +414,55 @@ func (s *ChannelStore) DeleteModelByPersona(ctx context.Context, channelID, pers
 		channelID, personaID)
 	return err
 }
+
+// ── Admin: Archived Channel Management ──────
+
+func (s *ChannelStore) ListArchived(ctx context.Context, opts store.ListOptions) ([]store.ArchivedChannel, int, error) {
+	// Count
+	var total int
+	DB.QueryRowContext(ctx,
+		`SELECT COUNT(*) FROM channels WHERE is_archived = true`).Scan(&total)
+
+	rows, err := DB.QueryContext(ctx, `
+		SELECT c.id, c.title, c.type, COALESCE(u.username, '') AS owner_name,
+		       c.updated_at,
+		       (SELECT COUNT(*) FROM messages WHERE channel_id = c.id) AS message_count
+		FROM channels c
+		LEFT JOIN users u ON u.id = c.user_id
+		WHERE c.is_archived = true
+		ORDER BY c.updated_at DESC
+		LIMIT $1 OFFSET $2`, opts.Limit, opts.Offset)
+	if err != nil {
+		return nil, 0, err
+	}
+	defer rows.Close()
+
+	var channels []store.ArchivedChannel
+	for rows.Next() {
+		var ch store.ArchivedChannel
+		if rows.Scan(&ch.ID, &ch.Title, &ch.Type, &ch.OwnerName, &ch.UpdatedAt, &ch.MessageCount) == nil {
+			channels = append(channels, ch)
+		}
+	}
+	if channels == nil {
+		channels = []store.ArchivedChannel{}
+	}
+	return channels, total, rows.Err()
+}
+
+func (s *ChannelStore) Purge(ctx context.Context, id string) error {
+	// Verify the channel is actually archived
+	var isArchived bool
+	err := DB.QueryRowContext(ctx,
+		`SELECT is_archived FROM channels WHERE id = $1`, id).Scan(&isArchived)
+	if err != nil {
+		return fmt.Errorf("channel not found")
+	}
+	if !isArchived {
+		return fmt.Errorf("channel must be archived before purging")
+	}
+
+	// Hard delete (CASCADE removes messages, participants, models)
+	_, err = DB.ExecContext(ctx, `DELETE FROM channels WHERE id = $1`, id)
+	return err
+}