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

package/src/hooks/useRemoteMachines.tui.ts

@@ -1,166 +0,0 @@
-/**
- * TUI Hook for remote machine directory connections.
- */
-
-import { useCallback, useMemo } from 'react';
-import type { Identity } from '../types/identity.js';
-import { keypairExists, loadKeypair } from '../core/identity.js';
-import { signMessage } from '../relay/signing.js';
-import type { MachineInfo } from '../components/index.js';
-import {
-  useMachineDirectory,
-  type RelayStatus,
-  nodeRelaySocketAdapter,
-  type NodeRelaySocket,
-} from '../relay-client/index.js';
-
-export interface RelayConfig {
-  url: string;
-}
-
-export interface UseRemoteMachinesOptions {
-  relayConfig?: RelayConfig;
-  onError?: (error: Error) => void;
-  /** Optional preloaded identity (avoids password/env lookup). */
-  identity?: Identity;
-  /** Optional password for loading local identity from disk. */
-  identityPassword?: string;
-}
-
-export type ConnectionStatus = RelayStatus;
-
-export interface UseRemoteMachinesReturn {
-  // Connection state
-  status: ConnectionStatus;
-  error: string | null;
-  identity: Identity | null;
-
-  // Machine list
-  machines: MachineInfo[];
-
-  // Actions
-  connect: () => Promise<void>;
-  disconnect: () => void;
-  refreshMachines: () => Promise<void>;
-
-  // Mode
-  isRemoteMode: boolean;
-  isLocal: (machine: MachineInfo) => boolean;
-}
-
-async function resolveIdentity(options: UseRemoteMachinesOptions): Promise<Identity | null> {
-  if (options.identity) {
-    return options.identity;
-  }
-
-  if (!keypairExists()) {
-    return null;
-  }
-
-  const password = options.identityPassword || process.env.GITSPACE_IDENTITY_PASSWORD;
-  if (!password) {
-    return null;
-  }
-
-  try {
-    return await loadKeypair(password);
-  } catch {
-    return null;
-  }
-}
-
-export function useRemoteMachines(options: UseRemoteMachinesOptions = {}): UseRemoteMachinesReturn {
-  const { relayConfig, onError } = options;
-  const isRemoteMode = !!relayConfig;
-
-  const localMachine = useMemo<MachineInfo>(
-    () => ({
-      machineId: 'local',
-      label: 'This Machine',
-      online: true,
-      isAuthorized: true,
-    }),
-    []
-  );
-
-  const isLocal = useCallback((machine: MachineInfo) => {
-    return machine.machineId === 'local';
-  }, []);
-
-  const directory = useMachineDirectory<NodeRelaySocket, Identity>({
-    enabled: isRemoteMode,
-    autoConnect: isRemoteMode,
-    socketAdapter: nodeRelaySocketAdapter,
-    mapMachines: (remoteMachines) => [localMachine, ...remoteMachines],
-    resolveClientConfig: async () => {
-      if (!relayConfig) {
-        throw new Error('Relay config is required for remote mode');
-      }
-
-      const identity = await resolveIdentity(options);
-      if (!identity) {
-        throw new Error(
-          'Remote relay requires an unlocked identity. Set GITSPACE_IDENTITY_PASSWORD or pass identity to useRemoteMachines.'
-        );
-      }
-
-      return {
-        relayUrl: relayConfig.url,
-        clientIdentityId: identity.id,
-        identity,
-        signer: <T extends object>(message: T): T => {
-          const privateKey = identity.signing.secretKey.slice(0, 32);
-          return signMessage(message, privateKey, identity.signing.publicKey);
-        },
-      };
-    },
-    onError,
-  });
-
-  const connect = useCallback(async () => {
-    if (!isRemoteMode) {
-      return;
-    }
-    await directory.connect();
-  }, [directory, isRemoteMode]);
-
-  const disconnect = useCallback(() => {
-    if (!isRemoteMode) {
-      return;
-    }
-    directory.disconnect();
-  }, [directory, isRemoteMode]);
-
-  const refreshMachines = useCallback(async () => {
-    if (!isRemoteMode) {
-      return;
-    }
-    await directory.refreshMachines();
-  }, [directory, isRemoteMode]);
-
-  if (!isRemoteMode) {
-    return {
-      status: 'connected',
-      error: null,
-      identity: null,
-      machines: [localMachine],
-      connect,
-      disconnect,
-      refreshMachines,
-      isRemoteMode,
-      isLocal,
-    };
-  }
-
-  return {
-    status: directory.status,
-    error: directory.error,
-    identity: directory.identity,
-    machines: directory.machines.length > 0 ? directory.machines : [localMachine],
-    connect,
-    disconnect,
-    refreshMachines,
-    isRemoteMode,
-    isLocal,
-  };
-}

