gitspace 0.2.0-rc.19 → 0.2.0-rc.20

package/.gitspace/events.json

@@ -0,0 +1,11 @@
+{
+  "savedFilters": [
+    {
+      "name": "Sample process events",
+      "filter": {
+        "processName": "sample-events"
+      },
+      "sinceMinutes": 60
+    }
+  ]
+}

package/.gitspace/processes.json

@@ -0,0 +1,23 @@
+{
+  "processes": [
+    {
+      "name": "sample-events",
+      "command": "bun",
+      "args": ["scripts/sample-events.ts"],
+      "autostart": false,
+      "events": {
+        "keepRawOutput": false,
+        "correlationField": "requestId",
+        "aggregateMode": "stream",
+        "updateIntervalMs": 200,
+        "maxTimeline": 50
+      },
+      "restart": {
+        "policy": "always",
+        "maxAttempts": 10,
+        "backoffMs": 2000,
+        "maxBackoffMs": 15000
+      }
+    }
+  ]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitspace",
-  "version": "0.2.0-rc.19",
+  "version": "0.2.0-rc.20",
   "description": "CLI for managing GitHub workspaces with git worktrees and secure remote terminal access",
   "bin": {
     "gssh": "./bin/gssh"
@@ -17,10 +17,10 @@
     "relay": "bun src/relay/index.ts"
   },
   "optionalDependencies": {
-    "@gitspace/darwin-arm64": "0.2.0-rc.19",
-    "@gitspace/darwin-x64": "0.2.0-rc.19",
-    "@gitspace/linux-x64": "0.2.0-rc.19",
-    "@gitspace/linux-arm64": "0.2.0-rc.19"
+    "@gitspace/darwin-arm64": "0.2.0-rc.20",
+    "@gitspace/darwin-x64": "0.2.0-rc.20",
+    "@gitspace/linux-x64": "0.2.0-rc.20",
+    "@gitspace/linux-arm64": "0.2.0-rc.20"
   },
   "keywords": [
     "cli",

package/scripts/sample-events.ts

@@ -0,0 +1,263 @@
+type EventLevel = "info" | "warn" | "error";
+
+type SampleEvent = {
+  event: string;
+  eventId: string;
+  level: EventLevel;
+  timestamp: string;
+  message: string;
+  requestId: string;
+  traceId?: string;
+  spanId?: string;
+  parentSpanId?: string;
+  durationMs?: number;
+};
+
+type TaskDefinition = {
+  name: string;
+  startMessage: string;
+  finishMessage: string;
+  errorMessage: string;
+};
+
+type ScheduledEvent = {
+  offsetMs: number;
+  event: string;
+  message: string;
+  level?: EventLevel;
+  spanId: string;
+  parentSpanId?: string;
+  durationMs?: number;
+};
+
+const TASKS: TaskDefinition[] = [
+  {
+    name: "auth.check",
+    startMessage: "Validating token",
+    finishMessage: "Token validated",
+    errorMessage: "Token validation failed",
+  },
+  {
+    name: "db.query",
+    startMessage: "Querying primary database",
+    finishMessage: "Query complete",
+    errorMessage: "Database timeout",
+  },
+  {
+    name: "cache.lookup",
+    startMessage: "Cache lookup",
+    finishMessage: "Cache response",
+    errorMessage: "Cache lookup failed",
+  },
+  {
+    name: "worker.dispatch",
+    startMessage: "Dispatching queue worker",
+    finishMessage: "Worker acknowledged",
+    errorMessage: "Worker dispatch stalled",
+  },
+  {
+    name: "billing.capture",
+    startMessage: "Capturing payment",
+    finishMessage: "Payment captured",
+    errorMessage: "Payment capture failed",
+  },
+  {
+    name: "inventory.reserve",
+    startMessage: "Reserving inventory",
+    finishMessage: "Inventory reserved",
+    errorMessage: "Inventory reservation failed",
+  },
+  {
+    name: "feature.flag",
+    startMessage: "Evaluating feature flags",
+    finishMessage: "Flags applied",
+    errorMessage: "Flag evaluation failed",
+  },
+  {
+    name: "webhook.emit",
+    startMessage: "Emitting webhook",
+    finishMessage: "Webhook delivered",
+    errorMessage: "Webhook delivery failed",
+  },
+];
+
+const REQUEST_DURATION_RANGE_MS = [6000, 18000] as const;
+const REQUEST_INTERVAL_RANGE_MS = [2000, 4000] as const;
+const TASK_COUNT_RANGE = [4, 8] as const;
+const FAILURE_RATE = 0.22;
+
+function randomId(prefix: string): string {
+  return `${prefix}-${Math.random().toString(36).slice(2, 10)}`;
+}
+
+function randomBetween(min: number, max: number): number {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+function shuffle<T>(items: T[]): T[] {
+  const copy = [...items];
+  for (let i = copy.length - 1; i > 0; i -= 1) {
+    const j = randomBetween(0, i);
+    [copy[i], copy[j]] = [copy[j], copy[i]];
+  }
+  return copy;
+}
+
+function pickOne<T>(items: T[]): T {
+  return items[randomBetween(0, items.length - 1)];
+}
+
+function emitEvent(payload: SampleEvent): void {
+  console.log(`@event ${JSON.stringify(payload)}`);
+}
+
+function buildEvent(params: {
+  requestId: string;
+  traceId: string;
+  spanId: string;
+  parentSpanId?: string;
+  event: string;
+  message: string;
+  level?: EventLevel;
+  durationMs?: number;
+}): SampleEvent {
+  const now = new Date();
+  return {
+    event: params.event,
+    eventId: randomId("evt"),
+    level: params.level ?? "info",
+    timestamp: now.toISOString(),
+    message: params.message,
+    requestId: params.requestId,
+    traceId: params.traceId,
+    spanId: params.spanId,
+    parentSpanId: params.parentSpanId,
+    durationMs: params.durationMs,
+  };
+}
+
+function scheduleEvents(params: {
+  requestId: string;
+  traceId: string;
+  events: ScheduledEvent[];
+}): void {
+  const { requestId, traceId, events } = params;
+  const sorted = [...events].sort((a, b) => a.offsetMs - b.offsetMs);
+  for (const event of sorted) {
+    setTimeout(() => {
+      emitEvent(buildEvent({
+        requestId,
+        traceId,
+        spanId: event.spanId,
+        parentSpanId: event.parentSpanId,
+        event: event.event,
+        message: event.message,
+        level: event.level,
+        durationMs: event.durationMs,
+      }));
+    }, event.offsetMs);
+  }
+}
+
+function emitRequestSequence(): void {
+  const requestId = randomId("req");
+  const traceId = randomId("trace");
+  const rootSpanId = randomId("span");
+  const totalDuration = randomBetween(...REQUEST_DURATION_RANGE_MS);
+  const willFail = Math.random() < FAILURE_RATE;
+  const failureOffset = willFail
+    ? randomBetween(Math.floor(totalDuration * 0.4), Math.floor(totalDuration * 0.85))
+    : totalDuration;
+  const finalOffset = willFail
+    ? failureOffset + randomBetween(120, 480)
+    : totalDuration + randomBetween(200, 600);
+
+  const scheduled: ScheduledEvent[] = [
+    {
+      offsetMs: 0,
+      event: "request.start",
+      message: "Request started",
+      spanId: rootSpanId,
+    },
+  ];
+
+  const taskCount = randomBetween(...TASK_COUNT_RANGE);
+  const selectedTasks = shuffle(TASKS).slice(0, taskCount);
+  const taskWindowEnd = Math.max(600, failureOffset - 600);
+
+  for (const task of selectedTasks) {
+    const spanId = randomId("span");
+    const startOffset = randomBetween(200, taskWindowEnd);
+    if (willFail && startOffset > failureOffset - 200) {
+      continue;
+    }
+
+    const duration = randomBetween(400, 3200);
+    const finishOffset = startOffset + duration;
+
+    scheduled.push({
+      offsetMs: startOffset,
+      event: `${task.name}.start`,
+      message: task.startMessage,
+      spanId,
+      parentSpanId: rootSpanId,
+    });
+
+    if (!willFail || finishOffset < failureOffset - 200) {
+      scheduled.push({
+        offsetMs: finishOffset,
+        event: `${task.name}.finish`,
+        message: task.finishMessage,
+        spanId,
+        parentSpanId: rootSpanId,
+        durationMs: duration,
+      });
+    }
+  }
+
+  if (willFail) {
+    const failureTask = pickOne(selectedTasks);
+    const failureSpanId = randomId("span");
+    const failureDetailOffset = Math.max(200, failureOffset - randomBetween(150, 400));
+
+    scheduled.push({
+      offsetMs: failureDetailOffset,
+      event: `${failureTask.name}.error`,
+      message: failureTask.errorMessage,
+      spanId: failureSpanId,
+      parentSpanId: rootSpanId,
+      level: "error",
+    });
+  }
+
+  scheduled.push({
+    offsetMs: finalOffset,
+    event: willFail ? "request.failed" : "request.complete",
+    message: willFail ? "Request failed" : "Request completed",
+    spanId: rootSpanId,
+    level: willFail ? "error" : "info",
+    durationMs: finalOffset,
+  });
+
+  scheduleEvents({ requestId, traceId, events: scheduled });
+}
+
+emitEvent(buildEvent({
+  requestId: "bootstrap",
+  traceId: randomId("trace"),
+  spanId: randomId("span"),
+  event: "sample.start",
+  message: "Sample event emitter started",
+  level: "info",
+}));
+
+function scheduleNextSequence(): void {
+  const delay = randomBetween(...REQUEST_INTERVAL_RANGE_MS);
+  setTimeout(() => {
+    emitRequestSequence();
+    scheduleNextSequence();
+  }, delay);
+}
+
+scheduleNextSequence();
+emitRequestSequence();

package/src/app/session/__tests__/useAttachController.test.ts

@@ -124,6 +124,33 @@ describe('useAttachController', () => {
     )
   })
 
+  it('passes through viewOnly on existing session attaches', async () => {
+    const attachSessionWithBundleRefresh = mock(async () => true)
+
+    const { result } = renderHook(() =>
+      useAttachController({
+        flow: {
+          showInput: () => {},
+          showMessage: () => {},
+          close: () => {},
+        },
+        attachSessionWithBundleRefresh,
+      })
+    )
+
+    await result.current.attachFromSelection({ sessionId: 'session-view', viewOnly: true })
+
+    expect(attachSessionWithBundleRefresh).toHaveBeenCalledWith(
+      {
+        sessionId: 'session-view',
+        viewOnly: true,
+      },
+      {
+        projectName: null,
+      }
+    )
+  })
+
   it('runs lifecycle callbacks for cancelled and failed attach attempts', async () => {
     const onAttachCancelled = mock(() => {})
     const onAttachError = mock(() => {})

package/src/app/session/useAttachController.ts

@@ -8,6 +8,7 @@ import type {
 export interface AttachSelectionParams {
   sessionId?: string
   workspaceId?: string
+  viewOnly?: boolean
 }
 
 export type AttachTarget = 'session' | 'workspace'
@@ -182,7 +183,14 @@ export function useAttachController(options: UseAttachControllerOptions): UseAtt
         return
       }
 
-      await attach({ sessionId: selection.sessionId })
+      const attachParams: BundleRefreshAttachParams = {
+        sessionId: selection.sessionId,
+      }
+      if (selection.viewOnly !== undefined) {
+        attachParams.viewOnly = selection.viewOnly
+      }
+
+      await attach(attachParams)
       return
     }
 

package/src/app/session/useProcessActions.ts

@@ -0,0 +1,201 @@
+import { useCallback, useEffect, useRef, useState } from 'react'
+
+export interface ProcessSessionInfo {
+  id: string
+  workspaceId: string
+  processName?: string
+  processInstance?: number
+  createdAt: number
+  exitCode?: number
+}
+
+export interface ProcessActionParams {
+  workspaceId: string
+  processName: string
+}
+
+export interface ProcessStartAttachParams extends ProcessActionParams {
+  instance?: number
+}
+
+export interface PendingProcessAttachTarget {
+  workspaceId: string
+  processName: string
+  instance: number
+}
+
+export interface UseProcessActionsOptions {
+  sessions: ProcessSessionInfo[]
+  startProcess: (workspaceId: string, processName: string, instance?: number) => Promise<void>
+  stopProcess: (workspaceId: string, processName: string) => Promise<void>
+  attachSession: (params: { sessionId?: string; workspaceId?: string; viewOnly?: boolean }) => Promise<void>
+  onStartProcessError?: (error: unknown) => void
+  onStopProcessError?: (error: unknown) => void
+  onStartProcessAttachError?: (error: unknown) => void
+  onAttachError?: (error: unknown) => void
+  onAttachTimeout?: (target: PendingProcessAttachTarget) => void
+  onStartProcessFinally?: () => void | Promise<void>
+  onStopProcessFinally?: () => void | Promise<void>
+  onStartProcessAttachFinally?: () => void | Promise<void>
+  pendingAttachCancelSignal?: unknown
+  attachTimeoutMs?: number
+}
+
+interface UseProcessActionsResult {
+  handleStartProcess: (params: ProcessActionParams) => void
+  handleStopProcess: (params: ProcessActionParams) => void
+  handleStartProcessAttach: (params: ProcessStartAttachParams) => void
+}
+
+function matchesTarget(
+  current: PendingProcessAttachTarget | null,
+  target: PendingProcessAttachTarget
+): boolean {
+  return Boolean(
+    current &&
+      current.workspaceId === target.workspaceId &&
+      current.processName === target.processName &&
+      current.instance === target.instance
+  )
+}
+
+export function useProcessActions(options: UseProcessActionsOptions): UseProcessActionsResult {
+  const {
+    sessions,
+    startProcess,
+    stopProcess,
+    attachSession,
+    onStartProcessError,
+    onStopProcessError,
+    onStartProcessAttachError,
+    onAttachError,
+    onAttachTimeout,
+    onStartProcessFinally,
+    onStopProcessFinally,
+    onStartProcessAttachFinally,
+    pendingAttachCancelSignal,
+    attachTimeoutMs = 8000,
+  } = options
+
+  const [pendingProcessAttach, setPendingProcessAttach] =
+    useState<PendingProcessAttachTarget | null>(null)
+  const pendingProcessAttachRef = useRef<PendingProcessAttachTarget | null>(null)
+
+  useEffect(() => {
+    pendingProcessAttachRef.current = pendingProcessAttach
+  }, [pendingProcessAttach])
+
+  const runFinally = useCallback((fn?: () => void | Promise<void>) => {
+    if (!fn) {
+      return
+    }
+    void Promise.resolve(fn()).catch(() => {})
+  }, [])
+
+  const handleStartProcess = useCallback((params: ProcessActionParams) => {
+    void Promise.resolve(startProcess(params.workspaceId, params.processName))
+      .catch((error) => {
+        onStartProcessError?.(error)
+      })
+      .finally(() => {
+        runFinally(onStartProcessFinally)
+      })
+  }, [onStartProcessError, onStartProcessFinally, runFinally, startProcess])
+
+  const handleStopProcess = useCallback((params: ProcessActionParams) => {
+    void Promise.resolve(stopProcess(params.workspaceId, params.processName))
+      .catch((error) => {
+        onStopProcessError?.(error)
+      })
+      .finally(() => {
+        runFinally(onStopProcessFinally)
+      })
+  }, [onStopProcessError, onStopProcessFinally, runFinally, stopProcess])
+
+  const handleStartProcessAttach = useCallback((params: ProcessStartAttachParams) => {
+    const target: PendingProcessAttachTarget = {
+      workspaceId: params.workspaceId,
+      processName: params.processName,
+      instance: params.instance ?? 1,
+    }
+
+    setPendingProcessAttach(target)
+    void Promise.resolve(startProcess(target.workspaceId, target.processName, target.instance))
+      .catch((error) => {
+        setPendingProcessAttach((current) =>
+          matchesTarget(current, target) ? null : current
+        )
+        const errorHandler = onStartProcessAttachError ?? onStartProcessError
+        errorHandler?.(error)
+      })
+      .finally(() => {
+        runFinally(onStartProcessAttachFinally)
+      })
+  }, [
+    onStartProcessAttachError,
+    onStartProcessAttachFinally,
+    onStartProcessError,
+    runFinally,
+    startProcess,
+  ])
+
+  useEffect(() => {
+    if (!pendingProcessAttach) {
+      return
+    }
+
+    const session = sessions
+      .filter((item) =>
+        item.workspaceId === pendingProcessAttach.workspaceId &&
+        item.processName === pendingProcessAttach.processName &&
+        (item.processInstance ?? 1) === pendingProcessAttach.instance &&
+        item.exitCode === undefined
+      )
+      .sort((a, b) => b.createdAt - a.createdAt)[0]
+
+    if (!session) {
+      return
+    }
+
+    const target = pendingProcessAttach
+    setPendingProcessAttach((current) =>
+      matchesTarget(current, target) ? null : current
+    )
+
+    void attachSession({ sessionId: session.id, viewOnly: true }).catch((error) => {
+      onAttachError?.(error)
+    })
+  }, [attachSession, onAttachError, pendingProcessAttach, sessions])
+
+  useEffect(() => {
+    if (!pendingProcessAttach) {
+      return
+    }
+
+    const target = pendingProcessAttach
+    const timeout = setTimeout(() => {
+      const current = pendingProcessAttachRef.current
+      if (!matchesTarget(current, target)) {
+        return
+      }
+
+      setPendingProcessAttach(null)
+      onAttachTimeout?.(target)
+    }, attachTimeoutMs)
+
+    return () => clearTimeout(timeout)
+  }, [attachTimeoutMs, onAttachTimeout, pendingProcessAttach])
+
+  useEffect(() => {
+    if (!pendingProcessAttach || !pendingAttachCancelSignal) {
+      return
+    }
+    setPendingProcessAttach(null)
+  }, [pendingAttachCancelSignal, pendingProcessAttach])
+
+  return {
+    handleStartProcess,
+    handleStopProcess,
+    handleStartProcessAttach,
+  }
+}