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

package/src/lib/processes/runner.ts

@@ -1,211 +0,0 @@
-#!/usr/bin/env bun
-/**
- * Process runner + event collector
- */
-
-import { spawn } from "bun";
-import { readFileSync } from "fs";
-import { join } from "path";
-import { WideEventCollector } from "../events/collector.js";
-import { buildProcessEventsConfig } from "./events-config.js";
-import { loadProcessesConfig, getProcessDefinition } from "./config.js";
-import { recordProcessExit } from "./state.js";
-import type { WideEvent } from "../../types/events.js";
-
-interface RunnerOptions {
-  workspacePath: string;
-  processName: string;
-  instance: number;
-}
-
-function parseArgs(argv: string[]): RunnerOptions {
-  const args = new Map<string, string>();
-  const filtered = argv.filter((arg) => arg !== "--internal-process-runner");
-  for (let i = 0; i < filtered.length; i += 2) {
-    const key = filtered[i];
-    const value = filtered[i + 1];
-    if (!key || !value) {
-      continue;
-    }
-    args.set(key, value);
-  }
-
-  const workspacePath = args.get("--workspace");
-  const processName = args.get("--process");
-  const instanceRaw = args.get("--instance");
-
-  if (!workspacePath || !processName || !instanceRaw) {
-    throw new Error("Usage: --workspace <path> --process <name> --instance <n>");
-  }
-
-  const instance = Number.parseInt(instanceRaw, 10);
-  if (!Number.isFinite(instance) || instance <= 0) {
-    throw new Error(`Invalid instance value: ${instanceRaw}`);
-  }
-
-  return { workspacePath, processName, instance };
-}
-
-function printEventLine(event: WideEvent): void {
-  const level = event.level.toUpperCase();
-  const message = event.message.trim();
-  const label = `${event.eventName} (${event.eventId})`;
-  console.log(`[event:${level}] ${label} — ${message}`);
-}
-
-function shouldSuppressRaw(definition: ReturnType<typeof getProcessDefinition>): boolean {
-  if (!definition) return true;
-  if (definition.events?.enabled === false) return true;
-  if (definition.events?.mode === "json") return false;
-  return definition.events?.keepRawOutput === true ? false : true;
-}
-
-async function run(): Promise<void> {
-  const opts = parseArgs(process.argv.slice(2));
-  const config = loadProcessesConfig(opts.workspacePath);
-  const definition = getProcessDefinition(config, opts.processName);
-
-  if (!definition?.command) {
-    throw new Error(`Process ${opts.processName} is missing command`);
-  }
-
-  const cwd = definition.cwd ? join(opts.workspacePath, definition.cwd) : opts.workspacePath;
-  const commandArgs = [definition.command, ...(definition.args ?? [])];
-  const env = {
-    ...process.env,
-    ...(definition.env ?? {}),
-    GITSPACE_PROCESS_NAME: opts.processName,
-    GITSPACE_PROCESS_INSTANCE: String(opts.instance),
-    TMUX_LITE: process.env.TMUX_LITE ?? "runner",
-  } as Record<string, string>;
-
-  const processName = opts.processName;
-  const workspaceId = opts.workspacePath.split("/").pop() ?? opts.workspacePath;
-  const projectName = opts.workspacePath.split("/").slice(-3, -2)[0] ?? "";
-  const eventsConfig = buildProcessEventsConfig(projectName, definition);
-
-  const collector = new WideEventCollector({
-    config: eventsConfig,
-    sessionId: "",
-    workspacePath: opts.workspacePath,
-    workspaceId,
-    projectName,
-    processName,
-    processInstance: opts.instance,
-  });
-
-  const suppressRaw = shouldSuppressRaw(definition);
-  const prefix = eventsConfig.prefix || "@event";
-
-  let stdoutBuffer = "";
-  let stderrBuffer = "";
-
-  const child = spawn({
-    cmd: commandArgs,
-    cwd,
-    env,
-    stdout: "pipe",
-    stderr: "pipe",
-  });
-
-  const handleChunk = (data: Uint8Array, stream: "stdout" | "stderr") => {
-    const buffer = Buffer.from(data);
-    const rawText = buffer.toString("utf-8");
-
-    const pending = stream === "stdout" ? stdoutBuffer : stderrBuffer;
-    const combined = pending + rawText;
-    const parts = combined.split("\n");
-
-    let remainder = "";
-    if (combined.endsWith("\n")) {
-      parts.pop();
-    } else {
-      remainder = parts.pop() ?? "";
-    }
-
-    if (stream === "stdout") {
-      stdoutBuffer = remainder;
-    } else {
-      stderrBuffer = remainder;
-    }
-
-    const eventLines: string[] = [];
-    let nonEventPayload = "";
-    let hasNonEventContent = false;
-
-    for (const line of parts) {
-      const trimmed = line.trim();
-      if (trimmed.startsWith(prefix)) {
-        eventLines.push(trimmed);
-      } else {
-        nonEventPayload += `${line}\n`;
-        if (trimmed.length > 0) {
-          hasNonEventContent = true;
-        }
-      }
-    }
-
-    if (!suppressRaw) {
-      if (stream === "stderr") {
-        process.stderr.write(buffer);
-      } else {
-        process.stdout.write(buffer);
-      }
-    } else if (hasNonEventContent) {
-      if (stream === "stderr") {
-        process.stderr.write(nonEventPayload);
-      } else {
-        process.stdout.write(nonEventPayload);
-      }
-    }
-
-    if (eventLines.length > 0) {
-      const eventBuffer = Buffer.from(eventLines.join("\n") + "\n");
-      const events = collector.handleChunk(eventBuffer);
-      for (const event of events) {
-        printEventLine(event);
-      }
-    }
-  };
-
-  const stdoutStream = child.stdout as ReadableStream<Uint8Array> | null;
-  const streamDrains: Array<Promise<void>> = [];
-  if (stdoutStream) {
-    const reader = stdoutStream.getReader();
-    const drain = (async () => {
-      while (true) {
-        const { value, done } = await reader.read();
-        if (done || !value) break;
-        handleChunk(value, "stdout");
-      }
-    })();
-    streamDrains.push(drain);
-  }
-
-  const stderrStream = child.stderr as ReadableStream<Uint8Array> | null;
-  if (stderrStream) {
-    const reader = stderrStream.getReader();
-    const drain = (async () => {
-      while (true) {
-        const { value, done } = await reader.read();
-        if (done || !value) break;
-        handleChunk(value, "stderr");
-      }
-    })();
-    streamDrains.push(drain);
-  }
-
-  const exitCode = await child.exited;
-  await Promise.all(streamDrains);
-  collector.finalize();
-  try {
-    recordProcessExit(opts.workspacePath, opts.processName, opts.instance, exitCode ?? 0);
-  } catch {}
-  process.exit(exitCode ?? 0);
-}
-
-run().catch((error) => {
-  const message = error instanceof Error ? error.message : String(error);
-  console.error(`process runner failed: ${message}`);
-  process.exit(1);
-});

