peak6-x-publishing-plugin 0.1.2 → 0.2.1

package/dist/worker.js

@@ -927,40 +927,46 @@ var STATE_KEYS = {
   oauthTokens: "oauth_tokens",
   rateLimits: "rate_limits"
 };
+var DEFAULT_APPROVAL_MODES = {
+  posts: "none",
+  replies: "none",
+  quotes: "none",
+  reposts: "none",
+  scheduled: "required"
+};
 var DEFAULT_CONFIG = {
   company_id: "",
-  x_handle: "",
-  x_user_id: "",
   oauth_client_id_ref: "X_OAUTH_CLIENT_ID",
   oauth_client_secret_ref: "X_OAUTH_CLIENT_SECRET",
+  default_account: "",
+  accounts: {},
   daily_post_limit: 25,
-  approval_modes: {
-    posts: "none",
-    replies: "none",
-    quotes: "none",
-    reposts: "none",
-    scheduled: "required"
-  },
   engagement_milestones: [50, 100, 500, 1e3],
   metrics_capture_lookback_days: 7,
   alert_agents: []
 };
+function accountStateKey(base, handle) {
+  return `${base}:${handle}`;
+}
 
 // src/pipeline/oauth-manager.ts
 var REFRESH_BUFFER_MS = 5 * 60 * 1e3;
 function stateKey(key) {
   return { scopeKind: "instance", stateKey: key };
 }
