peak6-x-publishing-plugin 0.1.2

package/dist/worker.js

@@ -0,0 +1,1990 @@
+// node_modules/.pnpm/@paperclipai+plugin-sdk@file+.paperclip-sdk+paperclipai-plugin-sdk-1.0.0.tgz_react@19.2.4/node_modules/@paperclipai/plugin-sdk/dist/define-plugin.js
+function definePlugin(definition) {
+  return Object.freeze({ definition });
+}
+
+// node_modules/.pnpm/@paperclipai+plugin-sdk@file+.paperclip-sdk+paperclipai-plugin-sdk-1.0.0.tgz_react@19.2.4/node_modules/@paperclipai/plugin-sdk/dist/worker-rpc-host.js
+import path from "node:path";
+import { createInterface } from "node:readline";
+import { fileURLToPath } from "node:url";
+
+// node_modules/.pnpm/@paperclipai+plugin-sdk@file+.paperclip-sdk+paperclipai-plugin-sdk-1.0.0.tgz_react@19.2.4/node_modules/@paperclipai/plugin-sdk/dist/protocol.js
+var JSONRPC_VERSION = "2.0";
+var JSONRPC_ERROR_CODES = {
+  /** Invalid JSON was received by the server. */
+  PARSE_ERROR: -32700,
+  /** The JSON sent is not a valid Request object. */
+  INVALID_REQUEST: -32600,
+  /** The method does not exist or is not available. */
+  METHOD_NOT_FOUND: -32601,
+  /** Invalid method parameter(s). */
+  INVALID_PARAMS: -32602,
+  /** Internal JSON-RPC error. */
+  INTERNAL_ERROR: -32603
+};
+var PLUGIN_RPC_ERROR_CODES = {
+  /** The worker process is not running or not reachable. */
+  WORKER_UNAVAILABLE: -32e3,
+  /** The plugin does not have the required capability for this operation. */
+  CAPABILITY_DENIED: -32001,
+  /** The worker reported an unhandled error during method execution. */
+  WORKER_ERROR: -32002,
+  /** The method call timed out waiting for the worker response. */
+  TIMEOUT: -32003,
+  /** The worker does not implement the requested optional method. */
+  METHOD_NOT_IMPLEMENTED: -32004,
+  /** A catch-all for errors that do not fit other categories. */
+  UNKNOWN: -32099
+};
+var _nextId = 1;
+var MAX_SAFE_RPC_ID = Number.MAX_SAFE_INTEGER - 1;
+function createRequest(method, params, id) {
+  if (_nextId >= MAX_SAFE_RPC_ID) {
+    _nextId = 1;
+  }
+  return {
+    jsonrpc: JSONRPC_VERSION,
+    id: id ?? _nextId++,
+    method,
+    params
+  };
+}
+function createSuccessResponse(id, result) {
+  return {
+    jsonrpc: JSONRPC_VERSION,
+    id,
+    result
+  };
+}
+function createErrorResponse(id, code, message, data) {
+  const response = {
+    jsonrpc: JSONRPC_VERSION,
+    id,
+    error: data !== void 0 ? { code, message, data } : { code, message }
+  };
+  return response;
+}
+function createNotification(method, params) {
+  return {
+    jsonrpc: JSONRPC_VERSION,
+    method,
+    params
+  };
+}
+function isJsonRpcRequest(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const obj = value;
+  return obj.jsonrpc === JSONRPC_VERSION && typeof obj.method === "string" && "id" in obj && obj.id !== void 0 && obj.id !== null;
+}
+function isJsonRpcNotification(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const obj = value;
+  return obj.jsonrpc === JSONRPC_VERSION && typeof obj.method === "string" && !("id" in obj);
+}
+function isJsonRpcResponse(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const obj = value;
+  return obj.jsonrpc === JSONRPC_VERSION && "id" in obj && ("result" in obj || "error" in obj);
+}
+function isJsonRpcSuccessResponse(response) {
+  return "result" in response && !("error" in response && response.error !== void 0);
+}
+function isJsonRpcErrorResponse(response) {
+  return "error" in response && response.error !== void 0;
+}
+var MESSAGE_DELIMITER = "\n";
+function serializeMessage(message) {
+  return JSON.stringify(message) + MESSAGE_DELIMITER;
+}
+function parseMessage(line) {
+  const trimmed = line.trim();
+  if (trimmed.length === 0) {
+    throw new JsonRpcParseError("Empty message");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    throw new JsonRpcParseError(`Invalid JSON: ${trimmed.slice(0, 200)}`);
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    throw new JsonRpcParseError("Message must be a JSON object");
+  }
+  const obj = parsed;
+  if (obj.jsonrpc !== JSONRPC_VERSION) {
+    throw new JsonRpcParseError(`Invalid or missing jsonrpc version (expected "${JSONRPC_VERSION}", got ${JSON.stringify(obj.jsonrpc)})`);
+  }
+  return parsed;
+}
+var JsonRpcParseError = class extends Error {
+  name = "JsonRpcParseError";
+  constructor(message) {
+    super(message);
+  }
+};
+var JsonRpcCallError = class extends Error {
+  name = "JsonRpcCallError";
+  /** The JSON-RPC error code. */
+  code;
+  /** Optional structured error data from the response. */
+  data;
+  constructor(error) {
+    super(error.message);
+    this.code = error.code;
+    this.data = error.data;
+  }
+};
+
+// node_modules/.pnpm/@paperclipai+plugin-sdk@file+.paperclip-sdk+paperclipai-plugin-sdk-1.0.0.tgz_react@19.2.4/node_modules/@paperclipai/plugin-sdk/dist/worker-rpc-host.js
+var DEFAULT_RPC_TIMEOUT_MS = 3e4;
+function runWorker(plugin2, moduleUrl, options) {
+  if (options?.stdin != null && options?.stdout != null) {
+    return startWorkerRpcHost({
+      plugin: plugin2,
+      stdin: options.stdin,
+      stdout: options.stdout
+    });
+  }
+  const entry = process.argv[1];
+  if (typeof entry !== "string")
+    return;
+  const thisFile = path.resolve(fileURLToPath(moduleUrl));
+  const entryPath = path.resolve(entry);
+  if (thisFile === entryPath) {
+    startWorkerRpcHost({ plugin: plugin2 });
+  }
+}
+function startWorkerRpcHost(options) {
+  const { plugin: plugin2 } = options;
+  const stdinStream = options.stdin ?? process.stdin;
+  const stdoutStream = options.stdout ?? process.stdout;
+  const rpcTimeoutMs = options.rpcTimeoutMs ?? DEFAULT_RPC_TIMEOUT_MS;
+  let running = true;
+  let initialized = false;
+  let manifest = null;
+  let currentConfig = {};
+  const eventHandlers = [];
+  const jobHandlers = /* @__PURE__ */ new Map();
+  const launcherRegistrations = /* @__PURE__ */ new Map();
+  const dataHandlers = /* @__PURE__ */ new Map();
+  const actionHandlers = /* @__PURE__ */ new Map();
+  const toolHandlers = /* @__PURE__ */ new Map();
+  const sessionEventCallbacks = /* @__PURE__ */ new Map();
+  const pendingRequests = /* @__PURE__ */ new Map();
+  let nextOutboundId = 1;
+  const MAX_OUTBOUND_ID = Number.MAX_SAFE_INTEGER - 1;
+  function sendMessage(message) {
+    if (!running)
+      return;
+    const serialized = serializeMessage(message);
+    stdoutStream.write(serialized);
+  }
+  function callHost(method, params, timeoutMs) {
+    return new Promise((resolve, reject) => {
+      if (!running) {
+        reject(new Error(`Cannot call "${method}" \u2014 worker RPC host is not running`));
+        return;
+      }
+      if (nextOutboundId >= MAX_OUTBOUND_ID) {
+        nextOutboundId = 1;
+      }
+      const id = nextOutboundId++;
+      const timeout = timeoutMs ?? rpcTimeoutMs;
+      let settled = false;
+      const settle = (fn, value) => {
+        if (settled)
+          return;
+        settled = true;
+        clearTimeout(timer);
+        pendingRequests.delete(id);
+        fn(value);
+      };
+      const timer = setTimeout(() => {
+        settle(reject, new JsonRpcCallError({
+          code: PLUGIN_RPC_ERROR_CODES.TIMEOUT,
+          message: `Worker\u2192host call "${method}" timed out after ${timeout}ms`
+        }));
+      }, timeout);
+      pendingRequests.set(id, {
+        resolve: (response) => {
+          if (isJsonRpcSuccessResponse(response)) {
+            settle(resolve, response.result);
+          } else if (isJsonRpcErrorResponse(response)) {
+            settle(reject, new JsonRpcCallError(response.error));
+          } else {
+            settle(reject, new Error(`Unexpected response format for "${method}"`));
+          }
+        },
+        timer
+      });
+      try {
+        const request = createRequest(method, params, id);
+        sendMessage(request);
+      } catch (err) {
+        settle(reject, err instanceof Error ? err : new Error(String(err)));
+      }
+    });
+  }
+  function notifyHost(method, params) {
+    try {
+      sendMessage(createNotification(method, params));
+    } catch {
+    }
+  }
+  function buildContext() {
+    return {
+      get manifest() {
+        if (!manifest)
+          throw new Error("Plugin context accessed before initialization");
+        return manifest;
+      },
+      config: {
+        async get() {
+          return callHost("config.get", {});
+        }
+      },
+      events: {
+        on(name, filterOrFn, maybeFn) {
+          let registration;
+          if (typeof filterOrFn === "function") {
+            registration = { name, fn: filterOrFn };
+          } else {
+            if (!maybeFn)
+              throw new Error("Event handler function is required");
+            registration = { name, filter: filterOrFn, fn: maybeFn };
+          }
+          eventHandlers.push(registration);
+          void callHost("events.subscribe", { eventPattern: name, filter: registration.filter ?? null }).catch((err) => {
+            notifyHost("log", {
+              level: "warn",
+              message: `Failed to subscribe to event "${name}" on host: ${err instanceof Error ? err.message : String(err)}`
+            });
+          });
+          return () => {
+            const idx = eventHandlers.indexOf(registration);
+            if (idx !== -1)
+              eventHandlers.splice(idx, 1);
+          };
+        },
+        async emit(name, companyId, payload) {
+          await callHost("events.emit", { name, companyId, payload });
+        }
+      },
+      jobs: {
+        register(key, fn) {
+          jobHandlers.set(key, fn);
+        }
+      },
+      launchers: {
+        register(launcher) {
+          launcherRegistrations.set(launcher.id, launcher);
+        }
+      },
+      http: {
+        async fetch(url, init) {
+          const serializedInit = {};
+          if (init) {
+            if (init.method)
+              serializedInit.method = init.method;
+            if (init.headers) {
+              if (init.headers instanceof Headers) {
+                const obj = {};
+                init.headers.forEach((v, k) => {
+                  obj[k] = v;
+                });
+                serializedInit.headers = obj;
+              } else if (Array.isArray(init.headers)) {
+                const obj = {};
+                for (const [k, v] of init.headers)
+                  obj[k] = v;
+                serializedInit.headers = obj;
+              } else {
+                serializedInit.headers = init.headers;
+              }
+            }
+            if (init.body !== void 0 && init.body !== null) {
+              serializedInit.body = typeof init.body === "string" ? init.body : String(init.body);
+            }
+          }
+          const result = await callHost("http.fetch", {
+            url,
+            init: Object.keys(serializedInit).length > 0 ? serializedInit : void 0
+          });
+          return new Response(result.body, {
+            status: result.status,
+            statusText: result.statusText,
+            headers: result.headers
+          });
+        }
+      },
+      secrets: {
+        async resolve(secretRef) {
+          return callHost("secrets.resolve", { secretRef });
+        }
+      },
+      activity: {
+        async log(entry) {
+          await callHost("activity.log", {
+            companyId: entry.companyId,
+            message: entry.message,
+            entityType: entry.entityType,
+            entityId: entry.entityId,
+            metadata: entry.metadata
+          });
+        }
+      },
+      state: {
+        async get(input) {
+          return callHost("state.get", {
+            scopeKind: input.scopeKind,
+            scopeId: input.scopeId,
+            namespace: input.namespace,
+            stateKey: input.stateKey
+          });
+        },
+        async set(input, value) {
+          await callHost("state.set", {
+            scopeKind: input.scopeKind,
+            scopeId: input.scopeId,
+            namespace: input.namespace,
+            stateKey: input.stateKey,
+            value
+          });
+        },
+        async delete(input) {
+          await callHost("state.delete", {
+            scopeKind: input.scopeKind,
+            scopeId: input.scopeId,
+            namespace: input.namespace,
+            stateKey: input.stateKey
+          });
+        }
+      },
+      entities: {
+        async upsert(input) {
+          return callHost("entities.upsert", {
+            entityType: input.entityType,
+            scopeKind: input.scopeKind,
+            scopeId: input.scopeId,
+            externalId: input.externalId,
+            title: input.title,
+            status: input.status,
+            data: input.data
+          });
+        },
+        async list(query) {
+          return callHost("entities.list", {
+            entityType: query.entityType,
+            scopeKind: query.scopeKind,
+            scopeId: query.scopeId,
+            externalId: query.externalId,
+            limit: query.limit,
+            offset: query.offset
+          });
+        }
+      },
+      projects: {
+        async list(input) {
+          return callHost("projects.list", {
+            companyId: input.companyId,
+            limit: input.limit,
+            offset: input.offset
+          });
+        },
+        async get(projectId, companyId) {
+          return callHost("projects.get", { projectId, companyId });
+        },
+        async listWorkspaces(projectId, companyId) {
+          return callHost("projects.listWorkspaces", { projectId, companyId });
+        },
+        async getPrimaryWorkspace(projectId, companyId) {
+          return callHost("projects.getPrimaryWorkspace", { projectId, companyId });
+        },
+        async getWorkspaceForIssue(issueId, companyId) {
+          return callHost("projects.getWorkspaceForIssue", { issueId, companyId });
+        }
+      },
+      companies: {
+        async list(input) {
+          return callHost("companies.list", {
+            limit: input?.limit,
+            offset: input?.offset
+          });
+        },
+        async get(companyId) {
+          return callHost("companies.get", { companyId });
+        }
+      },
+      issues: {
+        async list(input) {
+          return callHost("issues.list", {
+            companyId: input.companyId,
+            projectId: input.projectId,
+            assigneeAgentId: input.assigneeAgentId,
+            status: input.status,
+            limit: input.limit,
+            offset: input.offset
+          });
+        },
+        async get(issueId, companyId) {
+          return callHost("issues.get", { issueId, companyId });
+        },
+        async create(input) {
+          return callHost("issues.create", {
+            companyId: input.companyId,
+            projectId: input.projectId,
+            goalId: input.goalId,
+            parentId: input.parentId,
+            title: input.title,
+            description: input.description,
+            priority: input.priority,
+            assigneeAgentId: input.assigneeAgentId
+          });
+        },
+        async update(issueId, patch, companyId) {
+          return callHost("issues.update", {
+            issueId,
+            patch,
+            companyId
+          });
+        },
+        async listComments(issueId, companyId) {
+          return callHost("issues.listComments", { issueId, companyId });
+        },
+        async createComment(issueId, body, companyId) {
+          return callHost("issues.createComment", { issueId, body, companyId });
+        },
+        documents: {
+          async list(issueId, companyId) {
+            return callHost("issues.documents.list", { issueId, companyId });
+          },
+          async get(issueId, key, companyId) {
+            return callHost("issues.documents.get", { issueId, key, companyId });
+          },
+          async upsert(input) {
+            return callHost("issues.documents.upsert", {
+              issueId: input.issueId,
+              key: input.key,
+              body: input.body,
+              companyId: input.companyId,
+              title: input.title,
+              format: input.format,
+              changeSummary: input.changeSummary
+            });
+          },
+          async delete(issueId, key, companyId) {
+            return callHost("issues.documents.delete", { issueId, key, companyId });
+          }
+        }
+      },
+      agents: {
+        async list(input) {
+          return callHost("agents.list", {
+            companyId: input.companyId,
+            status: input.status,
+            limit: input.limit,
+            offset: input.offset
+          });
+        },
+        async get(agentId, companyId) {
+          return callHost("agents.get", { agentId, companyId });
+        },
+        async pause(agentId, companyId) {
+          return callHost("agents.pause", { agentId, companyId });
+        },
+        async resume(agentId, companyId) {
+          return callHost("agents.resume", { agentId, companyId });
+        },
+        async invoke(agentId, companyId, opts) {
+          return callHost("agents.invoke", { agentId, companyId, prompt: opts.prompt, reason: opts.reason });
+        },
+        sessions: {
+          async create(agentId, companyId, opts) {
+            return callHost("agents.sessions.create", {
+              agentId,
+              companyId,
+              taskKey: opts?.taskKey,
+              reason: opts?.reason
+            });
+          },
+          async list(agentId, companyId) {
+            return callHost("agents.sessions.list", { agentId, companyId });
+          },
+          async sendMessage(sessionId, companyId, opts) {
+            if (opts.onEvent) {
+              sessionEventCallbacks.set(sessionId, opts.onEvent);
+            }
+            try {
+              return await callHost("agents.sessions.sendMessage", {
+                sessionId,
+                companyId,
+                prompt: opts.prompt,
+                reason: opts.reason
+              });
+            } catch (err) {
+              sessionEventCallbacks.delete(sessionId);
+              throw err;
+            }
+          },
+          async close(sessionId, companyId) {
+            sessionEventCallbacks.delete(sessionId);
+            await callHost("agents.sessions.close", { sessionId, companyId });
+          }
+        }
+      },
+      goals: {
+        async list(input) {
+          return callHost("goals.list", {
+            companyId: input.companyId,
+            level: input.level,
+            status: input.status,
+            limit: input.limit,
+            offset: input.offset
+          });
+        },
+        async get(goalId, companyId) {
+          return callHost("goals.get", { goalId, companyId });
+        },
+        async create(input) {
+          return callHost("goals.create", {
+            companyId: input.companyId,
+            title: input.title,
+            description: input.description,
+            level: input.level,
+            status: input.status,
+            parentId: input.parentId,
+            ownerAgentId: input.ownerAgentId
+          });
+        },
+        async update(goalId, patch, companyId) {
+          return callHost("goals.update", {
+            goalId,
+            patch,
+            companyId
+          });
+        }
+      },
+      data: {
+        register(key, handler) {
+          dataHandlers.set(key, handler);
+        }
+      },
+      actions: {
+        register(key, handler) {
+          actionHandlers.set(key, handler);
+        }
+      },
+      streams: /* @__PURE__ */ (() => {
+        const channelCompanyMap = /* @__PURE__ */ new Map();
+        return {
+          open(channel, companyId) {
+            channelCompanyMap.set(channel, companyId);
+            notifyHost("streams.open", { channel, companyId });
+          },
+          emit(channel, event) {
+            const companyId = channelCompanyMap.get(channel) ?? "";
+            notifyHost("streams.emit", { channel, companyId, event });
+          },
+          close(channel) {
+            const companyId = channelCompanyMap.get(channel) ?? "";
+            channelCompanyMap.delete(channel);
+            notifyHost("streams.close", { channel, companyId });
+          }
+        };
+      })(),
+      tools: {
+        register(name, declaration, fn) {
+          toolHandlers.set(name, { declaration, fn });
+        }
+      },
+      metrics: {
+        async write(name, value, tags) {
+          await callHost("metrics.write", { name, value, tags });
+        }
+      },
+      logger: {
+        info(message, meta) {
+          notifyHost("log", { level: "info", message, meta });
+        },
+        warn(message, meta) {
+          notifyHost("log", { level: "warn", message, meta });
+        },
+        error(message, meta) {
+          notifyHost("log", { level: "error", message, meta });
+        },
+        debug(message, meta) {
+          notifyHost("log", { level: "debug", message, meta });
+        }
+      }
+    };
+  }
+  const ctx = buildContext();
+  async function handleHostRequest(request) {
+    const { id, method, params } = request;
+    try {
+      const result = await dispatchMethod(method, params);
+      sendMessage(createSuccessResponse(id, result ?? null));
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      const errorCode = typeof err?.code === "number" ? err.code : PLUGIN_RPC_ERROR_CODES.WORKER_ERROR;
+      sendMessage(createErrorResponse(id, errorCode, errorMessage));
+    }
+  }
+  async function dispatchMethod(method, params) {
+    switch (method) {
+      case "initialize":
+        return handleInitialize(params);
+      case "health":
+        return handleHealth();
+      case "shutdown":
+        return handleShutdown();
+      case "validateConfig":
+        return handleValidateConfig(params);
+      case "configChanged":
+        return handleConfigChanged(params);
+      case "onEvent":
+        return handleOnEvent(params);
+      case "runJob":
+        return handleRunJob(params);
+      case "handleWebhook":
+        return handleWebhook(params);
+      case "getData":
+        return handleGetData(params);
+      case "performAction":
+        return handlePerformAction(params);
+      case "executeTool":
+        return handleExecuteTool(params);
+      default:
+        throw Object.assign(new Error(`Unknown method: ${method}`), { code: JSONRPC_ERROR_CODES.METHOD_NOT_FOUND });
+    }
+  }
+  async function handleInitialize(params) {
+    if (initialized) {
+      throw new Error("Worker already initialized");
+    }
+    manifest = params.manifest;
+    currentConfig = params.config;
+    await plugin2.definition.setup(ctx);
+    initialized = true;
+    const supportedMethods = [];
+    if (plugin2.definition.onValidateConfig)
+      supportedMethods.push("validateConfig");
+    if (plugin2.definition.onConfigChanged)
+      supportedMethods.push("configChanged");
+    if (plugin2.definition.onHealth)
+      supportedMethods.push("health");
+    if (plugin2.definition.onShutdown)
+      supportedMethods.push("shutdown");
+    return { ok: true, supportedMethods };
+  }
+  async function handleHealth() {
+    if (plugin2.definition.onHealth) {
+      return plugin2.definition.onHealth();
+    }
+    return { status: "ok" };
+  }
+  async function handleShutdown() {
+    if (plugin2.definition.onShutdown) {
+      await plugin2.definition.onShutdown();
+    }
+    setImmediate(() => {
+      cleanup();
+      if (!options.stdin && !options.stdout) {
+        process.exit(0);
+      }
+    });
+  }
+  async function handleValidateConfig(params) {
+    if (!plugin2.definition.onValidateConfig) {
+      throw Object.assign(new Error("validateConfig is not implemented by this plugin"), { code: PLUGIN_RPC_ERROR_CODES.METHOD_NOT_IMPLEMENTED });
+    }
+    return plugin2.definition.onValidateConfig(params.config);
+  }
+  async function handleConfigChanged(params) {
+    currentConfig = params.config;
+    if (plugin2.definition.onConfigChanged) {
+      await plugin2.definition.onConfigChanged(params.config);
+    }
+  }
+  async function handleOnEvent(params) {
+    const event = params.event;
+    for (const registration of eventHandlers) {
+      const exactMatch = registration.name === event.eventType;
+      const wildcardPluginAll = registration.name === "plugin.*" && event.eventType.startsWith("plugin.");
+      const wildcardPluginOne = registration.name.endsWith(".*") && event.eventType.startsWith(registration.name.slice(0, -1));
+      if (!exactMatch && !wildcardPluginAll && !wildcardPluginOne)
+        continue;
+      if (registration.filter && !allowsEvent(registration.filter, event))
+        continue;
+      try {
+        await registration.fn(event);
+      } catch (err) {
+        notifyHost("log", {
+          level: "error",
+          message: `Event handler for "${registration.name}" failed: ${err instanceof Error ? err.message : String(err)}`,
+          meta: { eventType: event.eventType, stack: err instanceof Error ? err.stack : void 0 }
+        });
+      }
+    }
+  }
+  async function handleRunJob(params) {
+    const handler = jobHandlers.get(params.job.jobKey);
+    if (!handler) {
+      throw new Error(`No handler registered for job "${params.job.jobKey}"`);
+    }
+    await handler(params.job);
+  }
+  async function handleWebhook(params) {
+    if (!plugin2.definition.onWebhook) {
+      throw Object.assign(new Error("handleWebhook is not implemented by this plugin"), { code: PLUGIN_RPC_ERROR_CODES.METHOD_NOT_IMPLEMENTED });
+    }
+    await plugin2.definition.onWebhook(params);
+  }
+  async function handleGetData(params) {
+    const handler = dataHandlers.get(params.key);
+    if (!handler) {
+      throw new Error(`No data handler registered for key "${params.key}"`);
+    }
+    return handler(params.renderEnvironment === void 0 ? params.params : { ...params.params, renderEnvironment: params.renderEnvironment });
+  }
+  async function handlePerformAction(params) {
+    const handler = actionHandlers.get(params.key);
+    if (!handler) {
+      throw new Error(`No action handler registered for key "${params.key}"`);
+    }
+    return handler(params.renderEnvironment === void 0 ? params.params : { ...params.params, renderEnvironment: params.renderEnvironment });
+  }
+  async function handleExecuteTool(params) {
+    const entry = toolHandlers.get(params.toolName);
+    if (!entry) {
+      throw new Error(`No tool handler registered for "${params.toolName}"`);
+    }
+    return entry.fn(params.parameters, params.runContext);
+  }
+  function allowsEvent(filter, event) {
+    const payload = event.payload;
+    if (filter.companyId !== void 0) {
+      const companyId = event.companyId ?? String(payload?.companyId ?? "");
+      if (companyId !== filter.companyId)
+        return false;
+    }
+    if (filter.projectId !== void 0) {
+      const projectId = event.entityType === "project" ? event.entityId : String(payload?.projectId ?? "");
+      if (projectId !== filter.projectId)
+        return false;
+    }
+    if (filter.agentId !== void 0) {
+      const agentId = event.entityType === "agent" ? event.entityId : String(payload?.agentId ?? "");
+      if (agentId !== filter.agentId)
+        return false;
+    }
+    return true;
+  }
+  function handleHostResponse(response) {
+    const id = response.id;
+    if (id === null || id === void 0)
+      return;
+    const pending = pendingRequests.get(id);
+    if (!pending)
+      return;
+    clearTimeout(pending.timer);
+    pendingRequests.delete(id);
+    pending.resolve(response);
+  }
+  function handleLine(line) {
+    if (!line.trim())
+      return;
+    let message;
+    try {
+      message = parseMessage(line);
+    } catch (err) {
+      if (err instanceof JsonRpcParseError) {
+        sendMessage(createErrorResponse(null, JSONRPC_ERROR_CODES.PARSE_ERROR, `Parse error: ${err.message}`));
+      }
+      return;
+    }
+    if (isJsonRpcResponse(message)) {
+      handleHostResponse(message);
+    } else if (isJsonRpcRequest(message)) {
+      handleHostRequest(message).catch((err) => {
+        const errorMessage = err instanceof Error ? err.message : String(err);
+        const errorCode = err?.code ?? PLUGIN_RPC_ERROR_CODES.WORKER_ERROR;
+        try {
+          sendMessage(createErrorResponse(message.id, typeof errorCode === "number" ? errorCode : PLUGIN_RPC_ERROR_CODES.WORKER_ERROR, errorMessage));
+        } catch {
+        }
+      });
+    } else if (isJsonRpcNotification(message)) {
+      const notif = message;
+      if (notif.method === "agents.sessions.event" && notif.params) {
+        const event = notif.params;
+        const cb = sessionEventCallbacks.get(event.sessionId);
+        if (cb)
+          cb(event);
+      } else if (notif.method === "onEvent" && notif.params) {
+        handleOnEvent(notif.params).catch((err) => {
+          notifyHost("log", {
+            level: "error",
+            message: `Failed to handle event notification: ${err instanceof Error ? err.message : String(err)}`
+          });
+        });
+      }
+    }
+  }
+  function cleanup() {
+    running = false;
+    if (readline) {
+      readline.close();
+      readline = null;
+    }
+    for (const [id, pending] of pendingRequests) {
+      clearTimeout(pending.timer);
+      pending.resolve(createErrorResponse(id, PLUGIN_RPC_ERROR_CODES.WORKER_UNAVAILABLE, "Worker RPC host is shutting down"));
+    }
+    pendingRequests.clear();
+    sessionEventCallbacks.clear();
+  }
+  let readline = createInterface({
+    input: stdinStream,
+    crlfDelay: Infinity
+  });
+  readline.on("line", handleLine);
+  readline.on("close", () => {
+    if (running) {
+      cleanup();
+      if (!options.stdin && !options.stdout) {
+        process.exit(0);
+      }
+    }
+  });
+  if (!options.stdin && !options.stdout) {
+    process.on("uncaughtException", (err) => {
+      notifyHost("log", {
+        level: "error",
+        message: `Uncaught exception: ${err.message}`,
+        meta: { stack: err.stack }
+      });
+      setTimeout(() => process.exit(1), 100);
+    });
+    process.on("unhandledRejection", (reason) => {
+      const message = reason instanceof Error ? reason.message : String(reason);
+      const stack = reason instanceof Error ? reason.stack : void 0;
+      notifyHost("log", {
+        level: "error",
+        message: `Unhandled rejection: ${message}`,
+        meta: { stack }
+      });
+    });
+  }
+  return {
+    get running() {
+      return running;
+    },
+    stop() {
+      cleanup();
+    }
+  };
+}
+
+// src/constants.ts
+var TOOL_NAMES = {
+  draftPost: "draft-post",
+  updateDraft: "update-draft",
+  publishPost: "publish-post",
+  replyToTweet: "reply-to-tweet",
+  quoteTweet: "quote-tweet",
+  repost: "repost",
+  schedulePost: "schedule-post",
+  publishThread: "publish-thread",
+  draftThread: "draft-thread",
+  getDrafts: "get-drafts",
+  getSchedule: "get-schedule",
+  getPostMetrics: "get-post-metrics",
+  getAccountStatus: "get-account-status",
+  setupOauth: "setup-oauth"
+};
+var JOB_KEYS = {
+  tokenRefresh: "token-refresh",
+  publishScheduled: "publish-scheduled",
+  metricsCapture: "metrics-capture",
+  staleDraftCleanup: "stale-draft-cleanup"
+};
+var ENTITY_TYPES = {
+  draft: "draft",
+  publishedPost: "published-post"
+};
+var EVENT_NAMES = {
+  postPublished: "post.published",
+  draftCreated: "draft.created",
+  approvalRequired: "approval.required",
+  postEngagementMilestone: "post.engagement-milestone",
+  threadPublished: "thread.published"
+};
+var STATE_KEYS = {
+  oauthTokens: "oauth_tokens",
+  rateLimits: "rate_limits"
+};
+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",
+  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: []
+};
+
+// 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");
+  return raw;
+}
+async function setTokens(ctx, tokens) {
+  await ctx.state.set(stateKey(STATE_KEYS.oauthTokens), tokens);
+}
+async function refreshTokens(ctx, config) {
+  const current = await getTokens(ctx);
+  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", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded",
+      Authorization: `Basic ${btoa(`${clientId}:${clientSecret}`)}`
+    },
+    body: new URLSearchParams({
+      grant_type: "refresh_token",
+      refresh_token: current.refresh_token
+    }).toString()
+  });
+  if (!resp.ok) {
+    const text = await resp.text();
+    throw new Error(`Token refresh failed: HTTP ${resp.status} \u2014 ${text}`);
+  }
+  const body = await resp.json();
+  const newTokens = {
+    access_token: body.access_token,
+    refresh_token: body.refresh_token,
+    expires_at: Date.now() + body.expires_in * 1e3
+  };
+  await setTokens(ctx, newTokens);
+  return newTokens;
+}
+async function getValidAccessToken(ctx, config) {
+  const tokens = await getTokens(ctx);
+  if (tokens.expires_at - Date.now() < REFRESH_BUFFER_MS) {
+    const refreshed = await refreshTokens(ctx, config);
+    return refreshed.access_token;
+  }
+  return tokens.access_token;
+}
+
+// src/pipeline/x-api-write-client.ts
+function parseRateLimitHeaders(headers) {
+  const remaining = parseInt(headers.get("x-rate-limit-remaining") || "99", 10);
+  const resetEpoch = parseInt(headers.get("x-rate-limit-reset") || "0", 10);
+  return {
+    remaining,
+    reset_at: resetEpoch * 1e3
+    // X API returns epoch seconds
+  };
+}
+async function withRetry(fn, maxRetries = 2) {
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (attempt < maxRetries && message.includes("429")) {
+        const backoffMs = Math.pow(2, attempt + 1) * 1e3;
+        await new Promise((r) => setTimeout(r, backoffMs));
+        continue;
+      }
+      throw err;
+    }
+  }
+  throw new Error("Unreachable");
+}
+async function createTweet(http, token, params) {
+  return withRetry(async () => {
+    const body = { text: params.text };
+    if (params.reply_to) {
+      body.reply = { in_reply_to_tweet_id: params.reply_to };
+    }
+    if (params.quote_tweet_id) {
+      body.quote_tweet_id = params.quote_tweet_id;
+    }
+    if (params.media_ids && params.media_ids.length > 0) {
+      body.media = { media_ids: params.media_ids };
+    }
+    const resp = await http.fetch("https://api.x.com/2/tweets", {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body)
+    });
+    if (resp.status === 429) {
+      throw new Error("429 Rate limited");
+    }
+    if (resp.status !== 201) {
+      const text = await resp.text();
+      throw new Error(`Create tweet failed: HTTP ${resp.status} \u2014 ${text}`);
+    }
+    const json = await resp.json();
+    return {
+      data: json.data,
+      rateLimit: parseRateLimitHeaders(resp.headers)
+    };
+  });
+}
+async function repost(http, token, userId, tweetId) {
+  return withRetry(async () => {
+    const resp = await http.fetch(`https://api.x.com/2/users/${userId}/retweets`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ tweet_id: tweetId })
+    });
+    if (resp.status === 429) {
+      throw new Error("429 Rate limited");
+    }
+    if (resp.status !== 200) {
+      const text = await resp.text();
+      throw new Error(`Repost failed: HTTP ${resp.status} \u2014 ${text}`);
+    }
+    const json = await resp.json();
+    return {
+      data: json.data,
+      rateLimit: parseRateLimitHeaders(resp.headers)
+    };
+  });
+}
+
+// src/pipeline/rate-limiter.ts
+function stateKey2(key) {
+  return { scopeKind: "instance", stateKey: key };
+}
+var DEFAULT_STATE = {
+  post_tweets: { remaining: 99, reset_at: 0 },
+  delete_tweets: { remaining: 99, reset_at: 0 },
+  retweets: { remaining: 99, reset_at: 0 },
+  daily_posts: 0,
+  daily_reset_at: 0
+};
+async function getRateLimitState(ctx) {
+  const raw = await ctx.state.get(stateKey2(STATE_KEYS.rateLimits));
+  if (!raw) return { ...DEFAULT_STATE };
+  const state = raw;
+  if (state.daily_reset_at && Date.now() > state.daily_reset_at) {
+    state.daily_posts = 0;
+    state.daily_reset_at = getNextMidnightMs();
+  }
+  return state;
+}
+function getNextMidnightMs() {
+  const now = /* @__PURE__ */ new Date();
+  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);
+  state[endpoint] = {
+    remaining: headers.remaining,
+    reset_at: headers.reset_at
+  };
+  if (endpoint === "post_tweets") {
+    state.daily_posts++;
+    if (!state.daily_reset_at) {
+      state.daily_reset_at = getNextMidnightMs();
+    }
+  }
+  await ctx.state.set(stateKey2(STATE_KEYS.rateLimits), state);
+}
+
+// src/pipeline/approval-gate.ts
+async function checkApproval(ctx, config, contentType, draftId) {
+  const mode = config.approval_modes[contentType];
+  if (mode === "none") {
+    return { allowed: true };
+  }
+  if (mode === "optional") {
+    ctx.logger.info(`Approval optional for ${contentType}, proceeding`);
+    return { allowed: true };
+  }
+  if (!draftId) {
+    const issue = await ctx.issues.create({
+      companyId: config.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, {
+      content_type: contentType,
+      reason: "No draft provided for required approval"
+    });
+    return { allowed: false, reason: `Approval required for ${contentType}. Create a draft and get it approved first.` };
+  }
+  const allDrafts = await ctx.entities.list({ entityType: ENTITY_TYPES.draft, limit: 500 });
+  const entity = allDrafts.find((e) => e.id === draftId);
+  if (!entity) {
+    return { allowed: false, reason: `Draft ${draftId} not found.` };
+  }
+  const draft = entity.data;
+  if (draft.status === "approved") {
+    return { allowed: true };
+  }
+  if (draft.status !== "in_review") {
+    draft.status = "in_review";
+    const issue = await ctx.issues.create({
+      companyId: config.company_id,
+      title: `Review draft: ${draft.text.slice(0, 60)}`,
+      description: `Draft ID: ${draftId}
+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);
+    draft.review_issue_id = issue.id;
+    await ctx.entities.upsert({
+      entityType: ENTITY_TYPES.draft,
+      scopeKind: "instance",
+      externalId: entity.externalId ?? void 0,
+      title: entity.title ?? draft.text.slice(0, 60),
+      data: draft
+    });
+    await ctx.events.emit(EVENT_NAMES.approvalRequired, config.company_id, {
+      draft_id: draftId,
+      content_type: contentType,
+      reason: "Draft submitted for review"
+    });
+  }
+  return { allowed: false, reason: `Draft ${draftId} is ${draft.status}. Approval required before publishing.` };
+}
+
+// src/pipeline/thread-publisher.ts
+var MAX_RETRIES = 3;
+async function publishThread(ctx, token, tweets, metadata, companyId) {
+  const tweetIds = [];
+  let replyTo;
+  for (let i = 0; i < tweets.length; i++) {
+    const text = tweets[i];
+    let posted = false;
+    for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+      try {
+        const result = await createTweet(ctx.http, token, {
+          text,
+          reply_to: replyTo
+        });
+        await updateRateLimits(ctx, "post_tweets", result.rateLimit);
+        tweetIds.push(result.data.id);
+        replyTo = result.data.id;
+        const published = {
+          tweet_id: result.data.id,
+          text: result.data.text,
+          published_at: (/* @__PURE__ */ new Date()).toISOString(),
+          format: "thread",
+          thread_tweet_ids: tweetIds.slice(),
+          metadata
+        };
+        await ctx.entities.upsert({
+          entityType: ENTITY_TYPES.publishedPost,
+          scopeKind: "instance",
+          externalId: result.data.id,
+          title: `Thread ${i + 1}/${tweets.length}: ${text.slice(0, 40)}`,
+          data: published
+        });
+        posted = true;
+        break;
+      } catch (err) {
+        ctx.logger.error(`Thread tweet ${i + 1}/${tweets.length} attempt ${attempt + 1} failed`, { error: String(err) });
+        if (attempt < MAX_RETRIES - 1) {
+          await new Promise((r) => setTimeout(r, Math.pow(2, attempt + 1) * 1e3));
+        }
+      }
+    }
+    if (!posted) {
+      const issue = await ctx.issues.create({
+        companyId,
+        title: `Thread publish failed at tweet ${i + 1}/${tweets.length}`,
+        description: `Thread was partially published.
+
+Published tweet IDs: ${tweetIds.join(", ")}
+
+Failed tweet text: ${text}
+
+Remaining tweets: ${tweets.length - i}`
+      });
+      await ctx.issues.update(issue.id, { status: "todo" }, companyId);
+      return { tweetIds, partial: true };
+    }
+  }
+  return { tweetIds, partial: false };
+}
+
+// src/worker.ts
+function stateKey3(key) {
+  return { scopeKind: "instance", stateKey: key };
+}
+async function getConfig(ctx) {
+  const raw = await ctx.config.get();
+  return { ...DEFAULT_CONFIG, ...raw };
+}
+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 accessToken = params.access_token;
+  const refreshToken = params.refresh_token;
+  const expiresIn = params.expires_in || 7200;
+  const tokenState = {
+    access_token: accessToken,
+    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()}.` };
+}
+async function handleDraftPost(ctx, params) {
+  const text = params.text;
+  if (text.length > 280) {
+    return { error: `Tweet text exceeds 280 characters (${text.length}).` };
+  }
+  const config = await getConfig(ctx);
+  const format = params.format || "single";
+  const metadata = params.metadata || {};
+  const draft = {
+    text,
+    format,
+    reply_to_tweet_id: params.reply_to_tweet_id,
+    quote_tweet_id: params.quote_tweet_id,
+    schedule_at: params.schedule_at,
+    status: "draft",
+    metadata
+  };
+  const entity = await ctx.entities.upsert({
+    entityType: ENTITY_TYPES.draft,
+    scopeKind: "instance",
+    title: text.slice(0, 60),
+    data: draft
+  });
+  await ctx.events.emit(EVENT_NAMES.draftCreated, config.company_id, {
+    draft_id: entity.id,
+    format,
+    metadata
+  });
+  return { content: JSON.stringify({ draft_id: entity.id, status: "draft", format }) };
+}
+async function handleDraftThread(ctx, params) {
+  const threadTweets = params.thread_tweets;
+  if (!threadTweets || threadTweets.length < 2) {
+    return { error: "Thread must have at least 2 tweets." };
+  }
+  for (let i = 0; i < threadTweets.length; i++) {
+    if (threadTweets[i].length > 280) {
+      return { error: `Tweet ${i + 1} exceeds 280 characters (${threadTweets[i].length}).` };
+    }
+  }
+  const config = await getConfig(ctx);
+  const metadata = params.metadata || {};
+  const draft = {
+    text: threadTweets[0],
+    format: "thread",
+    thread_tweets: threadTweets,
+    schedule_at: params.schedule_at,
+    status: "draft",
+    metadata
+  };
+  const entity = await ctx.entities.upsert({
+    entityType: ENTITY_TYPES.draft,
+    scopeKind: "instance",
+    title: `Thread: ${threadTweets[0].slice(0, 50)}`,
+    data: draft
+  });
+  await ctx.events.emit(EVENT_NAMES.draftCreated, config.company_id, {
+    draft_id: entity.id,
+    format: "thread",
+    metadata
+  });
+  return { content: JSON.stringify({ draft_id: entity.id, status: "draft", format: "thread", tweet_count: threadTweets.length }) };
+}
+async function handleUpdateDraft(ctx, params) {
+  const draftId = params.draft_id;
+  const entities = await ctx.entities.list({ entityType: ENTITY_TYPES.draft, limit: 500 });
+  const match = findEntityById(entities, draftId);
+  if (!match) return { error: `Draft ${draftId} not found.` };
+  const data = match.data;
+  if (params.text !== void 0) data.text = params.text;
+  if (params.thread_tweets !== void 0) data.thread_tweets = params.thread_tweets;
+  if (params.schedule_at !== void 0) data.schedule_at = params.schedule_at;
+  if (params.metadata !== void 0) data.metadata = { ...data.metadata, ...params.metadata };
+  data.status = "draft";
+  await ctx.entities.upsert({
+    entityType: ENTITY_TYPES.draft,
+    scopeKind: "instance",
+    externalId: match.raw.externalId ?? void 0,
+    title: data.text.slice(0, 60),
+    data
+  });
+  return { content: JSON.stringify({ draft_id: draftId, status: "draft", updated: true }) };
+}
+async function handlePublishPost(ctx, params) {
+  const config = await getConfig(ctx);
+  let text = params.text;
+  let metadata = params.metadata || {};
+  const draftId = params.draft_id;
+  if (draftId) {
+    const entities = await ctx.entities.list({ entityType: ENTITY_TYPES.draft, limit: 500 });
+    const match = findEntityById(entities, draftId);
+    if (!match) return { error: `Draft ${draftId} not found.` };
+    text = match.data.text;
+    metadata = { ...match.data.metadata, ...metadata };
+  }
+  if (!text) return { error: "No text provided and no draft_id." };
+  const approval = await checkApproval(ctx, config, "posts", draftId);
+  if (!approval.allowed) return { error: `Blocked: ${approval.reason}` };
+  const token = await getValidAccessToken(ctx, config);
+  const result = await createTweet(ctx.http, token, { text });
+  await updateRateLimits(ctx, "post_tweets", result.rateLimit);
+  const published = {
+    tweet_id: result.data.id,
+    text: result.data.text,
+    published_at: (/* @__PURE__ */ new Date()).toISOString(),
+    draft_id: draftId,
+    format: "single",
+    metadata
+  };
+  await ctx.entities.upsert({
+    entityType: ENTITY_TYPES.publishedPost,
+    scopeKind: "instance",
+    externalId: result.data.id,
+    title: text.slice(0, 60),
+    data: published
+  });
+  await ctx.events.emit(EVENT_NAMES.postPublished, config.company_id, {
+    tweet_id: result.data.id,
+    text,
+    format: "single",
+    metadata
+  });
+  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 tweetId = params.tweet_id;
+  const text = params.text;
+  const metadata = params.metadata || {};
+  const approval = await checkApproval(ctx, config, "replies", params.draft_id);
+  if (!approval.allowed) return { error: `Blocked: ${approval.reason}` };
+  const token = await getValidAccessToken(ctx, config);
+  const result = await createTweet(ctx.http, token, { text, reply_to: tweetId });
+  await updateRateLimits(ctx, "post_tweets", result.rateLimit);
+  const published = {
+    tweet_id: result.data.id,
+    text: result.data.text,
+    published_at: (/* @__PURE__ */ new Date()).toISOString(),
+    draft_id: params.draft_id,
+    format: "reply",
+    metadata: { ...metadata, source_tweet_id: tweetId }
+  };
+  await ctx.entities.upsert({
+    entityType: ENTITY_TYPES.publishedPost,
+    scopeKind: "instance",
+    externalId: result.data.id,
+    title: `Reply: ${text.slice(0, 50)}`,
+    data: published
+  });
+  await ctx.events.emit(EVENT_NAMES.postPublished, config.company_id, {
+    tweet_id: result.data.id,
+    text,
+    format: "reply",
+    metadata: published.metadata
+  });
+  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 tweetId = params.tweet_id;
+  const text = params.text;
+  const metadata = params.metadata || {};
+  const approval = await checkApproval(ctx, config, "quotes", params.draft_id);
+  if (!approval.allowed) return { error: `Blocked: ${approval.reason}` };
+  const token = await getValidAccessToken(ctx, config);
+  const result = await createTweet(ctx.http, token, { text, quote_tweet_id: tweetId });
+  await updateRateLimits(ctx, "post_tweets", result.rateLimit);
+  const published = {
+    tweet_id: result.data.id,
+    text: result.data.text,
+    published_at: (/* @__PURE__ */ new Date()).toISOString(),
+    draft_id: params.draft_id,
+    format: "quote",
+    metadata: { ...metadata, source_tweet_id: tweetId }
+  };
+  await ctx.entities.upsert({
+    entityType: ENTITY_TYPES.publishedPost,
+    scopeKind: "instance",
+    externalId: result.data.id,
+    title: `Quote: ${text.slice(0, 50)}`,
+    data: published
+  });
+  await ctx.events.emit(EVENT_NAMES.postPublished, config.company_id, {
+    tweet_id: result.data.id,
+    text,
+    format: "quote",
+    metadata: published.metadata
+  });
+  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 tweetId = params.tweet_id;
+  const approval = await checkApproval(ctx, config, "reposts", params.draft_id);
+  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 published = {
+    tweet_id: tweetId,
+    text: "",
+    published_at: (/* @__PURE__ */ new Date()).toISOString(),
+    draft_id: params.draft_id,
+    format: "repost",
+    metadata: { source_tweet_id: tweetId }
+  };
+  await ctx.entities.upsert({
+    entityType: ENTITY_TYPES.publishedPost,
+    scopeKind: "instance",
+    externalId: `repost-${tweetId}`,
+    title: `Repost: ${tweetId}`,
+    data: published
+  });
+  await ctx.events.emit(EVENT_NAMES.postPublished, config.company_id, {
+    tweet_id: tweetId,
+    text: "",
+    format: "repost",
+    metadata: published.metadata
+  });
+  return { content: JSON.stringify({ tweet_id: tweetId, status: "reposted" }) };
+}
+async function handleSchedulePost(ctx, params) {
+  const scheduleAt = params.schedule_at;
+  const draftId = params.draft_id;
+  const text = params.text;
+  const metadata = params.metadata || {};
+  if (draftId) {
+    const entities = await ctx.entities.list({ entityType: ENTITY_TYPES.draft, limit: 500 });
+    const match = findEntityById(entities, draftId);
+    if (!match) return { error: `Draft ${draftId} not found.` };
+    match.data.schedule_at = scheduleAt;
+    await ctx.entities.upsert({
+      entityType: ENTITY_TYPES.draft,
+      scopeKind: "instance",
+      externalId: match.raw.externalId ?? void 0,
+      title: match.data.text.slice(0, 60),
+      data: match.data
+    });
+    return { content: JSON.stringify({ draft_id: draftId, schedule_at: scheduleAt, status: "scheduled" }) };
+  }
+  if (!text) return { error: "Provide text or draft_id." };
+  const draft = {
+    text,
+    format: "single",
+    schedule_at: scheduleAt,
+    status: "draft",
+    metadata
+  };
+  const entity = await ctx.entities.upsert({
+    entityType: ENTITY_TYPES.draft,
+    scopeKind: "instance",
+    title: text.slice(0, 60),
+    data: draft
+  });
+  return { content: JSON.stringify({ draft_id: entity.id, schedule_at: scheduleAt, status: "scheduled" }) };
+}
+async function handlePublishThread(ctx, params) {
+  const config = await getConfig(ctx);
+  let threadTweets = params.thread_tweets;
+  let metadata = params.metadata || {};
+  const draftId = params.draft_id;
+  if (draftId) {
+    const entities = await ctx.entities.list({ entityType: ENTITY_TYPES.draft, limit: 500 });
+    const match = findEntityById(entities, draftId);
+    if (!match) return { error: `Draft ${draftId} not found.` };
+    threadTweets = match.data.thread_tweets;
+    metadata = { ...match.data.metadata, ...metadata };
+  }
+  if (!threadTweets || threadTweets.length < 2) {
+    return { error: "Thread must have at least 2 tweets." };
+  }
+  const approval = await checkApproval(ctx, config, "posts", draftId);
+  if (!approval.allowed) return { error: `Blocked: ${approval.reason}` };
+  const token = await getValidAccessToken(ctx, config);
+  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,
+    thread_length: threadTweets.length,
+    partial: result.partial
+  });
+  for (const tweetId of result.tweetIds) {
+    await ctx.events.emit(EVENT_NAMES.postPublished, config.company_id, {
+      tweet_id: tweetId,
+      text: "",
+      format: "thread",
+      metadata
+    });
+  }
+  return { content: JSON.stringify({
+    tweet_ids: result.tweetIds,
+    thread_length: threadTweets.length,
+    partial: result.partial,
+    status: result.partial ? "partial" : "published"
+  }) };
+}
+async function handleGetDrafts(ctx, params) {
+  const statusFilter = params.status;
+  const limit = params.limit || 20;
+  const entities = await ctx.entities.list({ entityType: ENTITY_TYPES.draft, limit: 100 });
+  let drafts = entities.map((e) => ({ id: e.id, ...e.data }));
+  if (statusFilter) {
+    drafts = drafts.filter((d) => d.status === statusFilter);
+  }
+  return { content: JSON.stringify(drafts.slice(0, limit)) };
+}
+async function handleGetSchedule(ctx, params) {
+  const limit = params.limit || 20;
+  const entities = await ctx.entities.list({ entityType: ENTITY_TYPES.draft, limit: 100 });
+  const scheduled = entities.map((e) => ({ id: e.id, ...e.data })).filter((d) => d.schedule_at && (d.status === "draft" || d.status === "approved")).sort((a, b) => a.schedule_at > b.schedule_at ? 1 : -1);
+  return { content: JSON.stringify(scheduled.slice(0, limit)) };
+}
+async function handleGetPostMetrics(ctx, params) {
+  const tweetId = params.tweet_id;
+  const entities = await ctx.entities.list({ entityType: ENTITY_TYPES.publishedPost, limit: 500 });
+  const post = entities.find((e) => e.data.tweet_id === tweetId);
+  if (!post) return { error: `No published post found for tweet ${tweetId}.` };
+  const data = post.data;
+  return { content: JSON.stringify({
+    tweet_id: data.tweet_id,
+    text: data.text,
+    published_at: data.published_at,
+    format: data.format,
+    metadata: data.metadata,
+    metrics: data.metrics || null
+  }) };
+}
+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 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
+  }) };
+}
+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()}.
+
+Error: ${String(err)}
+
+Manual re-auth may be required via setup-oauth tool.`
+    });
+    await ctx.issues.update(issue.id, { status: "todo" }, config.company_id);
+  }
+}
+async function handlePublishScheduled(ctx, _job) {
+  const config = 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) => {
+    const d = e.data;
+    return d.schedule_at && d.schedule_at <= now && (d.status === "approved" || d.status === "draft");
+  });
+  for (const entity of due) {
+    const draft = entity.data;
+    const approval = await checkApproval(ctx, config, "scheduled", entity.id);
+    if (!approval.allowed) {
+      ctx.logger.info(`Scheduled draft ${entity.id} blocked: ${approval.reason}`);
+      continue;
+    }
+    try {
+      const token = await getValidAccessToken(ctx, config);
+      if (draft.format === "thread" && draft.thread_tweets) {
+        await publishThread(ctx, token, draft.thread_tweets, draft.metadata, config.company_id);
+      } else {
+        const result = await createTweet(ctx.http, token, {
+          text: draft.text,
+          reply_to: draft.reply_to_tweet_id,
+          quote_tweet_id: draft.quote_tweet_id
+        });
+        await updateRateLimits(ctx, "post_tweets", result.rateLimit);
+        await ctx.entities.upsert({
+          entityType: ENTITY_TYPES.publishedPost,
+          scopeKind: "instance",
+          externalId: result.data.id,
+          title: draft.text.slice(0, 60),
+          data: {
+            tweet_id: result.data.id,
+            text: result.data.text,
+            published_at: (/* @__PURE__ */ new Date()).toISOString(),
+            draft_id: entity.id,
+            format: draft.format,
+            metadata: draft.metadata
+          }
+        });
+        await ctx.events.emit(EVENT_NAMES.postPublished, config.company_id, {
+          tweet_id: result.data.id,
+          text: draft.text,
+          format: draft.format,
+          metadata: draft.metadata
+        });
+      }
+      draft.status = "approved";
+      await ctx.entities.upsert({
+        entityType: ENTITY_TYPES.draft,
+        scopeKind: "instance",
+        externalId: entity.externalId ?? void 0,
+        title: entity.title ?? draft.text.slice(0, 60),
+        data: draft
+      });
+      ctx.logger.info(`Published scheduled draft ${entity.id}`);
+    } catch (err) {
+      ctx.logger.error(`Failed to publish scheduled draft ${entity.id}`, { error: String(err) });
+    }
+  }
+}
+async function handleMetricsCapture(ctx, _job) {
+  const config = await getConfig(ctx);
+  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 });
+  const recent = entities.filter((e) => {
+    const d = e.data;
+    return d.published_at >= cutoff && d.format !== "repost";
+  });
+  if (recent.length === 0) return;
+  const tweetIds = recent.map((e) => e.data.tweet_id);
+  const token = await getValidAccessToken(ctx, config);
+  const batchSize = 100;
+  for (let i = 0; i < tweetIds.length; i += batchSize) {
+    const batch = tweetIds.slice(i, i + batchSize);
+    const url = `https://api.x.com/2/tweets?ids=${batch.join(",")}&tweet.fields=public_metrics`;
+    const resp = await ctx.http.fetch(url, {
+      headers: { Authorization: `Bearer ${token}` }
+    });
+    if (!resp.ok) {
+      ctx.logger.error("Metrics capture batch failed", { status: resp.status });
+      continue;
+    }
+    const body = await resp.json();
+    if (!body.data) continue;
+    for (const tweet of body.data) {
+      const entity = recent.find((e) => e.data.tweet_id === tweet.id);
+      if (!entity) continue;
+      const data = entity.data;
+      const newMetrics = {
+        likes: tweet.public_metrics.like_count,
+        retweets: tweet.public_metrics.retweet_count,
+        replies: tweet.public_metrics.reply_count,
+        impressions: tweet.public_metrics.impression_count || 0,
+        captured_at: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      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) {
+        if (totalEngagement >= milestone && prevTotal < milestone) {
+          await ctx.events.emit(EVENT_NAMES.postEngagementMilestone, config.company_id, {
+            tweet_id: tweet.id,
+            milestone,
+            current_metrics: newMetrics
+          });
+        }
+      }
+      data.metrics = newMetrics;
+      await ctx.entities.upsert({
+        entityType: ENTITY_TYPES.publishedPost,
+        scopeKind: "instance",
+        externalId: entity.externalId ?? void 0,
+        title: entity.title ?? data.text.slice(0, 60),
+        data
+      });
+    }
+  }
+  ctx.logger.info(`Metrics captured for ${recent.length} posts`);
+}
+async function handleStaleDraftCleanup(ctx, _job) {
+  const cutoff = new Date(Date.now() - 48 * 36e5).toISOString();
+  const entities = await ctx.entities.list({ entityType: ENTITY_TYPES.draft, limit: 500 });
+  let staleCount = 0;
+  for (const entity of entities) {
+    const data = entity.data;
+    if ((data.status === "draft" || data.status === "in_review") && entity.createdAt < cutoff) {
+      data.status = "stale";
+      await ctx.entities.upsert({
+        entityType: ENTITY_TYPES.draft,
+        scopeKind: "instance",
+        externalId: entity.externalId ?? void 0,
+        title: entity.title ?? data.text.slice(0, 60),
+        data
+      });
+      staleCount++;
+    }
+  }
+  if (staleCount > 0) {
+    ctx.logger.info(`Marked ${staleCount} drafts as stale`);
+  }
+}
+var pluginCtx = null;
+var plugin = definePlugin({
+  async setup(ctx) {
+    pluginCtx = ctx;
+    ctx.jobs.register(JOB_KEYS.tokenRefresh, (job) => handleTokenRefresh(ctx, job));
+    ctx.jobs.register(JOB_KEYS.publishScheduled, (job) => handlePublishScheduled(ctx, job));
+    ctx.jobs.register(JOB_KEYS.metricsCapture, (job) => handleMetricsCapture(ctx, job));
+    ctx.jobs.register(JOB_KEYS.staleDraftCleanup, (job) => handleStaleDraftCleanup(ctx, job));
+    const p = (params) => params;
+    ctx.tools.register(
+      TOOL_NAMES.setupOauth,
+      { displayName: "Setup OAuth", description: "Seed initial OAuth tokens", parametersSchema: {} },
+      (params) => handleSetupOauth(ctx, p(params))
+    );
+    ctx.tools.register(
+      TOOL_NAMES.draftPost,
+      { displayName: "Draft Post", description: "Create a draft post", parametersSchema: {} },
+      (params) => handleDraftPost(ctx, p(params))
+    );
+    ctx.tools.register(
+      TOOL_NAMES.draftThread,
+      { displayName: "Draft Thread", description: "Create a draft thread", parametersSchema: {} },
+      (params) => handleDraftThread(ctx, p(params))
+    );
+    ctx.tools.register(
+      TOOL_NAMES.updateDraft,
+      { displayName: "Update Draft", description: "Update an existing draft", parametersSchema: {} },
+      (params) => handleUpdateDraft(ctx, p(params))
+    );
+    ctx.tools.register(
+      TOOL_NAMES.publishPost,
+      { displayName: "Publish Post", description: "Publish a tweet to X", parametersSchema: {} },
+      (params) => handlePublishPost(ctx, p(params))
+    );
+    ctx.tools.register(
+      TOOL_NAMES.replyToTweet,
+      { displayName: "Reply to Tweet", description: "Post a reply to a tweet", parametersSchema: {} },
+      (params) => handleReplyToTweet(ctx, p(params))
+    );
+    ctx.tools.register(
+      TOOL_NAMES.quoteTweet,
+      { displayName: "Quote Tweet", description: "Post a quote tweet", parametersSchema: {} },
+      (params) => handleQuoteTweet(ctx, p(params))
+    );
+    ctx.tools.register(
+      TOOL_NAMES.repost,
+      { displayName: "Repost", description: "Repost a tweet", parametersSchema: {} },
+      (params) => handleRepost(ctx, p(params))
+    );
+    ctx.tools.register(
+      TOOL_NAMES.schedulePost,
+      { displayName: "Schedule Post", description: "Schedule a post for later", parametersSchema: {} },
+      (params) => handleSchedulePost(ctx, p(params))
+    );
+    ctx.tools.register(
+      TOOL_NAMES.publishThread,
+      { displayName: "Publish Thread", description: "Publish a multi-tweet thread", parametersSchema: {} },
+      (params) => handlePublishThread(ctx, p(params))
+    );
+    ctx.tools.register(
+      TOOL_NAMES.getDrafts,
+      { displayName: "Get Drafts", description: "Query drafts by status", parametersSchema: {} },
+      (params) => handleGetDrafts(ctx, p(params))
+    );
+    ctx.tools.register(
+      TOOL_NAMES.getSchedule,
+      { displayName: "Get Schedule", description: "Get upcoming scheduled posts", parametersSchema: {} },
+      (params) => handleGetSchedule(ctx, p(params))
+    );
+    ctx.tools.register(
+      TOOL_NAMES.getPostMetrics,
+      { displayName: "Get Post Metrics", description: "Get engagement metrics for a post", parametersSchema: {} },
+      (params) => handleGetPostMetrics(ctx, p(params))
+    );
+    ctx.tools.register(
+      TOOL_NAMES.getAccountStatus,
+      { displayName: "Get Account Status", description: "Account health and rate limits", parametersSchema: {} },
+      (params) => handleGetAccountStatus(ctx, p(params))
+    );
+    ctx.data.register("dashboard-summary", async () => {
+      const config = await getConfig(ctx);
+      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 });
+      const todayPosts = published.filter(
+        (e) => e.data.published_at.startsWith(today)
+      );
+      const pendingDrafts = drafts.filter((e) => {
+        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 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,
+        recent_posts: recentPosts
+      };
+    });
+    ctx.data.register("plugin-config", async () => {
+      const config = await getConfig(ctx);
+      return config;
+    });
+    ctx.data.register("content-queue", async () => {
+      const allDrafts = await ctx.entities.list({ entityType: ENTITY_TYPES.draft, limit: 100 });
+      const pending = allDrafts.map((e) => {
+        const d = e.data;
+        return { id: e.id, text: d.text, format: d.format, status: d.status, schedule_at: d.schedule_at };
+      }).filter((d) => (d.status === "draft" || d.status === "in_review" || d.status === "approved") && !d.schedule_at);
+      const scheduled = allDrafts.map((e) => {
+        const d = e.data;
+        return { id: e.id, text: d.text, format: d.format, status: d.status, schedule_at: d.schedule_at };
+      }).filter((d) => !!d.schedule_at && (d.status === "draft" || d.status === "approved" || d.status === "in_review")).sort((a, b) => a.schedule_at > b.schedule_at ? 1 : -1);
+      return { drafts: pending, scheduled };
+    });
+    ctx.events.on(`plugin.${ENTITY_TYPES.draft}`, async () => {
+    });
+    ctx.logger.info("X Publishing plugin initialized");
+  },
+  async onHealth() {
+    if (!pluginCtx) return { status: "error", message: "Plugin not initialized" };
+    const details = {};
+    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()) {
+          if (status === "ok") status = "degraded";
+          issues.push("Tweet rate limit exhausted");
+        }
+      }
+    } catch {
+      details.rate_limits = "unavailable";
+    }
+    const message = issues.length > 0 ? issues.join("; ") : "All systems operational";
+    return { status, message, details };
+  },
+  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");
+    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;
+      try {
+        await pluginCtx.secrets.resolve(clientIdRef);
+      } catch {
+        errors.push("Could not resolve oauth_client_id_ref secret");
+      }
+      try {
+        await pluginCtx.secrets.resolve(clientSecretRef);
+      } 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");
+      }
+    }
+    return { ok: errors.length === 0, warnings, errors };
+  }
+});
+var worker_default = plugin;
+runWorker(plugin, import.meta.url);
+export {
+  worker_default as default
+};
+//# sourceMappingURL=worker.js.map