package/src/lib/processes/scheduler.ts

@@ -1,17 +0,0 @@
-/**
- * Process scheduler loop
- */
-
-import { getProcessSpecs } from './manager.js';
-import { reconcileProcessRestarts } from './watchdog.js';
-
-const DEFAULT_INTERVAL_MS = 5000;
-
-export function startProcessScheduler(workspacePath: string, intervalMs = DEFAULT_INTERVAL_MS): NodeJS.Timer {
-  const timer = setInterval(() => {
-    const specs = getProcessSpecs(workspacePath);
-    void reconcileProcessRestarts(workspacePath, specs);
-  }, intervalMs);
-
-  return timer;
-}

package/src/lib/processes/schema.ts

@@ -1,74 +0,0 @@
-/**
- * Process schema utilities
- */
-
-import type { ProcessesConfig, ProcessDefinition } from '../../types/processes.js';
-
-export interface ProcessValidationResult {
-  valid: boolean;
-  errors: string[];
-}
-
-export function validateProcessesConfig(config: ProcessesConfig): ProcessValidationResult {
-  const errors: string[] = [];
-
-  if (!Array.isArray(config.processes)) {
-    errors.push('processes must be an array');
-    return { valid: false, errors };
-  }
-
-  const names = new Set<string>();
-  for (const process of config.processes) {
-    if (!process.name) {
-      errors.push('process is missing name');
-      continue;
-    }
-    if (names.has(process.name)) {
-      errors.push(`duplicate process name: ${process.name}`);
-    }
-    names.add(process.name);
-
-    if (!process.command) {
-      errors.push(`process ${process.name} missing command`);
-    }
-
-    if (process.instances !== undefined) {
-      if (!Number.isInteger(process.instances) || process.instances < 0) {
-        errors.push(`process ${process.name} instances must be a non-negative integer`);
-      }
-    }
-
-    if (process.events?.keepRawOutput !== undefined && typeof process.events.keepRawOutput !== 'boolean') {
-      errors.push(`process ${process.name} keepRawOutput must be a boolean`);
-    }
-
-    if (process.ports !== undefined) {
-      if (!Array.isArray(process.ports)) {
-        errors.push(`process ${process.name} ports must be an array`);
-      } else {
-        for (const port of process.ports) {
-          if (!port || typeof port !== 'object') {
-            errors.push(`process ${process.name} port entries must be objects`);
-            continue;
-          }
-          if (!Number.isInteger(port.port) || port.port <= 0 || port.port > 65535) {
-            errors.push(`process ${process.name} port must be a number between 1 and 65535`);
-          }
-          if (port.name !== undefined && typeof port.name !== 'string') {
-            errors.push(`process ${process.name} port name must be a string`);
-          }
-          if (port.protocol !== undefined && port.protocol !== 'http' && port.protocol !== 'tcp') {
-            errors.push(`process ${process.name} port protocol must be http or tcp`);
-          }
-        }
-      }
-    }
-  }
-
-  return { valid: errors.length === 0, errors };
-}
-
-export function describeProcess(process: ProcessDefinition): string {
-  const args = process.args?.join(' ') ?? '';
-  return `${process.name}: ${process.command} ${args}`.trim();
-}

