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

package/src/commands/__tests__/process.test.ts

@@ -1,251 +0,0 @@
-/**
- * Process command tests - validates error paths throw SpacesError with exit code 1
- */
-
-import { describe, expect, it, mock, beforeEach } from 'bun:test';
-import { SpacesError } from '../../types/errors.js';
-import type { ProcessInstanceSpec } from '../../types/processes.js';
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-
-// ============================================================================
-// Mocks
-// ============================================================================
-
-// Mock tmux-lite CLI
-const mockListSessions = mock<() => Promise<Array<{ id: string; name: string; cwd: string }>>>(
-  () => Promise.resolve([])
-);
-mock.module('../../lib/tmux-lite/cli.js', () => ({
-  listSessions: mockListSessions,
-  createSession: mock(() => Promise.resolve({ id: 'sess-1', name: 'test' })),
-  killSession: mock(() => Promise.resolve()),
-}));
-
-// Mock process manager
-const mockGetProcessSpecs = mock<(workspacePath: string) => ProcessInstanceSpec[]>(() => []);
-const mockStartProcessInstance = mock(() => Promise.resolve({ sessionId: 'sess-1', created: true }));
-const mockStopProcessInstance = mock(() => Promise.resolve());
-const mockListProcessSessions = mock<
-  () => Promise<Array<{ sessionId: string; processName: string; instance: number; name: string; workspacePath: string }>>
->(() => Promise.resolve([]));
-
-mock.module('../../lib/processes/manager.js', () => ({
-  getProcessSpecs: mockGetProcessSpecs,
-  startProcessInstance: mockStartProcessInstance,
-  stopProcessInstance: mockStopProcessInstance,
-  listProcessSessions: mockListProcessSessions,
-}));
-
-// Import after mocking
-const { listProcesses, startProcess, stopProcess, attachProcess } = await import('../process.js');
-
-// ============================================================================
-// startProcess
-// ============================================================================
-
-describe('startProcess', () => {
-  beforeEach(() => {
-    mockGetProcessSpecs.mockReset();
-    mockStartProcessInstance.mockReset();
-  });
-
-  it('should throw SpacesError with exit code 1 when --name is missing', async () => {
-    try {
-      await startProcess({});
-      expect.unreachable('should have thrown');
-    } catch (err) {
-      expect(err).toBeInstanceOf(SpacesError);
-      expect((err as SpacesError).exitCode).toBe(1);
-      expect((err as SpacesError).code).toBe('USER_ERROR');
-      expect((err as SpacesError).message).toContain('--name');
-    }
-  });
-
-  it('should throw SpacesError when process name is not found in specs', async () => {
-    mockGetProcessSpecs.mockImplementation(() => []);
-
-    try {
-      await startProcess({ name: 'nonexistent' });
-      expect.unreachable('should have thrown');
-    } catch (err) {
-      expect(err).toBeInstanceOf(SpacesError);
-      expect((err as SpacesError).exitCode).toBe(1);
-      expect((err as SpacesError).message).toContain('nonexistent');
-    }
-  });
-
-  it('should start process when spec exists', async () => {
-    const spec: ProcessInstanceSpec = {
-      name: 'web',
-      instance: 1,
-      definition: { name: 'web', command: 'npm start' },
-    };
-    mockGetProcessSpecs.mockImplementation(() => [spec]);
-    mockStartProcessInstance.mockResolvedValue({ sessionId: 'sess-1', created: true });
-
-    // Should not throw
-    await startProcess({ name: 'web' });
-
-    expect(mockStartProcessInstance).toHaveBeenCalledTimes(1);
-  });
-
-  it('should throw disabled error when process exists with instances: 0', async () => {
-    mockGetProcessSpecs.mockImplementation(() => []);
-    const workspacePath = mkdtempSync(join(tmpdir(), 'gssh-process-test-'));
-    const gitspaceDir = join(workspacePath, '.gitspace');
-    mkdirSync(gitspaceDir, { recursive: true });
-    writeFileSync(
-      join(gitspaceDir, 'processes.json'),
-      JSON.stringify({ processes: [{ name: 'web', command: 'npm start', instances: 0 }] }),
-      'utf-8'
-    );
-
-    try {
-      await startProcess({ name: 'web', workspace: workspacePath });
-      expect.unreachable('should have thrown');
-    } catch (err) {
-      expect(err).toBeInstanceOf(SpacesError);
-      expect((err as SpacesError).exitCode).toBe(1);
-      expect((err as SpacesError).message).toContain('Process is disabled');
-    } finally {
-      rmSync(workspacePath, { recursive: true, force: true });
-    }
-  });
-});
-
-// ============================================================================
-// stopProcess
-// ============================================================================
-
-describe('stopProcess', () => {
-  beforeEach(() => {
-    mockGetProcessSpecs.mockReset();
-    mockStopProcessInstance.mockReset();
-  });
-
-  it('should throw SpacesError with exit code 1 when --name is missing', async () => {
-    try {
-      await stopProcess({});
-      expect.unreachable('should have thrown');
-    } catch (err) {
-      expect(err).toBeInstanceOf(SpacesError);
-      expect((err as SpacesError).exitCode).toBe(1);
-      expect((err as SpacesError).message).toContain('--name');
-    }
-  });
-
-  it('should throw SpacesError when process name is not found', async () => {
-    mockGetProcessSpecs.mockImplementation(() => []);
-
-    try {
-      await stopProcess({ name: 'nonexistent' });
-      expect.unreachable('should have thrown');
-    } catch (err) {
-      expect(err).toBeInstanceOf(SpacesError);
-      expect((err as SpacesError).exitCode).toBe(1);
-      expect((err as SpacesError).message).toContain('nonexistent');
-    }
-  });
-
-  it('should stop process when spec exists', async () => {
-    const spec: ProcessInstanceSpec = {
-      name: 'web',
-      instance: 1,
-      definition: { name: 'web', command: 'npm start' },
-    };
-    mockGetProcessSpecs.mockImplementation(() => [spec]);
-    mockStopProcessInstance.mockResolvedValue(undefined);
-
-    await stopProcess({ name: 'web' });
-
-    expect(mockStopProcessInstance).toHaveBeenCalledTimes(1);
-  });
-});
-
-// ============================================================================
-// attachProcess
-// ============================================================================
-
-describe('attachProcess', () => {
-  beforeEach(() => {
-    mockListProcessSessions.mockReset();
-    mockListSessions.mockReset();
-  });
-
-  it('should throw SpacesError with exit code 1 when --name is missing', async () => {
-    try {
-      await attachProcess({});
-      expect.unreachable('should have thrown');
-    } catch (err) {
-      expect(err).toBeInstanceOf(SpacesError);
-      expect((err as SpacesError).exitCode).toBe(1);
-      expect((err as SpacesError).message).toContain('--name');
-    }
-  });
-
-  it('should throw SpacesError when process is not running', async () => {
-    mockListProcessSessions.mockImplementation(() => Promise.resolve([]));
-
-    try {
-      await attachProcess({ name: 'web' });
-      expect.unreachable('should have thrown');
-    } catch (err) {
-      expect(err).toBeInstanceOf(SpacesError);
-      expect((err as SpacesError).exitCode).toBe(1);
-      expect((err as SpacesError).message).toContain('not running');
-    }
-  });
-
-  it('should throw SYSTEM_ERROR when session is not found in tmux', async () => {
-    mockListProcessSessions.mockImplementation(() =>
-      Promise.resolve([
-        { sessionId: 'sess-99', processName: 'web', instance: 1, name: 'proc:ws:web:1', workspacePath: '/tmp' },
-      ])
-    );
-    mockListSessions.mockImplementation(() => Promise.resolve([]));
-
-    try {
-      await attachProcess({ name: 'web' });
-      expect.unreachable('should have thrown');
-    } catch (err) {
-      expect(err).toBeInstanceOf(SpacesError);
-      expect((err as SpacesError).exitCode).toBe(2);
-      expect((err as SpacesError).code).toBe('SYSTEM_ERROR');
-    }
-  });
-
-  it('should succeed when process is running and session exists', async () => {
-    mockListProcessSessions.mockImplementation(() =>
-      Promise.resolve([
-        { sessionId: 'sess-1', processName: 'web', instance: 1, name: 'proc:ws:web:1', workspacePath: '/tmp' },
-      ])
-    );
-    mockListSessions.mockImplementation(() =>
-      Promise.resolve([{ id: 'sess-1', name: 'proc:ws:web:1', cwd: '/tmp' }])
-    );
-
-    // Should not throw
-    await attachProcess({ name: 'web' });
-  });
-});
-
-// ============================================================================
-// listProcesses (no error paths, just smoke test)
-// ============================================================================
-
-describe('listProcesses', () => {
-  beforeEach(() => {
-    mockGetProcessSpecs.mockReset();
-    mockListProcessSessions.mockReset();
-  });
-
-  it('should not throw when no processes are configured', async () => {
-    mockGetProcessSpecs.mockImplementation(() => []);
-    mockListProcessSessions.mockImplementation(() => Promise.resolve([]));
-
-    // Should not throw
-    await listProcesses({});
-  });
-});

