clawdex-mobile 5.0.1 → 5.0.2

package/services/mac-bridge/src/server.ts

@@ -1,426 +0,0 @@
-import cors from '@fastify/cors';
-import websocket from '@fastify/websocket';
-import { isAbsolute, resolve as resolvePath } from 'node:path';
-import Fastify, {
-  type FastifyInstance,
-  type FastifyReply,
-  type FastifyRequest
-} from 'fastify';
-import { z } from 'zod';
-
-import { CodexCliAdapter, ThreadBusyError } from './services/codexCliAdapter';
-import { GitService } from './services/gitService';
-import { RealtimeHub } from './services/realtimeHub';
-import {
-  TerminalCommandRejectedError,
-  TerminalService
-} from './services/terminalService';
-import type {
-  ApprovalDecision,
-  BridgeWsEvent,
-  CreateThreadInput,
-  SendThreadMessageInput
-} from './types';
-
-const createThreadSchema = z.object({
-  title: z.string().trim().min(1).max(120).optional(),
-  message: z.string().trim().min(1).max(20_000).optional()
-});
-
-const sendMessageSchema = z.object({
-  content: z.string().trim().min(1).max(20_000),
-  role: z.enum(['user', 'assistant', 'system']).optional()
-});
-
-const terminalExecSchema = z.object({
-  command: z.string().trim().min(1),
-  cwd: z.string().trim().min(1).optional(),
-  timeoutMs: z.number().int().min(100).max(120_000).optional()
-});
-
-const gitCommitSchema = z.object({
-  message: z.string().trim().min(1).max(500)
-});
-
-const approvalDecisionSchema = z.object({
-  decision: z.enum(['accept', 'acceptForSession', 'decline', 'cancel'])
-});
-
-interface IdParams {
-  id: string;
-}
-
-type CreateThreadRequest = FastifyRequest<{ Body: CreateThreadInput }>;
-type MessageRequest = FastifyRequest<{
-  Params: IdParams;
-  Body: SendThreadMessageInput;
-}>;
-type ThreadByIdRequest = FastifyRequest<{ Params: IdParams }>;
-type TerminalExecBody = z.infer<typeof terminalExecSchema>;
-type TerminalRequest = FastifyRequest<{ Body: TerminalExecBody }>;
-type GitCommitBody = z.infer<typeof gitCommitSchema>;
-type GitCommitRequest = FastifyRequest<{ Body: GitCommitBody }>;
-type ApprovalDecisionBody = z.infer<typeof approvalDecisionSchema>;
-type ApprovalDecisionRequest = FastifyRequest<{
-  Params: IdParams;
-  Body: ApprovalDecisionBody;
-}>;
-
-export async function buildServer(): Promise<FastifyInstance> {
-  const app = Fastify({
-    logger: true
-  });
-
-  const startupAt = Date.now();
-  const bridgeWorkdir = resolvePath(process.env.BRIDGE_WORKDIR ?? process.cwd());
-  const bridgeAuthToken = process.env.BRIDGE_AUTH_TOKEN?.trim() ?? '';
-  const allowInsecureNoAuth = parseBoolean(process.env.BRIDGE_ALLOW_INSECURE_NO_AUTH);
-  const allowQueryTokenAuth = parseBoolean(process.env.BRIDGE_ALLOW_QUERY_TOKEN_AUTH);
-  const terminalEnabled = !parseBoolean(process.env.BRIDGE_DISABLE_TERMINAL_EXEC);
-  const terminalAllowedCommands = parseCsvList(process.env.BRIDGE_TERMINAL_ALLOWED_COMMANDS, [
-    'pwd',
-    'ls',
-    'cat',
-    'git'
-  ]);
-  const corsOrigins = parseCsvList(process.env.BRIDGE_CORS_ORIGINS);
-
-  if (!bridgeAuthToken && !allowInsecureNoAuth) {
-    throw new Error(
-      'BRIDGE_AUTH_TOKEN is required. Set BRIDGE_ALLOW_INSECURE_NO_AUTH=true only for local development.'
-    );
-  }
-
-  const authEnabled = bridgeAuthToken.length > 0;
-  const realtime = new RealtimeHub();
-
-  const codex = new CodexCliAdapter({
-    workdir: bridgeWorkdir,
-    cliBin: process.env.CODEX_CLI_BIN ?? undefined,
-    cliTimeoutMs: parseTimeoutMs(process.env.CODEX_CLI_TIMEOUT_MS),
-    emitEvent: (event) => {
-      realtime.broadcast(event);
-    }
-  });
-  const terminal = new TerminalService({
-    allowedCommands: terminalAllowedCommands
-  });
-  const git = new GitService(terminal, bridgeWorkdir);
-
-  await app.register(cors, {
-    origin: corsOrigins.length > 0 ? corsOrigins : false
-  });
-
-  await app.register(websocket);
-
-  if (!authEnabled && allowInsecureNoAuth) {
-    app.log.warn(
-      'bridge auth is disabled by BRIDGE_ALLOW_INSECURE_NO_AUTH=true (local development only)'
-    );
-  }
-  if (allowQueryTokenAuth) {
-    app.log.warn(
-      'query-token auth is enabled (BRIDGE_ALLOW_QUERY_TOKEN_AUTH=true); prefer Authorization headers instead'
-    );
-  }
-  if (corsOrigins.length === 0) {
-    app.log.info(
-      'CORS response headers are disabled. Set BRIDGE_CORS_ORIGINS to allow browser origins.'
-    );
-  }
-  if (!terminalEnabled) {
-    app.log.warn('terminal exec endpoint is disabled by BRIDGE_DISABLE_TERMINAL_EXEC=true');
-  } else if (terminalAllowedCommands.length === 0) {
-    app.log.warn(
-      'terminal allowlist is empty; all commands are currently permitted. Set BRIDGE_TERMINAL_ALLOWED_COMMANDS to restrict.'
-    );
-  }
-
-  app.addHook('onRequest', async (request, reply) => {
-    if (!authEnabled) {
-      return;
-    }
-
-    if (request.url === '/health' || request.url.startsWith('/health?')) {
-      return;
-    }
-
-    if (isAuthorized(request, bridgeAuthToken, allowQueryTokenAuth)) {
-      return;
-    }
-
-    return reply.code(401).send({
-      error: 'unauthorized',
-      message: 'Missing or invalid bridge token'
-    });
-  });
-
-  app.get('/ws', { websocket: true }, (socket) => {
-    realtime.addClient(socket);
-
-    const healthEvent: BridgeWsEvent = {
-      type: 'health',
-      payload: {
-        status: 'ok',
-        at: new Date().toISOString()
-      }
-    };
-
-    socket.send(JSON.stringify(healthEvent));
-  });
-
-  app.get('/health', async () => {
-    return {
-      status: 'ok' as const,
-      at: new Date().toISOString(),
-      uptimeSec: Math.floor((Date.now() - startupAt) / 1000)
-    };
-  });
-
-  app.get('/threads', async () => {
-    return codex.listThreads();
-  });
-
-  app.post('/threads', async (request: CreateThreadRequest, reply: FastifyReply) => {
-    const parsed = createThreadSchema.safeParse((request.body ?? {}) as CreateThreadInput);
-    if (!parsed.success) {
-      return reply.code(400).send({ error: parsed.error.flatten() });
-    }
-
-    const thread = await codex.createThread(parsed.data);
-    return reply.code(201).send(thread);
-  });
-
-  app.get('/threads/:id', async (request: ThreadByIdRequest, reply: FastifyReply) => {
-    const thread = await codex.getThread(request.params.id);
-    if (!thread) {
-      return reply.code(404).send({ error: 'thread_not_found' });
-    }
-
-    return thread;
-  });
-
-  app.post(
-    '/threads/:id/message',
-    async (request: MessageRequest, reply: FastifyReply) => {
-      const parsed = sendMessageSchema.safeParse(
-        (request.body ?? {}) as SendThreadMessageInput
-      );
-      if (!parsed.success) {
-        return reply.code(400).send({ error: parsed.error.flatten() });
-      }
-
-      try {
-        const thread = await codex.appendMessage(request.params.id, parsed.data);
-        if (!thread) {
-          return reply.code(404).send({ error: 'thread_not_found' });
-        }
-
-        return thread;
-      } catch (error) {
-        if (error instanceof ThreadBusyError) {
-          return reply.code(409).send({
-            error: error.code,
-            message: error.message,
-            threadId: error.threadId
-          });
-        }
-
-        return reply.code(500).send({
-          error: 'thread_message_failed',
-          message: (error as Error).message
-        });
-      }
-    }
-  );
-
-  app.get('/approvals', async () => {
-    return codex.listPendingApprovals();
-  });
-
-  app.post(
-    '/approvals/:id/decision',
-    async (request: ApprovalDecisionRequest, reply: FastifyReply) => {
-      const parsed = approvalDecisionSchema.safeParse(request.body ?? {});
-      if (!parsed.success) {
-        return reply.code(400).send({ error: parsed.error.flatten() });
-      }
-
-      const resolved = await codex.resolveApproval(
-        request.params.id,
-        parsed.data.decision as ApprovalDecision
-      );
-      if (!resolved) {
-        return reply.code(404).send({ error: 'approval_not_found' });
-      }
-
-      return {
-        ok: true as const,
-        approval: resolved,
-        decision: parsed.data.decision
-      };
-    }
-  );
-
-  app.post('/terminal/exec', async (request: TerminalRequest, reply: FastifyReply) => {
-    const parsed = terminalExecSchema.safeParse(request.body ?? {});
-    if (!parsed.success) {
-      return reply.code(400).send({ error: parsed.error.flatten() });
-    }
-
-    if (!terminalEnabled) {
-      return reply.code(403).send({
-        error: 'terminal_exec_disabled',
-        message: 'Terminal execution is disabled on this bridge.'
-      });
-    }
-
-    const resolvedCwd = resolveTerminalCwd(parsed.data.cwd, bridgeWorkdir);
-
-    try {
-      const result = await terminal.executeShell(parsed.data.command, {
-        cwd: resolvedCwd,
-        timeoutMs: parsed.data.timeoutMs
-      });
-
-      realtime.broadcast({
-        type: 'terminal.executed',
-        payload: result
-      });
-
-      return result;
-    } catch (error) {
-      if (error instanceof TerminalCommandRejectedError) {
-        return reply.code(400).send({
-          error: error.code,
-          message: error.message
-        });
-      }
-
-      return reply.code(500).send({
-        error: 'terminal_exec_failed',
-        message: (error as Error).message
-      });
-    }
-  });
-
-  app.get('/git/status', async (_request: FastifyRequest, reply: FastifyReply) => {
-    try {
-      return await git.getStatus();
-    } catch (error) {
-      return reply.code(500).send({
-        error: 'git_status_failed',
-        message: (error as Error).message
-      });
-    }
-  });
-
-  app.get('/git/diff', async (_request: FastifyRequest, reply: FastifyReply) => {
-    try {
-      return await git.getDiff();
-    } catch (error) {
-      return reply.code(500).send({
-        error: 'git_diff_failed',
-        message: (error as Error).message
-      });
-    }
-  });
-
-  app.post('/git/commit', async (request: GitCommitRequest, reply: FastifyReply) => {
-    const parsed = gitCommitSchema.safeParse(request.body ?? {});
-    if (!parsed.success) {
-      return reply.code(400).send({ error: parsed.error.flatten() });
-    }
-
-    try {
-      const commit = await git.commit(parsed.data.message);
-      const status = await git.getStatus();
-
-      realtime.broadcast({
-        type: 'git.updated',
-        payload: status
-      });
-
-      return commit;
-    } catch (error) {
-      return reply.code(500).send({
-        error: 'git_commit_failed',
-        message: (error as Error).message
-      });
-    }
-  });
-
-  return app;
-}
-
-function parseTimeoutMs(value: string | undefined): number | undefined {
-  if (!value) {
-    return undefined;
-  }
-
-  const parsed = Number(value);
-  if (!Number.isFinite(parsed) || parsed <= 0) {
-    return undefined;
-  }
-
-  return Math.floor(parsed);
-}
-
-function isAuthorized(
-  request: FastifyRequest,
-  token: string,
-  allowQueryTokenAuth: boolean
-): boolean {
-  const authHeader = request.headers.authorization;
-  if (typeof authHeader === 'string' && authHeader.startsWith('Bearer ')) {
-    const bearer = authHeader.slice('Bearer '.length).trim();
-    if (bearer === token) {
-      return true;
-    }
-  }
-
-  if (allowQueryTokenAuth) {
-    const queryToken = (() => {
-      try {
-        const parsedUrl = new URL(request.url, 'http://localhost');
-        return parsedUrl.searchParams.get('token');
-      } catch {
-        return null;
-      }
-    })();
-
-    if (queryToken && queryToken === token) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-function parseBoolean(value: string | undefined): boolean {
-  if (!value) {
-    return false;
-  }
-
-  return value.trim().toLowerCase() === 'true';
-}
-
-function parseCsvList(value: string | undefined, fallback: string[] = []): string[] {
-  if (!value) {
-    return [...fallback];
-  }
-
-  return value
-    .split(',')
-    .map((entry) => entry.trim())
-    .filter(Boolean);
-}
-
-function resolveTerminalCwd(rawCwd: string | undefined, root: string): string {
-  const normalizedRoot = resolvePath(root);
-  if (!rawCwd || rawCwd.trim().length === 0) {
-    return normalizedRoot;
-  }
-
-  return isAbsolute(rawCwd) ? resolvePath(rawCwd) : resolvePath(normalizedRoot, rawCwd);
-}

package/services/mac-bridge/src/services/__tests__/gitService.test.ts

@@ -1,157 +0,0 @@
-import type { TerminalExecResponse } from '../../types';
-import { GitService } from '../gitService';
-import type { TerminalService } from '../terminalService';
-
-function createMockTerminal(response: Partial<TerminalExecResponse> = {}) {
-  const defaults: TerminalExecResponse = {
-    command: '',
-    cwd: '/repo',
-    code: 0,
-    stdout: '',
-    stderr: '',
-    timedOut: false,
-    durationMs: 10,
-    ...response,
-  };
-  return {
-    executeBinary: vi.fn().mockResolvedValue(defaults),
-    executeShell: vi.fn(),
-  } as unknown as TerminalService;
-}
-
-describe('GitService', () => {
-  const repoPath = '/repo';
-
-  describe('getStatus', () => {
-    it('parses branch from ## main...origin/main', async () => {
-      const terminal = createMockTerminal({
-        stdout: '## main...origin/main',
-      });
-      const git = new GitService(terminal, repoPath);
-
-      const status = await git.getStatus();
-
-      expect(status.branch).toBe('main');
-    });
-
-    it('parses branch without tracking info: ## feature-x', async () => {
-      const terminal = createMockTerminal({
-        stdout: '## feature-x',
-      });
-      const git = new GitService(terminal, repoPath);
-
-      const status = await git.getStatus();
-
-      expect(status.branch).toBe('feature-x');
-    });
-
-    it('reports clean: true when only branch line present', async () => {
-      const terminal = createMockTerminal({
-        stdout: '## main...origin/main',
-      });
-      const git = new GitService(terminal, repoPath);
-
-      const status = await git.getStatus();
-
-      expect(status.clean).toBe(true);
-    });
-
-    it('reports clean: false when modified files are present', async () => {
-      const terminal = createMockTerminal({
-        stdout: '## main\n M src/index.ts',
-      });
-      const git = new GitService(terminal, repoPath);
-
-      const status = await git.getStatus();
-
-      expect(status.clean).toBe(false);
-    });
-
-    it('throws when exit code is non-zero', async () => {
-      const terminal = createMockTerminal({
-        code: 128,
-        stderr: 'fatal: not a git repository',
-      });
-      const git = new GitService(terminal, repoPath);
-
-      await expect(git.getStatus()).rejects.toThrow(
-        'fatal: not a git repository'
-      );
-    });
-
-    it('returns raw field with full stdout', async () => {
-      const stdout = '## main...origin/main\n M src/index.ts';
-      const terminal = createMockTerminal({ stdout });
-      const git = new GitService(terminal, repoPath);
-
-      const status = await git.getStatus();
-
-      expect(status.raw).toBe(stdout);
-    });
-  });
-
-  describe('getDiff', () => {
-    it('returns diff from stdout', async () => {
-      const diff = 'diff --git a/file.ts b/file.ts\n--- a/file.ts\n+++ b/file.ts';
-      const terminal = createMockTerminal({ stdout: diff });
-      const git = new GitService(terminal, repoPath);
-
-      const result = await git.getDiff();
-
-      expect(result.diff).toBe(diff);
-    });
-
-    it('throws when exit code is non-zero', async () => {
-      const terminal = createMockTerminal({
-        code: 1,
-        stderr: 'error: could not read diff',
-      });
-      const git = new GitService(terminal, repoPath);
-
-      await expect(git.getDiff()).rejects.toThrow(
-        'error: could not read diff'
-      );
-    });
-  });
-
-  describe('commit', () => {
-    it('returns committed: true when code is 0', async () => {
-      const terminal = createMockTerminal({
-        code: 0,
-        stdout: '[main abc1234] my commit message',
-      });
-      const git = new GitService(terminal, repoPath);
-
-      const result = await git.commit('my commit message');
-
-      expect(result.committed).toBe(true);
-      expect(result.code).toBe(0);
-    });
-
-    it('returns committed: false when code is non-zero', async () => {
-      const terminal = createMockTerminal({
-        code: 1,
-        stderr: 'nothing to commit',
-      });
-      const git = new GitService(terminal, repoPath);
-
-      const result = await git.commit('my commit message');
-
-      expect(result.committed).toBe(false);
-      expect(result.code).toBe(1);
-    });
-
-    it('passes message as git commit argument', async () => {
-      const terminal = createMockTerminal({ code: 0 });
-      const git = new GitService(terminal, repoPath);
-
-      await git.commit('fix: resolve bug');
-
-      expect(terminal.executeBinary).toHaveBeenCalledWith(
-        'git',
-        ['-C', repoPath, 'commit', '-m', 'fix: resolve bug'],
-        { cwd: repoPath }
-      );
-    });
-  });
-});

package/services/mac-bridge/src/services/__tests__/realtimeHub.test.ts

@@ -1,116 +0,0 @@
-import { RealtimeHub } from '../realtimeHub';
-import type { BridgeWsEvent } from '../../types';
-import type { WebSocket } from '@fastify/websocket';
-
-// ---------------------------------------------------------------------------
-// Mock WebSocket client helper
-// ---------------------------------------------------------------------------
-
-interface MockClient {
-  readyState: number;
-  send: ReturnType<typeof vi.fn>;
-  on: ReturnType<typeof vi.fn>;
-  _triggerClose: () => void;
-}
-
-function createMockClient(readyState = 1): MockClient {
-  const handlers: Record<string, () => void> = {};
-  return {
-    readyState,
-    send: vi.fn(),
-    on: vi.fn((event: string, handler: () => void) => {
-      handlers[event] = handler;
-    }),
-    // Helper to trigger close event in tests
-    _triggerClose: () => handlers['close']?.(),
-  };
-}
-
-// ---------------------------------------------------------------------------
-// RealtimeHub
-// ---------------------------------------------------------------------------
-
-describe('RealtimeHub', () => {
-  const sampleEvent: BridgeWsEvent = {
-    type: 'health',
-    payload: { status: 'ok', at: '2026-01-01T00:00:00.000Z' },
-  };
-
-  it('broadcast sends serialized JSON to all connected clients with readyState === 1', () => {
-    const hub = new RealtimeHub();
-    const client1 = createMockClient(1);
-    const client2 = createMockClient(1);
-
-    hub.addClient(client1 as unknown as WebSocket);
-    hub.addClient(client2 as unknown as WebSocket);
-    hub.broadcast(sampleEvent);
-
-    const expected = JSON.stringify(sampleEvent);
-    expect(client1.send).toHaveBeenCalledTimes(1);
-    expect(client1.send).toHaveBeenCalledWith(expected);
-    expect(client2.send).toHaveBeenCalledTimes(1);
-    expect(client2.send).toHaveBeenCalledWith(expected);
-  });
-
-  it('broadcast skips clients where readyState !== 1 (e.g., CLOSED)', () => {
-    const hub = new RealtimeHub();
-    const openClient = createMockClient(1);
-    const closedClient = createMockClient(3); // WebSocket.CLOSED = 3
-
-    hub.addClient(openClient as unknown as WebSocket);
-    hub.addClient(closedClient as unknown as WebSocket);
-    hub.broadcast(sampleEvent);
-
-    expect(openClient.send).toHaveBeenCalledTimes(1);
-    expect(closedClient.send).not.toHaveBeenCalled();
-  });
-
-  it('addClient registers a client; after triggering close, client is removed and no longer receives broadcasts', () => {
-    const hub = new RealtimeHub();
-    const client = createMockClient(1);
-
-    hub.addClient(client as unknown as WebSocket);
-
-    // Verify the close handler was registered
-    expect(client.on).toHaveBeenCalledWith('close', expect.any(Function));
-
-    // Client should receive broadcasts before close
-    hub.broadcast(sampleEvent);
-    expect(client.send).toHaveBeenCalledTimes(1);
-
-    // Trigger close -- client should be removed
-    client._triggerClose();
-
-    // Reset mock to verify no further calls
-    client.send.mockClear();
-    hub.broadcast(sampleEvent);
-    expect(client.send).not.toHaveBeenCalled();
-  });
-
-  it('broadcast on empty hub does nothing (no errors thrown)', () => {
-    const hub = new RealtimeHub();
-
-    expect(() => hub.broadcast(sampleEvent)).not.toThrow();
-  });
-
-  it('multiple clients each receive the same broadcast payload', () => {
-    const hub = new RealtimeHub();
-    const clients = [
-      createMockClient(1),
-      createMockClient(1),
-      createMockClient(1),
-    ];
-
-    for (const client of clients) {
-      hub.addClient(client as unknown as WebSocket);
-    }
-
-    hub.broadcast(sampleEvent);
-
-    const expected = JSON.stringify(sampleEvent);
-    for (const client of clients) {
-      expect(client.send).toHaveBeenCalledTimes(1);
-      expect(client.send).toHaveBeenCalledWith(expected);
-    }
-  });
-});