Mavis
68bc7015fd
CI / Lint, typecheck, test, build (pull_request) Failing after 9s
- packages/krpc-client: TypeScript kRPC protocol client
- connection.ts: varint encoding/decoding, length-prefix framing,
per-socket read queue (avoids race when multiple read promises
in flight). Uses multiplication not '<<' for varint shift
because JS truncates << to 32 bits.
- schema.ts: hand-written protobufjs schema for kRPC meta-protocol
(ConnectionRequest, Request, Response, StreamUpdate, Status, etc.)
- enough to do connection handshake, single procedure calls, and
stream subscription. Service-specific types (SpaceCenter.Vessel,
Orbit, CelestialBody) need to be loaded from the kRPC mod's
.proto files at runtime.
- client.ts: KRPCClient with connect/invoke/addStream/removeStream/
onStreamUpdate/close. Tested with hand-rolled mock server.
- 10 tests (varint round-trips incl. uint64, wire format with raw
sockets).
- apps/tools/ksp-bridge: bridge that connects KSP to our API
- convert.ts: pure kRPC -> UniverseSnapshot conversion
(situation enum mapping, body id normalization, etc.)
- bridge.ts: main poll loop with retry + backoff
- krpc-adapter.ts: KRPCAdapter class that owns the KRPCClient
- index.ts: entrypoint with MOCK MODE for development (emits
synthetic state when no KSP is available, so you can verify the
HTTP pipeline end-to-end)
- 9 tests (7 conversion + 2 end-to-end bridge)
- ksp/README.md: full setup guide
- CKAN install, KSP server start, env vars
- Hand-rolled KSP calls list (what SpaceCenter methods we need)
- Roadmap for the remaining .proto-loading work
- Protocol deep-dive (for the next dev)
- Bug fixes along the way: protobufjs default import (not namespace),
varint 32-bit truncation, JavaScript bitwise 32-bit limit,
handshake status enum comparison (number vs string).
End-to-end verified: API + bridge in mock mode, 2 bodies + 1 vessel
arriving at /api/v1/state, 500ms polling cadence, automatic recovery
on HTTP failures.
69 lines
2.2 KiB
TypeScript
69 lines
2.2 KiB
TypeScript
import { describe, it, expect } from 'vitest';
|
|
import { Buffer } from 'node:buffer';
|
|
import { encodeVarint, decodeVarint } from '../src/connection.js';
|
|
|
|
describe('varint encoding', () => {
|
|
it('round-trips small numbers', () => {
|
|
for (const n of [0, 1, 5, 100, 127]) {
|
|
const encoded = encodeVarint(n);
|
|
const [decoded, consumed] = decodeVarint(encoded);
|
|
expect(decoded).toBe(n);
|
|
expect(consumed).toBe(encoded.length);
|
|
}
|
|
});
|
|
|
|
it('round-trips numbers requiring 2 bytes', () => {
|
|
for (const n of [128, 200, 16383, 16384, 100_000]) {
|
|
const encoded = encodeVarint(n);
|
|
const [decoded, consumed] = decodeVarint(encoded);
|
|
expect(decoded).toBe(n);
|
|
expect(consumed).toBe(encoded.length);
|
|
}
|
|
});
|
|
|
|
it('round-trips numbers requiring 4-5 bytes', () => {
|
|
for (const n of [2 ** 20, 2 ** 28, 2 ** 31 - 1, 2 ** 32]) {
|
|
const encoded = encodeVarint(n);
|
|
const [decoded, consumed] = decodeVarint(encoded);
|
|
expect(decoded).toBe(n);
|
|
expect(consumed).toBe(encoded.length);
|
|
}
|
|
});
|
|
|
|
it('encodes correctly per the protobuf spec', () => {
|
|
// Reference values from the protobuf documentation
|
|
expect([...encodeVarint(0)]).toEqual([0x00]);
|
|
expect([...encodeVarint(1)]).toEqual([0x01]);
|
|
expect([...encodeVarint(127)]).toEqual([0x7f]);
|
|
expect([...encodeVarint(128)]).toEqual([0x80, 0x01]);
|
|
expect([...encodeVarint(300)]).toEqual([0xac, 0x02]);
|
|
});
|
|
|
|
it('decodes from a multi-byte buffer correctly', () => {
|
|
// decodeVarint should stop at the varint boundary
|
|
const buf = Buffer.concat([encodeVarint(42), Buffer.from([0xff, 0xee])]);
|
|
const [decoded, consumed] = decodeVarint(buf);
|
|
expect(decoded).toBe(42);
|
|
expect(consumed).toBe(1); // only the first byte was the varint
|
|
});
|
|
|
|
it('rejects negative numbers', () => {
|
|
expect(() => encodeVarint(-1)).toThrow();
|
|
});
|
|
});
|
|
|
|
describe('varint edge cases', () => {
|
|
it('decodes 0', () => {
|
|
const [v, c] = decodeVarint(Buffer.from([0]));
|
|
expect(v).toBe(0);
|
|
expect(c).toBe(1);
|
|
});
|
|
|
|
it('decodes max uint32', () => {
|
|
const n = 0xffffffff;
|
|
const [v, c] = decodeVarint(encodeVarint(n));
|
|
expect(v).toBe(n);
|
|
expect(c).toBe(encodeVarint(n).length);
|
|
});
|
|
});
|