npm - hanzi-browse - Versions diffs - 2.2.1 → 2.2.3 - Mend

hanzi-browse 2.2.1 → 2.2.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (22) hide show

package/dist/cli/setup.js +10 -1
package/dist/dashboard/assets/index-wVMUNuBA.js +61 -0
package/dist/dashboard/index.html +1 -1
package/dist/index.js +40 -0
package/dist/managed/api.d.ts +14 -0
package/dist/managed/api.js +272 -0
package/dist/managed/billing.js +2 -0
package/dist/managed/deploy.js +18 -1
package/dist/managed/notify.d.ts +7 -0
package/dist/managed/notify.js +36 -0
package/dist/managed/scheduler.d.ts +42 -0
package/dist/managed/scheduler.js +282 -0
package/dist/managed/store-pg.d.ts +116 -0
package/dist/managed/store-pg.js +215 -0
package/dist/managed/store.d.ts +13 -0
package/dist/managed/store.js +15 -0
package/dist/managed/telemetry.d.ts +8 -0
package/dist/managed/telemetry.js +61 -0
package/dist/telemetry.d.ts +14 -0
package/dist/telemetry.js +141 -0
package/package.json +4 -1
package/dist/dashboard/assets/index-B6M8kZZo.js +0 -46

package/dist/dashboard/index.html CHANGED Viewed

@@ -4,7 +4,7 @@
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
   <title>Hanzi Developer Console</title>
-  <script type="module" crossorigin src="/dashboard/assets/index-B6M8kZZo.js"></script>
+  <script type="module" crossorigin src="/dashboard/assets/index-wVMUNuBA.js"></script>
   <link rel="stylesheet" crossorigin href="/dashboard/assets/index-vMQ9aDcG.css">
 </head>
 <body>

package/dist/index.js CHANGED Viewed

@@ -12,6 +12,27 @@ if (process.argv[2] === 'setup') {
     catch { /* exit code propagated */ }
     process.exit(0);
 }
+// If invoked as `npx hanzi-browse telemetry [on|off]`, handle inline
+if (process.argv[2] === 'telemetry') {
+    const { isTelemetryEnabled, setTelemetryEnabled } = await import('./telemetry.js');
+    const sub = process.argv[3];
+    if (sub === 'on') {
+        setTelemetryEnabled(true);
+        console.log('Telemetry enabled. Anonymous usage stats help improve Hanzi.');
+    }
+    else if (sub === 'off') {
+        setTelemetryEnabled(false);
+        console.log('Telemetry disabled. No data will be collected.');
+    }
+    else {
+        console.log(`Telemetry is ${isTelemetryEnabled() ? 'enabled' : 'disabled'}.`);
+        console.log('Usage: hanzi-browse telemetry [on|off]');
+    }
+    process.exit(0);
+}
+import { initTelemetry, trackEvent, captureException, shutdownTelemetry } from "./telemetry.js";
+initTelemetry();
+trackEvent("mcp_start");
 /**
  * Hanzi Browse MCP Server
  *
@@ -978,6 +999,18 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     session.status = "timeout";
                     session.error = `Task still running after ${TASK_TIMEOUT_MS / 60000} minutes. Use browser_screenshot to check progress, then browser_message to continue or browser_stop to end.`;
                 }
+                if (session.status === "complete") {
+                    trackEvent("task_completed", {
+                        steps: session.steps.length,
+                        duration_ms: Date.now() - session.createdAt,
+                    });
+                }
+                else {
+                    trackEvent("task_failed", {
+                        error_category: session.status === "timeout" ? "timeout" : "unknown",
+                        steps: session.steps.length,
+                    });
+                }
                 return {
                     content: [{ type: "text", text: JSON.stringify(formatResult(session), null, 2) }],
                     isError: session.status === "error",
@@ -1068,6 +1101,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         }
     }
     catch (error) {
+        captureException(error, { tool: name });
         return { content: [{ type: "text", text: `Error: ${error.message}` }], isError: true };
     }
 });
@@ -1110,7 +1144,13 @@ async function main() {
     await server.connect(transport);
     console.error("[MCP] Server running (browser execution: extension-side)");
 }
+process.on("beforeExit", async () => {
+    await shutdownTelemetry();
+});
+process.on("SIGTERM", async () => { await shutdownTelemetry(); process.exit(0); });
+process.on("SIGINT", async () => { await shutdownTelemetry(); process.exit(0); });
 main().catch((error) => {
+    captureException(error, { context: "fatal_startup" });
     console.error("[MCP] Fatal:", error);
     process.exit(1);
 });

package/dist/managed/api.d.ts CHANGED Viewed

@@ -43,6 +43,20 @@ export declare function initManagedAPI(relay: WebSocketClient, sessionConnectedC
  * Handle incoming relay messages (tool results from extension).
  */
 export declare function handleRelayMessage(message: any): boolean;
