comparing v1.11.0-alpha and push-kuxpmtysszks on kot.pink/core

+1 -1

appview/pages/markup/extension/atlink.go

···

       89
       89
        
       	if entering {

     

       90
       90
        
       		w.WriteString(`<a href="/@`)

     

       91
       91
        
       		w.WriteString(n.(*AtNode).Handle)

     

       92
       92
       -
       		w.WriteString(`" class="mention">`)

     

       92
       92
       +
       		w.WriteString(`" class="mention font-bold">`)

     

       93
       93
        
       	} else {

     

       94
       94
        
       		w.WriteString("</a>")

     

       95
       95
        
       	}

+1 -1

appview/pages/markup/markdown.go

···

       249
       249
        
       	repoName := fmt.Sprintf("%s/%s", rctx.RepoInfo.OwnerDid, rctx.RepoInfo.Name)

     

       250
       250
        
       

     

       251
       251
        
       	query := fmt.Sprintf("repo=%s&ref=%s&path=%s&raw=true",

     

       252
       252
       -
       		url.PathEscape(repoName), url.PathEscape(rctx.RepoInfo.Ref), actualPath)

     

       252
       252
       +
       		url.QueryEscape(repoName), url.QueryEscape(rctx.RepoInfo.Ref), actualPath)

     

       253
       253
        
       

     

       254
       254
        
       	parsedURL := &url.URL{

     

       255
       255
        
       		Scheme:   scheme,

-1

appview/pages/templates/user/fragments/editBio.html

···

       31
       31
        
                 class="py-1 px-1 w-full"

     

       32
       32
        
                 name="pronouns"

     

       33
       33
        
                 placeholder="they/them"

     

       34
       34
       -
                 pattern="[a-zA-Z]{1,6}[\/\s\-][a-zA-Z]{1,6}"

     

       35
       34
        
                 value="{{ $pronouns }}"

     

       36
       35
        
               >

     

       37
       36
        
             </div>

+15 -7

spindle/secrets/openbao.go

···

       13
       13
        
       )

     

       14
       14
        
       

     

       15
       15
        
       type OpenBaoManager struct {

     

       16
       16
       -
       	client    *vault.Client

     

       17
       17
       -
       	mountPath string

     

       18
       18
       -
       	logger    *slog.Logger

     

       16
       16
       +
       	client            *vault.Client

     

       17
       17
       +
       	mountPath         string

     

       18
       18
       +
       	logger            *slog.Logger

     

       19
       19
       +
       	connectionTimeout time.Duration

     

       19
       20
        
       }

     

       20
       21
        
       

     

       21
       22
        
       type OpenBaoManagerOpt func(*OpenBaoManager)

     
···

       26
       27
        
       	}

     

       27
       28
        
       }

     

       28
       29
        
       

     

       30
       30
       +
       func WithConnectionTimeout(timeout time.Duration) OpenBaoManagerOpt {

     

       31
       31
       +
       	return func(v *OpenBaoManager) {

     

       32
       32
       +
       		v.connectionTimeout = timeout

     

       33
       33
       +
       	}

     

       34
       34
       +
       }

     

       35
       35
       +
       

     

       29
       36
        
       // NewOpenBaoManager creates a new OpenBao manager that connects to a Bao Proxy

     

       30
       37
        
       // The proxyAddress should point to the local Bao Proxy (e.g., "http://127.0.0.1:8200")

     

       31
       38
        
       // The proxy handles all authentication automatically via Auto-Auth

     
···

       43
       50
        
       	}

     

       44
       51
        
       

     

       45
       52
        
       	manager := &OpenBaoManager{

     

       46
       46
       -
       		client:    client,

     

       47
       47
       -
       		mountPath: "spindle", // default KV v2 mount path

     

       48
       48
       -
       		logger:    logger,

     

       53
       53
       +
       		client:            client,

     

       54
       54
       +
       		mountPath:         "spindle", // default KV v2 mount path

     

       55
       55
       +
       		logger:            logger,

     

       56
       56
       +
       		connectionTimeout: 10 * time.Second, // default connection timeout

     

       49
       57
        
       	}

     

       50
       58
        
       

     

       51
       59
        
       	for _, opt := range opts {

     
···

       62
       70
        
       

     

       63
       71
        
       // testConnection verifies that we can connect to the proxy

     

       64
       72
        
       func (v *OpenBaoManager) testConnection() error {

     

       65
       65
       -
       	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)

     

       73
       73
       +
       	ctx, cancel := context.WithTimeout(context.Background(), v.connectionTimeout)

     

       66
       74
        
       	defer cancel()

     

       67
       75
        
       

     

       68
       76
        
       	// try token self-lookup as a quick way to verify proxy works

+5 -2

spindle/secrets/openbao_test.go

···

       152
       152
        
       	for _, tt := range tests {

     

       153
       153
        
       		t.Run(tt.name, func(t *testing.T) {

     

       154
       154
        
       			logger := slog.New(slog.NewTextHandler(os.Stderr, nil))

     

       155
       155
       -
       			manager, err := NewOpenBaoManager(tt.proxyAddr, logger, tt.opts...)

     

       155
       155
       +
       			// Use shorter timeout for tests to avoid long waits

     

       156
       156
       +
       			opts := append(tt.opts, WithConnectionTimeout(1*time.Second))

     

       157
       157
       +
       			manager, err := NewOpenBaoManager(tt.proxyAddr, logger, opts...)

     

       156
       158
        
       

     

       157
       159
        
       			if tt.expectError {

     

       158
       160
        
       				assert.Error(t, err)

     
···

       596
       598
        
       

     

       597
       599
        
       			// All these will fail because no real proxy is running

     

       598
       600
        
       			// but we can test that the configuration is properly accepted

     

       599
       599
       -
       			manager, err := NewOpenBaoManager(tt.proxyAddr, logger)

     

       601
       601
       +
       			// Use shorter timeout for tests to avoid long waits

     

       602
       602
       +
       			manager, err := NewOpenBaoManager(tt.proxyAddr, logger, WithConnectionTimeout(1*time.Second))

     

       600
       603
        
       			assert.Error(t, err) // Expected because no real proxy

     

       601
       604
        
       			assert.Nil(t, manager)

     

       602
       605
        
       			assert.Contains(t, err.Error(), "failed to connect to bao proxy")

Compare changes