publish to all your social media!

Compose and schedule cross-platform social posts on Fedica (X, LinkedIn, Threads, Mastodon, Bluesky) via agent-browser. Handles login, image upload, scheduli...

view source

installs

stars

karma

SkillRank score ↗

8.5/ 10

evaluated by implexa, claude-haiku-4-5 · 2026-07-19

fedica skill composes and schedules cross-platform social posts (x, linkedin, threads, mastodon, bluesky) via agent-browser, with explicit handling of timezone conversion, character limits per platform, and shadow-dom date picker mechanics.

structure

9.0

trigger phrases

8.0

procedure

9.0

edge cases

8.0

documentation

9.0

strengths

view original SKILL.md from clawhubclick to expand

---
name: fedica
version: 1.0.0
description: Compose and schedule cross-platform social posts on Fedica (X, LinkedIn, Threads, Mastodon, Bluesky) via agent-browser. Handles login, image upload, scheduling, character limits, and Fedica's UTC-only time display.
metadata: {"openclaw":{"emoji":"📣","requires":{"commands":["agent-browser"]}}}
---

# Fedica Skill

[Fedica](https://fedica.com) is a cross-platform social scheduler that publishes to **X, LinkedIn, Threads, Mastodon, Bluesky** (and more) from one compose box. This skill drives it through `agent-browser`.

## Prerequisites

- `agent-browser` installed (`npm i -g agent-browser`)
- A Fedica account with at least one platform connected
- Credentials available to you (this skill does not manage secrets — load your own from your password manager, `pass`, `op`, env vars, `~/.secrets/...`, etc.)

## Safety

Fedica is public broadcast. **Never publish or schedule without explicit user confirmation on:**

- final post text
- target platforms (checkboxes in the composer)
- scheduled local time (Fedica shows UTC — convert before confirming)

Treat every `Post Now` / `Add to Calendar` / `Update` click like an email you cannot unsend.

---

## Key gotchas

| Gotcha | Rule |
|---|---|
| **Timezone** | Fedica displays **everything in GMT+00 (UTC)** regardless of browser or user TZ. Convert to the user's local TZ before confirming a schedule. Example: 07:00 UTC = 09:00 Europe/Paris (CEST, summer) or 08:00 Europe/Paris (CET, winter). |
| **Bluesky limit** | **300 graphemes max**. Almost always the binding constraint — design around it first. |
| **Threads / Mastodon** | 500 chars each. X and LinkedIn much more generous. |
| **Character counter** | Bottom right of composer shows `NNN / 300` (always anchored to Bluesky's 300). If the text exceeds a platform's limit, clicking `Schedule` pops an error listing which platforms fail. |
| **Custom Posts tab** | Allows per-platform versions (long LinkedIn + short Bluesky). Use when trimming to 300 kills the message. |
| **Image upload** | The visible camera icon only opens a hidden input that Fedica will not react to on direct upload. You must open the modal first: `openTweetBoxAttachmentUploadModal(1)`. The modal's input is `#imageUploader1` (note the trailing `1`). |
| **Schedule button** | It is a split button. The primary `Schedule` label alone does not open the modal. The dropdown entry `#openScheduleButton` (labelled "Specific date") is what opens the "When to publish?" modal. |
| **Date picker** | Web component `<calendar-date>` containing `<calendar-month>` whose day buttons live in a **shadow DOM**. Reach them via `document.querySelector('calendar-month').shadowRoot.querySelector('button[aria-label="April 20"]')`. |
| **Chrome extension nag** | A dialog "Fedica Browser extension" pops up on the Calendar page. Close with its X button, or use the "Don't remind me again" link, or `Escape`. |
| **Headless browser sandbox** | In a headless/server environment the first `agent-browser` call needs `--args "--no-sandbox"` (or equivalent). |

---

## Fast workflow (happy path)

```bash
# 1. Launch session (first call of the session may need --no-sandbox on servers)
agent-browser --args "--no-sandbox" open "https://fedica.com/dash/"

# 2. Log in if not already authenticated
#    Dashboard shows a "Log in" button in the top-right if you are logged out.
#    Use your own credential source; this skill does not fetch or store passwords.
#    Fedica routes to account.fedica.com/oauth2/... (Azure-B2C-style form).

# 3. Open composer
agent-browser open "https://fedica.com/publish/"

# 4. Verify which networks are checked (snapshot shows them as checkboxes)
agent-browser snapshot 2>&1 | grep -i "checkbox.*-"
# Uncheck any you do not want to target:
#   agent-browser click @<ref-of-checkbox>

# 5. Type the post
COMPOSE_REF=$(agent-browser snapshot 2>&1 | grep -oP 'textbox "Compose your post or thread" \[ref=\K[^\]]+')
agent-browser click @$COMPOSE_REF
agent-browser keyboard type "$(cat /tmp/post.txt)"

# 6. Attach image (skip if text-only)
agent-browser eval "openTweetBoxAttachmentUploadModal(1)"
sleep 1
agent-browser upload "#imageUploader1" "/absolute/path/to/image.png"
sleep 3  # let Fedica finish the upload

# 7. Open the When-to-publish modal
agent-browser eval "document.querySelector('#openScheduleButton').click()"
sleep 2

# 8. Pick the date (shadow DOM web component)
#    Replace "April 20" with the target month + day (e.g. "May 3")
agent-browser eval "
  const sr = document.querySelector('calendar-month').shadowRoot;
  sr.querySelector('button[aria-label=\"April 20\"]').click();
"

# 9. Switch from Optimized → Exact Time, then set the time
#    (find the Exact Time radio ref via snapshot, then click it)
EXACT_REF=$(agent-browser snapshot 2>&1 | grep -B1 '"Exact Time"' | grep -oP 'ref=\K[^\]]+' | head -1)
agent-browser click @$EXACT_REF

# Time in UTC (Fedica shows/accepts GMT+00). Convert from local TZ first!
agent-browser eval "
  const t = document.querySelector('#scheduleTimeControl');
  const setter = Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, 'value').set;
  setter.call(t, '07:00');
  t.dispatchEvent(new Event('change', {bubbles:true}));
"

# 10. Confirm with the primary button in the modal
#     New post  → "Add to Calendar"
#     Edit mode → "Update"
CONFIRM_REF=$(agent-browser snapshot 2>&1 | grep -B1 -E 'Add to Calendar|Update' | grep -oP 'ref=\K[^\]]+' | head -1)
agent-browser click @$CONFIRM_REF
```

---

## Verify a scheduled post

```bash
agent-browser open "https://fedica.com/schedule/"
# Close the Chrome-extension nag dialog if it appears
agent-browser press Escape

# Click a post from the calendar to get its preview modal
agent-browser find text "<snippet from the post>" click

# Preview header shows: "YYYY Mon DD HH:MM AM/PM" in GMT+00
# Post ID appears in the onclick handlers: editPost(<ID>) and delPost(<ID>, ...)
```

**Always re-verify the displayed time after scheduling.** Subtract or add the UTC offset to get the user's local time, and restate that local time to them.

---

## Editing / rescheduling

```bash
# From the preview popup, the pencil icon fires: editPost(<postId>)
agent-browser eval "editPost(<postId>)"

# Opens composer with existing content and the scheduled date/time visible
# Click the "Schedule" button next to the date to re-open the When-to-publish modal
# Change date/time → click "Update" (not "Add to Calendar" in edit mode)
```

---

## Composing for 5 platforms in one shot

Plan around the **Bluesky 300-grapheme** ceiling from the start. Techniques:

- Drop narrative intros — lead with the brand or headline
- Drop parenthetical qualifiers like "(no strings attached)"
- Remove redundant CTAs ("If you're building in this space…")
- 1 emoji per bullet + 1 CTA link is usually enough
- Em-dash (`—`) instead of "such as", "including", etc.

If the message needs the full long form, switch to the **Custom Posts** tab in the composer. Each platform then gets its own text field — full long version for LinkedIn/X, short teaser + link for Bluesky/Threads/Mastodon.

---

## Character counting

Fedica counts graphemes, and its live `NNN / 300` counter is authoritative. For an offline estimate, Python codepoint count is close but undercounts some emoji (e.g. `🏛️` = two codepoints):

```python
s = open('/tmp/post.txt').read()
print('codepoints:', len(s))
# For accurate grapheme count:
#   pip install grapheme
#   import grapheme; print(grapheme.length(s))
```

When you are close to the 300 limit, paste into the composer and read the live counter.

---

## Troubleshooting

| Symptom | Fix |
|---|---|
| Login redirects to `account.fedica.com/oauth2/...` | Normal OAuth handoff; fill the password on the Azure-B2C-style form that appears. |
| `upload` command fails with a CDP error | The file input element ID differs: `#imageUploader` (page-level, not wired up) vs `#imageUploader1` (inside the modal). Open the modal first with `openTweetBoxAttachmentUploadModal(1)` and use the modal input. |
| Date picker does not react to clicks | It is a shadow-DOM web component. Use `document.querySelector('calendar-month').shadowRoot` to reach the buttons. |
| `Post cannot be longer than N characters` popup | The error lists the offending platforms. Either trim to the lowest limit, or switch to Custom Posts. |
| Scheduled time is off by 1–2 hours | Fedica is in GMT+00. Adjust for the user's current offset (e.g. CEST = UTC+2, CET = UTC+1, EDT = UTC−4, EST = UTC−5). |
| "Fedica Browser extension" dialog blocks the calendar page | Close with the X or the "Don't remind me again" link. |

---

## Sensible defaults

When the user does not specify, propose and **then confirm**:

- Time: **09:00 local** on the next weekday (good slot for pro-network engagement). Convert to UTC before entering it into Fedica.
- Platforms: **all connected** (leave every checkbox checked).
- Visibility: default public on each platform (Fedica does not add visibility controls per post).

Do not assume — always restate the final plan (text preview, platforms list, local-time schedule) and wait for explicit go before clicking the confirm button.

---

## Fedica endpoints

- Dashboard: `https://fedica.com/dash/`
- Compose: `https://fedica.com/publish/`
- Scheduled queue: `https://fedica.com/schedule/`
- Drafts: `https://fedica.com/publish/drafts/`
- Media library: `https://fedica.com/publish/media/`

Post IDs are numeric integers. They appear in the `editPost(...)`, `delPost(...)`, and calendar-preview popup onclick handlers.

related skills

semantically similar in the cross-vendor index

clawhub

73% match

Scheduling And Queue

Use to schedule, queue, or publish FINISHED social media posts to the user's connected accounts through WoopSocial. This is a BRIDGE skill — it turns ready c...

don't have the plugin yet? install it then click "run inline in claude" again.

separated intent, inputs, procedure, decision points, output contract, and outcome signal into discrete sections

Fedica Skill

intent

schedule and publish social posts to X, LinkedIn, Threads, Mastodon, and Bluesky from a single compose interface using Fedica's web platform. use this skill when you need cross-platform posting, image attachment, precise scheduling, or bulk composition across five networks simultaneously. fedica enforces strict character limits per platform (bluesky 300 graphemes is the binding constraint), displays all times in UTC, and requires explicit user confirmation before publishing or scheduling any post.

inputs

external connections:

fedica account (https://fedica.com) with at least one social platform (X, LinkedIn, Threads, Mastodon, Bluesky) already connected and authenticated inside fedica's dashboard
fedica login credentials (email + password). this skill does not store or fetch credentials; you provide them from your own source (password manager, pass, op command, env vars, ~/.secrets/..., etc.)
agent-browser binary installed globally (npm i -g agent-browser)

context & parameters:

post text (plain string, up to 300 graphemes for bluesky constraint)
target platforms (list of X, LinkedIn, Threads, Mastodon, Bluesky; defaults to all connected if not specified)
scheduled publish time in user's local timezone (skill converts to UTC before entry into fedica)
optional image file (absolute path to PNG, JPG, etc.)
optional per-platform variants for custom posts (long-form linkedin + short bluesky, etc.)

environment:

fedica session state: may require --no-sandbox flag on headless/server environments (first agent-browser call in a session)
browser state: fedica may display a "Browser extension" nag dialog on the calendar page (side effect, requires dismissal)

procedure

step 1: launch and authenticate

input: fedica account credentials (email, password) process:

run: agent-browser --args "--no-sandbox" open "https://fedica.com/dash/" (include --no-sandbox if running on a server or headless environment)
wait 3 seconds for page load
if the top-right corner shows "Log in" button, navigate to the login form (fedica redirects to account.fedica.com/oauth2/...)
fill email and password fields using your credential source
click "Sign in"
wait for redirect back to https://fedica.com/dash/ (confirms authentication success) output: authenticated fedica session with dashboard visible

step 2: navigate to composer

input: authenticated fedica session process:

run: agent-browser open "https://fedica.com/publish/"
wait 2 seconds for composer page to load output: fedica composer page with text input and platform checkboxes visible

step 3: verify and configure target platforms

input: composer page process:

run: agent-browser snapshot 2>&1 | grep -E "checkbox|checked"
identify which platforms are currently checked (X, LinkedIn, Threads, Mastodon, Bluesky)
if user did not specify platforms, confirm that all connected platforms are checked
if user specified a subset, uncheck unwanted platforms: for each unchecked platform, find its checkbox ref and run agent-browser click @<ref>
restate the final platform list to the user and wait for explicit confirmation before proceeding output: platform checkboxes configured and confirmed by user

step 4: compose post text

input: post text (string), character limit awareness (bluesky 300 graphemes max) process:

run: COMPOSE_REF=$(agent-browser snapshot 2>&1 | grep -oP 'textbox "Compose your post or thread" \[ref=\K[^\]]+') to capture the composer text input ref
run: agent-browser click @$COMPOSE_REF to focus the input
run: agent-browser keyboard type "$(cat /tmp/post.txt)" (or pass the post text directly)
wait 1 second
run: agent-browser snapshot 2>&1 | grep -oP '\d+\s*/\s*300' to display the live character count
if count exceeds 300, restate the overage and offer to trim or switch to custom posts per platform
wait for user confirmation that text is final output: post text entered and character count verified; user confirms text

step 5: attach image (optional, skip if text-only post)

input: absolute file path to image (PNG, JPG, etc.) process:

run: agent-browser eval "openTweetBoxAttachmentUploadModal(1)" to open the image upload modal (do not use the visible camera icon, it does not wire to fedica's handler)
wait 1 second for modal to appear
run: agent-browser upload "#imageUploader1" "/absolute/path/to/image.png" (note: #imageUploader1 is inside the modal; #imageUploader alone is not functional)
wait 3 seconds for fedica to finish upload and display thumbnail output: image attached to post, thumbnail visible in composer

step 6: open schedule modal

input: composer page with text and optional image process:

run: EXACT_REF=$(agent-browser snapshot 2>&1 | grep 'openScheduleButton' | grep -oP 'ref=\K[^\]]+' | head -1) to find the schedule button
run: agent-browser click @$EXACT_REF (this opens the "when to publish?" modal; clicking the primary "Schedule" label alone does not)
wait 2 seconds for the date picker modal to appear output: "when to publish?" modal open with date picker and time selector visible

step 7: select publish date

input: target date (YYYY-MM-DD format or month + day as string), date picker modal visible process:

the date picker is a shadow-DOM web component. standard clicks do not reach the day buttons
run: agent-browser eval "const sr = document.querySelector('calendar-month').shadowRoot; sr.querySelector('button[aria-label=\"April 20\"]').click();" replacing "April 20" with the target month + day (e.g., "May 3")
wait 1 second for the date to be selected (button appearance changes or date field updates) output: target date selected in the date picker

step 8: set publish time in UTC

input: user's desired local time (string HH:MM), user's current timezone offset process:

convert user's local time to UTC (e.g., 09:00 CEST (UTC+2) = 07:00 UTC; 09:00 CET (UTC+1) = 08:00 UTC)
restate the converted UTC time to the user and wait for confirmation
run: agent-browser snapshot 2>&1 | grep -i "optimized\|exact" to check if "Optimized" or "Exact Time" is currently selected
if "Optimized" is selected, find and click the "Exact Time" radio button ref: EXACT_REF=$(agent-browser snapshot 2>&1 | grep -B1 '"Exact Time"' | grep -oP 'ref=\K[^\]]+' | head -1) then agent-browser click @$EXACT_REF
run: agent-browser eval "const t = document.querySelector('#scheduleTimeControl'); const setter = Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, 'value').set; setter.call(t, '07:00'); t.dispatchEvent(new Event('change', {bubbles:true}));" replacing '07:00' with the UTC time
wait 1 second for the time field to update output: UTC time set in the modal; user confirms the local-time equivalent

step 9: confirm and schedule

input: final post preview (text + image + platforms + UTC time visible) process:

restate to the user: final post text, target platforms (list), scheduled local time (re-converted from UTC), and image (if attached)
wait for explicit user confirmation ("yes, schedule this" or equivalent)
run: agent-browser snapshot 2>&1 | grep -oP 'button.*\K(Add to Calendar|Update)' | head -1 to identify the confirmation button label
run: CONFIRM_REF=$(agent-browser snapshot 2>&1 | grep -B1 -E 'Add to Calendar|Update' | grep -oP 'ref=\K[^\]]+' | head -1) to capture the button ref
run: agent-browser click @$CONFIRM_REF to submit
wait 3 seconds and check for error popups (character limit exceeded, validation error, etc.) output: post scheduled or published; no error dialogs present

step 10: verify scheduled post

input: scheduled post ID (appears in success message or calendar view) process:

run: agent-browser open "https://fedica.com/schedule/"
wait 2 seconds
if a "Fedica Browser extension" dialog appears, close it: agent-browser press Escape
run: agent-browser snapshot 2>&1 to view the calendar
locate the post by date and time (displayed in GMT+00)
click the post to open its preview modal
verify the displayed schedule time (shown as "YYYY Mon DD HH:MM AM/PM GMT+00")
restate to the user the scheduled local time (convert from UTC to their timezone: e.g., 07:00 UTC = 09:00 CEST in summer or 08:00 CET in winter) output: post preview modal shows correct schedule time; user confirms match

decision points

if user has not specified target platforms:

propose all connected platforms (X, LinkedIn, Threads, Mastodon, Bluesky) and confirm before proceeding

if post text exceeds 300 graphemes:

offer two options: trim to 300 graphemes for uniform posting across all platforms, or switch to custom posts tab (per-platform text variants)
if user chooses custom posts, navigate to that tab and repeat text entry for each platform (accounting for different character limits: bluesky 300, threads 500, mastodon 500, X and LinkedIn much higher)
if user chooses trim, help identify the lowest-value phrases to cut

if image upload fails with CDP error:

check the file input element ID. the visible camera icon links to #imageUploader (not wired). the functional input is #imageUploader1 (inside the modal)
re-run agent-browser eval "openTweetBoxAttachmentUploadModal(1)" to ensure the modal is open, then retry the upload

if date picker does not respond to clicks:

the date picker is a shadow-DOM web component. standard clicks do not reach it
use the shadow-root query syntax: document.querySelector('calendar-month').shadowRoot.querySelector('button[aria-label="April 20"]').click()

if scheduled time is off by 1-2 hours:

fedica operates in GMT+00 (UTC) regardless of browser timezone
convert user's local time to UTC accounting for daylight saving time offset (e.g., CEST = UTC+2, CET = UTC+1, EDT = UTC-4, EST = UTC-5)
recalculate and re-enter the time

if "Fedica Browser extension" dialog blocks the calendar page:

close with the X button or press Escape
optionally click "Don't remind me again" to suppress the nag

if running on a headless or server environment:

the first agent-browser call may fail without the --no-sandbox flag
re-run with agent-browser --args "--no-sandbox" open "https://fedica.com/dash/"

if user wants to edit or reschedule a post:

navigate to https://fedica.com/schedule/
click the target post to open its preview modal
click the pencil icon to trigger editPost()
modify text, image, or scheduled date/time as needed
click the Schedule button next to the date to re-open the date/time modal
click "Update" (not "Add to Calendar", which is for new posts only)

output contract

success state:

post appears in https://fedica.com/schedule/ calendar view with correct date and time (in GMT+00)
post preview modal displays all attached images, final text, and target platform list
no error dialogs or validation failures present
if published immediately ("Post Now"), post appears on target platforms within 30 seconds

data format:

scheduled post metadata: post ID (numeric integer), platforms list (array of X, LinkedIn, Threads, Mastodon, Bluesky), text (string, UTF-8), image URLs (array of strings, fedica-hosted), scheduled UTC datetime (ISO 8601 or human-readable)
character count: live count from fedica (grapheme count, not codepoint count; authoritative source is the NNN / 300 display in composer)

file locations:

scheduled posts: fedica backend (not exported locally unless user manually exports from https://fedica.com/schedule/)
drafts: saved to https://fedica.com/publish/drafts/ if user clicks "Save Draft" in composer (not automatic)
media library: uploaded images stored at https://fedica.com/publish/media/ (fedica-hosted, not local)

outcome signal

user knows the skill worked when:

the scheduled post appears in the fedica calendar (https://fedica.com/schedule/) under the correct date and UTC time
clicking the post opens a preview modal showing: final text, attached images (if any), target platform checkmarks, and the scheduled time converted to the user's local timezone
the user receives a mental confirmation restatement from the skill (e.g., "post scheduled for May 3 at 09:00 local time (07:00 UTC) on X, LinkedIn, Threads, Mastodon, Bluesky")
if published immediately, the post is live on all target platforms within 30 seconds
if scheduled, the post will publish at the specified UTC time on the target date (user can verify by checking each platform at the scheduled time)

key gotchas

gotcha	rule
timezone	fedica displays everything in GMT+00 (UTC) regardless of browser or user timezone. always convert user's local time to UTC before entering into fedica. example: 07:00 UTC = 09:00 Europe/Paris (CEST, summer) or 08:00 Europe/Paris (CET, winter).
bluesky limit	300 graphemes max. almost always the binding constraint, design around it first.
threads / mastodon	500 chars each. X and LinkedIn much more generous.
character counter	bottom right of composer shows `NNN / 300` (always anchored to bluesky's 300). if text exceeds a platform's limit, clicking schedule pops an error listing which platforms fail.
custom posts tab	allows per-platform versions (long linkedin + short bluesky). use when trimming to 300 kills the message.
image upload	the visible camera icon only opens a hidden input that fedica will not react to on direct upload. you must open the modal first: `openTweetBoxAttachmentUploadModal(1)`. the modal's input is `#imageUploader1` (note the trailing `1`).
schedule button	it is a split button. the primary `Schedule` label alone does not open the modal. the dropdown entry `#openScheduleButton` (labelled "Specific date") is what opens the "when to publish?" modal.
date picker	web component `<calendar-date>` containing `<calendar-month>` whose day buttons live in a shadow DOM. reach them via `document.querySelector('calendar-month').shadowRoot.querySelector('button[aria-label="April 20"]')`.
chrome extension nag	a dialog "Fedica Browser extension" pops up on the calendar page. close with its X button, or use the "Don't remind me again" link, or press Escape.
headless browser sandbox	in a headless/server environment the first `agent-browser` call needs `--args "--no-sandbox"` (or equivalent).

sensible defaults

when the user does not specify, propose and then confirm:

time: 09:00 local on the next weekday (good slot for pro-network engagement). convert to UTC before entering it into fedica.
platforms: all connected (leave every checkbox checked).
visibility: default public on each platform (fedica does not add visibility controls per post).

do not assume, always restate the final plan (text preview, platforms list, local-time schedule) and wait for explicit go before clicking the confirm button.

character counting

fedica counts graphemes, and its live NNN / 300 counter is authoritative. for an offline estimate, python codepoint count is close but undercounts some emoji (e.g. 🏛️ = two codepoints):

s = open('/tmp/post.txt').read()
print('codepoints:', len(s))
# for accurate grapheme count:
#   pip install grapheme
#   import grapheme; print(grapheme.length(s))

when you are close to the 300 limit, paste into the composer and read the live counter.

fedica endpoints

dashboard: https://fedica.com/dash/
compose: https://fedica.com/publish/
scheduled queue: https://fedica.com/schedule/
drafts: https://fedica.com/publish/drafts/
media library: https://fedica.com/publish/media/

post IDs are numeric integers. they appear in the editPost(...), delPost(...), and calendar-preview popup onclick handlers.

credits: original skill by jkobject (clawhub). enriched for implexa standards.