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

package/src/hooks/useDaemonStatus.tui.ts

@@ -1,174 +0,0 @@
-/**
- * Hook for monitoring daemon status (tmux-lite and serve)
- *
- * Provides real-time status of:
- * - tmux-lite server (sessions count, version)
- * - serve daemon (relay connection, clients count)
- */
-
-import { useState, useEffect, useCallback } from 'react';
-import { getStatus as getTmuxStatus, isServerRunning as isTmuxRunning } from '../lib/tmux-lite/cli.js';
-import { queryServeStatus, isServeRunning, type StatusResponse } from '../serve/daemon.js';
-
-/** Package version for comparison */
-const PACKAGE_VERSION = '1.0.0';
-
-/** Tmux daemon status */
-export interface TmuxStatus {
-  running: boolean;
-  version?: string;
-  sessions?: number;
-  attached?: number;
-  uptime?: number;
-}
-
-/** Serve daemon status */
-export interface ServeStatus {
-  running: boolean;
-  version?: string;
-  relayUrl?: string;
-  relayStatus?: 'connecting' | 'connected' | 'disconnected' | 'reconnecting';
-  clients?: number;
-  uptime?: number;
-  hosting?: {
-    subdomain: string;
-    tunnelActive: boolean;
-  };
-}
-
-/** Combined daemon status */
-export interface DaemonStatus {
-  tmux: TmuxStatus;
-  serve: ServeStatus;
-  versionMismatch: boolean;
-  packageVersion: string;
-}
-
-/** Hook options */
-export interface UseDaemonStatusOptions {
-  /** Polling interval in ms (default: 5000) */
-  pollInterval?: number;
-  /** Whether to poll automatically (default: true) */
-  autoPoll?: boolean;
-}
-
-/** Hook return type */
-export interface UseDaemonStatusReturn {
-  status: DaemonStatus;
-  refresh: () => Promise<void>;
-  isLoading: boolean;
-}
-
-/**
- * Hook for monitoring daemon status
- */
-export function useDaemonStatus(options: UseDaemonStatusOptions = {}): UseDaemonStatusReturn {
-  const { pollInterval = 5000, autoPoll = true } = options;
-
-  const [status, setStatus] = useState<DaemonStatus>({
-    tmux: { running: false },
-    serve: { running: false },
-    versionMismatch: false,
-    packageVersion: PACKAGE_VERSION,
-  });
-  const [isLoading, setIsLoading] = useState(true);
-
-  const refresh = useCallback(async () => {
-    try {
-      // Query tmux status
-      let tmuxStatus: TmuxStatus = { running: false };
-      if (await isTmuxRunning()) {
-        try {
-          const tmux = await getTmuxStatus();
-          tmuxStatus = {
-            running: true,
-            version: tmux.version,
-            sessions: tmux.sessions,
-            attached: tmux.attached,
-            uptime: tmux.uptime,
-          };
-        } catch {
-          tmuxStatus = { running: true }; // Running but couldn't get details
-        }
-      }
-
-      // Query serve status
-      let serveStatus: ServeStatus = { running: false };
-      if (isServeRunning()) {
-        try {
-          const serve = await queryServeStatus();
-          if (serve) {
-            serveStatus = {
-              running: true,
-              version: serve.version,
-              relayUrl: serve.relay.url,
-              relayStatus: serve.relay.status,
-              clients: serve.clients,
-              uptime: serve.uptime,
-              hosting: serve.hosting,
-            };
-          } else {
-            serveStatus = { running: true }; // Running but couldn't get details
-          }
-        } catch {
-          serveStatus = { running: true }; // Running but couldn't get details
-        }
-      }
-
-      // Check version mismatch
-      const versionMismatch =
-        (tmuxStatus.version && tmuxStatus.version !== PACKAGE_VERSION) ||
-        (serveStatus.version && serveStatus.version !== PACKAGE_VERSION);
-
-      setStatus({
-        tmux: tmuxStatus,
-        serve: serveStatus,
-        versionMismatch: !!versionMismatch,
-        packageVersion: PACKAGE_VERSION,
-      });
-    } finally {
-      setIsLoading(false);
-    }
-  }, []);
-
-  // Initial load
-  useEffect(() => {
-    refresh();
-  }, [refresh]);
-
-  // Polling
-  useEffect(() => {
-    if (!autoPoll) return;
-
-    const interval = setInterval(refresh, pollInterval);
-    return () => clearInterval(interval);
-  }, [autoPoll, pollInterval, refresh]);
-
-  return { status, refresh, isLoading };
-}
-
-/**
- * Format uptime in human-readable format
- */
-export function formatUptime(seconds: number): string {
-  if (seconds < 60) return `${seconds}s`;
-  if (seconds < 3600) return `${Math.floor(seconds / 60)}m`;
-  const hours = Math.floor(seconds / 3600);
-  const mins = Math.floor((seconds % 3600) / 60);
-  if (hours < 24) return `${hours}h ${mins}m`;
-  const days = Math.floor(hours / 24);
-  return `${days}d ${hours % 24}h`;
-}
-
-/**
- * Format relay status for display
- */
-export function formatRelayStatus(status: ServeStatus['relayStatus']): string {
-  switch (status) {
-    case 'connected': return '●';
-    case 'connecting': return '◐';
-    case 'reconnecting': return '◐';
-    case 'disconnected': return '○';
-    default: return '?';
-  }
-}