package/src/hooks/useRemoteTerminal.tui.ts

@@ -1,22 +0,0 @@
-import { useSessionClient } from '../app/session/useSessionClient.js'
-import {
-  createBunRemoteSessionBackend,
-  type BunRemoteSessionConnectParams,
-} from '../app/session/createSessionBackend.bun.js'
-import type {
-  SessionClientConnectionStatus,
-  SessionClientMode,
-  SessionClientScriptState,
-} from '../app/session/types.js'
-
-export type ConnectionStatus = SessionClientConnectionStatus
-export type SessionMode = SessionClientMode
-export type ScriptState = SessionClientScriptState
-
-export type ConnectionParams = BunRemoteSessionConnectParams
-
-export function useRemoteTerminal() {
-  return useSessionClient<ConnectionParams>({
-    createBackend: createBunRemoteSessionBackend,
-  })
-}

package/src/hooks/useReview.web.ts

@@ -1,248 +0,0 @@
-/** @jsxImportSource react */
-/**
- * useReview — React hook for the review system.
- *
- * Calls terminal.sendReviewRequest() over the existing encrypted WebSocket
- * channel and manages local state for threads, diff, and loading.
- */
-
-import { useState, useCallback } from 'react';
-import type { ReviewThread, ThreadTarget, HunkDecision, ReviewOperation } from '../types/review.js';
-
-export interface UseReviewOptions {
-  sendReviewRequest: (operation: ReviewOperation) => Promise<import('../types/review.js').ReviewResult>;
-  projectName: string;
-  workspaceName: string;
-}
-
-export interface UseReviewReturn {
-  /** All review threads for this workspace */
-  threads: ReviewThread[];
-  /** The raw unified diff text */
-  diff: string | null;
-  /** Base branch (e.g. "main") */
-  baseBranch: string | null;
-  /** Current branch */
-  headBranch: string | null;
-  /** True while any operation is in flight */
-  loading: boolean;
-  /** Last error message, if any */
-  error: string | null;
-
-  /** Load threads from the machine */
-  loadThreads: () => Promise<void>;
-  /** Load the current diff from the machine */
-  loadDiff: () => Promise<void>;
-
-  /** Create a new thread */
-  createThread: (target: ThreadTarget, body: string, decision?: HunkDecision) => Promise<void>;
-  /** Add a reply to an existing thread */
-  addReply: (threadId: string, body: string) => Promise<void>;
-  /** Update thread properties (resolve/unresolve, change hunk decision) */
-  updateThread: (threadId: string, updates: { resolved?: boolean; decision?: HunkDecision }) => Promise<void>;
-  /** Update the body of a specific comment */
-  updateComment: (threadId: string, commentId: string, body: string) => Promise<void>;
-  /** Delete a comment */
-  deleteComment: (threadId: string, commentId: string) => Promise<void>;
-  /** Import GitHub PR review comments */
-  importGitHub: (prNumber?: number) => Promise<{ imported: number }>;
-  /** Push local review to GitHub as a formal PR review */
-  pushGitHub: (prNumber?: number) => Promise<{ prNumber: number; url: string }>;
-}
-
-export function useReview({ sendReviewRequest, projectName, workspaceName }: UseReviewOptions): UseReviewReturn {
-  const [threads, setThreads] = useState<ReviewThread[]>([]);
-  const [diff, setDiff] = useState<string | null>(null);
-  const [baseBranch, setBaseBranch] = useState<string | null>(null);
-  const [headBranch, setHeadBranch] = useState<string | null>(null);
-  const [inFlightCount, setInFlightCount] = useState(0);
-  const [error, setError] = useState<string | null>(null);
-
-  const loading = inFlightCount > 0;
-
-  const run = useCallback(async <T>(fn: () => Promise<T>): Promise<T> => {
-    setInFlightCount((count) => count + 1);
-    setError(null);
-    try {
-      return await fn();
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      setError(message);
-      throw err;
-    } finally {
-      setInFlightCount((count) => (count > 0 ? count - 1 : 0));
-    }
-  }, []);
-
-  const loadThreads = useCallback(async () => {
-    await run(async () => {
-      const result = await sendReviewRequest({
-        op: 'get_threads',
-        projectName,
-        workspaceName,
-      });
-      if (result.op === 'threads') {
-        setThreads(result.threads);
-      }
-    });
-  }, [run, sendReviewRequest, projectName, workspaceName]);
-
-  const loadDiff = useCallback(async () => {
-    await run(async () => {
-      const result = await sendReviewRequest({
-        op: 'get_diff',
-        projectName,
-        workspaceName,
-      });
-      if (result.op === 'diff') {
-        setDiff(result.diff);
-        setBaseBranch(result.baseBranch);
-        setHeadBranch(result.headBranch);
-      }
-    });
-  }, [run, sendReviewRequest, projectName, workspaceName]);
-
-  const createThread = useCallback(async (
-    target: ThreadTarget,
-    body: string,
-    decision?: HunkDecision
-  ) => {
-    await run(async () => {
-      const result = await sendReviewRequest({
-        op: 'create_thread',
-        projectName,
-        workspaceName,
-        target,
-        body,
-        decision,
-      });
-      if (result.op === 'thread_created') {
-        setThreads((prev) => [...prev, result.thread]);
-      }
-    });
-  }, [run, sendReviewRequest, projectName, workspaceName]);
-
-  const addReply = useCallback(async (threadId: string, body: string) => {
-    await run(async () => {
-      const result = await sendReviewRequest({
-        op: 'add_reply',
-        projectName,
-        workspaceName,
-        threadId,
-        body,
-      });
-      if (result.op === 'comment_added') {
-        setThreads((prev) => prev.map((t) => t.id === threadId ? result.thread : t));
-      }
-    });
-  }, [run, sendReviewRequest, projectName, workspaceName]);
-
-  const updateThread = useCallback(async (
-    threadId: string,
-    updates: { resolved?: boolean; decision?: HunkDecision }
-  ) => {
-    await run(async () => {
-      const result = await sendReviewRequest({
-        op: 'update_thread',
-        projectName,
-        workspaceName,
-        threadId,
-        ...updates,
-      });
-      if (result.op === 'thread_updated') {
-        setThreads((prev) => prev.map((t) => t.id === threadId ? result.thread : t));
-      }
-    });
-  }, [run, sendReviewRequest, projectName, workspaceName]);
-
-  const updateComment = useCallback(async (
-    threadId: string,
-    commentId: string,
-    body: string
-  ) => {
-    await run(async () => {
-      const result = await sendReviewRequest({
-        op: 'update_comment',
-        projectName,
-        workspaceName,
-        threadId,
-        commentId,
-        body,
-      });
-      if (result.op === 'comment_updated') {
-        setThreads((prev) => prev.map((t) => t.id === threadId ? result.thread : t));
-      }
-    });
-  }, [run, sendReviewRequest, projectName, workspaceName]);
-
-  const deleteComment = useCallback(async (threadId: string, commentId: string) => {
-    await run(async () => {
-      const result = await sendReviewRequest({
-        op: 'delete_comment',
-        projectName,
-        workspaceName,
-        threadId,
-        commentId,
-      });
-      if (result.op === 'comment_deleted') {
-        // When the last comment is deleted, the server removes the whole thread
-        // and returns a stub with comments: []. Filter it out rather than keeping
-        // a zombie thread in state.
-        if (result.thread.comments.length === 0) {
-          setThreads((prev) => prev.filter((t) => t.id !== threadId));
-        } else {
-          setThreads((prev) => prev.map((t) => t.id === threadId ? result.thread : t));
-        }
-      }
-    });
-  }, [run, sendReviewRequest, projectName, workspaceName]);
-
-  const importGitHub = useCallback(async (prNumber?: number): Promise<{ imported: number }> => {
-    return run(async () => {
-      const result = await sendReviewRequest({
-        op: 'import_github',
-        projectName,
-        workspaceName,
-        prNumber,
-      });
-      if (result.op === 'github_imported') {
-        setThreads(result.threads);
-        return { imported: result.imported };
-      }
-      throw new Error(`Unexpected response from import_github: ${result.op}`);
-    });
-  }, [run, sendReviewRequest, projectName, workspaceName]);
-
-  const pushGitHub = useCallback(async (prNumber?: number): Promise<{ prNumber: number; url: string }> => {
-    return run(async () => {
-      const result = await sendReviewRequest({
-        op: 'push_github',
-        projectName,
-        workspaceName,
-        prNumber,
-      });
-      if (result.op === 'github_pushed') {
-        return { prNumber: result.prNumber, url: result.url };
-      }
-      throw new Error('Unexpected response from push_github');
-    });
-  }, [run, sendReviewRequest, projectName, workspaceName]);
-
-  return {
-    threads,
-    diff,
-    baseBranch,
-    headBranch,
-    loading,
-    error,
-    loadThreads,
-    loadDiff,
-    createThread,
-    addReply,
-    updateThread,
-    updateComment,
-    deleteComment,
-    importGitHub,
-    pushGitHub,
-  };
-}

