gitspace 0.2.0-rc.1

package/experiments/router/client.ts

@@ -0,0 +1,199 @@
+#!/usr/bin/env bun
+/**
+ * Client - connects to router, attaches to session
+ *
+ * Usage: bun client.ts [project] [workspace]
+ */
+
+import { select } from "@inquirer/prompts";
+import {
+  ROUTER_SOCKET,
+  type RouterCommand,
+  type RouterResponse,
+  type SessionInfo,
+  type AttachMode,
+  encodeControl,
+  isControl,
+  decodeControl,
+  type SessionEvent,
+} from "./protocol";
+
+const [project = "test", workspace = "default"] = process.argv.slice(2);
+
+// Connect to router
+async function routerCommand(cmd: RouterCommand): Promise<RouterResponse> {
+  return new Promise(async (resolve, reject) => {
+    const socket = await Bun.connect({
+      unix: ROUTER_SOCKET,
+      socket: {
+        data(socket, data) {
+          resolve(JSON.parse(data.toString()));
+          socket.end();
+        },
+        error(socket, error) {
+          reject(error);
+        },
+        connectError(socket, error) {
+          reject(new Error("Router not running. Start with: bun router.ts"));
+        }
+      }
+    });
+
+    socket.write(JSON.stringify(cmd));
+  });
+}
+
+// Get or create session
+console.log(`Connecting to ${project}/${workspace}...`);
+
+let session: SessionInfo;
+
+try {
+  let response = await routerCommand({
+    type: "create",
+    project,
+    workspace,
+    cwd: process.cwd()
+  });
+
+  // Handle already-attached case
+  if (response.type === "already-attached") {
+    console.log(`\nSession "${project}/${workspace}" is already attached.\n`);
+
+    const choice = await select({
+      message: "What would you like to do?",
+      choices: [
+        { value: "take-over", name: "Take over (disconnect other client)" },
+        { value: "new", name: "Create new session for this workspace" },
+        { value: "cancel", name: "Cancel" },
+      ]
+    }) as AttachMode;
+
+    if (choice === "cancel") {
+      console.log("Cancelled.");
+      process.exit(0);
+    }
+
+    if (choice === "take-over") {
+      // Attach with take-over mode
+      response = await routerCommand({
+        type: "attach",
+        sessionId: response.session.id,
+        mode: "take-over"
+      });
+    } else if (choice === "new") {
+      // Force create new session (kill old one first, then create)
+      await routerCommand({ type: "kill", sessionId: response.session.id });
+      response = await routerCommand({
+        type: "create",
+        project,
+        workspace,
+        cwd: process.cwd()
+      });
+    }
+  }
+
+  if (response.type === "error") {
+    console.error("Error:", response.message);
+    process.exit(1);
+  }
+
+  if (response.type !== "created") {
+    console.error("Unexpected response:", response);
+    process.exit(1);
+  }
+
+  session = response.session;
+} catch (e: any) {
+  console.error(e.message);
+  process.exit(1);
+}
+
+console.log(`Attached to session ${session.id}`);
+console.log("Press Ctrl+D to detach\n");
+
+// Connect to session
+const sessionSocket = await Bun.connect({
+  unix: session.socketPath,
+  socket: {
+    data(socket, data) {
+      const buf = Buffer.from(data);
+
+      if (isControl(buf)) {
+        const event = decodeControl(buf) as SessionEvent;
+
+        switch (event.type) {
+          case "attached":
+            // Replay scrollback
+            if (event.scrollback) {
+              const scrollback = Buffer.from(event.scrollback, "base64");
+              process.stdout.write(scrollback);
+            }
+            break;
+
+          case "exited":
+            process.stdin.setRawMode(false);
+            console.log(`\nSession exited with code ${event.code}`);
+            process.exit(event.code);
+            break;
+
+          case "kicked":
+            process.stdin.setRawMode(false);
+            console.log("\n\nAnother client took over this session.");
+            process.exit(0);
+            break;
+
+          case "pong":
+            break;
+        }
+      } else {
+        // PTY output - write to terminal
+        process.stdout.write(buf);
+      }
+    },
+
+    close() {
+      process.stdin.setRawMode(false);
+      console.log("\nDisconnected from session");
+      process.exit(0);
+    },
+
+    error(socket, error) {
+      process.stdin.setRawMode(false);
+      console.error("\nSession error:", error.message);
+      process.exit(1);
+    }
+  }
+});
+
+// Send initial resize
+sessionSocket.write(encodeControl({
+  type: "resize",
+  cols: process.stdout.columns || 80,
+  rows: process.stdout.rows || 24
+}));
+
+// Handle terminal resize
+process.stdout.on("resize", () => {
+  sessionSocket.write(encodeControl({
+    type: "resize",
+    cols: process.stdout.columns,
+    rows: process.stdout.rows
+  }));
+});
+
+// Forward stdin to session
+process.stdin.setRawMode(true);
+process.stdin.resume();
+
+for await (const chunk of process.stdin) {
+  // Check for Ctrl+D (detach)
+  if (chunk[0] === 4) {
+    sessionSocket.write(encodeControl({ type: "detach" }));
+    process.stdin.setRawMode(false);
+    console.log("\nDetached (session still running)");
+    process.exit(0);
+  }
+
+  sessionSocket.write(chunk);
+}

