peak6-x-publishing-plugin 0.2.1 → 0.2.3

package/dist/worker.js

@@ -965,10 +965,10 @@ async function setTokens(ctx, handle, tokens) {
     tokens
   );
 }
-async function refreshTokens(ctx, config, handle) {
+async function refreshTokens(ctx, config2, handle) {
   const current = await getTokens(ctx, handle);
-  const clientId = await ctx.secrets.resolve(config.oauth_client_id_ref);
-  const clientSecret = await ctx.secrets.resolve(config.oauth_client_secret_ref);
+  const clientId = await ctx.secrets.resolve(config2.oauth_client_id_ref);
+  const clientSecret = await ctx.secrets.resolve(config2.oauth_client_secret_ref);
   const resp = await ctx.http.fetch("https://api.x.com/2/oauth2/token", {
     method: "POST",
     headers: {
@@ -993,10 +993,10 @@ async function refreshTokens(ctx, config, handle) {
   await setTokens(ctx, handle, newTokens);
   return newTokens;
 }
-async function getValidAccessToken(ctx, config, handle) {
+async function getValidAccessToken(ctx, config2, handle) {
   const tokens = await getTokens(ctx, handle);
   if (tokens.expires_at - Date.now() < REFRESH_BUFFER_MS) {
-    const refreshed = await refreshTokens(ctx, config, handle);
+    const refreshed = await refreshTokens(ctx, config2, handle);
     return refreshed.access_token;
   }
   return tokens.access_token;
@@ -1132,7 +1132,7 @@ async function updateRateLimits(ctx, handle, endpoint, headers) {
 }
 
 // src/pipeline/approval-gate.ts
-async function checkApproval(ctx, config, contentType, draftId, approvalModes) {
+async function checkApproval(ctx, config2, contentType, draftId, approvalModes) {
   const modes = approvalModes || DEFAULT_APPROVAL_MODES;
   const mode = modes[contentType];
   if (mode === "none") {
@@ -1144,14 +1144,14 @@ async function checkApproval(ctx, config, contentType, draftId, approvalModes) {
   }
   if (!draftId) {
     const issue = await ctx.issues.create({
-      companyId: config.company_id,
+      companyId: config2.company_id,
       title: `Approval required for ${contentType}`,
       description: `Content type "${contentType}" requires approval but no draft was provided for review.
 
 Create a draft first, then have it approved before publishing.`
     });
-    await ctx.issues.update(issue.id, { status: "todo" }, config.company_id);
-    await ctx.events.emit(EVENT_NAMES.approvalRequired, config.company_id, {
+    await ctx.issues.update(issue.id, { status: "todo" }, config2.company_id);
+    await ctx.events.emit(EVENT_NAMES.approvalRequired, config2.company_id, {
       content_type: contentType,
       reason: "No draft provided for required approval"
     });
@@ -1169,7 +1169,7 @@ Create a draft first, then have it approved before publishing.`
   if (draft.status !== "in_review") {
     draft.status = "in_review";
     const issue = await ctx.issues.create({
-      companyId: config.company_id,
+      companyId: config2.company_id,
       title: `Review draft: ${draft.text.slice(0, 60)}`,
       description: `Draft ID: ${draftId}
 Format: ${draft.format}
@@ -1177,7 +1177,7 @@ Format: ${draft.format}
 Text:
 ${draft.text}${draft.thread_tweets ? "\n\nThread:\n" + draft.thread_tweets.join("\n---\n") : ""}`
     });
-    await ctx.issues.update(issue.id, { status: "todo" }, config.company_id);
+    await ctx.issues.update(issue.id, { status: "todo" }, config2.company_id);
     draft.review_issue_id = issue.id;
     await ctx.entities.upsert({
       entityType: ENTITY_TYPES.draft,
@@ -1186,7 +1186,7 @@ ${draft.text}${draft.thread_tweets ? "\n\nThread:\n" + draft.thread_tweets.join(
       title: entity.title ?? draft.text.slice(0, 60),
       data: draft
     });
-    await ctx.events.emit(EVENT_NAMES.approvalRequired, config.company_id, {
+    await ctx.events.emit(EVENT_NAMES.approvalRequired, config2.company_id, {
       draft_id: draftId,
       content_type: contentType,
       reason: "Draft submitted for review"
@@ -1197,7 +1197,7 @@ ${draft.text}${draft.thread_tweets ? "\n\nThread:\n" + draft.thread_tweets.join(
 
 // src/pipeline/thread-publisher.ts
 var MAX_RETRIES = 3;
-async function publishThread(ctx, token, tweets, metadata, companyId) {
+async function publishThread(ctx, token, handle, tweets, metadata, companyId) {
   const tweetIds = [];
   let replyTo;
   for (let i = 0; i < tweets.length; i++) {
@@ -1209,11 +1209,12 @@ async function publishThread(ctx, token, tweets, metadata, companyId) {
           text,
           reply_to: replyTo
         });
-        await updateRateLimits(ctx, "post_tweets", result.rateLimit);
+        await updateRateLimits(ctx, handle, "post_tweets", result.rateLimit);
         tweetIds.push(result.data.id);
         replyTo = result.data.id;
         const published = {
           tweet_id: result.data.id,
+          account: handle,
           text: result.data.text,
           published_at: (/* @__PURE__ */ new Date()).toISOString(),
           format: "thread",
@@ -1263,13 +1264,13 @@ async function getConfig(ctx) {
   const raw = await ctx.config.get();
   return { ...DEFAULT_CONFIG, ...raw };
 }
-function resolveAccount(config, handle) {
-  const accounts = config.accounts || {};
+function resolveAccount(config2, handle) {
+  const accounts = config2.accounts || {};
   const handles = Object.keys(accounts);
   if (handles.length === 0) {
     return { ok: false, error: "No accounts configured." };
   }
-  const target = handle || config.default_account || handles[0];
+  const target = handle || config2.default_account || handles[0];
   const account = accounts[target];
   if (!account) {
     return { ok: false, error: `Account @${target} not found in config. Available: ${handles.join(", ")}` };
@@ -1284,8 +1285,8 @@ function findEntityById(entities, id) {
 async function handleSetupOauth(ctx, params) {
   const handle = params.account;
   if (!handle) return { error: "account param is required (X handle to store tokens for)." };
-  const config = await getConfig(ctx);
-  const resolved = resolveAccount(config, handle);
+  const config2 = await getConfig(ctx);
+  const resolved = resolveAccount(config2, handle);
   if (!resolved.ok) return { error: resolved.error };
   const accessToken = params.access_token;
   const refreshToken = params.refresh_token;
@@ -1303,12 +1304,13 @@ async function handleDraftPost(ctx, params) {
   if (text.length > 280) {
     return { error: `Tweet text exceeds 280 characters (${text.length}).` };
   }
-  const config = await getConfig(ctx);
+  const config2 = await getConfig(ctx);
   const format = params.format || "single";
   const metadata = params.metadata || {};
   const draft = {
     text,
     format,
+    account: params.account || config2.default_account || void 0,
     reply_to_tweet_id: params.reply_to_tweet_id,
     quote_tweet_id: params.quote_tweet_id,
     schedule_at: params.schedule_at,
@@ -1321,7 +1323,7 @@ async function handleDraftPost(ctx, params) {
     title: text.slice(0, 60),
     data: draft
   });
-  await ctx.events.emit(EVENT_NAMES.draftCreated, config.company_id, {
+  await ctx.events.emit(EVENT_NAMES.draftCreated, config2.company_id, {
     draft_id: entity.id,
     format,
     metadata
@@ -1338,11 +1340,12 @@ async function handleDraftThread(ctx, params) {
       return { error: `Tweet ${i + 1} exceeds 280 characters (${threadTweets[i].length}).` };
     }
   }
-  const config = await getConfig(ctx);
+  const config2 = await getConfig(ctx);
   const metadata = params.metadata || {};
   const draft = {
     text: threadTweets[0],
     format: "thread",
+    account: params.account || config2.default_account || void 0,
     thread_tweets: threadTweets,
     schedule_at: params.schedule_at,
     status: "draft",
@@ -1354,7 +1357,7 @@ async function handleDraftThread(ctx, params) {
     title: `Thread: ${threadTweets[0].slice(0, 50)}`,
     data: draft
   });
-  await ctx.events.emit(EVENT_NAMES.draftCreated, config.company_id, {
+  await ctx.events.emit(EVENT_NAMES.draftCreated, config2.company_id, {
     draft_id: entity.id,
     format: "thread",
     metadata
@@ -1382,8 +1385,8 @@ async function handleUpdateDraft(ctx, params) {
   return { content: JSON.stringify({ draft_id: draftId, status: "draft", updated: true }) };
 }
 async function handlePublishPost(ctx, params) {
-  const config = await getConfig(ctx);
-  const resolved = resolveAccount(config, params.account);
+  const config2 = await getConfig(ctx);
+  const resolved = resolveAccount(config2, params.account);
   if (!resolved.ok) return { error: resolved.error };
   const { handle, account } = resolved;
   let text = params.text;
@@ -1397,13 +1400,14 @@ async function handlePublishPost(ctx, params) {
     metadata = { ...match.data.metadata, ...metadata };
   }
   if (!text) return { error: "No text provided and no draft_id." };
-  const approval = await checkApproval(ctx, config, "posts", draftId, account.approval_modes);
+  const approval = await checkApproval(ctx, config2, "posts", draftId, account.approval_modes);
   if (!approval.allowed) return { error: `Blocked: ${approval.reason}` };
-  const token = await getValidAccessToken(ctx, config, handle);
+  const token = await getValidAccessToken(ctx, config2, handle);
   const result = await createTweet(ctx.http, token, { text });
   await updateRateLimits(ctx, handle, "post_tweets", result.rateLimit);
   const published = {
     tweet_id: result.data.id,
+    account: handle,
     text: result.data.text,
     published_at: (/* @__PURE__ */ new Date()).toISOString(),
     draft_id: draftId,
@@ -1417,7 +1421,7 @@ async function handlePublishPost(ctx, params) {
     title: text.slice(0, 60),
     data: published
   });
-  await ctx.events.emit(EVENT_NAMES.postPublished, config.company_id, {
+  await ctx.events.emit(EVENT_NAMES.postPublished, config2.company_id, {
     tweet_id: result.data.id,
     text,
     format: "single",
@@ -1426,20 +1430,21 @@ async function handlePublishPost(ctx, params) {
   return { content: JSON.stringify({ tweet_id: result.data.id, text: result.data.text, status: "published" }) };
 }
 async function handleReplyToTweet(ctx, params) {
-  const config = await getConfig(ctx);
-  const resolved = resolveAccount(config, params.account);
+  const config2 = await getConfig(ctx);
+  const resolved = resolveAccount(config2, params.account);
   if (!resolved.ok) return { error: resolved.error };
   const { handle, account } = resolved;
   const tweetId = params.tweet_id;
   const text = params.text;
   const metadata = params.metadata || {};
-  const approval = await checkApproval(ctx, config, "replies", params.draft_id, account.approval_modes);
+  const approval = await checkApproval(ctx, config2, "replies", params.draft_id, account.approval_modes);
   if (!approval.allowed) return { error: `Blocked: ${approval.reason}` };
-  const token = await getValidAccessToken(ctx, config, handle);
+  const token = await getValidAccessToken(ctx, config2, handle);
   const result = await createTweet(ctx.http, token, { text, reply_to: tweetId });
   await updateRateLimits(ctx, handle, "post_tweets", result.rateLimit);
   const published = {
     tweet_id: result.data.id,
+    account: handle,
     text: result.data.text,
     published_at: (/* @__PURE__ */ new Date()).toISOString(),
     draft_id: params.draft_id,
@@ -1453,7 +1458,7 @@ async function handleReplyToTweet(ctx, params) {
     title: `Reply: ${text.slice(0, 50)}`,
     data: published
   });
-  await ctx.events.emit(EVENT_NAMES.postPublished, config.company_id, {
+  await ctx.events.emit(EVENT_NAMES.postPublished, config2.company_id, {
     tweet_id: result.data.id,
     text,
     format: "reply",
@@ -1462,20 +1467,21 @@ async function handleReplyToTweet(ctx, params) {
   return { content: JSON.stringify({ tweet_id: result.data.id, text: result.data.text, status: "published", reply_to: tweetId }) };
 }
 async function handleQuoteTweet(ctx, params) {
-  const config = await getConfig(ctx);
-  const resolved = resolveAccount(config, params.account);
+  const config2 = await getConfig(ctx);
+  const resolved = resolveAccount(config2, params.account);
   if (!resolved.ok) return { error: resolved.error };
   const { handle, account } = resolved;
   const tweetId = params.tweet_id;
   const text = params.text;
   const metadata = params.metadata || {};
-  const approval = await checkApproval(ctx, config, "quotes", params.draft_id, account.approval_modes);
+  const approval = await checkApproval(ctx, config2, "quotes", params.draft_id, account.approval_modes);
   if (!approval.allowed) return { error: `Blocked: ${approval.reason}` };
-  const token = await getValidAccessToken(ctx, config, handle);
+  const token = await getValidAccessToken(ctx, config2, handle);
   const result = await createTweet(ctx.http, token, { text, quote_tweet_id: tweetId });
   await updateRateLimits(ctx, handle, "post_tweets", result.rateLimit);
   const published = {
     tweet_id: result.data.id,
+    account: handle,
     text: result.data.text,
     published_at: (/* @__PURE__ */ new Date()).toISOString(),
     draft_id: params.draft_id,
@@ -1489,7 +1495,7 @@ async function handleQuoteTweet(ctx, params) {
     title: `Quote: ${text.slice(0, 50)}`,
     data: published
   });
-  await ctx.events.emit(EVENT_NAMES.postPublished, config.company_id, {
+  await ctx.events.emit(EVENT_NAMES.postPublished, config2.company_id, {
     tweet_id: result.data.id,
     text,
     format: "quote",
@@ -1498,18 +1504,19 @@ async function handleQuoteTweet(ctx, params) {
   return { content: JSON.stringify({ tweet_id: result.data.id, text: result.data.text, status: "published", quoted: tweetId }) };
 }
 async function handleRepost(ctx, params) {
-  const config = await getConfig(ctx);
-  const resolved = resolveAccount(config, params.account);
+  const config2 = await getConfig(ctx);
+  const resolved = resolveAccount(config2, params.account);
   if (!resolved.ok) return { error: resolved.error };
   const { handle, account } = resolved;
   const tweetId = params.tweet_id;
-  const approval = await checkApproval(ctx, config, "reposts", params.draft_id, account.approval_modes);
+  const approval = await checkApproval(ctx, config2, "reposts", params.draft_id, account.approval_modes);
   if (!approval.allowed) return { error: `Blocked: ${approval.reason}` };
-  const token = await getValidAccessToken(ctx, config, handle);
+  const token = await getValidAccessToken(ctx, config2, handle);
   const result = await repost(ctx.http, token, account.x_user_id, tweetId);
   await updateRateLimits(ctx, handle, "retweets", result.rateLimit);
   const published = {
     tweet_id: tweetId,
+    account: handle,
     text: "",
     published_at: (/* @__PURE__ */ new Date()).toISOString(),
     draft_id: params.draft_id,
@@ -1523,7 +1530,7 @@ async function handleRepost(ctx, params) {
     title: `Repost: ${tweetId}`,
     data: published
   });
-  await ctx.events.emit(EVENT_NAMES.postPublished, config.company_id, {
+  await ctx.events.emit(EVENT_NAMES.postPublished, config2.company_id, {
     tweet_id: tweetId,
     text: "",
     format: "repost",
@@ -1554,6 +1561,7 @@ async function handleSchedulePost(ctx, params) {
   const draft = {
     text,
     format: "single",
+    account: params.account || config.default_account || void 0,
     schedule_at: scheduleAt,
     status: "draft",
     metadata
@@ -1567,8 +1575,8 @@ async function handleSchedulePost(ctx, params) {
   return { content: JSON.stringify({ draft_id: entity.id, schedule_at: scheduleAt, status: "scheduled" }) };
 }
 async function handlePublishThread(ctx, params) {
-  const config = await getConfig(ctx);
-  const resolved = resolveAccount(config, params.account);
+  const config2 = await getConfig(ctx);
+  const resolved = resolveAccount(config2, params.account);
   if (!resolved.ok) return { error: resolved.error };
   const { handle, account } = resolved;
   let threadTweets = params.thread_tweets;
@@ -1584,17 +1592,17 @@ async function handlePublishThread(ctx, params) {
   if (!threadTweets || threadTweets.length < 2) {
     return { error: "Thread must have at least 2 tweets." };
   }
-  const approval = await checkApproval(ctx, config, "posts", draftId, account.approval_modes);
+  const approval = await checkApproval(ctx, config2, "posts", draftId, account.approval_modes);
   if (!approval.allowed) return { error: `Blocked: ${approval.reason}` };
-  const token = await getValidAccessToken(ctx, config, handle);
-  const result = await publishThread(ctx, token, threadTweets, metadata, config.company_id);
-  await ctx.events.emit(EVENT_NAMES.threadPublished, config.company_id, {
+  const token = await getValidAccessToken(ctx, config2, handle);
+  const result = await publishThread(ctx, token, handle, threadTweets, metadata, config2.company_id);
+  await ctx.events.emit(EVENT_NAMES.threadPublished, config2.company_id, {
     tweet_ids: result.tweetIds,
     thread_length: threadTweets.length,
     partial: result.partial
   });
   for (const tweetId of result.tweetIds) {
-    await ctx.events.emit(EVENT_NAMES.postPublished, config.company_id, {
+    await ctx.events.emit(EVENT_NAMES.postPublished, config2.company_id, {
       tweet_id: tweetId,
       text: "",
       format: "thread",
@@ -1640,8 +1648,8 @@ async function handleGetPostMetrics(ctx, params) {
   }) };
 }
 async function handleGetAccountStatus(ctx, params) {
-  const config = await getConfig(ctx);
-  const accounts = config.accounts || {};
+  const config2 = await getConfig(ctx);
+  const accounts = config2.accounts || {};
   const handles = params.account ? [params.account] : Object.keys(accounts);
   const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   const entities = await ctx.entities.list({ entityType: ENTITY_TYPES.publishedPost, limit: 500 });
@@ -1667,29 +1675,29 @@ async function handleGetAccountStatus(ctx, params) {
     }
     const todayCount = entities.filter((e) => {
       const data = e.data;
-      return data.published_at.startsWith(today);
+      return data.published_at.startsWith(today) && (!data.account || data.account === handle);
     }).length;
     statuses.push({
       x_handle: handle,
       role: accounts[handle]?.role || "unknown",
       token_health: tokenHealth,
-      daily_posts: { count: todayCount, limit: config.daily_post_limit },
+      daily_posts: { count: todayCount, limit: config2.daily_post_limit },
       rate_limits: rateLimits
     });
   }
   return { content: JSON.stringify(handles.length === 1 ? statuses[0] : statuses) };
 }
 async function handleTokenRefresh(ctx, _job) {
-  const config = await getConfig(ctx);
-  const handles = Object.keys(config.accounts || {});
+  const config2 = await getConfig(ctx);
+  const handles = Object.keys(config2.accounts || {});
   for (const handle of handles) {
     try {
-      await refreshTokens(ctx, config, handle);
+      await refreshTokens(ctx, config2, handle);
       ctx.logger.info(`Token refresh succeeded for @${handle}`);
     } catch (err) {
       ctx.logger.error(`Token refresh failed for @${handle}`, { error: String(err) });
       const issue = await ctx.issues.create({
-        companyId: config.company_id,
+        companyId: config2.company_id,
         title: `OAuth token refresh failed for @${handle}`,
         description: `Token refresh failed for @${handle} at ${(/* @__PURE__ */ new Date()).toISOString()}.
 
@@ -1697,18 +1705,12 @@ Error: ${String(err)}
 
 Manual re-auth may be required via setup-oauth tool.`
       });
-      await ctx.issues.update(issue.id, { status: "todo" }, config.company_id);
+      await ctx.issues.update(issue.id, { status: "todo" }, config2.company_id);
     }
   }
 }
 async function handlePublishScheduled(ctx, _job) {
-  const config = await getConfig(ctx);
-  const resolved = resolveAccount(config);
-  if (!resolved.ok) {
-    ctx.logger.error(resolved.error);
-    return;
-  }
-  const { handle } = resolved;
+  const config2 = await getConfig(ctx);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const entities = await ctx.entities.list({ entityType: ENTITY_TYPES.draft, limit: 100 });
   const due = entities.filter((e) => {
@@ -1717,15 +1719,21 @@ async function handlePublishScheduled(ctx, _job) {
   });
   for (const entity of due) {
     const draft = entity.data;
-    const approval = await checkApproval(ctx, config, "scheduled", entity.id, resolved.account.approval_modes);
+    const resolved = resolveAccount(config2, draft.account);
+    if (!resolved.ok) {
+      ctx.logger.error(`Scheduled draft ${entity.id}: ${resolved.error}`);
+      continue;
+    }
+    const { handle, account } = resolved;
+    const approval = await checkApproval(ctx, config2, "scheduled", entity.id, account.approval_modes);
     if (!approval.allowed) {
       ctx.logger.info(`Scheduled draft ${entity.id} blocked: ${approval.reason}`);
       continue;
     }
     try {
-      const token = await getValidAccessToken(ctx, config, handle);
+      const token = await getValidAccessToken(ctx, config2, handle);
       if (draft.format === "thread" && draft.thread_tweets) {
-        await publishThread(ctx, token, draft.thread_tweets, draft.metadata, config.company_id);
+        await publishThread(ctx, token, handle, draft.thread_tweets, draft.metadata, config2.company_id);
       } else {
         const result = await createTweet(ctx.http, token, {
           text: draft.text,
@@ -1740,6 +1748,7 @@ async function handlePublishScheduled(ctx, _job) {
           title: draft.text.slice(0, 60),
           data: {
             tweet_id: result.data.id,
+            account: handle,
             text: result.data.text,
             published_at: (/* @__PURE__ */ new Date()).toISOString(),
             draft_id: entity.id,
@@ -1747,7 +1756,7 @@ async function handlePublishScheduled(ctx, _job) {
             metadata: draft.metadata
           }
         });
-        await ctx.events.emit(EVENT_NAMES.postPublished, config.company_id, {
+        await ctx.events.emit(EVENT_NAMES.postPublished, config2.company_id, {
           tweet_id: result.data.id,
           text: draft.text,
           format: draft.format,
@@ -1769,14 +1778,14 @@ async function handlePublishScheduled(ctx, _job) {
   }
 }
 async function handleMetricsCapture(ctx, _job) {
-  const config = await getConfig(ctx);
-  const resolved = resolveAccount(config);
+  const config2 = await getConfig(ctx);
+  const resolved = resolveAccount(config2);
   if (!resolved.ok) {
     ctx.logger.error(resolved.error);
     return;
   }
   const { handle } = resolved;
-  const lookbackMs = config.metrics_capture_lookback_days * 864e5;
+  const lookbackMs = config2.metrics_capture_lookback_days * 864e5;
   const cutoff = new Date(Date.now() - lookbackMs).toISOString();
   const entities = await ctx.entities.list({ entityType: ENTITY_TYPES.publishedPost, limit: 500 });
   const recent = entities.filter((e) => {
@@ -1785,7 +1794,7 @@ async function handleMetricsCapture(ctx, _job) {
   });
   if (recent.length === 0) return;
   const tweetIds = recent.map((e) => e.data.tweet_id);
-  const token = await getValidAccessToken(ctx, config, handle);
+  const token = await getValidAccessToken(ctx, config2, handle);
   const batchSize = 100;
   for (let i = 0; i < tweetIds.length; i += batchSize) {
     const batch = tweetIds.slice(i, i + batchSize);
@@ -1812,9 +1821,9 @@ async function handleMetricsCapture(ctx, _job) {
       };
       const totalEngagement = newMetrics.likes + newMetrics.retweets + newMetrics.replies;
       const prevTotal = data.metrics ? data.metrics.likes + data.metrics.retweets + data.metrics.replies : 0;
-      for (const milestone of config.engagement_milestones) {
+      for (const milestone of config2.engagement_milestones) {
         if (totalEngagement >= milestone && prevTotal < milestone) {
-          await ctx.events.emit(EVENT_NAMES.postEngagementMilestone, config.company_id, {
+          await ctx.events.emit(EVENT_NAMES.postEngagementMilestone, config2.company_id, {
             tweet_id: tweet.id,
             milestone,
             current_metrics: newMetrics
@@ -1935,8 +1944,8 @@ var plugin = definePlugin({
       (params) => handleGetAccountStatus(ctx, p(params))
     );
     ctx.data.register("dashboard-summary", async () => {
-      const config = await getConfig(ctx);
-      const accounts = config.accounts || {};
+      const config2 = await getConfig(ctx);
+      const accounts = config2.accounts || {};
       const handles = Object.keys(accounts);
       const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
       const published = await ctx.entities.list({ entityType: ENTITY_TYPES.publishedPost, limit: 100 });
@@ -1962,7 +1971,7 @@ var plugin = definePlugin({
       const recentPosts = published.map((e) => e.data).sort((a, b) => a.published_at > b.published_at ? -1 : 1).slice(0, 5);
       return {
         today_post_count: todayPosts.length,
-        daily_limit: config.daily_post_limit,
+        daily_limit: config2.daily_post_limit,
         pending_drafts: pendingDrafts.length,
         token_health: tokenHealth,
         accounts: accountHealth,
@@ -1970,8 +1979,8 @@ var plugin = definePlugin({
       };
     });
     ctx.data.register("plugin-config", async () => {
-      const config = await getConfig(ctx);
-      return config;
+      const config2 = await getConfig(ctx);
+      return config2;
     });
     ctx.data.register("content-queue", async () => {
       const allDrafts = await ctx.entities.list({ entityType: ENTITY_TYPES.draft, limit: 100 });
@@ -1991,8 +2000,8 @@ var plugin = definePlugin({
   },
   async onHealth() {
     if (!pluginCtx) return { status: "error", message: "Plugin not initialized" };
-    const config = await getConfig(pluginCtx);
-    const accounts = config.accounts || {};
+    const config2 = await getConfig(pluginCtx);
+    const accounts = config2.accounts || {};
     const handles = Object.keys(accounts);
     if (handles.length === 0) {
       return { status: "error", message: "No accounts configured" };
@@ -2033,22 +2042,26 @@ var plugin = definePlugin({
     const message = issues.length > 0 ? issues.join("; ") : `All ${handles.length} account(s) operational`;
     return { status, message, details: { accounts: accountDetails } };
   },
-  async onValidateConfig(config) {
+  async onValidateConfig(config2) {
     const warnings = [];
     const errors = [];
-    const accounts = config.accounts || {};
+    const accounts = config2.accounts || {};
     const handles = Object.keys(accounts);
     if (handles.length === 0) {
       errors.push("At least one account is required in accounts map");
     }
+    const defaultAcct = config2.default_account;
+    if (defaultAcct && handles.length > 0 && !accounts[defaultAcct]) {
+      errors.push(`default_account "${defaultAcct}" is not in the accounts map. Available: ${handles.join(", ")}`);
+    }
     for (const handle of handles) {
       const acct = accounts[handle];
       if (!acct.x_handle) errors.push(`Account ${handle}: x_handle is required`);
       if (!acct.x_user_id) errors.push(`Account ${handle}: x_user_id is required`);
     }
     if (pluginCtx) {
-      const clientIdRef = config.oauth_client_id_ref || DEFAULT_CONFIG.oauth_client_id_ref;
-      const clientSecretRef = config.oauth_client_secret_ref || DEFAULT_CONFIG.oauth_client_secret_ref;
+      const clientIdRef = config2.oauth_client_id_ref || DEFAULT_CONFIG.oauth_client_id_ref;
+      const clientSecretRef = config2.oauth_client_secret_ref || DEFAULT_CONFIG.oauth_client_secret_ref;
       try {
         await pluginCtx.secrets.resolve(clientIdRef);
       } catch {