hanzi-browse 2.2.1 → 2.2.3

package/dist/managed/scheduler.js

@@ -0,0 +1,282 @@
+/**
+ * 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.
+ */
+import { CronExpressionParser } from "cron-parser";
+// These are injected via initScheduler() to avoid circular deps
+let S;
+let runTaskFn;
+let isSessionConnectedFn;
+let notifyFn = null;
+let schedulerInterval = null;
+const MAX_CONSECUTIVE_FAILURES = 3;
+// ── Init ──────────────────────────────────────────────────────────────
+export function initScheduler(deps) {
+    S = deps.store;
+    runTaskFn = deps.runTask;
+    isSessionConnectedFn = deps.isSessionConnected;
+    notifyFn = deps.notify || null;
+}
+export function startScheduler() {
+    if (schedulerInterval)
+        return;
+    schedulerInterval = setInterval(tick, 60_000);
+    console.error("[Scheduler] Started — checking every 60s");
+}
+export function stopScheduler() {
+    if (schedulerInterval) {
+        clearInterval(schedulerInterval);
+        schedulerInterval = null;
+    }
+}
+// ── Tick ──────────────────────────────────────────────────────────────
+async function tick() {
+    try {
+        const due = await S.getDueAutomations();
+        for (const auto of due) {
+            try {
+                await runScoutTask(auto);
+            }
+            catch (err) {
+                console.error(`[Scheduler] Error running automation ${auto.id}:`, err.message);
+            }
+        }
+    }
+    catch (err) {
+        console.error("[Scheduler] Tick error:", err.message);
+    }
+}
+// ── Scout Task ───────────────────────────────────────────────────────
+async function runScoutTask(auto) {
+    const { id, workspaceId, browserSessionId, config } = auto;
+    if (!browserSessionId) {
+        await S.updateAutomation(id, workspaceId, {
+            status: "error",
+            errorMessage: "No browser session configured",
+        });
+        return;
+    }
+    // Check browser is connected
+    if (!isSessionConnectedFn(browserSessionId)) {
+        const failures = auto.consecutiveFailures + 1;
+        if (failures >= MAX_CONSECUTIVE_FAILURES) {
+            await S.updateAutomation(id, workspaceId, {
+                status: "error",
+                consecutiveFailures: failures,
+                errorMessage: "Browser offline at scheduled time",
+            });
+        }
+        else {
+            await S.updateAutomation(id, workspaceId, {
+                consecutiveFailures: failures,
+            });
+        }
+        return;
+    }
+    // Build scout prompt
+    const engagedHandles = await S.getRecentlyEngagedHandles(workspaceId);
+    const prompt = buildScoutPrompt(config, engagedHandles);
+    // Compute next run time
+    const nextRunAt = computeNextRun(config.schedule_cron, config.timezone);
+    // Update automation state (mark as running)
+    await S.updateAutomation(id, workspaceId, {
+        lastRunAt: new Date(),
+        nextRunAt,
+        consecutiveFailures: 0,
+        errorMessage: null,
+    });
+    // Run the task
+    const result = await runTaskFn({
+        workspaceId,
+        browserSessionId,
+        task: prompt,
+        url: "https://x.com",
+    });
+    if (result.status !== "complete" || !result.answer) {
+        await S.updateAutomation(id, workspaceId, {
+            consecutiveFailures: auto.consecutiveFailures + 1,
+            errorMessage: `Scout task failed: ${result.status}`,
+        });
+        return;
+    }
+    // Parse drafts from answer
+    const drafts = parseScoutAnswer(result.answer);
+    if (!drafts || drafts.length === 0) {
+        await S.updateAutomation(id, workspaceId, {
+            errorMessage: "Scout returned no usable drafts",
+        });
+        return;
+    }
+    // Store drafts
+    const stored = await S.createDraftBatch({
+        automationId: id,
+        workspaceId,
+        scoutTaskId: result.taskId,
+        drafts,
+    });
+    // Notify
+    const email = config.notification_email;
+    if (email && notifyFn) {
+        try {
+            await notifyFn(email, stored.length);
+        }
+        catch (err) {
+            console.error(`[Scheduler] Notification failed:`, err.message);
+        }
+    }
+}
+// ── Scout Prompt ─────────────────────────────────────────────────────
+function buildScoutPrompt(config, engagedHandles) {
+    const keywords = (config.keywords || []).join('", "');
+    const maxDrafts = config.max_drafts || 8;
+    const replyMix = config.reply_mix || { a: 40, b: 40, c: 20 };
+    const voiceProfile = config.voice_profile
+        ? JSON.stringify(config.voice_profile, null, 2)
+        : "No voice profile set. Use a casual, helpful developer tone.";
+    const skipList = engagedHandles.length > 0
+        ? engagedHandles.join(", ")
+        : "None yet";
+    return `You are a professional X/Twitter marketing scout. Your job is to find high-value tweets and draft reply suggestions. You NEVER post anything — you only research and draft.
+
+## Product
+Name: ${config.product_name || ""}
+URL: ${config.product_url || ""}
+Description: ${config.product_description || ""}
+
+## Voice Profile
+${voiceProfile}
+
+## Previously engaged handles (do NOT draft replies for these)
+${skipList}
+
+## Instructions
+1. For each keyword below, navigate to the search URL and look at the Latest tab:
+   Keywords: "${keywords}"
+   Search URL pattern: https://x.com/search?q={keyword}&src=typed_query&f=live
+
+2. Scroll through results. Collect 15-20 candidate tweets that are:
+   - Posted within the last 24 hours
+   - From real people (not bots, not brands with millions of followers)
+   - Related to the product's problem space
+   - Have some engagement but aren't viral (5-200 likes ideal)
+
+3. For each promising tweet author, visit their profile briefly to understand who they are.
+
+4. Score each tweet 1-10 based on: relevance, timing, author quality, reply visibility, conversation potential.
+
+5. Select the top ${maxDrafts} tweets.
+
+6. Draft a reply for each. Follow this mix:
+   - Type A (value-only, no product mention): ~${replyMix.a}%
+   - Type B (value + soft mention): ~${replyMix.b}%
+   - Type C (direct recommendation): ~${replyMix.c}%
+
+7. Anti-AI rules for EVERY reply:
+   - Never use em dashes (—), semicolons, or words like "leverage", "harness", "streamline"
+   - Never start with "Hey!", "Great point!", "Love this!"
+   - Under 280 characters. Sound like a text message, not a press release.
+   - Use contractions (don't, can't, it's)
+   - Match the energy of the original poster
+
+8. Return your results as a JSON block at the very end of your response.
+
+## OUTPUT FORMAT (CRITICAL)
+After completing your research, output ONLY this JSON block at the end:
+
+\`\`\`json
+{"drafts": [
+  {
+    "tweet_url": "https://x.com/user/status/123456",
+    "tweet_text": "the original tweet text...",
+    "tweet_author_handle": "@username",
+    "tweet_author_name": "Display Name",
+    "tweet_author_bio": "their bio...",
+    "tweet_author_followers": 2100,
+    "tweet_engagement": {"likes": 12, "replies": 3, "retweets": 1},
+    "tweet_age_hours": 2.5,
+    "reply_text": "your drafted reply text here",
+    "reply_type": "B",
+    "reply_reasoning": "Why this tweet and this reply approach",
+    "score": 8
+  }
+]}
+\`\`\`
+
+Output ONLY this JSON block at the end. No other text after it.`;
+}
+export function parseScoutAnswer(answer) {
+    let raw;
+    // Try: ```json ... ``` block
+    const fenced = answer.match(/```json\s*([\s\S]*?)```/);
+    if (fenced) {
+        try {
+            raw = JSON.parse(fenced[1]);
+        }
+        catch { }
+    }
+    // Try: raw JSON starting with {"drafts"
+    if (!raw) {
+        const jsonStart = answer.lastIndexOf('{"drafts"');
+        if (jsonStart !== -1) {
+            try {
+                raw = JSON.parse(answer.slice(jsonStart));
+            }
+            catch { }
+        }
+    }
+    // Try: raw JSON array starting with [
+    if (!raw) {
+        const arrStart = answer.lastIndexOf('[{');
+        if (arrStart !== -1) {
+            try {
+                const parsed = JSON.parse(answer.slice(arrStart));
+                if (Array.isArray(parsed))
+                    raw = { drafts: parsed };
+            }
+            catch { }
+        }
+    }
+    if (!raw?.drafts || !Array.isArray(raw.drafts))
+        return null;
+    // Normalize field names (LLM might use snake_case)
+    return raw.drafts
+        .filter((d) => d.tweet_url && d.reply_text)
+        .map((d) => ({
+        tweetUrl: d.tweet_url,
+        tweetText: d.tweet_text,
+        tweetAuthorHandle: d.tweet_author_handle,
+        tweetAuthorName: d.tweet_author_name,
+        tweetAuthorBio: d.tweet_author_bio,
+        tweetAuthorFollowers: d.tweet_author_followers,
+        tweetEngagement: d.tweet_engagement,
+        tweetAgeHours: d.tweet_age_hours,
+        replyText: d.reply_text,
+        replyType: d.reply_type,
+        replyReasoning: d.reply_reasoning,
+        score: d.score,
+    }));
+}
+// ── Cron Helpers ─────────────────────────────────────────────────────
+export function computeNextRun(cronExpr, timezone) {
+    try {
+        const interval = CronExpressionParser.parse(cronExpr, {
+            tz: timezone || "UTC",
+        });
+        return interval.next().toDate();
+    }
+    catch {
+        return null;
+    }
+}
+// Post prompt for approved drafts
+export function buildPostPrompt(tweetUrl, replyText) {
+    return `Go to ${tweetUrl}
+
+Click the reply button. Type this exact text in the reply box:
+
+${replyText}
+
+Click the post/reply button to submit. Confirm the reply was posted successfully.`;
+}

