@chrysb/alphaclaw 0.8.0 → 0.8.1-beta.1

package/lib/server/db/webhooks/index.js

@@ -1,5 +1,6 @@
 const fs = require("fs");
 const path = require("path");
+const crypto = require("crypto");
 const { DatabaseSync } = require("node:sqlite");
 const { createSchema } = require("./schema");
 
@@ -43,6 +44,19 @@ const parseJsonText = (value) => {
   }
 };
 
+const generateOauthCallbackId = () => crypto.randomBytes(16).toString("hex");
+
+const toOauthCallbackModel = (row) => {
+  if (!row) return null;
+  return {
+    callbackId: String(row.callback_id || ""),
+    hookName: String(row.hook_name || ""),
+    createdAt: row.created_at || null,
+    rotatedAt: row.rotated_at || null,
+    lastUsedAt: row.last_used_at || null,
+  };
+};
+
 const toRequestModel = (row) => {
   if (!row) return null;
   return {
@@ -220,6 +234,130 @@ const deleteRequestsByHook = (hookName) => {
   return Number(result.changes || 0);
 };
 
+const createOauthCallback = ({ hookName }) => {
+  const database = ensureDb();
+  const normalizedHookName = String(hookName || "").trim();
+  if (!normalizedHookName) throw new Error("hookName is required");
+  const callbackId = generateOauthCallbackId();
+  database
+    .prepare(`
+      INSERT INTO oauth_callbacks (
+        callback_id,
+        hook_name
+      ) VALUES (
+        $callback_id,
+        $hook_name
+      )
+    `)
+    .run({
+      $callback_id: callbackId,
+      $hook_name: normalizedHookName,
+    });
+  const inserted = database
+    .prepare(`
+      SELECT
+        callback_id,
+        hook_name,
+        created_at,
+        rotated_at,
+        last_used_at
+      FROM oauth_callbacks
+      WHERE callback_id = $callback_id
+      LIMIT 1
+    `)
+    .get({ $callback_id: callbackId });
+  return toOauthCallbackModel(inserted);
+};
+
+const getOauthCallbackByHook = (hookName) => {
+  const database = ensureDb();
+  const normalizedHookName = String(hookName || "").trim();
+  if (!normalizedHookName) return null;
+  const row = database
+    .prepare(`
+      SELECT
+        callback_id,
+        hook_name,
+        created_at,
+        rotated_at,
+        last_used_at
+      FROM oauth_callbacks
+      WHERE hook_name = $hook_name
+      LIMIT 1
+    `)
+    .get({ $hook_name: normalizedHookName });
+  return toOauthCallbackModel(row);
+};
+
+const getOauthCallbackById = (callbackId) => {
+  const database = ensureDb();
+  const normalizedCallbackId = String(callbackId || "").trim();
+  if (!normalizedCallbackId) return null;
+  const row = database
+    .prepare(`
+      SELECT
+        callback_id,
+        hook_name,
+        created_at,
+        rotated_at,
+        last_used_at
+      FROM oauth_callbacks
+      WHERE callback_id = $callback_id
+      LIMIT 1
+    `)
+    .get({ $callback_id: normalizedCallbackId });
+  return toOauthCallbackModel(row);
+};
+
+const rotateOauthCallback = (hookName) => {
+  const database = ensureDb();
+  const normalizedHookName = String(hookName || "").trim();
+  if (!normalizedHookName) throw new Error("hookName is required");
+  const existing = getOauthCallbackByHook(normalizedHookName);
+  if (!existing) throw new Error("OAuth callback not found");
+  const nextCallbackId = generateOauthCallbackId();
+  database
+    .prepare(`
+      UPDATE oauth_callbacks
+      SET
+        callback_id = $callback_id,
+        rotated_at = strftime('%Y-%m-%dT%H:%M:%fZ','now')
+      WHERE hook_name = $hook_name
+    `)
+    .run({
+      $callback_id: nextCallbackId,
+      $hook_name: normalizedHookName,
+    });
+  return getOauthCallbackById(nextCallbackId);
+};
+
+const deleteOauthCallback = (hookName) => {
+  const database = ensureDb();
+  const normalizedHookName = String(hookName || "").trim();
+  if (!normalizedHookName) return 0;
+  const result = database
+    .prepare(`
+      DELETE FROM oauth_callbacks
+      WHERE hook_name = $hook_name
+    `)
+    .run({ $hook_name: normalizedHookName });
+  return Number(result.changes || 0);
+};
+
+const markOauthCallbackUsed = (callbackId) => {
+  const database = ensureDb();
+  const normalizedCallbackId = String(callbackId || "").trim();
+  if (!normalizedCallbackId) return 0;
+  const result = database
+    .prepare(`
+      UPDATE oauth_callbacks
+      SET last_used_at = strftime('%Y-%m-%dT%H:%M:%fZ','now')
+      WHERE callback_id = $callback_id
+    `)
+    .run({ $callback_id: normalizedCallbackId });
+  return Number(result.changes || 0);
+};
+
 const pruneOldEntries = (days = 30) => {
   const database = ensureDb();
   const safeDays = Math.max(1, Number.parseInt(String(days || 30), 10) || 30);
@@ -240,5 +378,11 @@ module.exports = {
   getRequestById,
   getHookSummaries,
   deleteRequestsByHook,
+  createOauthCallback,
+  getOauthCallbackByHook,
+  getOauthCallbackById,
+  rotateOauthCallback,
+  deleteOauthCallback,
+  markOauthCallbackUsed,
   pruneOldEntries,
 };

package/lib/server/db/webhooks/schema.js

@@ -18,6 +18,19 @@ const createSchema = (database) => {
     CREATE INDEX IF NOT EXISTS idx_webhook_requests_hook_ts
     ON webhook_requests(hook_name, created_at DESC);
   `);
+  database.exec(`
+    CREATE TABLE IF NOT EXISTS oauth_callbacks (
+      callback_id TEXT PRIMARY KEY,
+      hook_name TEXT NOT NULL UNIQUE,
+      created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')),
+      rotated_at TEXT,
+      last_used_at TEXT
+    );
+  `);
+  database.exec(`
+    CREATE INDEX IF NOT EXISTS idx_oauth_callbacks_hook_name
+    ON oauth_callbacks(hook_name);
+  `);
 };
 
 module.exports = {

package/lib/server/init/register-server-routes.js

@@ -17,6 +17,9 @@ const { registerDoctorRoutes } = require("../routes/doctor");
 const { registerAgentRoutes } = require("../routes/agents");
 const { registerCronRoutes } = require("../routes/cron");
 const { registerNodeRoutes } = require("../routes/nodes");
+const {
+  createOauthCallbackMiddleware,
+} = require("../oauth-callback-middleware");
 
 const registerServerRoutes = ({
   app,
@@ -58,6 +61,12 @@ const registerServerRoutes = ({
   getRequestById,
   getHookSummaries,
   deleteRequestsByHook,
+  createOauthCallback,
+  getOauthCallbackByHook,
+  getOauthCallbackById,
+  rotateOauthCallback,
+  deleteOauthCallback,
+  markOauthCallbackUsed,
   watchdog,
   getRecentEvents,
   readLogTail,
@@ -132,6 +141,8 @@ const registerServerRoutes = ({
     restartRequiredState,
     topicRegistry,
     authProfiles,
+    watchdog,
+    doctorService,
   });
   registerBrowseRoutes({
     app,
@@ -185,9 +196,18 @@ const registerServerRoutes = ({
       getRequestById,
       getHookSummaries,
       deleteRequestsByHook,
+      createOauthCallback,
+      getOauthCallbackByHook,
+      rotateOauthCallback,
+      deleteOauthCallback,
     },
     restartRequiredState,
   });
+  const oauthCallbackMiddleware = createOauthCallbackMiddleware({
+    getOauthCallbackById,
+    markOauthCallbackUsed,
+    webhookMiddleware,
+  });
   registerWatchdogRoutes({
     app,
     requireAuth,
@@ -233,6 +253,7 @@ const registerServerRoutes = ({
     getGatewayUrl,
     SETUP_API_PREFIXES,
     requireAuth,
+    oauthCallbackMiddleware,
     webhookMiddleware,
   });
 

package/lib/server/oauth-callback-middleware.js

@@ -0,0 +1,34 @@
+const createOauthCallbackMiddleware = ({
+  getOauthCallbackById,
+  markOauthCallbackUsed = () => {},
+  webhookMiddleware,
+}) => {
+  return (req, res) => {
+    const callbackId = String(req.params?.id || "").trim();
+    if (!callbackId) {
+      return res.status(404).json({ error: "Not found" });
+    }
+    const callback = getOauthCallbackById(callbackId);
+    if (!callback?.hookName) {
+      return res.status(404).json({ error: "Not found" });
+    }
+    try {
+      markOauthCallbackUsed(callbackId);
+    } catch {}
+    const originalUrl = String(req.originalUrl || req.url || "");
+    const queryIndex = originalUrl.indexOf("?");
+    const querySuffix = queryIndex >= 0 ? originalUrl.slice(queryIndex) : "";
+    const rewrittenUrl = `/hooks/${callback.hookName}${querySuffix}`;
+    req.url = rewrittenUrl;
+    req.originalUrl = rewrittenUrl;
+    const webhookToken = String(process.env.WEBHOOK_TOKEN || "").trim();
+    if (webhookToken) {
+      req.headers.authorization = `Bearer ${webhookToken}`;
+    }
+    return webhookMiddleware(req, res);
+  };
+};
+
+module.exports = {
+  createOauthCallbackMiddleware,
+};

package/lib/server/routes/proxy.js

@@ -4,6 +4,7 @@ const registerProxyRoutes = ({
   getGatewayUrl,
   SETUP_API_PREFIXES,
   requireAuth,
+  oauthCallbackMiddleware,
   webhookMiddleware,
 }) => {
   const kOpenClawPathPattern = /^\/openclaw\/.+/;
@@ -24,6 +25,7 @@ const registerProxyRoutes = ({
     proxy.web(req, res, { target: getGatewayUrl() }),
   );
 
+  app.all("/oauth/:id", oauthCallbackMiddleware);
   app.all(kHooksPathPattern, webhookMiddleware);
   app.all(kWebhookPathPattern, webhookMiddleware);
 

package/lib/server/routes/system.js

@@ -25,6 +25,8 @@ const registerSystemRoutes = ({
   restartRequiredState,
   topicRegistry,
   authProfiles,
+  watchdog,
+  doctorService,
 }) => {
   let envRestartPending = false;
   const kManagedChannelTokenPattern =
@@ -465,12 +467,12 @@ const registerSystemRoutes = ({
     res.json({ ok: true, changed, restartRequired });
   });
 
-  app.get("/api/status", async (req, res) => {
+  const buildStatusPayload = async () => {
     const configExists = fs.existsSync(`${OPENCLAW_DIR}/openclaw.json`);
     const running = await isGatewayRunning();
     const repo = process.env.GITHUB_WORKSPACE_REPO || "";
     const openclawVersion = openclawVersionService.readOpenclawVersion();
-    res.json({
+    return {
       gateway: running
         ? "running"
         : configExists
@@ -481,6 +483,52 @@ const registerSystemRoutes = ({
       repo,
       openclawVersion,
       syncCron: getSystemCronStatus(),
+    };
+  };
+
+  app.get("/api/status", async (req, res) => {
+    const payload = await buildStatusPayload();
+    res.json(payload);
+  });
+
+  app.get("/api/events/status", async (req, res) => {
+    res.setHeader("Content-Type", "text/event-stream");
+    res.setHeader("Cache-Control", "no-cache, no-transform");
+    res.setHeader("Connection", "keep-alive");
+    res.setHeader("X-Accel-Buffering", "no");
+    res.flushHeaders?.();
+
+    const writeStatusEvent = async () => {
+      try {
+        const status = await buildStatusPayload();
+        const watchdogStatus =
+          typeof watchdog?.getStatus === "function" ? watchdog.getStatus() : null;
+        const doctorStatus =
+          typeof doctorService?.buildStatus === "function"
+            ? doctorService.buildStatus()
+            : null;
+        res.write("event: status\n");
+        res.write(
+          `data: ${JSON.stringify({
+            status,
+            watchdogStatus,
+            doctorStatus,
+            timestamp: new Date().toISOString(),
+          })}\n\n`,
+        );
+      } catch {}
+    };
+
+    await writeStatusEvent();
+    const statusIntervalId = setInterval(writeStatusEvent, 2000);
+    const keepAliveIntervalId = setInterval(() => {
+      res.write(": keepalive\n\n");
+    }, 15000);
+
+    req.on("close", () => {
+      clearInterval(statusIntervalId);
+      clearInterval(keepAliveIntervalId);
+      res.end();
     });
   });
 

package/lib/server/routes/webhooks.js

@@ -46,7 +46,7 @@ const normalizeStatusFilter = (rawStatus) => {
   return "all";
 };
 
-const buildWebhookUrls = ({ baseUrl, name }) => {
+const buildWebhookUrls = ({ baseUrl, name, oauthCallback = null }) => {
   const fullUrl = `${baseUrl}/hooks/${name}`;
   const token = String(process.env.WEBHOOK_TOKEN || "").trim();
   const queryStringUrl = token
@@ -55,7 +55,18 @@ const buildWebhookUrls = ({ baseUrl, name }) => {
   const authHeaderValue = token
     ? `Authorization: Bearer ${token}`
     : "Authorization: Bearer <WEBHOOK_TOKEN>";
-  return { fullUrl, queryStringUrl, authHeaderValue, hasRuntimeToken: !!token };
+  const callbackId = String(oauthCallback?.callbackId || "").trim();
+  return {
+    fullUrl,
+    queryStringUrl,
+    authHeaderValue,
+    hasRuntimeToken: !!token,
+    oauthCallbackId: callbackId || "",
+    oauthCallbackUrl: callbackId ? `${baseUrl}/oauth/${callbackId}` : "",
+    oauthCallbackCreatedAt: oauthCallback?.createdAt || null,
+    oauthCallbackRotatedAt: oauthCallback?.rotatedAt || null,
+    oauthCallbackLastUsedAt: oauthCallback?.lastUsedAt || null,
+  };
 };
 
 const registerWebhookRoutes = ({
@@ -67,6 +78,16 @@ const registerWebhookRoutes = ({
   shellCmd,
   restartRequiredState,
 }) => {
+  const {
+    getRequests = () => [],
+    getRequestById = () => null,
+    getHookSummaries = () => [],
+    deleteRequestsByHook = () => 0,
+    createOauthCallback: createOauthCallbackEntry = () => null,
+    getOauthCallbackByHook: getOauthCallbackByHookEntry = () => null,
+    rotateOauthCallback: rotateOauthCallbackEntry = () => null,
+    deleteOauthCallback: deleteOauthCallbackEntry = () => 0,
+  } = webhooksDb || {};
   const fallbackRestartState = {
     markRequired: () => {},
     getSnapshot: async () => ({ restartRequired: false }),
@@ -91,14 +112,18 @@ const registerWebhookRoutes = ({
   app.get("/api/webhooks", (req, res) => {
     try {
       const hooks = listWebhooks({ fs, constants });
-      const summaries = webhooksDb.getHookSummaries();
+      const summaries = getHookSummaries();
       const summaryByHook = mapSummaryByHook(summaries);
-      const webhooks = hooks.map((webhook) =>
-        mergeWebhookAndSummary({
-          webhook,
-          summary: summaryByHook.get(webhook.name),
-        }),
-      );
+      const webhooks = hooks.map((webhook) => {
+        const oauthCallback = getOauthCallbackByHookEntry(webhook.name);
+        return {
+          ...mergeWebhookAndSummary({
+            webhook,
+            summary: summaryByHook.get(webhook.name),
+          }),
+          oauthCallbackEnabled: !!String(oauthCallback?.callbackId || "").trim(),
+        };
+      });
       res.json({ ok: true, webhooks });
     } catch (err) {
       res.status(500).json({ ok: false, error: err.message });
@@ -111,12 +136,11 @@ const registerWebhookRoutes = ({
       const detail = getWebhookDetail({ fs, constants, name });
       if (!detail)
         return res.status(404).json({ ok: false, error: "Webhook not found" });
-      const summary = webhooksDb
-        .getHookSummaries()
-        .find((item) => item.hookName === name);
+      const summary = getHookSummaries().find((item) => item.hookName === name);
+      const oauthCallback = getOauthCallbackByHookEntry(name);
       const merged = mergeWebhookAndSummary({ webhook: detail, summary });
       const baseUrl = getBaseUrl(req);
-      const urls = buildWebhookUrls({ baseUrl, name });
+      const urls = buildWebhookUrls({ baseUrl, name, oauthCallback });
       return res.json({
         ok: true,
         webhook: {
@@ -125,6 +149,11 @@ const registerWebhookRoutes = ({
           queryStringUrl: urls.queryStringUrl,
           authHeaderValue: urls.authHeaderValue,
           hasRuntimeToken: urls.hasRuntimeToken,
+          oauthCallbackId: urls.oauthCallbackId,
+          oauthCallbackUrl: urls.oauthCallbackUrl,
+          oauthCallbackCreatedAt: urls.oauthCallbackCreatedAt,
+          oauthCallbackRotatedAt: urls.oauthCallbackRotatedAt,
+          oauthCallbackLastUsedAt: urls.oauthCallbackLastUsedAt,
           authNote:
             "All hooks use WEBHOOK_TOKEN. Use Authorization: Bearer <token> or x-openclaw-token header.",
         },
@@ -136,11 +165,22 @@ const registerWebhookRoutes = ({
 
   app.post("/api/webhooks", async (req, res) => {
     try {
-      const { name: rawName, destination = null } = req.body || {};
+      const {
+        name: rawName,
+        destination = null,
+        oauthCallback = false,
+      } = req.body || {};
       const name = validateWebhookName(rawName);
       const webhook = createWebhook({ fs, constants, name, destination });
+      const oauthCallbackRecord = oauthCallback
+        ? createOauthCallbackEntry({ hookName: name })
+        : null;
       const baseUrl = getBaseUrl(req);
-      const urls = buildWebhookUrls({ baseUrl, name });
+      const urls = buildWebhookUrls({
+        baseUrl,
+        name,
+        oauthCallback: oauthCallbackRecord,
+      });
       const syncWarning = await runWebhookGitSync("create", name);
       markRestartRequired("webhooks");
       const snapshot = await getRestartSnapshot();
@@ -152,6 +192,11 @@ const registerWebhookRoutes = ({
           queryStringUrl: urls.queryStringUrl,
           authHeaderValue: urls.authHeaderValue,
           hasRuntimeToken: urls.hasRuntimeToken,
+          oauthCallbackId: urls.oauthCallbackId,
+          oauthCallbackUrl: urls.oauthCallbackUrl,
+          oauthCallbackCreatedAt: urls.oauthCallbackCreatedAt,
+          oauthCallbackRotatedAt: urls.oauthCallbackRotatedAt,
+          oauthCallbackLastUsedAt: urls.oauthCallbackLastUsedAt,
         },
         restartRequired: snapshot.restartRequired,
         syncWarning,
@@ -164,6 +209,68 @@ const registerWebhookRoutes = ({
     }
   });
 
+  app.post("/api/webhooks/:name/oauth-callback", (req, res) => {
+    try {
+      const name = validateWebhookName(req.params.name);
+      const detail = getWebhookDetail({ fs, constants, name });
+      if (!detail)
+        return res.status(404).json({ ok: false, error: "Webhook not found" });
+      const existing = getOauthCallbackByHookEntry(name);
+      if (existing?.callbackId) {
+        return res.status(409).json({
+          ok: false,
+          error: "OAuth callback alias already exists",
+        });
+      }
+      const oauthCallback = createOauthCallbackEntry({ hookName: name });
+      const baseUrl = getBaseUrl(req);
+      const urls = buildWebhookUrls({ baseUrl, name, oauthCallback });
+      return res.status(201).json({
+        ok: true,
+        oauthCallbackId: urls.oauthCallbackId,
+        oauthCallbackUrl: urls.oauthCallbackUrl,
+        oauthCallbackCreatedAt: urls.oauthCallbackCreatedAt,
+        oauthCallbackRotatedAt: urls.oauthCallbackRotatedAt,
+        oauthCallbackLastUsedAt: urls.oauthCallbackLastUsedAt,
+      });
+    } catch (err) {
+      return res.status(400).json({ ok: false, error: err.message });
+    }
+  });
+
+  app.post("/api/webhooks/:name/oauth-callback/rotate", (req, res) => {
+    try {
+      const name = validateWebhookName(req.params.name);
+      const detail = getWebhookDetail({ fs, constants, name });
+      if (!detail)
+        return res.status(404).json({ ok: false, error: "Webhook not found" });
+      const oauthCallback = rotateOauthCallbackEntry(name);
+      const baseUrl = getBaseUrl(req);
+      const urls = buildWebhookUrls({ baseUrl, name, oauthCallback });
+      return res.json({
+        ok: true,
+        oauthCallbackId: urls.oauthCallbackId,
+        oauthCallbackUrl: urls.oauthCallbackUrl,
+        oauthCallbackCreatedAt: urls.oauthCallbackCreatedAt,
+        oauthCallbackRotatedAt: urls.oauthCallbackRotatedAt,
+        oauthCallbackLastUsedAt: urls.oauthCallbackLastUsedAt,
+      });
+    } catch (err) {
+      const status = String(err?.message || "").includes("not found") ? 404 : 400;
+      return res.status(status).json({ ok: false, error: err.message });
+    }
+  });
+
+  app.delete("/api/webhooks/:name/oauth-callback", (req, res) => {
+    try {
+      const name = validateWebhookName(req.params.name);
+      const deletedCount = deleteOauthCallbackEntry(name);
+      return res.json({ ok: true, deleted: deletedCount > 0 });
+    } catch (err) {
+      return res.status(400).json({ ok: false, error: err.message });
+    }
+  });
+
   app.delete("/api/webhooks/:name", async (req, res) => {
     try {
       const name = validateWebhookName(req.params.name);
@@ -184,7 +291,8 @@ const registerWebhookRoutes = ({
       }
       if (!deletion?.removed)
         return res.status(404).json({ ok: false, error: "Webhook not found" });
-      const deletedRequestCount = webhooksDb.deleteRequestsByHook(name);
+      deleteOauthCallbackEntry(name);
+      const deletedRequestCount = deleteRequestsByHook(name);
       const syncWarning = await runWebhookGitSync("delete", name);
       markRestartRequired("webhooks");
       const snapshot = await getRestartSnapshot();
@@ -216,7 +324,7 @@ const registerWebhookRoutes = ({
           .status(400)
           .json({ ok: false, error: "Invalid limit/offset" });
       }
-      const requests = webhooksDb.getRequests(name, { limit, offset, status });
+      const requests = getRequests(name, { limit, offset, status });
       return res.json({ ok: true, requests });
     } catch (err) {
       return res.status(400).json({ ok: false, error: err.message });
@@ -230,7 +338,7 @@ const registerWebhookRoutes = ({
       if (!isFiniteInteger(requestId) || requestId <= 0) {
         return res.status(400).json({ ok: false, error: "Invalid request id" });
       }
-      const request = webhooksDb.getRequestById(name, requestId);
+      const request = getRequestById(name, requestId);
       if (!request)
         return res.status(404).json({ ok: false, error: "Request not found" });
       return res.json({ ok: true, request });

package/lib/server/webhook-middleware.js

@@ -114,6 +114,11 @@ const resolveGatewayPath = ({ pathname, search }) => {
   return `${pathname}${search || ""}`;
 };
 
+const resolveForwardMethod = (method) => {
+  if (String(method || "").toUpperCase() === "GET") return "POST";
+  return method;
+};
+
 const parseJsonSafe = (rawValue) => {
   try {
     return JSON.parse(String(rawValue || "").trim() || "{}");
@@ -297,7 +302,7 @@ const createWebhookMiddleware = ({
       protocol: gateway.protocol,
       hostname: gateway.hostname,
       port: gateway.port,
-      method: req.method,
+      method: resolveForwardMethod(req.method),
       path: resolveGatewayPath({
         pathname: inboundUrl.pathname,
         search: inboundUrl.search,

package/lib/server.js

@@ -30,6 +30,12 @@ const {
   getRequestById,
   getHookSummaries,
   deleteRequestsByHook,
+  createOauthCallback,
+  getOauthCallbackByHook,
+  getOauthCallbackById,
+  rotateOauthCallback,
+  deleteOauthCallback,
+  markOauthCallbackUsed,
 } = require("./server/db/webhooks");
 const {
   initWatchdogDb,
@@ -294,6 +300,12 @@ const { isAuthorizedRequest, gmailWatchService } = registerServerRoutes({
   getRequestById,
   getHookSummaries,
   deleteRequestsByHook,
+  createOauthCallback,
+  getOauthCallbackByHook,
+  getOauthCallbackById,
+  rotateOauthCallback,
+  deleteOauthCallback,
+  markOauthCallbackUsed,
   watchdog,
   getRecentEvents,
   readLogTail,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chrysb/alphaclaw",
-  "version": "0.8.0",
+  "version": "0.8.1-beta.1",
   "publishConfig": {
     "access": "public"
   },