@motionode/cli 0.1.1 → 0.2.0

package/lib/signals_watch.js

@@ -0,0 +1,168 @@
+'use strict';
+
+/**
+ * `motionode signals watch`: one long-lived connection to Motionode's signal
+ * stream (Server-Sent Events). Each pushed signal is written to the local inbox
+ * at once; no model is involved, so this costs no AI credits. Reconnects with a
+ * growing pause when the connection drops.
+ *
+ * Two robustness details, since this runs unattended for hours:
+ *  - the server heartbeats every 20s, but a silent intermediary (a proxy or NAT
+ *    that drops the stream without a FIN/RST) can leave the socket open and
+ *    looking "connected" while nothing ever arrives again. An idle timeout
+ *    (IDLE_TIMEOUT_MS, reset on every chunk received, heartbeats included)
+ *    aborts and reconnects instead of hanging forever.
+ *  - a single 401 could be a transient auth hiccup, not an actual revocation.
+ *    watch() only gives up for good after FATAL_401_STREAK consecutive 401s;
+ *    anything else in between (a real event, or a non-401 error) resets the count.
+ */
+
+const pkg = require('../package.json');
+const Inbox = require('./inbox');
+
+const IDLE_TIMEOUT_MS = 60000;
+const FATAL_401_STREAK = 2;
+
+function parseEvents(buffer) {
+	const events = [];
+	let rest = buffer;
+	let idx;
+	while ((idx = rest.indexOf('\n\n')) >= 0) {
+		const block = rest.slice(0, idx);
+		rest = rest.slice(idx + 2);
+		let event = 'message';
+		const data = [];
+		for (const line of block.split('\n')) {
+			if (line.startsWith(':')) continue;
+			if (line.startsWith('event:')) event = line.slice(6).trim();
+			else if (line.startsWith('data:')) data.push(line.slice(5).trimStart());
+		}
+		if (data.length) events.push({ event, data: data.join('\n') });
+	}
+	return { events, rest };
+}
+
+async function watchOnce({ base, token, dir, onSignal, onStatus = null }) {
+	const controller = new AbortController();
+	let idleTimer = null;
+	const armIdleTimer = () => {
+		clearTimeout(idleTimer);
+		idleTimer = setTimeout(() => controller.abort(), IDLE_TIMEOUT_MS);
+	};
+
+	armIdleTimer();
+	let resp;
+	try {
+		resp = await fetch(`${base}/api/v1/agent/signals/stream`, {
+			// Same agent name as the MCP server, so the watch and the tools are ONE session (one holder of its claims).
+			headers: { Authorization: `Bearer ${token}`, Accept: 'text/event-stream', 'User-Agent': `motionode-cli/${pkg.version}`, ...require('./agent_api').agentHeaders() },
+			signal: controller.signal,
+		});
+	} catch (err) {
+		clearTimeout(idleTimer);
+		if (err.name === 'AbortError') throw new Error(`No data from Motionode for ${Math.round(IDLE_TIMEOUT_MS / 1000)}s; reconnecting.`);
+		throw err;
+	}
+	if (resp.status === 401) { clearTimeout(idleTimer); throw Object.assign(new Error('Not connected or token revoked.'), { status: 401 }); }
+	if (!resp.ok || !resp.body) { clearTimeout(idleTimer); throw new Error(`Motionode answered ${resp.status}.`); }
+
+	const reader = resp.body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = '';
+	try {
+		for (;;) {
+			let value, done;
+			try {
+				({ value, done } = await reader.read());
+			} catch (err) {
+				if (err.name === 'AbortError') throw new Error(`No data from Motionode for ${Math.round(IDLE_TIMEOUT_MS / 1000)}s; reconnecting.`);
+				throw err;
+			}
+			if (done) return;
+			armIdleTimer(); // bytes arrived (an event or a heartbeat ping) -- the connection is alive
+			buffer += decoder.decode(value, { stream: true }).replace(/\r\n/g, '\n');
+			const parsed = parseEvents(buffer);
+			buffer = parsed.rest;
+			for (const ev of parsed.events) {
+				// The stream says when it is connected and which work it watches ("ready", then "scope" when that changes):
+				// shown, so a quiet watch reads as connected and waiting, never as stopped.
+				if ((ev.event === 'ready' || ev.event === 'scope') && onStatus) {
+					let info = null;
+					try { info = JSON.parse(ev.data); } catch (_e) { info = null; }
+					onStatus(ev.event, info || {});
+					continue;
+				}
+				// Motionode couldn't read the work or its signals (it retries): said, so silence never means "nothing".
+				if ((ev.event === 'error' || ev.event === 'recovered') && onStatus) {
+					let info = null;
+					try { info = JSON.parse(ev.data); } catch (_e) { info = null; }
+					onStatus(ev.event, info || {});
+					continue;
+				}
+				if (ev.event !== 'signal') continue;
+				let signal = null;
+				try { signal = JSON.parse(ev.data); } catch (_e) { continue; }
+				if (signal && Inbox.add(dir, signal) && onSignal) onSignal(signal);
+			}
+		}
+	} finally {
+		clearTimeout(idleTimer);
+	}
+}
+
+async function watch(config, { dir = process.cwd(), quiet = false } = {}) {
+	const base = String(config.apiUrl || '').replace(/\/+$/, '');
+	const token = process.env.MOTIONODE_TOKEN || config.token;
+	if (!token) {
+		console.error('Not connected. Run "motionode connect" first.');
+		process.exitCode = 1;
+		return;
+	}
+	Inbox.ensureExcluded(dir);
+	// The inbox exists from the start: an empty one means nothing has been sent yet, not that the watch is broken.
+	if (!Inbox.read(dir).length) Inbox.write(dir, []);
+	console.log(`Watching Motionode signals for this repository → ${Inbox.inboxPath(dir)}`);
+	let pause = 2000;
+	let consecutive401s = 0;
+	for (;;) {
+		try {
+			await watchOnce({
+				base,
+				token,
+				dir,
+				onStatus: (event, info) => {
+					pause = 2000;
+					consecutive401s = 0;
+					const n = Number(info.ticketCount) || 0;
+					if (event === 'error') { console.error(`[${new Date().toLocaleTimeString()}] ⚠ ${info.error || "Motionode couldn't read your work; retrying."}`); return; }
+					if (event === 'recovered') { if (!quiet) console.log(`[${new Date().toLocaleTimeString()}] Reading signals again: watching ${n} ticket${n === 1 ? '' : 's'}.`); return; }
+					if (!quiet) console.log(`[${new Date().toLocaleTimeString()}] ${event === 'ready' ? 'Connected' : 'Your work changed'}: watching ${n} ticket${n === 1 ? '' : 's'}.`);
+				},
+				onSignal: (s) => {
+					pause = 2000;
+					consecutive401s = 0;
+					if (!quiet) console.log(`[${new Date().toLocaleTimeString()}] ${s.requiresAction ? '⚠ ' : ''}${s.kind}: ${String(s.summary || '').split('\n')[0].slice(0, 160)}`);
+					if (s.requiresAction) process.stdout.write('\u0007');
+				},
+			});
+			consecutive401s = 0; // a clean connection (even with no signals) means the token is fine
+		} catch (err) {
+			if (err.status === 401) {
+				consecutive401s += 1;
+				if (consecutive401s >= FATAL_401_STREAK) {
+					console.error('Not connected or token revoked. Run "motionode connect".');
+					process.exitCode = 1;
+					return;
+				}
+				if (!quiet) console.error(`Motionode answered 401 (attempt ${consecutive401s}/${FATAL_401_STREAK}); retrying in case it's transient.`);
+			} else {
+				consecutive401s = 0;
+				if (!quiet) console.error(`Signal stream interrupted (${err.message}); reconnecting in ${Math.round(pause / 1000)}s`);
+			}
+		}
+		await new Promise((r) => setTimeout(r, pause));
+		pause = Math.min(pause * 2, 60000);
+	}
+}
+
+module.exports = { watch, parseEvents };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@motionode/cli",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Connect your local repositories to Motionode: work tickets in Cursor, VS Code or any editor while Motionode keeps the work tied to the ticket, its git branches, verification and delivery.",
   "license": "UNLICENSED",
   "bin": {