@cueloop/client 0.1.0-alpha.59 → 0.1.0-alpha.60

package/src/pty.test.ts

@@ -11,6 +11,7 @@ function runOnPty(file: string, args: string[]): Promise<{ output: string; exitC
     const pty = spawn(file, args, { name: "xterm-256color", cols: 80, rows: 24 });
     let output = "";
     const timeout = setTimeout(() => reject(new Error("pty child never exited")), 5000);
+
     pty.onData((chunk) => {
       output += chunk;
     });
@@ -35,6 +36,7 @@ describe("pty", () => {
     // Arrange - `cat` echoes stdin back through the tty until it closes
     const pty = spawn("cat", [], { name: "xterm-256color", cols: 80, rows: 24 });
     let output = "";
+
     pty.onData((chunk) => {
       output += chunk;
     });
@@ -63,6 +65,7 @@ describe("pty", () => {
       });
       let collected = "";
       const timeout = setTimeout(() => reject(new Error("no exit")), 5000);
+
       pty.onData((chunk) => {
         collected += chunk;
       });

package/src/pty.ts

@@ -68,14 +68,17 @@ function nativeLibraryPath(): string | null {
   const suffix = process.platform === "darwin" ? "dylib" : "so";
   const dir = `${process.platform}-${process.arch}`;
   const path = join(import.meta.dir, "..", "native", dir, `libcuelooppty.${suffix}`);
+
   return existsSync(path) ? path : null;
 }
 
 /** One shared load of the pty shim; null when no dylib ships for the platform. */
 let ptyLib: PtyLib | null | undefined;
+
 function library(): PtyLib | null {
   if (ptyLib !== undefined) return ptyLib;
   const path = nativeLibraryPath();
+
   if (!path) return (ptyLib = null);
   try {
     ptyLib = dlopen(path, PTY_SYMBOLS).symbols;
@@ -83,6 +86,7 @@ function library(): PtyLib | null {
     console.error(`cueloop: failed to load ${path}:`, error);
     ptyLib = null;
   }
+
   return ptyLib;
 }
 
@@ -95,9 +99,11 @@ class EventEmitter<T> {
   private listeners: ((value: T) => void)[] = [];
   readonly event = (listener: (value: T) => void): Disposable => {
     this.listeners.push(listener);
+
     return {
       dispose: () => {
         const index = this.listeners.indexOf(listener);
+
         if (index !== -1) this.listeners.splice(index, 1);
       },
     };
@@ -138,6 +144,7 @@ class Pty implements IPty {
 
     const argvPacked = packTokens([file, ...args]);
     const envPacked = packTokens(env);
+
     this.handle = lib.cueloop_pty_spawn(
       ptr(argvPacked),
       Buffer.from(`${cwd}\0`, "utf8"),
@@ -170,6 +177,7 @@ class Pty implements IPty {
   write(data: string): void {
     if (this.closing) return;
     const buffer = Buffer.from(data, "utf8");
+
     this.lib.cueloop_pty_write(this.handle, ptr(buffer), buffer.length);
   }
 
@@ -192,18 +200,23 @@ class Pty implements IPty {
     if (this.reading) return;
     this.reading = true;
     const buffer = Buffer.allocUnsafe(READ_BUFFER_BYTES);
+
     while (!this.closing) {
       const count = this.lib.cueloop_pty_read(this.handle, ptr(buffer), buffer.length);
+
       if (count > 0) {
         // Stream mode buffers a multibyte char split across reads (box-drawing etc.).
         const text = this.decoder.decode(buffer.subarray(0, count), { stream: true });
+
         if (text) this.dataEvent.fire(text);
       } else if (count === CHILD_EXITED || count < 0) {
         // Both the drained-exit sentinel and a hard read error end the session:
         // flush the decoder, reap for the code, close, and fire the exit once.
         const tail = this.decoder.decode();
+
         if (tail) this.dataEvent.fire(tail);
         const exitCode = this.lib.cueloop_pty_get_exit_code(this.handle);
+
         this.lib.cueloop_pty_close(this.handle);
         this.closing = true;
         this.exitEvent.fire({ exitCode });
@@ -217,6 +230,8 @@ class Pty implements IPty {
 /** Spawn `file` with `args` on a fresh PTY. Throws when no shim ships (gate on ptyAvailable). */
 export function spawn(file: string, args: string[], options: PtyForkOptions = {}): IPty {
   const lib = library();
+
   if (!lib) throw new Error("cueloop: no pty shim for this platform");
+
   return new Pty(lib, file, args, options);
 }

package/src/run.ts

@@ -19,6 +19,7 @@ export async function runClient(options: RunClientOptions): Promise<number> {
   const renderer = await createCliRenderer({ enableMouseMovement: true });
   const appearance =
     (await renderer.waitForThemeMode(THEME_QUERY_TIMEOUT_MS).catch(() => null)) ?? "dark";
+
   return new Promise<number>((resolve) => {
     createRoot(renderer).render(
       React.createElement(App, {

package/src/serve.test.ts

@@ -56,6 +56,7 @@ function sshCapture(
       else resolve(out);
     };
     const timer = setTimeout(() => finish(new Error(`timed out; captured:\n${out}`)), timeoutMs);
+
     conn
       .on("ready", () => {
         conn.shell({ term: "xterm-256color", cols: 100, rows: 30 }, (err, stream) => {

package/src/serve.ts

@@ -50,6 +50,7 @@ export interface ServeHandle {
 export async function serveClient(options: ServeOptions = {}): Promise<ServeHandle> {
   const home = options.home ?? cueloopHome();
   const sshDir = join(home, "ssh");
+
   mkdirSync(sshDir, { recursive: true, mode: 0o700 });
 
   const server = createServer({
@@ -65,6 +66,7 @@ export async function serveClient(options: ServeOptions = {}): Promise<ServeHand
     const appearance =
       (await session.renderer.waitForThemeMode(THEME_QUERY_TIMEOUT_MS).catch(() => null)) ?? "dark";
     const root = createRoot(session.renderer);
+
     root.render(
       React.createElement(App, {
         home,
@@ -79,5 +81,6 @@ export async function serveClient(options: ServeOptions = {}): Promise<ServeHand
   });
 
   const info = await server.listen(options.port ?? 2222, options.host ?? "127.0.0.1");
+
   return { ...info, close: () => server.close() };
 }

package/src/session-controller.curate.test.ts

@@ -46,6 +46,7 @@ function fakeClient(session: ReviewSession, sink: { workingCopy?: string }): Ses
     sessionList: async () => [session],
     sessionSetWorkingCopy: mock(async (_id: string, content: string | undefined) => {
       sink.workingCopy = content;
+
       return { ...session, workingCopy: content };
     }),
     close: () => {},
@@ -61,8 +62,10 @@ async function connected(session: ReviewSession) {
     sessionId: session.id,
     openClient: async () => client,
   });
+
   controller.connect();
   await tick();
+
   return { controller, client, sink };
 }
 
@@ -132,6 +135,7 @@ describe("diff hunk curation", () => {
 
     // Assert - one item: diff source, revealing the change's row, both lines previewed
     const items = controller.curationItems();
+
     expect(items.length).toBe(1);
     expect(items[0]!.source).toBe("diff");
     expect(items[0]!.id).toBe("diff:src/store.ts#0#1");
@@ -152,6 +156,7 @@ describe("diff hunk curation", () => {
 
     // Assert - the whole hunk, id diff:path#hunk#hunk
     const items = controller.curationItems();
+
     expect(items.length).toBe(1);
     expect(items[0]!.source).toBe("diff");
     expect(items[0]!.id).toBe("diff:src/store.ts#0#hunk");
@@ -160,6 +165,7 @@ describe("diff hunk curation", () => {
   test("restoreCuration drops the diff removal and reverts the working copy", async () => {
     // Arrange - one change rejected
     const { controller, sink } = await connected(diffSession(FILES));
+
     controller.toggleRejectChange(4);
     await tick();
     const [item] = controller.curationItems();
@@ -178,6 +184,7 @@ describe("diff hunk curation", () => {
   test("restoreCuration ignores an unknown id", async () => {
     // Arrange - one change rejected
     const { controller } = await connected(diffSession(FILES));
+
     controller.toggleRejectChange(4);
     await tick();
 

package/src/session-controller.share.test.ts

@@ -11,6 +11,7 @@ const pullShare = mock(async () => remote);
 const pushShare = mock(
   async (_shareId: string, _annotations: Array<Omit<Annotation, "createdAt">>) => {},
 );
+
 mock.module("./share", () => ({
   publishShare,
   pullShare,
@@ -60,8 +61,10 @@ function fakeClient(session: ReviewSession): SessionClient {
     ),
     sessionMergeShared: mock(async (_id: string, incoming: { annotations: Annotation[] }) => {
       const known = new Set(session.annotations.map((existing) => existing.id));
+
       for (const note of incoming.annotations)
         if (!known.has(note.id)) session.annotations.push(note);
+
       return session;
     }),
     close: () => {},
@@ -80,8 +83,10 @@ async function connectedController(
     openClient: async () => client,
     clock,
   });
+
   controller.connect();
   await tick();
+
   return { controller, client };
 }
 
@@ -199,6 +204,7 @@ describe("mirror on annotate", () => {
     const { controller, client } = await connectedController(
       sessionFixture({ shareId: "p_abc123xy", annotations: [annotation("a1", "SHA256:me")] }),
     );
+
     (client.sessionAnnotate as ReturnType<typeof mock>).mockImplementationOnce(async () => {
       throw new Error("session is resolved");
     });
@@ -225,6 +231,7 @@ describe("startSharePoll", () => {
 
     // Act - immediate pull
     const stop = controller.startSharePoll();
+
     await tick();
 
     // Assert
@@ -251,6 +258,7 @@ describe("startSharePoll", () => {
     pullShare.mockClear();
     remote = sessionFixture({ annotations: [] });
     let release: () => void = () => {};
+
     pullShare.mockImplementationOnce(
       () => new Promise<ReviewSession>((resolve) => (release = () => resolve(remote))),
     );
@@ -262,6 +270,7 @@ describe("startSharePoll", () => {
 
     // Act - start (pull is in flight), leave, then let the pull settle
     const stop = controller.startSharePoll();
+
     await tick();
     expect(pullShare).toHaveBeenCalledTimes(1);
     stop();
@@ -279,6 +288,7 @@ describe("startSharePoll", () => {
     pullShare.mockClear();
     remote = sessionFixture({ annotations: [] });
     let release: () => void = () => {};
+
     pullShare.mockImplementationOnce(
       () => new Promise<ReviewSession>((resolve) => (release = () => resolve(remote))),
     );
@@ -293,6 +303,7 @@ describe("startSharePoll", () => {
     await tick();
     expect(pullShare).toHaveBeenCalledTimes(1);
     const stopB = controller.startSharePoll();
+
     await tick();
     expect(pullShare).toHaveBeenCalledTimes(2);