Brandon LiandClaude Opus 5
25289cb9b3
Three changes that ride together because they touch the same surface. A control link to the master. lib/master-link.ts dials out to <master>/ws/instance and holds it open, so the dashboard can trigger a trade or queue an AutoBuyer run here. Commands call the same functions the local pages call — runTrade, startScheduler, queueRun — so nothing reaches the broker by a path the UI does not also use. Reports prefer the socket and fall back to the existing POST, which keeps older masters working unchanged. startMasterLink is idempotent, and that matters more than it looks: getClients() is lazy and starts the link, so the first command re-enters it from inside a command the live socket is waiting to ack. Tearing the socket down there loses the ack and reports a trade that actually executed as a failure — which invites pressing the button twice. queueRun is lifted out of the automations route so the socket and HTTP share one copy of the input clamping that decides how many times a purchase fires. Page capture loses its switch and gains a scope. It now runs every tick, but only against the active tab of the last-focused window that matches host_permissions — so it follows the page in front of you and stops when you switch away, where before it would fall back to any firm tab left open in the background. autobuyer_enabled is gone entirely. The AutoBuyer is ready whenever the runner is; a run happens because someone asked for one. That does mean a queued run executes as soon as clicker/runner.py claims it, with no second gate — stopping the runner is now the way to make a machine idle. Extension to 0.10.0; it needs a manual reload at chrome://extensions. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
57 lines
2.1 KiB
TypeScript
57 lines
2.1 KiB
TypeScript
/**
|
|
* Queuing an AutoBuyer run.
|
|
*
|
|
* Lifted out of POST /api/autobuyer/automations so the master dashboard's
|
|
* control link can queue the same run over its WebSocket without going back
|
|
* through HTTP — and, more to the point, without a second copy of the checks
|
|
* that decide how many times a purchase fires.
|
|
*
|
|
* Queuing is always allowed. Nothing arms the AutoBuyer any more, so the only
|
|
* thing standing between a queued run and a moving mouse is whether
|
|
* clicker/runner.py is up to claim it.
|
|
*/
|
|
|
|
import { createRun } from './db';
|
|
import { findAutomation, resolveSteps } from './automations';
|
|
|
|
export class QueueRunError extends Error {
|
|
constructor(message: string, readonly status: number) {
|
|
super(message);
|
|
this.name = 'QueueRunError';
|
|
}
|
|
}
|
|
|
|
export interface QueuedRun {
|
|
runId: number;
|
|
totalSteps: number;
|
|
inputs: Record<string, number>;
|
|
}
|
|
|
|
export function queueRun(automationId: string, supplied: Record<string, unknown> = {}): QueuedRun {
|
|
const found = findAutomation(automationId);
|
|
if (!found) {
|
|
throw new QueueRunError(`No automation "${automationId}"`, 404);
|
|
}
|
|
if (found.automation.steps.length === 0) {
|
|
throw new QueueRunError(`"${found.automation.label}" has no steps yet`, 400);
|
|
}
|
|
// Clamp every input to what the automation declared. The count decides how
|
|
// many times a purchase runs, so it is not taken on trust from the client.
|
|
const inputs: Record<string, number> = {};
|
|
for (const declared of found.automation.inputs ?? []) {
|
|
const raw = Number(supplied[declared.id]);
|
|
const value = Number.isFinite(raw) ? Math.floor(raw) : declared.default;
|
|
inputs[declared.id] = Math.min(declared.max, Math.max(declared.min, value));
|
|
}
|
|
|
|
let resolved;
|
|
try {
|
|
resolved = resolveSteps(found.firm, found.automation, inputs);
|
|
} catch (err: any) {
|
|
throw new QueueRunError(err?.message ?? 'Could not expand the steps', 400);
|
|
}
|
|
|
|
const run = createRun(automationId, resolved.length, inputs);
|
|
return { runId: run.id, totalSteps: run.total_steps, inputs };
|
|
}
|