package/src/hooks/useLocalSession.tui.ts

@@ -1,395 +0,0 @@
-import { useCallback, useEffect, useMemo, useRef } from 'react';
-import {
-  useSessionEngine,
-  type AttachSessionParams,
-  type DeleteWorkspaceParams,
-  type BundleRefreshPlan,
-  type BundleRefreshSubmission,
-  type BackendKey,
-  type SessionBackend,
-} from '../session/index.js';
-import type { NotificationConfig } from '../notifications/types.js';
-import type { WideEventFilter } from '../types/events.js';
-import { createBunLocalSessionBackend } from '../app/session/createSessionBackend.bun.js';
-import { logger } from '../utils/logger.js';
-import { SpacesError } from '../types/errors.js';
-
-const LOCAL_BACKEND_KEY: BackendKey = 'local';
-
-type SessionEngineApi = ReturnType<typeof useSessionEngine>;
-
-type LocalSessionPtyBackend = SessionBackend & {
-  setPtyOutputHandler(handler: ((data: Uint8Array) => void) | null): void;
-};
-
-function createBackendNotFoundError(backendKey: BackendKey): SpacesError {
-  return new SpacesError(`Backend not found: ${backendKey}`, 'SYSTEM_ERROR', 2);
-}
-
-function isBackendNotFoundError(error: unknown, backendKey: BackendKey): boolean {
-  if (!(error instanceof SpacesError)) {
-    return false;
-  }
-
-  if (error.code !== 'SYSTEM_ERROR') {
-    return false;
-  }
-
-  return error.message === `Backend not found: ${backendKey}`;
-}
-
-export interface UseLocalSessionOptions {
-  enabled?: boolean;
-  engine?: SessionEngineApi;
-  backendKey?: BackendKey;
-  createBackend?: () => LocalSessionPtyBackend;
-}
-
-export function useLocalSession(options: UseLocalSessionOptions = {}) {
-  const {
-    enabled = true,
-    engine: injectedEngine,
-    backendKey = LOCAL_BACKEND_KEY,
-    createBackend: createBackendOverride,
-  } = options;
-  const sessionEngine = useSessionEngine();
-  const engine = injectedEngine ?? sessionEngine;
-  const engineRef = useRef(engine);
-  const backendRef = useRef<LocalSessionPtyBackend | null>(null);
-  const writeCallbackRef = useRef<((data: Uint8Array) => void) | null>(null);
-
-  useEffect(() => {
-    engineRef.current = engine;
-  }, [engine]);
-
-  const recoverBackend = useCallback(async (sessionEngine: SessionEngineApi): Promise<boolean> => {
-    const backend = backendRef.current;
-    if (!backend) {
-      return false;
-    }
-
-    try {
-      sessionEngine.registerBackend(backend);
-      sessionEngine.setActiveBackend(backendKey);
-      await sessionEngine.connectBackend(backendKey);
-      return true;
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      logger.error(`[tui] Failed to recover local backend: ${message}`);
-      return false;
-    }
-  }, [backendKey]);
-
-  const runWithBackend = useCallback(async (
-    run: (sessionEngine: SessionEngineApi) => Promise<void>,
-    options: { strict?: boolean } = {}
-  ) => {
-    const { strict = false } = options;
-
-    if (!enabled) {
-      return;
-    }
-
-    const sessionEngine = engineRef.current;
-    if (!backendRef.current) {
-      if (strict) {
-        throw createBackendNotFoundError(backendKey);
-      }
-      return;
-    }
-
-    const runOnce = async () => {
-      sessionEngine.setActiveBackend(backendKey);
-      await run(sessionEngine);
-    };
-
-    try {
-      await runOnce();
-      return;
-    } catch (error) {
-      if (!isBackendNotFoundError(error, backendKey)) {
-        throw error;
-      }
-    }
-
-    const recovered = await recoverBackend(sessionEngine);
-    if (!recovered) {
-      const missingError = createBackendNotFoundError(backendKey);
-      if (strict) {
-        throw missingError;
-      }
-      logger.error(`[tui] ${missingError.message}`);
-      return;
-    }
-
-    try {
-      await runOnce();
-    } catch (error) {
-      if (strict || !isBackendNotFoundError(error, backendKey)) {
-        throw error;
-      }
-      const message = error instanceof Error ? error.message : String(error);
-      logger.error(`[tui] Failed local backend operation after recovery: ${message}`);
-    }
-  }, [backendKey, enabled, recoverBackend]);
-
-  const createBackend = useCallback((): LocalSessionPtyBackend => {
-    if (createBackendOverride) {
-      return createBackendOverride();
-    }
-
-    return createBunLocalSessionBackend(backendKey);
-  }, [backendKey, createBackendOverride]);
-
-  const localState = useMemo(() => {
-    return engine.getBackendState(backendKey);
-  }, [backendKey, engine, engine.state]);
-
-  useEffect(() => {
-    if (!enabled) {
-      return;
-    }
-
-    if (backendRef.current) {
-      return;
-    }
-
-    const backend = createBackend();
-    backend.setPtyOutputHandler(writeCallbackRef.current);
-
-    backendRef.current = backend;
-    const sessionEngine = engineRef.current;
-    sessionEngine.registerBackend(backend);
-    sessionEngine.setActiveBackend(backendKey);
-    void (async () => {
-      try {
-        await sessionEngine.connectBackend(backendKey);
-        await sessionEngine.listProjects(backendKey);
-        await sessionEngine.listWorkspaces(backendKey);
-        await sessionEngine.requestInbox(backendKey);
-        await sessionEngine.getNotificationConfig(backendKey);
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        logger.error(`[tui] Local session backend init failed: ${message}`);
-      }
-    })();
-
-    return () => {
-      backend.setPtyOutputHandler(null);
-      const currentEngine = engineRef.current;
-      void currentEngine.disconnectBackend(backendKey);
-      void currentEngine.unregisterBackend(backendKey);
-      backendRef.current = null;
-    };
-  }, [backendKey, createBackend, enabled]);
-
-  const requestProjects = useCallback(async () => {
-    await runWithBackend(async (sessionEngine) => {
-      await sessionEngine.listProjects(backendKey);
-    });
-  }, [backendKey, runWithBackend]);
-
-  const requestWorkspaces = useCallback(async () => {
-    await runWithBackend(async (sessionEngine) => {
-      await sessionEngine.listWorkspaces(backendKey);
-    });
-  }, [backendKey, runWithBackend]);
-
-  const requestSessions = useCallback(async (workspaceId?: string) => {
-    await runWithBackend(async (sessionEngine) => {
-      await sessionEngine.listSessions(backendKey, workspaceId);
-    });
-  }, [backendKey, runWithBackend]);
-
-  const requestInbox = useCallback(async () => {
-    await runWithBackend(async (sessionEngine) => {
-      await sessionEngine.requestInbox(backendKey);
-    });
-  }, [backendKey, runWithBackend]);
-
-  const clearInbox = useCallback(async (id?: string) => {
-    await runWithBackend(async (sessionEngine) => {
-      await sessionEngine.clearInbox(backendKey, id);
-    });
-  }, [backendKey, runWithBackend]);
-
-  const markInboxRead = useCallback(async (id: string) => {
-    await runWithBackend(async (sessionEngine) => {
-      await sessionEngine.markInboxRead(backendKey, id);
-    });
-  }, [backendKey, runWithBackend]);
-
-  const getNotificationConfig = useCallback(() => {
-    void runWithBackend(async (sessionEngine) => {
-      await sessionEngine.getNotificationConfig(backendKey);
-    });
-  }, [backendKey, runWithBackend]);
-
-  const updateNotificationConfig = useCallback((config: NotificationConfig) => {
-    void runWithBackend(async (sessionEngine) => {
-      await sessionEngine.updateNotificationConfig(backendKey, config);
-    });
-  }, [backendKey, runWithBackend]);
-
-  const attachSession = useCallback(async (params: AttachSessionParams) => {
-    await runWithBackend(async (sessionEngine) => {
-      await sessionEngine.attachSession(backendKey, params);
-      await sessionEngine.listSessions(backendKey);
-      await sessionEngine.listWorkspaces(backendKey);
-    }, { strict: true });
-  }, [backendKey, runWithBackend]);
-
-  const detachSession = useCallback(async () => {
-    await runWithBackend(async (sessionEngine) => {
-      await sessionEngine.detachSession(backendKey);
-      await sessionEngine.listSessions(backendKey);
-      await sessionEngine.listWorkspaces(backendKey);
-    }, { strict: true });
-  }, [backendKey, runWithBackend]);
-
-  const killSession = useCallback(async (sessionId: string) => {
-    await runWithBackend(async (sessionEngine) => {
-      await sessionEngine.killSession(backendKey, sessionId);
-      await sessionEngine.listSessions(backendKey);
-      await sessionEngine.listWorkspaces(backendKey);
-    }, { strict: true });
-  }, [backendKey, runWithBackend]);
-
-  const deleteWorkspace = useCallback(async (
-    projectName: string,
-    workspaceId: string,
-    params?: DeleteWorkspaceParams
-  ) => {
-    await runWithBackend(async (sessionEngine) => {
-      await sessionEngine.deleteWorkspace(backendKey, projectName, workspaceId, params);
-      await sessionEngine.listWorkspaces(backendKey);
-      await sessionEngine.listSessions(backendKey);
-    }, { strict: true });
-  }, [backendKey, runWithBackend]);
-
-  const getBundleRefreshPlan = useCallback(async (
-    projectName: string,
-    workspaceId: string
-  ): Promise<BundleRefreshPlan> => {
-    let plan: BundleRefreshPlan | null = null;
-    await runWithBackend(async (sessionEngine) => {
-      plan = await sessionEngine.getBundleRefreshPlan(backendKey, projectName, workspaceId);
-    }, { strict: true });
-
-    if (!plan) {
-      throw new SpacesError('Bundle refresh plan unavailable', 'SYSTEM_ERROR', 2);
-    }
-
-    return plan;
-  }, [backendKey, runWithBackend]);
-
-  const applyBundleRefresh = useCallback(async (
-    projectName: string,
-    workspaceId: string,
-    submission: BundleRefreshSubmission
-  ) => {
-    await runWithBackend(async (sessionEngine) => {
-      await sessionEngine.applyBundleRefresh(backendKey, projectName, workspaceId, submission);
-      await sessionEngine.listWorkspaces(backendKey);
-      await sessionEngine.listSessions(backendKey, workspaceId);
-    }, { strict: true });
-  }, [backendKey, runWithBackend]);
-
-  const send = useCallback((data: Uint8Array) => {
-    const backend = backendRef.current;
-    if (!enabled || !backend?.writePtyData) {
-      return;
-    }
-    void backend.writePtyData(data).catch((error) => {
-      const message = error instanceof Error ? error.message : String(error);
-      if (message.includes('No attached local session')) {
-        return;
-      }
-      logger.error(`[tui] Failed to write PTY data: ${message}`);
-    });
-  }, [enabled]);
-
-  const resize = useCallback((cols: number, rows: number) => {
-    const backend = backendRef.current;
-    if (!enabled || !backend?.resizePty) {
-      return;
-    }
-    void backend.resizePty(cols, rows).catch((error) => {
-      const message = error instanceof Error ? error.message : String(error);
-      if (message.includes('No attached local session')) {
-        return;
-      }
-      logger.error(`[tui] Failed to resize PTY: ${message}`);
-    });
-  }, [enabled]);
-
-  const startProcess = useCallback(async (workspaceId: string, processName: string, instance?: number) => {
-    await runWithBackend(async (sessionEngine) => {
-      await sessionEngine.startProcess(backendKey, workspaceId, processName, instance);
-      await sessionEngine.listWorkspaces(backendKey);
-      await sessionEngine.listSessions(backendKey);
-    });
-  }, [backendKey, runWithBackend]);
-
-  const stopProcess = useCallback(async (workspaceId: string, processName: string) => {
-    await runWithBackend(async (sessionEngine) => {
-      await sessionEngine.stopProcess(backendKey, workspaceId, processName);
-      await sessionEngine.listWorkspaces(backendKey);
-      await sessionEngine.listSessions(backendKey);
-    });
-  }, [backendKey, runWithBackend]);
-
-  const requestEvents = useCallback(async (
-    workspacePath: string,
-    filter?: WideEventFilter,
-    limit?: number,
-    sinceMs?: number,
-  ) => {
-    await runWithBackend(async (sessionEngine) => {
-      await sessionEngine.requestEvents(backendKey, workspacePath, filter, limit, sinceMs);
-    });
-  }, [backendKey, runWithBackend]);
-
-  const setWriteCallback = useCallback((fn: ((data: Uint8Array) => void) | null) => {
-    writeCallbackRef.current = fn;
-    backendRef.current?.setPtyOutputHandler(fn);
-  }, []);
-
-  return {
-    status: enabled ? (localState?.status ?? 'disconnected') : 'disconnected',
-    mode: localState?.mode ?? 'browsing',
-    projects: localState?.projects ?? [],
-    workspaces: localState?.workspaces ?? [],
-    sessions: localState?.sessions ?? [],
-    inbox: localState?.inbox ?? [],
-    inboxUnreadCount: localState?.inboxUnreadCount ?? 0,
-    notificationConfig: localState?.notificationConfig ?? null,
-    attachedSessionId: localState?.attachedSessionId ?? null,
-    attachedSessionName: localState?.attachedSessionName ?? null,
-    scriptState: localState?.scriptState ?? null,
-    commandError: localState?.commandError ?? null,
-    events: localState?.events ?? [],
-    liveEventIds: localState?.liveEventIds ?? [],
-    savedEventFilters: localState?.savedEventFilters ?? [],
-    requestProjects,
-    requestWorkspaces,
-    requestSessions,
-    requestInbox,
-    clearInbox,
-    markInboxRead,
-    getNotificationConfig,
-    updateNotificationConfig,
-    attachSession,
-    detachSession,
-    killSession,
-    deleteWorkspace,
-    getBundleRefreshPlan,
-    applyBundleRefresh,
-    startProcess,
-    stopProcess,
-    requestEvents,
-    send,
-    resize,
-    setWriteCallback,
-  };
-}

