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

package/src/lib/processes/__tests__/names.test.ts

@@ -1,125 +0,0 @@
-/**
- * Process session naming tests
- */
-
-import { describe, expect, it } from 'bun:test';
-import {
-  buildProcessSessionName,
-  encodeProcessNameForPath,
-  parseProcessSessionName,
-  PROCESS_SESSION_PREFIX,
-  PROCESS_SESSION_MAX_NAME,
-} from '../names.js';
-
-// ============================================================================
-// buildProcessSessionName
-// ============================================================================
-
-describe('buildProcessSessionName', () => {
-  it('should build name with correct format', () => {
-    const name = buildProcessSessionName('my-workspace', 'web', 1);
-    expect(name).toBe('proc:my-workspace:web:1');
-  });
-
-  it('should use the PROCESS_SESSION_PREFIX', () => {
-    const name = buildProcessSessionName('ws', 'api', 2);
-    expect(name.startsWith(`${PROCESS_SESSION_PREFIX}:`)).toBe(true);
-  });
-
-  it('should truncate names exceeding max length', () => {
-    const longWorkspace = 'a'.repeat(80);
-    const name = buildProcessSessionName(longWorkspace, 'web', 1);
-    expect(name.length).toBeLessThanOrEqual(PROCESS_SESSION_MAX_NAME);
-    expect(parseProcessSessionName(name)).not.toBeNull();
-  });
-
-  it('should not truncate short names', () => {
-    const name = buildProcessSessionName('ws', 'api', 1);
-    expect(name).toBe('proc:ws:api:1');
-    expect(name.length).toBeLessThan(PROCESS_SESSION_MAX_NAME);
-  });
-
-  it('should handle instance numbers > 1', () => {
-    const name = buildProcessSessionName('ws', 'worker', 5);
-    expect(name).toBe('proc:ws:worker:5');
-  });
-});
-
-// ============================================================================
-// parseProcessSessionName
-// ============================================================================
-
-describe('parseProcessSessionName', () => {
-  it('should parse a valid process session name', () => {
-    const result = parseProcessSessionName('proc:my-workspace:web:1');
-    expect(result).toEqual({
-      workspaceId: 'my-workspace',
-      processName: 'web',
-      instance: 1,
-    });
-  });
-
-  it('should return null for non-process names', () => {
-    expect(parseProcessSessionName('alpha:ws:1')).toBeNull();
-  });
-
-  it('should return null for empty string', () => {
-    expect(parseProcessSessionName('')).toBeNull();
-  });
-
-  it('should return null for wrong prefix', () => {
-    expect(parseProcessSessionName('session:ws:web:1')).toBeNull();
-  });
-
-  it('should return null for too few parts', () => {
-    expect(parseProcessSessionName('proc:ws')).toBeNull();
-    expect(parseProcessSessionName('proc:ws:web')).toBeNull();
-  });
-
-  it('should return null for non-numeric instance', () => {
-    expect(parseProcessSessionName('proc:ws:web:abc')).toBeNull();
-  });
-
-  it('should handle instance 0', () => {
-    const result = parseProcessSessionName('proc:ws:web:0');
-    expect(result).toEqual({
-      workspaceId: 'ws',
-      processName: 'web',
-      instance: 0,
-    });
-  });
-});
-
-// ============================================================================
-// Round-trip
-// ============================================================================
-
-describe('buildProcessSessionName / parseProcessSessionName round-trip', () => {
-  it('should round-trip standard names', () => {
-    const name = buildProcessSessionName('workspace', 'dev-server', 1);
-    const parsed = parseProcessSessionName(name);
-    expect(parsed).toEqual({
-      workspaceId: 'workspace',
-      processName: 'dev-server',
-      instance: 1,
-    });
-  });
-
-  it('should round-trip multi-instance', () => {
-    for (let i = 1; i <= 5; i++) {
-      const name = buildProcessSessionName('ws', 'worker', i);
-      const parsed = parseProcessSessionName(name);
-      expect(parsed?.instance).toBe(i);
-    }
-  });
-});
-
-describe('encodeProcessNameForPath', () => {
-  it('encodes path separators and dot segments safely', () => {
-    expect(encodeProcessNameForPath('../api/server')).toBe('..%2Fapi%2Fserver');
-  });
-
-  it('keeps simple names readable', () => {
-    expect(encodeProcessNameForPath('web-server')).toBe('web-server');
-  });
-});

