@@ -0,0 +1,274 @@
1+import { SpaceMoltClient } from "../client/src/client";
2+import type {
3+ WelcomePayload,
4+ RegisteredPayload,
5+ LoggedInPayload,
6+ ErrorPayload,
7+ StateUpdatePayload,
8+ ChatMessage,
9+ ScanResultPayload,
10+ EmpireID,
11+} from "../client/src/types";
12+import { config } from "./config";
13+import { MemoryStore } from "./memory";
14+import { OllamaAgent } from "./ollama";
15+import { buildActionPrompt, buildRegistrationPrompt } from "./prompt";
16+import { dispatchAction, validateAction } from "./actions";
17+import { Tui } from "./tui";
18+
19+type Credentials = { username: string; token: string };
20+type RegistrationChoice = { username: string; empire: EmpireID };
21+
22+const memory = new MemoryStore(config.memoryPath);
23+const ollama = new OllamaAgent(config.ollamaUrl, config.ollamaModel, config.ollamaTimeoutMs);
24+const tui = new Tui();
25+
26+const client = new SpaceMoltClient({
27+ url: config.spacemoltUrl,
28+ debug: config.debug,
29+ reconnect: true,
30+});
31+
32+let credentials: Credentials | null = null;
33+let pendingRegistration: RegistrationChoice | null = null;
34+let includeHelpInPrompt = true;
35+let actionLoopRunning = false;
36+
37+async function loadCredentials(): Promise<Credentials | null> {
38+ try {
39+ const file = Bun.file(config.credentialsFile);
40+ if (await file.exists()) {
41+ return (await file.json()) as Credentials;
42+ }
43+ } catch {
44+ return null;
45+ }
46+ return null;
47+}
48+
49+async function saveCredentials(username: string, token: string): Promise<void> {
50+ const data: Credentials = { username, token };
51+ await Bun.write(config.credentialsFile, JSON.stringify(data, null, 2));
52+}
53+
54+function log(message: string): void {
55+ tui.log(message);
56+}
57+
58+function updateStatus(): void {
59+ const state = client.state;
60+ if (!state.player || !state.ship) {
61+ tui.setStatus("Not logged in");
62+ return;
63+ }
64+ const location = `${state.system?.name ?? state.player.current_system} - ${
65+ state.poi?.name ?? state.player.current_poi
66+ }`;
67+ const status = [
68+ `Player ${state.player.username} [${state.player.empire}]`,
69+ `Cr ${state.player.credits}`,
70+ `Hull ${state.ship.hull}/${state.ship.max_hull}`,
71+ `Shield ${state.ship.shield}/${state.ship.max_shield}`,
72+ `Fuel ${state.ship.fuel}/${state.ship.max_fuel}`,
73+ `Docked ${state.player.docked_at_base ? "Y" : "N"}`,
74+ `Tick ${state.currentTick}`,
75+ location,
76+ ].join(" | ");
77+ tui.setStatus(status);
78+}
79+
80+function saveSnapshot(): void {
81+ memory.saveSnapshot({
82+ tick: client.state.currentTick,
83+ player: client.state.player,
84+ ship: client.state.ship,
85+ system: client.state.system,
86+ poi: client.state.poi,
87+ base: client.state.base,
88+ nearby: client.state.nearby,
89+ });
90+}
91+
92+async function runRegistrationFlow(): Promise<void> {
93+ log("No credentials found. Asking LLM to create a character...");
94+ let attempts = 0;
95+ while (attempts < 3) {
96+ attempts += 1;
97+ try {
98+ const prompt = buildRegistrationPrompt(true);
99+ const result = await ollama.generateJson<RegistrationChoice>(prompt);
100+ const username = String(result.json.username ?? "").trim();
101+ const empire = String(result.json.empire ?? "").trim() as EmpireID;
102+ if (!username || !isValidEmpire(empire)) {
103+ throw new Error("Invalid registration response");
104+ }
105+ pendingRegistration = { username, empire };
106+ log(`Registering new account: ${username} (${empire})`);
107+ client.register(username, empire);
108+ return;
109+ } catch (error) {
110+ log(`Registration attempt failed: ${(error as Error).message}`);
111+ }
112+ }
113+
114+ const fallback = `molt-bot-${Math.floor(Math.random() * 10000)}`;
115+ pendingRegistration = { username: fallback, empire: "solarian" };
116+ log(`Falling back to account: ${fallback} (solarian)`);
117+ client.register(fallback, "solarian");
118+}
119+
120+function isValidEmpire(empire: string): empire is EmpireID {
121+ return ["solarian", "voidborn", "crimson", "nebula", "outerrim"].includes(empire);
122+}
123+
124+async function startActionLoop(): Promise<void> {
125+ if (actionLoopRunning) return;
126+ actionLoopRunning = true;
127+
128+ while (client.state.authenticated) {
129+ try {
130+ const recentActions = memory.getRecentActions(config.maxContextActions);
131+ const recentEvents = memory.getRecentEvents(config.maxContextEvents);
132+ const prompt = buildActionPrompt({
133+ state: client.state,
134+ recentActions,
135+ recentEvents,
136+ includeHelp: includeHelpInPrompt,
137+ });
138+
139+ const promptExcerpt = prompt.slice(0, 1000);
140+ const result = await ollama.generateJson(prompt);
141+ const validation = validateAction(result.json);
142+ if (!validation.ok || !validation.action) {
143+ const message = `Invalid action from LLM: ${validation.error ?? "unknown"}`;
144+ log(message);
145+ memory.appendEvent("llm_invalid_action", { error: validation.error, raw: result.raw });
146+ includeHelpInPrompt = true;
147+ await sleep(config.tickDelayMs);
148+ continue;
149+ }
150+
151+ memory.appendAction(
152+ validation.action.action,
153+ validation.action.args ?? {},
154+ promptExcerpt,
155+ result.raw
156+ );
157+ includeHelpInPrompt = false;
158+
159+ const actionLog = dispatchAction(client, validation.action);
160+ log(`Action: ${actionLog}`);
161+ memory.appendEvent("action_sent", { action: validation.action });
162+ } catch (error) {
163+ log(`Loop error: ${(error as Error).message}`);
164+ memory.appendEvent("loop_error", { message: (error as Error).message });
165+ }
166+
167+ await sleep(config.tickDelayMs);
168+ }
169+
170+ actionLoopRunning = false;
171+}
172+
173+function sleep(ms: number): Promise<void> {
174+ return new Promise((resolve) => setTimeout(resolve, ms));
175+}
176+
177+function formatOkPayload(payload: Record<string, unknown>): string {
178+ if (payload.action) {
179+ return `OK ${payload.action}`;
180+ }
181+ return `OK ${safeJson(payload)}`;
182+}
183+
184+function safeJson(value: unknown): string {
185+ try {
186+ return JSON.stringify(value);
187+ } catch {
188+ return "[unserializable]";
189+ }
190+}
191+
192+function shutdown(): void {
193+ try {
194+ client.disconnect();
195+ } catch {
196+ // ignore
197+ }
198+ tui.destroy();
199+ process.exit(0);
200+}
201+
202+tui.onExit(shutdown);
203+process.on("SIGINT", shutdown);
204+process.on("SIGTERM", shutdown);
205+
206+client.on<WelcomePayload>("welcome", async (data) => {
207+ log(`Welcome: v${data.version} (tick ${data.tick_rate}s)`);
208+ if (data.motd) log(`MOTD: ${data.motd}`);
209+ memory.appendEvent("welcome", data);
210+
211+ if (credentials) {
212+ log(`Auto-login as ${credentials.username}`);
213+ client.login(credentials.username, credentials.token);
214+ } else {
215+ await runRegistrationFlow();
216+ }
217+});
218+
219+client.on<RegisteredPayload>("registered", async (data) => {
220+ memory.appendEvent("registered", data);
221+ if (pendingRegistration) {
222+ await saveCredentials(pendingRegistration.username, data.token);
223+ log(`Registered. Saved credentials for ${pendingRegistration.username}`);
224+ client.login(pendingRegistration.username, data.token);
225+ } else {
226+ log("Registered but no pending registration found.");
227+ }
228+});
229+
230+client.on<LoggedInPayload>("logged_in", (data) => {
231+ log(`Logged in as ${data.player.username} (${data.player.empire})`);
232+ memory.appendEvent("logged_in", data);
233+ updateStatus();
234+ saveSnapshot();
235+ startActionLoop();
236+});
237+
238+client.on<ErrorPayload>("error", (data) => {
239+ log(`Error [${data.code}] ${data.message}`);
240+ memory.appendEvent("error", data);
241+});
242+
243+client.on<StateUpdatePayload>("state_update", (data) => {
244+ memory.appendEvent("state_update", data);
245+ updateStatus();
246+ saveSnapshot();
247+ if (data.in_combat) {
248+ log(`IN COMBAT: Hull ${data.ship.hull}/${data.ship.max_hull} Shield ${data.ship.shield}/${data.ship.max_shield}`);
249+ }
250+});
251+
252+client.on<ChatMessage>("chat_message", (data) => {
253+ log(`[${data.channel}] ${data.sender}: ${data.content}`);
254+ memory.appendEvent("chat_message", data);
255+});
256+
257+client.on<ScanResultPayload>("scan_result", (data) => {
258+ log(`Scan result: ${safeJson(data)}`);
259+ memory.appendEvent("scan_result", data);
260+});
261+
262+client.on("ok", (data: Record<string, unknown>) => {
263+ log(formatOkPayload(data));
264+ memory.appendEvent("ok", data);
265+});
266+
267+client.on("version_info", (data: Record<string, unknown>) => {
268+ log(`Version info: ${safeJson(data)}`);
269+ memory.appendEvent("version_info", data);
270+});
271+
272+credentials = await loadCredentials();
273+await client.connect();
274+updateStatus();