package/src/hooks/useRelayConnection.web.ts

@@ -1,54 +0,0 @@
-/**
- * Hook for relay connection before terminal session.
- */
-
-import { useCallback } from 'react';
-import { getOrCreateIdentity } from '../lib/storage/identity-store.web';
-import { exportPublicKey } from '../session/crypto/identity.web';
-import { signRelayMessage } from '../session/crypto/relay-signing.web';
-import type { Identity } from '../types/identity';
-import {
-  useMachineDirectory,
-} from '../relay-client/useMachineDirectory.js';
-import { browserRelaySocketAdapter } from '../relay-client/adapters/browser.js';
-
-export function useRelayConnection() {
-  const machineDirectory = useMachineDirectory<
-    WebSocket,
-    Identity,
-    { publicKey: string }
-  >({
-    socketAdapter: browserRelaySocketAdapter,
-    resolveClientConfig: async () => {
-      const identity = await getOrCreateIdentity();
-      const publicKey = exportPublicKey(identity);
-
-      const wsProtocol = location.protocol === 'https:' ? 'wss:' : 'ws:';
-      const relayUrl = `${wsProtocol}//${location.host}/ws`;
-
-      return {
-        relayUrl,
-        clientIdentityId: identity.id,
-        identity,
-        context: { publicKey },
-        signer: (message) => signRelayMessage(message, identity),
-      };
-    },
-  });
-
-  const connect = useCallback(async () => {
-    await machineDirectory.connect();
-  }, [machineDirectory]);
-
-  return {
-    status: machineDirectory.status,
-    machines: machineDirectory.machines,
-    error: machineDirectory.error,
-    identity: machineDirectory.identity,
-    publicKey: machineDirectory.context?.publicKey ?? null,
-    connect,
-    disconnect: machineDirectory.disconnect,
-    refreshMachines: machineDirectory.refreshMachines,
-    getWebSocket: machineDirectory.getSocket,
-  };
-}