package/experiments/router/protocol.ts

@@ -0,0 +1,74 @@
+/**
+ * Shared protocol between router, sessions, and clients
+ */
+
+export const ROUTER_SOCKET = "/tmp/spaces-router.sock";
+export const SESSION_SOCKET_PREFIX = "/tmp/spaces-session-";
+
+// Router commands (JSON over socket)
+export type RouterCommand =
+  | { type: "list" }
+  | { type: "create"; project: string; workspace: string; cwd: string }
+  | { type: "attach"; sessionId: string; mode?: AttachMode }
+  | { type: "kill"; sessionId: string }
+  | { type: "kick"; sessionId: string };  // Disconnect current client
+
+export type RouterResponse =
+  | { type: "sessions"; sessions: SessionInfo[] }
+  | { type: "created"; session: SessionInfo }
+  | { type: "already-attached"; session: SessionInfo }  // Session exists but has a client
+  | { type: "error"; message: string }
+  | { type: "ok" };
+
+export interface SessionInfo {
+  id: string;
+  project: string;
+  workspace: string;
+  socketPath: string;
+  pid: number;
+  attached: boolean;  // true if a client is connected
+  createdAt: number;
+}
+
+// When attaching to an already-attached session
+export type AttachMode =
+  | "take-over"   // Disconnect existing client, you take over
+  | "new"         // Create a new session for the same workspace
+  | "cancel";     // Abort
+
+// Session protocol (binary + JSON control)
+// Control messages start with 0x00, data is raw bytes
+export const CONTROL_PREFIX = 0x00;
+
+export type SessionControl =
+  | { type: "resize"; cols: number; rows: number }
+  | { type: "detach" }
+  | { type: "ping" };
+
+export type SessionEvent =
+  | { type: "attached"; scrollback: string }
+  | { type: "exited"; code: number }
+  | { type: "kicked" }  // Another client took over
+  | { type: "pong" };
+
+// Helper to encode control message
+export function encodeControl(msg: SessionControl | SessionEvent): Buffer {
+  const json = JSON.stringify(msg);
+  const buf = Buffer.alloc(1 + 4 + json.length);
+  buf[0] = CONTROL_PREFIX;
+  buf.writeUInt32BE(json.length, 1);
+  buf.write(json, 5);
+  return buf;
+}
+
+// Helper to check if data is control message
+export function isControl(data: Buffer): boolean {
+  return data[0] === CONTROL_PREFIX;
+}
+
+// Helper to decode control message
+export function decodeControl(data: Buffer): SessionControl | SessionEvent {
+  const len = data.readUInt32BE(1);
+  const json = data.subarray(5, 5 + len).toString();
+  return JSON.parse(json);
+}

package/experiments/router/router.ts