package/dist/managed/store-pg.d.ts

@@ -188,4 +188,120 @@ export declare function ensureDefaultWorkspace(): Promise<{
     workspace: Workspace;
     apiKey: ApiKey;
 }>;
+export interface Automation {
+    id: string;
+    workspaceId: string;
+    browserSessionId?: string;
+    type: string;
+    status: "active" | "paused" | "error";
+    config: Record<string, any>;
+    lastRunAt?: number;
+    nextRunAt?: number;
+    consecutiveFailures: number;
+    errorMessage?: string;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface AutomationDraft {
+    id: string;
+    automationId: string;
+    workspaceId: string;
+    scoutTaskId?: string;
+    batchId: string;
+    status: "pending" | "approved" | "edited" | "skipped" | "posted" | "failed";
+    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;
+    postTaskId?: string;
+    postedAt?: number;
+    editedText?: string;
+    createdAt: number;
+}
+export interface EngagementEntry {
+    id: string;
+    workspaceId: string;
+    automationId?: string;
+    draftId?: string;
+    authorHandle: string;
+    replyType?: string;
+    keyword?: string;
+    tweetUrl?: string;
+    tweetSummary?: string;
+    replySummary?: string;
+    postedAt: number;
+}
+export declare function createAutomation(params: {
+    workspaceId: string;
+    browserSessionId: string;
+    type?: string;
+    config: Record<string, any>;
+    nextRunAt?: Date;
+}): Promise<Automation>;
+export declare function getAutomation(id: string): Promise<Automation | null>;
+export declare function listAutomations(workspaceId: string): Promise<Automation[]>;
+export declare function updateAutomation(id: string, workspaceId: string, fields: Partial<{
+    browserSessionId: string;
+    status: Automation["status"];
+    config: Record<string, any>;
+    lastRunAt: Date;
+    nextRunAt: Date | null;
+    consecutiveFailures: number;
+    errorMessage: string | null;
+}>): Promise<Automation | null>;
+export declare function deleteAutomation(id: string, workspaceId: string): Promise<boolean>;
+export declare function getDueAutomations(): Promise<Automation[]>;
+export declare function createDraftBatch(params: {
+    automationId: string;
+    workspaceId: string;
+    scoutTaskId: string;
+    drafts: Array<{
+        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;
+    }>;
+}): Promise<AutomationDraft[]>;
+export declare function listDrafts(workspaceId: string, filters?: {
+    status?: string;
+    automationId?: string;
+    batchId?: string;
+    limit?: number;
+}): Promise<AutomationDraft[]>;
+export declare function getDraft(id: string): Promise<AutomationDraft | null>;
+export declare function updateDraft(id: string, workspaceId: string, fields: Partial<{
+    status: AutomationDraft["status"];
+    editedText: string;
+    postTaskId: string;
+    postedAt: Date;
+}>): Promise<AutomationDraft | null>;
+export declare function logEngagement(params: {
+    workspaceId: string;
+    automationId?: string;
+    draftId?: string;
+    authorHandle: string;
+    replyType?: string;
+    keyword?: string;
+    tweetUrl?: string;
+    tweetSummary?: string;
+    replySummary?: string;
+}): Promise<void>;
+export declare function getRecentlyEngagedHandles(workspaceId: string, daysBack?: number): Promise<string[]>;
+export declare function listEngagements(workspaceId: string, limit?: number): Promise<EngagementEntry[]>;
 export declare function startHeartbeatFlush(): void;

package/dist/managed/store-pg.js

@@ -473,6 +473,221 @@ export async function ensureDefaultWorkspace() {
     const apiKey = await createApiKey(workspace.id, "default");
     return { workspace, apiKey };
 }
+function rowToAutomation(r) {
+    return {
+        id: r.id,
+        workspaceId: r.workspace_id,
+        browserSessionId: r.browser_session_id || undefined,
+        type: r.type,
+        status: r.status,
+        config: r.config || {},
+        lastRunAt: r.last_run_at ? new Date(r.last_run_at).getTime() : undefined,
+        nextRunAt: r.next_run_at ? new Date(r.next_run_at).getTime() : undefined,
+        consecutiveFailures: r.consecutive_failures ?? 0,
+        errorMessage: r.error_message || undefined,
+        createdAt: new Date(r.created_at).getTime(),
+        updatedAt: new Date(r.updated_at).getTime(),
+    };
+}
+function rowToDraft(r) {
+    return {
+        id: r.id,
+        automationId: r.automation_id,
+        workspaceId: r.workspace_id,
+        scoutTaskId: r.scout_task_id || undefined,
+        batchId: r.batch_id,
+        status: r.status,
+        tweetUrl: r.tweet_url,
+        tweetText: r.tweet_text || undefined,
+        tweetAuthorHandle: r.tweet_author_handle || undefined,
+        tweetAuthorName: r.tweet_author_name || undefined,
+        tweetAuthorBio: r.tweet_author_bio || undefined,
+        tweetAuthorFollowers: r.tweet_author_followers ?? undefined,
+        tweetEngagement: r.tweet_engagement || undefined,
+        tweetAgeHours: r.tweet_age_hours != null ? parseFloat(r.tweet_age_hours) : undefined,
+        replyText: r.reply_text,
+        replyType: r.reply_type || undefined,
+        replyReasoning: r.reply_reasoning || undefined,
+        score: r.score ?? undefined,
+        postTaskId: r.post_task_id || undefined,
+        postedAt: r.posted_at ? new Date(r.posted_at).getTime() : undefined,
+        editedText: r.edited_text || undefined,
+        createdAt: new Date(r.created_at).getTime(),
+    };
+}
+export async function createAutomation(params) {
+    const id = randomUUID();
+    const now = new Date();
+    const res = await db().query(`INSERT INTO automations (id, workspace_id, browser_session_id, type, config, next_run_at, created_at, updated_at)
+     VALUES ($1, $2, $3, $4, $5, $6, $7, $7) RETURNING *`, [id, params.workspaceId, params.browserSessionId, params.type || "x-marketer", JSON.stringify(params.config), params.nextRunAt || null, now]);
+    return rowToAutomation(res.rows[0]);
+}
+export async function getAutomation(id) {
+    const res = await db().query("SELECT * FROM automations WHERE id = $1", [id]);
+    if (res.rows.length === 0)
+        return null;
+    return rowToAutomation(res.rows[0]);
+}
+export async function listAutomations(workspaceId) {
+    const res = await db().query("SELECT * FROM automations WHERE workspace_id = $1 ORDER BY created_at DESC", [workspaceId]);
+    return res.rows.map(rowToAutomation);
+}
+export async function updateAutomation(id, workspaceId, fields) {
+    const sets = [];
+    const vals = [];
+    let idx = 1;
+    if (fields.browserSessionId !== undefined) {
+        sets.push(`browser_session_id = $${idx++}`);
+        vals.push(fields.browserSessionId);
+    }
+    if (fields.status !== undefined) {
+        sets.push(`status = $${idx++}`);
+        vals.push(fields.status);
+    }
+    if (fields.config !== undefined) {
+        sets.push(`config = $${idx++}`);
+        vals.push(JSON.stringify(fields.config));
+    }
+    if (fields.lastRunAt !== undefined) {
+        sets.push(`last_run_at = $${idx++}`);
+        vals.push(fields.lastRunAt);
+    }
+    if (fields.nextRunAt !== undefined) {
+        sets.push(`next_run_at = $${idx++}`);
+        vals.push(fields.nextRunAt);
+    }
+    if (fields.consecutiveFailures !== undefined) {
+        sets.push(`consecutive_failures = $${idx++}`);
+        vals.push(fields.consecutiveFailures);
+    }
+    if (fields.errorMessage !== undefined) {
+        sets.push(`error_message = $${idx++}`);
+        vals.push(fields.errorMessage);
+    }
+    if (sets.length === 0)
+        return getAutomation(id);
+    sets.push(`updated_at = $${idx++}`);
+    vals.push(new Date());
+    vals.push(id);
+    vals.push(workspaceId);
+    const res = await db().query(`UPDATE automations SET ${sets.join(", ")} WHERE id = $${idx++} AND workspace_id = $${idx} RETURNING *`, vals);
+    if (res.rows.length === 0)
+        return null;
+    return rowToAutomation(res.rows[0]);
+}
+export async function deleteAutomation(id, workspaceId) {
+    const res = await db().query("DELETE FROM automations WHERE id = $1 AND workspace_id = $2", [id, workspaceId]);
+    return (res.rowCount ?? 0) > 0;
+}
+export async function getDueAutomations() {
+    const res = await db().query("SELECT * FROM automations WHERE status = 'active' AND next_run_at <= NOW()");
+    return res.rows.map(rowToAutomation);
+}
+// --- Automation Drafts ---
+export async function createDraftBatch(params) {
+    const batchId = randomUUID();
+    const results = [];
+    for (const d of params.drafts) {
+        const id = randomUUID();
+        const res = await db().query(`INSERT INTO automation_drafts
+       (id, automation_id, workspace_id, scout_task_id, batch_id,
+        tweet_url, tweet_text, tweet_author_handle, tweet_author_name, tweet_author_bio,
+        tweet_author_followers, tweet_engagement, tweet_age_hours,
+        reply_text, reply_type, reply_reasoning, score)
+       VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17)
+       RETURNING *`, [id, params.automationId, params.workspaceId, params.scoutTaskId, batchId,
+            d.tweetUrl, d.tweetText || null, d.tweetAuthorHandle || null, d.tweetAuthorName || null, d.tweetAuthorBio || null,
+            d.tweetAuthorFollowers ?? null, d.tweetEngagement ? JSON.stringify(d.tweetEngagement) : null, d.tweetAgeHours ?? null,
+            d.replyText, d.replyType || null, d.replyReasoning || null, d.score ?? null]);
+        results.push(rowToDraft(res.rows[0]));
+    }
+    return results;
+}
+export async function listDrafts(workspaceId, filters) {
+    const where = ["workspace_id = $1"];
+    const vals = [workspaceId];
+    let idx = 2;
+    if (filters?.status) {
+        where.push(`status = $${idx++}`);
+        vals.push(filters.status);
+    }
+    if (filters?.automationId) {
+        where.push(`automation_id = $${idx++}`);
+        vals.push(filters.automationId);
+    }
+    if (filters?.batchId) {
+        where.push(`batch_id = $${idx++}`);
+        vals.push(filters.batchId);
+    }
+    const limit = filters?.limit || 50;
+    const res = await db().query(`SELECT * FROM automation_drafts WHERE ${where.join(" AND ")} ORDER BY score DESC NULLS LAST, created_at DESC LIMIT ${limit}`, vals);
+    return res.rows.map(rowToDraft);
+}
+export async function getDraft(id) {
+    const res = await db().query("SELECT * FROM automation_drafts WHERE id = $1", [id]);
+    if (res.rows.length === 0)
+        return null;
+    return rowToDraft(res.rows[0]);
+}
+export async function updateDraft(id, workspaceId, fields) {
+    const sets = [];
+    const vals = [];
+    let idx = 1;
+    if (fields.status !== undefined) {
+        sets.push(`status = $${idx++}`);
+        vals.push(fields.status);
+    }
+    if (fields.editedText !== undefined) {
+        sets.push(`edited_text = $${idx++}`);
+        vals.push(fields.editedText);
+    }
+    if (fields.postTaskId !== undefined) {
+        sets.push(`post_task_id = $${idx++}`);
+        vals.push(fields.postTaskId);
+    }
+    if (fields.postedAt !== undefined) {
+        sets.push(`posted_at = $${idx++}`);
+        vals.push(fields.postedAt);
+    }
+    if (sets.length === 0)
+        return getDraft(id);
+    vals.push(id);
+    vals.push(workspaceId);
+    const res = await db().query(`UPDATE automation_drafts SET ${sets.join(", ")} WHERE id = $${idx++} AND workspace_id = $${idx} RETURNING *`, vals);
+    if (res.rows.length === 0)
+        return null;
+    return rowToDraft(res.rows[0]);
+}
+// --- Engagement Log ---
+export async function logEngagement(params) {
+    await db().query(`INSERT INTO engagement_log
+     (id, workspace_id, automation_id, draft_id, author_handle, reply_type, keyword, tweet_url, tweet_summary, reply_summary)
+     VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10)`, [randomUUID(), params.workspaceId, params.automationId || null, params.draftId || null,
+        params.authorHandle, params.replyType || null, params.keyword || null,
+        params.tweetUrl || null, params.tweetSummary || null, params.replySummary || null]);
+}
+export async function getRecentlyEngagedHandles(workspaceId, daysBack = 30) {
+    const res = await db().query(`SELECT DISTINCT author_handle FROM engagement_log
+     WHERE workspace_id = $1 AND posted_at > NOW() - INTERVAL '1 day' * $2
+     ORDER BY author_handle`, [workspaceId, daysBack]);
+    return res.rows.map((r) => r.author_handle);
+}
+export async function listEngagements(workspaceId, limit = 50) {
+    const res = await db().query(`SELECT * FROM engagement_log WHERE workspace_id = $1 ORDER BY posted_at DESC LIMIT $2`, [workspaceId, limit]);
+    return res.rows.map((r) => ({
+        id: r.id,
+        workspaceId: r.workspace_id,
+        automationId: r.automation_id || undefined,
+        draftId: r.draft_id || undefined,
+        authorHandle: r.author_handle,
+        replyType: r.reply_type || undefined,
+        keyword: r.keyword || undefined,
+        tweetUrl: r.tweet_url || undefined,
+        tweetSummary: r.tweet_summary || undefined,
+        replySummary: r.reply_summary || undefined,
+        postedAt: new Date(r.posted_at).getTime(),
+    }));
+}
 // --- Heartbeat flush (no-op for Postgres, queries go to DB directly) ---
 export function startHeartbeatFlush() {
     // Not needed for Postgres — heartbeatSession writes to DB directly

package/dist/managed/store.d.ts

@@ -186,3 +186,16 @@ export declare function ensureDefaultWorkspace(): {
     workspace: Workspace;
     apiKey: ApiKey;
 };
+export declare function createAutomation(_p: any): Promise<any>;
+export declare function getAutomation(_id: string): Promise<any>;
+export declare function listAutomations(_wid: string): Promise<any[]>;
+export declare function updateAutomation(_id: string, _wid: string, _f: any): Promise<any>;
+export declare function deleteAutomation(_id: string, _wid: string): Promise<boolean>;
+export declare function getDueAutomations(): Promise<any[]>;
+export declare function createDraftBatch(_p: any): Promise<any[]>;
+export declare function listDrafts(_wid: string, _f?: any): Promise<any[]>;
+export declare function getDraft(_id: string): Promise<any>;
+export declare function updateDraft(_id: string, _wid: string, _f: any): Promise<any>;
+export declare function logEngagement(_p: any): Promise<void>;
+export declare function getRecentlyEngagedHandles(_wid: string, _d?: number): Promise<string[]>;
+export declare function listEngagements(_wid: string, _l?: number): Promise<any[]>;

package/dist/managed/store.js

@@ -377,3 +377,18 @@ export function ensureDefaultWorkspace() {
     const apiKey = createApiKey(workspace.id, "default");
     return { workspace, apiKey };
 }
+// --- Automation stubs (file store doesn't support automations — Postgres only) ---
+const NOT_SUPPORTED = "Automations require Postgres (set DATABASE_URL)";
+export async function createAutomation(_p) { throw new Error(NOT_SUPPORTED); }
+export async function getAutomation(_id) { return null; }
+export async function listAutomations(_wid) { return []; }
+export async function updateAutomation(_id, _wid, _f) { return null; }
+export async function deleteAutomation(_id, _wid) { return false; }
+export async function getDueAutomations() { return []; }
+export async function createDraftBatch(_p) { return []; }
+export async function listDrafts(_wid, _f) { return []; }
+export async function getDraft(_id) { return null; }
+export async function updateDraft(_id, _wid, _f) { return null; }
+export async function logEngagement(_p) { }
+export async function getRecentlyEngagedHandles(_wid, _d) { return []; }
+export async function listEngagements(_wid, _l) { return []; }

package/dist/managed/telemetry.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Telemetry for the managed backend (api.hanzilla.co).
+ * Gated by SENTRY_DSN and POSTHOG_API_KEY env vars — no-op in dev.
+ */
+export declare function initManagedTelemetry(): void;
+export declare function trackManagedEvent(name: string, workspaceId: string, properties?: Record<string, any>): void;
+export declare function captureManagedError(error: Error, context?: Record<string, string>): void;
+export declare function shutdownManagedTelemetry(): Promise<void>;