package/src/lib/processes/__tests__/schema.test.ts

@@ -1,208 +0,0 @@
-/**
- * Process schema validation tests
- */
-
-import { describe, expect, it } from 'bun:test';
-import { validateProcessesConfig, describeProcess } from '../schema.js';
-import type { ProcessesConfig, ProcessDefinition } from '../../../types/processes.js';
-
-// ============================================================================
-// validateProcessesConfig
-// ============================================================================
-
-describe('validateProcessesConfig', () => {
-  it('should pass for valid config with one process', () => {
-    const config: ProcessesConfig = {
-      processes: [{ name: 'web', command: 'npm start' }],
-    };
-    const result = validateProcessesConfig(config);
-    expect(result.valid).toBe(true);
-    expect(result.errors).toEqual([]);
-  });
-
-  it('should pass for valid config with multiple processes', () => {
-    const config: ProcessesConfig = {
-      processes: [
-        { name: 'web', command: 'npm start' },
-        { name: 'worker', command: 'npm run worker' },
-      ],
-    };
-    const result = validateProcessesConfig(config);
-    expect(result.valid).toBe(true);
-  });
-
-  it('should pass for empty processes array', () => {
-    const config: ProcessesConfig = { processes: [] };
-    const result = validateProcessesConfig(config);
-    expect(result.valid).toBe(true);
-  });
-
-  it('should fail when processes is not an array', () => {
-    const config = { processes: 'not-an-array' } as unknown as ProcessesConfig;
-    const result = validateProcessesConfig(config);
-    expect(result.valid).toBe(false);
-    expect(result.errors).toContain('processes must be an array');
-  });
-
-  it('should fail when process has no name', () => {
-    const config = {
-      processes: [{ command: 'npm start' }],
-    } as unknown as ProcessesConfig;
-    const result = validateProcessesConfig(config);
-    expect(result.valid).toBe(false);
-    expect(result.errors).toContain('process is missing name');
-  });
-
-  it('should fail for duplicate process names', () => {
-    const config: ProcessesConfig = {
-      processes: [
-        { name: 'web', command: 'npm start' },
-        { name: 'web', command: 'npm run dev' },
-      ],
-    };
-    const result = validateProcessesConfig(config);
-    expect(result.valid).toBe(false);
-    expect(result.errors).toContain('duplicate process name: web');
-  });
-
-  it('should fail when process has no command', () => {
-    const config = {
-      processes: [{ name: 'web' }],
-    } as unknown as ProcessesConfig;
-    const result = validateProcessesConfig(config);
-    expect(result.valid).toBe(false);
-    expect(result.errors).toContain('process web missing command');
-  });
-
-  it('should allow instances set to 0 (disabled process)', () => {
-    const config: ProcessesConfig = {
-      processes: [{ name: 'worker', command: 'npm run worker', instances: 0 }],
-    };
-    const result = validateProcessesConfig(config);
-    expect(result.valid).toBe(true);
-  });
-
-  it('should fail when instances is negative', () => {
-    const config = {
-      processes: [{ name: 'worker', command: 'npm run worker', instances: -1 }],
-    } as unknown as ProcessesConfig;
-    const result = validateProcessesConfig(config);
-    expect(result.valid).toBe(false);
-    expect(result.errors).toContain('process worker instances must be a non-negative integer');
-  });
-
-  it('should fail when instances is not an integer', () => {
-    const config = {
-      processes: [{ name: 'worker', command: 'npm run worker', instances: 1.5 }],
-    } as unknown as ProcessesConfig;
-    const result = validateProcessesConfig(config);
-    expect(result.valid).toBe(false);
-    expect(result.errors).toContain('process worker instances must be a non-negative integer');
-  });
-
-  it('should fail when keepRawOutput is not boolean', () => {
-    const config = {
-      processes: [
-        { name: 'web', command: 'npm start', events: { keepRawOutput: 'yes' } },
-      ],
-    } as unknown as ProcessesConfig;
-    const result = validateProcessesConfig(config);
-    expect(result.valid).toBe(false);
-    expect(result.errors[0]).toContain('keepRawOutput must be a boolean');
-  });
-
-  it('should pass when keepRawOutput is boolean', () => {
-    const config: ProcessesConfig = {
-      processes: [
-        { name: 'web', command: 'npm start', events: { keepRawOutput: true } },
-      ],
-    };
-    const result = validateProcessesConfig(config);
-    expect(result.valid).toBe(true);
-  });
-
-  it('should fail when ports is not an array', () => {
-    const config = {
-      processes: [{ name: 'web', command: 'npm start', ports: 'not-array' }],
-    } as unknown as ProcessesConfig;
-    const result = validateProcessesConfig(config);
-    expect(result.valid).toBe(false);
-    expect(result.errors[0]).toContain('ports must be an array');
-  });
-
-  it('should fail for port out of range', () => {
-    const config: ProcessesConfig = {
-      processes: [
-        { name: 'web', command: 'npm start', ports: [{ port: 0 }] },
-      ],
-    };
-    const result = validateProcessesConfig(config);
-    expect(result.valid).toBe(false);
-    expect(result.errors[0]).toContain('port must be a number between 1 and 65535');
-  });
-
-  it('should fail for port over 65535', () => {
-    const config: ProcessesConfig = {
-      processes: [
-        { name: 'web', command: 'npm start', ports: [{ port: 70000 }] },
-      ],
-    };
-    const result = validateProcessesConfig(config);
-    expect(result.valid).toBe(false);
-  });
-
-  it('should pass for valid port config', () => {
-    const config: ProcessesConfig = {
-      processes: [
-        { name: 'web', command: 'npm start', ports: [{ port: 3000, name: 'http', protocol: 'http' }] },
-      ],
-    };
-    const result = validateProcessesConfig(config);
-    expect(result.valid).toBe(true);
-  });
-
-  it('should fail for invalid port protocol', () => {
-    const config = {
-      processes: [
-        { name: 'web', command: 'npm start', ports: [{ port: 3000, protocol: 'udp' }] },
-      ],
-    } as unknown as ProcessesConfig;
-    const result = validateProcessesConfig(config);
-    expect(result.valid).toBe(false);
-    expect(result.errors[0]).toContain('protocol must be http or tcp');
-  });
-
-  it('should accumulate multiple errors', () => {
-    const config = {
-      processes: [
-        { name: 'web', command: 'npm start' },
-        { name: 'web', command: 'npm run dev' },  // duplicate
-        { command: 'npm test' },                    // missing name
-      ],
-    } as unknown as ProcessesConfig;
-    const result = validateProcessesConfig(config);
-    expect(result.valid).toBe(false);
-    expect(result.errors.length).toBeGreaterThanOrEqual(2);
-  });
-});
-
-// ============================================================================
-// describeProcess
-// ============================================================================
-
-describe('describeProcess', () => {
-  it('should describe process with command only', () => {
-    const process: ProcessDefinition = { name: 'web', command: 'npm start' };
-    expect(describeProcess(process)).toBe('web: npm start');
-  });
-
-  it('should describe process with args', () => {
-    const process: ProcessDefinition = { name: 'api', command: 'node', args: ['server.js', '--port', '3000'] };
-    expect(describeProcess(process)).toBe('api: node server.js --port 3000');
-  });
-
-  it('should describe process with empty args', () => {
-    const process: ProcessDefinition = { name: 'worker', command: 'python', args: [] };
-    expect(describeProcess(process)).toBe('worker: python');
-  });
-});

