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

package/src/__tests__/test-utils.ts

@@ -1,298 +0,0 @@
-/**
- * Test Utilities for Type-Safe Mocking
- *
- * Provides type-safe mock factories and type guards for testing.
- * Avoids the need for `as any` casts in test files.
- */
-
-import type {
-  ProcessResult,
-  HandshakeMessage,
-  EstablishedSession,
-} from "../lib/tmux-lite/handshake-handler.js";
-
-// ============================================================================
-// WebSocket Mocks
-// ============================================================================
-
-/**
- * WebSocket data interface used by the relay server
- */
-export interface WebSocketData {
-  machineId: string;
-  role: "machine" | "client";
-  connectionId: string;
-  accountId: string;
-  clientIdentityId?: string;
-}
-
-/**
- * Mock WebSocket configuration
- */
-export interface MockWebSocketConfig {
-  data?: Partial<WebSocketData>;
-  sendMock?: (data: string) => void;
-  closeMock?: (code?: number, reason?: string) => void;
-}
-
-/**
- * Type-safe mock WebSocket interface
- */
-export interface MockWebSocket {
-  data: WebSocketData;
-  send: MockFn<[string], void>;
-  close: MockFn<[number?, string?], void>;
-  readyState: number;
-}
-
-/**
- * Mock function type with call tracking
- */
-interface MockFn<Args extends unknown[] = unknown[], Return = void> {
-  (...args: Args): Return;
-  calls: Args[];
-  callCount: number;
-}
-
-/**
- * Create a mock function that tracks calls
- */
-function createMockFn<Args extends unknown[] = unknown[], Return = void>(
-  impl?: (...args: Args) => Return
-): MockFn<Args, Return> {
-  const calls: Args[] = [];
-  const fn = ((...args: Args) => {
-    calls.push(args);
-    return impl?.(...args) as Return;
-  }) as MockFn<Args, Return>;
-  fn.calls = calls;
-  Object.defineProperty(fn, "callCount", {
-    get() {
-      return calls.length;
-    },
-  });
-  return fn;
-}
-
-/**
- * Create a type-safe mock WebSocket for testing
- *
- * @example
- * const mockWs = createMockWebSocket({
- *   data: { machineId: "test-machine", role: "machine" },
- * });
- * expect(mockWs.send.callCount).toBe(0);
- */
-export function createMockWebSocket(config: MockWebSocketConfig = {}): MockWebSocket {
-  return {
-    data: {
-      machineId: config.data?.machineId ?? "test-machine",
-      role: config.data?.role ?? "machine",
-      connectionId: config.data?.connectionId ?? "conn-1",
-      accountId: config.data?.accountId ?? "test-account",
-      clientIdentityId: config.data?.clientIdentityId,
-    },
-    send: createMockFn<[string], void>(config.sendMock),
-    close: createMockFn<[number?, string?], void>(config.closeMock),
-    readyState: 1, // OPEN
-  };
-}
-
-/**
- * Cast a mock WebSocket to any type for use with functions that expect
- * specific WebSocket types (like ServerWebSocket<WebSocketData>).
- *
- * This is a deliberate type assertion for testing purposes - the mock
- * implements the minimal interface needed for the tests.
- *
- * @example
- * const mockWs = asMockWs(createMockWebSocket({ data: { machineId: "test" } }));
- * registerMachine("id", "account", "key", "kxKey", mockWs);
- */
-export function asMockWs<T>(mock: MockWebSocket): T {
-  return mock as unknown as T;
-}
-
-// ============================================================================
-// Handler Result Type Guards
-// ============================================================================
-
-// Re-export types from handshake-handler for convenience
-export type { ProcessResult, HandshakeMessage, EstablishedSession };
-
-/** Reply result from handshake processing */
-export type ReplyResult = Extract<ProcessResult, { type: "reply" }>;
-
-/** Established result from handshake processing */
-export type EstablishedResult = Extract<ProcessResult, { type: "established" }>;
-
-/** Error result from handshake processing */
-export type ErrorResult = Extract<ProcessResult, { type: "error" }>;
-
-/**
- * Type guard for reply results
- */
-export function isReplyResult(result: ProcessResult): result is ReplyResult {
-  return result.type === "reply";
-}
-
-/**
- * Type guard for established results
- */
-export function isEstablishedResult(result: ProcessResult): result is EstablishedResult {
-  return result.type === "established";
-}
-
-/**
- * Type guard for error results
- */
-export function isErrorResult(result: ProcessResult): result is ErrorResult {
-  return result.type === "error";
-}
-
-/**
- * Extract message data from a reply result with proper typing
- */
-export function getReplyData<T>(result: ProcessResult): T {
-  if (!isReplyResult(result)) {
-    throw new Error(`Expected reply result, got: ${result.type}`);
-  }
-  return result.message.data as T;
-}
-
-/**
- * Get error reason from an error result
- */
-export function getErrorReason(result: ProcessResult): string {
-  if (!isErrorResult(result)) {
-    throw new Error(`Expected error result, got: ${result.type}`);
-  }
-  return result.reason;
-}
-
-// ============================================================================
-// Object Utilities
-// ============================================================================
-
-/**
- * Create a copy of an object with specific properties omitted.
- * Safer alternative to `delete (obj as any).prop`.
- *
- * @example
- * const authWithoutSignature = omit(clientAuth, 'identitySignature');
- */
-export function omit<T extends object, K extends keyof T>(
-  obj: T,
-  ...keys: K[]
-): Omit<T, K> {
-  const result = { ...obj };
-  for (const key of keys) {
-    delete result[key];
-  }
-  return result;
-}
-
-/**
- * Create a copy of an object with only specific properties included.
- *
- * @example
- * const minimalAuth = pick(clientAuth, 'version', 'identityKey');
- */
-export function pick<T extends object, K extends keyof T>(
-  obj: T,
-  ...keys: K[]
-): Pick<T, K> {
-  const result = {} as Pick<T, K>;
-  for (const key of keys) {
-    if (key in obj) {
-      result[key] = obj[key];
-    }
-  }
-  return result;
-}
-
-// ============================================================================
-// Private Property Access for Testing
-// ============================================================================
-
-/**
- * Interface for accessing RelayClient internal state in tests.
- * This should only be used for test verification, not production code.
- */
-export interface RelayClientTestAccess {
-  readKey: Buffer | null;
-  writeKey: Buffer | null;
-  handshakeState: unknown;
-  sessionKeys: unknown;
-  peerIdentityId: string | null;
-}
-
-/**
- * Get test access to RelayClient private properties.
- * This uses a type assertion to access private fields for testing verification.
- *
- * @example
- * const testAccess = getRelayClientTestAccess(client);
- * expect(testAccess.writeKey).toBeDefined();
- */
-export function getRelayClientTestAccess(client: object): RelayClientTestAccess {
-  // This is a deliberate type assertion for test purposes
-  // RelayClient has private properties that we need to verify in tests
-  const internal = client as {
-    readKey: Buffer | null;
-    writeKey: Buffer | null;
-    handshakeState: unknown;
-    sessionKeys: unknown;
-    peerIdentityId: string | null;
-  };
-  return {
-    readKey: internal.readKey,
-    writeKey: internal.writeKey,
-    handshakeState: internal.handshakeState,
-    sessionKeys: internal.sessionKeys,
-    peerIdentityId: internal.peerIdentityId,
-  };
-}
-
-// ============================================================================
-// Assertion Helpers
-// ============================================================================
-
-/**
- * Assert that a value is defined (not null or undefined)
- */
-export function assertDefined<T>(
-  value: T | null | undefined,
-  message = "Expected value to be defined"
-): asserts value is T {
-  if (value === null || value === undefined) {
-    throw new Error(message);
-  }
-}
-
-/**
- * Assert that a result is a reply type
- */
-export function assertReply(result: ProcessResult): asserts result is ReplyResult {
-  if (!isReplyResult(result)) {
-    throw new Error(`Expected reply result, got: ${result.type}`);
-  }
-}
-
-/**
- * Assert that a result is an established type
- */
-export function assertEstablished(result: ProcessResult): asserts result is EstablishedResult {
-  if (!isEstablishedResult(result)) {
-    throw new Error(`Expected established result, got: ${result.type}`);
-  }
-}
-
-/**
- * Assert that a result is an error type
- */
-export function assertError(result: ProcessResult): asserts result is ErrorResult {
-  if (!isErrorResult(result)) {
-    throw new Error(`Expected error result, got: ${result.type}`);
-  }
-}

