linkshell-cli 0.2.57 → 0.2.59

package/src/index.ts

@@ -5,6 +5,9 @@ import { resolveProviderConfig } from "./providers.js";
 import { loadConfig } from "./config.js";
 import { runDoctor } from "./commands/doctor.js";
 import { runSetup } from "./commands/setup.js";
+import { runUpgrade } from "./commands/upgrade.js";
+import { runLogin } from "./commands/login.js";
+import { runLogout } from "./commands/logout.js";
 import { getLanIp } from "./utils/lan-ip.js";
 
 import { createRequire } from "node:module";
@@ -158,6 +161,13 @@ program
     // Save PID for status/stop
     daemon.savePid("bridge", process.pid);
 
+    // Load auth token if logged in
+    let authToken: string | undefined;
+    try {
+      const { getValidToken } = await import("./auth.js");
+      authToken = (await getValidToken()) ?? undefined;
+    } catch {}
+
     const session = new BridgeSession({
       gatewayUrl,
       gatewayHttpUrl,
@@ -170,6 +180,7 @@ program
       verbose: Boolean(options.verbose),
       screen: Boolean(options.screen),
       providerConfig,
+      authToken,
     });
 
     const cleanup = async () => {
@@ -352,6 +363,114 @@ program
     await runSetup();
   });
 