-async function getTokens(ctx) {
-  const raw = await ctx.state.get(stateKey(STATE_KEYS.oauthTokens));
-  if (!raw) throw new Error("No OAuth tokens in state");
+async function getTokens(ctx, handle) {
+  const raw = await ctx.state.get(stateKey(accountStateKey(STATE_KEYS.oauthTokens, handle)));
+  if (!raw) throw new Error(`No OAuth tokens in state for @${handle}`);
   return raw;
 }
-async function setTokens(ctx, tokens) {
-  await ctx.state.set(stateKey(STATE_KEYS.oauthTokens), tokens);
+async function setTokens(ctx, handle, tokens) {
+  await ctx.state.set(
+    stateKey(accountStateKey(STATE_KEYS.oauthTokens, handle)),
+    tokens
+  );
 }
-async function refreshTokens(ctx, config) {
-  const current = await getTokens(ctx);
+async function refreshTokens(ctx, config, 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 resp = await ctx.http.fetch("https://api.x.com/2/oauth2/token", {
@@ -976,7 +982,7 @@ async function refreshTokens(ctx, config) {
   });
   if (!resp.ok) {
     const text = await resp.text();
-    throw new Error(`Token refresh failed: HTTP ${resp.status} \u2014 ${text}`);
+    throw new Error(`Token refresh failed for @${handle}: HTTP ${resp.status} \u2014 ${text}`);
   }
   const body = await resp.json();
   const newTokens = {
@@ -984,13 +990,13 @@ async function refreshTokens(ctx, config) {
     refresh_token: body.refresh_token,
     expires_at: Date.now() + body.expires_in * 1e3
   };
-  await setTokens(ctx, newTokens);
+  await setTokens(ctx, handle, newTokens);
   return newTokens;
 }
-async function getValidAccessToken(ctx, config) {
-  const tokens = await getTokens(ctx);
+async function getValidAccessToken(ctx, config, handle) {
+  const tokens = await getTokens(ctx, handle);
   if (tokens.expires_at - Date.now() < REFRESH_BUFFER_MS) {
-    const refreshed = await refreshTokens(ctx, config);
+    const refreshed = await refreshTokens(ctx, config, handle);
     return refreshed.access_token;
   }
   return tokens.access_token;
@@ -1092,8 +1098,8 @@ var DEFAULT_STATE = {
   daily_posts: 0,
   daily_reset_at: 0
 };
-async function getRateLimitState(ctx) {
-  const raw = await ctx.state.get(stateKey2(STATE_KEYS.rateLimits));
+async function getRateLimitState(ctx, handle) {
+  const raw = await ctx.state.get(stateKey2(accountStateKey(STATE_KEYS.rateLimits, handle)));
   if (!raw) return { ...DEFAULT_STATE };
   const state = raw;
   if (state.daily_reset_at && Date.now() > state.daily_reset_at) {
@@ -1107,8 +1113,8 @@ function getNextMidnightMs() {
   const tomorrow = new Date(now.getFullYear(), now.getMonth(), now.getDate() + 1);
   return tomorrow.getTime();
 }
-async function updateRateLimits(ctx, endpoint, headers) {
-  const state = await getRateLimitState(ctx);
+async function updateRateLimits(ctx, handle, endpoint, headers) {
+  const state = await getRateLimitState(ctx, handle);
   state[endpoint] = {
     remaining: headers.remaining,
     reset_at: headers.reset_at
@@ -1119,12 +1125,16 @@ async function updateRateLimits(ctx, endpoint, headers) {
       state.daily_reset_at = getNextMidnightMs();
     }
   }
-  await ctx.state.set(stateKey2(STATE_KEYS.rateLimits), state);
+  await ctx.state.set(
+    stateKey2(accountStateKey(STATE_KEYS.rateLimits, handle)),
+    state
+  );
 }
 
 // src/pipeline/approval-gate.ts
-async function checkApproval(ctx, config, contentType, draftId) {
-  const mode = config.approval_modes[contentType];
+async function checkApproval(ctx, config, contentType, draftId, approvalModes) {
+  const modes = approvalModes || DEFAULT_APPROVAL_MODES;
+  const mode = modes[contentType];
   if (mode === "none") {
     return { allowed: true };
   }
@@ -1253,12 +1263,30 @@ async function getConfig(ctx) {
   const raw = await ctx.config.get();
   return { ...DEFAULT_CONFIG, ...raw };
 }
+function resolveAccount(config, handle) {
+  const accounts = config.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 account = accounts[target];
+  if (!account) {
+    return { ok: false, error: `Account @${target} not found in config. Available: ${handles.join(", ")}` };
+  }
+  return { ok: true, handle: target, account };
+}
 function findEntityById(entities, id) {
   const found = entities.find((e) => e.id === id);
   if (!found) return null;
   return { id: found.id, data: found.data, raw: found };
 }
 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);
+  if (!resolved.ok) return { error: resolved.error };
   const accessToken = params.access_token;
   const refreshToken = params.refresh_token;
   const expiresIn = params.expires_in || 7200;
@@ -1267,8 +1295,8 @@ async function handleSetupOauth(ctx, params) {
     refresh_token: refreshToken,
     expires_at: Date.now() + expiresIn * 1e3
   };
-  await setTokens(ctx, tokenState);
-  return { content: `OAuth tokens stored. Expires at ${new Date(tokenState.expires_at).toISOString()}.` };
+  await setTokens(ctx, handle, tokenState);
+  return { content: `OAuth tokens stored for @${handle}. Expires at ${new Date(tokenState.expires_at).toISOString()}.` };
 }
 async function handleDraftPost(ctx, params) {
   const text = params.text;
@@ -1355,6 +1383,9 @@ async function handleUpdateDraft(ctx, params) {
 }
 async function handlePublishPost(ctx, params) {
   const config = await getConfig(ctx);
+  const resolved = resolveAccount(config, params.account);
+  if (!resolved.ok) return { error: resolved.error };
+  const { handle, account } = resolved;
   let text = params.text;
   let metadata = params.metadata || {};
   const draftId = params.draft_id;
@@ -1366,11 +1397,11 @@ 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);
+  const approval = await checkApproval(ctx, config, "posts", draftId, account.approval_modes);
   if (!approval.allowed) return { error: `Blocked: ${approval.reason}` };
-  const token = await getValidAccessToken(ctx, config);
+  const token = await getValidAccessToken(ctx, config, handle);
   const result = await createTweet(ctx.http, token, { text });
-  await updateRateLimits(ctx, "post_tweets", result.rateLimit);
+  await updateRateLimits(ctx, handle, "post_tweets", result.rateLimit);
   const published = {
     tweet_id: result.data.id,
     text: result.data.text,
@@ -1396,14 +1427,17 @@ async function handlePublishPost(ctx, params) {
 }
 async function handleReplyToTweet(ctx, params) {
   const config = await getConfig(ctx);
+  const resolved = resolveAccount(config, 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);
+  const approval = await checkApproval(ctx, config, "replies", params.draft_id, account.approval_modes);
   if (!approval.allowed) return { error: `Blocked: ${approval.reason}` };
-  const token = await getValidAccessToken(ctx, config);
+  const token = await getValidAccessToken(ctx, config, handle);
   const result = await createTweet(ctx.http, token, { text, reply_to: tweetId });
-  await updateRateLimits(ctx, "post_tweets", result.rateLimit);
+  await updateRateLimits(ctx, handle, "post_tweets", result.rateLimit);
   const published = {
     tweet_id: result.data.id,
     text: result.data.text,
@@ -1429,14 +1463,17 @@ async function handleReplyToTweet(ctx, params) {
 }
 async function handleQuoteTweet(ctx, params) {
   const config = await getConfig(ctx);
+  const resolved = resolveAccount(config, 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);
+  const approval = await checkApproval(ctx, config, "quotes", params.draft_id, account.approval_modes);
   if (!approval.allowed) return { error: `Blocked: ${approval.reason}` };
-  const token = await getValidAccessToken(ctx, config);
+  const token = await getValidAccessToken(ctx, config, handle);
   const result = await createTweet(ctx.http, token, { text, quote_tweet_id: tweetId });
-  await updateRateLimits(ctx, "post_tweets", result.rateLimit);
+  await updateRateLimits(ctx, handle, "post_tweets", result.rateLimit);
   const published = {
     tweet_id: result.data.id,
     text: result.data.text,
@@ -1462,12 +1499,15 @@ async function handleQuoteTweet(ctx, params) {
 }
 async function handleRepost(ctx, params) {
   const config = await getConfig(ctx);
+  const resolved = resolveAccount(config, 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);
+  const approval = await checkApproval(ctx, config, "reposts", params.draft_id, account.approval_modes);
   if (!approval.allowed) return { error: `Blocked: ${approval.reason}` };
-  const token = await getValidAccessToken(ctx, config);
-  const result = await repost(ctx.http, token, config.x_user_id, tweetId);
-  await updateRateLimits(ctx, "retweets", result.rateLimit);
+  const token = await getValidAccessToken(ctx, config, 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,
     text: "",
@@ -1528,6 +1568,9 @@ async function handleSchedulePost(ctx, params) {
 }
 async function handlePublishThread(ctx, params) {
   const config = await getConfig(ctx);
+  const resolved = resolveAccount(config, params.account);
+  if (!resolved.ok) return { error: resolved.error };
+  const { handle, account } = resolved;
   let threadTweets = params.thread_tweets;
   let metadata = params.metadata || {};
   const draftId = params.draft_id;
@@ -1541,9 +1584,9 @@ 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);
+  const approval = await checkApproval(ctx, config, "posts", draftId, account.approval_modes);
   if (!approval.allowed) return { error: `Blocked: ${approval.reason}` };
-  const token = await getValidAccessToken(ctx, config);
+  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, {
     tweet_ids: result.tweetIds,
@@ -1596,60 +1639,76 @@ async function handleGetPostMetrics(ctx, params) {
     metrics: data.metrics || null
   }) };
 }
-async function handleGetAccountStatus(ctx, _params) {
+async function handleGetAccountStatus(ctx, params) {
   const config = await getConfig(ctx);
-  let tokenHealth = "unknown";
-  try {
-    const tokens = await getTokens(ctx);
-    if (tokens.expires_at > Date.now()) {
-      const minutesLeft = Math.round((tokens.expires_at - Date.now()) / 6e4);
-      tokenHealth = `valid (${minutesLeft}m remaining)`;
-    } else {
-      tokenHealth = "expired";
-    }
-  } catch {
-    tokenHealth = "no tokens stored";
-  }
-  let rateLimits = null;
-  try {
-    const raw = await ctx.state.get(stateKey3(STATE_KEYS.rateLimits));
-    if (raw) rateLimits = raw;
-  } catch {
-  }
+  const accounts = config.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 });
-  const todayCount = entities.filter((e) => {
-    const data = e.data;
-    return data.published_at.startsWith(today);
-  }).length;
-  return { content: JSON.stringify({
-    x_handle: config.x_handle,
-    token_health: tokenHealth,
-    daily_posts: { count: todayCount, limit: config.daily_post_limit },
-    rate_limits: rateLimits
-  }) };
+  const statuses = [];
+  for (const handle of handles) {
+    let tokenHealth = "unknown";
+    try {
+      const tokens = await getTokens(ctx, handle);
+      if (tokens.expires_at > Date.now()) {
+        const minutesLeft = Math.round((tokens.expires_at - Date.now()) / 6e4);
+        tokenHealth = `valid (${minutesLeft}m remaining)`;
+      } else {
+        tokenHealth = "expired";
+      }
+    } catch {
+      tokenHealth = "no tokens stored";
+    }
+    let rateLimits = null;
+    try {
+      const raw = await ctx.state.get(stateKey3(accountStateKey(STATE_KEYS.rateLimits, handle)));
+      if (raw) rateLimits = raw;
+    } catch {
+    }
+    const todayCount = entities.filter((e) => {
+      const data = e.data;
+      return data.published_at.startsWith(today);
+    }).length;
+    statuses.push({
+      x_handle: handle,
+      role: accounts[handle]?.role || "unknown",
+      token_health: tokenHealth,
+      daily_posts: { count: todayCount, limit: config.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);
-  try {
-    await refreshTokens(ctx, config);
-    ctx.logger.info("Token refresh succeeded");
-  } catch (err) {
-    ctx.logger.error("Token refresh failed", { error: String(err) });
-    const issue = await ctx.issues.create({
-      companyId: config.company_id,
-      title: "OAuth token refresh failed",
-      description: `Token refresh failed at ${(/* @__PURE__ */ new Date()).toISOString()}.
+  const handles = Object.keys(config.accounts || {});
+  for (const handle of handles) {
+    try {
+      await refreshTokens(ctx, config, 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,
+        title: `OAuth token refresh failed for @${handle}`,
+        description: `Token refresh failed for @${handle} at ${(/* @__PURE__ */ new Date()).toISOString()}.
 
 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" }, config.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 now = (/* @__PURE__ */ new Date()).toISOString();
   const entities = await ctx.entities.list({ entityType: ENTITY_TYPES.draft, limit: 100 });
   const due = entities.filter((e) => {
@@ -1658,13 +1717,13 @@ async function handlePublishScheduled(ctx, _job) {
   });
   for (const entity of due) {
     const draft = entity.data;
-    const approval = await checkApproval(ctx, config, "scheduled", entity.id);
+    const approval = await checkApproval(ctx, config, "scheduled", entity.id, resolved.account.approval_modes);
     if (!approval.allowed) {
       ctx.logger.info(`Scheduled draft ${entity.id} blocked: ${approval.reason}`);
       continue;
     }
     try {
-      const token = await getValidAccessToken(ctx, config);
+      const token = await getValidAccessToken(ctx, config, handle);
       if (draft.format === "thread" && draft.thread_tweets) {
         await publishThread(ctx, token, draft.thread_tweets, draft.metadata, config.company_id);
       } else {
@@ -1673,7 +1732,7 @@ async function handlePublishScheduled(ctx, _job) {
           reply_to: draft.reply_to_tweet_id,
           quote_tweet_id: draft.quote_tweet_id
         });
-        await updateRateLimits(ctx, "post_tweets", result.rateLimit);
+        await updateRateLimits(ctx, handle, "post_tweets", result.rateLimit);
         await ctx.entities.upsert({
           entityType: ENTITY_TYPES.publishedPost,
           scopeKind: "instance",
@@ -1711,6 +1770,12 @@ async function handlePublishScheduled(ctx, _job) {
 }
 async function handleMetricsCapture(ctx, _job) {
   const config = await getConfig(ctx);
+  const resolved = resolveAccount(config);
+  if (!resolved.ok) {
+    ctx.logger.error(resolved.error);
+    return;
+  }
+  const { handle } = resolved;
   const lookbackMs = config.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 });
@@ -1720,7 +1785,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);
+  const token = await getValidAccessToken(ctx, config, handle);
   const batchSize = 100;
   for (let i = 0; i < tweetIds.length; i += batchSize) {
     const batch = tweetIds.slice(i, i + batchSize);
@@ -1871,6 +1936,8 @@ var plugin = definePlugin({
     );
     ctx.data.register("dashboard-summary", async () => {
       const config = await getConfig(ctx);
+      const accounts = config.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 });
       const drafts = await ctx.entities.list({ entityType: ENTITY_TYPES.draft, limit: 100 });
@@ -1881,19 +1948,24 @@ var plugin = definePlugin({
         const d = e.data;
         return d.status === "draft" || d.status === "in_review" || d.status === "approved";
       });
-      let tokenHealth = "unknown";
-      try {
-        const tokens = await getTokens(ctx);
-        tokenHealth = tokens.expires_at > Date.now() ? "valid" : "expired";
-      } catch {
-        tokenHealth = "not configured";
+      const accountHealth = {};
+      for (const handle of handles) {
+        try {
+          const tokens = await getTokens(ctx, handle);
+          accountHealth[handle] = tokens.expires_at > Date.now() ? "valid" : "expired";
+        } catch {
+          accountHealth[handle] = "not configured";
+        }
       }
+      const allValid = Object.values(accountHealth).every((h) => h === "valid");
+      const tokenHealth = handles.length === 0 ? "no accounts" : allValid ? "valid" : "degraded";
       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,
         pending_drafts: pendingDrafts.length,
         token_health: tokenHealth,
+        accounts: accountHealth,
         recent_posts: recentPosts
       };
     });
@@ -1919,47 +1991,61 @@ var plugin = definePlugin({
   },
   async onHealth() {
     if (!pluginCtx) return { status: "error", message: "Plugin not initialized" };
-    const details = {};
+    const config = await getConfig(pluginCtx);
+    const accounts = config.accounts || {};
+    const handles = Object.keys(accounts);
+    if (handles.length === 0) {
+      return { status: "error", message: "No accounts configured" };
+    }
     let status = "ok";
     const issues = [];
-    try {
-      const tokens = await getTokens(pluginCtx);
-      const tokenOk = tokens.expires_at > Date.now();
-      const minutesLeft = Math.round((tokens.expires_at - Date.now()) / 6e4);
-      details.token = tokenOk ? `valid (${minutesLeft}m remaining)` : "expired";
-      if (!tokenOk) {
-        status = "degraded";
-        issues.push("Token expired");
-      }
-    } catch {
-      status = "error";
-      issues.push("No OAuth tokens configured");
-      details.token = "not configured";
-    }
-    try {
-      const raw = await pluginCtx.state.get(stateKey3(STATE_KEYS.rateLimits));
-      if (raw) {
-        const limits = raw;
-        details.rate_limits = {
-          post_tweets_remaining: limits.post_tweets?.remaining ?? "unknown",
-          daily_posts: limits.daily_posts ?? 0
-        };
-        if (limits.post_tweets && limits.post_tweets.remaining === 0 && limits.post_tweets.reset_at > Date.now()) {
+    const accountDetails = {};
+    for (const handle of handles) {
+      const detail = { role: accounts[handle].role };
+      try {
+        const tokens = await getTokens(pluginCtx, handle);
+        const tokenOk = tokens.expires_at > Date.now();
+        const minutesLeft = Math.round((tokens.expires_at - Date.now()) / 6e4);
+        detail.token = tokenOk ? `valid (${minutesLeft}m remaining)` : "expired";
+        if (!tokenOk) {
           if (status === "ok") status = "degraded";
-          issues.push("Tweet rate limit exhausted");
+          issues.push(`@${handle} token expired`);
         }
+      } catch {
+        status = "error";
+        issues.push(`@${handle} no tokens`);
+        detail.token = "not configured";
       }
-    } catch {
-      details.rate_limits = "unavailable";
+      try {
+        const raw = await pluginCtx.state.get(stateKey3(accountStateKey(STATE_KEYS.rateLimits, handle)));
+        if (raw) {
+          const limits = raw;
+          detail.rate_limits = { remaining: limits.post_tweets?.remaining ?? "unknown", daily: limits.daily_posts ?? 0 };
+          if (limits.post_tweets && limits.post_tweets.remaining === 0 && limits.post_tweets.reset_at > Date.now()) {
+            if (status === "ok") status = "degraded";
+            issues.push(`@${handle} rate limited`);
+          }
+        }
+      } catch {
+      }
+      accountDetails[handle] = detail;
     }
-    const message = issues.length > 0 ? issues.join("; ") : "All systems operational";
-    return { status, message, details };
+    const message = issues.length > 0 ? issues.join("; ") : `All ${handles.length} account(s) operational`;
+    return { status, message, details: { accounts: accountDetails } };
   },
   async onValidateConfig(config) {
     const warnings = [];
     const errors = [];
-    if (!config.x_handle) errors.push("x_handle is required");
-    if (!config.x_user_id) errors.push("x_user_id is required");
+    const accounts = config.accounts || {};
+    const handles = Object.keys(accounts);
+    if (handles.length === 0) {
+      errors.push("At least one account is required in accounts map");
+    }
+    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;
@@ -1973,10 +2059,12 @@ var plugin = definePlugin({
       } catch {
         errors.push("Could not resolve oauth_client_secret_ref secret");
       }
-      try {
-        await getTokens(pluginCtx);
-      } catch {
-        warnings.push("No OAuth tokens in state \u2014 run setup-oauth tool after configuration");
+      for (const handle of handles) {
+        try {
+          await getTokens(pluginCtx, handle);
+        } catch {
+          warnings.push(`No OAuth tokens for @${handle} \u2014 run setup-oauth tool`);
+        }
       }
     }
     return { ok: errors.length === 0, warnings, errors };