package/src/hooks/useTerminal.web.ts

@@ -1,36 +0,0 @@
-/**
- * Web terminal hook backed by shared session client facade.
- */
-
-import type {
-  WorkspaceInfo,
-  SessionInfo,
-  ProjectInfo,
-} from '../lib/remote-session/protocol'
-import { useSessionClient } from '../app/session/useSessionClient.js'
-import {
-  createWebRemoteSessionBackend,
-  type WebRemoteSessionConnectParams,
-} from '../app/session/createSessionBackend.web.js'
-import type {
-  SessionClientConnectionStatus,
-  SessionClientMode,
-  SessionClientScriptState,
-  SessionClientCommandError,
-} from '../app/session/types.js'
-
-export type ConnectionStatus = SessionClientConnectionStatus
-export type SessionMode = SessionClientMode
-
-export type { WorkspaceInfo, SessionInfo, ProjectInfo }
-
-export type ScriptState = SessionClientScriptState
-export type CommandErrorState = SessionClientCommandError
-
-export type ConnectionParams = WebRemoteSessionConnectParams
-
-export function useTerminal() {
-  return useSessionClient<ConnectionParams>({
-    createBackend: createWebRemoteSessionBackend,
-  })
-}

package/src/hooks/useUserActivity.ts

@@ -1,61 +0,0 @@
-import { useCallback, useEffect, useMemo, useState } from 'react';
-
-export interface UseUserActivityOptions {
-  /**
-   * Whether the UI is currently in a mode where user activity should be tracked.
-   * If false, user is treated as active.
-   */
-  isActivityTracked: boolean;
-  /** Duration window for considering the user active. */
-  holdWhenIdleMs: number;
-  /** Interval for re-evaluating active/idle state. */
-  tickIntervalMs?: number;
-}
-
-export interface UseUserActivityResult {
-  /** Last activity timestamp in ms since epoch. */
-  lastActivityAt: number;
-  /** Whether user is currently active. */
-  isUserActive: boolean;
-  /** Mark activity (call on keypress/terminal input/etc). */
-  markActivity: () => void;
-}
-
-/**
- * Shared user-activity helper used by web and TUI notification logic.
- */
-export function useUserActivity(options: UseUserActivityOptions): UseUserActivityResult {
-  const {
-    isActivityTracked,
-    holdWhenIdleMs,
-    tickIntervalMs = 1000,
-  } = options;
-
-  const [lastActivityAt, setLastActivityAt] = useState(Date.now());
-  const [activityTick, setActivityTick] = useState(0);
-
-  const markActivity = useCallback(() => {
-    setLastActivityAt(Date.now());
-  }, []);
-
-  useEffect(() => {
-    const interval = setInterval(() => {
-      setActivityTick((t) => t + 1);
-    }, tickIntervalMs);
-
-    return () => clearInterval(interval);
-  }, [tickIntervalMs]);
-
-  const isUserActive = useMemo(() => {
-    if (!isActivityTracked) {
-      return true;
-    }
-    return Date.now() - lastActivityAt < holdWhenIdleMs;
-  }, [isActivityTracked, lastActivityAt, holdWhenIdleMs, activityTick]);
-
-  return {
-    lastActivityAt,
-    isUserActive,
-    markActivity,
-  };
-}