package/src/app/input/__tests__/sessionCommands.test.ts

@@ -1,40 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import {
-  resolveInboxCommand,
-  resolveMachineListCommand,
-  resolveSessionBrowserCommand,
-} from '../sessionCommands.js'
-
-describe('sessionCommands', () => {
-  it('resolves machine list commands for web and tui inputs', () => {
-    expect(resolveMachineListCommand({ key: 'ArrowUp' })).toBe('move-up')
-    expect(resolveMachineListCommand({ name: 'down' })).toBe('move-down')
-    expect(resolveMachineListCommand({ key: 'Enter' })).toBe('activate')
-    expect(resolveMachineListCommand({ raw: 'r' })).toBe('refresh')
-    expect(resolveMachineListCommand({ key: 'c' })).toBe('copy')
-    expect(resolveMachineListCommand({ key: '?' })).toBe('help')
-  })
-
-  it('resolves inbox commands for web and tui inputs', () => {
-    expect(resolveInboxCommand({ key: 'ArrowUp' })).toBe('move-up')
-    expect(resolveInboxCommand({ raw: 'j' })).toBe('move-down')
-    expect(resolveInboxCommand({ key: 'Enter' })).toBe('activate')
-    expect(resolveInboxCommand({ key: 'Escape' })).toBe('back')
-    expect(resolveInboxCommand({ key: 'x' })).toBe('delete')
-    expect(resolveInboxCommand({ key: 'c' })).toBe('clear')
-    expect(resolveInboxCommand({ key: 'a' })).toBe('attach')
-  })
-
-  it('resolves session browser commands for web and tui inputs', () => {
-    expect(resolveSessionBrowserCommand({ key: 'ArrowUp' })).toBe('move-up')
-    expect(resolveSessionBrowserCommand({ raw: 'j' })).toBe('move-down')
-    expect(resolveSessionBrowserCommand({ key: 'Enter' })).toBe('activate')
-    expect(resolveSessionBrowserCommand({ key: 'n' })).toBe('new')
-    expect(resolveSessionBrowserCommand({ key: 'r' })).toBe('refresh')
-    expect(resolveSessionBrowserCommand({ key: 'q' })).toBe('back')
-    expect(resolveSessionBrowserCommand({ key: '?' })).toBe('help')
-    expect(resolveSessionBrowserCommand({ key: 'x' })).toBe('kill')
-    expect(resolveSessionBrowserCommand({ key: 'd' })).toBe('delete')
-    expect(resolveSessionBrowserCommand({ key: 'i' })).toBe('open-inbox')
-  })
-})

