fly-to-moon 0.1.16 → 0.1.18

package/README.md

@@ -174,6 +174,7 @@ npm link
 | `--max-tokens <n>`       | Abort after `n` total input+output tokens                                      | unlimited              |
 | `--detach`               | Run in daemon mode (background execution with `--max-iterations`)              | `false` (foreground)   |
 | `--prevent-sleep <mode>` | Prevent system sleep during the run (`on`/`off` or `true`/`false`)             | config file (`on`)     |
+| `--commit`               | Commit both successful and failed iterations (default: only on success)        | `false`                |
 | `--version`              | Show version                                                                   |                        |
 
 ## Configuration

package/dist/cli.mjs

@@ -135,18 +135,108 @@ function loadConfig(overrides) {
 }
 //#endregion
 //#region src/core/debug-log.ts
-function appendDebugLog(event, details = {}) {
-	const logPath = process.env.GNHF_DEBUG_LOG_PATH;
-	if (!logPath) return;
+const PRE_INIT_BUFFER_CAPACITY = 1e3;
+const STACK_LINE_LIMIT = 12;
+const CAUSE_DEPTH_LIMIT = 6;
+let logPath = null;
+let preInitBuffer = [];
+let preInitDroppedCount = 0;
+function formatLine(event, details) {
+	const base = {
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		pid: process.pid,
+		event
+	};
 	try {
-		appendFileSync(logPath, `${JSON.stringify({
-			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-			pid: process.pid,
-			event,
+		return `${JSON.stringify({
+			...base,
 			...details
-		})}\n`, "utf-8");
+		})}\n`;
+	} catch (error) {
+		return `${JSON.stringify({
+			...base,
+			logError: error instanceof Error ? `${error.name}: ${error.message}` : String(error),
+			detailsKeys: Object.keys(details)
+		})}\n`;
+	}
+}
+function initDebugLog(path) {
+	const resolvedPath = process.env.GNHF_DEBUG_LOG_PATH ?? path;
+	logPath = resolvedPath;
+	try {
+		mkdirSync(dirname(resolvedPath), { recursive: true });
+	} catch {}
+	if (preInitBuffer.length === 0 && preInitDroppedCount === 0) return;
+	const droppedSentinel = preInitDroppedCount > 0 ? formatLine("debug-log:pre-init-overflow", {
+		droppedCount: preInitDroppedCount,
+		bufferCapacity: PRE_INIT_BUFFER_CAPACITY
+	}) : "";
+	try {
+		appendFileSync(resolvedPath, droppedSentinel + preInitBuffer.join(""), "utf-8");
+	} catch {} finally {
+		preInitBuffer = [];
+		preInitDroppedCount = 0;
+	}
+}
+function appendDebugLog(event, details = {}) {
+	const line = formatLine(event, details);
+	if (logPath === null) {
+		const envLogPath = process.env.GNHF_DEBUG_LOG_PATH;
+		if (envLogPath) logPath = envLogPath;
+		else {
+			preInitBuffer.push(line);
+			if (preInitBuffer.length > PRE_INIT_BUFFER_CAPACITY) {
+				preInitBuffer.shift();
+				preInitDroppedCount += 1;
+			}
+			return;
+		}
+	}
+	try {
+		appendFileSync(logPath, line, "utf-8");
 	} catch {}
 }
+function serializeError(error, depth = 0) {
+	try {
+		return serializeErrorUnsafe(error, depth);
+	} catch (serializationError) {
+		return {
+			value: "[serialization failed]",
+			serializationError: serializationError instanceof Error ? `${serializationError.name}: ${serializationError.message}` : String(serializationError)
+		};
+	}
+}
+function tryRead(read) {
+	try {
+		return read();
+	} catch {
+		return;
+	}
+}
+function serializeErrorUnsafe(error, depth) {
+	if (depth > CAUSE_DEPTH_LIMIT) return { value: "[cause chain truncated]" };
+	if (error instanceof Error) {
+		const result = {
+			name: tryRead(() => error.name) ?? "Error",
+			message: tryRead(() => error.message) ?? ""
+		};
+		const code = tryRead(() => error.code);
+		if (typeof code === "string" || typeof code === "number") result.code = code;
+		const stack = tryRead(() => error.stack);
+		if (typeof stack === "string") result.stack = stack.split("\n").slice(0, STACK_LINE_LIMIT).join("\n");
+		const cause = tryRead(() => "cause" in error ? error.cause : void 0);
+		if (cause !== void 0) result.cause = serializeError(cause, depth + 1);
+		return result;
+	}
+	if (error === null || error === void 0) return { value: String(error) };
+	if (typeof error === "bigint") return { value: error.toString() };
+	if (typeof error === "object") try {
+		return { value: JSON.parse(JSON.stringify(error)) };
+	} catch {
+		return { value: String(error) };
+	}
+	return { value: String(error) };
+}
 //#endregion
 //#region src/core/git.ts
 const NOT_GIT_REPOSITORY_MESSAGE = "This command must be run inside a Git repository. Change into a repo or run \"git init\" first.";
@@ -274,6 +364,7 @@ function setupRun(runId, prompt, baseCommit, cwd) {
 	writeFileSync(notesPath, `# fttm run: ${runId}\n\nObjective: ${prompt}\n\n## Iteration Log\n`, "utf-8");
 	const schemaPath = join(runDir, "output-schema.json");
 	writeSchemaFile(schemaPath);
+	const logPath = join(runDir, "debug.jsonl");
 	const baseCommitPath = join(runDir, "base-commit");
 	const hasStoredBaseCommit = existsSync(baseCommitPath);
 	const resolvedBaseCommit = hasStoredBaseCommit ? readFileSync(baseCommitPath, "utf-8").trim() : baseCommit;
@@ -284,6 +375,7 @@ function setupRun(runId, prompt, baseCommit, cwd) {
 		promptPath,
 		notesPath,
 		schemaPath,
+		logPath,
 		baseCommit: resolvedBaseCommit,
 		baseCommitPath
 	};
@@ -294,6 +386,7 @@ function resumeRun(runId, cwd) {
 	const promptPath = join(runDir, "prompt.md");
 	const notesPath = join(runDir, "notes.md");
 	const schemaPath = join(runDir, "output-schema.json");
+	const logPath = join(runDir, "debug.jsonl");
 	writeSchemaFile(schemaPath);
 	const baseCommitPath = join(runDir, "base-commit");
 	return {
@@ -302,6 +395,7 @@ function resumeRun(runId, cwd) {
 		promptPath,
 		notesPath,
 		schemaPath,
+		logPath,
 		baseCommit: existsSync(baseCommitPath) ? readFileSync(baseCommitPath, "utf-8").trim() : backfillLegacyBaseCommit(runId, baseCommitPath, cwd),
 		baseCommitPath
 	};
@@ -1199,6 +1293,14 @@ var OpenCodeAgent = class {
 			return await this.streamMessage(server, sessionId, buildPrompt(prompt), runController.signal, logStream, onUsage, onMessage);
 		} catch (error) {
 			if (runController.signal.aborted || isAbortError$1(error)) throw createAbortError$1();
+			appendDebugLog("opencode:run:error", {
+				sessionId,
+				cwd,
+				error: serializeError(error),
+				serverClosed: this.server?.closed ?? true,
+				serverStderr: this.server?.stderr.slice(-2048),
+				serverStdout: this.server?.stdout.slice(-2048)
+			});
 			throw error;
 		} finally {
 			signal?.removeEventListener("abort", onAbort);
@@ -1328,31 +1430,32 @@ var OpenCodeAgent = class {
 		let messageRequestError = null;
 		const messageRequest = (async () => {
 			try {
+				await this.request(server, `/session/${sessionId}/prompt_async`, {
+					method: "POST",
+					body: {
+						role: "user",
+						parts: [{
+							type: "text",
+							text: prompt
+						}],
+						...this.model ? { model: (() => {
+							const parts = this.model.split("/");
+							if (parts.length === 2) return {
+								providerID: parts[0],
+								modelID: parts[1]
+							};
+							return {
+								providerID: "opencode",
+								modelID: this.model
+							};
+						})() } : {},
+						format: STRUCTURED_OUTPUT_FORMAT
+					},
+					signal
+				});
 				return {
 					ok: true,
-					body: await this.requestText(server, `/session/${sessionId}/message`, {
-						method: "POST",
-						body: {
-							role: "user",
-							parts: [{
-								type: "text",
-								text: prompt
-							}],
-							...this.model ? { model: (() => {
-								const parts = this.model.split("/");
-								if (parts.length === 2) return {
-									providerID: parts[0],
-									modelID: parts[1]
-								};
-								return {
-									providerID: "opencode",
-									modelID: this.model
-								};
-							})() } : {},
-							format: STRUCTURED_OUTPUT_FORMAT
-						},
-						signal
-					})
+					body: ""
 				};
 			} catch (error) {
 				messageRequestError = error;
@@ -1374,6 +1477,7 @@ var OpenCodeAgent = class {
 		let lastText = null;
 		let lastFinalAnswerText = null;
 		let lastUsageSignature = "0:0:0:0";
+		let structuredOutputFromSSE = null;
 		const updateUsage = (messageId, tokens) => {
 			if (!messageId || !tokens) return;
 			usageByMessageId.set(messageId, toUsage(tokens));
@@ -1437,6 +1541,7 @@ var OpenCodeAgent = class {
 			}
 			if (payload?.type === "message.updated") {
 				if (properties.info?.role === "assistant") updateUsage(properties.info.id, properties.info.tokens);
+				if (properties.info?.structured) structuredOutputFromSSE = properties.info.structured;
 				return false;
 			}
 			return payload?.type === "session.idle";
@@ -1513,21 +1618,13 @@ var OpenCodeAgent = class {
 			throw messageResult.error;
 		}
 		const body = messageResult.body;
-		let response;
-		try {
-			response = JSON.parse(body);
+		if (body) try {
+			JSON.parse(body);
 		} catch (error) {
 			throw new Error(`Failed to parse opencode response: ${error instanceof Error ? error.message : String(error)}`);
 		}
-		if (response.info?.role === "assistant") updateUsage(response.info.id, response.info.tokens);
-		for (const part of response.parts ?? []) {
-			if (part.type !== "text" || typeof part.text !== "string") continue;
-			if (!part.text.trim()) continue;
-			lastText = part.text;
-			if (part.metadata?.openai?.phase === "final_answer") lastFinalAnswerText = part.text;
-		}
-		if (response.info?.structured) return {
-			output: response.info.structured,
+		if (structuredOutputFromSSE) return {
+			output: structuredOutputFromSSE,
 			usage
 		};
 		const outputText = lastFinalAnswerText ?? lastText;
@@ -1592,12 +1689,24 @@ var OpenCodeAgent = class {
 		const headers = new Headers(options.headers);
 		if (options.body !== void 0) headers.set("content-type", "application/json");
 		const signal = withTimeoutSignal$1(options.signal, options.timeoutMs);
-		const response = await this.fetchFn(`${server.baseUrl}${path}`, {
-			method: options.method,
-			headers,
-			body: options.body === void 0 ? void 0 : JSON.stringify(options.body),
-			signal
-		});
+		let response;
+		try {
+			response = await this.fetchFn(`${server.baseUrl}${path}`, {
+				method: options.method,
+				headers,
+				body: options.body === void 0 ? void 0 : JSON.stringify(options.body),
+				signal
+			});
+		} catch (error) {
+			appendDebugLog("opencode:request:error", {
+				method: options.method,
+				path,
+				timeoutMs: options.timeoutMs,
+				error: serializeError(error),
+				serverClosed: server.closed
+			});
+			throw error;
+		}
 		if (!response.ok) {
 			const body = await response.text();
 			throw new Error(`opencode ${options.method} ${path} failed with ${response.status}: ${body}`);
@@ -1740,6 +1849,14 @@ var RovoDevAgent = class {
 			return await this.streamChat(server, sessionId, runController.signal, logStream, onUsage, onMessage);
 		} catch (error) {
 			if (runController.signal.aborted || isAbortError(error)) throw createAbortError();
+			appendDebugLog("rovodev:run:error", {
+				sessionId,
+				cwd,
+				error: serializeError(error),
+				serverClosed: this.server?.closed ?? true,
+				serverStderr: this.server?.stderr.slice(-2048),
+				serverStdout: this.server?.stdout.slice(-2048)
+			});
 			throw error;
 		} finally {
 			signal?.removeEventListener("abort", onAbort);
@@ -2070,12 +2187,24 @@ var RovoDevAgent = class {
 		if (options.sessionId) headers.set("x-session-id", options.sessionId);
 		if (options.body !== void 0 && !headers.has("content-type")) headers.set("content-type", "application/json");
 		const signal = withTimeoutSignal(options.signal, options.timeoutMs);
-		const response = await this.fetchFn(`${server.baseUrl}${path}`, {
-			method: options.method,
-			headers,
-			body: options.body === void 0 ? void 0 : JSON.stringify(options.body),
-			signal
-		});
+		let response;
+		try {
+			response = await this.fetchFn(`${server.baseUrl}${path}`, {
+				method: options.method,
+				headers,
+				body: options.body === void 0 ? void 0 : JSON.stringify(options.body),
+				signal
+			});
+		} catch (error) {
+			appendDebugLog("rovodev:request:error", {
+				method: options.method,
+				path,
+				timeoutMs: options.timeoutMs,
+				error: serializeError(error),
+				serverClosed: server.closed
+			});
+			throw error;
+		}
 		if (!response.ok) {
 			const body = await response.text();
 			throw new Error(`rovodev ${options.method} ${path} failed with ${response.status}: ${body}`);
@@ -2177,6 +2306,11 @@ var Orchestrator = class extends EventEmitter {
 	}
 	stop() {
 		this.stopRequested = true;
+		appendDebugLog("orchestrator:stop-requested", {
+			iteration: this.state.currentIteration,
+			hasActiveIteration: this.activeIterationPromise !== null,
+			loopDone: this.loopDone
+		});
 		this.activeAbortController?.abort();
 		if (this.loopDone) {
 			this.emit("stopped");
@@ -2211,6 +2345,15 @@ var Orchestrator = class extends EventEmitter {
 		this.state.startTime = /* @__PURE__ */ new Date();
 		this.state.status = "running";
 		this.emit("state", this.getState());
+		appendDebugLog("orchestrator:start", {
+			agent: this.agent.name,
+			runId: this.runInfo.runId,
+			startIteration: this.state.currentIteration,
+			maxIterations: this.limits.maxIterations,
+			maxTokens: this.limits.maxTokens,
+			maxConsecutiveFailures: this.config.maxConsecutiveFailures,
+			initialCommitCount: this.state.commitCount
+		});
 		try {
 			while (!this.stopRequested) {
 				const preIterationAbortReason = this.getPreIterationAbortReason();
@@ -2266,6 +2409,15 @@ var Orchestrator = class extends EventEmitter {
 			if (this.stopPromise) await this.stopPromise;
 			else await this.closeAgent();
 			this.loopDone = true;
+			appendDebugLog("orchestrator:end", {
+				status: this.state.status,
+				iterations: this.state.currentIteration,
+				successCount: this.state.successCount,
+				failCount: this.state.failCount,
+				totalInputTokens: this.state.totalInputTokens,
+				totalOutputTokens: this.state.totalOutputTokens,
+				commitCount: this.state.commitCount
+			});
 		}
 	}
 	async runIteration(prompt) {
@@ -2288,6 +2440,12 @@ var Orchestrator = class extends EventEmitter {
 			this.emit("state", this.getState());
 		};
 		const logPath = join(this.runInfo.runDir, `iteration-${this.state.currentIteration}.jsonl`);
+		const agentStartedAt = Date.now();
+		appendDebugLog("agent:run:start", {
+			iteration: this.state.currentIteration,
+			agent: this.agent.name,
+			logPath
+		});
 		try {
 			const result = await this.agent.run(prompt, this.cwd, {
 				onUsage,
@@ -2295,6 +2453,15 @@ var Orchestrator = class extends EventEmitter {
 				signal: this.activeAbortController.signal,
 				logPath
 			});
+			appendDebugLog("agent:run:end", {
+				iteration: this.state.currentIteration,
+				elapsedMs: Date.now() - agentStartedAt,
+				success: result.output.success,
+				inputTokens: result.usage.inputTokens,
+				outputTokens: result.usage.outputTokens,
+				cacheReadTokens: result.usage.cacheReadTokens,
+				cacheCreationTokens: result.usage.cacheCreationTokens
+			});
 			if (this.stopRequested) return { type: "stopped" };
 			if (result.output.success) return {
 				type: "completed",
@@ -2306,13 +2473,29 @@ var Orchestrator = class extends EventEmitter {
 			};
 		} catch (err) {
 			if (this.pendingAbortReason && err instanceof Error && err.message === "Agent was aborted") {
+				appendDebugLog("agent:run:aborted", {
+					iteration: this.state.currentIteration,
+					elapsedMs: Date.now() - agentStartedAt,
+					reason: this.pendingAbortReason
+				});
 				resetHard(this.cwd);
 				return {
 					type: "aborted",
 					reason: this.pendingAbortReason
 				};
 			}
-			if (this.stopRequested) return { type: "stopped" };
+			if (this.stopRequested) {
+				appendDebugLog("agent:run:stopped", {
+					iteration: this.state.currentIteration,
+					elapsedMs: Date.now() - agentStartedAt
+				});
+				return { type: "stopped" };
+			}
+			appendDebugLog("agent:run:error", {
+				iteration: this.state.currentIteration,
+				elapsedMs: Date.now() - agentStartedAt,
+				error: serializeError(err)
+			});
 			const summary = err instanceof Error ? err.message : String(err);
 			return {
 				type: "completed",
@@ -2387,13 +2570,20 @@ var Orchestrator = class extends EventEmitter {
 		this.state.status = "aborted";
 		this.state.lastMessage = reason;
 		this.state.waitingUntil = null;
+		appendDebugLog("orchestrator:abort", {
+			reason,
+			iteration: this.state.currentIteration,
+			consecutiveFailures: this.state.consecutiveFailures
+		});
 		this.emit("abort", reason);
 		this.emit("state", this.getState());
 	}
 	async closeAgent() {
 		try {
 			await this.agent.close?.();
-		} catch {}
+		} catch (err) {
+			appendDebugLog("agent:close:error", { error: serializeError(err) });
+		}
 	}
 };
 //#endregion
@@ -3310,7 +3500,22 @@ program.name("fttm").description("Fly to the moon, fly to the mars - AI agents f
 			if (!reexeced) persistedPrompt?.cleanup();
 		}
 	}
-	appendDebugLog("run:start", { args: process$1.argv.slice(2) });
+	initDebugLog(runInfo.logPath);
+	appendDebugLog("run:start", {
+		args: process$1.argv.slice(2),
+		runId: runInfo.runId,
+		runDir: runInfo.runDir,
+		agent: config.agent,
+		promptLength: prompt.length,
+		promptFromStdin,
+		startIteration,
+		maxIterations: options.maxIterations,
+		maxTokens: options.maxTokens,
+		preventSleep: config.preventSleep,
+		platform: process$1.platform,
+		nodeVersion: process$1.version,
+		fttmVersion: packageVersion
+	});
 	const orchestrator = new Orchestrator(config, createAgent(config.agent, runInfo, config.agentPathOverride[config.agent], options.model), runInfo, prompt, cwd, startIteration, {
 		maxIterations: options.maxIterations,
 		maxTokens: options.maxTokens,
@@ -3334,6 +3539,7 @@ program.name("fttm").description("Fly to the moon, fly to the mars - AI agents f
 	const orchestratorPromise = orchestrator.start().finally(() => {
 		if (!(orchestrator.getState().status === "aborted" && process$1.stdin.isTTY)) renderer.stop();
 	}).catch((err) => {
+		appendDebugLog("orchestrator:fatal", { error: serializeError(err) });
 		exitAltScreen();
 		die(err instanceof Error ? err.message : String(err));
 	});
@@ -3355,7 +3561,19 @@ program.name("fttm").description("Fly to the moon, fly to the mars - AI agents f
 		process$1.off("SIGTERM", handleSigTerm);
 		await sleepPreventionCleanup?.();
 	}
-	appendDebugLog("run:complete", { signal: shutdownSignal });
+	{
+		const finalState = orchestrator.getState();
+		appendDebugLog("run:complete", {
+			signal: shutdownSignal,
+			status: finalState.status,
+			iterations: finalState.currentIteration,
+			successCount: finalState.successCount,
+			failCount: finalState.failCount,
+			totalInputTokens: finalState.totalInputTokens,
+			totalOutputTokens: finalState.totalOutputTokens,
+			commitCount: finalState.commitCount
+		});
+	}
 	if (shutdownSignal) process$1.exit(getSignalExitCode(shutdownSignal));
 });
 function enterAltScreen() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fly-to-moon",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "description": "Humans fly to space. AI does the work. — Fly to the moon, fly to Mars",
   "type": "module",
   "bin": {