package/src/lib/processes/session-list.ts

@@ -1,15 +0,0 @@
-/**
- * Process session list helpers
- */
-
-import type { Session } from '../tmux-lite/protocol.js';
-import { parseProcessSessionName } from './manager.js';
-
-export function decorateSessionWithProcess(session: Session) {
-  const parsed = parseProcessSessionName(session.name);
-  return {
-    ...session,
-    processName: parsed?.processName,
-    processInstance: parsed?.instance,
-  };
-}

package/src/lib/processes/state.ts

@@ -1,82 +0,0 @@
-/**
- * Process state helpers (started + last exit)
- */
-
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'fs';
-import { join } from 'path';
-import { getProcessControlDir } from './control.js';
-import { encodeProcessNameForPath } from './names.js';
-
-export interface ProcessExitInfo {
-  exitCode: number;
-  exitedAt: number;
-}
-
-function getStartedDir(workspacePath: string): string {
-  return join(getProcessControlDir(workspacePath), 'started');
-}
-
-function getExitDir(workspacePath: string): string {
-  return join(getProcessControlDir(workspacePath), 'exit');
-}
-
-function getStartedPath(workspacePath: string, name: string, instance: number): string {
-  return join(getStartedDir(workspacePath), `${encodeProcessNameForPath(name)}-${instance}`);
-}
-
-function getExitPath(workspacePath: string, name: string, instance: number): string {
-  return join(getExitDir(workspacePath), `${encodeProcessNameForPath(name)}-${instance}.json`);
-}
-
-export function markProcessStarted(workspacePath: string, name: string, instance: number): void {
-  const dir = getStartedDir(workspacePath);
-  mkdirSync(dir, { recursive: true });
-  const file = getStartedPath(workspacePath, name, instance);
-  writeFileSync(file, String(Date.now()), 'utf-8');
-}
-
-export function hasProcessStarted(workspacePath: string, name: string, instance: number): boolean {
-  return existsSync(getStartedPath(workspacePath, name, instance));
-}
-
-export function recordProcessExit(
-  workspacePath: string,
-  name: string,
-  instance: number,
-  exitCode: number,
-  exitedAt = Date.now()
-): void {
-  const dir = getExitDir(workspacePath);
-  mkdirSync(dir, { recursive: true });
-  const file = getExitPath(workspacePath, name, instance);
-  const payload = JSON.stringify({ exitCode, exitedAt });
-  writeFileSync(file, payload, 'utf-8');
-}
-
-export function readProcessExit(
-  workspacePath: string,
-  name: string,
-  instance: number
-): ProcessExitInfo | null {
-  const file = getExitPath(workspacePath, name, instance);
-  if (!existsSync(file)) return null;
-  try {
-    const raw = readFileSync(file, 'utf-8');
-    const parsed = JSON.parse(raw) as ProcessExitInfo;
-    if (
-      parsed &&
-      typeof parsed.exitCode === 'number' &&
-      typeof parsed.exitedAt === 'number'
-    ) {
-      return parsed;
-    }
-  } catch {}
-  return null;
-}
-
-export function clearProcessExit(workspacePath: string, name: string, instance: number): void {
-  const file = getExitPath(workspacePath, name, instance);
-  if (existsSync(file)) {
-    rmSync(file, { force: true });
-  }
-}

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