+program
+  .command("upgrade")
+  .description("Upgrade LinkShell to the latest version")
+  .action(async () => {
+    await runUpgrade();
+  });
+
+program
+  .command("login")
+  .description("Log in to LinkShell (enables premium gateway)")
+  .action(async () => {
+    await runLogin();
+  });
+
+program
+  .command("logout")
+  .description("Log out of LinkShell")
+  .action(() => {
+    runLogout();
+  });
+
+program
+  .command("list")
+  .description("List your sessions on official gateways")
+  .action(async () => {
+    const { getValidToken, loadAuth, SUPABASE_URL, SUPABASE_ANON_KEY } =
+      await import("./auth.js");
+    const token = await getValidToken();
+    if (!token) {
+      process.stderr.write(
+        "\n  Not logged in. Run: linkshell login\n\n",
+      );
+      return;
+    }
+
+    const auth = loadAuth();
+    process.stderr.write(`\n  Logged in as ${auth?.email || auth?.userId || "unknown"}\n\n`);
+
+    // Fetch official gateways
+    let gateways: { url: string; name: string; region: string | null }[] = [];
+    try {
+      const res = await fetch(
+        `${SUPABASE_URL}/rest/v1/linkshell_official_gateways?enabled=eq.true&select=url,name,region`,
+        {
+          headers: {
+            Authorization: `Bearer ${token}`,
+            apikey: SUPABASE_ANON_KEY,
+          },
+          signal: AbortSignal.timeout(10_000),
+        },
+      );
+      if (res.ok) {
+        gateways = (await res.json()) as typeof gateways;
+      }
+    } catch {}
+
+    if (gateways.length === 0) {
+      process.stderr.write("  No official gateways available.\n\n");
+      return;
+    }
+
+    process.stderr.write("  Official Gateways:\n\n");
+
+    for (const gw of gateways) {
+      const label = gw.region ? `${gw.name} (${gw.region})` : gw.name;
+      // Fetch user's sessions on this gateway
+      let sessions: {
+        id: string;
+        provider: string | null;
+        projectName: string | null;
+        hasHost: boolean;
+        lastActivity: number;
+      }[] = [];
+      try {
+        const res = await fetch(`${gw.url}/sessions/mine`, {
+          headers: { Authorization: `Bearer ${token}` },
+          signal: AbortSignal.timeout(5_000),
+        });
+        if (res.ok) {
+          const body = (await res.json()) as { sessions: typeof sessions };
+          sessions = body.sessions;
+        }
+      } catch {}
+
+      process.stderr.write(`  \x1b[32m✓\x1b[0m ${label}\n`);
+      process.stderr.write(`    ${gw.url}\n`);
+
+      if (sessions.length === 0) {
+        process.stderr.write("    (no active sessions)\n\n");
+      } else {
+        for (const s of sessions) {
+          const ago = Math.round((Date.now() - s.lastActivity) / 60_000);
+          const agoStr = ago < 1 ? "just now" : `${ago}m ago`;
+          const info = [s.provider, s.projectName].filter(Boolean).join(" · ");
+          const hostIcon = s.hasHost ? "\x1b[32m●\x1b[0m" : "\x1b[31m●\x1b[0m";
+          process.stderr.write(
+            `    └ ${hostIcon} ${s.id.slice(0, 8)} — ${info || "unknown"} · ${agoStr}\n`,
+          );
+        }
+        process.stderr.write("\n");
+      }
+    }
+
+    process.stderr.write(
+      "  Connect: linkshell start --gateway <url> --provider claude\n\n",
+    );
+  });
+
 program.parseAsync(process.argv).catch((error: unknown) => {
   const message = error instanceof Error ? error.message : String(error);
   process.stderr.write(`${message}\n`);

package/src/runtime/bridge-session.ts

@@ -31,6 +31,7 @@ export interface BridgeSessionOptions {
   verbose?: boolean;
   screen?: boolean;
   providerConfig: ProviderConfig;
+  authToken?: string;
 }
 
 const HEARTBEAT_INTERVAL = 15_000;
@@ -158,9 +159,13 @@ export class BridgeSession {
   }
 
   private async createPairing(): Promise<void> {
+    const headers: Record<string, string> = { "content-type": "application/json" };
+    if (this.options.authToken) {
+      headers["Authorization"] = `Bearer ${this.options.authToken}`;
+    }
     const res = await fetch(`${this.options.gatewayHttpUrl}/pairings`, {
       method: "POST",
-      headers: { "content-type": "application/json" },
+      headers,
       body: JSON.stringify({}),
     });
     if (!res.ok) {
@@ -222,6 +227,9 @@ export class BridgeSession {
     const url = new URL(this.options.gatewayUrl);
     url.searchParams.set("sessionId", this.sessionId);
     url.searchParams.set("role", "host");
+    if (this.options.authToken) {
+      url.searchParams.set("auth_token", this.options.authToken);
+    }
 
     this.socket = new WebSocket(url);
 
@@ -401,6 +409,42 @@ export class BridgeSession {
         this.sendTerminalList();
         break;
       }
+      case "terminal.history.request": {
+        const p = parseTypedPayload("terminal.history.request", envelope.payload);
+        const count = p.count ?? 100;
+        let entries: string[] = [];
+        let shell = "unknown";
+        try {
+          const home = homedir();
+          // Try zsh first, then bash
+          const histFiles = [
+            { path: join(home, ".zsh_history"), shell: "zsh" },
+            { path: join(home, ".bash_history"), shell: "bash" },
+          ];
+          for (const hf of histFiles) {
+            if (existsSync(hf.path)) {
+              const raw = readFileSync(hf.path, "utf8");
+              const lines = raw.split("\n").filter(Boolean);
+              // zsh history lines may start with ": <timestamp>:0;" — strip prefix
+              const parsed = lines.map((l) => {
+                const m = l.match(/^:\s*\d+:\d+;(.*)$/);
+                return m ? m[1]! : l;
+              });
+              // Deduplicate and take last N
+              const unique = [...new Set(parsed.reverse())].slice(0, count).reverse();
+              entries = unique;
+              shell = hf.shell;
+              break;
+            }
+          }
+        } catch {}
+        this.send(createEnvelope({
+          type: "terminal.history.response",
+          sessionId: this.sessionId,
+          payload: { entries, shell },
+        }));
+        break;
+      }
       case "session.ack": {
         const p = parseTypedPayload("session.ack", envelope.payload);
         const term = this.terminals.get(tid);
@@ -609,13 +653,14 @@ export class BridgeSession {
 
     localWs.on("close", (code, reason) => {
       this.tunnelSockets.delete(requestId);
+      const safeCode = typeof code === "number" && code >= 1000 && code <= 4999 ? code : 1000;
       this.send(
         createEnvelope({
           type: "tunnel.ws.close",
           sessionId: this.sessionId,
           payload: {
             requestId,
-            code,
+            code: safeCode,
             reason: reason?.toString() || "",
           },
         }),

package/src/runtime/screen-share.ts

@@ -270,7 +270,7 @@ export class ScreenShare {
 
     // RTP state
     let seqNum = 0;
-    let timestamp = 0;
+    let timestamp = -Math.floor(90000 / fps); // so first bump yields 0
     const clockRate = 90000;
     const frameDuration = Math.floor(clockRate / fps);
     const ssrc = (Math.random() * 0xffffffff) >>> 0;
@@ -350,7 +350,7 @@ export class ScreenShare {
       }
     };
 
-    const extractNalUnits = () => {
+    const extractNalUnits = (flush = false) => {
       // Find NAL unit boundaries (0x00000001 or 0x000001)
       const units: Buffer[] = [];
       let start = -1;
@@ -373,11 +373,22 @@ export class ScreenShare {
         }
       }
 
-      if (start >= 0 && units.length > 0) {
+      // On flush (ffmpeg exit), emit the trailing NAL unit too
+      if (flush && start >= 0) {
+        units.push(nalBuffer.subarray(start));
+        nalBuffer = Buffer.alloc(0);
+        return units;
+      }
+
+      if (start >= 0) {
         // Keep remaining data from last start code onward
         nalBuffer = nalBuffer.subarray(start);
-      } else if (start < 0) {
-        // No start code found yet, keep accumulating
+      }
+
+      // Safety cap: if buffer grows beyond 4MB without producing NALs, discard
+      if (nalBuffer.length > 4 * 1024 * 1024 && units.length === 0) {
+        process.stderr.write(`[screen-share] NAL buffer exceeded 4MB, resetting\n`);
+        nalBuffer = Buffer.alloc(0);
       }
 
       return units;
@@ -401,6 +412,11 @@ export class ScreenShare {
     });
 
     this.ffmpeg.on("exit", (code) => {
+      // Flush any remaining NAL unit in the buffer
+      const remaining = extractNalUnits(true);
+      for (const unit of remaining) {
+        sendNalUnit(unit);
+      }
       if (this.active) {
         process.stderr.write(`[screen-share] ffmpeg exited with code ${code}\n`);
         this.stop();