gitspace 0.2.0-rc.2 → 0.2.0-rc.21

package/experiments/router/client.ts

@@ -1,199 +0,0 @@
-#!/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

@@ -1,74 +0,0 @@
-/**
- * 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

@@ -1,217 +0,0 @@
-#!/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

@@ -1,180 +0,0 @@
-#!/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);
-});