gitspace 0.2.0-rc.20 → 0.2.0-rc.21

package/src/session/__tests__/workspace-shell-hooks.test.ts

@@ -1,24 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-import { buildWorkspaceSessionHooks } from '../workspace-shell-hooks.js';
-
-describe('buildWorkspaceSessionHooks', () => {
-  it('injects workspace environment context', () => {
-    const hooks = buildWorkspaceSessionHooks('acme', 'feature-1');
-
-    expect(hooks.env).toEqual({
-      GSSH_SESSION_MODE: 'workspace',
-      GSSH_SPACE_PROJECT: 'acme',
-      GSSH_SPACE_WORKSPACE: 'feature-1',
-    });
-  });
-
-  it('builds bash and zsh space function with escaped args', () => {
-    const hooks = buildWorkspaceSessionHooks("acme's repo", 'feat one');
-
-    const expected =
-      `space() { GSSH_SPACE_PROJECT='acme'\\''s repo' GSSH_SPACE_WORKSPACE='feat one' gssh space "$@"; }`;
-
-    expect(hooks.shellInit?.bash).toBe(expected);
-    expect(hooks.shellInit?.zsh).toBe(expected);
-  });
-});

package/src/session/adapters/browser-remote.ts

@@ -1,101 +0,0 @@
-import type {
-  RemoteSessionCryptoAdapter,
-  RemoteSessionHandshakeAdapter,
-  RemoteSessionSocketAdapter,
-} from '../backends/remote-session-backend.js'
-import { SpacesError } from '../../types/errors.js'
-
-const DEFAULT_CONTROL_STREAM_ID = 1
-
-export type BrowserRemoteSocket = WebSocket
-
-export const browserRemoteSocketAdapter: RemoteSessionSocketAdapter<WebSocket> = {
-  setHandlers: (socket, handlers) => {
-    socket.onopen = handlers.onOpen
-    socket.onclose = handlers.onClose
-    socket.onmessage = (event) => {
-      handlers.onMessage(String(event.data))
-    }
-    socket.onerror = () => {
-      handlers.onError(new SpacesError('Connection failed', 'SYSTEM_ERROR', 2))
-    }
-  },
-  clearHandlers: (socket) => {
-    socket.onopen = null
-    socket.onclose = null
-    socket.onmessage = null
-    socket.onerror = null
-  },
-  send: (socket, data) => socket.send(data),
-  close: (socket) => socket.close(),
-  getReadyState: (socket) => socket.readyState,
-  getOpenReadyStateValue: () => WebSocket.OPEN,
-}
-
-export interface BrowserRemoteFrameCodec {
-  masterStreamId: number
-  createFrame: (streamId: number, data: Uint8Array, key: Uint8Array) => Promise<Uint8Array>
-  openFrame: (
-    frame: Uint8Array,
-    key: Uint8Array
-  ) => Promise<{ streamId: number; data: Uint8Array } | null>
-}
-
-function encodeBase64(data: Uint8Array): string {
-  const chunkSize = 0x8000
-  let binary = ''
-  for (let index = 0; index < data.length; index += chunkSize) {
-    const chunk = data.subarray(index, index + chunkSize)
-    binary += String.fromCharCode(...chunk)
-  }
-  return btoa(binary)
-}
-
-function decodeBase64(base64: string): Uint8Array {
-  const binary = atob(base64)
-  const bytes = new Uint8Array(binary.length)
-  for (let index = 0; index < binary.length; index += 1) {
-    bytes[index] = binary.charCodeAt(index)
-  }
-  return bytes
-}
-
-export function createBrowserRemoteCryptoAdapter(
-  codec: BrowserRemoteFrameCodec,
-  options: { controlStreamId?: number } = {}
-): RemoteSessionCryptoAdapter {
-  return {
-    masterStreamId: codec.masterStreamId,
-    controlStreamId: options.controlStreamId ?? DEFAULT_CONTROL_STREAM_ID,
-    createFrame: codec.createFrame,
-    openFrame: codec.openFrame,
-    encodeBase64,
-    decodeBase64,
-  }
-}
-
-export function createBrowserRemoteHandshakeAdapter<
-  THandshakeState,
-  TServerHello,
-  TServerAuth,
->(
-  adapter: RemoteSessionHandshakeAdapter<THandshakeState, TServerHello, TServerAuth>
-): RemoteSessionHandshakeAdapter<THandshakeState, TServerHello, TServerAuth> {
-  return adapter
-}
-
-export function deriveRelayUrlFromBrowserSocket(socket: Pick<WebSocket, 'url'>): string {
-  let parsedUrl: URL
-  try {
-    parsedUrl = new URL(socket.url)
-  } catch {
-    throw new SpacesError(
-      `Unable to derive relay URL from socket URL: ${socket.url}`,
-      'SYSTEM_ERROR',
-      2
-    )
-  }
-  parsedUrl.search = ''
-  parsedUrl.hash = ''
-  return parsedUrl.toString()
-}

