julien.rbrt.fr
+42
config.example.yaml
+42
config.example.yaml
···
1
+
# bskyrss configuration file
2
+
# This file allows you to map different RSS/Atom feeds to different Bluesky accounts
3
+
4
+
# List of accounts with their associated feeds
5
+
accounts:
6
+
# First account - posts from multiple feeds
7
+
- handle: "user1.bsky.social"
8
+
# Password can be plain text (not recommended) or environment variable reference
9
+
# Use ${VAR_NAME} or $VAR_NAME format for environment variables
10
+
password: "${BSKY_PASSWORD_USER1}"
11
+
# Optional: Custom PDS server (defaults to https://bsky.social)
12
+
pds: "https://bsky.social"
13
+
# Optional: Custom storage file for this account (defaults to global storage with account suffix)
14
+
# storage: "user1_posted.txt"
15
+
feeds:
16
+
- "https://example.com/feed.xml"
17
+
- "https://blog.example.com/rss"
18
+
- "https://news.example.com/atom.xml"
19
+
20
+
# Second account - posts from different feeds
21
+
- handle: "user2.bsky.social"
22
+
password: "${BSKY_PASSWORD_USER2}"
23
+
feeds:
24
+
- "https://another-blog.com/feed.xml"
25
+
- "https://tech-news.com/rss"
26
+
27
+
# Third account - posts from a single feed
28
+
- handle: "user3.bsky.social"
29
+
password: "${BSKY_PASSWORD_USER3}"
30
+
pds: "https://custom-pds.example.com"
31
+
feeds:
32
+
- "https://personal-blog.com/feed.xml"
33
+
34
+
# Global settings (optional)
35
+
# Poll interval for checking feeds (default: 15m)
36
+
# Valid units: s, m, h (e.g., "30s", "5m", "1h")
37
+
interval: "15m"
38
+
39
+
# Default storage file for tracking posted items (default: posted_items.txt)
40
+
# When multiple accounts are configured, separate files will be created automatically
41
+
# (e.g., posted_items_user1_bsky_social.txt, posted_items_user2_bsky_social.txt)
42
+
storage: "posted_items.txt"
+1
go.mod
+1
go.mod
+106
internal/config/config.go
+106
internal/config/config.go
···
1
+
package config
2
+
3
+
import (
4
+
"fmt"
5
+
"os"
6
+
"strings"
7
+
"time"
8
+
9
+
"gopkg.in/yaml.v3"
10
+
)
11
+
12
+
// Config represents the application configuration
13
+
type Config struct {
14
+
Accounts []Account `yaml:"accounts"`
15
+
Interval time.Duration `yaml:"interval,omitempty"`
16
+
Storage string `yaml:"storage,omitempty"`
17
+
}
18
+
19
+
// Account represents a Bluesky account with its associated feeds
20
+
type Account struct {
21
+
Handle string `yaml:"handle"`
22
+
Password string `yaml:"password,omitempty"`
23
+
PDS string `yaml:"pds,omitempty"`
24
+
Feeds []string `yaml:"feeds"`
25
+
Storage string `yaml:"storage,omitempty"` // Optional per-account storage file
26
+
}
27
+
28
+
// LoadFromFile loads configuration from a YAML file
29
+
func LoadFromFile(path string) (*Config, error) {
30
+
data, err := os.ReadFile(path)
31
+
if err != nil {
32
+
return nil, fmt.Errorf("failed to read config file: %w", err)
33
+
}
34
+
35
+
var cfg Config
36
+
if err := yaml.Unmarshal(data, &cfg); err != nil {
37
+
return nil, fmt.Errorf("failed to parse config file: %w", err)
38
+
}
39
+
40
+
if err := cfg.Validate(); err != nil {
41
+
return nil, fmt.Errorf("invalid configuration: %w", err)
42
+
}
43
+
44
+
// Process environment variables in passwords
45
+
for i := range cfg.Accounts {
46
+
cfg.Accounts[i].Password = expandEnvVar(cfg.Accounts[i].Password)
47
+
}
48
+
49
+
// Set defaults
50
+
if cfg.Interval == 0 {
51
+
cfg.Interval = 15 * time.Minute
52
+
}
53
+
if cfg.Storage == "" {
54
+
cfg.Storage = "posted_items.txt"
55
+
}
56
+
57
+
return &cfg, nil
58
+
}
59
+
60
+
// Validate checks if the configuration is valid
61
+
func (c *Config) Validate() error {
62
+
if len(c.Accounts) == 0 {
63
+
return fmt.Errorf("at least one account is required")
64
+
}
65
+
66
+
for i, account := range c.Accounts {
67
+
if account.Handle == "" {
68
+
return fmt.Errorf("account %d: handle is required", i)
69
+
}
70
+
if len(account.Feeds) == 0 {
71
+
return fmt.Errorf("account %d (%s): at least one feed is required", i, account.Handle)
72
+
}
73
+
if account.Password == "" {
74
+
return fmt.Errorf("account %d (%s): password is required", i, account.Handle)
75
+
}
76
+
}
77
+
78
+
return nil
79
+
}
80
+
81
+
// expandEnvVar expands environment variable references in the format ${VAR_NAME} or $VAR_NAME
82
+
func expandEnvVar(value string) string {
83
+
if value == "" {
84
+
return value
85
+
}
86
+
87
+
// Handle ${VAR_NAME} format
88
+
if strings.HasPrefix(value, "${") && strings.HasSuffix(value, "}") {
89
+
varName := value[2 : len(value)-1]
90
+
if envVal := os.Getenv(varName); envVal != "" {
91
+
return envVal
92
+
}
93
+
return value
94
+
}
95
+
96
+
// Handle $VAR_NAME format
97
+
if strings.HasPrefix(value, "$") {
98
+
varName := value[1:]
99
+
if envVal := os.Getenv(varName); envVal != "" {
100
+
return envVal
101
+
}
102
+
return value
103
+
}
104
+
105
+
return value
106
+
}
+256
internal/config/config_test.go
+256
internal/config/config_test.go
···
1
+
package config
2
+
3
+
import (
4
+
"os"
5
+
"path/filepath"
6
+
"testing"
7
+
"time"
8
+
)
9
+
10
+
func TestLoadFromFile(t *testing.T) {
11
+
// Create a temporary config file
12
+
tmpDir := t.TempDir()
13
+
configPath := filepath.Join(tmpDir, "config.yaml")
14
+
15
+
configContent := `
16
+
accounts:
17
+
- handle: "user1.bsky.social"
18
+
password: "password1"
19
+
pds: "https://bsky.social"
20
+
feeds:
21
+
- "https://feed1.com/rss"
22
+
- "https://feed2.com/atom"
23
+
- handle: "user2.bsky.social"
24
+
password: "password2"
25
+
feeds:
26
+
- "https://feed3.com/rss"
27
+
28
+
interval: "10m"
29
+
storage: "custom_storage.txt"
30
+
`
31
+
32
+
if err := os.WriteFile(configPath, []byte(configContent), 0644); err != nil {
33
+
t.Fatalf("Failed to write config file: %v", err)
34
+
}
35
+
36
+
cfg, err := LoadFromFile(configPath)
37
+
if err != nil {
38
+
t.Fatalf("LoadFromFile failed: %v", err)
39
+
}
40
+
41
+
// Verify accounts
42
+
if len(cfg.Accounts) != 2 {
43
+
t.Errorf("Expected 2 accounts, got %d", len(cfg.Accounts))
44
+
}
45
+
46
+
// Verify first account
47
+
if cfg.Accounts[0].Handle != "user1.bsky.social" {
48
+
t.Errorf("Expected handle 'user1.bsky.social', got '%s'", cfg.Accounts[0].Handle)
49
+
}
50
+
if cfg.Accounts[0].Password != "password1" {
51
+
t.Errorf("Expected password 'password1', got '%s'", cfg.Accounts[0].Password)
52
+
}
53
+
if len(cfg.Accounts[0].Feeds) != 2 {
54
+
t.Errorf("Expected 2 feeds for account 1, got %d", len(cfg.Accounts[0].Feeds))
55
+
}
56
+
57
+
// Verify second account
58
+
if cfg.Accounts[1].Handle != "user2.bsky.social" {
59
+
t.Errorf("Expected handle 'user2.bsky.social', got '%s'", cfg.Accounts[1].Handle)
60
+
}
61
+
if len(cfg.Accounts[1].Feeds) != 1 {
62
+
t.Errorf("Expected 1 feed for account 2, got %d", len(cfg.Accounts[1].Feeds))
63
+
}
64
+
65
+
// Verify global settings
66
+
if cfg.Interval != 10*time.Minute {
67
+
t.Errorf("Expected interval 10m, got %v", cfg.Interval)
68
+
}
69
+
if cfg.Storage != "custom_storage.txt" {
70
+
t.Errorf("Expected storage 'custom_storage.txt', got '%s'", cfg.Storage)
71
+
}
72
+
}
73
+
74
+
func TestLoadFromFileWithEnvVars(t *testing.T) {
75
+
// Set environment variable
76
+
os.Setenv("TEST_PASSWORD", "env-password")
77
+
defer os.Unsetenv("TEST_PASSWORD")
78
+
79
+
tmpDir := t.TempDir()
80
+
configPath := filepath.Join(tmpDir, "config.yaml")
81
+
82
+
configContent := `
83
+
accounts:
84
+
- handle: "user1.bsky.social"
85
+
password: "${TEST_PASSWORD}"
86
+
feeds:
87
+
- "https://feed1.com/rss"
88
+
`
89
+
90
+
if err := os.WriteFile(configPath, []byte(configContent), 0644); err != nil {
91
+
t.Fatalf("Failed to write config file: %v", err)
92
+
}
93
+
94
+
cfg, err := LoadFromFile(configPath)
95
+
if err != nil {
96
+
t.Fatalf("LoadFromFile failed: %v", err)
97
+
}
98
+
99
+
if cfg.Accounts[0].Password != "env-password" {
100
+
t.Errorf("Expected password 'env-password' from env var, got '%s'", cfg.Accounts[0].Password)
101
+
}
102
+
}
103
+
104
+
func TestLoadFromFileDefaults(t *testing.T) {
105
+
tmpDir := t.TempDir()
106
+
configPath := filepath.Join(tmpDir, "config.yaml")
107
+
108
+
// Minimal config with only required fields
109
+
configContent := `
110
+
accounts:
111
+
- handle: "user1.bsky.social"
112
+
password: "password1"
113
+
feeds:
114
+
- "https://feed1.com/rss"
115
+
`
116
+
117
+
if err := os.WriteFile(configPath, []byte(configContent), 0644); err != nil {
118
+
t.Fatalf("Failed to write config file: %v", err)
119
+
}
120
+
121
+
cfg, err := LoadFromFile(configPath)
122
+
if err != nil {
123
+
t.Fatalf("LoadFromFile failed: %v", err)
124
+
}
125
+
126
+
// Check defaults
127
+
if cfg.Interval != 15*time.Minute {
128
+
t.Errorf("Expected default interval 15m, got %v", cfg.Interval)
129
+
}
130
+
if cfg.Storage != "posted_items.txt" {
131
+
t.Errorf("Expected default storage 'posted_items.txt', got '%s'", cfg.Storage)
132
+
}
133
+
134
+
}
135
+
136
+
func TestLoadFromFileInvalid(t *testing.T) {
137
+
tests := []struct {
138
+
name string
139
+
content string
140
+
wantErr bool
141
+
}{
142
+
{
143
+
name: "no accounts",
144
+
content: `
145
+
interval: "15m"
146
+
`,
147
+
wantErr: true,
148
+
},
149
+
{
150
+
name: "account without handle",
151
+
content: `
152
+
accounts:
153
+
- password: "password1"
154
+
feeds:
155
+
- "https://feed1.com/rss"
156
+
`,
157
+
wantErr: true,
158
+
},
159
+
{
160
+
name: "account without password",
161
+
content: `
162
+
accounts:
163
+
- handle: "user1.bsky.social"
164
+
feeds:
165
+
- "https://feed1.com/rss"
166
+
`,
167
+
wantErr: true,
168
+
},
169
+
{
170
+
name: "account without feeds",
171
+
content: `
172
+
accounts:
173
+
- handle: "user1.bsky.social"
174
+
password: "password1"
175
+
feeds: []
176
+
`,
177
+
wantErr: true,
178
+
},
179
+
}
180
+
181
+
for _, tt := range tests {
182
+
t.Run(tt.name, func(t *testing.T) {
183
+
tmpDir := t.TempDir()
184
+
configPath := filepath.Join(tmpDir, "config.yaml")
185
+
186
+
if err := os.WriteFile(configPath, []byte(tt.content), 0644); err != nil {
187
+
t.Fatalf("Failed to write config file: %v", err)
188
+
}
189
+
190
+
_, err := LoadFromFile(configPath)
191
+
if (err != nil) != tt.wantErr {
192
+
t.Errorf("LoadFromFile() error = %v, wantErr %v", err, tt.wantErr)
193
+
}
194
+
})
195
+
}
196
+
}
197
+
198
+
func TestExpandEnvVar(t *testing.T) {
199
+
tests := []struct {
200
+
name string
201
+
input string
202
+
envKey string
203
+
envValue string
204
+
want string
205
+
}{
206
+
{
207
+
name: "expand ${VAR}",
208
+
input: "${TEST_VAR}",
209
+
envKey: "TEST_VAR",
210
+
envValue: "test-value",
211
+
want: "test-value",
212
+
},
213
+
{
214
+
name: "expand $VAR",
215
+
input: "$TEST_VAR",
216
+
envKey: "TEST_VAR",
217
+
envValue: "test-value",
218
+
want: "test-value",
219
+
},
220
+
{
221
+
name: "no expansion plain text",
222
+
input: "plain-text",
223
+
envKey: "TEST_VAR",
224
+
envValue: "test-value",
225
+
want: "plain-text",
226
+
},
227
+
{
228
+
name: "env var not set ${VAR}",
229
+
input: "${NONEXISTENT}",
230
+
envKey: "OTHER_VAR",
231
+
envValue: "test-value",
232
+
want: "${NONEXISTENT}",
233
+
},
234
+
{
235
+
name: "env var not set $VAR",
236
+
input: "$NONEXISTENT",
237
+
envKey: "OTHER_VAR",
238
+
envValue: "test-value",
239
+
want: "$NONEXISTENT",
240
+
},
241
+
}
242
+
243
+
for _, tt := range tests {
244
+
t.Run(tt.name, func(t *testing.T) {
245
+
if tt.envKey != "" {
246
+
os.Setenv(tt.envKey, tt.envValue)
247
+
defer os.Unsetenv(tt.envKey)
248
+
}
249
+
250
+
got := expandEnvVar(tt.input)
251
+
if got != tt.want {
252
+
t.Errorf("expandEnvVar(%q) = %q, want %q", tt.input, got, tt.want)
253
+
}
254
+
})
255
+
}
256
+
}
+123
-94
main.go
+123
-94
main.go
···
13
13
"time"
14
14
15
15
"pkg.rbrt.fr/bskyrss/internal/bluesky"
16
+
"pkg.rbrt.fr/bskyrss/internal/config"
16
17
"pkg.rbrt.fr/bskyrss/internal/rss"
17
18
"pkg.rbrt.fr/bskyrss/internal/storage"
18
19
)
···
25
26
26
27
func main() {
27
28
// Command line flags
28
-
feedURLs := flag.String("feed", "", "RSS/Atom feed URL(s) to monitor (comma-delimited for multiple feeds, required)")
29
-
handle := flag.String("handle", "", "Bluesky handle (required)")
30
-
password := flag.String("password", "", "Bluesky password (can also use BSKY_PASSWORD env var)")
31
-
pds := flag.String("pds", "https://bsky.social", "Bluesky PDS server URL")
32
-
pollInterval := flag.Duration("interval", defaultPollInterval, "Poll interval for checking RSS feed")
33
-
storageFile := flag.String("storage", defaultStorageFile, "File to store posted item GUIDs")
29
+
configFile := flag.String("config", "config.yaml", "Path to configuration file (YAML)")
34
30
dryRun := flag.Bool("dry-run", false, "Don't actually post to Bluesky, just show what would be posted")
35
31
flag.Parse()
36
32
37
-
// Validate required flags
38
-
if *feedURLs == "" {
39
-
log.Fatal("Error: -feed flag is required")
40
-
}
41
-
if *handle == "" {
42
-
log.Fatal("Error: -handle flag is required")
33
+
// Load configuration from file
34
+
if *configFile == "" {
35
+
log.Fatal("Error: -config flag is required")
43
36
}
44
37
45
-
// Parse comma-delimited feed URLs
46
-
feeds := parseFeedURLs(*feedURLs)
47
-
if len(feeds) == 0 {
48
-
log.Fatal("Error: no valid feed URLs provided")
38
+
cfg, err := config.LoadFromFile(*configFile)
39
+
if err != nil {
40
+
log.Fatalf("Failed to load config file: %v", err)
49
41
}
50
-
log.Printf("Monitoring %d feed(s)", len(feeds))
42
+
log.Printf("Loaded configuration with %d account(s)", len(cfg.Accounts))
51
43
52
-
// Get password from flag or environment variable
53
-
bskyPassword := *password
54
-
if bskyPassword == "" {
55
-
bskyPassword = os.Getenv("BSKY_PASSWORD")
56
-
if bskyPassword == "" {
57
-
log.Fatal("Error: -password flag or BSKY_PASSWORD environment variable is required")
58
-
}
44
+
if *dryRun {
45
+
log.Println("Running in DRY-RUN mode - no posts will be made")
59
46
}
60
47
61
-
store, err := storage.New(*storageFile)
62
-
if err != nil {
63
-
log.Fatalf("Failed to initialize storage: %v", err)
48
+
// Count total feeds across all accounts
49
+
totalFeeds := 0
50
+
for _, account := range cfg.Accounts {
51
+
totalFeeds += len(account.Feeds)
64
52
}
65
-
log.Printf("Storage initialized with %d previously posted items", store.Count())
66
-
67
-
rssChecker := rss.NewChecker()
68
-
69
-
// Initialize Bluesky client (unless dry-run mode)
70
-
var bskyClient *bluesky.Client
71
-
if !*dryRun {
72
-
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
73
-
defer cancel()
74
-
75
-
bskyClient, err = bluesky.NewClient(ctx, bluesky.Config{
76
-
Handle: *handle,
77
-
Password: bskyPassword,
78
-
PDS: *pds,
79
-
})
80
-
if err != nil {
81
-
log.Fatalf("Failed to initialize Bluesky client: %v", err)
82
-
}
83
-
log.Printf("Authenticated as @%s", bskyClient.GetHandle())
84
-
} else {
85
-
log.Println("Running in DRY-RUN mode - no posts will be made")
86
-
}
53
+
log.Printf("Monitoring %d feed(s) across %d account(s)", totalFeeds, len(cfg.Accounts))
87
54
88
55
// Setup signal handling for graceful shutdown
89
56
ctx, cancel := context.WithCancel(context.Background())
···
98
65
cancel()
99
66
}()
100
67
101
-
// Main loop
102
-
log.Printf("Poll interval: %s", *pollInterval)
68
+
// Initialize managers for each account
69
+
managers := make([]*AccountManager, 0, len(cfg.Accounts))
70
+
for i, account := range cfg.Accounts {
71
+
// Determine storage file for this account
72
+
storageFilePath := cfg.Storage
73
+
if account.Storage != "" {
74
+
storageFilePath = account.Storage
75
+
} else if len(cfg.Accounts) > 1 {
76
+
// For multiple accounts, use separate storage files by default
77
+
ext := ".txt"
78
+
base := strings.TrimSuffix(cfg.Storage, ext)
79
+
storageFilePath = fmt.Sprintf("%s_%s%s", base, sanitizeHandle(account.Handle), ext)
80
+
}
103
81
104
-
ticker := time.NewTicker(*pollInterval)
82
+
manager, err := NewAccountManager(ctx, account, storageFilePath, *dryRun)
83
+
if err != nil {
84
+
log.Fatalf("Failed to initialize account %d (%s): %v", i+1, account.Handle, err)
85
+
}
86
+
managers = append(managers, manager)
87
+
log.Printf("Initialized account: @%s with %d feed(s) (storage: %s)", account.Handle, len(account.Feeds), storageFilePath)
88
+
}
89
+
90
+
log.Printf("Poll interval: %s", cfg.Interval)
91
+
92
+
ticker := time.NewTicker(cfg.Interval)
105
93
defer ticker.Stop()
106
94
107
95
// Check immediately on startup
108
-
if err := checkAndPostFeeds(ctx, rssChecker, bskyClient, store, feeds, *dryRun); err != nil {
109
-
log.Printf("Error during initial check: %v", err)
96
+
for _, manager := range managers {
97
+
if err := manager.CheckAndPost(ctx); err != nil {
98
+
log.Printf("Error during initial check for @%s: %v", manager.account.Handle, err)
99
+
}
110
100
}
111
101
112
-
// Continue checking on interval (not first run anymore after first check)
102
+
// Continue checking on interval
113
103
for {
114
104
select {
115
105
case <-ctx.Done():
116
106
return
117
107
case <-ticker.C:
118
-
if err := checkAndPostFeeds(ctx, rssChecker, bskyClient, store, feeds, *dryRun); err != nil {
119
-
log.Printf("Error during check: %v", err)
108
+
for _, manager := range managers {
109
+
if err := manager.CheckAndPost(ctx); err != nil {
110
+
log.Printf("Error during check for @%s: %v", manager.account.Handle, err)
111
+
}
120
112
}
121
113
}
122
114
}
123
115
}
124
116
125
-
// parseFeedURLs splits comma-delimited feed URLs and trims whitespace
126
-
func parseFeedURLs(feedString string) []string {
127
-
if feedString == "" {
128
-
return nil
117
+
// AccountManager manages RSS checking and posting for a single Bluesky account
118
+
type AccountManager struct {
119
+
account config.Account
120
+
bskyClient *bluesky.Client
121
+
rssChecker *rss.Checker
122
+
store *storage.Storage
123
+
dryRun bool
124
+
}
125
+
126
+
// NewAccountManager creates a new account manager
127
+
func NewAccountManager(ctx context.Context, account config.Account, storageFile string, dryRun bool) (*AccountManager, error) {
128
+
store, err := storage.New(storageFile)
129
+
if err != nil {
130
+
return nil, fmt.Errorf("failed to initialize storage: %w", err)
129
131
}
130
132
131
-
parts := strings.Split(feedString, ",")
132
-
feeds := make([]string, 0, len(parts))
133
+
rssChecker := rss.NewChecker()
134
+
135
+
var bskyClient *bluesky.Client
136
+
if !dryRun {
137
+
authCtx, cancel := context.WithTimeout(ctx, 30*time.Second)
138
+
defer cancel()
133
139
134
-
for _, part := range parts {
135
-
trimmed := strings.TrimSpace(part)
136
-
if trimmed != "" {
137
-
feeds = append(feeds, trimmed)
140
+
pds := account.PDS
141
+
if pds == "" {
142
+
pds = "https://bsky.social"
143
+
}
144
+
145
+
bskyClient, err = bluesky.NewClient(authCtx, bluesky.Config{
146
+
Handle: account.Handle,
147
+
Password: account.Password,
148
+
PDS: pds,
149
+
})
150
+
if err != nil {
151
+
return nil, fmt.Errorf("failed to initialize Bluesky client: %w", err)
138
152
}
139
153
}
140
154
141
-
return feeds
155
+
return &AccountManager{
156
+
account: account,
157
+
bskyClient: bskyClient,
158
+
rssChecker: rssChecker,
159
+
store: store,
160
+
dryRun: dryRun,
161
+
}, nil
142
162
}
143
163
144
-
func checkAndPostFeeds(ctx context.Context, rssChecker *rss.Checker, bskyClient *bluesky.Client, store *storage.Storage, feedURLs []string, dryRun bool) error {
145
-
for _, feedURL := range feedURLs {
146
-
if err := checkAndPost(ctx, rssChecker, bskyClient, store, feedURL, dryRun); err != nil {
147
-
log.Printf("Error checking feed %s: %v", feedURL, err)
164
+
// CheckAndPost checks all feeds for this account and posts new items
165
+
func (m *AccountManager) CheckAndPost(ctx context.Context) error {
166
+
for _, feedURL := range m.account.Feeds {
167
+
if err := m.checkAndPostFeed(ctx, feedURL); err != nil {
168
+
log.Printf("[@%s] Error checking feed %s: %v", m.account.Handle, feedURL, err)
148
169
// Continue with other feeds even if one fails
149
170
}
150
171
}
151
-
152
172
return nil
153
173
}
154
174
155
-
func checkAndPost(ctx context.Context, rssChecker *rss.Checker, bskyClient *bluesky.Client, store *storage.Storage, feedURL string, dryRun bool) error {
156
-
log.Printf("Checking RSS feed: %s", feedURL)
175
+
// checkAndPostFeed checks a single feed and posts new items
176
+
func (m *AccountManager) checkAndPostFeed(ctx context.Context, feedURL string) error {
177
+
log.Printf("[@%s] Checking RSS feed: %s", m.account.Handle, feedURL)
157
178
158
-
items, err := rssChecker.FetchLatestItems(ctx, feedURL)
179
+
items, err := m.rssChecker.FetchLatestItems(ctx, feedURL)
159
180
if err != nil {
160
181
return fmt.Errorf("failed to fetch RSS items: %w", err)
161
182
}
162
183
163
-
log.Printf("Found %d items in feed", len(items))
184
+
log.Printf("[@%s] Found %d items in feed", m.account.Handle, len(items))
164
185
165
186
// Check if this is the first time seeing this feed (no items from it in storage)
166
187
hasSeenFeedBefore := false
167
188
for _, item := range items {
168
-
if store.IsPosted(item.GUID) {
189
+
if m.store.IsPosted(item.GUID) {
169
190
hasSeenFeedBefore = true
170
191
break
171
192
}
···
179
200
item := items[i]
180
201
181
202
// Skip if already posted
182
-
if store.IsPosted(item.GUID) {
203
+
if m.store.IsPosted(item.GUID) {
183
204
continue
184
205
}
185
206
···
187
208
188
209
// If this is first time seeing this feed, mark items as seen without posting
189
210
if !hasSeenFeedBefore {
190
-
if err := store.MarkPosted(item.GUID); err != nil {
191
-
log.Printf("Failed to mark item as seen: %v", err)
211
+
if err := m.store.MarkPosted(item.GUID); err != nil {
212
+
log.Printf("[@%s] Failed to mark item as seen: %v", m.account.Handle, err)
192
213
}
193
214
continue
194
215
}
195
216
196
-
log.Printf("New item found: %s", item.Title)
217
+
log.Printf("[@%s] New item found: %s", m.account.Handle, item.Title)
197
218
198
219
// Create post text
199
220
postText := formatPost(item)
200
221
201
-
if dryRun {
202
-
log.Printf("[DRY-RUN] Would post:\n%s\n", postText)
222
+
if m.dryRun {
223
+
log.Printf("[@%s] [DRY-RUN] Would post:\n%s\n", m.account.Handle, postText)
203
224
postedCount++
204
225
} else {
205
226
// Post to Bluesky
206
227
postCtx, cancel := context.WithTimeout(ctx, 30*time.Second)
207
-
err := bskyClient.Post(postCtx, postText)
228
+
err := m.bskyClient.Post(postCtx, postText)
208
229
cancel()
209
230
210
231
if err != nil {
211
-
log.Printf("Failed to post item '%s': %v", item.Title, err)
232
+
log.Printf("[@%s] Failed to post item '%s': %v", m.account.Handle, item.Title, err)
212
233
continue
213
234
}
214
235
215
-
log.Printf("Successfully posted: %s", item.Title)
236
+
log.Printf("[@%s] Successfully posted: %s", m.account.Handle, item.Title)
216
237
postedCount++
217
238
}
218
239
219
240
// Mark as posted
220
-
if err := store.MarkPosted(item.GUID); err != nil {
221
-
log.Printf("Failed to mark item as posted: %v", err)
241
+
if err := m.store.MarkPosted(item.GUID); err != nil {
242
+
log.Printf("[@%s] Failed to mark item as posted: %v", m.account.Handle, err)
222
243
}
223
244
224
-
// Rate limiting - wait a bit between posts to avoid overwhelming Bluesky
225
-
if postedCount > 0 && !dryRun {
245
+
// Rate limiting ourselves to not get rate limited.
246
+
if postedCount > 0 && !m.dryRun {
226
247
time.Sleep(2 * time.Second)
227
248
}
228
249
}
229
250
230
251
if !hasSeenFeedBefore {
231
252
if newItemCount > 0 {
232
-
log.Printf("New feed detected: marked %d items as seen from %s (not posted)", newItemCount, feedURL)
253
+
log.Printf("[@%s] New feed detected: marked %d items as seen from %s (not posted)", m.account.Handle, newItemCount, feedURL)
233
254
}
234
255
} else {
235
256
if newItemCount == 0 {
236
-
log.Printf("No new items in feed %s", feedURL)
257
+
log.Printf("[@%s] No new items in feed %s", m.account.Handle, feedURL)
237
258
} else {
238
-
log.Printf("Processed %d new items from feed %s (%d posted)", newItemCount, feedURL, postedCount)
259
+
log.Printf("[@%s] Processed %d new items from feed %s (%d posted)", m.account.Handle, newItemCount, feedURL, postedCount)
239
260
}
240
261
}
241
262
···
299
320
300
321
return truncated
301
322
}
323
+
324
+
// sanitizeHandle removes special characters from handle for use in filenames
325
+
func sanitizeHandle(handle string) string {
326
+
// Replace dots and @ with underscores
327
+
sanitized := strings.ReplaceAll(handle, ".", "_")
328
+
sanitized = strings.ReplaceAll(sanitized, "@", "")
329
+
return sanitized
330
+
}
+73
-46
main_test.go
+73
-46
main_test.go
···
1
1
package main
2
2
3
3
import (
4
-
"reflect"
5
4
"testing"
6
5
)
7
6
8
-
func TestParseFeedURLs(t *testing.T) {
7
+
func TestSanitizeHandle(t *testing.T) {
9
8
tests := []struct {
10
9
name string
11
10
input string
12
-
expected []string
11
+
expected string
13
12
}{
14
13
{
15
-
name: "single feed",
16
-
input: "https://example.com/feed.xml",
17
-
expected: []string{"https://example.com/feed.xml"},
18
-
},
19
-
{
20
-
name: "multiple feeds",
21
-
input: "https://example.com/feed1.xml,https://example.com/feed2.xml",
22
-
expected: []string{"https://example.com/feed1.xml", "https://example.com/feed2.xml"},
14
+
name: "simple handle",
15
+
input: "user.bsky.social",
16
+
expected: "user_bsky_social",
23
17
},
24
18
{
25
-
name: "multiple feeds with spaces",
26
-
input: "https://example.com/feed1.xml, https://example.com/feed2.xml, https://example.com/feed3.xml",
27
-
expected: []string{"https://example.com/feed1.xml", "https://example.com/feed2.xml", "https://example.com/feed3.xml"},
19
+
name: "handle with multiple dots",
20
+
input: "my.user.name.bsky.social",
21
+
expected: "my_user_name_bsky_social",
28
22
},
29
23
{
30
-
name: "feeds with extra whitespace",
31
-
input: " https://example.com/feed1.xml , https://example.com/feed2.xml ",
32
-
expected: []string{"https://example.com/feed1.xml", "https://example.com/feed2.xml"},
24
+
name: "handle with @ prefix",
25
+
input: "@user.bsky.social",
26
+
expected: "user_bsky_social",
33
27
},
34
28
{
35
-
name: "empty string",
36
-
input: "",
37
-
expected: nil,
29
+
name: "handle with multiple @ symbols",
30
+
input: "@@user.bsky.social",
31
+
expected: "user_bsky_social",
38
32
},
39
33
{
40
-
name: "only commas and spaces",
41
-
input: " , , , ",
42
-
expected: []string{},
34
+
name: "handle without dots",
35
+
input: "user",
36
+
expected: "user",
43
37
},
44
38
{
45
-
name: "trailing comma",
46
-
input: "https://example.com/feed1.xml,https://example.com/feed2.xml,",
47
-
expected: []string{"https://example.com/feed1.xml", "https://example.com/feed2.xml"},
39
+
name: "handle with dots and @",
40
+
input: "@test.user.example.com",
41
+
expected: "test_user_example_com",
48
42
},
49
43
{
50
-
name: "leading comma",
51
-
input: ",https://example.com/feed1.xml,https://example.com/feed2.xml",
52
-
expected: []string{"https://example.com/feed1.xml", "https://example.com/feed2.xml"},
44
+
name: "empty string",
45
+
input: "",
46
+
expected: "",
53
47
},
54
48
{
55
-
name: "mixed RSS and Atom feeds",
56
-
input: "https://blog.com/rss,https://news.com/atom.xml,https://site.com/feed",
57
-
expected: []string{"https://blog.com/rss", "https://news.com/atom.xml", "https://site.com/feed"},
49
+
name: "only special characters",
50
+
input: "@.@.",
51
+
expected: "__",
58
52
},
59
53
}
60
54
61
55
for _, tt := range tests {
62
56
t.Run(tt.name, func(t *testing.T) {
63
-
result := parseFeedURLs(tt.input)
64
-
if !reflect.DeepEqual(result, tt.expected) {
65
-
t.Errorf("parseFeedURLs(%q) = %v, want %v", tt.input, result, tt.expected)
57
+
result := sanitizeHandle(tt.input)
58
+
if result != tt.expected {
59
+
t.Errorf("sanitizeHandle(%q) = %q, want %q", tt.input, result, tt.expected)
66
60
}
67
61
})
68
62
}
69
63
}
70
64
71
-
func TestParseFeedURLsCount(t *testing.T) {
65
+
func TestTruncateText(t *testing.T) {
72
66
tests := []struct {
73
-
name string
74
-
input string
75
-
expectedCount int
67
+
name string
68
+
text string
69
+
maxLen int
70
+
expected string
76
71
}{
77
-
{"one feed", "https://example.com/feed.xml", 1},
78
-
{"two feeds", "https://a.com/feed,https://b.com/feed", 2},
79
-
{"five feeds", "https://1.com/f,https://2.com/f,https://3.com/f,https://4.com/f,https://5.com/f", 5},
80
-
{"empty", "", 0},
72
+
{
73
+
name: "no truncation needed",
74
+
text: "short text",
75
+
maxLen: 20,
76
+
expected: "short text",
77
+
},
78
+
{
79
+
name: "truncate at word boundary",
80
+
text: "this is a long text that needs truncation",
81
+
maxLen: 20,
82
+
expected: "this is a long text",
83
+
},
84
+
{
85
+
name: "truncate without word boundary",
86
+
text: "verylongtextwithoutspaces",
87
+
maxLen: 10,
88
+
expected: "verylongte",
89
+
},
90
+
{
91
+
name: "exact length",
92
+
text: "exactly ten",
93
+
maxLen: 11,
94
+
expected: "exactly ten",
95
+
},
96
+
{
97
+
name: "empty string",
98
+
text: "",
99
+
maxLen: 10,
100
+
expected: "",
101
+
},
102
+
{
103
+
name: "truncate with space at end",
104
+
text: "text with space ",
105
+
maxLen: 10,
106
+
expected: "text with",
107
+
},
81
108
}
82
109
83
110
for _, tt := range tests {
84
111
t.Run(tt.name, func(t *testing.T) {
85
-
result := parseFeedURLs(tt.input)
86
-
if len(result) != tt.expectedCount {
87
-
t.Errorf("parseFeedURLs(%q) returned %d feeds, want %d", tt.input, len(result), tt.expectedCount)
112
+
result := truncateText(tt.text, tt.maxLen)
113
+
if result != tt.expected {
114
+
t.Errorf("truncateText(%q, %d) = %q, want %q", tt.text, tt.maxLen, result, tt.expected)
88
115
}
89
116
})
90
117
}
+88
-65
readme.md
+88
-65
readme.md
···
2
2
3
3
Tool to automatically post on Bluesky when new items are added to RSS/Atom feeds.
4
4
5
+
Supports:
6
+
7
+
- Multiple feeds posting to a single account
8
+
- Different feeds posting to different accounts
9
+
- Flexible configuration via YAML config file
10
+
5
11
## Installation
6
12
7
13
### Go Binary
···
15
21
```bash
16
22
docker run -d \
17
23
--name bksyrss \
24
+
-v $(pwd)/config.yaml:/config.yaml \
18
25
-v $(pwd)/data:/data \
19
26
-e BSKY_PASSWORD="your-app-password" \
20
27
bksyrss \
21
-
-feed "https://example.com/feed.xml" \
22
-
-handle "your-handle.bsky.social" \
23
-
-storage /data/posted_items.txt
28
+
-config /config.yaml
24
29
```
25
30
26
31
## Usage
27
32
28
-
### Basic Usage
33
+
### Basic Setup
34
+
35
+
bskyrss requires a YAML configuration file to run. Create a `config.yaml` file:
29
36
30
-
```bash
31
-
./bksyrss \
32
-
-feed "https://example.com/feed.xml" \
33
-
-handle "your-handle.bsky.social" \
34
-
-password "your-app-password"
37
+
```yaml
38
+
accounts:
39
+
- handle: "your-handle.bsky.social"
40
+
password: "${BSKY_PASSWORD}"
41
+
feeds:
42
+
- "https://example.com/feed.xml"
35
43
```
36
44
37
-
### Multiple Feeds
38
-
39
-
Monitor multiple feeds by separating URLs with commas:
45
+
Set your password as an environment variable:
40
46
41
47
```bash
42
-
./bksyrss \
43
-
-feed "https://blog1.com/feed.xml,https://blog2.com/rss,https://news.com/atom.xml" \
44
-
-handle "your-handle.bsky.social" \
45
-
-password "your-app-password"
48
+
export BSKY_PASSWORD="your-app-password"
46
49
```
47
50
48
-
or
51
+
Run bskyrss:
49
52
50
53
```bash
51
-
export BSKY_PASSWORD="your-app-password"
52
-
./bksyrss \
53
-
-feed "https://example.com/feed.xml" \
54
-
-handle "your-handle.bsky.social"
54
+
./bskyrss -config config.yaml
55
55
```
56
56
57
-
### Command Line Options
57
+
### Multiple Feeds to One Account
58
58
59
-
| Flag | Description | Required | Default |
60
-
| ----------- | ------------------------------------------------- | -------- | ------------------- |
61
-
| `-feed` | RSS/Atom feed URL(s) to monitor (comma-delimited) | Yes | - |
62
-
| `-handle` | Bluesky handle (e.g., user.bsky.social) | Yes | - |
63
-
| `-password` | Bluesky password or app password | Yes\* | - |
64
-
| `-pds` | Bluesky PDS server URL | No | https://bsky.social |
65
-
| `-interval` | Poll interval for checking RSS feed | No | 15m |
66
-
| `-storage` | File to store posted item GUIDs | No | posted_items.txt |
67
-
| `-dry-run` | Don't post, just show what would be posted | No | false |
59
+
```yaml
60
+
accounts:
61
+
- handle: "your-handle.bsky.social"
62
+
password: "${BSKY_PASSWORD}"
63
+
feeds:
64
+
- "https://example.com/feed.xml"
65
+
- "https://blog.example.com/rss"
66
+
- "https://news.example.com/atom.xml"
67
+
```
68
68
69
-
\*Can be provided via `BSKY_PASSWORD` environment variable instead
69
+
### Multiple Accounts with Different Feeds
70
70
71
-
### Examples
71
+
Map different feeds to different Bluesky accounts:
72
72
73
-
#### Monitor multiple feeds
73
+
```yaml
74
+
accounts:
75
+
- handle: "tech-news.bsky.social"
76
+
password: "${BSKY_PASSWORD_TECH}"
77
+
feeds:
78
+
- "https://hackernews.com/rss"
79
+
- "https://techcrunch.com/feed"
74
80
75
-
```bash
76
-
./bksyrss \
77
-
-feed "https://blog.com/rss,https://news.com/atom.xml,https://podcast.com/feed" \
78
-
-handle "your-handle.bsky.social"
79
-
```
81
+
- handle: "personal.bsky.social"
82
+
password: "${BSKY_PASSWORD_PERSONAL}"
83
+
feeds:
84
+
- "https://personal-blog.com/feed.xml"
80
85
81
-
#### Check feeds every 5 minutes
82
-
83
-
```bash
84
-
./bksyrss \
85
-
-feed "https://example.com/feed.xml" \
86
-
-handle "your-handle.bsky.social" \
87
-
-interval 5m
86
+
interval: "15m"
88
87
```
89
88
90
-
#### Test without posting (dry-run mode)
89
+
Set environment variables:
91
90
92
91
```bash
93
-
./bksyrss \
94
-
-feed "https://example.com/feed.xml" \
95
-
-handle "your-handle.bsky.social" \
96
-
-dry-run
92
+
export BSKY_PASSWORD_TECH="tech-app-password"
93
+
export BSKY_PASSWORD_PERSONAL="personal-app-password"
94
+
./bskyrss -config config.yaml
97
95
```
98
96
99
-
#### Use custom storage file
100
-
101
-
```bash
102
-
./bksyrss \
103
-
-feed "https://example.com/feed.xml" \
104
-
-handle "your-handle.bsky.social" \
105
-
-storage /var/lib/bksyrss/posted.txt
106
-
```
97
+
See [`config.example.yaml`](config.example.yaml) for a complete example with all options.
107
98
108
99
## Bluesky Authentication
109
100
···
113
104
114
105
1. Go to Bluesky Settings → App Passwords
115
106
2. Create a new App Password
116
-
3. Use this password with the `-password` flag or `BSKY_PASSWORD` environment variable
107
+
3. Use this password in your config file (via environment variable)
108
+
109
+
### Environment Variables
110
+
111
+
Passwords should be provided via environment variables for security:
112
+
113
+
```yaml
114
+
accounts:
115
+
- handle: "user.bsky.social"
116
+
password: "${BSKY_PASSWORD}" # References $BSKY_PASSWORD env var
117
+
```
118
+
119
+
Supported formats:
120
+
121
+
- `${VAR_NAME}` - Standard format
122
+
- `$VAR_NAME` - Short format
117
123
118
124
### Self-hosted PDS
119
125
120
126
If you're using a self-hosted Personal Data Server:
121
127
122
-
```bash
123
-
./bksyrss \
124
-
-feed "https://example.com/feed.xml" \
125
-
-handle "your-handle.your-pds.com" \
126
-
-pds "https://your-pds.com"
128
+
```yaml
129
+
accounts:
130
+
- handle: "your-handle.your-pds.com"
131
+
password: "${BSKY_PASSWORD}"
132
+
pds: "https://your-pds.com"
133
+
feeds:
134
+
- "https://example.com/feed.xml"
127
135
```
128
136
129
137
## Post Format
···
145
153
The tool maintains a simple text file (default: `posted_items.txt`) containing the GUIDs of all posted items. This ensures that items are not posted multiple times, even if the tool is restarted.
146
154
147
155
The storage file contains one GUID per line and is safe to manually edit if needed.
156
+
157
+
### Multiple Accounts
158
+
159
+
When using multiple accounts, separate storage files are automatically created for each account (e.g., `posted_items_user1_bsky_social.txt`, `posted_items_user2_bsky_social.txt`). This ensures that each account tracks its own posted items independently.
160
+
161
+
You can also specify custom storage files per account in the configuration file:
162
+
163
+
```yaml
164
+
accounts:
165
+
- handle: "user1.bsky.social"
166
+
storage: "custom_storage_user1.txt"
167
+
password: "${BSKY_PASSWORD_1}"
168
+
feeds:
169
+
- "https://feed1.com/rss"
170
+
```
148
171
149
172
### First Run Behavior
150
173