linkshell-cli 0.2.58 → 0.2.60

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,204 @@ 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 () => {
+    const result = await runLogin();
+    if (!result) return;
+
+    if (result.plan !== "pro") {
+      process.stderr.write(
+        "  Upgrade to Pro for official gateway access: https://itool.tech\n\n",
+      );
+      return;
+    }
+
+    // Pro user — fetch official gateways and offer to connect
+    const { SUPABASE_URL, SUPABASE_ANON_KEY } = await import("./auth.js");
+    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 ${result.accessToken}`,
+            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 yet.\n\n");
+      return;
+    }
+
+    process.stderr.write("  Available gateways:\n\n");
+    for (let i = 0; i < gateways.length; i++) {
+      const gw = gateways[i]!;
+      const label = gw.region ? `${gw.name} (${gw.region})` : gw.name;
+      process.stderr.write(`    [${i + 1}] ${label}  ${gw.url}\n`);
+    }
+    process.stderr.write(`    [0] Skip\n\n`);
+
+    const { createInterface } = await import("node:readline");
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    const answer = await new Promise<string>((res) => {
+      rl.question("  Connect to gateway [1]: ", (ans) => {
+        rl.close();
+        res(ans.trim());
+      });
+    });
+
+    if (answer === "0") return;
+
+    const idx = (answer === "" ? 1 : Number(answer)) - 1;
+    if (idx < 0 || idx >= gateways.length || Number.isNaN(idx)) {
+      process.stderr.write("  Invalid choice.\n\n");
+      return;
+    }
+
+    const chosen = gateways[idx]!;
+    const gwWsUrl = chosen.url.replace(/\/$/, "") + "/ws";
+
+    process.stderr.write(`\n  Connecting to ${chosen.name}...\n`);
+
+    // Start daemon with the chosen gateway
+    const daemon = await import("./utils/daemon.js");
+    const existingPid = daemon.readPid("bridge");
+    if (existingPid) {
+      process.stderr.write(
+        `  Bridge already running (PID ${existingPid}). Run: linkshell stop\n\n`,
+      );
+      return;
+    }
+
+    const childArgs = [
+      "start",
+      "--_foreground-bridge",
+      "--gateway", gwWsUrl,
+      "--provider", config.provider ?? "claude",
+      "--client-name", config.clientName ?? "local-cli",
+      "--cols", String(config.cols ?? 120),
+      "--rows", String(config.rows ?? 36),
+    ];
+
+    const pid = daemon.spawnDaemon("bridge", childArgs);
+    process.stderr.write(`\n  \x1b[32m✓\x1b[0m Bridge started in background (PID ${pid})\n`);
+    process.stderr.write(`    Gateway: ${chosen.name}\n`);
+    process.stderr.write(`    Open the LinkShell app on your phone to connect.\n\n`);
+    process.stderr.write(`    Stop:   linkshell stop\n`);
+    process.stderr.write(`    Status: linkshell status\n`);
+    process.stderr.write(`    Logs:   tail -f ${daemon.getLogFile("bridge")}\n\n`);
+  });
+
+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);

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();