package/src/session/adapters/node-remote.ts

@@ -1,135 +0,0 @@
-import WebSocket from 'ws';
-import type {
-  Identity,
-  X3DHResponseMessage,
-  X3DHResultMessage,
-} from '../../types/identity.js';
-import {
-  createClientHello,
-  processServerHello,
-  createClientAuth,
-  processServerAuth,
-  type X3DHClientState,
-} from '../../lib/tmux-lite/crypto/handshake.js';
-import {
-  createFrame as createEncryptedFrame,
-  openFrame as openEncryptedFrame,
-  MASTER_STREAM_ID,
-} from '../../lib/tmux-lite/crypto/frames.js';
-import { signMessage } from '../../relay/signing.js';
-import type {
-  RemoteSessionCryptoAdapter,
-  RemoteSessionHandshakeAdapter,
-  RemoteSessionSocketAdapter,
-} from '../backends/remote-session-backend.js';
-
-const CONTROL_STREAM_ID = 1;
-
-export type NodeRemoteSocket = WebSocket;
-
-export const nodeRemoteSocketAdapter: RemoteSessionSocketAdapter<WebSocket> = {
-  setHandlers: (socket, handlers) => {
-    socket.on('open', handlers.onOpen);
-    socket.on('close', handlers.onClose);
-    socket.on('message', (data) => {
-      const raw = typeof data === 'string' ? data : data.toString();
-      handlers.onMessage(raw);
-    });
-    socket.on('error', (error) => {
-      handlers.onError(error instanceof Error ? error : new Error(String(error)));
-    });
-  },
-  clearHandlers: (socket) => {
-    socket.removeAllListeners('open');
-    socket.removeAllListeners('close');
-    socket.removeAllListeners('message');
-    socket.removeAllListeners('error');
-  },
-  send: (socket, data) => socket.send(data),
-  close: (socket) => socket.close(),
-  getReadyState: (socket) => socket.readyState,
-  getOpenReadyStateValue: () => WebSocket.OPEN,
-};
-
-export const nodeRemoteCryptoAdapter: RemoteSessionCryptoAdapter = {
-  masterStreamId: MASTER_STREAM_ID,
-  controlStreamId: CONTROL_STREAM_ID,
-  createFrame: async (streamId, data, key) => {
-    const frame = createEncryptedFrame(streamId, Buffer.from(data), key);
-    return new Uint8Array(frame);
-  },
-  openFrame: async (frame, key) => {
-    const result = openEncryptedFrame(Buffer.from(frame), key);
-    if (!result) {
-      return null;
-    }
-    return {
-      streamId: result.streamId,
-      data: new Uint8Array(result.data),
-    };
-  },
-  encodeBase64: (data) => Buffer.from(data).toString('base64'),
-  decodeBase64: (base64) => new Uint8Array(Buffer.from(base64, 'base64')),
-};
-
-function isServerHello(data: unknown): data is X3DHResponseMessage {
-  if (!data || typeof data !== 'object') {
-    return false;
-  }
-  const value = data as Record<string, unknown>;
-  return (
-    typeof value.version === 'number' &&
-    typeof value.identityKey === 'string' &&
-    typeof value.keyExchangeKey === 'string' &&
-    typeof value.ephemeralKey === 'string' &&
-    typeof value.signedPreKey === 'string' &&
-    typeof value.preKeySignature === 'string' &&
-    typeof value.serverNonce === 'string' &&
-    typeof value.timestamp === 'number'
-  );
-}
-
-function isServerAuth(data: unknown): data is X3DHResultMessage {
-  if (!data || typeof data !== 'object') {
-    return false;
-  }
-  const value = data as Record<string, unknown>;
-  if (
-    typeof value.version !== 'number' ||
-    typeof value.identityKey !== 'string' ||
-    typeof value.identityProof !== 'string'
-  ) {
-    return false;
-  }
-  const result = value.result as Record<string, unknown> | undefined;
-  if (!result || typeof result !== 'object' || typeof result.type !== 'string') {
-    return false;
-  }
-  if (result.type === 'accepted') {
-    return result.accessType === 'full' || result.accessType === 'session-invite';
-  }
-  if (result.type === 'rejected') {
-    return typeof result.reason === 'string';
-  }
-  return false;
-}
-
-export const nodeRemoteHandshakeAdapter: RemoteSessionHandshakeAdapter<
-  X3DHClientState,
-  X3DHResponseMessage,
-  X3DHResultMessage
-> = {
-  createClientHello,
-  isServerHello,
-  processServerHello,
-  createClientAuth,
-  isServerAuth,
-  processServerAuth,
-};
-
-export function createNodeRelaySigner(identity: Identity) {
-  return <T extends object>(message: T): T => {
-    const privateKey = identity.signing.secretKey.slice(0, 32);
-    return signMessage(message, privateKey, identity.signing.publicKey);
-  };
-}