package/src/commands/__tests__/serve-messages.test.ts

@@ -1,190 +0,0 @@
-/**
- * Serve Message Handler Tests
- *
- * Tests that the serve command properly handles all message types
- * from the relay server. This ensures no "Unknown message type" errors.
- */
-
-import { describe, expect, test } from "bun:test";
-import type { RelayToMachineMessage } from "../../relay/protocol";
-
-/**
- * All message types that the relay can send to a machine.
- * The serve command's message handler must handle all of these.
- */
-const RELAY_TO_MACHINE_MESSAGE_TYPES: RelayToMachineMessage["type"][] = [
-  "relay_identity",
-  "challenge",
-  "registered",
-  "access_list",
-  "access_update",
-  "client_authorized",
-  "client_revoked",
-  "client_connected",
-  "client_disconnected",
-  "data",
-  "error",
-];
-
-/**
- * Message types that require explicit handling (not just acknowledgment).
- */
-const CRITICAL_MESSAGE_TYPES = [
-  "relay_identity",   // Must respond with register_machine
-  "registered",       // Must sync access list
-  "client_connected", // Must set up session
-  "client_disconnected", // Must clean up session
-  "data",            // Must route to session
-  "error",           // Must log/handle error
-  "access_list",     // Must update local ACL
-  "access_update",   // Must update local ACL
-];
-
-/**
- * Message types that are acknowledgments (can be no-ops).
- */
-const ACKNOWLEDGMENT_MESSAGE_TYPES = [
-  "client_authorized",
-  "client_revoked",
-  "challenge", // Only used if relay sends separate challenge (usually included in relay_identity)
-];
-
-describe("serve message handler coverage", () => {
-  test("documents all relay-to-machine message types", () => {
-    // This test documents the expected message types.
-    // If the protocol adds new types, this test should be updated.
-    expect(RELAY_TO_MACHINE_MESSAGE_TYPES).toHaveLength(11);
-  });
-
-  test("critical message types are a subset of all types", () => {
-    for (const type of CRITICAL_MESSAGE_TYPES) {
-      expect(RELAY_TO_MACHINE_MESSAGE_TYPES).toContain(type as RelayToMachineMessage["type"]);
-    }
-  });
-
-  test("acknowledgment message types are a subset of all types", () => {
-    for (const type of ACKNOWLEDGMENT_MESSAGE_TYPES) {
-      expect(RELAY_TO_MACHINE_MESSAGE_TYPES).toContain(type as RelayToMachineMessage["type"]);
-    }
-  });
-
-  test("all message types are either critical or acknowledgment", () => {
-    const allCovered = new Set([
-      ...CRITICAL_MESSAGE_TYPES,
-      ...ACKNOWLEDGMENT_MESSAGE_TYPES,
-    ]);
-
-    for (const type of RELAY_TO_MACHINE_MESSAGE_TYPES) {
-      expect(allCovered.has(type)).toBe(true);
-    }
-  });
-});
-
-describe("message type handling requirements", () => {
-  /**
-   * These tests document what each message type requires.
-   * They serve as living documentation for the serve command implementation.
-   */
-
-  test("relay_identity requires challenge-response authentication", () => {
-    const requirements = {
-      type: "relay_identity",
-      requiredFields: ["publicKey", "fingerprint", "challenge"],
-      expectedResponse: "register_machine with challengeResponse",
-      securityNote: "Must verify relay trust before responding",
-    };
-
-    expect(requirements.requiredFields).toContain("challenge");
-    expect(requirements.expectedResponse).toContain("challengeResponse");
-  });
-
-  test("registered triggers access list sync", () => {
-    const requirements = {
-      type: "registered",
-      requiredFields: ["machineId"],
-      sideEffects: [
-        "Sync all access entries to relay",
-        "Start access list file watcher",
-        "Set up access command handler",
-      ],
-    };
-
-    expect(requirements.sideEffects.length).toBeGreaterThan(0);
-  });
-
-  test("client_authorized is an acknowledgment", () => {
-    const requirements = {
-      type: "client_authorized",
-      requiredFields: ["clientIdentityId"],
-      sideEffects: [], // No action needed - authorization was already applied locally
-      note: "Sent by relay to confirm authorize_client was processed",
-    };
-
-    expect(requirements.sideEffects).toHaveLength(0);
-  });
-
-  test("client_revoked is an acknowledgment", () => {
-    const requirements = {
-      type: "client_revoked",
-      requiredFields: ["clientIdentityId"],
-      sideEffects: [], // No action needed - revocation was already applied locally
-      note: "Sent by relay to confirm revoke_client was processed",
-    };
-
-    expect(requirements.sideEffects).toHaveLength(0);
-  });
-
-  test("access_list requires full ACL replacement", () => {
-    const requirements = {
-      type: "access_list",
-      requiredFields: ["entries"],
-      sideEffects: [
-        "Update local access control list with all entries",
-      ],
-      note: "Sent on reconnect to sync full state",
-    };
-
-    expect(requirements.requiredFields).toContain("entries");
-  });
-
-  test("access_update requires incremental ACL update", () => {
-    const requirements = {
-      type: "access_update",
-      requiredFields: ["added", "removed"],
-      sideEffects: [
-        "Add new entries to local ACL",
-        "Remove revoked entries from local ACL",
-      ],
-    };
-
-    expect(requirements.requiredFields).toContain("added");
-    expect(requirements.requiredFields).toContain("removed");
-  });
-});
-
-describe("error scenarios", () => {
-  test("unknown message types should log warning", () => {
-    // The serve command should log unknown message types
-    // rather than silently ignoring them
-    const unknownType = "some_future_message_type";
-    expect(RELAY_TO_MACHINE_MESSAGE_TYPES).not.toContain(unknownType);
-  });
-
-  test("malformed messages should not crash handler", () => {
-    // These are examples of malformed messages that the handler
-    // should gracefully reject without crashing
-    const malformedMessages = [
-      null,
-      undefined,
-      {},
-      { type: null },
-      { type: 123 },
-      "not an object",
-      { type: "registered" }, // missing machineId
-      { type: "data" }, // missing data field
-    ];
-
-    // Each should be handled without throwing
-    expect(malformedMessages.length).toBe(8);
-  });
-});