@@ -0,0 +1,217 @@
+#!/usr/bin/env bun
+/**
+ * Router - manages session lifecycle
+ * Always running, spawns sessions on demand
+ *
+ * Usage: bun router.ts
+ */
+
+import { unlinkSync, existsSync } from "fs";
+import { spawn } from "bun";
+import {
+  ROUTER_SOCKET,
+  SESSION_SOCKET_PREFIX,
+  type RouterCommand,
+  type RouterResponse,
+  type SessionInfo,
+} from "./protocol";
+
+// Clean up existing socket
+try { unlinkSync(ROUTER_SOCKET); } catch {}
+
+// Active sessions
+const sessions = new Map<string, {
+  info: SessionInfo;
+  proc: Bun.Subprocess;
+  stdin: WritableStream<Uint8Array>;
+}>();
+
+// Generate session ID
+function genId(): string {
+  return Math.random().toString(36).substring(2, 10);
+}
+
+// Find session by project/workspace
+function findSession(project: string, workspace: string) {
+  for (const [id, session] of sessions) {
+    if (session.info.project === project && session.info.workspace === workspace) {
+      return session;
+    }
+  }
+  return null;
+}
+
+// Spawn a new session
+async function createSession(project: string, workspace: string, cwd: string): Promise<SessionInfo> {
+  const id = genId();
+  const socketPath = `${SESSION_SOCKET_PREFIX}${id}.sock`;
+
+  const proc = spawn({
+    cmd: ["bun", "run", `${import.meta.dir}/session.ts`, socketPath, cwd, project, workspace],
+    stdout: "pipe",
+    stdin: "pipe",
+    stderr: "inherit",
+  });
+
+  // Wait for ready event
+  const reader = proc.stdout.getReader();
+  const { value } = await reader.read();
+  const ready = JSON.parse(new TextDecoder().decode(value));
+
+  if (ready.event !== "ready") {
+    throw new Error("Session failed to start");
+  }
+
+  const info: SessionInfo = {
+    id,
+    project,
+    workspace,
+    socketPath,
+    pid: ready.pid,
+    attached: false,
+    createdAt: Date.now(),
+  };
+
+  const sessionData = { info, proc, stdin: proc.stdin };
+  sessions.set(id, sessionData);
+
+  // Monitor session stdout for state updates
+  (async () => {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      try {
+        const lines = new TextDecoder().decode(value).trim().split('\n');
+        for (const line of lines) {
+          const event = JSON.parse(line);
+          if (event.attached !== undefined) {
+            const session = sessions.get(id);
+            if (session) session.info.attached = event.attached;
+          }
+        }
+      } catch {}
+    }
+
+    // Session ended
+    sessions.delete(id);
+    console.log(`[router] Session ${id} ended`);
+  })();
+
+  console.log(`[router] Created session ${id} for ${project}/${workspace}`);
+  return info;
+}
+
+// Kick client from session
+async function kickSession(sessionId: string): Promise<boolean> {
+  const session = sessions.get(sessionId);
+  if (!session) return false;
+
+  const writer = session.stdin.getWriter();
+  await writer.write(new TextEncoder().encode("kick\n"));
+  writer.releaseLock();
+  return true;
+}
+
+// Start router server
+const server = Bun.listen({
+  unix: ROUTER_SOCKET,
+  socket: {
+    async data(socket, data) {
+      try {
+        const cmd: RouterCommand = JSON.parse(data.toString());
+        let response: RouterResponse;
+
+        switch (cmd.type) {
+          case "list":
+            response = {
+              type: "sessions",
+              sessions: Array.from(sessions.values()).map(s => s.info)
+            };
+            break;
+
+          case "create": {
+            // Check if session already exists for this workspace
+            const existing = findSession(cmd.project, cmd.workspace);
+
+            if (existing) {
+              if (existing.info.attached) {
+                // Session exists and has a client
+                response = { type: "already-attached", session: existing.info };
+              } else {
+                // Session exists but detached - reuse it
+                response = { type: "created", session: existing.info };
+              }
+            } else {
+              // Create new session
+              const session = await createSession(cmd.project, cmd.workspace, cmd.cwd);
+              response = { type: "created", session };
+            }
+            break;
+          }
+
+          case "attach": {
+            const session = sessions.get(cmd.sessionId);
+            if (!session) {
+              response = { type: "error", message: "Session not found" };
+            } else if (session.info.attached && cmd.mode !== "take-over") {
+              response = { type: "already-attached", session: session.info };
+            } else {
+              if (cmd.mode === "take-over" && session.info.attached) {
+                await kickSession(cmd.sessionId);
+                await Bun.sleep(50); // Let kick propagate
+              }
+              response = { type: "created", session: session.info };
+            }
+            break;
+          }
+
+          case "kick": {
+            const kicked = await kickSession(cmd.sessionId);
+            response = kicked ? { type: "ok" } : { type: "error", message: "Session not found" };
+            break;
+          }
+
+          case "kill": {
+            const toKill = sessions.get(cmd.sessionId);
+            if (toKill) {
+              toKill.proc.kill();
+              sessions.delete(cmd.sessionId);
+              response = { type: "ok" };
+            } else {
+              response = { type: "error", message: "Session not found" };
+            }
+            break;
+          }
+
+          default:
+            response = { type: "error", message: "Unknown command" };
+        }
+
+        socket.write(JSON.stringify(response));
+      } catch (e: any) {
+        socket.write(JSON.stringify({ type: "error", message: e.message }));
+      }
+    },
+    error(socket, error) {
+      console.error("[router] Client error:", error.message);
+    }
+  }
+});
+
+console.log(`[router] Listening on ${ROUTER_SOCKET}`);
+console.log("[router] Ready");
+
+// Cleanup on exit
+process.on("SIGTERM", () => {
+  for (const [id, session] of sessions) {
+    session.proc.kill();
+  }
+  server.stop();
+  try { unlinkSync(ROUTER_SOCKET); } catch {}
+  process.exit(0);
+});
+
+process.on("SIGINT", () => {
+  process.emit("SIGTERM" as any);
+});