package/src/session/backend-key.ts

@@ -1,5 +0,0 @@
-import type { BackendKey } from './backend.js';
-
-export function buildRemoteBackendKey(relayUrl: string, machineId: string): BackendKey {
-  return `remote:${relayUrl}:${machineId}`;
-}

package/src/session/backend-manager.ts

@@ -1,80 +0,0 @@
-import type { SessionBackend, BackendKey } from './backend.js';
-import type { BackendEvent } from './events.js';
-import { SpacesError } from '../types/errors.js';
-
-export interface BackendManagerEvent {
-  backendKey: BackendKey;
-  event: BackendEvent;
-}
-
-/**
- * Registry/lifecycle helper for multiple concurrent backends.
- */
-export class BackendManager {
-  private readonly backends = new Map<BackendKey, SessionBackend>();
-  private readonly unsubs = new Map<BackendKey, () => void>();
-  private readonly onEvent: (event: BackendManagerEvent) => void;
-
-  constructor(onEvent: (event: BackendManagerEvent) => void) {
-    this.onEvent = onEvent;
-  }
-
-  register(backend: SessionBackend): void {
-    const key = backend.descriptor.key;
-    if (this.backends.has(key)) {
-      return;
-    }
-
-    this.backends.set(key, backend);
-    const unsub = backend.onEvent((event) => {
-      this.onEvent({ backendKey: key, event });
-    });
-    this.unsubs.set(key, unsub);
-  }
-
-  async unregister(backendKey: BackendKey): Promise<void> {
-    const backend = this.backends.get(backendKey);
-    if (!backend) {
-      return;
-    }
-
-    const unsub = this.unsubs.get(backendKey);
-    if (unsub) {
-      unsub();
-      this.unsubs.delete(backendKey);
-    }
-
-    await backend.disconnect();
-    this.backends.delete(backendKey);
-  }
-
-  async connect(backendKey: BackendKey): Promise<void> {
-    const backend = this.backends.get(backendKey);
-    if (!backend) {
-      throw new SpacesError(`Backend not found: ${backendKey}`, 'SYSTEM_ERROR', 2);
-    }
-
-    await backend.connect();
-  }
-
-  async disconnect(backendKey: BackendKey): Promise<void> {
-    const backend = this.backends.get(backendKey);
-    if (!backend) {
-      return;
-    }
-    await backend.disconnect();
-  }
-
-  get(backendKey: BackendKey): SessionBackend | null {
-    return this.backends.get(backendKey) || null;
-  }
-
-  keys(): BackendKey[] {
-    return [...this.backends.keys()];
-  }
-
-  async disconnectAll(): Promise<void> {
-    const keys = this.keys();
-    await Promise.all(keys.map((key) => this.disconnect(key)));
-  }
-}