@@ -1,79 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { ProcessInstanceSpec } from "../../types/processes.js";
-import { reconcileProcessRestarts, type ProcessWatchdogDeps } from "./watchdog.js";
-
-function buildSpec(name: string, policy: "never" | "on-failure" | "always"): ProcessInstanceSpec {
-  return {
-    name,
-    instance: 1,
-    definition: {
-      name,
-      command: "echo",
-      restart: {
-        policy,
-        maxAttempts: 3,
-        backoffMs: 10,
-        maxBackoffMs: 100,
-      },
-    },
-  };
-}
-
-describe("process watchdog", () => {
-  test("does not restart when never started", async () => {
-    const spec = buildSpec("never-started", "always");
-    const started: string[] = [];
-
-    const deps: ProcessWatchdogDeps = {
-      listSessions: async () => [],
-      startProcessInstance: async (_workspace, target) => {
-        started.push(`${target.name}:${target.instance}`);
-        return { sessionId: "s1", created: true };
-      },
-      isProcessRestartDisabled: () => false,
-      hasProcessStarted: () => false,
-    };
-
-    await reconcileProcessRestarts("/tmp/workspace", [spec], deps);
-    expect(started.length).toBe(0);
-  });
-
-  test("restarts missing session when started and exit was non-zero", async () => {
-    const spec = buildSpec("crashed-process", "on-failure");
-    const started: string[] = [];
-
-    const deps: ProcessWatchdogDeps = {
-      listSessions: async () => [],
-      startProcessInstance: async (_workspace, target) => {
-        started.push(`${target.name}:${target.instance}`);
-        return { sessionId: "s2", created: true };
-      },
-      isProcessRestartDisabled: () => false,
-      hasProcessStarted: () => true,
-      readProcessExit: () => ({ exitCode: 1, exitedAt: 123 }),
-      now: () => 1000,
-    };
-
-    await reconcileProcessRestarts("/tmp/workspace", [spec], deps);
-    expect(started).toEqual(["crashed-process:1"]);
-  });
-
-  test("does not restart on-failure when last exit was clean", async () => {
-    const spec = buildSpec("clean-exit", "on-failure");
-    const started: string[] = [];
-
-    const deps: ProcessWatchdogDeps = {
-      listSessions: async () => [],
-      startProcessInstance: async (_workspace, target) => {
-        started.push(`${target.name}:${target.instance}`);
-        return { sessionId: "s3", created: true };
-      },
-      isProcessRestartDisabled: () => false,
-      hasProcessStarted: () => true,
-      readProcessExit: () => ({ exitCode: 0, exitedAt: 456 }),
-    };
-
-    await reconcileProcessRestarts("/tmp/workspace", [spec], deps);
-    expect(started.length).toBe(0);
-  });
-});

package/src/lib/processes/watchdog.ts

