···

       
1
       
1
       
-
       
#!/usr/bin/env bash

     

       
2
       
2
       
-
       


     

       
3
       
3
       
-
       
# Dynamic Profile Picture Updater

     

       
4
       
4
       
-
       
# Automatically updates your profile pictures across platforms based on time and weather

     

       
5
       
5
       
-
       
# Usage: ./auto_pfp.sh [options]

     

       
6
       
6
       
-
       


     

       
7
       
7
       
-
       
set -euo pipefail

     

       
8
       
8
       
-
       


     

       
9
       
9
       
-
       
# Default configuration

     

       
10
       
10
       
-
       
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

     

       
11
       
11
       
-
       
CONFIG_FILE="${SCRIPT_DIR}/config.json"

     

       
12
       
12
       
-
       
IMAGES_DIR="${SCRIPT_DIR}/rendered_timelines"

     

       
13
       
13
       
-
       
LOG_FILE="${SCRIPT_DIR}/auto_pfp.log"

     

       
14
       
14
       
-
       
SESSION_FILE="${SCRIPT_DIR}/.bluesky_session"

     

       
15
       
15
       
-
       
DEFAULT_TIMELINE="sunny"

     

       
16
       
16
       
-
       


     

       
17
       
17
       
-
       
# Colors for output

     

       
18
       
18
       
-
       
RED='\033[0;31m'

     

       
19
       
19
       
-
       
GREEN='\033[0;32m'

     

       
20
       
20
       
-
       
YELLOW='\033[1;33m'

     

       
21
       
21
       
-
       
BLUE='\033[0;34m'

     

       
22
       
22
       
-
       
NC='\033[0m' # No Color

     

       
23
       
23
       
-
       


     

       
24
       
24
       
-
       
# Logging function

     

       
25
       
25
       
-
       
log() {

     

       
26
       
26
       
-
       
    local level="$1"

     

       
27
       
27
       
-
       
    shift

     

       
28
       
28
       
-
       
    local message="$*"

     

       
29
       
29
       
-
       
    local timestamp=$(date '+%Y-%m-%d %H:%M:%S')

     

       
30
       
30
       
-
       
    echo -e "${timestamp} - ${level} - ${message}" | tee -a "$LOG_FILE" >&2

     

       
31
       
31
       
-
       
}

     

       
32
       
32
       
-
       


     

       
33
       
33
       
-
       
log_info() { log "${BLUE}[INFO]${NC}" "$@"; }

     

       
34
       
34
       
-
       
log_success() { log "${GREEN}[SUCCESS]${NC}" "$@"; }

     

       
35
       
35
       
-
       
log_warning() { log "${YELLOW}[WARNING]${NC}" "$@"; }

     

       
36
       
36
       
-
       
log_error() { log "${RED}[ERROR]${NC}" "$@"; }

     

       
37
       
37
       
-
       


     

       
38
       
38
       
-
       
# Check dependencies

     

       
39
       
39
       
-
       