package/src/app/input/sessionCommands.ts

@@ -1,94 +0,0 @@
-export interface SessionCommandKeyInput {
-  key?: string | null
-  name?: string | null
-  raw?: string | null
-  shift?: boolean
-}
-
-export type SessionUiCommand =
-  | 'move-up'
-  | 'move-down'
-  | 'activate'
-  | 'back'
-  | 'new'
-  | 'refresh'
-  | 'help'
-  | 'delete'
-  | 'clear'
-  | 'attach'
-  | 'kill'
-  | 'open-inbox'
-  | 'copy'
-
-function normalizeCommandKey(input: SessionCommandKeyInput): string | null {
-  const key = input.key?.toLowerCase()
-  if (key) {
-    if (key === 'arrowup') return 'up'
-    if (key === 'arrowdown') return 'down'
-    if (key === 'enter') return 'return'
-    if (key === 'escape') return 'escape'
-    return key
-  }
-
-  const name = input.name?.toLowerCase()
-  if (name === 'up' || name === 'down' || name === 'return' || name === 'escape') {
-    return name
-  }
-
-  const raw = input.raw
-  if (!raw) {
-    return null
-  }
-
-  return raw.toLowerCase()
-}
-
-export function resolveMachineListCommand(input: SessionCommandKeyInput): SessionUiCommand | null {
-  const key = normalizeCommandKey(input)
-  if (!key) {
-    return null
-  }
-
-  if (key === 'up' || key === 'k') return 'move-up'
-  if (key === 'down' || key === 'j') return 'move-down'
-  if (key === 'return') return 'activate'
-  if (key === 'r') return 'refresh'
-  if (key === 'c') return 'copy'
-  if (key === '?') return 'help'
-  return null
-}
-
-export function resolveInboxCommand(input: SessionCommandKeyInput): SessionUiCommand | null {
-  const key = normalizeCommandKey(input)
-  if (!key) {
-    return null
-  }
-
-  if (key === 'up' || key === 'k') return 'move-up'
-  if (key === 'down' || key === 'j') return 'move-down'
-  if (key === 'return') return 'activate'
-  if (key === 'escape' || key === 'q') return 'back'
-  if (key === 'x') return 'delete'
-  if (key === 'c') return 'clear'
-  if (key === 'a') return 'attach'
-  return null
-}
-
-export function resolveSessionBrowserCommand(input: SessionCommandKeyInput): SessionUiCommand | null {
-  const key = normalizeCommandKey(input)
-  if (!key) {
-    return null
-  }
-
-  if (key === 'up' || key === 'k') return 'move-up'
-  if (key === 'down' || key === 'j') return 'move-down'
-  if (key === 'return') return 'activate'
-  if (key === 'n') return 'new'
-  if (key === 'r') return 'refresh'
-  if (key === 'escape' || key === 'q') return 'back'
-  if (key === '?') return 'help'
-  if (key === 'x') return 'kill'
-  if (key === 'd') return 'delete'
-  if (key === 'i') return 'open-inbox'
-  return null
-}