@@ -1,106 +0,0 @@
-/**
- * Process watchdog for restart policies
- */
-
-import type { ProcessInstanceSpec } from '../../types/processes.js';
-import { listSessions } from '../tmux-lite/cli.js';
-import { parseProcessSessionName, startProcessInstance, getRestartConfig } from './manager.js';
-import { isProcessRestartDisabled, disableProcessRestart } from './control.js';
-import { hasProcessStarted, readProcessExit } from './state.js';
-
-export interface ProcessRestartState {
-  attempts: number;
-  lastStart: number;
-  nextDelay: number;
-  disabled?: boolean;
-}
-
-export interface ProcessWatchdogDeps {
-  listSessions?: typeof listSessions;
-  startProcessInstance?: typeof startProcessInstance;
-  isProcessRestartDisabled?: typeof isProcessRestartDisabled;
-  disableProcessRestart?: typeof disableProcessRestart;
-  hasProcessStarted?: typeof hasProcessStarted;
-  readProcessExit?: typeof readProcessExit;
-  now?: () => number;
-}
-
-const restartState = new Map<string, ProcessRestartState>();
-
-function getRestartKey(workspacePath: string, spec: ProcessInstanceSpec): string {
-  return `${workspacePath}:${spec.name}:${spec.instance}`;
-}
-
-export async function reconcileProcessRestarts(
-  workspacePath: string,
-  specs: ProcessInstanceSpec[],
-  deps: ProcessWatchdogDeps = {}
-): Promise<void> {
-  const listSessionsFn = deps.listSessions ?? listSessions;
-  const startProcessInstanceFn = deps.startProcessInstance ?? startProcessInstance;
-  const isProcessRestartDisabledFn = deps.isProcessRestartDisabled ?? isProcessRestartDisabled;
-  const disableProcessRestartFn = deps.disableProcessRestart ?? disableProcessRestart;
-  const hasProcessStartedFn = deps.hasProcessStarted ?? hasProcessStarted;
-  const readProcessExitFn = deps.readProcessExit ?? readProcessExit;
-  const nowFn = deps.now ?? Date.now;
-
-  const sessions = await listSessionsFn();
-
-  for (const spec of specs) {
-    const key = getRestartKey(workspacePath, spec);
-    const restart = getRestartConfig(spec.definition);
-    if (restart.policy === 'never') continue;
-
-    const existing = sessions.find((session) => {
-      const parsed = parseProcessSessionName(session.name);
-      const inWorkspace =
-        session.cwd === workspacePath || session.cwd.startsWith(`${workspacePath}/`);
-      return (
-        inWorkspace &&
-        parsed?.processName === spec.name &&
-        parsed.instance === spec.instance
-      );
-    });
-
-    if (isProcessRestartDisabledFn(workspacePath, spec.name, spec.instance)) {
-      continue;
-    }
-
-    const state = restartState.get(key) ?? { attempts: 0, lastStart: 0, nextDelay: restart.backoffMs };
-    if (state.disabled) {
-      continue;
-    }
-
-    if (existing) {
-      restartState.set(key, { ...state, lastStart: nowFn() });
-      continue;
-    }
-
-    if (!hasProcessStartedFn(workspacePath, spec.name, spec.instance)) {
-      continue;
-    }
-
-    if (restart.policy === 'on-failure') {
-      const exitInfo = readProcessExitFn(workspacePath, spec.name, spec.instance);
-      if (exitInfo?.exitCode === 0) {
-        restartState.delete(key);
-        continue;
-      }
-    }
-
-    if (state.attempts >= restart.maxAttempts) {
-      restartState.set(key, { ...state, disabled: true });
-      disableProcessRestartFn(workspacePath, spec.name, spec.instance);
-      continue;
-    }
-
-    const now = nowFn();
-    if (state.lastStart > 0 && now - state.lastStart < state.nextDelay) {
-      continue;
-    }
-
-    await startProcessInstanceFn(workspacePath, spec);
-    const nextDelay = Math.min(state.nextDelay * 2, restart.maxBackoffMs);
-    restartState.set(key, { attempts: state.attempts + 1, lastStart: now, nextDelay });
-  }
-}