Function createRequestExecutionScope

src/daemon/request-execution-scope.ts:78–153

(params: {
  req: DaemonRequest;
  sessionStore: SessionStore;
  leaseRegistry: LeaseRegistry;
})

  | { type: 'response'; response: DaemonResponse };

export async function createRequestExecutionScope(params: {
  req: DaemonRequest;
  sessionStore: SessionStore;
  leaseRegistry: LeaseRegistry;
}): Promise<RequestExecutionScope> {
  const { sessionStore, leaseRegistry } = params;
  let scopedReq = applyRequestCommandDefaults(scopeRequestSession(params.req));

  const command = scopedReq.command;
  const sessionName = resolveEffectiveSessionName(scopedReq, sessionStore);
  const diagnosticsMeta = getDiagnosticsMeta();
  const sessionDir = sessionStore.resolveSessionDir(sessionName);
  const requestLogPath = resolveSessionRequestLogPath(
    sessionDir,
    scopedReq.meta?.requestId ?? diagnosticsMeta.requestId,
  );
  const runnerLogPath = resolveSessionRunnerLogPath(sessionDir);
  updateDiagnosticsScope({
    session: sessionName,
    logPath: requestLogPath,
  });
  emitDiagnostic({
    level: 'info',
    phase: 'request_start',
    data: {
      publicSession: scopedReq.session,
      effectiveSession: sessionName,
      command: scopedReq.command,
      tenant: scopedReq.meta?.tenantId,
      isolation: scopedReq.meta?.sessionIsolation,
      requestLogPath,
      runnerLogPath,
    },
  });
  assertLockedLeaseAdmissionPreflight(scopedReq);
  const executionLockKeys = shouldLockSessionExecution(command)
    ? await resolveRequestExecutionLockKeys({ req: scopedReq, sessionName, sessionStore })
    : [];
  const executionLocks = getLeaseRegistryExecutionLocks(leaseRegistry);

  const scope: RequestExecutionScope = {
    req: scopedReq,
    command,
    sessionName,
    requestLogPath,
    runnerLogPath,
    throwIfCanceled: () => throwIfRequestCanceled(scopedReq.meta?.requestId),
    runAdmitted: async (task) => {
      throwIfRequestCanceled(scopedReq.meta?.requestId);
      await cleanupExpiredLeasedSession({
        sessionName,
        sessionStore,
        leaseRegistry,
        teardownSession: teardownSessionResources,
      });
      scopedReq = admitRequestLeaseForLockedScope({
        req: scopedReq,
        sessionName,