package/src/commands/__tests__/serve-process-hosting.test.ts

@@ -1,63 +0,0 @@
-/**
- * Serve process hosting helpers tests
- */
-
-import { describe, expect, test } from "bun:test";
-import {
-  buildServeIngressConfig,
-  type ProcessHostEntry,
-} from "../serve";
-import { buildProcessHostname, normalizeHostLabel } from "../../utils/hostnames";
-
-describe("process hosting helpers", () => {
-  test("normalizeHostLabel cleans and lowercases", () => {
-    expect(normalizeHostLabel("My App")).toBe("my-app");
-    expect(normalizeHostLabel("API__Server")).toBe("api-server");
-    expect(normalizeHostLabel("---")).toBe("x");
-  });
-
-  test("buildProcessHostname assembles expected segments", () => {
-    const hostname = buildProcessHostname(
-      "brad.serve.gitspace.sh",
-      "my-workspace",
-      "web-api",
-      2,
-      "web"
-    );
-
-    expect(hostname).toBe("web.web-api-2.my-workspace.brad.serve.gitspace.sh");
-  });
-
-  test("buildServeIngressConfig adds fallback", () => {
-    const entries: ProcessHostEntry[] = [
-      {
-        hostname: "web.api-1.alpha.brad.serve.gitspace.sh",
-        service: "http://127.0.0.1:3000",
-        protocol: "http",
-        workspaceId: "alpha",
-        processName: "api",
-        instance: 1,
-        port: 3000,
-        portName: "web",
-      },
-      {
-        hostname: "tcp.api-1.alpha.brad.serve.gitspace.sh",
-        service: "tcp://127.0.0.1:9000",
-        protocol: "tcp",
-        workspaceId: "alpha",
-        processName: "api",
-        instance: 1,
-        port: 9000,
-        portName: "tcp",
-      },
-    ];
-
-    const config = buildServeIngressConfig(entries);
-    expect(config).toContain("ingress:");
-    expect(config).toContain("hostname: web.api-1.alpha.brad.serve.gitspace.sh");
-    expect(config).toContain("service: http://127.0.0.1:3000");
-    expect(config).toContain("hostname: tcp.api-1.alpha.brad.serve.gitspace.sh");
-    expect(config).toContain("service: tcp://127.0.0.1:9000");
-    expect(config).toContain("service: http_status:404");
-  });
-});