pairshell-cli 0.0.1

package/src/start.js

@@ -0,0 +1,453 @@
+import http from "node:http";
+import { randomBytes } from "node:crypto";
+import { writeFileSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { WebSocketServer } from "ws";
+import qrcode from "qrcode-terminal";
+import { resolve } from "./providers/index.js";
+import { PairingStore } from "./pairing.js";
+import { SessionStore } from "./session.js";
+import { lanAddress } from "./net.js";
+import { bridgeSession } from "./pty-bridge.js";
+import { readConfig, getProvider } from "./config.js";
+import { deriveKey } from "./crypto.js";
+import { ok, info, warn, fail, header, kv, pairingUrl, BOLD, RESET } from "./format.js";
+import fs from "node:fs/promises";
+import { exec } from "node:child_process";
+
+const DEFAULT_TUNNEL_PORT = 7442;
+const MAX_PORT_TRIES = 10;
+const AUTH_TIMEOUT_MS = 10000;
+const MAX_PENDING_CONNECTIONS = 5;
+
+function toPairingUrl(base, token) {
+  const url = new URL(base);
+  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+  url.pathname = "/";
+  url.searchParams.set("token", token);
+  return url.toString();
+}
+
+function sessionListHandler(req, res, sessions) {
+  if (req.method === "GET" && req.url === "/sessions") {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(sessions.list()));
+    return true;
+  }
+  return false;
+}
+
+async function revokeHandler(req, res, sessions) {
+  if (req.method === "POST" && req.url === "/revoke") {
+    let body = "";
+    for await (const chunk of req) body += chunk;
+    let data;
+    try { data = JSON.parse(body); } catch {}
+    if (!data || !data.deviceId) {
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "deviceId required" }));
+      return true;
+    }
+    const removed = sessions.revoke(data.deviceId);
+    res.writeHead(removed ? 200 : 404, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ revoked: removed, deviceId: data.deviceId }));
+    return true;
+  }
+  return false;
+}
+
+function healthHandler(req, res) {
+  if (req.method === "GET" && (req.url === "/" || req.url === "/health")) {
+    res.writeHead(200, {
+      "Content-Type": "application/json",
+      "Access-Control-Allow-Origin": "*",
+    });
+    res.end(JSON.stringify({ status: "ok", service: "pairshell-cli" }));
+    return true;
+  }
+  return false;
+}
+
+async function bindServer(server, preferred, host) {
+  let port = preferred;
+  for (let attempt = 0; attempt < MAX_PORT_TRIES; attempt++) {
+    const tryPort = port > 0 ? port + attempt : 0;
+    try {
+      await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(tryPort, host, resolve);
+      });
+      return server.address().port;
+    } catch (err) {
+      if (err.code !== "EADDRINUSE") throw err;
+      if (tryPort === 0) throw err;
+    }
+  }
+  throw new Error(`Could not find an available port after ${MAX_PORT_TRIES} tries`);
+}
+
+function printQr(wsUrl, token) {
+  console.log(`\n  ${BOLD}Paste this in the PairShell app:${RESET}`);
+  console.log(`  ${pairingUrl(wsUrl)}\n`);
+  qrcode.generate(wsUrl, { small: true });
+}
+
+export async function startCommand(opts) {
+  if (opts.path) {
+    try {
+      process.chdir(opts.path);
+      info(`Changed to ${opts.path}`);
+    } catch (err) {
+      fail(`Cannot access path: ${err.message}`);
+      process.exit(1);
+    }
+  }
+
+  const useTunnel = opts.tunnel !== false;
+  const providerName = opts.provider || getProvider();
+
+  const server = http.createServer((req, res) => {
+    if (healthHandler(req, res)) return;
+    res.writeHead(426, { "Content-Type": "text/plain" });
+    res.end("PairShell requires a WebSocket connection.\n");
+  });
+
+  const adminServer = http.createServer((req, res) => {
+    if (sessionListHandler(req, res, sessions)) return;
+    if (revokeHandler(req, res, sessions)) return;
+    res.writeHead(404).end();
+  });
+
+  const wss = new WebSocketServer({ server });
+  const pairing = new PairingStore();
+  const sessions = new SessionStore();
+
+  header("Starting PairShell");
+
+  let port = opts.port || (useTunnel ? DEFAULT_TUNNEL_PORT : 0);
+  const boundPort = await bindServer(server, port);
+  if (port && boundPort !== port) {
+    warn(`Port ${port} was in use, bound to ${boundPort} instead`);
+  }
+  info(`WebSocket server listening on port ${boundPort}`);
+
+  const adminPort = await bindServer(adminServer, boundPort + 1000, "127.0.0.1");
+  adminServer.unref();
+  info(`Admin HTTP server on 127.0.0.1:${adminPort}`);
+
+  const activeFile = join(homedir(), ".pairshell", "active.json");
+  try {
+    mkdirSync(join(homedir(), ".pairshell"), { recursive: true });
+    writeFileSync(activeFile, JSON.stringify({ port: adminPort }), "utf8");
+  } catch {}
+
+  let tunnelProc = null;
+  let publicBase;
+
+  if (useTunnel) {
+    const prov = resolve(providerName);
+    const config = readConfig();
+    const check = prov.checkSetup(config);
+    if (!check.ok) {
+      fail(`${prov.label} is not configured: ${check.message}`);
+      console.log(`\n  Run ${BOLD}pairshell-cli setup ${providerName}${RESET} first.\n`);
+      process.exit(1);
+    }
+
+    info(`Starting ${prov.label} tunnel ...`);
+    const result = await prov.startTunnel(boundPort, config);
+    publicBase = result.url;
+    tunnelProc = result.child;
+    ok(`${prov.label} tunnel established`);
+  } else {
+    publicBase = `http://${lanAddress()}:${boundPort}`;
+    info("Local-network mode (no tunnel)");
+  }
+
+  const token = pairing.create();
+  const wsUrl = toPairingUrl(publicBase, token);
+
+  header("Pairing Info");
+  kv([
+    ["Provider", useTunnel ? `${providerName} (outbound-only tunnel, no inbound ports)` : "local network"],
+    ["Working dir", process.cwd()],
+  ]);
+  printQr(wsUrl, token);
+
+  let pendingConnections = 0;
+
+  wss.on("connection", (ws, req) => {
+    const ip = req.socket.remoteAddress || "unknown";
+    info(`Incoming connection from ${ip}`);
+
+    const requestUrl = new URL(req.url, "http://localhost");
+    const queryToken = requestUrl.searchParams.get("token");
+    const querySession = requestUrl.searchParams.get("session");
+
+    if (pendingConnections >= MAX_PENDING_CONNECTIONS) {
+      ws.close(1013, "too many pending connections");
+      return;
+    }
+    pendingConnections++;
+
+    const authTimer = setTimeout(() => {
+      ws.close(4001, "auth timeout");
+    }, AUTH_TIMEOUT_MS);
+
+    let authed = false;
+
+    const authorize = (presented) => {
+      if (authed) return true;
+      const key = deriveKey(presented);
+
+      const sessionMeta = sessions.validate(presented);
+      if (sessionMeta) {
+        authed = true;
+        clearTimeout(authTimer);
+        pendingConnections = Math.max(0, pendingConnections - 1);
+        ok(`Device reconnected (session: ${sessionMeta.deviceId})`);
+        info("Opening terminal session ...");
+        bridgeSession(ws, { cols: 80, rows: 24, sharedKey: key });
+        return true;
+      }
+
+      if (!pairing.consume(presented)) {
+        warn(`Connection rejected: token ${presented ? presented.slice(0, 8) : "null"}... is invalid or already consumed.`);
+        ws.close(4001, "invalid or already-used pairing token");
+        return false;
+      }
+      authed = true;
+      clearTimeout(authTimer);
+      pendingConnections = Math.max(0, pendingConnections - 1);
+
+      const deviceId = randomBytes(8).toString("hex");
+      const sessionToken = sessions.create(deviceId);
+      try {
+        ws.send(JSON.stringify({ type: "paired", sessionToken, deviceId }));
+      } catch {}
+
+      ok("Device paired successfully");
+      info("Opening terminal session ...");
+      bridgeSession(ws, { cols: 80, rows: 24, sharedKey: key });
+      return true;
+    };
+
+    if (querySession && authorize(querySession)) return;
+    if (queryToken && authorize(queryToken)) return;
+
+    ws.on("message", async (message) => {
+      if (typeof message !== "string") return;
+      let control;
+      try {
+        control = JSON.parse(message);
+      } catch {
+        return;
+      }
+      if (!control || typeof control.type !== "string") return;
+
+      if (!authed) {
+        if (control.type === "auth" && typeof control.token === "string") {
+          authorize(control.token);
+        }
+        return;
+      }
+
+      // Handle File and Git requests once authenticated
+      try {
+        await handleControlMessage(ws, control, process.cwd());
+      } catch (err) {
+        warn(`Error handling control message ${control.type}: ${err.message}`);
+      }
+    });
+
+    ws.once("close", () => {
+      clearTimeout(authTimer);
+      if (!authed) pendingConnections = Math.max(0, pendingConnections - 1);
+    });
+  });
+
+  const shutdown = () => {
+    header("Shutting Down");
+    try { wss.close(); } catch {}
+    try { server.close(); } catch {}
+    try { adminServer.close(); } catch {}
+    if (tunnelProc) {
+      try { tunnelProc.kill("SIGTERM"); } catch {}
+    }
+    ok("PairShell stopped");
+    process.exit(0);
+  };
+
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+    process.stdin.on("data", (buf) => {
+      for (const byte of buf) {
+        if (byte === 0x03) {
+          shutdown();
+          return;
+        }
+        if (byte === 0x0d || byte === 0x0a) {
+          const newToken = pairing.create();
+          const newWsUrl = toPairingUrl(publicBase, newToken);
+          header("New Pairing Info");
+          printQr(newWsUrl, newToken);
+        }
+      }
+    });
+  }
+
+  console.log(`\n  ${BOLD}Press Enter${RESET} for a fresh pairing code  ${BOLD}Ctrl-C${RESET} to stop\n`);
+}
+
+async function handleControlMessage(ws, control, baseDir) {
+  switch (control.type) {
+    case "file_list_request": {
+      const relativePath = control.path || "./";
+      const targetPath = join(baseDir, relativePath);
+      try {
+        const entries = await fs.readdir(targetPath, { withFileTypes: true });
+        const files = entries
+          .filter(e => !e.name.startsWith(".") && e.name !== "node_modules" && e.name !== "build")
+          .map(e => ({
+            name: e.name,
+            isDirectory: e.isDirectory()
+          }));
+        ws.send(JSON.stringify({
+          type: "file_list_response",
+          path: relativePath,
+          files
+        }));
+      } catch (err) {
+        ws.send(JSON.stringify({
+          type: "file_list_response",
+          path: relativePath,
+          files: [],
+          error: err.message
+        }));
+      }
+      break;
+    }
+    case "file_read_request": {
+      const targetPath = join(baseDir, control.path);
+      try {
+        const content = await fs.readFile(targetPath, "utf8");
+        ws.send(JSON.stringify({
+          type: "file_read_response",
+          path: control.path,
+          content,
+          success: true
+        }));
+      } catch (err) {
+        ws.send(JSON.stringify({
+          type: "file_read_response",
+          path: control.path,
+          content: "",
+          success: false,
+          error: err.message
+        }));
+      }
+      break;
+    }
+    case "file_write_request": {
+      const targetPath = join(baseDir, control.path);
+      try {
+        const dir = join(targetPath, "..");
+        await fs.mkdir(dir, { recursive: true });
+        await fs.writeFile(targetPath, control.content, "utf8");
+        ws.send(JSON.stringify({
+          type: "file_write_response",
+          path: control.path,
+          success: true
+        }));
+      } catch (err) {
+        ws.send(JSON.stringify({
+          type: "file_write_response",
+          path: control.path,
+          success: false,
+          error: err.message
+        }));
+      }
+      break;
+    }
+    case "git_status_request": {
+      exec("git branch --show-current && git status -s", { cwd: baseDir }, (err, stdout) => {
+        if (err) {
+          ws.send(JSON.stringify({
+            type: "git_status_response",
+            branch: "unknown",
+            changes: [],
+            error: err.message
+          }));
+          return;
+        }
+        const lines = stdout.split("\n").filter(Boolean);
+        const branch = lines[0] || "main";
+        const changes = lines.slice(1).map(line => {
+          const typeChar = line.slice(0, 2).trim();
+          const file = line.slice(3).trim();
+          const type = typeChar === "??" ? "untracked" :
+                       typeChar === "A" ? "added" :
+                       typeChar === "D" ? "deleted" : "modified";
+          return { file, type, additions: 0, deletions: 0 };
+        });
+        ws.send(JSON.stringify({
+          type: "git_status_response",
+          branch,
+          changes
+        }));
+      });
+      break;
+    }
+    case "git_stage_request": {
+      const files = control.files || [];
+      const filesArg = files.includes("*") ? "." : files.map(f => `"${f}"`).join(" ");
+      exec(`git add ${filesArg}`, { cwd: baseDir }, (err) => {
+        ws.send(JSON.stringify({
+          type: "git_stage_response",
+          success: !err,
+          error: err ? err.message : null
+        }));
+      });
+      break;
+    }
+    case "git_commit_request": {
+      const message = control.message || "Commit from PairShell";
+      exec(`git commit -m "${message.replace(/"/g, '\\"')}"`, { cwd: baseDir }, (err, stdout) => {
+        const hash = !err ? (stdout.match(/\[\w+ ([a-f0-9]+)\]/) || [])[1] : null;
+        ws.send(JSON.stringify({
+          type: "git_commit_response",
+          success: !err,
+          hash,
+          error: err ? err.message : null
+        }));
+      });
+      break;
+    }
+    case "git_action_request": {
+      const action = control.action || "fetch";
+      if (!["fetch", "pull", "push"].includes(action)) {
+        ws.send(JSON.stringify({
+          type: "git_action_response",
+          action,
+          success: false,
+          error: "Invalid git action"
+        }));
+        break;
+      }
+      exec(`git ${action}`, { cwd: baseDir }, (err, stdout, stderr) => {
+        ws.send(JSON.stringify({
+          type: "git_action_response",
+          action,
+          success: !err,
+          logs: stdout + "\n" + stderr,
+          error: err ? err.message : null
+        }));
+      });
+      break;
+    }
+  }
+}

package/src/status.js

@@ -0,0 +1,32 @@
+import { readConfig, getProvider } from "./config.js";
+import { resolve } from "./providers/index.js";
+import { lanAddress } from "./net.js";
+import { header, kv, info, BOLD, RESET } from "./format.js";
+
+export function statusCommand() {
+  header("PairShell Status");
+
+  const config = readConfig();
+  const providerName = getProvider();
+  const prov = resolve(providerName);
+  const check = prov.checkSetup(config);
+
+  const items = [
+    ["Provider", prov.label],
+    ["Status", check.ok ? "configured" : `${BOLD}(not configured)${RESET}`],
+    ["LAN address", lanAddress()],
+    ["Config file", "~/.pairshell/config.json"],
+  ];
+
+  if (check.ok && check.message) {
+    items.splice(1, 0, ["Detail", check.message]);
+  }
+
+  kv(items);
+
+  if (!check.ok) {
+    console.log(`\n  Run ${BOLD}pairshell-cli setup ${providerName}${RESET} to configure ${prov.label}.\n`);
+  } else {
+    console.log(`\n  Run ${BOLD}pairshell-cli start${RESET} to begin.\n`);
+  }
+}