linkshell-cli 0.10.3 → 0.10.5

package/src/commands/host.ts

@@ -210,7 +210,7 @@ export async function joinGatewayAfterLogin(plan: "pro" | "free"): Promise<void>
   if (!chosen && plan !== "pro") {
     // A running host now gets the gateway's own answer, instead of an old login's.
     await refreshGateway(0);
-    out("The official gateway needs a Pro subscription: https://itool.tech");
+    out("The official gateway needs a Pro subscription: https://liutianjie.github.io/LinkShell/pricing/");
     out("Or use your own gateway: linkshell host --gateway <url>, then linkshell pair\n");
     return;
   }
@@ -355,7 +355,7 @@ export async function runAgentShim(agent: string, args: string[]): Promise<void>
 
   const sessionId = launch.sessionId;
   let child: import("node:child_process").ChildProcess | undefined;
-  let yielded = false;
+  let yielded: boolean;
   let showingRemote = false;
   client.on("desktop.yield", ({ sessionId: target }) => {
     if (target !== sessionId) return;

package/src/commands/login.ts

@@ -26,6 +26,7 @@ export async function runLogin(): Promise<LoginResult | null> {
   process.stderr.write("\n  LinkShell Login\n\n");
 
   return new Promise<LoginResult | null>((resolve) => {
+    let timeout: ReturnType<typeof setTimeout> | undefined;
     const server = http.createServer(async (req, res) => {
       const url = new URL(req.url ?? "/", "http://localhost");
 
@@ -136,6 +137,8 @@ export async function runLogin(): Promise<LoginResult | null> {
           `  \x1b[32m✓\x1b[0m Logged in as ${email || userId} (${planLabel})\n\n`,
         );
 
+        // Left pending, the five-minute limit would keep the command alive long after the login.
+        clearTimeout(timeout);
         setTimeout(() => {
           server.close();
           resolve({
@@ -182,7 +185,7 @@ export async function runLogin(): Promise<LoginResult | null> {
       } catch {}
 
       // Timeout after 5 minutes
-      setTimeout(() => {
+      timeout = setTimeout(() => {
         process.stderr.write("  Login timed out.\n\n");
         server.close();
         resolve(null);

package/src/commands/pair.ts

@@ -1,4 +1,5 @@
 import qrcode from "qrcode-terminal";
+import type { HostClient } from "@linkshell/host";
 
 // `linkshell pair`: show a QR code (and a code to type) that lets a phone reach
 // this computer through the gateway, then wait for it to pair.
@@ -34,19 +35,29 @@ export async function runPair(): Promise<void> {
     const code = `${offer.code.slice(0, 3)} ${offer.code.slice(3)}`;
     const minutes = Math.round((offer.expiresAt - Date.now()) / 60_000);
     process.stdout.write(`\n  Or enter the code:  ${code}   (valid ${minutes} min, gateway ${offer.gateway})\n\n  Waiting for your phone…`);
-    const device = await new Promise<{ name: string } | undefined>((resolve) => {
-      const stop = client.on("pairing.done", ({ device }) => {
-        stop();
-        resolve(device);
-      });
-      setTimeout(() => {
-        stop();
-        resolve(undefined);
-      }, offer.expiresAt - Date.now());
-      process.on("SIGINT", () => resolve(undefined));
-    });
-    process.stdout.write(device ? `\r  ✓ Paired with ${device.name}. It can reach this computer from anywhere now.\n\n` : "\r  Pairing window closed.            \n\n");
+    const outcome = await waitForPairing(client, offer.expiresAt);
+    process.stdout.write(typeof outcome === "object" ? `\r  ✓ Paired with ${outcome.name}. It can reach this computer from anywhere now.\n\n` : "\r  Pairing window closed.            \n\n");
+    // What a shell expects of a command ended by Ctrl-C.
+    if (outcome === "interrupted") process.exitCode = 130;
   } finally {
     client.close();
   }
 }
+
+/** Waits for a phone to pair: the device, or why the wait ended without one. */
+export function waitForPairing(client: Pick<HostClient, "on">, expiresAt: number): Promise<{ name: string } | "expired" | "interrupted"> {
+  return new Promise((resolve) => {
+    // However the wait ends, the timer and the listeners end with it: a pending timer keeps the process alive until
+    // the window closes, and a SIGINT listener left behind swallows every later Ctrl-C.
+    const finish = (outcome: { name: string } | "expired" | "interrupted") => {
+      stop();
+      clearTimeout(timer);
+      process.off("SIGINT", interrupt);
+      resolve(outcome);
+    };
+    const stop = client.on("pairing.done", ({ device }) => finish(device));
+    const timer = setTimeout(() => finish("expired"), expiresAt - Date.now());
+    const interrupt = () => finish("interrupted");
+    process.on("SIGINT", interrupt);
+  });
+}

package/src/utils/daemon.ts

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, writeFileSync, unlinkSync, mkdirSync, openSync } from "node:fs";
+import { existsSync, readFileSync, writeFileSync, unlinkSync, mkdirSync, openSync, renameSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
 import { spawn } from "node:child_process";
@@ -58,9 +58,24 @@ export function getLogFile(service: ServiceName): string {
   return logFile(service);
 }
 
+const MAX_LOG_BYTES = 5 * 1024 * 1024;
+
+/**
+ * Keeps a log from growing forever: a full one becomes `<service>.log.1`, replacing the one before it.
+ * Only when a daemon starts, since a running one holds the file open.
+ */
+export function rotateLog(log: string, maxBytes = MAX_LOG_BYTES): void {
+  try {
+    if (statSync(log).size > maxBytes) renameSync(log, `${log}.1`);
+  } catch {
+    // No log yet.
+  }
+}
+
 export function spawnDaemon(service: ServiceName, args: string[]): number {
   mkdirSync(LINKSHELL_DIR, { recursive: true });
   const log = logFile(service);
+  rotateLog(log);
   const out = openSync(log, "a");
   const err = openSync(log, "a");