check_dependencies() {

     

       
40
       
40
       
-
       
    local missing_deps=()

     

       
41
       
41
       
-
       


     

       
42
       
42
       
-
       
    if ! command -v curl &> /dev/null; then

     

       
43
       
43
       
-
       
        missing_deps+=("curl")

     

       
44
       
44
       
-
       
    fi

     

       
45
       
45
       
-
       


     

       
46
       
46
       
-
       
    if ! command -v jq &> /dev/null; then

     

       
47
       
47
       
-
       
        missing_deps+=("jq")

     

       
48
       
48
       
-
       
    fi

     

       
49
       
49
       
-
       
    

     

       
50
       
50
       
-
       
    if ! command -v sha256sum &> /dev/null; then

     

       
51
       
51
       
-
       
        missing_deps+=("sha256sum")

     

       
52
       
52
       
-
       
    fi

     

       
53
       
53
       
-
       


     

       
54
       
54
       
-
       
    if [ ${#missing_deps[@]} -ne 0 ]; then

     

       
55
       
55
       
-
       
        log_error "Missing required dependencies:"

     

       
56
       
56
       
-
       
        for dep in "${missing_deps[@]}"; do

     

       
57
       
57
       
-
       
            echo "  - $dep"

     

       
58
       
58
       
-
       
        done

     

       
59
       
59
       
-
       
        exit 1

     

       
60
       
60
       
-
       
    fi

     

       
61
       
61
       
-
       
}

     

       
62
       
62
       
-
       


     

       
63
       
63
       
-
       
# Create default config file

     

       
64
       
64
       
-
       
create_default_config() {

     

       
65
       
65
       
-
       
    cat > "$CONFIG_FILE" << 'EOF'

     

       
66
       
66
       
-
       
{

     

       
67
       
67
       
-
       
  "platforms": {

     

       
68
       
68
       
-
       
    "bluesky": {

     

       
69
       
69
       
-
       
      "enabled": true,

     

       
70
       
70
       
-
       
      "handle": "your-handle.bsky.social",

     

       
71
       
71
       
-
       
      "password": "your-app-password"

     

       
72
       
72
       
-
       
    },

     

       
73
       
73
       
-
       
    "slack": {

     

       
74
       
74
       
-
       
      "enabled": false,

     

       
75
       
75
       
-
       
      "user_token": ""

     

       
76
       
76
       
-
       
    }

     

       
77
       
77
       
-
       
  },

     

       
78
       
78
       
-
       
  "weather": {

     

       
79
       
79
       
-
       
    "enabled": false,

     

       
80
       
80
       
-
       
    "api_key": "",

     

       
81
       
81
       
-
       
    "location": "auto",

     

       
82
       
82
       
-
       
    "timeline_mapping": {

     

       
83
       
83
       
-
       
      "clear": "sunny",

     

       
84
       
84
       
-
       
      "clouds": "cloudy",

     

       
85
       
85
       
-
       
      "rain": "rainy",

     

       
86
       
86
       
-
       
      "drizzle": "rainy",

     

       
87
       
87
       
-
       
      "thunderstorm": "stormy",

     

       
88
       
88
       
-
       
      "snow": "snowy",

     

       
89
       
89
       
-
       
      "mist": "cloudy",

     

       
90
       
90
       
-
       
      "fog": "cloudy"

     

       
91
       
91
       
-
       
    }

     

       
92
       
92
       
-
       
  },

     

       
93
       
93
       
-
       
  "settings": {

     

       
94
       
94
       
-
       
    "default_timeline": "sunny",

     

       
95
       
95
       
-
       
    "images_dir": "./rendered_timelines"

     

       
96
       
96
       
-
       
  }

     

       
97
       
97
       
-
       
}

     

       
98
       
98
       
-
       
EOF

     

       
99
       
99
       
-
       
    log_info "Created default config file: $CONFIG_FILE"

     

       
100
       
100
       
-
       
    log_warning "Please edit the config file with your platform credentials"

     

       
101
       
101
       
-
       
}

     

       
102
       
102
       
-
       


     

       
103
       
103
       
-
       
# Load configuration

     

       
104
       
104
       
-
       
load_config() {

     

       
105
       
105
       
-
       
    if [ ! -f "$CONFIG_FILE" ]; then

     

       
106
       
106
       
-
       
        log_warning "Config file not found, creating default..."

     

       
107
       
107
       
-
       
        create_default_config

     

       
108
       
108
       
-
       
        exit 1

     

       
109
       
109
       
-
       
    fi

     

       
110
       
110
       
-
       


     

       
111
       
111
       
-
       
    # Read platform settings

     

       
112
       
112
       
-
       
    BLUESKY_ENABLED=$(jq -r '.platforms.bluesky.enabled' "$CONFIG_FILE")

     

       
113
       
113
       
-
       
    BLUESKY_HANDLE=$(jq -r '.platforms.bluesky.handle' "$CONFIG_FILE")

     

       
114
       
114
       
-
       
    BLUESKY_PASSWORD=$(jq -r '.platforms.bluesky.password' "$CONFIG_FILE")

     

       
115
       
115
       
-
       
    SLACK_ENABLED=$(jq -r '.platforms.slack.enabled' "$CONFIG_FILE")

     

       
116
       
116
       
-
       
    SLACK_USER_TOKEN=$(jq -r '.platforms.slack.user_token' "$CONFIG_FILE")

     

       
117
       
117
       
-
       


     

       
118
       
118
       
-
       
    # Read weather settings

     

       
119
       
119
       
-
       
    WEATHER_ENABLED=$(jq -r '.weather.enabled' "$CONFIG_FILE")

     

       
120
       
120
       
-
       
    WEATHER_API_KEY=$(jq -r '.weather.api_key' "$CONFIG_FILE")

     

       
121
       
121
       
-
       
    WEATHER_LOCATION=$(jq -r '.weather.location' "$CONFIG_FILE")

     

       
122
       
122
       
-
       


     

       
123
       
123
       
-
       
    # Read general settings

     

       
124
       
124
       
-
       
    DEFAULT_TIMELINE=$(jq -r '.settings.default_timeline' "$CONFIG_FILE")

     

       
125
       
125
       
-
       
    IMAGES_DIR=$(jq -r '.settings.images_dir' "$CONFIG_FILE")

     

       
126
       
126
       
-
       


     

       
127
       
127
       
-
       
    # Validate at least one platform is enabled and configured

     

       
128
       
128
       
-
       
    local enabled_platforms=()

     

       
129
       
129
       
-
       


     

       
130
       
130
       
-
       
    # Check Bluesky

     

       
131
       
131
       
-
       
    if [ "$BLUESKY_ENABLED" = "true" ]; then

     

       
132
       
132
       
-
       
        if [ "$BLUESKY_HANDLE" = "your-handle.bsky.social" ] || [ "$BLUESKY_HANDLE" = "null" ] || [ -z "$BLUESKY_HANDLE" ]; then

     

       
133
       
133
       
-
       
            log_warning "Bluesky enabled but handle not configured - will be skipped"

     

       
134
       
134
       
-
       
            BLUESKY_ENABLED="false"

     

       
135
       
135
       
-
       
        elif [ "$BLUESKY_PASSWORD" = "your-app-password" ] || [ "$BLUESKY_PASSWORD" = "null" ] || [ -z "$BLUESKY_PASSWORD" ]; then

     

       
136
       
136
       
-
       
            log_warning "Bluesky enabled but password not configured - will be skipped"

     

       
137
       
137
       
-
       
            BLUESKY_ENABLED="false"

     

       
138
       
138
       
-
       
        else

     

       
139
       
139
       
-
       
            enabled_platforms+=("Bluesky")

     

       
140
       
140
       
-
       
        fi

     

       
141
       
141
       
-
       
    fi

     

       
142
       
142
       
-
       


     

       
143
       
143
       
-
       
    # Check Slack

     

       
144
       
144
       
-
       
    if [ "$SLACK_ENABLED" = "true" ]; then

     

       
145
       
145
       
-
       
        if [ -z "$SLACK_USER_TOKEN" ] || [ "$SLACK_USER_TOKEN" = "null" ]; then

     

       
146
       
146
       
-
       
            log_warning "Slack enabled but no user token provided - will be skipped"

     

       
147
       
147
       
-
       
            SLACK_ENABLED="false"

     

       
148
       
148
       
-
       
        else

     

       
149
       
149
       
-
       
            enabled_platforms+=("Slack")

     

       
150
       
150
       
-
       
        fi

     

       
151
       
151
       
-
       
    fi

     

       
152
       
152
       
-
       


     

       
153
       
153
       
-
       
    # Ensure at least one platform is enabled

     

       
154
       
154
       
-
       
    if [ ${#enabled_platforms[@]} -eq 0 ]; then

     

       
155
       
155
       
-
       
        log_error "No platforms are properly configured. Please check your config file."

     

       
156
       
156
       
-
       
        exit 1

     

       
157
       
157
       
-
       
    fi

     

       
158
       
158
       
-
       


     

       
159
       
159
       
-
       
    # Convert relative paths to absolute

     

       
160
       
160
       
-
       
    if [[ ! "$IMAGES_DIR" =~ ^/ ]]; then

     

       
161
       
161
       
-
       
        IMAGES_DIR="${SCRIPT_DIR}/${IMAGES_DIR}"

     

       
162
       
162
       
-
       
    fi

     

       
163
       
163
       
-
       


     

       
164
       
164
       
-
       
    log_info "Loaded configuration with enabled platforms: ${enabled_platforms[*]}"

     

       
165
       
165
       
-
       
}

     

       
166
       
166
       
-
       


     

       
167
       
167
       
-
       
# Authenticate with Bluesky

     

       
168
       
168
       
-
       
authenticate_bluesky() {

     

       
169
       
169
       
-
       
    if [ "$BLUESKY_ENABLED" != "true" ]; then

     

       
170
       
170
       
-
       
        return 1

     

       
171
       
171
       
-
       
    fi

     

       
172
       
172
       
-
       


     

       
173
       
173
       
-
       
    log_info "Authenticating with Bluesky..."

     

       
174
       
174
       
-
       


     

       
175
       
175
       
-
       
    local auth_response

     

       
176
       
176
       
-
       
    auth_response=$(curl -s -X POST \

     

       
177
       
177
       
-
       
        "https://bsky.social/xrpc/com.atproto.server.createSession" \

     

       
178
       
178
       
-
       
        -H "Content-Type: application/json" \

     

       
179
       
179
       
-
       
        -d "{\"identifier\":\"$BLUESKY_HANDLE\",\"password\":\"$BLUESKY_PASSWORD\"}")

     

       
180
       
180
       
-
       


     

       
181
       
181
       
-
       
    if echo "$auth_response" | jq -e '.accessJwt' > /dev/null 2>&1; then

     

       
182
       
182
       
-
       
        echo "$auth_response" > "$SESSION_FILE"

     

       
183
       
183
       
-
       
        log_success "Successfully authenticated with Bluesky"

     

       
184
       
184
       
-
       
        return 0

     

       
185
       
185
       
-
       
    else

     

       
186
       
186
       
-
       
        log_error "Bluesky authentication failed: $(echo "$auth_response" | jq -r '.message // "Unknown error"')"

     

       
187
       
187
       
-
       
        return 1

     

       
188
       
188
       
-
       
    fi

     

       
189
       
189
       
-
       
}

     

       
190
       
190
       
-
       


     

       
191
       
191
       
-
       
# Get session token

     

       
192
       
192
       
-
       
get_session_token() {

     

       
193
       
193
       
-
       
    if [ ! -f "$SESSION_FILE" ]; then

     

       
194
       
194
       
-
       
        return 1

     

       
195
       
195
       
-
       
    fi

     

       
196
       
196
       
-
       


     

       
197
       
197
       
-
       
    # Check if session is still valid (sessions typically last 24 hours)

     

       
198
       
198
       
-
       
    local session_age=$(($(date +%s) - $(stat -c %Y "$SESSION_FILE" 2>/dev/null || echo 0)))

     

       
199
       
199
       
-
       
    if [ $session_age -gt 86400 ]; then  # 24 hours

     

       
200
       
200
       
-
       
        log_info "Session expired, re-authenticating..."

     

       
201
       
201
       
-
       
        rm -f "$SESSION_FILE"

     

       
202
       
202
       
-
       
        return 1

     

       
203
       
203
       
-
       
    fi

     

       
204
       
204
       
-
       


     

       
205
       
205
       
-
       
    jq -r '.accessJwt' "$SESSION_FILE" 2>/dev/null || return 1

     

       
206
       
206
       
-
       
}

     

       
207
       
207
       
-
       


     

       
208
       
208
       
-
       
# Calculate SHA256 hash of image file

     

       
209
       
209
       
-
       
calculate_image_hash() {

     

       
210
       
210
       
-
       
    local image_path="$1"

     

       
211
       
211
       
-
       
    if [ ! -f "$image_path" ]; then

     

       
212
       
212
       
-
       
        return 1

     

       
213
       
213
       
-
       
    fi

     

       
214
       
214
       
-
       
    sha256sum "$image_path" | cut -d' ' -f1

     

       
215
       
215
       
-
       
}

     

       
216
       
216
       
-
       


     

       
217
       
217
       
-
       
# Get blob reference from ATProto record

     

       
218
       
218
       
-
       
get_cached_blob() {

     

       
219
       
219
       
-
       
    local weather_type="$1"

     

       
220
       
220
       
-
       
    local hour="$2"

     

       
221
       
221
       
-
       
    local image_hash="$3"

     

       
222
       
222
       
-
       
    local token="$4"

     

       
223
       
223
       
-
       
    local did

     

       
224
       
224
       
-
       
    

     

       
225
       
225
       
-
       
    did=$(jq -r '.did' "$SESSION_FILE")

     

       
226
       
226
       
-
       
    local rkey="${weather_type}_hour_${hour}"

     

       
227
       
227
       
-
       
    

     

       
228
       
228
       
-
       
    # Validate DID

     

       
229
       
229
       
-
       
    if [ -z "$did" ] || [ "$did" = "null" ]; then

     

       
230
       
230
       
-
       
        log_error "Could not get DID from session file"

     

       
231
       
231
       
-
       
        return 1

     

       
232
       
232
       
-
       
    fi

     

       
233
       
233
       
-
       
    

     

       
234
       
234
       
-
       
    log_info "Checking for cached blob: $weather_type hour $hour (DID: ${did:0:20}...)"

     

       
235
       
235
       
-
       
    

     

       
236
       
236
       
-
       
    # Try to get existing record

     

       
237
       
237
       
-
       
    local record_response

     

       
238
       
238
       
-
       
    record_response=$(curl -s \

     

       
239
       
239
       
-
       
        "https://bsky.social/xrpc/com.atproto.repo.getRecord?repo=$did&collection=pfp.updates.${weather_type}&rkey=$rkey" \

     

       
240
       
240
       
-
       
        -H "Authorization: Bearer $token")

     

       
241
       
241
       
-
       
    

     

       
242
       
242
       
-
       
    if echo "$record_response" | jq -e '.value' > /dev/null 2>&1; then

     

       
243
       
243
       
-
       
        local stored_hash=$(echo "$record_response" | jq -r '.value.imageHash // empty')

     

       
244
       
244
       
-
       
        local stored_blob=$(echo "$record_response" | jq -c '.value.blobRef // empty')

     

       
245
       
245
       
-
       
        

     

       
246
       
246
       
-
       
        if [ "$stored_hash" = "$image_hash" ] && [ -n "$stored_blob" ] && [ "$stored_blob" != "empty" ]; then

     

       
247
       
247
       
-
       
            log_success "Found cached blob with matching hash"

     

       
248
       
248
       
-
       
            echo "$stored_blob"

     

       
249
       
249
       
-
       
            return 0

     

       
250
       
250
       
-
       
        else

     

       
251
       
251
       
-
       
            log_info "Cached blob found but hash mismatch or missing blob reference"

     

       
252
       
252
       
-
       
            return 1

     

       
253
       
253
       
-
       
        fi

     

       
254
       
254
       
-
       
    else

     

       
255
       
255
       
-
       
        log_info "No cached blob record found"

     

       
256
       
256
       
-
       
        return 1

     

       
257
       
257
       
-
       
    fi

     

       
258
       
258
       
-
       
}

     

       
259
       
259
       
-
       


     

       
260
       
260
       
-
       
# Store blob reference in ATProto record

     

       
261
       
261
       
-
       
store_blob_reference() {

     

       
262
       
262
       
-
       
    local weather_type="$1"

     

       
263
       
263
       
-
       
    local hour="$2"

     

       
264
       
264
       
-
       
    local image_hash="$3"

     

       
265
       
265
       
-
       
    local blob_ref="$4"

     

       
266
       
266
       
-
       
    local token="$5"

     

       
267
       
267
       
-
       
    local did

     

       
268
       
268
       
-
       
    

     

       
269
       
269
       
-
       
    did=$(jq -r '.did' "$SESSION_FILE")

     

       
270
       
270
       
-
       
    local rkey="${weather_type}_hour_${hour}"

     

       
271
       
271
       
-
       
    

     

       
272
       
272
       
-
       
    # Validate DID

     

       
273
       
273
       
-
       
    if [ -z "$did" ] || [ "$did" = "null" ]; then

     

       
274
       
274
       
-
       
        log_error "Could not get DID from session file"

     

       
275
       
275
       
-
       
        return 1

     

       
276
       
276
       
-
       
    fi

     

       
277
       
277
       
-
       
    

     

       
278
       
278
       
-
       
    log_info "Storing blob reference for $weather_type hour $hour (DID: ${did:0:20}...)"

     

       
279
       
279
       
-
       
    

     

       
280
       
280
       
-
       
    # Create record data

     

       
281
       
281
       
-
       
    local record_data

     

       
282
       
282
       
-
       
    record_data=$(jq -n \

     

       
283
       
283
       
-
       
        --arg type_field "pfp.updates.${weather_type}" \

     

       
284
       
284
       
-
       
        --arg hash "$image_hash" \

     

       
285
       
285
       
-
       
        --argjson blob "$blob_ref" \

     

       
286
       
286
       
-
       
        --arg weather "$weather_type" \

     

       
287
       
287
       
-
       
        --arg hour "$hour" \

     

       
288
       
288
       
-
       
        --arg timestamp "$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)" \

     

       
289
       
289
       
-
       
        '{

     

       
290
       
290
       
-
       
            "$type": $type_field,

     

       
291
       
291
       
-
       
            "timeline": $weather,

     

       
292
       
292
       
-
       
            "hour": $hour,

     

       
293
       
293
       
-
       
            "imageHash": $hash,

     

       
294
       
294
       
-
       
            "blobRef": $blob,

     

       
295
       
295
       
-
       
            "createdAt": $timestamp

     

       
296
       
296
       
-
       
        }')

     

       
297
       
297
       
-
       
    

     

       
298
       
298
       
-
       
    log_info "Record data: $record_data"

     

       
299
       
299
       
-
       
    

     

       
300
       
300
       
-
       
    # Create the request payload using direct JSON construction

     

       
301
       
301
       
-
       
    local request_payload

     

       
302
       
302
       
-
       
    request_payload=$(jq -n \

     

       
303
       
303
       
-
       
        --arg repo "$did" \

     

       
304
       
304
       
-
       
        --arg collection "pfp.updates.${weather_type}" \

     

       
305
       
305
       
-
       
        --arg rkey "$rkey" \

     

       
306
       
306
       
-
       
        --argjson record "$record_data" \

     

       
307
       
307
       
-
       
        '{

     

       
308
       
308
       
-
       
            "repo": $repo,

     

       
309
       
309
       
-
       
            "collection": $collection,

     

       
310
       
310
       
-
       
            "rkey": $rkey,

     

       
311
       
311
       
-
       
            "record": $record

     

       
312
       
312
       
-
       
        }')

     

       
313
       
313
       
-
       
    

     

       
314
       
314
       
-
       
    log_info "Request payload preview: $(echo "$request_payload" | jq -c '.' | head -c 200)..."

     

       
315
       
315
       
-
       
    

     

       
316
       
316
       
-
       
    # Validate the payload has required fields

     

       
317
       
317
       
-
       
    if ! echo "$request_payload" | jq -e '.repo' > /dev/null 2>&1; then

     

       
318
       
318
       
-
       
        log_error "Request payload missing 'repo' field"

     

       
319
       
319
       
-
       
        log_error "DID value: '$did'"

     

       
320
       
320
       
-
       
        log_error "Full payload: $request_payload"

     

       
321
       
321
       
-
       
        return 1

     

       
322
       
322
       
-
       
    fi

     

       
323
       
323
       
-
       
    

     

       
324
       
324
       
-
       
    # In dry run mode, don't actually store

     

       
325
       
325
       
-
       
    if [ "${DRY_RUN:-false}" = "true" ]; then

     

       
326
       
326
       
-
       
        log_info "DRY RUN MODE - Would store blob reference"

     

       
327
       
327
       
-
       
        return 0

     

       
328
       
328
       
-
       
    fi

     

       
329
       
329
       
-
       
    

     

       
330
       
330
       
-
       
    # Store the record

     

       
331
       
331
       
-
       
    local store_response

     

       
332
       
332
       
-
       
    store_response=$(curl -s -X POST \

     

       
333
       
333
       
-
       
        "https://bsky.social/xrpc/com.atproto.repo.putRecord" \

     

       
334
       
334
       
-
       
        -H "Authorization: Bearer $token" \

     

       
335
       
335
       
-
       
        -H "Content-Type: application/json" \

     

       
336
       
336
       
-
       
        -d "$request_payload")

     

       
337
       
337
       
-
       
    

     

       
338
       
338
       
-
       
    if echo "$store_response" | jq -e '.uri' > /dev/null 2>&1; then

     

       
339
       
339
       
-
       
        log_success "Successfully stored blob reference"

     

       
340
       
340
       
-
       
        return 0

     

       
341
       
341
       
-
       
    else

     

       
342
       
342
       
-
       
        log_error "Failed to store blob reference: $(echo "$store_response" | jq -r '.message // "Unknown error"')"

     

       
343
       
343
       
-
       
        log_error "Full response: $store_response"

     

       
344
       
344
       
-
       
        return 1

     

       
345
       
345
       
-
       
    fi

     

       
346
       
346
       
-
       
}

     

       
347
       
347
       
-
       


     

       
348
       
348
       
-
       
# Upload image as blob

     

       
349
       
349
       
-
       
upload_blob() {

     

       
350
       
350
       
-
       
    local image_path="$1"

     

       
351
       
351
       
-
       
    local token="$2"

     

       
352
       
352
       
-
       


     

       
353
       
353
       
-
       
    if [ ! -f "$image_path" ]; then

     

       
354
       
354
       
-
       
        log_error "Image file not found: $image_path"

     

       
355
       
355
       
-
       
        return 1

     

       
356
       
356
       
-
       
    fi

     

       
357
       
357
       
-
       


     

       
358
       
358
       
-
       
    # Check image file size (should be reasonable)

     

       
359
       
359
       
-
       
    local file_size=$(stat -c%s "$image_path" 2>/dev/null || echo 0)

     

       
360
       
360
       
-
       
    if [ "$file_size" -lt 1000 ]; then

     

       
361
       
361
       
-
       
        log_error "Image file too small ($file_size bytes): $image_path"

     

       
362
       
362
       
-
       
        return 1

     

       
363
       
363
       
-
       
    fi

     

       
364
       
364
       
-
       


     

       
365
       
365
       
-
       
    if [ "$file_size" -gt 10000000 ]; then  # 10MB limit

     

       
366
       
366
       
-
       
        log_error "Image file too large ($file_size bytes): $image_path"

     

       
367
       
367
       
-
       
        return 1

     

       
368
       
368
       
-
       
    fi

     

       
369
       
369
       
-
       


     

       
370
       
370
       
-
       
    log_info "Uploading image: $(basename "$image_path") ($(numfmt --to=iec "$file_size"))"

     

       
371
       
371
       
-
       


     

       
372
       
372
       
-
       
    local upload_response

     

       
373
       
373
       
-
       
    upload_response=$(curl -s -X POST \

     

       
374
       
374
       
-
       
        "https://bsky.social/xrpc/com.atproto.repo.uploadBlob" \

     

       
375
       
375
       
-
       
        -H "Authorization: Bearer $token" \

     

       
376
       
376
       
-
       
        -H "Content-Type: image/jpeg" \

     

       
377
       
377
       
-
       
        --data-binary "@$image_path")

     

       
378
       
378
       
-
       


     

       
379
       
379
       
-
       
    if echo "$upload_response" | jq -e '.blob' > /dev/null 2>&1; then

     

       
380
       
380
       
-
       
        local blob_result

     

       
381
       
381
       
-
       
        blob_result=$(echo "$upload_response" | jq -c '.blob')

     

       
382
       
382
       
-
       
        log_success "Successfully uploaded image"

     

       
383
       
383
       
-
       
        log_info "Blob data: $blob_result"

     

       
384
       
384
       
-
       
        echo "$blob_result"

     

       
385
       
385
       
-
       
        return 0

     

       
386
       
386
       
-
       
    else

     

       
387
       
387
       
-
       
        local error_type=$(echo "$upload_response" | jq -r '.error // "Unknown"')

     

       
388
       
388
       
-
       
        local error_msg=$(echo "$upload_response" | jq -r '.message // "Unknown error"')

     

       
389
       
389
       
-
       


     

       
390
       
390
       
-
       
        if [ "$error_type" = "ExpiredToken" ] || echo "$error_msg" | grep -qi "expired"; then

     

       
391
       
391
       
-
       
            log_error "Token has expired - session needs refresh"

     

       
392
       
392
       
-
       
            # Remove the expired session file so it will be regenerated

     

       
393
       
393
       
-
       
            rm -f "$SESSION_FILE"

     

       
394
       
394
       
-
       
            return 2  # Special return code for expired token

     

       
395
       
395
       
-
       
        else

     

       
396
       
396
       
-
       
            log_error "Failed to upload image: $error_msg"

     

       
397
       
397
       
-
       
            log_error "Full response: $upload_response"

     

       
398
       
398
       
-
       
            return 1

     

       
399
       
399
       
-
       
        fi

     

       
400
       
400
       
-
       
    fi

     

       
401
       
401
       
-
       
}

     

       
402
       
402
       
-
       


     

       
403
       
403
       
-
       
# Get or upload blob with caching

     

       
404
       
404
       
-
       
get_or_upload_blob() {

     

       
405
       
405
       
-
       
    local image_path="$1"

     

       
406
       
406
       
-
       
    local weather_type="$2"

     

       
407
       
407
       
-
       
    local hour="$3"

     

       
408
       
408
       
-
       
    local token="$4"

     

       
409
       
409
       
-
       
    

     

       
410
       
410
       
-
       
    if [ ! -f "$image_path" ]; then

     

       
411
       
411
       
-
       
        log_error "Image file not found: $image_path"

     

       
412
       
412
       
-
       
        return 1

     

       
413
       
413
       
-
       
    fi

     

       
414
       
414
       
-
       
    

     

       
415
       
415
       
-
       
    # Calculate image hash

     

       
416
       
416
       
-
       
    local image_hash

     

       
417
       
417
       
-
       
    image_hash=$(calculate_image_hash "$image_path")

     

       
418
       
418
       
-
       
    if [ -z "$image_hash" ]; then

     

       
419
       
419
       
-
       
        log_error "Failed to calculate image hash"

     

       
420
       
420
       
-
       
        return 1

     

       
421
       
421
       
-
       
    fi

     

       
422
       
422
       
-
       
    

     

       
423
       
423
       
-
       
    log_info "Image hash: $image_hash"

     

       
424
       
424
       
-
       
    

     

       
425
       
425
       
-
       
    # Try to get cached blob

     

       
426
       
426
       
-
       
    local cached_blob

     

       
427
       
427
       
-
       
    if cached_blob=$(get_cached_blob "$weather_type" "$hour" "$image_hash" "$token"); then

     

       
428
       
428
       
-
       
        log_success "Using cached blob reference"

     

       
429
       
429
       
-
       
        echo "$cached_blob"

     

       
430
       
430
       
-
       
        return 0

     

       
431
       
431
       
-
       
    fi

     

       
432
       
432
       
-
       
    

     

       
433
       
433
       
-
       
    # No cache hit, upload the blob

     

       
434
       
434
       
-
       
    log_info "No valid cache found, uploading new blob..."

     

       
435
       
435
       
-
       
    local new_blob

     

       
436
       
436
       
-
       
    new_blob=$(upload_blob "$image_path" "$token")

     

       
437
       
437
       
-
       
    

     

       
438
       
438
       
-
       
    if [ -n "$new_blob" ]; then

     

       
439
       
439
       
-
       
        # Store the blob reference for future use

     

       
440
       
440
       
-
       
        if store_blob_reference "$weather_type" "$hour" "$image_hash" "$new_blob" "$token"; then

     

       
441
       
441
       
-
       
            log_success "Blob uploaded and cached successfully"

     

       
442
       
442
       
-
       
        else

     

       
443
       
443
       
-
       
            log_warning "Blob uploaded but failed to cache reference"

     

       
444
       
444
       
-
       
        fi

     

       
445
       
445
       
-
       
        echo "$new_blob"

     

       
446
       
446
       
-
       
        return 0

     

       
447
       
447
       
-
       
    else

     

       
448
       
448
       
-
       
        log_error "Failed to upload blob"

     

       
449
       
449
       
-
       
        return 1

     

       
450
       
450
       
-
       
    fi

     

       
451
       
451
       
-
       
}

     

       
452
       
452
       
-
       


     

       
453
       
453
       
-
       
# List all cached blobs

     

       
454
       
454
       
-
       
list_cached_blobs() {

     

       
455
       
455
       
-
       
    local token="$1"

     

       
456
       
456
       
-
       
    local did

     

       
457
       
457
       
-
       
    

     

       
458
       
458
       
-
       
    did=$(jq -r '.did' "$SESSION_FILE")

     

       
459
       
459
       
-
       
    

     

       
460
       
460
       
-
       
    log_info "Listing cached blob records..."

     

       
461
       
461
       
-
       
    

     

       
462
       
462
       
-
       
    # Get list of available timelines to check each collection

     

       
463
       
463
       
-
       
    local timelines=()

     

       
464
       
464
       
-
       
    if [ -d "$IMAGES_DIR" ]; then

     

       
465
       
465
       
-
       
        for timeline_dir in "$IMAGES_DIR"/*; do

     

       
466
       
466
       
-
       
            if [ -d "$timeline_dir" ]; then

     

       
467
       
467
       
-
       
                timelines+=($(basename "$timeline_dir"))

     

       
468
       
468
       
-
       
            fi

     

       
469
       
469
       
-
       
        done

     

       
470
       
470
       
-
       
    fi

     

       
471
       
471
       
-
       
    

     

       
472
       
472
       
-
       
    local total_records=0

     

       
473
       
473
       
-
       
    echo "Cached blob records:"

     

       
474
       
474
       
-
       
    

     

       
475
       
475
       
-
       
    for timeline in "${timelines[@]}"; do

     

       
476
       
476
       
-
       
        # List records in each timeline collection

     

       
477
       
477
       
-
       
        local list_response

     

       
478
       
478
       
-
       
        list_response=$(curl -s \

     

       
479
       
479
       
-
       
            "https://bsky.social/xrpc/com.atproto.repo.listRecords?repo=$did&collection=pfp.updates.${timeline}" \

     

       
480
       
480
       
-
       
            -H "Authorization: Bearer $token" 2>/dev/null)

     

       
481
       
481
       
-
       
        

     

       
482
       
482
       
-
       
        if echo "$list_response" | jq -e '.records' > /dev/null 2>&1; then

     

       
483
       
483
       
-
       
            local timeline_count=$(echo "$list_response" | jq '.records | length')

     

       
484
       
484
       
-
       
            if [ "$timeline_count" -gt 0 ]; then

     

       
485
       
485
       
-
       
                echo "  $timeline timeline:"

     

       
486
       
486
       
-
       
                echo "$list_response" | jq -r '.records[] | "    hour \(.value.hour) - Hash: \(.value.imageHash[0:12])... (Created: \(.value.createdAt))"'

     

       
487
       
487
       
-
       
                total_records=$((total_records + timeline_count))

     

       
488
       
488
       
-
       
            fi

     

       
489
       
489
       
-
       
        fi

     

       
490
       
490
       
-
       
    done

     

       
491
       
491
       
-
       
    

     

       
492
       
492
       
-
       
    echo "Total cached records: $total_records"

     

       
493
       
493
       
-
       
}

     

       
494
       
494
       
-
       


     

       
495
       
495
       
-
       
# Clean up old cached blobs (optional maintenance function)

     

       
496
       
496
       
-
       
cleanup_cached_blobs() {

     

       
497
       
497
       
-
       
    local token="$1"

     

       
498
       
498
       
-
       
    local days_to_keep="${2:-30}"  # Keep records for 30 days by default

     

       
499
       
499
       
-
       
    local did

     

       
500
       
500
       
-
       
    

     

       
501
       
501
       
-
       
    did=$(jq -r '.did' "$SESSION_FILE")

     

       
502
       
502
       
-
       
    

     

       
503
       
503
       
-
       
    log_info "Cleaning up cached blobs older than $days_to_keep days..."

     

       
504
       
504
       
-
       
    

     

       
505
       
505
       
-
       
    # Get current timestamp minus retention period

     

       
506
       
506
       
-
       
    local cutoff_date

     

       
507
       
507
       
-
       
    cutoff_date=$(date -u -d "$days_to_keep days ago" +%Y-%m-%dT%H:%M:%S.%3NZ)

     

       
508
       
508
       
-
       
    

     

       
509
       
509
       
-
       
    # Get list of available timelines to check each collection

     

       
510
       
510
       
-
       
    local timelines=()

     

       
511
       
511
       
-
       
    if [ -d "$IMAGES_DIR" ]; then

     

       
512
       
512
       
-
       
        for timeline_dir in "$IMAGES_DIR"/*; do

     

       
513
       
513
       
-
       
            if [ -d "$timeline_dir" ]; then

     

       
514
       
514
       
-
       
                timelines+=($(basename "$timeline_dir"))

     

       
515
       
515
       
-
       
            fi

     

       
516
       
516
       
-
       
        done

     

       
517
       
517
       
-
       
    fi

     

       
518
       
518
       
-
       
    

     

       
519
       
519
       
-
       
    local deleted_count=0

     

       
520
       
520
       
-
       
    

     

       
521
       
521
       
-
       
    for timeline in "${timelines[@]}"; do

     

       
522
       
522
       
-
       
        # List all records in this timeline collection

     

       
523
       
523
       
-
       
        local list_response

     

       
524
       
524
       
-
       
        list_response=$(curl -s \

     

       
525
       
525
       
-
       
            "https://bsky.social/xrpc/com.atproto.repo.listRecords?repo=$did&collection=pfp.updates.${timeline}" \

     

       
526
       
526
       
-
       
            -H "Authorization: Bearer $token" 2>/dev/null)

     

       
527
       
527
       
-
       
        

     

       
528
       
528
       
-
       
        if echo "$list_response" | jq -e '.records' > /dev/null 2>&1; then

     

       
529
       
529
       
-
       
            # Find records older than cutoff

     

       
530
       
530
       
-
       
            local old_records

     

       
531
       
531
       
-
       
            old_records=$(echo "$list_response" | jq --arg cutoff "$cutoff_date" '.records[] | select(.value.createdAt < $cutoff)')

     

       
532
       
532
       
-
       
            

     

       
533
       
533
       
-
       
            if [ -n "$old_records" ]; then

     

       
534
       
534
       
-
       
                echo "$old_records" | jq -r '.uri' | while read -r record_uri; do

     

       
535
       
535
       
-
       
                    local rkey=$(echo "$record_uri" | sed 's/.*\///')

     

       
536
       
536
       
-
       
                    log_info "Deleting old record: $timeline/$rkey"

     

       
537
       
537
       
-
       
                    

     

       
538
       
538
       
-
       
                    curl -s -X POST \

     

       
539
       
539
       
-
       
                        "https://bsky.social/xrpc/com.atproto.repo.deleteRecord" \

     

       
540
       
540
       
-
       
                        -H "Authorization: Bearer $token" \

     

       
541
       
541
       
-
       
                        -H "Content-Type: application/json" \

     

       
542
       
542
       
-
       
                        -d "{\"repo\":\"$did\",\"collection\":\"pfp.updates.${timeline}\",\"rkey\":\"$rkey\"}" > /dev/null

     

       
543
       
543
       
-
       
                    

     

       
544
       
544
       
-
       
                    deleted_count=$((deleted_count + 1))

     

       
545
       
545
       
-
       
                done

     

       
546
       
546
       
-
       
            fi

     

       
547
       
547
       
-
       
        fi

     

       
548
       
548
       
-
       
    done

     

       
549
       
549
       
-
       
    

     

       
550
       
550
       
-
       
    if [ "$deleted_count" -eq 0 ]; then

     

       
551
       
551
       
-
       
        log_info "No old records found to clean up"

     

       
552
       
552
       
-
       
    else

     

       
553
       
553
       
-
       
        log_success "Deleted $deleted_count old records"

     

       
554
       
554
       
-
       
    fi

     

       
555
       
555
       
-
       
}

     

       
556
       
556
       
-
       


     

       
557
       
557
       
-
       
# Update profile picture

     

       
558
       
558
       
-
       
update_profile_picture() {

     

       
559
       
559
       
-
       
    local blob_ref="$1"

     

       
560
       
560
       
-
       
    local token="$2"

     

       
561
       
561
       
-
       
    local did

     

       
562
       
562
       
-
       


     

       
563
       
563
       
-
       
    # Validate blob reference

     

       
564
       
564
       
-
       
    if [ -z "$blob_ref" ] || [ "$blob_ref" = "null" ]; then

     

       
565
       
565
       
-
       
        log_error "Invalid blob reference provided"

     

       
566
       
566
       
-
       
        return 1

     

       
567
       
567
       
-
       
    fi

     

       
568
       
568
       
-
       


     

       
569
       
569
       
-
       
    # Validate blob reference format

     

       
570
       
570
       
-
       
    if ! echo "$blob_ref" | jq -e '.ref' > /dev/null 2>&1; then

     

       
571
       
571
       
-
       
        log_error "Blob reference missing required 'ref' field: $blob_ref"

     

       
572
       
572
       
-
       
        return 1

     

       
573
       
573
       
-
       
    fi

     

       
574
       
574
       
-
       


     

       
575
       
575
       
-
       
    # Get DID from session

     

       
576
       
576
       
-
       
    did=$(jq -r '.did' "$SESSION_FILE")

     

       
577
       
577
       
-
       


     

       
578
       
578
       
-
       
    log_info "Updating profile picture..."

     

       
579
       
579
       
-
       
    log_info "Using blob: $blob_ref"

     

       
580
       
580
       
-
       


     

       
581
       
581
       
-
       
    # Get current profile

     

       
582
       
582
       
-
       
    local current_profile

     

       
583
       
583
       
-
       
    current_profile=$(curl -s \

     

       
584
       
584
       
-
       
        "https://bsky.social/xrpc/com.atproto.repo.getRecord?repo=$did&collection=app.bsky.actor.profile&rkey=self" \

     

       
585
       
585
       
-
       
        -H "Authorization: Bearer $token")

     

       
586
       
586
       
-
       


     

       
587
       
587
       
-
       
    log_info "Current profile response: $current_profile"

     

       
588
       
588
       
-
       


     

       
589
       
589
       
-
       
    local profile_data

     

       
590
       
590
       
-
       
    if echo "$current_profile" | jq -e '.value' > /dev/null 2>&1; then

     

       
591
       
591
       
-
       
        # Update existing profile - PRESERVE ALL EXISTING FIELDS

     

       
592
       
592
       
-
       
        profile_data=$(echo "$current_profile" | jq --argjson avatar "$blob_ref" '.value | .avatar = $avatar')

     

       
593
       
593
       
-
       
        log_info "Updating existing profile (preserving existing fields)"

     

       
594
       
594
       
-
       
    else

     

       
595
       
595
       
-
       
        log_error "No existing profile found - cannot safely create new profile"

     

       
596
       
596
       
-
       
        log_error "Please manually restore your profile in the Bluesky app first"

     

       
597
       
597
       
-
       
        return 1

     

       
598
       
598
       
-
       
    fi

     

       
599
       
599
       
-
       


     

       
600
       
600
       
-
       
    log_info "Profile data to send: $profile_data"

     

       
601
       
601
       
-
       


     

       
602
       
602
       
-
       
    # Validate profile data before sending

     

       
603
       
603
       
-
       
    if ! echo "$profile_data" | jq -e '.avatar' > /dev/null 2>&1; then

     

       
604
       
604
       
-
       
        log_error "Generated profile data is invalid"

     

       
605
       
605
       
-
       
        return 1

     

       
606
       
606
       
-
       
    fi

     

       
607
       
607
       
-
       


     

       
608
       
608
       
-
       
    # Double-check we're preserving important fields

     

       
609
       
609
       
-
       
    local display_name=$(echo "$profile_data" | jq -r '.displayName // empty')

     

       
610
       
610
       
-
       
    local description=$(echo "$profile_data" | jq -r '.description // empty')

     

       
611
       
611
       
-
       


     

       
612
       
612
       
-
       
    if [ -n "$display_name" ]; then

     

       
613
       
613
       
-
       
        log_info "Preserving display name: $display_name"

     

       
614
       
614
       
-
       
    fi

     

       
615
       
615
       
-
       


     

       
616
       
616
       
-
       
    if [ -n "$description" ]; then

     

       
617
       
617
       
-
       
        log_info "Preserving description: $(echo "$description" | head -c 50)..."

     

       
618
       
618
       
-
       
    fi

     

       
619
       
619
       
-
       


     

       
620
       
620
       
-
       
    # Create the request payload

     

       
621
       
621
       
-
       
    local request_payload

     

       
622
       
622
       
-
       
    request_payload=$(jq -n \

     

       
623
       
623
       
-
       
        --arg repo "$did" \

     

       
624
       
624
       
-
       
        --arg collection "app.bsky.actor.profile" \

     

       
625
       
625
       
-
       
        --arg rkey "self" \

     

       
626
       
626
       
-
       
        --argjson record "$profile_data" \

     

       
627
       
627
       
-
       
        '{repo: $repo, collection: $collection, rkey: $rkey, record: $record}')

     

       
628
       
628
       
-
       


     

       
629
       
629
       
-
       
    log_info "Request payload: $request_payload"

     

       
630
       
630
       
-
       


     

       
631
       
631
       
-
       
    # In dry run mode, don't actually update

     

       
632
       
632
       
-
       
    if [ "${DRY_RUN:-false}" = "true" ]; then

     

       
633
       
633
       
-
       
        log_info "DRY RUN MODE - Would send profile update with avatar"

     

       
634
       
634
       
-
       
        log_info "DRY RUN MODE - Profile fields would be preserved"

     

       
635
       
635
       
-
       
        return 0

     

       
636
       
636
       
-
       
    fi

     

       
637
       
637
       
-
       


     

       
638
       
638
       
-
       
    # Update profile

     

       
639
       
639
       
-
       
    local update_response

     

       
640
       
640
       
-
       
    update_response=$(curl -s -X POST \

     

       
641
       
641
       
-
       
        "https://bsky.social/xrpc/com.atproto.repo.putRecord" \

     

       
642
       
642
       
-
       
        -H "Authorization: Bearer $token" \

     

       
643
       
643
       
-
       
        -H "Content-Type: application/json" \

     

       
644
       
644
       
-
       
        -d "$request_payload")

     

       
645
       
645
       
-
       


     

       
646
       
646
       
-
       
    log_info "Update response: $update_response"

     

       
647
       
647
       
-
       


     

       
648
       
648
       
-
       
    if echo "$update_response" | jq -e '.uri' > /dev/null 2>&1; then

     

       
649
       
649
       
-
       
        log_success "Successfully updated profile picture"

     

       
650
       
650
       
-
       
        return 0

     

       
651
       
651
       
-
       
    else

     

       
652
       
652
       
-
       
        log_error "Failed to update profile picture: $(echo "$update_response" | jq -r '.message // "Unknown error"')"

     

       
653
       
653
       
-
       
        log_error "Full error response: $update_response"

     

       
654
       
654
       
-
       
        return 1

     

       
655
       
655
       
-
       
    fi

     

       
656
       
656
       
-
       
}

     

       
657
       
657
       
-
       


     

       
658
       
658
       
-
       
# Update Slack profile picture

     

       
659
       
659
       
-
       
update_slack_profile_picture() {

     

       
660
       
660
       
-
       
    local image_path="$1"

     

       
661
       
661
       
-
       


     

       
662
       
662
       
-
       
    if [ "$SLACK_ENABLED" != "true" ] || [ -z "$SLACK_USER_TOKEN" ] || [ "$SLACK_USER_TOKEN" = "null" ]; then

     

       
663
       
663
       
-
       
        log_info "Slack integration disabled or not configured"

     

       
664
       
664
       
-
       
        return 0

     

       
665
       
665
       
-
       
    fi

     

       
666
       
666
       
-
       


     

       
667
       
667
       
-
       
    if [ ! -f "$image_path" ]; then

     

       
668
       
668
       
-
       
        log_error "Image file not found for Slack: $image_path"

     

       
669
       
669
       
-
       
        return 1

     

       
670
       
670
       
-
       
    fi

     

       
671
       
671
       
-
       


     

       
672
       
672
       
-
       
    log_info "Updating Slack profile picture..."

     

       
673
       
673
       
-
       


     

       
674
       
674
       
-
       
    # First, upload the image to Slack

     

       
675
       
675
       
-
       
    local upload_response

     

       
676
       
676
       
-
       
    upload_response=$(curl -s -X POST \

     

       
677
       
677
       
-
       
        "https://slack.com/api/users.setPhoto" \

     

       
678
       
678
       
-
       
        -H "Authorization: Bearer $SLACK_USER_TOKEN" \

     

       
679
       
679
       
-
       
        -F "image=@$image_path")

     

       
680
       
680
       
-
       


     

       
681
       
681
       
-
       
    if echo "$upload_response" | jq -e '.ok' > /dev/null 2>&1; then

     

       
682
       
682
       
-
       
        local ok_status=$(echo "$upload_response" | jq -r '.ok')

     

       
683
       
683
       
-
       
        if [ "$ok_status" = "true" ]; then

     

       
684
       
684
       
-
       
            log_success "Successfully updated Slack profile picture"

     

       
685
       
685
       
-
       
            return 0

     

       
686
       
686
       
-
       
        else

     

       
687
       
687
       
-
       
            local error_msg=$(echo "$upload_response" | jq -r '.error // "Unknown error"')

     

       
688
       
688
       
-
       
            log_error "Failed to update Slack profile picture: $error_msg"

     

       
689
       
689
       
-
       


     

       
690
       
690
       
-
       
            # Handle common errors

     

       
691
       
691
       
-
       
            case "$error_msg" in

     

       
692
       
692
       
-
       
                "invalid_auth")

     

       
693
       
693
       
-
       
                    log_error "Invalid Slack token - please check your user token"

     

       
694
       
694
       
-
       
                    ;;

     

       
695
       
695
       
-
       
                "not_authed")

     

       
696
       
696
       
-
       
                    log_error "Authentication failed - token may be expired"

     

       
697
       
697
       
-
       
                    ;;

     

       
698
       
698
       
-
       
                "missing_scope")

     

       
699
       
699
       
-
       
                    log_error "Token missing required scope - needs 'users.profile:write'"

     

       
700
       
700
       
-
       
                    ;;

     

       
701
       
701
       
-
       
                "too_large")

     

       
702
       
702
       
-
       
                    log_error "Image file too large for Slack"

     

       
703
       
703
       
-
       
                    ;;

     

       
704
       
704
       
-
       
            esac

     

       
705
       
705
       
-
       
            return 1

     

       
706
       
706
       
-
       
        fi

     

       
707
       
707
       
-
       
    else

     

       
708
       
708
       
-
       
        log_error "Invalid response from Slack API: $upload_response"

     

       
709
       
709
       
-
       
        return 1

     

       
710
       
710
       
-
       
    fi

     

       
711
       
711
       
-
       
}

     

       
712
       
712
       
-
       


     

       
713
       
713
       
-
       
# Get weather-based timeline

     

       
714
       
714
       
-
       
get_weather_timeline() {

     

       
715
       
715
       
-
       
    if [ "$WEATHER_ENABLED" != "true" ] || [ -z "$WEATHER_API_KEY" ] || [ "$WEATHER_API_KEY" = "null" ]; then

     

       
716
       
716
       
-
       
        log_info "Weather integration disabled, using default timeline: $DEFAULT_TIMELINE"

     

       
717
       
717
       
-
       
        echo "$DEFAULT_TIMELINE"

     

       
718
       
718
       
-
       
        return 0

     

       
719
       
719
       
-
       
    fi

     

       
720
       
720
       
-
       


     

       
721
       
721
       
-
       
    log_info "Fetching weather data..."

     

       
722
       
722
       
-
       


     

       
723
       
723
       
-
       
    local lat lon

     

       
724
       
724
       
-
       


     

       
725
       
725
       
-
       
    if [ "$WEATHER_LOCATION" = "auto" ]; then

     

       
726
       
726
       
-
       
        # Auto-detect location from IP

     

       
727
       
727
       
-
       
        local ip_data

     

       
728
       
728
       
-
       
        ip_data=$(curl -s "http://ip-api.com/json/" --connect-timeout 10)

     

       
729
       
729
       
-
       


     

       
730
       
730
       
-
       
        if echo "$ip_data" | jq -e '.lat' > /dev/null 2>&1; then

     

       
731
       
731
       
-
       
            lat=$(echo "$ip_data" | jq -r '.lat')

     

       
732
       
732
       
-
       
            lon=$(echo "$ip_data" | jq -r '.lon')

     

       
733
       
733
       
-
       
            local city=$(echo "$ip_data" | jq -r '.city')

     

       
734
       
734
       
-
       
            local country=$(echo "$ip_data" | jq -r '.country')

     

       
735
       
735
       
-
       
            log_info "Auto-detected location: $city, $country"

     

       
736
       
736
       
-
       
        else

     

       
737
       
737
       
-
       
            log_warning "Could not auto-detect location, using default timeline"

     

       
738
       
738
       
-
       
            echo "$DEFAULT_TIMELINE"

     

       
739
       
739
       
-
       
            return 0

     

       
740
       
740
       
-
       
        fi

     

       
741
       
741
       
-
       
    else

     

       
742
       
742
       
-
       
        # Use provided location (assume it's "lat,lon" or city name)

     

       
743
       
743
       
-
       
        if [[ "$WEATHER_LOCATION" =~ ^-?[0-9]+\.?[0-9]*,-?[0-9]+\.?[0-9]*$ ]]; then

     

       
744
       
744
       
-
       
            # It's coordinates

     

       
745
       
745
       
-
       
            lat=$(echo "$WEATHER_LOCATION" | cut -d',' -f1)

     

       
746
       
746
       
-
       
            lon=$(echo "$WEATHER_LOCATION" | cut -d',' -f2)

     

       
747
       
747
       
-
       
        else

     

       
748
       
748
       
-
       
            # It's a city name, geocode it

     

       
749
       
749
       
-
       
            local geocode_response

     

       
750
       
750
       
-
       
            geocode_response=$(curl -s "http://api.openweathermap.org/geo/1.0/direct?q=$WEATHER_LOCATION&limit=1&appid=$WEATHER_API_KEY")

     

       
751
       
751
       
-
       


     

       
752
       
752
       
-
       
            if echo "$geocode_response" | jq -e '.[0].lat' > /dev/null 2>&1; then

     

       
753
       
753
       
-
       
                lat=$(echo "$geocode_response" | jq -r '.[0].lat')

     

       
754
       
754
       
-
       
                lon=$(echo "$geocode_response" | jq -r '.[0].lon')

     

       
755
       
755
       
-
       
                log_info "Geocoded location: $WEATHER_LOCATION"

     

       
756
       
756
       
-
       
            else

     

       
757
       
757
       
-
       
                log_warning "Could not geocode location: $WEATHER_LOCATION"

     

       
758
       
758
       
-
       
                echo "$DEFAULT_TIMELINE"

     

       
759
       
759
       
-
       
                return 0

     

       
760
       
760
       
-
       
            fi

     

       
761
       
761
       
-
       
        fi

     

       
762
       
762
       
-
       
    fi

     

       
763
       
763
       
-
       


     

       
764
       
764
       
-
       
    # Get current weather

     

       
765
       
765
       
-
       
    local weather_response

     

       
766
       
766
       
-
       
    weather_response=$(curl -s "http://api.openweathermap.org/data/2.5/weather?lat=$lat&lon=$lon&appid=$WEATHER_API_KEY" --connect-timeout 10)

     

       
767
       
767
       
-
       


     

       
768
       
768
       
-
       
    if echo "$weather_response" | jq -e '.weather[0].main' > /dev/null 2>&1; then

     

       
769
       
769
       
-
       
        local weather_main=$(echo "$weather_response" | jq -r '.weather[0].main' | tr '[:upper:]' '[:lower:]')

     

       
770
       
770
       
-
       
        local weather_desc=$(echo "$weather_response" | jq -r '.weather[0].description')

     

       
771
       
771
       
-
       
        log_info "Current weather: $weather_desc"

     

       
772
       
772
       
-
       


     

       
773
       
773
       
-
       
        # Map weather to timeline

     

       
774
       
774
       
-
       
        local timeline

     

       
775
       
775
       
-
       
        timeline=$(jq -r ".weather.timeline_mapping.\"$weather_main\" // \"$DEFAULT_TIMELINE\"" "$CONFIG_FILE")

     

       
776
       
776
       
-
       


     

       
777
       
777
       
-
       
        # Check if the mapped timeline exists

     

       
778
       
778
       
-
       
        if [ ! -d "$IMAGES_DIR/$timeline" ]; then

     

       
779
       
779
       
-
       
            log_warning "Timeline '$timeline' not found, falling back to default: $DEFAULT_TIMELINE"

     

       
780
       
780
       
-
       
            echo "$DEFAULT_TIMELINE"

     

       
781
       
781
       
-
       
        else

     

       
782
       
782
       
-
       
            log_info "Weather mapped to timeline: $timeline"

     

       
783
       
783
       
-
       
            echo "$timeline"

     

       
784
       
784
       
-
       
        fi

     

       
785
       
785
       
-
       
    else

     

       
786
       
786
       
-
       
        log_warning "Could not fetch weather data, using default timeline"

     

       
787
       
787
       
-
       
        echo "$DEFAULT_TIMELINE"

     

       
788
       
788
       
-
       
    fi

     

       
789
       
789
       
-
       
}

     

       
790
       
790
       
-
       


     

       
791
       
791
       
-
       
# Get current hour image path

     

       
792
       
792
       
-
       
get_hour_image_path() {

     

       
793
       
793
       
-
       
    local timeline="$1"

     

       
794
       
794
       
-
       
    local hour=$(date +%H)

     

       
795
       
795
       
-
       
    # Remove leading zero to avoid octal interpretation, then pad with zero

     

       
796
       
796
       
-
       
    local hour_decimal=$((10#$hour))  # Force decimal interpretation

     

       
797
       
797
       
-
       
    local hour_padded=$(printf "%02d" "$hour_decimal")

     

       
798
       
798
       
-
       
    local image_path="$IMAGES_DIR/$timeline/hour_${hour_padded}.jpg"

     

       
799
       
799
       
-
       


     

       
800
       
800
       
-
       
    if [ -f "$image_path" ]; then

     

       
801
       
801
       
-
       
        echo "$image_path"

     

       
802
       
802
       
-
       
        return 0

     

       
803
       
803
       
-
       
    else

     

       
804
       
804
       
-
       
        log_warning "Image not found: $image_path" >&2

     

       
805
       
805
       
-
       


     

       
806
       
806
       
-
       
        # Try fallback to default timeline

     

       
807
       
807
       
-
       
        if [ "$timeline" != "$DEFAULT_TIMELINE" ]; then

     

       
808
       
808
       
-
       
            local fallback_path="$IMAGES_DIR/$DEFAULT_TIMELINE/hour_${hour_padded}.jpg"

     

       
809
       
809
       
-
       
            if [ -f "$fallback_path" ]; then

     

       
810
       
810
       
-
       
                log_info "Using fallback image: $fallback_path" >&2

     

       
811
       
811
       
-
       
                echo "$fallback_path"

     

       
812
       
812
       
-
       
                return 0

     

       
813
       
813
       
-
       
            fi

     

       
814
       
814
       
-
       
        fi

     

       
815
       
815
       
-
       


     

       
816
       
816
       
-
       
        return 1

     

       
817
       
817
       
-
       
    fi

     

       
818
       
818
       
-
       
}

     

       
819
       
819
       
-
       


     

       
820
       
820
       
-
       
# List available timelines

     

       
821
       
821
       
-
       
list_timelines() {

     

       
822
       
822
       
-
       
    if [ ! -d "$IMAGES_DIR" ]; then

     

       
823
       
823
       
-
       
        log_error "Images directory not found: $IMAGES_DIR"

     

       
824
       
824
       
-
       
        return 1

     

       
825
       
825
       
-
       
    fi

     

       
826
       
826
       
-
       


     

       
827
       
827
       
-
       
    echo "Available timelines:"

     

       
828
       
828
       
-
       
    for timeline_dir in "$IMAGES_DIR"/*; do

     

       
829
       
829
       
-
       
        if [ -d "$timeline_dir" ]; then

     

       
830
       
830
       
-
       
            local timeline_name=$(basename "$timeline_dir")

     

       
831
       
831
       
-
       
            local image_count=$(find "$timeline_dir" -name "hour_*.jpg" | wc -l)

     

       
832
       
832
       
-
       
            echo "  - $timeline_name ($image_count images)"

     

       
833
       
833
       
-
       
        fi

     

       
834
       
834
       
-
       
    done

     

       
835
       
835
       
-
       
}

     

       
836
       
836
       
-
       


     

       
837
       
837
       
-
       
# Test mode - show what would be used

     

       
838
       
838
       
-
       
test_mode() {

     

       
839
       
839
       
-
       
    local timeline

     

       
840
       
840
       
-
       
    timeline=$(get_weather_timeline)

     

       
841
       
841
       
-
       


     

       
842
       
842
       
-
       
    local image_path

     

       
843
       
843
       
-
       
    image_path=$(get_hour_image_path "$timeline")

     

       
844
       
844
       
-
       


     

       
845
       
845
       
-
       
    local hour=$(date +%H)

     

       
846
       
846
       
-
       


     

       
847
       
847
       
-
       
    echo "=== Test Mode ==="

     

       
848
       
848
       
-
       
    echo "Current time: $(date)"

     

       
849
       
849
       
-
       
    echo "Current hour: $hour"

     

       
850
       
850
       
-
       
    echo "Weather enabled: $WEATHER_ENABLED"

     

       
851
       
851
       
-
       
    echo "Selected timeline: $timeline"

     

       
852
       
852
       
-
       
    echo "Image path: $image_path"

     

       
853
       
853
       
-
       


     

       
854
       
854
       
-
       
    if [ -f "$image_path" ]; then

     

       
855
       
855
       
-
       
        echo "✓ Image exists"

     

       
856
       
856
       
-
       
        echo "Image size: $(du -h "$image_path" | cut -f1)"

     

       
857
       
857
       
-
       
        

     

       
858
       
858
       
-
       
        # Show hash info in test mode

     

       
859
       
859
       
-
       
        local test_hash=$(calculate_image_hash "$image_path")

     

       
860
       
860
       
-
       
        echo "Image hash: $test_hash"

     

       
861
       
861
       
-
       
    else

     

       
862
       
862
       
-
       
        echo "✗ Image not found"

     

       
863
       
863
       
-
       


     

       
864
       
864
       
-
       
        # Show available alternatives

     

       
865
       
865
       
-
       
        echo ""

     

       
866
       
866
       
-
       
        echo "Available timelines:"

     

       
867
       
867
       
-
       
        list_timelines

     

       
868
       
868
       
-
       
        return 1

     

       
869
       
869
       
-
       
    fi

     

       
870
       
870
       
-
       


     

       
871
       
871
       
-
       
    # Show weather info if enabled

     

       
872
       
872
       
-
       
    if [ "$WEATHER_ENABLED" = "true" ] && [ -n "$WEATHER_API_KEY" ] && [ "$WEATHER_API_KEY" != "null" ]; then

     

       
873
       
873
       
-
       
        echo ""

     

       
874
       
874
       
-
       
        echo "Weather integration: enabled"

     

       
875
       
875
       
-
       
        echo "Location setting: $WEATHER_LOCATION"

     

       
876
       
876
       
-
       
    else

     

       
877
       
877
       
-
       
        echo ""

     

       
878
       
878
       
-
       
        echo "Weather integration: disabled (using default timeline)"

     

       
879
       
879
       
-
       
    fi

     

       
880
       
880
       
-
       


     

       
881
       
881
       
-
       
    # Show platform info

     

       
882
       
882
       
-
       
    echo ""

     

       
883
       
883
       
-
       
    echo "Enabled platforms:"

     

       
884
       
884
       
-
       
    if [ "$BLUESKY_ENABLED" = "true" ]; then

     

       
885
       
885
       
-
       
        echo "  ✓ Bluesky ($BLUESKY_HANDLE)"

     

       
886
       
886
       
-
       
    else

     

       
887
       
887
       
-
       
        echo "  ✗ Bluesky (disabled or not configured)"

     

       
888
       
888
       
-
       
    fi

     

       
889
       
889
       
-
       


     

       
890
       
890
       
-
       
    if [ "$SLACK_ENABLED" = "true" ]; then

     

       
891
       
891
       
-
       
        echo "  ✓ Slack"

     

       
892
       
892
       
-
       
    else

     

       
893
       
893
       
-
       
        echo "  ✗ Slack (disabled or not configured)"

     

       
894
       
894
       
-
       
    fi

     

       
895
       
895
       
-
       
    

     

       
896
       
896
       
-
       
    # Show caching info

     

       
897
       
897
       
-
       
    echo ""

     

       
898
       
898
       
-
       
    echo "Blob caching: enabled for Bluesky uploads"

     

       
899
       
899
       
-
       
    local hour_decimal=$((10#$hour))

     

       
900
       
900
       
-
       
    local hour_padded=$(printf "%02d" "$hour_decimal")

     

       
901
       
901
       
-
       
    echo "Cache key would be: ${timeline}_hour_${hour_padded}"

     

       
902
       
902
       
-
       
}

     

       
903
       
903
       
-
       


     

       
904
       
904
       
-
       
# Modified update_pfp function to use caching

     

       
905
       
905
       
-
       
update_pfp() {

     

       
906
       
906
       
-
       
    log_info "Starting profile picture update..."

     

       
907
       
907
       
-
       


     

       
908
       
908
       
-
       
    # Determine timeline based on weather

     

       
909
       
909
       
-
       
    local timeline

     

       
910
       
910
       
-
       
    timeline=$(get_weather_timeline)

     

       
911
       
911
       
-
       
    log_info "Using timeline: $timeline"

     

       
912
       
912
       
-
       


     

       
913
       
913
       
-
       
    # Get appropriate image for current hour

     

       
914
       
914
       
-
       
    local image_path

     

       
915
       
915
       
-
       
    image_path=$(get_hour_image_path "$timeline")

     

       
916
       
916
       
-
       


     

       
917
       
917
       
-
       
    if [ -z "$image_path" ]; then

     

       
918
       
918
       
-
       
        log_error "No suitable image found for current time"

     

       
919
       
919
       
-
       
        return 1

     

       
920
       
920
       
-
       
    fi

     

       
921
       
921
       
-
       


     

       
922
       
922
       
-
       
    log_info "Selected image: $image_path"

     

       
923
       
923
       
-
       


     

       
924
       
924
       
-
       
    # Get current hour for caching

     

       
925
       
925
       
-
       
    local current_hour=$(date +%H)

     

       
926
       
926
       
-
       
    local hour_decimal=$((10#$current_hour))

     

       
927
       
927
       
-
       
    local hour_padded=$(printf "%02d" "$hour_decimal")

     

       
928
       
928
       
-
       


     

       
929
       
929
       
-
       
    # Dry run mode - don't actually upload

     

       
930
       
930
       
-
       
    if [ "${DRY_RUN:-false}" = "true" ]; then

     

       
931
       
931
       
-
       
        log_info "DRY RUN MODE - Would upload: $image_path"

     

       
932
       
932
       
-
       
        log_info "Image size: $(stat -c%s "$image_path" 2>/dev/null | numfmt --to=iec)"

     

       
933
       
933
       
-
       
        local test_hash=$(calculate_image_hash "$image_path")

     

       
934
       
934
       
-
       
        log_info "Image hash: $test_hash"

     

       
935
       
935
       
-
       
        log_info "Would cache as: $timeline hour $hour_padded"

     

       
936
       
936
       
-
       
        if [ "$BLUESKY_ENABLED" = "true" ]; then

     

       
937
       
937
       
-
       
            log_info "DRY RUN MODE - Would update Bluesky profile"

     

       
938
       
938
       
-
       
        fi

     

       
939
       
939
       
-
       
        if [ "$SLACK_ENABLED" = "true" ]; then

     

       
940
       
940
       
-
       
            log_info "DRY RUN MODE - Would update Slack profile"

     

       
941
       
941
       
-
       
        fi

     

       
942
       
942
       
-
       
        log_info "DRY RUN MODE - No changes made"

     

       
943
       
943
       
-
       
        return 0

     

       
944
       
944
       
-
       
    fi

     

       
945
       
945
       
-
       


     

       
946
       
946
       
-
       
    local bluesky_success=false

     

       
947
       
947
       
-
       
    local slack_success=false

     

       
948
       
948
       
-
       


     

       
949
       
949
       
-
       
    # Update Bluesky with caching

     

       
950
       
950
       
-
       
    if [ "$BLUESKY_ENABLED" = "true" ]; then

     

       
951
       
951
       
-
       
        log_info "Updating Bluesky profile picture with caching..."

     

       
952
       
952
       
-
       


     

       
953
       
953
       
-
       
        # Get session token

     

       
954
       
954
       
-
       
        local token

     

       
955
       
955
       
-
       
        token=$(get_session_token)

     

       
956
       
956
       
-
       


     

       
957
       
957
       
-
       
        if [ -z "$token" ] || [ "$token" = "null" ]; then

     

       
958
       
958
       
-
       
            log_info "No valid session found, authenticating..."

     

       
959
       
959
       
-
       
            if ! authenticate_bluesky; then

     

       
960
       
960
       
-
       
                log_error "Failed to authenticate with Bluesky"

     

       
961
       
961
       
-
       
            else

     

       
962
       
962
       
-
       
                token=$(get_session_token)

     

       
963
       
963
       
-
       
            fi

     

       
964
       
964
       
-
       
        fi

     

       
965
       
965
       
-
       


     

       
966
       
966
       
-
       
        if [ -n "$token" ] && [ "$token" != "null" ]; then

     

       
967
       
967
       
-
       
            # Get or upload blob with caching

     

       
968
       
968
       
-
       
            local blob_ref

     

       
969
       
969
       
-
       
            blob_ref=$(get_or_upload_blob "$image_path" "$timeline" "$hour_padded" "$token")

     

       
970
       
970
       
-
       


     

       
971
       
971
       
-
       
            # If operation failed due to expired token, try re-authenticating once

     

       
972
       
972
       
-
       
            if [ -z "$blob_ref" ]; then

     

       
973
       
973
       
-
       
                log_info "Failed to get blob, trying to re-authenticate..."

     

       
974
       
974
       
-
       
                rm -f "$SESSION_FILE"  # Remove expired session

     

       
975
       
975
       
-
       
                if authenticate_bluesky; then

     

       
976
       
976
       
-
       
                    token=$(get_session_token)

     

       
977
       
977
       
-
       
                    if [ -n "$token" ] && [ "$token" != "null" ]; then

     

       
978
       
978
       
-
       
                        blob_ref=$(get_or_upload_blob "$image_path" "$timeline" "$hour_padded" "$token")

     

       
979
       
979
       
-
       
                    fi

     

       
980
       
980
       
-
       
                fi

     

       
981
       
981
       
-
       
            fi

     

       
982
       
982
       
-
       


     

       
983
       
983
       
-
       
            if [ -n "$blob_ref" ]; then

     

       
984
       
984
       
-
       
                # Update profile picture

     

       
985
       
985
       
-
       
                if update_profile_picture "$blob_ref" "$token"; then

     

       
986
       
986
       
-
       
                    bluesky_success=true

     

       
987
       
987
       
-
       
                fi

     

       
988
       
988
       
-
       
            fi

     

       
989
       
989
       
-
       
        else

     

       
990
       
990
       
-
       
            log_error "Could not obtain valid Bluesky session token"

     

       
991
       
991
       
-
       
        fi

     

       
992
       
992
       
-
       
    fi

     

       
993
       
993
       
-
       


     

       
994
       
994
       
-
       
    # Update Slack (independent of Bluesky success)

     

       
995
       
995
       
-
       
    if [ "$SLACK_ENABLED" = "true" ]; then

     

       
996
       
996
       
-
       
        if update_slack_profile_picture "$image_path"; then

     

       
997
       
997
       
-
       
            slack_success=true

     

       
998
       
998
       
-
       
        fi

     

       
999
       
999
       
-
       
    fi

     

       
1000
       
1000
       
-
       


     

       
1001
       
1001
       
-
       
    # Report results

     

       
1002
       
1002
       
-
       
    local updated_services=()

     

       
1003
       
1003
       
-
       
    local failed_services=()

     

       
1004
       
1004
       
-
       


     

       
1005
       
1005
       
-
       
    if [ "$BLUESKY_ENABLED" = "true" ]; then

     

       
1006
       
1006
       
-
       
        if [ "$bluesky_success" = "true" ]; then

     

       
1007
       
1007
       
-
       
            updated_services+=("Bluesky")

     

       
1008
       
1008
       
-
       
        else

     

       
1009
       
1009
       
-
       
            failed_services+=("Bluesky")

     

       
1010
       
1010
       
-
       
        fi

     

       
1011
       
1011
       
-
       
    fi

     

       
1012
       
1012
       
-
       


     

       
1013
       
1013
       
-
       
    if [ "$SLACK_ENABLED" = "true" ]; then

     

       
1014
       
1014
       
-
       
        if [ "$slack_success" = "true" ]; then

     

       
1015
       
1015
       
-
       
            updated_services+=("Slack")

     

       
1016
       
1016
       
-
       
        else

     

       
1017
       
1017
       
-
       
            failed_services+=("Slack")

     

       
1018
       
1018
       
-
       
        fi

     

       
1019
       
1019
       
-
       
    fi

     

       
1020
       
1020
       
-
       


     

       
1021
       
1021
       
-
       
    # Final status

     

       
1022
       
1022
       
-
       
    if [ ${#updated_services[@]} -gt 0 ]; then

     

       
1023
       
1023
       
-
       
        log_success "Successfully updated: ${updated_services[*]}"

     

       
1024
       
1024
       
-
       
    fi

     

       
1025
       
1025
       
-
       


     

       
1026
       
1026
       
-
       
    if [ ${#failed_services[@]} -gt 0 ]; then

     

       
1027
       
1027
       
-
       
        log_error "Failed to update: ${failed_services[*]}"

     

       
1028
       
1028
       
-
       
    fi

     

       
1029
       
1029
       
-
       


     

       
1030
       
1030
       
-
       
    # Return success if at least one service updated

     

       
1031
       
1031
       
-
       
    if [ ${#updated_services[@]} -gt 0 ]; then

     

       
1032
       
1032
       
-
       
        return 0

     

       
1033
       
1033
       
-
       
    else

     

       
1034
       
1034
       
-
       
        return 1

     

       
1035
       
1035
       
-
       
    fi

     

       
1036
       
1036
       
-
       
}

     

       
1037
       
1037
       
-
       


     

       
1038
       
1038
       
-
       
# Show help

     

       
1039
       
1039
       
-
       
show_help() {

     

       
1040
       
1040
       
-
       
    cat << EOF

     

       
1041
       
1041
       
-
       
Dynamic Profile Picture Updater

     

       
1042
       
1042
       
-
       


     

       
1043
       
1043
       
-
       
Automatically updates your profile pictures across multiple platforms based on time and weather.

     

       
1044
       
1044
       
-
       
Uses ATProto record caching to avoid re-uploading identical images.

     

       
1045
       
1045
       
-
       


     

       
1046
       
1046
       
-
       
Usage: $0 [options]

     

       
1047
       
1047
       
-
       


     

       
1048
       
1048
       
-
       
Options:

     

       
1049
       
1049
       
-
       
    -c, --config FILE       Use custom config file (default: $CONFIG_FILE)

     

       
1050
       
1050
       
-
       
    -t, --test             Test mode - show what would be used without updating

     

       
1051
       
1051
       
-
       
    -d, --dry-run          Dry run - authenticate and prepare but don't actually update

     

       
1052
       
1052
       
-
       
    -l, --list             List available timelines

     

       
1053
       
1053
       
-
       
    -f, --force TIMELINE   Force use of specific timeline (ignore weather)

     

       
1054
       
1054
       
-
       
    --list-cache           List all cached blob references

     

       
1055
       
1055
       
-
       
    --cleanup-cache [DAYS] Clean up cached blobs older than DAYS (default: 30)

     

       
1056
       
1056
       
-
       
    --clear-cache          Delete all cached blob references (USE WITH CAUTION)

     

       
1057
       
1057
       
-
       
    -h, --help             Show this help message

     

       
1058
       
1058
       
-
       


     

       
1059
       
1059
       
-
       
Configuration:

     

       
1060
       
1060
       
-
       
    Edit $CONFIG_FILE to set your platform credentials and preferences.

     

       
1061
       
1061
       
-
       
    

     

       
1062
       
1062
       
-
       
    Supported platforms:

     

       
1063
       
1063
       
-
       
    - Bluesky: Set handle and app password

     

       
1064
       
1064
       
-
       
    - Slack: Set user token (xoxp-...) with users.profile:write scope

     

       
1065
       
1065
       
-
       
    

     

       
1066
       
1066
       
-
       
    Blob Caching:

     

       
1067
       
1067
       
-
       
    Images are uploaded once and cached in ATProto records at:

     

       
1068
       
1068
       
-
       
    pfp.updates.{timeline}.{timeline}_hour_{HH}

     

       
1069
       
1069
       
-
       
    

     

       
1070
       
1070
       
-
       
    Each record contains:

     

       
1071
       
1071
       
-
       
    - Image SHA256 hash for change detection

     

       
1072
       
1072
       
-
       
    - Blob reference for reuse

     

       
1073
       
1073
       
-
       
    - Metadata (timeline, hour, creation time)

     

       
1074
       
1074
       
-
       
    

     

       
1075
       
1075
       
-
       
    Examples of cache locations:

     

       
1076
       
1076
       
-
       
    - pfp.updates.sunny.sunny_hour_09

     

       
1077
       
1077
       
-
       
    - pfp.updates.rainy.rainy_hour_14

     

       
1078
       
1078
       
-
       
    - pfp.updates.cloudy.cloudy_hour_23

     

       
1079
       
1079
       
-
       
    

     

       
1080
       
1080
       
-
       
Examples:

     

       
1081
       
1081
       
-
       
    $0                     # Update profile pictures (uses cache when possible)

     

       
1082
       
1082
       
-
       
    $0 --test              # Test what would be used

     

       
1083
       
1083
       
-
       
    $0 --list-cache        # Show all cached blob references

     

       
1084
       
1084
       
-
       
    $0 --cleanup-cache 7   # Remove cached blobs older than 7 days

     

       
1085
       
1085
       
-
       
    $0 --force sunny       # Force sunny timeline

     

       
1086
       
1086
       
-
       


     

       
1087
       
1087
       
-
       
For automated updates, add to crontab:

     

       
1088
       
1088
       
-
       
    # Update 2 minutes after every hour

     

       
1089
       
1089
       
-
       
    2 * * * * $0 >/dev/null 2>&1

     

       
1090
       
1090
       
-
       
EOF

     

       
1091
       
1091
       
-
       
}

     

       
1092
       
1092
       
-
       


     

       
1093
       
1093
       
-
       
# Parse command line arguments

     

       
1094
       
1094
       
-
       
parse_args() {

     

       
1095
       
1095
       
-
       
    FORCE_TIMELINE=""

     

       
1096
       
1096
       
-
       


     

       
1097
       
1097
       
-
       
    while [[ $# -gt 0 ]]; do

     

       
1098
       
1098
       
-
       
        case $1 in

     

       
1099
       
1099
       
-
       
            -c|--config)

     

       
1100
       
1100
       
-
       
                CONFIG_FILE="$2"

     

       
1101
       
1101
       
-
       
                shift 2

     

       
1102
       
1102
       
-
       
                ;;

     

       
1103
       
1103
       
-
       
            -t|--test)

     

       
1104
       
1104
       
-
       
                load_config

     

       
1105
       
1105
       
-
       
                test_mode

     

       
1106
       
1106
       
-
       
                exit $?

     

       
1107
       
1107
       
-
       
                ;;

     

       
1108
       
1108
       
-
       
            -d|--dry-run)

     

       
1109
       
1109
       
-
       
                DRY_RUN=true

     

       
1110
       
1110
       
-
       
                shift

     

       
1111
       
1111
       
-
       
                ;;

     

       
1112
       
1112
       
-
       
            -l|--list)

     

       
1113
       
1113
       
-
       
                load_config

     

       
1114
       
1114
       
-
       
                list_timelines

     

       
1115
       
1115
       
-
       
                exit 0

     

       
1116
       
1116
       
-
       
                ;;

     

       
1117
       
1117
       
-
       
            -f|--force)

     

       
1118
       
1118
       
-
       
                FORCE_TIMELINE="$2"

     

       
1119
       
1119
       
-
       
                shift 2

     

       
1120
       
1120
       
-
       
                ;;

     

       
1121
       
1121
       
-
       
            --list-cache)

     

       
1122
       
1122
       
-
       
                load_config

     

       
1123
       
1123
       
-
       
                check_dependencies

     

       
1124
       
1124
       
-
       
                

     

       
1125
       
1125
       
-
       
                # Get session token

     

       
1126
       
1126
       
-
       
                local token

     

       
1127
       
1127
       
-
       
                token=$(get_session_token)

     

       
1128
       
1128
       
-
       
                if [ -z "$token" ] || [ "$token" = "null" ]; then

     

       
1129
       
1129
       
-
       
                    if ! authenticate_bluesky; then

     

       
1130
       
1130
       
-
       
                        log_error "Failed to authenticate with Bluesky"

     

       
1131
       
1131
       
-
       
                        exit 1

     

       
1132
       
1132
       
-
       
                    else

     

       
1133
       
1133
       
-
       
                        token=$(get_session_token)

     

       
1134
       
1134
       
-
       
                    fi

     

       
1135
       
1135
       
-
       
                fi

     

       
1136
       
1136
       
-
       
                

     

       
1137
       
1137
       
-
       
                list_cached_blobs "$token"

     

       
1138
       
1138
       
-
       
                exit $?

     

       
1139
       
1139
       
-
       
                ;;

     

       
1140
       
1140
       
-
       
            --cleanup-cache)

     

       
1141
       
1141
       
-
       
                local cleanup_days="30"

     

       
1142
       
1142
       
-
       
                if [[ "$2" =~ ^[0-9]+$ ]]; then

     

       
1143
       
1143
       
-
       
                    cleanup_days="$2"

     

       
1144
       
1144
       
-
       
                    shift

     

       
1145
       
1145
       
-
       
                fi

     

       
1146
       
1146
       
-
       
                

     

       
1147
       
1147
       
-
       
                load_config

     

       
1148
       
1148
       
-
       
                check_dependencies

     

       
1149
       
1149
       
-
       
                

     

       
1150
       
1150
       
-
       
                # Get session token

     

       
1151
       
1151
       
-
       
                local token

     

       
1152
       
1152
       
-
       
                token=$(get_session_token)

     

       
1153
       
1153
       
-
       
                if [ -z "$token" ] || [ "$token" = "null" ]; then

     

       
1154
       
1154
       
-
       
                    if ! authenticate_bluesky; then

     

       
1155
       
1155
       
-
       
                        log_error "Failed to authenticate with Bluesky"

     

       
1156
       
1156
       
-
       
                        exit 1

     

       
1157
       
1157
       
-
       
                    else

     

       
1158
       
1158
       
-
       
                        token=$(get_session_token)

     

       
1159
       
1159
       
-
       
                    fi

     

       
1160
       
1160
       
-
       
                fi

     

       
1161
       
1161
       
-
       
                

     

       
1162
       
1162
       
-
       
                cleanup_cached_blobs "$token" "$cleanup_days"

     

       
1163
       
1163
       
-
       
                exit $?

     

       
1164
       
1164
       
-
       
                ;;

     

       
1165
       
1165
       
-
       
            --clear-cache)

     

       
1166
       
1166
       
-
       
                echo "WARNING: This will delete ALL cached blob references!"

     

       
1167
       
1167
       
-
       
                echo "You will need to re-upload all images on next use."

     

       
1168
       
1168
       
-
       
                read -p "Are you sure? (y/N): " -n 1 -r

     

       
1169
       
1169
       
-
       
                echo

     

       
1170
       
1170
       
-
       
                if [[ $REPLY =~ ^[Yy]$ ]]; then

     

       
1171
       
1171
       
-
       
                    load_config

     

       
1172
       
1172
       
-
       
                    check_dependencies

     

       
1173
       
1173
       
-
       
                    

     

       
1174
       
1174
       
-
       
                    # Get session token

     

       
1175
       
1175
       
-
       
                    local token

     

       
1176
       
1176
       
-
       
                    token=$(get_session_token)

     

       
1177
       
1177
       
-
       
                    if [ -z "$token" ] || [ "$token" = "null" ]; then

     

       
1178
       
1178
       
-
       
                        if ! authenticate_bluesky; then

     

       
1179
       
1179
       
-
       
                            log_error "Failed to authenticate with Bluesky"

     

       
1180
       
1180
       
-
       
                            exit 1

     

       
1181
       
1181
       
-
       
                        else

     

       
1182
       
1182
       
-
       
                            token=$(get_session_token)

     

       
1183
       
1183
       
-
       
                        fi

     

       
1184
       
1184
       
-
       
                    fi

     

       
1185
       
1185
       
-
       
                    

     

       
1186
       
1186
       
-
       
                    cleanup_cached_blobs "$token" "0"  # Delete all

     

       
1187
       
1187
       
-
       
                    log_success "Cache cleared"

     

       
1188
       
1188
       
-
       
                else

     

       
1189
       
1189
       
-
       
                    log_info "Cache clear cancelled"

     

       
1190
       
1190
       
-
       
                fi

     

       
1191
       
1191
       
-
       
                exit 0

     

       
1192
       
1192
       
-
       
                ;;

     

       
1193
       
1193
       
-
       
            -h|--help)

     

       
1194
       
1194
       
-
       
                show_help

     

       
1195
       
1195
       
-
       
                exit 0

     

       
1196
       
1196
       
-
       
                ;;

     

       
1197
       
1197
       
-
       
            *)

     

       
1198
       
1198
       
-
       
                echo "Unknown option: $1"

     

       
1199
       
1199
       
-
       
                show_help

     

       
1200
       
1200
       
-
       
                exit 1

     

       
1201
       
1201
       
-
       
                ;;

     

       
1202
       
1202
       
-
       
        esac

     

       
1203
       
1203
       
-
       
    done

     

       
1204
       
1204
       
-
       
}

     

       
1205
       
1205
       
-
       


     

       
1206
       
1206
       
-
       
# Override weather function if timeline is forced

     

       
1207
       
1207
       
-
       
if [ -n "${FORCE_TIMELINE:-}" ]; then

     

       
1208
       
1208
       
-
       
    get_weather_timeline() {

     

       
1209
       
1209
       
-
       
        echo "$FORCE_TIMELINE"

     

       
1210
       
1210
       
-
       
    }

     

       
1211
       
1211
       
-
       
fi

     

       
1212
       
1212
       
-
       


     

       
1213
       
1213
       
-
       
# Main execution

     

       
1214
       
1214
       
-
       
main() {

     

       
1215
       
1215
       
-
       
    parse_args "$@"

     

       
1216
       
1216
       
-
       
    check_dependencies

     

       
1217
       
1217
       
-
       
    load_config

     

       
1218
       
1218
       
-
       


     

       
1219
       
1219
       
-
       
    if ! update_pfp; then

     

       
1220
       
1220
       
-
       
        exit 1

     

       
1221
       
1221
       
-
       
    fi

     

       
1222
       
1222
       
-
       
}

     

       
1223
       
1223
       
-
       


     

       
1224
       
1224
       
-
       
# Run main function

     

       
1225
       
1225
       
-
       
main "$@"