screenhand 0.2.0 → 0.3.1

package/dist/scripts/orchestrator-daemon.js

@@ -0,0 +1,399 @@
+#!/usr/bin/env npx tsx
+/**
+ * Orchestrator Daemon — multi-agent task router and coordinator.
+ *
+ * Manages a pool of worker slots that process tasks in parallel:
+ *   - Web slots (CDP-only): truly parallel, no mouse/keyboard conflict
+ *   - Native slots: serialized per-app via lease locks
+ *
+ * Each worker slot runs a JobRunner independently. The orchestrator
+ * routes tasks to the right slot type and manages coordination.
+ *
+ * Usage:
+ *   npx tsx scripts/orchestrator-daemon.ts
+ *   npx tsx scripts/orchestrator-daemon.ts --web-slots 4 --native-slots 1 --poll 1000
+ *
+ * State files:
+ *   ~/.screenhand/orchestrator/state.json         — orchestrator state
+ *   ~/.screenhand/orchestrator/orchestrator.pid   — PID of this process
+ *   ~/.screenhand/orchestrator/orchestrator.log   — log output
+ */
+import path from "node:path";
+import fs from "node:fs";
+import os from "node:os";
+import { BridgeClient } from "../src/native/bridge-client.js";
+import { SessionSupervisor, LeaseManager } from "../src/supervisor/supervisor.js";
+import { JobManager } from "../src/jobs/manager.js";
+import { JobRunner } from "../src/jobs/runner.js";
+import { PlaybookEngine } from "../src/playbook/engine.js";
+import { PlaybookStore } from "../src/playbook/store.js";
+import { AccessibilityAdapter } from "../src/runtime/accessibility-adapter.js";
+import { AutomationRuntimeService } from "../src/runtime/service.js";
+import { TimelineLogger } from "../src/logging/timeline-logger.js";
+import { MemoryService } from "../src/memory/service.js";
+import { writeOrchestratorState, getOrchestratorDaemonPid } from "../src/orchestrator/state.js";
+import { ORCHESTRATOR_DIR, ORCHESTRATOR_PID_FILE, ORCHESTRATOR_LOG_FILE } from "../src/orchestrator/types.js";
+// ── Config from CLI args ──
+const args = process.argv.slice(2);
+function getArg(name, fallback) {
+    const idx = args.indexOf("--" + name);
+    if (idx === -1)
+        return fallback;
+    return args[idx + 1] ?? fallback;
+}
+const WEB_SLOTS = Number(getArg("web-slots", "4"));
+const NATIVE_SLOTS = Number(getArg("native-slots", "1"));
+const POLL_MS = Number(getArg("poll", "1000"));
+// ── Directories ──
+const JOB_DIR = path.join(os.homedir(), ".screenhand", "jobs");
+const LOCK_DIR = path.join(os.homedir(), ".screenhand", "locks");
+const PLAYBOOKS_DIR = path.join(os.homedir(), ".screenhand", "playbooks");
+const SUPERVISOR_STATE_DIR = path.join(os.homedir(), ".screenhand", "supervisor");
+fs.mkdirSync(ORCHESTRATOR_DIR, { recursive: true });
+fs.mkdirSync(JOB_DIR, { recursive: true });
+// ── Logging ──
+const logStream = fs.createWriteStream(ORCHESTRATOR_LOG_FILE, { flags: "a" });
+let daemonized = false;
+function log(msg) {
+    const line = `[${new Date().toISOString()}] ${msg}`;
+    logStream.write(line + "\n");
+    if (!daemonized)
+        process.stderr.write(line + "\n");
+}
+// ── Bridge setup ──
+const scriptDir = import.meta.dirname ?? path.dirname(new URL(import.meta.url).pathname);
+const projectRoot = scriptDir.includes("/dist/")
+    ? path.resolve(scriptDir, "../..")
+    : path.resolve(scriptDir, "..");
+const bridgePath = process.platform === "win32"
+    ? path.resolve(projectRoot, "native/windows-bridge/bin/Release/net8.0-windows/windows-bridge.exe")
+    : path.resolve(projectRoot, "native/macos-bridge/.build/release/macos-bridge");
+// Each worker slot gets its own bridge for true parallelism
+function createBridge() {
+    return new BridgeClient(bridgePath);
+}
+// ── Shared services ──
+const leaseManager = new LeaseManager(LOCK_DIR);
+const supervisor = new SessionSupervisor({
+    stateDir: SUPERVISOR_STATE_DIR,
+    lockDir: LOCK_DIR,
+});
+const memory = new MemoryService(os.homedir());
+const jobManager = new JobManager({ jobDir: JOB_DIR, memory, supervisor });
+jobManager.init();
+const playbookStore = new PlaybookStore(PLAYBOOKS_DIR);
+// ── State ──
+let stopped = false;
+const startedAt = new Date().toISOString();
+let totalSubmitted = 0;
+let totalCompleted = 0;
+let totalFailed = 0;
+// Task queue — loaded from / persisted to state.json
+let taskQueue = [];
+// Worker slots
+const workers = [];
+const workerRunners = new Map();
+// App locks for native tasks — bundleId → worker slot ID
+const nativeLocks = new Map();
+// ── Worker slot initialization ──
+async function initWorkerSlots() {
+    let slotId = 0;
+    // Web slots
+    for (let i = 0; i < WEB_SLOTS; i++) {
+        const slot = {
+            id: slotId,
+            type: "web",
+            busy: false,
+            tasksCompleted: 0,
+            tasksFailed: 0,
+        };
+        workers.push(slot);
+        const bridge = createBridge();
+        await bridge.start();
+        const adapter = new AccessibilityAdapter(bridge);
+        const logger = new TimelineLogger();
+        const runtimeService = new AutomationRuntimeService(adapter, logger);
+        const playbookEngine = new PlaybookEngine(runtimeService);
+        const runner = new JobRunner(bridge, jobManager, leaseManager, supervisor, {
+            playbookEngine,
+            playbookStore,
+            runtimeService,
+            onLog: (msg) => log(`[W${slotId}] ${msg}`),
+        });
+        workerRunners.set(slotId, { runner, bridge, busy: false });
+        slotId++;
+    }
+    // Native slots
+    for (let i = 0; i < NATIVE_SLOTS; i++) {
+        const slot = {
+            id: slotId,
+            type: "native",
+            busy: false,
+            tasksCompleted: 0,
+            tasksFailed: 0,
+        };
+        workers.push(slot);
+        const bridge = createBridge();
+        await bridge.start();
+        const adapter = new AccessibilityAdapter(bridge);
+        const logger = new TimelineLogger();
+        const runtimeService = new AutomationRuntimeService(adapter, logger);
+        const playbookEngine = new PlaybookEngine(runtimeService);
+        const runner = new JobRunner(bridge, jobManager, leaseManager, supervisor, {
+            playbookEngine,
+            playbookStore,
+            runtimeService,
+            onLog: (msg) => log(`[W${slotId}] ${msg}`),
+        });
+        workerRunners.set(slotId, { runner, bridge, busy: false });
+        slotId++;
+    }
+    log(`Initialized ${WEB_SLOTS} web slots + ${NATIVE_SLOTS} native slots = ${workers.length} total`);
+}
+// ── Task routing ──
+function findAvailableSlot(task) {
+    if (task.mode === "web") {
+        // Any free web slot
+        return workers.find(w => w.type === "web" && !w.busy) ?? null;
+    }
+    if (task.mode === "native" || task.mode === "mixed") {
+        // Native tasks need a free native slot AND the app must not be locked by another slot
+        const bundleId = task.bundleId ?? "unknown";
+        const lockHolder = nativeLocks.get(bundleId);
+        if (lockHolder !== undefined) {
+            // App is locked — only the lock holder can work on it
+            const slot = workers.find(w => w.id === lockHolder && !w.busy);
+            return slot ?? null;
+        }
+        // No lock — find any free native slot
+        return workers.find(w => w.type === "native" && !w.busy) ?? null;
+    }
+    return null;
+}
+// ── Task → Job conversion ──
+function taskToJobParams(task) {
+    return {
+        task: task.task,
+        ...(task.playbookId !== undefined ? { playbookId: task.playbookId } : {}),
+        ...(task.bundleId !== undefined ? { bundleId: task.bundleId } : {}),
+        ...(task.windowId !== undefined ? { windowId: task.windowId } : {}),
+        ...(task.vars ? { vars: task.vars } : {}),
+        priority: task.priority,
+        tags: ["orchestrator", `task_${task.id}`],
+    };
+}
+// ── Task dispatch ──
+async function dispatchTask(task, slot) {
+    const worker = workerRunners.get(slot.id);
+    if (!worker)
+        return;
+    // Mark slot as busy
+    slot.busy = true;
+    slot.currentTaskId = task.id;
+    worker.busy = true;
+    // Lock native app
+    if ((task.mode === "native" || task.mode === "mixed") && task.bundleId) {
+        nativeLocks.set(task.bundleId, slot.id);
+    }
+    // Update task status
+    task.status = "assigned";
+    task.assignedWorker = slot.id;
+    task.startedAt = new Date().toISOString();
+    log(`Dispatching task ${task.id} ("${task.task.slice(0, 50)}") to slot ${slot.id} (${slot.type})`);
+    // Create a job for this task
+    const jobParams = taskToJobParams(task);
+    const job = jobManager.create(jobParams);
+    task.jobId = job.id;
+    task.status = "running";
+    persistState();
+    // Run the job asynchronously
+    try {
+        const result = await worker.runner.run();
+        if (result) {
+            task.result = `${result.finalState}: ${result.stepsCompleted}/${result.totalSteps} steps in ${result.durationMs}ms`;
+            if (result.finalState === "done") {
+                task.status = "done";
+                slot.tasksCompleted++;
+                totalCompleted++;
+                log(`Task ${task.id} completed (${result.durationMs}ms)`);
+            }
+            else if (result.finalState === "blocked" || result.finalState === "waiting_human") {
+                task.status = "blocked";
+                task.error = result.error ?? "Blocked";
+                log(`Task ${task.id} blocked: ${result.error ?? "unknown"}`);
+            }
+            else {
+                task.status = "failed";
+                task.error = result.error ?? "Failed";
+                slot.tasksFailed++;
+                totalFailed++;
+                log(`Task ${task.id} failed: ${result.error ?? "unknown"}`);
+            }
+        }
+        else {
+            // No job was dequeued — it may have been picked up already
+            task.status = "failed";
+            task.error = "No job to dequeue";
+            slot.tasksFailed++;
+            totalFailed++;
+        }
+    }
+    catch (err) {
+        task.status = "failed";
+        task.error = err instanceof Error ? err.message : String(err);
+        slot.tasksFailed++;
+        totalFailed++;
+        log(`Task ${task.id} error: ${task.error}`);
+    }
+    // Release slot
+    task.completedAt = new Date().toISOString();
+    slot.busy = false;
+    delete slot.currentTaskId;
+    worker.busy = false;
+    // Release native app lock
+    if ((task.mode === "native" || task.mode === "mixed") && task.bundleId) {
+        nativeLocks.delete(task.bundleId);
+    }
+    persistState();
+}
+// ── State persistence ──
+function buildState() {
+    const nativeLocksObj = {};
+    for (const [k, v] of nativeLocks)
+        nativeLocksObj[k] = v;
+    return {
+        pid: process.pid,
+        running: !stopped,
+        startedAt,
+        workers: [...workers],
+        webSlots: WEB_SLOTS,
+        nativeSlots: NATIVE_SLOTS,
+        tasks: taskQueue,
+        totalSubmitted,
+        totalCompleted,
+        totalFailed,
+        nativeLocks: nativeLocksObj,
+    };
+}
+function persistState() {
+    try {
+        writeOrchestratorState(buildState());
+    }
+    catch {
+        // Non-fatal
+    }
+}
+// ── Load tasks from state (resume after restart) ──
+function loadState() {
+    try {
+        const state = readExistingState();
+        if (state && state.tasks) {
+            // Resume queued/running tasks
+            for (const task of state.tasks) {
+                if (task.status === "queued" || task.status === "assigned" || task.status === "running") {
+                    task.status = "queued"; // Re-queue interrupted tasks
+                    delete task.assignedWorker;
+                    taskQueue.push(task);
+                }
+            }
+            totalSubmitted = state.totalSubmitted ?? 0;
+            totalCompleted = state.totalCompleted ?? 0;
+            totalFailed = state.totalFailed ?? 0;
+            if (taskQueue.length > 0) {
+                log(`Resumed ${taskQueue.length} tasks from previous state`);
+            }
+        }
+    }
+    catch {
+        // Fresh start
+    }
+}
+function readExistingState() {
+    try {
+        const data = fs.readFileSync(path.join(ORCHESTRATOR_DIR, "state.json"), "utf-8");
+        return JSON.parse(data);
+    }
+    catch {
+        return null;
+    }
+}
+// ── Main poll loop ──
+async function poll() {
+    // Also reload playbooks periodically
+    playbookStore.load();
+    // Sort queue by priority (lower = higher priority)
+    const queued = taskQueue
+        .filter(t => t.status === "queued")
+        .sort((a, b) => a.priority - b.priority);
+    // Dispatch tasks to available slots
+    const dispatches = [];
+    for (const task of queued) {
+        const slot = findAvailableSlot(task);
+        if (slot) {
+            // Dispatch in parallel — don't await here
+            dispatches.push(dispatchTask(task, slot));
+        }
+    }
+    // Wait for all dispatched tasks in this cycle
+    if (dispatches.length > 0) {
+        await Promise.allSettled(dispatches);
+    }
+}
+async function main() {
+    // Enforce single daemon
+    const existingPid = getOrchestratorDaemonPid();
+    if (existingPid !== null && existingPid !== process.pid) {
+        log(`Another orchestrator daemon already running (pid=${existingPid}). Aborting.`);
+        process.exit(1);
+    }
+    fs.writeFileSync(ORCHESTRATOR_PID_FILE, String(process.pid));
+    daemonized = true;
+    log(`Orchestrator daemon started (pid=${process.pid})`);
+    log(`Config: web-slots=${WEB_SLOTS} native-slots=${NATIVE_SLOTS} poll=${POLL_MS}ms`);
+    // Load previous state
+    loadState();
+    // Initialize worker slots (each with its own bridge)
+    await initWorkerSlots();
+    persistState();
+    // Poll loop
+    while (!stopped) {
+        try {
+            await poll();
+        }
+        catch (err) {
+            log(`Poll error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        await sleep(POLL_MS);
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+// ── Graceful shutdown ──
+process.on("SIGINT", shutdown);
+process.on("SIGTERM", shutdown);
+async function shutdown() {
+    if (stopped)
+        return;
+    stopped = true;
+    log("Shutting down...");
+    // Stop all worker bridges
+    for (const [, w] of workerRunners) {
+        try {
+            await w.bridge.stop();
+        }
+        catch { /* ignore */ }
+    }
+    persistState();
+    try {
+        fs.unlinkSync(ORCHESTRATOR_PID_FILE);
+    }
+    catch { /* ignore */ }
+    logStream.end();
+    log(`Orchestrator exiting (${totalCompleted} done, ${totalFailed} failed)`);
+    process.exit(0);
+}
+main().catch((err) => {
+    log(`Fatal: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+});

package/dist/scripts/threads-campaign.js

@@ -0,0 +1,208 @@
+/**
+ * ScreenHand Twitter/X 2-Hour Campaign Runner
+ *
+ * Executes the engagement cadence from threads-campaign.md
+ * Uses ScreenHand MCP tools via direct function calls
+ *
+ * Usage: tsx scripts/threads-campaign.ts
+ * With cron/loop: keeps alive for 2 hours
+ */
+import { join } from 'path';
+// Campaign config
+const CONFIG = {
+    duration: 2 * 60 * 60 * 1000, // 2 hours in ms
+    tabId: '', // filled at runtime
+    searchQueries: [
+        '"MCP server" -is:retweet',
+        '"AI agent" automation -is:retweet',
+        '"Claude Code" -is:retweet',
+        '"desktop automation" -is:retweet',
+        '"Selenium frustrating" OR "Playwright broken" -is:retweet',
+        '"browser automation" -is:retweet',
+        '"Figma to code" -is:retweet',
+    ],
+    tweets: [
+        {
+            time: 0,
+            content: `AI agents can think, code, and reason.
+
+But they can't click a button.
+
+That's the gap ScreenHand fills — an MCP server giving any AI agent native desktop control on macOS + Windows.
+
+No API keys. No cloud. No fixed scripts. Just real OS-level control. 82 tools. One protocol.`
+        },
+        {
+            time: 20,
+            content: `If your automation breaks when a button moves 10 pixels, you don't have automation. You have a time bomb.
+
+ScreenHand doesn't rely on fixed selectors. It uses fallback chains:
+
+Accessibility API → CDP → Vision → AppleScript
+
+If one fails, it adapts. It also remembers what worked — gets faster every run.`
+        },
+        {
+            time: 40,
+            content: `The AI stack everyone's sleeping on:
+
+Claude Code → thinks + codes
+Figma MCP → design tokens
+ScreenHand → opens the actual browser, verifies pixels, clicks deploy
+
+What takes 45 min manually takes 3 min with this stack. The AI has a brain. ScreenHand gives it hands.`
+        },
+        {
+            time: 60,
+            content: `Every cloud automation tool has the same problem — your credentials pass through someone else's server.
+
+ScreenHand runs locally. On your machine. No cloud relay. No API keys to leak. No third-party credential storage.
+
+AGPL licensed. You own it completely.`
+        },
+        {
+            time: 80,
+            content: `Building AI agents? Here's what nobody tells you:
+
+The hardest part isn't the reasoning. It's the last mile — actually executing actions in real software.
+
+We built ScreenHand because we hit this wall ourselves. 82 MCP tools later, our agents can control any app on the desktop.
+
+What are you building?`
+        },
+        {
+            time: 100,
+            content: `What ScreenHand can do in one MCP call:
+
+- browser_human_click — clicks like a real human, anti-detection built in
+- memory_recall — remembers patterns from previous runs
+- execution_plan — plans multi-step workflows with fallback strategies
+- export_playbook — saves learned flows for autonomous replay
+
+Not scripts. Not recordings. Adaptive execution.`
+        },
+    ],
+    replyTemplates: [
+        `This is exactly why we built ScreenHand — the execution layer is the missing piece. Agents can reason but need OS-level control to do real work. We use accessibility APIs + CDP, not screenshots.`,
+        `Interesting approach. One thing we've found — the fallback chain matters more than any single method. AX API fails? Try CDP. CDP fails? Try Vision. Resilience > precision.`,
+        `Have you tried giving your agent actual desktop control? We built an MCP server (ScreenHand) that lets Claude/GPT control any app natively. Game changer for automation.`,
+        `MCP is the right protocol for this. We built ScreenHand as an MCP server — 82 tools for desktop + browser automation. Any MCP client can drive it.`,
+        `The composability of MCP is what makes it powerful. ScreenHand (desktop control) stacks with tools like yours naturally. Brain + hands.`,
+        `Felt this. Selector-based automation is brittle. We switched to accessibility-tree-first with ScreenHand — the OS exposes UI elements semantically, not positionally.`,
+        `The maintenance tax on Selenium scripts is brutal. We built fallback chains (AX → CDP → Vision → AppleScript) because no single method is reliable enough alone.`,
+        `This is why we went API-free. No API keys = no rate limits, no platform approval needed. ScreenHand controls the actual UI like a human would.`,
+        `Claude Code + ScreenHand is a wild combo. Claude thinks and codes, ScreenHand handles everything outside the IDE — browser testing, deployment UIs, verification.`,
+        `Figma MCP gives you design tokens. But who verifies the implementation matches? ScreenHand opens the browser, screenshots the result, compares. Loop closed.`,
+    ],
+    // Rate limits
+    maxLikesPerHour: 18,
+    maxRepliesPerHour: 6,
+    maxDmsPerHour: 2,
+    maxTweetsPerHour: 3,
+};
+// Randomized delay (human-like)
+function randomDelay(minSec, maxSec) {
+    return (Math.floor(Math.random() * (maxSec - minSec + 1)) + minSec) * 1000;
+}
+function createInitialState() {
+    return {
+        startTime: Date.now(),
+        tweetsPosted: 0,
+        likesGiven: 0,
+        repliesSent: 0,
+        dmsSent: 0,
+        searchIndex: 0,
+        replyIndex: 0,
+        minutesElapsed: 0,
+    };
+}
+const SCHEDULE = [
+    { minute: 0, type: 'post', tweetIndex: 0 },
+    { minute: 3, type: 'like', count: 3 },
+    { minute: 8, type: 'reply', replyTemplate: 0 },
+    { minute: 10, type: 'reply', replyTemplate: 3 },
+    { minute: 15, type: 'like', count: 2 },
+    { minute: 20, type: 'post', tweetIndex: 1 },
+    { minute: 25, type: 'reply', replyTemplate: 5 },
+    { minute: 27, type: 'reply', replyTemplate: 7 },
+    { minute: 30, type: 'like', count: 3 },
+    { minute: 35, type: 'reply', replyTemplate: 8 },
+    { minute: 40, type: 'post', tweetIndex: 2 },
+    { minute: 45, type: 'like', count: 3 },
+    { minute: 50, type: 'reply', replyTemplate: 9 },
+    { minute: 52, type: 'reply', replyTemplate: 1 },
+    { minute: 55, type: 'search' },
+    { minute: 60, type: 'post', tweetIndex: 3 },
+    { minute: 65, type: 'like', count: 2 },
+    { minute: 70, type: 'reply', replyTemplate: 2 },
+    { minute: 72, type: 'reply', replyTemplate: 4 },
+    { minute: 75, type: 'like', count: 3 },
+    { minute: 80, type: 'post', tweetIndex: 4 },
+    { minute: 85, type: 'reply', replyTemplate: 6 },
+    { minute: 87, type: 'reply', replyTemplate: 1 },
+    { minute: 90, type: 'search' },
+    { minute: 95, type: 'like', count: 3 },
+    { minute: 100, type: 'post', tweetIndex: 5 },
+    { minute: 105, type: 'reply', replyTemplate: 3 },
+    { minute: 107, type: 'reply', replyTemplate: 8 },
+    { minute: 110, type: 'like', count: 2 },
+    { minute: 115, type: 'like', count: 3 },
+    { minute: 120, type: 'search' },
+];
+// Log action for tracking
+function logAction(action, details) {
+    const ts = new Date().toISOString();
+    const line = `[${ts}] ${action}: ${details}`;
+    console.log(line);
+    // Append to campaign log
+    const logPath = join(__dirname, '..', 'threads_campaign_log.txt');
+    const { appendFileSync } = require('fs');
+    appendFileSync(logPath, line + '\n');
+}
+// Main — this file is designed to be driven by ScreenHand MCP tools
+// When run standalone, it outputs the schedule for the current minute
+if (require.main === module) {
+    const state = createInitialState();
+    const elapsed = Math.floor((Date.now() - state.startTime) / 60000);
+    // Find next actions
+    const upcoming = SCHEDULE.filter(a => a.minute >= elapsed).slice(0, 3);
+    console.log('=== ScreenHand Campaign Runner ===');
+    console.log(`Started: ${new Date(state.startTime).toLocaleTimeString()}`);
+    console.log(`Elapsed: ${elapsed} minutes`);
+    console.log(`\nNext actions:`);
+    for (const action of upcoming) {
+        const inMinutes = action.minute - elapsed;
+        let desc = '';
+        switch (action.type) {
+            case 'post':
+                desc = `Post tweet #${(action.tweetIndex ?? 0) + 1}`;
+                break;
+            case 'like':
+                desc = `Like ${action.count} relevant tweets`;
+                break;
+            case 'reply':
+                desc = `Reply using template #${(action.replyTemplate ?? 0) + 1}`;
+                break;
+            case 'search':
+                desc = `Search for new engagement targets`;
+                break;
+            case 'dm':
+                desc = `Send warm DM`;
+                break;
+        }
+        console.log(`  ${inMinutes === 0 ? 'NOW' : `in ${inMinutes}m`}: ${desc}`);
+    }
+    console.log(`\nTweet content for next post:`);
+    const nextPost = upcoming.find(a => a.type === 'post');
+    if (nextPost?.tweetIndex !== undefined) {
+        console.log(CONFIG.tweets[nextPost.tweetIndex]?.content.substring(0, 200) + '...');
+    }
+    console.log(`\nReply template for next reply:`);
+    const nextReply = upcoming.find(a => a.type === 'reply');
+    if (nextReply?.replyTemplate !== undefined) {
+        console.log(CONFIG.replyTemplates[nextReply.replyTemplate]?.substring(0, 200) + '...');
+    }
+    console.log('\n--- Campaign will be executed via ScreenHand MCP tools ---');
+    console.log('Use /loop 5m to keep the campaign runner alive');
+}
+export { CONFIG, SCHEDULE, createInitialState, logAction, randomDelay };