package/experiments/router/session.ts

@@ -0,0 +1,180 @@
+#!/usr/bin/env bun
+/**
+ * Session server - manages a single PTY session
+ * One client at a time, supports kick for takeover
+ *
+ * Usage: bun session.ts <socket-path> <cwd> <project> <workspace>
+ */
+
+import { unlinkSync } from "fs";
+import {
+  encodeControl,
+  isControl,
+  decodeControl,
+  type SessionControl,
+} from "./protocol";
+
+const [socketPath, cwd, project, workspace] = process.argv.slice(2);
+
+if (!socketPath || !cwd) {
+  console.error("Usage: bun session.ts <socket-path> <cwd> <project> <workspace>");
+  process.exit(1);
+}
+
+// Clean up existing socket
+try { unlinkSync(socketPath); } catch {}
+
+// Scrollback buffer (keep last 50KB)
+const MAX_SCROLLBACK = 50 * 1024;
+let scrollback = Buffer.alloc(0);
+
+// Current attached client (only one allowed)
+let client: any = null;
+
+// Create PTY
+const terminal = new Bun.Terminal({
+  cols: 120,
+  rows: 40,
+  data(term, data) {
+    // Add to scrollback
+    scrollback = Buffer.concat([scrollback, data]);
+    if (scrollback.length > MAX_SCROLLBACK) {
+      scrollback = scrollback.subarray(-MAX_SCROLLBACK);
+    }
+
+    // Send to attached client
+    if (client) {
+      client.write(data);
+    }
+  }
+});
+
+// Spawn shell
+const proc = Bun.spawn(["bash"], {
+  terminal,
+  cwd,
+  env: {
+    ...process.env,
+    SPACES_PROJECT: project,
+    SPACES_WORKSPACE: workspace,
+  },
+});
+
+// Handle shell exit
+proc.exited.then(code => {
+  if (client) {
+    client.write(encodeControl({ type: "exited", code }));
+  }
+  // Give client time to receive exit message
+  setTimeout(() => {
+    server.stop();
+    try { unlinkSync(socketPath); } catch {}
+    process.exit(code);
+  }, 100);
+});
+
+// Report state to router
+function reportState(event: string) {
+  console.log(JSON.stringify({ event, attached: client !== null }));
+}
+
+// Kick current client
+function kickClient() {
+  if (client) {
+    client.write(encodeControl({ type: "kicked" }));
+    client.end();
+    client = null;
+    reportState("client_kicked");
+  }
+}
+
+// Start server
+const server = Bun.listen({
+  unix: socketPath,
+  socket: {
+    open(socket) {
+      if (client) {
+        // Already have a client - kick them
+        kickClient();
+      }
+
+      client = socket;
+      reportState("client_attached");
+
+      // Send scrollback to new client
+      const attachMsg = encodeControl({
+        type: "attached",
+        scrollback: scrollback.toString("base64")
+      });
+      socket.write(attachMsg);
+    },
+
+    data(socket, data) {
+      const buf = Buffer.from(data);
+
+      if (isControl(buf)) {
+        const ctrl = decodeControl(buf) as SessionControl;
+
+        switch (ctrl.type) {
+          case "resize":
+            terminal.resize(ctrl.cols, ctrl.rows);
+            break;
+          case "detach":
+            if (socket === client) {
+              client = null;
+              reportState("client_detached");
+            }
+            socket.end();
+            break;
+          case "ping":
+            socket.write(encodeControl({ type: "pong" }));
+            break;
+        }
+      } else {
+        // Raw input - write to PTY
+        terminal.write(buf);
+      }
+    },
+
+    close(socket) {
+      if (socket === client) {
+        client = null;
+        reportState("client_disconnected");
+      }
+    },
+
+    error(socket, error) {
+      console.error(JSON.stringify({ event: "error", message: error.message }));
+      if (socket === client) {
+        client = null;
+      }
+    }
+  }
+});
+
+console.log(JSON.stringify({
+  event: "ready",
+  socketPath,
+  pid: process.pid,
+  project,
+  workspace,
+  attached: false
+}));
+
+// Handle stdin commands from router (for kick)
+const decoder = new TextDecoder();
+for await (const chunk of Bun.stdin.stream()) {
+  const cmd = decoder.decode(chunk).trim();
+  if (cmd === "kick") {
+    kickClient();
+  }
+}
+
+// Handle termination
+process.on("SIGTERM", () => {
+  proc.kill();
+  terminal.close();
+  server.stop();
+  try { unlinkSync(socketPath); } catch {}
+  process.exit(0);
+});