@rine-network/cli 0.8.3 → 0.9.0

package/README.md

@@ -81,10 +81,15 @@ The CLI resolves its config directory in order: `$RINE_CONFIG_DIR` > `~/.config/
 
 ## License
 
-[EUPL-1.2](LICENSE) — European Union Public Licence v1.2
+[EUPL-1.2](https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12)
+
+## For AI Agents
+
+- [Platform docs](https://rine.network/llms.txt)
+- [CLI reference](https://rine.network/cli.md)
+- [Protocol](https://rine.network/protocol.md)
 
 ## Links
 
 - Website: [rine.network](https://rine.network)
-- Protocol: [rine.network/protocol.md](https://rine.network/protocol.md)
 - Source: [codeberg.org/rine/rine-cli](https://codeberg.org/rine/rine-cli)

package/dist/main.js

@@ -1326,6 +1326,15 @@ function registerRegister(program) {
 }
 //#endregion
 //#region src/commands/stream.ts
+function emitLifecycle(gOpts, data) {
+	if (gOpts.json) console.log(JSON.stringify({
+		event: "lifecycle",
+		data
+	}));
+}
+function jitteredDelayMs(backoffSeconds) {
+	return Math.round(backoffSeconds * (.5 + Math.random()) * 1e3);
+}
 async function formatMessageLine(dataStr, agentId, configDir, client) {
 	try {
 		const data = JSON.parse(dataStr);
@@ -1360,72 +1369,151 @@ async function formatMessageLine(dataStr, agentId, configDir, client) {
 	}
 }
 function registerStream(program) {
-	program.command("stream").description("Stream incoming messages via SSE").option("--agent <id>", "Agent ID to stream (defaults to your agent)").option("--verbose", "Show heartbeats and reconnect details").action(async (opts) => {
+	program.command("stream").description("Stream incoming messages via SSE").option("--agent <id>", "Agent ID to stream (defaults to your agent)").option("--verbose", "Show heartbeats and reconnect details").option("--persistent", "Disable server-side connection timeout").option("--heartbeat-timeout <seconds>", "Seconds of silence before reconnecting (default: 70)", "70").action(async (opts) => {
 		try {
 			const gOpts = program.opts();
 			const configDir = resolveConfigDir();
 			const apiUrl = resolveApiUrl();
 			const { client, profileName, entry } = await createClient(configDir, apiUrl, gOpts.profile);
 			const agentId = await resolveAgent(apiUrl, await fetchAgents(client), opts.agent, gOpts.as);
-			const url = `${apiUrl}/agents/${agentId}/stream`;
+			let url = `${apiUrl}/agents/${agentId}/stream`;
+			if (opts.persistent) url += "?persistent=true";
+			const heartbeatTimeoutMs = Math.max(Number(opts.heartbeatTimeout) || 70, 10) * 1e3;
 			let lastEventId;
 			let backoff = 1;
+			let attempt = 0;
 			let stopped = false;
 			process.on("SIGINT", () => {
 				stopped = true;
 				process.exitCode = 0;
 			});
-			while (!stopped) try {
-				const envToken = process.env.RINE_TOKEN;
-				const headers = {
-					Authorization: `Bearer ${await getOrRefreshToken(configDir, apiUrl, entry, profileName, {
-						force: false,
-						envToken
-					})}`,
-					Accept: "text/event-stream"
-				};
-				if (lastEventId) headers["Last-Event-ID"] = lastEventId;
-				await new Promise((resolve) => {
-					if (stopped) {
-						resolve();
-						return;
-					}
-					const es = createEventSource({
-						url,
-						headers,
-						onMessage: ({ event, data, id }) => {
-							if (id) lastEventId = id;
-							if (gOpts.json) console.log(JSON.stringify({
-								event,
-								id,
-								data
-							}));
-							else if (event === "message") formatMessageLine(data, agentId, configDir, client).then((line) => console.log(line), () => console.log(`[message] ${data.slice(0, 80)}`));
-							else if (event === "heartbeat" && opts.verbose) process.stderr.write(`[heartbeat] ${data}\n`);
-						},
-						onDisconnect: () => resolve(),
-						onScheduleReconnect: () => {
+			while (!stopped) {
+				attempt++;
+				const state = { disconnectReason: "server_close" };
+				try {
+					const envToken = process.env.RINE_TOKEN;
+					const headers = {
+						Authorization: `Bearer ${await getOrRefreshToken(configDir, apiUrl, entry, profileName, {
+							force: false,
+							envToken
+						})}`,
+						Accept: "text/event-stream"
+					};
+					if (lastEventId) headers["Last-Event-ID"] = lastEventId;
+					emitLifecycle(gOpts, {
+						state: "connecting",
+						attempt,
+						url
+					});
+					await new Promise((resolve) => {
+						if (stopped) {
+							resolve();
+							return;
+						}
+						let heartbeatTimer;
+						const resetHeartbeatTimer = () => {
+							if (heartbeatTimer) clearTimeout(heartbeatTimer);
+							heartbeatTimer = setTimeout(() => {
+								state.disconnectReason = "heartbeat_timeout";
+								es.close();
+								resolve();
+							}, heartbeatTimeoutMs);
+						};
+						const es = createEventSource({
+							url,
+							headers,
+							onMessage: ({ event, data, id }) => {
+								resetHeartbeatTimer();
+								if (id) lastEventId = id;
+								if (gOpts.json) console.log(JSON.stringify({
+									event,
+									id,
+									data
+								}));
+								else if (event === "message") formatMessageLine(data, agentId, configDir, client).then((line) => console.log(line), () => console.log(`[message] ${data.slice(0, 80)}`));
+								else if (event === "heartbeat" && opts.verbose) process.stderr.write(`[heartbeat] ${data}\n`);
+							},
+							onDisconnect: () => {
+								if (heartbeatTimer) clearTimeout(heartbeatTimer);
+								state.disconnectReason = "server_close";
+								resolve();
+							},
+							onScheduleReconnect: () => {
+								if (heartbeatTimer) clearTimeout(heartbeatTimer);
+								es.close();
+								resolve();
+							}
+						});
+						resetHeartbeatTimer();
+						if (attempt === 1 && !gOpts.json) {
+							process.stderr.write(`Connected to stream for agent ${agentId}\n`);
+							if (opts.persistent) process.stderr.write("Persistent mode (no server timeout)\n");
+						}
+						emitLifecycle(gOpts, {
+							state: "connected",
+							attempt
+						});
+						const onStop = () => {
+							if (heartbeatTimer) clearTimeout(heartbeatTimer);
+							state.disconnectReason = "signal";
 							es.close();
 							resolve();
+						};
+						if (stopped) {
+							onStop();
+							return;
 						}
+						process.once("SIGINT", onStop);
 					});
-					const onStop = () => {
-						es.close();
-						resolve();
-					};
+					if (state.disconnectReason === "heartbeat_timeout") {
+						const jitteredBackoff = jitteredDelayMs(backoff);
+						emitLifecycle(gOpts, {
+							state: "reconnecting",
+							reason: "heartbeat_timeout",
+							attempt: attempt + 1,
+							backoff_ms: jitteredBackoff
+						});
+						if (!gOpts.json) process.stderr.write(`Reconnecting (attempt ${attempt + 1}, heartbeat timeout)...\n`);
+						await new Promise((r) => setTimeout(r, jitteredBackoff));
+						backoff = Math.min(backoff * 2, 30);
+					} else if (state.disconnectReason === "signal") {
+						emitLifecycle(gOpts, {
+							state: "stopped",
+							reason: "signal"
+						});
+						break;
+					} else {
+						emitLifecycle(gOpts, {
+							state: "reconnecting",
+							reason: "server_close",
+							attempt: attempt + 1,
+							backoff_ms: 0
+						});
+						if (!gOpts.json) process.stderr.write(`Reconnecting (attempt ${attempt + 1}, server close)...\n`);
+						backoff = 1;
+					}
+				} catch (err) {
 					if (stopped) {
-						onStop();
-						return;
+						emitLifecycle(gOpts, {
+							state: "stopped",
+							reason: "signal"
+						});
+						break;
 					}
-					process.once("SIGINT", onStop);
-				});
-				backoff = 1;
-			} catch {
-				if (stopped) break;
-				if (opts.verbose) process.stderr.write(`Reconnecting in ${backoff}s...\n`);
-				else process.stderr.write("Reconnecting...\n");
-				await new Promise((r) => setTimeout(r, backoff * 1e3));
-				backoff = Math.min(backoff * 2, 30);
+					const errorMsg = err instanceof Error ? err.message : String(err);
+					const jitteredBackoff = jitteredDelayMs(backoff);
+					emitLifecycle(gOpts, {
+						state: "reconnecting",
+						reason: "error",
+						attempt: attempt + 1,
+						backoff_ms: jitteredBackoff,
+						error: errorMsg
+					});
+					if (opts.verbose) process.stderr.write(`Reconnecting in ${Math.round(jitteredBackoff / 1e3)}s (attempt ${attempt + 1}, error: ${errorMsg})...\n`);
+					else process.stderr.write(`Reconnecting (attempt ${attempt + 1}, error)...\n`);
+					await new Promise((r) => setTimeout(r, jitteredBackoff));
+					backoff = Math.min(backoff * 2, 30);
+				}
 			}
 		} catch (err) {
 			printError(formatError(err));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rine-network/cli",
-  "version": "0.8.3",
+  "version": "0.9.0",
   "description": "CLI client for rine.network \u2014 EU-first messaging infrastructure for AI agents",
   "author": "mmmbs <mmmbs@proton.me>",
   "license": "EUPL-1.2",
@@ -28,7 +28,7 @@
     "dev": "tsx src/main.ts"
   },
   "dependencies": {
-    "@rine-network/core": "^0.3.4",
+    "@rine-network/core": "^0.4.0",
     "commander": "^12.0.0",
     "eventsource-client": "^1.1.0"
   },