+/**
+ * Run a task internally (used by scheduler — no HTTP, no auth, no billing).
+ * Returns a promise that resolves when the task completes.
+ */
+export declare function runInternalTask(params: {
+    workspaceId: string;
+    browserSessionId: string;
+    task: string;
+    url?: string;
+}): Promise<{
+    taskId: string;
+    answer?: string;
+    status: string;
+}>;
 export declare function startManagedAPI(port?: number): void;
 /**
  * Graceful shutdown: abort all running tasks and update their status.

package/dist/managed/api.js CHANGED Viewed

@@ -21,6 +21,7 @@
 import { createServer } from "http";
 import { randomUUID } from "crypto";
 import { log } from "./log.js";
+import { trackManagedEvent, captureManagedError } from "./telemetry.js";
 import { runAgentLoop, } from "../agent/loop.js";
 import * as fileStore from "./store.js";
 import { createAuth, resolveSessionToWorkspace, resolveSessionProfile } from "./auth.js";
@@ -35,6 +36,20 @@ let S = fileStore;
 export function setStoreModule(storeModule) {
     S = storeModule;
 }
+function categorizeError(err) {
+    const msg = err.message.toLowerCase();
+    if (msg.includes("timeout"))
+        return "timeout";
+    if (msg.includes("disconnected") || msg.includes("not connected"))
+        return "browser_disconnected";
+    if (msg.includes("rate limit") || msg.includes("429"))
+        return "rate_limited";
+    if (msg.includes("fetch failed") || msg.includes("llm"))
+        return "llm_error";
+    if (msg.includes("abort"))
+        return "aborted";
+    return "internal";
+}
 let isSessionConnectedFn = null;
 let relayPort = 7862;
 // --- State ---
@@ -609,9 +624,11 @@ async function handleCreateTask(body, apiKey, requestId) {
         context,
         browserSessionId: browser_session_id,
     });
+    trackManagedEvent("task_created", apiKey.workspaceId, { has_url: !!url, has_context: !!context });
     const abort = new AbortController();
     taskAborts.set(taskRun.id, abort);
     taskWorkspaceMap.set(taskRun.id, { workspaceId: apiKey.workspaceId, startedAt: Date.now() });
+    const taskStartedAt = Date.now();
     // Task-level timeout — abort if agent loop exceeds max duration
     const taskTimeout = setTimeout(() => {
         abort.abort();
@@ -720,10 +737,18 @@ async function handleCreateTask(body, apiKey, requestId) {
             }
         }
         if (updated) {
+            trackManagedEvent("task_completed", apiKey.workspaceId, {
+                steps: result.steps,
+                duration_ms: Date.now() - taskStartedAt,
+                input_tokens: result.usage.inputTokens,
+                output_tokens: result.usage.outputTokens,
+            });
             log.info("Task completed", { requestId, taskId: taskRun.id, workspaceId: apiKey.workspaceId }, { status, steps: result.steps });
         }
     })
         .catch(async (err) => {
+        trackManagedEvent("task_failed", apiKey.workspaceId, { error_category: categorizeError(err), duration_ms: Date.now() - taskStartedAt });
+        captureManagedError(err, { task_id: taskRun.id, workspace_id: apiKey.workspaceId });
         for (let attempt = 0; attempt < 2; attempt++) {
             try {
                 await S.updateTaskRun(taskRun.id, {
@@ -1075,6 +1100,7 @@ async function handleRequest(req, res) {
                 sendJson(req, res, 401, { error: "Invalid, expired, or already consumed pairing token" });
                 return;
             }
+            trackManagedEvent("browser_paired", session.workspaceId);
             sendJson(req, res, 201, {
                 browser_session_id: session.id,
                 session_token: session.sessionToken,
@@ -1098,6 +1124,7 @@ async function handleRequest(req, res) {
             const label = typeof body.label === "string" ? body.label.slice(0, 200) : undefined;
             const externalUserId = typeof body.external_user_id === "string" ? body.external_user_id.slice(0, 200) : undefined;
             const token = await S.createPairingToken(apiKey.workspaceId, apiKey.id, { label, externalUserId });
+            trackManagedEvent("pairing_link_generated", apiKey.workspaceId);
             sendJson(req, res, 201, {
                 pairing_token: token._plainToken,
                 expires_at: token.expiresAt,
@@ -1220,6 +1247,7 @@ async function handleRequest(req, res) {
                 return;
             }
             const newKey = await S.createApiKey(apiKey.workspaceId, name);
+            trackManagedEvent("api_key_created", apiKey.workspaceId);
             sendJson(req, res, 201, {
                 id: newKey.id,
                 key: newKey.key, // plaintext — shown once
@@ -1283,6 +1311,195 @@ async function handleRequest(req, res) {
             sendJson(req, res, 200, session);
             return;
         }
+        // ── Automations ───────────────────────────────────────────────────
+        // POST /v1/automations — create a new automation
+        if (method === "POST" && url === "/v1/automations") {
+            const body = await parseBody(req);
+            const { browser_session_id, config } = body;
+            if (!browser_session_id || !config) {
+                sendJson(req, res, 400, { error: "browser_session_id and config are required" });
+                return;
+            }
+            if (!config.keywords?.length || !config.product_name) {
+                sendJson(req, res, 400, { error: "config must include keywords (array) and product_name" });
+                return;
+            }
+            if (!config.schedule_cron) {
+                config.schedule_cron = "0 9 * * 1,3,5"; // default: 3x/week at 9am
+            }
+            const { computeNextRun } = await import("./scheduler.js");
+            const nextRunAt = computeNextRun(config.schedule_cron, config.timezone);
+            const auto = await S.createAutomation({
+                workspaceId: apiKey.workspaceId,
+                browserSessionId: browser_session_id,
+                config,
+                nextRunAt: nextRunAt || undefined,
+            });
+            sendJson(req, res, 201, auto);
+            return;
+        }
+        // GET /v1/automations — list automations for workspace
+        if (method === "GET" && url === "/v1/automations") {
+            const list = await S.listAutomations(apiKey.workspaceId);
+            sendJson(req, res, 200, list);
+            return;
+        }
+        // PATCH /v1/automations/:id — update config, pause/resume
+        const autoMatch = url?.match(/^\/v1\/automations\/([^/]+)$/);
+        if (autoMatch && method === "PATCH") {
+            const autoId = autoMatch[1];
+            const body = await parseBody(req);
+            const fields = {};
+            if (body.status !== undefined)
+                fields.status = body.status;
+            if (body.config !== undefined)
+                fields.config = body.config;
+            if (body.browser_session_id !== undefined)
+                fields.browserSessionId = body.browser_session_id;
+            if (body.config?.schedule_cron || body.status === "active") {
+                const auto = await S.getAutomation(autoId);
+                if (auto) {
+                    const cron = body.config?.schedule_cron || auto.config.schedule_cron;
+                    const tz = body.config?.timezone || auto.config.timezone;
+                    const { computeNextRun } = await import("./scheduler.js");
+                    const next = computeNextRun(cron, tz);
+                    if (next)
+                        fields.nextRunAt = next;
+                }
+            }
+            if (body.status === "active") {
+                fields.consecutiveFailures = 0;
+                fields.errorMessage = null;
+            }
+            const updated = await S.updateAutomation(autoId, apiKey.workspaceId, fields);
+            if (!updated) {
+                sendJson(req, res, 404, { error: "Automation not found" });
+                return;
+            }
+            sendJson(req, res, 200, updated);
+            return;
+        }
+        // DELETE /v1/automations/:id
+        if (autoMatch && method === "DELETE") {
+            const deleted = await S.deleteAutomation(autoMatch[1], apiKey.workspaceId);
+            if (!deleted) {
+                sendJson(req, res, 404, { error: "Automation not found" });
+                return;
+            }
+            sendJson(req, res, 200, { id: autoMatch[1], deleted: true });
+            return;
+        }
+        // GET /v1/automations/drafts — list drafts
+        if (method === "GET" && (url === "/v1/automations/drafts" || url?.startsWith("/v1/automations/drafts?"))) {
+            const params = new URLSearchParams(url?.split("?")[1] || "");
+            const drafts = await S.listDrafts(apiKey.workspaceId, {
+                status: params.get("status") || undefined,
+                automationId: params.get("automation_id") || undefined,
+                limit: params.has("limit") ? parseInt(params.get("limit")) : undefined,
+            });
+            sendJson(req, res, 200, drafts);
+            return;
+        }
+        // PATCH /v1/automations/drafts/:id — approve/edit/skip a draft
+        const draftMatch = url?.match(/^\/v1\/automations\/drafts\/([^/]+)$/);
+        if (draftMatch && method === "PATCH") {
+            const body = await parseBody(req);
+            const fields = {};
+            if (body.status !== undefined)
+                fields.status = body.status;
+            if (body.edited_text !== undefined)
+                fields.editedText = body.edited_text;
+            const updated = await S.updateDraft(draftMatch[1], apiKey.workspaceId, fields);
+            if (!updated) {
+                sendJson(req, res, 404, { error: "Draft not found" });
+                return;
+            }
+            sendJson(req, res, 200, updated);
+            return;
+        }
+        // POST /v1/automations/drafts/:id/post — trigger post task for an approved draft
+        const draftPostMatch = url?.match(/^\/v1\/automations\/drafts\/([^/]+)\/post$/);
+        if (draftPostMatch && method === "POST") {
+            const draft = await S.getDraft(draftPostMatch[1]);
+            if (!draft || draft.workspaceId !== apiKey.workspaceId) {
+                sendJson(req, res, 404, { error: "Draft not found" });
+                return;
+            }
+            if (draft.status !== "approved" && draft.status !== "edited") {
+                sendJson(req, res, 400, { error: `Draft must be approved or edited to post (current: ${draft.status})` });
+                return;
+            }
+            const auto = await S.getAutomation(draft.automationId);
+            if (!auto?.browserSessionId) {
+                sendJson(req, res, 409, { error: "No browser session configured on automation" });
+                return;
+            }
+            const connected = isSessionConnectedFn ? isSessionConnectedFn(auto.browserSessionId) : false;
+            if (!connected) {
+                sendJson(req, res, 409, { error: "Browser session is not connected" });
+                return;
+            }
+            const replyText = draft.editedText || draft.replyText;
+            const { buildPostPrompt } = await import("./scheduler.js");
+            const postPrompt = buildPostPrompt(draft.tweetUrl, replyText);
+            // Run post task in background
+            runInternalTask({
+                workspaceId: apiKey.workspaceId,
+                browserSessionId: auto.browserSessionId,
+                task: postPrompt,
+                url: draft.tweetUrl,
+            }).then(async (result) => {
+                if (result.status === "complete") {
+                    await S.updateDraft(draft.id, apiKey.workspaceId, {
+                        status: "posted",
+                        postTaskId: result.taskId,
+                        postedAt: new Date(),
+                    });
+                    await S.logEngagement({
+                        workspaceId: apiKey.workspaceId,
+                        automationId: draft.automationId,
+                        draftId: draft.id,
+                        authorHandle: draft.tweetAuthorHandle || "unknown",
+                        replyType: draft.replyType,
+                        tweetUrl: draft.tweetUrl,
+                        tweetSummary: draft.tweetText?.slice(0, 200),
+                        replySummary: replyText.slice(0, 200),
+                    });
+                }
+                else {
+                    await S.updateDraft(draft.id, apiKey.workspaceId, {
+                        status: "failed",
+                        postTaskId: result.taskId,
+                    });
+                }
+            }).catch(() => { });
+            sendJson(req, res, 202, { draft_id: draft.id, status: "posting", task_id: "pending" });
+            return;
+        }
+        // POST /v1/automations/drafts/batch-approve — approve multiple drafts
+        if (method === "POST" && url === "/v1/automations/drafts/batch-approve") {
+            const body = await parseBody(req);
+            const { draft_ids } = body;
+            if (!Array.isArray(draft_ids) || draft_ids.length === 0) {
+                sendJson(req, res, 400, { error: "draft_ids array is required" });
+                return;
+            }
+            const results = [];
+            for (const draftId of draft_ids) {
+                const updated = await S.updateDraft(draftId, apiKey.workspaceId, { status: "approved" });
+                results.push({ id: draftId, status: updated ? "approved" : "not_found" });
+            }
+            sendJson(req, res, 200, { results });
+            return;
+        }
+        // GET /v1/automations/engagements — list engagement history
+        if (method === "GET" && (url === "/v1/automations/engagements" || url?.startsWith("/v1/automations/engagements?"))) {
+            const params = new URLSearchParams(url?.split("?")[1] || "");
+            const limit = params.has("limit") ? parseInt(params.get("limit")) : 50;
+            const engagements = await S.listEngagements(apiKey.workspaceId, limit);
+            sendJson(req, res, 200, engagements);
+            return;
+        }
         sendJson(req, res, 404, { error: "Not found" });
     }
     catch (err) {
@@ -1290,6 +1507,61 @@ async function handleRequest(req, res) {
         sendJson(req, res, 500, { error: err.message, request_id: requestId });
     }
 }
+/**
+ * Run a task internally (used by scheduler — no HTTP, no auth, no billing).
+ * Returns a promise that resolves when the task completes.
+ */
+export async function runInternalTask(params) {
+    const { workspaceId, browserSessionId, task, url } = params;
+    const taskRun = await S.createTaskRun({
+        workspaceId,
+        apiKeyId: "scheduler",
+        task,
+        url,
+        browserSessionId,
+    });
+    const abort = new AbortController();
+    taskAborts.set(taskRun.id, abort);
+    taskWorkspaceMap.set(taskRun.id, { workspaceId, startedAt: Date.now() });
+    const taskTimeout = setTimeout(() => {
+        abort.abort();
+    }, TASK_TIMEOUT_MS);
+    let currentStep = 0;
+    try {
+        const result = await runAgentLoop({
+            task,
+            url,
+            executeTool: async (toolName, toolInput) => {
+                return executeToolViaRelay(toolName, toolInput, browserSessionId);
+            },
+            onStep: (step) => {
+                currentStep = step.step;
+                void S.updateTaskRun(taskRun.id, { steps: step.step });
+            },
+            maxSteps: 50,
+            signal: abort.signal,
+        });
+        const status = result.status === "complete" ? "complete" : "error";
+        await S.updateTaskRun(taskRun.id, {
+            status: status,
+            answer: result.answer || undefined,
+            steps: result.usage.apiCalls,
+        });
+        return { taskId: taskRun.id, answer: result.answer, status };
+    }
+    catch (err) {
+        try {
+            await S.updateTaskRun(taskRun.id, { status: "error", answer: err.message });
+        }
+        catch { }
+        return { taskId: taskRun.id, status: "error" };
+    }
+    finally {
+        clearTimeout(taskTimeout);
+        taskAborts.delete(taskRun.id);
+        taskWorkspaceMap.delete(taskRun.id);
+    }
+}
 export function startManagedAPI(port = 3456) {
     const host = process.env.NODE_ENV === "production" ? "127.0.0.1" : "0.0.0.0";
     const server = createServer(handleRequest);

package/dist/managed/billing.js CHANGED Viewed

@@ -24,6 +24,7 @@
  */
 import Stripe from "stripe";
 import { log } from "./log.js";
+import { trackManagedEvent } from "./telemetry.js";
 let stripe = null;
 let S = null;
 /** Set the backing store so billing can persist webhook results. */
@@ -182,6 +183,7 @@ export async function handleWebhook(rawBody, signature) {
                     if (credits > 0) {
                         const newBalance = await S.addCredits(workspaceId, credits);
                         log.info("Credits purchased", { workspaceId }, { credits, newBalance });
+                        trackManagedEvent("credits_purchased", workspaceId, { credits });
                     }
                 }
                 catch (err) {

package/dist/managed/deploy.js CHANGED Viewed

@@ -16,9 +16,12 @@
 import { WebSocketServer, WebSocket } from "ws";
 import { randomUUID } from "crypto";
 import { initVertex } from "../llm/vertex.js";
-import { startManagedAPI, initManagedAPI, handleRelayMessage, setStoreModule, onSessionDisconnected, shutdownManagedAPI, recoverStuckTasks } from "./api.js";
+import { startManagedAPI, initManagedAPI, handleRelayMessage, setStoreModule, onSessionDisconnected, shutdownManagedAPI, recoverStuckTasks, runInternalTask } from "./api.js";
+import { initScheduler, startScheduler, stopScheduler } from "./scheduler.js";
+import { notifyDraftsReady } from "./notify.js";
 import { initBilling, setBillingStore } from "./billing.js";
 import { WebSocketClient } from "../ipc/websocket-client.js";
+import { initManagedTelemetry, shutdownManagedTelemetry } from "./telemetry.js";
 // Dynamic store import — Postgres when DATABASE_URL is set, file-based otherwise
 const DATABASE_URL = process.env.DATABASE_URL;
 let store;
@@ -312,6 +315,7 @@ function setupRelayHandlers(wss) {
 }
 // --- Main ---
 async function main() {
+    initManagedTelemetry();
     // 1. Init Vertex AI (optional — managed task execution disabled without it)
     const saJson = process.env.VERTEX_SA_JSON;
     const saPath = process.env.VERTEX_SA_PATH;
@@ -370,6 +374,17 @@ async function main() {
     store.startHeartbeatFlush();
     // 7. Recover tasks stuck in "running" from a previous process
     await recoverStuckTasks();
+    // 8. Start scheduler for automated tasks
+    if (DATABASE_URL) {
+        const pgStore = await import("./store-pg.js");
+        initScheduler({
+            store: pgStore,
+            runTask: runInternalTask,
+            isSessionConnected: isSessionConnected,
+            notify: notifyDraftsReady,
+        });
+        startScheduler();
+    }
     console.error(`
 ╔════════════════════════════════════════════════╗
 ║  Hanzi Managed Backend (deployed)              ║
@@ -392,7 +407,9 @@ main().catch((err) => {
 async function handleShutdown(signal) {
     console.error(`\n[Server] Received ${signal} — shutting down gracefully...`);
     try {
+        stopScheduler();
         await shutdownManagedAPI();
+        await shutdownManagedTelemetry();
     }
     catch (err) {
         console.error(`[Server] Shutdown error:`, err.message);

package/dist/managed/notify.d.ts ADDED Viewed

@@ -0,0 +1,7 @@
+/**
+ * Email notifications via Resend.
+ * Free tier: 100 emails/day — more than enough for automation drafts.
+ *
+ * Set RESEND_API_KEY env var to enable. Without it, notifications are no-ops.
+ */
+export declare function notifyDraftsReady(email: string, count: number): Promise<void>;

package/dist/managed/notify.js ADDED Viewed

@@ -0,0 +1,36 @@
+/**
+ * Email notifications via Resend.
+ * Free tier: 100 emails/day — more than enough for automation drafts.
+ *
+ * Set RESEND_API_KEY env var to enable. Without it, notifications are no-ops.
+ */
+const RESEND_API_KEY = process.env.RESEND_API_KEY;
+const DASHBOARD_URL = process.env.DASHBOARD_URL || "https://api.hanzilla.co/dashboard";
+export async function notifyDraftsReady(email, count) {
+    if (!RESEND_API_KEY) {
+        console.error("[Notify] RESEND_API_KEY not set — skipping email notification");
+        return;
+    }
+    try {
+        const res = await fetch("https://api.resend.com/emails", {
+            method: "POST",
+            headers: {
+                "Authorization": `Bearer ${RESEND_API_KEY}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                from: "Hanzi <notifications@hanzilla.co>",
+                to: email,
+                subject: `${count} X reply draft${count === 1 ? "" : "s"} ready for review`,
+                text: `Your X marketing scout found ${count} opportunity${count === 1 ? "" : "ies"}.\n\nReview and approve them:\n${DASHBOARD_URL}?tab=automations\n\nDrafts are waiting for your approval — nothing gets posted until you say so.`,
+            }),
+        });
+        if (!res.ok) {
+            const body = await res.text();
+            console.error(`[Notify] Resend error ${res.status}: ${body}`);
+        }
+    }
+    catch (err) {
+        console.error(`[Notify] Failed to send email:`, err.message);
+    }
+}