package/src/hooks/useVisualViewport.web.ts

@@ -1,104 +0,0 @@
-import { useEffect, useCallback, useState } from 'react';
-
-/** Threshold in pixels to consider the keyboard visible */
-const KEYBOARD_THRESHOLD = 100;
-
-/**
- * Hook to track the visual viewport and detect keyboard visibility.
- * Sets CSS custom properties for dynamic layout adjustment:
- * - --visual-viewport-height: actual visible height (shrinks when keyboard shows)
- * - --keyboard-inset: keyboard height for positioning elements above it
- *
- * On iOS Safari, visualViewport.height shrinks when the keyboard appears,
- * but window.innerHeight may stay the same. We use visualViewport directly
- * for accurate sizing.
- *
- * @returns Whether the keyboard is currently visible
- */
-export function useVisualViewport(): boolean {
-  const [keyboardVisible, setKeyboardVisible] = useState(false);
-
-  const updateViewport = useCallback(() => {
-    if (typeof window === 'undefined') return;
-
-    const viewport = window.visualViewport;
-    if (!viewport) {
-      // Fallback for browsers without Visual Viewport API
-      document.documentElement.style.setProperty('--visual-viewport-height', '100dvh');
-      document.documentElement.style.setProperty('--keyboard-inset', '0px');
-      setKeyboardVisible(false);
-      return;
-    }
-
-    // Use visualViewport.height directly - this is the actual visible area
-    // On iOS Safari this shrinks when the keyboard appears
-    const viewportHeight = viewport.height;
-
-    // Account for any offset (e.g., when page is scrolled with keyboard)
-    const offsetTop = viewport.offsetTop || 0;
-
-    // Calculate keyboard height from the difference between window and viewport
-    // On iOS Safari, window.innerHeight may not change, but visualViewport.height does
-    const keyboardHeight = Math.max(0, window.innerHeight - viewportHeight - offsetTop);
-
-    // Set CSS custom properties
-    document.documentElement.style.setProperty('--visual-viewport-height', `${viewportHeight}px`);
-    document.documentElement.style.setProperty('--keyboard-inset', `${keyboardHeight}px`);
-
-    // Update keyboard visibility state
-    setKeyboardVisible(keyboardHeight > KEYBOARD_THRESHOLD);
-  }, []);
-
-  useEffect(() => {
-    if (typeof window === 'undefined') return;
-
-    // Initial update (works even without visualViewport)
-    updateViewport();
-
-    const viewport = window.visualViewport;
-    if (!viewport) {
-      // No Visual Viewport API - just listen to window resize
-      window.addEventListener('resize', updateViewport);
-      return () => {
-        window.removeEventListener('resize', updateViewport);
-      };
-    }
-
-    // Listen for viewport changes (keyboard show/hide, resize, scroll)
-    viewport.addEventListener('resize', updateViewport);
-    viewport.addEventListener('scroll', updateViewport);
-
-    // Also listen to window resize as fallback
-    window.addEventListener('resize', updateViewport);
-
-    return () => {
-      viewport.removeEventListener('resize', updateViewport);
-      viewport.removeEventListener('scroll', updateViewport);
-      window.removeEventListener('resize', updateViewport);
-    };
-  }, [updateViewport]);
-
-  return keyboardVisible;
-}
-
-/**
- * Returns current keyboard height in pixels.
- * Useful for imperative checks.
- */
-export function getKeyboardHeight(): number {
-  if (typeof window === 'undefined') return 0;
-
-  const viewport = window.visualViewport;
-  if (!viewport) return 0;
-
-  const offsetTop = viewport.offsetTop || 0;
-  return Math.max(0, window.innerHeight - viewport.height - offsetTop);
-}
-
-/**
- * Returns whether the keyboard is currently visible.
- * Uses a threshold to avoid false positives from small viewport changes.
- */
-export function isKeyboardVisible(threshold = 100): boolean {
-  return getKeyboardHeight() > threshold;
-}