package/src/session/backend.ts

@@ -1,93 +0,0 @@
-import type { NotificationConfig } from '../notifications/types.js';
-import type { BackendEvent } from './events.js';
-import type {
-  BundleRefreshPlan,
-  BundleRefreshSubmission,
-} from '../types/bundle-refresh.js';
-import type { ReviewOperation, ReviewResult } from '../types/review.js';
-import type { WideEventFilter } from '../types/events.js';
-
-export type BackendKey = string;
-export type BackendKind = 'local' | 'remote';
-
-export interface BackendDescriptor {
-  key: BackendKey;
-  kind: BackendKind;
-  label: string;
-  machineId?: string;
-  relayUrl?: string;
-}
-
-export interface AttachSessionParams {
-  sessionId?: string;
-  workspaceId?: string;
-  sessionName?: string;
-  cols?: number;
-  rows?: number;
-  scriptPolicy?: 'auto' | 'skip';
-  /** When true, the client cannot send input to the PTY (view-only mode) */
-  viewOnly?: boolean;
-  /** Custom command to run (skips workspace scripts when set) */
-  command?: string;
-  /** Arguments for the custom command */
-  args?: string[];
-  /** Environment variables for the custom command */
-  env?: Record<string, string>;
-}
-
-export interface DeleteWorkspaceParams {
-  scriptPolicy?: 'auto' | 'skip';
-  /**
-   * Optional timeout for delete completion when waiting on remote responses.
-   * Ignored by local backend.
-   */
-  timeoutMs?: number;
-}
-
-/**
- * Canonical backend contract used by shared session engine.
- */
-export interface SessionBackend {
-  readonly descriptor: BackendDescriptor;
-
-  connect(): Promise<void>;
-  disconnect(): Promise<void>;
-
-  listProjects(): Promise<void>;
-  listWorkspaces(): Promise<void>;
-  listSessions(workspaceId?: string): Promise<void>;
-
-  attachSession(params: AttachSessionParams): Promise<void>;
-  detachSession(): Promise<void>;
-
-  killSession(sessionId: string): Promise<void>;
-  deleteWorkspace(
-    projectName: string,
-    workspaceId: string,
-    params?: DeleteWorkspaceParams
-  ): Promise<void>;
-
-  getBundleRefreshPlan(projectName: string, workspaceId: string): Promise<BundleRefreshPlan>;
-  applyBundleRefresh(
-    projectName: string,
-    workspaceId: string,
-    submission: BundleRefreshSubmission
-  ): Promise<void>;
-
-  requestInbox(): Promise<void>;
-  clearInbox(id?: string): Promise<void>;
-  markInboxRead(id: string): Promise<void>;
-
-  getNotificationConfig(): Promise<void>;
-  updateNotificationConfig(config: NotificationConfig): Promise<void>;
-
-  sendReviewRequest(operation: ReviewOperation): Promise<ReviewResult>;
-  startProcess?(workspaceId: string, processName: string, instance?: number): Promise<void>;
-  stopProcess?(workspaceId: string, processName: string): Promise<void>;
-  requestEvents?(workspacePath: string, filter?: WideEventFilter, limit?: number, sinceMs?: number): Promise<void>;
-
-  writePtyData?(data: Uint8Array): Promise<void>;
-  resizePty?(cols: number, rows: number): Promise<void>;
-
-  onEvent(handler: (event: BackendEvent) => void): () => void;
-}