package/dist/managed/scheduler.d.ts ADDED Viewed

@@ -0,0 +1,42 @@
+/**
+ * Scheduler for automated browser tasks
+ *
+ * Checks every 60 seconds for automations whose next_run_at has passed.
+ * Runs scout tasks via the existing agent loop infrastructure.
+ */
+declare let runTaskFn: (params: {
+    workspaceId: string;
+    browserSessionId: string;
+    task: string;
+    url?: string;
+}) => Promise<{
+    taskId: string;
+    answer?: string;
+    status: string;
+}>;
+export declare function initScheduler(deps: {
+    store: typeof import("./store-pg.js");
+    runTask: typeof runTaskFn;
+    isSessionConnected: (id: string) => boolean;
+    notify?: (email: string, count: number) => Promise<void>;
+}): void;
+export declare function startScheduler(): void;
+export declare function stopScheduler(): void;
+interface ParsedDraft {
+    tweetUrl: string;
+    tweetText?: string;
+    tweetAuthorHandle?: string;
+    tweetAuthorName?: string;
+    tweetAuthorBio?: string;
+    tweetAuthorFollowers?: number;
+    tweetEngagement?: Record<string, any>;
+    tweetAgeHours?: number;
+    replyText: string;
+    replyType?: "A" | "B" | "C";
+    replyReasoning?: string;
+    score?: number;
+}
+export declare function parseScoutAnswer(answer: string): ParsedDraft[] | null;
+export declare function computeNextRun(cronExpr: string, timezone?: string): Date | null;
+export declare function buildPostPrompt(tweetUrl: string, replyText: string): string;
+export {};