package/src/app/session/__tests__/useAttachController.test.ts

@@ -1,229 +0,0 @@
-import { afterAll, beforeAll, describe, expect, it, mock } from 'bun:test'
-import { renderHook } from '@testing-library/react'
-import { Window } from 'happy-dom'
-import { useAttachController } from '../useAttachController.js'
-
-const domWindow = new Window()
-const originalWindow = globalThis.window
-const originalDocument = globalThis.document
-
-beforeAll(() => {
-  // @ts-expect-error test DOM setup
-  globalThis.window = domWindow
-  // @ts-expect-error test DOM setup
-  globalThis.document = domWindow.document
-})
-
-afterAll(() => {
-  globalThis.window = originalWindow
-  globalThis.document = originalDocument
-})
-
-describe('useAttachController', () => {
-  it('prompts for session name and attaches workspace after submit', async () => {
-    const close = mock(() => {})
-    const showInputCalls: Array<{
-      onSubmit: (value: string) => Promise<void> | void
-    }> = []
-
-    const attachSessionWithBundleRefresh = mock(async () => true)
-
-    const { result } = renderHook(() =>
-      useAttachController({
-        flow: {
-          showInput: (opts) => {
-            showInputCalls.push({ onSubmit: opts.onSubmit })
-          },
-          showMessage: () => {},
-          close,
-        },
-        attachSessionWithBundleRefresh,
-      })
-    )
-
-    await result.current.attachFromSelection({ workspaceId: 'my-project:my-workspace' })
-    expect(showInputCalls.length).toBe(1)
-
-    await showInputCalls[0]?.onSubmit('custom-name')
-
-    expect(close).toHaveBeenCalledTimes(1)
-    expect(attachSessionWithBundleRefresh).toHaveBeenCalledTimes(1)
-    expect(attachSessionWithBundleRefresh).toHaveBeenCalledWith(
-      {
-        workspaceId: 'my-project:my-workspace',
-        sessionName: 'custom-name',
-      },
-      {
-        projectName: 'my-project',
-      }
-    )
-  })
-
-  it('uses preflight gate for existing session attaches', async () => {
-    const attachSessionWithBundleRefresh = mock(async () => true)
-    const preflightSessionAttach = mock(async () => false)
-
-    const { result } = renderHook(() =>
-      useAttachController({
-        flow: {
-          showInput: () => {},
-          showMessage: () => {},
-          close: () => {},
-        },
-        attachSessionWithBundleRefresh,
-        preflightSessionAttach,
-      })
-    )
-
-    await result.current.attachFromSelection({ sessionId: 'session-1' })
-
-    expect(preflightSessionAttach).toHaveBeenCalledTimes(1)
-    expect(attachSessionWithBundleRefresh).toHaveBeenCalledTimes(0)
-  })
-
-  it('waits for async preflight approval before attaching existing session', async () => {
-    const attachSessionWithBundleRefresh = mock(async () => true)
-    const resolver: { current: ((value: boolean) => void) | null } = { current: null }
-    const preflightSessionAttach = mock(() =>
-      new Promise<boolean>((resolve) => {
-        resolver.current = resolve
-      })
-    )
-
-    const { result } = renderHook(() =>
-      useAttachController({
-        flow: {
-          showInput: () => {},
-          showMessage: () => {},
-          close: () => {},
-        },
-        attachSessionWithBundleRefresh,
-        preflightSessionAttach,
-      })
-    )
-
-    const attachPromise = result.current.attachFromSelection({ sessionId: 'session-2' })
-    await Promise.resolve()
-    expect(attachSessionWithBundleRefresh).toHaveBeenCalledTimes(0)
-
-    if (!resolver.current) {
-      throw new Error('Expected preflight resolver to be set')
-    }
-    resolver.current(true)
-    await attachPromise
-
-    expect(preflightSessionAttach).toHaveBeenCalledTimes(1)
-    expect(attachSessionWithBundleRefresh).toHaveBeenCalledTimes(1)
-    expect(attachSessionWithBundleRefresh).toHaveBeenCalledWith(
-      {
-        sessionId: 'session-2',
-      },
-      {
-        projectName: null,
-      }
-    )
-  })
-
-  it('passes through viewOnly on existing session attaches', async () => {
-    const attachSessionWithBundleRefresh = mock(async () => true)
-
-    const { result } = renderHook(() =>
-      useAttachController({
-        flow: {
-          showInput: () => {},
-          showMessage: () => {},
-          close: () => {},
-        },
-        attachSessionWithBundleRefresh,
-      })
-    )
-
-    await result.current.attachFromSelection({ sessionId: 'session-view', viewOnly: true })
-
-    expect(attachSessionWithBundleRefresh).toHaveBeenCalledWith(
-      {
-        sessionId: 'session-view',
-        viewOnly: true,
-      },
-      {
-        projectName: null,
-      }
-    )
-  })
-
-  it('runs lifecycle callbacks for cancelled and failed attach attempts', async () => {
-    const onAttachCancelled = mock(() => {})
-    const onAttachError = mock(() => {})
-    const attachSessionWithBundleRefresh = mock(async (params: { sessionId?: string }) => {
-      if (params.sessionId === 'cancelled') {
-        return false
-      }
-
-      throw new Error('boom')
-    })
-
-    const { result } = renderHook(() =>
-      useAttachController({
-        flow: {
-          showInput: () => {},
-          showMessage: () => {},
-          close: () => {},
-        },
-        attachSessionWithBundleRefresh,
-        onAttachCancelled,
-        onAttachError,
-      })
-    )
-
-    const cancelled = await result.current.attach({ sessionId: 'cancelled' })
-    const failed = await result.current.attach({ sessionId: 'failed' })
-
-    expect(cancelled).toBe(false)
-    expect(failed).toBe(false)
-    expect(onAttachCancelled).toHaveBeenCalledTimes(1)
-    expect(onAttachError).toHaveBeenCalledTimes(1)
-  })
-
-  it('injects terminal size into attach params when available', async () => {
-    const attachSessionWithBundleRefresh = mock(async () => true)
-
-    const { result } = renderHook(() =>
-      useAttachController({
-        flow: {
-          showInput: () => {},
-          showMessage: () => {},
-          close: () => {},
-        },
-        attachSessionWithBundleRefresh,
-        getAttachSize: () => ({ cols: 132, rows: 41 }),
-      })
-    )
-
-    await result.current.attach({ sessionId: 'session-3' })
-    await result.current.attach({ sessionId: 'session-4', cols: 90, rows: 22 })
-
-    expect(attachSessionWithBundleRefresh).toHaveBeenNthCalledWith(
-      1,
-      {
-        sessionId: 'session-3',
-        cols: 132,
-        rows: 41,
-      },
-      {
-        projectName: null,
-      }
-    )
-
-    expect(attachSessionWithBundleRefresh).toHaveBeenNthCalledWith(
-      2,
-      {
-        sessionId: 'session-4',
-        cols: 90,
-        rows: 22,
-      },
-      {
-        projectName: null,
-      }
-    )
-  })
-})