package/src/lib/processes/__tests__/watchdog.test.ts

@@ -1,210 +0,0 @@
-/**
- * Process watchdog tests - restart policy enforcement with injected deps
- *
- * NOTE: The watchdog uses a module-level restartState map keyed by "workspacePath:name:instance".
- * Each test uses a unique process name to avoid state leaking between tests.
- */
-
-import { describe, expect, it, mock } from 'bun:test';
-import { reconcileProcessRestarts, type ProcessWatchdogDeps } from '../watchdog.js';
-import type { ProcessInstanceSpec } from '../../../types/processes.js';
-
-let testCounter = 0;
-function uniqueName(): string {
-  return `test-proc-${++testCounter}`;
-}
-
-function makeSpec(overrides: {
-  name?: string;
-  instance?: number;
-  policy?: 'always' | 'on-failure' | 'never';
-  maxAttempts?: number;
-  backoffMs?: number;
-  maxBackoffMs?: number;
-} = {}): ProcessInstanceSpec {
-  const name = overrides.name ?? uniqueName();
-  return {
-    name,
-    instance: overrides.instance ?? 1,
-    definition: {
-      name,
-      command: 'npm start',
-      restart: {
-        policy: overrides.policy ?? 'always',
-        maxAttempts: overrides.maxAttempts ?? 5,
-        backoffMs: overrides.backoffMs ?? 1000,
-        maxBackoffMs: overrides.maxBackoffMs ?? 30000,
-      },
-    },
-  };
-}
-
-function makeDeps(overrides: Partial<ProcessWatchdogDeps> = {}): ProcessWatchdogDeps {
-  return {
-    listSessions: mock(() => Promise.resolve([])),
-    startProcessInstance: mock(() => Promise.resolve({ sessionId: 'sess-1', created: true })),
-    isProcessRestartDisabled: mock(() => false),
-    disableProcessRestart: mock(() => {}),
-    hasProcessStarted: mock(() => true),
-    readProcessExit: mock(() => null),
-    now: mock(() => Date.now()),
-    ...overrides,
-  };
-}
-
-// ============================================================================
-// reconcileProcessRestarts
-// ============================================================================
-
-describe('reconcileProcessRestarts', () => {
-  it('should skip processes with restart policy "never"', async () => {
-    const deps = makeDeps();
-    const specs = [makeSpec({ policy: 'never' })];
-
-    await reconcileProcessRestarts('/tmp/ws', specs, deps);
-
-    expect(deps.startProcessInstance).not.toHaveBeenCalled();
-  });
-
-  it('should skip processes that are currently running', async () => {
-    const spec = makeSpec();
-    const deps = makeDeps({
-      listSessions: mock(() =>
-        Promise.resolve([
-          { id: 's1', name: `proc:ws:${spec.name}:1`, socketPath: '/tmp/s', pid: 1, attached: false, cwd: '/tmp/ws', createdAt: 0 },
-        ])
-      ),
-    });
-
-    await reconcileProcessRestarts('/tmp/ws', [spec], deps);
-
-    expect(deps.startProcessInstance).not.toHaveBeenCalled();
-  });
-
-  it('should skip processes where restart is externally disabled', async () => {
-    const deps = makeDeps({
-      isProcessRestartDisabled: mock(() => true),
-    });
-    const specs = [makeSpec()];
-
-    await reconcileProcessRestarts('/tmp/ws', specs, deps);
-
-    expect(deps.startProcessInstance).not.toHaveBeenCalled();
-  });
-
-  it('should skip processes that have never been started', async () => {
-    const deps = makeDeps({
-      hasProcessStarted: mock(() => false),
-    });
-    const specs = [makeSpec()];
-
-    await reconcileProcessRestarts('/tmp/ws', specs, deps);
-
-    expect(deps.startProcessInstance).not.toHaveBeenCalled();
-  });
-
-  it('should restart a crashed process with "always" policy', async () => {
-    const deps = makeDeps();
-    const specs = [makeSpec({ policy: 'always' })];
-
-    await reconcileProcessRestarts('/tmp/ws', specs, deps);
-
-    expect(deps.startProcessInstance).toHaveBeenCalledTimes(1);
-  });
-
-  it('should restart a process with "on-failure" policy when exit code is non-zero', async () => {
-    const deps = makeDeps({
-      readProcessExit: mock(() => ({ exitCode: 1, exitedAt: Date.now() })),
-    });
-    const specs = [makeSpec({ policy: 'on-failure' })];
-
-    await reconcileProcessRestarts('/tmp/ws', specs, deps);
-
-    expect(deps.startProcessInstance).toHaveBeenCalledTimes(1);
-  });
-
-  it('should NOT restart a process with "on-failure" policy when exit code is 0', async () => {
-    const deps = makeDeps({
-      readProcessExit: mock(() => ({ exitCode: 0, exitedAt: Date.now() })),
-    });
-    const specs = [makeSpec({ policy: 'on-failure' })];
-
-    await reconcileProcessRestarts('/tmp/ws', specs, deps);
-
-    expect(deps.startProcessInstance).not.toHaveBeenCalled();
-  });
-
-  it('should disable restart after maxAttempts exceeded', async () => {
-    const startMock = mock(() => Promise.resolve({ sessionId: 's', created: true }));
-    let currentTime = 1000;
-
-    const deps = makeDeps({
-      startProcessInstance: startMock,
-      now: mock(() => {
-        currentTime += 100000; // jump forward enough to skip backoff
-        return currentTime;
-      }),
-    });
-
-    const spec = makeSpec({ maxAttempts: 2, backoffMs: 1 });
-    const specs = [spec];
-
-    // First call: attempt 1
-    await reconcileProcessRestarts('/tmp/ws', specs, deps);
-    expect(startMock).toHaveBeenCalledTimes(1);
-
-    // Second call: attempt 2
-    await reconcileProcessRestarts('/tmp/ws', specs, deps);
-    expect(startMock).toHaveBeenCalledTimes(2);
-
-    // Third call: maxAttempts exceeded, should disable
-    await reconcileProcessRestarts('/tmp/ws', specs, deps);
-    expect(deps.disableProcessRestart).toHaveBeenCalled();
-    expect(startMock).toHaveBeenCalledTimes(2); // no additional start
-  });
-
-  it('should respect backoff delay', async () => {
-    let currentTime = 1000;
-    const deps = makeDeps({
-      now: mock(() => currentTime),
-    });
-
-    const specs = [makeSpec({ backoffMs: 5000 })];
-
-    // First call starts the process
-    await reconcileProcessRestarts('/tmp/ws', specs, deps);
-    expect(deps.startProcessInstance).toHaveBeenCalledTimes(1);
-
-    // Second call too soon - should skip due to backoff
-    currentTime += 1000; // only 1 second later, but backoff doubled to 10000
-    await reconcileProcessRestarts('/tmp/ws', specs, deps);
-    expect(deps.startProcessInstance).toHaveBeenCalledTimes(1); // still 1
-
-    // Third call after backoff - should restart
-    currentTime += 20000; // well past doubled backoff
-    await reconcileProcessRestarts('/tmp/ws', specs, deps);
-    expect(deps.startProcessInstance).toHaveBeenCalledTimes(2);
-  });
-
-  it('keeps restart backoff isolated per workspace for same process name', async () => {
-    const name = uniqueName();
-    const spec = makeSpec({ name, backoffMs: 60_000 });
-    const startA = mock(() => Promise.resolve({ sessionId: 'a', created: true }));
-    const startB = mock(() => Promise.resolve({ sessionId: 'b', created: true }));
-
-    const depsA = makeDeps({
-      startProcessInstance: startA,
-      now: mock(() => 1000),
-    });
-    const depsB = makeDeps({
-      startProcessInstance: startB,
-      now: mock(() => 1000),
-    });
-
-    await reconcileProcessRestarts('/tmp/ws-a', [spec], depsA);
-    await reconcileProcessRestarts('/tmp/ws-b', [spec], depsB);
-
-    expect(startA).toHaveBeenCalledTimes(1);
-    expect(startB).toHaveBeenCalledTimes(1);
-  });
-});

package/src/lib/processes/autostart.ts

@@ -1,16 +0,0 @@
-/**
- * Process autostart helpers
- */
-
-import type { ProcessInstanceSpec } from '../../types/processes.js';
-import { startProcessInstance } from './manager.js';
-
-export async function autostartProcesses(
-  workspacePath: string,
-  specs: ProcessInstanceSpec[]
-): Promise<void> {
-  const autostart = specs.filter((spec) => spec.definition.autostart);
-  for (const spec of autostart) {
-    await startProcessInstance(workspacePath, spec);
-  }
-}